@loaders.gl/loader-utils 3.3.0 → 3.4.0-alpha.1

package/dist/es5/index.js

@@ -35,6 +35,12 @@ Object.defineProperty(exports, "assert", {
     return _assert.assert;
   }
 });
+Object.defineProperty(exports, "bufferToArrayBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _bufferUtils.bufferToArrayBuffer;
+  }
+});
 Object.defineProperty(exports, "canEncodeWithWorker", {
   enumerable: true,
   get: function get() {
@@ -80,25 +86,25 @@ Object.defineProperty(exports, "copyArrayBuffer", {
 Object.defineProperty(exports, "copyBinaryToDataView", {
   enumerable: true,
   get: function get() {
-    return _dataviewCopyUtils.copyBinaryToDataView;
+    return _encodeUtils.copyBinaryToDataView;
   }
 });
 Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
   enumerable: true,
   get: function get() {
-    return _dataviewCopyUtils.copyPaddedArrayBufferToDataView;
+    return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
   }
 });
 Object.defineProperty(exports, "copyPaddedStringToDataView", {
   enumerable: true,
   get: function get() {
-    return _dataviewCopyUtils.copyPaddedStringToDataView;
+    return _binaryCopyUtils.copyPaddedStringToDataView;
   }
 });
 Object.defineProperty(exports, "copyStringToDataView", {
   enumerable: true,
   get: function get() {
-    return _dataviewCopyUtils.copyStringToDataView;
+    return _encodeUtils.copyStringToDataView;
   }
 });
 Object.defineProperty(exports, "copyToArray", {
@@ -159,7 +165,7 @@ Object.defineProperty(exports, "isBrowser", {
 Object.defineProperty(exports, "isBuffer", {
   enumerable: true,
   get: function get() {
-    return _memoryConversionUtils.isBuffer;
+    return _bufferUtils.isBuffer;
   }
 });
 Object.defineProperty(exports, "isWorker", {
@@ -180,12 +186,6 @@ Object.defineProperty(exports, "makeNumberedLineIterator", {
     return _textIterators.makeNumberedLineIterator;
   }
 });
-Object.defineProperty(exports, "makeReadableFile", {
-  enumerable: true,
-  get: function get() {
-    return _readableFile.makeReadableFile;
-  }
-});
 Object.defineProperty(exports, "makeTextDecoderIterator", {
   enumerable: true,
   get: function get() {
@@ -198,12 +198,6 @@ Object.defineProperty(exports, "makeTextEncoderIterator", {
     return _textIterators.makeTextEncoderIterator;
   }
 });
-Object.defineProperty(exports, "makeWritableFile", {
-  enumerable: true,
-  get: function get() {
-    return _writableFile.makeWritableFile;
-  }
-});
 Object.defineProperty(exports, "nodeVersion", {
   enumerable: true,
   get: function get() {
@@ -213,7 +207,7 @@ Object.defineProperty(exports, "nodeVersion", {
 Object.defineProperty(exports, "padStringToByteAlignment", {
   enumerable: true,
   get: function get() {
-    return _dataviewCopyUtils.padStringToByteAlignment;
+    return _encodeUtils.padStringToByteAlignment;
   }
 });
 Object.defineProperty(exports, "padToNBytes", {
@@ -235,16 +229,10 @@ Object.defineProperty(exports, "parseWithWorker", {
   }
 });
 exports.path = void 0;
-Object.defineProperty(exports, "promisify1", {
-  enumerable: true,
-  get: function get() {
-    return _util.promisify1;
-  }
-});
-Object.defineProperty(exports, "promisify2", {
+Object.defineProperty(exports, "promisify", {
   enumerable: true,
   get: function get() {
-    return _util.promisify2;
+    return util.promisify;
   }
 });
 Object.defineProperty(exports, "resolvePath", {
@@ -271,19 +259,19 @@ Object.defineProperty(exports, "sliceArrayBuffer", {
     return _arrayBufferUtils.sliceArrayBuffer;
   }
 });
-exports.stream = void 0;
 Object.defineProperty(exports, "toArrayBuffer", {
   enumerable: true,
   get: function get() {
-    return _memoryConversionUtils.toArrayBuffer;
+    return _arrayBufferUtils.toArrayBuffer;
   }
 });
 Object.defineProperty(exports, "toBuffer", {
   enumerable: true,
   get: function get() {
-    return _memoryConversionUtils.toBuffer;
+    return _bufferUtils.toBuffer;
   }
 });
+exports.util = void 0;
 Object.defineProperty(exports, "window", {
   enumerable: true,
   get: function get() {
@@ -298,23 +286,21 @@ var _encodeWithWorker = require("./lib/worker-loader-utils/encode-with-worker");
 var _parseJson = require("./lib/parser-utils/parse-json");
 var _arrayBufferUtils = require("./lib/binary-utils/array-buffer-utils");
 var _memoryCopyUtils = require("./lib/binary-utils/memory-copy-utils");
-var _dataviewCopyUtils = require("./lib/binary-utils/dataview-copy-utils");
+var _binaryCopyUtils = require("./lib/binary-utils/binary-copy-utils");
+var _encodeUtils = require("./lib/binary-utils/encode-utils");
 var _getFirstCharacters = require("./lib/binary-utils/get-first-characters");
 var _textIterators = require("./lib/iterators/text-iterators");
 var _asyncIteration = require("./lib/iterators/async-iteration");
 var _requestScheduler = _interopRequireDefault(require("./lib/request-utils/request-scheduler"));
 var _fileAliases = require("./lib/path-utils/file-aliases");
 var _jsonLoader = require("./json-loader");
-var _memoryConversionUtils = require("./lib/binary-utils/memory-conversion-utils");
-var _util = require("./lib/node/util");
 var path = _interopRequireWildcard(require("./lib/path-utils/path"));
 exports.path = path;
+var _bufferUtils = require("./lib/binary-utils/buffer-utils");
+var util = _interopRequireWildcard(require("./lib/node/util"));
+exports.util = util;
 var fs = _interopRequireWildcard(require("./lib/node/fs"));
 exports.fs = fs;
-var stream = _interopRequireWildcard(require("./lib/node/stream"));
-exports.stream = stream;
-var _readableFile = require("./lib/filesystems/readable-file");
-var _writableFile = require("./lib/filesystems/writable-file");
 var _nodeFilesystem = _interopRequireDefault(require("./lib/filesystems/node-filesystem"));
 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 || _typeof(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; }

package/dist/es5/index.js.map

@@ -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\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/util';\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;AAWA;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"}
+{"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\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  toArrayBuffer,\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  copyPaddedArrayBufferToDataView,\n  copyPaddedStringToDataView\n} from './lib/binary-utils/binary-copy-utils';\nexport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from './lib/binary-utils/encode-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// `path` replacement (avoids bundling big path polyfill)\nimport * as path from './lib/path-utils/path';\nexport {path};\n\n// Avoid direct use of `Buffer` which pulls in 50KB polyfill\nexport {isBuffer, toBuffer, bufferToArrayBuffer} from './lib/binary-utils/buffer-utils';\n\n// Note.js wrappers (can be safely imported, but not used in browser)\n\n// Use instead of importing 'util'\nimport * as util from './lib/node/util';\nexport {util};\n// TODO - remove\nexport {promisify} from './lib/node/util';\n\n// Use instead of importing 'fs';`\nimport * as fs from './lib/node/fs';\nexport {fs};\n\n// EXPERIMENTAL\nexport {default as _NodeFileSystem} from './lib/filesystems/node-filesystem';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA;AACA;AAWA;AACA;AACA;AAGA;AAGA;AAOA;AACA;AAIA;AAKA;AAGA;AAMA;AAGA;AAGA;AAIA;AAOA;AAA8C;AAI9C;AAKA;AAAwC;AAMxC;AAAoC;AAIpC;AAA6E;AAAA"}

package/dist/es5/json-loader.js

@@ -7,7 +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.3.0" !== 'undefined' ? "3.3.0" : 'latest';
+var VERSION = typeof "3.4.0-alpha.1" !== 'undefined' ? "3.4.0-alpha.1" : 'latest';
 
 var JSONLoader = {
   name: 'JSON',

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

@@ -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,cAAkB,KAAK,WAAW,aAAiB,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"}
+{"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"}

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

@@ -1,5 +1,6 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7,9 +8,38 @@ exports.compareArrayBuffers = compareArrayBuffers;
 exports.concatenateArrayBuffers = concatenateArrayBuffers;
 exports.concatenateTypedArrays = concatenateTypedArrays;
 exports.sliceArrayBuffer = sliceArrayBuffer;
+exports.toArrayBuffer = toArrayBuffer;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _bufferUtils = require("./buffer-utils");
 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 toArrayBuffer(data) {
+  if ((0, _bufferUtils.isBuffer)(data)) {
+    return (0, _bufferUtils.bufferToArrayBuffer)(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return data.buffer;
+    }
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+  if (typeof data === 'string') {
+    var text = data;
+    var uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+
+  if (data && (0, _typeof2.default)(data) === 'object' && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+  throw new Error('toArrayBuffer');
+}
+
 function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
   byteLength = byteLength || arrayBuffer1.byteLength;
   if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {

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

@@ -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":"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"}
+{"version":3,"file":"array-buffer-utils.js","names":["toArrayBuffer","data","isBuffer","bufferToArrayBuffer","ArrayBuffer","isView","byteOffset","byteLength","buffer","slice","text","uint8Array","TextEncoder","encode","_toArrayBuffer","Error","compareArrayBuffers","arrayBuffer1","arrayBuffer2","array1","Uint8Array","array2","i","length","concatenateArrayBuffers","sources","sourceArrays","map","source2","reduce","typedArray","result","offset","sourceArray","set","concatenateTypedArrays","typedArrays","arrays","TypedArrayConstructor","constructor","sumLength","acc","value","array","sliceArrayBuffer","arrayBuffer","subArray","undefined","subarray","arrayCopy"],"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\nimport {isBuffer, bufferToArrayBuffer} from './buffer-utils';\n\n/**\n * Convert an object to an array buffer\n */\nexport function toArrayBuffer(data: any): ArrayBuffer {\n  // Note: Should be called first, Buffers can trigger other detections below\n  if (isBuffer(data)) {\n    return bufferToArrayBuffer(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._toArrayBuffer) {\n    return data._toArrayBuffer();\n  }\n\n  throw new Error('toArrayBuffer');\n}\n\n/**\n * compare two binary arrays for equality\n * @param {ArrayBuffer} a\n * @param {ArrayBuffer} b\n * @param {number} 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 {...*} arrays - 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 → binary-copy-utils.js}

@@ -3,41 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.copyBinaryToDataView = copyBinaryToDataView;
 exports.copyPaddedArrayBufferToDataView = copyPaddedArrayBufferToDataView;
 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;
-  var padding = paddedLength - length;
-  var whitespace = '';
-  for (var i = 0; i < padding; ++i) {
-    whitespace += ' ';
-  }
-  return string + whitespace;
-}
-
-function copyStringToDataView(dataView, byteOffset, string, byteLength) {
-  if (dataView) {
-    for (var i = 0; i < byteLength; i++) {
-      dataView.setUint8(byteOffset + i, string.charCodeAt(i));
-    }
-  }
-  return byteOffset + byteLength;
-}
-function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
-  if (dataView) {
-    for (var i = 0; i < byteLength; i++) {
-      dataView.setUint8(byteOffset + i, binary[i]);
-    }
-  }
-  return byteOffset + byteLength;
-}
-
 function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
   var paddedLength = (0, _memoryCopyUtils.padToNBytes)(sourceBuffer.byteLength, padding);
   var padLength = paddedLength - sourceBuffer.byteLength;
@@ -60,4 +28,4 @@ function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
   byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
   return byteOffset;
 }
-//# sourceMappingURL=dataview-copy-utils.js.map
+//# sourceMappingURL=binary-copy-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binary-copy-utils.js","names":["copyPaddedArrayBufferToDataView","dataView","byteOffset","sourceBuffer","padding","paddedLength","padToNBytes","byteLength","padLength","targetArray","Uint8Array","buffer","sourceArray","set","i","setUint8","copyPaddedStringToDataView","string","textEncoder","TextEncoder","stringBuffer","encode"],"sources":["../../../../src/lib/binary-utils/binary-copy-utils.ts"],"sourcesContent":["import {TypedArray} from '../../types';\nimport {padToNBytes} from './memory-copy-utils';\n\n/**\n * Copy sourceBuffer 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 {Array | TypedArray} sourceBuffer - source data buffer\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 copyPaddedArrayBufferToDataView(\n  dataView: DataView | null,\n  byteOffset: number,\n  sourceBuffer: TypedArray,\n  padding: number\n) {\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":";;;;;;;AACA;AAYO,SAASA,+BAA+B,CAC7CC,QAAyB,EACzBC,UAAkB,EAClBC,YAAwB,EACxBC,OAAe,EACf;EACA,IAAMC,YAAY,GAAG,IAAAC,4BAAW,EAACH,YAAY,CAACI,UAAU,EAAEH,OAAO,CAAC;EAClE,IAAMI,SAAS,GAAGH,YAAY,GAAGF,YAAY,CAACI,UAAU;EAExD,IAAIN,QAAQ,EAAE;IAEZ,IAAMQ,WAAW,GAAG,IAAIC,UAAU,CAChCT,QAAQ,CAACU,MAAM,EACfV,QAAQ,CAACC,UAAU,GAAGA,UAAU,EAChCC,YAAY,CAACI,UAAU,CACxB;IACD,IAAMK,WAAW,GAAG,IAAIF,UAAU,CAACP,YAAY,CAAC;IAChDM,WAAW,CAACI,GAAG,CAACD,WAAW,CAAC;;IAG5B,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,SAAS,EAAE,EAAEM,CAAC,EAAE;MAElCb,QAAQ,CAACc,QAAQ,CAACb,UAAU,GAAGC,YAAY,CAACI,UAAU,GAAGO,CAAC,EAAE,IAAI,CAAC;IACnE;EACF;EACAZ,UAAU,IAAIG,YAAY;EAC1B,OAAOH,UAAU;AACnB;;AAYO,SAASc,0BAA0B,CACxCf,QAAyB,EACzBC,UAAkB,EAClBe,MAAc,EACdb,OAAe,EACP;EACR,IAAMc,WAAW,GAAG,IAAIC,WAAW,EAAE;EAGrC,IAAMC,YAAY,GAAGF,WAAW,CAACG,MAAM,CAACJ,MAAM,CAAC;EAE/Cf,UAAU,GAAGF,+BAA+B,CAACC,QAAQ,EAAEC,UAAU,EAAEkB,YAAY,EAAEhB,OAAO,CAAC;EAEzF,OAAOF,UAAU;AACnB"}

package/dist/es5/lib/binary-utils/{memory-conversion-utils.js → buffer-utils.js}

@@ -5,14 +5,13 @@ var _typeof3 = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.bufferToArrayBuffer = bufferToArrayBuffer;
 exports.isBuffer = isBuffer;
-exports.toArrayBuffer = toArrayBuffer;
 exports.toBuffer = toBuffer;
 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;
 }
@@ -21,29 +20,11 @@ function toBuffer(data) {
   return node.toBuffer ? node.toBuffer(data) : data;
 }
 
-function toArrayBuffer(data) {
-  if (isBuffer(data)) {
-    return node.toArrayBuffer(data);
-  }
-  if (data instanceof ArrayBuffer) {
-    return data;
-  }
-
-  if (ArrayBuffer.isView(data)) {
-    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-      return data.buffer;
-    }
-    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-  }
-  if (typeof data === 'string') {
-    var text = data;
-    var uint8Array = new TextEncoder().encode(text);
-    return uint8Array.buffer;
-  }
-
-  if (data && (0, _typeof2.default)(data) === 'object' && data._toArrayBuffer) {
-    return data._toArrayBuffer();
+function bufferToArrayBuffer(buffer) {
+  if (isBuffer(buffer)) {
+    var typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+    return typedArray.slice().buffer;
   }
-  throw new Error('toArrayBuffer');
+  return buffer;
 }
-//# sourceMappingURL=memory-conversion-utils.js.map
+//# sourceMappingURL=buffer-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-utils.js","names":["isBuffer","value","toBuffer","data","node","bufferToArrayBuffer","buffer","typedArray","Uint8Array","byteOffset","length","slice"],"sources":["../../../../src/lib/binary-utils/buffer-utils.ts"],"sourcesContent":["import * 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 * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function bufferToArrayBuffer(buffer: any): ArrayBuffer {\n  if (isBuffer(buffer)) {\n    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);\n    return typedArray.slice().buffer;\n  }\n  return buffer;\n}\n"],"mappings":";;;;;;;;;;;AAAA;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;;AAMO,SAASE,mBAAmB,CAACC,MAAW,EAAe;EAC5D,IAAIN,QAAQ,CAACM,MAAM,CAAC,EAAE;IACpB,IAAMC,UAAU,GAAG,IAAIC,UAAU,CAACF,MAAM,CAACA,MAAM,EAAEA,MAAM,CAACG,UAAU,EAAEH,MAAM,CAACI,MAAM,CAAC;IAClF,OAAOH,UAAU,CAACI,KAAK,EAAE,CAACL,MAAM;EAClC;EACA,OAAOA,MAAM;AACf"}

package/dist/es5/lib/binary-utils/encode-utils.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copyBinaryToDataView = copyBinaryToDataView;
+exports.copyStringToDataView = copyStringToDataView;
+exports.padStringToByteAlignment = padStringToByteAlignment;
+
+function padStringToByteAlignment(string, byteAlignment) {
+  var length = string.length;
+  var paddedLength = Math.ceil(length / byteAlignment) * byteAlignment;
+  var padding = paddedLength - length;
+  var whitespace = '';
+  for (var i = 0; i < padding; ++i) {
+    whitespace += ' ';
+  }
+  return string + whitespace;
+}
+function copyStringToDataView(dataView, byteOffset, string, byteLength) {
+  if (dataView) {
+    for (var i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, string.charCodeAt(i));
+    }
+  }
+  return byteOffset + byteLength;
+}
+function copyBinaryToDataView(dataView, byteOffset, binary, byteLength) {
+  if (dataView) {
+    for (var i = 0; i < byteLength; i++) {
+      dataView.setUint8(byteOffset + i, binary[i]);
+    }
+  }
+  return byteOffset + byteLength;
+}
+//# sourceMappingURL=encode-utils.js.map

package/dist/es5/lib/binary-utils/encode-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-utils.js","names":["padStringToByteAlignment","string","byteAlignment","length","paddedLength","Math","ceil","padding","whitespace","i","copyStringToDataView","dataView","byteOffset","byteLength","setUint8","charCodeAt","copyBinaryToDataView","binary"],"sources":["../../../../src/lib/binary-utils/encode-utils.ts"],"sourcesContent":["// Note: These were broken out from gltf loader...\n// eslint-disable-next-line complexity\n\n// PERFORMANCE IDEA: No need to copy string twice...\nexport function padStringToByteAlignment(string, byteAlignment) {\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\nexport function copyStringToDataView(dataView, byteOffset, string, byteLength) {\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"],"mappings":";;;;;;;;;AAIO,SAASA,wBAAwB,CAACC,MAAM,EAAEC,aAAa,EAAE;EAC9D,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;AAEO,SAASE,oBAAoB,CAACC,QAAQ,EAAEC,UAAU,EAAEX,MAAM,EAAEY,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,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"}

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

@@ -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

@@ -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"}
+{"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":["export function getFirstCharacters(data, length = 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\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":";;;;;;;AAAO,SAASA,kBAAkB,CAACC,IAAI,EAAsB;EAAA,IAApBC,MAAM,uEAAG,CAAC;EACjD,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;AAEO,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"}

package/dist/es5/lib/node/buffer.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.toArrayBuffer = toArrayBuffer;
 exports.toBuffer = toBuffer;
+var _assert = require("../env-utils/assert");
 
 function toArrayBuffer(buffer) {
   if (Buffer.isBuffer(buffer)) {
@@ -15,15 +16,17 @@ function toArrayBuffer(buffer) {
 }
 
 function toBuffer(binaryData) {
-  if (Buffer.isBuffer(binaryData)) {
-    return binaryData;
-  }
   if (ArrayBuffer.isView(binaryData)) {
     binaryData = binaryData.buffer;
   }
   if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {
-    return Buffer.from(binaryData);
+    var buffer = new Buffer(binaryData.byteLength);
+    var view = new Uint8Array(binaryData);
+    for (var i = 0; i < buffer.length; ++i) {
+      buffer[i] = view[i];
+    }
+    return buffer;
   }
-  throw new Error('toBuffer');
+  return (0, _assert.assert)(false);
 }
 //# sourceMappingURL=buffer.js.map

package/dist/es5/lib/node/buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.js","names":["toArrayBuffer","buffer","Buffer","isBuffer","typedArray","Uint8Array","byteOffset","length","slice","toBuffer","binaryData","ArrayBuffer","isView","from","Error"],"sources":["../../../../src/lib/node/buffer.ts"],"sourcesContent":["// Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)\n// this file is not visible to webpack (it is excluded in the package.json \"browser\" field).\n\n/**\n * Convert Buffer to ArrayBuffer\n * Converts Node.js `Buffer` to `ArrayBuffer` (without triggering bundler to include Buffer polyfill on browser)\n * @todo better data type\n */\nexport function toArrayBuffer(buffer) {\n  // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n  if (Buffer.isBuffer(buffer)) {\n    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);\n    return typedArray.slice().buffer;\n  }\n  return buffer;\n}\n\n/**\n * Convert (copy) ArrayBuffer to Buffer\n */\nexport function toBuffer(binaryData: ArrayBuffer | ArrayBuffer | Buffer): Buffer {\n  if (Buffer.isBuffer(binaryData)) {\n    return binaryData;\n  }\n\n  if (ArrayBuffer.isView(binaryData)) {\n    binaryData = binaryData.buffer;\n  }\n\n  if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {\n    return Buffer.from(binaryData);\n  }\n\n  throw new Error('toBuffer');\n}\n"],"mappings":";;;;;;;;AAQO,SAASA,aAAa,CAACC,MAAM,EAAE;EAEpC,IAAIC,MAAM,CAACC,QAAQ,CAACF,MAAM,CAAC,EAAE;IAC3B,IAAMG,UAAU,GAAG,IAAIC,UAAU,CAACJ,MAAM,CAACA,MAAM,EAAEA,MAAM,CAACK,UAAU,EAAEL,MAAM,CAACM,MAAM,CAAC;IAClF,OAAOH,UAAU,CAACI,KAAK,EAAE,CAACP,MAAM;EAClC;EACA,OAAOA,MAAM;AACf;;AAKO,SAASQ,QAAQ,CAACC,UAA8C,EAAU;EAC/E,IAAIR,MAAM,CAACC,QAAQ,CAACO,UAAU,CAAC,EAAE;IAC/B,OAAOA,UAAU;EACnB;EAEA,IAAIC,WAAW,CAACC,MAAM,CAACF,UAAU,CAAC,EAAE;IAClCA,UAAU,GAAGA,UAAU,CAACT,MAAM;EAChC;EAEA,IAAI,OAAOC,MAAM,KAAK,WAAW,IAAIQ,UAAU,YAAYC,WAAW,EAAE;IACtE,OAAOT,MAAM,CAACW,IAAI,CAACH,UAAU,CAAC;EAChC;EAEA,MAAM,IAAII,KAAK,CAAC,UAAU,CAAC;AAC7B"}
+{"version":3,"file":"buffer.js","names":["toArrayBuffer","buffer","Buffer","isBuffer","typedArray","Uint8Array","byteOffset","length","slice","toBuffer","binaryData","ArrayBuffer","isView","byteLength","view","i","assert"],"sources":["../../../../src/lib/node/buffer.ts"],"sourcesContent":["// Isolates Buffer references to ensure they are only bundled under Node.js (avoids big webpack polyfill)\n// this file is not visible to webpack (it is excluded in the package.json \"browser\" field).\n\nimport {assert} from '../env-utils/assert';\n\n/**\n * Convert Buffer to ArrayBuffer\n */\nexport function toArrayBuffer(buffer) {\n  // TODO - per docs we should just be able to call buffer.buffer, but there are issues\n  if (Buffer.isBuffer(buffer)) {\n    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);\n    return typedArray.slice().buffer;\n  }\n  return buffer;\n}\n\n/**\n * Convert (copy) ArrayBuffer to Buffer\n */\nexport function toBuffer(binaryData) {\n  if (ArrayBuffer.isView(binaryData)) {\n    binaryData = binaryData.buffer;\n  }\n\n  if (typeof Buffer !== 'undefined' && binaryData instanceof ArrayBuffer) {\n    const buffer = new Buffer(binaryData.byteLength);\n    const view = new Uint8Array(binaryData);\n    for (let i = 0; i < buffer.length; ++i) {\n      buffer[i] = view[i];\n    }\n    return buffer;\n  }\n\n  return assert(false);\n}\n"],"mappings":";;;;;;;AAGA;;AAKO,SAASA,aAAa,CAACC,MAAM,EAAE;EAEpC,IAAIC,MAAM,CAACC,QAAQ,CAACF,MAAM,CAAC,EAAE;IAC3B,IAAMG,UAAU,GAAG,IAAIC,UAAU,CAACJ,MAAM,CAACA,MAAM,EAAEA,MAAM,CAACK,UAAU,EAAEL,MAAM,CAACM,MAAM,CAAC;IAClF,OAAOH,UAAU,CAACI,KAAK,EAAE,CAACP,MAAM;EAClC;EACA,OAAOA,MAAM;AACf;;AAKO,SAASQ,QAAQ,CAACC,UAAU,EAAE;EACnC,IAAIC,WAAW,CAACC,MAAM,CAACF,UAAU,CAAC,EAAE;IAClCA,UAAU,GAAGA,UAAU,CAACT,MAAM;EAChC;EAEA,IAAI,OAAOC,MAAM,KAAK,WAAW,IAAIQ,UAAU,YAAYC,WAAW,EAAE;IACtE,IAAMV,MAAM,GAAG,IAAIC,MAAM,CAACQ,UAAU,CAACG,UAAU,CAAC;IAChD,IAAMC,IAAI,GAAG,IAAIT,UAAU,CAACK,UAAU,CAAC;IACvC,KAAK,IAAIK,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGd,MAAM,CAACM,MAAM,EAAE,EAAEQ,CAAC,EAAE;MACtCd,MAAM,CAACc,CAAC,CAAC,GAAGD,IAAI,CAACC,CAAC,CAAC;IACrB;IACA,OAAOd,MAAM;EACf;EAEA,OAAO,IAAAe,cAAM,EAAC,KAAK,CAAC;AACtB"}

package/dist/es5/lib/node/fs.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._readToArrayBuffer = _readToArrayBuffer;
-exports.writeFileSync = exports.writeFile = exports.stat = exports.readdir = exports.readFileSync = exports.readFile = exports.read = exports.open = exports.isSupported = exports.fstat = exports.createWriteStream = exports.close = void 0;
+exports.writeFileSync = exports.writeFile = exports.stat = exports.readdir = exports.readFileSync = exports.readFile = exports.read = exports.open = exports.isSupported = exports.fstat = exports.close = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _fs = _interopRequireDefault(require("fs"));
@@ -35,32 +35,23 @@ var read;
 exports.read = read;
 var fstat;
 exports.fstat = fstat;
-var createWriteStream;
-exports.createWriteStream = createWriteStream;
 var isSupported = Boolean(_fs.default);
 
 exports.isSupported = isSupported;
 
 try {
-  exports.readdir = readdir = (0, _util.promisify2)(_fs.default.readdir);
-  exports.stat = stat = (0, _util.promisify2)(_fs.default.stat);
+  exports.readdir = readdir = (0, _util.promisify)(_fs.default.readdir);
+  exports.stat = stat = (0, _util.promisify)(_fs.default.stat);
 
-  exports.readFile = readFile = _fs.default.readFile;
+  exports.readFile = readFile = (0, _util.promisify)(_fs.default.readFile);
   exports.readFileSync = readFileSync = _fs.default.readFileSync;
-  exports.writeFile = writeFile = (0, _util.promisify3)(_fs.default.writeFile);
+  exports.writeFile = writeFile = (0, _util.promisify)(_fs.default.writeFile);
   exports.writeFileSync = writeFileSync = _fs.default.writeFileSync;
 
-  exports.open = open = _fs.default.open;
-  exports.close = close = function close(fd) {
-    return new Promise(function (resolve, reject) {
-      return _fs.default.close(fd, function (err) {
-        return err ? reject(err) : resolve();
-      });
-    });
-  };
-  exports.read = read = _fs.default.read;
-  exports.fstat = fstat = _fs.default.fstat;
-  exports.createWriteStream = createWriteStream = _fs.default.createWriteStream;
+  exports.open = open = (0, _util.promisify)(_fs.default.open);
+  exports.close = close = (0, _util.promisify)(_fs.default.close);
+  exports.read = read = (0, _util.promisify)(_fs.default.read);
+  exports.fstat = fstat = (0, _util.promisify)(_fs.default.fstat);
   exports.isSupported = isSupported = Boolean(_fs.default);
 } catch (_unused) {
 }

package/dist/es5/lib/node/fs.js.map

@@ -1 +1 @@
-{"version":3,"file":"fs.js","names":["readdir","stat","readFile","readFileSync","writeFile","writeFileSync","open","close","read","fstat","createWriteStream","isSupported","Boolean","fs","promisify2","promisify3","fd","Promise","resolve","reject","err","_readToArrayBuffer","start","length","buffer","Buffer","alloc","bytesRead","Error","toArrayBuffer"],"sources":["../../../../src/lib/node/fs.ts"],"sourcesContent":["// fs wrapper (promisified fs + avoids bundling fs in browsers)\nimport fs from 'fs';\nimport {toArrayBuffer} from './buffer';\nimport {promisify2, promisify3} from './util';\n\nexport type {Stats, WriteStream} from 'fs';\n\nexport let readdir;\n/** Wrapper for Node.js fs method */\nexport let stat;\n\n/** Wrapper for Node.js fs method */\nexport let readFile;\n/** Wrapper for Node.js fs method */\nexport let readFileSync;\n/** Wrapper for Node.js fs method */\nexport let writeFile;\n/** Wrapper for Node.js fs method */\nexport let writeFileSync;\n\n// file descriptors\n\n/** Wrapper for Node.js fs method */\nexport let open;\n/** Wrapper for Node.js fs method */\nexport let close: (fd: number) => Promise<void>;\n/** Wrapper for Node.js fs method */\nexport let read;\n/** Wrapper for Node.js fs method */\nexport let fstat;\n\nexport let createWriteStream: typeof fs.createWriteStream;\n\nexport let isSupported = Boolean(fs);\n\n// paths\n\ntry {\n  /** Wrapper for Node.js fs method */\n  readdir = promisify2(fs.readdir);\n  /** Wrapper for Node.js fs method */\n  stat = promisify2(fs.stat);\n\n  /** Wrapper for Node.js fs method */\n  readFile = fs.readFile;\n  /** Wrapper for Node.js fs method */\n  readFileSync = fs.readFileSync;\n  /** Wrapper for Node.js fs method */\n  writeFile = promisify3(fs.writeFile);\n  /** Wrapper for Node.js fs method */\n  writeFileSync = fs.writeFileSync;\n\n  // file descriptors\n\n  /** Wrapper for Node.js fs method */\n  open = fs.open;\n  /** Wrapper for Node.js fs method */\n  close = (fd: number) =>\n    new Promise((resolve, reject) => fs.close(fd, (err) => (err ? reject(err) : resolve())));\n  /** Wrapper for Node.js fs method */\n  read = fs.read;\n  /** Wrapper for Node.js fs method */\n  fstat = fs.fstat;\n\n  createWriteStream = fs.createWriteStream;\n\n  isSupported = Boolean(fs);\n} catch {\n  // ignore\n}\n\nexport async function _readToArrayBuffer(fd: number, start: number, length: number) {\n  const buffer = Buffer.alloc(length);\n  const {bytesRead} = await read(fd, buffer, 0, length, start);\n  if (bytesRead !== length) {\n    throw new Error('fs.read failed');\n  }\n  return toArrayBuffer(buffer);\n}\n"],"mappings":";;;;;;;;;;AACA;AACA;AACA;;AAIO,IAAIA,OAAO;AAAC;AAEZ,IAAIC,IAAI;;AAAC;AAGT,IAAIC,QAAQ;AAAC;AAEb,IAAIC,YAAY;AAAC;AAEjB,IAAIC,SAAS;AAAC;AAEd,IAAIC,aAAa;;AAAC;;AAKlB,IAAIC,IAAI;AAAC;AAET,IAAIC,KAAoC;AAAC;AAEzC,IAAIC,IAAI;AAAC;AAET,IAAIC,KAAK;AAAC;AAEV,IAAIC,iBAA8C;AAAC;AAEnD,IAAIC,WAAW,GAAGC,OAAO,CAACC,WAAE,CAAC;;AAAC;;AAIrC,IAAI;EAEF,kBAAAb,OAAO,GAAG,IAAAc,gBAAU,EAACD,WAAE,CAACb,OAAO,CAAC;EAEhC,eAAAC,IAAI,GAAG,IAAAa,gBAAU,EAACD,WAAE,CAACZ,IAAI,CAAC;;EAG1B,mBAAAC,QAAQ,GAAGW,WAAE,CAACX,QAAQ;EAEtB,uBAAAC,YAAY,GAAGU,WAAE,CAACV,YAAY;EAE9B,oBAAAC,SAAS,GAAG,IAAAW,gBAAU,EAACF,WAAE,CAACT,SAAS,CAAC;EAEpC,wBAAAC,aAAa,GAAGQ,WAAE,CAACR,aAAa;;EAKhC,eAAAC,IAAI,GAAGO,WAAE,CAACP,IAAI;EAEd,gBAAAC,KAAK,GAAG,eAACS,EAAU;IAAA,OACjB,IAAIC,OAAO,CAAC,UAACC,OAAO,EAAEC,MAAM;MAAA,OAAKN,WAAE,CAACN,KAAK,CAACS,EAAE,EAAE,UAACI,GAAG;QAAA,OAAMA,GAAG,GAAGD,MAAM,CAACC,GAAG,CAAC,GAAGF,OAAO,EAAE;MAAA,CAAC,CAAC;IAAA,EAAC;EAAA;EAE1F,eAAAV,IAAI,GAAGK,WAAE,CAACL,IAAI;EAEd,gBAAAC,KAAK,GAAGI,WAAE,CAACJ,KAAK;EAEhB,4BAAAC,iBAAiB,GAAGG,WAAE,CAACH,iBAAiB;EAExC,sBAAAC,WAAW,GAAGC,OAAO,CAACC,WAAE,CAAC;AAC3B,CAAC,CAAC,gBAAM;AAER;AAAC,SAEqBQ,kBAAkB;EAAA;AAAA;AAAA;EAAA,gFAAjC,iBAAkCL,EAAU,EAAEM,KAAa,EAAEC,MAAc;IAAA;IAAA;MAAA;QAAA;UAAA;YAC1EC,MAAM,GAAGC,MAAM,CAACC,KAAK,CAACH,MAAM,CAAC;YAAA;YAAA,OACTf,IAAI,CAACQ,EAAE,EAAEQ,MAAM,EAAE,CAAC,EAAED,MAAM,EAAED,KAAK,CAAC;UAAA;YAAA;YAArDK,SAAS,eAATA,SAAS;YAAA,MACZA,SAAS,KAAKJ,MAAM;cAAA;cAAA;YAAA;YAAA,MAChB,IAAIK,KAAK,CAAC,gBAAgB,CAAC;UAAA;YAAA,iCAE5B,IAAAC,qBAAa,EAACL,MAAM,CAAC;UAAA;UAAA;YAAA;QAAA;MAAA;IAAA;EAAA,CAC7B;EAAA;AAAA"}
+{"version":3,"file":"fs.js","names":["readdir","stat","readFile","readFileSync","writeFile","writeFileSync","open","close","read","fstat","isSupported","Boolean","fs","promisify","_readToArrayBuffer","fd","start","length","buffer","Buffer","alloc","bytesRead","Error","toArrayBuffer"],"sources":["../../../../src/lib/node/fs.ts"],"sourcesContent":["// fs wrapper (promisified fs + avoids bundling fs in browsers)\nimport fs from 'fs';\nimport {toArrayBuffer} from './buffer';\nimport {promisify} from './util';\n\nexport type {Stats} from 'fs';\n\nexport let readdir;\n/** Wrapper for Node.js fs method */\nexport let stat;\n\n/** Wrapper for Node.js fs method */\nexport let readFile;\n/** Wrapper for Node.js fs method */\nexport let readFileSync;\n/** Wrapper for Node.js fs method */\nexport let writeFile;\n/** Wrapper for Node.js fs method */\nexport let writeFileSync;\n\n// file descriptors\n\n/** Wrapper for Node.js fs method */\nexport let open;\n/** Wrapper for Node.js fs method */\nexport let close;\n/** Wrapper for Node.js fs method */\nexport let read;\n/** Wrapper for Node.js fs method */\nexport let fstat;\n\nexport let isSupported = Boolean(fs);\n\n// paths\n\ntry {\n  /** Wrapper for Node.js fs method */\n  readdir = promisify(fs.readdir);\n  /** Wrapper for Node.js fs method */\n  stat = promisify(fs.stat);\n\n  /** Wrapper for Node.js fs method */\n  readFile = promisify(fs.readFile);\n  /** Wrapper for Node.js fs method */\n  readFileSync = fs.readFileSync;\n  /** Wrapper for Node.js fs method */\n  writeFile = promisify(fs.writeFile);\n  /** Wrapper for Node.js fs method */\n  writeFileSync = fs.writeFileSync;\n\n  // file descriptors\n\n  /** Wrapper for Node.js fs method */\n  open = promisify(fs.open);\n  /** Wrapper for Node.js fs method */\n  close = promisify(fs.close);\n  /** Wrapper for Node.js fs method */\n  read = promisify(fs.read);\n  /** Wrapper for Node.js fs method */\n  fstat = promisify(fs.fstat);\n\n  isSupported = Boolean(fs);\n} catch {\n  // ignore\n}\n\nexport async function _readToArrayBuffer(fd: number, start: number, length: number) {\n  const buffer = Buffer.alloc(length);\n  const {bytesRead} = await read(fd, buffer, 0, length, start);\n  if (bytesRead !== length) {\n    throw new Error('fs.read failed');\n  }\n  return toArrayBuffer(buffer);\n}\n"],"mappings":";;;;;;;;;;AACA;AACA;AACA;;AAIO,IAAIA,OAAO;AAAC;AAEZ,IAAIC,IAAI;;AAAC;AAGT,IAAIC,QAAQ;AAAC;AAEb,IAAIC,YAAY;AAAC;AAEjB,IAAIC,SAAS;AAAC;AAEd,IAAIC,aAAa;;AAAC;;AAKlB,IAAIC,IAAI;AAAC;AAET,IAAIC,KAAK;AAAC;AAEV,IAAIC,IAAI;AAAC;AAET,IAAIC,KAAK;AAAC;AAEV,IAAIC,WAAW,GAAGC,OAAO,CAACC,WAAE,CAAC;;AAAC;;AAIrC,IAAI;EAEF,kBAAAZ,OAAO,GAAG,IAAAa,eAAS,EAACD,WAAE,CAACZ,OAAO,CAAC;EAE/B,eAAAC,IAAI,GAAG,IAAAY,eAAS,EAACD,WAAE,CAACX,IAAI,CAAC;;EAGzB,mBAAAC,QAAQ,GAAG,IAAAW,eAAS,EAACD,WAAE,CAACV,QAAQ,CAAC;EAEjC,uBAAAC,YAAY,GAAGS,WAAE,CAACT,YAAY;EAE9B,oBAAAC,SAAS,GAAG,IAAAS,eAAS,EAACD,WAAE,CAACR,SAAS,CAAC;EAEnC,wBAAAC,aAAa,GAAGO,WAAE,CAACP,aAAa;;EAKhC,eAAAC,IAAI,GAAG,IAAAO,eAAS,EAACD,WAAE,CAACN,IAAI,CAAC;EAEzB,gBAAAC,KAAK,GAAG,IAAAM,eAAS,EAACD,WAAE,CAACL,KAAK,CAAC;EAE3B,eAAAC,IAAI,GAAG,IAAAK,eAAS,EAACD,WAAE,CAACJ,IAAI,CAAC;EAEzB,gBAAAC,KAAK,GAAG,IAAAI,eAAS,EAACD,WAAE,CAACH,KAAK,CAAC;EAE3B,sBAAAC,WAAW,GAAGC,OAAO,CAACC,WAAE,CAAC;AAC3B,CAAC,CAAC,gBAAM;AAER;AAAC,SAEqBE,kBAAkB;EAAA;AAAA;AAAA;EAAA,gFAAjC,iBAAkCC,EAAU,EAAEC,KAAa,EAAEC,MAAc;IAAA;IAAA;MAAA;QAAA;UAAA;YAC1EC,MAAM,GAAGC,MAAM,CAACC,KAAK,CAACH,MAAM,CAAC;YAAA;YAAA,OACTT,IAAI,CAACO,EAAE,EAAEG,MAAM,EAAE,CAAC,EAAED,MAAM,EAAED,KAAK,CAAC;UAAA;YAAA;YAArDK,SAAS,eAATA,SAAS;YAAA,MACZA,SAAS,KAAKJ,MAAM;cAAA;cAAA;YAAA;YAAA,MAChB,IAAIK,KAAK,CAAC,gBAAgB,CAAC;UAAA;YAAA,iCAE5B,IAAAC,qBAAa,EAACL,MAAM,CAAC;UAAA;UAAA;YAAA;QAAA;MAAA;IAAA;EAAA,CAC7B;EAAA;AAAA"}