1. module base-64
   1. function base-64.decode (input)
   2. function base-64.encode (input)
   3. string base-64.version

module base-64

function base-64.decode (input)

• description and source-code

  decode = function (input) {
  		input = String(input)
  			.replace(REGEX_SPACE_CHARACTERS, '');
  		var length = input.length;
  		if (length % 4 == 0) {
  			input = input.replace(/==?$/, '');
  			length = input.length;
  		}
  		if (
  			length % 4 == 1 ||
  			// http://whatwg.org/C#alphanumeric-ascii-characters
  			/[^+a-zA-Z0-9/]/.test(input)
  		) {
  			error(
  				'Invalid character: the string to be decoded is not correctly encoded.'
  			);
  		}
  		var bitCounter = 0;
  		var bitStorage;
  		var buffer;
  		var output = '';
  		var position = -1;
  		while (++position < length) {
  			buffer = TABLE.indexOf(input.charAt(position));
  			bitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;
  			// Unless this is the first of a group of 4 characters…
  			if (bitCounter++ % 4) {
  				// …convert the first 8 bits to a single ASCII character.
  				output += String.fromCharCode(
  					0xFF & bitStorage >> (-2 * bitCounter & 6)
  				);
  			}
  		}
  		return output;
  	}

• example usage

  ...
  var text = 'foo © bar 𝌆 baz';
  var bytes = utf8.encode(text);
  var encoded = base64.encode(bytes);
  console.log(encoded);
  // → 'Zm9vIMKpIGJhciDwnYyGIGJheg=='
  ```
  
  ### `base64.decode(input)`
  
  This function takes a base64-encoded string (the `input` parameter) and decodes it. The return value is in the form of a string
  containing only characters in the range from U+0000 to U+00FF, each representing a binary byte with values `0x00` to `0xFF`. The
   `base64.decode()` function is designed to be fully compatible with [`atob()` as described in the HTML Standard](http://www.whatwg
  .org/specs/web-apps/current-work/multipage/webappapis.html#dom-windowbase64-atob).
  
  ```js
  var decodedData = base64.decode(encodedData);
  ```
  ...

function base-64.encode (input)

• description and source-code

  encode = function (input) {
  		input = String(input);
  		if (/[^\0-\xFF]/.test(input)) {
  			// Note: no need to special-case astral symbols here, as surrogates are
  			// matched, and the input is supposed to only contain ASCII anyway.
  			error(
  				'The string to be encoded contains characters outside of the ' +
  				'Latin1 range.'
  			);
  		}
  		var padding = input.length % 3;
  		var output = '';
  		var position = -1;
  		var a;
  		var b;
  		var c;
  		var d;
  		var buffer;
  		// Make sure any padding is handled outside of the loop.
  		var length = input.length - padding;
  
  		while (++position < length) {
  			// Read three bytes, i.e. 24 bits.
  			a = input.charCodeAt(position) << 16;
  			b = input.charCodeAt(++position) << 8;
  			c = input.charCodeAt(++position);
  			buffer = a + b + c;
  			// Turn the 24 bits into four chunks of 6 bits each, and append the
  			// matching character for each of them to the output.
  			output += (
  				TABLE.charAt(buffer >> 18 & 0x3F) +
  				TABLE.charAt(buffer >> 12 & 0x3F) +
  				TABLE.charAt(buffer >> 6 & 0x3F) +
  				TABLE.charAt(buffer & 0x3F)
  			);
  		}
  
  		if (padding == 2) {
  			a = input.charCodeAt(position) << 8;
  			b = input.charCodeAt(++position);
  			buffer = a + b;
  			output += (
  				TABLE.charAt(buffer >> 10) +
  				TABLE.charAt((buffer >> 4) & 0x3F) +
  				TABLE.charAt((buffer << 2) & 0x3F) +
  				'='
  			);
  		} else if (padding == 1) {
  			buffer = input.charCodeAt(position);
  			output += (
  				TABLE.charAt(buffer >> 2) +
  				TABLE.charAt((buffer << 4) & 0x3F) +
  				'=='
  			);
  		}
  
  		return output;
  	}

• example usage

  ...
  
  ## API
  
  ### `base64.version`
  
  A string representing the semantic version number.
  
  ### `base64.encode(input)`
  
  This function takes a byte string (the `input` parameter) and encodes it according to base64. The input data must be in the form
   of a string containing only characters in the range from U+0000 to U+00FF, each representing a binary byte with values `0x00` to
   `0xFF`. The `base64.encode()` function is designed to be fully compatible with [`btoa()` as described in the HTML Standard](http
  ://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#dom-windowbase64-btoa).
  
  ```js
  var encodedData = base64.encode(input);
  ```
  ...