{ "scope": "Exact comment slices from every included dependency source, including copyright, permission and modification comments. All comments are retained without classifying each as a licence notice.", "sources": [ { "source": "node_modules/base64-js/index.js", "sourceSha256": "e9da5491f454b79f987264e5ce1ceb4d45b1b8893778f403d5e7bd112e0ee4d4", "comments": [ { "type": "line", "start": 410, "end": 471, "line": 17, "text": "// Support decoding URL-safe base64 strings, as Node.js does." }, { "type": "line", "start": 472, "end": 533, "line": 18, "text": "// See: https://en.wikipedia.org/wiki/Base64#URL_applications" }, { "type": "line", "start": 750, "end": 807, "line": 29, "text": "// Trim off extra bytes after placeholder bytes are found" }, { "type": "line", "start": 810, "end": 867, "line": 30, "text": "// See: https://github.com/beatgammit/base64-js/issues/42" }, { "type": "line", "start": 1056, "end": 1116, "line": 41, "text": "// base64 is 4/3 + up to two characters of the original data" }, { "type": "line", "start": 1632, "end": 1702, "line": 63, "text": "// if there are placeholders, only get up to the last complete 4 chars" }, { "type": "line", "start": 3106, "end": 3144, "line": 122, "text": "// if we have 1 byte left, pad 2 bytes" }, { "type": "line", "start": 3191, "end": 3215, "line": 124, "text": "// must be multiple of 3" }, { "type": "line", "start": 3219, "end": 3298, "line": 126, "text": "// go through the array every three bytes, we'll deal with trailing stuff later" }, { "type": "line", "start": 3491, "end": 3561, "line": 133, "text": "// pad the end with zeros, but make sure to not forget the extra bytes" } ] }, { "source": "node_modules/ieee754/index.js", "sourceSha256": "9698a7beea1cebe9050d67cb1016031223ee223f3670526b8520f652de4fca63", "comments": [] }, { "source": "node_modules/buffer/index.js", "sourceSha256": "e1e6c70a59201231644b8e8740a1eb06c0f8fc59193df533ba8d5e7721eb08c1", "comments": [ { "type": "block", "start": 0, "end": 133, "line": 1, "text": "/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */" }, { "type": "block", "start": 134, "end": 163, "line": 7, "text": "/* eslint-disable no-proto */" }, { "type": "block", "start": 553, "end": 1237, "line": 25, "text": "/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Print warning and recommend using `buffer` v4.x which has an Object\n * implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */" }, { "type": "line", "start": 1615, "end": 1661, "line": 50, "text": "// Can typed array instances can be augmented?" }, { "type": "line", "start": 2418, "end": 2462, "line": 82, "text": "// Return an augmented `Uint8Array` instance" }, { "type": "block", "start": 2561, "end": 2971, "line": 88, "text": "/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */" }, { "type": "line", "start": 3025, "end": 3040, "line": 99, "text": "// Common case." }, { "type": "line", "start": 3343, "end": 3377, "line": 111, "text": "// not used by this implementation" }, { "type": "block", "start": 4942, "end": 5179, "line": 167, "text": "/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/" }, { "type": "line", "start": 5289, "end": 5371, "line": 179, "text": "// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:" }, { "type": "line", "start": 5372, "end": 5416, "line": 180, "text": "// https://github.com/feross/buffer/pull/148" }, { "type": "line", "start": 5909, "end": 5965, "line": 198, "text": "// Only pay attention to encoding if it's a string. This" }, { "type": "line", "start": 5970, "end": 6025, "line": 199, "text": "// prevents accidentally sending in a number that would" }, { "type": "line", "start": 6030, "end": 6067, "line": 200, "text": "// be interpretted as a start offset." }, { "type": "block", "start": 6229, "end": 6313, "line": 208, "text": "/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/" }, { "type": "block", "start": 6511, "end": 6604, "line": 221, "text": "/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */" }, { "type": "block", "start": 6673, "end": 6768, "line": 227, "text": "/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */" }, { "type": "line", "start": 7224, "end": 7299, "line": 249, "text": "// Writing a hex string, for example, that contains invalid characters will" }, { "type": "line", "start": 7304, "end": 7378, "line": 250, "text": "// cause everything after the first invalid character to be ignored. (e.g." }, { "type": "line", "start": 7383, "end": 7419, "line": 251, "text": "// 'abxxcd' will be treated as 'ab')" }, { "type": "line", "start": 8248, "end": 8292, "line": 285, "text": "// Return an augmented `Uint8Array` instance" }, { "type": "line", "start": 8890, "end": 8962, "line": 317, "text": "// Note: cannot use `length < K_MAX_LENGTH` here because that fails when" }, { "type": "line", "start": 8965, "end": 9019, "line": 318, "text": "// length is NaN (which is otherwise coerced to zero.)" }, { "type": "line", "start": 9290, "end": 9319, "line": 327, "text": "// eslint-disable-line eqeqeq" }, { "type": "line", "start": 9488, "end": 9541, "line": 335, "text": "// so Buffer.isBuffer(Buffer.prototype) will be false" }, { "type": "line", "start": 11779, "end": 11815, "line": 435, "text": "// Use a for loop to avoid recursion" }, { "type": "line", "start": 12359, "end": 12373, "line": 457, "text": "// assume utf8" }, { "type": "line", "start": 12580, "end": 12656, "line": 469, "text": "// No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only" }, { "type": "line", "start": 12659, "end": 12688, "line": 470, "text": "// property of a typed array." }, { "type": "line", "start": 12692, "end": 12767, "line": 472, "text": "// This behaves neither like String nor Uint8Array in that we set start/end" }, { "type": "line", "start": 12770, "end": 12837, "line": 473, "text": "// to their upper/lower bounds if the value passed is out of range." }, { "type": "line", "start": 12840, "end": 12902, "line": 474, "text": "// undefined is handled specially as per ECMA-262 6th Edition," }, { "type": "line", "start": 12905, "end": 12971, "line": 475, "text": "// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization." }, { "type": "line", "start": 13034, "end": 13111, "line": 479, "text": "// Return early if start > this.length. Done here to prevent potential uint32" }, { "type": "line", "start": 13114, "end": 13137, "line": 480, "text": "// coercion fail below." }, { "type": "line", "start": 13300, "end": 13374, "line": 493, "text": "// Force coersion to uint32. This will also coerce falsey/NaN values to 0." }, { "type": "line", "start": 14199, "end": 14278, "line": 536, "text": "// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)" }, { "type": "line", "start": 14279, "end": 14355, "line": 537, "text": "// to detect a Buffer instance. It's not possible to use `instanceof Buffer`" }, { "type": "line", "start": 14356, "end": 14433, "line": 538, "text": "// reliably in a browserify context because there could be multiple different" }, { "type": "line", "start": 14434, "end": 14509, "line": 539, "text": "// copies of the 'buffer' package in use. This method works even for Buffer" }, { "type": "line", "start": 14510, "end": 14583, "line": 540, "text": "// instances that were created from another copy of the `buffer` package." }, { "type": "line", "start": 14584, "end": 14635, "line": 541, "text": "// See: https://github.com/feross/buffer/issues/154" }, { "type": "line", "start": 17806, "end": 17885, "line": 678, "text": "// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`," }, { "type": "line", "start": 17886, "end": 17954, "line": 679, "text": "// OR the last index of `val` in `buffer` at offset <= `byteOffset`." }, { "type": "line", "start": 17955, "end": 17957, "line": 680, "text": "//" }, { "type": "line", "start": 17958, "end": 17971, "line": 681, "text": "// Arguments:" }, { "type": "line", "start": 17972, "end": 18004, "line": 682, "text": "// - buffer - a Buffer to search" }, { "type": "line", "start": 18005, "end": 18043, "line": 683, "text": "// - val - a string, Buffer, or number" }, { "type": "line", "start": 18044, "end": 18113, "line": 684, "text": "// - byteOffset - an index into `buffer`; will be clamped to an int32" }, { "type": "line", "start": 18114, "end": 18179, "line": 685, "text": "// - encoding - an optional encoding, relevant is val is a string" }, { "type": "line", "start": 18180, "end": 18230, "line": 686, "text": "// - dir - true for indexOf, false for lastIndexOf" }, { "type": "line", "start": 18306, "end": 18336, "line": 688, "text": "// Empty buffer means no match" }, { "type": "line", "start": 18377, "end": 18400, "line": 691, "text": "// Normalize byteOffset" }, { "type": "line", "start": 18655, "end": 18675, "line": 700, "text": "// Coerce to Number." }, { "type": "line", "start": 18713, "end": 18789, "line": 702, "text": "// byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer" }, { "type": "line", "start": 18844, "end": 18918, "line": 706, "text": "// Normalize byteOffset: negative offsets start from the end of the buffer" }, { "type": "line", "start": 19166, "end": 19182, "line": 716, "text": "// Normalize val" }, { "type": "line", "start": 19260, "end": 19325, "line": 721, "text": "// Finally, search either indexOf (if dir is true) or lastIndexOf" }, { "type": "line", "start": 19360, "end": 19421, "line": 723, "text": "// Special case: looking for empty string/buffer always fails" }, { "type": "line", "start": 19597, "end": 19631, "line": 729, "text": "// Search for a byte value [0-255]" }, { "type": "line", "start": 23090, "end": 23113, "line": 857, "text": "// Buffer#write(string)" }, { "type": "line", "start": 23208, "end": 23241, "line": 862, "text": "// Buffer#write(string, encoding)" }, { "type": "line", "start": 23373, "end": 23426, "line": 867, "text": "// Buffer#write(string, offset[, length][, encoding])" }, { "type": "line", "start": 24522, "end": 24581, "line": 910, "text": "// Warning: maxLength not taken into account in base64Write" }, { "type": "line", "start": 27131, "end": 27183, "line": 997, "text": "// we did not generate a valid codePoint so insert a" }, { "type": "line", "start": 27190, "end": 27242, "line": 998, "text": "// replacement char (U+FFFD) and advance only 1 byte" }, { "type": "line", "start": 27338, "end": 27379, "line": 1002, "text": "// encode to utf16 (surrogate pair dance)" }, { "type": "line", "start": 27603, "end": 27675, "line": 1015, "text": "// Based on http://stackoverflow.com/a/22747272/680742, the browser with" }, { "type": "line", "start": 27676, "end": 27725, "line": 1016, "text": "// the lowest limit is Chrome, with 0x10000 args." }, { "type": "line", "start": 27726, "end": 27763, "line": 1017, "text": "// We go 1 magnitude less, for safety" }, { "type": "line", "start": 27969, "end": 27991, "line": 1023, "text": "// avoid extra slice()" }, { "type": "line", "start": 27999, "end": 28055, "line": 1026, "text": "// Decode in chunks to avoid \"call stack size exceeded\"." }, { "type": "line", "start": 29526, "end": 29570, "line": 1102, "text": "// Return an augmented `Uint8Array` instance" }, { "type": "block", "start": 29641, "end": 29717, "line": 1108, "text": "/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */" }, { "type": "line", "start": 41674, "end": 41750, "line": 1515, "text": "// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)" }, { "type": "line", "start": 42120, "end": 42147, "line": 1524, "text": "// Copy 0 bytes; we're done" }, { "type": "line", "start": 42238, "end": 42263, "line": 1528, "text": "// Fatal error conditions" }, { "type": "line", "start": 42497, "end": 42511, "line": 1535, "text": "// Are we oob?" }, { "type": "line", "start": 42768, "end": 42817, "line": 1544, "text": "// Use built-in when available, missing from IE11" }, { "type": "line", "start": 42943, "end": 42970, "line": 1547, "text": "// descending copy from end" }, { "type": "line", "start": 43204, "end": 43213, "line": 1562, "text": "// Usage:" }, { "type": "line", "start": 43214, "end": 43256, "line": 1563, "text": "// buffer.fill(number[, offset[, end]])" }, { "type": "line", "start": 43257, "end": 43299, "line": 1564, "text": "// buffer.fill(buffer[, offset[, end]])" }, { "type": "line", "start": 43300, "end": 43354, "line": 1565, "text": "// buffer.fill(string[, offset[, end]][, encoding])" }, { "type": "line", "start": 43425, "end": 43448, "line": 1567, "text": "// Handle string cases:" }, { "type": "line", "start": 44094, "end": 44165, "line": 1587, "text": "// Fast path: If `val` fits into a single byte, use that numeric value." }, { "type": "line", "start": 44329, "end": 44398, "line": 1597, "text": "// Invalid ranges are not set to a default, so can range check early." }, { "type": "line", "start": 45105, "end": 45124, "line": 1633, "text": "// HELPER FUNCTIONS" }, { "type": "line", "start": 45125, "end": 45144, "line": 1634, "text": "// ================" }, { "type": "line", "start": 45222, "end": 45277, "line": 1639, "text": "// Node takes equal signs as end of the Base64 encoding" }, { "type": "line", "start": 45306, "end": 45394, "line": 1641, "text": "// Node strips out invalid characters like \\n and \\t from the string, base64-js does not" }, { "type": "line", "start": 45447, "end": 45493, "line": 1643, "text": "// Node converts strings with length < 2 to ''" }, { "type": "line", "start": 45528, "end": 45615, "line": 1645, "text": "// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not" }, { "type": "line", "start": 45925, "end": 45950, "line": 1662, "text": "// is surrogate component" }, { "type": "line", "start": 46009, "end": 46032, "line": 1664, "text": "// last char was a lead" }, { "type": "line", "start": 46069, "end": 46083, "line": 1666, "text": "// no lead yet" }, { "type": "line", "start": 46128, "end": 46147, "line": 1668, "text": "// unexpected trail" }, { "type": "line", "start": 46278, "end": 46294, "line": 1672, "text": "// unpaired lead" }, { "type": "line", "start": 46395, "end": 46408, "line": 1677, "text": "// valid lead" }, { "type": "line", "start": 46476, "end": 46495, "line": 1683, "text": "// 2 leads in a row" }, { "type": "line", "start": 46654, "end": 46677, "line": 1690, "text": "// valid surrogate pair" }, { "type": "line", "start": 46796, "end": 46839, "line": 1693, "text": "// valid bmp char, but last char was a lead" }, { "type": "line", "start": 46935, "end": 46949, "line": 1699, "text": "// encode utf8" }, { "type": "line", "start": 47831, "end": 47885, "line": 1735, "text": "// Node's code seems to be doing this and not & 0x7F.." }, { "type": "line", "start": 48515, "end": 48598, "line": 1769, "text": "// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass" }, { "type": "line", "start": 48599, "end": 48668, "line": 1770, "text": "// the `instanceof` check but they should be treated as of that type." }, { "type": "line", "start": 48669, "end": 48720, "line": 1771, "text": "// See: https://github.com/feross/buffer/issues/166" }, { "type": "line", "start": 48941, "end": 48960, "line": 1778, "text": "// For IE11 support" }, { "type": "line", "start": 48982, "end": 49020, "line": 1779, "text": "// eslint-disable-line no-self-compare" }, { "type": "line", "start": 49024, "end": 49068, "line": 1782, "text": "// Create lookup table for `toString('hex')`" }, { "type": "line", "start": 49069, "end": 49120, "line": 1783, "text": "// See: https://github.com/feross/buffer/issues/219" } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/events.js", "sourceSha256": "8e8b80b8cb009cd76d0b8d750151ad08f0abf27cc265c47a7b172f00a3507475", "comments": [ { "type": "line", "start": 28, "end": 102, "line": 5, "text": "// This constructor is used to store event handlers. Instantiating this is" }, { "type": "line", "start": 103, "end": 181, "line": 6, "text": "// faster than explicitly calling `Object.create(null)` to get a \"clean\" empty" }, { "type": "line", "start": 182, "end": 214, "line": 7, "text": "// object (tested with v8 v4.9)." }, { "type": "line", "start": 404, "end": 420, "line": 17, "text": "// nodejs oddity" }, { "type": "line", "start": 421, "end": 476, "line": 18, "text": "// require('events') === require('events').EventEmitter" }, { "type": "line", "start": 693, "end": 771, "line": 27, "text": "// By default EventEmitters will print a warning if more than 10 listeners are" }, { "type": "line", "start": 772, "end": 846, "line": 28, "text": "// added to it. This is a useful default which helps finding memory leaks." }, { "type": "line", "start": 981, "end": 1032, "line": 34, "text": "// if there is an active domain, then attach to it." }, { "type": "line", "start": 1351, "end": 1426, "line": 48, "text": "// Obviously not all Emitters should be limited to 10. This function allows" }, { "type": "line", "start": 1427, "end": 1478, "line": 49, "text": "// that to be increased. Set to zero for unlimited." }, { "type": "line", "start": 1970, "end": 2043, "line": 67, "text": "// These standalone emit* functions are used to optimize calling of event" }, { "type": "line", "start": 2044, "end": 2123, "line": 68, "text": "// handlers for fast cases because emit() itself often has a variable number of" }, { "type": "line", "start": 2124, "end": 2204, "line": 69, "text": "// arguments and can be deoptimized because of that. These functions always have" }, { "type": "line", "start": 2205, "end": 2281, "line": 70, "text": "// the same number of arguments and thus do not get deoptimized, so the code" }, { "type": "line", "start": 2282, "end": 2316, "line": 71, "text": "// inside them can execute faster." }, { "type": "line", "start": 3934, "end": 3986, "line": 137, "text": "// If there is no 'error' event listener then throw." }, { "type": "line", "start": 4297, "end": 4323, "line": 148, "text": "// Unhandled 'error' event" }, { "type": "line", "start": 4343, "end": 4392, "line": 150, "text": "// At least give some kind of context to the user" }, { "type": "line", "start": 4696, "end": 4709, "line": 166, "text": "// fast cases" }, { "type": "line", "start": 5045, "end": 5054, "line": 179, "text": "// slower" }, { "type": "line", "start": 5620, "end": 5689, "line": 206, "text": "// To avoid recursion in the case that type === \"newListener\"! Before" }, { "type": "line", "start": 5694, "end": 5750, "line": 207, "text": "// adding it to the listeners, first emit \"newListener\"." }, { "type": "line", "start": 5896, "end": 5969, "line": 212, "text": "// Re-assign `events` because a newListener handler could have caused the" }, { "type": "line", "start": 5976, "end": 6022, "line": 213, "text": "// this._events to be assigned to a new object" }, { "type": "line", "start": 6117, "end": 6189, "line": 220, "text": "// Optimize the case of one listener. Don't need the extra array object." }, { "type": "line", "start": 6316, "end": 6370, "line": 225, "text": "// Adding the second element, need to change to array." }, { "type": "line", "start": 6519, "end": 6565, "line": 229, "text": "// If we've already got an array, just append." }, { "type": "line", "start": 6690, "end": 6716, "line": 237, "text": "// Check for listener leak" }, { "type": "line", "start": 8529, "end": 8591, "line": 298, "text": "// emits a 'removeListener' event iff the listener was removed" }, { "type": "line", "start": 10348, "end": 10400, "line": 364, "text": "// not listening for removeListener, no need to emit" }, { "type": "line", "start": 10772, "end": 10826, "line": 378, "text": "// emit removeListener for all listeners on all events" }, { "type": "line", "start": 11399, "end": 11412, "line": 397, "text": "// LIFO order" }, { "type": "line", "start": 12620, "end": 12684, "line": 455, "text": "// About 1.5x faster than the two-arg version of Array#splice()." } ] }, { "source": "node_modules/rollup-plugin-node-globals/src/global.js", "sourceSha256": "2ef256204281fb0502555c0dc77afaf8b17287f045f665e1a8083a11ec90a8c1", "comments": [] }, { "source": "node_modules/process-es6/browser.js", "sourceSha256": "7274c714eb5831588c5469239700438065d467a25f2e7e2d6cb09ad375aecea1", "comments": [ { "type": "line", "start": 0, "end": 36, "line": 1, "text": "// shim for using process in browser" }, { "type": "line", "start": 37, "end": 118, "line": 2, "text": "// based off https://github.com/defunctzombie/node-process/blob/master/browser.js" }, { "type": "line", "start": 642, "end": 681, "line": 21, "text": "//normal enviroments in sane situations" }, { "type": "line", "start": 727, "end": 783, "line": 24, "text": "// if setTimeout wasn't available but was latter defined" }, { "type": "line", "start": 968, "end": 1038, "line": 30, "text": "// when when somebody has screwed with setTimeout but no I.E. maddness" }, { "type": "line", "start": 1122, "end": 1236, "line": 34, "text": "// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally" }, { "type": "line", "start": 1325, "end": 1486, "line": 37, "text": "// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error" }, { "type": "line", "start": 1653, "end": 1692, "line": 46, "text": "//normal enviroments in sane situations" }, { "type": "line", "start": 1740, "end": 1798, "line": 49, "text": "// if clearTimeout wasn't available but was latter defined" }, { "type": "line", "start": 1998, "end": 2068, "line": 55, "text": "// when when somebody has screwed with setTimeout but no I.E. maddness" }, { "type": "line", "start": 2155, "end": 2270, "line": 59, "text": "// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally" }, { "type": "line", "start": 2362, "end": 2524, "line": 62, "text": "// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error." }, { "type": "line", "start": 2537, "end": 2613, "line": 63, "text": "// Some versions of I.E. have different rules for clearTimeout vs setTimeout" }, { "type": "line", "start": 3906, "end": 3937, "line": 126, "text": "// v8 likes predictible objects" }, { "type": "line", "start": 4246, "end": 4284, "line": 139, "text": "// empty string to avoid regexp issues" }, { "type": "line", "start": 4835, "end": 4913, "line": 164, "text": "// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js" }, { "type": "line", "start": 5165, "end": 5195, "line": 174, "text": "// generate timestamp or delta" }, { "type": "line", "start": 5196, "end": 5260, "line": 175, "text": "// see http://nodejs.org/api/process.html#process_process_hrtime" } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/inherits.js", "sourceSha256": "edfbb12fadf6c5a5ddb8236c4a64042ee9690729bc1910a4818b2abc744e228b", "comments": [ { "type": "line", "start": 111, "end": 164, "line": 5, "text": "// implementation from standard node.js 'util' module" } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/util.js", "sourceSha256": "2b5589efcad9b8ab8ecedc8482084b29973b2bdaac37e4bf6325a381cdca56a2", "comments": [ { "type": "line", "start": 0, "end": 54, "line": 1, "text": "// Copyright Joyent, Inc. and other Node contributors." }, { "type": "line", "start": 55, "end": 57, "line": 2, "text": "//" }, { "type": "line", "start": 58, "end": 132, "line": 3, "text": "// Permission is hereby granted, free of charge, to any person obtaining a" }, { "type": "line", "start": 133, "end": 197, "line": 4, "text": "// copy of this software and associated documentation files (the" }, { "type": "line", "start": 198, "end": 268, "line": 5, "text": "// \"Software\"), to deal in the Software without restriction, including" }, { "type": "line", "start": 269, "end": 339, "line": 6, "text": "// without limitation the rights to use, copy, modify, merge, publish," }, { "type": "line", "start": 340, "end": 416, "line": 7, "text": "// distribute, sublicense, and/or sell copies of the Software, and to permit" }, { "type": "line", "start": 417, "end": 486, "line": 8, "text": "// persons to whom the Software is furnished to do so, subject to the" }, { "type": "line", "start": 487, "end": 511, "line": 9, "text": "// following conditions:" }, { "type": "line", "start": 512, "end": 514, "line": 10, "text": "//" }, { "type": "line", "start": 515, "end": 589, "line": 11, "text": "// The above copyright notice and this permission notice shall be included" }, { "type": "line", "start": 590, "end": 647, "line": 12, "text": "// in all copies or substantial portions of the Software." }, { "type": "line", "start": 648, "end": 650, "line": 13, "text": "//" }, { "type": "line", "start": 651, "end": 725, "line": 14, "text": "// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS" }, { "type": "line", "start": 726, "end": 787, "line": 15, "text": "// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF" }, { "type": "line", "start": 788, "end": 864, "line": 16, "text": "// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN" }, { "type": "line", "start": 865, "end": 940, "line": 17, "text": "// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM," }, { "type": "line", "start": 941, "end": 1013, "line": 18, "text": "// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR" }, { "type": "line", "start": 1014, "end": 1090, "line": 19, "text": "// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE" }, { "type": "line", "start": 1091, "end": 1132, "line": 20, "text": "// USE OR OTHER DEALINGS IN THE SOFTWARE." }, { "type": "line", "start": 2048, "end": 2089, "line": 62, "text": "// Mark that a method should not be used." }, { "type": "line", "start": 2090, "end": 2149, "line": 63, "text": "// Returns a modified function which warns once by default." }, { "type": "line", "start": 2150, "end": 2200, "line": 64, "text": "// If --no-deprecation is set, then it is a no-op." }, { "type": "line", "start": 2240, "end": 2302, "line": 66, "text": "// Allow for deprecating things in the process of starting up." }, { "type": "block", "start": 3358, "end": 3602, "line": 117, "text": "/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */" }, { "type": "block", "start": 3603, "end": 3646, "line": 124, "text": "/* legacy: obj, showHidden, depth, colors*/" }, { "type": "line", "start": 3686, "end": 3704, "line": 126, "text": "// default options" }, { "type": "line", "start": 3768, "end": 3780, "line": 131, "text": "// legacy..." }, { "type": "line", "start": 3921, "end": 3933, "line": 135, "text": "// legacy..." }, { "type": "line", "start": 3986, "end": 4012, "line": 138, "text": "// got an \"options\" object" }, { "type": "line", "start": 4043, "end": 4065, "line": 141, "text": "// set default options" }, { "type": "line", "start": 4381, "end": 4438, "line": 150, "text": "// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics" }, { "type": "line", "start": 4747, "end": 4789, "line": 167, "text": "// Don't use 'blue' not visible on cmd.exe" }, { "type": "line", "start": 4960, "end": 4996, "line": 176, "text": "// \"name\": intentionally not styling" }, { "type": "line", "start": 5517, "end": 5572, "line": 210, "text": "// Provide a hook for user-specified inspect functions." }, { "type": "line", "start": 5575, "end": 5638, "line": 211, "text": "// Check that value is an object with an inspect function on it" }, { "type": "line", "start": 5722, "end": 5785, "line": 215, "text": "// Filter out the util module, it's inspect function is special" }, { "type": "line", "start": 5827, "end": 5893, "line": 217, "text": "// Also filter out any prototype objects using the circular check." }, { "type": "line", "start": 6117, "end": 6158, "line": 226, "text": "// Primitive types cannot have properties" }, { "type": "line", "start": 6254, "end": 6288, "line": 232, "text": "// Look up the keys of the object." }, { "type": "line", "start": 6439, "end": 6485, "line": 240, "text": "// IE doesn't make error fields non-enumerable" }, { "type": "line", "start": 6488, "end": 6556, "line": 241, "text": "// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx" }, { "type": "line", "start": 6695, "end": 6756, "line": 247, "text": "// Some type of object without properties can be shortcutted." }, { "type": "line", "start": 7272, "end": 7309, "line": 266, "text": "// Make Array say that they are Array" }, { "type": "line", "start": 7384, "end": 7429, "line": 272, "text": "// Make functions say that they are functions" }, { "type": "line", "start": 7548, "end": 7589, "line": 278, "text": "// Make RegExps say that they are RegExps" }, { "type": "line", "start": 7678, "end": 7726, "line": 283, "text": "// Make dates with properties first say the date" }, { "type": "line", "start": 7814, "end": 7860, "line": 288, "text": "// Make error with message first say the error" }, { "type": "line", "start": 9115, "end": 9180, "line": 335, "text": "// For some reason typeof null is \"object\", so special case here." }, { "type": "line", "start": 12007, "end": 12082, "line": 446, "text": "// NOTE: These type checking functions intentionally don't use `instanceof`" }, { "type": "line", "start": 12083, "end": 12155, "line": 447, "text": "// because it is fragile and can be easily faked with `Object.create()`." }, { "type": "line", "start": 13365, "end": 13378, "line": 506, "text": "// ES6 symbol" }, { "type": "line", "start": 13765, "end": 13783, "line": 527, "text": "// 26 Feb 16:19:34" }, { "type": "line", "start": 14009, "end": 14079, "line": 537, "text": "// log is just a thin wrapper to console.log that prepends a timestamp" }, { "type": "block", "start": 14178, "end": 14792, "line": 543, "text": "/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n * prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */" }, { "type": "line", "start": 14888, "end": 14931, "line": 560, "text": "// Don't do anything if add isn't an object" } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/buffer-list.js", "sourceSha256": "c3e65fc88e34c4768931f029c2c4a1e7f4809e41d16cb3807844f0e9a321377d", "comments": [] }, { "source": "node_modules/string_decoder/index.js", "sourceSha256": "80a2189c98a61ea4987ce6635df8c8685054aa274c672df4bb1cff023b06fb74", "comments": [ { "type": "line", "start": 0, "end": 54, "line": 1, "text": "// Copyright Joyent, Inc. and other Node contributors." }, { "type": "line", "start": 55, "end": 57, "line": 2, "text": "//" }, { "type": "line", "start": 58, "end": 132, "line": 3, "text": "// Permission is hereby granted, free of charge, to any person obtaining a" }, { "type": "line", "start": 133, "end": 197, "line": 4, "text": "// copy of this software and associated documentation files (the" }, { "type": "line", "start": 198, "end": 268, "line": 5, "text": "// \"Software\"), to deal in the Software without restriction, including" }, { "type": "line", "start": 269, "end": 339, "line": 6, "text": "// without limitation the rights to use, copy, modify, merge, publish," }, { "type": "line", "start": 340, "end": 416, "line": 7, "text": "// distribute, sublicense, and/or sell copies of the Software, and to permit" }, { "type": "line", "start": 417, "end": 486, "line": 8, "text": "// persons to whom the Software is furnished to do so, subject to the" }, { "type": "line", "start": 487, "end": 511, "line": 9, "text": "// following conditions:" }, { "type": "line", "start": 512, "end": 514, "line": 10, "text": "//" }, { "type": "line", "start": 515, "end": 589, "line": 11, "text": "// The above copyright notice and this permission notice shall be included" }, { "type": "line", "start": 590, "end": 647, "line": 12, "text": "// in all copies or substantial portions of the Software." }, { "type": "line", "start": 648, "end": 650, "line": 13, "text": "//" }, { "type": "line", "start": 651, "end": 725, "line": 14, "text": "// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS" }, { "type": "line", "start": 726, "end": 787, "line": 15, "text": "// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF" }, { "type": "line", "start": 788, "end": 864, "line": 16, "text": "// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN" }, { "type": "line", "start": 865, "end": 940, "line": 17, "text": "// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM," }, { "type": "line", "start": 941, "end": 1013, "line": 18, "text": "// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR" }, { "type": "line", "start": 1014, "end": 1090, "line": 19, "text": "// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE" }, { "type": "line", "start": 1091, "end": 1132, "line": 20, "text": "// USE OR OTHER DEALINGS IN THE SOFTWARE." }, { "type": "line", "start": 1667, "end": 1743, "line": 39, "text": "// StringDecoder provides an interface for efficiently splitting a series of" }, { "type": "line", "start": 1744, "end": 1816, "line": 40, "text": "// buffers into a series of JS strings without breaking apart multi-byte" }, { "type": "line", "start": 1817, "end": 1880, "line": 41, "text": "// characters. CESU-8 is handled as part of the UTF-8 encoding." }, { "type": "line", "start": 1881, "end": 1883, "line": 42, "text": "//" }, { "type": "line", "start": 1884, "end": 1962, "line": 43, "text": "// @TODO Handling all encodings inside a single object makes it very difficult" }, { "type": "line", "start": 1963, "end": 2032, "line": 44, "text": "// to reason about this code, so it should be split up in the future." }, { "type": "line", "start": 2033, "end": 2112, "line": 45, "text": "// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code" }, { "type": "line", "start": 2113, "end": 2141, "line": 46, "text": "// points as used by CESU-8." }, { "type": "line", "start": 2359, "end": 2413, "line": 52, "text": "// CESU-8 represents each of Surrogate Pair by 3-bytes" }, { "type": "line", "start": 2500, "end": 2554, "line": 57, "text": "// UTF-16 represents each of Surrogate Pair by 2-bytes" }, { "type": "line", "start": 2684, "end": 2745, "line": 62, "text": "// Base-64 stores 3 bytes in 4 chars, and pads the remainder." }, { "type": "line", "start": 2922, "end": 2993, "line": 71, "text": "// Enough space to store all bytes of a single character. UTF-8 needs 4" }, { "type": "line", "start": 2996, "end": 3061, "line": 72, "text": "// bytes, but CESU-8 may require up to 6 (3 bytes per surrogate)." }, { "type": "line", "start": 3099, "end": 3175, "line": 74, "text": "// Number of bytes received for the current incomplete multi-byte character." }, { "type": "line", "start": 3203, "end": 3279, "line": 76, "text": "// Number of bytes expected for the current incomplete multi-byte character." }, { "type": "line", "start": 3308, "end": 3377, "line": 81, "text": "// write decodes the given buffer and returns it as JS string that is" }, { "type": "line", "start": 3378, "end": 3453, "line": 82, "text": "// guaranteed to not contain any partial multi-byte characters. Any partial" }, { "type": "line", "start": 3454, "end": 3525, "line": 83, "text": "// character found at the end of the buffer is buffered up, and will be" }, { "type": "line", "start": 3526, "end": 3588, "line": 84, "text": "// returned when calling write again with the remaining bytes." }, { "type": "line", "start": 3589, "end": 3591, "line": 85, "text": "//" }, { "type": "line", "start": 3592, "end": 3663, "line": 86, "text": "// Note: Converting a Buffer containing an orphan surrogate to a String" }, { "type": "line", "start": 3664, "end": 3741, "line": 87, "text": "// currently works, but converting a String to a Buffer (via `new Buffer`, or" }, { "type": "line", "start": 3742, "end": 3810, "line": 88, "text": "// Buffer#write) will replace incomplete surrogates with the unicode" }, { "type": "line", "start": 3811, "end": 3885, "line": 89, "text": "// replacement character. See https://codereview.chromium.org/121173009/ ." }, { "type": "line", "start": 3959, "end": 4024, "line": 92, "text": "// if our last write ended with an incomplete multibyte character" }, { "type": "line", "start": 4057, "end": 4133, "line": 94, "text": "// determine how many remaining bytes this buffer has to offer for this char" }, { "type": "line", "start": 4285, "end": 4324, "line": 99, "text": "// add the new bytes to the char buffer" }, { "type": "line", "start": 4482, "end": 4541, "line": 104, "text": "// still not enough chars in this buffer? wait for more ..." }, { "type": "line", "start": 4570, "end": 4636, "line": 108, "text": "// remove bytes belonging to the current character from the buffer" }, { "type": "line", "start": 4695, "end": 4730, "line": 111, "text": "// get the character that was split" }, { "type": "line", "start": 4817, "end": 4887, "line": 114, "text": "// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character" }, { "type": "line", "start": 5136, "end": 5200, "line": 123, "text": "// if there are no more bytes in this buffer, just emit our char" }, { "type": "line", "start": 5278, "end": 5324, "line": 130, "text": "// determine and set charLength / charReceived" }, { "type": "line", "start": 5419, "end": 5466, "line": 135, "text": "// buffer the incomplete character bytes we got" }, { "type": "line", "start": 5709, "end": 5779, "line": 144, "text": "// CESU-8: lead surrogate (D800-DBFF) is also the incomplete character" }, { "type": "line", "start": 6074, "end": 6101, "line": 154, "text": "// or just emit the charStr" }, { "type": "line", "start": 6124, "end": 6203, "line": 158, "text": "// detectIncompleteChar determines if there is an incomplete UTF-8 character at" }, { "type": "line", "start": 6204, "end": 6278, "line": 159, "text": "// the end of the given buffer. If so, it sets this.charLength to the byte" }, { "type": "line", "start": 6279, "end": 6354, "line": 160, "text": "// length that character, and sets this.charReceived to the number of bytes" }, { "type": "line", "start": 6355, "end": 6396, "line": 161, "text": "// that are available for this character." }, { "type": "line", "start": 6465, "end": 6535, "line": 163, "text": "// determine how many bytes we have to check at the end of this buffer" }, { "type": "line", "start": 6591, "end": 6658, "line": 166, "text": "// Figure out if one of the last i bytes of our buffer announces an" }, { "type": "line", "start": 6661, "end": 6680, "line": 167, "text": "// incomplete char." }, { "type": "line", "start": 6748, "end": 6801, "line": 171, "text": "// See http://en.wikipedia.org/wiki/UTF-8#Description" }, { "type": "line", "start": 6807, "end": 6818, "line": 173, "text": "// 110XXXXX" }, { "type": "line", "start": 6906, "end": 6917, "line": 179, "text": "// 1110XXXX" }, { "type": "line", "start": 7005, "end": 7016, "line": 185, "text": "// 11110XXX" } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/readable.js", "sourceSha256": "d1ce5bd11da7ca31137f7ce89934e9e9c855a5486e4973adddb7b8756dd563e1", "comments": [ { "type": "line", "start": 402, "end": 467, "line": 16, "text": "// Sadly this is not cacheable as some libraries bundle their own" }, { "type": "line", "start": 470, "end": 512, "line": 17, "text": "// event emitter implementation with them." }, { "type": "line", "start": 630, "end": 706, "line": 21, "text": "// This is a hack to make sure that our error handler is attached before any" }, { "type": "line", "start": 711, "end": 786, "line": 22, "text": "// userland ones. NEVER DO THIS. This is here only because this code needs" }, { "type": "line", "start": 791, "end": 864, "line": 23, "text": "// to continue to work with older versions of Node.js that do not include" }, { "type": "line", "start": 869, "end": 945, "line": 24, "text": "// the prependListener() method. The goal is to eventually remove this hack." }, { "type": "line", "start": 1355, "end": 1414, "line": 40, "text": "// object stream flag. Used to make read(n) ignore n and to" }, { "type": "line", "start": 1417, "end": 1473, "line": 41, "text": "// make all the buffer merging and length checks go away" }, { "type": "line", "start": 1619, "end": 1684, "line": 46, "text": "// the point at which it stops calling _read() to fill the buffer" }, { "type": "line", "start": 1687, "end": 1758, "line": 47, "text": "// Note: 0 is a valid value, means \"don't call _read preemptively ever\"" }, { "type": "line", "start": 1910, "end": 1926, "line": 52, "text": "// cast to ints." }, { "type": "line", "start": 1976, "end": 2053, "line": 55, "text": "// A linked list is used to store data chunks instead of an array because the" }, { "type": "line", "start": 2056, "end": 2121, "line": 56, "text": "// linked list can remove elements from the beginning faster than" }, { "type": "line", "start": 2124, "end": 2140, "line": 57, "text": "// array.shift()" }, { "type": "line", "start": 2337, "end": 2406, "line": 67, "text": "// a flag to be able to tell if the onwrite cb is called immediately," }, { "type": "line", "start": 2409, "end": 2474, "line": 68, "text": "// or on a later tick. We set this to true at first, because any" }, { "type": "line", "start": 2477, "end": 2545, "line": 69, "text": "// actions that shouldn't happen until \"later\" should generally also" }, { "type": "line", "start": 2548, "end": 2590, "line": 70, "text": "// not happen before the first write call." }, { "type": "line", "start": 2614, "end": 2667, "line": 73, "text": "// whenever we return null, then we set a flag to say" }, { "type": "line", "start": 2670, "end": 2721, "line": 74, "text": "// that we're awaiting a 'readable' event emission." }, { "type": "line", "start": 2852, "end": 2922, "line": 80, "text": "// Crypto is kind of old and crusty. Historically, its default string" }, { "type": "line", "start": 2925, "end": 2986, "line": 81, "text": "// encoding is 'binary' so we have to make this configurable." }, { "type": "line", "start": 2989, "end": 3044, "line": 82, "text": "// Everything else in the universe uses 'utf8', though." }, { "type": "line", "start": 3108, "end": 3172, "line": 85, "text": "// when piping, we only care about 'readable' events that happen" }, { "type": "line", "start": 3175, "end": 3237, "line": 86, "text": "// after read()ing all the bytes and not getting any pushback." }, { "type": "line", "start": 3264, "end": 3332, "line": 89, "text": "// the number of writers that are awaiting a drain event in .pipe()s" }, { "type": "line", "start": 3359, "end": 3405, "line": 92, "text": "// if true, a maybeReadMore has been scheduled" }, { "type": "line", "start": 3797, "end": 3806, "line": 109, "text": "// legacy" }, { "type": "line", "start": 3943, "end": 3994, "line": 117, "text": "// Manually shove something into the read() buffer." }, { "type": "line", "start": 3995, "end": 4058, "line": 118, "text": "// This returns true if the highWaterMark has not been hit yet," }, { "type": "line", "start": 4059, "end": 4120, "line": 119, "text": "// similar to how Writable.write() returns true if you should" }, { "type": "line", "start": 4121, "end": 4142, "line": 120, "text": "// write() some more." }, { "type": "line", "start": 4523, "end": 4585, "line": 135, "text": "// Unshift should *always* be something directly out of read()" }, { "type": "line", "start": 5646, "end": 5718, "line": 168, "text": "// Don't add to the buffer if we've decoded to an empty string chunk and" }, { "type": "line", "start": 5725, "end": 5752, "line": 169, "text": "// we're not in object mode" }, { "type": "line", "start": 5783, "end": 5824, "line": 171, "text": "// if we want the data now, just emit it." }, { "type": "line", "start": 5982, "end": 6008, "line": 176, "text": "// update the buffer info." }, { "type": "line", "start": 6368, "end": 6430, "line": 193, "text": "// if it's past the high water mark, we can push in some more." }, { "type": "line", "start": 6431, "end": 6481, "line": 194, "text": "// Also, if we have no data yet, we can stand some" }, { "type": "line", "start": 6482, "end": 6539, "line": 195, "text": "// more bytes. This is to work around cases where hwm=0," }, { "type": "line", "start": 6540, "end": 6593, "line": 196, "text": "// such as the repl. Also, if the push() triggered a" }, { "type": "line", "start": 6594, "end": 6660, "line": 197, "text": "// readable event, and the user called read(largeNumber) such that" }, { "type": "line", "start": 6661, "end": 6729, "line": 198, "text": "// needReadable was set, then we ought to push more, so that another" }, { "type": "line", "start": 6730, "end": 6768, "line": 199, "text": "// 'readable' event will be triggered." }, { "type": "line", "start": 6910, "end": 6937, "line": 204, "text": "// backwards compatibility." }, { "type": "line", "start": 7101, "end": 7129, "line": 211, "text": "// Don't raise the hwm > 8MB" }, { "type": "line", "start": 7246, "end": 7321, "line": 217, "text": "// Get the next highest power of 2 to prevent increasing hwm excessively in" }, { "type": "line", "start": 7326, "end": 7341, "line": 218, "text": "// tiny amounts" }, { "type": "line", "start": 7470, "end": 7547, "line": 230, "text": "// This function is designed to be inlinable, so please take care when making" }, { "type": "line", "start": 7548, "end": 7580, "line": 231, "text": "// changes to the function body." }, { "type": "line", "start": 7732, "end": 7765, "line": 236, "text": "// Only flow one buffer at a time" }, { "type": "line", "start": 7874, "end": 7943, "line": 239, "text": "// If we're asking for more than the current hwm, then raise the hwm." }, { "type": "line", "start": 8062, "end": 8082, "line": 242, "text": "// Don't have enough" }, { "type": "line", "start": 8180, "end": 8248, "line": 250, "text": "// you can override either this method, or the async _read(n) below." }, { "type": "line", "start": 8435, "end": 8496, "line": 259, "text": "// if we're doing read(0) to trigger a readable event, but we" }, { "type": "line", "start": 8499, "end": 8563, "line": 260, "text": "// already have a bunch of data in the buffer, then just trigger" }, { "type": "line", "start": 8566, "end": 8602, "line": 261, "text": "// the 'readable' event and move on." }, { "type": "line", "start": 8900, "end": 8958, "line": 270, "text": "// if we've ended, and we're now clear, then finish it up." }, { "type": "line", "start": 9062, "end": 9114, "line": 276, "text": "// All the actual chunk generation logic needs to be" }, { "type": "line", "start": 9117, "end": 9177, "line": 277, "text": "// *below* the call to _read. The reason is that in certain" }, { "type": "line", "start": 9180, "end": 9241, "line": 278, "text": "// synthetic stream cases, such as passthrough streams, _read" }, { "type": "line", "start": 9244, "end": 9305, "line": 279, "text": "// may be a completely synchronous operation which may change" }, { "type": "line", "start": 9308, "end": 9367, "line": 280, "text": "// the state of the read buffer, providing enough data when" }, { "type": "line", "start": 9370, "end": 9403, "line": 281, "text": "// before there was *not* enough." }, { "type": "line", "start": 9406, "end": 9408, "line": 282, "text": "//" }, { "type": "line", "start": 9411, "end": 9432, "line": 283, "text": "// So, the steps are:" }, { "type": "line", "start": 9435, "end": 9496, "line": 284, "text": "// 1. Figure out what the state of things will be after we do" }, { "type": "line", "start": 9499, "end": 9525, "line": 285, "text": "// a read from the buffer." }, { "type": "line", "start": 9528, "end": 9530, "line": 286, "text": "//" }, { "type": "line", "start": 9533, "end": 9601, "line": 287, "text": "// 2. If that resulting state will trigger a _read, then call _read." }, { "type": "line", "start": 9604, "end": 9670, "line": 288, "text": "// Note that this may be asynchronous, or synchronous. Yes, it is" }, { "type": "line", "start": 9673, "end": 9739, "line": 289, "text": "// deeply ugly to write APIs this way, but that still doesn't mean" }, { "type": "line", "start": 9742, "end": 9809, "line": 290, "text": "// that the Readable class should behave improperly, as streams are" }, { "type": "line", "start": 9812, "end": 9850, "line": 291, "text": "// designed to be sync/async agnostic." }, { "type": "line", "start": 9853, "end": 9922, "line": 292, "text": "// Take note if the _read call is sync or async (ie, if the read call" }, { "type": "line", "start": 9925, "end": 9995, "line": 293, "text": "// has returned yet), so that we know whether or not it's safe to emit" }, { "type": "line", "start": 9998, "end": 10016, "line": 294, "text": "// 'readable' etc." }, { "type": "line", "start": 10019, "end": 10021, "line": 295, "text": "//" }, { "type": "line", "start": 10024, "end": 10094, "line": 296, "text": "// 3. Actually pull the requested chunks out of the buffer and return." }, { "type": "line", "start": 10098, "end": 10162, "line": 298, "text": "// if we need a readable event, then we need to do some reading." }, { "type": "line", "start": 10235, "end": 10307, "line": 302, "text": "// if we currently have less than the highWaterMark, then also read some" }, { "type": "line", "start": 10453, "end": 10524, "line": 308, "text": "// however, if we've ended, then there's no point, and if we're already" }, { "type": "line", "start": 10527, "end": 10561, "line": 309, "text": "// reading, then it's unnecessary." }, { "type": "line", "start": 10757, "end": 10825, "line": 317, "text": "// if the length is currently zero, then we *need* a readable event." }, { "type": "line", "start": 10885, "end": 10913, "line": 319, "text": "// call internal read method" }, { "type": "line", "start": 10979, "end": 11047, "line": 322, "text": "// If _read pushed data synchronously, then `reading` will be false," }, { "type": "line", "start": 11052, "end": 11122, "line": 323, "text": "// and we need to re-evaluate how much data we can return to the user." }, { "type": "line", "start": 11387, "end": 11444, "line": 338, "text": "// If we have nothing in the buffer, then we want to know" }, { "type": "line", "start": 11449, "end": 11501, "line": 339, "text": "// as soon as we *do* get something into the buffer." }, { "type": "line", "start": 11556, "end": 11626, "line": 342, "text": "// If we tried to read() past the EOF, then emit end on the next tick." }, { "type": "line", "start": 12291, "end": 12345, "line": 370, "text": "// emit 'readable' now to make sure it gets picked up." }, { "type": "line", "start": 12373, "end": 12445, "line": 374, "text": "// Don't emit readable right away in sync mode, because this can trigger" }, { "type": "line", "start": 12446, "end": 12515, "line": 375, "text": "// another read() call => stack overflow. This way, it might trigger" }, { "type": "line", "start": 12516, "end": 12571, "line": 376, "text": "// a nextTick recursion warning, but that's not so bad." }, { "type": "line", "start": 12971, "end": 13039, "line": 393, "text": "// at this point, the user has presumably seen the 'readable' event," }, { "type": "line", "start": 13040, "end": 13107, "line": 394, "text": "// and called read() to consume some data. that may have triggered" }, { "type": "line", "start": 13108, "end": 13173, "line": 395, "text": "// in turn another _read(n) call, in which case reading = true if" }, { "type": "line", "start": 13174, "end": 13194, "line": 396, "text": "// it's in progress." }, { "type": "line", "start": 13195, "end": 13260, "line": 397, "text": "// However, if we're not ended, or reading, and the length < hwm," }, { "type": "line", "start": 13261, "end": 13317, "line": 398, "text": "// then go ahead and try to read some more preemptively." }, { "type": "line", "start": 13725, "end": 13763, "line": 412, "text": "// didn't get any data, stop spinning." }, { "type": "line", "start": 13837, "end": 13910, "line": 418, "text": "// abstract method. to be overridden in specific implementation classes." }, { "type": "line", "start": 13911, "end": 13961, "line": 419, "text": "// call cb(er, data) where data is <= n in length." }, { "type": "line", "start": 13962, "end": 14031, "line": 420, "text": "// for virtual (non-string, non-buffer) streams, \"length\" is somewhat" }, { "type": "line", "start": 14032, "end": 14078, "line": 421, "text": "// arbitrary, and perhaps not very meaningful." }, { "type": "line", "start": 14949, "end": 15007, "line": 462, "text": "// when the dest drains, it reduces the awaitDrain counter" }, { "type": "line", "start": 15010, "end": 15070, "line": 463, "text": "// on the source. This would be more elegant with a .once()" }, { "type": "line", "start": 15073, "end": 15132, "line": 464, "text": "// handler in flow(), but adding and removing repeatedly is" }, { "type": "line", "start": 15135, "end": 15147, "line": 465, "text": "// too slow." }, { "type": "line", "start": 15286, "end": 15335, "line": 472, "text": "// cleanup event handlers once the pipe is broken" }, { "type": "line", "start": 15701, "end": 15756, "line": 484, "text": "// if the reader is waiting for a drain event from this" }, { "type": "line", "start": 15761, "end": 15818, "line": 485, "text": "// specific writer, then it would cause it to never start" }, { "type": "line", "start": 15823, "end": 15840, "line": 486, "text": "// flowing again." }, { "type": "line", "start": 15845, "end": 15906, "line": 487, "text": "// So, if this is awaiting a drain, then we just call it now." }, { "type": "line", "start": 15911, "end": 15972, "line": 488, "text": "// If we don't know, then assume that we are waiting for one." }, { "type": "line", "start": 16076, "end": 16153, "line": 492, "text": "// If the user pushes more data while we're writing to dest then we'll end up" }, { "type": "line", "start": 16156, "end": 16233, "line": 493, "text": "// in ondata again. However, we only want to increase awaitDrain once because" }, { "type": "line", "start": 16236, "end": 16301, "line": 494, "text": "// dest will only emit one 'drain' event for the multiple writes." }, { "type": "line", "start": 16304, "end": 16353, "line": 495, "text": "// => Introduce a guard on increasing awaitDrain." }, { "type": "line", "start": 16584, "end": 16644, "line": 503, "text": "// If the user unpiped during `dest.write()`, it is possible" }, { "type": "line", "start": 16651, "end": 16710, "line": 504, "text": "// to get stuck in a permanently paused state if that write" }, { "type": "line", "start": 16717, "end": 16740, "line": 505, "text": "// also returned false." }, { "type": "line", "start": 16747, "end": 16804, "line": 506, "text": "// => Check whether `dest` is still a piping destination." }, { "type": "line", "start": 17136, "end": 17190, "line": 516, "text": "// if the dest has an error, then stop piping into it." }, { "type": "line", "start": 17193, "end": 17251, "line": 517, "text": "// however, don't suppress the throwing behavior for this." }, { "type": "line", "start": 17435, "end": 17499, "line": 525, "text": "// Make sure our error handler is attached before userland ones." }, { "type": "line", "start": 17546, "end": 17608, "line": 528, "text": "// Both close and finish should trigger unpipe, but only once." }, { "type": "line", "start": 17940, "end": 17981, "line": 546, "text": "// tell the dest that it's being piped to" }, { "type": "line", "start": 18011, "end": 18063, "line": 549, "text": "// start the flow if it hasn't been started already." }, { "type": "line", "start": 18542, "end": 18591, "line": 573, "text": "// if we're not piping anywhere, then do nothing." }, { "type": "line", "start": 18638, "end": 18681, "line": 576, "text": "// just one destination. most common case." }, { "type": "line", "start": 18718, "end": 18763, "line": 578, "text": "// passed in one, but it's not the right one." }, { "type": "line", "start": 18856, "end": 18871, "line": 583, "text": "// got a match." }, { "type": "line", "start": 19014, "end": 19055, "line": 591, "text": "// slow case. multiple pipe destinations." }, { "type": "line", "start": 19076, "end": 19090, "line": 594, "text": "// remove all." }, { "type": "line", "start": 19332, "end": 19361, "line": 606, "text": "// try to find the right one." }, { "type": "line", "start": 19593, "end": 19636, "line": 619, "text": "// set up data events if they are asked for" }, { "type": "line", "start": 19637, "end": 19690, "line": 620, "text": "// Ensure readable listeners eventually get something" }, { "type": "line", "start": 19821, "end": 19884, "line": 625, "text": "// Start flowing on next tick if stream isn't explicitly paused" }, { "type": "line", "start": 20492, "end": 20562, "line": 649, "text": "// pause() and resume() are remnants of the legacy readable stream API" }, { "type": "line", "start": 20563, "end": 20615, "line": 650, "text": "// If the user uses them, then switch into old mode." }, { "type": "line", "start": 21631, "end": 21684, "line": 697, "text": "// wrap an old-style stream as the async data source." }, { "type": "line", "start": 21685, "end": 21740, "line": 698, "text": "// This is *not* part of the readable stream interface." }, { "type": "line", "start": 21741, "end": 21786, "line": 699, "text": "// It is an ugly unfortunate mess of history." }, { "type": "line", "start": 22265, "end": 22310, "line": 719, "text": "// don't skip over falsy values in objectMode" }, { "type": "line", "start": 22559, "end": 22590, "line": 729, "text": "// proxy all the other methods." }, { "type": "line", "start": 22593, "end": 22641, "line": 730, "text": "// important when wrapping filters and duplexes." }, { "type": "line", "start": 22895, "end": 22929, "line": 741, "text": "// proxy certain important events." }, { "type": "line", "start": 23083, "end": 23144, "line": 747, "text": "// when we try to consume some more bytes, simply unpause the" }, { "type": "line", "start": 23147, "end": 23168, "line": 748, "text": "// underlying stream." }, { "type": "line", "start": 23324, "end": 23361, "line": 760, "text": "// exposed for testing purposes only." }, { "type": "line", "start": 23394, "end": 23440, "line": 763, "text": "// Pluck off n bytes from an array of buffers." }, { "type": "line", "start": 23441, "end": 23506, "line": 764, "text": "// Length is the combined lengths of all the buffers in the list." }, { "type": "line", "start": 23507, "end": 23584, "line": 765, "text": "// This function is designed to be inlinable, so please take care when making" }, { "type": "line", "start": 23585, "end": 23617, "line": 766, "text": "// changes to the function body." }, { "type": "line", "start": 23650, "end": 23669, "line": 768, "text": "// nothing buffered" }, { "type": "line", "start": 23812, "end": 23845, "line": 773, "text": "// read it all, truncate the list" }, { "type": "line", "start": 24049, "end": 24069, "line": 777, "text": "// read part of list" }, { "type": "line", "start": 24151, "end": 24221, "line": 784, "text": "// Extracts only enough buffered data to satisfy the amount requested." }, { "type": "line", "start": 24222, "end": 24299, "line": 785, "text": "// This function is designed to be inlinable, so please take care when making" }, { "type": "line", "start": 24300, "end": 24332, "line": 786, "text": "// changes to the function body." }, { "type": "line", "start": 24431, "end": 24475, "line": 790, "text": "// slice is the same for buffers and strings" }, { "type": "line", "start": 24608, "end": 24641, "line": 794, "text": "// first chunk is a perfect match" }, { "type": "line", "start": 24681, "end": 24717, "line": 797, "text": "// result spans more than one buffer" }, { "type": "line", "start": 24819, "end": 24892, "line": 803, "text": "// Copies a specified amount of characters from the list of buffered data" }, { "type": "line", "start": 24893, "end": 24903, "line": 804, "text": "// chunks." }, { "type": "line", "start": 24904, "end": 24981, "line": 805, "text": "// This function is designed to be inlinable, so please take care when making" }, { "type": "line", "start": 24982, "end": 25014, "line": 806, "text": "// changes to the function body." }, { "type": "line", "start": 25584, "end": 25660, "line": 833, "text": "// Copies a specified amount of bytes from the list of buffered data chunks." }, { "type": "line", "start": 25661, "end": 25738, "line": 834, "text": "// This function is designed to be inlinable, so please take care when making" }, { "type": "line", "start": 25739, "end": 25771, "line": 835, "text": "// changes to the function body." }, { "type": "line", "start": 26419, "end": 26483, "line": 866, "text": "// If we get here before consuming all the bytes, then that is a" }, { "type": "line", "start": 26486, "end": 26523, "line": 867, "text": "// bug in node. Should never happen." }, { "type": "line", "start": 26756, "end": 26801, "line": 877, "text": "// Check that we didn't get one last unshift." } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/writable.js", "sourceSha256": "386bb13e956409a722776709e0289cb2c8bc809d5cee9effda0c5def0ea526f7", "comments": [ { "type": "line", "start": 0, "end": 39, "line": 1, "text": "// A bit simpler than readable streams." }, { "type": "line", "start": 40, "end": 112, "line": 2, "text": "// Implement an async ._write(chunk, encoding, cb), and it'll handle all" }, { "type": "line", "start": 113, "end": 155, "line": 3, "text": "// the drain event emission and buffering." }, { "type": "line", "start": 839, "end": 899, "line": 31, "text": "// object stream flag to indicate whether or not this stream" }, { "type": "line", "start": 902, "end": 933, "line": 32, "text": "// contains buffers or objects." }, { "type": "line", "start": 1079, "end": 1131, "line": 37, "text": "// the point at which write() starts returning false" }, { "type": "line", "start": 1134, "end": 1199, "line": 38, "text": "// Note: 0 is a valid value, means that we always return false if" }, { "type": "line", "start": 1202, "end": 1260, "line": 39, "text": "// the entire buffer is not flushed immediately on write()" }, { "type": "line", "start": 1412, "end": 1428, "line": 44, "text": "// cast to ints." }, { "type": "line", "start": 1504, "end": 1536, "line": 48, "text": "// at the start of calling end()" }, { "type": "line", "start": 1562, "end": 1605, "line": 50, "text": "// when end() has been called, and returned" }, { "type": "line", "start": 1630, "end": 1657, "line": 52, "text": "// when 'finish' is emitted" }, { "type": "line", "start": 1686, "end": 1752, "line": 55, "text": "// should we decode strings into buffers before passing to _write?" }, { "type": "line", "start": 1755, "end": 1821, "line": 56, "text": "// this is here so that some node-core streams can optimize string" }, { "type": "line", "start": 1824, "end": 1853, "line": 57, "text": "// handling at a lower level." }, { "type": "line", "start": 1941, "end": 2011, "line": 61, "text": "// Crypto is kind of old and crusty. Historically, its default string" }, { "type": "line", "start": 2014, "end": 2075, "line": 62, "text": "// encoding is 'binary' so we have to make this configurable." }, { "type": "line", "start": 2078, "end": 2133, "line": 63, "text": "// Everything else in the universe uses 'utf8', though." }, { "type": "line", "start": 2197, "end": 2256, "line": 66, "text": "// not an actual buffer we keep track of, but a measurement" }, { "type": "line", "start": 2259, "end": 2320, "line": 67, "text": "// of how much we're waiting to get pushed to some underlying" }, { "type": "line", "start": 2323, "end": 2341, "line": 68, "text": "// socket or file." }, { "type": "line", "start": 2364, "end": 2417, "line": 71, "text": "// a flag to see when we're in the middle of a write." }, { "type": "line", "start": 2445, "end": 2506, "line": 74, "text": "// when true all writes will be buffered until .uncork() call" }, { "type": "line", "start": 2529, "end": 2598, "line": 77, "text": "// a flag to be able to tell if the onwrite cb is called immediately," }, { "type": "line", "start": 2601, "end": 2666, "line": 78, "text": "// or on a later tick. We set this to true at first, because any" }, { "type": "line", "start": 2669, "end": 2737, "line": 79, "text": "// actions that shouldn't happen until \"later\" should generally also" }, { "type": "line", "start": 2740, "end": 2782, "line": 80, "text": "// not happen before the first write call." }, { "type": "line", "start": 2806, "end": 2876, "line": 83, "text": "// a flag to know if we're processing previously buffered items, which" }, { "type": "line", "start": 2879, "end": 2947, "line": 84, "text": "// may call the _write() callback in the same tick, so that we don't" }, { "type": "line", "start": 2950, "end": 2995, "line": 85, "text": "// end up in an overlapped onwrite situation." }, { "type": "line", "start": 3032, "end": 3081, "line": 88, "text": "// the callback that's passed to _write(chunk,cb)" }, { "type": "line", "start": 3148, "end": 3214, "line": 93, "text": "// the callback that the user supplies to write(chunk,encoding,cb)" }, { "type": "line", "start": 3241, "end": 3299, "line": 96, "text": "// the amount that is being written when _write is called." }, { "type": "line", "start": 3391, "end": 3441, "line": 102, "text": "// number of pending user-supplied write callbacks" }, { "type": "line", "start": 3444, "end": 3492, "line": 103, "text": "// this must be 0 before 'finish' can be emitted" }, { "type": "line", "start": 3518, "end": 3585, "line": 106, "text": "// emit prefinish if the only thing we're waiting for is _write cbs" }, { "type": "line", "start": 3588, "end": 3641, "line": 107, "text": "// This is relevant for synchronous Transform streams" }, { "type": "line", "start": 3673, "end": 3744, "line": 110, "text": "// True if the error was already emitted and should not be thrown again" }, { "type": "line", "start": 3777, "end": 3803, "line": 113, "text": "// count buffered requests" }, { "type": "line", "start": 3840, "end": 3892, "line": 116, "text": "// allocate the first CorkedRequest, there is always" }, { "type": "line", "start": 3895, "end": 3956, "line": 117, "text": "// one allocated and free to use, and we maintain at most two" }, { "type": "line", "start": 4296, "end": 4355, "line": 134, "text": "// Writable ctor is applied to Duplexes, though they're not" }, { "type": "line", "start": 4358, "end": 4410, "line": 135, "text": "// instanceof Writable, they're instanceof Readable." }, { "type": "line", "start": 4567, "end": 4577, "line": 140, "text": "// legacy." }, { "type": "line", "start": 4807, "end": 4874, "line": 152, "text": "// Otherwise people can pipe Writable streams, which is just wrong." }, { "type": "line", "start": 5061, "end": 5129, "line": 159, "text": "// TODO: defer error events consistently everywhere, not just the cb" }, { "type": "line", "start": 5181, "end": 5253, "line": 164, "text": "// If we get something that is not a buffer, string, null, or undefined," }, { "type": "line", "start": 5254, "end": 5307, "line": 165, "text": "// and we're not in objectMode, then that's an error." }, { "type": "line", "start": 5308, "end": 5380, "line": 166, "text": "// Otherwise stream chunks are all considered to be of length=1, and the" }, { "type": "line", "start": 5381, "end": 5456, "line": 167, "text": "// watermarks determine how many objects to keep in the buffer, rather than" }, { "type": "line", "start": 5457, "end": 5489, "line": 168, "text": "// how many bytes or characters." }, { "type": "line", "start": 5578, "end": 5620, "line": 172, "text": "// Always throw error if a null is written" }, { "type": "line", "start": 5623, "end": 5665, "line": 173, "text": "// if we are not in object mode then throw" }, { "type": "line", "start": 5668, "end": 5715, "line": 174, "text": "// if it is not a buffer, string, or undefined." }, { "type": "line", "start": 7075, "end": 7120, "line": 226, "text": "// node::ParseEncoding() requires lower case." }, { "type": "line", "start": 7671, "end": 7728, "line": 240, "text": "// if we're already writing something, then just put this" }, { "type": "line", "start": 7729, "end": 7788, "line": 241, "text": "// in the queue, and wait our turn. Otherwise, call _write" }, { "type": "line", "start": 7789, "end": 7857, "line": 242, "text": "// If we return false, then we need a drain event, so set that flag." }, { "type": "line", "start": 8142, "end": 8211, "line": 252, "text": "// we must ensure that previous needDrain will not be reset to false." }, { "type": "line", "start": 9503, "end": 9565, "line": 303, "text": "// Check if we're actually ready to finish, but don't emit yet" }, { "type": "block", "start": 9758, "end": 9775, "line": 311, "text": "/**/" }, { "type": "block", "start": 9841, "end": 9859, "line": 313, "text": "/**/" }, { "type": "line", "start": 10096, "end": 10161, "line": 327, "text": "// Must force callback to be called on nextTick, so that we don't" }, { "type": "line", "start": 10162, "end": 10229, "line": 328, "text": "// emit 'drain' before the write() consumer gets the 'false' return" }, { "type": "line", "start": 10230, "end": 10286, "line": 329, "text": "// value, and has a chance to attach a 'drain' listener." }, { "type": "line", "start": 10435, "end": 10497, "line": 337, "text": "// if there's something in the buffer waiting, then process it" }, { "type": "line", "start": 10658, "end": 10704, "line": 343, "text": "// Fast case, write everything using _writev()" }, { "type": "line", "start": 11045, "end": 11113, "line": 358, "text": "// doWrite is almost always async, defer these to save a bit of time" }, { "type": "line", "start": 11118, "end": 11154, "line": 359, "text": "// as the hot path ends with doWrite" }, { "type": "line", "start": 11404, "end": 11441, "line": 369, "text": "// Slow case, write chunks one-by-one" }, { "type": "line", "start": 11710, "end": 11760, "line": 378, "text": "// if we didn't call the onwrite immediately, then" }, { "type": "line", "start": 11767, "end": 11814, "line": 379, "text": "// it means that we need to wait until it does." }, { "type": "line", "start": 11821, "end": 11876, "line": 380, "text": "// also, that means that the chunk and cb are currently" }, { "type": "line", "start": 11883, "end": 11940, "line": 381, "text": "// being processed, so move the buffer counter past them." }, { "type": "line", "start": 12657, "end": 12680, "line": 415, "text": "// .end() fully uncorks" }, { "type": "line", "start": 12751, "end": 12785, "line": 421, "text": "// ignore unnecessary end() calls." }, { "type": "line", "start": 13651, "end": 13690, "line": 460, "text": "// It seems a linked list but it is not" }, { "type": "line", "start": 13691, "end": 13739, "line": 461, "text": "// there will be only 2 of these for each stream" } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/duplex.js", "sourceSha256": "95cfd86bc948699947de296caeb4864bcf36933707f3f1d34d5c3b2c9c6a65bf", "comments": [ { "type": "line", "start": 829, "end": 857, "line": 32, "text": "// the no-half-open enforcer" }, { "type": "line", "start": 879, "end": 941, "line": 34, "text": "// if we allow half-open state, or if the writable side ended," }, { "type": "line", "start": 944, "end": 961, "line": 35, "text": "// then we're ok." }, { "type": "line", "start": 1028, "end": 1059, "line": 38, "text": "// no more data can be written." }, { "type": "line", "start": 1062, "end": 1110, "line": 39, "text": "// But allow more writes to happen in this tick." } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/transform.js", "sourceSha256": "bc0a1485dde4c16264b97281dfb31c6503fc314bc4226860c79b5579f9a10133", "comments": [ { "type": "line", "start": 0, "end": 64, "line": 1, "text": "// a transform stream is a readable/writable stream where you do" }, { "type": "line", "start": 65, "end": 127, "line": 2, "text": "// something with the data. Sometimes it's called a \"filter\"," }, { "type": "line", "start": 128, "end": 199, "line": 3, "text": "// but that's not a great name for it, since that implies a thing where" }, { "type": "line", "start": 200, "end": 270, "line": 4, "text": "// some bits pass through, and others are simply ignored. (That would" }, { "type": "line", "start": 271, "end": 320, "line": 5, "text": "// be a valid example of a transform, of course.)" }, { "type": "line", "start": 321, "end": 323, "line": 6, "text": "//" }, { "type": "line", "start": 324, "end": 388, "line": 7, "text": "// While the output is causally related to the input, it's not a" }, { "type": "line", "start": 389, "end": 458, "line": 8, "text": "// necessarily symmetric or synchronous transformation. For example," }, { "type": "line", "start": 459, "end": 525, "line": 9, "text": "// a zlib stream might take multiple plain-text writes(), and then" }, { "type": "line", "start": 526, "end": 584, "line": 10, "text": "// emit a single compressed chunk some time in the future." }, { "type": "line", "start": 585, "end": 587, "line": 11, "text": "//" }, { "type": "line", "start": 588, "end": 613, "line": 12, "text": "// Here's how this works:" }, { "type": "line", "start": 614, "end": 616, "line": 13, "text": "//" }, { "type": "line", "start": 617, "end": 689, "line": 14, "text": "// The Transform stream has all the aspects of the readable and writable" }, { "type": "line", "start": 690, "end": 760, "line": 15, "text": "// stream classes. When you write(chunk), that calls _write(chunk,cb)" }, { "type": "line", "start": 761, "end": 828, "line": 16, "text": "// internally, and returns false if there's a lot of pending writes" }, { "type": "line", "start": 829, "end": 893, "line": 17, "text": "// buffered up. When you call read(), that calls _read(n) until" }, { "type": "line", "start": 894, "end": 946, "line": 18, "text": "// there's enough pending readable data buffered up." }, { "type": "line", "start": 947, "end": 949, "line": 19, "text": "//" }, { "type": "line", "start": 950, "end": 1021, "line": 20, "text": "// In a transform stream, the written data is placed in a buffer. When" }, { "type": "line", "start": 1022, "end": 1090, "line": 21, "text": "// _read(n) is called, it transforms the queued up data, calling the" }, { "type": "line", "start": 1091, "end": 1160, "line": 22, "text": "// buffered _write cb's as it consumes chunks. If consuming a single" }, { "type": "line", "start": 1161, "end": 1232, "line": 23, "text": "// written chunk would result in multiple output chunks, then the first" }, { "type": "line", "start": 1233, "end": 1302, "line": 24, "text": "// outputted bit calls the readcb, and subsequent chunks just go into" }, { "type": "line", "start": 1303, "end": 1373, "line": 25, "text": "// the read buffer, and will cause it to emit 'readable' if necessary." }, { "type": "line", "start": 1374, "end": 1376, "line": 26, "text": "//" }, { "type": "line", "start": 1377, "end": 1447, "line": 27, "text": "// This way, back-pressure is actually determined by the reading side," }, { "type": "line", "start": 1448, "end": 1522, "line": 28, "text": "// since _read has to be called to start processing a new chunk. However," }, { "type": "line", "start": 1523, "end": 1596, "line": 29, "text": "// a pathological inflate type of transform can cause excessive buffering" }, { "type": "line", "start": 1597, "end": 1665, "line": 30, "text": "// here. For example, imagine a stream where every byte of input is" }, { "type": "line", "start": 1666, "end": 1736, "line": 31, "text": "// interpreted as an integer from 0-255, and then results in that many" }, { "type": "line", "start": 1737, "end": 1807, "line": 32, "text": "// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in" }, { "type": "line", "start": 1808, "end": 1880, "line": 33, "text": "// 1kb of data being output. In this case, you could write a very small" }, { "type": "line", "start": 1881, "end": 1951, "line": 34, "text": "// amount of input, and end up with a very large amount of output. In" }, { "type": "line", "start": 1952, "end": 2021, "line": 35, "text": "// such a pathological inflating mechanism, there'd be no way to tell" }, { "type": "line", "start": 2022, "end": 2090, "line": 36, "text": "// the system to stop doing the transform. A single 4MB write could" }, { "type": "line", "start": 2091, "end": 2132, "line": 37, "text": "// cause the system to run out of memory." }, { "type": "line", "start": 2133, "end": 2135, "line": 38, "text": "//" }, { "type": "line", "start": 2136, "end": 2209, "line": 39, "text": "// However, even in such a pathological case, only a single written chunk" }, { "type": "line", "start": 2210, "end": 2283, "line": 40, "text": "// would be consumed, and then the rest would wait (un-transformed) until" }, { "type": "line", "start": 2284, "end": 2347, "line": 41, "text": "// the results of the previous transformed chunk were consumed." }, { "type": "line", "start": 3424, "end": 3494, "line": 91, "text": "// when the writable side finishes, then flush out anything remaining." }, { "type": "line", "start": 3519, "end": 3585, "line": 94, "text": "// start out asking for a readable event once data is transformed." }, { "type": "line", "start": 3632, "end": 3698, "line": 97, "text": "// we have implemented the _read method, and done the other things" }, { "type": "line", "start": 3701, "end": 3765, "line": 98, "text": "// that Readable wants before the first _read call, so unset the" }, { "type": "line", "start": 3768, "end": 3787, "line": 99, "text": "// sync guard flag." }, { "type": "line", "start": 4343, "end": 4382, "line": 120, "text": "// This is the part where you do stuff!" }, { "type": "line", "start": 4383, "end": 4435, "line": 121, "text": "// override this function in implementation classes." }, { "type": "line", "start": 4436, "end": 4465, "line": 122, "text": "// 'chunk' is an input chunk." }, { "type": "line", "start": 4466, "end": 4468, "line": 123, "text": "//" }, { "type": "line", "start": 4469, "end": 4526, "line": 124, "text": "// Call `push(newChunk)` to pass along transformed output" }, { "type": "line", "start": 4527, "end": 4592, "line": 125, "text": "// to the readable side. You may call 'push' zero or more times." }, { "type": "line", "start": 4593, "end": 4595, "line": 126, "text": "//" }, { "type": "line", "start": 4596, "end": 4661, "line": 127, "text": "// Call `cb(err)` when you are done with this chunk. If you pass" }, { "type": "line", "start": 4662, "end": 4732, "line": 128, "text": "// an error, then that'll put the hurt on the whole operation. If you" }, { "type": "line", "start": 4733, "end": 4789, "line": 129, "text": "// never call cb(), then you'll never get another chunk." }, { "type": "line", "start": 5243, "end": 5284, "line": 145, "text": "// Doesn't matter what the args are here." }, { "type": "line", "start": 5285, "end": 5317, "line": 146, "text": "// _transform does all the work." }, { "type": "line", "start": 5318, "end": 5383, "line": 147, "text": "// That we got here means that the readable side wants more data." }, { "type": "line", "start": 5643, "end": 5707, "line": 155, "text": "// mark that we need a transform, so that any data that comes in" }, { "type": "line", "start": 5712, "end": 5763, "line": 156, "text": "// will get processed, now that we've asked for it." }, { "type": "line", "start": 5875, "end": 5933, "line": 164, "text": "// if there's nothing in the write buffer, then that means" }, { "type": "line", "start": 5936, "end": 5978, "line": 165, "text": "// that nothing more will ever be provided" } ] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/readable-stream/passthrough.js", "sourceSha256": "e3047dff25efd0f0059851c93887e9127d7ff038aad1b88ddbddb0f44e7dfc9f", "comments": [] }, { "source": "node_modules/rollup-plugin-node-builtins/src/es6/stream.js", "sourceSha256": "f8da30c880d8e59754c164ef9c06e6e851dcccf0e64f098ea28a587795c62405", "comments": [ { "type": "line", "start": 508, "end": 543, "line": 16, "text": "// Backwards-compat with node 0.4.x" }, { "type": "line", "start": 656, "end": 723, "line": 22, "text": "// old-style streams. Note that the pipe method (the only relevant" }, { "type": "line", "start": 724, "end": 783, "line": 23, "text": "// part of this class) is overridden in the Readable class." }, { "type": "line", "start": 1212, "end": 1282, "line": 50, "text": "// If the 'end' option is not supplied, dest.end() will be called when" }, { "type": "line", "start": 1285, "end": 1351, "line": 51, "text": "// source gets the 'end' or 'close' events. Only dest.end() once." }, { "type": "line", "start": 1735, "end": 1787, "line": 73, "text": "// don't leave dangling pipes when there are errors." }, { "type": "line", "start": 1893, "end": 1927, "line": 77, "text": "// Unhandled stream error in pipe." }, { "type": "line", "start": 2002, "end": 2052, "line": 84, "text": "// remove all the event listeners that were added." }, { "type": "line", "start": 2599, "end": 2646, "line": 108, "text": "// Allow for unix-like usage: A.pipe(B).pipe(C)" } ] }, { "source": "node_modules/safer-buffer/safer.js", "sourceSha256": "37f9716144105051ab302f6a0c30a52ff5de7269b9e1173ac22be798fc11ccad", "comments": [ { "type": "block", "start": 0, "end": 43, "line": 1, "text": "/* eslint-disable node/no-deprecated-api */" }, { "type": "line", "start": 1775, "end": 1851, "line": 63, "text": "// we can't determine kStringMaxLength in environments where process.binding" }, { "type": "line", "start": 1856, "end": 1894, "line": 64, "text": "// is unsupported, so let's not set it" } ] }, { "source": "node_modules/iconv-lite/lib/bom-handling.js", "sourceSha256": "c230d25d8e7fbb50960c634b636b71327c409e9a77e67fe9446b566bdcea362d", "comments": [ { "type": "line", "start": 442, "end": 522, "line": 25, "text": "//------------------------------------------------------------------------------" } ] }, { "source": "node_modules/iconv-lite/encodings/internal.js", "sourceSha256": "39d9dd0568708a23c5999fcd6c417ec64f35ecbecd37205f91c7c6b59d14d773", "comments": [ { "type": "line", "start": 60, "end": 97, "line": 4, "text": "// Export Node.js internal encodings." }, { "type": "line", "start": 122, "end": 134, "line": 7, "text": "// Encodings" }, { "type": "line", "start": 445, "end": 454, "line": 19, "text": "// Codec." }, { "type": "line", "start": 489, "end": 569, "line": 23, "text": "//------------------------------------------------------------------------------" }, { "type": "line", "start": 844, "end": 869, "line": 32, "text": "// Use utf8 for decoding." }, { "type": "line", "start": 924, "end": 981, "line": 35, "text": "// Add decoder for versions of Node not supporting CESU-8" }, { "type": "line", "start": 1287, "end": 1367, "line": 46, "text": "//------------------------------------------------------------------------------" }, { "type": "line", "start": 1369, "end": 1439, "line": 48, "text": "// We use node.js internal decoder. Its signature is the same as ours." }, { "type": "line", "start": 1536, "end": 1574, "line": 51, "text": "// Node v0.8 doesn't have this method." }, { "type": "line", "start": 1768, "end": 1848, "line": 62, "text": "//------------------------------------------------------------------------------" }, { "type": "line", "start": 1849, "end": 1877, "line": 63, "text": "// Encoder is mostly trivial" }, { "type": "line", "start": 2092, "end": 2172, "line": 77, "text": "//------------------------------------------------------------------------------" }, { "type": "line", "start": 2173, "end": 2225, "line": 78, "text": "// Except base64 encoder, which must keep its state." }, { "type": "line", "start": 2673, "end": 2753, "line": 98, "text": "//------------------------------------------------------------------------------" }, { "type": "line", "start": 2754, "end": 2788, "line": 99, "text": "// CESU-8 encoder is also special." }, { "type": "line", "start": 3045, "end": 3116, "line": 108, "text": "// Naive implementation, but it works because CESU-8 is especially easy" }, { "type": "line", "start": 3125, "end": 3189, "line": 109, "text": "// to convert from UTF-16 (which all JS strings are encoded in)." }, { "type": "line", "start": 3426, "end": 3477, "line": 116, "text": "// charCode will always be < 0x10000 in javascript." }, { "type": "line", "start": 3753, "end": 3833, "line": 128, "text": "//------------------------------------------------------------------------------" }, { "type": "line", "start": 3834, "end": 3884, "line": 129, "text": "// CESU-8 decoder is not implemented in Node v4.0+" }, { "type": "line", "start": 4324, "end": 4339, "line": 143, "text": "// Leading byte" }, { "type": "line", "start": 4373, "end": 4400, "line": 144, "text": "// Previous code is invalid" }, { "type": "line", "start": 4529, "end": 4548, "line": 149, "text": "// Single-byte code" }, { "type": "line", "start": 4643, "end": 4659, "line": 151, "text": "// Two-byte code" }, { "type": "line", "start": 4784, "end": 4802, "line": 154, "text": "// Three-byte code" }, { "type": "line", "start": 4907, "end": 4952, "line": 157, "text": "// Four or more are not supported for CESU-8." }, { "type": "line", "start": 5032, "end": 5052, "line": 160, "text": "// Continuation byte" }, { "type": "line", "start": 5086, "end": 5110, "line": 161, "text": "// We're waiting for it." }, { "type": "line", "start": 5264, "end": 5347, "line": 165, "text": "// Check for overlong encoding, but support Modified UTF-8 (encoding NULL as C0 80)" }, { "type": "line", "start": 5634, "end": 5660, "line": 171, "text": "// Actually add character." }, { "type": "line", "start": 5757, "end": 5788, "line": 174, "text": "// Unexpected continuation byte" } ] }, { "source": "node_modules/iconv-lite/encodings/utf16.js", "sourceSha256": "baf708be438edf0fef70a3e34619c6be94cd53d963acb9b2542419d5fc3bb8c8", "comments": [ { "type": "line", "start": 60, "end": 138, "line": 4, "text": "// Note: UTF16-LE (or UCS2) codec is Node.js native. See encodings/internal.js" }, { "type": "line", "start": 140, "end": 220, "line": 6, "text": "// == UTF16-BE codec. ==========================================================" }, { "type": "line", "start": 423, "end": 437, "line": 17, "text": "// -- Encoding" }, { "type": "line", "start": 739, "end": 753, "line": 34, "text": "// -- Decoding" }, { "type": "line", "start": 1381, "end": 1461, "line": 67, "text": "// == UTF-16 codec =============================================================" }, { "type": "line", "start": 1462, "end": 1558, "line": 68, "text": "// Decoder chooses automatically from UTF-16LE and UTF-16BE using BOM and space-based heuristic." }, { "type": "line", "start": 1559, "end": 1622, "line": 69, "text": "// Defaults to UTF-16LE, as it's prevalent and default in Node." }, { "type": "line", "start": 1623, "end": 1707, "line": 70, "text": "// http://en.wikipedia.org/wiki/UTF-16 and http://encoding.spec.whatwg.org/#utf-16le" }, { "type": "line", "start": 1708, "end": 1801, "line": 71, "text": "// Decoder default can be changed: iconv.decode(buf, 'utf16', {defaultEncoding: 'utf-16be'});" }, { "type": "line", "start": 1803, "end": 1890, "line": 73, "text": "// Encoder uses UTF-16LE and prepends BOM (which can be overridden with addBOM: false)." }, { "type": "line", "start": 2082, "end": 2111, "line": 84, "text": "// -- Encoding (pass-through)" }, { "type": "line", "start": 2481, "end": 2495, "line": 102, "text": "// -- Decoding" }, { "type": "line", "start": 2768, "end": 2821, "line": 115, "text": "// Codec is not chosen yet. Accumulate initial bytes." }, { "type": "line", "start": 2951, "end": 3007, "line": 119, "text": "// We need more bytes to use space heuristic (see below)" }, { "type": "line", "start": 3040, "end": 3085, "line": 122, "text": "// We have enough bytes -> detect endianness." }, { "type": "line", "start": 3950, "end": 3963, "line": 150, "text": "// Check BOM." }, { "type": "line", "start": 4010, "end": 4025, "line": 151, "text": "// UTF-16BE BOM" }, { "type": "line", "start": 4107, "end": 4122, "line": 153, "text": "// UTF-16LE BOM" }, { "type": "line", "start": 4180, "end": 4241, "line": 156, "text": "// No BOM found. Try to deduce encoding from initial content." }, { "type": "line", "start": 4254, "end": 4351, "line": 157, "text": "// Most of the time, the content has ASCII chars (U+00**), but the opposite (U+**00) is uncommon." }, { "type": "line", "start": 4364, "end": 4430, "line": 158, "text": "// So, we count ASCII as if it was LE or BE, and decide from that." }, { "type": "line", "start": 4483, "end": 4519, "line": 159, "text": "// Counts of chars in both positions" }, { "type": "line", "start": 4588, "end": 4610, "line": 160, "text": "// Len is always even." } ] }, { "source": "node_modules/iconv-lite/encodings/utf7.js", "sourceSha256": "c814ad268d19265ccafc9f7bba2e8dfcdd2afdea62698bb24b7284b3f2ea18a0", "comments": [ { "type": "line", "start": 60, "end": 124, "line": 4, "text": "// UTF-7 codec, according to https://tools.ietf.org/html/rfc2152" }, { "type": "line", "start": 125, "end": 224, "line": 5, "text": "// See also below a UTF-7-IMAP codec, according to http://tools.ietf.org/html/rfc3501#section-5.1.3" }, { "type": "line", "start": 284, "end": 310, "line": 8, "text": "// Alias UNICODE-1-1-UTF-7" }, { "type": "line", "start": 506, "end": 520, "line": 18, "text": "// -- Encoding" }, { "type": "line", "start": 705, "end": 729, "line": 27, "text": "// Naive implementation." }, { "type": "line", "start": 734, "end": 818, "line": 28, "text": "// Non-direct chars are encoded as \"+-\"; single \"+\" char is encoded as \"+-\"." }, { "type": "line", "start": 1108, "end": 1122, "line": 40, "text": "// -- Decoding" }, { "type": "line", "start": 1660, "end": 1727, "line": 62, "text": "// The decoder is more involved as we must handle chunks in stream." }, { "type": "line", "start": 1797, "end": 1821, "line": 65, "text": "// We're in direct mode." }, { "type": "line", "start": 1834, "end": 1865, "line": 66, "text": "// Write direct chars until '+'" }, { "type": "line", "start": 1976, "end": 1998, "line": 68, "text": "// Write direct chars." }, { "type": "line", "start": 2092, "end": 2112, "line": 72, "text": "// We decode base64." }, { "type": "line", "start": 2153, "end": 2169, "line": 73, "text": "// Base64 ended." }, { "type": "line", "start": 2226, "end": 2240, "line": 74, "text": "// \"+-\" -> \"+\"" }, { "type": "line", "start": 2526, "end": 2560, "line": 81, "text": "// Minus is absorbed after base64." }, { "type": "line", "start": 2797, "end": 2819, "line": 92, "text": "// Write direct chars." }, { "type": "line", "start": 2962, "end": 3012, "line": 96, "text": "// Minimal chunk: 2 quads -> 2x3 bytes -> 3 chars." }, { "type": "line", "start": 3063, "end": 3101, "line": 97, "text": "// The rest will be decoded in future." }, { "type": "line", "start": 3595, "end": 3615, "line": 120, "text": "// UTF-7-IMAP codec." }, { "type": "line", "start": 3616, "end": 3703, "line": 121, "text": "// RFC3501 Sec. 5.1.3 Modified UTF-7 (http://tools.ietf.org/html/rfc3501#section-5.1.3)" }, { "type": "line", "start": 3704, "end": 3719, "line": 122, "text": "// Differences:" }, { "type": "line", "start": 3720, "end": 3770, "line": 123, "text": "// * Base64 part is started by \"&\" instead of \"+\"" }, { "type": "line", "start": 3771, "end": 3827, "line": 124, "text": "// * Direct characters are 0x20-0x7E, except \"&\" (0x26)" }, { "type": "line", "start": 3828, "end": 3871, "line": 125, "text": "// * In Base64, \",\" is used instead of \"/\"" }, { "type": "line", "start": 3872, "end": 3933, "line": 126, "text": "// * Base64 must not be used to represent direct characters." }, { "type": "line", "start": 3934, "end": 4003, "line": 127, "text": "// * No implicit shift back from Base64 (should always end with '-')" }, { "type": "line", "start": 4004, "end": 4050, "line": 128, "text": "// * String must end in non-shifted position." }, { "type": "line", "start": 4051, "end": 4093, "line": 129, "text": "// * \"-&\" while in base64 is not allowed." }, { "type": "line", "start": 4349, "end": 4363, "line": 142, "text": "// -- Encoding" }, { "type": "line", "start": 4895, "end": 4922, "line": 159, "text": "// Direct character or '&'." }, { "type": "line", "start": 5240, "end": 5277, "line": 166, "text": "// Write '-', then go to direct mode." }, { "type": "line", "start": 5395, "end": 5420, "line": 171, "text": "// Write direct character" }, { "type": "line", "start": 5462, "end": 5482, "line": 173, "text": "// Ampersand -> '&-'" }, { "type": "line", "start": 5562, "end": 5585, "line": 177, "text": "// Non-direct character" }, { "type": "line", "start": 5656, "end": 5693, "line": 179, "text": "// Write '&', then go to base64 mode." }, { "type": "line", "start": 6634, "end": 6671, "line": 208, "text": "// Write '-', then go to direct mode." }, { "type": "line", "start": 6747, "end": 6761, "line": 216, "text": "// -- Decoding" }, { "type": "line", "start": 7138, "end": 7205, "line": 232, "text": "// The decoder is more involved as we must handle chunks in stream." }, { "type": "line", "start": 7210, "end": 7297, "line": 233, "text": "// It is forgiving, closer to standard UTF-7 (for example, '-' is optional at the end)." }, { "type": "line", "start": 7367, "end": 7391, "line": 236, "text": "// We're in direct mode." }, { "type": "line", "start": 7404, "end": 7435, "line": 237, "text": "// Write direct chars until '&'" }, { "type": "line", "start": 7545, "end": 7567, "line": 239, "text": "// Write direct chars." }, { "type": "line", "start": 7661, "end": 7681, "line": 243, "text": "// We decode base64." }, { "type": "line", "start": 7726, "end": 7742, "line": 244, "text": "// Base64 ended." }, { "type": "line", "start": 7800, "end": 7814, "line": 245, "text": "// \"&-\" -> \"&\"" }, { "type": "line", "start": 8119, "end": 8157, "line": 252, "text": "// Minus may be absorbed after base64." }, { "type": "line", "start": 8394, "end": 8416, "line": 263, "text": "// Write direct chars." }, { "type": "line", "start": 8578, "end": 8628, "line": 267, "text": "// Minimal chunk: 2 quads -> 2x3 bytes -> 3 chars." }, { "type": "line", "start": 8679, "end": 8717, "line": 268, "text": "// The rest will be decoded in future." } ] }, { "source": "node_modules/iconv-lite/encodings/sbcs-codec.js", "sourceSha256": "fb511c4c70a6cb0e2a06d03e67ca88dca9f4da6266b909c7338e453d2ecc9fdb", "comments": [ { "type": "line", "start": 60, "end": 150, "line": 4, "text": "// Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that" }, { "type": "line", "start": 151, "end": 219, "line": 5, "text": "// correspond to encoded bytes (if 128 - then lower half is ASCII). " }, { "type": "line", "start": 388, "end": 424, "line": 12, "text": "// Prepare char buffer for decoding." }, { "type": "line", "start": 951, "end": 970, "line": 25, "text": "// Encoding buffer." }, { "type": "line", "start": 1751, "end": 1829, "line": 59, "text": "// Strings are immutable in JS -> we use ucs2 buffer to speed up computations." } ] }, { "source": "node_modules/iconv-lite/encodings/sbcs-data.js", "sourceSha256": "3116c986bff5d0b3a0d9ee1700d97ac466965a7b30d353300d408b41622604c2", "comments": [ { "type": "line", "start": 15, "end": 92, "line": 3, "text": "// Manually added data to be used by sbcs codec in addition to generated one." }, { "type": "line", "start": 117, "end": 157, "line": 6, "text": "// Not supported by iconv, not sure why." }, { "type": "line", "start": 825, "end": 859, "line": 25, "text": "// Aliases of generated encodings." } ] }, { "source": "node_modules/iconv-lite/encodings/sbcs-data-generated.js", "sourceSha256": "2cf44b3f70c61c9cdd59fda7ec085bc3180809638f208c7239688ccb90a48866", "comments": [ { "type": "line", "start": 15, "end": 117, "line": 3, "text": "// Generated data for sbcs codec. Don't edit manually. Regenerate using generation/gen-sbcs.js script." } ] }, { "source": "node_modules/iconv-lite/encodings/dbcs-codec.js", "sourceSha256": "d39bc17f93fc56af631b00e36542488923378cce5ad9e7db48252ce7a1e7b1ed", "comments": [ { "type": "line", "start": 60, "end": 142, "line": 4, "text": "// Multibyte codec. In this scheme, a character is represented by 1 or more bytes." }, { "type": "line", "start": 143, "end": 229, "line": 5, "text": "// Our codec supports UTF-16 surrogates, extensions for GB18030 and unicode sequences." }, { "type": "line", "start": 230, "end": 306, "line": 6, "text": "// To save memory and loading time, we read table files only when requested." }, { "type": "line", "start": 557, "end": 613, "line": 21, "text": "// Class DBCSCodec reads and initializes mapping tables." }, { "type": "line", "start": 908, "end": 923, "line": 29, "text": "// Load tables." }, { "type": "line", "start": 975, "end": 1009, "line": 33, "text": "// Decode tables: MBCS -> Unicode." }, { "type": "line", "start": 1015, "end": 1139, "line": 35, "text": "// decodeTables is a trie, encoded as an array of arrays of integers. Internal arrays are trie nodes and all have len = 256." }, { "type": "line", "start": 1144, "end": 1176, "line": 36, "text": "// Trie root is decodeTables[0]." }, { "type": "line", "start": 1181, "end": 1240, "line": 37, "text": "// Values: >= 0 -> unicode character code. can be > 0xFFFF" }, { "type": "line", "start": 1245, "end": 1301, "line": 38, "text": "// == UNASSIGNED -> unknown/unassigned sequence." }, { "type": "line", "start": 1306, "end": 1381, "line": 39, "text": "// == GB18030_CODE -> this is the end of a GB18030 4-byte sequence." }, { "type": "line", "start": 1386, "end": 1470, "line": 40, "text": "// <= NODE_START -> index of the next node in our trie to process next byte." }, { "type": "line", "start": 1475, "end": 1570, "line": 41, "text": "// <= SEQ_START -> index of the start of a character code sequence, in decodeTableSeq." }, { "type": "line", "start": 1652, "end": 1672, "line": 43, "text": "// Create root node." }, { "type": "line", "start": 1678, "end": 1789, "line": 45, "text": "// Sometimes a MBCS char corresponds to a sequence of unicode chars. We store them as arrays of integers here. " }, { "type": "line", "start": 1825, "end": 1903, "line": 48, "text": "// Actual mapping tables consist of chunks. Use them to fill up decode tables." }, { "type": "line", "start": 2068, "end": 2102, "line": 55, "text": "// Encode tables: Unicode -> DBCS." }, { "type": "line", "start": 2108, "end": 2221, "line": 57, "text": "// `encodeTable` is array mapping from unicode char to encoded char. All its values are integers for performance." }, { "type": "line", "start": 2226, "end": 2331, "line": 58, "text": "// Because it can be sparse, it is represented as array of buckets by 256 chars each. Bucket can be null." }, { "type": "line", "start": 2336, "end": 2447, "line": 59, "text": "// Values: >= 0 -> it is a normal char. Write the value (if <=256 then 1 byte, if <=65536 then 2 bytes, etc.)." }, { "type": "line", "start": 2452, "end": 2523, "line": 60, "text": "// == UNASSIGNED -> no conversion found. Output a default char." }, { "type": "line", "start": 2528, "end": 2632, "line": 61, "text": "// <= SEQ_START -> it's an index in encodeTableSeq, see below. The character starts a sequence." }, { "type": "line", "start": 2669, "end": 2780, "line": 64, "text": "// `encodeTableSeq` is used when a sequence of unicode characters is encoded as a single code. We use a tree of" }, { "type": "line", "start": 2785, "end": 2905, "line": 65, "text": "// objects where keys correspond to characters in sequence and leafs are the encoded dbcs values. A special DEF_CHAR key" }, { "type": "line", "start": 2910, "end": 2997, "line": 66, "text": "// means end of sequence (needed when one sequence is a strict subsequence of another)." }, { "type": "line", "start": 3002, "end": 3074, "line": 67, "text": "// Objects are kept separately from encodeTable to increase performance." }, { "type": "line", "start": 3110, "end": 3164, "line": 70, "text": "// Some chars can be decoded, but need not be encoded." }, { "type": "line", "start": 3587, "end": 3644, "line": 82, "text": "// Use decode trie to recursively fill out encode tables." }, { "type": "line", "start": 3700, "end": 3739, "line": 85, "text": "// Add more encoding pairs when needed." }, { "type": "line", "start": 4254, "end": 4298, "line": 97, "text": "// Load & create GB18030 tables when needed." }, { "type": "line", "start": 4400, "end": 4423, "line": 99, "text": "// Load GB18030 ranges." }, { "type": "line", "start": 4433, "end": 4462, "line": 101, "text": "// Add GB18030 decode tables." }, { "type": "line", "start": 5378, "end": 5396, "line": 124, "text": "// Decoder helpers" }, { "type": "line", "start": 5676, "end": 5715, "line": 133, "text": "// Traverse nodes deeper into the trie." }, { "type": "line", "start": 5784, "end": 5803, "line": 136, "text": "// Create new node." }, { "type": "line", "start": 5989, "end": 6006, "line": 140, "text": "// Existing node." }, { "type": "line", "start": 6277, "end": 6339, "line": 151, "text": "// First element of chunk is the hex mbcs code where we start." }, { "type": "line", "start": 6387, "end": 6443, "line": 154, "text": "// Choose the decoding node where we'll write our chars." }, { "type": "line", "start": 6534, "end": 6588, "line": 158, "text": "// Write all other elements of the chunk to the table." }, { "type": "line", "start": 6703, "end": 6726, "line": 161, "text": "// String, write as-is." }, { "type": "line", "start": 6879, "end": 6898, "line": 164, "text": "// Decode surrogate" }, { "type": "line", "start": 7353, "end": 7398, "line": 171, "text": "// Character sequence (our own encoding used)" }, { "type": "line", "start": 7587, "end": 7656, "line": 175, "text": "// Simple variation: don't support surrogates or subsequences in seq." }, { "type": "line", "start": 7882, "end": 7895, "line": 181, "text": "// Basic char" }, { "type": "line", "start": 7966, "end": 8035, "line": 184, "text": "// Integer, meaning increasing sequence starting with prev character." }, { "type": "line", "start": 8488, "end": 8506, "line": 196, "text": "// Encoder helpers" }, { "type": "line", "start": 8591, "end": 8644, "line": 198, "text": "// This could be > 0xFF because of astral characters." }, { "type": "line", "start": 8750, "end": 8777, "line": 200, "text": "// Create bucket on demand." }, { "type": "line", "start": 9063, "end": 9130, "line": 208, "text": "// There's already a sequence, set a single-char subsequence of it." }, { "type": "line", "start": 9282, "end": 9361, "line": 215, "text": "// Get the root of character tree according to first character of the sequence." }, { "type": "line", "start": 9520, "end": 9565, "line": 222, "text": "// There's already a sequence with - use it." }, { "type": "line", "start": 9650, "end": 9703, "line": 226, "text": "// There was no sequence object - allocate a new one." }, { "type": "line", "start": 9793, "end": 9857, "line": 228, "text": "// If a char was set before - make it a single-char subsequence." }, { "type": "line", "start": 9971, "end": 10034, "line": 233, "text": "// Traverse the character tree, allocating new nodes as needed." }, { "type": "line", "start": 10331, "end": 10365, "line": 245, "text": "// Set the leaf to given dbcsCode." }, { "type": "line", "start": 11043, "end": 11123, "line": 269, "text": "// == Encoder ==================================================================" }, { "type": "line", "start": 11168, "end": 11184, "line": 272, "text": "// Encoder state" }, { "type": "line", "start": 11252, "end": 11266, "line": 276, "text": "// Static data" }, { "type": "line", "start": 11697, "end": 11722, "line": 290, "text": "// 0. Get next character." }, { "type": "line", "start": 11948, "end": 11972, "line": 300, "text": "// 1. Handle surrogates." }, { "type": "line", "start": 12022, "end": 12051, "line": 301, "text": "// Char is one of surrogates." }, { "type": "line", "start": 12086, "end": 12114, "line": 302, "text": "// We've got lead surrogate." }, { "type": "line", "start": 12320, "end": 12351, "line": 308, "text": "// Double lead surrogate found." }, { "type": "line", "start": 12431, "end": 12460, "line": 311, "text": "// We've got trail surrogate." }, { "type": "line", "start": 12681, "end": 12739, "line": 316, "text": "// Incomplete surrogate pair - only trail surrogate found." }, { "type": "line", "start": 12892, "end": 12949, "line": 323, "text": "// Incomplete surrogate pair - only lead surrogate found." }, { "type": "line", "start": 13000, "end": 13037, "line": 324, "text": "// Write an error, then current char." }, { "type": "line", "start": 13089, "end": 13119, "line": 328, "text": "// 2. Convert uCode character." }, { "type": "line", "start": 13214, "end": 13253, "line": 330, "text": "// We are in the middle of the sequence" }, { "type": "line", "start": 13342, "end": 13364, "line": 332, "text": "// Sequence continues." }, { "type": "line", "start": 13479, "end": 13510, "line": 336, "text": "// Sequence finished. Write it." }, { "type": "line", "start": 13595, "end": 13644, "line": 339, "text": "// Current character is not part of the sequence." }, { "type": "line", "start": 13662, "end": 13704, "line": 341, "text": "// Try default character for this sequence" }, { "type": "line", "start": 13834, "end": 13853, "line": 344, "text": "// Found. Write it." }, { "type": "line", "start": 13892, "end": 13955, "line": 345, "text": "// Current character will be written too in the next iteration." }, { "type": "line", "start": 14002, "end": 14061, "line": 348, "text": "// TODO: What if we have no default? (resCode == undefined)" }, { "type": "line", "start": 14082, "end": 14169, "line": 349, "text": "// Then, we should write first char of the sequence as-is and try the rest recursively." }, { "type": "line", "start": 14190, "end": 14257, "line": 350, "text": "// Didn't do it for now because no encoding has this situation yet." }, { "type": "line", "start": 14278, "end": 14338, "line": 351, "text": "// Currently, just skip the sequence and write current char." }, { "type": "line", "start": 14445, "end": 14465, "line": 356, "text": "// Regular character" }, { "type": "line", "start": 14668, "end": 14685, "line": 361, "text": "// Sequence start" }, { "type": "line", "start": 14867, "end": 14922, "line": 367, "text": "// Use GB18030 algorithm to find character(s) to write." }, { "type": "line", "start": 15542, "end": 15573, "line": 380, "text": "// 3. Write dbcsCode character." }, { "type": "line", "start": 15831, "end": 15843, "line": 388, "text": "// high byte" }, { "type": "line", "start": 15887, "end": 15898, "line": 389, "text": "// low byte" }, { "type": "line", "start": 16297, "end": 16327, "line": 405, "text": "// All clean. Most often case." }, { "type": "line", "start": 16395, "end": 16420, "line": 409, "text": "// We're in the sequence." }, { "type": "line", "start": 16505, "end": 16540, "line": 411, "text": "// Write beginning of the sequence." }, { "type": "line", "start": 16697, "end": 16709, "line": 416, "text": "// high byte" }, { "type": "line", "start": 16757, "end": 16768, "line": 417, "text": "// low byte" }, { "type": "line", "start": 16812, "end": 16830, "line": 420, "text": "// See todo above." }, { "type": "line", "start": 16926, "end": 16983, "line": 426, "text": "// Incomplete surrogate pair - only lead surrogate found." }, { "type": "line", "start": 17112, "end": 17133, "line": 434, "text": "// Export for testing" }, { "type": "line", "start": 17177, "end": 17257, "line": 438, "text": "// == Decoder ==================================================================" }, { "type": "line", "start": 17302, "end": 17318, "line": 441, "text": "// Decoder state" }, { "type": "line", "start": 17382, "end": 17396, "line": 445, "text": "// Static data" }, { "type": "line", "start": 17816, "end": 17863, "line": 456, "text": "// idx of the start of current parsed sequence." }, { "type": "line", "start": 17907, "end": 17974, "line": 459, "text": "// Make prev buf overlap a little to make it easier to slice later." }, { "type": "line", "start": 18171, "end": 18202, "line": 465, "text": "// Lookup in current trie node." }, { "type": "line", "start": 18300, "end": 18333, "line": 469, "text": "// Normal character, just use it." }, { "type": "line", "start": 18385, "end": 18401, "line": 471, "text": "// Unknown char." }, { "type": "line", "start": 18414, "end": 18441, "line": 472, "text": "// TODO: Callback with seq." }, { "type": "line", "start": 18454, "end": 18575, "line": 473, "text": "//var curSeq = (seqStart >= 0) ? buf.slice(seqStart, i+1) : prevBuf.slice(seqStart + prevBufOffset, i+1 + prevBufOffset);" }, { "type": "line", "start": 18602, "end": 18708, "line": 474, "text": "// Try to parse again, after skipping first byte of the sequence ('i' will be incremented by 'for' cycle)." }, { "type": "line", "start": 19252, "end": 19276, "line": 483, "text": "// Go to next trie node." }, { "type": "line", "start": 19390, "end": 19420, "line": 487, "text": "// Output a sequence of chars." }, { "type": "line", "start": 19873, "end": 19951, "line": 499, "text": "// Write the character to buffer, handling higher planes using surrogate pair." }, { "type": "line", "start": 20297, "end": 20316, "line": 511, "text": "// Reset trie node." }, { "type": "line", "start": 20604, "end": 20640, "line": 523, "text": "// Try to parse all remaining chars." }, { "type": "line", "start": 20687, "end": 20721, "line": 525, "text": "// Skip 1 character in the buffer." }, { "type": "line", "start": 20812, "end": 20840, "line": 529, "text": "// Parse remaining as usual." }, { "type": "line", "start": 21019, "end": 21093, "line": 540, "text": "// Binary search for GB18030. Returns largest i such that table[i] <= val." }, { "type": "line", "start": 21224, "end": 21260, "line": 546, "text": "// always table[l] <= val < table[r]" } ] }, { "source": "node_modules/iconv-lite/encodings/dbcs-data.js", "sourceSha256": "e213f77e926605c30649ea48bcea851d1ec063bb17fa4c2ab6d3b64853b481ac", "comments": [ { "type": "line", "start": 15, "end": 77, "line": 3, "text": "// Description of supported double byte encodings and aliases." }, { "type": "line", "start": 78, "end": 155, "line": 4, "text": "// Tables are not require()-d until they are needed to speed up library load." }, { "type": "line", "start": 156, "end": 204, "line": 5, "text": "// require()-s are direct to support Browserify." }, { "type": "line", "start": 234, "end": 310, "line": 9, "text": "// == Japanese/ShiftJIS ====================================================" }, { "type": "line", "start": 315, "end": 377, "line": 10, "text": "// All japanese encodings are based on JIS X set of standards:" }, { "type": "line", "start": 382, "end": 458, "line": 11, "text": "// JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF." }, { "type": "line", "start": 463, "end": 557, "line": 12, "text": "// JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. " }, { "type": "line", "start": 562, "end": 630, "line": 13, "text": "// Has several variations in 1978, 1983, 1990 and 1997." }, { "type": "line", "start": 635, "end": 724, "line": 14, "text": "// JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead." }, { "type": "line", "start": 729, "end": 815, "line": 15, "text": "// JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233." }, { "type": "line", "start": 820, "end": 895, "line": 16, "text": "// 2 planes, first is superset of 0208, second - revised 0212." }, { "type": "line", "start": 900, "end": 998, "line": 17, "text": "// Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)" }, { "type": "line", "start": 1004, "end": 1026, "line": 19, "text": "// Byte encodings are:" }, { "type": "line", "start": 1031, "end": 1134, "line": 20, "text": "// * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte" }, { "type": "line", "start": 1139, "end": 1265, "line": 21, "text": "// encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC." }, { "type": "line", "start": 1270, "end": 1375, "line": 22, "text": "// Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI." }, { "type": "line", "start": 1380, "end": 1448, "line": 23, "text": "// * EUC-JP: Up to 3 bytes per character. Used mostly on *nixes." }, { "type": "line", "start": 1453, "end": 1506, "line": 24, "text": "// 0x00-0x7F - lower part of 0201" }, { "type": "line", "start": 1511, "end": 1564, "line": 25, "text": "// 0x8E, 0xA1-0xDF - upper part of 0201" }, { "type": "line", "start": 1569, "end": 1623, "line": 26, "text": "// (0xA1-0xFE)x2 - 0208 plane (94x94)." }, { "type": "line", "start": 1628, "end": 1686, "line": 27, "text": "// 0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94)." }, { "type": "line", "start": 1691, "end": 1785, "line": 28, "text": "// * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon." }, { "type": "line", "start": 1790, "end": 1836, "line": 29, "text": "// Used as-is in ISO2022 family." }, { "type": "line", "start": 1841, "end": 1925, "line": 30, "text": "// * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, " }, { "type": "line", "start": 1930, "end": 1986, "line": 31, "text": "// 0201-1976 Roman, 0208-1978, 0208-1983." }, { "type": "line", "start": 1991, "end": 2038, "line": 32, "text": "// * ISO2022-JP-1: Adds esc seq for 0212-1990." }, { "type": "line", "start": 2043, "end": 2128, "line": 33, "text": "// * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7." }, { "type": "line", "start": 2133, "end": 2212, "line": 34, "text": "// * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2." }, { "type": "line", "start": 2217, "end": 2263, "line": 35, "text": "// * ISO2022-JP-2004: Adds 0213-2004 Plane 1." }, { "type": "line", "start": 2268, "end": 2270, "line": 36, "text": "//" }, { "type": "line", "start": 2275, "end": 2394, "line": 37, "text": "// After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes." }, { "type": "line", "start": 2399, "end": 2401, "line": 38, "text": "//" }, { "type": "line", "start": 2406, "end": 2505, "line": 39, "text": "// Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html" }, { "type": "line", "start": 3171, "end": 3207, "line": 64, "text": "// TODO: KDDI extension to Shift_JIS" }, { "type": "line", "start": 3212, "end": 3290, "line": 65, "text": "// TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes." }, { "type": "line", "start": 3295, "end": 3378, "line": 66, "text": "// TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars." }, { "type": "line", "start": 3385, "end": 3461, "line": 69, "text": "// == Chinese/GBK ==========================================================" }, { "type": "line", "start": 3466, "end": 3501, "line": 70, "text": "// http://en.wikipedia.org/wiki/GBK" }, { "type": "line", "start": 3506, "end": 3592, "line": 71, "text": "// We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder" }, { "type": "line", "start": 3598, "end": 3655, "line": 73, "text": "// Oldest GB2312 (1981, ~7600 chars) is a subset of CP936" }, { "type": "line", "start": 3815, "end": 3873, "line": 81, "text": "// Microsoft's CP936 is a subset and approximation of GBK." }, { "type": "line", "start": 4062, "end": 4153, "line": 90, "text": "// GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other." }, { "type": "line", "start": 4355, "end": 4401, "line": 98, "text": "// GB18030 is an algorithmic extension of GBK." }, { "type": "line", "start": 4406, "end": 4465, "line": 99, "text": "// Main source: https://www.w3.org/TR/encoding/#gbk-encoder" }, { "type": "line", "start": 4470, "end": 4520, "line": 100, "text": "// http://icu-project.org/docs/papers/gb18030.html" }, { "type": "line", "start": 4525, "end": 4613, "line": 101, "text": "// http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml" }, { "type": "line", "start": 4618, "end": 4676, "line": 102, "text": "// http://www.khngai.com/chinese/charmap/tblgbk.php?page=0" }, { "type": "line", "start": 5015, "end": 5091, "line": 114, "text": "// == Korean ===============================================================" }, { "type": "line", "start": 5096, "end": 5152, "line": 115, "text": "// EUC-KR, KS_C_5601 and KS X 1001 are exactly the same." }, { "type": "line", "start": 5547, "end": 5623, "line": 134, "text": "// == Big5/Taiwan/Hong Kong ================================================" }, { "type": "line", "start": 5628, "end": 5719, "line": 135, "text": "// There are lots of tables for Big5 and cp950. Please see the following links for history:" }, { "type": "line", "start": 5724, "end": 5819, "line": 136, "text": "// http://moztw.org/docs/big5/ http://www.haible.de/bruno/charsets/conversion-tables/Big5.html" }, { "type": "line", "start": 5824, "end": 5874, "line": 137, "text": "// Variations, in roughly number of defined chars:" }, { "type": "line", "start": 5879, "end": 6010, "line": 138, "text": "// * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT" }, { "type": "line", "start": 6015, "end": 6158, "line": 139, "text": "// * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/" }, { "type": "line", "start": 6163, "end": 6222, "line": 140, "text": "// * Big5-2003 (Taiwan standard) almost superset of cp950." }, { "type": "line", "start": 6227, "end": 6331, "line": 141, "text": "// * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers." }, { "type": "line", "start": 6336, "end": 6396, "line": 142, "text": "// * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. " }, { "type": "line", "start": 6401, "end": 6495, "line": 143, "text": "// many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years." }, { "type": "line", "start": 6500, "end": 6541, "line": 144, "text": "// Plus, it has 4 combining sequences." }, { "type": "line", "start": 6546, "end": 6708, "line": 145, "text": "// Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299" }, { "type": "line", "start": 6713, "end": 6811, "line": 146, "text": "// because big5-hkscs is the only encoding to include astral characters in non-algorithmic way." }, { "type": "line", "start": 6816, "end": 6905, "line": 147, "text": "// Implementations are not consistent within browsers; sometimes labeled as just big5." }, { "type": "line", "start": 6910, "end": 6991, "line": 148, "text": "// MS Internet Explorer switches from big5 to big5-hkscs when a patch applied." }, { "type": "line", "start": 6996, "end": 7101, "line": 149, "text": "// Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31" }, { "type": "line", "start": 7106, "end": 7205, "line": 150, "text": "// In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s." }, { "type": "line", "start": 7210, "end": 7313, "line": 151, "text": "// Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt" }, { "type": "line", "start": 7318, "end": 7428, "line": 152, "text": "// http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt" }, { "type": "line", "start": 7433, "end": 7436, "line": 153, "text": "// " }, { "type": "line", "start": 7441, "end": 7573, "line": 154, "text": "// Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder" }, { "type": "line", "start": 7578, "end": 7691, "line": 155, "text": "// Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong." }, { "type": "line", "start": 7881, "end": 7981, "line": 165, "text": "// Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus." } ] }, { "source": "node_modules/iconv-lite/encodings/index.js", "sourceSha256": "69607a9ee51b63333d0e7ee20a38b52e1e96652a4bbc09c701d70835fbbfe10a", "comments": [ { "type": "line", "start": 15, "end": 85, "line": 3, "text": "// Update this array if you add/rename/remove files in this directory." }, { "type": "line", "start": 86, "end": 181, "line": 4, "text": "// We support Browserify by skipping automatic module discovery and requiring modules directly." }, { "type": "line", "start": 428, "end": 504, "line": 16, "text": "// Put all encoding/alias/codec definitions to single object and export it. " } ] }, { "source": "node_modules/iconv-lite/lib/streams.js", "sourceSha256": "25a423eaf41f8dc6bc40cb28189a24e2d63b990ed72c824940bed55d0264ea6d", "comments": [ { "type": "line", "start": 101, "end": 181, "line": 7, "text": "// == Exports ==================================================================" }, { "type": "line", "start": 226, "end": 251, "line": 10, "text": "// Additional Public API." }, { "type": "line", "start": 620, "end": 641, "line": 22, "text": "// Not published yet." }, { "type": "line", "start": 828, "end": 904, "line": 29, "text": "// == Encoder stream =======================================================" }, { "type": "line", "start": 1040, "end": 1099, "line": 33, "text": "// We accept only strings, so we don't need to decode them." }, { "type": "line", "start": 2112, "end": 2188, "line": 76, "text": "// == Decoder stream =======================================================" }, { "type": "line", "start": 2336, "end": 2357, "line": 80, "text": "// We output strings." } ] }, { "source": "node_modules/iconv-lite/lib/extend-node.js", "sourceSha256": "7b86aebd7175d940c50f60eac1981490962855d9723bf971981ddd703ba6af43", "comments": [ { "type": "line", "start": 53, "end": 128, "line": 3, "text": "// Note: not polyfilled with safer-buffer on a purpose, as overrides Buffer" }, { "type": "line", "start": 130, "end": 210, "line": 5, "text": "// == Extend Node primitives to use iconv-lite =================================" }, { "type": "line", "start": 278, "end": 312, "line": 8, "text": "// Place to keep original methods." }, { "type": "line", "start": 318, "end": 385, "line": 10, "text": "// Node authors rewrote Buffer internals to make it compatible with" }, { "type": "line", "start": 390, "end": 449, "line": 11, "text": "// Uint8Array and we cannot patch key functions since then." }, { "type": "line", "start": 454, "end": 506, "line": 12, "text": "// Note: this does use older Buffer API on a purpose" }, { "type": "line", "start": 1415, "end": 1491, "line": 34, "text": "// -- SlowBuffer -----------------------------------------------------------" }, { "type": "line", "start": 1768, "end": 1806, "line": 41, "text": "// Use native conversion when possible" }, { "type": "line", "start": 1956, "end": 1994, "line": 45, "text": "// Otherwise, use our decoding method." }, { "type": "line", "start": 2348, "end": 2398, "line": 53, "text": "// Support both (string, offset, length, encoding)" }, { "type": "line", "start": 2411, "end": 2463, "line": 54, "text": "// and the legacy (string, encoding, offset, length)" }, { "type": "line", "start": 2660, "end": 2669, "line": 60, "text": "// legacy" }, { "type": "line", "start": 3216, "end": 3254, "line": 79, "text": "// Use native conversion when possible" }, { "type": "line", "start": 3558, "end": 3596, "line": 86, "text": "// Otherwise, use our encoding method." }, { "type": "line", "start": 3802, "end": 3878, "line": 93, "text": "// -- Buffer ---------------------------------------------------------------" }, { "type": "line", "start": 4294, "end": 4332, "line": 104, "text": "// Use native conversion when possible" }, { "type": "line", "start": 4473, "end": 4525, "line": 108, "text": "// Slow, I know, but we don't have a better way yet." }, { "type": "line", "start": 4800, "end": 4838, "line": 116, "text": "// Use native conversion when possible" }, { "type": "line", "start": 4984, "end": 5022, "line": 120, "text": "// Otherwise, use our decoding method." }, { "type": "line", "start": 5438, "end": 5488, "line": 129, "text": "// Support both (string, offset, length, encoding)" }, { "type": "line", "start": 5501, "end": 5553, "line": 130, "text": "// and the legacy (string, encoding, offset, length)" }, { "type": "line", "start": 5750, "end": 5759, "line": 136, "text": "// legacy" }, { "type": "line", "start": 5989, "end": 6027, "line": 145, "text": "// Use native conversion when possible" }, { "type": "line", "start": 6648, "end": 6686, "line": 163, "text": "// Otherwise, use our encoding method." }, { "type": "line", "start": 6886, "end": 6913, "line": 169, "text": "// TODO: Set _charsWritten." }, { "type": "line", "start": 6934, "end": 7010, "line": 173, "text": "// -- Readable -------------------------------------------------------------" }, { "type": "line", "start": 7277, "end": 7327, "line": 179, "text": "// Use our own decoder, it has the same interface." }, { "type": "line", "start": 7344, "end": 7406, "line": 180, "text": "// We cannot use original function as it doesn't handle BOM-s." }, { "type": "line", "start": 7630, "end": 7677, "line": 189, "text": "// Remove iconv-lite Node primitive extensions." } ] }, { "source": "node_modules/iconv-lite/lib/index.js", "sourceSha256": "77d20e2fd5bcd9e324fb6cfdb909cd06fdaf6a91769adffcf4d7c4c066cce4c3", "comments": [ { "type": "line", "start": 15, "end": 81, "line": 3, "text": "// Some environments don't have global Buffer (e.g. React Native)." }, { "type": "line", "start": 82, "end": 159, "line": 4, "text": "// Solution would be installing npm modules \"buffer\" and \"stream\" explicitly." }, { "type": "line", "start": 280, "end": 350, "line": 10, "text": "// All codecs and aliases are kept here, keyed by encoding name/alias." }, { "type": "line", "start": 351, "end": 421, "line": 11, "text": "// They are lazy loaded in `iconv.getCodec` from `encodings/index.js`." }, { "type": "line", "start": 447, "end": 486, "line": 14, "text": "// Characters emitted in case of error." }, { "type": "line", "start": 555, "end": 569, "line": 18, "text": "// Public API." }, { "type": "line", "start": 655, "end": 672, "line": 20, "text": "// Ensure string." }, { "type": "line", "start": 1288, "end": 1305, "line": 37, "text": "// Ensure buffer." }, { "type": "line", "start": 1641, "end": 1679, "line": 57, "text": "// Legacy aliases to convert functions" }, { "type": "line", "start": 1749, "end": 1833, "line": 61, "text": "// Search for a codec in iconv.encodings. Cache codec data in iconv._codecDataCache." }, { "type": "line", "start": 1986, "end": 2024, "line": 65, "text": "// Lazy load all encoding definitions." }, { "type": "line", "start": 2034, "end": 2116, "line": 67, "text": "// Canonicalize encoding name: strip all non-alphanumeric chars and appended year." }, { "type": "line", "start": 2175, "end": 2224, "line": 70, "text": "// Traverse iconv.encodings to find actual codec." }, { "type": "line", "start": 2473, "end": 2507, "line": 80, "text": "// Direct alias to other encoding." }, { "type": "line", "start": 2591, "end": 2629, "line": 84, "text": "// Alias with options. Can be layered." }, { "type": "line", "start": 2936, "end": 2952, "line": 94, "text": "// Codec itself." }, { "type": "line", "start": 3071, "end": 3167, "line": 98, "text": "// The codec function must load all tables and return object with .encoder and .decoder methods." }, { "type": "line", "start": 3184, "end": 3249, "line": 99, "text": "// It'll be called only once (for each different options object)." }, { "type": "line", "start": 3384, "end": 3414, "line": 102, "text": "// Save it to be reused later." }, { "type": "line", "start": 3646, "end": 3728, "line": 112, "text": "// Canonicalize encoding name: strip all non-alphanumeric chars and appended year." }, { "type": "line", "start": 4414, "end": 4522, "line": 137, "text": "// Load extensions in Node. All of them are omitted in Browserify build via 'browser' field in package.json." }, { "type": "line", "start": 4634, "end": 4674, "line": 141, "text": "// Load streaming support in Node v0.10+" }, { "type": "line", "start": 4828, "end": 4862, "line": 147, "text": "// Load Node primitive extensions." } ] }, { "source": "node_modules/@pdf-lib/restructure/src/DecodeStream.js", "sourceSha256": "378d5c2ada8566fff281ce41ee870605880b8e2ea28717289cf60349c0ad0dda", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/EncodeStream.js", "sourceSha256": "a236f52d974e7f8ff797e2a0fac1854f090d30627ad03d6caab592e76f2d907d", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Number.js", "sourceSha256": "5f65d67d36489e6767e0b75b886886d735e3408903c5b3a3a8b5bed12f3e685a", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/utils.js", "sourceSha256": "2a713b38ee27abe8028a419cdc93d92f39b21df2fee83e9c8ffb9b0c9d716014", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Array.js", "sourceSha256": "31e906c570918b036ab53bceb2e2b53034638cb2a125a28c42daf6791920cd35", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/LazyArray.js", "sourceSha256": "6d15b75221de1dddfea7c2c3d58cc0e9bf8e27c5cef418482e4dcd9f11a2320a", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Bitfield.js", "sourceSha256": "599f59dd780c66a1a08a0caa7cad5106ea835b6590ab7704f762ba02c0607422", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Boolean.js", "sourceSha256": "790b32a555ad4cd528db5f53a0d98df1dcde489b605a168de24ec9301ce35593", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Buffer.js", "sourceSha256": "514d034049d5bfe33cf9239d826f3ca0fd8682318d7775cd0155dec299a690e4", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Enum.js", "sourceSha256": "42d05fd62c7f2a9927ef2d82cb66db2c83868ef596268857c310abd127f9d524", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Optional.js", "sourceSha256": "2e60c306cec25e2c20d64dd2d2bb5afea2e2bd6af82c4f55b56c5914190d8777", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Reserved.js", "sourceSha256": "d8469ee7dd28676810dbdbdfdba383846a5e186b673fa890184b4c786b1e7541", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/String.js", "sourceSha256": "18545cbfce426aee3b89100fe3402e128f3f4a5737d973552b35e9b55a59b707", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Struct.js", "sourceSha256": "1ce8c8b3d407f8752752e888cb147907ba77ce2c4803e1c7302f6cbf5dba76a4", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/VersionedStruct.js", "sourceSha256": "4143df6571b45ed8900305cf2d4669ae3077c88768e9966cd08fb7579cf0b591", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/src/Pointer.js", "sourceSha256": "0dedea10cb59f5f8c788ab9394b2bfbe3ae55a02b87d166c9bfc13d5dd6ba9b5", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/@pdf-lib/restructure/index.js", "sourceSha256": "161666bab404d61d4b3b7828f74442fae00eddd23e42bc0cee4be36d9547e7eb", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/object-keys/isArguments.js", "sourceSha256": "31f36ded2784150b7480f56ca42e7fda6e119d4345d5884a4d5f55e13fe6ac30", "comments": [] }, { "source": "node_modules/object-keys/implementation.js", "sourceSha256": "4dd43bf86b886f6adc16aa34b2f0d3a27b92ecf65adcb87224e54cd394d2024c", "comments": [ { "type": "line", "start": 50, "end": 103, "line": 5, "text": "// modified from https://github.com/es-shims/es5-shim" }, { "type": "line", "start": 228, "end": 265, "line": 8, "text": "// eslint-disable-line global-require" }, { "type": "block", "start": 1308, "end": 1327, "line": 51, "text": "/* global window */" }, { "type": "block", "start": 1764, "end": 1783, "line": 69, "text": "/* global window */" } ] }, { "source": "node_modules/object-keys/index.js", "sourceSha256": "4004588aa7a3769d8c34ef9a837e1632237487e53ed57caec51bfcc6668f2c29", "comments": [ { "type": "line", "start": 363, "end": 380, "line": 14, "text": "// Safari 5.0 bug" }, { "type": "line", "start": 557, "end": 598, "line": 19, "text": "// eslint-disable-line func-name-matching" } ] }, { "source": "node_modules/is-arguments/index.js", "sourceSha256": "9531ad8d9c3f7360dc601d12f6bf614340fac643db8deec332cb7c8db637b14c", "comments": [ { "type": "line", "start": 849, "end": 861, "line": 29, "text": "// for tests" } ] }, { "source": "node_modules/define-properties/index.js", "sourceSha256": "dc7b9a6bcbbe00c55e0040775cd6aed65f6a91fbbf5cf9cb49992e7d09ee6467", "comments": [ { "type": "line", "start": 516, "end": 580, "line": 18, "text": "// eslint-disable-next-line no-unused-vars, no-restricted-syntax" }, { "type": "line", "start": 604, "end": 642, "line": 19, "text": "// jscs:ignore disallowUnusedVariables" }, { "type": "block", "start": 703, "end": 722, "line": 23, "text": "/* this is IE 8. */" } ] }, { "source": "node_modules/function-bind/implementation.js", "sourceSha256": "8752a57f05844ec002c9b603529b65b35070169448adaba681150f7c97f7689d", "comments": [ { "type": "block", "start": 15, "end": 46, "line": 3, "text": "/* eslint no-invalid-this: 1 */" } ] }, { "source": "node_modules/function-bind/index.js", "sourceSha256": "12fa1b92429db25599f6fe118cbbb877f7f62b83cb9bfe2fc896b2d6a8110647", "comments": [] }, { "source": "node_modules/has-symbols/shams.js", "sourceSha256": "efd9ff7dbfe3fe33305963ad127718cad3503eb155b696f333553dae4005cb9c", "comments": [ { "type": "block", "start": 15, "end": 72, "line": 3, "text": "/* eslint complexity: [2, 18], max-statements: [2, 33] */" }, { "type": "line", "start": 568, "end": 638, "line": 16, "text": "// temp disabled per https://github.com/ljharb/object.assign/issues/17" }, { "type": "line", "start": 640, "end": 687, "line": 17, "text": "// if (sym instanceof Symbol) { return false; }" }, { "type": "line", "start": 689, "end": 776, "line": 18, "text": "// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4" }, { "type": "line", "start": 778, "end": 831, "line": 19, "text": "// if (!(symObj instanceof Symbol)) { return false; }" }, { "type": "line", "start": 834, "end": 907, "line": 21, "text": "// if (typeof Symbol.prototype.toString !== 'function') { return false; }" }, { "type": "line", "start": 909, "end": 986, "line": 22, "text": "// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }" }, { "type": "line", "start": 1062, "end": 1105, "line": 26, "text": "// eslint-disable-line no-restricted-syntax" } ] }, { "source": "node_modules/has-symbols/index.js", "sourceSha256": "b5d3a9379639d4299a654f78a0aa708a8981219a50e6ecbbd52219281a26ddbc", "comments": [] }, { "source": "node_modules/es-abstract/GetIntrinsic.js", "sourceSha256": "fd0489c5d4a6083b75712860f0c7e9b662f85807a6c5ac6926498f93f619d2a9", "comments": [ { "type": "block", "start": 15, "end": 58, "line": 3, "text": "/* globals\n\tAtomics,\n\tSharedArrayBuffer,\n*/" }, { "type": "line", "start": 218, "end": 258, "line": 17, "text": "// this is IE 8, which has a broken gOPD" }, { "type": "line", "start": 383, "end": 469, "line": 25, "text": "// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties" }, { "type": "line", "start": 491, "end": 518, "line": 26, "text": "// IE 8 does not throw here" }, { "type": "line", "start": 585, "end": 649, "line": 30, "text": "// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')" }, { "type": "line", "start": 903, "end": 934, "line": 41, "text": "// eslint-disable-line no-proto" }, { "type": "line", "start": 951, "end": 973, "line": 43, "text": "// = function * () {};" }, { "type": "line", "start": 1056, "end": 1079, "line": 45, "text": "// async function() {};" }, { "type": "line", "start": 1157, "end": 1183, "line": 47, "text": "// async function * () {};" }, { "type": "line", "start": 3009, "end": 3039, "line": 83, "text": "// eslint-disable-line no-eval" }, { "type": "block", "start": 8170, "end": 8261, "line": 168, "text": "/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */" }, { "type": "block", "start": 8412, "end": 8463, "line": 170, "text": "/** Used to match backslashes in property paths. */" }, { "type": "block", "start": 8727, "end": 8747, "line": 178, "text": "/* end adaptation */" }, { "type": "line", "start": 8922, "end": 8987, "line": 185, "text": "// istanbul ignore if // hopefully this is impossible to test :-)" } ] }, { "source": "node_modules/es-abstract/helpers/callBind.js", "sourceSha256": "f5b1f507d75f4027c07c314da1e54f9d9a6fcceb146eca05946654aeb532bbc5", "comments": [] }, { "source": "node_modules/object-is/implementation.js", "sourceSha256": "3511c578d1c2ffce03ff1a0b4fbf41f072bf6b5ede1740752b62c318a5288289", "comments": [] }, { "source": "node_modules/object-is/polyfill.js", "sourceSha256": "ccaacf13be4930444e7d5fff16eb5c40a2b64b93057b886d29a606be02589d11", "comments": [] }, { "source": "node_modules/object-is/shim.js", "sourceSha256": "c4f6cdcdd4c8dfd235ed618b3f2e387cd227b42f8979b292fd5eb47504a2aeb1", "comments": [] }, { "source": "node_modules/object-is/index.js", "sourceSha256": "387bb110c927984f9a030dfa65c5fcec68c30f78b21f59f50db8621ac55cca60", "comments": [] }, { "source": "node_modules/has/src/index.js", "sourceSha256": "d4fa3ffe19a4722028a3d34982b75eae4d6d2c45d737e7967ffba9ce13515c4c", "comments": [] }, { "source": "node_modules/is-regex/index.js", "sourceSha256": "6408eb25b6d76e6407e9039f1d7a79f1dc6652304f871930a6205f8ff39bc064", "comments": [ { "type": "line", "start": 244, "end": 284, "line": 10, "text": "// eslint-disable-line no-param-reassign" }, { "type": "line", "start": 401, "end": 441, "line": 17, "text": "// eslint-disable-line no-param-reassign" } ] }, { "source": "node_modules/regexp.prototype.flags/implementation.js", "sourceSha256": "9c92ff76a6eaadeb2467585f9b388aa511b0ec9cc64a1157ee1a580746e271af", "comments": [] }, { "source": "node_modules/regexp.prototype.flags/polyfill.js", "sourceSha256": "e8affaaba506bdfcc8192b64d367b9a91fe1fa3cc530e79212d2f49d1264abf9", "comments": [] }, { "source": "node_modules/regexp.prototype.flags/shim.js", "sourceSha256": "3f33b3eeb7c3246b410b2e94975e9d015a314a34cf1d89f6489ba6ea45360bef", "comments": [] }, { "source": "node_modules/regexp.prototype.flags/index.js", "sourceSha256": "73cd909dc13818a84f070ac0219ac59e0b4b8d633a880f83ddf9dd63e7472336", "comments": [] }, { "source": "node_modules/is-date-object/index.js", "sourceSha256": "4bed5484e7a8d1751428703508b021d93e66c0d64ce717191b907a12ea815ae0", "comments": [] }, { "source": "node_modules/deep-equal/index.js", "sourceSha256": "3c0d2b2ad6f8ee1dd12fed5bfed929275698acce30c67629e9a33ce272688f30", "comments": [ { "type": "line", "start": 356, "end": 422, "line": 13, "text": "// 7.1. All identical values are equivalent, as determined by ===." }, { "type": "line", "start": 513, "end": 613, "line": 18, "text": "// 7.3. Other pairs that do not both pass typeof value == 'object', equivalence is determined by ==." }, { "type": "block", "start": 783, "end": 1227, "line": 23, "text": "/*\n * 7.4. For all other Object pairs, including Array objects, equivalence is\n * determined by having the same number of owned properties (as verified\n * with Object.prototype.hasOwnProperty.call), the same set of keys\n * (although not necessarily the same order), equivalent values for every\n * corresponding key, and an identical 'prototype' property. Note: this\n * accounts for both named and indexed properties on Arrays.\n */" }, { "type": "line", "start": 1230, "end": 1278, "line": 31, "text": "// eslint-disable-next-line no-use-before-define" }, { "type": "block", "start": 1743, "end": 1779, "line": 53, "text": "/* eslint max-statements: [2, 50] */" }, { "type": "line", "start": 1914, "end": 1951, "line": 58, "text": "// an identical 'prototype' property." }, { "type": "line", "start": 2493, "end": 2555, "line": 77, "text": "// && would work too, because both are true or both false here" }, { "type": "line", "start": 2841, "end": 2900, "line": 90, "text": "// happens when one is a string literal and the other isn't" }, { "type": "line", "start": 2925, "end": 3005, "line": 93, "text": "// having the same number of owned properties (keys incorporates hasOwnProperty)" }, { "type": "line", "start": 3058, "end": 3124, "line": 96, "text": "// the same set of keys (although not necessarily the same order)," }, { "type": "line", "start": 3153, "end": 3173, "line": 99, "text": "// ~~~cheap key test" }, { "type": "line", "start": 3263, "end": 3348, "line": 103, "text": "// equivalent values for every corresponding key, and ~~~possibly expensive deep test" } ] }, { "source": "node_modules/unicode-trie/node_modules/tiny-inflate/index.js", "sourceSha256": "203ccaa89e30ec4d6f9467a91758b0f55597424a817ea2107510bbadaab1b90d", "comments": [ { "type": "block", "start": 100, "end": 133, "line": 5, "text": "/* table of code length counts */" }, { "type": "block", "start": 172, "end": 210, "line": 6, "text": "/* code -> symbol translation table */" }, { "type": "block", "start": 403, "end": 435, "line": 18, "text": "/* dynamic length/symbol tree */" }, { "type": "block", "start": 464, "end": 491, "line": 19, "text": "/* dynamic distance tree */" }, { "type": "block", "start": 495, "end": 666, "line": 22, "text": "/* --------------------------------------------------- *\n * -- uninitialized global data (static structures) -- *\n * --------------------------------------------------- */" }, { "type": "block", "start": 719, "end": 768, "line": 29, "text": "/* extra bits and base tables for length codes */" }, { "type": "block", "start": 847, "end": 898, "line": 33, "text": "/* extra bits and base tables for distance codes */" }, { "type": "block", "start": 973, "end": 1016, "line": 37, "text": "/* special ordering of code length codes */" }, { "type": "block", "start": 1123, "end": 1185, "line": 44, "text": "/* used by tinf_decode_trees, avoids allocations every call */" }, { "type": "block", "start": 1255, "end": 1342, "line": 48, "text": "/* ----------------------- *\n * -- utility functions -- *\n * ----------------------- */" }, { "type": "block", "start": 1344, "end": 1382, "line": 52, "text": "/* build extra bits and base tables */" }, { "type": "block", "start": 1458, "end": 1480, "line": 56, "text": "/* build bits table */" }, { "type": "block", "start": 1595, "end": 1617, "line": 60, "text": "/* build base table */" }, { "type": "block", "start": 1711, "end": 1746, "line": 67, "text": "/* build the fixed huffman trees */" }, { "type": "block", "start": 1801, "end": 1830, "line": 71, "text": "/* build fixed length tree */" }, { "type": "block", "start": 2167, "end": 2198, "line": 83, "text": "/* build fixed distance tree */" }, { "type": "block", "start": 2311, "end": 2361, "line": 91, "text": "/* given an array of code lengths, build a tree */" }, { "type": "block", "start": 2461, "end": 2496, "line": 97, "text": "/* clear code length count table */" }, { "type": "block", "start": 2543, "end": 2596, "line": 100, "text": "/* scan symbol lengths, and sum code length counts */" }, { "type": "block", "start": 2676, "end": 2724, "line": 105, "text": "/* compute offset table for distribution sort */" }, { "type": "block", "start": 2812, "end": 2880, "line": 111, "text": "/* create code->symbol translation table (symbols sorted by code) */" }, { "type": "block", "start": 2983, "end": 3067, "line": 117, "text": "/* ---------------------- *\n * -- decode functions -- *\n * ---------------------- */" }, { "type": "block", "start": 3069, "end": 3105, "line": 121, "text": "/* get one bit from source stream */" }, { "type": "block", "start": 3134, "end": 3161, "line": 123, "text": "/* check if tag is empty */" }, { "type": "block", "start": 3189, "end": 3208, "line": 125, "text": "/* load next tag */" }, { "type": "block", "start": 3275, "end": 3301, "line": 130, "text": "/* shift bit out of tag */" }, { "type": "block", "start": 3359, "end": 3412, "line": 137, "text": "/* read a num bit value from a stream and add base */" }, { "type": "block", "start": 3699, "end": 3752, "line": 153, "text": "/* given a data stream and a tree, decode a symbol */" }, { "type": "block", "start": 3954, "end": 4003, "line": 163, "text": "/* get more bits while code value is above sum */" }, { "type": "block", "start": 4214, "end": 4269, "line": 179, "text": "/* given a data stream, decode dynamic trees from it */" }, { "type": "block", "start": 4361, "end": 4392, "line": 184, "text": "/* get 5 bits HLIT (257-286) */" }, { "type": "block", "start": 4432, "end": 4461, "line": 187, "text": "/* get 5 bits HDIST (1-32) */" }, { "type": "block", "start": 4500, "end": 4529, "line": 190, "text": "/* get 4 bits HCLEN (4-19) */" }, { "type": "block", "start": 4612, "end": 4660, "line": 195, "text": "/* read code lengths for code length alphabet */" }, { "type": "block", "start": 4697, "end": 4731, "line": 197, "text": "/* get 3 bits code length (0-7) */" }, { "type": "block", "start": 4810, "end": 4838, "line": 202, "text": "/* build code length tree */" }, { "type": "block", "start": 4888, "end": 4935, "line": 205, "text": "/* decode code lengths for the dynamic trees */" }, { "type": "block", "start": 5066, "end": 5121, "line": 211, "text": "/* copy previous code length 3-6 times (read 2 bits) */" }, { "type": "block", "start": 5307, "end": 5362, "line": 218, "text": "/* repeat code length 0 for 3-10 times (read 3 bits) */" }, { "type": "block", "start": 5508, "end": 5565, "line": 224, "text": "/* repeat code length 0 for 11-138 times (read 7 bits) */" }, { "type": "block", "start": 5712, "end": 5763, "line": 230, "text": "/* values 0-15 represent the actual code lengths */" }, { "type": "block", "start": 5822, "end": 5847, "line": 236, "text": "/* build dynamic trees */" }, { "type": "block", "start": 5937, "end": 6042, "line": 241, "text": "/* ----------------------------- *\n * -- block inflate functions -- *\n * ----------------------------- */" }, { "type": "block", "start": 6044, "end": 6103, "line": 245, "text": "/* given a stream and two trees, inflate a block of data */" }, { "type": "block", "start": 6210, "end": 6238, "line": 250, "text": "/* check for end of block */" }, { "type": "block", "start": 6427, "end": 6472, "line": 263, "text": "/* possibly get more bits from length code */" }, { "type": "block", "start": 6591, "end": 6638, "line": 268, "text": "/* possibly get more bits from distance code */" }, { "type": "block", "start": 6724, "end": 6740, "line": 271, "text": "/* copy match */" }, { "type": "block", "start": 6850, "end": 6893, "line": 279, "text": "/* inflate an uncompressed block of data */" }, { "type": "block", "start": 6979, "end": 7006, "line": 284, "text": "/* unread from bitbuffer */" }, { "type": "block", "start": 7083, "end": 7099, "line": 290, "text": "/* get length */" }, { "type": "block", "start": 7194, "end": 7230, "line": 294, "text": "/* get one's complement of length */" }, { "type": "block", "start": 7338, "end": 7356, "line": 298, "text": "/* check length */" }, { "type": "block", "start": 7455, "end": 7471, "line": 304, "text": "/* copy block */" }, { "type": "block", "start": 7555, "end": 7609, "line": 308, "text": "/* make sure we start next block on a byte boundary */" }, { "type": "block", "start": 7650, "end": 7690, "line": 314, "text": "/* inflate stream from source to dest */" }, { "type": "block", "start": 7804, "end": 7831, "line": 320, "text": "/* read final block flag */" }, { "type": "block", "start": 7866, "end": 7896, "line": 323, "text": "/* read block type (2 bits) */" }, { "type": "block", "start": 7939, "end": 7961, "line": 326, "text": "/* decompress block */" }, { "type": "block", "start": 8005, "end": 8040, "line": 329, "text": "/* decompress uncompressed block */" }, { "type": "block", "start": 8128, "end": 8175, "line": 333, "text": "/* decompress block with fixed huffman trees */" }, { "type": "block", "start": 8271, "end": 8320, "line": 337, "text": "/* decompress block with dynamic huffman trees */" }, { "type": "block", "start": 8782, "end": 8860, "line": 360, "text": "/* -------------------- *\n * -- initialization -- *\n * -------------------- */" }, { "type": "block", "start": 8862, "end": 8893, "line": 364, "text": "/* build fixed huffman trees */" }, { "type": "block", "start": 8935, "end": 8973, "line": 367, "text": "/* build extra bits and base tables */" }, { "type": "block", "start": 9079, "end": 9103, "line": 371, "text": "/* fix a special case */" } ] }, { "source": "node_modules/unicode-trie/index.js", "sourceSha256": "c3dd0c080ddcddaa6f51e4b3ae688ce17feff76d392de2740ba66ba118d63e2b", "comments": [ { "type": "line", "start": 0, "end": 34, "line": 1, "text": "// Generated by CoffeeScript 1.7.1" } ] }, { "source": "node_modules/base64-arraybuffer/lib/base64-arraybuffer.js", "sourceSha256": "f1749f1d4ac924264b74b5511385db93385398bb3c9668d6b91fece182558fd8", "comments": [ { "type": "block", "start": 0, "end": 157, "line": 1, "text": "/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */" }, { "type": "line", "start": 273, "end": 313, "line": 13, "text": "// Use a lookup table to find the index." } ] }, { "source": "node_modules/@pdf-lib/unicode-properties/es/index.js", "sourceSha256": "170b484086cac239b0259c1e15f73a00716132c05ad9c34cbb2f9dc9f91803ca", "comments": [ { "type": "line", "start": 203, "end": 254, "line": 5, "text": "// Trie is serialized as a Buffer in node, but here" }, { "type": "line", "start": 255, "end": 313, "line": 6, "text": "// we may be running in a browser so we make an Uint8Array" }, { "type": "line", "start": 660, "end": 711, "line": 18, "text": "// compute the number of bits stored for each field" }, { "type": "line", "start": 942, "end": 989, "line": 25, "text": "// compute shift and mask values for each field" } ] }, { "source": "node_modules/dfa/index.js", "sourceSha256": "1781af74f714561763b2f405b6764d4141876acc167fb0c0aa7160374f97f5ab", "comments": [ { "type": "block", "start": 58, "end": 214, "line": 5, "text": "/**\n * A StateMachine represents a deterministic finite automaton.\n * It can perform matches over a sequence of values, similar to a regular expression.\n */" }, { "type": "block", "start": 364, "end": 517, "line": 16, "text": "/**\n * Returns an iterable object that yields pattern matches over the input sequence.\n * Matches are of the form [startIndex, endIndex, tags].\n */" }, { "type": "line", "start": 925, "end": 955, "line": 37, "text": "// yield the last match if any" }, { "type": "line", "start": 1129, "end": 1192, "line": 40, "text": "// reset the state as if we started over from the initial state" }, { "type": "line", "start": 1291, "end": 1333, "line": 45, "text": "// start a run if not in the failure state" }, { "type": "line", "start": 1432, "end": 1477, "line": 50, "text": "// if accepting, mark the potential match end" }, { "type": "line", "start": 1562, "end": 1634, "line": 55, "text": "// reset the state to the initial state if we get into the failure state" }, { "type": "line", "start": 1732, "end": 1762, "line": 61, "text": "// yield the last match if any" }, { "type": "block", "start": 1944, "end": 2141, "line": 71, "text": "/**\n * For each match over the input sequence, action functions matching\n * the tag definitions in the input pattern are called with the startIndex,\n * endIndex, and sub-match sequence.\n */" }, { "type": "line", "start": 2428, "end": 2461, "line": 91, "text": "//# sourceMappingURL=index.js.map" } ] }, { "source": "node_modules/clone/clone.js", "sourceSha256": "27b2db27fafe0f8e35245d81f72ae6523132ce3fae68e4413953d888f62013a9", "comments": [ { "type": "block", "start": 41, "end": 866, "line": 4, "text": "/**\n * Clones (copies) an Object using deep copying.\n *\n * This function supports circular references by default, but if you are certain\n * there are no circular references in your object, you can save some CPU time\n * by calling clone(obj, false).\n *\n * Caution: if `circular` is false and `parent` contains circular references,\n * your program may enter an infinite loop and crash.\n *\n * @param `parent` - the object to be cloned\n * @param `circular` - set to true if the object to be cloned may contain\n * circular references. (optional - true by default)\n * @param `depth` - set to a number if the object is only to be cloned to\n * a particular depth. (optional - defaults to Infinity)\n * @param `prototype` - sets the prototype to be used when cloning an object.\n * (optional - defaults to parent prototype).\n*/" }, { "type": "line", "start": 1105, "end": 1180, "line": 30, "text": "// maintain two arrays for circular references, where corresponding parents" }, { "type": "line", "start": 1183, "end": 1218, "line": 31, "text": "// and children have the same index" }, { "type": "line", "start": 1436, "end": 1505, "line": 43, "text": "// recurse this function so we don't reset allParents and allChildren" }, { "type": "line", "start": 1545, "end": 1580, "line": 45, "text": "// cloning null always returns null" }, { "type": "line", "start": 2168, "end": 2187, "line": 67, "text": "// Node.js >= 4.5.0" }, { "type": "line", "start": 2262, "end": 2287, "line": 70, "text": "// Older Node.js versions" }, { "type": "block", "start": 3147, "end": 3389, "line": 114, "text": "/**\n * Simple flat clone using prototype, accepts only objects, usefull for property\n * override on FLAT configuration object (no nested props).\n *\n * USE WITH CAUTION! This may not behave as you wish if you do not know how this\n * works.\n */" }, { "type": "line", "start": 3560, "end": 3588, "line": 130, "text": "// private utility functions" } ] }, { "source": "node_modules/tiny-inflate/index.js", "sourceSha256": "203ccaa89e30ec4d6f9467a91758b0f55597424a817ea2107510bbadaab1b90d", "comments": [ { "type": "block", "start": 100, "end": 133, "line": 5, "text": "/* table of code length counts */" }, { "type": "block", "start": 172, "end": 210, "line": 6, "text": "/* code -> symbol translation table */" }, { "type": "block", "start": 403, "end": 435, "line": 18, "text": "/* dynamic length/symbol tree */" }, { "type": "block", "start": 464, "end": 491, "line": 19, "text": "/* dynamic distance tree */" }, { "type": "block", "start": 495, "end": 666, "line": 22, "text": "/* --------------------------------------------------- *\n * -- uninitialized global data (static structures) -- *\n * --------------------------------------------------- */" }, { "type": "block", "start": 719, "end": 768, "line": 29, "text": "/* extra bits and base tables for length codes */" }, { "type": "block", "start": 847, "end": 898, "line": 33, "text": "/* extra bits and base tables for distance codes */" }, { "type": "block", "start": 973, "end": 1016, "line": 37, "text": "/* special ordering of code length codes */" }, { "type": "block", "start": 1123, "end": 1185, "line": 44, "text": "/* used by tinf_decode_trees, avoids allocations every call */" }, { "type": "block", "start": 1255, "end": 1342, "line": 48, "text": "/* ----------------------- *\n * -- utility functions -- *\n * ----------------------- */" }, { "type": "block", "start": 1344, "end": 1382, "line": 52, "text": "/* build extra bits and base tables */" }, { "type": "block", "start": 1458, "end": 1480, "line": 56, "text": "/* build bits table */" }, { "type": "block", "start": 1595, "end": 1617, "line": 60, "text": "/* build base table */" }, { "type": "block", "start": 1711, "end": 1746, "line": 67, "text": "/* build the fixed huffman trees */" }, { "type": "block", "start": 1801, "end": 1830, "line": 71, "text": "/* build fixed length tree */" }, { "type": "block", "start": 2167, "end": 2198, "line": 83, "text": "/* build fixed distance tree */" }, { "type": "block", "start": 2311, "end": 2361, "line": 91, "text": "/* given an array of code lengths, build a tree */" }, { "type": "block", "start": 2461, "end": 2496, "line": 97, "text": "/* clear code length count table */" }, { "type": "block", "start": 2543, "end": 2596, "line": 100, "text": "/* scan symbol lengths, and sum code length counts */" }, { "type": "block", "start": 2676, "end": 2724, "line": 105, "text": "/* compute offset table for distribution sort */" }, { "type": "block", "start": 2812, "end": 2880, "line": 111, "text": "/* create code->symbol translation table (symbols sorted by code) */" }, { "type": "block", "start": 2983, "end": 3067, "line": 117, "text": "/* ---------------------- *\n * -- decode functions -- *\n * ---------------------- */" }, { "type": "block", "start": 3069, "end": 3105, "line": 121, "text": "/* get one bit from source stream */" }, { "type": "block", "start": 3134, "end": 3161, "line": 123, "text": "/* check if tag is empty */" }, { "type": "block", "start": 3189, "end": 3208, "line": 125, "text": "/* load next tag */" }, { "type": "block", "start": 3275, "end": 3301, "line": 130, "text": "/* shift bit out of tag */" }, { "type": "block", "start": 3359, "end": 3412, "line": 137, "text": "/* read a num bit value from a stream and add base */" }, { "type": "block", "start": 3699, "end": 3752, "line": 153, "text": "/* given a data stream and a tree, decode a symbol */" }, { "type": "block", "start": 3954, "end": 4003, "line": 163, "text": "/* get more bits while code value is above sum */" }, { "type": "block", "start": 4214, "end": 4269, "line": 179, "text": "/* given a data stream, decode dynamic trees from it */" }, { "type": "block", "start": 4361, "end": 4392, "line": 184, "text": "/* get 5 bits HLIT (257-286) */" }, { "type": "block", "start": 4432, "end": 4461, "line": 187, "text": "/* get 5 bits HDIST (1-32) */" }, { "type": "block", "start": 4500, "end": 4529, "line": 190, "text": "/* get 4 bits HCLEN (4-19) */" }, { "type": "block", "start": 4612, "end": 4660, "line": 195, "text": "/* read code lengths for code length alphabet */" }, { "type": "block", "start": 4697, "end": 4731, "line": 197, "text": "/* get 3 bits code length (0-7) */" }, { "type": "block", "start": 4810, "end": 4838, "line": 202, "text": "/* build code length tree */" }, { "type": "block", "start": 4888, "end": 4935, "line": 205, "text": "/* decode code lengths for the dynamic trees */" }, { "type": "block", "start": 5066, "end": 5121, "line": 211, "text": "/* copy previous code length 3-6 times (read 2 bits) */" }, { "type": "block", "start": 5307, "end": 5362, "line": 218, "text": "/* repeat code length 0 for 3-10 times (read 3 bits) */" }, { "type": "block", "start": 5508, "end": 5565, "line": 224, "text": "/* repeat code length 0 for 11-138 times (read 7 bits) */" }, { "type": "block", "start": 5712, "end": 5763, "line": 230, "text": "/* values 0-15 represent the actual code lengths */" }, { "type": "block", "start": 5822, "end": 5847, "line": 236, "text": "/* build dynamic trees */" }, { "type": "block", "start": 5937, "end": 6042, "line": 241, "text": "/* ----------------------------- *\n * -- block inflate functions -- *\n * ----------------------------- */" }, { "type": "block", "start": 6044, "end": 6103, "line": 245, "text": "/* given a stream and two trees, inflate a block of data */" }, { "type": "block", "start": 6210, "end": 6238, "line": 250, "text": "/* check for end of block */" }, { "type": "block", "start": 6427, "end": 6472, "line": 263, "text": "/* possibly get more bits from length code */" }, { "type": "block", "start": 6591, "end": 6638, "line": 268, "text": "/* possibly get more bits from distance code */" }, { "type": "block", "start": 6724, "end": 6740, "line": 271, "text": "/* copy match */" }, { "type": "block", "start": 6850, "end": 6893, "line": 279, "text": "/* inflate an uncompressed block of data */" }, { "type": "block", "start": 6979, "end": 7006, "line": 284, "text": "/* unread from bitbuffer */" }, { "type": "block", "start": 7083, "end": 7099, "line": 290, "text": "/* get length */" }, { "type": "block", "start": 7194, "end": 7230, "line": 294, "text": "/* get one's complement of length */" }, { "type": "block", "start": 7338, "end": 7356, "line": 298, "text": "/* check length */" }, { "type": "block", "start": 7455, "end": 7471, "line": 304, "text": "/* copy block */" }, { "type": "block", "start": 7555, "end": 7609, "line": 308, "text": "/* make sure we start next block on a byte boundary */" }, { "type": "block", "start": 7650, "end": 7690, "line": 314, "text": "/* inflate stream from source to dest */" }, { "type": "block", "start": 7804, "end": 7831, "line": 320, "text": "/* read final block flag */" }, { "type": "block", "start": 7866, "end": 7896, "line": 323, "text": "/* read block type (2 bits) */" }, { "type": "block", "start": 7939, "end": 7961, "line": 326, "text": "/* decompress block */" }, { "type": "block", "start": 8005, "end": 8040, "line": 329, "text": "/* decompress uncompressed block */" }, { "type": "block", "start": 8128, "end": 8175, "line": 333, "text": "/* decompress block with fixed huffman trees */" }, { "type": "block", "start": 8271, "end": 8320, "line": 337, "text": "/* decompress block with dynamic huffman trees */" }, { "type": "block", "start": 8782, "end": 8860, "line": 360, "text": "/* -------------------- *\n * -- initialization -- *\n * -------------------- */" }, { "type": "block", "start": 8862, "end": 8893, "line": 364, "text": "/* build fixed huffman trees */" }, { "type": "block", "start": 8935, "end": 8973, "line": 367, "text": "/* build extra bits and base tables */" }, { "type": "block", "start": 9079, "end": 9103, "line": 371, "text": "/* fix a special case */" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/streams.js", "sourceSha256": "90e23fca221adbfafd4cda38934920648781f4bb65d993fd6187fb7b270513ea", "comments": [] }, { "source": "node_modules/@pdf-lib/brotli/dec/bit_reader.js", "sourceSha256": "1c7488ebdbcb2dba8a61965f5458452fe8cac38c06c3db0cc5184408a5aacf77", "comments": [ { "type": "block", "start": 0, "end": 625, "line": 1, "text": "/* Copyright 2013 Google Inc. All Rights Reserved.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n Bit reading helpers\n*/" }, { "type": "block", "start": 957, "end": 1032, "line": 27, "text": "/* Input byte buffer, consist of a ringbuffer and a \"slack\" region where */" }, { "type": "block", "start": 1033, "end": 1089, "line": 28, "text": "/* bytes from the start of the ringbuffer are copied. */" }, { "type": "block", "start": 1198, "end": 1218, "line": 31, "text": "/* input callback */" }, { "type": "block", "start": 1407, "end": 1439, "line": 40, "text": "/* next input will write here */" }, { "type": "block", "start": 1466, "end": 1488, "line": 41, "text": "/* pre-fetched bits */" }, { "type": "block", "start": 1515, "end": 1544, "line": 42, "text": "/* byte position in stream */" }, { "type": "block", "start": 1571, "end": 1613, "line": 43, "text": "/* current bit-reading position in val_ */" }, { "type": "block", "start": 1640, "end": 1687, "line": 44, "text": "/* bit-reading end position from LSB of val_ */" }, { "type": "block", "start": 1714, "end": 1744, "line": 45, "text": "/* input stream is finished */" }, { "type": "block", "start": 1914, "end": 2404, "line": 56, "text": "/* Fills up the input ringbuffer by calling the input callback.\n\n Does nothing if there are at least 32 bytes present after current position.\n\n Returns 0 if either:\n - the input callback returned an error, or\n - there is no more input and the position is past the end of the stream.\n\n After encountering the end of the input stream, 32 additional zero bytes are\n copied to the ringbuffer, therefore it is safe to call this function after\n every 32 bytes of input is read.\n*/" }, { "type": "block", "start": 2935, "end": 2985, "line": 83, "text": "/* Store 32 bytes of zero after the stream end. */" }, { "type": "block", "start": 3104, "end": 3162, "line": 89, "text": "/* Copy the head of the ringbuffer to the slack region. */" }, { "type": "block", "start": 3401, "end": 3464, "line": 102, "text": "/* Guarantees that there are at least 24 bits in the buffer. */" }, { "type": "block", "start": 3764, "end": 3822, "line": 113, "text": "/* Reads the specified number of bits from Read Buffer. */" } ] }, { "source": "node_modules/@pdf-lib/brotli/node_modules/base64-js/index.js", "sourceSha256": "3bcee9eda04894ff32f5fd1cdb665a6ebeffa01e0c4512578505eed634bcd9cc", "comments": [ { "type": "line", "start": 410, "end": 471, "line": 17, "text": "// Support decoding URL-safe base64 strings, as Node.js does." }, { "type": "line", "start": 472, "end": 533, "line": 18, "text": "// See: https://en.wikipedia.org/wiki/Base64#URL_applications" }, { "type": "line", "start": 750, "end": 807, "line": 29, "text": "// Trim off extra bytes after placeholder bytes are found" }, { "type": "line", "start": 810, "end": 867, "line": 30, "text": "// See: https://github.com/beatgammit/base64-js/issues/42" }, { "type": "line", "start": 1056, "end": 1116, "line": 41, "text": "// base64 is 4/3 + up to two characters of the original data" }, { "type": "line", "start": 1632, "end": 1702, "line": 63, "text": "// if there are placeholders, only get up to the last complete 4 chars" }, { "type": "line", "start": 3102, "end": 3140, "line": 121, "text": "// if we have 1 byte left, pad 2 bytes" }, { "type": "line", "start": 3187, "end": 3211, "line": 123, "text": "// must be multiple of 3" }, { "type": "line", "start": 3215, "end": 3294, "line": 125, "text": "// go through the array every three bytes, we'll deal with trailing stuff later" }, { "type": "line", "start": 3487, "end": 3557, "line": 132, "text": "// pad the end with zeros, but make sure to not forget the extra bytes" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/dictionary.bin.js", "sourceSha256": "ac06c0a4b369ac16cb604b3dbacf0d5c739579e9324fffbb4388a7478a03c06c", "comments": [] }, { "source": "node_modules/@pdf-lib/brotli/dec/dictionary-data-compressed.js", "sourceSha256": "64dfe729e79d0b09f0c504a74a0c31ace11f160a7a98ab5d721690e5ff85bcb7", "comments": [ { "type": "block", "start": 36, "end": 316, "line": 3, "text": "/**\n * The normal dictionary-data.js is quite large, which makes it\n * unsuitable for browser usage. In order to make it smaller,\n * we read dictionary.bin, which is a compressed version of\n * the dictionary, and on initial load, Brotli decompresses\n * it's own dictionary. 😜\n */" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/dictionary.js", "sourceSha256": "cc74ff8ed49ebc1e499753f9df05eae6c0e3a5da7e4cf3b313934001f00dc021", "comments": [ { "type": "block", "start": 0, "end": 644, "line": 1, "text": "/* Copyright 2013 Google Inc. All Rights Reserved.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n Collection of static dictionary words.\n*/" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/huffman.js", "sourceSha256": "69cb67902c20896c89ae679d7c71b1f2274b34c51d4b235865396187f6d7e572", "comments": [ { "type": "block", "start": 58, "end": 99, "line": 2, "text": "/* number of bits used for this symbol */" }, { "type": "block", "start": 122, "end": 156, "line": 3, "text": "/* symbol value or table offset */" }, { "type": "block", "start": 218, "end": 362, "line": 10, "text": "/* Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the\n bit-wise reversal of the len least significant bits of key. */" }, { "type": "block", "start": 506, "end": 580, "line": 20, "text": "/* Stores code in table[0], table[step], table[2*step], ..., table[end] */" }, { "type": "block", "start": 581, "end": 634, "line": 21, "text": "/* Assumes that end is an integer multiple of step */" }, { "type": "block", "start": 797, "end": 978, "line": 29, "text": "/* Returns the table width of the next 2nd level table. count is the histogram\n of bit lengths for the remaining symbols, len is the code length of the next\n processed symbol */" }, { "type": "block", "start": 1364, "end": 1389, "line": 45, "text": "/* current table entry */" }, { "type": "block", "start": 1413, "end": 1438, "line": 46, "text": "/* current code length */" }, { "type": "block", "start": 1462, "end": 1508, "line": 47, "text": "/* symbol index in original or sorted table */" }, { "type": "block", "start": 1532, "end": 1558, "line": 48, "text": "/* reversed prefix code */" }, { "type": "block", "start": 1582, "end": 1634, "line": 49, "text": "/* step size to replicate values in current table */" }, { "type": "block", "start": 1658, "end": 1695, "line": 50, "text": "/* low bits for current root entry */" }, { "type": "block", "start": 1719, "end": 1742, "line": 51, "text": "/* mask for low bits */" }, { "type": "block", "start": 1766, "end": 1799, "line": 52, "text": "/* key length of current table */" }, { "type": "block", "start": 1823, "end": 1850, "line": 53, "text": "/* size of current table */" }, { "type": "block", "start": 1874, "end": 1928, "line": 54, "text": "/* sum of root table size and 2nd level table sizes */" }, { "type": "block", "start": 1952, "end": 1987, "line": 55, "text": "/* symbols sorted by code length */" }, { "type": "block", "start": 2035, "end": 2071, "line": 56, "text": "/* number of codes of each length */" }, { "type": "block", "start": 2120, "end": 2165, "line": 57, "text": "/* offsets in sorted table for each length */" }, { "type": "block", "start": 2216, "end": 2253, "line": 61, "text": "/* build histogram of code lengths */" }, { "type": "block", "start": 2355, "end": 2417, "line": 66, "text": "/* generate offsets into sorted symbol table by code length */" }, { "type": "block", "start": 2533, "end": 2597, "line": 72, "text": "/* sort symbols by length, by symbol order within each length */" }, { "type": "block", "start": 2851, "end": 2894, "line": 83, "text": "/* special case code with only one value */" }, { "type": "block", "start": 3087, "end": 3111, "line": 92, "text": "/* fill in root table */" }, { "type": "block", "start": 3432, "end": 3493, "line": 103, "text": "/* fill in 2nd level tables and add pointers to root table */" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/context.js", "sourceSha256": "5cd72c7ce643693ff902cd9c1ada003b45f70b4daec1bfb1a6a4a842efca811e", "comments": [ { "type": "block", "start": 0, "end": 4852, "line": 1, "text": "/* Copyright 2013 Google Inc. All Rights Reserved.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n Lookup table to map the previous two bytes to a context id.\n\n There are four different context modeling modes defined here:\n CONTEXT_LSB6: context id is the least significant 6 bits of the last byte,\n CONTEXT_MSB6: context id is the most significant 6 bits of the last byte,\n CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text,\n CONTEXT_SIGNED: second-order context model tuned for signed integers.\n\n The context id for the UTF8 context model is calculated as follows. If p1\n and p2 are the previous two bytes, we calcualte the context as\n\n context = kContextLookup[p1] | kContextLookup[p2 + 256].\n\n If the previous two bytes are ASCII characters (i.e. < 128), this will be\n equivalent to\n\n context = 4 * context1(p1) + context2(p2),\n\n where context1 is based on the previous byte in the following way:\n\n 0 : non-ASCII control\n 1 : \\t, \\n, \\r\n 2 : space\n 3 : other punctuation\n 4 : \" '\n 5 : %\n 6 : ( < [ {\n 7 : ) > ] }\n 8 : , ; :\n 9 : .\n 10 : =\n 11 : number\n 12 : upper-case vowel\n 13 : upper-case consonant\n 14 : lower-case vowel\n 15 : lower-case consonant\n\n and context2 is based on the second last byte:\n\n 0 : control, space\n 1 : punctuation\n 2 : upper-case letter, number\n 3 : lower-case letter\n\n If the last byte is ASCII, and the second last byte is not (in a valid UTF8\n stream it will be a continuation byte, value between 128 and 191), the\n context is the same as if the second last byte was an ASCII control or space.\n\n If the last byte is a UTF8 lead byte (value >= 192), then the next byte will\n be a continuation byte and the context id is 2 or 3 depending on the LSB of\n the last byte and to a lesser extent on the second last byte if it is ASCII.\n\n If the last byte is a UTF8 continuation byte, the second last byte can be:\n - continuation byte: the next byte is probably ASCII or lead byte (assuming\n 4-byte UTF8 characters are rare) and the context id is 0 or 1.\n - lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1\n - lead byte (208 - 255): next byte is continuation byte, context is 2 or 3\n\n The possible value combinations of the previous two bytes, the range of\n context ids and the type of the next byte is summarized in the table below:\n\n |--------\\-----------------------------------------------------------------|\n | \\ Last byte |\n | Second \\---------------------------------------------------------------|\n | last byte \\ ASCII | cont. byte | lead byte |\n | \\ (0-127) | (128-191) | (192-) |\n |=============|===================|=====================|==================|\n | ASCII | next: ASCII/lead | not valid | next: cont. |\n | (0-127) | context: 4 - 63 | | context: 2 - 3 |\n |-------------|-------------------|---------------------|------------------|\n | cont. byte | next: ASCII/lead | next: ASCII/lead | next: cont. |\n | (128-191) | context: 4 - 63 | context: 0 - 1 | context: 2 - 3 |\n |-------------|-------------------|---------------------|------------------|\n | lead byte | not valid | next: ASCII/lead | not valid |\n | (192-207) | | context: 0 - 1 | |\n |-------------|-------------------|---------------------|------------------|\n | lead byte | not valid | next: cont. | not valid |\n | (208-) | | context: 2 - 3 | |\n |-------------|-------------------|---------------------|------------------|\n\n The context id for the signed context mode is calculated as:\n\n context = (kContextLookup[512 + p1] << 3) | kContextLookup[512 + p2].\n\n For any context modeling modes, the context ids can be calculated by |-ing\n together two lookups from one table using context model dependent offsets:\n\n context = kContextLookup[offset1 + p1] | kContextLookup[offset2 + p2].\n\n where offset1 and offset2 are dependent on the context mode.\n*/" }, { "type": "block", "start": 4975, "end": 5031, "line": 112, "text": "/* Common context lookup table for all context modes. */" }, { "type": "block", "start": 5068, "end": 5098, "line": 114, "text": "/* CONTEXT_UTF8, last byte. */" }, { "type": "block", "start": 5101, "end": 5119, "line": 115, "text": "/* ASCII range. */" }, { "type": "block", "start": 5650, "end": 5685, "line": 124, "text": "/* UTF8 continuation byte range. */" }, { "type": "block", "start": 5888, "end": 5915, "line": 129, "text": "/* UTF8 lead byte range. */" }, { "type": "block", "start": 6118, "end": 6154, "line": 134, "text": "/* CONTEXT_UTF8 second last byte. */" }, { "type": "block", "start": 6157, "end": 6175, "line": 135, "text": "/* ASCII range. */" }, { "type": "block", "start": 6578, "end": 6613, "line": 144, "text": "/* UTF8 continuation byte range. */" }, { "type": "block", "start": 6866, "end": 6893, "line": 150, "text": "/* UTF8 lead byte range. */" }, { "type": "block", "start": 7046, "end": 7085, "line": 154, "text": "/* CONTEXT_SIGNED, second last byte. */" }, { "type": "block", "start": 7888, "end": 7964, "line": 171, "text": "/* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */" }, { "type": "block", "start": 9008, "end": 9038, "line": 188, "text": "/* CONTEXT_LSB6, last byte. */" }, { "type": "block", "start": 10097, "end": 10127, "line": 205, "text": "/* CONTEXT_MSB6, last byte. */" }, { "type": "block", "start": 11186, "end": 11227, "line": 222, "text": "/* CONTEXT_{M,L}SB6, second last byte, */" }, { "type": "block", "start": 12077, "end": 12095, "line": 242, "text": "/* CONTEXT_LSB6 */" }, { "type": "block", "start": 12112, "end": 12130, "line": 244, "text": "/* CONTEXT_MSB6 */" }, { "type": "block", "start": 12147, "end": 12165, "line": 246, "text": "/* CONTEXT_UTF8 */" }, { "type": "block", "start": 12178, "end": 12198, "line": 248, "text": "/* CONTEXT_SIGNED */" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/prefix.js", "sourceSha256": "e65fb2183d6fc1058020ba55939ea08334d39ae33bf4832d952d9acab5db2d8a", "comments": [ { "type": "block", "start": 0, "end": 754, "line": 1, "text": "/* Copyright 2013 Google Inc. All Rights Reserved.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n Lookup tables to map prefix codes to value ranges. This is used during\n decoding of the block lengths, literal insertion lengths and copy lengths.\n*/" }, { "type": "block", "start": 756, "end": 820, "line": 19, "text": "/* Represents the range of values belonging to a prefix code: */" }, { "type": "block", "start": 821, "end": 853, "line": 20, "text": "/* [offset, offset + 2^nbits) */" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/transform.js", "sourceSha256": "56c0ebea0ce70b4d7afa7225eca2e5c9e0046dbdc9a4d6b568c5d5f4b47f170b", "comments": [ { "type": "block", "start": 0, "end": 642, "line": 1, "text": "/* Copyright 2013 Google Inc. All Rights Reserved.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n Transformations on dictionary words.\n*/" }, { "type": "block", "start": 9684, "end": 9739, "line": 189, "text": "/* An overly simplified uppercasing model for utf-8. */" }, { "type": "block", "start": 9804, "end": 9859, "line": 195, "text": "/* An arbitrary transform for three byte characters. */" } ] }, { "source": "node_modules/@pdf-lib/brotli/dec/decode.js", "sourceSha256": "b0130dead682abd005efcc91bde9ff4059e236e5fdb36d61b1e817c3713a0435", "comments": [ { "type": "block", "start": 0, "end": 601, "line": 1, "text": "/* Copyright 2013 Google Inc. All Rights Reserved.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n*/" }, { "type": "block", "start": 1315, "end": 1430, "line": 36, "text": "/* Maximum possible Huffman table size for an alphabet size of 704, max code\n * length 15 and root table bits 8. */" }, { "type": "block", "start": 2261, "end": 2330, "line": 78, "text": "/* Decodes a number in the range [0..255], by reading 1 - 11 bits. */" }, { "type": "block", "start": 3819, "end": 3871, "line": 146, "text": "/* Decodes the next Huffman code from bit-stream. */" }, { "type": "block", "start": 6402, "end": 6542, "line": 240, "text": "/* simple_code_or_skip is used as follows:\n 1 for simple code;\n 0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */" }, { "type": "block", "start": 6622, "end": 6672, "line": 245, "text": "/* Read symbols, codes & code lengths directly. */" }, { "type": "block", "start": 8119, "end": 8159, "line": 296, "text": "/* Decode Huffman-coded code lengths. */" }, { "type": "block", "start": 8288, "end": 8346, "line": 301, "text": "/* Static Huffman code for the code length code lengths */" }, { "type": "block", "start": 10570, "end": 10643, "line": 378, "text": "/* Contains a collection of huffman trees with the same alphabet size. */" }, { "type": "block", "start": 13470, "end": 13511, "line": 479, "text": "/* For short lengths copy byte-by-byte */" }, { "type": "block", "start": 13910, "end": 13968, "line": 496, "text": "/* Copy remaining 0-4 bytes from br.val_ to ringbuffer. */" }, { "type": "block", "start": 14104, "end": 14158, "line": 504, "text": "/* Copy remaining bytes from br.buf_ to ringbuffer. */" }, { "type": "block", "start": 14608, "end": 14759, "line": 523, "text": "/* If we wrote past the logical end of the ringbuffer, copy the tail of the\n ringbuffer to its beginning and flush the ringbuffer to the output. */" }, { "type": "block", "start": 14940, "end": 15115, "line": 532, "text": "/* If we have more to copy than the remaining size of the ringbuffer, then we\n first fill the ringbuffer from the input and then flush the ringbuffer to\n the output */" }, { "type": "block", "start": 15408, "end": 15530, "line": 545, "text": "/* Copy straight from the input onto the ringbuffer. The ringbuffer will be\n flushed to the output at a later time. */" }, { "type": "block", "start": 15666, "end": 15708, "line": 551, "text": "/* Restore the state of the bit reader. */" }, { "type": "block", "start": 15726, "end": 15845, "line": 555, "text": "/* Advances the bit reader position to the next byte boundary and verifies\n that any skipped bits are set to zero. */" }, { "type": "block", "start": 17043, "end": 17118, "line": 605, "text": "/* This ring buffer holds a few past copy distances that will be used by */" }, { "type": "block", "start": 17121, "end": 17155, "line": 606, "text": "/* some special distance codes. */" }, { "type": "block", "start": 17216, "end": 17260, "line": 609, "text": "/* The previous 2 bytes used for context. */" }, { "type": "block", "start": 17466, "end": 17682, "line": 617, "text": "/* We need the slack region for the following reasons:\n - always doing two 8-byte copies for fast backward copying\n - transforms\n - flushing the input ringbuffer when decoding uncompressed blocks */" }, { "type": "block", "start": 17790, "end": 17815, "line": 625, "text": "/* Decode window size. */" }, { "type": "block", "start": 19515, "end": 19582, "line": 679, "text": "/* We need to grow the output buffer to fit the additional data. */" }, { "type": "block", "start": 19959, "end": 19993, "line": 692, "text": "/* Read one byte and ignore it. */" }, { "type": "block", "start": 26413, "end": 26487, "line": 856, "text": "/* Convert the distance code to the actual distance by possibly looking */" }, { "type": "block", "start": 26494, "end": 26538, "line": 857, "text": "/* up past distnaces from the ringbuffer. */" }, { "type": "block", "start": 29156, "end": 29226, "line": 922, "text": "/* When we get here, we must have inserted at least one literal and */" }, { "type": "block", "start": 29233, "end": 29305, "line": 923, "text": "/* made a copy of at least length two, therefore accessing the last 2 */" }, { "type": "block", "start": 29312, "end": 29333, "line": 924, "text": "/* bytes is valid. */" }, { "type": "block", "start": 29465, "end": 29538, "line": 929, "text": "/* Protect pos from overflow, wrap it around at every GB of input data */" } ] }, { "source": "node_modules/@pdf-lib/brotli/decompress.js", "sourceSha256": "a8aa73fda6d64d69ddc097d75b309322c190d1c733a2d4321c053b79c4a9cc9b", "comments": [] } ] }