@loaders.gl/loader-utils 3.1.0-alpha.4 → 4.0.0-alpha.1

package/dist/es5/index.js

@@ -1,325 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _typeof = require("@babel/runtime/helpers/typeof");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "assert", {
-  enumerable: true,
-  get: function get() {
-    return _assert.assert;
-  }
-});
-Object.defineProperty(exports, "isBrowser", {
-  enumerable: true,
-  get: function get() {
-    return _globals.isBrowser;
-  }
-});
-Object.defineProperty(exports, "isWorker", {
-  enumerable: true,
-  get: function get() {
-    return _globals.isWorker;
-  }
-});
-Object.defineProperty(exports, "nodeVersion", {
-  enumerable: true,
-  get: function get() {
-    return _globals.nodeVersion;
-  }
-});
-Object.defineProperty(exports, "self", {
-  enumerable: true,
-  get: function get() {
-    return _globals.self;
-  }
-});
-Object.defineProperty(exports, "window", {
-  enumerable: true,
-  get: function get() {
-    return _globals.window;
-  }
-});
-Object.defineProperty(exports, "global", {
-  enumerable: true,
-  get: function get() {
-    return _globals.global;
-  }
-});
-Object.defineProperty(exports, "document", {
-  enumerable: true,
-  get: function get() {
-    return _globals.document;
-  }
-});
-Object.defineProperty(exports, "createLoaderWorker", {
-  enumerable: true,
-  get: function get() {
-    return _createLoaderWorker.createLoaderWorker;
-  }
-});
-Object.defineProperty(exports, "parseWithWorker", {
-  enumerable: true,
-  get: function get() {
-    return _parseWithWorker.parseWithWorker;
-  }
-});
-Object.defineProperty(exports, "canParseWithWorker", {
-  enumerable: true,
-  get: function get() {
-    return _parseWithWorker.canParseWithWorker;
-  }
-});
-Object.defineProperty(exports, "parseJSON", {
-  enumerable: true,
-  get: function get() {
-    return _parseJson.parseJSON;
-  }
-});
-Object.defineProperty(exports, "toArrayBuffer", {
-  enumerable: true,
-  get: function get() {
-    return _arrayBufferUtils.toArrayBuffer;
-  }
-});
-Object.defineProperty(exports, "sliceArrayBuffer", {
-  enumerable: true,
-  get: function get() {
-    return _arrayBufferUtils.sliceArrayBuffer;
-  }
-});
-Object.defineProperty(exports, "concatenateArrayBuffers", {
-  enumerable: true,
-  get: function get() {
-    return _arrayBufferUtils.concatenateArrayBuffers;
-  }
-});
-Object.defineProperty(exports, "concatenateTypedArrays", {
-  enumerable: true,
-  get: function get() {
-    return _arrayBufferUtils.concatenateTypedArrays;
-  }
-});
-Object.defineProperty(exports, "compareArrayBuffers", {
-  enumerable: true,
-  get: function get() {
-    return _arrayBufferUtils.compareArrayBuffers;
-  }
-});
-Object.defineProperty(exports, "padToNBytes", {
-  enumerable: true,
-  get: function get() {
-    return _memoryCopyUtils.padToNBytes;
-  }
-});
-Object.defineProperty(exports, "copyToArray", {
-  enumerable: true,
-  get: function get() {
-    return _memoryCopyUtils.copyToArray;
-  }
-});
-Object.defineProperty(exports, "copyArrayBuffer", {
-  enumerable: true,
-  get: function get() {
-    return _memoryCopyUtils.copyArrayBuffer;
-  }
-});
-Object.defineProperty(exports, "copyPaddedArrayBufferToDataView", {
-  enumerable: true,
-  get: function get() {
-    return _binaryCopyUtils.copyPaddedArrayBufferToDataView;
-  }
-});
-Object.defineProperty(exports, "copyPaddedStringToDataView", {
-  enumerable: true,
-  get: function get() {
-    return _binaryCopyUtils.copyPaddedStringToDataView;
-  }
-});
-Object.defineProperty(exports, "padStringToByteAlignment", {
-  enumerable: true,
-  get: function get() {
-    return _encodeUtils.padStringToByteAlignment;
-  }
-});
-Object.defineProperty(exports, "copyStringToDataView", {
-  enumerable: true,
-  get: function get() {
-    return _encodeUtils.copyStringToDataView;
-  }
-});
-Object.defineProperty(exports, "copyBinaryToDataView", {
-  enumerable: true,
-  get: function get() {
-    return _encodeUtils.copyBinaryToDataView;
-  }
-});
-Object.defineProperty(exports, "getFirstCharacters", {
-  enumerable: true,
-  get: function get() {
-    return _getFirstCharacters.getFirstCharacters;
-  }
-});
-Object.defineProperty(exports, "getMagicString", {
-  enumerable: true,
-  get: function get() {
-    return _getFirstCharacters.getMagicString;
-  }
-});
-Object.defineProperty(exports, "makeTextEncoderIterator", {
-  enumerable: true,
-  get: function get() {
-    return _textIterators.makeTextEncoderIterator;
-  }
-});
-Object.defineProperty(exports, "makeTextDecoderIterator", {
-  enumerable: true,
-  get: function get() {
-    return _textIterators.makeTextDecoderIterator;
-  }
-});
-Object.defineProperty(exports, "makeLineIterator", {
-  enumerable: true,
-  get: function get() {
-    return _textIterators.makeLineIterator;
-  }
-});
-Object.defineProperty(exports, "makeNumberedLineIterator", {
-  enumerable: true,
-  get: function get() {
-    return _textIterators.makeNumberedLineIterator;
-  }
-});
-Object.defineProperty(exports, "forEach", {
-  enumerable: true,
-  get: function get() {
-    return _asyncIteration.forEach;
-  }
-});
-Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
-  enumerable: true,
-  get: function get() {
-    return _asyncIteration.concatenateArrayBuffersAsync;
-  }
-});
-Object.defineProperty(exports, "RequestScheduler", {
-  enumerable: true,
-  get: function get() {
-    return _requestScheduler.default;
-  }
-});
-Object.defineProperty(exports, "setPathPrefix", {
-  enumerable: true,
-  get: function get() {
-    return _fileAliases.setPathPrefix;
-  }
-});
-Object.defineProperty(exports, "getPathPrefix", {
-  enumerable: true,
-  get: function get() {
-    return _fileAliases.getPathPrefix;
-  }
-});
-Object.defineProperty(exports, "resolvePath", {
-  enumerable: true,
-  get: function get() {
-    return _fileAliases.resolvePath;
-  }
-});
-Object.defineProperty(exports, "_addAliases", {
-  enumerable: true,
-  get: function get() {
-    return _fileAliases.addAliases;
-  }
-});
-Object.defineProperty(exports, "JSONLoader", {
-  enumerable: true,
-  get: function get() {
-    return _jsonLoader.JSONLoader;
-  }
-});
-Object.defineProperty(exports, "isBuffer", {
-  enumerable: true,
-  get: function get() {
-    return _bufferUtils.isBuffer;
-  }
-});
-Object.defineProperty(exports, "toBuffer", {
-  enumerable: true,
-  get: function get() {
-    return _bufferUtils.toBuffer;
-  }
-});
-Object.defineProperty(exports, "bufferToArrayBuffer", {
-  enumerable: true,
-  get: function get() {
-    return _bufferUtils.bufferToArrayBuffer;
-  }
-});
-Object.defineProperty(exports, "promisify", {
-  enumerable: true,
-  get: function get() {
-    return util.promisify;
-  }
-});
-Object.defineProperty(exports, "_NodeFileSystem", {
-  enumerable: true,
-  get: function get() {
-    return _nodeFilesystem.default;
-  }
-});
-exports.fs = exports.util = exports.path = void 0;
-
-var _assert = require("./lib/env-utils/assert");
-
-var _globals = require("./lib/env-utils/globals");
-
-var _createLoaderWorker = require("./lib/worker-loader-utils/create-loader-worker");
-
-var _parseWithWorker = require("./lib/worker-loader-utils/parse-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 _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 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 _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; }
-//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA;;AACA;;AAWA;;AACA;;AAGA;;AAGA;;AAOA;;AACA;;AAIA;;AAKA;;AAGA;;AAMA;;AAGA;;AAGA;;AAIA;;AAOA;;;;AAIA;;AAKA;;;;AAMA;;;;AAIA","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';\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"],"file":"index.js"}

package/dist/es5/json-loader.js

@@ -1,57 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-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.1.0-alpha.4" !== 'undefined' ? "3.1.0-alpha.4" : 'latest';
-var JSONLoader = {
-  name: 'JSON',
-  id: 'json',
-  module: 'json',
-  version: VERSION,
-  extensions: ['json', 'geojson'],
-  mimeTypes: ['application/json'],
-  category: 'json',
-  text: true,
-  parseTextSync: parseTextSync,
-  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();
-          }
-        }
-      }, _callee);
-    }));
-
-    function parse(_x) {
-      return _parse.apply(this, arguments);
-    }
-
-    return parse;
-  }(),
-  options: {}
-};
-exports.JSONLoader = JSONLoader;
-
-function parseTextSync(text) {
-  return JSON.parse(text);
-}
-
-var _typecheckJSONLoader = JSONLoader;
-exports._typecheckJSONLoader = _typecheckJSONLoader;
-//# sourceMappingURL=json-loader.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/json-loader.ts"],"names":["VERSION","JSONLoader","name","id","module","version","extensions","mimeTypes","category","text","parseTextSync","parse","arrayBuffer","TextDecoder","decode","options","JSON","_typecheckJSONLoader"],"mappings":";;;;;;;;;;;;;AAIA,IAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AAMO,IAAMC,UAAU,GAAG;AACxBC,EAAAA,IAAI,EAAE,MADkB;AAExBC,EAAAA,EAAE,EAAE,MAFoB;AAGxBC,EAAAA,MAAM,EAAE,MAHgB;AAIxBC,EAAAA,OAAO,EAAEL,OAJe;AAKxBM,EAAAA,UAAU,EAAE,CAAC,MAAD,EAAS,SAAT,CALY;AAMxBC,EAAAA,SAAS,EAAE,CAAC,kBAAD,CANa;AAOxBC,EAAAA,QAAQ,EAAE,MAPc;AAQxBC,EAAAA,IAAI,EAAE,IARkB;AASxBC,EAAAA,aAAa,EAAbA,aATwB;AAUxBC,EAAAA,KAAK;AAAA,2EAAE,iBAAOC,WAAP;AAAA;AAAA;AAAA;AAAA;AAAA,+CAAuBF,aAAa,CAAC,IAAIG,WAAJ,GAAkBC,MAAlB,CAAyBF,WAAzB,CAAD,CAApC;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAAF;;AAAA;AAAA;AAAA;;AAAA;AAAA,KAVmB;AAWxBG,EAAAA,OAAO,EAAE;AAXe,CAAnB;;;AAeP,SAASL,aAAT,CAAuBD,IAAvB,EAA6B;AAC3B,SAAOO,IAAI,CAACL,KAAL,CAAWF,IAAX,CAAP;AACD;;AAEM,IAAMQ,oBAAsC,GAAGhB,UAA/C","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"],"file":"json-loader.js"}

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

@@ -1,137 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.toArrayBuffer = toArrayBuffer;
-exports.compareArrayBuffers = compareArrayBuffers;
-exports.concatenateArrayBuffers = concatenateArrayBuffers;
-exports.concatenateTypedArrays = concatenateTypedArrays;
-exports.sliceArrayBuffer = sliceArrayBuffer;
-
-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) {
-    return false;
-  }
-
-  var array1 = new Uint8Array(arrayBuffer1);
-  var array2 = new Uint8Array(arrayBuffer2);
-
-  for (var i = 0; i < array1.length; ++i) {
-    if (array1[i] !== array2[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function concatenateArrayBuffers() {
-  for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
-    sources[_key] = arguments[_key];
-  }
-
-  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;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var sourceArray = _step.value;
-      result.set(sourceArray, offset);
-      offset += sourceArray.byteLength;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-
-  return result.buffer;
-}
-
-function concatenateTypedArrays() {
-  for (var _len2 = arguments.length, typedArrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    typedArrays[_key2] = arguments[_key2];
-  }
-
-  var arrays = typedArrays;
-  var TypedArrayConstructor = arrays && arrays.length > 1 && arrays[0].constructor || null;
-
-  if (!TypedArrayConstructor) {
-    throw new Error('"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types');
-  }
-
-  var sumLength = arrays.reduce(function (acc, value) {
-    return acc + value.length;
-  }, 0);
-  var result = new TypedArrayConstructor(sumLength);
-  var offset = 0;
-
-  for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
-    var array = _arrays[_i];
-    result.set(array, offset);
-    offset += array.length;
-  }
-
-  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);
-  return arrayCopy.buffer;
-}
-//# sourceMappingURL=array-buffer-utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/lib/binary-utils/array-buffer-utils.ts"],"names":["toArrayBuffer","data","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"],"mappings":"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","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"],"file":"array-buffer-utils.js"}

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

@@ -1,35 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.copyPaddedArrayBufferToDataView = copyPaddedArrayBufferToDataView;
-exports.copyPaddedStringToDataView = copyPaddedStringToDataView;
-
-var _memoryCopyUtils = require("./memory-copy-utils");
-
-function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
-  var paddedLength = (0, _memoryCopyUtils.padToNBytes)(sourceBuffer.byteLength, padding);
-  var padLength = paddedLength - sourceBuffer.byteLength;
-
-  if (dataView) {
-    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);
-    }
-  }
-
-  byteOffset += paddedLength;
-  return byteOffset;
-}
-
-function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
-  var textEncoder = new TextEncoder();
-  var stringBuffer = textEncoder.encode(string);
-  byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
-  return byteOffset;
-}
-//# sourceMappingURL=binary-copy-utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/lib/binary-utils/binary-copy-utils.ts"],"names":["copyPaddedArrayBufferToDataView","dataView","byteOffset","sourceBuffer","padding","paddedLength","byteLength","padLength","targetArray","Uint8Array","buffer","sourceArray","set","i","setUint8","copyPaddedStringToDataView","string","textEncoder","TextEncoder","stringBuffer","encode"],"mappings":";;;;;;;;AACA;;AAYO,SAASA,+BAAT,CACLC,QADK,EAELC,UAFK,EAGLC,YAHK,EAILC,OAJK,EAKL;AACA,MAAMC,YAAY,GAAG,kCAAYF,YAAY,CAACG,UAAzB,EAAqCF,OAArC,CAArB;AACA,MAAMG,SAAS,GAAGF,YAAY,GAAGF,YAAY,CAACG,UAA9C;;AAEA,MAAIL,QAAJ,EAAc;AAEZ,QAAMO,WAAW,GAAG,IAAIC,UAAJ,CAClBR,QAAQ,CAACS,MADS,EAElBT,QAAQ,CAACC,UAAT,GAAsBA,UAFJ,EAGlBC,YAAY,CAACG,UAHK,CAApB;AAKA,QAAMK,WAAW,GAAG,IAAIF,UAAJ,CAAeN,YAAf,CAApB;AACAK,IAAAA,WAAW,CAACI,GAAZ,CAAgBD,WAAhB;;AAGA,SAAK,IAAIE,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGN,SAApB,EAA+B,EAAEM,CAAjC,EAAoC;AAElCZ,MAAAA,QAAQ,CAACa,QAAT,CAAkBZ,UAAU,GAAGC,YAAY,CAACG,UAA1B,GAAuCO,CAAzD,EAA4D,IAA5D;AACD;AACF;;AACDX,EAAAA,UAAU,IAAIG,YAAd;AACA,SAAOH,UAAP;AACD;;AAYM,SAASa,0BAAT,CACLd,QADK,EAELC,UAFK,EAGLc,MAHK,EAILZ,OAJK,EAKG;AACR,MAAMa,WAAW,GAAG,IAAIC,WAAJ,EAApB;AAGA,MAAMC,YAAY,GAAGF,WAAW,CAACG,MAAZ,CAAmBJ,MAAnB,CAArB;AAEAd,EAAAA,UAAU,GAAGF,+BAA+B,CAACC,QAAD,EAAWC,UAAX,EAAuBiB,YAAvB,EAAqCf,OAArC,CAA5C;AAEA,SAAOF,UAAP;AACD","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"],"file":"binary-copy-utils.js"}

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

@@ -1,38 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _typeof3 = require("@babel/runtime/helpers/typeof");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isBuffer = isBuffer;
-exports.toBuffer = toBuffer;
-exports.bufferToArrayBuffer = bufferToArrayBuffer;
-
-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 bufferToArrayBuffer(buffer) {
-  if (isBuffer(buffer)) {
-    var typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
-    return typedArray.slice().buffer;
-  }
-
-  return buffer;
-}
-//# sourceMappingURL=buffer-utils.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/lib/binary-utils/buffer-utils.ts"],"names":["isBuffer","value","toBuffer","data","node","bufferToArrayBuffer","buffer","typedArray","Uint8Array","byteOffset","length","slice"],"mappings":";;;;;;;;;;;;;;;AAAA;;;;;;AAKO,SAASA,QAAT,CAAkBC,KAAlB,EAAuC;AAC5C,SAAOA,KAAK,IAAI,sBAAOA,KAAP,MAAiB,QAA1B,IAAsCA,KAAK,CAACD,QAAnD;AACD;;AAMM,SAASE,QAAT,CAAkBC,IAAlB,EAAqC;AAC1C,SAAOC,IAAI,CAACF,QAAL,GAAgBE,IAAI,CAACF,QAAL,CAAcC,IAAd,CAAhB,GAAsCA,IAA7C;AACD;;AAMM,SAASE,mBAAT,CAA6BC,MAA7B,EAAuD;AAC5D,MAAIN,QAAQ,CAACM,MAAD,CAAZ,EAAsB;AACpB,QAAMC,UAAU,GAAG,IAAIC,UAAJ,CAAeF,MAAM,CAACA,MAAtB,EAA8BA,MAAM,CAACG,UAArC,EAAiDH,MAAM,CAACI,MAAxD,CAAnB;AACA,WAAOH,UAAU,CAACI,KAAX,GAAmBL,MAA1B;AACD;;AACD,SAAOA,MAAP;AACD","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"],"file":"buffer-utils.js"}