add package: json3

This commit is contained in:
Namhyeon Go 2020-07-20 07:05:42 +09:00
parent 2922cd66ec
commit 5fc75f0b3a
10 changed files with 1570 additions and 1 deletions

View File

@ -36,6 +36,9 @@ if (!Function.prototype.GetResource) {
require("node_modules/es5-shim/es5-shim");
require("node_modules/es5-shim/es5-sham");
// JSON 3 was a JSON polyfill for older JavaScript platforms
require("node_modules/json3/lib/json3");
// ECMAScript 6 compatibility shims for legacy JS engines
require("node_modules/es6-shim/es6-shim");
require("node_modules/es6-shim/es6-sham");

160
node_modules/json3/CHANGELOG.md generated vendored Normal file
View File

@ -0,0 +1,160 @@
# JSON 3 Releases
## 3.3.2
### 2014-06-22
* Test the minified version on Travis [Issue #35].
* Add a change log and contribution guidelines [Issue #55].
* Include the minified version in the npm package [Issue #59].
* Simplify `bower.json`.
## 3.3.1
### 2014-04-08
* Reduce the Bower package size by lazily downloading the Closure Compiler [Issue #54].
* Make `JSON3.noConflict()` idempotent [Issue #56].
* Improve AMD `define` pragma detection before minifying.
* Support [`node-webkit`](https://github.com/rogerwang/node-webkit) and web workers.
## 3.3.0
### 2014-01-20
* Export a `JSON3` global in browsers and JavaScript engines.
* Add `JSON3.noConflict()` and `JSON3.runInContext()` [Issue #50].
* Add a post-minification step to remove multiple IIFE wrappers.
* Optimize `quote`.
## 3.2.6
### 2013-10-25
* Add Travis CI integration.
* Support [Bower](http://bower.io/), [Component](https://component.github.io/), [Jam](http://jamjs.org/), and [Volo](http://volojs.org/).
* Test with Node, PhantomJS, RingoJS, Rhino, and Narwhal on Travis.
* Simplify exports.
* `stringify()` optimizations.
* Add a `?minified` query parameter to the browser harness for testing the minified version [Issue #35].
* Detect trailing comma and trailing decimal extensions in Rhino 1.7R3-R4 [Issue #46].
## 3.2.5
### 2013-06-14
* Use `object.hasOwnProperty(prop)` instead of `Object#hasOwnProperty.call(object, prop)` when iterating over host objects [Issue #18].
* Minification improvements; avoid munging the AMD `define` pragma [Issue #22; PR #25].
* Use character codes instead of strings in `lex()`. Optimize for valid source strings [Issue #23; PR #27].
* Support Adobe ExtendScript [Issue #29].
* Handle serializing ExtendScript host objects that throw exceptions [Issue #30; PR #31].
* Support Browserify and RequireJS by exporting for CommonJS and AMD [PR #33].
* Use square bracket character access in `parse`. Add a `charIndexBuggy` flag.
* Add a benchmark suite.
## 3.2.4
### 2012-10-11
* Change the export order to prefer `module.exports`, `exports`, and then `define` [PR #14].
* Avoid conflating duplicate properties and circular references [Issue #15].
* Export `parse` and `stringify` globally even if an AMD loader is present [PR #17].
* Isolate the feature tests into a `has()` function for [`has.js`](https://github.com/phiggins42/has.js) compatibility [Issue #19].
## 3.2.3
### 2012-07-13
* Prototype <= 1.6.1 compatibility [Issue #8].
* `stringify()`: Iterate over whitelisted properties in order [Issue #12].
* Correctly detect trailing commas in array literals.
## 3.2.2
### 2012-05-05
* Correctly detect native `parse()` implementations in AMD loaders and CommonJS environments [Issue #9].
* `parse()`: Use `delete` instead of `Array#splice()` when removing elements from traversed arrays [Issue #10].
* Detect `parse()` number grammar extensions in IE 9 [Issue #11].
## 3.2.1
### 2012-04-26
* Reduce the file size by removing parse error strings [Issue #5].
* Fall back to the native `stringify()` and `parse()` implementations in AMD loaders and CommonJS environments [Issue #6].
* Use the correct global object when exporting for browsers and JavaScript engines.
* Support building on Windows by using `zlib` instead of shelling out to `gzip`.
* Switch to the Closure Compiler for generating the minified version.
* [`r.js`](http://requirejs.org/docs/optimization.html) compatibility.
* Safari < 2.0.2 and Opera >= 10.53 support.
## 3.2.0
### 2012-04-15
* Override native `stringify()` implementations to work around date serialization bugs.
* Ensure the date serialization tests pass in all time zones [Issue #3].
* Add a workaround for buggy `Date#getUTC{FullYear, Month, Date}` implementations in Opera > 9.64 [Issue #4].
* Ensure Firefox <= 11.0 serializes negative years as six-digit extended years.
* Ensure Safari <= 5.1.5 serializes milliseconds correctly.
* Add a Node-based build script.
* Vendor all dependencies.
* Opera 7.54u2 support.
## 3.1.0
### 2012-03-22
* Switched to `bestiejs` organisation
* Added support for a list of properties as the `filter` argument for `JSON.stringify`
* Fixed Firefox 4 and 4.0.1 allowing non-standard extensions to `JSON.parse`
## 3.0.0
### 2012-03-20
* Renamed `JSON3` to `JSON`
* Removed `JSON3.Version`
* Added minified version of library
* Created a [GitHub Project Page](http://bestiejs.github.io/json3)
* Preserved alphanumeric order when iterating over shadowed properties on objects
## 0.8.5
### 2012-03-16
* Avoided relying on native functions `Math.abs`, and `isFinite`, and native constructors `String`, `Number`, `Object`, and `Array`
* Fixed AMD export logic
## 0.8.0
### 2012-03-15
* Renamed `Prim` to `JSON3`
* Added `JSON3.Version`
* Added support for AMD lodaers as the `"json"` module
* Added feature tests for native `JSON` implementations
* Added string coercion for the `source` argument in `JSON3.parse`
* Fixed the date serialization routine in `JSON3.stringify`
## 0.5.0
### 2012-02-18
* Fixed `Prim.stringify`s handling of the `width` argument
* Added Microsofts [ES5 Conformance Tests](https://es5conform.codeplex.com/) to the test suite
## 0.2.0
### 2012-02-17
* Added `Prim.stringify` for serializing values
* Renamed `Prim.Escapes` to `Prim.Unescapes`
* Disallowed unescaped tab characters in strings passed to `Prim.parse`
## 0.1.0
### 2012-02-16
* Initial release of Prim

23
node_modules/json3/LICENSE generated vendored Normal file
View File

@ -0,0 +1,23 @@
Copyright (c) 2012-2015 Kit Cambridge.
http://kitcambridge.be/
Copyright (c) 2013-2015 Benjamin Tan.
https://d10.github.io/
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

128
node_modules/json3/README.md generated vendored Normal file
View File

@ -0,0 +1,128 @@
# 🚨 Unmaintained 🚨
<p class="banner">JSON 3 is **deprecated** and **no longer maintained**. Please don't use it in new projects, and migrate existing projects to use the native `JSON.parse` and `JSON.stringify` instead.</p>
Thanks to everyone who contributed patches or found it useful! ❤️
# JSON 3 #
[![No Maintenance Intended](http://unmaintained.tech/badge.svg)](http://unmaintained.tech/)
**JSON 3** was a JSON polyfill for older JavaScript platforms.
## About ##
[JSON](http://json.org/) is a language-independent data interchange format based on a loose subset of the JavaScript grammar. Originally popularized by [Douglas Crockford](http://www.crockford.com/), the format was standardized in the [fifth edition](http://es5.github.io/) of the ECMAScript specification. The 5.1 edition, ratified in June 2011, incorporates several modifications to the grammar pertaining to the serialization of dates.
JSON 3 exposes two functions: `stringify()` for [serializing](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/JSON/stringify) a JavaScript value to JSON, and `parse()` for [producing](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/JSON/parse) a JavaScript value from a JSON source string. The JSON 3 parser uses recursive descent instead of `eval` and regular expressions, which makes it slower on older platforms compared to [JSON 2](http://json.org/js). The functions behave exactly as described in the ECMAScript spec, **except** for the date serialization discrepancy noted below.
The project is [hosted on GitHub](http://git.io/json3), along with the [unit tests](http://bestiejs.github.io/json3/test/test_browser.html). It is part of the [BestieJS](https://github.com/bestiejs) family, a collection of best-in-class JavaScript libraries that promote cross-platform support, specification precedents, unit testing, and plenty of documentation.
## Date Serialization
**JSON 3 deviates from the specification in one important way**: it does not define `Date#toISOString()` or `Date#toJSON()`. This preserves CommonJS compatibility and avoids polluting native prototypes. Instead, date serialization is performed internally by the `stringify()` implementation: if a date object does not define a custom `toJSON()` method, it is serialized as a [simplified ISO 8601 date-time string](http://es5.github.com/#x15.9.1.15).
**Several native `Date#toJSON()` implementations produce date time strings that do *not* conform to the grammar outlined in the spec**. In these environments, JSON 3 will override the native `stringify()` implementation. There is an [issue](https://github.com/bestiejs/json3/issues/73) on file to make these tests less strict.
Portions of the date serialization code are adapted from the [`date-shim`](https://github.com/Yaffle/date-shim) project.
# Usage #
## Web Browsers
<script src="//cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js"></script>
<script>
JSON.stringify({"Hello": 123});
// => '{"Hello":123}'
JSON.parse("[[1, 2, 3], 1, 2, 3, 4]", function (key, value) {
if (typeof value == "number") {
value = value % 2 ? "Odd" : "Even";
}
return value;
});
// => [["Odd", "Even", "Odd"], "Odd", "Even", "Odd", "Even"]
</script>
**When used in a web browser**, JSON 3 exposes an additional `JSON3` object containing the `noConflict()` and `runInContext()` functions, as well as aliases to the `stringify()` and `parse()` functions.
### `noConflict` and `runInContext`
* `JSON3.noConflict()` restores the original value of the global `JSON` object and returns a reference to the `JSON3` object.
* `JSON3.runInContext([context, exports])` initializes JSON 3 using the given `context` object (e.g., `window`, `global`, etc.), or the global object if omitted. If an `exports` object is specified, the `stringify()`, `parse()`, and `runInContext()` functions will be attached to it instead of a new object.
### Asynchronous Module Loaders
JSON 3 is defined as an [anonymous module](https://github.com/amdjs/amdjs-api/wiki/AMD#define-function-) for compatibility with [RequireJS](http://requirejs.org/), [`curl.js`](https://github.com/cujojs/curl), and other asynchronous module loaders.
<script src="//cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.js"></script>
<script>
require({
"paths": {
"json3": "./path/to/json3"
}
}, ["json3"], function (JSON) {
JSON.parse("[1, 2, 3]");
// => [1, 2, 3]
});
</script>
To avoid issues with third-party scripts, **JSON 3 is exported to the global scope even when used with a module loader**. If this behavior is undesired, `JSON3.noConflict()` can be used to restore the global `JSON` object to its original value.
**Note:** If you intend to use JSON3 alongside another module, **please do not simply concatenate these modules together**, as that would cause multiple `define` calls in one script, resulting in errors in AMD loaders. The `r.js` build optimizer can be used instead if you need a single compressed file for production.
## CommonJS Environments
var JSON3 = require("./path/to/json3");
JSON3.parse("[1, 2, 3]");
// => [1, 2, 3]
## JavaScript Engines
load("path/to/json3.js");
JSON.stringify({"Hello": 123, "Good-bye": 456}, ["Hello"], "\t");
// => '{\n\t"Hello": 123\n}'
# Compatibility #
JSON 3 has been **tested** with the following web browsers, CommonJS environments, and JavaScript engines.
## Web Browsers
- Windows [Internet Explorer](http://windows.microsoft.com/en-us/internet-explorer/download-ie), version 6.0 and higher
- Google [Chrome](http://www.google.com/chrome), version 19.0 and higher
- Mozilla [Firefox](https://www.mozilla.org/en-US/firefox/new/), version 2.0 and higher
- Apple [Safari](http://www.apple.com/safari/), version 3.0 and higher
- [Opera](http://www.opera.com/) 8.54 and higher
- [SeaMonkey](http://www.seamonkey-project.org/) 1.0 and higher
## CommonJS Environments
- [Node](http://nodejs.org/) 0.6.21 and higher
- [io.js](https://iojs.org/) 1.0.3 and higher
- [RingoJS](http://ringojs.org/) 0.9 and higher
- [Narwhal](https://github.com/280north/narwhal) 0.3.2
## JavaScript Engines
- Mozilla [Rhino](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/Rhino) 1.7R3 and higher
- WebKit [JSC](https://trac.webkit.org/wiki/JSC)
- Google [V8](http://code.google.com/p/v8/)
## Known Incompatibilities
* Attempting to serialize the `arguments` object may produce inconsistent results across environments due to specification version differences. As a workaround, please convert the `arguments` object to an array first: `JSON.stringify([].slice.call(arguments, 0))`.
## Required Native Methods
JSON 3 assumes that the following methods exist and function as described in the ECMAScript specification:
- The `Number`, `String`, `Array`, `Object`, `Date`, `SyntaxError`, and `TypeError` constructors.
- `String.fromCharCode`
- `Object#toString`
- `Object#hasOwnProperty`
- `Function#call`
- `Math.floor`
- `Number#toString`
- `Date#valueOf`
- `String.prototype`: `indexOf`, `charCodeAt`, `charAt`, `slice`, `replace`.
- `Array.prototype`: `push`, `pop`, `join`.

163
node_modules/json3/changes.html generated vendored Normal file
View File

@ -0,0 +1,163 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Releases | JSON 3</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="page/style.css" media="screen">
</head>
<body>
<ul id="navigation">
</ul>
<div id="content">
<h1 id="json-3-releases">JSON 3 Releases</h1>
<h2 id="3-3-2">3.3.2</h2>
<h3 id="2014-06-22">2014-06-22</h3>
<ul>
<li>Test the minified version on Travis [<a href="https://github.com/bestiejs/json3/issues/35">#35</a>].</li>
<li>Add a change log and contribution guidelines [<a href="https://github.com/bestiejs/json3/issues/55">#55</a>].</li>
<li>Include the minified version in the npm package [<a href="https://github.com/bestiejs/json3/issues/59">#59</a>].</li>
<li>Simplify <code>bower.json</code>.</li>
</ul>
<h2 id="3-3-1">3.3.1</h2>
<h3 id="2014-04-08">2014-04-08</h3>
<ul>
<li>Reduce the Bower package size by lazily downloading the Closure Compiler [<a href="https://github.com/bestiejs/json3/issues/54">#54</a>].</li>
<li>Make <code>JSON3.noConflict()</code> idempotent [<a href="https://github.com/bestiejs/json3/issues/56">#56</a>].</li>
<li>Improve AMD <code>define</code> pragma detection before minifying.</li>
<li>Support <a href="https://github.com/rogerwang/node-webkit"><code>node-webkit</code></a> and web workers.</li>
</ul>
<h2 id="3-3-0">3.3.0</h2>
<h3 id="2014-01-20">2014-01-20</h3>
<ul>
<li>Export a <code>JSON3</code> global in browsers and JavaScript engines.</li>
<li>Add <code>JSON3.noConflict()</code> and <code>JSON3.runInContext()</code> [<a href="https://github.com/bestiejs/json3/issues/50">#50</a>].</li>
<li>Add a post-minification step to remove multiple IIFE wrappers.</li>
<li>Optimize <code>quote</code>.</li>
</ul>
<h2 id="3-2-6">3.2.6</h2>
<h3 id="2013-10-25">2013-10-25</h3>
<ul>
<li>Add Travis CI integration.</li>
<li>Support <a href="http://bower.io/">Bower</a>, <a href="https://component.github.io/">Component</a>, <a href="http://jamjs.org/">Jam</a>, and <a href="http://volojs.org/">Volo</a>.</li>
<li>Test with Node, PhantomJS, RingoJS, Rhino, and Narwhal on Travis.</li>
<li>Simplify exports.</li>
<li><code>stringify()</code> optimizations.</li>
<li>Add a <code>?minified</code> query parameter to the browser harness for testing the minified version [<a href="https://github.com/bestiejs/json3/issues/35">#35</a>].</li>
<li>Detect trailing comma and trailing decimal extensions in Rhino 1.7R3-R4 [<a href="https://github.com/bestiejs/json3/issues/46">#46</a>].</li>
</ul>
<h2 id="3-2-5">3.2.5</h2>
<h3 id="2013-06-14">2013-06-14</h3>
<ul>
<li>Use <code>object.hasOwnProperty(prop)</code> instead of <code>Object#hasOwnProperty.call(object, prop)</code> when iterating over host objects [<a href="https://github.com/bestiejs/json3/issues/18">#18</a>].</li>
<li>Minification improvements; avoid munging the AMD <code>define</code> pragma [<a href="https://github.com/bestiejs/json3/issues/22">#22</a>; <a href="https://github.com/bestiejs/json3/pull/25">#25</a>].</li>
<li>Use character codes instead of strings in <code>lex()</code>. Optimize for valid source strings [<a href="https://github.com/bestiejs/json3/issues/23">#23</a>; <a href="https://github.com/bestiejs/json3/pull/27">#27</a>].</li>
<li>Support Adobe ExtendScript [<a href="https://github.com/bestiejs/json3/issues/29">#29</a>].</li>
<li>Handle serializing ExtendScript host objects that throw exceptions [<a href="https://github.com/bestiejs/json3/issues/30">#30</a>; <a href="https://github.com/bestiejs/json3/pull/31">#31</a>].</li>
<li>Support Browserify and RequireJS by exporting for CommonJS and AMD [<a href="https://github.com/bestiejs/json3/pull/33">#33</a>].</li>
<li>Use square bracket character access in <code>parse</code>. Add a <code>charIndexBuggy</code> flag.</li>
<li>Add a benchmark suite.</li>
</ul>
<h2 id="3-2-4">3.2.4</h2>
<h3 id="2012-10-11">2012-10-11</h3>
<ul>
<li>Change the export order to prefer <code>module.exports</code>, <code>exports</code>, and then <code>define</code> [<a href="https://github.com/bestiejs/json3/pull/14">#14</a>].</li>
<li>Avoid conflating duplicate properties and circular references [<a href="https://github.com/bestiejs/json3/issues/15">#15</a>].</li>
<li>Export <code>parse</code> and <code>stringify</code> globally even if an AMD loader is present [<a href="https://github.com/bestiejs/json3/pull/17">#17</a>].</li>
<li>Isolate the feature tests into a <code>has()</code> function for <a href="https://github.com/phiggins42/has.js"><code>has.js</code></a> compatibility [<a href="https://github.com/bestiejs/json3/issues/19">#19</a>].</li>
</ul>
<h2 id="3-2-3">3.2.3</h2>
<h3 id="2012-07-13">2012-07-13</h3>
<ul>
<li>Prototype &lt;= 1.6.1 compatibility [<a href="https://github.com/bestiejs/json3/issues/8">#8</a>].</li>
<li><code>stringify()</code>: Iterate over whitelisted properties in order [<a href="https://github.com/bestiejs/json3/issues/12">#12</a>].</li>
<li>Correctly detect trailing commas in array literals.</li>
</ul>
<h2 id="3-2-2">3.2.2</h2>
<h3 id="2012-05-05">2012-05-05</h3>
<ul>
<li>Correctly detect native <code>parse()</code> implementations in AMD loaders and CommonJS environments [<a href="https://github.com/bestiejs/json3/issues/9">#9</a>].</li>
<li><code>parse()</code>: Use <code>delete</code> instead of <code>Array#splice()</code> when removing elements from traversed arrays [<a href="https://github.com/bestiejs/json3/issues/10">#10</a>].</li>
<li>Detect <code>parse()</code> number grammar extensions in IE 9 [<a href="https://github.com/bestiejs/json3/issues/11">#11</a>].</li>
</ul>
<h2 id="3-2-1">3.2.1</h2>
<h3 id="2012-04-26">2012-04-26</h3>
<ul>
<li>Reduce the file size by removing parse error strings [<a href="https://github.com/bestiejs/json3/issues/5">#5</a>].</li>
<li>Fall back to the native <code>stringify()</code> and <code>parse()</code> implementations in AMD loaders and CommonJS environments [<a href="https://github.com/bestiejs/json3/issues/6">#6</a>].</li>
<li>Use the correct global object when exporting for browsers and JavaScript engines.</li>
<li>Support building on Windows by using <code>zlib</code> instead of shelling out to <code>gzip</code>.</li>
<li>Switch to the Closure Compiler for generating the minified version.</li>
<li><a href="http://requirejs.org/docs/optimization.html"><code>r.js</code></a> compatibility.</li>
<li>Safari &lt; 2.0.2 and Opera &gt;= 10.53 support.</li>
</ul>
<h2 id="3-2-0">3.2.0</h2>
<h3 id="2012-04-15">2012-04-15</h3>
<ul>
<li>Override native <code>stringify()</code> implementations to work around date serialization bugs.</li>
<li>Ensure the date serialization tests pass in all time zones [<a href="https://github.com/bestiejs/json3/issues/3">#3</a>].</li>
<li>Add a workaround for buggy <code>Date#getUTC{FullYear, Month, Date}</code> implementations in Opera &gt; 9.64 [<a href="https://github.com/bestiejs/json3/issues/4">#4</a>].</li>
<li>Ensure Firefox &lt;= 11.0 serializes negative years as six-digit extended years.</li>
<li>Ensure Safari &lt;= 5.1.5 serializes milliseconds correctly.</li>
<li>Add a Node-based build script.</li>
<li>Vendor all dependencies.</li>
<li>Opera 7.54u2 support.</li>
</ul>
<h2 id="3-1-0">3.1.0</h2>
<h3 id="2012-03-22">2012-03-22</h3>
<ul>
<li>Switched to <code>bestiejs</code> organisation</li>
<li>Added support for a list of properties as the <code>filter</code> argument for <code>JSON.stringify</code></li>
<li>Fixed Firefox 4 and 4.0.1 allowing non-standard extensions to <code>JSON.parse</code></li>
</ul>
<h2 id="3-0-0">3.0.0</h2>
<h3 id="2012-03-20">2012-03-20</h3>
<ul>
<li>Renamed <code>JSON3</code> to <code>JSON</code></li>
<li>Removed <code>JSON3.Version</code></li>
<li>Added minified version of library</li>
<li>Created a <a href="http://bestiejs.github.io/json3">GitHub Project Page</a></li>
<li>Preserved alphanumeric order when iterating over shadowed properties on objects</li>
</ul>
<h2 id="0-8-5">0.8.5</h2>
<h3 id="2012-03-16">2012-03-16</h3>
<ul>
<li>Avoided relying on native functions <code>Math.abs</code>, and <code>isFinite</code>, and native constructors <code>String</code>, <code>Number</code>, <code>Object</code>, and <code>Array</code></li>
<li>Fixed AMD export logic</li>
</ul>
<h2 id="0-8-0">0.8.0</h2>
<h3 id="2012-03-15">2012-03-15</h3>
<ul>
<li>Renamed <code>Prim</code> to <code>JSON3</code></li>
<li>Added <code>JSON3.Version</code></li>
<li>Added support for AMD lodaers as the <code>&quot;json&quot;</code> module</li>
<li>Added feature tests for native <code>JSON</code> implementations</li>
<li>Added string coercion for the <code>source</code> argument in <code>JSON3.parse</code></li>
<li>Fixed the date serialization routine in <code>JSON3.stringify</code></li>
</ul>
<h2 id="0-5-0">0.5.0</h2>
<h3 id="2012-02-18">2012-02-18</h3>
<ul>
<li>Fixed <code>Prim.stringify</code>s handling of the <code>width</code> argument</li>
<li>Added Microsofts <a href="https://es5conform.codeplex.com/">ES5 Conformance Tests</a> to the test suite</li>
</ul>
<h2 id="0-2-0">0.2.0</h2>
<h3 id="2012-02-17">2012-02-17</h3>
<ul>
<li>Added <code>Prim.stringify</code> for serializing values</li>
<li>Renamed <code>Prim.Escapes</code> to <code>Prim.Unescapes</code></li>
<li>Disallowed unescaped tab characters in strings passed to <code>Prim.parse</code></li>
</ul>
<h2 id="0-1-0">0.1.0</h2>
<h3 id="2012-02-16">2012-02-16</h3>
<ul>
<li>Initial release of Prim</li>
</ul>
</div>
<div id="footer">
<p>&copy; 2012-2015 <a href="http://kitcambridge.be/">Kit Cambridge</a>, <a href="https://d10.github.io/">Benjamin Tan</a>.</p>
</div>
</body>
</html>

938
node_modules/json3/lib/json3.js generated vendored Normal file
View File

@ -0,0 +1,938 @@
/*! JSON v3.3.2 | https://bestiejs.github.io/json3 | Copyright 2012-2015, Kit Cambridge, Benjamin Tan | http://kit.mit-license.org */
;(function () {
// Detect the `define` function exposed by asynchronous module loaders. The
// strict `define` check is necessary for compatibility with `r.js`.
var isLoader = typeof define === "function" && define.amd;
// A set of types used to distinguish objects from primitives.
var objectTypes = {
"function": true,
"object": true
};
// Detect the `exports` object exposed by CommonJS implementations.
var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
// Use the `global` object exposed by Node (including Browserify via
// `insert-module-globals`), Narwhal, and Ringo as the default context,
// and the `window` object in browsers. Rhino exports a `global` function
// instead.
var root = objectTypes[typeof window] && window || this,
freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global;
if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
root = freeGlobal;
}
// Public: Initializes JSON 3 using the given `context` object, attaching the
// `stringify` and `parse` functions to the specified `exports` object.
function runInContext(context, exports) {
context || (context = root.Object());
exports || (exports = root.Object());
// Native constructor aliases.
var Number = context.Number || root.Number,
String = context.String || root.String,
Object = context.Object || root.Object,
Date = context.Date || root.Date,
SyntaxError = context.SyntaxError || root.SyntaxError,
TypeError = context.TypeError || root.TypeError,
Math = context.Math || root.Math,
nativeJSON = context.JSON || root.JSON;
// Delegate to the native `stringify` and `parse` implementations.
if (typeof nativeJSON == "object" && nativeJSON) {
exports.stringify = nativeJSON.stringify;
exports.parse = nativeJSON.parse;
}
// Convenience aliases.
var objectProto = Object.prototype,
getClass = objectProto.toString,
isProperty = objectProto.hasOwnProperty,
undefined;
// Internal: Contains `try...catch` logic used by other functions.
// This prevents other functions from being deoptimized.
function attempt(func, errorFunc) {
try {
func();
} catch (exception) {
if (errorFunc) {
errorFunc();
}
}
}
// Test the `Date#getUTC*` methods. Based on work by @Yaffle.
var isExtended = new Date(-3509827334573292);
attempt(function () {
// The `getUTCFullYear`, `Month`, and `Date` methods return nonsensical
// results for certain dates in Opera >= 10.53.
isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 &&
isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708;
});
// Internal: Determines whether the native `JSON.stringify` and `parse`
// implementations are spec-compliant. Based on work by Ken Snyder.
function has(name) {
if (has[name] != null) {
// Return cached feature test result.
return has[name];
}
var isSupported;
if (name == "bug-string-char-index") {
// IE <= 7 doesn't support accessing string characters using square
// bracket notation. IE 8 only supports this for primitives.
isSupported = "a"[0] != "a";
} else if (name == "json") {
// Indicates whether both `JSON.stringify` and `JSON.parse` are
// supported.
isSupported = has("json-stringify") && has("date-serialization") && has("json-parse");
} else if (name == "date-serialization") {
// Indicates whether `Date`s can be serialized accurately by `JSON.stringify`.
isSupported = has("json-stringify") && isExtended;
if (isSupported) {
var stringify = exports.stringify;
attempt(function () {
isSupported =
// JSON 2, Prototype <= 1.7, and older WebKit builds incorrectly
// serialize extended years.
stringify(new Date(-8.64e15)) == '"-271821-04-20T00:00:00.000Z"' &&
// The milliseconds are optional in ES 5, but required in 5.1.
stringify(new Date(8.64e15)) == '"+275760-09-13T00:00:00.000Z"' &&
// Firefox <= 11.0 incorrectly serializes years prior to 0 as negative
// four-digit years instead of six-digit years. Credits: @Yaffle.
stringify(new Date(-621987552e5)) == '"-000001-01-01T00:00:00.000Z"' &&
// Safari <= 5.1.5 and Opera >= 10.53 incorrectly serialize millisecond
// values less than 1000. Credits: @Yaffle.
stringify(new Date(-1)) == '"1969-12-31T23:59:59.999Z"';
});
}
} else {
var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
// Test `JSON.stringify`.
if (name == "json-stringify") {
var stringify = exports.stringify, stringifySupported = typeof stringify == "function";
if (stringifySupported) {
// A test function object with a custom `toJSON` method.
(value = function () {
return 1;
}).toJSON = value;
attempt(function () {
stringifySupported =
// Firefox 3.1b1 and b2 serialize string, number, and boolean
// primitives as object literals.
stringify(0) === "0" &&
// FF 3.1b1, b2, and JSON 2 serialize wrapped primitives as object
// literals.
stringify(new Number()) === "0" &&
stringify(new String()) == '""' &&
// FF 3.1b1, 2 throw an error if the value is `null`, `undefined`, or
// does not define a canonical JSON representation (this applies to
// objects with `toJSON` properties as well, *unless* they are nested
// within an object or array).
stringify(getClass) === undefined &&
// IE 8 serializes `undefined` as `"undefined"`. Safari <= 5.1.7 and
// FF 3.1b3 pass this test.
stringify(undefined) === undefined &&
// Safari <= 5.1.7 and FF 3.1b3 throw `Error`s and `TypeError`s,
// respectively, if the value is omitted entirely.
stringify() === undefined &&
// FF 3.1b1, 2 throw an error if the given value is not a number,
// string, array, object, Boolean, or `null` literal. This applies to
// objects with custom `toJSON` methods as well, unless they are nested
// inside object or array literals. YUI 3.0.0b1 ignores custom `toJSON`
// methods entirely.
stringify(value) === "1" &&
stringify([value]) == "[1]" &&
// Prototype <= 1.6.1 serializes `[undefined]` as `"[]"` instead of
// `"[null]"`.
stringify([undefined]) == "[null]" &&
// YUI 3.0.0b1 fails to serialize `null` literals.
stringify(null) == "null" &&
// FF 3.1b1, 2 halts serialization if an array contains a function:
// `[1, true, getClass, 1]` serializes as "[1,true,],". FF 3.1b3
// elides non-JSON values from objects and arrays, unless they
// define custom `toJSON` methods.
stringify([undefined, getClass, null]) == "[null,null,null]" &&
// Simple serialization test. FF 3.1b1 uses Unicode escape sequences
// where character escape codes are expected (e.g., `\b` => `\u0008`).
stringify({ "a": [value, true, false, null, "\x00\b\n\f\r\t"] }) == serialized &&
// FF 3.1b1 and b2 ignore the `filter` and `width` arguments.
stringify(null, value) === "1" &&
stringify([1, 2], null, 1) == "[\n 1,\n 2\n]";
}, function () {
stringifySupported = false;
});
}
isSupported = stringifySupported;
}
// Test `JSON.parse`.
if (name == "json-parse") {
var parse = exports.parse, parseSupported;
if (typeof parse == "function") {
attempt(function () {
// FF 3.1b1, b2 will throw an exception if a bare literal is provided.
// Conforming implementations should also coerce the initial argument to
// a string prior to parsing.
if (parse("0") === 0 && !parse(false)) {
// Simple parsing test.
value = parse(serialized);
parseSupported = value["a"].length == 5 && value["a"][0] === 1;
if (parseSupported) {
attempt(function () {
// Safari <= 5.1.2 and FF 3.1b1 allow unescaped tabs in strings.
parseSupported = !parse('"\t"');
});
if (parseSupported) {
attempt(function () {
// FF 4.0 and 4.0.1 allow leading `+` signs and leading
// decimal points. FF 4.0, 4.0.1, and IE 9-10 also allow
// certain octal literals.
parseSupported = parse("01") !== 1;
});
}
if (parseSupported) {
attempt(function () {
// FF 4.0, 4.0.1, and Rhino 1.7R3-R4 allow trailing decimal
// points. These environments, along with FF 3.1b1 and 2,
// also allow trailing commas in JSON objects and arrays.
parseSupported = parse("1.") !== 1;
});
}
}
}
}, function () {
parseSupported = false;
});
}
isSupported = parseSupported;
}
}
return has[name] = !!isSupported;
}
has["bug-string-char-index"] = has["date-serialization"] = has["json"] = has["json-stringify"] = has["json-parse"] = null;
if (!has("json")) {
// Common `[[Class]]` name aliases.
var functionClass = "[object Function]",
dateClass = "[object Date]",
numberClass = "[object Number]",
stringClass = "[object String]",
arrayClass = "[object Array]",
booleanClass = "[object Boolean]";
// Detect incomplete support for accessing string characters by index.
var charIndexBuggy = has("bug-string-char-index");
// Internal: Normalizes the `for...in` iteration algorithm across
// environments. Each enumerated key is yielded to a `callback` function.
var forOwn = function (object, callback) {
var size = 0, Properties, dontEnums, property;
// Tests for bugs in the current environment's `for...in` algorithm. The
// `valueOf` property inherits the non-enumerable flag from
// `Object.prototype` in older versions of IE, Netscape, and Mozilla.
(Properties = function () {
this.valueOf = 0;
}).prototype.valueOf = 0;
// Iterate over a new instance of the `Properties` class.
dontEnums = new Properties();
for (property in dontEnums) {
// Ignore all properties inherited from `Object.prototype`.
if (isProperty.call(dontEnums, property)) {
size++;
}
}
Properties = dontEnums = null;
// Normalize the iteration algorithm.
if (!size) {
// A list of non-enumerable properties inherited from `Object.prototype`.
dontEnums = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
// IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable
// properties.
forOwn = function (object, callback) {
var isFunction = getClass.call(object) == functionClass, property, length;
var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;
for (property in object) {
// Gecko <= 1.0 enumerates the `prototype` property of functions under
// certain conditions; IE does not.
if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {
callback(property);
}
}
// Manually invoke the callback for each non-enumerable property.
for (length = dontEnums.length; property = dontEnums[--length];) {
if (hasProperty.call(object, property)) {
callback(property);
}
}
};
} else {
// No bugs detected; use the standard `for...in` algorithm.
forOwn = function (object, callback) {
var isFunction = getClass.call(object) == functionClass, property, isConstructor;
for (property in object) {
if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {
callback(property);
}
}
// Manually invoke the callback for the `constructor` property due to
// cross-environment inconsistencies.
if (isConstructor || isProperty.call(object, (property = "constructor"))) {
callback(property);
}
};
}
return forOwn(object, callback);
};
// Public: Serializes a JavaScript `value` as a JSON string. The optional
// `filter` argument may specify either a function that alters how object and
// array members are serialized, or an array of strings and numbers that
// indicates which properties should be serialized. The optional `width`
// argument may be either a string or number that specifies the indentation
// level of the output.
if (!has("json-stringify") && !has("date-serialization")) {
// Internal: A map of control characters and their escaped equivalents.
var Escapes = {
92: "\\\\",
34: '\\"',
8: "\\b",
12: "\\f",
10: "\\n",
13: "\\r",
9: "\\t"
};
// Internal: Converts `value` into a zero-padded string such that its
// length is at least equal to `width`. The `width` must be <= 6.
var leadingZeroes = "000000";
var toPaddedString = function (width, value) {
// The `|| 0` expression is necessary to work around a bug in
// Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`.
return (leadingZeroes + (value || 0)).slice(-width);
};
// Internal: Serializes a date object.
var serializeDate = function (value) {
var getData, year, month, date, time, hours, minutes, seconds, milliseconds;
// Define additional utility methods if the `Date` methods are buggy.
if (!isExtended) {
var floor = Math.floor;
// A mapping between the months of the year and the number of days between
// January 1st and the first of the respective month.
var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
// Internal: Calculates the number of days between the Unix epoch and the
// first day of the given month.
var getDay = function (year, month) {
return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);
};
getData = function (value) {
// Manually compute the year, month, date, hours, minutes,
// seconds, and milliseconds if the `getUTC*` methods are
// buggy. Adapted from @Yaffle's `date-shim` project.
date = floor(value / 864e5);
for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);
for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);
date = 1 + date - getDay(year, month);
// The `time` value specifies the time within the day (see ES
// 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used
// to compute `A modulo B`, as the `%` operator does not
// correspond to the `modulo` operation for negative numbers.
time = (value % 864e5 + 864e5) % 864e5;
// The hours, minutes, seconds, and milliseconds are obtained by
// decomposing the time within the day. See section 15.9.1.10.
hours = floor(time / 36e5) % 24;
minutes = floor(time / 6e4) % 60;
seconds = floor(time / 1e3) % 60;
milliseconds = time % 1e3;
};
} else {
getData = function (value) {
year = value.getUTCFullYear();
month = value.getUTCMonth();
date = value.getUTCDate();
hours = value.getUTCHours();
minutes = value.getUTCMinutes();
seconds = value.getUTCSeconds();
milliseconds = value.getUTCMilliseconds();
};
}
serializeDate = function (value) {
if (value > -1 / 0 && value < 1 / 0) {
// Dates are serialized according to the `Date#toJSON` method
// specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15
// for the ISO 8601 date time string format.
getData(value);
// Serialize extended years correctly.
value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +
"-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) +
// Months, dates, hours, minutes, and seconds should have two
// digits; milliseconds should have three.
"T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) +
// Milliseconds are optional in ES 5.0, but required in 5.1.
"." + toPaddedString(3, milliseconds) + "Z";
year = month = date = hours = minutes = seconds = milliseconds = null;
} else {
value = null;
}
return value;
};
return serializeDate(value);
};
// For environments with `JSON.stringify` but buggy date serialization,
// we override the native `Date#toJSON` implementation with a
// spec-compliant one.
if (has("json-stringify") && !has("date-serialization")) {
// Internal: the `Date#toJSON` implementation used to override the native one.
function dateToJSON (key) {
return serializeDate(this);
}
// Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
var nativeStringify = exports.stringify;
exports.stringify = function (source, filter, width) {
var nativeToJSON = Date.prototype.toJSON;
Date.prototype.toJSON = dateToJSON;
var result = nativeStringify(source, filter, width);
Date.prototype.toJSON = nativeToJSON;
return result;
}
} else {
// Internal: Double-quotes a string `value`, replacing all ASCII control
// characters (characters with code unit values between 0 and 31) with
// their escaped equivalents. This is an implementation of the
// `Quote(value)` operation defined in ES 5.1 section 15.12.3.
var unicodePrefix = "\\u00";
var escapeChar = function (character) {
var charCode = character.charCodeAt(0), escaped = Escapes[charCode];
if (escaped) {
return escaped;
}
return unicodePrefix + toPaddedString(2, charCode.toString(16));
};
var reEscape = /[\x00-\x1f\x22\x5c]/g;
var quote = function (value) {
reEscape.lastIndex = 0;
return '"' +
(
reEscape.test(value)
? value.replace(reEscape, escapeChar)
: value
) +
'"';
};
// Internal: Recursively serializes an object. Implements the
// `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.
var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {
var value, type, className, results, element, index, length, prefix, result;
attempt(function () {
// Necessary for host object support.
value = object[property];
});
if (typeof value == "object" && value) {
if (value.getUTCFullYear && getClass.call(value) == dateClass && value.toJSON === Date.prototype.toJSON) {
value = serializeDate(value);
} else if (typeof value.toJSON == "function") {
value = value.toJSON(property);
}
}
if (callback) {
// If a replacement function was provided, call it to obtain the value
// for serialization.
value = callback.call(object, property, value);
}
// Exit early if value is `undefined` or `null`.
if (value == undefined) {
return value === undefined ? value : "null";
}
type = typeof value;
// Only call `getClass` if the value is an object.
if (type == "object") {
className = getClass.call(value);
}
switch (className || type) {
case "boolean":
case booleanClass:
// Booleans are represented literally.
return "" + value;
case "number":
case numberClass:
// JSON numbers must be finite. `Infinity` and `NaN` are serialized as
// `"null"`.
return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";
case "string":
case stringClass:
// Strings are double-quoted and escaped.
return quote("" + value);
}
// Recursively serialize objects and arrays.
if (typeof value == "object") {
// Check for cyclic structures. This is a linear search; performance
// is inversely proportional to the number of unique nested objects.
for (length = stack.length; length--;) {
if (stack[length] === value) {
// Cyclic structures cannot be serialized by `JSON.stringify`.
throw TypeError();
}
}
// Add the object to the stack of traversed objects.
stack.push(value);
results = [];
// Save the current indentation level and indent one additional level.
prefix = indentation;
indentation += whitespace;
if (className == arrayClass) {
// Recursively serialize array elements.
for (index = 0, length = value.length; index < length; index++) {
element = serialize(index, value, callback, properties, whitespace, indentation, stack);
results.push(element === undefined ? "null" : element);
}
result = results.length ? (whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : ("[" + results.join(",") + "]")) : "[]";
} else {
// Recursively serialize object members. Members are selected from
// either a user-specified list of property names, or the object
// itself.
forOwn(properties || value, function (property) {
var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
if (element !== undefined) {
// According to ES 5.1 section 15.12.3: "If `gap` {whitespace}
// is not the empty string, let `member` {quote(property) + ":"}
// be the concatenation of `member` and the `space` character."
// The "`space` character" refers to the literal space
// character, not the `space` {width} argument provided to
// `JSON.stringify`.
results.push(quote(property) + ":" + (whitespace ? " " : "") + element);
}
});
result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}";
}
// Remove the object from the traversed object stack.
stack.pop();
return result;
}
};
// Public: `JSON.stringify`. See ES 5.1 section 15.12.3.
exports.stringify = function (source, filter, width) {
var whitespace, callback, properties, className;
if (objectTypes[typeof filter] && filter) {
className = getClass.call(filter);
if (className == functionClass) {
callback = filter;
} else if (className == arrayClass) {
// Convert the property names array into a makeshift set.
properties = {};
for (var index = 0, length = filter.length, value; index < length;) {
value = filter[index++];
className = getClass.call(value);
if (className == "[object String]" || className == "[object Number]") {
properties[value] = 1;
}
}
}
}
if (width) {
className = getClass.call(width);
if (className == numberClass) {
// Convert the `width` to an integer and create a string containing
// `width` number of space characters.
if ((width -= width % 1) > 0) {
if (width > 10) {
width = 10;
}
for (whitespace = ""; whitespace.length < width;) {
whitespace += " ";
}
}
} else if (className == stringClass) {
whitespace = width.length <= 10 ? width : width.slice(0, 10);
}
}
// Opera <= 7.54u2 discards the values associated with empty string keys
// (`""`) only if they are used directly within an object member list
// (e.g., `!("" in { "": 1})`).
return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []);
};
}
}
// Public: Parses a JSON source string.
if (!has("json-parse")) {
var fromCharCode = String.fromCharCode;
// Internal: A map of escaped control characters and their unescaped
// equivalents.
var Unescapes = {
92: "\\",
34: '"',
47: "/",
98: "\b",
116: "\t",
110: "\n",
102: "\f",
114: "\r"
};
// Internal: Stores the parser state.
var Index, Source;
// Internal: Resets the parser state and throws a `SyntaxError`.
var abort = function () {
Index = Source = null;
throw SyntaxError();
};
// Internal: Returns the next token, or `"$"` if the parser has reached
// the end of the source string. A token may be a string, number, `null`
// literal, or Boolean literal.
var lex = function () {
var source = Source, length = source.length, value, begin, position, isSigned, charCode;
while (Index < length) {
charCode = source.charCodeAt(Index);
switch (charCode) {
case 9: case 10: case 13: case 32:
// Skip whitespace tokens, including tabs, carriage returns, line
// feeds, and space characters.
Index++;
break;
case 123: case 125: case 91: case 93: case 58: case 44:
// Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at
// the current position.
value = charIndexBuggy ? source.charAt(Index) : source[Index];
Index++;
return value;
case 34:
// `"` delimits a JSON string; advance to the next character and
// begin parsing the string. String tokens are prefixed with the
// sentinel `@` character to distinguish them from punctuators and
// end-of-string tokens.
for (value = "@", Index++; Index < length;) {
charCode = source.charCodeAt(Index);
if (charCode < 32) {
// Unescaped ASCII control characters (those with a code unit
// less than the space character) are not permitted.
abort();
} else if (charCode == 92) {
// A reverse solidus (`\`) marks the beginning of an escaped
// control character (including `"`, `\`, and `/`) or Unicode
// escape sequence.
charCode = source.charCodeAt(++Index);
switch (charCode) {
case 92: case 34: case 47: case 98: case 116: case 110: case 102: case 114:
// Revive escaped control characters.
value += Unescapes[charCode];
Index++;
break;
case 117:
// `\u` marks the beginning of a Unicode escape sequence.
// Advance to the first character and validate the
// four-digit code point.
begin = ++Index;
for (position = Index + 4; Index < position; Index++) {
charCode = source.charCodeAt(Index);
// A valid sequence comprises four hexdigits (case-
// insensitive) that form a single hexadecimal value.
if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
// Invalid Unicode escape sequence.
abort();
}
}
// Revive the escaped character.
value += fromCharCode("0x" + source.slice(begin, Index));
break;
default:
// Invalid escape sequence.
abort();
}
} else {
if (charCode == 34) {
// An unescaped double-quote character marks the end of the
// string.
break;
}
charCode = source.charCodeAt(Index);
begin = Index;
// Optimize for the common case where a string is valid.
while (charCode >= 32 && charCode != 92 && charCode != 34) {
charCode = source.charCodeAt(++Index);
}
// Append the string as-is.
value += source.slice(begin, Index);
}
}
if (source.charCodeAt(Index) == 34) {
// Advance to the next character and return the revived string.
Index++;
return value;
}
// Unterminated string.
abort();
default:
// Parse numbers and literals.
begin = Index;
// Advance past the negative sign, if one is specified.
if (charCode == 45) {
isSigned = true;
charCode = source.charCodeAt(++Index);
}
// Parse an integer or floating-point value.
if (charCode >= 48 && charCode <= 57) {
// Leading zeroes are interpreted as octal literals.
if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {
// Illegal octal literal.
abort();
}
isSigned = false;
// Parse the integer component.
for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);
// Floats cannot contain a leading decimal point; however, this
// case is already accounted for by the parser.
if (source.charCodeAt(Index) == 46) {
position = ++Index;
// Parse the decimal component.
for (; position < length; position++) {
charCode = source.charCodeAt(position);
if (charCode < 48 || charCode > 57) {
break;
}
}
if (position == Index) {
// Illegal trailing decimal.
abort();
}
Index = position;
}
// Parse exponents. The `e` denoting the exponent is
// case-insensitive.
charCode = source.charCodeAt(Index);
if (charCode == 101 || charCode == 69) {
charCode = source.charCodeAt(++Index);
// Skip past the sign following the exponent, if one is
// specified.
if (charCode == 43 || charCode == 45) {
Index++;
}
// Parse the exponential component.
for (position = Index; position < length; position++) {
charCode = source.charCodeAt(position);
if (charCode < 48 || charCode > 57) {
break;
}
}
if (position == Index) {
// Illegal empty exponent.
abort();
}
Index = position;
}
// Coerce the parsed value to a JavaScript number.
return +source.slice(begin, Index);
}
// A negative sign may only precede numbers.
if (isSigned) {
abort();
}
// `true`, `false`, and `null` literals.
var temp = source.slice(Index, Index + 4);
if (temp == "true") {
Index += 4;
return true;
} else if (temp == "fals" && source.charCodeAt(Index + 4 ) == 101) {
Index += 5;
return false;
} else if (temp == "null") {
Index += 4;
return null;
}
// Unrecognized token.
abort();
}
}
// Return the sentinel `$` character if the parser has reached the end
// of the source string.
return "$";
};
// Internal: Parses a JSON `value` token.
var get = function (value) {
var results, hasMembers;
if (value == "$") {
// Unexpected end of input.
abort();
}
if (typeof value == "string") {
if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
// Remove the sentinel `@` character.
return value.slice(1);
}
// Parse object and array literals.
if (value == "[") {
// Parses a JSON array, returning a new JavaScript array.
results = [];
for (;;) {
value = lex();
// A closing square bracket marks the end of the array literal.
if (value == "]") {
break;
}
// If the array literal contains elements, the current token
// should be a comma separating the previous element from the
// next.
if (hasMembers) {
if (value == ",") {
value = lex();
if (value == "]") {
// Unexpected trailing `,` in array literal.
abort();
}
} else {
// A `,` must separate each array element.
abort();
}
} else {
hasMembers = true;
}
// Elisions and leading commas are not permitted.
if (value == ",") {
abort();
}
results.push(get(value));
}
return results;
} else if (value == "{") {
// Parses a JSON object, returning a new JavaScript object.
results = {};
for (;;) {
value = lex();
// A closing curly brace marks the end of the object literal.
if (value == "}") {
break;
}
// If the object literal contains members, the current token
// should be a comma separator.
if (hasMembers) {
if (value == ",") {
value = lex();
if (value == "}") {
// Unexpected trailing `,` in object literal.
abort();
}
} else {
// A `,` must separate each object member.
abort();
}
} else {
hasMembers = true;
}
// Leading commas are not permitted, object property names must be
// double-quoted strings, and a `:` must separate each property
// name and value.
if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
abort();
}
results[value.slice(1)] = get(lex());
}
return results;
}
// Unexpected token encountered.
abort();
}
return value;
};
// Internal: Updates a traversed object member.
var update = function (source, property, callback) {
var element = walk(source, property, callback);
if (element === undefined) {
delete source[property];
} else {
source[property] = element;
}
};
// Internal: Recursively traverses a parsed JSON object, invoking the
// `callback` function for each value. This is an implementation of the
// `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.
var walk = function (source, property, callback) {
var value = source[property], length;
if (typeof value == "object" && value) {
// `forOwn` can't be used to traverse an array in Opera <= 8.54
// because its `Object#hasOwnProperty` implementation returns `false`
// for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`).
if (getClass.call(value) == arrayClass) {
for (length = value.length; length--;) {
update(getClass, forOwn, value, length, callback);
}
} else {
forOwn(value, function (property) {
update(value, property, callback);
});
}
}
return callback.call(source, property, value);
};
// Public: `JSON.parse`. See ES 5.1 section 15.12.2.
exports.parse = function (source, callback) {
var result, value;
Index = 0;
Source = "" + source;
result = get(lex());
// If a JSON string contains multiple tokens, it is invalid.
if (lex() != "$") {
abort();
}
// Reset the parser state.
Index = Source = null;
return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result;
};
}
}
exports.runInContext = runInContext;
return exports;
}
if (freeExports && !isLoader) {
// Export for CommonJS environments.
runInContext(root, freeExports);
} else {
// Export for web browsers and JavaScript engines.
var nativeJSON = root.JSON,
previousJSON = root.JSON3,
isRestored = false;
var JSON3 = runInContext(root, (root.JSON3 = {
// Public: Restores the original value of the global `JSON` object and
// returns a reference to the `JSON3` object.
"noConflict": function () {
if (!isRestored) {
isRestored = true;
root.JSON = nativeJSON;
root.JSON3 = previousJSON;
nativeJSON = previousJSON = null;
}
return JSON3;
}
}));
root.JSON = {
"parse": JSON3.parse,
"stringify": JSON3.stringify
};
}
// Export for asynchronous module loaders.
if (isLoader) {
define(function () {
return JSON3;
});
}
}).call(this);

19
node_modules/json3/lib/json3.min.js generated vendored Normal file
View File

@ -0,0 +1,19 @@
/*! JSON v3.3.2 | https://bestiejs.github.io/json3 | Copyright 2012-2015, Kit Cambridge, Benjamin Tan | http://kit.mit-license.org */
/*
JSON v3.3.2 | https://bestiejs.github.io/json3 | Copyright 2012-2015, Kit Cambridge, Benjamin Tan | http://kit.mit-license.org */
(function(){function O(u,v){function B(a,d){try{a()}catch(c){d&&d()}}function q(a){if(null!=q[a])return q[a];if("bug-string-char-index"==a)var d=!1;else if("json"==a)d=q("json-stringify")&&q("date-serialization")&&q("json-parse");else if("date-serialization"==a){if(d=q("json-stringify")&&y){var c=v.stringify;B(function(){d='"-271821-04-20T00:00:00.000Z"'==c(new z(-864E13))&&'"+275760-09-13T00:00:00.000Z"'==c(new z(864E13))&&'"-000001-01-01T00:00:00.000Z"'==c(new z(-621987552E5))&&'"1969-12-31T23:59:59.999Z"'==
c(new z(-1))})}}else{var e;if("json-stringify"==a){c=v.stringify;var g="function"==typeof c;g&&((e=function(){return 1}).toJSON=e,B(function(){g="0"===c(0)&&"0"===c(new ca)&&'""'==c(new U)&&c(w)===x&&c(x)===x&&c()===x&&"1"===c(e)&&"[1]"==c([e])&&"[null]"==c([x])&&"null"==c(null)&&"[null,null,null]"==c([x,w,null])&&'{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}'==c({a:[e,!0,!1,null,"\x00\b\n\f\r\t"]})&&"1"===c(null,e)&&"[\n 1,\n 2\n]"==c([1,2],null,1)},function(){g=!1}));d=g}if("json-parse"==
a){var l=v.parse,b;"function"==typeof l&&B(function(){0===l("0")&&!l(!1)&&(e=l('{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}'),b=5==e.a.length&&1===e.a[0])&&(B(function(){b=!l('"\t"')}),b&&B(function(){b=1!==l("01")}),b&&B(function(){b=1!==l("1.")}))},function(){b=!1});d=b}}return q[a]=!!d}u||(u=r.Object());v||(v=r.Object());var ca=u.Number||r.Number,U=u.String||r.String,I=u.Object||r.Object,z=u.Date||r.Date,da=u.SyntaxError||r.SyntaxError,ea=u.TypeError||r.TypeError,fa=u.Math||r.Math;u=u.JSON||
r.JSON;"object"==typeof u&&u&&(v.stringify=u.stringify,v.parse=u.parse);I=I.prototype;var w=I.toString,J=I.hasOwnProperty,x,y=new z(-0xc782b5b800cec);B(function(){y=-109252==y.getUTCFullYear()&&0===y.getUTCMonth()&&1===y.getUTCDate()&&10==y.getUTCHours()&&37==y.getUTCMinutes()&&6==y.getUTCSeconds()&&708==y.getUTCMilliseconds()});q["bug-string-char-index"]=q["date-serialization"]=q.json=q["json-stringify"]=q["json-parse"]=null;if(!q("json")){var P=q("bug-string-char-index"),G=function(a,d){var c=0,
e,g;(e=function(){this.valueOf=0}).prototype.valueOf=0;var l=new e;for(g in l)J.call(l,g)&&c++;e=l=null;c?G=function(b,h){var p="[object Function]"==w.call(b),k,n;for(k in b)p&&"prototype"==k||!J.call(b,k)||(n="constructor"===k)||h(k);(n||J.call(b,k="constructor"))&&h(k)}:(l="valueOf toString toLocaleString propertyIsEnumerable isPrototypeOf hasOwnProperty constructor".split(" "),G=function(b,h){var p="[object Function]"==w.call(b),k,n=!p&&"function"!=typeof b.constructor&&H[typeof b.hasOwnProperty]&&
b.hasOwnProperty||J;for(k in b)p&&"prototype"==k||!n.call(b,k)||h(k);for(p=l.length;k=l[--p];)n.call(b,k)&&h(k)});return G(a,d)};if(!q("json-stringify")&&!q("date-serialization")){var ha={92:"\\\\",34:'\\"',8:"\\b",12:"\\f",10:"\\n",13:"\\r",9:"\\t"},A=function(a,d){return("000000"+(d||0)).slice(-a)},L=function(a){var d,c,e,g,l,b,h,p;if(y)var k=function(m){d=m.getUTCFullYear();c=m.getUTCMonth();e=m.getUTCDate();l=m.getUTCHours();b=m.getUTCMinutes();h=m.getUTCSeconds();p=m.getUTCMilliseconds()};else{var n=
fa.floor,K=[0,31,59,90,120,151,181,212,243,273,304,334],D=function(m,C){return K[C]+365*(m-1970)+n((m-1969+(C=+(1<C)))/4)-n((m-1901+C)/100)+n((m-1601+C)/400)};k=function(m){e=n(m/864E5);for(d=n(e/365.2425)+1970-1;D(d+1,0)<=e;d++);for(c=n((e-D(d,0))/30.42);D(d,c+1)<=e;c++);e=1+e-D(d,c);g=(m%864E5+864E5)%864E5;l=n(g/36E5)%24;b=n(g/6E4)%60;h=n(g/1E3)%60;p=g%1E3}}L=function(m){m>-1/0&&m<1/0?(k(m),m=(0>=d||1E4<=d?(0>d?"-":"+")+A(6,0>d?-d:d):A(4,d))+"-"+A(2,c+1)+"-"+A(2,e)+"T"+A(2,l)+":"+A(2,b)+":"+A(2,
h)+"."+A(3,p)+"Z",d=c=e=l=b=h=p=null):m=null;return m};return L(a)};if(q("json-stringify")&&!q("date-serialization")){var ia=function(){return L(this)},ja=v.stringify;v.stringify=function(a,d,c){var e=z.prototype.toJSON;z.prototype.toJSON=ia;a=ja(a,d,c);z.prototype.toJSON=e;return a}}else{var ka=function(a){a=a.charCodeAt(0);var d=ha[a];return d?d:"\\u00"+A(2,a.toString(16))},Q=/[\x00-\x1f\x22\x5c]/g,V=function(a){Q.lastIndex=0;return'"'+(Q.test(a)?a.replace(Q,ka):a)+'"'},R=function(a,d,c,e,g,l,b){var h,
p;B(function(){h=d[a]});"object"==typeof h&&h&&(h.getUTCFullYear&&"[object Date]"==w.call(h)&&h.toJSON===z.prototype.toJSON?h=L(h):"function"==typeof h.toJSON&&(h=h.toJSON(a)));c&&(h=c.call(d,a,h));if(h==x)return h===x?h:"null";var k=typeof h;"object"==k&&(p=w.call(h));switch(p||k){case "boolean":case "[object Boolean]":return""+h;case "number":case "[object Number]":return h>-1/0&&h<1/0?""+h:"null";case "string":case "[object String]":return V(""+h)}if("object"==typeof h){for(k=b.length;k--;)if(b[k]===
h)throw ea();b.push(h);var n=[];var K=l;l+=g;if("[object Array]"==p){var D=0;for(k=h.length;D<k;D++)p=R(D,h,c,e,g,l,b),n.push(p===x?"null":p);k=n.length?g?"[\n"+l+n.join(",\n"+l)+"\n"+K+"]":"["+n.join(",")+"]":"[]"}else G(e||h,function(m){var C=R(m,h,c,e,g,l,b);C!==x&&n.push(V(m)+":"+(g?" ":"")+C)}),k=n.length?g?"{\n"+l+n.join(",\n"+l)+"\n"+K+"}":"{"+n.join(",")+"}":"{}";b.pop();return k}};v.stringify=function(a,d,c){var e;if(H[typeof d]&&d){var g=w.call(d);if("[object Function]"==g)var l=d;else if("[object Array]"==
g){var b={};for(var h=0,p=d.length,k;h<p;)if(k=d[h++],g=w.call(k),"[object String]"==g||"[object Number]"==g)b[k]=1}}if(c)if(g=w.call(c),"[object Number]"==g){if(0<(c-=c%1))for(10<c&&(c=10),e="";e.length<c;)e+=" "}else"[object String]"==g&&(e=10>=c.length?c:c.slice(0,10));return R("",(k={},k[""]=a,k),l,b,e,"",[])}}}if(!q("json-parse")){var la=U.fromCharCode,ma={92:"\\",34:'"',47:"/",98:"\b",116:"\t",110:"\n",102:"\f",114:"\r"},f,M,t=function(){f=M=null;throw da();},E=function(){for(var a=M,d=a.length,
c,e,g,l,b;f<d;)switch(b=a.charCodeAt(f),b){case 9:case 10:case 13:case 32:f++;break;case 123:case 125:case 91:case 93:case 58:case 44:return c=P?a.charAt(f):a[f],f++,c;case 34:c="@";for(f++;f<d;)if(b=a.charCodeAt(f),32>b)t();else if(92==b)switch(b=a.charCodeAt(++f),b){case 92:case 34:case 47:case 98:case 116:case 110:case 102:case 114:c+=ma[b];f++;break;case 117:e=++f;for(g=f+4;f<g;f++)b=a.charCodeAt(f),48<=b&&57>=b||97<=b&&102>=b||65<=b&&70>=b||t();c+=la("0x"+a.slice(e,f));break;default:t()}else{if(34==
b)break;b=a.charCodeAt(f);for(e=f;32<=b&&92!=b&&34!=b;)b=a.charCodeAt(++f);c+=a.slice(e,f)}if(34==a.charCodeAt(f))return f++,c;t();default:e=f;45==b&&(l=!0,b=a.charCodeAt(++f));if(48<=b&&57>=b){for(48==b&&(b=a.charCodeAt(f+1),48<=b&&57>=b)&&t();f<d&&(b=a.charCodeAt(f),48<=b&&57>=b);f++);if(46==a.charCodeAt(f)){for(g=++f;g<d&&!(b=a.charCodeAt(g),48>b||57<b);g++);g==f&&t();f=g}b=a.charCodeAt(f);if(101==b||69==b){b=a.charCodeAt(++f);43!=b&&45!=b||f++;for(g=f;g<d&&!(b=a.charCodeAt(g),48>b||57<b);g++);
g==f&&t();f=g}return+a.slice(e,f)}l&&t();c=a.slice(f,f+4);if("true"==c)return f+=4,!0;if("fals"==c&&101==a.charCodeAt(f+4))return f+=5,!1;if("null"==c)return f+=4,null;t()}return"$"},S=function(a){var d;"$"==a&&t();if("string"==typeof a){if("@"==(P?a.charAt(0):a[0]))return a.slice(1);if("["==a){for(d=[];;){a=E();if("]"==a)break;if(c)","==a?(a=E(),"]"==a&&t()):t();else var c=!0;","==a&&t();d.push(S(a))}return d}if("{"==a){for(d={};;){a=E();if("}"==a)break;c?","==a?(a=E(),"}"==a&&t()):t():c=!0;","!=
a&&"string"==typeof a&&"@"==(P?a.charAt(0):a[0])&&":"==E()||t();d[a.slice(1)]=S(E())}return d}t()}return a},X=function(a,d,c){c=W(a,d,c);c===x?delete a[d]:a[d]=c},W=function(a,d,c){var e=a[d],g;if("object"==typeof e&&e)if("[object Array]"==w.call(e))for(g=e.length;g--;)X(w,G,e,g,c);else G(e,function(l){X(e,l,c)});return c.call(a,d,e)};v.parse=function(a,d){var c;f=0;M=""+a;a=S(E());"$"!=E()&&t();f=M=null;return d&&"[object Function]"==w.call(d)?W((c={},c[""]=a,c),"",d):a}}}v.runInContext=O;return v}
var Y=typeof define==="function"&&define.amd,H={"function":!0,object:!0},T=H[typeof exports]&&exports&&!exports.nodeType&&exports,r=H[typeof window]&&window||this,F=T&&H[typeof module]&&module&&!module.nodeType&&"object"==typeof global&&global;!F||F.global!==F&&F.window!==F&&F.self!==F||(r=F);if(T&&!Y)O(r,T);else{var Z=r.JSON,aa=r.JSON3,ba=!1,N=O(r,r.JSON3={noConflict:function(){ba||(ba=!0,r.JSON=Z,r.JSON3=aa,Z=aa=null);return N}});r.JSON={parse:N.parse,stringify:N.stringify}}Y&&define(function(){return N})}).call(this);

129
node_modules/json3/package.json generated vendored Normal file
View File

@ -0,0 +1,129 @@
{
"_from": "json3@^3.3.3",
"_id": "json3@3.3.3",
"_inBundle": false,
"_integrity": "sha512-c7/8mbUsKigAbLkD5B010BK4D9LZm7A1pNItkEwiUZRpIN66exu/e7YQWysGun+TRKaJp8MhemM+VkfWv42aCA==",
"_location": "/json3",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "json3@^3.3.3",
"name": "json3",
"escapedName": "json3",
"rawSpec": "^3.3.3",
"saveSpec": null,
"fetchSpec": "^3.3.3"
},
"_requiredBy": [
"#USER",
"/"
],
"_resolved": "https://registry.npmjs.org/json3/-/json3-3.3.3.tgz",
"_shasum": "7fc10e375fc5ae42c4705a5cc0aa6f62be305b81",
"_spec": "json3@^3.3.3",
"_where": "C:\\Users\\knh94\\Documents\\GitHub\\welsonjs",
"author": {
"name": "Kit Cambridge",
"email": "github@kitcambridge.be",
"url": "http://kitcambridge.be/"
},
"bugs": {
"url": "https://github.com/bestiejs/json3/issues"
},
"bundleDependencies": false,
"contributors": [
{
"name": "Mangled Deutz",
"email": "olivier@webitup.fr",
"url": "http://tech.roxee.tv/"
},
{
"name": "Øyvind Sean Kinsey",
"email": "oyvind@kinsey.no",
"url": "http://fb.me/ok"
},
{
"name": "Oskar Schöldström",
"email": "public@oxy.fi",
"url": "http://oxy.fi/"
},
{
"name": "Kiryl Yermakou",
"email": "rma4ok@gmail.com",
"url": "https://github.com/rma4ok"
}
],
"deprecated": false,
"description": "A JSON polyfill for older JavaScript platforms.",
"devDependencies": {
"curl-amd": "~0.8.12",
"highlight.js": "~8.3.0",
"marked": "~0.3.2",
"requirejs": "~2.1.15",
"spec": "~1.0.1",
"tar": "~1.0.2"
},
"files": [
"README.md",
"LICENSE",
"lib/json3.js",
"lib/json3.min.js"
],
"homepage": "https://bestiejs.github.io/json3",
"jam": {
"main": "./lib/json3.js",
"includes": [
"README.md",
"LICENSE",
"lib/json3.js",
"lib/json3.min.js"
]
},
"keywords": [
"json",
"spec",
"ecma",
"es5",
"lexer",
"parser",
"stringify"
],
"license": "MIT",
"main": "./lib/json3",
"maintainers": [
{
"name": "Kit Cambridge",
"email": "github@kitcambridge.be",
"url": "http://kitcambridge.be/"
},
{
"name": "Benjamin Tan",
"email": "demoneaux@gmail.com",
"url": "https://d10.github.io/"
}
],
"name": "json3",
"repository": {
"type": "git",
"url": "git://github.com/bestiejs/json3.git"
},
"scripts": {
"test": "node test/test_*.js"
},
"version": "3.3.3",
"volo": {
"type": "directory",
"ignore": [
".*",
"build.js",
"index.html",
"component.json",
"bower.json",
"benchmark",
"page",
"test",
"vendor"
]
}
}

5
package-lock.json generated
View File

@ -13,6 +13,11 @@
"version": "0.35.5",
"resolved": "https://registry.npmjs.org/es6-shim/-/es6-shim-0.35.5.tgz",
"integrity": "sha512-E9kK/bjtCQRpN1K28Xh4BlmP8egvZBGJJ+9GtnzOwt7mdqtrjHFuVGr7QJfdjBIKqrlU5duPf3pCBoDrkjVYFg=="
},
"json3": {
"version": "3.3.3",
"resolved": "https://registry.npmjs.org/json3/-/json3-3.3.3.tgz",
"integrity": "sha512-c7/8mbUsKigAbLkD5B010BK4D9LZm7A1pNItkEwiUZRpIN66exu/e7YQWysGun+TRKaJp8MhemM+VkfWv42aCA=="
}
}
}

View File

@ -36,6 +36,7 @@
"homepage": "https://github.com/gnh1201/welsonjs#readme",
"dependencies": {
"es5-shim": "^4.5.14",
"es6-shim": "^0.35.5"
"es6-shim": "^0.35.5",
"json3": "^3.3.3"
}
}