spider-src 0.1.5 → 0.1.6

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/README.md

@@ -0,0 +1,344 @@
+# RSVP.js  [![Build Status](https://secure.travis-ci.org/tildeio/rsvp.js.png?branch=master)](http://travis-ci.org/tildeio/rsvp.js)
+
+RSVP.js provides simple tools for organizing asynchronous code.
+
+Specifically, it is a tiny implementation of Promises/A+.
+
+It works in node and the browser.
+
+## downloads
+
+- [rsvp-latest](http://rsvpjs-builds.s3.amazonaws.com/rsvp-latest.js)
+- [rsvp-latest (minified)](http://rsvpjs-builds.s3.amazonaws.com/rsvp-latest.min.js)
+
+## Promises
+
+
+Although RSVP is es6 compliant, it does bring along some extra toys. If you would prefer a strict es6 subset, I would suggest checking out our sibling project https://github.com/jakearchibald/es6-promise, It is RSVP but stripped down to the es6 spec features.
+
+## Bower
+
+`bower install -S rsvp`
+
+## NPM
+
+`npm install --save rsvp`
+
+`RSVP.Promise` is an implementation of
+[Promises/A+](http://promises-aplus.github.com/promises-spec/) that passes the
+[test suite](https://github.com/promises-aplus/promises-tests).
+
+It delivers all promises asynchronously, even if the value is already
+available, to help you write consistent code that doesn't change if the
+underlying data provider changes from synchronous to asynchronous.
+
+It is compatible with [TaskJS](http://taskjs.org/), a library by Dave
+Herman of Mozilla that uses ES6 generators to allow you to write
+synchronous code with promises. It currently works in Firefox, and will
+work in any browser that adds support for ES6 generators. See the
+section below on TaskJS for more information.
+
+### Basic Usage
+
+```javascript
+var RSVP = require('rsvp');
+
+var promise = new RSVP.Promise(function(resolve, reject) {
+  // succeed
+  resolve(value);
+  // or reject
+  reject(error);
+});
+
+promise.then(function(value) {
+  // success
+}, function(value) {
+  // failure
+});
+```
+
+Once a promise has been resolved or rejected, it cannot be resolved or
+rejected again.
+
+Here is an example of a simple XHR2 wrapper written using RSVP.js:
+
+```javascript
+var getJSON = function(url) {
+  var promise = new RSVP.Promise(function(resolve, reject){
+    var client = new XMLHttpRequest();
+    client.open("GET", url);
+    client.onreadystatechange = handler;
+    client.responseType = "json";
+    client.setRequestHeader("Accept", "application/json");
+    client.send();
+
+    function handler() {
+      if (this.readyState === this.DONE) {
+        if (this.status === 200) { resolve(this.response); }
+        else { reject(this); }
+      }
+    };
+  });
+
+  return promise;
+};
+
+getJSON("/posts.json").then(function(json) {
+  // continue
+}, function(error) {
+  // handle errors
+});
+```
+
+### Chaining
+
+One of the really awesome features of Promises/A+ promises are that they
+can be chained together. In other words, the return value of the first
+resolve handler will be passed to the second resolve handler.
+
+If you return a regular value, it will be passed, as is, to the next
+handler.
+
+```javascript
+getJSON("/posts.json").then(function(json) {
+  return json.post;
+}).then(function(post) {
+  // proceed
+});
+```
+
+The really awesome part comes when you return a promise from the first
+handler:
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  // save off post
+  return getJSON(post.commentURL);
+}).then(function(comments) {
+  // proceed with access to posts and comments
+});
+```
+
+This allows you to flatten out nested callbacks, and is the main feature
+of promises that prevents "rightward drift" in programs with a lot of
+asynchronous code.
+
+Errors also propagate:
+
+```javascript
+getJSON("/posts.json").then(function(posts) {
+
+}).catch(function(error) {
+  // since no rejection handler was passed to the
+  // first `.then`, the error propagates.
+});
+```
+
+You can use this to emulate `try/catch` logic in synchronous code.
+Simply chain as many resolve callbacks as a you want, and add a failure
+handler at the end to catch errors.
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  return getJSON(post.commentURL);
+}).then(function(comments) {
+  // proceed with access to posts and comments
+}).catch(function(error) {
+  // handle errors in either of the two requests
+});
+```
+
+You can also use `catch` for error handling, which is a shortcut for
+`then(null, rejection)`, like so:
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  return getJSON(post.commentURL);
+}).catch(function(error) {
+  // handle errors
+});
+```
+
+## Error Handling
+
+There are times when dealing with promises that it seems like any errors
+are being 'swallowed', and not properly raised. This makes is extremely
+difficult to track down where a given issue is coming from. Thankfully,
+`RSVP` has a solution for this problem built in.
+
+You can register functions to be called when an uncaught error occurs
+within your promises. These callback functions can be anything, but a common
+practice is to call `console.assert` to dump the error to the console.
+
+```javascript
+RSVP.on('error', function(reason) {
+  console.assert(false, reason);
+});
+```
+
+**NOTE:** promises do allow for errors to be handled asynchronously, so
+this callback may result in false positives.
+
+**NOTE:** Usage of `RSVP.configure('onerror', yourCustomFunction);` is
+deprecated in favor of using `RSVP.on`.
+
+## Arrays of promises
+
+Sometimes you might want to work with many promises at once. If you
+pass an array of promises to the `all()` method it will return a new
+promise that will be fulfilled when all of the promises in the array
+have been fulfilled; or rejected immediately if any promise in the array
+is rejected.
+
+```javascript
+var promises = [2, 3, 5, 7, 11, 13].map(function(id){
+  return getJSON("/post/" + id + ".json");
+});
+
+RSVP.all(promises).then(function(posts) {
+  // posts contains an array of results for the given promises
+}).catch(function(reason){
+  // if any of the promises fails.
+});
+```
+
+## Hash of promises
+
+If you need to reference many promises at once (like `all()`), but would like
+to avoid encoding the actual promise order you can use `hash()`. If you pass
+an object literal (where the values are promises) to the `hash()` method it will
+return a new promise that will be fulfilled when all of the promises have been
+fulfilled; or rejected immediately if any promise is rejected.
+
+The key difference to the `all()` function is that both the fulfillment value
+and the argument to the `hash()` function are object literals. This allows
+you to simply reference the results directly off the returned object without
+having to remember the initial order like you would with `all()`.
+
+```javascript
+var promises = {
+  posts: getJSON("/posts.json"),
+  users: getJSON("/users.json")
+};
+
+RSVP.hash(promises).then(function(results) {
+  console.log(results.users) // print the users.json results
+  console.log(results.posts) // print the posts.json results
+});
+```
+
+## All settled and hash settled
+
+Sometimes you want to work with several promises at once, but instead of
+rejecting immediately if any promise is rejected, as with `all()` or `hash()`,
+you want to be able to inspect the results of all your promises, whether
+they fulfill or reject. For this purpose, you can use `allSettled()` and
+`hashSettled()`. These work exactly like `all()` and `hash()`, except that
+they fulfill with an array or hash (respectively) of the constituent promises'
+result states. Each state object will either indicate fulfillment or
+rejection, and provide the corresponding value or reason. The states will take
+one of the following formats:
+
+```javascript
+{ state: 'fulfilled', value: value }
+  or
+{ state: 'rejected', reason: reason }
+```
+
+## Deferred
+
+> The `RSVP.Promise` constructor is generally a better, less error-prone choice
+> than `RSVP.defer()`. Promises are recommended unless the specific 
+> properties of deferred are needed.
+
+Sometimes one need to create a deferred object, without immediately specifying
+how it will be resolved. These deferred objects are essentially a wrapper around
+a promise, whilst providing late access to the `resolve()` and `reject()` methods.
+
+A deferred object has this form: `{ promise, resolve(x), reject(r) }`.
+
+```javascript
+var deferred = RSVP.defer();
+// ...
+deferred.promise // access the promise
+// ...
+deferred.resolve();
+
+```
+
+## TaskJS
+
+The [TaskJS](http://taskjs.org/) library makes it possible to take
+promises-oriented code and make it synchronous using ES6 generators.
+
+Let's review an earlier example:
+
+```javascript
+getJSON("/post/1.json").then(function(post) {
+  return getJSON(post.commentURL);
+}).then(function(comments) {
+  // proceed with access to posts and comments
+}).catch(function(reason) {
+  // handle errors in either of the two requests
+});
+```
+
+Without any changes to the implementation of `getJSON`, you could write
+the following code with TaskJS:
+
+```javascript
+spawn(function *() {
+  try {
+    var post = yield getJSON("/post/1.json");
+    var comments = yield getJSON(post.commentURL);
+  } catch(error) {
+    // handle errors
+  }
+});
+```
+
+In the above example, `function *` is new syntax in ES6 for
+[generators](http://wiki.ecmascript.org/doku.php?id=harmony:generators).
+Inside a generator, `yield` pauses the generator, returning control to
+the function that invoked the generator. In this case, the invoker is a
+special function that understands the semantics of Promises/A, and will
+automatically resume the generator as soon as the promise is resolved.
+
+The cool thing here is the same promises that work with current
+JavaScript using `.then` will work seamlessly with TaskJS once a browser
+has implemented it!
+
+## Instrumentation
+
+```js
+function listener (event) {
+  event.guid      // guid of promise. Must be globally unique, not just within the implementation
+  event.childGuid // child of child promise (for chained via `then`)
+  event.eventName // one of ['created', 'chained', 'fulfilled', 'rejected']
+  event.detail    // fulfillment value or rejection reason, if applicable
+  event.label     // label passed to promise's constructor
+  event.timeStamp // milliseconds elapsed since 1 January 1970 00:00:00 UTC up until now
+}
+
+RSVP.configure('instrument', true | false);
+RSVP.on('created', listener);
+RSVP.on('chained', listener);
+RSVP.on('fulfilled', listener);
+RSVP.on('rejected', listener);
+```
+
+Events are only triggered when `RSVP.configure('instrument')` is true, although
+listeners can be registered at any time.
+
+## Building & Testing
+
+Custom tasks:
+
+* `ember build` - Build distribution
+* `testem ci` - Run tests.
+* `testem` - Run test server.
+
+## Releasing
+
+Check what release-it will do by running `npm run-script dry-run-release`.
+To actually release, run `node_modules/.bin/release-it`.

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/bin/publish_to_s3.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+// To invoke this from the commandline you need the following to env vars to exist:
+//
+// S3_BUCKET_NAME
+// TRAVIS_BRANCH
+// TRAVIS_TAG
+// TRAVIS_COMMIT
+// S3_SECRET_ACCESS_KEY
+// S3_ACCESS_KEY_ID
+//
+// Once you have those you execute with the following:
+//
+// ```sh
+// ./bin/publish_to_s3.js
+// ```
+var S3Publisher = require('ember-publisher');
+var configPath = require('path').join(__dirname, '../config/s3ProjectConfig.js');
+publisher = new S3Publisher({ projectConfigPath: configPath });
+
+// Always use wildcard section of project config.
+// This is useful when the including library does not
+// require channels (like in ember.js / ember-data).
+publisher.currentBranch = function() {
+  return (process.env.TRAVIS_BRANCH === 'master') ? 'wildcard' : 'no-op';
+};
+publisher.publish();
+

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/bower.json

@@ -0,0 +1,26 @@
+{
+  "name": "rsvp.js",
+  "version": "3.0.14",
+  "homepage": "https://github.com/tildeio/rsvp.js",
+  "authors": [
+    "Stefan Penner <stefan.penner@gmail.com>"
+  ],
+  "description": "A lightweight library that provides tools for organizing asynchronous code",
+  "main": "dist/rsvp.js",
+  "keywords": [
+    "promise"
+  ],
+  "license": "MIT",
+  "ignore": [
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests",
+    "vendor",
+    "tasks"
+  ],
+  "devDependencies": {
+    "mocha": "~1.21.4",
+    "json3": "~3.3.2"
+  }
+}

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/bower_components/json3/.bower.json

@@ -0,0 +1,47 @@
+{
+  "name": "json3",
+  "version": "3.3.2",
+  "main": "lib/json3.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/bestiejs/json3.git"
+  },
+  "ignore": [
+    ".*",
+    "**/.*",
+    "build.js",
+    "index.html",
+    "index.js",
+    "component.json",
+    "package.json",
+    "benchmark",
+    "page",
+    "test",
+    "vendor",
+    "tests"
+  ],
+  "homepage": "https://github.com/bestiejs/json3",
+  "description": "A modern JSON implementation compatible with nearly all JavaScript platforms",
+  "keywords": [
+    "json",
+    "spec",
+    "ecma",
+    "es5",
+    "lexer",
+    "parser",
+    "stringify"
+  ],
+  "authors": [
+    "Kit Cambridge <github@kitcambridge.be>"
+  ],
+  "license": "MIT",
+  "_release": "3.3.2",
+  "_resolution": {
+    "type": "version",
+    "tag": "v3.3.2",
+    "commit": "dec5c2a5dc723ff867caa32a81ed93ab814f7426"
+  },
+  "_source": "git://github.com/bestiejs/json3.git",
+  "_target": "~3.3.2",
+  "_originalSource": "json3"
+}

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/bower_components/json3/CHANGELOG.md

@@ -0,0 +1,44 @@
+# JSON3 Changelog
+
+## 3.1.0
+
+ * 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
+
+ * 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
+
+ * Avoided relying on native functions `Math.abs`, and `isFinite`, and native constructors `String`, `Number`, `Object`, and `Array`
+ * Fixed AMD export logic
+
+## 0.8.0
+
+ * 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
+
+ * Fixed `Prim.stringify`'s handling of the `width` argument
+ * Added Microsoft's ES5 Conformance Tests to the test suite
+
+## 0.2.0
+
+ * 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
+
+ * Initial release of Prim

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/bower_components/json3/CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Contributing to JSON3
+
+If you'd like to contribute to JSON3, please review our [contributing guidelines](http://bestiejs.github.io/json3/#section_5). Thanks!

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/bower_components/json3/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012-2014 Kit Cambridge.
+http://kitcambridge.be/
+
+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.

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/rsvp/bower_components/json3/README.md

@@ -0,0 +1,152 @@
+# JSON 3 #
+
+![JSON 3 Logo](http://bestiejs.github.io/json3/page/logo.png)
+
+[![Build Status](https://secure.travis-ci.org/bestiejs/json3.png?branch=gh-pages)](http://travis-ci.org/bestiejs/json3)
+
+**JSON 3** is a modern JSON implementation compatible with a variety of JavaScript platforms, including Internet Explorer 6, Opera 7, Safari 2, and Netscape 6. The current version is **3.3.2**.
+
+- [Development Version](http://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.js) *(43 KB; uncompressed with comments)*
+- [Production Version](http://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js) *(3.5 KB; compressed and `gzip`-ped)*
+
+Special thanks to [cdnjs](http://cdnjs.com/libraries/json3/) and [jsDelivr](http://www.jsdelivr.com/#!json3) for hosting CDN copies of JSON 3.
+
+[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.com/) 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. It is a **drop-in replacement** for [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 JSON 3 parser does **not** use `eval` or regular expressions. This provides security and performance benefits in obsolete and mobile environments, where the margin is particularly significant. The complete [benchmark suite](http://jsperf.com/json3) is available on [jsPerf](http://jsperf.com/).
+
+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.
+
+# Changes from JSON 2 #
+
+JSON 3...
+
+* Correctly serializes primitive wrapper objects.
+* Throws a `TypeError` when serializing cyclic structures (JSON 2 recurses until the call stack overflows).
+* Utilizes **feature tests** to detect broken or incomplete *native* JSON implementations (JSON 2 only checks for the presence of the native functions). The tests are only executed once at runtime, so there is no additional performance cost when parsing or serializing values.
+
+**As of v3.2.3**, JSON 3 is compatible with [Prototype](http://prototypejs.org) 1.6.1 and older.
+
+In contrast to JSON 2, JSON 3 **does not**...
+
+* Add `toJSON()` methods to the `Boolean`, `Number`, and `String` prototypes. These are not part of any standard, and are made redundant by the design of the `stringify()` implementation.
+* Add `toJSON()` or `toISOString()` methods to `Date.prototype`. See the note about date serialization below.
+
+## 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**. For instance, all versions of Safari 4, as well as JSON 2, fail to serialize extended years correctly. Furthermore, JSON 2 and older implementations omit the milliseconds from the date-time string (optional in ES 5, but required in 5.1). Finally, in all versions of Safari 4 and 5, serializing an invalid date will produce the string `"Invalid Date"`, rather than `null`. Because these environments exhibit other serialization bugs, however, JSON 3 will override the native `stringify()` implementation.
+
+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.
+
+## 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://www.microsoft.com/windows/internet-explorer), version 6.0 and higher
+- Mozilla [Firefox](http://www.mozilla.com/firefox), version 1.0 and higher
+- Apple [Safari](http://www.apple.com/safari), version 2.0 and higher
+- [Opera](http://www.opera.com) 7.02 and higher
+- [Mozilla](http://sillydog.org/narchive/gecko.php) 1.0, [Netscape](http://sillydog.org/narchive/) 6.2.3, and [SeaMonkey](http://www.seamonkey-project.org/) 1.0 and higher
+
+## CommonJS Environments
+
+- [Node](http://nodejs.org/) 0.2.6 and higher
+- [RingoJS](http://ringojs.org/) 0.4 and higher
+- [Narwhal](http://narwhaljs.org/) 0.3.2 and higher
+
+## JavaScript Engines
+
+- Mozilla [Rhino](http://www.mozilla.org/rhino) 1.5R5 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`
+- `Function#call`
+- `Math.floor`
+- `Number#toString`
+- `Date#valueOf`
+- `String.prototype`: `indexOf`, `charCodeAt`, `charAt`, `slice`.
+- `Array.prototype`: `push`, `pop`, `join`.
+
+# Contribute #
+
+Check out a working copy of the JSON 3 source code with [Git](http://git-scm.com/):
+
+    $ git clone git://github.com/bestiejs/json3.git
+    $ cd json3
+
+If you'd like to contribute a feature or bug fix, you can [fork](http://help.github.com/fork-a-repo/) JSON 3, commit your changes, and [send a pull request](http://help.github.com/send-pull-requests/). Please make sure to update the unit tests in the `test` directory as well.
+
+Alternatively, you can use the [GitHub issue tracker](https://github.com/bestiejs/json3/issues) to submit bug reports, feature requests, and questions, or send tweets to [@kitcambridge](http://twitter.com/kitcambridge).
+
+JSON 3 is released under the [MIT License](http://kit.mit-license.org/).