pleeease 0.0.2

data/node_modules/pleeease/node_modules/postcss/node_modules/base64-js/package.json

@@ -0,0 +1,47 @@
+{
+  "author": {
+    "name": "T. Jameson Little",
+    "email": "t.jameson.little@gmail.com"
+  },
+  "name": "base64-js",
+  "description": "Base64 encoding/decoding in pure JS",
+  "version": "0.0.7",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/beatgammit/base64-js.git"
+  },
+  "main": "lib/b64.js",
+  "scripts": {
+    "test": "tape test/*.js"
+  },
+  "testling": {
+    "files": "test/*.js",
+    "browsers": [
+      "ie/6..latest",
+      "chrome/4..latest",
+      "firefox/3..latest",
+      "safari/5.1..latest",
+      "opera/11.0..latest",
+      "iphone/6",
+      "ipad/6"
+    ]
+  },
+  "engines": {
+    "node": ">= 0.4"
+  },
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "tape": "~2.3.2"
+  },
+  "readme": "base64-js\n=========\n\n`base64-js` does basic base64 encoding/decoding in pure JS.\n\n[![build status](https://secure.travis-ci.org/beatgammit/base64-js.png)](http://travis-ci.org/beatgammit/base64-js)\n\n[![testling badge](https://ci.testling.com/beatgammit/base64-js.png)](https://ci.testling.com/beatgammit/base64-js)\n\nMany browsers already have base64 encoding/decoding functionality, but it is for text data, not all-purpose binary data.\n\nSometimes encoding/decoding binary data in the browser is useful, and that is what this module does.\n\n## install\n\nWith [npm](https://npmjs.org) do:\n\n`npm install base64-js`\n\n## methods\n\n`var base64 = require('base64-js')`\n\n`base64` has two exposed functions, `toByteArray` and `fromByteArray`, which both take a single argument.\n\n* `toByteArray` - Takes a base64 string and returns a byte array\n* `fromByteArray` - Takes a byte array and returns a base64 string\n\n## license\n\nMIT",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/beatgammit/base64-js/issues"
+  },
+  "homepage": "https://github.com/beatgammit/base64-js",
+  "_id": "base64-js@0.0.7",
+  "_shasum": "54400dc91d696cec32a8a47902f971522fee8f48",
+  "_from": "base64-js@~0.0.6",
+  "_resolved": "https://registry.npmjs.org/base64-js/-/base64-js-0.0.7.tgz"
+}

data/node_modules/pleeease/node_modules/postcss/node_modules/base64-js/test/convert.js

@@ -0,0 +1,51 @@
+var test = require('tape'),
+  b64 = require('../lib/b64'),
+	checks = [
+		'a',
+		'aa',
+		'aaa',
+		'hi',
+		'hi!',
+		'hi!!',
+		'sup',
+		'sup?',
+		'sup?!'
+	];
+
+test('convert to base64 and back', function (t) {
+  t.plan(checks.length);
+
+  for (var i = 0; i < checks.length; i++) {
+    var check = checks[i],
+      b64Str,
+      arr,
+      str;
+
+    b64Str = b64.fromByteArray(map(check, function (char) { return char.charCodeAt(0); }));
+
+    arr = b64.toByteArray(b64Str);
+    str = map(arr, function (byte) { return String.fromCharCode(byte); }).join('');
+
+    t.equal(check, str, 'Checked ' + check);
+  }
+
+});
+
+function map (arr, callback) {
+	var res = [],
+    kValue,
+    mappedValue;
+
+	for (var k = 0, len = arr.length; k < len; k++) {
+		if ((typeof arr === 'string' && !!arr.charAt(k))) {
+			kValue = arr.charAt(k);
+			mappedValue = callback(kValue, k, arr);
+			res[k] = mappedValue;
+		} else if (typeof arr !== 'string' && k in arr) {
+			kValue = arr[k];
+			mappedValue = callback(kValue, k, arr);
+			res[k] = mappedValue;
+		}
+	}
+	return res;
+}

data/node_modules/pleeease/node_modules/postcss/node_modules/source-map/.npmignore

@@ -0,0 +1,2 @@
+dist/*
+node_modules/*

data/node_modules/pleeease/node_modules/postcss/node_modules/source-map/.tern-port

@@ -0,0 +1 @@
+55494

data/node_modules/pleeease/node_modules/postcss/node_modules/source-map/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.8
+  - "0.10"

data/node_modules/pleeease/node_modules/postcss/node_modules/source-map/CHANGELOG.md

@@ -0,0 +1,137 @@
+# Change Log
+
+## 0.1.34
+
+* Make `SourceNode` work with windows style ("\r\n") newlines. Issue #103.
+
+* Fix bug involving source contents and the
+  `SourceMapGenerator.prototype.applySourceMap`. Issue #100.
+
+## 0.1.33
+
+* Fix some edge cases surrounding path joining and URL resolution.
+
+* Add a third parameter for relative path to
+  `SourceMapGenerator.prototype.applySourceMap`.
+
+* Fix issues with mappings and EOLs.
+
+## 0.1.32
+
+* Fixed a bug where SourceMapConsumer couldn't handle negative relative columns
+  (issue 92).
+
+* Fixed test runner to actually report number of failed tests as its process
+  exit code.
+
+* Fixed a typo when reporting bad mappings (issue 87).
+
+## 0.1.31
+
+* Delay parsing the mappings in SourceMapConsumer until queried for a source
+  location.
+
+* Support Sass source maps (which at the time of writing deviate from the spec
+  in small ways) in SourceMapConsumer.
+
+## 0.1.30
+
+* Do not join source root with a source, when the source is a data URI.
+
+* Extend the test runner to allow running single specific test files at a time.
+
+* Performance improvements in `SourceNode.prototype.walk` and
+  `SourceMapConsumer.prototype.eachMapping`.
+
+* Source map browser builds will now work inside Workers.
+
+* Better error messages when attempting to add an invalid mapping to a
+  `SourceMapGenerator`.
+
+## 0.1.29
+
+* Allow duplicate entries in the `names` and `sources` arrays of source maps
+  (usually from TypeScript) we are parsing. Fixes github issue 72.
+
+## 0.1.28
+
+* Skip duplicate mappings when creating source maps from SourceNode; github
+  issue 75.
+
+## 0.1.27
+
+* Don't throw an error when the `file` property is missing in SourceMapConsumer,
+  we don't use it anyway.
+
+## 0.1.26
+
+* Fix SourceNode.fromStringWithSourceMap for empty maps. Fixes github issue 70.
+
+## 0.1.25
+
+* Make compatible with browserify
+
+## 0.1.24
+
+* Fix issue with absolute paths and `file://` URIs. See
+  https://bugzilla.mozilla.org/show_bug.cgi?id=885597
+
+## 0.1.23
+
+* Fix issue with absolute paths and sourcesContent, github issue 64.
+
+## 0.1.22
+
+* Ignore duplicate mappings in SourceMapGenerator. Fixes github issue 21.
+
+## 0.1.21
+
+* Fixed handling of sources that start with a slash so that they are relative to
+  the source root's host.
+
+## 0.1.20
+
+* Fixed github issue #43: absolute URLs aren't joined with the source root
+  anymore.
+
+## 0.1.19
+
+* Using Travis CI to run tests.
+
+## 0.1.18
+
+* Fixed a bug in the handling of sourceRoot.
+
+## 0.1.17
+
+* Added SourceNode.fromStringWithSourceMap.
+
+## 0.1.16
+
+* Added missing documentation.
+
+* Fixed the generating of empty mappings in SourceNode.
+
+## 0.1.15
+
+* Added SourceMapGenerator.applySourceMap.
+
+## 0.1.14
+
+* The sourceRoot is now handled consistently.
+
+## 0.1.13
+
+* Added SourceMapGenerator.fromSourceMap.
+
+## 0.1.12
+
+* SourceNode now generates empty mappings too.
+
+## 0.1.11
+
+* Added name support to SourceNode.
+
+## 0.1.10
+
+* Added sourcesContent support to the customer and generator.

data/node_modules/pleeease/node_modules/postcss/node_modules/source-map/LICENSE

@@ -0,0 +1,28 @@
+
+Copyright (c) 2009-2011, Mozilla Foundation and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the names of the Mozilla Foundation nor the names of project
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/node_modules/pleeease/node_modules/postcss/node_modules/source-map/Makefile.dryice.js

@@ -0,0 +1,166 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+var path = require('path');
+var fs = require('fs');
+var copy = require('dryice').copy;
+
+function removeAmdefine(src) {
+  src = String(src).replace(
+    /if\s*\(typeof\s*define\s*!==\s*'function'\)\s*{\s*var\s*define\s*=\s*require\('amdefine'\)\(module,\s*require\);\s*}\s*/g,
+    '');
+  src = src.replace(
+    /\b(define\(.*)('amdefine',?)/gm,
+    '$1');
+  return src;
+}
+removeAmdefine.onRead = true;
+
+function makeNonRelative(src) {
+  return src
+    .replace(/require\('.\//g, 'require(\'source-map/')
+    .replace(/\.\.\/\.\.\/lib\//g, '');
+}
+makeNonRelative.onRead = true;
+
+function buildBrowser() {
+  console.log('\nCreating dist/source-map.js');
+
+  var project = copy.createCommonJsProject({
+    roots: [ path.join(__dirname, 'lib') ]
+  });
+
+  copy({
+    source: [
+      'build/mini-require.js',
+      {
+        project: project,
+        require: [ 'source-map/source-map-generator',
+                   'source-map/source-map-consumer',
+                   'source-map/source-node']
+      },
+      'build/suffix-browser.js'
+    ],
+    filter: [
+      copy.filter.moduleDefines,
+      removeAmdefine
+    ],
+    dest: 'dist/source-map.js'
+  });
+}
+
+function buildBrowserMin() {
+  console.log('\nCreating dist/source-map.min.js');
+
+  copy({
+    source: 'dist/source-map.js',
+    filter: copy.filter.uglifyjs,
+    dest: 'dist/source-map.min.js'
+  });
+}
+
+function buildFirefox() {
+  console.log('\nCreating dist/SourceMap.jsm');
+
+  var project = copy.createCommonJsProject({
+    roots: [ path.join(__dirname, 'lib') ]
+  });
+
+  copy({
+    source: [
+      'build/prefix-source-map.jsm',
+      {
+        project: project,
+        require: [ 'source-map/source-map-consumer',
+                   'source-map/source-map-generator',
+                   'source-map/source-node' ]
+      },
+      'build/suffix-source-map.jsm'
+    ],
+    filter: [
+      copy.filter.moduleDefines,
+      removeAmdefine,
+      makeNonRelative
+    ],
+    dest: 'dist/SourceMap.jsm'
+  });
+
+  // Create dist/test/Utils.jsm
+  console.log('\nCreating dist/test/Utils.jsm');
+
+  project = copy.createCommonJsProject({
+    roots: [ __dirname, path.join(__dirname, 'lib') ]
+  });
+
+  copy({
+    source: [
+      'build/prefix-utils.jsm',
+      'build/assert-shim.js',
+      {
+        project: project,
+        require: [ 'test/source-map/util' ]
+      },
+      'build/suffix-utils.jsm'
+    ],
+    filter: [
+      copy.filter.moduleDefines,
+      removeAmdefine,
+      makeNonRelative
+    ],
+    dest: 'dist/test/Utils.jsm'
+  });
+
+  function isTestFile(f) {
+    return /^test\-.*?\.js/.test(f);
+  }
+
+  var testFiles = fs.readdirSync(path.join(__dirname, 'test', 'source-map')).filter(isTestFile);
+
+  testFiles.forEach(function (testFile) {
+    console.log('\nCreating', path.join('dist', 'test', testFile.replace(/\-/g, '_')));
+
+    copy({
+      source: [
+        'build/test-prefix.js',
+        path.join('test', 'source-map', testFile),
+        'build/test-suffix.js'
+      ],
+      filter: [
+        removeAmdefine,
+        makeNonRelative,
+        function (input, source) {
+          return input.replace('define(',
+                               'define("'
+                               + path.join('test', 'source-map', testFile.replace(/\.js$/, ''))
+                               + '", ["require", "exports", "module"], ');
+        },
+        function (input, source) {
+          return input.replace('{THIS_MODULE}', function () {
+            return "test/source-map/" + testFile.replace(/\.js$/, '');
+          });
+        }
+      ],
+      dest: path.join('dist', 'test', testFile.replace(/\-/g, '_'))
+    });
+  });
+}
+
+function ensureDir(name) {
+  var dirExists = false;
+  try {
+    dirExists = fs.statSync(name).isDirectory();
+  } catch (err) {}
+
+  if (!dirExists) {
+    fs.mkdirSync(name, 0777);
+  }
+}
+
+ensureDir("dist");
+ensureDir("dist/test");
+buildFirefox();
+buildBrowser();
+buildBrowserMin();

data/node_modules/pleeease/node_modules/postcss/node_modules/source-map/README.md

@@ -0,0 +1,446 @@
+# Source Map
+
+This is a library to generate and consume the source map format
+[described here][format].
+
+This library is written in the Asynchronous Module Definition format, and works
+in the following environments:
+
+* Modern Browsers supporting ECMAScript 5 (either after the build, or with an
+  AMD loader such as RequireJS)
+
+* Inside Firefox (as a JSM file, after the build)
+
+* With NodeJS versions 0.8.X and higher
+
+## Node
+
+    $ npm install source-map
+
+## Building from Source (for everywhere else)
+
+Install Node and then run
+
+    $ git clone https://fitzgen@github.com/mozilla/source-map.git
+    $ cd source-map
+    $ npm link .
+
+Next, run
+
+    $ node Makefile.dryice.js
+
+This should spew a bunch of stuff to stdout, and create the following files:
+
+* `dist/source-map.js` - The unminified browser version.
+
+* `dist/source-map.min.js` - The minified browser version.
+
+* `dist/SourceMap.jsm` - The JavaScript Module for inclusion in Firefox source.
+
+## Examples
+
+### Consuming a source map
+
+    var rawSourceMap = {
+      version: 3,
+      file: 'min.js',
+      names: ['bar', 'baz', 'n'],
+      sources: ['one.js', 'two.js'],
+      sourceRoot: 'http://example.com/www/js/',
+      mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+    };
+
+    var smc = new SourceMapConsumer(rawSourceMap);
+
+    console.log(smc.sources);
+    // [ 'http://example.com/www/js/one.js',
+    //   'http://example.com/www/js/two.js' ]
+
+    console.log(smc.originalPositionFor({
+      line: 2,
+      column: 28
+    }));
+    // { source: 'http://example.com/www/js/two.js',
+    //   line: 2,
+    //   column: 10,
+    //   name: 'n' }
+
+    console.log(smc.generatedPositionFor({
+      source: 'http://example.com/www/js/two.js',
+      line: 2,
+      column: 10
+    }));
+    // { line: 2, column: 28 }
+
+    smc.eachMapping(function (m) {
+      // ...
+    });
+
+### Generating a source map
+
+In depth guide:
+[**Compiling to JavaScript, and Debugging with Source Maps**](https://hacks.mozilla.org/2013/05/compiling-to-javascript-and-debugging-with-source-maps/)
+
+#### With SourceNode (high level API)
+
+    function compile(ast) {
+      switch (ast.type) {
+      case 'BinaryExpression':
+        return new SourceNode(
+          ast.location.line,
+          ast.location.column,
+          ast.location.source,
+          [compile(ast.left), " + ", compile(ast.right)]
+        );
+      case 'Literal':
+        return new SourceNode(
+          ast.location.line,
+          ast.location.column,
+          ast.location.source,
+          String(ast.value)
+        );
+      // ...
+      default:
+        throw new Error("Bad AST");
+      }
+    }
+
+    var ast = parse("40 + 2", "add.js");
+    console.log(compile(ast).toStringWithSourceMap({
+      file: 'add.js'
+    }));
+    // { code: '40 + 2',
+    //   map: [object SourceMapGenerator] }
+
+#### With SourceMapGenerator (low level API)
+
+    var map = new SourceMapGenerator({
+      file: "source-mapped.js"
+    });
+
+    map.addMapping({
+      generated: {
+        line: 10,
+        column: 35
+      },
+      source: "foo.js",
+      original: {
+        line: 33,
+        column: 2
+      },
+      name: "christopher"
+    });
+
+    console.log(map.toString());
+    // '{"version":3,"file":"source-mapped.js","sources":["foo.js"],"names":["christopher"],"mappings":";;;;;;;;;mCAgCEA"}'
+
+## API
+
+Get a reference to the module:
+
+    // NodeJS
+    var sourceMap = require('source-map');
+
+    // Browser builds
+    var sourceMap = window.sourceMap;
+
+    // Inside Firefox
+    let sourceMap = {};
+    Components.utils.import('resource:///modules/devtools/SourceMap.jsm', sourceMap);
+
+### SourceMapConsumer
+
+A SourceMapConsumer instance represents a parsed source map which we can query
+for information about the original file positions by giving it a file position
+in the generated source.
+
+#### new SourceMapConsumer(rawSourceMap)
+
+The only parameter is the raw source map (either as a string which can be
+`JSON.parse`'d, or an object). According to the spec, source maps have the
+following attributes:
+
+* `version`: Which version of the source map spec this map is following.
+
+* `sources`: An array of URLs to the original source files.
+
+* `names`: An array of identifiers which can be referrenced by individual
+  mappings.
+
+* `sourceRoot`: Optional. The URL root from which all sources are relative.
+
+* `sourcesContent`: Optional. An array of contents of the original source files.
+
+* `mappings`: A string of base64 VLQs which contain the actual mappings.
+
+* `file`: Optional. The generated filename this source map is associated with.
+
+#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)
+
+Returns the original source, line, and column information for the generated
+source's line and column positions provided. The only argument is an object with
+the following properties:
+
+* `line`: The line number in the generated source.
+
+* `column`: The column number in the generated source.
+
+and an object is returned with the following properties:
+
+* `source`: The original source file, or null if this information is not
+  available.
+
+* `line`: The line number in the original source, or null if this information is
+  not available.
+
+* `column`: The column number in the original source, or null or null if this
+  information is not available.
+
+* `name`: The original identifier, or null if this information is not available.
+
+#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)
+
+Returns the generated line and column information for the original source,
+line, and column positions provided. The only argument is an object with
+the following properties:
+
+* `source`: The filename of the original source.
+
+* `line`: The line number in the original source.
+
+* `column`: The column number in the original source.
+
+and an object is returned with the following properties:
+
+* `line`: The line number in the generated source, or null.
+
+* `column`: The column number in the generated source, or null.
+
+#### SourceMapConsumer.prototype.sourceContentFor(source)
+
+Returns the original source content for the source provided. The only
+argument is the URL of the original source file.
+
+#### SourceMapConsumer.prototype.eachMapping(callback, context, order)
+
+Iterate over each mapping between an original source/line/column and a
+generated line/column in this source map.
+
+* `callback`: The function that is called with each mapping. Mappings have the
+  form `{ source, generatedLine, generatedColumn, originalLine, originalColumn,
+  name }`
+
+* `context`: Optional. If specified, this object will be the value of `this`
+  every time that `callback` is called.
+
+* `order`: Either `SourceMapConsumer.GENERATED_ORDER` or
+  `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to iterate over
+  the mappings sorted by the generated file's line/column order or the
+  original's source/line/column order, respectively. Defaults to
+  `SourceMapConsumer.GENERATED_ORDER`.
+
+### SourceMapGenerator
+
+An instance of the SourceMapGenerator represents a source map which is being
+built incrementally.
+
+#### new SourceMapGenerator([startOfSourceMap])
+
+You may pass an object with the following properties:
+
+* `file`: The filename of the generated source that this source map is
+  associated with.
+
+* `sourceRoot`: A root for all relative URLs in this source map.
+
+#### SourceMapGenerator.fromSourceMap(sourceMapConsumer)
+
+Creates a new SourceMapGenerator based on a SourceMapConsumer
+
+* `sourceMapConsumer` The SourceMap.
+
+#### SourceMapGenerator.prototype.addMapping(mapping)
+
+Add a single mapping from original source line and column to the generated
+source's line and column for this source map being created. The mapping object
+should have the following properties:
+
+* `generated`: An object with the generated line and column positions.
+
+* `original`: An object with the original line and column positions.
+
+* `source`: The original source file (relative to the sourceRoot).
+
+* `name`: An optional original token name for this mapping.
+
+#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for an original source file.
+
+* `sourceFile` the URL of the original source file.
+
+* `sourceContent` the content of the source file.
+
+#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])
+
+Applies a SourceMap for a source file to the SourceMap.
+Each mapping to the supplied source file is rewritten using the
+supplied SourceMap. Note: The resolution for the resulting mappings
+is the minimium of this map and the supplied map.
+
+* `sourceMapConsumer`: The SourceMap to be applied.
+
+* `sourceFile`: Optional. The filename of the source file.
+  If omitted, sourceMapConsumer.file will be used, if it exists.
+  Otherwise an error will be thrown.
+
+* `sourceMapPath`: Optional. The dirname of the path to the SourceMap
+  to be applied. If relative, it is relative to the SourceMap.
+
+  This parameter is needed when the two SourceMaps aren't in the same
+  directory, and the SourceMap to be applied contains relative source
+  paths. If so, those relative source paths need to be rewritten
+  relative to the SourceMap.
+
+  If omitted, it is assumed that both SourceMaps are in the same directory,
+  thus not needing any rewriting. (Supplying `'.'` has the same effect.)
+
+#### SourceMapGenerator.prototype.toString()
+
+Renders the source map being generated to a string.
+
+### SourceNode
+
+SourceNodes provide a way to abstract over interpolating and/or concatenating
+snippets of generated JavaScript source code, while maintaining the line and
+column information associated between those snippets and the original source
+code. This is useful as the final intermediate representation a compiler might
+use before outputting the generated JS and source map.
+
+#### new SourceNode([line, column, source[, chunk[, name]]])
+
+* `line`: The original line number associated with this source node, or null if
+  it isn't associated with an original line.
+
+* `column`: The original column number associated with this source node, or null
+  if it isn't associated with an original column.
+
+* `source`: The original source's filename; null if no filename is provided.
+
+* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see
+  below.
+
+* `name`: Optional. The original identifier.
+
+#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer)
+
+Creates a SourceNode from generated code and a SourceMapConsumer.
+
+* `code`: The generated code
+
+* `sourceMapConsumer` The SourceMap for the generated code
+
+#### SourceNode.prototype.add(chunk)
+
+Add a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+#### SourceNode.prototype.prepend(chunk)
+
+Prepend a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for a source file. This will be added to the
+`SourceMap` in the `sourcesContent` field.
+
+* `sourceFile`: The filename of the source file
+
+* `sourceContent`: The content of the source file
+
+#### SourceNode.prototype.walk(fn)
+
+Walk over the tree of JS snippets in this node and its children. The walking
+function is called once for each snippet of JS and is passed that snippet and
+the its original associated source's line/column location.
+
+* `fn`: The traversal function.
+
+#### SourceNode.prototype.walkSourceContents(fn)
+
+Walk over the tree of SourceNodes. The walking function is called for each
+source file content and is passed the filename and source content.
+
+* `fn`: The traversal function.
+
+#### SourceNode.prototype.join(sep)
+
+Like `Array.prototype.join` except for SourceNodes. Inserts the separator
+between each of this source node's children.
+
+* `sep`: The separator.
+
+#### SourceNode.prototype.replaceRight(pattern, replacement)
+
+Call `String.prototype.replace` on the very right-most source snippet. Useful
+for trimming whitespace from the end of a source node, etc.
+
+* `pattern`: The pattern to replace.
+
+* `replacement`: The thing to replace the pattern with.
+
+#### SourceNode.prototype.toString()
+
+Return the string representation of this source node. Walks over the tree and
+concatenates all the various snippets together to one string.
+
+### SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])
+
+Returns the string representation of this tree of source nodes, plus a
+SourceMapGenerator which contains all the mappings between the generated and
+original sources.
+
+The arguments are the same as those to `new SourceMapGenerator`.
+
+## Tests
+
+[![Build Status](https://travis-ci.org/mozilla/source-map.png?branch=master)](https://travis-ci.org/mozilla/source-map)
+
+Install NodeJS version 0.8.0 or greater, then run `node test/run-tests.js`.
+
+To add new tests, create a new file named `test/test-<your new test name>.js`
+and export your test functions with names that start with "test", for example
+
+    exports["test doing the foo bar"] = function (assert, util) {
+      ...
+    };
+
+The new test will be located automatically when you run the suite.
+
+The `util` argument is the test utility module located at `test/source-map/util`.
+
+The `assert` argument is a cut down version of node's assert module. You have
+access to the following assertion functions:
+
+* `doesNotThrow`
+
+* `equal`
+
+* `ok`
+
+* `strictEqual`
+
+* `throws`
+
+(The reason for the restricted set of test functions is because we need the
+tests to run inside Firefox's test suite as well and so the assert module is
+shimmed in that environment. See `build/assert-shim.js`.)
+
+[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+[feature]: https://wiki.mozilla.org/DevTools/Features/SourceMap
+[Dryice]: https://github.com/mozilla/dryice