@loaders.gl/i3s 3.4.0-alpha.4 → 3.4.0

package/dist/dist.min.js

@@ -234,6 +234,22 @@
     }
     return false;
   }
+  function getTransferListForWriter(object) {
+    if (object === null) {
+      return {};
+    }
+    const clone3 = Object.assign({}, object);
+    Object.keys(clone3).forEach((key) => {
+      if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+        clone3[key] = getTransferListForWriter(object[key]);
+      } else if (typeof clone3[key] === "function" || clone3[key] instanceof RegExp) {
+        clone3[key] = {};
+      } else {
+        clone3[key] = object[key];
+      }
+    });
+    return clone3;
+  }
   var init_get_transfer_list = __esm({
     "../worker-utils/src/lib/worker-utils/get-transfer-list.ts"() {
     }
@@ -381,9 +397,9 @@
             this.onDebug = props.onDebug;
           }
         }
-        async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+        async startJob(name, onMessage3 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
           const startPromise = new Promise((onStart) => {
-            this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+            this.jobQueue.push({ name, onMessage: onMessage3, onError, onStart });
             return this;
           });
           this._startQueuedJob();
@@ -513,6 +529,10 @@
   });
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerName(worker) {
+    const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+    return `${worker.name}@${worker.version}${warning}`;
+  }
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
     const workerFile = `${worker.id}-worker.js`;
@@ -534,11 +554,64 @@
     assert2(url);
     return url;
   }
-  var NPM_TAG;
+  var NPM_TAG, VERSION2;
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert2();
+      init_version();
       NPM_TAG = "beta";
+      VERSION2 = typeof VERSION !== "undefined" ? VERSION : NPM_TAG;
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-api/process-on-worker.ts
+  async function processOnWorker(worker, data, options = {}, context = {}) {
+    const name = getWorkerName(worker);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const { source } = options;
+    const workerPoolProps = { name, source };
+    if (!source) {
+      workerPoolProps.url = getWorkerURL(worker, options);
+    }
+    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+    const jobName = options.jobName || worker.name;
+    const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
+    const transferableOptions = getTransferListForWriter(options);
+    job.postMessage("process", { input: data, options: transferableOptions });
+    const result = await job.result;
+    return result.result;
+  }
+  async function onMessage(context, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const { id, input, options } = payload;
+        try {
+          if (!context.process) {
+            job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+            return;
+          }
+          const result = await context.process(input, options);
+          job.postMessage("done", { id, result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", { id, error: message });
+        }
+        break;
+      default:
+        console.warn(`process-on-worker: unknown message ${type}`);
+    }
+  }
+  var init_process_on_worker = __esm({
+    "../worker-utils/src/lib/worker-api/process-on-worker.ts"() {
+      init_worker_farm();
+      init_get_worker_url();
+      init_get_transfer_list();
     }
   });
 
@@ -585,7 +658,7 @@
     }
     if (options.CDN) {
       assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+      return `${options.CDN}/${moduleName}@${VERSION3}/dist/libs/${library}`;
     }
     if (isWorker) {
       return `../src/libs/${library}`;
@@ -629,7 +702,7 @@
     document.body.appendChild(script);
     return null;
   }
-  var node, LATEST, VERSION2, loadLibraryPromises;
+  var node, LATEST, VERSION3, loadLibraryPromises;
   var init_library_utils = __esm({
     "../worker-utils/src/lib/library-utils/library-utils.ts"() {
       init_globals2();
@@ -637,7 +710,7 @@
       init_assert2();
       init_version();
       LATEST = "beta";
-      VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
+      VERSION3 = typeof VERSION !== "undefined" ? VERSION : LATEST;
       loadLibraryPromises = {};
     }
   });
@@ -648,6 +721,7 @@
       init_assert2();
       init_globals2();
       init_worker_farm();
+      init_process_on_worker();
       init_get_worker_url();
       init_validate_worker_version();
       init_library_utils();
@@ -671,7 +745,7 @@
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
     context = JSON.parse(JSON.stringify(context || {}));
-    const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread));
+    const job = await workerPool.startJob("process-on-worker", onMessage2.bind(null, parseOnMainThread));
     job.postMessage("process", {
       input: data,
       options,
@@ -680,7 +754,7 @@
     const result = await job.result;
     return await result.result;
   }
-  async function onMessage(parseOnMainThread, job, type, payload) {
+  async function onMessage2(parseOnMainThread, job, type, payload) {
     switch (type) {
       case "done":
         job.done(payload);
@@ -845,15 +919,15 @@
   function parseTextSync(text) {
     return JSON.parse(text);
   }
-  var VERSION3, JSONLoader;
+  var VERSION4, JSONLoader;
   var init_json_loader = __esm({
     "../loader-utils/src/json-loader.ts"() {
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       JSONLoader = {
         name: "JSON",
         id: "json",
         module: "json",
-        version: VERSION3,
+        version: VERSION4,
         extensions: ["json", "geojson"],
         mimeTypes: ["application/json"],
         category: "json",
@@ -1115,39 +1189,60 @@
     }
   });
 
+  // ../core/src/lib/utils/url-utils.ts
+  function extractQueryString(url) {
+    const matches3 = url.match(QUERY_STRING_PATTERN);
+    return matches3 && matches3[0];
+  }
+  function stripQueryString(url) {
+    return url.replace(QUERY_STRING_PATTERN, "");
+  }
+  var QUERY_STRING_PATTERN;
+  var init_url_utils = __esm({
+    "../core/src/lib/utils/url-utils.ts"() {
+      QUERY_STRING_PATTERN = /\?.*/;
+    }
+  });
+
   // ../core/src/lib/utils/resource-utils.ts
-  function getResourceUrlAndType(resource) {
+  function getResourceUrl(resource) {
     if (isResponse(resource)) {
-      const url = stripQueryString(resource.url || "");
-      const contentTypeHeader = resource.headers.get("content-type") || "";
-      return {
-        url,
-        type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)
-      };
+      const response = resource;
+      return response.url;
     }
     if (isBlob(resource)) {
-      return {
-        url: stripQueryString(resource.name || ""),
-        type: resource.type || ""
-      };
+      const blob = resource;
+      return blob.name || "";
     }
     if (typeof resource === "string") {
-      return {
-        url: stripQueryString(resource),
-        type: parseMIMETypeFromURL(resource)
-      };
+      return resource;
     }
-    return {
-      url: "",
-      type: ""
-    };
+    return "";
+  }
+  function getResourceMIMEType(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      const contentTypeHeader = response.headers.get("content-type") || "";
+      const noQueryUrl = stripQueryString(response.url);
+      return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+    }
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.type || "";
+    }
+    if (typeof resource === "string") {
+      return parseMIMETypeFromURL(resource);
+    }
+    return "";
   }
   function getResourceContentLength(resource) {
     if (isResponse(resource)) {
-      return resource.headers["content-length"] || -1;
+      const response = resource;
+      return response.headers["content-length"] || -1;
     }
     if (isBlob(resource)) {
-      return resource.size;
+      const blob = resource;
+      return blob.size;
     }
     if (typeof resource === "string") {
       return resource.length;
@@ -1160,15 +1255,11 @@
     }
     return -1;
   }
-  function stripQueryString(url) {
-    return url.replace(QUERY_STRING_PATTERN, "");
-  }
-  var QUERY_STRING_PATTERN;
   var init_resource_utils = __esm({
     "../core/src/lib/utils/resource-utils.ts"() {
       init_is_type();
       init_mime_type_utils();
-      QUERY_STRING_PATTERN = /\?.*/;
+      init_url_utils();
     }
   });
 
@@ -1182,7 +1273,8 @@
     if (contentLength >= 0) {
       headers["content-length"] = String(contentLength);
     }
-    const { url, type } = getResourceUrlAndType(resource);
+    const url = getResourceUrl(resource);
+    const type = getResourceMIMEType(resource);
     if (type) {
       headers["content-type"] = type;
     }
@@ -1316,11 +1408,11 @@
   });
 
   // ../../node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION4, isBrowser4;
+  var VERSION5, isBrowser4;
   var init_globals4 = __esm({
     "../../node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser();
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
@@ -1657,7 +1749,7 @@
             id: ""
           };
           _defineProperty(this, "id", void 0);
-          _defineProperty(this, "VERSION", VERSION4);
+          _defineProperty(this, "VERSION", VERSION5);
           _defineProperty(this, "_startTs", getHiResTimestamp());
           _defineProperty(this, "_deltaTs", getHiResTimestamp());
           _defineProperty(this, "_storage", void 0);
@@ -1860,7 +1952,7 @@
           return noop;
         }
       };
-      _defineProperty(Log, "VERSION", VERSION4);
+      _defineProperty(Log, "VERSION", VERSION5);
     }
   });
 
@@ -2168,8 +2260,9 @@
     return loader;
   }
   function selectLoaderInternal(data, loaders, options, context) {
-    const { url, type } = getResourceUrlAndType(data);
-    const testUrl = url || context?.url;
+    const url = getResourceUrl(data);
+    const type = getResourceMIMEType(data);
+    const testUrl = stripQueryString(url) || context?.url;
     let loader = null;
     let reason = "";
     if (options?.mimeType) {
@@ -2198,7 +2291,8 @@
     return true;
   }
   function getNoValidLoaderMessage(data) {
-    const { url, type } = getResourceUrlAndType(data);
+    const url = getResourceUrl(data);
+    const type = getResourceMIMEType(data);
     let message = "No valid loader found (";
     message += url ? `${path_exports.filename(url)}, ` : "no url provided, ";
     message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
@@ -2317,6 +2411,7 @@
       init_resource_utils();
       init_register_loaders();
       init_is_type();
+      init_url_utils();
       EXT_PATTERN = /\.([^.]+)$/;
     }
   });
@@ -2529,18 +2624,25 @@
   });
 
   // ../core/src/lib/loader-utils/loader-context.ts
-  function getLoaderContext(context, options, previousContext = null) {
-    if (previousContext) {
-      return previousContext;
+  function getLoaderContext(context, options, parentContext) {
+    if (parentContext) {
+      return parentContext;
     }
-    const resolvedContext = {
+    const newContext = {
       fetch: getFetchFunction(options, context),
       ...context
     };
-    if (!Array.isArray(resolvedContext.loaders)) {
-      resolvedContext.loaders = null;
+    if (newContext.url) {
+      const baseUrl = stripQueryString(newContext.url);
+      newContext.baseUrl = baseUrl;
+      newContext.queryString = extractQueryString(newContext.url);
+      newContext.filename = path_exports.filename(baseUrl);
+      newContext.baseUrl = path_exports.dirname(baseUrl);
+    }
+    if (!Array.isArray(newContext.loaders)) {
+      newContext.loaders = null;
     }
-    return resolvedContext;
+    return newContext;
   }
   function getLoadersFromContext(loaders, context) {
     if (!context && loaders && !Array.isArray(loaders)) {
@@ -2559,6 +2661,8 @@
   var init_loader_context = __esm({
     "../core/src/lib/loader-utils/loader-context.ts"() {
       init_get_fetch_function();
+      init_url_utils();
+      init_src2();
     }
   });
 
@@ -2572,7 +2676,7 @@
     }
     data = await data;
     options = options || {};
-    const { url } = getResourceUrlAndType(data);
+    const url = getResourceUrl(data);
     const typedLoaders = loaders;
     const candidateLoaders = getLoadersFromContext(typedLoaders, context);
     const loader = await selectLoader(data, candidateLoaders, options);
@@ -2580,7 +2684,7 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context);
+    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
@@ -5973,10 +6077,10 @@
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION5;
+  var VERSION6;
   var init_version2 = __esm({
     "../images/src/lib/utils/version.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -6425,7 +6529,7 @@
         id: "image",
         module: "images",
         name: "Images",
-        version: VERSION5,
+        version: VERSION6,
         mimeTypes: MIME_TYPES,
         extensions: EXTENSIONS,
         parse: parseImage,
@@ -6443,10 +6547,10 @@
   });
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION6;
+  var VERSION7;
   var init_version3 = __esm({
     "../draco/src/lib/utils/version.ts"() {
-      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -6469,7 +6573,7 @@
         id: isBrowser2 ? "draco" : "draco-nodejs",
         module: "draco",
         shapes: ["mesh"],
-        version: VERSION6,
+        version: VERSION7,
         worker: true,
         extensions: ["drc"],
         mimeTypes: ["application/octet-stream"],
@@ -7525,10 +7629,10 @@
   });
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION7;
+  var VERSION8;
   var init_version4 = __esm({
     "../textures/src/lib/utils/version.ts"() {
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
     }
   });
 
@@ -7595,13 +7699,13 @@
       });
     });
   }
-  var VERSION8, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
+  var VERSION9, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
   var init_basis_module_loader = __esm({
     "../textures/src/lib/parsers/basis-module-loader.ts"() {
       init_src();
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
-      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.wasm`;
-      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.js`;
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION9}/dist/libs/basis_encoder.wasm`;
+      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION9}/dist/libs/basis_encoder.js`;
     }
   });
 
@@ -8169,7 +8273,7 @@
         name: "Basis",
         id: isBrowser2 ? "basis" : "basis-nodejs",
         module: "textures",
-        version: VERSION7,
+        version: VERSION8,
         worker: true,
         extensions: ["basis", "ktx2"],
         mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -8512,7 +8616,7 @@
         name: "Texture Containers",
         id: "compressed-texture",
         module: "textures",
-        version: VERSION7,
+        version: VERSION8,
         worker: true,
         extensions: [
           "ktx",
@@ -8605,7 +8709,7 @@
     }
     return attributeUrls;
   }
-  var init_url_utils = __esm({
+  var init_url_utils2 = __esm({
     "src/lib/utils/url-utils.ts"() {
     }
   });
@@ -9448,20 +9552,20 @@
     }
     return value;
   }
-  var VERSION9, EMPTY_VALUE, REJECTED_STATUS, I3SAttributeLoader;
+  var VERSION10, EMPTY_VALUE, REJECTED_STATUS, I3SAttributeLoader;
   var init_i3s_attribute_loader = __esm({
     "src/i3s-attribute-loader.ts"() {
       init_src3();
       init_parse_i3s_attribute();
-      init_url_utils();
-      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      init_url_utils2();
+      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       EMPTY_VALUE = "";
       REJECTED_STATUS = "rejected";
       I3SAttributeLoader = {
         name: "I3S Attribute",
         id: "i3s-attribute",
         module: "i3s",
-        version: VERSION9,
+        version: VERSION10,
         mimeTypes: ["application/binary"],
         parse: parse3,
         extensions: ["bin"],
@@ -9534,7 +9638,7 @@
     "src/lib/utils/customizeColors.ts"() {
       init_src3();
       init_i3s_attribute_loader();
-      init_url_utils();
+      init_url_utils2();
     }
   });
 
@@ -9920,7 +10024,7 @@
       init_src6();
       init_src7();
       init_types();
-      init_url_utils();
+      init_url_utils2();
       init_constants2();
       init_customizeColors();
       scratchVector5 = new Vector3([0, 0, 0]);
@@ -9938,18 +10042,18 @@
     }
     return await parseI3STileContent(data, tileOptions, tilesetOptions, options, context);
   }
-  var VERSION10, I3SContentLoader;
+  var VERSION11, I3SContentLoader;
   var init_i3s_content_loader = __esm({
     "src/i3s-content-loader.ts"() {
       init_src();
       init_parse_i3s_tile_content();
-      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       I3SContentLoader = {
         name: "I3S Content (Indexed Scene Layers)",
         id: isBrowser2 ? "i3s-content" : "i3s-content-nodejs",
         module: "i3s",
         worker: true,
-        version: VERSION10,
+        version: VERSION11,
         mimeTypes: ["application/octet-stream"],
         parse: parse4,
         extensions: ["bin"],
@@ -10553,15 +10657,15 @@
     data = parseNodePage(data);
     return data;
   }
-  var VERSION11, I3SNodePageLoader;
+  var VERSION12, I3SNodePageLoader;
   var init_i3s_node_page_loader = __esm({
     "src/i3s-node-page-loader.ts"() {
-      VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       I3SNodePageLoader = {
         name: "I3S Node Page",
         id: "i3s-node-page",
         module: "i3s",
-        version: VERSION11,
+        version: VERSION12,
         mimeTypes: ["application/json"],
         parse: parse5,
         extensions: ["json"],
@@ -10578,7 +10682,7 @@
       init_src7();
       init_i3s_node_page_loader();
       init_parse_i3s();
-      init_url_utils();
+      init_url_utils2();
       I3SNodePagesTiles = class {
         constructor(tileset, options) {
           this.nodePages = [];
@@ -10830,7 +10934,7 @@
       init_src3();
       init_src8();
       init_i3s_nodepages_tiles();
-      init_url_utils();
+      init_url_utils2();
     }
   });
 
@@ -10885,14 +10989,14 @@
     }
     return null;
   }
-  var VERSION12, TILESET_REGEX, TILE_HEADER_REGEX, SLPK_HEX, POINT_CLOUD, I3SLoader;
+  var VERSION13, TILESET_REGEX, TILE_HEADER_REGEX, SLPK_HEX, POINT_CLOUD, I3SLoader;
   var init_i3s_loader = __esm({
     "src/i3s-loader.ts"() {
       init_src3();
       init_i3s_content_loader();
       init_parse_i3s();
       init_constants2();
-      VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       TILESET_REGEX = /layers\/[0-9]+$/;
       TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
       SLPK_HEX = "504b0304";
@@ -10901,7 +11005,7 @@
         name: "I3S (Indexed Scene Layers)",
         id: "i3s",
         module: "i3s",
-        version: VERSION12,
+        version: VERSION13,
         mimeTypes: ["application/octet-stream"],
         parse: parseI3S,
         extensions: ["bin"],
@@ -10925,6 +11029,459 @@
     }
   });
 
+  // src/lib/parsers/parse-zip/cd-file-header.ts
+  var parseZipCDFileHeader;
+  var init_cd_file_header = __esm({
+    "src/lib/parsers/parse-zip/cd-file-header.ts"() {
+      parseZipCDFileHeader = (headerOffset, buffer) => {
+        const offsets = {
+          CD_COMPRESSED_SIZE_OFFSET: 20,
+          CD_UNCOMPRESSED_SIZE_OFFSET: 24,
+          CD_FILE_NAME_LENGTH_OFFSET: 28,
+          CD_EXTRA_FIELD_LENGTH_OFFSET: 30,
+          CD_LOCAL_HEADER_OFFSET_OFFSET: 42,
+          CD_FILE_NAME_OFFSET: 46
+        };
+        const compressedSize = buffer.getUint32(headerOffset + offsets.CD_COMPRESSED_SIZE_OFFSET, true);
+        const uncompressedSize = buffer.getUint32(headerOffset + offsets.CD_UNCOMPRESSED_SIZE_OFFSET, true);
+        const fileNameLength = buffer.getUint16(headerOffset + offsets.CD_FILE_NAME_LENGTH_OFFSET, true);
+        const fileName = buffer.buffer.slice(headerOffset + offsets.CD_FILE_NAME_OFFSET, headerOffset + offsets.CD_FILE_NAME_OFFSET + fileNameLength);
+        const extraOffset = headerOffset + offsets.CD_FILE_NAME_OFFSET + fileNameLength;
+        const oldFormatOffset = buffer.getUint32(headerOffset + offsets.CD_LOCAL_HEADER_OFFSET_OFFSET, true);
+        let fileDataOffset = oldFormatOffset;
+        if (fileDataOffset === 4294967295) {
+          let offsetInZip64Data = 4;
+          if (compressedSize === 4294967295) {
+            offsetInZip64Data += 8;
+          }
+          if (uncompressedSize === 4294967295) {
+            offsetInZip64Data += 8;
+          }
+          fileDataOffset = buffer.getUint32(extraOffset + offsetInZip64Data, true);
+        }
+        const localHeaderOffset = fileDataOffset;
+        return {
+          compressedSize,
+          uncompressedSize,
+          fileNameLength,
+          fileName,
+          extraOffset,
+          localHeaderOffset
+        };
+      };
+    }
+  });
+
+  // src/lib/parsers/parse-zip/local-file-header.ts
+  var parseZipLocalFileHeader;
+  var init_local_file_header = __esm({
+    "src/lib/parsers/parse-zip/local-file-header.ts"() {
+      parseZipLocalFileHeader = (headerOffset, buffer) => {
+        const offsets = {
+          COMPRESSED_SIZE_OFFSET: 18,
+          FILE_NAME_LENGTH_OFFSET: 26,
+          EXTRA_FIELD_LENGTH_OFFSET: 28,
+          FILE_NAME_OFFSET: 30
+        };
+        const fileNameLength = buffer.getUint16(headerOffset + offsets.FILE_NAME_LENGTH_OFFSET, true);
+        const extraFieldLength = buffer.getUint16(headerOffset + offsets.EXTRA_FIELD_LENGTH_OFFSET, true);
+        const fileDataOffset = headerOffset + offsets.FILE_NAME_OFFSET + fileNameLength + extraFieldLength;
+        const compressedSize = buffer.getUint32(headerOffset + offsets.COMPRESSED_SIZE_OFFSET, true);
+        return {
+          fileNameLength,
+          extraFieldLength,
+          fileDataOffset,
+          compressedSize
+        };
+      };
+    }
+  });
+
+  // ../../node_modules/crypt/crypt.js
+  var require_crypt = __commonJS({
+    "../../node_modules/crypt/crypt.js"(exports, module) {
+      (function() {
+        var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", crypt = {
+          rotl: function(n2, b) {
+            return n2 << b | n2 >>> 32 - b;
+          },
+          rotr: function(n2, b) {
+            return n2 << 32 - b | n2 >>> b;
+          },
+          endian: function(n2) {
+            if (n2.constructor == Number) {
+              return crypt.rotl(n2, 8) & 16711935 | crypt.rotl(n2, 24) & 4278255360;
+            }
+            for (var i2 = 0; i2 < n2.length; i2++)
+              n2[i2] = crypt.endian(n2[i2]);
+            return n2;
+          },
+          randomBytes: function(n2) {
+            for (var bytes = []; n2 > 0; n2--)
+              bytes.push(Math.floor(Math.random() * 256));
+            return bytes;
+          },
+          bytesToWords: function(bytes) {
+            for (var words = [], i2 = 0, b = 0; i2 < bytes.length; i2++, b += 8)
+              words[b >>> 5] |= bytes[i2] << 24 - b % 32;
+            return words;
+          },
+          wordsToBytes: function(words) {
+            for (var bytes = [], b = 0; b < words.length * 32; b += 8)
+              bytes.push(words[b >>> 5] >>> 24 - b % 32 & 255);
+            return bytes;
+          },
+          bytesToHex: function(bytes) {
+            for (var hex = [], i2 = 0; i2 < bytes.length; i2++) {
+              hex.push((bytes[i2] >>> 4).toString(16));
+              hex.push((bytes[i2] & 15).toString(16));
+            }
+            return hex.join("");
+          },
+          hexToBytes: function(hex) {
+            for (var bytes = [], c2 = 0; c2 < hex.length; c2 += 2)
+              bytes.push(parseInt(hex.substr(c2, 2), 16));
+            return bytes;
+          },
+          bytesToBase64: function(bytes) {
+            for (var base64 = [], i2 = 0; i2 < bytes.length; i2 += 3) {
+              var triplet = bytes[i2] << 16 | bytes[i2 + 1] << 8 | bytes[i2 + 2];
+              for (var j = 0; j < 4; j++)
+                if (i2 * 8 + j * 6 <= bytes.length * 8)
+                  base64.push(base64map.charAt(triplet >>> 6 * (3 - j) & 63));
+                else
+                  base64.push("=");
+            }
+            return base64.join("");
+          },
+          base64ToBytes: function(base64) {
+            base64 = base64.replace(/[^A-Z0-9+\/]/ig, "");
+            for (var bytes = [], i2 = 0, imod4 = 0; i2 < base64.length; imod4 = ++i2 % 4) {
+              if (imod4 == 0)
+                continue;
+              bytes.push((base64map.indexOf(base64.charAt(i2 - 1)) & Math.pow(2, -2 * imod4 + 8) - 1) << imod4 * 2 | base64map.indexOf(base64.charAt(i2)) >>> 6 - imod4 * 2);
+            }
+            return bytes;
+          }
+        };
+        module.exports = crypt;
+      })();
+    }
+  });
+
+  // ../../node_modules/charenc/charenc.js
+  var require_charenc = __commonJS({
+    "../../node_modules/charenc/charenc.js"(exports, module) {
+      var charenc = {
+        utf8: {
+          stringToBytes: function(str) {
+            return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+          },
+          bytesToString: function(bytes) {
+            return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+          }
+        },
+        bin: {
+          stringToBytes: function(str) {
+            for (var bytes = [], i2 = 0; i2 < str.length; i2++)
+              bytes.push(str.charCodeAt(i2) & 255);
+            return bytes;
+          },
+          bytesToString: function(bytes) {
+            for (var str = [], i2 = 0; i2 < bytes.length; i2++)
+              str.push(String.fromCharCode(bytes[i2]));
+            return str.join("");
+          }
+        }
+      };
+      module.exports = charenc;
+    }
+  });
+
+  // ../../node_modules/is-buffer/index.js
+  var require_is_buffer = __commonJS({
+    "../../node_modules/is-buffer/index.js"(exports, module) {
+      module.exports = function(obj) {
+        return obj != null && (isBuffer3(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+      };
+      function isBuffer3(obj) {
+        return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+      }
+      function isSlowBuffer(obj) {
+        return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer3(obj.slice(0, 0));
+      }
+    }
+  });
+
+  // ../../node_modules/md5/md5.js
+  var require_md5 = __commonJS({
+    "../../node_modules/md5/md5.js"(exports, module) {
+      (function() {
+        var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer3 = require_is_buffer(), bin = require_charenc().bin, md52 = function(message, options) {
+          if (message.constructor == String)
+            if (options && options.encoding === "binary")
+              message = bin.stringToBytes(message);
+            else
+              message = utf8.stringToBytes(message);
+          else if (isBuffer3(message))
+            message = Array.prototype.slice.call(message, 0);
+          else if (!Array.isArray(message) && message.constructor !== Uint8Array)
+            message = message.toString();
+          var m = crypt.bytesToWords(message), l2 = message.length * 8, a2 = 1732584193, b = -271733879, c2 = -1732584194, d = 271733878;
+          for (var i2 = 0; i2 < m.length; i2++) {
+            m[i2] = (m[i2] << 8 | m[i2] >>> 24) & 16711935 | (m[i2] << 24 | m[i2] >>> 8) & 4278255360;
+          }
+          m[l2 >>> 5] |= 128 << l2 % 32;
+          m[(l2 + 64 >>> 9 << 4) + 14] = l2;
+          var FF = md52._ff, GG = md52._gg, HH = md52._hh, II = md52._ii;
+          for (var i2 = 0; i2 < m.length; i2 += 16) {
+            var aa = a2, bb = b, cc = c2, dd = d;
+            a2 = FF(a2, b, c2, d, m[i2 + 0], 7, -680876936);
+            d = FF(d, a2, b, c2, m[i2 + 1], 12, -389564586);
+            c2 = FF(c2, d, a2, b, m[i2 + 2], 17, 606105819);
+            b = FF(b, c2, d, a2, m[i2 + 3], 22, -1044525330);
+            a2 = FF(a2, b, c2, d, m[i2 + 4], 7, -176418897);
+            d = FF(d, a2, b, c2, m[i2 + 5], 12, 1200080426);
+            c2 = FF(c2, d, a2, b, m[i2 + 6], 17, -1473231341);
+            b = FF(b, c2, d, a2, m[i2 + 7], 22, -45705983);
+            a2 = FF(a2, b, c2, d, m[i2 + 8], 7, 1770035416);
+            d = FF(d, a2, b, c2, m[i2 + 9], 12, -1958414417);
+            c2 = FF(c2, d, a2, b, m[i2 + 10], 17, -42063);
+            b = FF(b, c2, d, a2, m[i2 + 11], 22, -1990404162);
+            a2 = FF(a2, b, c2, d, m[i2 + 12], 7, 1804603682);
+            d = FF(d, a2, b, c2, m[i2 + 13], 12, -40341101);
+            c2 = FF(c2, d, a2, b, m[i2 + 14], 17, -1502002290);
+            b = FF(b, c2, d, a2, m[i2 + 15], 22, 1236535329);
+            a2 = GG(a2, b, c2, d, m[i2 + 1], 5, -165796510);
+            d = GG(d, a2, b, c2, m[i2 + 6], 9, -1069501632);
+            c2 = GG(c2, d, a2, b, m[i2 + 11], 14, 643717713);
+            b = GG(b, c2, d, a2, m[i2 + 0], 20, -373897302);
+            a2 = GG(a2, b, c2, d, m[i2 + 5], 5, -701558691);
+            d = GG(d, a2, b, c2, m[i2 + 10], 9, 38016083);
+            c2 = GG(c2, d, a2, b, m[i2 + 15], 14, -660478335);
+            b = GG(b, c2, d, a2, m[i2 + 4], 20, -405537848);
+            a2 = GG(a2, b, c2, d, m[i2 + 9], 5, 568446438);
+            d = GG(d, a2, b, c2, m[i2 + 14], 9, -1019803690);
+            c2 = GG(c2, d, a2, b, m[i2 + 3], 14, -187363961);
+            b = GG(b, c2, d, a2, m[i2 + 8], 20, 1163531501);
+            a2 = GG(a2, b, c2, d, m[i2 + 13], 5, -1444681467);
+            d = GG(d, a2, b, c2, m[i2 + 2], 9, -51403784);
+            c2 = GG(c2, d, a2, b, m[i2 + 7], 14, 1735328473);
+            b = GG(b, c2, d, a2, m[i2 + 12], 20, -1926607734);
+            a2 = HH(a2, b, c2, d, m[i2 + 5], 4, -378558);
+            d = HH(d, a2, b, c2, m[i2 + 8], 11, -2022574463);
+            c2 = HH(c2, d, a2, b, m[i2 + 11], 16, 1839030562);
+            b = HH(b, c2, d, a2, m[i2 + 14], 23, -35309556);
+            a2 = HH(a2, b, c2, d, m[i2 + 1], 4, -1530992060);
+            d = HH(d, a2, b, c2, m[i2 + 4], 11, 1272893353);
+            c2 = HH(c2, d, a2, b, m[i2 + 7], 16, -155497632);
+            b = HH(b, c2, d, a2, m[i2 + 10], 23, -1094730640);
+            a2 = HH(a2, b, c2, d, m[i2 + 13], 4, 681279174);
+            d = HH(d, a2, b, c2, m[i2 + 0], 11, -358537222);
+            c2 = HH(c2, d, a2, b, m[i2 + 3], 16, -722521979);
+            b = HH(b, c2, d, a2, m[i2 + 6], 23, 76029189);
+            a2 = HH(a2, b, c2, d, m[i2 + 9], 4, -640364487);
+            d = HH(d, a2, b, c2, m[i2 + 12], 11, -421815835);
+            c2 = HH(c2, d, a2, b, m[i2 + 15], 16, 530742520);
+            b = HH(b, c2, d, a2, m[i2 + 2], 23, -995338651);
+            a2 = II(a2, b, c2, d, m[i2 + 0], 6, -198630844);
+            d = II(d, a2, b, c2, m[i2 + 7], 10, 1126891415);
+            c2 = II(c2, d, a2, b, m[i2 + 14], 15, -1416354905);
+            b = II(b, c2, d, a2, m[i2 + 5], 21, -57434055);
+            a2 = II(a2, b, c2, d, m[i2 + 12], 6, 1700485571);
+            d = II(d, a2, b, c2, m[i2 + 3], 10, -1894986606);
+            c2 = II(c2, d, a2, b, m[i2 + 10], 15, -1051523);
+            b = II(b, c2, d, a2, m[i2 + 1], 21, -2054922799);
+            a2 = II(a2, b, c2, d, m[i2 + 8], 6, 1873313359);
+            d = II(d, a2, b, c2, m[i2 + 15], 10, -30611744);
+            c2 = II(c2, d, a2, b, m[i2 + 6], 15, -1560198380);
+            b = II(b, c2, d, a2, m[i2 + 13], 21, 1309151649);
+            a2 = II(a2, b, c2, d, m[i2 + 4], 6, -145523070);
+            d = II(d, a2, b, c2, m[i2 + 11], 10, -1120210379);
+            c2 = II(c2, d, a2, b, m[i2 + 2], 15, 718787259);
+            b = II(b, c2, d, a2, m[i2 + 9], 21, -343485551);
+            a2 = a2 + aa >>> 0;
+            b = b + bb >>> 0;
+            c2 = c2 + cc >>> 0;
+            d = d + dd >>> 0;
+          }
+          return crypt.endian([a2, b, c2, d]);
+        };
+        md52._ff = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (b & c2 | ~b & d) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._gg = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (b & d | c2 & ~d) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._hh = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (b ^ c2 ^ d) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._ii = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (c2 ^ (b | ~d)) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._blocksize = 16;
+        md52._digestsize = 16;
+        module.exports = function(message, options) {
+          if (message === void 0 || message === null)
+            throw new Error("Illegal argument " + message);
+          var digestbytes = crypt.wordsToBytes(md52(message, options));
+          return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
+        };
+      })();
+    }
+  });
+
+  // ../compression/src/compression-worker.ts
+  var VERSION14, CompressionWorker;
+  var init_compression_worker = __esm({
+    "../compression/src/compression-worker.ts"() {
+      VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      CompressionWorker = {
+        id: "compression",
+        name: "compression",
+        module: "compression",
+        version: VERSION14,
+        options: {}
+      };
+    }
+  });
+
+  // ../compression/src/index.ts
+  var init_src9 = __esm({
+    "../compression/src/index.ts"() {
+      init_compression_worker();
+    }
+  });
+
+  // src/lib/parsers/parse-slpk/slpk-archieve.ts
+  var import_md5, SLPKArchive;
+  var init_slpk_archieve = __esm({
+    "src/lib/parsers/parse-slpk/slpk-archieve.ts"() {
+      init_src();
+      import_md5 = __toModule(require_md5());
+      init_src9();
+      init_local_file_header();
+      SLPKArchive = class {
+        constructor(slpkArchiveBuffer, hashFile) {
+          this.slpkArchive = new DataView(slpkArchiveBuffer);
+          this.hashArray = this.parseHashFile(hashFile);
+        }
+        parseHashFile(hashFile) {
+          const hashFileBuffer = Buffer.from(hashFile);
+          const hashArray = [];
+          for (let i2 = 0; i2 < hashFileBuffer.buffer.byteLength; i2 = i2 + 24) {
+            const offsetBuffer = new DataView(hashFileBuffer.buffer.slice(hashFileBuffer.byteOffset + i2 + 16, hashFileBuffer.byteOffset + i2 + 24));
+            const offset = offsetBuffer.getUint32(offsetBuffer.byteOffset, true);
+            hashArray.push({
+              hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i2, hashFileBuffer.byteOffset + i2 + 16)),
+              offset
+            });
+          }
+          return hashArray;
+        }
+        async getFile(path, mode = "raw") {
+          if (mode === "http") {
+            throw new Error("http mode is not supported");
+          }
+          const fileToDecompress = this.getFileBytes(`${path}.gz`);
+          if (fileToDecompress) {
+            const decompressedData = await processOnWorker(CompressionWorker, fileToDecompress, {
+              compression: "gzip",
+              operation: "decompress",
+              _workerType: "test",
+              gzip: {}
+            });
+            return decompressedData;
+          }
+          const fileWithoutCompression = this.getFileBytes(path);
+          if (fileWithoutCompression) {
+            return Promise.resolve(Buffer.from(fileWithoutCompression));
+          }
+          throw new Error("No such file in the archieve");
+        }
+        getFileBytes(path) {
+          const nameHash = Buffer.from((0, import_md5.default)(path), "hex");
+          const fileInfo = this.hashArray.find((val) => Buffer.compare(val.hash, nameHash) === 0);
+          if (!fileInfo) {
+            return void 0;
+          }
+          const localFileHeader = parseZipLocalFileHeader(this.slpkArchive.byteOffset + fileInfo?.offset, this.slpkArchive);
+          const compressedFile = this.slpkArchive.buffer.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+          return compressedFile;
+        }
+      };
+    }
+  });
+
+  // src/lib/parsers/parse-slpk/parse-slpk.ts
+  async function parseSLPK(data, options = {}) {
+    const archive = new DataView(data);
+    const cdFileHeaderSignature = [80, 75, 1, 2];
+    const searchWindow = [
+      getByteAt(archive.byteLength - 1, archive),
+      getByteAt(archive.byteLength - 2, archive),
+      getByteAt(archive.byteLength - 3, archive),
+      void 0
+    ];
+    let hashCDOffset = 0;
+    for (let i2 = archive.byteLength - 4; i2 > -1; i2--) {
+      searchWindow[3] = searchWindow[2];
+      searchWindow[2] = searchWindow[1];
+      searchWindow[1] = searchWindow[0];
+      searchWindow[0] = getByteAt(i2, archive);
+      if (searchWindow.every((val, index) => val === cdFileHeaderSignature[index])) {
+        hashCDOffset = i2;
+        break;
+      }
+    }
+    const cdFileHeader = parseZipCDFileHeader(hashCDOffset, archive);
+    const textDecoder = new TextDecoder();
+    if (textDecoder.decode(cdFileHeader.fileName) !== "@specialIndexFileHASH128@") {
+      throw new Error("No hash file in slpk");
+    }
+    const localFileHeader = parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, archive);
+    const fileDataOffset = localFileHeader.fileDataOffset;
+    const hashFile = archive.buffer.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
+    if (!hashFile) {
+      throw new Error("No hash file in slpk");
+    }
+    return await new SLPKArchive(data, hashFile).getFile(options.path ?? "");
+  }
+  var getByteAt;
+  var init_parse_slpk = __esm({
+    "src/lib/parsers/parse-slpk/parse-slpk.ts"() {
+      init_cd_file_header();
+      init_local_file_header();
+      init_slpk_archieve();
+      getByteAt = (offset, buffer) => {
+        return buffer.getUint8(buffer.byteOffset + offset);
+      };
+    }
+  });
+
+  // src/i3s-slpk-loader.ts
+  var VERSION15, SLPKLoader;
+  var init_i3s_slpk_loader = __esm({
+    "src/i3s-slpk-loader.ts"() {
+      init_parse_slpk();
+      VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      SLPKLoader = {
+        name: "I3S SLPK (Scene Layer Package)",
+        id: "slpk",
+        module: "i3s",
+        version: VERSION15,
+        mimeTypes: ["application/octet-stream"],
+        parse: parseSLPK,
+        extensions: ["slpk"],
+        options: {}
+      };
+    }
+  });
+
   // src/lib/parsers/parse-i3s-building-scene-layer.ts
   async function parseBuildingSceneLayer(data, url) {
     const layer0 = JSON.parse(new TextDecoder().decode(data));
@@ -10969,16 +11526,16 @@
     }
     return parseBuildingSceneLayer(data, context.url);
   }
-  var VERSION13, I3SBuildingSceneLayerLoader;
+  var VERSION16, I3SBuildingSceneLayerLoader;
   var init_i3s_building_scene_layer_loader = __esm({
     "src/i3s-building-scene-layer-loader.ts"() {
       init_parse_i3s_building_scene_layer();
-      VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION16 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       I3SBuildingSceneLayerLoader = {
         name: "I3S Building Scene Layer",
         id: "i3s-building-scene-layer",
         module: "i3s",
-        version: VERSION13,
+        version: VERSION16,
         mimeTypes: ["application/json"],
         parse: parse6,
         extensions: ["json"],
@@ -11059,16 +11616,16 @@
   async function parse7(data) {
     return parseWebscene(data);
   }
-  var VERSION14, ArcGisWebSceneLoader;
+  var VERSION17, ArcGisWebSceneLoader;
   var init_arcgis_webscene_loader = __esm({
     "src/arcgis-webscene-loader.ts"() {
       init_parse_arcgis_webscene();
-      VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION17 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       ArcGisWebSceneLoader = {
         name: "ArcGIS Web Scene Loader",
         id: "arcgis-web-scene",
         module: "i3s",
-        version: VERSION14,
+        version: VERSION17,
         mimeTypes: ["application/json"],
         parse: parse7,
         extensions: ["json"],
@@ -11086,11 +11643,13 @@
     I3SBuildingSceneLayerLoader: () => I3SBuildingSceneLayerLoader,
     I3SContentLoader: () => I3SContentLoader,
     I3SLoader: () => I3SLoader,
+    SLPKLoader: () => SLPKLoader,
     loadFeatureAttributes: () => loadFeatureAttributes
   });
-  var init_src9 = __esm({
+  var init_src10 = __esm({
     "src/index.ts"() {
       init_i3s_loader();
+      init_i3s_slpk_loader();
       init_i3s_content_loader();
       init_i3s_attribute_loader();
       init_i3s_building_scene_layer_loader();
@@ -11102,10 +11661,16 @@
   // src/bundle.ts
   var require_bundle = __commonJS({
     "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src9(), src_exports);
+      var moduleExports = (init_src10(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
       module.exports = Object.assign(globalThis.loaders, moduleExports);
     }
   });
   require_bundle();
 })();
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */