@loaders.gl/zip 4.0.4 → 4.1.0-alpha.10

package/dist/hash-file-utility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash-file-utility.d.ts","sourceRoot":"","sources":["../src/hash-file-utility.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAGtD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAY/E;AASD;;;;GAIG;AACH,wBAAsB,2BAA2B,CAC/C,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAejC"}
+{"version":3,"file":"hash-file-utility.d.ts","sourceRoot":"","sources":["../src/hash-file-utility.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,YAAY,EAGb,MAAM,0BAA0B,CAAC;AAGlC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAY/E;AASD;;;;GAIG;AACH,wBAAsB,2BAA2B,CAC/C,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAejC;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAMtF"}

package/dist/hash-file-utility.js

@@ -1,4 +1,5 @@
 import { MD5Hash } from '@loaders.gl/crypto';
+import { concatenateArrayBuffers, concatenateArrayBuffersFromArray } from '@loaders.gl/loader-utils';
 import { makeZipCDHeaderIterator } from "./parse-zip/cd-file-header.js";
 export function parseHashTable(arrayBuffer) {
   const dataView = new DataView(arrayBuffer);
@@ -26,4 +27,25 @@ export async function makeHashTableFromZipHeaders(fileProvider) {
   }
   return hashTable;
 }
+export async function composeHashFile(fileProvider) {
+  const hashArray = await makeHashTableFromZipHeaders(fileProvider);
+  const bufferArray = Object.entries(hashArray).map(_ref => {
+    let [key, value] = _ref;
+    return concatenateArrayBuffers(hexStringToBuffer(key), bigintToBuffer(value));
+  }).sort(compareHashes);
+  return concatenateArrayBuffersFromArray(bufferArray);
+}
+function compareHashes(arrA, arrB) {
+  const a = new BigUint64Array(arrA);
+  const b = new BigUint64Array(arrB);
+  return Number(a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+}
+function hexStringToBuffer(str) {
+  var _str$match;
+  const byteArray = (_str$match = str.match(/../g)) === null || _str$match === void 0 ? void 0 : _str$match.map(h => parseInt(h, 16));
+  return new Uint8Array(byteArray !== null && byteArray !== void 0 ? byteArray : new Array(16)).buffer;
+}
+function bigintToBuffer(n) {
+  return new BigUint64Array([n]).buffer;
+}
 //# sourceMappingURL=hash-file-utility.js.map

package/dist/hash-file-utility.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash-file-utility.js","names":["MD5Hash","makeZipCDHeaderIterator","parseHashTable","arrayBuffer","dataView","DataView","hashMap","i","byteLength","offset","getBigUint64","hash","bufferToHex","buffer","start","length","Uint8Array","map","x","toString","padStart","join","makeHashTableFromZipHeaders","fileProvider","zipCDIterator","md5Hash","textEncoder","TextEncoder","hashTable","cdHeader","filename","fileName","split","toLocaleLowerCase","encode","md5","localHeaderOffset"],"sources":["../src/hash-file-utility.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {MD5Hash} from '@loaders.gl/crypto';\nimport {FileProvider} from '@loaders.gl/loader-utils';\nimport {makeZipCDHeaderIterator} from './parse-zip/cd-file-header';\n\n/**\n * Reads hash file from buffer and returns it in ready-to-use form\n * @param arrayBuffer - buffer containing hash file\n * @returns Map containing hash and offset\n */\nexport function parseHashTable(arrayBuffer: ArrayBuffer): Record<string, bigint> {\n  const dataView = new DataView(arrayBuffer);\n\n  const hashMap: Record<string, bigint> = {};\n\n  for (let i = 0; i < arrayBuffer.byteLength; i = i + 24) {\n    const offset = dataView.getBigUint64(i + 16, true);\n    const hash = bufferToHex(arrayBuffer, i, 16);\n    hashMap[hash] = offset;\n  }\n\n  return hashMap;\n}\n\nfunction bufferToHex(buffer: ArrayBuffer, start: number, length: number): string {\n  // buffer is an ArrayBuffer\n  return [...new Uint8Array(buffer, start, length)]\n    .map((x) => x.toString(16).padStart(2, '0'))\n    .join('');\n}\n\n/**\n * generates hash info from zip files \"central directory\"\n * @param fileProvider - provider of the archive\n * @returns ready to use hash info\n */\nexport async function makeHashTableFromZipHeaders(\n  fileProvider: FileProvider\n): Promise<Record<string, bigint>> {\n  const zipCDIterator = makeZipCDHeaderIterator(fileProvider);\n  const md5Hash = new MD5Hash();\n  const textEncoder = new TextEncoder();\n\n  const hashTable: Record<string, bigint> = {};\n\n  for await (const cdHeader of zipCDIterator) {\n    const filename = cdHeader.fileName.split('\\\\').join('/').toLocaleLowerCase();\n    const arrayBuffer = textEncoder.encode(filename).buffer;\n    const md5 = await md5Hash.hash(arrayBuffer, 'hex');\n    hashTable[md5] = cdHeader.localHeaderOffset;\n  }\n\n  return hashTable;\n}\n"],"mappings":"AAGA,SAAQA,OAAO,QAAO,oBAAoB;AAAC,SAEnCC,uBAAuB;AAO/B,OAAO,SAASC,cAAcA,CAACC,WAAwB,EAA0B;EAC/E,MAAMC,QAAQ,GAAG,IAAIC,QAAQ,CAACF,WAAW,CAAC;EAE1C,MAAMG,OAA+B,GAAG,CAAC,CAAC;EAE1C,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGJ,WAAW,CAACK,UAAU,EAAED,CAAC,GAAGA,CAAC,GAAG,EAAE,EAAE;IACtD,MAAME,MAAM,GAAGL,QAAQ,CAACM,YAAY,CAACH,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC;IAClD,MAAMI,IAAI,GAAGC,WAAW,CAACT,WAAW,EAAEI,CAAC,EAAE,EAAE,CAAC;IAC5CD,OAAO,CAACK,IAAI,CAAC,GAAGF,MAAM;EACxB;EAEA,OAAOH,OAAO;AAChB;AAEA,SAASM,WAAWA,CAACC,MAAmB,EAAEC,KAAa,EAAEC,MAAc,EAAU;EAE/E,OAAO,CAAC,GAAG,IAAIC,UAAU,CAACH,MAAM,EAAEC,KAAK,EAAEC,MAAM,CAAC,CAAC,CAC9CE,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAACC,QAAQ,CAAC,EAAE,CAAC,CAACC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAC3CC,IAAI,CAAC,EAAE,CAAC;AACb;AAOA,OAAO,eAAeC,2BAA2BA,CAC/CC,YAA0B,EACO;EACjC,MAAMC,aAAa,GAAGvB,uBAAuB,CAACsB,YAAY,CAAC;EAC3D,MAAME,OAAO,GAAG,IAAIzB,OAAO,CAAC,CAAC;EAC7B,MAAM0B,WAAW,GAAG,IAAIC,WAAW,CAAC,CAAC;EAErC,MAAMC,SAAiC,GAAG,CAAC,CAAC;EAE5C,WAAW,MAAMC,QAAQ,IAAIL,aAAa,EAAE;IAC1C,MAAMM,QAAQ,GAAGD,QAAQ,CAACE,QAAQ,CAACC,KAAK,CAAC,IAAI,CAAC,CAACX,IAAI,CAAC,GAAG,CAAC,CAACY,iBAAiB,CAAC,CAAC;IAC5E,MAAM9B,WAAW,GAAGuB,WAAW,CAACQ,MAAM,CAACJ,QAAQ,CAAC,CAACjB,MAAM;IACvD,MAAMsB,GAAG,GAAG,MAAMV,OAAO,CAACd,IAAI,CAACR,WAAW,EAAE,KAAK,CAAC;IAClDyB,SAAS,CAACO,GAAG,CAAC,GAAGN,QAAQ,CAACO,iBAAiB;EAC7C;EAEA,OAAOR,SAAS;AAClB"}
+{"version":3,"file":"hash-file-utility.js","names":["MD5Hash","concatenateArrayBuffers","concatenateArrayBuffersFromArray","makeZipCDHeaderIterator","parseHashTable","arrayBuffer","dataView","DataView","hashMap","i","byteLength","offset","getBigUint64","hash","bufferToHex","buffer","start","length","Uint8Array","map","x","toString","padStart","join","makeHashTableFromZipHeaders","fileProvider","zipCDIterator","md5Hash","textEncoder","TextEncoder","hashTable","cdHeader","filename","fileName","split","toLocaleLowerCase","encode","md5","localHeaderOffset","composeHashFile","hashArray","bufferArray","Object","entries","_ref","key","value","hexStringToBuffer","bigintToBuffer","sort","compareHashes","arrA","arrB","a","BigUint64Array","b","Number","str","_str$match","byteArray","match","h","parseInt","Array","n"],"sources":["../src/hash-file-utility.ts"],"sourcesContent":["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {MD5Hash} from '@loaders.gl/crypto';\nimport {\n  FileProvider,\n  concatenateArrayBuffers,\n  concatenateArrayBuffersFromArray\n} from '@loaders.gl/loader-utils';\nimport {makeZipCDHeaderIterator} from './parse-zip/cd-file-header';\n\n/**\n * Reads hash file from buffer and returns it in ready-to-use form\n * @param arrayBuffer - buffer containing hash file\n * @returns Map containing hash and offset\n */\nexport function parseHashTable(arrayBuffer: ArrayBuffer): Record<string, bigint> {\n  const dataView = new DataView(arrayBuffer);\n\n  const hashMap: Record<string, bigint> = {};\n\n  for (let i = 0; i < arrayBuffer.byteLength; i = i + 24) {\n    const offset = dataView.getBigUint64(i + 16, true);\n    const hash = bufferToHex(arrayBuffer, i, 16);\n    hashMap[hash] = offset;\n  }\n\n  return hashMap;\n}\n\nfunction bufferToHex(buffer: ArrayBuffer, start: number, length: number): string {\n  // buffer is an ArrayBuffer\n  return [...new Uint8Array(buffer, start, length)]\n    .map((x) => x.toString(16).padStart(2, '0'))\n    .join('');\n}\n\n/**\n * generates hash info from zip files \"central directory\"\n * @param fileProvider - provider of the archive\n * @returns ready to use hash info\n */\nexport async function makeHashTableFromZipHeaders(\n  fileProvider: FileProvider\n): Promise<Record<string, bigint>> {\n  const zipCDIterator = makeZipCDHeaderIterator(fileProvider);\n  const md5Hash = new MD5Hash();\n  const textEncoder = new TextEncoder();\n\n  const hashTable: Record<string, bigint> = {};\n\n  for await (const cdHeader of zipCDIterator) {\n    const filename = cdHeader.fileName.split('\\\\').join('/').toLocaleLowerCase();\n    const arrayBuffer = textEncoder.encode(filename).buffer;\n    const md5 = await md5Hash.hash(arrayBuffer, 'hex');\n    hashTable[md5] = cdHeader.localHeaderOffset;\n  }\n\n  return hashTable;\n}\n\n/**\n * creates hash file that later can be added to the SLPK archive\n * @param fileProvider SLPK archive where we need to add hash file\n * @returns ArrayBuffer containing hash file\n */\nexport async function composeHashFile(fileProvider: FileProvider): Promise<ArrayBuffer> {\n  const hashArray = await makeHashTableFromZipHeaders(fileProvider);\n  const bufferArray = Object.entries(hashArray)\n    .map(([key, value]) => concatenateArrayBuffers(hexStringToBuffer(key), bigintToBuffer(value)))\n    .sort(compareHashes);\n  return concatenateArrayBuffersFromArray(bufferArray);\n}\n\n/**\n * Function to compare md5 hashes according to https://github.com/Esri/i3s-spec/blob/master/docs/2.0/slpk_hashtable.pcsl.md\n * @param arrA first hash to compare\n * @param arrB second hash to compare\n * @returns 0 if equal, negative number if a<b, pozitive if a>b\n */\nfunction compareHashes(arrA: ArrayBuffer, arrB: ArrayBuffer): number {\n  const a = new BigUint64Array(arrA);\n  const b = new BigUint64Array(arrB);\n\n  return Number(a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);\n}\n\n/**\n * converts hex string to buffer\n * @param str hex string to convert\n * @returns conversion result\n */\nfunction hexStringToBuffer(str: string): ArrayBuffer {\n  const byteArray = str.match(/../g)?.map((h) => parseInt(h, 16));\n  return new Uint8Array(byteArray ?? new Array(16)).buffer;\n}\n\n/**\n * converts bigint to buffer\n * @param n bigint to convert\n * @returns convertion result\n */\nfunction bigintToBuffer(n: bigint): ArrayBuffer {\n  return new BigUint64Array([n]).buffer;\n}\n"],"mappings":"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"}

package/dist/index.cjs

@@ -30,12 +30,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  CD_HEADER_SIGNATURE: () => signature2,
   TarBuilder: () => TarBuilder,
   ZipFileSystem: () => ZipFileSystem,
   ZipLoader: () => ZipLoader,
   ZipWriter: () => ZipWriter,
-  cdSignature: () => signature,
-  localHeaderSignature: () => signature2,
+  addOneFile: () => addOneFile,
+  composeHashFile: () => composeHashFile,
+  generateCDHeader: () => generateCDHeader,
+  generateLocalHeader: () => generateLocalHeader,
+  localHeaderSignature: () => signature3,
   makeHashTableFromZipHeaders: () => makeHashTableFromZipHeaders,
   makeZipCDHeaderIterator: () => makeZipCDHeaderIterator,
   parseEoCDRecord: () => parseEoCDRecord,
@@ -93,27 +97,41 @@ async function loadZipEntry(jsZip, subFilename, options = {}) {
 
 // src/zip-writer.ts
 var import_jszip2 = __toESM(require("jszip"), 1);
+var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 var ZipWriter = {
   name: "Zip Archive",
+  id: "zip",
+  module: "zip",
+  version: VERSION2,
   extensions: ["zip"],
   category: "archive",
   mimeTypes: ["application/zip"],
-  // @ts-ignore
+  options: {
+    zip: {
+      onUpdate: () => {
+      }
+    },
+    jszip: {}
+  },
   encode: encodeZipAsync
 };
 async function encodeZipAsync(fileMap, options = {}) {
+  var _a;
   const jsZip = new import_jszip2.default();
   for (const subFileName in fileMap) {
     const subFileData = fileMap[subFileName];
     jsZip.file(subFileName, subFileData, (options == null ? void 0 : options.jszip) || {});
   }
-  const jszipOptions = { ...options == null ? void 0 : options.jszip, type: "arraybuffer" };
-  const { onUpdate = () => {
-  } } = options;
+  const zipOptions = { ...ZipWriter.options.zip, ...options == null ? void 0 : options.zip };
+  const jszipOptions = { ...(_a = ZipWriter.options) == null ? void 0 : _a.jszip, ...options.jszip };
   try {
-    return await jsZip.generateAsync(jszipOptions, onUpdate);
+    return await jsZip.generateAsync(
+      { ...jszipOptions, type: "arraybuffer" },
+      // generate an arraybuffer
+      zipOptions.onUpdate
+    );
   } catch (error) {
-    options.log.error(`Unable to write zip archive: ${error}`);
+    options.log.error(`Unable to encode zip archive: ${error}`);
     throw error;
   }
 }
@@ -334,10 +352,10 @@ var TarBuilder = class {
 };
 
 // src/parse-zip/cd-file-header.ts
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
 
 // src/parse-zip/end-of-central-directory.ts
-var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
 
 // src/parse-zip/search-from-the-end.ts
 var searchFromTheEnd = async (file, target) => {
@@ -361,40 +379,143 @@ var searchFromTheEnd = async (file, target) => {
   return targetOffset;
 };
 
+// src/parse-zip/zip64-info-generation.ts
+var import_loader_utils = require("@loaders.gl/loader-utils");
+var signature = new Uint8Array([1, 0]);
+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 (0, import_loader_utils.concatenateArrayBuffers)(...arraysToConcat);
+}
+function setFieldToNumber(header, fieldSize, fieldOffset, value) {
+  NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);
+}
+var NUMBER_SETTERS = {
+  2: (header, offset, value) => {
+    header.setUint16(offset, Number(value), true);
+  },
+  4: (header, offset, value) => {
+    header.setUint32(offset, Number(value), true);
+  },
+  8: (header, offset, value) => {
+    header.setBigUint64(offset, BigInt(value), true);
+  }
+};
+var 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"
+  }
+];
+
 // src/parse-zip/end-of-central-directory.ts
 var eoCDSignature = new Uint8Array([80, 75, 5, 6]);
 var zip64EoCDLocatorSignature = new Uint8Array([80, 75, 6, 7]);
 var zip64EoCDSignature = new Uint8Array([80, 75, 6, 6]);
 var CD_RECORDS_NUMBER_OFFSET = 8n;
+var CD_RECORDS_NUMBER_ON_DISC_OFFSET = 10n;
+var CD_CD_BYTE_SIZE_OFFSET = 12n;
 var CD_START_OFFSET_OFFSET = 16n;
 var ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
 var ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+var ZIP64_CD_RECORDS_NUMBER_ON_DISC_OFFSET = 32n;
+var ZIP64_CD_CD_BYTE_SIZE_OFFSET = 40n;
 var ZIP64_CD_START_OFFSET_OFFSET = 48n;
 var parseEoCDRecord = async (file) => {
   const zipEoCDOffset = await searchFromTheEnd(file, eoCDSignature);
   let cdRecordsNumber = BigInt(await file.getUint16(zipEoCDOffset + CD_RECORDS_NUMBER_OFFSET));
   let cdStartOffset = BigInt(await file.getUint32(zipEoCDOffset + CD_START_OFFSET_OFFSET));
-  if (cdStartOffset === BigInt(4294967295) || cdRecordsNumber === BigInt(4294967295)) {
-    const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
-    const magicBytes = await file.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
-    if (!(0, import_loader_utils.compareArrayBuffers)(magicBytes, zip64EoCDLocatorSignature)) {
-      throw new Error("zip64 EoCD locator not found");
-    }
-    const zip64EoCDOffset = await file.getBigUint64(
+  let zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+  let zip64EoCDOffset = 0n;
+  const magicBytes = await file.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
+  if ((0, import_loader_utils2.compareArrayBuffers)(magicBytes, zip64EoCDLocatorSignature)) {
+    zip64EoCDOffset = await file.getBigUint64(
       zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
     );
     const endOfCDMagicBytes = await file.slice(zip64EoCDOffset, zip64EoCDOffset + 4n);
-    if (!(0, import_loader_utils.compareArrayBuffers)(endOfCDMagicBytes, zip64EoCDSignature.buffer)) {
+    if (!(0, import_loader_utils2.compareArrayBuffers)(endOfCDMagicBytes, zip64EoCDSignature.buffer)) {
       throw new Error("zip64 EoCD not found");
     }
     cdRecordsNumber = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_RECORDS_NUMBER_OFFSET);
     cdStartOffset = await file.getBigUint64(zip64EoCDOffset + ZIP64_CD_START_OFFSET_OFFSET);
+  } else {
+    zip64EoCDLocatorOffset = 0n;
   }
   return {
     cdRecordsNumber,
-    cdStartOffset
+    cdStartOffset,
+    offsets: {
+      zip64EoCDOffset,
+      zip64EoCDLocatorOffset,
+      zipEoCDOffset
+    }
   };
 };
+async function updateEoCD(eocdBody, oldEoCDOffsets, newCDStartOffset, eocdStartOffset, newCDRecordsNumber) {
+  const eocd = new DataView(eocdBody);
+  const classicEoCDOffset = oldEoCDOffsets.zip64EoCDOffset ? oldEoCDOffsets.zipEoCDOffset - oldEoCDOffsets.zip64EoCDOffset : 0n;
+  if (Number(newCDRecordsNumber) <= 65535) {
+    setFieldToNumber(eocd, 2, classicEoCDOffset + CD_RECORDS_NUMBER_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(
+      eocd,
+      2,
+      classicEoCDOffset + CD_RECORDS_NUMBER_ON_DISC_OFFSET,
+      newCDRecordsNumber
+    );
+  }
+  if (eocdStartOffset - newCDStartOffset <= 4294967295) {
+    setFieldToNumber(
+      eocd,
+      4,
+      classicEoCDOffset + CD_CD_BYTE_SIZE_OFFSET,
+      eocdStartOffset - newCDStartOffset
+    );
+  }
+  if (newCDStartOffset < 4294967295) {
+    setFieldToNumber(eocd, 4, classicEoCDOffset + CD_START_OFFSET_OFFSET, newCDStartOffset);
+  }
+  if (oldEoCDOffsets.zip64EoCDLocatorOffset && oldEoCDOffsets.zip64EoCDOffset) {
+    const locatorOffset = oldEoCDOffsets.zip64EoCDLocatorOffset - oldEoCDOffsets.zip64EoCDOffset;
+    setFieldToNumber(eocd, 8, locatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET, eocdStartOffset);
+    setFieldToNumber(eocd, 8, ZIP64_CD_START_OFFSET_OFFSET, newCDStartOffset);
+    setFieldToNumber(eocd, 8, ZIP64_CD_RECORDS_NUMBER_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(eocd, 8, ZIP64_CD_RECORDS_NUMBER_ON_DISC_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(eocd, 8, ZIP64_CD_CD_BYTE_SIZE_OFFSET, eocdStartOffset - newCDStartOffset);
+  }
+  return new Uint8Array(eocd.buffer);
+}
 
 // src/parse-zip/cd-file-header.ts
 var CD_COMPRESSED_SIZE_OFFSET = 20n;
@@ -404,10 +525,10 @@ var CD_EXTRA_FIELD_LENGTH_OFFSET = 30n;
 var CD_START_DISK_OFFSET = 32n;
 var CD_LOCAL_HEADER_OFFSET_OFFSET = 42n;
 var CD_FILE_NAME_OFFSET = 46n;
-var signature = new Uint8Array([80, 75, 1, 2]);
+var signature2 = new Uint8Array([80, 75, 1, 2]);
 var parseZipCDFileHeader = async (headerOffset, file) => {
   const magicBytes = await file.slice(headerOffset, headerOffset + 4n);
-  if (!(0, import_loader_utils2.compareArrayBuffers)(magicBytes, signature.buffer)) {
+  if (!(0, import_loader_utils3.compareArrayBuffers)(magicBytes, signature2.buffer)) {
     return null;
   }
   const compressedSize = BigInt(await file.getUint32(headerOffset + CD_COMPRESSED_SIZE_OFFSET));
@@ -489,19 +610,157 @@ var findExpectedData = (zip64data) => {
   }
   return zip64dataList;
 };
+function generateCDHeader(options) {
+  const optionsToUse = {
+    ...options,
+    fnlength: options.fileName.length,
+    extraLength: 0
+  };
+  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 = (0, import_loader_utils3.concatenateArrayBuffers)(header.buffer, encodedName, zip64header);
+  return resHeader;
+}
+var 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"
+  }
+];
 
 // src/parse-zip/local-file-header.ts
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 var COMPRESSION_METHOD_OFFSET = 8n;
 var COMPRESSED_SIZE_OFFSET = 18n;
 var UNCOMPRESSED_SIZE_OFFSET = 22n;
 var FILE_NAME_LENGTH_OFFSET = 26n;
 var EXTRA_FIELD_LENGTH_OFFSET = 28n;
 var FILE_NAME_OFFSET = 30n;
-var signature2 = new Uint8Array([80, 75, 3, 4]);
+var signature3 = new Uint8Array([80, 75, 3, 4]);
 var parseZipLocalFileHeader = async (headerOffset, buffer) => {
   const magicBytes = await buffer.slice(headerOffset, headerOffset + 4n);
-  if (!(0, import_loader_utils3.compareArrayBuffers)(magicBytes, signature2)) {
+  if (!(0, import_loader_utils4.compareArrayBuffers)(magicBytes, signature3)) {
     return null;
   }
   const fileNameLength = await buffer.getUint16(headerOffset + FILE_NAME_LENGTH_OFFSET);
@@ -538,9 +797,162 @@ var parseZipLocalFileHeader = async (headerOffset, buffer) => {
     compressionMethod
   };
 };
+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 = (0, import_loader_utils4.concatenateArrayBuffers)(header.buffer, encodedName, zip64header);
+  return resHeader;
+}
+var 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"
+  }
+];
 
-// src/hash-file-utility.ts
+// src/parse-zip/zip-compozition.ts
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
 var import_crypto = require("@loaders.gl/crypto");
+async function cutTheTailOff(provider) {
+  const oldEoCDinfo = await parseEoCDRecord(provider);
+  const oldCDStartOffset = oldEoCDinfo.cdStartOffset;
+  const oldCDLength = Number(
+    oldEoCDinfo.offsets.zip64EoCDOffset ? oldEoCDinfo.offsets.zip64EoCDOffset - oldCDStartOffset : oldEoCDinfo.offsets.zipEoCDOffset - oldCDStartOffset
+  );
+  const zipEnding = await provider.slice(oldCDStartOffset, provider.length);
+  await provider.truncate(Number(oldCDStartOffset));
+  const oldCDBody = zipEnding.slice(0, oldCDLength);
+  const eocdBody = zipEnding.slice(oldCDLength, zipEnding.byteLength);
+  return [oldCDBody, eocdBody, oldEoCDinfo];
+}
+async function generateFileHeaders(fileName, fileToAdd, localFileHeaderOffset) {
+  const newFileCRC322 = parseInt(await new import_crypto.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((0, import_loader_utils5.concatenateArrayBuffers)(newFileLocalHeader, fileToAdd)),
+    new Uint8Array(newFileCDHeader)
+  ];
+}
+async function addOneFile(zipUrl, fileToAdd, fileName) {
+  const provider = new import_loader_utils5.FileHandleFile(zipUrl, true);
+  const [oldCDBody, eocdBody, oldEoCDinfo] = await cutTheTailOff(provider);
+  const newFileOffset = provider.length;
+  const [localPart, cdHeaderPart] = await generateFileHeaders(fileName, fileToAdd, newFileOffset);
+  await provider.append(localPart);
+  const newCDBody = (0, import_loader_utils5.concatenateArrayBuffers)(oldCDBody, cdHeaderPart);
+  const newCDStartOffset = provider.length;
+  await provider.append(new Uint8Array(newCDBody));
+  const eocdOffset = provider.length;
+  await provider.append(
+    await updateEoCD(
+      eocdBody,
+      oldEoCDinfo.offsets,
+      newCDStartOffset,
+      eocdOffset,
+      oldEoCDinfo.cdRecordsNumber + 1n
+    )
+  );
+}
+
+// src/hash-file-utility.ts
+var import_crypto2 = require("@loaders.gl/crypto");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
 function parseHashTable(arrayBuffer) {
   const dataView = new DataView(arrayBuffer);
   const hashMap = {};
@@ -556,7 +968,7 @@ function bufferToHex(buffer, start, length) {
 }
 async function makeHashTableFromZipHeaders(fileProvider) {
   const zipCDIterator = makeZipCDHeaderIterator(fileProvider);
-  const md5Hash = new import_crypto.MD5Hash();
+  const md5Hash = new import_crypto2.MD5Hash();
   const textEncoder = new TextEncoder();
   const hashTable = {};
   for await (const cdHeader of zipCDIterator) {
@@ -567,11 +979,29 @@ async function makeHashTableFromZipHeaders(fileProvider) {
   }
   return hashTable;
 }
+async function composeHashFile(fileProvider) {
+  const hashArray = await makeHashTableFromZipHeaders(fileProvider);
+  const bufferArray = Object.entries(hashArray).map(([key, value]) => (0, import_loader_utils6.concatenateArrayBuffers)(hexStringToBuffer(key), bigintToBuffer(value))).sort(compareHashes);
+  return (0, import_loader_utils6.concatenateArrayBuffersFromArray)(bufferArray);
+}
+function compareHashes(arrA, arrB) {
+  const a = new BigUint64Array(arrA);
+  const b = new BigUint64Array(arrB);
+  return Number(a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+}
+function hexStringToBuffer(str) {
+  var _a;
+  const byteArray = (_a = str.match(/../g)) == null ? void 0 : _a.map((h) => parseInt(h, 16));
+  return new Uint8Array(byteArray ?? new Array(16)).buffer;
+}
+function bigintToBuffer(n) {
+  return new BigUint64Array([n]).buffer;
+}
 
 // src/filesystems/zip-filesystem.ts
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
+var import_loader_utils7 = require("@loaders.gl/loader-utils");
+var import_loader_utils8 = require("@loaders.gl/loader-utils");
+var import_loader_utils9 = require("@loaders.gl/loader-utils");
 var import_compression = require("@loaders.gl/compression");
 var COMPRESSION_METHODS = {
   /** No compression */
@@ -593,12 +1023,12 @@ var ZipFileSystem = class {
     this.fileProvider = null;
     if (typeof file === "string") {
       this.fileName = file;
-      if (!import_loader_utils4.isBrowser) {
-        this.fileProvider = new import_loader_utils6.FileHandleFile(file);
+      if (!import_loader_utils7.isBrowser) {
+        this.fileProvider = new import_loader_utils9.FileHandleFile(file);
       } else {
         throw new Error("Cannot open file for random access in a WEB browser");
       }
-    } else if ((0, import_loader_utils5.isFileProvider)(file)) {
+    } else if ((0, import_loader_utils8.isFileProvider)(file)) {
       this.fileProvider = file;
     }
   }