@loaders.gl/tile-converter 5.0.0-alpha.11 → 5.0.0-alpha.12

package/dist/index.js

@@ -1,28 +1,17 @@
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res, err2) => function __init() {
-  if (err2) throw err2[0];
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
   try {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   } catch (e) {
-    throw err2 = [e], e;
+    throw err = [e], e;
   }
 };
 var __export = (target, all) => {
   for (var name18 in all)
     __defProp(target, name18, { get: all[name18], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
 // ../../modules/loader-utils/src/loader-types.ts
 async function parseFromContext(data, loaders, options, context) {
@@ -141,6 +130,41 @@ var init_merge_options = __esm({
   }
 });
 
+// ../../modules/loader-utils/src/lib/module-utils/initialize-wasm-module.ts
+function initializeWasmModule(initialize, extractExports) {
+  return new Promise((resolve2, reject) => {
+    let isSettled = false;
+    function rejectInitialization(error) {
+      if (!isSettled) {
+        isSettled = true;
+        reject(error);
+      }
+    }
+    function resolveInitialization(module) {
+      if (isSettled) {
+        return;
+      }
+      isSettled = true;
+      try {
+        resolve2(extractExports(module));
+      } catch (error) {
+        reject(error);
+      }
+    }
+    try {
+      const modulePromise = initialize(resolveInitialization, rejectInitialization);
+      modulePromise?.then(resolveInitialization, rejectInitialization);
+    } catch (error) {
+      rejectInitialization(error);
+    }
+  });
+}
+var init_initialize_wasm_module = __esm({
+  "../../modules/loader-utils/src/lib/module-utils/initialize-wasm-module.ts"() {
+    "use strict";
+  }
+});
+
 // ../../modules/loader-utils/src/lib/module-utils/js-module-utils.ts
 function registerJSModules(modules) {
   globalThis.loaders ||= {};
@@ -300,18 +324,11 @@ var init_worker_job = __esm({
 });
 
 // ../../modules/worker-utils/src/lib/node/worker_threads.ts
-var worker_threads_exports = {};
-__export(worker_threads_exports, {
-  NodeWorker: () => NodeWorker,
-  parentPort: () => parentPort
-});
 import * as WorkerThreads from "worker_threads";
-import * as worker_threads_star from "worker_threads";
 var parentPort, NodeWorker;
 var init_worker_threads = __esm({
   "../../modules/worker-utils/src/lib/node/worker_threads.ts"() {
     "use strict";
-    __reExport(worker_threads_exports, worker_threads_star);
     parentPort = WorkerThreads?.parentPort;
     NodeWorker = WorkerThreads.Worker;
   }
@@ -1432,6 +1449,9 @@ var init_src = __esm({
 
 // ../../modules/loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
 function canParseWithWorker(loader, options) {
+  const workerUrl = options?.[loader.id]?.workerUrl;
+  if (options?.core?.worker === false || !(loader.worker || loader.loadWorker || workerUrl))
+    return false;
   if (options?.core?.credentials?.some(
     (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
   ))
@@ -1562,12 +1582,14 @@ function resolveWorkerLoaders(loader, loaderIds, loaderIsArray, context, options
   }
 }
 function getWorkerOptions(options = {}, loader) {
+  const optionsToSerialize = {
+    ...options,
+    ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
+  };
   const serializedOptions = JSON.parse(
-    JSON.stringify({
-      ...options,
-      ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
-    })
+    JSON.stringify(optionsToSerialize, (_key, value) => typeof value === "bigint" ? null : value)
   );
+  restoreBigIntOptions(optionsToSerialize, serializedOptions);
   const workerOptions = {
     ...serializedOptions.core,
     ...serializedOptions
@@ -1580,6 +1602,14 @@ function getWorkerOptions(options = {}, loader) {
   }
   return workerOptions;
 }
+function restoreBigIntOptions(original, serialized) {
+  if (!serialized || typeof serialized !== "object") return;
+  for (const key of Object.keys(serialized)) {
+    const value = original?.[key];
+    if (typeof value === "bigint") serialized[key] = value;
+    else restoreBigIntOptions(value, serialized[key]);
+  }
+}
 function getSerializableLoaderContext(context) {
   if (!context) {
     return {};
@@ -3767,6 +3797,7 @@ var init_src2 = __esm({
     init_log();
     init_is_type();
     init_merge_options();
+    init_initialize_wasm_module();
     init_js_module_utils();
     init_js_module_utils();
     init_parse_with_worker();
@@ -6307,6 +6338,7 @@ function convertArrowTableToMesh(table) {
   const schema = serializeArrowSchema(arrowTable.schema);
   const fields = schema.fields;
   const attributes = {};
+  const columns = [];
   for (const field of fields) {
     const { name: name18 } = field;
     if (name18 === "indices") {
@@ -6316,11 +6348,16 @@ function convertArrowTableToMesh(table) {
     const size = getFixedSizeListSize(attributeData);
     const typedArray = getAttributeTypedArray(attributeData, size);
     const metadata = getMeshAttributeMetadata(field.metadata);
+    const value = metadata.componentType === "float16" ? restoreFloat16Array(typedArray) : typedArray;
+    const shared = columns.find(
+      (column) => column.data.length === attributeData.data.length && attributes[column.name].value.constructor === value.constructor && column.data.every((chunk, index) => shareArrowStorage(chunk, attributeData.data[index]))
+    );
     attributes[name18] = {
-      value: metadata.componentType === "float16" ? restoreFloat16Array(typedArray) : typedArray,
+      value: shared ? attributes[shared.name].value : value,
       size,
       ...metadata
     };
+    if (!shared) columns.push({ name: name18, data: attributeData.data });
   }
   fixMetadata(schema);
   const topology = schema.metadata.topology;
@@ -6437,6 +6474,15 @@ function getIndices(arrowTable) {
   const values = indicesData.children[0].values.subarray(start, end);
   return { value: values, size: 1 };
 }
+function shareArrowStorage(left, right) {
+  const rightBuffers = Object.values(right.buffers);
+  return left.type.toString() === right.type.toString() && left.offset === right.offset && left.length === right.length && left.nullCount === right.nullCount && left.dictionary === right.dictionary && Object.values(left.buffers).every((buffer, index) => {
+    const other = rightBuffers[index];
+    return buffer === other || Boolean(
+      buffer && other && buffer.buffer === other.buffer && buffer.byteOffset === other.byteOffset && buffer.byteLength === other.byteLength
+    );
+  }) && left.children.length === right.children.length && left.children.every((child, index) => shareArrowStorage(child, right.children[index]));
+}
 var init_convert_table_to_mesh = __esm({
   "../../modules/schema-utils/src/lib/mesh/convert-table-to-mesh.ts"() {
     "use strict";
@@ -6589,8 +6635,8 @@ function convertDataToBatch(parsedData, loader) {
 }
 async function applyInputTransforms(inputIterator, transforms = []) {
   let iteratorChain = inputIterator;
-  for await (const transformBatches of transforms) {
-    iteratorChain = transformBatches(iteratorChain);
+  for await (const transformBatches2 of transforms) {
+    iteratorChain = transformBatches2(iteratorChain);
   }
   return iteratorChain;
 }
@@ -9943,16 +9989,16 @@ function encodeExtMeshFeaturesForPrimitive(scenegraph, primitive) {
 function createAccessorKey(attributes) {
   const prefix = "_FEATURE_ID_";
   const attrs = Object.keys(attributes).filter((item) => item.indexOf(prefix) === 0);
-  let max2 = -1;
+  let max = -1;
   for (const a of attrs) {
     const n = Number(a.substring(prefix.length));
-    if (n > max2) {
-      max2 = n;
+    if (n > max) {
+      max = n;
     }
   }
-  max2++;
-  const accessorKey = `${prefix}${max2}`;
-  return { accessorKey, index: max2 };
+  max++;
+  const accessorKey = `${prefix}${max}`;
+  return { accessorKey, index: max };
 }
 var EXT_MESH_FEATURES_NAME, name;
 var init_EXT_mesh_features = __esm({
@@ -11866,8 +11912,9 @@ function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
   if (wasmBinary) {
     options.wasmBinary = wasmBinary;
   }
-  return new Promise((resolve2) => {
-    BasisModule(options).then((module) => {
+  return initializeWasmModule(
+    () => BasisModule(options),
+    (module) => {
       const {
         BasisFile,
         KTX2File,
@@ -11877,15 +11924,15 @@ function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
         isFormatSupported
       } = module;
       initializeBasis();
-      resolve2({
+      return {
         BasisFile,
         KTX2File,
         getBasisTexFormatBlockHeight,
         getBasisTexFormatBlockWidth,
         isFormatSupported
-      });
-    });
-  });
+      };
+    }
+  );
 }
 var BASIS_EXTERNAL_LIBRARIES, loadBasisTranscoderPromise;
 var init_basis_module_loader = __esm({
@@ -13143,7 +13190,6 @@ var init_src7 = __esm({
     init_version4();
     init_basis_loader();
     init_compressed_texture_loader();
-    init_gl_extensions();
     KTX2BasisWriterWorker = {
       name: "Basis Universal Supercompressed GPU Texture",
       id: "ktx2-basis-writer",
@@ -13675,7 +13721,10 @@ async function loadDracoDecoderModuleFromDraco3D(draco3DModule) {
   const typedDraco3DModule = validateDracoDecoderModule(draco3DModule);
   let decoderPromise = injectedDecoderPromises.get(typedDraco3DModule);
   if (!decoderPromise) {
-    decoderPromise = typedDraco3DModule.createDecoderModule({}).then((draco) => ({ draco }));
+    decoderPromise = initializeWasmModule(
+      () => typedDraco3DModule.createDecoderModule({}),
+      (draco) => ({ draco })
+    );
     injectedDecoderPromises.set(typedDraco3DModule, decoderPromise);
   }
   return await decoderPromise;
@@ -13686,7 +13735,10 @@ async function loadDracoEncoderModule(options = {}) {
     const typedDraco3DModule = validateDracoEncoderModule(draco3DModule);
     let encoderPromise2 = injectedEncoderPromises.get(typedDraco3DModule);
     if (!encoderPromise2) {
-      encoderPromise2 = typedDraco3DModule.createEncoderModule({}).then((draco) => ({ draco }));
+      encoderPromise2 = initializeWasmModule(
+        () => typedDraco3DModule.createEncoderModule({}),
+        (draco) => ({ draco })
+      );
       injectedEncoderPromises.set(typedDraco3DModule, encoderPromise2);
     }
     return await encoderPromise2;
@@ -13816,17 +13868,13 @@ function initializeDracoModule(initializer, wasmBinary) {
   if (typeof initializer !== "function") {
     throw new Error("Draco module initializer could not be loaded");
   }
-  return new Promise((resolve2, reject) => {
-    try {
-      const modulePromise = initializer({
-        ...wasmBinary ? { wasmBinary } : {},
-        onModuleLoaded: (draco) => resolve2({ draco })
-      });
-      modulePromise?.then((draco) => resolve2({ draco }), reject);
-    } catch (error) {
-      reject(error);
-    }
-  });
+  return initializeWasmModule(
+    (onInitialized) => initializer({
+      ...wasmBinary ? { wasmBinary } : {},
+      onModuleLoaded: onInitialized
+    }),
+    (draco) => ({ draco })
+  );
 }
 function getLibraryExport(library, exportName) {
   if (typeof library === "function") {
@@ -13876,6 +13924,7 @@ var DRACO_VERSION, DRACO_RELEASE_COMMIT, STATIC_DECODER_URL, STATIC_ENCODER_URL,
 var init_draco_module_loader = __esm({
   "../../modules/draco/src/lib/draco-module-loader.ts"() {
     "use strict";
+    init_src2();
     init_draco_library_loader();
     DRACO_VERSION = "1.5.7";
     DRACO_RELEASE_COMMIT = "8786740086a9f4d83f44aa83badfbea4dce7a1b5";
@@ -13972,13 +14021,13 @@ function hasAttributeQuantization(options) {
     options.attributeQuantization && Object.keys(options.attributeQuantization).length
   );
 }
-function validateQuantizationBits(attributeName, bits2, attributeType) {
-  if (!Number.isInteger(bits2) || bits2 < 1 || bits2 > 30) {
+function validateQuantizationBits(attributeName, bits, attributeType) {
+  if (!Number.isInteger(bits) || bits < 1 || bits > 30) {
     throw new Error(
       `DracoWriter: quantization bits for "${attributeName}" must be an integer from 1 to 30`
     );
   }
-  if (attributeType === "NORMAL" && (bits2 < 2 || bits2 > 29)) {
+  if (attributeType === "NORMAL" && (bits < 2 || bits > 29)) {
     throw new Error(
       `DracoWriter: quantization bits for NORMAL attribute "${attributeName}" must be an integer from 2 to 29`
     );
@@ -14217,10 +14266,10 @@ var init_draco_builder = __esm({
         if (options.quantization) {
           for (const attribute in options.quantization) {
             const attributeType = attribute;
-            const bits2 = options.quantization[attributeType];
-            if (bits2 !== void 0) {
-              validateQuantizationBits(attributeType, bits2, attributeType);
-              this.dracoEncoder.SetAttributeQuantization(this.draco[attributeType], bits2);
+            const bits = options.quantization[attributeType];
+            if (bits !== void 0) {
+              validateQuantizationBits(attributeType, bits, attributeType);
+              this.dracoEncoder.SetAttributeQuantization(this.draco[attributeType], bits);
             }
           }
         }
@@ -14253,17 +14302,17 @@ var init_draco_builder = __esm({
       _getAttributeQuantization(attributes, options) {
         const categoryQuantization = /* @__PURE__ */ new Map();
         for (const attributeType of Object.keys(options.quantization || {})) {
-          const bits2 = options.quantization?.[attributeType];
-          if (bits2 !== void 0) {
-            validateQuantizationBits(attributeType, bits2, attributeType);
-            categoryQuantization.set(this.draco[attributeType], bits2);
+          const bits = options.quantization?.[attributeType];
+          if (bits !== void 0) {
+            validateQuantizationBits(attributeType, bits, attributeType);
+            categoryQuantization.set(this.draco[attributeType], bits);
           }
         }
         const quantization = /* @__PURE__ */ new Map();
         for (const [attributeName, attribute] of Object.entries(attributes)) {
-          const bits2 = categoryQuantization.get(attribute.attributeType);
-          if (bits2 !== void 0) {
-            quantization.set(attributeName, bits2);
+          const bits = categoryQuantization.get(attribute.attributeType);
+          if (bits !== void 0) {
+            quantization.set(attributeName, bits);
           }
         }
         for (const [attributeName, setting] of Object.entries(options.attributeQuantization || {})) {
@@ -15045,8 +15094,8 @@ function getTransformedMeshBoundingBox(attributes) {
   if (position?.transform?.type !== "quantization") {
     return boundingBox;
   }
-  const { bits: bits2, origin, range } = position.transform;
-  const scale = range / (2 ** bits2 - 1);
+  const { bits, origin, range } = position.transform;
+  const scale = range / (2 ** bits - 1);
   return boundingBox.map(
     (bounds) => bounds.map((value, componentIndex) => origin[componentIndex] + value * scale)
   );
@@ -20747,6 +20796,7 @@ var init_spatial_resource_registry = __esm({
 // ../../modules/tiles/src/spatial/spatial-coordinate-transformer.ts
 import { Vector3 as Vector34 } from "@math.gl/core";
 import { Ellipsoid as Ellipsoid2 } from "@math.gl/geospatial";
+import { ProjectionBuffer } from "@math.gl/projection/bulk";
 function getFiniteDifferenceJacobian(transformer, position, epsilon) {
   const columns = [];
   for (let axis = 0; axis < 3; axis++) {
@@ -20859,6 +20909,8 @@ var init_spatial_coordinate_transformer = __esm({
       spatialReference;
       /** Projection from the source CRS directly to the requested horizontal target CRS. */
       horizontalProjection;
+      /** Reusable packed xyz projection for horizontal-only coordinate batches. */
+      horizontalProjectionBuffer;
       /** Projection from the source CRS to geographic longitude, latitude, and ellipsoidal height. */
       geographicProjection;
       /** Projection from adjusted geographic coordinates to the requested output CRS. */
@@ -20894,6 +20946,12 @@ var init_spatial_coordinate_transformer = __esm({
             to: getHorizontalProjectionDefinition(spatialReference.targetCrs),
             enforceAxis: false
           });
+          if (!requiresHeightTransformation(spatialReference)) {
+            this.horizontalProjectionBuffer = new ProjectionBuffer({
+              projection: this.horizontalProjection,
+              dimension: 3
+            });
+          }
         }
         if (requiresHeightTransformation(spatialReference) || this.sourceIsGeocentric || this.outputIsGeocentric) {
           if (!this.sourceIsGeographic && !this.sourceIsGeocentric) {
@@ -20956,12 +21014,21 @@ var init_spatial_coordinate_transformer = __esm({
         }
         return result;
       }
-      /** Transform a packed sequence of xyz positions, preserving the input array type only when safe. */
+      /** Transform packed xyz positions into owned Float64 storage, batching finite horizontal transforms. */
       transformPositions(positions) {
         if (positions.length % 3 !== 0) {
           throw new Error("Packed spatial positions must contain a multiple of three components");
         }
         const transformedPositions = new Float64Array(positions.length);
+        if (this.horizontalProjectionBuffer) {
+          transformedPositions.set(positions);
+          if (transformedPositions.every(Number.isFinite)) {
+            return this.horizontalProjectionBuffer.projectFlatTo(
+              transformedPositions,
+              transformedPositions
+            );
+          }
+        }
         for (let index = 0; index < positions.length; index += 3) {
           const transformed = this.transformPosition([
             Number(positions[index]),
@@ -25799,6 +25866,152 @@ var init_cesium_ion_loader = __esm({
   }
 });
 
+// ../../modules/compression/src/lib/compression.ts
+var CompressionTransform, Decompressor;
+var init_compression = __esm({
+  "../../modules/compression/src/lib/compression.ts"() {
+    "use strict";
+    init_src2();
+    CompressionTransform = class {
+      /** Preloads any dynamic libraries. May enable sync functions */
+      async preload(modules = {}) {
+        registerJSModules(modules);
+        return void 0;
+      }
+      // HELPERS
+      concatenate(asyncIterator) {
+        return concatenateArrayBuffersAsync(asyncIterator);
+      }
+      improveError(error) {
+        if (!error.message.includes(this.name)) {
+          error.message = `${this.name} ${error.message}`;
+        }
+        return error;
+      }
+    };
+    Decompressor = class extends CompressionTransform {
+      constructor(options) {
+        super();
+        this.decompressBatches = this.decompressBatches.bind(this);
+      }
+      /** Asynchronously decompresses data. */
+      async decompress(input, size) {
+        await this.preload();
+        return this.decompressSync(input, size);
+      }
+      /** Synchronously decompresses data. */
+      decompressSync(input, size) {
+        throw new Error(`${this.name}: sync decompression not supported`);
+      }
+      /** Decompresses batches. */
+      async *decompressBatches(asyncIterator) {
+        const input = await this.concatenate(asyncIterator);
+        yield this.decompress(input);
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/lib/compress-utils-compression.ts
+async function* transformBatches(stream, inputBatches) {
+  try {
+    for await (const input of inputBatches) {
+      const output2 = stream.write(new Uint8Array(input));
+      if (output2.byteLength > 0) yield copyArrayBuffer2(output2);
+    }
+    const output = stream.finish();
+    if (output.byteLength > 0) yield copyArrayBuffer2(output);
+  } finally {
+    stream.destroy();
+  }
+}
+function copyArrayBuffer2(bytes) {
+  return bytes.slice().buffer;
+}
+function getDecompressOptions(options, size) {
+  const decodeOptions = {
+    ...options.compressUtils,
+    ...size === void 0 ? {} : { expectedSize: size }
+  };
+  const capacity = decodeOptions.expectedSize;
+  const maximum = options.maxOutputByteLength ?? 512 * 1024 * 1024;
+  if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > 2147483647)
+    throw new RangeError("Invalid maxOutputByteLength");
+  if (capacity !== void 0 && (!Number.isSafeInteger(capacity) || capacity < 0 || capacity > maximum)) {
+    throw new RangeError("expectedSize exceeds the configured output capacity limit");
+  }
+  return decodeOptions;
+}
+var CompressUtilsDecompressor;
+var init_compress_utils_compression = __esm({
+  "../../modules/compression/src/lib/compress-utils-compression.ts"() {
+    "use strict";
+    init_compression();
+    CompressUtilsDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      options;
+      loadModule;
+      /** Module initialized for synchronous operations. */
+      module = null;
+      /** Shared import and WASM initialization for concurrent callers. */
+      modulePromise = null;
+      /** Creates a format-specific compress-utils decoder. */
+      constructor(metadata, loadModule, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = metadata.extensions || [];
+        this.contentEncodings = metadata.contentEncodings || [];
+        this.loadModule = loadModule;
+        this.options = options;
+      }
+      /** Imports and initializes the codec without loading the opposite direction. */
+      async preload(modules = {}) {
+        await super.preload(modules);
+        this.modulePromise ||= this.loadModule().then(async (module) => {
+          await module.preload?.();
+          this.module = module;
+        });
+        try {
+          await this.modulePromise;
+        } catch (error) {
+          this.modulePromise = null;
+          throw error;
+        }
+      }
+      /** Runs synchronously after preload has initialized the WASM codec. */
+      decompressSync(input, size) {
+        if (!this.module?.decompressSync)
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        return copyArrayBuffer2(
+          this.module.decompressSync(new Uint8Array(input), getDecompressOptions(this.options, size))
+        );
+      }
+      /** Decompresses one buffer with the selected compress-utils decoder. */
+      async decompress(input, size) {
+        const decodeOptions = getDecompressOptions(this.options, size);
+        await this.preload();
+        const module = this.module;
+        const output = await module.decompress(new Uint8Array(input), decodeOptions);
+        return copyArrayBuffer2(output);
+      }
+      /** Incrementally decompresses input batches with compress-utils. */
+      async *decompressBatches(inputBatches) {
+        await this.preload();
+        const module = this.module;
+        if (!module.createDecompressStream) {
+          yield await this.decompress(await this.concatenate(inputBatches));
+          return;
+        }
+        const stream = await module.createDecompressStream();
+        yield* transformBatches(stream, inputBatches);
+      }
+    };
+  }
+});
+
 // ../../modules/crypto/src/lib/hash.ts
 var Hash;
 var init_hash = __esm({
@@ -26255,65 +26468,25 @@ var init_crc32_hash = __esm({
 });
 
 // ../../modules/crypto/src/lib/algorithms/md5-wasm.ts
-function md5WASM(data) {
-  var mem, memView, importObj, imports, len, buff, thenFun, catchFun, result, endTime;
-  const md5JS = makeMD5JS(), md5WA = makeMD5WA(), returnObj = {}, startTime = (/* @__PURE__ */ new Date()).getTime();
-  returnObj["then"] = function(fun) {
-    thenFun = fun;
-    getThen();
-    return returnObj;
-  };
-  returnObj["catch"] = function(fun) {
-    catchFun = fun;
-    return returnObj;
-  };
-  buff = normalizeInput(data);
-  if (!buff) {
-    getCatch(new TypeError(parmTypeErrStr));
-  }
-  if (buff) {
-    len = buff.length;
-    if (wasm && len > bounder) {
-      if (len > upperLimit) {
-        getCatch(new Error(tooBigErrStr));
-      } else {
-        mem = new WebAssembly.Memory({
-          initial: len > 32e6 ? len > 64e6 ? len > 128e6 ? 4096 : 2048 : 1024 : 512
-        });
-        memView = new Uint32Array(mem.buffer);
-        imports = { mem, log: console.log };
-        importObj = { imports };
-        WebAssembly.instantiate(wasm, importObj).then(giterdone);
-      }
-    } else {
-      getThen(md5JS(buff));
-    }
+async function md5WASM(data) {
+  const input = normalizeInput(data);
+  if (!input) {
+    throw new TypeError(parmTypeErrStr);
   }
-  return returnObj;
-  function giterdone(obj) {
-    getThen(md5WA(buff, obj.instance.exports, memView));
+  if (!wasm || input.length <= bounder) {
+    return makeMD5JS()(input);
   }
-  function getThen(r) {
-    var res = Boolean(r) ? r : result;
-    if (Boolean(r)) {
-      endTime = (/* @__PURE__ */ new Date()).getTime();
-    }
-    if (typeof thenFun === "function") {
-      if (Boolean(res)) {
-        thenFun(res, endTime - startTime);
-        thenFun = catchFun = null;
-      }
-    } else {
-      if (Boolean(r)) {
-        result = r;
-      }
-    }
-  }
-  function getCatch(err2) {
-    if (typeof catchFun === "function") {
-      catchFun(err2);
-    }
+  if (input.length > upperLimit) {
+    throw new Error(tooBigErrStr);
   }
+  const memory = new WebAssembly.Memory({
+    initial: input.length > 32e6 ? input.length > 64e6 ? input.length > 128e6 ? 4096 : 2048 : 1024 : 512
+  });
+  const memoryView = new Uint32Array(memory.buffer);
+  const { instance } = await WebAssembly.instantiate(wasm, {
+    imports: { mem: memory, log: console.log }
+  });
+  return makeMD5WA()(input, instance.exports, memoryView);
 }
 function makeMD5WA() {
   var _loop, loops;
@@ -26714,13 +26887,7 @@ var init_md5_hash = __esm({
        * @returns base64 encoded hash
        */
       async hash(input, encoding) {
-        const md5Promise = new Promise(
-          (resolve2, reject) => (
-            // @ts-expect-error
-            md5WASM(input).then(resolve2).catch(reject)
-          )
-        );
-        const hex = await md5Promise;
+        const hex = await md5WASM(input);
         return encodeHex(hex, encoding);
       }
     };
@@ -26736,442 +26903,7 @@ var init_src11 = __esm({
   }
 });
 
-// ../../modules/zip/src/parse-zip/readable-file-utils.ts
-function toBigInt(value) {
-  return typeof value === "bigint" ? value : BigInt(value);
-}
-function toNumber(value) {
-  const numberValue = Number(value);
-  if (!Number.isFinite(numberValue)) {
-    throw new Error("Offset is out of bounds");
-  }
-  return numberValue;
-}
-function normalizeOffset2(offset, size) {
-  if (offset < 0) {
-    return Math.max(size + offset, 0);
-  }
-  return Math.min(offset, size);
-}
-async function readRange(file, start, end) {
-  const startOffset = toBigInt(start);
-  const endOffset = toBigInt(end);
-  const length = endOffset - startOffset;
-  if (length < 0) {
-    throw new Error("Invalid range requested");
-  }
-  return await file.read(startOffset, toNumber(length));
-}
-async function readDataView(file, start, end) {
-  const arrayBuffer = await readRange(file, start, end);
-  return new DataView(arrayBuffer);
-}
-async function readUint16(file, offset) {
-  const dataView = await readDataView(file, offset, toBigInt(offset) + 2n);
-  return dataView.getUint16(0, true);
-}
-async function readUint32(file, offset) {
-  const dataView = await readDataView(file, offset, toBigInt(offset) + 4n);
-  return dataView.getUint32(0, true);
-}
-async function readBigUint64(file, offset) {
-  const dataView = await readDataView(file, offset, toBigInt(offset) + 8n);
-  return dataView.getBigUint64(0, true);
-}
-async function getReadableFileSize(file) {
-  if (file.bigsize > 0n) {
-    return file.bigsize;
-  }
-  if (file.size > 0) {
-    return BigInt(file.size);
-  }
-  if (file.stat) {
-    const stats = await file.stat();
-    if (stats?.bigsize !== void 0) {
-      return stats.bigsize;
-    }
-    if (stats?.size !== void 0) {
-      return BigInt(stats.size);
-    }
-  }
-  return 0n;
-}
-var DataViewReadableFile;
-var init_readable_file_utils = __esm({
-  "../../modules/zip/src/parse-zip/readable-file-utils.ts"() {
-    "use strict";
-    init_src2();
-    DataViewReadableFile = class {
-      handle;
-      size;
-      bigsize;
-      url;
-      constructor(dataView, url = "") {
-        this.handle = dataView;
-        this.size = dataView.byteLength;
-        this.bigsize = BigInt(dataView.byteLength);
-        this.url = url;
-      }
-      async close() {
-      }
-      async stat() {
-        return { size: this.size, bigsize: this.bigsize, isDirectory: false };
-      }
-      async read(start = 0, length) {
-        const offset = toNumber(start);
-        const end = length ? offset + length : this.size;
-        const normalizedStart = normalizeOffset2(offset, this.size);
-        const normalizedEnd = normalizeOffset2(end, this.size);
-        const clampedEnd = Math.max(normalizedEnd, normalizedStart);
-        const lengthToRead = clampedEnd - normalizedStart;
-        if (lengthToRead <= 0) {
-          return new ArrayBuffer(0);
-        }
-        return copyToArrayBuffer2(this.handle.buffer, normalizedStart, lengthToRead);
-      }
-    };
-  }
-});
-
-// ../../modules/zip/src/parse-zip/search-from-the-end.ts
-var buffLength, searchFromTheEnd;
-var init_search_from_the_end = __esm({
-  "../../modules/zip/src/parse-zip/search-from-the-end.ts"() {
-    "use strict";
-    init_readable_file_utils();
-    buffLength = 1024;
-    searchFromTheEnd = async (file, target) => {
-      const fileLength = await getReadableFileSize(file);
-      if (fileLength < BigInt(target.length)) {
-        return -1n;
-      }
-      const lastBytes = new Uint8Array(await readRange(file, fileLength - 3n, fileLength));
-      const searchWindow = [lastBytes[0], lastBytes[1], lastBytes[2], void 0];
-      let targetOffset = -1;
-      let point = fileLength - 3n;
-      do {
-        const prevPoint = point;
-        point -= BigInt(buffLength);
-        point = point >= 0n ? point : 0n;
-        const buff = new Uint8Array(await readRange(file, point, prevPoint));
-        for (let i = buff.length - 1; i > -1; i--) {
-          searchWindow[3] = searchWindow[2];
-          searchWindow[2] = searchWindow[1];
-          searchWindow[1] = searchWindow[0];
-          searchWindow[0] = buff[i];
-          if (searchWindow.every((val, index) => val === target[index])) {
-            targetOffset = i;
-            break;
-          }
-        }
-      } while (targetOffset === -1 && point > 0n);
-      return point + BigInt(targetOffset);
-    };
-  }
-});
-
-// ../../modules/zip/src/parse-zip/zip64-info-generation.ts
-function createZip64Info(options) {
-  const optionsToUse = {
-    ...options,
-    zip64Length: (options.offset ? 1 : 0) * 8 + (options.size ? 1 : 0) * 16
-  };
-  const arraysToConcat = [];
-  for (const field of ZIP64_FIELDS) {
-    if (!optionsToUse[field.name ?? ""] && !field.default) {
-      continue;
-    }
-    const newValue = new DataView(new ArrayBuffer(field.size));
-    NUMBER_SETTERS[field.size](newValue, 0, optionsToUse[field.name ?? ""] ?? field.default);
-    arraysToConcat.push(newValue.buffer);
-  }
-  return concatenateArrayBuffers(...arraysToConcat);
-}
-function setFieldToNumber(header, fieldSize, fieldOffset, value) {
-  NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);
-}
-var signature, NUMBER_SETTERS, ZIP64_FIELDS;
-var init_zip64_info_generation = __esm({
-  "../../modules/zip/src/parse-zip/zip64-info-generation.ts"() {
-    "use strict";
-    init_src2();
-    signature = new Uint8Array([1, 0]);
-    NUMBER_SETTERS = {
-      2: (header, offset, value) => {
-        header.setUint16(offset, Number(value > 65535 ? 65535 : value), true);
-      },
-      4: (header, offset, value) => {
-        header.setUint32(offset, Number(value > 4294967295 ? 4294967295 : value), true);
-      },
-      8: (header, offset, value) => {
-        header.setBigUint64(offset, BigInt(value), true);
-      }
-    };
-    ZIP64_FIELDS = [
-      // Header ID 0x0001
-      {
-        size: 2,
-        default: new DataView(signature.buffer).getUint16(0, true)
-      },
-      // Size of the extra field chunk (8, 16, 24 or 28)
-      {
-        size: 2,
-        name: "zip64Length"
-      },
-      // Original uncompressed file size
-      {
-        size: 8,
-        name: "size"
-      },
-      // Size of compressed data
-      {
-        size: 8,
-        name: "size"
-      },
-      // Offset of local header record
-      {
-        size: 8,
-        name: "offset"
-      }
-    ];
-  }
-});
-
-// ../../modules/zip/src/parse-zip/end-of-central-directory.ts
-function generateEoCD(options) {
-  const header = new DataView(new ArrayBuffer(Number(CD_COMMENT_OFFSET)));
-  for (const field of EOCD_FIELDS) {
-    setFieldToNumber(
-      header,
-      field.size,
-      field.offset,
-      options[field.name ?? ""] ?? field.default ?? 0
-    );
-  }
-  const locator = generateZip64InfoLocator(options);
-  const zip64Record = generateZip64Info(options);
-  return concatenateArrayBuffers(zip64Record, locator, header.buffer);
-}
-function generateZip64Info(options) {
-  const record = new DataView(new ArrayBuffer(Number(ZIP64_COMMENT_OFFSET)));
-  for (const field of ZIP64_EOCD_FIELDS) {
-    setFieldToNumber(
-      record,
-      field.size,
-      field.offset,
-      options[field.name ?? ""] ?? field.default ?? 0
-    );
-  }
-  return record.buffer;
-}
-function generateZip64InfoLocator(options) {
-  const locator = new DataView(new ArrayBuffer(Number(20)));
-  for (const field of ZIP64_EOCD_LOCATOR_FIELDS) {
-    setFieldToNumber(
-      locator,
-      field.size,
-      field.offset,
-      options[field.name ?? ""] ?? field.default ?? 0
-    );
-  }
-  return locator.buffer;
-}
-var eoCDSignature, zip64EoCDLocatorSignature, zip64EoCDSignature, CD_RECORDS_NUMBER_OFFSET, CD_CD_BYTE_SIZE_OFFSET, CD_START_OFFSET_OFFSET, CD_COMMENT_OFFSET, ZIP64_EOCD_START_OFFSET_OFFSET, ZIP64_CD_RECORDS_NUMBER_OFFSET, ZIP64_CD_CD_BYTE_SIZE_OFFSET, ZIP64_CD_START_OFFSET_OFFSET, ZIP64_COMMENT_OFFSET, parseEoCDRecord, EOCD_FIELDS, ZIP64_EOCD_LOCATOR_FIELDS, ZIP64_EOCD_FIELDS;
-var init_end_of_central_directory = __esm({
-  "../../modules/zip/src/parse-zip/end-of-central-directory.ts"() {
-    "use strict";
-    init_src2();
-    init_search_from_the_end();
-    init_readable_file_utils();
-    init_zip64_info_generation();
-    eoCDSignature = new Uint8Array([80, 75, 5, 6]);
-    zip64EoCDLocatorSignature = new Uint8Array([80, 75, 6, 7]);
-    zip64EoCDSignature = new Uint8Array([80, 75, 6, 6]);
-    CD_RECORDS_NUMBER_OFFSET = 8n;
-    CD_CD_BYTE_SIZE_OFFSET = 12n;
-    CD_START_OFFSET_OFFSET = 16n;
-    CD_COMMENT_OFFSET = 22n;
-    ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
-    ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
-    ZIP64_CD_CD_BYTE_SIZE_OFFSET = 40n;
-    ZIP64_CD_START_OFFSET_OFFSET = 48n;
-    ZIP64_COMMENT_OFFSET = 56n;
-    parseEoCDRecord = async (file) => {
-      const zipEoCDOffset = await searchFromTheEnd(file, eoCDSignature);
-      let cdRecordsNumber = BigInt(await readUint16(file, zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
-      let cdByteSize = BigInt(await readUint32(file, zipEoCDOffset + CD_CD_BYTE_SIZE_OFFSET));
-      let cdStartOffset = BigInt(await readUint32(file, zipEoCDOffset + CD_START_OFFSET_OFFSET));
-      let zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
-      let zip64EoCDOffset = 0n;
-      const magicBytes = await readRange(file, zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
-      if (compareArrayBuffers(magicBytes, zip64EoCDLocatorSignature.buffer)) {
-        zip64EoCDOffset = await readBigUint64(
-          file,
-          zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
-        );
-        const endOfCDMagicBytes = await readRange(file, zip64EoCDOffset, zip64EoCDOffset + 4n);
-        if (!compareArrayBuffers(endOfCDMagicBytes, zip64EoCDSignature.buffer)) {
-          throw new Error("zip64 EoCD not found");
-        }
-        cdRecordsNumber = await readBigUint64(file, zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
-        cdByteSize = await readBigUint64(file, zip64EoCDOffset + ZIP64_CD_CD_BYTE_SIZE_OFFSET);
-        cdStartOffset = await readBigUint64(file, zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
-      } else {
-        zip64EoCDLocatorOffset = 0n;
-      }
-      return {
-        cdRecordsNumber,
-        cdStartOffset,
-        cdByteSize,
-        offsets: {
-          zip64EoCDOffset,
-          zip64EoCDLocatorOffset,
-          zipEoCDOffset
-        }
-      };
-    };
-    EOCD_FIELDS = [
-      // End of central directory signature = 0x06054b50
-      {
-        offset: 0,
-        size: 4,
-        default: new DataView(eoCDSignature.buffer).getUint32(0, true)
-      },
-      // Number of this disk (or 0xffff for ZIP64)
-      {
-        offset: 4,
-        size: 2,
-        default: 0
-      },
-      // Disk where central directory starts (or 0xffff for ZIP64)
-      {
-        offset: 6,
-        size: 2,
-        default: 0
-      },
-      // Number of central directory records on this disk (or 0xffff for ZIP64)
-      {
-        offset: 8,
-        size: 2,
-        name: "recordsNumber"
-      },
-      // Total number of central directory records (or 0xffff for ZIP64)
-      {
-        offset: 10,
-        size: 2,
-        name: "recordsNumber"
-      },
-      // Size of central directory (bytes) (or 0xffffffff for ZIP64)
-      {
-        offset: 12,
-        size: 4,
-        name: "cdSize"
-      },
-      // Offset of start of central directory, relative to start of archive (or 0xffffffff for ZIP64)
-      {
-        offset: 16,
-        size: 4,
-        name: "cdOffset"
-      },
-      // Comment length (n)
-      {
-        offset: 20,
-        size: 2,
-        default: 0
-      }
-    ];
-    ZIP64_EOCD_LOCATOR_FIELDS = [
-      // zip64 end of central dir locator signature
-      {
-        offset: 0,
-        size: 4,
-        default: new DataView(zip64EoCDLocatorSignature.buffer).getUint32(0, true)
-      },
-      // number of the disk with the start of the zip64 end of
-      {
-        offset: 4,
-        size: 4,
-        default: 0
-      },
-      // start of the zip64 end of central directory
-      {
-        offset: 8,
-        size: 8,
-        name: "eoCDStart"
-      },
-      // total number of disks
-      {
-        offset: 16,
-        size: 4,
-        default: 1
-      }
-    ];
-    ZIP64_EOCD_FIELDS = [
-      // End of central directory signature = 0x06064b50
-      {
-        offset: 0,
-        size: 4,
-        default: new DataView(zip64EoCDSignature.buffer).getUint32(0, true)
-      },
-      // Size of the EOCD64 minus 12
-      {
-        offset: 4,
-        size: 8,
-        default: 44
-      },
-      // Version made by
-      {
-        offset: 12,
-        size: 2,
-        default: 45
-      },
-      // Version needed to extract (minimum)
-      {
-        offset: 14,
-        size: 2,
-        default: 45
-      },
-      // Number of this disk
-      {
-        offset: 16,
-        size: 4,
-        default: 0
-      },
-      // Disk where central directory starts
-      {
-        offset: 20,
-        size: 4,
-        default: 0
-      },
-      // Number of central directory records on this disk
-      {
-        offset: 24,
-        size: 8,
-        name: "recordsNumber"
-      },
-      // Total number of central directory records
-      {
-        offset: 32,
-        size: 8,
-        name: "recordsNumber"
-      },
-      // Size of central directory (bytes)
-      {
-        offset: 40,
-        size: 8,
-        name: "cdSize"
-      },
-      // Offset of start of central directory, relative to start of archive
-      {
-        offset: 48,
-        size: 8,
-        name: "cdOffset"
-      }
-    ];
-  }
-});
-
-// ../../modules/zip/src/parse-zip/zip64-extra-field.ts
+// ../../modules/zip/src/lib/zip64-extra-field.ts
 function parseZip64ExtraField(extraField, expectedFields) {
   const values = {};
   if (expectedFields.length === 0) {
@@ -27214,537 +26946,264 @@ function parseZip64ExtraField(extraField, expectedFields) {
   }
   throw new Error("Invalid ZIP archive: required ZIP64 extended information is missing");
 }
-var ZIP64_EXTRA_FIELD_ID, ZIP64_UINT16_SENTINEL, ZIP64_UINT32_SENTINEL;
+var ZIP64_EXTRA_FIELD_ID;
 var init_zip64_extra_field = __esm({
-  "../../modules/zip/src/parse-zip/zip64-extra-field.ts"() {
+  "../../modules/zip/src/lib/zip64-extra-field.ts"() {
     "use strict";
     ZIP64_EXTRA_FIELD_ID = 1;
-    ZIP64_UINT16_SENTINEL = 0xffffn;
-    ZIP64_UINT32_SENTINEL = 0xffffffffn;
   }
 });
 
-// ../../modules/zip/src/parse-zip/cd-file-header.ts
-async function* makeZipCDHeaderIterator(fileProvider) {
-  const { cdStartOffset, cdByteSize } = await parseEoCDRecord(fileProvider);
-  const centralDirectory = new DataViewReadableFile(
-    new DataView(await readRange(fileProvider, cdStartOffset, cdStartOffset + cdByteSize))
-  );
-  let cdHeader = await parseZipCDFileHeader(0n, centralDirectory);
-  while (cdHeader) {
-    yield cdHeader;
-    cdHeader = await parseZipCDFileHeader(
-      cdHeader.extraOffset + BigInt(cdHeader.extraFieldLength),
-      centralDirectory
-    );
-  }
-}
-function generateCDHeader(options) {
-  const optionsToUse = {
-    ...options,
-    fnlength: options.fileName.length,
-    extraLength: 0
+// ../../modules/zip/src/lib/zip-entry-metadata.ts
+function decodeZipHeader(bytes, central) {
+  const header = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const fixedBytes = central ? 46 : 30;
+  if (bytes.byteLength < fixedBytes || header.getUint32(0, true) !== (central ? 33639248 : 67324752))
+    throw new Error("Invalid ZIP archive: missing entry header");
+  const nameLength = header.getUint16(central ? 28 : 26, true);
+  const extraLength = header.getUint16(central ? 30 : 28, true);
+  const commentLength = central ? header.getUint16(32, true) : 0;
+  if (bytes.byteLength !== fixedBytes + nameLength + extraLength + commentLength)
+    throw new Error("Invalid ZIP archive: truncated entry metadata");
+  const flags = header.getUint16(central ? 8 : 6, true);
+  const method = header.getUint16(central ? 10 : 8, true);
+  if (flags & (1 | 64 | 8192)) throw new Error("Unsupported ZIP encryption");
+  if (flags & ~(8 | 2048 | (method === 8 ? 6 : 0))) throw new Error("Unsupported ZIP flags");
+  if (method !== 0 && method !== 8)
+    throw new Error(`Unsupported ZIP compression method: ${method}`);
+  let compressedSize = BigInt(header.getUint32(central ? 20 : 18, true));
+  let size = BigInt(header.getUint32(central ? 24 : 22, true));
+  let localHeaderOffset = central ? BigInt(header.getUint32(42, true)) : 0n;
+  let disk = central ? BigInt(header.getUint16(34, true)) : 0n;
+  let zip64 = compressedSize === 0xffffffffn || size === 0xffffffffn;
+  const fields = [];
+  if (central) {
+    if (size === 0xffffffffn) fields.push({ name: "size", byteLength: 8 });
+    if (compressedSize === 0xffffffffn) fields.push({ name: "compressedSize", byteLength: 8 });
+    if (localHeaderOffset === 0xffffffffn) fields.push({ name: "localHeaderOffset", byteLength: 8 });
+    if (disk === 0xffffn) fields.push({ name: "disk", byteLength: 4 });
+  } else if (zip64)
+    fields.push({ name: "size", byteLength: 8 }, { name: "compressedSize", byteLength: 8 });
+  const extraBytes = bytes.subarray(fixedBytes + nameLength, fixedBytes + nameLength + extraLength);
+  const extra = new DataView(extraBytes.buffer, extraBytes.byteOffset, extraBytes.byteLength);
+  const extraValues = parseZip64ExtraField(extra, fields);
+  if (size === 0xffffffffn) size = extraValues.size;
+  if (compressedSize === 0xffffffffn) compressedSize = extraValues.compressedSize;
+  if (localHeaderOffset === 0xffffffffn) localHeaderOffset = extraValues.localHeaderOffset;
+  if (disk === 0xffffn) disk = extraValues.disk;
+  if (disk !== 0n) throw new Error("Unsupported split ZIP archive");
+  const nameBytes = bytes.subarray(fixedBytes, fixedBytes + nameLength);
+  let path = decodeZipText(nameBytes, Boolean(flags & 2048));
+  const commentBytes = bytes.subarray(fixedBytes + nameLength + extraLength);
+  let comment = decodeZipText(commentBytes, Boolean(flags & 2048));
+  for (let offset = 0; offset < extra.byteLength; ) {
+    if (offset + 4 > extra.byteLength)
+      throw new Error("Invalid ZIP archive: truncated extra field");
+    const identifier = extra.getUint16(offset, true);
+    const length = extra.getUint16(offset + 2, true);
+    if (offset + 4 + length > extra.byteLength)
+      throw new Error("Invalid ZIP archive: truncated extra field");
+    if (!central && flags & 8 && identifier === 1) {
+      if (length >= 16) zip64 = true;
+    }
+    if (identifier === 28789 || identifier === 25461) {
+      const original = identifier === 28789 ? nameBytes : commentBytes;
+      if (length < 5) throw new Error("Invalid ZIP archive: truncated Unicode extra field");
+      if (extra.getUint8(offset + 4) === 1 && extra.getUint32(offset + 5, true) === calculateZipChecksum(original)) {
+        const text = decodeZipText(extraBytes.subarray(offset + 9, offset + 4 + length), true);
+        if (identifier === 28789) path = text;
+        else comment = text;
+      }
+    }
+    offset += 4 + length;
+  }
+  validateZipPath(path);
+  return {
+    path,
+    nameBytes,
+    flags,
+    method,
+    crc32: header.getUint32(central ? 16 : 14, true),
+    compressedSize,
+    size,
+    localHeaderOffset,
+    comment,
+    zip64
   };
-  let zip64header = new ArrayBuffer(0);
-  const optionsToZip64 = {};
-  if (optionsToUse.offset >= 4294967295) {
-    optionsToZip64.offset = optionsToUse.offset;
-    optionsToUse.offset = BigInt(4294967295);
-  }
-  if (optionsToUse.length >= 4294967295) {
-    optionsToZip64.size = optionsToUse.length;
-    optionsToUse.length = 4294967295;
-  }
-  if (Object.keys(optionsToZip64).length) {
-    zip64header = createZip64Info(optionsToZip64);
-    optionsToUse.extraLength = zip64header.byteLength;
-  }
-  const header = new DataView(new ArrayBuffer(Number(CD_FILE_NAME_OFFSET)));
-  for (const field of ZIP_HEADER_FIELDS) {
-    setFieldToNumber(
-      header,
-      field.size,
-      field.offset,
-      optionsToUse[field.name ?? ""] ?? field.default ?? 0
-    );
-  }
-  const encodedName = new TextEncoder().encode(optionsToUse.fileName);
-  const resHeader = concatenateArrayBuffers(header.buffer, encodedName, zip64header);
-  return resHeader;
 }
-var CD_COMPRESSED_SIZE_OFFSET, CD_UNCOMPRESSED_SIZE_OFFSET, CD_FILE_NAME_LENGTH_OFFSET, CD_EXTRA_FIELD_LENGTH_OFFSET, CD_START_DISK_OFFSET, CD_LOCAL_HEADER_OFFSET_OFFSET, CD_FILE_NAME_OFFSET, signature2, parseZipCDFileHeader, ZIP_HEADER_FIELDS;
-var init_cd_file_header = __esm({
-  "../../modules/zip/src/parse-zip/cd-file-header.ts"() {
-    "use strict";
-    init_src2();
-    init_end_of_central_directory();
-    init_zip64_info_generation();
-    init_zip64_extra_field();
-    init_readable_file_utils();
-    CD_COMPRESSED_SIZE_OFFSET = 20;
-    CD_UNCOMPRESSED_SIZE_OFFSET = 24;
-    CD_FILE_NAME_LENGTH_OFFSET = 28;
-    CD_EXTRA_FIELD_LENGTH_OFFSET = 30;
-    CD_START_DISK_OFFSET = 34;
-    CD_LOCAL_HEADER_OFFSET_OFFSET = 42;
-    CD_FILE_NAME_OFFSET = 46n;
-    signature2 = new Uint8Array([80, 75, 1, 2]);
-    parseZipCDFileHeader = async (headerOffset, file) => {
-      const fileLength = await getReadableFileSize(file);
-      if (headerOffset >= fileLength) {
-        return null;
-      }
-      const mainHeader = await readDataView(file, headerOffset, headerOffset + CD_FILE_NAME_OFFSET);
-      const magicBytes = mainHeader.buffer.slice(0, 4);
-      if (!compareArrayBuffers(magicBytes, signature2.buffer)) {
-        return null;
-      }
-      const compressedSize = BigInt(mainHeader.getUint32(CD_COMPRESSED_SIZE_OFFSET, true));
-      const uncompressedSize = BigInt(mainHeader.getUint32(CD_UNCOMPRESSED_SIZE_OFFSET, true));
-      const extraFieldLength = mainHeader.getUint16(CD_EXTRA_FIELD_LENGTH_OFFSET, true);
-      const startDisk = BigInt(mainHeader.getUint16(CD_START_DISK_OFFSET, true));
-      const fileNameLength = mainHeader.getUint16(CD_FILE_NAME_LENGTH_OFFSET, true);
-      const additionalHeader = await readRange(
-        file,
-        headerOffset + CD_FILE_NAME_OFFSET,
-        headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
-      );
-      const filenameBytes = additionalHeader.slice(0, fileNameLength);
-      const fileName = new TextDecoder().decode(filenameBytes);
-      const extraOffset = headerOffset + CD_FILE_NAME_OFFSET + BigInt(fileNameLength);
-      const oldFormatOffset = mainHeader.getUint32(CD_LOCAL_HEADER_OFFSET_OFFSET, true);
-      const localHeaderOffset = BigInt(oldFormatOffset);
-      const extraField = new DataView(
-        additionalHeader.slice(fileNameLength, additionalHeader.byteLength)
-      );
-      const zip64Data = {
-        uncompressedSize,
-        compressedSize,
-        localHeaderOffset,
-        startDisk
-      };
-      const expectedZip64Fields = [];
-      if (zip64Data.uncompressedSize === ZIP64_UINT32_SENTINEL) {
-        expectedZip64Fields.push({ name: "uncompressedSize", byteLength: 8 });
-      }
-      if (zip64Data.compressedSize === ZIP64_UINT32_SENTINEL) {
-        expectedZip64Fields.push({ name: "compressedSize", byteLength: 8 });
-      }
-      if (zip64Data.localHeaderOffset === ZIP64_UINT32_SENTINEL) {
-        expectedZip64Fields.push({ name: "localHeaderOffset", byteLength: 8 });
-      }
-      if (zip64Data.startDisk === ZIP64_UINT16_SENTINEL) {
-        expectedZip64Fields.push({ name: "startDisk", byteLength: 4 });
-      }
-      const zip64Values = parseZip64ExtraField(extraField, expectedZip64Fields);
-      return {
-        ...zip64Data,
-        ...zip64Values,
-        extraFieldLength,
-        fileNameLength,
-        fileName,
-        extraOffset
-      };
-    };
-    ZIP_HEADER_FIELDS = [
-      // Central directory file header signature = 0x02014b50
-      {
-        offset: 0,
-        size: 4,
-        default: new DataView(signature2.buffer).getUint32(0, true)
-      },
-      // Version made by
-      {
-        offset: 4,
-        size: 2,
-        default: 45
-      },
-      // Version needed to extract (minimum)
-      {
-        offset: 6,
-        size: 2,
-        default: 45
-      },
-      // General purpose bit flag
-      {
-        offset: 8,
-        size: 2,
-        default: 0
-      },
-      // Compression method
-      {
-        offset: 10,
-        size: 2,
-        default: 0
-      },
-      // File last modification time
-      {
-        offset: 12,
-        size: 2,
-        default: 0
-      },
-      // File last modification date
-      {
-        offset: 14,
-        size: 2,
-        default: 0
-      },
-      // CRC-32 of uncompressed data
-      {
-        offset: 16,
-        size: 4,
-        name: "crc32"
-      },
-      // Compressed size (or 0xffffffff for ZIP64)
-      {
-        offset: 20,
-        size: 4,
-        name: "length"
-      },
-      // Uncompressed size (or 0xffffffff for ZIP64)
-      {
-        offset: 24,
-        size: 4,
-        name: "length"
-      },
-      // File name length (n)
-      {
-        offset: 28,
-        size: 2,
-        name: "fnlength"
-      },
-      // Extra field length (m)
-      {
-        offset: 30,
-        size: 2,
-        default: 0,
-        name: "extraLength"
-      },
-      // File comment length (k)
-      {
-        offset: 32,
-        size: 2,
-        default: 0
-      },
-      // Disk number where file starts (or 0xffff for ZIP64)
-      {
-        offset: 34,
-        size: 2,
-        default: 0
-      },
-      // Internal file attributes
-      {
-        offset: 36,
-        size: 2,
-        default: 0
-      },
-      // External file attributes
-      {
-        offset: 38,
-        size: 4,
-        default: 0
-      },
-      // Relative offset of local file header
-      {
-        offset: 42,
-        size: 4,
-        name: "offset"
-      }
-    ];
-  }
-});
-
-// ../../modules/zip/src/parse-zip/local-file-header.ts
-function generateLocalHeader(options) {
-  const optionsToUse = {
-    ...options,
-    extraLength: 0,
-    fnlength: options.fileName.length
-  };
-  let zip64header = new ArrayBuffer(0);
-  const optionsToZip64 = {};
-  if (optionsToUse.length >= 4294967295) {
-    optionsToZip64.size = optionsToUse.length;
-    optionsToUse.length = 4294967295;
-  }
-  if (Object.keys(optionsToZip64).length) {
-    zip64header = createZip64Info(optionsToZip64);
-    optionsToUse.extraLength = zip64header.byteLength;
-  }
-  const header = new DataView(new ArrayBuffer(Number(FILE_NAME_OFFSET)));
-  for (const field of ZIP_HEADER_FIELDS2) {
-    setFieldToNumber(
-      header,
-      field.size,
-      field.offset,
-      optionsToUse[field.name ?? ""] ?? field.default ?? 0
-    );
-  }
-  const encodedName = new TextEncoder().encode(optionsToUse.fileName);
-  const resHeader = concatenateArrayBuffers(header.buffer, encodedName, zip64header);
-  return resHeader;
+function decodeZipText(bytes, utf8) {
+  if (utf8) return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  return Array.from(
+    bytes,
+    (value) => value < 128 ? String.fromCharCode(value) : CP437_HIGH[value - 128]
+  ).join("");
+}
+function validateZipPath(path) {
+  const segments = path.endsWith("/") ? path.slice(0, -1).split("/") : path.split("/");
+  if (!path || path.includes("\\") || path.includes("\0") || /^[A-Za-z]:/.test(path) || segments.some((segment) => !segment || segment === "." || segment === ".."))
+    throw new Error("Invalid ZIP archive: noncanonical relative path");
+}
+function calculateZipChecksum(bytes) {
+  return Number.parseInt(new CRC32Hash().hashSync(bytes.slice().buffer, "hex"), 16);
+}
+function encodeUtf8Text(value) {
+  const bytes = new TextEncoder().encode(value);
+  if (new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes) !== value)
+    throw new TypeError("ZIP names and entry comments must be well-formed Unicode");
+  return bytes;
 }
-var COMPRESSION_METHOD_OFFSET, COMPRESSED_SIZE_OFFSET, UNCOMPRESSED_SIZE_OFFSET, FILE_NAME_LENGTH_OFFSET, EXTRA_FIELD_LENGTH_OFFSET, FILE_NAME_OFFSET, signature3, parseZipLocalFileHeader, ZIP_HEADER_FIELDS2;
-var init_local_file_header = __esm({
-  "../../modules/zip/src/parse-zip/local-file-header.ts"() {
+var CP437_HIGH;
+var init_zip_entry_metadata = __esm({
+  "../../modules/zip/src/lib/zip-entry-metadata.ts"() {
     "use strict";
-    init_src2();
-    init_zip64_info_generation();
+    init_src11();
     init_zip64_extra_field();
-    init_readable_file_utils();
-    COMPRESSION_METHOD_OFFSET = 8;
-    COMPRESSED_SIZE_OFFSET = 18;
-    UNCOMPRESSED_SIZE_OFFSET = 22;
-    FILE_NAME_LENGTH_OFFSET = 26;
-    EXTRA_FIELD_LENGTH_OFFSET = 28;
-    FILE_NAME_OFFSET = 30n;
-    signature3 = new Uint8Array([80, 75, 3, 4]);
-    parseZipLocalFileHeader = async (headerOffset, file) => {
-      const mainHeader = await readDataView(file, headerOffset, headerOffset + FILE_NAME_OFFSET);
-      const magicBytes = mainHeader.buffer.slice(0, 4);
-      if (!compareArrayBuffers(magicBytes, signature3.buffer)) {
-        return null;
-      }
-      const fileNameLength = mainHeader.getUint16(FILE_NAME_LENGTH_OFFSET, true);
-      const extraFieldLength = mainHeader.getUint16(EXTRA_FIELD_LENGTH_OFFSET, true);
-      const additionalHeader = await readRange(
-        file,
-        headerOffset + FILE_NAME_OFFSET,
-        headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength)
-      );
-      const fileNameBuffer = additionalHeader.slice(0, fileNameLength);
-      const extraDataBuffer = new DataView(
-        additionalHeader.slice(fileNameLength, additionalHeader.byteLength)
-      );
-      const fileName = new TextDecoder().decode(fileNameBuffer).split("\\").join("/");
-      const fileDataOffset = headerOffset + FILE_NAME_OFFSET + BigInt(fileNameLength + extraFieldLength);
-      const compressionMethod = mainHeader.getUint16(COMPRESSION_METHOD_OFFSET, true);
-      let compressedSize = BigInt(mainHeader.getUint32(COMPRESSED_SIZE_OFFSET, true));
-      const uncompressedSize = BigInt(mainHeader.getUint32(UNCOMPRESSED_SIZE_OFFSET, true));
-      const expectedZip64Fields = [];
-      if (uncompressedSize === ZIP64_UINT32_SENTINEL || compressedSize === ZIP64_UINT32_SENTINEL) {
-        expectedZip64Fields.push(
-          { name: "uncompressedSize", byteLength: 8 },
-          { name: "compressedSize", byteLength: 8 }
-        );
-      }
-      const zip64Sizes = parseZip64ExtraField(extraDataBuffer, expectedZip64Fields);
-      if (compressedSize === ZIP64_UINT32_SENTINEL && zip64Sizes.compressedSize !== void 0) {
-        compressedSize = zip64Sizes.compressedSize;
-      }
-      return {
-        fileNameLength,
-        fileName,
-        extraFieldLength,
-        fileDataOffset,
-        compressedSize,
-        compressionMethod
-      };
-    };
-    ZIP_HEADER_FIELDS2 = [
-      // Local file header signature = 0x04034b50
-      {
-        offset: 0,
-        size: 4,
-        default: new DataView(signature3.buffer).getUint32(0, true)
-      },
-      // Version needed to extract (minimum)
-      {
-        offset: 4,
-        size: 2,
-        default: 45
-      },
-      // General purpose bit flag
-      {
-        offset: 6,
-        size: 2,
-        default: 0
-      },
-      // Compression method
-      {
-        offset: 8,
-        size: 2,
-        default: 0
-      },
-      // File last modification time
-      {
-        offset: 10,
-        size: 2,
-        default: 0
-      },
-      // File last modification date
-      {
-        offset: 12,
-        size: 2,
-        default: 0
-      },
-      // CRC-32 of uncompressed data
-      {
-        offset: 14,
-        size: 4,
-        name: "crc32"
-      },
-      // Compressed size (or 0xffffffff for ZIP64)
-      {
-        offset: 18,
-        size: 4,
-        name: "length"
-      },
-      // Uncompressed size (or 0xffffffff for ZIP64)
-      {
-        offset: 22,
-        size: 4,
-        name: "length"
-      },
-      // File name length (n)
-      {
-        offset: 26,
-        size: 2,
-        name: "fnlength"
-      },
-      // Extra field length (m)
-      {
-        offset: 28,
-        size: 2,
-        default: 0,
-        name: "extraLength"
-      }
-    ];
-  }
-});
-
-// ../../modules/zip/src/parse-zip/zip-composition.ts
-async function generateFileHeaders(fileName, fileToAdd, localFileHeaderOffset) {
-  const newFileCRC322 = parseInt(await new CRC32Hash().hash(fileToAdd, "hex"), 16);
-  const newFileLocalHeader = generateLocalHeader({
-    crc32: newFileCRC322,
-    fileName,
-    length: fileToAdd.byteLength
-  });
-  const newFileCDHeader = generateCDHeader({
-    crc32: newFileCRC322,
-    fileName,
-    offset: localFileHeaderOffset,
-    length: fileToAdd.byteLength
-  });
-  return [
-    new Uint8Array(concatenateArrayBuffers(newFileLocalHeader, fileToAdd)),
-    new Uint8Array(newFileCDHeader)
-  ];
-}
-async function createZip(inputPath, outputPath, createAdditionalData) {
-  const fileIterator = getFileIterator(inputPath);
-  const resFile = new NodeFileFacade(outputPath, "w");
-  const fileList = [];
-  const cdArray = [];
-  for await (const file of fileIterator) {
-    await addFile(file, resFile, cdArray, fileList);
-  }
-  if (createAdditionalData) {
-    const additionaldata = await createAdditionalData(fileList);
-    await addFile(additionaldata, resFile, cdArray);
-  }
-  const cdOffset = (await resFile.stat()).bigsize;
-  const cd = concatenateArrayBuffers(...cdArray);
-  await resFile.append(new Uint8Array(cd));
-  const eoCDStart = (await resFile.stat()).bigsize;
-  await resFile.append(
-    new Uint8Array(
-      generateEoCD({ recordsNumber: cdArray.length, cdSize: cd.byteLength, cdOffset, eoCDStart })
-    )
+    CP437_HIGH = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+  }
+});
+
+// ../../modules/zip/src/lib/zip-serialization.ts
+function encodeZipLocalHeader(entry) {
+  validateHeaderEntry(entry);
+  const bytes = new Uint8Array(30 + entry.nameBytes.length + (entry.zip64 ? 20 : 0));
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, 67324752, true);
+  view.setUint16(4, getZipVersion(entry), true);
+  view.setUint16(6, entry.flags, true);
+  view.setUint16(8, entry.method, true);
+  view.setUint32(10, encodeZipTimestamp(entry.date), true);
+  const descriptor = Boolean(entry.flags & 8);
+  view.setUint32(14, descriptor ? 0 : entry.crc32, true);
+  view.setUint32(
+    18,
+    entry.zip64 ? Number(ZIP32_SENTINEL) : descriptor ? 0 : Number(entry.compressedSize),
+    true
   );
+  view.setUint32(
+    22,
+    entry.zip64 ? Number(ZIP32_SENTINEL) : descriptor ? 0 : Number(entry.size),
+    true
+  );
+  view.setUint16(26, entry.nameBytes.length, true);
+  view.setUint16(28, entry.zip64 ? 20 : 0, true);
+  bytes.set(entry.nameBytes, 30);
+  if (entry.zip64) {
+    const extraOffset = 30 + entry.nameBytes.length;
+    view.setUint16(extraOffset, 1, true);
+    view.setUint16(extraOffset + 2, 16, true);
+    view.setBigUint64(extraOffset + 4, descriptor ? 0n : entry.size, true);
+    view.setBigUint64(extraOffset + 12, descriptor ? 0n : entry.compressedSize, true);
+  }
+  return bytes;
 }
-async function addFile(file, resFile, cdArray, fileList) {
-  const size = (await resFile.stat()).bigsize;
-  fileList?.push({ fileName: file.path, localHeaderOffset: size });
-  const [localPart, cdHeaderPart] = await generateFileHeaders(file.path, file.file, size);
-  await resFile.append(localPart);
-  cdArray.push(toArrayBuffer2(cdHeaderPart));
+function encodeZipCentralHeader(entry) {
+  validateHeaderEntry(entry);
+  const comment = entry.commentBytes ?? new Uint8Array();
+  const extraBytes = entry.zip64 ? 28 : 0;
+  const bytes = new Uint8Array(46 + entry.nameBytes.length + extraBytes + comment.length);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, 33639248, true);
+  view.setUint16(4, entry.zip64 ? 45 : 20, true);
+  view.setUint16(6, getZipVersion(entry), true);
+  view.setUint16(8, entry.flags, true);
+  view.setUint16(10, entry.method, true);
+  view.setUint32(12, encodeZipTimestamp(entry.date), true);
+  view.setUint32(16, entry.crc32, true);
+  view.setUint32(20, entry.zip64 ? Number(ZIP32_SENTINEL) : Number(entry.compressedSize), true);
+  view.setUint32(24, entry.zip64 ? Number(ZIP32_SENTINEL) : Number(entry.size), true);
+  view.setUint16(28, entry.nameBytes.length, true);
+  view.setUint16(30, extraBytes, true);
+  view.setUint16(32, comment.length, true);
+  view.setUint32(38, entry.directory ? 16 : 0, true);
+  view.setUint32(42, entry.zip64 ? Number(ZIP32_SENTINEL) : Number(entry.localHeaderOffset), true);
+  bytes.set(entry.nameBytes, 46);
+  if (entry.zip64) {
+    const extraOffset = 46 + entry.nameBytes.length;
+    view.setUint16(extraOffset, 1, true);
+    view.setUint16(extraOffset + 2, 24, true);
+    view.setBigUint64(extraOffset + 4, entry.size, true);
+    view.setBigUint64(extraOffset + 12, entry.compressedSize, true);
+    view.setBigUint64(extraOffset + 20, entry.localHeaderOffset, true);
+  }
+  bytes.set(comment, 46 + entry.nameBytes.length + extraBytes);
+  return bytes;
 }
-function getFileIterator(inputPath) {
-  async function* iterable() {
-    const fileList = await getAllFiles(inputPath);
-    for (const filePath of fileList) {
-      const provider = new NodeFileFacade(path_exports.join(inputPath, filePath), "r");
-      const { bigsize } = await provider.stat();
-      const file = await provider.read(0, Number(bigsize));
-      await provider.close();
-      yield { path: filePath, file };
-    }
-  }
-  return iterable();
+function encodeZipEndRecords(count, directorySize, directoryOffset, zip64, comment = new Uint8Array()) {
+  for (const value of [count, directorySize, directoryOffset, directoryOffset + directorySize])
+    validateUint64(value);
+  if (comment.length > 65535) throw new RangeError("ZIP archive comment exceeds 65535 bytes");
+  if (!zip64 && (count > 0xffffn || directorySize >= ZIP32_SENTINEL || directoryOffset >= ZIP32_SENTINEL))
+    throw new RangeError("ZIP32 end record capacity exceeded");
+  const bytes = new Uint8Array((zip64 ? 98 : 22) + comment.length);
+  const view = new DataView(bytes.buffer);
+  if (zip64) {
+    view.setUint32(0, 101075792, true);
+    view.setBigUint64(4, 44n, true);
+    view.setUint16(12, 45, true);
+    view.setUint16(14, 45, true);
+    view.setBigUint64(24, count, true);
+    view.setBigUint64(32, count, true);
+    view.setBigUint64(40, directorySize, true);
+    view.setBigUint64(48, directoryOffset, true);
+    view.setUint32(56, 117853008, true);
+    view.setBigUint64(64, directoryOffset + directorySize, true);
+    view.setUint32(72, 1, true);
+  }
+  const endOffset = zip64 ? 76 : 0;
+  view.setUint32(endOffset, 101010256, true);
+  view.setUint16(endOffset + 8, zip64 ? 65535 : Number(count), true);
+  view.setUint16(endOffset + 10, zip64 ? 65535 : Number(count), true);
+  view.setUint32(endOffset + 12, zip64 ? Number(ZIP32_SENTINEL) : Number(directorySize), true);
+  view.setUint32(endOffset + 16, zip64 ? Number(ZIP32_SENTINEL) : Number(directoryOffset), true);
+  view.setUint16(endOffset + 20, comment.length, true);
+  bytes.set(comment, endOffset + 22);
+  return bytes;
 }
-async function getAllFiles(basePath, subfolder = "", fsPassed) {
-  const fs3 = fsPassed ? fsPassed : new NodeFileSystemFacade({});
-  const files = await fs3.readdir(pathJoin(basePath, subfolder));
-  const arrayOfFiles = [];
-  for (const file of files) {
-    const fullPath = pathJoin(basePath, subfolder, file);
-    if ((await fs3.stat(fullPath)).isDirectory) {
-      const files2 = await getAllFiles(basePath, pathJoin(subfolder, file));
-      arrayOfFiles.push(...files2);
-    } else {
-      arrayOfFiles.push(pathJoin(subfolder, file));
-    }
-  }
-  return arrayOfFiles;
+function encodeZipTimestamp(date) {
+  if (!(date instanceof Date) || !Number.isFinite(date.getTime()) || date.getUTCFullYear() < 1980 || date.getUTCFullYear() > 2107)
+    throw new RangeError("ZIP timestamp must be a valid UTC date in 1980\u20132107");
+  const time = date.getUTCHours() << 11 | date.getUTCMinutes() << 5 | Math.floor(date.getUTCSeconds() / 2);
+  const day = date.getUTCFullYear() - 1980 << 9 | date.getUTCMonth() + 1 << 5 | date.getUTCDate();
+  return (day << 16 | time) >>> 0;
+}
+function getZipVersion(entry) {
+  return entry.zip64 ? 45 : entry.method === 8 || entry.flags & 8 ? 20 : 10;
+}
+function validateHeaderEntry(entry) {
+  if (!entry.nameBytes.length || entry.nameBytes.length > 65535 || (entry.commentBytes?.length ?? 0) > 65535)
+    throw new RangeError("ZIP name/comment exceeds header capacity");
+  for (const value of [entry.size, entry.compressedSize, entry.localHeaderOffset])
+    validateUint64(value);
+  if (!entry.zip64 && [entry.size, entry.compressedSize, entry.localHeaderOffset].some(
+    (value) => value >= ZIP32_SENTINEL
+  ))
+    throw new RangeError("ZIP32 entry capacity exceeded");
 }
-function pathJoin(...paths) {
-  const resPaths = paths.filter((val) => val.length);
-  return path_exports.join(...resPaths);
+function validateUint64(value) {
+  if (typeof value !== "bigint" || value < 0n || value > 0xffffffffffffffffn)
+    throw new RangeError("ZIP64 unsigned integer capacity exceeded");
 }
-var init_zip_composition = __esm({
-  "../../modules/zip/src/parse-zip/zip-composition.ts"() {
+var ZIP32_SENTINEL;
+var init_zip_serialization = __esm({
+  "../../modules/zip/src/lib/zip-serialization.ts"() {
     "use strict";
-    init_src2();
-    init_end_of_central_directory();
-    init_src11();
-    init_local_file_header();
-    init_cd_file_header();
+    ZIP32_SENTINEL = 0xffffffffn;
   }
 });
 
-// ../../modules/compression/src/lib/compression.ts
-var CompressionTransform, Decompressor;
-var init_compression = __esm({
-  "../../modules/compression/src/lib/compression.ts"() {
+// ../../modules/compression/src/deflate-decompressor-compress-utils.ts
+var DeflateCompressUtilsDecompressor;
+var init_deflate_decompressor_compress_utils = __esm({
+  "../../modules/compression/src/deflate-decompressor-compress-utils.ts"() {
     "use strict";
-    init_src2();
-    CompressionTransform = class {
-      /** Preloads any dynamic libraries. May enable sync functions */
-      async preload(modules = {}) {
-        registerJSModules(modules);
-        return void 0;
-      }
-      // HELPERS
-      concatenate(asyncIterator) {
-        return concatenateArrayBuffersAsync(asyncIterator);
-      }
-      improveError(error) {
-        if (!error.message.includes(this.name)) {
-          error.message = `${this.name} ${error.message}`;
-        }
-        return error;
-      }
-    };
-    Decompressor = class extends CompressionTransform {
-      constructor(options) {
-        super();
-        this.decompressBatches = this.decompressBatches.bind(this);
-      }
-      /** Asynchronously decompresses data. */
-      async decompress(input, size) {
-        await this.preload();
-        return this.decompressSync(input, size);
-      }
-      /** Synchronously decompresses data. */
-      decompressSync(input, size) {
-        throw new Error(`${this.name}: sync decompression not supported`);
-      }
-      /** Decompresses batches. */
-      async *decompressBatches(asyncIterator) {
-        const input = await this.concatenate(asyncIterator);
-        yield this.decompress(input);
+    init_compress_utils_compression();
+    DeflateCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
+      constructor(options = {}) {
+        super(
+          { name: "deflate", contentEncodings: ["deflate"] },
+          () => options.raw ? import("compress-utils/deflate/decompress") : import("compress-utils/zlib/decompress"),
+          options
+        );
       }
     };
   }
@@ -27845,680 +27304,32 @@ var init_decompression_stream = __esm({
   }
 });
 
-// ../../modules/compression/src/lib/native-decompressor.ts
-var native_decompressor_exports = {};
-__export(native_decompressor_exports, {
-  NativeDecompressor: () => NativeDecompressor
-});
-var NativeDecompressor;
-var init_native_decompressor = __esm({
-  "../../modules/compression/src/lib/native-decompressor.ts"() {
-    "use strict";
-    init_compression();
-    init_decompression_stream();
-    NativeDecompressor = class extends Decompressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Runtime stream format used for every operation. */
-      format;
-      constructor(metadata, format, options = {}) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.format = format;
-      }
-      /** Decompresses one buffer with the runtime-provided stream. */
-      async decompress(input) {
-        const output = await decompressWithNativeDecompressionStream(input, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        return output;
-      }
-      /** Decompresses batches incrementally with the runtime-provided stream. */
-      async *decompressBatches(inputBatches) {
-        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        yield* output;
-      }
-    };
-  }
-});
-
-// ../../modules/compression/src/lib/lazy-compression.ts
-function mergeModules(options, modules) {
-  return { ...options, modules: { ...options.modules, ...modules } };
-}
-var LazyDecompressor;
-var init_lazy_compression = __esm({
-  "../../modules/compression/src/lib/lazy-compression.ts"() {
-    "use strict";
-    init_compression();
-    init_decompression_stream();
-    LazyDecompressor = class extends Decompressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Constructor options retained until a concrete implementation is selected. */
-      options;
-      /** Built-in stream format to probe, or null when the format has no built-in path. */
-      nativeFormat;
-      /** Returns whether built-in selection remains eligible for the merged preload options. */
-      shouldUseNative;
-      /** Dynamically imports the balanced fallback constructor. */
-      loadFallback;
-      /** Selected concrete implementation after preload completes. */
-      implementation = null;
-      /** Shared in-flight selection used by concurrent asynchronous calls. */
-      implementationPromise = null;
-      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.options = options;
-        this.nativeFormat = nativeFormat;
-        this.shouldUseNative = shouldUseNative;
-        this.loadFallback = loadFallback;
-      }
-      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
-      async preload(modules = {}) {
-        if (this.implementation) return this.implementation;
-        const options = mergeModules(this.options, modules);
-        this.implementationPromise ||= this.loadImplementation(options);
-        try {
-          this.implementation = await this.implementationPromise;
-          return this.implementation;
-        } catch (error) {
-          this.implementationPromise = null;
-          throw error;
-        }
-      }
-      /** Loads the selected concrete decompressor. */
-      async loadImplementation(options) {
-        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
-          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
-          return new NativeDecompressor2(this, this.nativeFormat, options);
-        }
-        const Decompressor2 = await this.loadFallback();
-        const implementation = new Decompressor2({ ...options, useNative: false });
-        await implementation.preload(options.modules);
-        return implementation;
-      }
-      /** Decompresses after lazily selecting the default implementation. */
-      async decompress(input, size) {
-        return (await this.preload()).decompress(input, size);
-      }
-      /** Decompresses synchronously after an implementation has been preloaded. */
-      decompressSync(input, size) {
-        if (!this.implementation) {
-          throw new Error(`${this.name}: call preload() before decompressSync()`);
-        }
-        return this.implementation.decompressSync(input, size);
-      }
-      /** Decompresses batches after lazily selecting the default implementation. */
-      async *decompressBatches(inputBatches) {
-        yield* (await this.preload()).decompressBatches(inputBatches);
-      }
-    };
-  }
-});
-
-// ../../modules/compression/src/no-decompressor.ts
-var no_decompressor_exports = {};
-__export(no_decompressor_exports, {
-  NoDecompressor: () => NoDecompressor
-});
-var NoDecompressor;
-var init_no_decompressor = __esm({
-  "../../modules/compression/src/no-decompressor.ts"() {
-    "use strict";
-    init_compression();
-    NoDecompressor = class extends Decompressor {
-      name = "uncompressed";
-      extensions = [];
-      contentEncodings = [];
-      isSupported = true;
-      constructor(options = {}) {
-        super(options);
-      }
-      /** Returns the input without modification. */
-      decompressSync(input) {
-        return input;
-      }
-    };
-  }
-});
-
-// ../../modules/compression/src/lib/fflate/index.ts
-function inflateSync(data, out) {
-  return inflt(data, out);
-}
-function gunzipSync(data, out) {
-  return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
-}
-function unzlibSync(data, out) {
-  return inflt((zlv(data), data.subarray(2, -4)), out);
-}
-var u8, u16, u32, fleb, fdeb, clim, freb, fl, revfl, fd, revfd, rev, hMap, flt, fdt, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, gzs, gzl, zlv, Inflate, Gunzip, Unzlib;
-var init_fflate = __esm({
-  "../../modules/compression/src/lib/fflate/index.ts"() {
-    "use strict";
-    u8 = Uint8Array;
-    u16 = Uint16Array;
-    u32 = Uint32Array;
-    fleb = new u8([
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-      1,
-      1,
-      1,
-      2,
-      2,
-      2,
-      2,
-      3,
-      3,
-      3,
-      3,
-      4,
-      4,
-      4,
-      4,
-      5,
-      5,
-      5,
-      5,
-      0,
-      /* unused */
-      0,
-      0,
-      /* impossible */
-      0
-    ]);
-    fdeb = new u8([
-      0,
-      0,
-      0,
-      0,
-      1,
-      1,
-      2,
-      2,
-      3,
-      3,
-      4,
-      4,
-      5,
-      5,
-      6,
-      6,
-      7,
-      7,
-      8,
-      8,
-      9,
-      9,
-      10,
-      10,
-      11,
-      11,
-      12,
-      12,
-      13,
-      13,
-      /* unused */
-      0,
-      0
-    ]);
-    clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
-    freb = (eb, start) => {
-      const b = new u16(31);
-      for (let i = 0; i < 31; ++i) {
-        b[i] = start += 1 << eb[i - 1];
-      }
-      const r = new u32(b[30]);
-      for (let i = 1; i < 30; ++i) {
-        for (let j = b[i]; j < b[i + 1]; ++j) {
-          r[j] = j - b[i] << 5 | i;
-        }
-      }
-      return [b, r];
-    };
-    [fl, revfl] = freb(fleb, 2);
-    fl[28] = 258, revfl[258] = 28;
-    [fd, revfd] = freb(fdeb, 0);
-    rev = new u16(32768);
-    for (let i = 0; i < 32768; ++i) {
-      let x = (i & 43690) >>> 1 | (i & 21845) << 1;
-      x = (x & 52428) >>> 2 | (x & 13107) << 2;
-      x = (x & 61680) >>> 4 | (x & 3855) << 4;
-      rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
-    }
-    hMap = (cd, mb, r) => {
-      const s = cd.length;
-      let i = 0;
-      const l = new u16(mb);
-      for (; i < s; ++i) {
-        if (cd[i]) ++l[cd[i] - 1];
-      }
-      const le = new u16(mb);
-      for (i = 0; i < mb; ++i) {
-        le[i] = le[i - 1] + l[i - 1] << 1;
-      }
-      let co;
-      if (r) {
-        co = new u16(1 << mb);
-        const rvb = 15 - mb;
-        for (i = 0; i < s; ++i) {
-          if (cd[i]) {
-            const sv = i << 4 | cd[i];
-            const r2 = mb - cd[i];
-            let v = le[cd[i] - 1]++ << r2;
-            for (const m = v | (1 << r2) - 1; v <= m; ++v) {
-              co[rev[v] >>> rvb] = sv;
-            }
-          }
-        }
-      } else {
-        co = new u16(s);
-        for (i = 0; i < s; ++i) {
-          if (cd[i]) {
-            co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
-          }
-        }
-      }
-      return co;
-    };
-    flt = new u8(288);
-    for (let i = 0; i < 144; ++i) flt[i] = 8;
-    for (let i = 144; i < 256; ++i) flt[i] = 9;
-    for (let i = 256; i < 280; ++i) flt[i] = 7;
-    for (let i = 280; i < 288; ++i) flt[i] = 8;
-    fdt = new u8(32);
-    for (let i = 0; i < 32; ++i) fdt[i] = 5;
-    flrm = /* @__PURE__ */ hMap(flt, 9, 1);
-    fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
-    max = (a) => {
-      let m = a[0];
-      for (let i = 1; i < a.length; ++i) {
-        if (a[i] > m) m = a[i];
-      }
-      return m;
-    };
-    bits = (d, p, m) => {
-      const o = p / 8 | 0;
-      return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
-    };
-    bits16 = (d, p) => {
-      const o = p / 8 | 0;
-      return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
-    };
-    shft = (p) => (p + 7) / 8 | 0;
-    slc = (v, s, e) => {
-      if (s == null || s < 0) s = 0;
-      if (e == null || e > v.length) e = v.length;
-      const n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
-      n.set(v.subarray(s, e));
-      return n;
-    };
-    ec = [
-      "unexpected EOF",
-      "invalid block type",
-      "invalid length/literal",
-      "invalid distance",
-      "stream finished",
-      "no stream handler",
-      ,
-      // determined by compression function
-      "no callback",
-      "invalid UTF-8 data",
-      "extra field too long",
-      "date not in range 1980-2099",
-      "filename too long",
-      "stream finishing",
-      "invalid zip data"
-      // determined by unknown compression method
-    ];
-    err = (ind, msg, nt) => {
-      const e = new Error(msg || ec[ind]);
-      e.code = ind;
-      if (Error.captureStackTrace) Error.captureStackTrace(e, err);
-      if (!nt) throw e;
-      return e;
-    };
-    inflt = (dat, buf, st) => {
-      const sl = dat.length;
-      if (!sl || st && st.f && !st.l) return buf || new u8(0);
-      const noBuf = !buf || st;
-      const noSt = !st || st.i;
-      if (!st) st = {};
-      if (!buf) buf = new u8(sl * 3);
-      const cbuf = (l) => {
-        let bl = buf.length;
-        if (l > bl) {
-          const nbuf = new u8(Math.max(bl * 2, l));
-          nbuf.set(buf);
-          buf = nbuf;
-        }
-      };
-      let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
-      const tbts = sl * 8;
-      do {
-        if (!lm) {
-          final = bits(dat, pos, 1);
-          const type = bits(dat, pos + 1, 3);
-          pos += 3;
-          if (!type) {
-            const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
-            if (t > sl) {
-              if (noSt) err(0);
-              break;
-            }
-            if (noBuf) cbuf(bt + l);
-            buf.set(dat.subarray(s, t), bt);
-            st.b = bt += l, st.p = pos = t * 8, st.f = final;
-            continue;
-          } else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
-          else if (type == 2) {
-            const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
-            const tl = hLit + bits(dat, pos + 5, 31) + 1;
-            pos += 14;
-            const ldt = new u8(tl);
-            const clt = new u8(19);
-            for (let i = 0; i < hcLen; ++i) {
-              clt[clim[i]] = bits(dat, pos + i * 3, 7);
-            }
-            pos += hcLen * 3;
-            const clb = max(clt), clbmsk = (1 << clb) - 1;
-            const clm = hMap(clt, clb, 1);
-            for (let i = 0; i < tl; ) {
-              const r = clm[bits(dat, pos, clbmsk)];
-              pos += r & 15;
-              const s = r >>> 4;
-              if (s < 16) {
-                ldt[i++] = s;
-              } else {
-                let c = 0, n = 0;
-                if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
-                else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
-                else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
-                while (n--) ldt[i++] = c;
-              }
-            }
-            const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
-            lbt = max(lt);
-            dbt = max(dt);
-            lm = hMap(lt, lbt, 1);
-            dm = hMap(dt, dbt, 1);
-          } else err(1);
-          if (pos > tbts) {
-            if (noSt) err(0);
-            break;
-          }
-        }
-        if (noBuf) cbuf(bt + 131072);
-        const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
-        let lpos = pos;
-        for (; ; lpos = pos) {
-          const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
-          pos += c & 15;
-          if (pos > tbts) {
-            if (noSt) err(0);
-            break;
-          }
-          if (!c) err(2);
-          if (sym < 256) buf[bt++] = sym;
-          else if (sym == 256) {
-            lpos = pos, lm = void 0;
-            break;
-          } else {
-            let add = sym - 254;
-            if (sym > 264) {
-              const i = sym - 257, b = fleb[i];
-              add = bits(dat, pos, (1 << b) - 1) + fl[i];
-              pos += b;
-            }
-            const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
-            if (!d) err(3);
-            pos += d & 15;
-            let dt = fd[dsym];
-            if (dsym > 3) {
-              const b = fdeb[dsym];
-              dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
-            }
-            if (pos > tbts) {
-              if (noSt) err(0);
-              break;
-            }
-            if (noBuf) cbuf(bt + 131072);
-            const end = bt + add;
-            for (; bt < end; bt += 4) {
-              buf[bt] = buf[bt - dt];
-              buf[bt + 1] = buf[bt + 1 - dt];
-              buf[bt + 2] = buf[bt + 2 - dt];
-              buf[bt + 3] = buf[bt + 3 - dt];
-            }
-            bt = end;
-          }
-        }
-        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
-        if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
-      } while (!final);
-      return bt == buf.length ? buf : slc(buf, 0, bt);
-    };
-    gzs = (d) => {
-      if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
-      const flg = d[3];
-      let st = 10;
-      if (flg & 4) st += d[10] | (d[11] << 8) + 2;
-      for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
-      return st + (flg & 2);
-    };
-    gzl = (d) => {
-      const l = d.length;
-      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
-    };
-    zlv = (d) => {
-      if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
-      if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
-    };
-    Inflate = class {
-      /**
-       * Creates an inflation stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        this.ondata = cb;
-      }
-      /** Persistent bit-reader and Huffman decoding state. */
-      s = {};
-      /** Compression options or retained output window for this stream. */
-      o;
-      /** Compressed bytes pending decoding. */
-      p = new u8(0);
-      /** Whether the stream has received its final chunk. */
-      d;
-      /**
-       * The handler to call whenever data is available
-       */
-      ondata;
-      /** Appends pending input after checking stream lifecycle. */
-      e(c) {
-        if (!this.ondata) err(5);
-        if (this.d) err(4);
-        const l = this.p.length;
-        const n = new u8(l + c.length);
-        n.set(this.p), n.set(c, l), this.p = n;
-      }
-      /** Decodes pending input and retains the sliding window. */
-      c(final) {
-        this.d = this.s.i = final || false;
-        const bts = this.s.b;
-        const dt = inflt(this.p, this.o, this.s);
-        this.ondata(slc(dt, bts, this.s.b), this.d);
-        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
-        this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
-      }
-      /**
-       * Pushes a chunk to be inflated
-       * @param chunk The chunk to push
-       * @param final Whether this is the final chunk
-       */
-      push(chunk, final) {
-        this.e(chunk), this.c(final);
-      }
-    };
-    Gunzip = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a GUNZIP stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be GUNZIPped
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          const s = this.p.length > 3 ? gzs(this.p) : 4;
-          if (s >= this.p.length && !final) return;
-          this.p = this.p.subarray(s), this.v = 0;
-        }
-        if (final) {
-          if (this.p.length < 8) err(6, "invalid gzip data");
-          this.p = this.p.subarray(0, -8);
-        }
-        Inflate.prototype.c.call(this, final);
-      }
-    };
-    Unzlib = class extends Inflate {
-      /** Whether the stream header still needs to be emitted or consumed. */
-      v = 1;
-      /**
-       * Creates a Zlib decompression stream
-       * @param cb The callback to call whenever data is inflated
-       */
-      constructor(cb) {
-        super(cb);
-      }
-      /**
-       * Pushes a chunk to be unzlibbed
-       * @param chunk The chunk to push
-       * @param final Whether this is the last chunk
-       */
-      push(chunk, final) {
-        Inflate.prototype.e.call(this, chunk);
-        if (this.v) {
-          if (this.p.length < 2 && !final) return;
-          this.p = this.p.subarray(2), this.v = 0;
-        }
-        if (final) {
-          if (this.p.length < 4) err(6, "invalid zlib data");
-          this.p = this.p.subarray(0, -4);
-        }
-        Inflate.prototype.c.call(this, final);
-      }
-    };
-  }
-});
-
-// ../../modules/compression/src/lib/fflate-stream.ts
-async function* transformFflateBatches(processor, inputBatches) {
-  const chunks = [];
-  processor.ondata = (data) => {
-    chunks.push(data.slice().buffer);
-  };
-  for await (const batch of inputBatches) {
-    processor.push(new Uint8Array(batch), false);
-    yield* chunks.splice(0);
-  }
-  processor.push(new Uint8Array(0), true);
-  yield* chunks;
-}
-var init_fflate_stream = __esm({
-  "../../modules/compression/src/lib/fflate-stream.ts"() {
-    "use strict";
-  }
-});
-
-// ../../modules/compression/src/deflate-decompressor-fflate.ts
-var DeflateFflateDecompressor;
-var init_deflate_decompressor_fflate = __esm({
-  "../../modules/compression/src/deflate-decompressor-fflate.ts"() {
-    "use strict";
-    init_fflate();
-    init_compression();
-    init_fflate_stream();
-    DeflateFflateDecompressor = class extends Decompressor {
-      name = "deflate";
-      extensions = [];
-      contentEncodings = ["deflate"];
-      isSupported = true;
-      options;
-      constructor(options = {}) {
-        super(options);
-        this.options = options;
-      }
-      /** Decompresses one zlib-wrapped DEFLATE payload synchronously. */
-      decompressSync(input) {
-        const bytes = new Uint8Array(input);
-        const output = this.options.raw ? inflateSync(bytes) : unzlibSync(bytes);
-        return output.slice().buffer;
-      }
-      /** Decompresses DEFLATE batches incrementally. */
-      async *decompressBatches(inputBatches) {
-        const processor = this.options.raw ? new Inflate() : new Unzlib();
-        yield* transformFflateBatches(processor, inputBatches);
-      }
-    };
-  }
-});
-
 // ../../modules/compression/src/deflate-decompressor.ts
-var deflate_decompressor_exports = {};
-__export(deflate_decompressor_exports, {
-  DeflateDecompressor: () => DeflateDecompressor
-});
 var DeflateDecompressor;
 var init_deflate_decompressor = __esm({
   "../../modules/compression/src/deflate-decompressor.ts"() {
     "use strict";
-    init_deflate_decompressor_fflate();
+    init_deflate_decompressor_compress_utils();
     init_decompression_stream();
-    DeflateDecompressor = class extends DeflateFflateDecompressor {
-      constructor(options = {}) {
-        super(options);
-      }
-      /** Decompresses with the built-in stream when available, then falls back to fflate. */
-      async decompress(input) {
+    DeflateDecompressor = class extends DeflateCompressUtilsDecompressor {
+      /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
+      async decompress(input, size) {
         if (this.options.useNative !== false) {
-          const format = this.options.raw ? "deflate-raw" : "deflate";
-          const output = await decompressWithNativeDecompressionStream(input, format);
+          const output = await decompressWithNativeDecompressionStream(
+            input,
+            this.options.raw ? "deflate-raw" : "deflate"
+          );
           if (output) return output;
         }
-        return this.decompressSync(input);
+        return super.decompress(input, size);
       }
-      /** Decompresses batches with a built-in or fflate stream. */
+      /** Streams native batches when available, otherwise uses the WASM stream. */
       async *decompressBatches(inputBatches) {
         if (this.options.useNative !== false) {
-          const format = this.options.raw ? "deflate-raw" : "deflate";
-          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, format);
+          const output = decompressBatchesWithNativeDecompressionStream(
+            inputBatches,
+            this.options.raw ? "deflate-raw" : "deflate"
+          );
           if (output) {
             yield* output;
             return;
@@ -28530,303 +27341,679 @@ var init_deflate_decompressor = __esm({
   }
 });
 
-// ../../modules/compression/src/gzip-decompressor-fflate.ts
-var GZipFflateDecompressor;
-var init_gzip_decompressor_fflate = __esm({
-  "../../modules/compression/src/gzip-decompressor-fflate.ts"() {
-    "use strict";
-    init_fflate();
-    init_compression();
-    init_fflate_stream();
-    GZipFflateDecompressor = class extends Decompressor {
-      name = "gzip";
-      extensions = ["gz", "gzip"];
-      contentEncodings = ["gzip", "x-gzip"];
-      isSupported = true;
-      constructor(options = {}) {
-        super(options);
-      }
-      /** Decompresses one GZIP payload synchronously. */
-      decompressSync(input) {
-        return gunzipSync(new Uint8Array(input)).slice().buffer;
-      }
-      /** Decompresses GZIP batches incrementally. */
-      async *decompressBatches(inputBatches) {
-        yield* transformFflateBatches(new Gunzip(), inputBatches);
-      }
-    };
-  }
-});
-
-// ../../modules/compression/src/gzip-decompressor.ts
-var gzip_decompressor_exports = {};
-__export(gzip_decompressor_exports, {
-  GZipDecompressor: () => GZipDecompressor
-});
-var GZipDecompressor;
-var init_gzip_decompressor = __esm({
-  "../../modules/compression/src/gzip-decompressor.ts"() {
+// ../../modules/zip/src/zip-archive.ts
+async function openZipArchive(input, options = {}) {
+  return await ZipArchive.open(input, options);
+}
+function normalizeZipInput(input) {
+  if (input instanceof ArrayBuffer) return new BlobFile(input);
+  if (ArrayBuffer.isView(input))
+    return new BlobFile(
+      new Blob([new Uint8Array(input.buffer, input.byteOffset, input.byteLength).slice()])
+    );
+  if (input instanceof Blob) return new BlobFile(input);
+  return input;
+}
+function minimumBigInt(left, right) {
+  return left < right ? left : right;
+}
+var DEFAULT_OPTIONS, ZipArchive;
+var init_zip_archive = __esm({
+  "../../modules/zip/src/zip-archive.ts"() {
     "use strict";
-    init_gzip_decompressor_fflate();
-    init_decompression_stream();
-    GZipDecompressor = class extends GZipFflateDecompressor {
-      options;
-      constructor(options = {}) {
-        super(options);
-        this.options = options;
-      }
-      /** Decompresses with the built-in stream when available, then falls back to fflate. */
-      async decompress(input) {
-        if (this.options.useNative !== false) {
-          const output = await decompressWithNativeDecompressionStream(input, "gzip");
-          if (output) return output;
+    init_src2();
+    init_deflate_decompressor();
+    init_src11();
+    init_zip_entry_metadata();
+    init_zip_serialization();
+    DEFAULT_OPTIONS = {
+      maxArchiveBytes: 1024n ** 4n,
+      maxDirectoryBytes: 32 * 1024 * 1024,
+      maxEntries: 1e5,
+      maxReadBytes: 1024 * 1024,
+      maxCompressedBytes: 64n * 1024n * 1024n,
+      maxDecodedBytes: 64n * 1024n * 1024n,
+      chunkBytes: 64 * 1024
+    };
+    ZipArchive = class _ZipArchive {
+      /** Archive byte length, without losing ZIP64 precision. */
+      size;
+      /** Archive comment, decoded using legacy ZIP CP437. */
+      comment;
+      /** Shared file limits captured at open time. */
+      limits;
+      /** Owned random-access transport. */
+      file;
+      /** File lifetime, including in-flight operations. */
+      controller = new AbortController();
+      /** Initialization/caller cancellation combined with close. */
+      signal;
+      /** Validated directory boundary. */
+      directory;
+      /** A single directory-index promise shared by concurrent lookups. */
+      directoryPromise;
+      /** Local-header validation shared by repeated path reads. */
+      entriesByOffset = /* @__PURE__ */ new Map();
+      /** Central-validated named lookups share their local-header work. */
+      entriesByPath = /* @__PURE__ */ new Map();
+      /** Next local-header boundary for central-validated, nonoverlapping payloads. */
+      nextOffsets = /* @__PURE__ */ new Map();
+      /** Only entries issued by this archive can be used for reads. */
+      issuedEntries = /* @__PURE__ */ new WeakSet();
+      /** Idempotent file cleanup, including open failure. */
+      closePromise;
+      /** Captures the owned transport and validates independent limits. */
+      constructor(file, size, options) {
+        this.file = file;
+        this.size = size;
+        this.comment = "";
+        this.limits = {
+          maxArchiveBytes: options.maxArchiveBytes ?? DEFAULT_OPTIONS.maxArchiveBytes,
+          maxDirectoryBytes: options.maxDirectoryBytes ?? DEFAULT_OPTIONS.maxDirectoryBytes,
+          maxEntries: options.maxEntries ?? DEFAULT_OPTIONS.maxEntries,
+          maxReadBytes: options.maxReadBytes ?? DEFAULT_OPTIONS.maxReadBytes,
+          maxCompressedBytes: options.maxCompressedBytes ?? DEFAULT_OPTIONS.maxCompressedBytes,
+          maxDecodedBytes: options.maxDecodedBytes ?? DEFAULT_OPTIONS.maxDecodedBytes,
+          chunkBytes: options.chunkBytes ?? DEFAULT_OPTIONS.chunkBytes
+        };
+        for (const [name18, value] of Object.entries(this.limits)) {
+          const bigintLimit = ["maxArchiveBytes", "maxCompressedBytes", "maxDecodedBytes"].includes(
+            name18
+          );
+          if (bigintLimit ? typeof value !== "bigint" || value < 0n : typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+            throw new RangeError(`Invalid ZIP ${name18} limit`);
         }
-        return this.decompressSync(input);
+        this.signal = options.signal ? AbortSignal.any([this.controller.signal, options.signal]) : this.controller.signal;
       }
-      /** Decompresses batches with a built-in or fflate stream. */
-      async *decompressBatches(inputBatches) {
-        if (this.options.useNative !== false) {
-          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "gzip");
-          if (output) {
-            yield* output;
-            return;
-          }
+      /** Initializes directory bounds without scanning entries or reading their payloads. */
+      static async open(input, options = {}) {
+        const file = normalizeZipInput(input);
+        let archive;
+        try {
+          const advertisedSize = file.bigsize;
+          const status = advertisedSize === void 0 || advertisedSize === 0n ? await file.stat?.() : void 0;
+          const reportedBigsize = status?.bigsize ?? file.bigsize;
+          const size = reportedBigsize !== void 0 && reportedBigsize !== 0n ? reportedBigsize : BigInt(status?.size || file.size);
+          archive = new _ZipArchive(file, size, options);
+          archive.signal.throwIfAborted();
+          if (size < 22n || size > archive.limits.maxArchiveBytes)
+            throw new RangeError("ZIP archive size limit or minimum header size");
+          archive.directory = await archive.readDirectoryLocation();
+          Object.defineProperty(archive, "comment", { value: archive.directory.comment });
+          return archive;
+        } catch (error) {
+          if (archive) await archive.close();
+          else await file.close();
+          throw error;
         }
-        yield* super.decompressBatches(inputBatches);
-      }
-    };
-  }
-});
-
-// ../../modules/compression/src/default-codecs.ts
-var UNCOMPRESSED, DEFLATE, GZIP, NoDecompressor2, DeflateDecompressor2, GZipDecompressor2;
-var init_default_codecs = __esm({
-  "../../modules/compression/src/default-codecs.ts"() {
-    "use strict";
-    init_lazy_compression();
-    UNCOMPRESSED = { name: "uncompressed", extensions: [], contentEncodings: [] };
-    DEFLATE = { name: "deflate", extensions: [], contentEncodings: ["deflate"] };
-    GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
-    NoDecompressor2 = class extends LazyDecompressor {
-      constructor(options = {}) {
-        super(UNCOMPRESSED, async () => (await Promise.resolve().then(() => (init_no_decompressor(), no_decompressor_exports))).NoDecompressor, options);
       }
-    };
-    DeflateDecompressor2 = class extends LazyDecompressor {
-      constructor(options = {}) {
-        super(
-          DEFLATE,
-          async () => (await Promise.resolve().then(() => (init_deflate_decompressor(), deflate_decompressor_exports))).DeflateDecompressor,
-          options,
-          options.raw ? "deflate-raw" : "deflate"
-        );
-      }
-    };
-    GZipDecompressor2 = class extends LazyDecompressor {
-      constructor(options = {}) {
-        super(
-          GZIP,
-          async () => (await Promise.resolve().then(() => (init_gzip_decompressor(), gzip_decompressor_exports))).GZipDecompressor,
-          options,
-          "gzip"
-        );
-      }
-    };
-  }
-});
-
-// ../../modules/compression/src/index.ts
-var init_src12 = __esm({
-  "../../modules/compression/src/index.ts"() {
-    "use strict";
-    init_default_codecs();
-  }
-});
-
-// ../../modules/zip/src/filesystems/zip-filesystem.ts
-var ZIP_COMPRESSION_HANDLERS, ZipFileSystem;
-var init_zip_filesystem = __esm({
-  "../../modules/zip/src/filesystems/zip-filesystem.ts"() {
-    "use strict";
-    init_src2();
-    init_cd_file_header();
-    init_local_file_header();
-    init_src12();
-    init_IndexedArchive();
-    init_readable_file_utils();
-    ZIP_COMPRESSION_HANDLERS = {
-      /** No compression */
-      0: async (compressedFile) => compressedFile,
-      /** Deflation */
-      8: async (compressedFile) => {
-        const compression = new DeflateDecompressor2({ raw: true });
-        const decompressedData = await compression.decompress(compressedFile);
-        return decompressedData;
-      }
-    };
-    ZipFileSystem = class {
-      /** File instance */
-      file = null;
-      fileName;
-      archive = null;
       /**
-       * Constructor
-       * @param file - instance of ReadableFile or file path string
+       * Appends one STORE entry through validated container metadata and the native serializer.
+       * Internal composition operation: callers own the writable file and discard it on write failure.
+       * Existing payload offsets, central metadata and archive comments are retained.
        */
-      constructor(file) {
-        if (typeof file === "string") {
-          this.fileName = file;
-          if (isBrowser) {
-            throw new Error("ZipFileSystem cannot open file paths in browser environments");
+      static async appendEntry(file, path, data, options = {}) {
+        const archive = await _ZipArchive.open(file, options);
+        try {
+          validateZipPath(path);
+          if (archive.directory.offset > BigInt(Number.MAX_SAFE_INTEGER))
+            throw new RangeError("ZIP append transport offset exceeds safe integer range");
+          if (await archive.getEntry(path)) throw new Error("ZIP entry already exists");
+          for await (const _entry of archive.entries()) {
           }
-          this.file = new NodeFileFacade(file);
-        } else if (file instanceof Blob || file instanceof ArrayBuffer) {
-          this.file = new BlobFile(file);
-        } else if (file instanceof IndexedArchive) {
-          this.file = file.file;
-          this.archive = file;
-          this.fileName = file.fileName;
-        } else {
-          this.file = file;
+          const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+          if (path.endsWith("/") && bytes.length)
+            throw new Error("ZIP directory payload must be empty");
+          const entry = {
+            nameBytes: encodeUtf8Text(path),
+            date: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z"),
+            flags: 2048,
+            method: 0,
+            crc32: 0,
+            size: BigInt(bytes.length),
+            compressedSize: BigInt(bytes.length),
+            localHeaderOffset: archive.directory.offset,
+            zip64: archive.directory.offset >= 0xffffffffn || bytes.length >= 4294967295
+          };
+          let local = encodeZipLocalHeader(entry);
+          let central = encodeZipCentralHeader(entry);
+          const directoryBytes = archive.directory.size + BigInt(central.length);
+          const directoryOffset = archive.directory.offset + BigInt(local.length + bytes.length);
+          const count = archive.directory.count + 1n;
+          const comment = new Uint8Array(
+            await archive.readExact(
+              archive.size - BigInt(archive.comment.length),
+              archive.comment.length
+            )
+          );
+          const footer = encodeZipEndRecords(
+            count,
+            directoryBytes,
+            directoryOffset,
+            directoryOffset + directoryBytes > 0x7fffffffn || count >= 0xffffn,
+            comment
+          );
+          if (count > BigInt(archive.limits.maxEntries) || directoryBytes > BigInt(archive.limits.maxDirectoryBytes) || directoryOffset + directoryBytes + BigInt(footer.length) > archive.limits.maxArchiveBytes)
+            throw new RangeError("ZIP append metadata/archive limit exceeded");
+          entry.crc32 = calculateZipChecksum(bytes);
+          local = encodeZipLocalHeader(entry);
+          central = encodeZipCentralHeader(entry);
+          const directory = new Uint8Array(
+            await archive.readExact(archive.directory.offset, Number(archive.directory.size))
+          );
+          archive.signal.throwIfAborted();
+          await file.truncate(Number(archive.directory.offset));
+          for (const chunk of [local, bytes, directory, central, footer]) {
+            archive.signal.throwIfAborted();
+            await file.append(chunk);
+          }
+          archive.signal.throwIfAborted();
+        } finally {
+          await archive.close();
         }
       }
-      /** Clean up resources */
-      async destroy() {
-        if (this.file) {
-          await this.file.close();
-        }
+      /** Enumerates validated entries in central-directory order; metadata is indexed once. */
+      async *entries() {
+        for (const path of (await this.getDirectory()).keys()) yield await this.getEntry(path);
       }
       /**
-       * Get file names list from zip archive
-       * @returns array of file names
+       * Reads the final central entry using at most one maximum-sized header from the directory tail.
+       * Ambiguous header signatures in comments fall back to the cached directory. This supports
+       * final-index discovery without scanning a large directory in the normal indexed profile.
        */
-      async readdir() {
-        if (!this.file) {
-          throw new Error("No data detected in the zip archive");
-        }
-        const fileNames = [];
-        const zipCDIterator = makeZipCDHeaderIterator(this.file);
-        for await (const cdHeader of zipCDIterator) {
-          fileNames.push(cdHeader.fileName);
+      async getLastEntry() {
+        this.signal.throwIfAborted();
+        if (!this.directory.count) return void 0;
+        const length = Number(minimumBigInt(this.directory.size, 46n + 3n * 65535n));
+        const bytes = new Uint8Array(
+          await this.readExact(this.directory.offset + this.directory.size - BigInt(length), length)
+        );
+        const view = new DataView(bytes.buffer);
+        const positions = [];
+        for (let position = 0; position + 46 <= length; position++) {
+          if (view.getUint32(position, true) !== 33639248) continue;
+          const end = position + 46 + view.getUint16(position + 28, true) + view.getUint16(position + 30, true) + view.getUint16(position + 32, true);
+          if (end === length) positions.push(position);
+        }
+        if (positions.length !== 1) {
+          const headers = [...(await this.getDirectory()).values()];
+          return await this.getEntry(headers[headers.length - 1].path);
+        }
+        const metadata = decodeZipHeader(bytes.subarray(positions[0]), true);
+        return await this.getValidatedEntry(metadata.localHeaderOffset, metadata);
+      }
+      /** Looks up a canonical path; returns undefined when the entry is absent. */
+      async getEntry(path) {
+        this.signal.throwIfAborted();
+        const metadata = (await this.getDirectory()).get(path);
+        if (!metadata) return void 0;
+        let promise = this.entriesByPath.get(path);
+        if (!promise) {
+          promise = this.getValidatedEntry(metadata.localHeaderOffset, metadata).catch((error) => {
+            this.entriesByPath.delete(path);
+            throw error;
+          });
+          this.entriesByPath.set(path, promise);
         }
-        return fileNames;
+        return await promise;
       }
       /**
-       * Get file metadata
-       * @param filename - name of a file
-       * @returns central directory data
+       * Validates a populated local header at an index-provided offset without a directory scan.
+       * Descriptor entries fall back to the shared directory because their local sizes may be zero.
+       * Direct access validates local layout/bounds; central consistency requires named lookup.
        */
-      async stat(filename2) {
-        const cdFileHeader = await this.getCDFileHeader(filename2);
-        return { ...cdFileHeader, size: Number(cdFileHeader.uncompressedSize) };
-      }
-      /**
-       * Implementation of fetch against this file system
-       * @param filename - name of a file
-       * @returns - Response with file data
-       */
-      async fetch(filename2) {
-        if (this.fileName && filename2.indexOf(this.fileName) === 0) {
-          filename2 = filename2.substring(this.fileName.length + 1);
-        }
-        let uncompressedFile;
-        if (this.archive) {
-          uncompressedFile = await this.archive.getFile(filename2, "http");
-        } else {
-          if (!this.file) {
-            throw new Error("No data detected in the zip archive");
-          }
-          const cdFileHeader = await this.getCDFileHeader(filename2);
-          const localFileHeader = await parseZipLocalFileHeader(
-            cdFileHeader.localHeaderOffset,
-            this.file
-          );
-          if (!localFileHeader) {
-            throw new Error("Local file header has not been found in the zip archive`");
-          }
-          const compressionHandler = ZIP_COMPRESSION_HANDLERS[localFileHeader.compressionMethod.toString()];
-          if (!compressionHandler) {
-            throw Error("Only Deflation compression is supported");
+      async getEntryAt(localHeaderOffset) {
+        this.signal.throwIfAborted();
+        const existing = this.entriesByOffset.get(localHeaderOffset);
+        if (existing) return await existing;
+        const metadata = await this.readLocalHeader(localHeaderOffset);
+        if (metadata.header.flags & 8) {
+          for (const header of (await this.getDirectory()).values())
+            if (header.localHeaderOffset === localHeaderOffset)
+              return await this.getEntry(header.path);
+          throw new Error("Invalid ZIP archive: indexed offset missing from directory");
+        }
+        return await this.getValidatedEntry(localHeaderOffset, void 0, metadata);
+      }
+      /** Reads one complete entry and verifies its decoded size and CRC-32. */
+      async read(entryOrPath, options = {}) {
+        const signal = this.getReadSignal(options);
+        signal.throwIfAborted();
+        const entry = await this.resolveEntry(entryOrPath);
+        signal.throwIfAborted();
+        this.checkEntryBudget(entry);
+        if (entry.size > BigInt(Number.MAX_SAFE_INTEGER))
+          throw new RangeError("ZIP allocation is not safely representable");
+        const output = new Uint8Array(Number(entry.size));
+        let offset = 0;
+        for await (const chunk of this.readInBatches(entry, options)) {
+          output.set(chunk, offset);
+          offset += chunk.byteLength;
+        }
+        return output.buffer;
+      }
+      /** Streams decoded chunks with backpressure; consuming through completion verifies CRC-32. */
+      async *readInBatches(entryOrPath, options = {}) {
+        const signal = this.getReadSignal(options);
+        signal.throwIfAborted();
+        const entry = await this.resolveEntry(entryOrPath);
+        signal.throwIfAborted();
+        this.checkEntryBudget(entry);
+        let decodedBytes = 0n;
+        let checksum = 0;
+        const hash = new CRC32Hash({
+          crypto: {
+            onEnd: (result) => {
+              checksum = Number.parseInt(result.hash, 16);
+            }
           }
-          const compressedFile = await readRange(
-            this.file,
-            localFileHeader.fileDataOffset,
-            localFileHeader.fileDataOffset + cdFileHeader.compressedSize
-          );
-          uncompressedFile = await compressionHandler(compressedFile);
-        }
-        const response = new Response(uncompressedFile);
-        Object.defineProperty(response, "url", {
-          value: filename2 ? `${this.fileName || ""}/${filename2}` : this.fileName || ""
         });
-        return response;
+        const compressed = this.readPayloadChunks(entry, signal);
+        const decoded = entry.compression === "store" ? compressed : new DeflateDecompressor({ raw: true }).decompressBatches(compressed);
+        for await (const chunk of hash.hashBatches(decoded, "hex")) {
+          signal.throwIfAborted();
+          decodedBytes += BigInt(chunk.byteLength);
+          if (decodedBytes > entry.size || decodedBytes > this.limits.maxDecodedBytes)
+            throw new RangeError("ZIP decoded entry size limit exceeded");
+          yield new Uint8Array(chunk);
+        }
+        signal.throwIfAborted();
+        if (decodedBytes !== entry.size) throw new Error("Invalid ZIP archive: decoded size mismatch");
+        if (checksum !== entry.crc32) throw new Error("Invalid ZIP archive: CRC-32 mismatch");
+      }
+      /** Reads only a STORE byte range. Partial reads cannot verify a whole-entry CRC. */
+      async readRange(entryOrPath, options) {
+        const signal = this.getReadSignal(options);
+        signal.throwIfAborted();
+        const entry = await this.resolveEntry(entryOrPath);
+        if (entry.compression !== "store") throw new Error("ZIP ranges require STORE entries");
+        if (options.start < 0n || options.end < options.start || options.end > entry.size || options.end - options.start > BigInt(this.limits.maxReadBytes))
+          throw new RangeError("ZIP byte-range limit exceeded");
+        return await this.readExact(
+          entry.dataOffset + options.start,
+          Number(options.end - options.start),
+          signal
+        );
       }
-      /**
-       * Get central directory file header
-       * @param filename - name of a file
-       * @returns central directory file header
-       */
-      async getCDFileHeader(filename2) {
-        if (!this.file) {
-          throw new Error("No data detected in the zip archive");
-        }
-        const zipCDIterator = makeZipCDHeaderIterator(this.file);
-        let result = null;
-        for await (const cdHeader of zipCDIterator) {
-          if (cdHeader.fileName === filename2) {
-            result = cdHeader;
+      /** Cancels reads and closes the owned transport exactly once; all subsequent reads reject. */
+      close() {
+        this.controller.abort(new Error("ZIP archive is closed"));
+        this.closePromise ||= this.file.close();
+        return this.closePromise;
+      }
+      /** Resolves a named entry or rejects metadata not issued by this archive. */
+      async resolveEntry(entryOrPath) {
+        this.signal.throwIfAborted();
+        const entry = typeof entryOrPath === "string" ? await this.getEntry(entryOrPath) : entryOrPath;
+        if (!entry || !this.issuedEntries.has(entry))
+          throw new Error("ZIP entry not found or belongs to another archive");
+        return entry;
+      }
+      /** Combines per-read cancellation with the owned lifetime. */
+      getReadSignal(options) {
+        return options.signal ? AbortSignal.any([this.signal, options.signal]) : this.signal;
+      }
+      /** Checks whole-entry consumption before allocation or decompression. */
+      checkEntryBudget(entry) {
+        if (entry.size > this.limits.maxDecodedBytes || entry.compressedSize > this.limits.maxCompressedBytes)
+          throw new RangeError("ZIP entry compressed/decoded byte limit exceeded");
+      }
+      /** Yields compressed bytes without retaining a complete entry. */
+      async *readPayloadChunks(entry, signal) {
+        const chunkBytes = Math.min(this.limits.chunkBytes, this.limits.maxReadBytes);
+        for (let offset = 0n; offset < entry.compressedSize; offset += BigInt(chunkBytes)) {
+          const length = Number(minimumBigInt(BigInt(chunkBytes), entry.compressedSize - offset));
+          yield await this.readExact(entry.dataOffset + offset, length, signal);
+        }
+      }
+      /** Performs exact, bounded physical reads and rejects truncated transports. */
+      async readExact(offset, length, signal = this.signal) {
+        signal.throwIfAborted();
+        if (offset < 0n || !Number.isSafeInteger(length) || length < 0 || offset + BigInt(length) > this.size)
+          throw new Error("Invalid ZIP archive: read outside file");
+        const output = new Uint8Array(length);
+        for (let copied = 0; copied < length; ) {
+          const readBytes = Math.min(length - copied, this.limits.maxReadBytes);
+          const bytes = await this.file.read(offset + BigInt(copied), readBytes, signal);
+          signal.throwIfAborted();
+          if (bytes.byteLength !== readBytes)
+            throw new Error("Invalid ZIP archive: truncated file read");
+          output.set(new Uint8Array(bytes), copied);
+          copied += readBytes;
+        }
+        return output.buffer;
+      }
+      /** Finds an EOCD whose complete comment ends at EOF, not a signature embedded in the comment. */
+      async readDirectoryLocation() {
+        const magic = new DataView(await this.readExact(0n, 4)).getUint32(0, true);
+        if (magic !== 67324752 && magic !== 101010256 && magic !== 101075792)
+          throw new Error("Unsupported ZIP prefix or archive format");
+        const tailLength = Number(minimumBigInt(this.size, 65557n));
+        const tailStart = this.size - BigInt(tailLength);
+        const tail = new DataView(await this.readExact(tailStart, tailLength));
+        let position = -1;
+        for (let candidate = tailLength - 22; candidate >= 0; candidate--) {
+          if (tail.getUint32(candidate, true) !== 101010256 || candidate + 22 + tail.getUint16(candidate + 20, true) !== tailLength)
+            continue;
+          if (position < 0) position = candidate;
+          const emptyDirectoryAtEnd = tail.getUint32(candidate + 12, true) === 0 && BigInt(tail.getUint32(candidate + 16, true)) === tailStart + BigInt(candidate);
+          if (tail.getUint16(candidate + 10, true) !== 0 || emptyDirectoryAtEnd || magic === 101075792) {
+            position = candidate;
             break;
           }
         }
-        if (!result) {
-          throw new Error("File has not been found in the zip archive");
+        if (position < 0) throw new Error("Invalid ZIP archive: end record not found");
+        const disk = tail.getUint16(position + 4, true);
+        const directoryDisk = tail.getUint16(position + 6, true);
+        if (disk !== 0 && disk !== 65535 || directoryDisk !== 0 && directoryDisk !== 65535)
+          throw new Error("Unsupported split ZIP archive");
+        const onDisk = BigInt(tail.getUint16(position + 8, true));
+        let count = BigInt(tail.getUint16(position + 10, true));
+        let size = BigInt(tail.getUint32(position + 12, true));
+        let offset = BigInt(tail.getUint32(position + 16, true));
+        let footerOffset = tailStart + BigInt(position);
+        let zip64 = false;
+        if (footerOffset >= 20n) {
+          const locator = new DataView(await this.readExact(footerOffset - 20n, 20));
+          const locatorInsideDirectory = size !== 0xffffffffn && offset !== 0xffffffffn && offset + size > footerOffset - 20n;
+          if (locator.getUint32(0, true) === 117853008 && !locatorInsideDirectory) {
+            zip64 = true;
+            if (locator.getUint32(4, true) || locator.getUint32(16, true) !== 1)
+              throw new Error("Unsupported split ZIP64 archive");
+            const zip64Offset = locator.getBigUint64(8, true);
+            const record = new DataView(await this.readExact(zip64Offset, 56));
+            if (record.getUint32(0, true) !== 101075792 || record.getBigUint64(4, true) < 44n || zip64Offset + 12n + record.getBigUint64(4, true) !== footerOffset - 20n || record.getUint32(16, true) || record.getUint32(20, true) || record.getBigUint64(24, true) !== record.getBigUint64(32, true))
+              throw new Error("Invalid ZIP64 end record");
+            const zip64Count = record.getBigUint64(32, true);
+            const zip64Size = record.getBigUint64(40, true);
+            const zip64DirectoryOffset = record.getBigUint64(48, true);
+            if (onDisk !== 0xffffn && onDisk !== zip64Count || count !== 0xffffn && count !== zip64Count || size !== 0xffffffffn && size !== zip64Size || offset !== 0xffffffffn && offset !== zip64DirectoryOffset)
+              throw new Error("Invalid ZIP64 legacy end values");
+            count = zip64Count;
+            size = zip64Size;
+            offset = zip64DirectoryOffset;
+            footerOffset = zip64Offset;
+          } else if (size === 0xffffffffn || offset === 0xffffffffn)
+            throw new Error("Invalid ZIP archive: ZIP64 locator missing");
+        } else if (size === 0xffffffffn || offset === 0xffffffffn)
+          throw new Error("Invalid ZIP archive: ZIP64 locator missing");
+        if (!zip64) {
+          if (disk === 65535 || directoryDisk === 65535)
+            throw new Error("Invalid ZIP archive: ZIP64 locator missing");
+          if (onDisk !== count) throw new Error("Invalid ZIP archive: inconsistent entry counts");
+        }
+        if (count > BigInt(this.limits.maxEntries) || size > BigInt(this.limits.maxDirectoryBytes))
+          throw new RangeError("ZIP directory entry/byte limit exceeded");
+        if (offset + size > footerOffset || size < count * 46n || count === 0n !== (size === 0n))
+          throw new Error("Invalid ZIP archive: directory outside bounds");
+        if (count && new DataView(await this.readExact(offset, 4)).getUint32(0, true) !== 33639248)
+          throw new Error("Invalid ZIP archive: directory signature missing");
+        const comment = decodeZipText(new Uint8Array(tail.buffer, position + 22), false);
+        return { count, size, offset, comment };
+      }
+      /** Indexes central metadata once, without eagerly reading every local header. */
+      getDirectory() {
+        this.signal.throwIfAborted();
+        this.directoryPromise ||= this.readDirectory().catch((error) => {
+          this.directoryPromise = void 0;
+          this.nextOffsets.clear();
+          throw error;
+        });
+        return this.directoryPromise;
+      }
+      /** Parses exact directory records, including comments and Unicode/ZIP64 extras. */
+      async readDirectory() {
+        const bytes = new Uint8Array(
+          await this.readExact(this.directory.offset, Number(this.directory.size))
+        );
+        const view = new DataView(bytes.buffer);
+        const entries = /* @__PURE__ */ new Map();
+        const offsets = /* @__PURE__ */ new Set();
+        let position = 0;
+        for (let index = 0n; index < this.directory.count; index++) {
+          if (position + 46 > bytes.byteLength)
+            throw new Error("Invalid ZIP archive: truncated directory");
+          const length = 46 + view.getUint16(position + 28, true) + view.getUint16(position + 30, true) + view.getUint16(position + 32, true);
+          const header = decodeZipHeader(bytes.subarray(position, position + length), true);
+          if (header.localHeaderOffset + 30n > this.directory.offset)
+            throw new Error("Invalid ZIP archive: local header outside data region");
+          if (entries.has(header.path) || offsets.has(header.localHeaderOffset))
+            throw new Error("Invalid ZIP archive: duplicate path or local-header offset");
+          entries.set(header.path, header);
+          offsets.add(header.localHeaderOffset);
+          position += length;
+        }
+        const sortedOffsets = [...offsets].sort(
+          (left, right) => left < right ? -1 : left > right ? 1 : 0
+        );
+        sortedOffsets.forEach(
+          (offset, index) => this.nextOffsets.set(offset, sortedOffsets[index + 1] ?? this.directory.offset)
+        );
+        if (position !== bytes.byteLength)
+          throw new Error("Invalid ZIP archive: directory length mismatch");
+        return entries;
+      }
+      /** Reads local metadata without inspecting unrelated payloads. */
+      async readLocalHeader(offset) {
+        if (offset < 0n || offset + 30n > this.directory.offset)
+          throw new Error("Invalid ZIP archive: local header outside data region");
+        const fixed = new DataView(await this.readExact(offset, 30));
+        const length = 30 + fixed.getUint16(26, true) + fixed.getUint16(28, true);
+        if (offset + BigInt(length) > this.directory.offset)
+          throw new Error("Invalid ZIP archive: local metadata overlaps directory");
+        const bytes = new Uint8Array(length);
+        bytes.set(new Uint8Array(fixed.buffer));
+        bytes.set(new Uint8Array(await this.readExact(offset + 30n, length - 30)), 30);
+        const header = decodeZipHeader(bytes, false);
+        return { header, dataOffset: offset + BigInt(length) };
+      }
+      /** Shares local validation; a later named lookup additionally verifies central metadata. */
+      async getValidatedEntry(offset, central, localMetadata) {
+        if (central) return await this.validateEntry(offset, central);
+        let entry = this.entriesByOffset.get(offset);
+        if (!entry) {
+          entry = this.validateEntry(offset, void 0, localMetadata).catch((error) => {
+            this.entriesByOffset.delete(offset);
+            throw error;
+          });
+          this.entriesByOffset.set(offset, entry);
+        }
+        return await entry;
+      }
+      /** Validates local/central identity, payload bounds and signed or unsigned descriptors. */
+      async validateEntry(offset, central, localMetadata) {
+        const { header: local, dataOffset } = localMetadata ?? await this.readLocalHeader(offset);
+        const metadata = central || local;
+        const descriptor = Boolean(local.flags & 8);
+        if (central && (central.flags !== local.flags || central.method !== local.method || central.nameBytes.length !== local.nameBytes.length || central.nameBytes.some((value, index) => value !== local.nameBytes[index]) || !descriptor && (central.crc32 !== local.crc32 || central.size !== local.size || central.compressedSize !== local.compressedSize)))
+          throw new Error("Invalid ZIP archive: local/central metadata mismatch");
+        if (metadata.method === 0 && metadata.size !== metadata.compressedSize)
+          throw new Error("Invalid ZIP archive: STORE sizes mismatch");
+        if (central && descriptor && (local.crc32 !== 0 && local.crc32 !== central.crc32 || local.size !== 0n && local.size !== central.size || local.compressedSize !== 0n && local.compressedSize !== central.compressedSize))
+          throw new Error("Invalid ZIP archive: descriptor local/central metadata mismatch");
+        const payloadEnd = dataOffset + metadata.compressedSize;
+        const entryEnd = central ? this.nextOffsets.get(offset) ?? this.directory.offset : this.directory.offset;
+        if (payloadEnd > entryEnd) throw new Error("Invalid ZIP archive: payload overlaps directory");
+        if (descriptor)
+          await this.validateDescriptor(
+            payloadEnd,
+            metadata,
+            local.zip64 || Boolean(central?.zip64),
+            entryEnd
+          );
+        const entry = Object.freeze({
+          path: metadata.path,
+          directory: metadata.path.endsWith("/"),
+          compression: metadata.method === 0 ? "store" : "deflate",
+          size: metadata.size,
+          compressedSize: metadata.compressedSize,
+          crc32: metadata.crc32,
+          localHeaderOffset: offset,
+          dataOffset,
+          comment: central?.comment || ""
+        });
+        this.issuedEntries.add(entry);
+        return entry;
+      }
+      /** Resolves the optional descriptor signature using the expected CRC and sizes. */
+      async validateDescriptor(offset, metadata, zip64, entryEnd) {
+        const length = Number(minimumBigInt(24n, entryEnd - offset));
+        const bytes = new DataView(await this.readExact(offset, length));
+        for (const wide of zip64 ? [true, false] : [false, true]) {
+          if (!wide && (metadata.size > 0xffffffffn || metadata.compressedSize > 0xffffffffn)) continue;
+          const descriptorLength = wide ? 20 : 12;
+          for (const prefix of [4, 0]) {
+            if (length < prefix + descriptorLength || prefix && bytes.getUint32(0, true) !== 134695760)
+              continue;
+            const compressed = wide ? bytes.getBigUint64(prefix + 4, true) : BigInt(bytes.getUint32(prefix + 4, true));
+            const decoded = wide ? bytes.getBigUint64(prefix + 12, true) : BigInt(bytes.getUint32(prefix + 8, true));
+            if (bytes.getUint32(prefix, true) === metadata.crc32 && compressed === metadata.compressedSize && decoded === metadata.size)
+              return;
+          }
         }
-        return result;
+        throw new Error("Invalid ZIP archive: data descriptor mismatch");
       }
     };
   }
 });
 
-// ../../modules/zip/src/filesystems/IndexedArchive.ts
-var IndexedArchive;
-var init_IndexedArchive = __esm({
-  "../../modules/zip/src/filesystems/IndexedArchive.ts"() {
-    "use strict";
-    init_zip_filesystem();
-    IndexedArchive = class {
-      file;
-      fileName;
-      /**
-       * Constructor
-       * @param fileProvider - readable file instance for random access
-       * @param hashTable - pre-loaded hashTable. If presented, getFile will skip reading the hash file
-       * @param fileName - name of the archive. It is used to add to an URL of a loader context
-       */
-      constructor(file, hashTable, fileName) {
-        this.file = file;
-        this.fileName = fileName;
-      }
-      /**
-       * Get file as from order ZIP arhive without using the hash file
-       * @param filename - path to the internal file
-       * @returns
-       */
-      async getFileWithoutHash(filename2) {
-        const zipFS = new ZipFileSystem(this.file);
-        const response = await zipFS.fetch(filename2);
-        return await response.arrayBuffer();
+// ../../modules/zip/src/lib/zip-composition.ts
+async function generateFileHeaders(fileName, file, offset) {
+  validateZipPath(fileName);
+  const header = {
+    nameBytes: encodeUtf8Text(fileName),
+    date: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z"),
+    flags: 2048,
+    method: 0,
+    crc32: Number.parseInt(await new CRC32Hash().hash(file, "hex"), 16),
+    size: BigInt(file.byteLength),
+    compressedSize: BigInt(file.byteLength),
+    localHeaderOffset: offset,
+    zip64: offset >= 0xffffffffn || file.byteLength >= 4294967295
+  };
+  return [
+    new Uint8Array(concatenateArrayBuffers(encodeZipLocalHeader(header), file)),
+    encodeZipCentralHeader(header)
+  ];
+}
+async function createZip(inputPath, outputPath, createAdditionalData, options = {}) {
+  const state = {
+    maxArchiveBytes: options.maxArchiveBytes ?? 1024n ** 4n,
+    maxEntries: options.maxEntries ?? 1e5,
+    maxDirectoryBytes: options.maxDirectoryBytes ?? 32 * 1024 * 1024,
+    signal: options.signal,
+    directoryBytes: 0
+  };
+  if (typeof state.maxArchiveBytes !== "bigint" || state.maxArchiveBytes < 0n || !Number.isSafeInteger(state.maxEntries) || state.maxEntries < 1 || !Number.isSafeInteger(state.maxDirectoryBytes) || state.maxDirectoryBytes < 1)
+    throw new RangeError("Invalid ZIP composition limits");
+  if (state.maxArchiveBytes < 22n) throw new RangeError("ZIP composition archive limit exceeded");
+  state.signal?.throwIfAborted();
+  const fileIterator = getFileIterator(inputPath);
+  const resFile = new NodeFileFacade(outputPath, "w");
+  const fileList = [];
+  const cdArray = [];
+  try {
+    for await (const file of fileIterator) {
+      await addFile(file, resFile, cdArray, state, fileList);
+    }
+    if (createAdditionalData) {
+      const additionaldata = await createAdditionalData(fileList);
+      await addFile(additionaldata, resFile, cdArray, state);
+    }
+    state.signal?.throwIfAborted();
+    const cdOffset = (await resFile.stat()).bigsize;
+    const cd = concatenateArrayBuffers(...cdArray);
+    await resFile.append(new Uint8Array(cd));
+    const eoCDStart = (await resFile.stat()).bigsize;
+    await resFile.append(
+      new Uint8Array(
+        encodeZipEndRecords(
+          BigInt(cdArray.length),
+          BigInt(cd.byteLength),
+          cdOffset,
+          eoCDStart > 0x7fffffffn || cdArray.length >= 65535
+        )
+      )
+    );
+  } finally {
+    await resFile.close();
+  }
+}
+async function addFile(file, resFile, cdArray, state, fileList) {
+  state.signal?.throwIfAborted();
+  const size = (await resFile.stat()).bigsize;
+  fileList?.push({ fileName: file.path, localHeaderOffset: size });
+  const [localPart, cdHeaderPart] = await generateFileHeaders(file.path, file.file, size);
+  const directoryBytes = state.directoryBytes + cdHeaderPart.byteLength;
+  const directoryOffset = size + BigInt(localPart.byteLength);
+  const count = cdArray.length + 1;
+  const footer = encodeZipEndRecords(
+    BigInt(count),
+    BigInt(directoryBytes),
+    directoryOffset,
+    directoryOffset + BigInt(directoryBytes) > 0x7fffffffn || count >= 65535
+  );
+  if (count > state.maxEntries || directoryBytes > state.maxDirectoryBytes || directoryOffset + BigInt(directoryBytes + footer.length) > state.maxArchiveBytes)
+    throw new RangeError("ZIP composition metadata/archive limit exceeded");
+  state.signal?.throwIfAborted();
+  await resFile.append(localPart);
+  state.directoryBytes = directoryBytes;
+  cdArray.push(toArrayBuffer2(cdHeaderPart));
+}
+function getFileIterator(inputPath) {
+  async function* iterable() {
+    const fileList = await getAllFiles(inputPath);
+    for (const filePath of fileList) {
+      const provider = new NodeFileFacade(path_exports.join(inputPath, filePath), "r");
+      try {
+        const { bigsize } = await provider.stat();
+        const file = await provider.read(0, Number(bigsize));
+        yield { path: filePath, file };
+      } finally {
+        await provider.close();
       }
-    };
+    }
+  }
+  return iterable();
+}
+async function getAllFiles(basePath, subfolder = "", fsPassed) {
+  const fs3 = fsPassed ? fsPassed : new NodeFileSystemFacade({});
+  const files = await fs3.readdir(pathJoin(basePath, subfolder));
+  const arrayOfFiles = [];
+  for (const file of files) {
+    const fullPath = pathJoin(basePath, subfolder, file);
+    if ((await fs3.stat(fullPath)).isDirectory) {
+      const files2 = await getAllFiles(basePath, pathJoin(subfolder, file));
+      arrayOfFiles.push(...files2);
+    } else {
+      arrayOfFiles.push(pathJoin(subfolder, file));
+    }
+  }
+  return arrayOfFiles;
+}
+function pathJoin(...paths) {
+  const resPaths = paths.filter((val) => val.length);
+  return path_exports.join(...resPaths);
+}
+var init_zip_composition = __esm({
+  "../../modules/zip/src/lib/zip-composition.ts"() {
+    "use strict";
+    init_src2();
+    init_zip_entry_metadata();
+    init_src11();
+    init_zip_serialization();
   }
 });
 
 // ../../modules/zip/src/hash-file-utility.ts
 function parseHashTable(arrayBuffer) {
+  if (arrayBuffer.byteLength % 24) throw new Error("Invalid ZIP index length");
   const dataView = new DataView(arrayBuffer);
   const hashMap = {};
   for (let i = 0; i < arrayBuffer.byteLength; i = i + 24) {
     const offset = dataView.getBigUint64(i + 16, true);
     const hash = bufferToHex(arrayBuffer, i, 16);
+    if (hash in hashMap) throw new Error("Duplicate ZIP index hash");
     hashMap[hash] = offset;
   }
   return hashMap;
@@ -28834,30 +28021,14 @@ function parseHashTable(arrayBuffer) {
 function bufferToHex(buffer, start, length) {
   return [...new Uint8Array(buffer, start, length)].map((x) => x.toString(16).padStart(2, "0")).join("");
 }
-async function makeHashTableFromZipHeaders(fileProvider) {
-  const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
-  return getHashTable(zipCDIterator);
-}
-async function getHashTable(zipCDIterator) {
-  const md5Hash = new MD5Hash();
-  const textEncoder = new TextEncoder();
-  const hashTable = {};
-  for await (const cdHeader of zipCDIterator) {
-    const filename2 = cdHeader.fileName.split("\\").join("/").toLocaleLowerCase();
-    const arrayBuffer = textEncoder.encode(filename2).buffer;
-    const md53 = await md5Hash.hash(arrayBuffer, "hex");
-    hashTable[md53] = cdHeader.localHeaderOffset;
-  }
-  return hashTable;
-}
 async function composeHashFile(zipCDIterator) {
   const md5Hash = new MD5Hash();
   const textEncoder = new TextEncoder();
   const hashArray = [];
   for await (const cdHeader of zipCDIterator) {
-    let filename2 = cdHeader.fileName.split("\\").join("/");
+    let filename2 = ("path" in cdHeader ? cdHeader.path : cdHeader.fileName).split("\\").join("/");
     if (filename2 !== "3dSceneLayer.json.gz") {
-      filename2 = filename2.toLocaleLowerCase();
+      filename2 = filename2.toLowerCase();
     }
     const arrayBuffer = textEncoder.encode(filename2).buffer;
     const md53 = await md5Hash.hash(arrayBuffer, "hex");
@@ -28885,18 +28056,313 @@ var init_hash_file_utility = __esm({
     "use strict";
     init_src11();
     init_src2();
-    init_cd_file_header();
+  }
+});
+
+// ../../modules/zip/src/filesystems/IndexedArchive.ts
+var IndexedArchive;
+var init_IndexedArchive = __esm({
+  "../../modules/zip/src/filesystems/IndexedArchive.ts"() {
+    "use strict";
+    init_src11();
+    init_zip_archive();
+    init_hash_file_utility();
+    IndexedArchive = class {
+      /** Captures the source and an optional already-loaded format index. */
+      constructor(file, hashTable, fileName, options = {}) {
+        this.options = options;
+        this.file = file;
+        this.hashTable = hashTable;
+        this.fileName = fileName;
+      }
+      options;
+      /** Owned random-access archive source. */
+      file;
+      /** Optional resource URL prefix. */
+      fileName;
+      /** Format-provided path hashes, or a directory-derived fallback. */
+      hashTable;
+      /** Cancellation for metadata initialization and indexed reads. */
+      controller = new AbortController();
+      /** Shared lazy ZIP reader and directory cache. */
+      readerPromise;
+      /** Idempotent release even when no reader has been opened. */
+      closePromise;
+      /**
+       * Loads a final index when present, otherwise hashes validated directory entries.
+       * The format supplies the reserved name and fallback path-case policy. Returns true for an index.
+       */
+      async initializeIndex(indexPath, lowercasePaths = false) {
+        const reader = await this.getZipArchive();
+        const last = await reader.getLastEntry();
+        if (last?.path === indexPath) {
+          this.hashTable = parseHashTable(await reader.read(last));
+          return true;
+        }
+        const hash = new MD5Hash();
+        const table = /* @__PURE__ */ Object.create(null);
+        for await (const entry of reader.entries()) {
+          const path = lowercasePaths ? entry.path.toLowerCase() : entry.path;
+          const digest = await hash.hash(new TextEncoder().encode(path).buffer, "hex");
+          if (digest in table) throw new Error("Duplicate ZIP index path hash");
+          table[digest] = entry.localHeaderOffset;
+        }
+        this.hashTable = table;
+        return false;
+      }
+      /** Closes the reader/transport exactly once and rejects subsequent resource reads. */
+      async close() {
+        this.controller.abort(new Error("ZIP archive is closed"));
+        this.closePromise ||= this.readerPromise ? this.readerPromise.then(
+          (reader) => reader.close(),
+          () => {
+          }
+        ) : this.file.close();
+        await this.closePromise;
+      }
+      /** Reads and verifies a complete ZIP entry, retaining direct indexed local-header access. */
+      async readZipEntry(path) {
+        const reader = await this.getZipArchive();
+        let entry;
+        if (this.hashTable) {
+          const digest = await new MD5Hash().hash(new TextEncoder().encode(path).buffer, "hex");
+          const offset = this.hashTable[digest];
+          if (offset === void 0) return void 0;
+          entry = await reader.getEntryAt(offset);
+          if (entry.path.toLowerCase() !== path.toLowerCase())
+            throw new Error("ZIP index path mismatch");
+        } else entry = await reader.getEntry(path);
+        return entry ? await reader.read(entry) : void 0;
+      }
+      /** Compatibility helper for adapters with no path index. */
+      async getFileWithoutHash(path) {
+        const data = await this.readZipEntry(path);
+        if (!data) throw new Error(`No such file in the archive: ${path}`);
+        return data;
+      }
+      /** Initializes container metadata once without reading unrelated payloads. */
+      async getZipArchive() {
+        if (this.closePromise) throw new Error("ZIP archive is closed");
+        this.readerPromise ||= openZipArchive(this.file, {
+          ...this.options,
+          signal: this.options.signal ? AbortSignal.any([this.controller.signal, this.options.signal]) : this.controller.signal
+        });
+        return await this.readerPromise;
+      }
+    };
+  }
+});
+
+// ../../modules/zip/src/filesystems/zip-filesystem.ts
+function parseByteRange(value, size) {
+  const match = /^bytes=(\d*)-(\d*)$/i.exec(value.trim());
+  if (!match || !match[1] && !match[2] || size === 0n) return void 0;
+  if (!match[1]) {
+    const suffix = BigInt(match[2]);
+    if (!suffix) return void 0;
+    return { start: suffix < size ? size - suffix : 0n, end: size };
+  }
+  const start = BigInt(match[1]);
+  const last = match[2] ? BigInt(match[2]) : size - 1n;
+  if (start >= size || last < start) return void 0;
+  return { start, end: last < size ? last + 1n : size };
+}
+var ZipFileSystem;
+var init_zip_filesystem = __esm({
+  "../../modules/zip/src/filesystems/zip-filesystem.ts"() {
+    "use strict";
+    init_src2();
+    init_IndexedArchive();
+    init_zip_archive();
+    ZipFileSystem = class {
+      /** Opens portable bytes, a random-access file, a format adapter, or a Node file path lazily. */
+      constructor(file, options = {}) {
+        this.options = options;
+        this.signal = options.signal ? AbortSignal.any([this.controller.signal, options.signal]) : this.controller.signal;
+        this.archive = file instanceof IndexedArchive ? file : null;
+        if (typeof file === "string") {
+          if (isBrowser)
+            throw new Error("ZipFileSystem cannot open file paths in browser environments");
+          this.fileName = file;
+          this.file = new NodeFileFacade(file);
+        } else if (file instanceof IndexedArchive) {
+          this.file = file.file;
+          this.fileName = file.fileName;
+        } else if (file instanceof Blob || file instanceof ArrayBuffer) {
+          this.file = new BlobFile(file);
+        } else if (ArrayBuffer.isView(file)) {
+          this.file = new BlobFile(
+            Uint8Array.from(new Uint8Array(file.buffer, file.byteOffset, file.byteLength)).buffer
+          );
+        } else {
+          this.file = file;
+        }
+      }
+      options;
+      /** Owned random-access transport. */
+      file;
+      /** Optional archive name used in response URLs. */
+      fileName;
+      /** Optional format adapter retaining resource aliases and content-level decoding. */
+      archive;
+      /** Shared reader initialization, performed once when first needed. */
+      readerPromise;
+      /** Cancellation for opening and all reads during the filesystem lifetime. */
+      controller = new AbortController();
+      /** Caller cancellation combined with filesystem destruction. */
+      signal;
+      /** Idempotent transport release. */
+      destroyPromise;
+      /** Cancels pending reads and closes the owned file once; later operations reject. */
+      destroy() {
+        this.controller.abort(new Error("ZIP filesystem is closed"));
+        this.destroyPromise ||= this.archive ? this.archive.close() : this.readerPromise ? this.readerPromise.then(
+          (reader) => reader.close(),
+          () => {
+          }
+        ) : this.file.close();
+        return this.destroyPromise;
+      }
+      /** Lists validated archive paths in central-directory order, including directory entries. */
+      async readdir() {
+        const reader = await this.getReader();
+        const paths = [];
+        for await (const entry of reader.entries()) paths.push(entry.path);
+        return paths;
+      }
+      /** Returns validated metadata; rejects sizes that cannot be represented safely as a number. */
+      async stat(filename2) {
+        const entry = await this.getEntry(filename2);
+        if (entry.size > BigInt(Number.MAX_SAFE_INTEGER))
+          throw new RangeError("ZIP FileSystem size is not safely representable");
+        return { ...entry, size: Number(entry.size), uncompressedSize: entry.size };
+      }
+      /**
+       * Fetches a confined resource. Complete streams verify CRC when consumed through completion.
+       * Single STORE ranges return 206 or 416; compressed and format-decoded ranges reject.
+       */
+      async fetch(filename2, options = {}) {
+        this.signal.throwIfAborted();
+        options.signal?.throwIfAborted();
+        if (options.method && options.method.toUpperCase() !== "GET")
+          throw new Error("ZIP filesystem only supports GET");
+        let path;
+        const range = new Headers(options.headers).get("range");
+        let response;
+        if (this.archive) {
+          path = this.resolveResourcePath(filename2);
+          if (range !== null)
+            throw new Error("ZIP ranges are unavailable through format resource adapters");
+          response = new Response(await this.archive.getFile(path, "http"));
+          this.signal.throwIfAborted();
+          options.signal?.throwIfAborted();
+        } else {
+          const reader = await this.getReader();
+          options.signal?.throwIfAborted();
+          const entry = await this.getEntry(filename2);
+          options.signal?.throwIfAborted();
+          path = entry.path;
+          const headers = new Headers({
+            "Accept-Ranges": entry.compression === "store" ? "bytes" : "none",
+            "Content-Length": String(entry.size)
+          });
+          if (range !== null) {
+            if (entry.compression !== "store") throw new Error("ZIP ranges require STORE entries");
+            const bounds = parseByteRange(range, entry.size);
+            if (!bounds) {
+              headers.set("Content-Range", `bytes */${entry.size}`);
+              headers.set("Content-Length", "0");
+              response = new Response(null, { status: 416, headers });
+            } else {
+              const bytes = await reader.readRange(entry, {
+                ...bounds,
+                signal: options.signal || void 0
+              });
+              headers.set("Content-Range", `bytes ${bounds.start}-${bounds.end - 1n}/${entry.size}`);
+              headers.set("Content-Length", String(bounds.end - bounds.start));
+              response = new Response(bytes, { status: 206, headers });
+            }
+          } else {
+            const iterator = reader.readInBatches(entry, { signal: options.signal || void 0 })[Symbol.asyncIterator]();
+            const stream = new ReadableStream(
+              {
+                async pull(controller) {
+                  try {
+                    const chunk = await iterator.next();
+                    if (chunk.done) controller.close();
+                    else controller.enqueue(chunk.value);
+                  } catch (error) {
+                    controller.error(error);
+                  }
+                },
+                async cancel() {
+                  await iterator.return?.();
+                }
+              },
+              { highWaterMark: 0 }
+            );
+            response = new Response(stream, { headers });
+          }
+        }
+        Object.defineProperty(response, "url", {
+          value: this.getResourceUrl(path)
+        });
+        return response;
+      }
+      /** Resolves resources once, allowing parents inside the archive but rejecting root escapes. */
+      resolveResourcePath(filename2, decodeUri = false) {
+        const archivePath = filename2.startsWith("./") ? filename2.slice(2) : filename2;
+        const archiveName = this.fileName?.replace(/^\.\//, "");
+        if (archiveName && (archivePath === archiveName || archivePath.startsWith(`${archiveName}/`))) {
+          filename2 = archivePath.slice(archiveName.length).replace(/^\//, "");
+          decodeUri = true;
+        }
+        decodeUri ||= filename2.startsWith("/") || filename2.startsWith("./");
+        if (/^[a-z][a-z\d+.-]*:/i.test(filename2) || filename2.startsWith("//"))
+          throw new Error("ZIP resource must stay inside the archive");
+        const decoded = decodeUri ? decodeURIComponent(filename2.split(/[?#]/, 1)[0]) : filename2;
+        if (decoded.includes("\\") || decoded.includes("\0") || decoded.startsWith("//") || /^[a-z][a-z\d+.-]*:/i.test(decoded))
+          throw new Error("ZIP resource must stay inside the archive");
+        const segments = [];
+        for (const segment of decoded.split("/")) {
+          if (!segment || segment === ".") continue;
+          if (segment === "..") {
+            if (!segments.length) throw new Error("ZIP resource escapes the archive");
+            segments.pop();
+          } else segments.push(segment);
+        }
+        return segments.join("/") + (decoded.endsWith("/") && segments.length ? "/" : "");
+      }
+      /** Creates a qualified URL that cannot be confused with a canonical literal archive path. */
+      getResourceUrl(path) {
+        const prefix = this.fileName && !/^(?:\/|[a-z][a-z\d+.-]*:)/i.test(this.fileName) ? `./${this.fileName.replace(/^\.\//, "")}` : this.fileName || "";
+        return `${prefix}/${path.split("/").map(encodeURIComponent).join("/")}`;
+      }
+      /** Shares the directory cache and lifetime with every filesystem lookup. */
+      async getReader() {
+        this.signal.throwIfAborted();
+        if (this.archive) return await this.archive.getZipArchive();
+        this.readerPromise ||= openZipArchive(this.file, {
+          ...this.options,
+          signal: this.signal
+        });
+        return await this.readerPromise;
+      }
+      /** Resolves one validated entry and reports absent resources explicitly. */
+      async getEntry(path) {
+        const reader = await this.getReader();
+        const entry = await reader.getEntry(path) || await reader.getEntry(this.resolveResourcePath(path, true));
+        if (!entry) throw new Error(`File has not been found in the zip archive: ${path}`);
+        return entry;
+      }
+    };
   }
 });
 
 // ../../modules/zip/src/index.ts
-var init_src13 = __esm({
+var init_src12 = __esm({
   "../../modules/zip/src/index.ts"() {
     "use strict";
-    init_cd_file_header();
-    init_local_file_header();
-    init_search_from_the_end();
-    init_readable_file_utils();
     init_zip_composition();
     init_IndexedArchive();
     init_hash_file_utility();
@@ -28905,30 +28371,19 @@ var init_src13 = __esm({
 });
 
 // ../../modules/3d-tiles/src/3d-tiles-archive/3d-tiles-archive-archive.ts
-var COMPRESSION_METHODS, Tiles3DArchive;
+var Tiles3DArchive;
 var init_d_tiles_archive_archive = __esm({
   "../../modules/3d-tiles/src/3d-tiles-archive/3d-tiles-archive-archive.ts"() {
     "use strict";
-    init_src11();
     init_src12();
-    init_src13();
-    COMPRESSION_METHODS = {
-      /** No compression */
-      0: (data) => new NoDecompressor2().decompress(data),
-      /** Deflation */
-      8: (data) => new DeflateDecompressor2({ raw: true }).decompress(data)
-    };
     Tiles3DArchive = class extends IndexedArchive {
-      /** hash info */
-      hashTable;
       /**
        * creates Tiles3DArchive handler
        * @param fileProvider - readable file handle with the whole archive
        * @param hashTable - hash info
        */
-      constructor(fileProvider, hashTable, fileName) {
-        super(fileProvider, hashTable, fileName);
-        this.hashTable = hashTable;
+      constructor(fileProvider, hashTable, fileName, options) {
+        super(fileProvider, hashTable, fileName, options);
       }
       /**
        * Returns file with the given path from 3tz archive
@@ -28951,37 +28406,33 @@ var init_d_tiles_archive_archive = __esm({
        * @returns buffer with the raw file data
        */
       async getFileBytes(path) {
-        let uncompressedFile;
-        if (this.hashTable) {
-          const arrayBuffer = new TextEncoder().encode(path).buffer;
-          const nameHash = await new MD5Hash().hash(arrayBuffer, "hex");
-          const byteOffset = this.hashTable[nameHash];
-          if (byteOffset === void 0) {
-            return null;
-          }
-          const localFileHeader = await parseZipLocalFileHeader(byteOffset, this.file);
-          if (!localFileHeader) {
-            return null;
-          }
-          const compressedFile = await readRange(
-            this.file,
-            localFileHeader.fileDataOffset,
-            localFileHeader.fileDataOffset + localFileHeader.compressedSize
-          );
-          const compressionMethod = COMPRESSION_METHODS[localFileHeader.compressionMethod];
-          if (!compressionMethod) {
-            throw Error("Only Deflation compression is supported");
-          }
-          uncompressedFile = await compressionMethod(compressedFile);
-        } else {
-          uncompressedFile = await this.getFileWithoutHash(path);
-        }
-        return uncompressedFile;
+        return await this.readZipEntry(path) ?? null;
       }
     };
   }
 });
 
+// ../../modules/3d-tiles/src/3d-tiles-archive/3d-tiles-archive-parser.ts
+async function parse3DTilesArchive(fileProvider, callback, fileName, options) {
+  const archive = new Tiles3DArchive(fileProvider, void 0, fileName, options);
+  try {
+    if (!await archive.initializeIndex("@3dtilesIndex1@", false))
+      callback?.(
+        "3tz doesnt contain hash file, hash info has been composed according to zip archive headers"
+      );
+    return archive;
+  } catch (error) {
+    await archive.close();
+    throw error;
+  }
+}
+var init_d_tiles_archive_parser = __esm({
+  "../../modules/3d-tiles/src/3d-tiles-archive/3d-tiles-archive-parser.ts"() {
+    "use strict";
+    init_d_tiles_archive_archive();
+  }
+});
+
 // ../../modules/i3s/src/i3s-zod-schema.ts
 import { z as z3 } from "zod";
 var I3SObbSchema, I3SMeshMaterialSchema, I3SMeshGeometrySchema, I3SNodeInPageSchema, I3SNodePageSchema, I3SPointCloudNodeSchema, I3SPointCloudNodePageSchema, I3SSpatialReferenceSchema, I3SPointCloudStoreSchema, I3SPointCloudSceneLayerBaseSchema, I3SPointCloudNodePagesRequirementSchema, I3SPointCloudSceneLayerSchema, I3SGeometryBufferItemSchema, I3SGeometryBufferSchema, I3SGeometryDefinitionSchema, I3SSceneLayerSchema, I3SPointSceneLayerSchema;
@@ -30885,14 +30336,215 @@ var init_i3s_loader = __esm({
   }
 });
 
+// ../../modules/compression/src/lib/native-decompressor.ts
+var native_decompressor_exports = {};
+__export(native_decompressor_exports, {
+  NativeDecompressor: () => NativeDecompressor
+});
+var NativeDecompressor;
+var init_native_decompressor = __esm({
+  "../../modules/compression/src/lib/native-decompressor.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    NativeDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Decompresses one buffer with the runtime-provided stream. */
+      async decompress(input) {
+        const output = await decompressWithNativeDecompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        return output;
+      }
+      /** Decompresses batches incrementally with the runtime-provided stream. */
+      async *decompressBatches(inputBatches) {
+        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        yield* output;
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+var LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../../modules/compression/src/lib/lazy-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    LazyDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Constructor options retained until a concrete implementation is selected. */
+      options;
+      /** Built-in stream format to probe, or null when the format has no built-in path. */
+      nativeFormat;
+      /** Returns whether built-in selection remains eligible for the merged preload options. */
+      shouldUseNative;
+      /** Dynamically imports the balanced fallback constructor. */
+      loadFallback;
+      /** Selected concrete implementation after preload completes. */
+      implementation = null;
+      /** Shared in-flight selection used by concurrent asynchronous calls. */
+      implementationPromise = null;
+      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.options = options;
+        this.nativeFormat = nativeFormat;
+        this.shouldUseNative = shouldUseNative;
+        this.loadFallback = loadFallback;
+      }
+      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
+      async preload(modules = {}) {
+        if (this.implementation) return this.implementation;
+        const options = mergeModules(this.options, modules);
+        this.implementationPromise ||= this.loadImplementation(options);
+        try {
+          this.implementation = await this.implementationPromise;
+          return this.implementation;
+        } catch (error) {
+          this.implementationPromise = null;
+          throw error;
+        }
+      }
+      /** Loads the selected concrete decompressor. */
+      async loadImplementation(options) {
+        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
+          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
+          return new NativeDecompressor2(this, this.nativeFormat, options);
+        }
+        const Decompressor2 = await this.loadFallback();
+        const implementation = new Decompressor2({ ...options, useNative: false });
+        await implementation.preload(options.modules);
+        return implementation;
+      }
+      /** Decompresses after lazily selecting the default implementation. */
+      async decompress(input, size) {
+        return (await this.preload()).decompress(input, size);
+      }
+      /** Decompresses synchronously after an implementation has been preloaded. */
+      decompressSync(input, size) {
+        if (!this.implementation) {
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        }
+        return this.implementation.decompressSync(input, size);
+      }
+      /** Decompresses batches after lazily selecting the default implementation. */
+      async *decompressBatches(inputBatches) {
+        yield* (await this.preload()).decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/gzip-decompressor-compress-utils.ts
+var GZipCompressUtilsDecompressor;
+var init_gzip_decompressor_compress_utils = __esm({
+  "../../modules/compression/src/gzip-decompressor-compress-utils.ts"() {
+    "use strict";
+    init_compress_utils_compression();
+    GZipCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
+      constructor(options = {}) {
+        super(
+          { name: "gzip", extensions: ["gz", "gzip"], contentEncodings: ["gzip", "x-gzip"] },
+          () => import("compress-utils/gzip/decompress"),
+          options
+        );
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/gzip-decompressor.ts
+var gzip_decompressor_exports = {};
+__export(gzip_decompressor_exports, {
+  GZipDecompressor: () => GZipDecompressor
+});
+var GZipDecompressor;
+var init_gzip_decompressor = __esm({
+  "../../modules/compression/src/gzip-decompressor.ts"() {
+    "use strict";
+    init_gzip_decompressor_compress_utils();
+    init_decompression_stream();
+    GZipDecompressor = class extends GZipCompressUtilsDecompressor {
+      /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
+      async decompress(input, size) {
+        if (this.options.useNative !== false) {
+          const output = await decompressWithNativeDecompressionStream(input, "gzip");
+          if (output) return output;
+        }
+        return super.decompress(input, size);
+      }
+      /** Streams native batches when available, otherwise uses the WASM stream. */
+      async *decompressBatches(inputBatches) {
+        if (this.options.useNative !== false) {
+          const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "gzip");
+          if (output) {
+            yield* output;
+            return;
+          }
+        }
+        yield* super.decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/default-codecs.ts
+var GZIP, GZipDecompressor2;
+var init_default_codecs = __esm({
+  "../../modules/compression/src/default-codecs.ts"() {
+    "use strict";
+    init_lazy_compression();
+    GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
+    GZipDecompressor2 = class extends LazyDecompressor {
+      constructor(options = {}) {
+        super(
+          GZIP,
+          async () => (await Promise.resolve().then(() => (init_gzip_decompressor(), gzip_decompressor_exports))).GZipDecompressor,
+          options,
+          "gzip"
+        );
+      }
+    };
+  }
+});
+
+// ../../modules/compression/src/index.ts
+var init_src13 = __esm({
+  "../../modules/compression/src/index.ts"() {
+    "use strict";
+    init_default_codecs();
+  }
+});
+
 // ../../modules/i3s/src/lib/parsers/parse-slpk/slpk-archieve.ts
 var PATH_DESCRIPTIONS, SLPKArchive;
 var init_slpk_archieve = __esm({
   "../../modules/i3s/src/lib/parsers/parse-slpk/slpk-archieve.ts"() {
     "use strict";
-    init_src11();
-    init_src13();
     init_src12();
+    init_src13();
     PATH_DESCRIPTIONS = [
       {
         test: /^$/,
@@ -30932,20 +30584,14 @@ var init_slpk_archieve = __esm({
       }
     ];
     SLPKArchive = class extends IndexedArchive {
-      // Maps hex-encoded md5 filename hashes to bigint offsets into the archive
-      hashTable;
-      _textEncoder = new TextEncoder();
-      _textDecoder = new TextDecoder();
-      _md5Hash = new MD5Hash();
       /**
        * Constructor
        * @param fileProvider - readable file handle for random access
        * @param hashTable - pre-loaded hashTable. If presented, getFile will skip reading the hash file
        * @param fileName - name of the archive. It is used to add to an URL of a loader context
        */
-      constructor(fileProvider, hashTable, fileName) {
-        super(fileProvider, hashTable, fileName);
-        this.hashTable = hashTable;
+      constructor(fileProvider, hashTable, fileName, options) {
+        super(fileProvider, hashTable, fileName, options);
       }
       /**
        * Returns file with the given path from slpk archive
@@ -30990,7 +30636,7 @@ var init_slpk_archieve = __esm({
        * @returns buffer with the file data
        */
       async getDataByPath(path) {
-        let data = await this.getFileBytes(path.toLocaleLowerCase());
+        let data = await this.getFileBytes(path.toLowerCase());
         if (!data) {
           data = await this.getFileBytes(path);
         }
@@ -31010,68 +30656,29 @@ var init_slpk_archieve = __esm({
        * @returns buffer with the raw file data
        */
       async getFileBytes(path) {
-        let compressedFile;
-        if (this.hashTable) {
-          const binaryPath = this._textEncoder.encode(path);
-          const nameHash = await this._md5Hash.hash(binaryPath.buffer, "hex");
-          const offset = this.hashTable[nameHash];
-          if (offset === void 0) {
-            return void 0;
-          }
-          const localFileHeader = await parseZipLocalFileHeader(offset, this.file);
-          if (!localFileHeader) {
-            return void 0;
-          }
-          compressedFile = await readRange(
-            this.file,
-            localFileHeader.fileDataOffset,
-            localFileHeader.fileDataOffset + localFileHeader.compressedSize
-          );
-        } else {
-          try {
-            compressedFile = await this.getFileWithoutHash(path);
-          } catch {
-            compressedFile = void 0;
-          }
-        }
-        return compressedFile;
+        return await this.readZipEntry(path);
       }
     };
   }
 });
 
 // ../../modules/i3s/src/lib/parsers/parse-slpk/parse-slpk.ts
-async function parseSLPKArchive(fileProvider, cb, fileName) {
-  const hashCDOffset = await searchFromTheEnd(fileProvider, signature2);
-  const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
-  let hashTable;
-  if (cdFileHeader?.fileName !== "@specialIndexFileHASH128@") {
-    hashTable = await makeHashTableFromZipHeaders(fileProvider);
-    cb?.(
-      "SLPK doesnt contain hash file, hash info has been composed according to zip archive headers"
-    );
-  } else {
-    const localFileHeader = await parseZipLocalFileHeader(
-      cdFileHeader.localHeaderOffset,
-      fileProvider
-    );
-    if (!localFileHeader) {
-      throw new Error("corrupted SLPK");
-    }
-    const fileDataOffset = localFileHeader.fileDataOffset;
-    const hashFile = await readRange(
-      fileProvider,
-      fileDataOffset,
-      fileDataOffset + localFileHeader.compressedSize
-    );
-    hashTable = parseHashTable(hashFile);
+async function parseSLPKArchive(fileProvider, callback, fileName, options) {
+  const archive = new SLPKArchive(fileProvider, void 0, fileName, options);
+  try {
+    if (!await archive.initializeIndex("@specialIndexFileHASH128@", true))
+      callback?.(
+        "SLPK doesnt contain hash file, hash info has been composed according to zip archive headers"
+      );
+    return archive;
+  } catch (error) {
+    await archive.close();
+    throw error;
   }
-  return new SLPKArchive(fileProvider, hashTable, fileName);
 }
 var init_parse_slpk = __esm({
   "../../modules/i3s/src/lib/parsers/parse-slpk/parse-slpk.ts"() {
     "use strict";
-    init_src13();
     init_slpk_archieve();
   }
 });
@@ -31980,7 +31587,7 @@ function encodeSync3(tile, options) {
 
 // ../../modules/3d-tiles/src/index.ts
 init_constants();
-init_d_tiles_archive_archive();
+init_d_tiles_archive_parser();
 
 // src/v4/i3s-converter/i3s-converter.ts
 import { join as join8 } from "path";
@@ -32058,8 +31665,8 @@ async function writeFile(path, data, fileName = "index.json") {
   const pathFile = join2(path, fileName);
   try {
     await fs.writeFile(pathFile, toWriteData);
-  } catch (err2) {
-    throw err2;
+  } catch (err) {
+    throw err;
   }
   console.log(`${pathFile} saved.`);
   return pathFile;
@@ -32119,8 +31726,8 @@ function getAbsoluteFilePath(filePath) {
 async function renameFile(oldPath, newPath) {
   try {
     await fs.rename(oldPath, newPath);
-  } catch (err2) {
-    console.log("Can't rename file", err2);
+  } catch (err) {
+    console.log("Can't rename file", err);
   }
 }
 
@@ -34286,7 +33893,8 @@ var STORE = {
   },
   normalReferenceFrame: {
     path: "normalReferenceFrame",
-    default: "east-north-up"
+    // Geometry conversion rotates normals into the ECEF frame.
+    default: "earth-centered"
   },
   attributeEncoding: {
     path: "attributeEncoding",
@@ -35103,7 +34711,7 @@ var NodeIndexDocument = class _NodeIndexDocument {
     }
   }
   /**
-   * Add neighbors to child nodes of this node
+   * Add neighbors, save leaf documents and children, then release finalized child data.
    */
   async addNeighbors() {
     if (this.finalized) {
@@ -35131,6 +34739,9 @@ var NodeIndexDocument = class _NodeIndexDocument {
       }
       await childNode.save();
     }
+    if (!this.children.length) {
+      await this.save();
+    }
     this.finalize();
   }
   /** Save 3DNodeIndexDocument in file on disk */
@@ -35303,7 +34914,7 @@ var NodeIndexDocument = class _NodeIndexDocument {
 // src/v4/i3s-converter/helpers/load-3d-tiles.ts
 init_src5();
 init_src2();
-init_src13();
+init_src12();
 var loadNestedTileset = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
   const isTileset = isNestedTileset(sourceTile);
   if (!sourceTileset || !sourceTile.contentUrl || !isTileset) {
@@ -35362,8 +34973,7 @@ async function loadFromArchive(url, loader, loadOptions) {
   if (filename2) {
     const tz3Path = `${tz3UrlParts[0]}.3tz`;
     const fileProvider = createReadableFile(tz3Path);
-    const hashTable = await loadHashTable(fileProvider);
-    const archive = new Tiles3DArchive(fileProvider, hashTable, tz3Path);
+    const archive = await parse3DTilesArchive(fileProvider, void 0, tz3Path);
     const fileSystem = new ZipFileSystem(archive);
     const archiveLoadOptions = {
       ...loadOptions,
@@ -35384,28 +34994,6 @@ function createReadableFile(path) {
   }
   return isBrowser ? new HttpFile(path) : new NodeFileFacade(path);
 }
-async function loadHashTable(fileProvider) {
-  let hashTable;
-  const hashCDOffset = await searchFromTheEnd(fileProvider, signature2);
-  const cdFileHeader = await parseZipCDFileHeader(hashCDOffset, fileProvider);
-  if (cdFileHeader?.fileName === "@3dtilesIndex1@") {
-    const localFileHeader = await parseZipLocalFileHeader(
-      cdFileHeader.localHeaderOffset,
-      fileProvider
-    );
-    if (!localFileHeader) {
-      throw new Error("corrupted 3tz");
-    }
-    const fileDataOffset = localFileHeader.fileDataOffset;
-    const hashFile = await readRange(
-      fileProvider,
-      fileDataOffset,
-      fileDataOffset + localFileHeader.compressedSize
-    );
-    hashTable = parseHashTable(hashFile);
-  }
-  return hashTable;
-}
 
 // src/v4/i3s-converter/i3s-converter.ts
 init_src10();
@@ -35469,7 +35057,7 @@ var analyzeTileContent = async (tileContent) => {
     return defaultResult;
   }
   const gltfData = await parse(tileContent.gltfArrayBuffer, GLTFLoader, {
-    gltf: { normalize: false, loadBuffers: false, loadImages: false, decompressMeshes: false }
+    gltf: { normalize: true, loadBuffers: false, loadImages: false, decompressMeshes: false }
   });
   const gltf = gltfData.json;
   if (!gltf) {
@@ -35663,7 +35251,7 @@ var Progress = class {
 };
 
 // src/v4/i3s-converter/i3s-converter.ts
-init_src13();
+init_src12();
 
 // src/v4/lib/utils/conversion-dump.ts
 import { isDeepStrictEqual } from "util";
@@ -38077,7 +37665,7 @@ var Tiles3DContentConverter = class {
 // src/v4/3d-tiles-converter/helpers/load-i3s.ts
 init_src5();
 init_src2();
-init_src13();
+init_src12();
 var loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions, slpkFilesystem) => {
   if (!sourceTileset || !sourceTile.contentUrl) {
     return null;
@@ -38142,9 +37730,7 @@ async function getNodeCount(fileSystem) {
     return 0;
   }
   const nodeSet = /* @__PURE__ */ new Set();
-  const filesIterator = makeZipCDHeaderIterator(fileSystem.file);
-  for await (const file of filesIterator) {
-    const filename2 = file.fileName;
+  for (const filename2 of await fileSystem.readdir()) {
     const nodeNumberSearchResult = /^nodes\/(\d+)\//.exec(filename2);
     if (nodeNumberSearchResult) {
       nodeSet.add(nodeNumberSearchResult[1]);