JAVASCRIPT   662

base64.js

Guest on 27th August 2021 01:20:23 AM

  1. /*! http://mths.be/base64 v0.1.0 by @mathias | MIT license */
  2. ;(function(root) {
  3.  
  4.         // Detect free variables `exports`.
  5.         var freeExports = typeof exports == 'object' && exports;
  6.  
  7.         // Detect free variable `module`.
  8.         var freeModule = typeof module == 'object' && module &&
  9.                 module.exports == freeExports && module;
  10.  
  11.         // Detect free variable `global`, from Node.js or Browserified code, and use
  12.         // it as `root`.
  13.         var freeGlobal = typeof global == 'object' && global;
  14.         if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
  15.                 root = freeGlobal;
  16.         }
  17.  
  18.         /*--------------------------------------------------------------------------*/
  19.  
  20.         var InvalidCharacterError = function(message) {
  21.                 this.message = message;
  22.         };
  23.         InvalidCharacterError.prototype = new Error;
  24.         InvalidCharacterError.prototype.name = 'InvalidCharacterError';
  25.  
  26.         var error = function(message) {
  27.                 // Note: the error messages used throughout this file match those used by
  28.                 // the native `atob`/`btoa` implementation in Chromium.
  29.                 throw new InvalidCharacterError(message);
  30.         };
  31.  
  32.         var TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
  33.         // http://whatwg.org/html/common-microsyntaxes.html#space-character
  34.         var REGEX_SPACE_CHARACTERS = /[\t\n\f\r ]/g;
  35.  
  36.         // `decode` is designed to be fully compatible with `atob` as described in the
  37.         // HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob
  38.         // The optimized base64-decoding algorithm used is based on @atkā€™s excellent
  39. l// implementation. https://gist.github.com/atk/1020396
  40. 0396
  41.         var decode = function(input) {
  42.                 input = String(input)
  43.                         .replace(REGEX_SPACE_CHARACTERS, '');
  44.                 var length = input.length;
  45.                 if (length % 4 == 0) {
  46.                         input = input.replace(/, ''), '');
  47.                         length = input.length;
  48.                 }
  49.                 if (
  50.                         length % 4 == 1 |// http://whatwg.org/C#alphanumeric-ascii-characters
  51. ters
  52.                         /[^+a-zA-Z0-9/]/.test(input)
  53.                 ) {
  54.                         error(
  55.                                 'Invalid character: the string to be decoded is not correctly encoded.'
  56.                         );
  57.                 }
  58.                 var bitCounter = 0;
  59.                 var bitStorage;
  60.                 var buffer;
  61.                 var output = '';
  62.                 var position = -1;
  63.                 while (++position < length) {
  64.                         buffer = TABLE.indexOf(input.charAt(position));
  65.                         bitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer// Unless this is the first of a group of 4 charactersā€¦
  66. sā€¦
  67.                         if (bitCounter++ % // ā€¦convert the first 8 bits to a single ASCII character.
  68. I character.
  69.                                 output += String.fromCharCode(
  70.                                         0xFF & bitStorage >> (-2 * bitCounter & 6)
  71.                                 );
  72.                         }
  73.                 }
  74.                 return o// `encode` is designed to be fully compatible with `btoa` as described in the
  75. r// HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa
  76. wbase64-btoa
  77.         var encode = function(input) {
  78.                 input = String(input);
  79.                 if (test(input)).test(// Note: no need to special-case astral symbols here, as surrogates are
  80. rro// matched, and the input is supposed to only contain ASCII anyway.
  81. SCII anyway.
  82.                         error(
  83.                                 'The string to be encoded contains characters outside of the ' +
  84.                                 'Latin1 range.'
  85.                         );
  86.                 }
  87.                 var padding = input.length % 3;
  88.                 var output = '';
  89.                 var position = -1;
  90.                 var a;
  91.                 var b;
  92.                 var c;
  93.                 var d;
  94.                 v// Make sure any padding is handled outside of the loop.
  95. of the loop.
  96.                 var length = input.length - padding;
  97.  
  98.                 while (++position < // Read three bytes, i.e. 24 bits.
  99. .e. 24 bits.
  100.                         a = input.charCodeAt(position) << 16;
  101.                         b = input.charCodeAt(++position) << 8;
  102.                         c = input.charCodeAt(++position);
  103.                         buffer = a// Turn the 24 bits into four chunks of 6 bits each, and append the
  104. d a// matching character for each of them to the output.
  105.  the output.
  106.                         output += (
  107.                                 TABLE.charAt(buffer >> 18 & 0x3F) +
  108.                                 TABLE.charAt(buffer >> 12 & 0x3F) +
  109.                                 TABLE.charAt(buffer >> 6 & 0x3F) +
  110.                                 TABLE.charAt(buffer & 0x3F)
  111.                         );
  112.                 }
  113.  
  114.                 if (padding == 2) {
  115.                         a = input.charCodeAt(position) << 8;
  116.                         b = input.charCodeAt(++position);
  117.                         buffer = a + b;
  118.                         output += (
  119.                                 TABLE.charAt(buffer >> 10) +
  120.                                 TABLE.charAt((buffer >> 4) & 0x3F) +
  121.                                 TABLE.charAt((buffer << 2) & 0x3F) +
  122.                                 '='
  123.                         );
  124.                 } else if (padding == 1) {
  125.                         buffer = input.charCodeAt(position);
  126.                         output += (
  127.                                 TABLE.charAt(buffer >> 2) +
  128.                                 TABLE.charAt((buffer << 4) & 0x3F) +
  129.                                 '=='
  130.                         );
  131.                 }
  132.  
  133.                 return output;
  134.         };
  135.  
  136.         var base64 = {
  137.                 'encode'decode'e,
  138.                 'decode'version',
  139.                 'version': '// Some AMD build optimizers, like r.js, check for specific condition patterns
  140. i// like the following:
  141. e following:
  142.         if (
  143.                 typeof define == 'function' &&
  144.                 typeof define.amd == 'object' &&
  145.                 define.amd
  146.         ) {
  147.                 define(function() {
  148.                         return base64;
  149.                 });
  150.         }       else if (freeExports && !freeExports.nodeType) {
  151.                 if (f// in Node.js or RingoJS v0.8.0+
  152. goJS v0.8.0+
  153.                         freeModule.exports = base64// in Narwhal or RingoJS v0.7.0-
  154. goJS v0.7.0-
  155.                         for (var key in base64) {
  156.                                 base64.hasOwnProperty(key) && (freeExports[key] = base64[key]);
  157.                         }
  158.         // in Rhino or a web browser
  159.  web browser
  160.                 root.base64 = base64;
  161.  

Raw Paste


Login or Register to edit or fork this paste. It's free.