1'use strict'; 2// Async base64 encoding and decoding 3// Bundles TextEncoderLite and b64.js for utf8 and typed array support. 4// See: https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding 5 6function asyncToBase64(value, encoding, onSuccess, onError) { 7 try { 8 switch (encoding) { 9 case 'ascii': 10 var result = window.btoa(value); 11 onSuccess(result); 12 break; 13 case 'utf8': 14 value = Base64Utils.encodeToUtf8Array(value); 15 // Fall through into byte array case. 16 case undefined: 17 var result = Base64Utils.uint8ToBase64(value); 18 onSuccess(result); 19 break; 20 default: 21 onError('Unknown encoding \'' + encoding + '\'.'); 22 } 23 } catch (error) { 24 if (error.name === 'InvalidCharacterError') { 25 onError('Couldn\'t convert non-latin1 characters to base64.'); 26 } else if (error.message) { 27 onError('Couldn\'t convert to base64 because ' + error.message + '.'); 28 } else { 29 onError('Couldn\'t convert to base64 because ' + error + '.'); 30 } 31 } 32} 33 34function asyncFromBase64(value, encoding, onSuccess, onError) { 35 try { 36 switch (encoding) { 37 case 'ascii': 38 var result = window.atob(Base64Utils.cleanupBase64(value)); 39 onSuccess(result); 40 break; 41 case 'utf8': 42 var utf8ByteArray = Base64Utils.b64ToByteArray(Base64Utils.cleanupBase64(value)); 43 var result = Base64Utils.decodeFromUtf8Array(utf8ByteArray); 44 onSuccess(result); 45 break; 46 default: 47 onError('Unknown encoding \'' + encoding + '\'.'); 48 } 49 } catch (error) { 50 if (error.name == 'InvalidCharacterError') { 51 onError('Couldn\'t convert because the base64 decodes to non-latin1 characters.'); 52 } else if (error.message) { 53 onError('Couldn\'t convert from base64 because ' + error.message + '.'); 54 } else { 55 onError('Couldn\'t convert from base64 because ' + error + '.'); 56 } 57 } 58} 59 60// Utility helper functions: 61// cleanupBase64, uint8ToBase64, b64ToByteArray, encodeToUtf8Array, decodeFromUtf8Array 62function Base64Utils() { 63} 64 65// Remove invalid characters and correct padding to accept more liberal input. 66// This is modified from https://github.com/feross/buffer/blob/master/index.js by feross et. al. 67Base64Utils.cleanupBase64 = function(dirty) { 68 // Trim whitespace. 69 dirty = dirty.trim ? dirty.trim() : dirty.replace(/^\s+|\s+$/g, ''); 70 71 // Remove anything outside our range. 72 var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; 73 dirty = dirty.replace(INVALID_BASE64_RE, ''); 74 75 if (dirty.length < 2) 76 return ''; 77 78 // Ensure padding is correct. 79 while (dirty.length % 4 !== 0) 80 dirty = dirty + '='; 81 82 return dirty; 83} 84 85// b64.js from https://github.com/beatgammit/base64-js by beatgammit, feross, and others. 86// Modified to only export uint8ToBase64 and b64ToByteArray. 87// 88// The MIT License (MIT) 89// 90// Copyright (c) 2014 91// 92// Permission is hereby granted, free of charge, to any person obtaining a copy 93// of this software and associated documentation files (the "Software"), to deal 94// in the Software without restriction, including without limitation the rights 95// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 96// copies of the Software, and to permit persons to whom the Software is 97// furnished to do so, subject to the following conditions: 98// 99// The above copyright notice and this permission notice shall be included in 100// all copies or substantial portions of the Software. 101// 102// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 103// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 104// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 105// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 106// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
107// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 108// THE SOFTWARE. 109;(function (exports) { 110 var i, code, lookup, revLookup, Arr; 111 112 function initIfNeeded() { 113 if (code !== undefined) 114 return; 115 116 code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; 117 lookup = []; 118 for (i = 0; i < code.length; i++) 119 lookup[i] = code[i]; 120 revLookup = []; 121 for (i = 0; i < code.length; ++i) 122 revLookup[code.charCodeAt(i)] = i; 123 revLookup['-'.charCodeAt(0)] = 62; 124 revLookup['_'.charCodeAt(0)] = 63; 125 Arr = (typeof Uint8Array !== 'undefined') ? Uint8Array : Array; 126 } 127 128 function decode(elt) { 129 var v = revLookup[elt.charCodeAt(0)]; 130 return v !== undefined ? v : -1; 131 } 132 133 function b64ToByteArray(b64) { 134 initIfNeeded(); 135 136 var i, j, l, tmp, placeHolders, arr; 137 138 if (b64.length % 4 > 0) 139 throw new Error('the length is not a multiple of 4'); 140 141 // the number of equal signs (place holders) 142 // if there are two placeholders, than the two characters before it 143 // represent one byte 144 // if there is only one, then the three characters before it represent 2 bytes 145 // this is just a cheap hack to not do indexOf twice 146 var len = b64.length; 147 placeHolders = b64.charAt(len - 2) === '=' ? 2 : b64.charAt(len - 1) === '=' ? 1 : 0; 148 149 // base64 is 4/3 + up to two characters of the original data 150 arr = new Arr(b64.length * 3 / 4 - placeHolders); 151 152 // if there are placeholders, only get up to the last complete 4 chars 153 l = placeHolders > 0 ? b64.length - 4 : b64.length; 154 155 var L = 0; 156 157 function push(v) { 158 arr[L++] = v; 159 } 160 161 for (i = 0, j = 0; i < l; i += 4, j += 3) { 162 tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)); 163 push((tmp & 0xFF0000) >> 16); 164 push((tmp & 0xFF00) >> 8); 165 push(tmp & 0xFF); 166 } 167 168 if (placeHolders === 2) { 169 tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4); 170 push(tmp & 0xFF); 171 } else if (placeHolders === 1) { 172 tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2); 173 push((tmp >> 8) & 0xFF); 174 push(tmp & 0xFF); 175 } 176 return arr; 177 } 178 179 function encode(num) { 180 return lookup[num]; 181 } 182 183 function tripletToBase64(num) { 184 return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F); 185 } 186 187 function encodeChunk(uint8, start, end) { 188 var temp; 189 var output = []; 190 for (var i = start; i < end; i += 3) { 191 temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); 192 output.push(tripletToBase64(temp)); 193 } 194 return output.join(''); 195 } 196 197 function uint8ToBase64(uint8) { 198 initIfNeeded(); 199 200 var i; 201 var extraBytes = uint8.length % 3; // if we have 1 byte left, pad 2 bytes 202 var output = ''; 203 var parts = []; 204 var temp, length; 205 var maxChunkLength = 16383; // must be multiple of 3 206 207 // go through the array every three bytes, we'll deal with trailing stuff later 208 for (i = 0, length = uint8.length - extraBytes; i < length; i += maxChunkLength) 209 parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > length ? length : (i + maxChunkLength))); 210 211 // pad the end with zeros, but make sure to not forget the extra bytes 212 switch (extraBytes) { 213 case 1: 214 temp = uint8[uint8.length - 1]; 215 output += encode(temp >> 2); 216 output += encode((temp << 4) & 0x3F); 217 output += '=='; 218 break; 219 case 2: 220 temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]); 221 output += encode(temp >> 10); 222 output += encode((temp >> 4) & 0x3F); 223 output += encode((temp << 2) & 0x3F); 224 output += '='; 225 break; 226 default: 227 break; 228 } 229 230 parts.push(output); 231 return parts.join(''); 232 } 233 234 exports.uint8ToBase64 = uint8ToBase64; 235 exports.b64ToByteArray = b64ToByteArray; 236}(Base64Utils)); 237 238// TextEncoderLite from https://github.com/coolaj86/TextEncoderLite/blob/master/index.js by
239// coolaj86, feross, and others. 240// Modified to only export encodeToUtf8Array and decodeFromUtf8Array. 241// 242// The MIT License (MIT) 243// 244// Copyright (c) Feross Aboukhadijeh, and other contributors. 245// 246// Permission is hereby granted, free of charge, to any person obtaining a copy 247// of this software and associated documentation files (the "Software"), to deal 248// in the Software without restriction, including without limitation the rights 249// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 250// copies of the Software, and to permit persons to whom the Software is 251// furnished to do so, subject to the following conditions: 252// 253// The above copyright notice and this permission notice shall be included in 254// all copies or substantial portions of the Software. 255// 256// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 257// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 258// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 259// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 260// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
261// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 262// THE SOFTWARE. 263;(function (exports) { 264 function utf8ToBytes(string, units) { 265 units = units || Infinity; 266 var codePoint; 267 var length = string.length; 268 var leadSurrogate = null; 269 var bytes = []; 270 271 for (var i = 0; i < length; i++) { 272 codePoint = string.charCodeAt(i); 273 274 // is surrogate component 275 if (codePoint > 0xD7FF && codePoint < 0xE000) { 276 // last char was a lead 277 if (leadSurrogate) { 278 // 2 leads in a row 279 if (codePoint < 0xDC00) { 280 if ((units -= 3) > -1) 281 bytes.push(0xEF, 0xBF, 0xBD); 282 leadSurrogate = codePoint; 283 continue; 284 } else { 285 // valid surrogate pair 286 codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000; 287 leadSurrogate = null; 288 } 289 } else { 290 // no lead yet 291 if (codePoint > 0xDBFF) { 292 // unexpected trail 293 if ((units -= 3) > -1) 294 bytes.push(0xEF, 0xBF, 0xBD); 295 continue; 296 } else if (i + 1 === length) { 297 // unpaired lead 298 if ((units -= 3) > -1) 299 bytes.push(0xEF, 0xBF, 0xBD); 300 continue; 301 } else { 302 // valid lead 303 leadSurrogate = codePoint; 304 continue; 305 } 306 } 307 } else if (leadSurrogate) { 308 // valid bmp char, but last char was a lead 309 if ((units -= 3) > -1) 310 bytes.push(0xEF, 0xBF, 0xBD); 311 leadSurrogate = null; 312 } 313 314 // encode utf8 315 if (codePoint < 0x80) { 316 if ((units -= 1) < 0) 317 break; 318 bytes.push(codePoint); 319 } else if (codePoint < 0x800) { 320 if ((units -= 2) < 0) 321 break; 322 bytes.push( 323 codePoint >> 0x6 | 0xC0, 324 codePoint & 0x3F | 0x80 325 ); 326 } else if (codePoint < 0x10000) { 327 if ((units -= 3) < 0) 328 break; 329 bytes.push( 330 codePoint >> 0xC | 0xE0, 331 codePoint >> 0x6 & 0x3F | 0x80, 332 codePoint & 0x3F | 0x80 333 ); 334 } else if (codePoint < 0x200000) { 335 if ((units -= 4) < 0) 336 break; 337 bytes.push( 338 codePoint >> 0x12 | 0xF0, 339 codePoint >> 0xC & 0x3F | 0x80, 340 codePoint >> 0x6 & 0x3F | 0x80, 341 codePoint & 0x3F | 0x80 342 ); 343 } else { 344 throw new Error('Invalid code point'); 345 } 346 } 347 return bytes; 348 } 349 350 function utf8Slice(buf, start, end) { 351 var res = ''; 352 var tmp = ''; 353 end = Math.min(buf.length, end || Infinity); 354 start = start || 0; 355 for (var i = start; i < end; i++) { 356 if (buf[i] <= 0x7F) { 357 res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i]); 358 tmp = ''; 359 } else { 360 tmp += '%' + buf[i].toString(16); 361 } 362 } 363 return res + decodeUtf8Char(tmp); 364 } 365 366 function decodeUtf8Char(str) { 367 try { 368 return decodeURIComponent(str); 369 } catch (err) { 370 return String.fromCharCode(0xFFFD); // UTF 8 invalid char 371 } 372 } 373 374 exports.encodeToUtf8Array = function(str) { 375 var result; 376 if ('undefined' === typeof Uint8Array) 377 result = utf8ToBytes(str); 378 else 379 result = new Uint8Array(utf8ToBytes(str)); 380 return result; 381 } 382 383 exports.decodeFromUtf8Array = function(bytes) { 384 return utf8Slice(bytes, 0, bytes.length); 385 } 386}(Base64Utils));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.