sprockets-browserify 0.2.0 → 0.3.0

data/node_modules/browserify/node_modules/url/node_modules/punycode/LICENSE-MIT.txt

@@ -0,0 +1,20 @@
+Copyright Mathias Bynens <http://mathiasbynens.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/node_modules/browserify/node_modules/url/node_modules/punycode/README.md

@@ -0,0 +1,107 @@
+# Punycode.js
+
+A robust Punycode converter that fully complies to [RFC 3492](http://tools.ietf.org/html/rfc3492) and [RFC 5891](http://tools.ietf.org/html/rfc5891), and works on nearly all JavaScript platforms.
+
+This JavaScript library is the result of comparing, optimizing and documenting different open-source implementations of the Punycode algorithm:
+
+* [The C example code from RFC 3492](http://tools.ietf.org/html/rfc3492#appendix-C)
+* [`punycode.c` by _Markus W. Scherer_ (IBM)](http://opensource.apple.com/source/ICU/ICU-400.42/icuSources/common/punycode.c)
+* [`punycode.c` by _Ben Noordhuis_](https://github.com/bnoordhuis/punycode/blob/master/punycode.c)
+* [JavaScript implementation by _some_](http://stackoverflow.com/questions/183485/can-anyone-recommend-a-good-free-javascript-for-punycode-to-unicode-conversion/301287#301287)
+* [`punycode.js` by _Ben Noordhuis_](https://github.com/joyent/node/blob/426298c8c1c0d5b5224ac3658c41e7c2a3fe9377/lib/punycode.js) (note: [not fully compliant](https://github.com/joyent/node/issues/2072))
+
+This project is [bundled](https://github.com/joyent/node/blob/master/lib/punycode.js) with [Node.js v0.6.2+](https://github.com/joyent/node/compare/975f1930b1...61e796decc).
+
+## Installation and usage
+
+In a browser:
+
+~~~html
+<script src="punycode.js"></script>
+~~~
+
+Via [npm](http://npmjs.org/) (only required for Node.js releases older than v0.6.2):
+
+~~~bash
+npm install punycode
+~~~
+
+In [Narwhal](http://narwhaljs.org/), [Node.js](http://nodejs.org/), and [RingoJS](http://ringojs.org/):
+
+~~~js
+var punycode = require('punycode');
+~~~
+
+In [Rhino](http://www.mozilla.org/rhino/):
+
+~~~js
+load('punycode.js');
+~~~
+
+Using an AMD loader like [RequireJS](http://requirejs.org/):
+
+~~~js
+require(
+  {
+    'paths': {
+      'punycode': 'path/to/punycode'
+    }
+  },
+  ['punycode'],
+  function(punycode) {
+    console.log(punycode);
+  }
+);
+~~~
+
+Usage example:
+
+~~~js
+
+// encode/decode domain names
+punycode.toASCII('mañana.com'); // 'xn--maana-pta.com'
+punycode.toUnicode('xn--maana-pta.com'); // 'mañana.com'
+punycode.toASCII('☃-⌘.com'); // 'xn----dqo34k.com'
+punycode.toUnicode('xn----dqo34k.com'); // '☃-⌘.com'
+
+// encode/decode domain name parts
+punycode.encode('mañana'); // 'maana-pta'
+punycode.decode('maana-pta'); // 'mañana'
+punycode.encode('☃-⌘'); // '--dqo34k'
+punycode.decode('--dqo34k'); // '☃-⌘'
+~~~
+
+[Full API documentation is available.](https://github.com/bestiejs/punycode.js/tree/master/docs#readme)
+
+## Cloning this repo
+
+To clone this repository including all submodules, using Git 1.6.5 or later:
+
+~~~ bash
+git clone --recursive https://github.com/bestiejs/punycode.js.git
+cd punycode.js
+~~~
+
+For older Git versions, just use:
+
+~~~ bash
+git clone https://github.com/bestiejs/punycode.js.git
+cd punycode.js
+git submodule update --init
+~~~
+
+Feel free to fork if you see possible improvements!
+
+## Authors
+
+* [Mathias Bynens](http://mathiasbynens.be/)
+  [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](http://twitter.com/mathias "Follow @mathias on Twitter")
+
+## Contributors
+
+* [John-David Dalton](http://allyoucanleet.com/)
+  [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](http://twitter.com/jdalton "Follow @jdalton on Twitter")
+
+## License
+
+Punycode.js is dual licensed under the [MIT](http://mths.be/mit) and [GPL](http://mths.be/gpl) licenses.

data/node_modules/browserify/node_modules/url/node_modules/punycode/docs/README.md

@@ -0,0 +1,169 @@
+# Punycode.js API documentation
+
+<!-- div -->
+
+
+<!-- div -->
+
+## `punycode`
+* [`punycode`](#punycode)
+* [`punycode.version`](#punycode.version)
+* [`punycode.decode`](#punycode.decode)
+* [`punycode.encode`](#punycode.encode)
+* [`punycode.toASCII`](#punycode.toASCII)
+* [`punycode.toUnicode`](#punycode.toUnicode)
+
+<!-- /div -->
+
+
+<!-- div -->
+
+## `punycode.ucs2`
+* [`punycode.ucs2`](#punycode.ucs2)
+* [`punycode.ucs2.decode`](#punycode.ucs2.decode)
+* [`punycode.ucs2.encode`](#punycode.ucs2.encode)
+
+<!-- /div -->
+
+
+<!-- /div -->
+
+
+<!-- div -->
+
+
+<!-- div -->
+
+## `punycode`
+
+<!-- div -->
+
+### <a id="punycode" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L9" title="View in source">`punycode`</a>
+*(Object)*: The `punycode` object.
+[&#9650;][1]
+
+<!-- /div -->
+
+
+<!-- div -->
+
+### <a id="punycode.version" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L475" title="View in source">`punycode.version`</a>
+*(String)*: A string representing the current Punycode.js version number.
+[&#9650;][1]
+
+<!-- /div -->
+
+
+<!-- div -->
+
+### <a id="punycode.decode" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L223" title="View in source">`punycode.decode(input)`</a>
+Converts a Punycode string of ASCII code points to a string of Unicode code points.
+[&#9650;][1]
+
+#### Arguments
+1. `input` *(String)*: The Punycode string of ASCII code points.
+
+#### Returns
+*(String)*: The resulting string of Unicode code points.
+
+<!-- /div -->
+
+
+<!-- div -->
+
+### <a id="punycode.encode" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L325" title="View in source">`punycode.encode(input)`</a>
+Converts a string of Unicode code points to a Punycode string of ASCII code points.
+[&#9650;][1]
+
+#### Arguments
+1. `input` *(String)*: The string of Unicode code points.
+
+#### Returns
+*(String)*: The resulting Punycode string of ASCII code points.
+
+<!-- /div -->
+
+
+<!-- div -->
+
+### <a id="punycode.toASCII" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L458" title="View in source">`punycode.toASCII(domain)`</a>
+Converts a Unicode string representing a domain name to Punycode. Only the non-ASCII parts of the domain name will be converted, i.e. it doesn't matter if you call it with a domain that's already in ASCII.
+[&#9650;][1]
+
+#### Arguments
+1. `domain` *(String)*: The domain name to convert, as a Unicode string.
+
+#### Returns
+*(String)*: The Punycode representation of the given domain name.
+
+<!-- /div -->
+
+
+<!-- div -->
+
+### <a id="punycode.toUnicode" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L442" title="View in source">`punycode.toUnicode(domain)`</a>
+Converts a Punycode string representing a domain name to Unicode. Only the Punycoded parts of the domain name will be converted, i.e. it doesn't matter if you call it on a string that has already been converted to Unicode.
+[&#9650;][1]
+
+#### Arguments
+1. `domain` *(String)*: The Punycode domain name to convert to Unicode.
+
+#### Returns
+*(String)*: The Unicode representation of the given Punycode string.
+
+<!-- /div -->
+
+
+<!-- /div -->
+
+
+<!-- div -->
+
+## `punycode.ucs2`
+
+<!-- div -->
+
+### <a id="punycode.ucs2" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L483" title="View in source">`punycode.ucs2`</a>
+*(Object)*: An object of methods to convert from JavaScript's internal character representation *(UCS-2)* to decimal Unicode code points, and back.
+[&#9650;][1]
+
+<!-- /div -->
+
+
+<!-- div -->
+
+### <a id="punycode.ucs2.decode" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L107" title="View in source">`punycode.ucs2.decode(string)`</a>
+Creates an array containing the decimal code points of each Unicode character in the string. While JavaScript uses UCS-2 internally, this function will convert a pair of surrogate halves *(each of which UCS-2 exposes as separate characters)* into a single code point, matching UTF-16.
+[&#9650;][1]
+
+#### Arguments
+1. `string` *(String)*: The Unicode input string *(UCS-2)*.
+
+#### Returns
+*(Array)*: The new array of code points.
+
+<!-- /div -->
+
+
+<!-- div -->
+
+### <a id="punycode.ucs2.encode" href="https://github.com/bestiejs/punycode.js/blob/master/punycode.js#L135" title="View in source">`punycode.ucs2.encode(codePoints)`</a>
+Creates a string based on an array of decimal code points.
+[&#9650;][1]
+
+#### Arguments
+1. `codePoints` *(Array)*: The array of decimal code points.
+
+#### Returns
+*(String)*: The new Unicode string *(UCS-2)*.
+
+<!-- /div -->
+
+
+<!-- /div -->
+
+
+<!-- /div -->
+
+
+  [1]: #readme "Jump back to the TOC."

data/node_modules/browserify/node_modules/url/node_modules/punycode/docs/parse.php

@@ -0,0 +1,34 @@
+<?php
+
+	// cleanup requested filepath
+	$file = isset($_GET['f']) ? $_GET['f'] : 'punycode';
+	$file = preg_replace('#(\.*[\/])+#', '', $file);
+	$file .= preg_match('/\.[a-z]+$/', $file) ? '' : '.js';
+
+	// output filename
+	if (isset($_GET['o'])) {
+		$output = $_GET['o'];
+	} else if (isset($_SERVER['argv'][1])) {
+		$output = $_SERVER['argv'][1];
+	} else {
+		$output = basename($file);
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	require('../vendor/docdown/docdown.php');
+
+	// generate Markdown
+	$markdown = docdown(array(
+		'path' => '../' . $file,
+		'url'  => 'https://github.com/bestiejs/punycode.js/blob/master/punycode.js'
+	));
+
+	// save to a .md file
+	file_put_contents($output . '.md', $markdown);
+
+	// print
+	header('Content-Type: text/plain;charset=utf-8');
+	echo $markdown . PHP_EOL;
+
+?>

data/node_modules/browserify/node_modules/url/node_modules/punycode/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "punycode",
+  "version": "1.0.0",
+  "description": "A robust Punycode converter that fully complies to RFC 3492 and RFC 5891, and works on nearly all JavaScript platforms.",
+  "homepage": "http://mths.be/punycode",
+  "main": "punycode.js",
+  "keywords": [
+    "punycode",
+    "unicode",
+    "idn",
+    "url",
+    "domain"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://mths.be/mit"
+    },
+    {
+      "type": "GPL",
+      "url": "http://mths.be/gpl"
+    }
+  ],
+  "author": {
+    "name": "Mathias Bynens",
+    "email": "mathias@qiwi.be",
+    "url": "http://mathiasbynens.be/"
+  },
+  "maintainers": [
+    {
+      "name": "Mathias Bynens",
+      "email": "mathias@qiwi.be",
+      "url": "http://mathiasbynens.be/"
+    },
+    {
+      "name": "John-David Dalton",
+      "email": "john@fusejs.com",
+      "url": "http://allyoucanleet.com/"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/bestiejs/punycode.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bestiejs/punycode.js.git"
+  },
+  "engines": [
+    "node",
+    "rhino"
+  ],
+  "directories": {
+    "doc": "docs",
+    "test": "tests"
+  },
+  "readme": "# Punycode.js\n\nA robust Punycode converter that fully complies to [RFC 3492](http://tools.ietf.org/html/rfc3492) and [RFC 5891](http://tools.ietf.org/html/rfc5891), and works on nearly all JavaScript platforms.\n\nThis JavaScript library is the result of comparing, optimizing and documenting different open-source implementations of the Punycode algorithm:\n\n* [The C example code from RFC 3492](http://tools.ietf.org/html/rfc3492#appendix-C)\n* [`punycode.c` by _Markus W. Scherer_ (IBM)](http://opensource.apple.com/source/ICU/ICU-400.42/icuSources/common/punycode.c)\n* [`punycode.c` by _Ben Noordhuis_](https://github.com/bnoordhuis/punycode/blob/master/punycode.c)\n* [JavaScript implementation by _some_](http://stackoverflow.com/questions/183485/can-anyone-recommend-a-good-free-javascript-for-punycode-to-unicode-conversion/301287#301287)\n* [`punycode.js` by _Ben Noordhuis_](https://github.com/joyent/node/blob/426298c8c1c0d5b5224ac3658c41e7c2a3fe9377/lib/punycode.js) (note: [not fully compliant](https://github.com/joyent/node/issues/2072))\n\nThis project is [bundled](https://github.com/joyent/node/blob/master/lib/punycode.js) with [Node.js v0.6.2+](https://github.com/joyent/node/compare/975f1930b1...61e796decc).\n\n## Installation and usage\n\nIn a browser:\n\n~~~html\n<script src=\"punycode.js\"></script>\n~~~\n\nVia [npm](http://npmjs.org/) (only required for Node.js releases older than v0.6.2):\n\n~~~bash\nnpm install punycode\n~~~\n\nIn [Narwhal](http://narwhaljs.org/), [Node.js](http://nodejs.org/), and [RingoJS](http://ringojs.org/):\n\n~~~js\nvar punycode = require('punycode');\n~~~\n\nIn [Rhino](http://www.mozilla.org/rhino/):\n\n~~~js\nload('punycode.js');\n~~~\n\nUsing an AMD loader like [RequireJS](http://requirejs.org/):\n\n~~~js\nrequire(\n  {\n    'paths': {\n      'punycode': 'path/to/punycode'\n    }\n  },\n  ['punycode'],\n  function(punycode) {\n    console.log(punycode);\n  }\n);\n~~~\n\nUsage example:\n\n~~~js\n\n// encode/decode domain names\npunycode.toASCII('mañana.com'); // 'xn--maana-pta.com'\npunycode.toUnicode('xn--maana-pta.com'); // 'mañana.com'\npunycode.toASCII('☃-⌘.com'); // 'xn----dqo34k.com'\npunycode.toUnicode('xn----dqo34k.com'); // '☃-⌘.com'\n\n// encode/decode domain name parts\npunycode.encode('mañana'); // 'maana-pta'\npunycode.decode('maana-pta'); // 'mañana'\npunycode.encode('☃-⌘'); // '--dqo34k'\npunycode.decode('--dqo34k'); // '☃-⌘'\n~~~\n\n[Full API documentation is available.](https://github.com/bestiejs/punycode.js/tree/master/docs#readme)\n\n## Cloning this repo\n\nTo clone this repository including all submodules, using Git 1.6.5 or later:\n\n~~~ bash\ngit clone --recursive https://github.com/bestiejs/punycode.js.git\ncd punycode.js\n~~~\n\nFor older Git versions, just use:\n\n~~~ bash\ngit clone https://github.com/bestiejs/punycode.js.git\ncd punycode.js\ngit submodule update --init\n~~~\n\nFeel free to fork if you see possible improvements!\n\n## Authors\n\n* [Mathias Bynens](http://mathiasbynens.be/)\n  [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](http://twitter.com/mathias \"Follow @mathias on Twitter\")\n\n## Contributors\n\n* [John-David Dalton](http://allyoucanleet.com/)\n  [![twitter/jdalton](http://gravatar.com/avatar/299a3d891ff1920b69c364d061007043?s=70)](http://twitter.com/jdalton \"Follow @jdalton on Twitter\")\n\n## License\n\nPunycode.js is dual licensed under the [MIT](http://mths.be/mit) and [GPL](http://mths.be/gpl) licenses.",
+  "readmeFilename": "README.md",
+  "_id": "punycode@1.0.0",
+  "dist": {
+    "shasum": "cdb5a1f5e1a0e33a825f7fca222fd3510a7b1b71"
+  },
+  "_from": "punycode@>=1.0.0 <1.1.0",
+  "_resolved": "https://registry.npmjs.org/punycode/-/punycode-1.0.0.tgz"
+}

data/node_modules/browserify/node_modules/url/node_modules/punycode/punycode.js

@@ -0,0 +1,512 @@
+/*! http://mths.be/punycode by @mathias */
+;(function(root) {
+
+	/**
+	 * The `punycode` object.
+	 * @name punycode
+	 * @type Object
+	 */
+	var punycode,
+
+	/** Detect free variables `define`, `exports`, `module` and `require` */
+	freeDefine = typeof define == 'function' && typeof define.amd == 'object' &&
+		define.amd && define,
+	freeExports = typeof exports == 'object' && exports,
+	freeModule = typeof module == 'object' && module,
+	freeRequire = typeof require == 'function' && require,
+
+	/** Highest positive signed 32-bit float value */
+	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
+
+	/** Bootstring parameters */
+	base = 36,
+	tMin = 1,
+	tMax = 26,
+	skew = 38,
+	damp = 700,
+	initialBias = 72,
+	initialN = 128, // 0x80
+	delimiter = '-', // '\x2D'
+
+	/** Regular expressions */
+	regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
+	regexPunycode = /^xn--/,
+
+	/** Error messages */
+	errors = {
+		'overflow': 'Overflow: input needs wider integers to process.',
+		'ucs2decode': 'UCS-2(decode): illegal sequence',
+		'ucs2encode': 'UCS-2(encode): illegal value',
+		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+		'invalid-input': 'Invalid input'
+	},
+
+	/** Convenience shortcuts */
+	baseMinusTMin = base - tMin,
+	floor = Math.floor,
+	stringFromCharCode = String.fromCharCode,
+
+	/** Temporary variable */
+	key;
+
+	/*--------------------------------------------------------------------------*/
+
+	/**
+	 * A generic error utility function.
+	 * @private
+	 * @param {String} type The error type.
+	 * @returns {Error} Throws a `RangeError` with the applicable error message.
+	 */
+	function error(type) {
+		throw RangeError(errors[type]);
+	}
+
+	/**
+	 * A generic `Array#map` utility function.
+	 * @private
+	 * @param {Array} array The array to iterate over.
+	 * @param {Function} callback The function that gets called for every array
+	 * item.
+	 * @returns {Array} A new array of values returned by the callback function.
+	 */
+	function map(array, fn) {
+		var length = array.length;
+		while (length--) {
+			array[length] = fn(array[length]);
+		}
+		return array;
+	}
+
+	/**
+	 * A simple `Array#map`-like wrapper to work with domain name strings.
+	 * @private
+	 * @param {String} domain The domain name.
+	 * @param {Function} callback The function that gets called for every
+	 * character.
+	 * @returns {Array} A new string of characters returned by the callback
+	 * function.
+	 */
+	function mapDomain(string, fn) {
+		var glue = '.';
+		return map(string.split(glue), fn).join(glue);
+	}
+
+	/**
+	 * Creates an array containing the decimal code points of each Unicode
+	 * character in the string. While JavaScript uses UCS-2 internally,
+	 * this function will convert a pair of surrogate halves (each of which
+	 * UCS-2 exposes as separate characters) into a single code point,
+	 * matching UTF-16.
+	 * @see `punycode.ucs2.encode`
+	 * @see <http://mathiasbynens.be/notes/javascript-encoding>
+	 * @memberOf punycode.ucs2
+	 * @name decode
+	 * @param {String} string The Unicode input string (UCS-2).
+	 * @returns {Array} The new array of code points.
+	 */
+	function ucs2decode(string) {
+		var output = [],
+		    counter = 0,
+		    length = string.length,
+		    value,
+		    extra;
+		while (counter < length) {
+			value = string.charCodeAt(counter++);
+			if ((value & 0xF800) == 0xD800) {
+				extra = string.charCodeAt(counter++);
+				if ((value & 0xFC00) != 0xD800 || (extra & 0xFC00) != 0xDC00) {
+					error('ucs2decode');
+				}
+				value = ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000;
+			}
+			output.push(value);
+		}
+		return output;
+	}
+
+	/**
+	 * Creates a string based on an array of decimal code points.
+	 * @see `punycode.ucs2.decode`
+	 * @memberOf punycode.ucs2
+	 * @name encode
+	 * @param {Array} codePoints The array of decimal code points.
+	 * @returns {String} The new Unicode string (UCS-2).
+	 */
+	function ucs2encode(array) {
+		return map(array, function(value) {
+			var output = '';
+			if ((value & 0xF800) == 0xD800) {
+				error('ucs2encode');
+			}
+			if (value > 0xFFFF) {
+				value -= 0x10000;
+				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+				value = 0xDC00 | value & 0x3FF;
+			}
+			output += stringFromCharCode(value);
+			return output;
+		}).join('');
+	}
+
+	/**
+	 * Converts a basic code point into a digit/integer.
+	 * @see `digitToBasic()`
+	 * @private
+	 * @param {Number} codePoint The basic (decimal) code point.
+	 * @returns {Number} The numeric value of a basic code point (for use in
+	 * representing integers) in the range `0` to `base - 1`, or `base` if
+	 * the code point does not represent a value.
+	 */
+	function basicToDigit(codePoint) {
+		return codePoint - 48 < 10
+			? codePoint - 22
+			: codePoint - 65 < 26
+				? codePoint - 65
+				: codePoint - 97 < 26
+					? codePoint - 97
+					: base;
+	}
+
+	/**
+	 * Converts a digit/integer into a basic code point.
+	 * @see `basicToDigit()`
+	 * @private
+	 * @param {Number} digit The numeric value of a basic code point.
+	 * @returns {Number} The basic code point whose value (when used for
+	 * representing integers) is `digit`, which needs to be in the range
+	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+	 * used; else, the lowercase form is used. The behavior is undefined
+	 * if flag is non-zero and `digit` has no uppercase form.
+	 */
+	function digitToBasic(digit, flag) {
+		//  0..25 map to ASCII a..z or A..Z
+		// 26..35 map to ASCII 0..9
+		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+	}
+
+	/**
+	 * Bias adaptation function as per section 3.4 of RFC 3492.
+	 * http://tools.ietf.org/html/rfc3492#section-3.4
+	 * @private
+	 */
+	function adapt(delta, numPoints, firstTime) {
+		var k = 0;
+		delta = firstTime ? floor(delta / damp) : delta >> 1;
+		delta += floor(delta / numPoints);
+		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+			delta = floor(delta / baseMinusTMin);
+		}
+		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+	}
+
+	/**
+	 * Converts a basic code point to lowercase is `flag` is falsy, or to
+	 * uppercase if `flag` is truthy. The code point is unchanged if it's
+	 * caseless. The behavior is undefined if `codePoint` is not a basic code
+	 * point.
+	 * @private
+	 * @param {Number} codePoint The numeric value of a basic code point.
+	 * @returns {Number} The resulting basic code point.
+	 */
+	function encodeBasic(codePoint, flag) {
+		codePoint -= (codePoint - 97 < 26) << 5;
+		return codePoint + (!flag && codePoint - 65 < 26) << 5;
+	}
+
+	/**
+	 * Converts a Punycode string of ASCII code points to a string of Unicode
+	 * code points.
+	 * @memberOf punycode
+	 * @param {String} input The Punycode string of ASCII code points.
+	 * @returns {String} The resulting string of Unicode code points.
+	 */
+	function decode(input) {
+		// Don't use UCS-2
+		var output = [],
+		    inputLength = input.length,
+		    out,
+		    i = 0,
+		    n = initialN,
+		    bias = initialBias,
+		    basic,
+		    j,
+		    index,
+		    oldi,
+		    w,
+		    k,
+		    digit,
+		    t,
+		    length,
+		    /** Cached calculation results */
+		    baseMinusT;
+
+		// Handle the basic code points: let `basic` be the number of input code
+		// points before the last delimiter, or `0` if there is none, then copy
+		// the first basic code points to the output.
+
+		basic = input.lastIndexOf(delimiter);
+		if (basic < 0) {
+			basic = 0;
+		}
+
+		for (j = 0; j < basic; ++j) {
+			// if it's not a basic code point
+			if (input.charCodeAt(j) >= 0x80) {
+				error('not-basic');
+			}
+			output.push(input.charCodeAt(j));
+		}
+
+		// Main decoding loop: start just after the last delimiter if any basic code
+		// points were copied; start at the beginning otherwise.
+
+		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+			// `index` is the index of the next character to be consumed.
+			// Decode a generalized variable-length integer into `delta`,
+			// which gets added to `i`. The overflow checking is easier
+			// if we increase `i` as we go, then subtract off its starting
+			// value at the end to obtain `delta`.
+			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
+
+				if (index >= inputLength) {
+					error('invalid-input');
+				}
+
+				digit = basicToDigit(input.charCodeAt(index++));
+
+				if (digit >= base || digit > floor((maxInt - i) / w)) {
+					error('overflow');
+				}
+
+				i += digit * w;
+				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+				if (digit < t) {
+					break;
+				}
+
+				baseMinusT = base - t;
+				if (w > floor(maxInt / baseMinusT)) {
+					error('overflow');
+				}
+
+				w *= baseMinusT;
+
+			}
+
+			out = output.length + 1;
+			bias = adapt(i - oldi, out, oldi == 0);
+
+			// `i` was supposed to wrap around from `out` to `0`,
+			// incrementing `n` each time, so we'll fix that now:
+			if (floor(i / out) > maxInt - n) {
+				error('overflow');
+			}
+
+			n += floor(i / out);
+			i %= out;
+
+			// Insert `n` at position `i` of the output
+			output.splice(i++, 0, n);
+
+		}
+
+		return ucs2encode(output);
+	}
+
+	/**
+	 * Converts a string of Unicode code points to a Punycode string of ASCII
+	 * code points.
+	 * @memberOf punycode
+	 * @param {String} input The string of Unicode code points.
+	 * @returns {String} The resulting Punycode string of ASCII code points.
+	 */
+	function encode(input) {
+		var n,
+		    delta,
+		    handledCPCount,
+		    basicLength,
+		    bias,
+		    j,
+		    m,
+		    q,
+		    k,
+		    t,
+		    currentValue,
+		    output = [],
+		    /** `inputLength` will hold the number of code points in `input`. */
+		    inputLength,
+		    /** Cached calculation results */
+		    handledCPCountPlusOne,
+		    baseMinusT,
+		    qMinusT;
+
+		// Convert the input in UCS-2 to Unicode
+		input = ucs2decode(input);
+
+		// Cache the length
+		inputLength = input.length;
+
+		// Initialize the state
+		n = initialN;
+		delta = 0;
+		bias = initialBias;
+
+		// Handle the basic code points
+		for (j = 0; j < inputLength; ++j) {
+			currentValue = input[j];
+			if (currentValue < 0x80) {
+				output.push(stringFromCharCode(currentValue));
+			}
+		}
+
+		handledCPCount = basicLength = output.length;
+
+		// `handledCPCount` is the number of code points that have been handled;
+		// `basicLength` is the number of basic code points.
+
+		// Finish the basic string - if it is not empty - with a delimiter
+		if (basicLength) {
+			output.push(delimiter);
+		}
+
+		// Main encoding loop:
+		while (handledCPCount < inputLength) {
+
+			// All non-basic code points < n have been handled already. Find the next
+			// larger one:
+			for (m = maxInt, j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+				if (currentValue >= n && currentValue < m) {
+					m = currentValue;
+				}
+			}
+
+			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+			// but guard against overflow
+			handledCPCountPlusOne = handledCPCount + 1;
+			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+				error('overflow');
+			}
+
+			delta += (m - n) * handledCPCountPlusOne;
+			n = m;
+
+			for (j = 0; j < inputLength; ++j) {
+				currentValue = input[j];
+
+				if (currentValue < n && ++delta > maxInt) {
+					error('overflow');
+				}
+
+				if (currentValue == n) {
+					// Represent delta as a generalized variable-length integer
+					for (q = delta, k = base; /* no condition */; k += base) {
+						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+						if (q < t) {
+							break;
+						}
+						qMinusT = q - t;
+						baseMinusT = base - t;
+						output.push(
+							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+						);
+						q = floor(qMinusT / baseMinusT);
+					}
+
+					output.push(stringFromCharCode(digitToBasic(q, 0)));
+					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+					delta = 0;
+					++handledCPCount;
+				}
+			}
+
+			++delta;
+			++n;
+
+		}
+		return output.join('');
+	}
+
+	/**
+	 * Converts a Punycode string representing a domain name to Unicode. Only the
+	 * Punycoded parts of the domain name will be converted, i.e. it doesn't
+	 * matter if you call it on a string that has already been converted to
+	 * Unicode.
+	 * @memberOf punycode
+	 * @param {String} domain The Punycode domain name to convert to Unicode.
+	 * @returns {String} The Unicode representation of the given Punycode
+	 * string.
+	 */
+	function toUnicode(domain) {
+		return mapDomain(domain, function(string) {
+			return regexPunycode.test(string)
+				? decode(string.slice(4).toLowerCase())
+				: string;
+		});
+	}
+
+	/**
+	 * Converts a Unicode string representing a domain name to Punycode. Only the
+	 * non-ASCII parts of the domain name will be converted, i.e. it doesn't
+	 * matter if you call it with a domain that's already in ASCII.
+	 * @memberOf punycode
+	 * @param {String} domain The domain name to convert, as a Unicode string.
+	 * @returns {String} The Punycode representation of the given domain name.
+	 */
+	function toASCII(domain) {
+		return mapDomain(domain, function(string) {
+			return regexNonASCII.test(string)
+				? 'xn--' + encode(string)
+				: string;
+		});
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	/** Define the public API */
+	punycode = {
+		/**
+		 * A string representing the current Punycode.js version number.
+		 * @memberOf punycode
+		 * @type String
+		 */
+		'version': '1.0.0',
+		/**
+		 * An object of methods to convert from JavaScript's internal character
+		 * representation (UCS-2) to decimal Unicode code points, and back.
+		 * @see <http://mathiasbynens.be/notes/javascript-encoding>
+		 * @memberOf punycode
+		 * @type Object
+		 */
+		'ucs2': {
+			'decode': ucs2decode,
+			'encode': ucs2encode
+		},
+		'decode': decode,
+		'encode': encode,
+		'toASCII': toASCII,
+		'toUnicode': toUnicode
+	};
+
+	/** Expose `punycode` */
+	if (freeExports) {
+		if (freeModule && freeModule.exports == freeExports) {
+			// in Node.js or Ringo 0.8+
+			freeModule.exports = punycode;
+		} else {
+			// in Narwhal or Ringo 0.7-
+			for (key in punycode) {
+				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+			}
+		}
+	} else if (freeDefine) {
+		// via curl.js or RequireJS
+		define('punycode', punycode);
+	} else {
+		// in a browser or Rhino
+		root.punycode = punycode;
+	}
+
+}(this));