npm - @loaders.gl/loader-utils - Versions diffs - 3.4.0-alpha.2 → 3.4.0-alpha.3 - Mend

@loaders.gl/loader-utils 3.4.0-alpha.2 → 3.4.0-alpha.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (125) hide show

package/dist/es5/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["// TYPES\nexport type {\n Loader,\n LoaderWithParser,\n LoaderContext,\n LoaderOptions,\n Writer,\n WriterOptions,\n DataType,\n SyncDataType,\n BatchableDataType,\n IFileSystem,\n IRandomAccessReadFileSystem\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {\n isBrowser,\n isWorker,\n nodeVersion,\n self,\n window,\n global,\n document\n} from './lib/env-utils/globals';\n\nexport {mergeLoaderOptions} from './lib/option-utils/merge-loader-options';\n\n// LOADERS.GL-SPECIFIC WORKER UTILS\nexport {createLoaderWorker} from './lib/worker-loader-utils/create-loader-worker';\nexport {parseWithWorker, canParseWithWorker} from './lib/worker-loader-utils/parse-with-worker';\nexport {canEncodeWithWorker} from './lib/worker-loader-utils/encode-with-worker';\n\n// PARSER UTILS\nexport {parseJSON} from './lib/parser-utils/parse-json';\n\n// MEMORY COPY UTILS\nexport {\n sliceArrayBuffer,\n concatenateArrayBuffers,\n concatenateTypedArrays,\n compareArrayBuffers\n} from './lib/binary-utils/array-buffer-utils';\nexport {padToNBytes, copyToArray, copyArrayBuffer} from './lib/binary-utils/memory-copy-utils';\nexport {\n padStringToByteAlignment,\n copyStringToDataView,\n copyBinaryToDataView,\n copyPaddedArrayBufferToDataView,\n copyPaddedStringToDataView\n} from './lib/binary-utils/dataview-copy-utils';\nexport {getFirstCharacters, getMagicString} from './lib/binary-utils/get-first-characters';\n\n// ITERATOR UTILS\nexport {\n makeTextEncoderIterator,\n makeTextDecoderIterator,\n makeLineIterator,\n makeNumberedLineIterator\n} from './lib/iterators/text-iterators';\nexport {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-iteration';\n\n// REQUEST UTILS\nexport {default as RequestScheduler} from './lib/request-utils/request-scheduler';\n\n// PATH HELPERS\nexport {setPathPrefix, getPathPrefix, resolvePath} from './lib/path-utils/file-aliases';\nexport {addAliases as _addAliases} from './lib/path-utils/file-aliases';\n\n// MICRO LOADERS\nexport {JSONLoader} from './json-loader';\n\n// NODE support\n\n// Node.js emulation (can be used in browser)\n\n// Avoid direct use of `Buffer` which pulls in 50KB polyfill\nexport {isBuffer, toBuffer, toArrayBuffer} from './lib/binary-utils/memory-conversion-utils';\n\n// Note.js wrappers (can be safely imported, but not used in browser)\n\n// Use instead of importing 'util' to avoid node dependencies\nexport {promisify1, promisify2} from './lib/node/promisify';\n\n// `path` replacement (avoids bundling big path polyfill)\nimport * as path from './lib/path-utils/path';\nexport {path};\n\n// Use instead of importing 'fs' to avoid node dependencies`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// Use instead of importing 'stream' to avoid node dependencies`\nimport * as stream from './lib/node/stream';\nexport {stream};\n\n// EXPERIMENTAL\nexport type {ReadableFile} from './lib/filesystems/readable-file';\nexport {makeReadableFile} from './lib/filesystems/readable-file';\n\nexport type {WritableFile} from './lib/filesystems/writable-file';\nexport {makeWritableFile} from './lib/filesystems/writable-file';\n\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA;AACA;AAUA;AAGA;AACA;AACA;AAGA;AAGA;AAMA;AACA;AAOA;AAGA;AAMA;AAGA;AAGA;AAIA;AAOA;AAKA;AAGA;~~AAA8C~~;AAI9C;~~AAAoC~~;AAIpC;~~AAA4C~~;AAK5C;AAGA;AAEA;AAA6E;AAAA"}
1	+ {"version":3,"file":"index.js","names":["_assert","require","_globals","_mergeLoaderOptions","_createLoaderWorker","_parseWithWorker","_encodeWithWorker","_parseJson","_arrayBufferUtils","_memoryCopyUtils","_dataviewCopyUtils","_getFirstCharacters","_textIterators","_asyncIteration","_requestScheduler","_interopRequireDefault","_fileAliases","_jsonLoader","_memoryConversionUtils","_promisify","path","_interopRequireWildcard","exports","fs","stream","_readableFile","_writableFile","_nodeFilesystem","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set"],"sources":["../../src/index.ts"],"sourcesContent":["// TYPES\nexport type {\n Loader,\n LoaderWithParser,\n LoaderContext,\n LoaderOptions,\n Writer,\n WriterOptions,\n DataType,\n SyncDataType,\n BatchableDataType,\n IFileSystem,\n IRandomAccessReadFileSystem\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {\n isBrowser,\n isWorker,\n nodeVersion,\n self,\n window,\n global,\n document\n} from './lib/env-utils/globals';\n\nexport {mergeLoaderOptions} from './lib/option-utils/merge-loader-options';\n\n// LOADERS.GL-SPECIFIC WORKER UTILS\nexport {createLoaderWorker} from './lib/worker-loader-utils/create-loader-worker';\nexport {parseWithWorker, canParseWithWorker} from './lib/worker-loader-utils/parse-with-worker';\nexport {canEncodeWithWorker} from './lib/worker-loader-utils/encode-with-worker';\n\n// PARSER UTILS\nexport {parseJSON} from './lib/parser-utils/parse-json';\n\n// MEMORY COPY UTILS\nexport {\n sliceArrayBuffer,\n concatenateArrayBuffers,\n concatenateTypedArrays,\n compareArrayBuffers\n} from './lib/binary-utils/array-buffer-utils';\nexport {padToNBytes, copyToArray, copyArrayBuffer} from './lib/binary-utils/memory-copy-utils';\nexport {\n padStringToByteAlignment,\n copyStringToDataView,\n copyBinaryToDataView,\n copyPaddedArrayBufferToDataView,\n copyPaddedStringToDataView\n} from './lib/binary-utils/dataview-copy-utils';\nexport {getFirstCharacters, getMagicString} from './lib/binary-utils/get-first-characters';\n\n// ITERATOR UTILS\nexport {\n makeTextEncoderIterator,\n makeTextDecoderIterator,\n makeLineIterator,\n makeNumberedLineIterator\n} from './lib/iterators/text-iterators';\nexport {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-iteration';\n\n// REQUEST UTILS\nexport {default as RequestScheduler} from './lib/request-utils/request-scheduler';\n\n// PATH HELPERS\nexport {setPathPrefix, getPathPrefix, resolvePath} from './lib/path-utils/file-aliases';\nexport {addAliases as _addAliases} from './lib/path-utils/file-aliases';\n\n// MICRO LOADERS\nexport {JSONLoader} from './json-loader';\n\n// NODE support\n\n// Node.js emulation (can be used in browser)\n\n// Avoid direct use of `Buffer` which pulls in 50KB polyfill\nexport {isBuffer, toBuffer, toArrayBuffer} from './lib/binary-utils/memory-conversion-utils';\n\n// Note.js wrappers (can be safely imported, but not used in browser)\n\n// Use instead of importing 'util' to avoid node dependencies\nexport {promisify1, promisify2} from './lib/node/promisify';\n\n// `path` replacement (avoids bundling big path polyfill)\nimport * as path from './lib/path-utils/path';\nexport {path};\n\n// Use instead of importing 'fs' to avoid node dependencies`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// Use instead of importing 'stream' to avoid node dependencies`\nimport * as stream from './lib/node/stream';\nexport {stream};\n\n// EXPERIMENTAL\nexport type {ReadableFile} from './lib/filesystems/readable-file';\nexport {makeReadableFile} from './lib/filesystems/readable-file';\n\nexport type {WritableFile} from './lib/filesystems/writable-file';\nexport {makeWritableFile} from './lib/filesystems/writable-file';\n\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n"],"mappings":"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"}

package/dist/es5/json-loader.js CHANGED Viewed

@@ -7,8 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports._typecheckJSONLoader = exports.JSONLoader = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var VERSION = typeof "3.4.0-alpha.2" !== 'undefined' ? "3.4.0-alpha.2" : 'latest';
+var VERSION = typeof "3.4.0-alpha.3" !== 'undefined' ? "3.4.0-alpha.3" : 'latest';
 var JSONLoader = {
   name: 'JSON',
   id: 'json',
@@ -22,14 +21,12 @@ var JSONLoader = {
   parse: function () {
     var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer) {
       return _regenerator.default.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              return _context.abrupt("return", parseTextSync(new TextDecoder().decode(arrayBuffer)));
-            case 1:
-            case "end":
-              return _context.stop();
-          }
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", parseTextSync(new TextDecoder().decode(arrayBuffer)));
+          case 1:
+          case "end":
+            return _context.stop();
         }
       }, _callee);
     }));
@@ -40,7 +37,6 @@ var JSONLoader = {
   }(),
   options: {}
 };
 exports.JSONLoader = JSONLoader;
 function parseTextSync(text) {
   return JSON.parse(text);

package/dist/es5/json-loader.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"json-loader.js","names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","arrayBuffer","TextDecoder","decode","options","JSON","_typecheckJSONLoader"],"sources":["../../src/json-loader.ts"],"sourcesContent":["import type {LoaderWithParser} from './types';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/*\n A JSON Micro loader (minimal bundle size)\n * Alternative to `@loaders.gl/json`\n */\nexport const JSONLoader = {\n name: 'JSON',\n id: 'json',\n module: 'json',\n version: VERSION,\n extensions: ['json', 'geojson'],\n mimeTypes: ['application/json'],\n category: 'json',\n text: true,\n parseTextSync,\n parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),\n options: {}\n};\n\n// TODO - deprecated\nfunction parseTextSync(text) {\n return JSON.parse(text);\n}\n\nexport const _typecheckJSONLoader: LoaderWithParser = JSONLoader;\n"],"mappings":";;;;;;;;;AAIA,IAAMA,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;;AAMpE,IAAMC,UAAU,GAAG;EACxBC,IAAI,EAAE,MAAM;EACZC,EAAE,EAAE,MAAM;EACVC,MAAM,EAAE,MAAM;EACdC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC;EAC/BC,SAAS,EAAE,CAAC,kBAAkB,CAAC;EAC/BC,QAAQ,EAAE,MAAM;EAChBC,IAAI,EAAE,IAAI;EACVC,aAAa,EAAbA,aAAa;EACbC,KAAK;IAAA,~~uEAAE~~,~~iBAAOC~~,WAAW;MAAA;QAAA;UAAA;YAAA~~;cAAA~~,~~iCAAKF~~,aAAa,CAAC,~~IAAIG~~,WAAW,EAAE,CAACC,MAAM,~~CAACF~~,WAAW,CAAC,CAAC;~~YAAA~~;~~YAAA;cAAA;~~UAAA;QAAA;MAAA;IAAA;IAAA;MAAA;IAAA;IAAA;EAAA;~~EAClFG~~,OAAO,EAAE,CAAC;AACZ,CAAC~~;;AAAC~~;AAGF,~~SAASL~~,~~aAAa~~,CAACD,IAAI,EAAE;EAC3B,~~OAAOO~~,IAAI,~~CAACL~~,KAAK,CAACF,IAAI,CAAC;AACzB;AAEO,~~IAAMQ~~,oBAAsC,~~GAAGhB~~,UAAU;AAAC"}
1	+ {"version":3,"file":"json-loader.js","names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","_parse","_asyncToGenerator2","default","_regenerator","mark","_callee","arrayBuffer","wrap","_callee$","_context","prev","next","abrupt","TextDecoder","decode","stop","_x","apply","arguments","options","exports","JSON","_typecheckJSONLoader"],"sources":["../../src/json-loader.ts"],"sourcesContent":["import type {LoaderWithParser} from './types';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/*\n A JSON Micro loader (minimal bundle size)\n * Alternative to `@loaders.gl/json`\n */\nexport const JSONLoader = {\n name: 'JSON',\n id: 'json',\n module: 'json',\n version: VERSION,\n extensions: ['json', 'geojson'],\n mimeTypes: ['application/json'],\n category: 'json',\n text: true,\n parseTextSync,\n parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),\n options: {}\n};\n\n// TODO - deprecated\nfunction parseTextSync(text) {\n return JSON.parse(text);\n}\n\nexport const _typecheckJSONLoader: LoaderWithParser = JSONLoader;\n"],"mappings":";;;;;;;;;AAIA,IAAMA,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAMpE,IAAMC,UAAU,GAAG;EACxBC,IAAI,EAAE,MAAM;EACZC,EAAE,EAAE,MAAM;EACVC,MAAM,EAAE,MAAM;EACdC,OAAO,EAAEL,OAAO;EAChBM,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC;EAC/BC,SAAS,EAAE,CAAC,kBAAkB,CAAC;EAC/BC,QAAQ,EAAE,MAAM;EAChBC,IAAI,EAAE,IAAI;EACVC,aAAa,EAAbA,aAAa;EACbC,KAAK;IAAA,IAAAC,MAAA,OAAAC,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAE,SAAAC,QAAOC,WAAW;MAAA,OAAAH,YAAA,CAAAD,OAAA,CAAAK,IAAA,UAAAC,SAAAC,QAAA;QAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;UAAA;YAAA,OAAAF,QAAA,CAAAG,MAAA,WAAKd,aAAa,CAAC,IAAIe,WAAW,EAAE,CAACC,MAAM,CAACR,WAAW,CAAC,CAAC;UAAA;UAAA;YAAA,OAAAG,QAAA,CAAAM,IAAA;QAAA;MAAA,GAAAV,OAAA;IAAA;IAAA,SAAAN,MAAAiB,EAAA;MAAA,OAAAhB,MAAA,CAAAiB,KAAA,OAAAC,SAAA;IAAA;IAAA,OAAAnB,KAAA;EAAA;EAClFoB,OAAO,EAAE,CAAC;AACZ,CAAC;AAACC,OAAA,CAAA/B,UAAA,GAAAA,UAAA;AAGF,SAASS,aAAaA,CAACD,IAAI,EAAE;EAC3B,OAAOwB,IAAI,CAACtB,KAAK,CAACF,IAAI,CAAC;AACzB;AAEO,IAAMyB,oBAAsC,GAAGjC,UAAU;AAAC+B,OAAA,CAAAE,oBAAA,GAAAA,oBAAA"}

package/dist/es5/lib/binary-utils/array-buffer-utils.js CHANGED Viewed

@@ -9,7 +9,7 @@ exports.concatenateTypedArrays = concatenateTypedArrays;
 exports.sliceArrayBuffer = sliceArrayBuffer;
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
   byteLength = byteLength || arrayBuffer1.byteLength;
   if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
@@ -24,7 +24,6 @@ function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
   }
   return true;
 }
 function concatenateArrayBuffers() {
   for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
     sources[_key] = arguments[_key];
@@ -32,13 +31,10 @@ function concatenateArrayBuffers() {
   var sourceArrays = sources.map(function (source2) {
     return source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2;
   });
   var byteLength = sourceArrays.reduce(function (length, typedArray) {
     return length + typedArray.byteLength;
   }, 0);
   var result = new Uint8Array(byteLength);
   var offset = 0;
   var _iterator = _createForOfIteratorHelper(sourceArrays),
     _step;
@@ -48,7 +44,6 @@ function concatenateArrayBuffers() {
       result.set(sourceArray, offset);
       offset += sourceArray.byteLength;
     }
   } catch (err) {
     _iterator.e(err);
   } finally {
@@ -56,7 +51,6 @@ function concatenateArrayBuffers() {
   }
   return result.buffer;
 }
 function concatenateTypedArrays() {
   for (var _len2 = arguments.length, typedArrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
     typedArrays[_key2] = arguments[_key2];
@@ -78,7 +72,6 @@ function concatenateTypedArrays() {
   }
   return result;
 }
 function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
   var subArray = byteLength !== undefined ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
   var arrayCopy = new Uint8Array(subArray);

package/dist/es5/lib/binary-utils/array-buffer-utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"array-buffer-utils.js","names":["compareArrayBuffers","arrayBuffer1","arrayBuffer2","byteLength","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","sources","sourceArrays","map","source2","ArrayBuffer","reduce","typedArray","result","offset","sourceArray","set","buffer","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","constructor","Error","sumLength","acc","~~value~~","array","sliceArrayBuffer","arrayBuffer","byteOffset","subArray","undefined","subarray","arrayCopy"],"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\n\n/*\n compare two binary arrays for equality\n * @param a\n * @param b\n * @param byteLength\n /\nexport function compareArrayBuffers(\n arrayBuffer1: ArrayBuffer,\n arrayBuffer2: ArrayBuffer,\n byteLength?: number\n): boolean {\n byteLength = byteLength \|\| arrayBuffer1.byteLength;\n if (arrayBuffer1.byteLength < byteLength \|\| arrayBuffer2.byteLength < byteLength) {\n return false;\n }\n const array1 = new Uint8Array(arrayBuffer1);\n const array2 = new Uint8Array(arrayBuffer2);\n for (let i = 0; i < array1.length; ++i) {\n if (array1[i] !== array2[i]) {\n return false;\n }\n }\n return true;\n}\n\n/\n Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n /\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer \| Uint8Array)[]): ArrayBuffer {\n // Make sure all inputs are wrapped in typed arrays\n const sourceArrays = sources.map((source2) =>\n source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n );\n\n // Get length of all inputs\n const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n // Allocate array with space for all inputs\n const result = new Uint8Array(byteLength);\n\n // Copy the subarrays\n let offset = 0;\n for (const sourceArray of sourceArrays) {\n result.set(sourceArray, offset);\n offset += sourceArray.byteLength;\n }\n\n // We work with ArrayBuffers, discard the typed array wrapper\n return result.buffer;\n}\n\n/\n Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n /\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n // @ts-ignore\n const arrays = typedArrays as TypedArray[];\n // @ts-ignore\n const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) \|\| null;\n if (!TypedArrayConstructor) {\n throw new Error(\n '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n );\n }\n\n const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n // @ts-ignore typescript does not like dynamic constructors\n const result = new TypedArrayConstructor(sumLength);\n let offset = 0;\n for (const array of arrays) {\n result.set(array, offset);\n offset += array.length;\n }\n return result;\n}\n\n/\n Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n arrayBuffer: ArrayBuffer,\n byteOffset: number,\n byteLength?: number\n): ArrayBuffer {\n const subArray =\n byteLength !== undefined\n ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n : new Uint8Array(arrayBuffer).subarray(byteOffset);\n const arrayCopy = new Uint8Array(subArray);\n return arrayCopy.buffer;\n}\n"],"mappings":";;;;;;;;;;;;AAQO,SAASA,~~mBAAmB~~,CACjCC,YAAyB,EACzBC,YAAyB,EACzBC,UAAmB,EACV;EACTA,UAAU,GAAGA,UAAU,IAAIF,YAAY,CAACE,UAAU;EAClD,IAAIF,YAAY,CAACE,UAAU,GAAGA,UAAU,IAAID,YAAY,CAACC,UAAU,GAAGA,UAAU,EAAE;IAChF,OAAO,KAAK;EACd;EACA,IAAMC,MAAM,GAAG,IAAIC,UAAU,CAACJ,YAAY,CAAC;EAC3C,IAAMK,MAAM,GAAG,IAAID,UAAU,CAACH,YAAY,CAAC;EAC3C,KAAK,IAAIK,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,MAAM,CAACI,MAAM,EAAE,EAAED,CAAC,EAAE;IACtC,IAAIH,MAAM,CAACG,CAAC,CAAC,KAAKD,MAAM,CAACC,CAAC,CAAC,EAAE;MAC3B,OAAO,KAAK;IACd;EACF;EACA,OAAO,IAAI;AACb;;AAMO,SAASE,~~uBAAuB~~,~~GAAwD~~;EAAA,~~kCAApDC~~,OAAO;~~IAAPA~~,OAAO;EAAA;EAEhD,IAAMC,YAAY,~~GAAGD~~,OAAO,~~CAACE~~,GAAG,CAAC,UAACC,OAAO;IAAA,OACvCA,OAAO,YAAYC,WAAW,GAAG,~~IAAIT~~,UAAU,~~CAACQ~~,OAAO,CAAC,GAAGA,OAAO;EAAA,EACnE;;EAGD,~~IAAMV~~,UAAU,~~GAAGQ~~,YAAY,CAACI,MAAM,CAAC,~~UAACP~~,MAAM,~~EAAEQ~~,UAAU;IAAA,~~OAAKR~~,MAAM,~~GAAGQ~~,UAAU,~~CAACb~~,UAAU;EAAA,GAAE,CAAC,CAAC;;EAGjG,~~IAAMc~~,MAAM,GAAG,~~IAAIZ~~,UAAU,CAACF,UAAU,CAAC;;EAGzC,~~IAAIe~~,MAAM,GAAG,CAAC;EAAC,~~2CACWP~~,YAAY;~~IAAA~~;EAAA;IAAtC,~~oDAAwC~~;MAAA,~~IAA7BQ~~,WAAW;~~MACpBF~~,MAAM,~~CAACG~~,GAAG,~~CAACD~~,WAAW,~~EAAED~~,MAAM,CAAC;MAC/BA,MAAM,~~IAAIC~~,WAAW,~~CAAChB~~,UAAU;IAClC;;EAAC;~~IAAA~~;EAAA;~~IAAA~~;EAAA;EAGD,~~OAAOc~~,MAAM,~~CAACI~~,MAAM;AACtB;;AAQO,SAASC,~~sBAAsB~~,~~GAA4B~~;EAAA,~~mCAArBC~~,WAAW;~~IAAXA~~,WAAW;EAAA;EAEtD,IAAMC,MAAM,~~GAAGD~~,WAA2B;EAE1C,~~IAAME~~,qBAAqB,GAAID,MAAM,IAAIA,MAAM,~~CAAChB~~,MAAM,GAAG,CAAC,~~IAAIgB~~,MAAM,CAAC,CAAC,CAAC,CAACE,WAAW,IAAK,IAAI;EAC5F,IAAI,CAACD,qBAAqB,EAAE;IAC1B,MAAM,IAAIE,KAAK,CACb,sGAAsG,CACvG;EACH;EAEA,IAAMC,SAAS,GAAGJ,MAAM,~~CAACT~~,MAAM,CAAC,~~UAACc~~,GAAG,~~EAAEC~~,KAAK;IAAA,~~OAAKD~~,GAAG,~~GAAGC~~,KAAK,CAACtB,MAAM;EAAA,GAAE,CAAC,CAAC;EAEtE,~~IAAMS~~,MAAM,GAAG,~~IAAIQ~~,qBAAqB,CAACG,SAAS,CAAC;EACnD,~~IAAIV~~,MAAM,GAAG,CAAC;EACd,~~2BAAoBM~~,MAAM,~~6BAAE~~;IAAvB,~~IAAMO~~,KAAK;~~IACdd~~,MAAM,~~CAACG~~,GAAG,~~CAACW~~,KAAK,~~EAAEb~~,MAAM,CAAC;IACzBA,MAAM,~~IAAIa~~,KAAK,~~CAACvB~~,MAAM;EACxB;EACA,~~OAAOS~~,MAAM;AACf;;AAQO,~~SAASe~~,~~gBAAgB~~,CAC9BC,WAAwB,EACxBC,UAAkB,~~EAClB/B~~,UAAmB,EACN;EACb,~~IAAMgC~~,QAAQ,~~GACZhC~~,UAAU,~~KAAKiC~~,SAAS,GACpB,~~IAAI/B~~,UAAU,~~CAAC4B~~,WAAW,CAAC,CAACI,QAAQ,CAACH,UAAU,EAAEA,UAAU,~~GAAG/B~~,UAAU,CAAC,GACzE,IAAIE,UAAU,~~CAAC4B~~,WAAW,CAAC,CAACI,QAAQ,CAACH,UAAU,CAAC;EACtD,IAAMI,SAAS,GAAG,~~IAAIjC~~,UAAU,~~CAAC8B~~,QAAQ,CAAC;EAC1C,OAAOG,SAAS,~~CAACjB~~,MAAM;AACzB"}
1	+ {"version":3,"file":"array-buffer-utils.js","names":["compareArrayBuffers","arrayBuffer1","arrayBuffer2","byteLength","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","_len","arguments","sources","Array","_key","sourceArrays","map","source2","ArrayBuffer","reduce","typedArray","result","offset","_iterator","_createForOfIteratorHelper","_step","s","n","done","sourceArray","value","set","err","e","f","buffer","concatenateTypedArrays","_len2","typedArrays","_key2","arrays","TypedArrayConstructor","constructor","Error","sumLength","acc","_i","_arrays","array","sliceArrayBuffer","arrayBuffer","byteOffset","subArray","undefined","subarray","arrayCopy"],"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\n\n/*\n compare two binary arrays for equality\n * @param a\n * @param b\n * @param byteLength\n /\nexport function compareArrayBuffers(\n arrayBuffer1: ArrayBuffer,\n arrayBuffer2: ArrayBuffer,\n byteLength?: number\n): boolean {\n byteLength = byteLength \|\| arrayBuffer1.byteLength;\n if (arrayBuffer1.byteLength < byteLength \|\| arrayBuffer2.byteLength < byteLength) {\n return false;\n }\n const array1 = new Uint8Array(arrayBuffer1);\n const array2 = new Uint8Array(arrayBuffer2);\n for (let i = 0; i < array1.length; ++i) {\n if (array1[i] !== array2[i]) {\n return false;\n }\n }\n return true;\n}\n\n/\n Concatenate a sequence of ArrayBuffers\n * @return A concatenated ArrayBuffer\n /\nexport function concatenateArrayBuffers(...sources: (ArrayBuffer \| Uint8Array)[]): ArrayBuffer {\n // Make sure all inputs are wrapped in typed arrays\n const sourceArrays = sources.map((source2) =>\n source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2\n );\n\n // Get length of all inputs\n const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);\n\n // Allocate array with space for all inputs\n const result = new Uint8Array(byteLength);\n\n // Copy the subarrays\n let offset = 0;\n for (const sourceArray of sourceArrays) {\n result.set(sourceArray, offset);\n offset += sourceArray.byteLength;\n }\n\n // We work with ArrayBuffers, discard the typed array wrapper\n return result.buffer;\n}\n\n/\n Concatenate arbitrary count of typed arrays\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays\n * @param - list of arrays. All arrays should be the same type\n * @return A concatenated TypedArray\n /\nexport function concatenateTypedArrays<T>(...typedArrays: T[]): T {\n // @ts-ignore\n const arrays = typedArrays as TypedArray[];\n // @ts-ignore\n const TypedArrayConstructor = (arrays && arrays.length > 1 && arrays[0].constructor) \|\| null;\n if (!TypedArrayConstructor) {\n throw new Error(\n '\"concatenateTypedArrays\" - incorrect quantity of arguments or arguments have incompatible data types'\n );\n }\n\n const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);\n // @ts-ignore typescript does not like dynamic constructors\n const result = new TypedArrayConstructor(sumLength);\n let offset = 0;\n for (const array of arrays) {\n result.set(array, offset);\n offset += array.length;\n }\n return result;\n}\n\n/\n Copy a view of an ArrayBuffer into new ArrayBuffer with byteOffset = 0\n * @param arrayBuffer\n * @param byteOffset\n * @param byteLength\n */\nexport function sliceArrayBuffer(\n arrayBuffer: ArrayBuffer,\n byteOffset: number,\n byteLength?: number\n): ArrayBuffer {\n const subArray =\n byteLength !== undefined\n ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength)\n : new Uint8Array(arrayBuffer).subarray(byteOffset);\n const arrayCopy = new Uint8Array(subArray);\n return arrayCopy.buffer;\n}\n"],"mappings":"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"}

package/dist/es5/lib/binary-utils/dataview-copy-utils.js CHANGED Viewed

@@ -9,7 +9,6 @@ exports.copyPaddedStringToDataView = copyPaddedStringToDataView;
 exports.copyStringToDataView = copyStringToDataView;
 exports.padStringToByteAlignment = padStringToByteAlignment;
 var _memoryCopyUtils = require("./memory-copy-utils");
 function padStringToByteAlignment(string, byteAlignment) {
   var length = string.length;
   var paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
@@ -20,7 +19,6 @@ function padStringToByteAlignment(string, byteAlignment) {
   }
   return string + whitespace;
 }
 function copyStringToDataView(dataView, byteOffset, string, byteLength) {
   if (dataView) {
     for (var i = 0; i < byteLength; i++) {
@@ -37,7 +35,6 @@ function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
   }
   return byteOffset + byteLength;
 }
 function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
   var paddedLength = (0, _memoryCopyUtils.padToNBytes)(sourceBuffer.byteLength, padding);
   var padLength = paddedLength - sourceBuffer.byteLength;
@@ -45,7 +42,6 @@ function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, pad
     var targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
     var sourceArray = new Uint8Array(sourceBuffer);
     targetArray.set(sourceArray);
     for (var i = 0; i < padLength; ++i) {
       dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);
     }
@@ -53,7 +49,6 @@ function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, pad
   byteOffset += paddedLength;
   return byteOffset;
 }
 function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
   var textEncoder = new TextEncoder();
   var stringBuffer = textEncoder.encode(string);

package/dist/es5/lib/binary-utils/dataview-copy-utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"dataview-copy-utils.js","names":["padStringToByteAlignment","string","byteAlignment","length","paddedLength","Math","ceil","padding","whitespace","i","copyStringToDataView","dataView","byteOffset","byteLength","setUint8","charCodeAt","copyBinaryToDataView","binary","copyPaddedArrayBufferToDataView","sourceBuffer","padToNBytes","padLength","targetArray","Uint8Array","buffer","sourceArray","set","copyPaddedStringToDataView","textEncoder","TextEncoder","stringBuffer","encode"],"sources":["../../../../src/lib/binary-utils/dataview-copy-utils.ts"],"sourcesContent":["// loaders./gl, MIT license\n\nimport {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/*\n Helper function that pads a string with spaces to fit a certain byte alignment\n * @param string\n * @param byteAlignment\n * @returns\n \n @todo PERFORMANCE IDEA: No need to copy string twice...\n /\nexport function padStringToByteAlignment(string: string, byteAlignment: number): string {\n const length = string.length;\n const paddedLength = Math.ceil(length / byteAlignment) byteAlignment; // Round up to the required alignment\n const padding = paddedLength - length;\n let whitespace = '';\n for (let i = 0; i < padding; ++i) {\n whitespace += ' ';\n }\n return string + whitespace;\n}\n\n/*\n \n * @param dataView\n * @param byteOffset\n * @param string\n * @param byteLength\n * @returns\n /\nexport function copyStringToDataView(\n dataView: DataView,\n byteOffset: number,\n string: string,\n byteLength: number\n): number {\n if (dataView) {\n for (let i = 0; i < byteLength; i++) {\n dataView.setUint8(byteOffset + i, string.charCodeAt(i));\n }\n }\n return byteOffset + byteLength;\n}\n\nexport function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {\n if (dataView) {\n for (let i = 0; i < byteLength; i++) {\n dataView.setUint8(byteOffset + i, binary[i]);\n }\n }\n return byteOffset + byteLength;\n}\n\n/\n Copy sourceBuffer to dataView with some padding\n \n @param dataView - destination data container. If null - only new offset is calculated\n * @param byteOffset - destination byte offset to copy to\n * @param sourceBuffer - source data buffer\n * @param padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n \n @return new byteOffset of resulting dataView\n /\nexport function copyPaddedArrayBufferToDataView(\n dataView: DataView \| null,\n byteOffset: number,\n sourceBuffer: TypedArray,\n padding: number\n): number {\n const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);\n const padLength = paddedLength - sourceBuffer.byteLength;\n\n if (dataView) {\n // Copy array\n const targetArray = new Uint8Array(\n dataView.buffer,\n dataView.byteOffset + byteOffset,\n sourceBuffer.byteLength\n );\n const sourceArray = new Uint8Array(sourceBuffer);\n targetArray.set(sourceArray);\n\n // Add PADDING\n for (let i = 0; i < padLength; ++i) {\n // json chunk is padded with spaces (ASCII 0x20)\n dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);\n }\n }\n byteOffset += paddedLength;\n return byteOffset;\n}\n\n/\n Copy string to dataView with some padding\n \n @param {DataView \| null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {string} string - source string\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n \n @return new byteOffset of resulting dataView\n */\nexport function copyPaddedStringToDataView(\n dataView: DataView \| null,\n byteOffset: number,\n string: string,\n padding: number\n): number {\n const textEncoder = new TextEncoder();\n // PERFORMANCE IDEA: We encode twice, once to get size and once to store\n // PERFORMANCE IDEA: Use TextEncoder.encodeInto() to avoid temporary copy\n const stringBuffer = textEncoder.encode(string);\n\n byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);\n\n return byteOffset;\n}\n"],"mappings":";;;;;;;;;;AAGA;;AAUO,~~SAASA~~,~~wBAAwB~~,CAACC,MAAc,EAAEC,aAAqB,EAAU;EACtF,IAAMC,MAAM,GAAGF,MAAM,CAACE,MAAM;EAC5B,IAAMC,YAAY,GAAGC,IAAI,CAACC,IAAI,CAACH,MAAM,GAAGD,aAAa,CAAC,GAAGA,aAAa;EACtE,IAAMK,OAAO,GAAGH,YAAY,GAAGD,MAAM;EACrC,IAAIK,UAAU,GAAG,EAAE;EACnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,OAAO,EAAE,EAAEE,CAAC,EAAE;IAChCD,UAAU,IAAI,GAAG;EACnB;EACA,OAAOP,MAAM,GAAGO,UAAU;AAC5B;;AAUO,SAASE,~~oBAAoB~~,CAClCC,QAAkB,EAClBC,UAAkB,EAClBX,MAAc,EACdY,UAAkB,EACV;EACR,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAER,MAAM,CAACc,UAAU,CAACN,CAAC,CAAC,CAAC;IACzD;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC;AAEO,SAASG,~~oBAAoB~~,CAACL,QAAQ,EAAEC,UAAU,EAAEK,MAAM,EAAEJ,UAAU,EAAE;EAC7E,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAEQ,MAAM,CAACR,CAAC,CAAC,CAAC;IAC9C;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC;;AAYO,SAASK,+BAA+B,CAC7CP,QAAyB,EACzBC,UAAkB,EAClBO,YAAwB,EACxBZ,OAAe,EACP;EACR,IAAMH,YAAY,GAAG,IAAAgB,4BAAW,EAACD,YAAY,CAACN,UAAU,EAAEN,OAAO,CAAC;EAClE,IAAMc,SAAS,GAAGjB,YAAY,GAAGe,YAAY,CAACN,UAAU;EAExD,IAAIF,QAAQ,EAAE;IAEZ,IAAMW,WAAW,GAAG,IAAIC,UAAU,CAChCZ,QAAQ,CAACa,MAAM,EACfb,QAAQ,CAACC,UAAU,GAAGA,UAAU,EAChCO,YAAY,CAACN,UAAU,CACxB;IACD,IAAMY,WAAW,GAAG,IAAIF,UAAU,CAACJ,YAAY,CAAC;IAChDG,WAAW,CAACI,GAAG,CAACD,WAAW,CAAC;;IAG5B,KAAK,IAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGY,SAAS,EAAE,EAAEZ,CAAC,EAAE;MAElCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGO,YAAY,CAACN,UAAU,GAAGJ,CAAC,EAAE,IAAI,CAAC;IACnE;EACF;EACAG,UAAU,IAAIR,YAAY;EAC1B,OAAOQ,UAAU;AACnB;;AAYO,SAASe,~~0BAA0B~~,CACxChB,QAAyB,EACzBC,UAAkB,EAClBX,MAAc,EACdM,OAAe,EACP;EACR,IAAMqB,WAAW,GAAG,IAAIC,WAAW,EAAE;EAGrC,IAAMC,YAAY,GAAGF,WAAW,CAACG,MAAM,CAAC9B,MAAM,CAAC;EAE/CW,UAAU,GAAGM,+BAA+B,CAACP,QAAQ,EAAEC,UAAU,EAAEkB,YAAY,EAAEvB,OAAO,CAAC;EAEzF,OAAOK,UAAU;AACnB"}
1	+ {"version":3,"file":"dataview-copy-utils.js","names":["_memoryCopyUtils","require","padStringToByteAlignment","string","byteAlignment","length","paddedLength","Math","ceil","padding","whitespace","i","copyStringToDataView","dataView","byteOffset","byteLength","setUint8","charCodeAt","copyBinaryToDataView","binary","copyPaddedArrayBufferToDataView","sourceBuffer","padToNBytes","padLength","targetArray","Uint8Array","buffer","sourceArray","set","copyPaddedStringToDataView","textEncoder","TextEncoder","stringBuffer","encode"],"sources":["../../../../src/lib/binary-utils/dataview-copy-utils.ts"],"sourcesContent":["// loaders./gl, MIT license\n\nimport {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/*\n Helper function that pads a string with spaces to fit a certain byte alignment\n * @param string\n * @param byteAlignment\n * @returns\n \n @todo PERFORMANCE IDEA: No need to copy string twice...\n /\nexport function padStringToByteAlignment(string: string, byteAlignment: number): string {\n const length = string.length;\n const paddedLength = Math.ceil(length / byteAlignment) byteAlignment; // Round up to the required alignment\n const padding = paddedLength - length;\n let whitespace = '';\n for (let i = 0; i < padding; ++i) {\n whitespace += ' ';\n }\n return string + whitespace;\n}\n\n/*\n \n * @param dataView\n * @param byteOffset\n * @param string\n * @param byteLength\n * @returns\n /\nexport function copyStringToDataView(\n dataView: DataView,\n byteOffset: number,\n string: string,\n byteLength: number\n): number {\n if (dataView) {\n for (let i = 0; i < byteLength; i++) {\n dataView.setUint8(byteOffset + i, string.charCodeAt(i));\n }\n }\n return byteOffset + byteLength;\n}\n\nexport function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {\n if (dataView) {\n for (let i = 0; i < byteLength; i++) {\n dataView.setUint8(byteOffset + i, binary[i]);\n }\n }\n return byteOffset + byteLength;\n}\n\n/\n Copy sourceBuffer to dataView with some padding\n \n @param dataView - destination data container. If null - only new offset is calculated\n * @param byteOffset - destination byte offset to copy to\n * @param sourceBuffer - source data buffer\n * @param padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n \n @return new byteOffset of resulting dataView\n /\nexport function copyPaddedArrayBufferToDataView(\n dataView: DataView \| null,\n byteOffset: number,\n sourceBuffer: TypedArray,\n padding: number\n): number {\n const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);\n const padLength = paddedLength - sourceBuffer.byteLength;\n\n if (dataView) {\n // Copy array\n const targetArray = new Uint8Array(\n dataView.buffer,\n dataView.byteOffset + byteOffset,\n sourceBuffer.byteLength\n );\n const sourceArray = new Uint8Array(sourceBuffer);\n targetArray.set(sourceArray);\n\n // Add PADDING\n for (let i = 0; i < padLength; ++i) {\n // json chunk is padded with spaces (ASCII 0x20)\n dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 0x20);\n }\n }\n byteOffset += paddedLength;\n return byteOffset;\n}\n\n/\n Copy string to dataView with some padding\n \n @param {DataView \| null} dataView - destination data container. If null - only new offset is calculated\n * @param {number} byteOffset - destination byte offset to copy to\n * @param {string} string - source string\n * @param {number} padding - pad the resulting array to multiple of \"padding\" bytes. Additional bytes are filled with 0x20 (ASCII space)\n \n @return new byteOffset of resulting dataView\n */\nexport function copyPaddedStringToDataView(\n dataView: DataView \| null,\n byteOffset: number,\n string: string,\n padding: number\n): number {\n const textEncoder = new TextEncoder();\n // PERFORMANCE IDEA: We encode twice, once to get size and once to store\n // PERFORMANCE IDEA: Use TextEncoder.encodeInto() to avoid temporary copy\n const stringBuffer = textEncoder.encode(string);\n\n byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);\n\n return byteOffset;\n}\n"],"mappings":";;;;;;;;;;AAGA,IAAAA,gBAAA,GAAAC,OAAA;AAUO,SAASC,wBAAwBA,CAACC,MAAc,EAAEC,aAAqB,EAAU;EACtF,IAAMC,MAAM,GAAGF,MAAM,CAACE,MAAM;EAC5B,IAAMC,YAAY,GAAGC,IAAI,CAACC,IAAI,CAACH,MAAM,GAAGD,aAAa,CAAC,GAAGA,aAAa;EACtE,IAAMK,OAAO,GAAGH,YAAY,GAAGD,MAAM;EACrC,IAAIK,UAAU,GAAG,EAAE;EACnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,OAAO,EAAE,EAAEE,CAAC,EAAE;IAChCD,UAAU,IAAI,GAAG;EACnB;EACA,OAAOP,MAAM,GAAGO,UAAU;AAC5B;AAUO,SAASE,oBAAoBA,CAClCC,QAAkB,EAClBC,UAAkB,EAClBX,MAAc,EACdY,UAAkB,EACV;EACR,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAER,MAAM,CAACc,UAAU,CAACN,CAAC,CAAC,CAAC;IACzD;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC;AAEO,SAASG,oBAAoBA,CAACL,QAAQ,EAAEC,UAAU,EAAEK,MAAM,EAAEJ,UAAU,EAAE;EAC7E,IAAIF,QAAQ,EAAE;IACZ,KAAK,IAAIF,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGI,UAAU,EAAEJ,CAAC,EAAE,EAAE;MACnCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGH,CAAC,EAAEQ,MAAM,CAACR,CAAC,CAAC,CAAC;IAC9C;EACF;EACA,OAAOG,UAAU,GAAGC,UAAU;AAChC;AAYO,SAASK,+BAA+BA,CAC7CP,QAAyB,EACzBC,UAAkB,EAClBO,YAAwB,EACxBZ,OAAe,EACP;EACR,IAAMH,YAAY,GAAG,IAAAgB,4BAAW,EAACD,YAAY,CAACN,UAAU,EAAEN,OAAO,CAAC;EAClE,IAAMc,SAAS,GAAGjB,YAAY,GAAGe,YAAY,CAACN,UAAU;EAExD,IAAIF,QAAQ,EAAE;IAEZ,IAAMW,WAAW,GAAG,IAAIC,UAAU,CAChCZ,QAAQ,CAACa,MAAM,EACfb,QAAQ,CAACC,UAAU,GAAGA,UAAU,EAChCO,YAAY,CAACN,UAAU,CACxB;IACD,IAAMY,WAAW,GAAG,IAAIF,UAAU,CAACJ,YAAY,CAAC;IAChDG,WAAW,CAACI,GAAG,CAACD,WAAW,CAAC;IAG5B,KAAK,IAAIhB,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGY,SAAS,EAAE,EAAEZ,CAAC,EAAE;MAElCE,QAAQ,CAACG,QAAQ,CAACF,UAAU,GAAGO,YAAY,CAACN,UAAU,GAAGJ,CAAC,EAAE,IAAI,CAAC;IACnE;EACF;EACAG,UAAU,IAAIR,YAAY;EAC1B,OAAOQ,UAAU;AACnB;AAYO,SAASe,0BAA0BA,CACxChB,QAAyB,EACzBC,UAAkB,EAClBX,MAAc,EACdM,OAAe,EACP;EACR,IAAMqB,WAAW,GAAG,IAAIC,WAAW,EAAE;EAGrC,IAAMC,YAAY,GAAGF,WAAW,CAACG,MAAM,CAAC9B,MAAM,CAAC;EAE/CW,UAAU,GAAGM,+BAA+B,CAACP,QAAQ,EAAEC,UAAU,EAAEkB,YAAY,EAAEvB,OAAO,CAAC;EAEzF,OAAOK,UAAU;AACnB"}

package/dist/es5/lib/binary-utils/get-first-characters.js CHANGED Viewed

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getFirstCharacters = getFirstCharacters;
 exports.getMagicString = getMagicString;
 function getFirstCharacters(data) {
   var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
   if (typeof data === 'string') {
@@ -18,7 +17,6 @@ function getFirstCharacters(data) {
   }
   return '';
 }
 function getMagicString(arrayBuffer, byteOffset, length) {
   if (arrayBuffer.byteLength <= byteOffset + length) {
     return '';

package/dist/es5/lib/binary-utils/get-first-characters.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"get-first-characters.js","names":["getFirstCharacters","data","length","slice","ArrayBuffer","isView","getMagicString","buffer","byteOffset","arrayBuffer","byteLength","dataView","DataView","magic","i","String","fromCharCode","getUint8"],"sources":["../../../../src/lib/binary-utils/get-first-characters.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n/*\n Get the first characters from a binary file (interpret the first bytes as an ASCII string)\n * @param data\n * @param length\n * @returns\n /\nexport function getFirstCharacters(data: string \| ArrayBuffer, length: number = 5): string {\n if (typeof data === 'string') {\n return data.slice(0, length);\n } else if (ArrayBuffer.isView(data)) {\n // Typed Arrays can have offsets into underlying buffer\n return getMagicString(data.buffer, data.byteOffset, length);\n } else if (data instanceof ArrayBuffer) {\n const byteOffset = 0;\n return getMagicString(data, byteOffset, length);\n }\n return '';\n}\n\n/\n Gets a magic string from a \"file\"\n * Typically used to check or detect file format\n * @param arrayBuffer\n * @param byteOffset\n * @param length\n * @returns\n */\nexport function getMagicString(\n arrayBuffer: ArrayBuffer,\n byteOffset: number,\n length: number\n): string {\n if (arrayBuffer.byteLength <= byteOffset + length) {\n return '';\n }\n const dataView = new DataView(arrayBuffer);\n let magic = '';\n for (let i = 0; i < length; i++) {\n magic += String.fromCharCode(dataView.getUint8(byteOffset + i));\n }\n return magic;\n}\n"],"mappings":"~~;;;;;;;;~~AAQO,SAASA,~~kBAAkB~~,CAACC,IAA0B,EAA8B;EAAA,IAA5BC,MAAc,~~uEAAG~~,CAAC;EAC/E,IAAI,~~OAAOD~~,IAAI,KAAK,QAAQ,EAAE;IAC5B,OAAOA,IAAI,~~CAACE~~,KAAK,CAAC,CAAC,~~EAAED~~,MAAM,CAAC;EAC9B,CAAC,MAAM,~~IAAIE~~,WAAW,CAACC,MAAM,~~CAACJ~~,IAAI,CAAC,EAAE;IAEnC,~~OAAOK~~,cAAc,~~CAACL~~,IAAI,~~CAACM~~,MAAM,~~EAAEN~~,IAAI,~~CAACO~~,UAAU,~~EAAEN~~,MAAM,CAAC;EAC7D,CAAC,MAAM,IAAID,IAAI,~~YAAYG~~,WAAW,EAAE;IACtC,IAAMI,UAAU,GAAG,CAAC;IACpB,OAAOF,cAAc,~~CAACL~~,IAAI,~~EAAEO~~,UAAU,~~EAAEN~~,MAAM,CAAC;EACjD;EACA,OAAO,EAAE;AACX;;AAUO,~~SAASI~~,~~cAAc~~,CAC5BG,WAAwB,EACxBD,UAAkB,~~EAClBN~~,MAAc,EACN;EACR,~~IAAIO~~,WAAW,CAACC,UAAU,IAAIF,UAAU,~~GAAGN~~,MAAM,EAAE;IACjD,OAAO,EAAE;EACX;EACA,~~IAAMS~~,QAAQ,GAAG,IAAIC,QAAQ,CAACH,WAAW,CAAC;EAC1C,IAAII,KAAK,GAAG,EAAE;EACd,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,~~GAAGZ~~,MAAM,~~EAAEY~~,CAAC,EAAE,EAAE;IAC/BD,KAAK,IAAIE,MAAM,CAACC,YAAY,CAACL,QAAQ,CAACM,QAAQ,CAACT,UAAU,GAAGM,CAAC,CAAC,CAAC;EACjE;EACA,OAAOD,KAAK;AACd"}
1	+ {"version":3,"file":"get-first-characters.js","names":["getFirstCharacters","data","length","arguments","undefined","slice","ArrayBuffer","isView","getMagicString","buffer","byteOffset","arrayBuffer","byteLength","dataView","DataView","magic","i","String","fromCharCode","getUint8"],"sources":["../../../../src/lib/binary-utils/get-first-characters.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n/*\n Get the first characters from a binary file (interpret the first bytes as an ASCII string)\n * @param data\n * @param length\n * @returns\n /\nexport function getFirstCharacters(data: string \| ArrayBuffer, length: number = 5): string {\n if (typeof data === 'string') {\n return data.slice(0, length);\n } else if (ArrayBuffer.isView(data)) {\n // Typed Arrays can have offsets into underlying buffer\n return getMagicString(data.buffer, data.byteOffset, length);\n } else if (data instanceof ArrayBuffer) {\n const byteOffset = 0;\n return getMagicString(data, byteOffset, length);\n }\n return '';\n}\n\n/\n Gets a magic string from a \"file\"\n * Typically used to check or detect file format\n * @param arrayBuffer\n * @param byteOffset\n * @param length\n * @returns\n */\nexport function getMagicString(\n arrayBuffer: ArrayBuffer,\n byteOffset: number,\n length: number\n): string {\n if (arrayBuffer.byteLength <= byteOffset + length) {\n return '';\n }\n const dataView = new DataView(arrayBuffer);\n let magic = '';\n for (let i = 0; i < length; i++) {\n magic += String.fromCharCode(dataView.getUint8(byteOffset + i));\n }\n return magic;\n}\n"],"mappings":";;;;;;;AAQO,SAASA,kBAAkBA,CAACC,IAA0B,EAA8B;EAAA,IAA5BC,MAAc,GAAAC,SAAA,CAAAD,MAAA,QAAAC,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,CAAC;EAC/E,IAAI,OAAOF,IAAI,KAAK,QAAQ,EAAE;IAC5B,OAAOA,IAAI,CAACI,KAAK,CAAC,CAAC,EAAEH,MAAM,CAAC;EAC9B,CAAC,MAAM,IAAII,WAAW,CAACC,MAAM,CAACN,IAAI,CAAC,EAAE;IAEnC,OAAOO,cAAc,CAACP,IAAI,CAACQ,MAAM,EAAER,IAAI,CAACS,UAAU,EAAER,MAAM,CAAC;EAC7D,CAAC,MAAM,IAAID,IAAI,YAAYK,WAAW,EAAE;IACtC,IAAMI,UAAU,GAAG,CAAC;IACpB,OAAOF,cAAc,CAACP,IAAI,EAAES,UAAU,EAAER,MAAM,CAAC;EACjD;EACA,OAAO,EAAE;AACX;AAUO,SAASM,cAAcA,CAC5BG,WAAwB,EACxBD,UAAkB,EAClBR,MAAc,EACN;EACR,IAAIS,WAAW,CAACC,UAAU,IAAIF,UAAU,GAAGR,MAAM,EAAE;IACjD,OAAO,EAAE;EACX;EACA,IAAMW,QAAQ,GAAG,IAAIC,QAAQ,CAACH,WAAW,CAAC;EAC1C,IAAII,KAAK,GAAG,EAAE;EACd,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGd,MAAM,EAAEc,CAAC,EAAE,EAAE;IAC/BD,KAAK,IAAIE,MAAM,CAACC,YAAY,CAACL,QAAQ,CAACM,QAAQ,CAACT,UAAU,GAAGM,CAAC,CAAC,CAAC;EACjE;EACA,OAAOD,KAAK;AACd"}

package/dist/es5/lib/binary-utils/memory-conversion-utils.js CHANGED Viewed

@@ -12,15 +12,12 @@ var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var node = _interopRequireWildcard(require("../node/buffer"));
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function isBuffer(value) {
   return value && (0, _typeof2.default)(value) === 'object' && value.isBuffer;
 }
 function toBuffer(data) {
   return node.toBuffer ? node.toBuffer(data) : data;
 }
 function toArrayBuffer(data) {
   if (isBuffer(data)) {
     return node.toArrayBuffer(data);
@@ -28,7 +25,6 @@ function toArrayBuffer(data) {
   if (data instanceof ArrayBuffer) {
     return data;
   }
   if (ArrayBuffer.isView(data)) {
     if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
       return data.buffer;
@@ -40,7 +36,6 @@ function toArrayBuffer(data) {
     var uint8Array = new TextEncoder().encode(text);
     return uint8Array.buffer;
   }
   if (data && (0, _typeof2.default)(data) === 'object' && data._toArrayBuffer) {
     return data._toArrayBuffer();
   }

package/dist/es5/lib/binary-utils/memory-conversion-utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"memory-conversion-utils.js","names":["isBuffer","value","~~toBuffer~~","~~data~~","~~node~~","toArrayBuffer","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error"],"sources":["../../../../src/lib/binary-utils/memory-conversion-utils.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport * as node from '../node/buffer';\n\n/*\n Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n /\nexport function isBuffer(value: any): boolean {\n return value && typeof value === 'object' && value.isBuffer;\n}\n\n/\n Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n /\nexport function toBuffer(data: any): Buffer {\n return node.toBuffer ? node.toBuffer(data) : data;\n}\n\n/\n Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: unknown): ArrayBuffer {\n // Note: Should be called first, Buffers can trigger other detections below\n if (isBuffer(data)) {\n return node.toArrayBuffer(data);\n }\n\n if (data instanceof ArrayBuffer) {\n return data;\n }\n\n // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n if (ArrayBuffer.isView(data)) {\n if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n return data.buffer;\n }\n return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n }\n\n if (typeof data === 'string') {\n const text = data;\n const uint8Array = new TextEncoder().encode(text);\n return uint8Array.buffer;\n }\n\n // HACK to support Blob polyfill\n if (data && typeof data === 'object' && (data as any)._toArrayBuffer) {\n return (data as any)._toArrayBuffer();\n }\n\n throw new Error('toArrayBuffer');\n}\n"],"mappings":";;;;;;;;;;;AAEA;AAAuC;AAAA;;AAKhC,~~SAASA~~,~~QAAQ~~,CAACC,KAAU,EAAW;EAC5C,OAAOA,KAAK,IAAI,~~sBAAOA~~,KAAK,MAAK,QAAQ,IAAIA,KAAK,CAACD,QAAQ;AAC7D;;AAMO,~~SAASE~~,~~QAAQ~~,CAACC,IAAS,EAAU;EAC1C,~~OAAOC~~,IAAI,~~CAACF~~,QAAQ,~~GAAGE~~,IAAI,~~CAACF~~,QAAQ,CAACC,IAAI,CAAC,GAAGA,IAAI;AACnD;;AAKO,~~SAASE~~,~~aAAa~~,~~CAACF~~,IAAa,EAAe;EAExD,~~IAAIH~~,QAAQ,~~CAACG~~,IAAI,CAAC,EAAE;IAClB,~~OAAOC~~,IAAI,~~CAACC~~,aAAa,~~CAACF~~,IAAI,CAAC;EACjC;EAEA,IAAIA,IAAI,~~YAAYG~~,WAAW,EAAE;IAC/B,~~OAAOH~~,IAAI;EACb;;EAGA,~~IAAIG~~,WAAW,CAACC,MAAM,~~CAACJ~~,IAAI,CAAC,EAAE;IAC5B,IAAIA,IAAI,~~CAACK~~,UAAU,KAAK,CAAC,~~IAAIL~~,IAAI,~~CAACM~~,UAAU,~~KAAKN~~,IAAI,~~CAACO~~,MAAM,CAACD,UAAU,EAAE;MACvE,~~OAAON~~,IAAI,~~CAACO~~,MAAM;IACpB;IACA,~~OAAOP~~,IAAI,~~CAACO~~,MAAM,CAACC,KAAK,~~CAACR~~,IAAI,~~CAACK~~,UAAU,~~EAAEL~~,IAAI,~~CAACK~~,UAAU,~~GAAGL~~,IAAI,~~CAACM~~,UAAU,CAAC;EAC9E;EAEA,IAAI,~~OAAON~~,IAAI,KAAK,QAAQ,EAAE;IAC5B,~~IAAMS~~,IAAI,~~GAAGT~~,IAAI;IACjB,~~IAAMU~~,UAAU,GAAG,IAAIC,WAAW,EAAE,CAACC,MAAM,CAACH,IAAI,CAAC;IACjD,OAAOC,UAAU,CAACH,MAAM;EAC1B;;EAGA,~~IAAIP~~,IAAI,IAAI,~~sBAAOA~~,IAAI,MAAK,QAAQ,IAAKA,IAAI,~~CAASa~~,cAAc,EAAE;IACpE,~~OAAQb~~,IAAI,~~CAASa~~,cAAc,EAAE;EACvC;EAEA,MAAM,IAAIC,KAAK,CAAC,eAAe,CAAC;AAClC"}
1	+ {"version":3,"file":"memory-conversion-utils.js","names":["node","_interopRequireWildcard","require","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","_typeof3","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","isBuffer","value","_typeof2","toBuffer","data","toArrayBuffer","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error"],"sources":["../../../../src/lib/binary-utils/memory-conversion-utils.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport * as node from '../node/buffer';\n\n/*\n Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n /\nexport function isBuffer(value: any): boolean {\n return value && typeof value === 'object' && value.isBuffer;\n}\n\n/\n Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n /\nexport function toBuffer(data: any): Buffer {\n return node.toBuffer ? node.toBuffer(data) : data;\n}\n\n/\n Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: unknown): ArrayBuffer {\n // Note: Should be called first, Buffers can trigger other detections below\n if (isBuffer(data)) {\n return node.toArrayBuffer(data);\n }\n\n if (data instanceof ArrayBuffer) {\n return data;\n }\n\n // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)\n if (ArrayBuffer.isView(data)) {\n if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {\n return data.buffer;\n }\n return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);\n }\n\n if (typeof data === 'string') {\n const text = data;\n const uint8Array = new TextEncoder().encode(text);\n return uint8Array.buffer;\n }\n\n // HACK to support Blob polyfill\n if (data && typeof data === 'object' && (data as any)._toArrayBuffer) {\n return (data as any)._toArrayBuffer();\n }\n\n throw new Error('toArrayBuffer');\n}\n"],"mappings":"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"}

package/dist/es5/lib/binary-utils/memory-copy-utils.js CHANGED Viewed

@@ -12,7 +12,6 @@ function padToNBytes(byteLength, padding) {
   (0, _assert.assert)(padding > 0);
   return byteLength + (padding - 1) & ~(padding - 1);
 }
 function copyArrayBuffer(targetBuffer, sourceBuffer, byteOffset) {
   var byteLength = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : sourceBuffer.byteLength;
   var targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);
@@ -20,7 +19,6 @@ function copyArrayBuffer(targetBuffer, sourceBuffer, byteOffset) {
   targetArray.set(sourceArray);
   return targetBuffer;
 }
 function copyToArray(source, target, targetOffset) {
   var sourceArray;
   if (source instanceof ArrayBuffer) {
@@ -30,7 +28,6 @@ function copyToArray(source, target, targetOffset) {
     var srcByteLength = source.byteLength;
     sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);
   }
   target.set(sourceArray, targetOffset);
   return targetOffset + padToNBytes(sourceArray.byteLength, 4);
 }

package/dist/es5/lib/binary-utils/memory-copy-utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"memory-copy-utils.js","names":["padToNBytes","byteLength","padding","assert","copyArrayBuffer","targetBuffer","sourceBuffer","byteOffset","targetArray","Uint8Array","sourceArray","set","copyToArray","source","target","targetOffset","ArrayBuffer","srcByteOffset","srcByteLength","buffer","arrayBuffer"],"sources":["../../../../src/lib/binary-utils/memory-copy-utils.ts"],"sourcesContent":["import {assert} from '../env-utils/assert';\n\n/*\n Calculate new size of an arrayBuffer to be aligned to an n-byte boundary\n * This function increases `byteLength` by the minimum delta,\n * allowing the total length to be divided by `padding`\n * @param byteLength\n * @param padding\n /\nexport function padToNBytes(byteLength: number, padding: number): number {\n assert(byteLength >= 0); // `Incorrect 'byteLength' value: ${byteLength}`\n assert(padding > 0); // `Incorrect 'padding' value: ${padding}`\n return (byteLength + (padding - 1)) & ~(padding - 1);\n}\n\n/\n Creates a new Uint8Array based on two different ArrayBuffers\n * @param targetBuffer The first buffer.\n * @param sourceBuffer The second buffer.\n * @return The new ArrayBuffer created out of the two.\n /\nexport function copyArrayBuffer(\n targetBuffer: ArrayBuffer,\n sourceBuffer: ArrayBuffer,\n byteOffset: number,\n byteLength: number = sourceBuffer.byteLength\n): ArrayBuffer {\n const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);\n const sourceArray = new Uint8Array(sourceBuffer);\n targetArray.set(sourceArray);\n return targetBuffer;\n}\n\n/\n Copy from source to target at the targetOffset\n \n @param source - The data to copy\n * @param target - The destination to copy data into\n * @param targetOffset - The start offset into target to place the copied data\n * @returns the new offset taking into account proper padding\n */\nexport function copyToArray(source: ArrayBuffer \| any, target: any, targetOffset: number): number {\n let sourceArray;\n\n if (source instanceof ArrayBuffer) {\n sourceArray = new Uint8Array(source);\n } else {\n // Pack buffer onto the big target array\n //\n // 'source.data.buffer' could be a view onto a larger buffer.\n // We MUST use this constructor to ensure the byteOffset and byteLength is\n // set to correct values from 'source.data' and not the underlying\n // buffer for target.set() to work properly.\n const srcByteOffset = source.byteOffset;\n const srcByteLength = source.byteLength;\n // In gltf parser it is set as \"arrayBuffer\" instead of \"buffer\"\n // https://github.com/visgl/loaders.gl/blob/1e3a82a0a65d7b6a67b1e60633453e5edda2960a/modules/gltf/src/lib/parse-gltf.js#L85\n sourceArray = new Uint8Array(source.buffer \|\| source.arrayBuffer, srcByteOffset, srcByteLength);\n }\n\n // Pack buffer onto the big target array\n target.set(sourceArray, targetOffset);\n\n return targetOffset + padToNBytes(sourceArray.byteLength, 4);\n}\n"],"mappings":";;;;;;;;AAAA;AASO,~~SAASA~~,~~WAAW~~,CAACC,UAAkB,EAAEC,OAAe,EAAU;EACvE,IAAAC,cAAM,EAACF,UAAU,IAAI,CAAC,CAAC;EACvB,IAAAE,cAAM,EAACD,OAAO,GAAG,CAAC,CAAC;EACnB,OAAQD,UAAU,IAAIC,OAAO,GAAG,CAAC,CAAC,GAAI,EAAEA,OAAO,GAAG,CAAC,CAAC;AACtD;;AAQO,SAASE,~~eAAe~~,CAC7BC,YAAyB,EACzBC,YAAyB,EACzBC,UAAkB,EAEL;EAAA,IADbN,UAAkB,~~uEAAGK~~,YAAY,CAACL,UAAU;EAE5C,~~IAAMO~~,WAAW,GAAG,IAAIC,UAAU,~~CAACJ~~,YAAY,EAAEE,UAAU,EAAEN,UAAU,CAAC;EACxE,~~IAAMS~~,WAAW,GAAG,IAAID,UAAU,~~CAACH~~,YAAY,CAAC;~~EAChDE~~,WAAW,CAACG,GAAG,CAACD,WAAW,CAAC;EAC5B,~~OAAOL~~,YAAY;AACrB;;AAUO,~~SAASO~~,~~WAAW~~,CAACC,MAAyB,EAAEC,MAAW,EAAEC,YAAoB,EAAU;EAChG,IAAIL,WAAW;EAEf,IAAIG,MAAM,YAAYG,WAAW,EAAE;IACjCN,WAAW,GAAG,IAAID,UAAU,CAACI,MAAM,CAAC;EACtC,CAAC,MAAM;IAOL,IAAMI,aAAa,GAAGJ,MAAM,~~CAACN~~,UAAU;IACvC,~~IAAMW~~,aAAa,GAAGL,MAAM,~~CAACZ~~,UAAU;~~IAGvCS~~,WAAW,GAAG,IAAID,UAAU,CAACI,MAAM,CAACM,MAAM,IAAIN,MAAM,CAACO,WAAW,EAAEH,aAAa,EAAEC,aAAa,CAAC;EACjG;;EAGAJ,MAAM,CAACH,GAAG,CAACD,WAAW,EAAEK,YAAY,CAAC;EAErC,OAAOA,YAAY,~~GAAGf~~,WAAW,~~CAACU~~,WAAW,~~CAACT~~,UAAU,EAAE,CAAC,CAAC;AAC9D"}
1	+ {"version":3,"file":"memory-copy-utils.js","names":["_assert","require","padToNBytes","byteLength","padding","assert","copyArrayBuffer","targetBuffer","sourceBuffer","byteOffset","arguments","length","undefined","targetArray","Uint8Array","sourceArray","set","copyToArray","source","target","targetOffset","ArrayBuffer","srcByteOffset","srcByteLength","buffer","arrayBuffer"],"sources":["../../../../src/lib/binary-utils/memory-copy-utils.ts"],"sourcesContent":["import {assert} from '../env-utils/assert';\n\n/*\n Calculate new size of an arrayBuffer to be aligned to an n-byte boundary\n * This function increases `byteLength` by the minimum delta,\n * allowing the total length to be divided by `padding`\n * @param byteLength\n * @param padding\n /\nexport function padToNBytes(byteLength: number, padding: number): number {\n assert(byteLength >= 0); // `Incorrect 'byteLength' value: ${byteLength}`\n assert(padding > 0); // `Incorrect 'padding' value: ${padding}`\n return (byteLength + (padding - 1)) & ~(padding - 1);\n}\n\n/\n Creates a new Uint8Array based on two different ArrayBuffers\n * @param targetBuffer The first buffer.\n * @param sourceBuffer The second buffer.\n * @return The new ArrayBuffer created out of the two.\n /\nexport function copyArrayBuffer(\n targetBuffer: ArrayBuffer,\n sourceBuffer: ArrayBuffer,\n byteOffset: number,\n byteLength: number = sourceBuffer.byteLength\n): ArrayBuffer {\n const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);\n const sourceArray = new Uint8Array(sourceBuffer);\n targetArray.set(sourceArray);\n return targetBuffer;\n}\n\n/\n Copy from source to target at the targetOffset\n \n @param source - The data to copy\n * @param target - The destination to copy data into\n * @param targetOffset - The start offset into target to place the copied data\n * @returns the new offset taking into account proper padding\n */\nexport function copyToArray(source: ArrayBuffer \| any, target: any, targetOffset: number): number {\n let sourceArray;\n\n if (source instanceof ArrayBuffer) {\n sourceArray = new Uint8Array(source);\n } else {\n // Pack buffer onto the big target array\n //\n // 'source.data.buffer' could be a view onto a larger buffer.\n // We MUST use this constructor to ensure the byteOffset and byteLength is\n // set to correct values from 'source.data' and not the underlying\n // buffer for target.set() to work properly.\n const srcByteOffset = source.byteOffset;\n const srcByteLength = source.byteLength;\n // In gltf parser it is set as \"arrayBuffer\" instead of \"buffer\"\n // https://github.com/visgl/loaders.gl/blob/1e3a82a0a65d7b6a67b1e60633453e5edda2960a/modules/gltf/src/lib/parse-gltf.js#L85\n sourceArray = new Uint8Array(source.buffer \|\| source.arrayBuffer, srcByteOffset, srcByteLength);\n }\n\n // Pack buffer onto the big target array\n target.set(sourceArray, targetOffset);\n\n return targetOffset + padToNBytes(sourceArray.byteLength, 4);\n}\n"],"mappings":";;;;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AASO,SAASC,WAAWA,CAACC,UAAkB,EAAEC,OAAe,EAAU;EACvE,IAAAC,cAAM,EAACF,UAAU,IAAI,CAAC,CAAC;EACvB,IAAAE,cAAM,EAACD,OAAO,GAAG,CAAC,CAAC;EACnB,OAAQD,UAAU,IAAIC,OAAO,GAAG,CAAC,CAAC,GAAI,EAAEA,OAAO,GAAG,CAAC,CAAC;AACtD;AAQO,SAASE,eAAeA,CAC7BC,YAAyB,EACzBC,YAAyB,EACzBC,UAAkB,EAEL;EAAA,IADbN,UAAkB,GAAAO,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAGF,YAAY,CAACL,UAAU;EAE5C,IAAMU,WAAW,GAAG,IAAIC,UAAU,CAACP,YAAY,EAAEE,UAAU,EAAEN,UAAU,CAAC;EACxE,IAAMY,WAAW,GAAG,IAAID,UAAU,CAACN,YAAY,CAAC;EAChDK,WAAW,CAACG,GAAG,CAACD,WAAW,CAAC;EAC5B,OAAOR,YAAY;AACrB;AAUO,SAASU,WAAWA,CAACC,MAAyB,EAAEC,MAAW,EAAEC,YAAoB,EAAU;EAChG,IAAIL,WAAW;EAEf,IAAIG,MAAM,YAAYG,WAAW,EAAE;IACjCN,WAAW,GAAG,IAAID,UAAU,CAACI,MAAM,CAAC;EACtC,CAAC,MAAM;IAOL,IAAMI,aAAa,GAAGJ,MAAM,CAACT,UAAU;IACvC,IAAMc,aAAa,GAAGL,MAAM,CAACf,UAAU;IAGvCY,WAAW,GAAG,IAAID,UAAU,CAACI,MAAM,CAACM,MAAM,IAAIN,MAAM,CAACO,WAAW,EAAEH,aAAa,EAAEC,aAAa,CAAC;EACjG;EAGAJ,MAAM,CAACH,GAAG,CAACD,WAAW,EAAEK,YAAY,CAAC;EAErC,OAAOA,YAAY,GAAGlB,WAAW,CAACa,WAAW,CAACZ,UAAU,EAAE,CAAC,CAAC;AAC9D"}

package/dist/es5/lib/env-utils/assert.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"assert.js","names":["assert","condition","message","Error"],"sources":["../../../../src/lib/env-utils/assert.ts"],"sourcesContent":["/*\n Throws an `Error` with the optional `message` if `condition` is falsy\n * @note Replacement for the external assert method to reduce bundle size\n */\nexport function assert(condition: any, message?: string): void {\n if (!condition) {\n throw new Error(message \|\| 'loader assertion failed.');\n }\n}\n"],"mappings":";;;;;;AAIO,SAASA,~~MAAM~~,CAACC,SAAc,EAAEC,OAAgB,EAAQ;EAC7D,IAAI,CAACD,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,CAACD,OAAO,IAAI,0BAA0B,CAAC;EACxD;AACF"}
1	+ {"version":3,"file":"assert.js","names":["assert","condition","message","Error"],"sources":["../../../../src/lib/env-utils/assert.ts"],"sourcesContent":["/*\n Throws an `Error` with the optional `message` if `condition` is falsy\n * @note Replacement for the external assert method to reduce bundle size\n */\nexport function assert(condition: any, message?: string): void {\n if (!condition) {\n throw new Error(message \|\| 'loader assertion failed.');\n }\n}\n"],"mappings":";;;;;;AAIO,SAASA,MAAMA,CAACC,SAAc,EAAEC,OAAgB,EAAQ;EAC7D,IAAI,CAACD,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,CAACD,OAAO,IAAI,0BAA0B,CAAC;EACxD;AACF"}

package/dist/es5/lib/env-utils/globals.js CHANGED Viewed

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.window = exports.self = exports.nodeVersion = exports.isWorker = exports.isBrowser = exports.global = exports.document = void 0;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var globals = {
   self: typeof self !== 'undefined' && self,
   window: typeof window !== 'undefined' && window,
@@ -21,12 +20,9 @@ var global_ = globals.global || globals.self || globals.window || {};
 exports.global = global_;
 var document_ = globals.document || {};
 exports.document = document_;
-var isBrowser =
-Boolean((typeof process === "undefined" ? "undefined" : (0, _typeof2.default)(process)) !== 'object' || String(process) !== '[object process]' || process.browser);
+var isBrowser = Boolean((typeof process === "undefined" ? "undefined" : (0, _typeof2.default)(process)) !== 'object' || String(process) !== '[object process]' || process.browser);
 exports.isBrowser = isBrowser;
 var isWorker = typeof importScripts === 'function';
 exports.isWorker = isWorker;
 var matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion = matches && parseFloat(matches[1]) || 0;

package/dist/es5/lib/env-utils/globals.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"globals.js","names":["globals","self","window","global","document","self_","window_","global_","document_","isBrowser","Boolean","process","String","browser","isWorker","importScripts","matches","version","exec","nodeVersion","parseFloat"],"sources":["../../../../src/lib/env-utils/globals.ts"],"sourcesContent":["// Purpose: include this in your module to avoid\n// dependencies on micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals /\nconst globals = {\n self: typeof self !== 'undefined' && self,\n window: typeof window !== 'undefined' && window,\n global: typeof global !== 'undefined' && global,\n document: typeof document !== 'undefined' && document\n};\n\ntype obj = {[key: string]: any};\nconst self_: obj = globals.self \|\| globals.window \|\| globals.global \|\| {};\nconst window_: obj = globals.window \|\| globals.self \|\| globals.global \|\| {};\nconst global_: obj = globals.global \|\| globals.self \|\| globals.window \|\| {};\nconst document_: obj = globals.document \|\| {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/* true if running in a browser /\nexport const isBrowser: boolean =\n // @ts-ignore process does not exist on browser\n Boolean(typeof process !== 'object' \|\| String(process) !== '[object process]' \|\| process.browser);\n\n/* true if running in a worker thread /\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n// Extract node major version\nconst matches =\n typeof process !== 'undefined' && process.version && /v([0-9])/.exec(process.version);\n/** Major Node version (as a number) */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) \|\| 0;\n"],"mappings":"~~;;;;;;;;;~~AAIA,IAAMA,OAAO,GAAG;EACdC,IAAI,EAAE,OAAOA,IAAI,KAAK,WAAW,IAAIA,IAAI;EACzCC,MAAM,EAAE,OAAOA,MAAM,KAAK,WAAW,IAAIA,MAAM;EAC/CC,MAAM,EAAE,OAAOA,MAAM,KAAK,WAAW,IAAIA,MAAM;EAC/CC,QAAQ,EAAE,OAAOA,QAAQ,KAAK,WAAW,IAAIA;AAC/C,CAAC;AAGD,IAAMC,KAAU,GAAGL,OAAO,CAACC,IAAI,IAAID,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACG,MAAM,IAAI,CAAC,CAAC;~~AAAC~~;AAC1E,~~IAAMG~~,OAAY,~~GAAGN~~,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACC,IAAI,IAAID,OAAO,CAACG,MAAM,IAAI,CAAC,CAAC;~~AAAC~~;AAC5E,~~IAAMI~~,OAAY,~~GAAGP~~,OAAO,CAACG,MAAM,IAAIH,OAAO,CAACC,IAAI,IAAID,OAAO,CAACE,MAAM,IAAI,CAAC,CAAC;~~AAAC~~;AAC5E,~~IAAMM~~,SAAc,~~GAAGR~~,OAAO,CAACI,QAAQ,IAAI,CAAC,CAAC;~~AAAC~~;AAKvC,~~IAAMK~~,SAAkB~~;AAE7BC~~,OAAO,CAAC,QAAOC,OAAO,~~uDAAPA~~,OAAO,OAAK,QAAQ,~~IAAIC~~,MAAM,~~CAACD~~,OAAO,CAAC,KAAK,kBAAkB,IAAIA,OAAO,~~CAACE~~,OAAO,CAAC~~;;AAAC~~;AAG7F,~~IAAMC~~,QAAiB,GAAG,OAAOC,aAAa,KAAK,UAAU~~;;AAAC~~;AAGrE,~~IAAMC~~,OAAO,GACX,~~OAAOL~~,OAAO,KAAK,WAAW,IAAIA,OAAO,~~CAACM~~,OAAO,IAAI,WAAW,CAACC,IAAI,~~CAACP~~,OAAO,~~CAACM~~,OAAO,CAAC;AAEjF,IAAME,WAAmB,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAC,CAAC,CAAC,IAAK,CAAC;~~AAAC~~"}
1	+ {"version":3,"file":"globals.js","names":["globals","self","window","global","document","self_","exports","window_","global_","document_","isBrowser","Boolean","process","_typeof2","default","String","browser","isWorker","importScripts","matches","version","exec","nodeVersion","parseFloat"],"sources":["../../../../src/lib/env-utils/globals.ts"],"sourcesContent":["// Purpose: include this in your module to avoid\n// dependencies on micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals /\nconst globals = {\n self: typeof self !== 'undefined' && self,\n window: typeof window !== 'undefined' && window,\n global: typeof global !== 'undefined' && global,\n document: typeof document !== 'undefined' && document\n};\n\ntype obj = {[key: string]: any};\nconst self_: obj = globals.self \|\| globals.window \|\| globals.global \|\| {};\nconst window_: obj = globals.window \|\| globals.self \|\| globals.global \|\| {};\nconst global_: obj = globals.global \|\| globals.self \|\| globals.window \|\| {};\nconst document_: obj = globals.document \|\| {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/* true if running in a browser /\nexport const isBrowser: boolean =\n // @ts-ignore process does not exist on browser\n Boolean(typeof process !== 'object' \|\| String(process) !== '[object process]' \|\| process.browser);\n\n/* true if running in a worker thread /\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n// Extract node major version\nconst matches =\n typeof process !== 'undefined' && process.version && /v([0-9])/.exec(process.version);\n/** Major Node version (as a number) */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) \|\| 0;\n"],"mappings":";;;;;;;;AAIA,IAAMA,OAAO,GAAG;EACdC,IAAI,EAAE,OAAOA,IAAI,KAAK,WAAW,IAAIA,IAAI;EACzCC,MAAM,EAAE,OAAOA,MAAM,KAAK,WAAW,IAAIA,MAAM;EAC/CC,MAAM,EAAE,OAAOA,MAAM,KAAK,WAAW,IAAIA,MAAM;EAC/CC,QAAQ,EAAE,OAAOA,QAAQ,KAAK,WAAW,IAAIA;AAC/C,CAAC;AAGD,IAAMC,KAAU,GAAGL,OAAO,CAACC,IAAI,IAAID,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACG,MAAM,IAAI,CAAC,CAAC;AAACG,OAAA,CAAAL,IAAA,GAAAI,KAAA;AAC1E,IAAME,OAAY,GAAGP,OAAO,CAACE,MAAM,IAAIF,OAAO,CAACC,IAAI,IAAID,OAAO,CAACG,MAAM,IAAI,CAAC,CAAC;AAACG,OAAA,CAAAJ,MAAA,GAAAK,OAAA;AAC5E,IAAMC,OAAY,GAAGR,OAAO,CAACG,MAAM,IAAIH,OAAO,CAACC,IAAI,IAAID,OAAO,CAACE,MAAM,IAAI,CAAC,CAAC;AAACI,OAAA,CAAAH,MAAA,GAAAK,OAAA;AAC5E,IAAMC,SAAc,GAAGT,OAAO,CAACI,QAAQ,IAAI,CAAC,CAAC;AAACE,OAAA,CAAAF,QAAA,GAAAK,SAAA;AAKvC,IAAMC,SAAkB,GAE7BC,OAAO,CAAC,QAAOC,OAAO,qCAAAC,QAAA,CAAAC,OAAA,EAAPF,OAAO,OAAK,QAAQ,IAAIG,MAAM,CAACH,OAAO,CAAC,KAAK,kBAAkB,IAAIA,OAAO,CAACI,OAAO,CAAC;AAACV,OAAA,CAAAI,SAAA,GAAAA,SAAA;AAG7F,IAAMO,QAAiB,GAAG,OAAOC,aAAa,KAAK,UAAU;AAACZ,OAAA,CAAAW,QAAA,GAAAA,QAAA;AAGrE,IAAME,OAAO,GACX,OAAOP,OAAO,KAAK,WAAW,IAAIA,OAAO,CAACQ,OAAO,IAAI,WAAW,CAACC,IAAI,CAACT,OAAO,CAACQ,OAAO,CAAC;AAEjF,IAAME,WAAmB,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAC,CAAC,CAAC,IAAK,CAAC;AAACb,OAAA,CAAAgB,WAAA,GAAAA,WAAA"}