uri-js-rails 1.11.2 → 1.14.1

data/vendor/assets/javascripts/jquery.URI.js

@@ -2,231 +2,234 @@
  * URI.js - Mutating URLs
  * jQuery Plugin
  *
- * Version: 1.11.2
+ * Version: 1.14.1
  *
  * Author: Rodney Rehm
- * Web: http://medialize.github.com/URI.js/jquery-uri-plugin.html
+ * Web: http://medialize.github.io/URI.js/jquery-uri-plugin.html
  *
  * Licensed under
  *   MIT License http://www.opensource.org/licenses/mit-license
  *   GPL v3 http://opensource.org/licenses/GPL-3.0
  *
  */
-
 (function (root, factory) {
-    // https://github.com/umdjs/umd/blob/master/returnExports.js
-    if (typeof exports === 'object') {
-        // Node
-        module.exports = factory(require('jquery', './URI'));
-    } else if (typeof define === 'function' && define.amd) {
-        // AMD. Register as an anonymous module.
-        define(['jquery', './URI'], factory);
-    } else {
-        // Browser globals (root is window)
-        factory(root.jQuery, root.URI);
-    }
+  'use strict';
+  // https://github.com/umdjs/umd/blob/master/returnExports.js
+  if (typeof exports === 'object') {
+    // Node
+    module.exports = factory(require('jquery', './URI'));
+  } else if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(['jquery', './URI'], factory);
+  } else {
+    // Browser globals (root is window)
+    factory(root.jQuery, root.URI);
+  }
 }(this, function ($, URI) {
-"use strict";
+  'use strict';
+  // FIXME: v2.0.0 renamce non-camelCase properties to uppercase
+  /*jshint camelcase: false */
 
-var comparable = {};
-var compare = {
+  var comparable = {};
+  var compare = {
     // equals 
     '=': function(value, target) {
-        return value === target;
+      return value === target;
     },
     // ~= translates to value.match((?:^|\s)target(?:\s|$)) which is useless for URIs
     // |= translates to value.match((?:\b)target(?:-|\s|$)) which is useless for URIs
     // begins with
-    '^=': function(value, target, property) {
-        return !!(value + "").match(new RegExp('^' + escapeRegEx(target), 'i'));
+    '^=': function(value, target) {
+      return !!(value + '').match(new RegExp('^' + escapeRegEx(target), 'i'));
     },
     // ends with
-    '$=': function(value, target, property) {
-        return !!(value + "").match(new RegExp(escapeRegEx(target) + '$', 'i'));
+    '$=': function(value, target) {
+      return !!(value + '').match(new RegExp(escapeRegEx(target) + '$', 'i'));
     },
     // contains
     '*=': function(value, target, property) {
-        if (property == 'directory') {
-            // add trailing slash so /dir/ will match the deep-end as well
-            value += '/';
-        }
-        
-        return !!(value + "").match(new RegExp(escapeRegEx(target), 'i'));
+      if (property === 'directory') {
+        // add trailing slash so /dir/ will match the deep-end as well
+        value += '/';
+      }
+    
+      return !!(value + '').match(new RegExp(escapeRegEx(target), 'i'));
     },
     'equals:': function(uri, target) {
-        return uri.equals(target);
+      return uri.equals(target);
     },
     'is:': function(uri, target) {
-        return uri.is(target);
+      return uri.is(target);
     }
-};
+  };
 
-function escapeRegEx(string) {
+  function escapeRegEx(string) {
     // https://github.com/medialize/URI.js/commit/85ac21783c11f8ccab06106dba9735a31a86924d#commitcomment-821963
     return string.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
-}
+  }
 
-function getUriProperty(elem) {
+  function getUriProperty(elem) {
     var nodeName = elem.nodeName.toLowerCase();
     var property = URI.domAttributes[nodeName];
     if (nodeName === 'input' && elem.type !== 'image') {
-        // compensate ambiguous <input> that is not an image
-        return undefined;
+      // compensate ambiguous <input> that is not an image
+      return undefined;
     }
-    
+  
     // NOTE: as we use a static mapping from element to attribute,
     // the HTML5 attribute issue should not come up again
     // https://github.com/medialize/URI.js/issues/69
     return property;
-}
+  }
 
-function generateAccessor(property) {
+  function generateAccessor(property) {
     return {
-        get: function(elem) {
-            return $(elem).uri()[property]();
-        },
-        set: function(elem, value) {
-            $(elem).uri()[property](value);
-            return value;
-        }
+      get: function(elem) {
+        return $(elem).uri()[property]();
+      },
+      set: function(elem, value) {
+        $(elem).uri()[property](value);
+        return value;
+      }
     };
-};
+  }
 
-// populate lookup table and register $.attr('uri:accessor') handlers
-$.each('authority directory domain filename fragment hash host hostname href password path pathname port protocol query resource scheme search subdomain suffix tld username'.split(" "), function(k, v) {
+  // populate lookup table and register $.attr('uri:accessor') handlers
+  $.each('authority directory domain filename fragment hash host hostname href password path pathname port protocol query resource scheme search subdomain suffix tld username'.split(' '), function(k, v) {
     comparable[v] = true;
     $.attrHooks['uri:' + v] = generateAccessor(v);
-});
+  });
 
-// pipe $.attr('src') and $.attr('href') through URI.js
-var _attrHooks = {
+  // pipe $.attr('src') and $.attr('href') through URI.js
+  var _attrHooks = {
     get: function(elem) {
-        return $(elem).uri();
+      return $(elem).uri();
     },
     set: function(elem, value) {
-        return $(elem).uri().href(value).toString();
+      return $(elem).uri().href(value).toString();
     }
-};
-$.each(['src', 'href', 'action', 'uri', 'cite'], function(k, v) {
+  };
+  $.each(['src', 'href', 'action', 'uri', 'cite'], function(k, v) {
     $.attrHooks[v] = {
-        set: _attrHooks.set
+      set: _attrHooks.set
     };
-});
-$.attrHooks.uri.get = _attrHooks.get;
+  });
+  $.attrHooks.uri.get = _attrHooks.get;
 
-// general URI accessor
-$.fn.uri = function(uri) {
+  // general URI accessor
+  $.fn.uri = function(uri) {
     var $this = this.first();
     var elem = $this.get(0);
     var property = getUriProperty(elem);
-    
+  
     if (!property) {
-        throw new Error('Element "' + elem.nodeName + '" does not have either property: href, src, action, cite');
+      throw new Error('Element "' + elem.nodeName + '" does not have either property: href, src, action, cite');
     }
-    
+  
     if (uri !== undefined) {
-        var old = $this.data('uri');
-        if (old) {
-            return old.href(uri);
-        }
-        
-        if (!(uri instanceof URI)) {
-            uri = URI(uri || '');
-        }
+      var old = $this.data('uri');
+      if (old) {
+        return old.href(uri);
+      }
+    
+      if (!(uri instanceof URI)) {
+        uri = URI(uri || '');
+      }
     } else {
-        uri = $this.data('uri');
-        if (uri) {
-            return uri;
-        } else {
-            uri = URI($this.attr(property) || '');
-        }
+      uri = $this.data('uri');
+      if (uri) {
+        return uri;
+      } else {
+        uri = URI($this.attr(property) || '');
+      }
     }
-    
+  
     uri._dom_element = elem;
     uri._dom_attribute = property;
     uri.normalize();
     $this.data('uri', uri);
     return uri;
-};
+  };
 
-// overwrite URI.build() to update associated DOM element if necessary
-URI.prototype.build = function(deferBuild) {
+  // overwrite URI.build() to update associated DOM element if necessary
+  URI.prototype.build = function(deferBuild) {
     if (this._dom_element) {
-        // cannot defer building when hooked into a DOM element
-        this._string = URI.build(this._parts);
-        this._deferred_build = false;
-        this._dom_element.setAttribute(this._dom_attribute, this._string);
-        this._dom_element[this._dom_attribute] = this._string;
+      // cannot defer building when hooked into a DOM element
+      this._string = URI.build(this._parts);
+      this._deferred_build = false;
+      this._dom_element.setAttribute(this._dom_attribute, this._string);
+      this._dom_element[this._dom_attribute] = this._string;
     } else if (deferBuild === true) {
-        this._deferred_build = true;
+      this._deferred_build = true;
     } else if (deferBuild === undefined || this._deferred_build) {
-        this._string = URI.build(this._parts);
-        this._deferred_build = false;
+      this._string = URI.build(this._parts);
+      this._deferred_build = false;
     }
-    
+  
     return this;
-};
+  };
 
-// add :uri() pseudo class selector to sizzle
-var uriSizzle;
-var pseudoArgs = /^([a-zA-Z]+)\s*([\^\$*]?=|:)\s*(['"]?)(.+)\3|^\s*([a-zA-Z0-9]+)\s*$/;
-function uriPseudo (elem, text) {
+  // add :uri() pseudo class selector to sizzle
+  var uriSizzle;
+  var pseudoArgs = /^([a-zA-Z]+)\s*([\^\$*]?=|:)\s*(['"]?)(.+)\3|^\s*([a-zA-Z0-9]+)\s*$/;
+  function uriPseudo (elem, text) {
     var match, property, uri;
-    
+  
     // skip anything without src|href|action and bad :uri() syntax
     if (!getUriProperty(elem) || !text) {
-        return false;
+      return false;
     }
-    
+  
     match = text.match(pseudoArgs);
 
     if (!match || (!match[5] && match[2] !== ':' && !compare[match[2]])) {
-        // abort because the given selector cannot be executed
-        // filers seem to fail silently
-        return false;
+      // abort because the given selector cannot be executed
+      // filers seem to fail silently
+      return false;
     }
 
     uri = $(elem).uri();
-    
+  
     if (match[5]) {
-        return uri.is(match[5]);
+      return uri.is(match[5]);
     } else if (match[2] === ':') {
-        property = match[1].toLowerCase() + ':';
-        if (!compare[property]) {
-            // filers seem to fail silently
-            return false;
-        }
-        
-        return compare[property](uri, match[4]);
+      property = match[1].toLowerCase() + ':';
+      if (!compare[property]) {
+        // filers seem to fail silently
+        return false;
+      }
+    
+      return compare[property](uri, match[4]);
     } else {
-        property = match[1].toLowerCase();
-        if (!comparable[property]) {
-            // filers seem to fail silently
-            return false;
-        }
-        
-        return compare[match[2]](uri[property](), match[4], property);
+      property = match[1].toLowerCase();
+      if (!comparable[property]) {
+        // filers seem to fail silently
+        return false;
+      }
+    
+      return compare[match[2]](uri[property](), match[4], property);
     }
 
     return false;
-}
+  }
 
-if ($.expr.createPseudo) {
+  if ($.expr.createPseudo) {
     // jQuery >= 1.8
     uriSizzle = $.expr.createPseudo(function (text) {
-        return function (elem) {
-            return uriPseudo(elem, text);
-        };
+      return function (elem) {
+        return uriPseudo(elem, text);
+      };
     });
-} else {
+  } else {
     // jQuery < 1.8
     uriSizzle = function (elem, i, match) {
-        return uriPseudo(elem, match[3]);
+      return uriPseudo(elem, match[3]);
     };
-}
+  }
 
-$.expr[":"].uri = uriSizzle;
+  $.expr[':'].uri = uriSizzle;
 
-// extending existing object rather than defining something new
-return {};
+  // extending existing object rather than defining something new,
+  // return jQuery anyway
+  return $;
 }));

data/vendor/assets/javascripts/jquery.URI.min.js

@@ -0,0 +1,7 @@
+/*! URI.js v1.14.1 http://medialize.github.io/URI.js/ */
+/* build contains: jquery.URI.js */
+(function(d,e){"object"===typeof exports?module.exports=e(require("jquery","./URI")):"function"===typeof define&&define.amd?define(["jquery","./URI"],e):e(d.jQuery,d.URI)})(this,function(d,e){function h(a){return a.replace(/([.*+?^=!:${}()|[\]\/\\])/g,"\\$1")}function k(a){var b=a.nodeName.toLowerCase();return"input"===b&&"image"!==a.type?void 0:e.domAttributes[b]}function p(a){return{get:function(b){return d(b).uri()[a]()},set:function(b,c){d(b).uri()[a](c);return c}}}function l(a,b){var c,e,f;if(!k(a)||
+!b)return!1;c=b.match(q);if(!c||!c[5]&&":"!==c[2]&&!g[c[2]])return!1;f=d(a).uri();if(c[5])return f.is(c[5]);if(":"===c[2])return e=c[1].toLowerCase()+":",g[e]?g[e](f,c[4]):!1;e=c[1].toLowerCase();return m[e]?g[c[2]](f[e](),c[4],e):!1}var m={},g={"=":function(a,b){return a===b},"^=":function(a,b){return!!(a+"").match(new RegExp("^"+h(b),"i"))},"$=":function(a,b){return!!(a+"").match(new RegExp(h(b)+"$","i"))},"*=":function(a,b,c){"directory"===c&&(a+="/");return!!(a+"").match(new RegExp(h(b),"i"))},
+"equals:":function(a,b){return a.equals(b)},"is:":function(a,b){return a.is(b)}};d.each("authority directory domain filename fragment hash host hostname href password path pathname port protocol query resource scheme search subdomain suffix tld username".split(" "),function(a,b){m[b]=!0;d.attrHooks["uri:"+b]=p(b)});var r=function(a,b){return d(a).uri().href(b).toString()};d.each(["src","href","action","uri","cite"],function(a,b){d.attrHooks[b]={set:r}});d.attrHooks.uri.get=function(a){return d(a).uri()};
+d.fn.uri=function(a){var b=this.first(),c=b.get(0),d=k(c);if(!d)throw Error('Element "'+c.nodeName+'" does not have either property: href, src, action, cite');if(void 0!==a){var f=b.data("uri");if(f)return f.href(a);a instanceof e||(a=e(a||""))}else{if(a=b.data("uri"))return a;a=e(b.attr(d)||"")}a._dom_element=c;a._dom_attribute=d;a.normalize();b.data("uri",a);return a};e.prototype.build=function(a){if(this._dom_element)this._string=e.build(this._parts),this._deferred_build=!1,this._dom_element.setAttribute(this._dom_attribute,
+this._string),this._dom_element[this._dom_attribute]=this._string;else if(!0===a)this._deferred_build=!0;else if(void 0===a||this._deferred_build)this._string=e.build(this._parts),this._deferred_build=!1;return this};var n,q=/^([a-zA-Z]+)\s*([\^\$*]?=|:)\s*(['"]?)(.+)\3|^\s*([a-zA-Z0-9]+)\s*$/;n=d.expr.createPseudo?d.expr.createPseudo(function(a){return function(b){return l(b,a)}}):function(a,b,c){return l(a,c[3])};d.expr[":"].uri=n;return d});

data/vendor/assets/javascripts/punycode.js

@@ -0,0 +1,508 @@
+/*! http://mths.be/punycode v1.2.3 by @mathias */
+;(function(root) {
+
+	/** Detect free variables */
+	var freeExports = typeof exports == 'object' && exports;
+	var freeModule = typeof module == 'object' && module &&
+		module.exports == freeExports && module;
+	var freeGlobal = typeof global == 'object' && global;
+	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+		root = freeGlobal;
+	}
+
+	/**
+	 * The `punycode` object.
+	 * @name punycode
+	 * @type Object
+	 */
+	var punycode,
+
+	/** 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 */
+	regexPunycode = /^xn--/,
+	regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
+	regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators
+
+	/** Error messages */
+	errors = {
+		'overflow': 'Overflow: input needs wider integers to process',
+		'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) {
+		return map(string.split(regexSeparators), fn).join('.');
+	}
+
+	/**
+	 * Creates an array containing the numeric 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 >= 0xD800 && value <= 0xDBFF && counter < length) {
+				// high surrogate, and there is a next character
+				extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+				} else {
+					// unmatched surrogate; only append this code unit, in case the next
+					// code unit is the high surrogate of a surrogate pair
+					output.push(value);
+					counter--;
+				}
+			} else {
+				output.push(value);
+			}
+		}
+		return output;
+	}
+
+	/**
+	 * Creates a string based on an array of numeric code points.
+	 * @see `punycode.ucs2.decode`
+	 * @memberOf punycode.ucs2
+	 * @name encode
+	 * @param {Array} codePoints The array of numeric code points.
+	 * @returns {String} The new Unicode string (UCS-2).
+	 */
+	function ucs2encode(array) {
+		return map(array, function(value) {
+			var output = '';
+			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 numeric code point value.
+	 * @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) {
+		if (codePoint - 48 < 10) {
+			return codePoint - 22;
+		}
+		if (codePoint - 65 < 26) {
+			return codePoint - 65;
+		}
+		if (codePoint - 97 < 26) {
+			return codePoint - 97;
+		}
+		return 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 Punycode string of ASCII-only symbols to a string of Unicode
+	 * symbols.
+	 * @memberOf punycode
+	 * @param {String} input The Punycode string of ASCII-only symbols.
+	 * @returns {String} The resulting string of Unicode symbols.
+	 */
+	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 symbols to a Punycode string of ASCII-only
+	 * symbols.
+	 * @memberOf punycode
+	 * @param {String} input The string of Unicode symbols.
+	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
+	 */
+	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.2.3',
+		/**
+		 * An object of methods to convert from JavaScript's internal character
+		 * representation (UCS-2) to 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` */
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define(function() {
+			return punycode;
+		});
+	}	else if (freeExports && !freeExports.nodeType) {
+		if (freeModule) { // in Node.js or RingoJS v0.8.0+
+			freeModule.exports = punycode;
+		} else { // in Narwhal or RingoJS v0.7.0-
+			for (key in punycode) {
+				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+			}
+		}
+	} else { // in Rhino or a web browser
+		root.punycode = punycode;
+	}
+
+}(this));