@loaders.gl/zip 4.1.0-alpha.3 → 4.1.0-alpha.5

package/dist/parse-zip/zip-compozition.js

@@ -0,0 +1,43 @@
+import { FileHandleFile, concatenateArrayBuffers } from '@loaders.gl/loader-utils';
+import { parseEoCDRecord, updateEoCD } from "./end-of-central-directory.js";
+import { CRC32Hash } from '@loaders.gl/crypto';
+import { generateLocalHeader } from "./local-file-header.js";
+import { generateCDHeader } from "./cd-file-header.js";
+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 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)];
+}
+export async function addOneFile(zipUrl, fileToAdd, fileName) {
+  const provider = new 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 = 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));
+}
+//# sourceMappingURL=zip-compozition.js.map

package/dist/parse-zip/zip-compozition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-compozition.js","names":["FileHandleFile","concatenateArrayBuffers","parseEoCDRecord","updateEoCD","CRC32Hash","generateLocalHeader","generateCDHeader","cutTheTailOff","provider","oldEoCDinfo","oldCDStartOffset","cdStartOffset","oldCDLength","Number","offsets","zip64EoCDOffset","zipEoCDOffset","zipEnding","slice","length","truncate","oldCDBody","eocdBody","byteLength","generateFileHeaders","fileName","fileToAdd","localFileHeaderOffset","newFileCRC322","parseInt","hash","newFileLocalHeader","crc32","newFileCDHeader","offset","Uint8Array","addOneFile","zipUrl","newFileOffset","localPart","cdHeaderPart","append","newCDBody","newCDStartOffset","eocdOffset","cdRecordsNumber"],"sources":["../../src/parse-zip/zip-compozition.ts"],"sourcesContent":["import {FileHandleFile, concatenateArrayBuffers} from '@loaders.gl/loader-utils';\nimport {ZipEoCDRecord, parseEoCDRecord, updateEoCD} from './end-of-central-directory';\nimport {CRC32Hash} from '@loaders.gl/crypto';\nimport {generateLocalHeader} from './local-file-header';\nimport {generateCDHeader} from './cd-file-header';\n\n/**\n * cut off CD and EoCD records from zip file\n * @param provider zip file\n * @returns tuple with three values: CD, EoCD record, EoCD information\n */\nasync function cutTheTailOff(\n  provider: FileHandleFile\n): Promise<[ArrayBuffer, ArrayBuffer, ZipEoCDRecord]> {\n  // define where the body ends\n  const oldEoCDinfo = await parseEoCDRecord(provider);\n  const oldCDStartOffset = oldEoCDinfo.cdStartOffset;\n\n  // define cd length\n  const oldCDLength = Number(\n    oldEoCDinfo.offsets.zip64EoCDOffset\n      ? oldEoCDinfo.offsets.zip64EoCDOffset - oldCDStartOffset\n      : oldEoCDinfo.offsets.zipEoCDOffset - oldCDStartOffset\n  );\n\n  // cut off everything except of archieve body\n  const zipEnding = await provider.slice(oldCDStartOffset, provider.length);\n  await provider.truncate(Number(oldCDStartOffset));\n\n  // divide cd body and eocd record\n  const oldCDBody = zipEnding.slice(0, oldCDLength);\n  const eocdBody = zipEnding.slice(oldCDLength, zipEnding.byteLength);\n\n  return [oldCDBody, eocdBody, oldEoCDinfo];\n}\n\n/**\n * generates CD and local headers for the file\n * @param fileName name of the file\n * @param fileToAdd buffer with the file\n * @param localFileHeaderOffset offset of the file local header\n * @returns tuple with two values: local header and file body, cd header\n */\nasync function generateFileHeaders(\n  fileName: string,\n  fileToAdd: ArrayBuffer,\n  localFileHeaderOffset: bigint\n): Promise<[Uint8Array, Uint8Array]> {\n  // generating CRC32 of the content\n  const newFileCRC322 = parseInt(await new CRC32Hash().hash(fileToAdd, 'hex'), 16);\n\n  // generate local header for the file\n  const newFileLocalHeader = generateLocalHeader({\n    crc32: newFileCRC322,\n    fileName,\n    length: fileToAdd.byteLength\n  });\n\n  // generate hash file cd header\n  const newFileCDHeader = generateCDHeader({\n    crc32: newFileCRC322,\n    fileName,\n    offset: localFileHeaderOffset,\n    length: fileToAdd.byteLength\n  });\n  return [\n    new Uint8Array(concatenateArrayBuffers(newFileLocalHeader, fileToAdd)),\n    new Uint8Array(newFileCDHeader)\n  ];\n}\n\n/**\n * adds one file in the end of the archieve\n * @param zipUrl path to the file\n * @param fileToAdd new file body\n * @param fileName new file name\n */\nexport async function addOneFile(zipUrl: string, fileToAdd: ArrayBuffer, fileName: string) {\n  // init file handler\n  const provider = new FileHandleFile(zipUrl, true);\n\n  const [oldCDBody, eocdBody, oldEoCDinfo] = await cutTheTailOff(provider);\n\n  // remember the new file local header start offset\n  const newFileOffset = provider.length;\n\n  const [localPart, cdHeaderPart] = await generateFileHeaders(fileName, fileToAdd, newFileOffset);\n\n  // write down the file local header\n  await provider.append(localPart);\n\n  // add the file CD header to the CD\n  const newCDBody = concatenateArrayBuffers(oldCDBody, cdHeaderPart);\n\n  // remember the CD start offset\n  const newCDStartOffset = provider.length;\n\n  // write down new CD\n  await provider.append(new Uint8Array(newCDBody));\n\n  // remember where eocd starts\n  const eocdOffset = provider.length;\n\n  await provider.append(\n    await updateEoCD(\n      eocdBody,\n      oldEoCDinfo.offsets,\n      newCDStartOffset,\n      eocdOffset,\n      oldEoCDinfo.cdRecordsNumber + 1n\n    )\n  );\n}\n"],"mappings":"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"}

package/dist/parse-zip/zip64-info-generation.d.ts

@@ -19,6 +19,6 @@ export declare function createZip64Info(options: Zip64Options): ArrayBuffer;
  * @param fieldOffset offset of the field
  * @param value value to be written
  */
-export declare function setFieldToNumber(header: DataView, fieldSize: number, fieldOffset: number, value: number | bigint): void;
+export declare function setFieldToNumber(header: DataView, fieldSize: number, fieldOffset: number | bigint, value: number | bigint): void;
 export {};
 //# sourceMappingURL=zip64-info-generation.d.ts.map

package/dist/parse-zip/zip64-info-generation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zip64-info-generation.d.ts","sourceRoot":"","sources":["../../src/parse-zip/zip64-info-generation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,YAA+B,CAAC;AAEtD,2GAA2G;AAC3G,KAAK,YAAY,GAAG;IAClB,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW,CAkBlE;AAUD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,QAAQ,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GAAG,MAAM,GACrB,IAAI,CAEN"}
+{"version":3,"file":"zip64-info-generation.d.ts","sourceRoot":"","sources":["../../src/parse-zip/zip64-info-generation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,YAA+B,CAAC;AAEtD,2GAA2G;AAC3G,KAAK,YAAY,GAAG;IAClB,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW,CAkBlE;AAUD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,QAAQ,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,KAAK,EAAE,MAAM,GAAG,MAAM,GACrB,IAAI,CAEN"}

package/dist/parse-zip/zip64-info-generation.js

@@ -18,7 +18,7 @@ export function createZip64Info(options) {
   return concatenateArrayBuffers(...arraysToConcat);
 }
 export function setFieldToNumber(header, fieldSize, fieldOffset, value) {
-  NUMBER_SETTERS[fieldSize](header, fieldOffset, value);
+  NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);
 }
 const NUMBER_SETTERS = {
   2: (header, offset, value) => {

package/dist/parse-zip/zip64-info-generation.js.map

@@ -1 +1 @@
-{"version":3,"file":"zip64-info-generation.js","names":["concatenateArrayBuffers","signature","Uint8Array","createZip64Info","options","optionsToUse","zip64Length","offset","size","arraysToConcat","field","ZIP64_FIELDS","_field$name","_optionsToUse","_field$name2","name","default","newValue","DataView","ArrayBuffer","NUMBER_SETTERS","push","buffer","setFieldToNumber","header","fieldSize","fieldOffset","value","setUint16","Number","setUint32","setBigUint64","BigInt","getUint16"],"sources":["../../src/parse-zip/zip64-info-generation.ts"],"sourcesContent":["import {concatenateArrayBuffers} from '@loaders.gl/loader-utils';\n\nexport const signature = new Uint8Array([0x01, 0x00]);\n\n/** info that can be placed into zip64 field, doc: https://en.wikipedia.org/wiki/ZIP_(file_format)#ZIP64 */\ntype Zip64Options = {\n  /** Original uncompressed file size and Size of compressed data */\n  size?: number;\n  /** Offset of local header record */\n  offset?: number;\n};\n\n/**\n * creates zip64 extra field\n * @param options info that can be placed into zip64 field\n * @returns buffer with field\n */\nexport function createZip64Info(options: Zip64Options): ArrayBuffer {\n  const optionsToUse = {\n    ...options,\n    zip64Length: (options.offset ? 1 : 0) * 8 + (options.size ? 1 : 0) * 16\n  };\n\n  const arraysToConcat: ArrayBuffer[] = [];\n\n  for (const field of ZIP64_FIELDS) {\n    if (!optionsToUse[field.name ?? ''] && !field.default) {\n      continue;\n    }\n    const newValue = new DataView(new ArrayBuffer(field.size));\n    NUMBER_SETTERS[field.size](newValue, 0, optionsToUse[field.name ?? ''] ?? field.default);\n    arraysToConcat.push(newValue.buffer);\n  }\n\n  return concatenateArrayBuffers(...arraysToConcat);\n}\n\n/**\n * Function to write values into buffer\n * @param header buffer where to write a value\n * @param offset offset of the writing start\n * @param value value to be written\n */\ntype NumberSetter = (header: DataView, offset: number, value: number | bigint) => void;\n\n/**\n * Writes values into buffer according to the bytes amount\n * @param header header where to write the data\n * @param fieldSize size of the field in bytes\n * @param fieldOffset offset of the field\n * @param value value to be written\n */\nexport function setFieldToNumber(\n  header: DataView,\n  fieldSize: number,\n  fieldOffset: number,\n  value: number | bigint\n): void {\n  NUMBER_SETTERS[fieldSize](header, fieldOffset, value);\n}\n\n/** functions to write values into buffer according to the bytes amount */\nconst NUMBER_SETTERS: {[key: number]: NumberSetter} = {\n  2: (header, offset, value) => {\n    header.setUint16(offset, Number(value), true);\n  },\n  4: (header, offset, value) => {\n    header.setUint32(offset, Number(value), true);\n  },\n  8: (header, offset, value) => {\n    header.setBigUint64(offset, BigInt(value), true);\n  }\n};\n\n/** zip64 info fields description, we need it as a pattern to build a zip64 info */\nconst ZIP64_FIELDS = [\n  // Header ID 0x0001\n  {\n    size: 2,\n    default: new DataView(signature.buffer).getUint16(0, true)\n  },\n\n  // Size of the extra field chunk (8, 16, 24 or 28)\n  {\n    size: 2,\n    name: 'zip64Length'\n  },\n\n  // Original uncompressed file size\n  {\n    size: 8,\n    name: 'size'\n  },\n\n  // Size of compressed data\n  {\n    size: 8,\n    name: 'size'\n  },\n\n  // Offset of local header record\n  {\n    size: 8,\n    name: 'offset'\n  }\n];\n"],"mappings":"AAAA,SAAQA,uBAAuB,QAAO,0BAA0B;AAEhE,OAAO,MAAMC,SAAS,GAAG,IAAIC,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAerD,OAAO,SAASC,eAAeA,CAACC,OAAqB,EAAe;EAClE,MAAMC,YAAY,GAAG;IACnB,GAAGD,OAAO;IACVE,WAAW,EAAE,CAACF,OAAO,CAACG,MAAM,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAACH,OAAO,CAACI,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI;EACvE,CAAC;EAED,MAAMC,cAA6B,GAAG,EAAE;EAExC,KAAK,MAAMC,KAAK,IAAIC,YAAY,EAAE;IAAA,IAAAC,WAAA,EAAAC,aAAA,EAAAC,YAAA;IAChC,IAAI,CAACT,YAAY,EAAAO,WAAA,GAACF,KAAK,CAACK,IAAI,cAAAH,WAAA,cAAAA,WAAA,GAAI,EAAE,CAAC,IAAI,CAACF,KAAK,CAACM,OAAO,EAAE;MACrD;IACF;IACA,MAAMC,QAAQ,GAAG,IAAIC,QAAQ,CAAC,IAAIC,WAAW,CAACT,KAAK,CAACF,IAAI,CAAC,CAAC;IAC1DY,cAAc,CAACV,KAAK,CAACF,IAAI,CAAC,CAACS,QAAQ,EAAE,CAAC,GAAAJ,aAAA,GAAER,YAAY,EAAAS,YAAA,GAACJ,KAAK,CAACK,IAAI,cAAAD,YAAA,cAAAA,YAAA,GAAI,EAAE,CAAC,cAAAD,aAAA,cAAAA,aAAA,GAAIH,KAAK,CAACM,OAAO,CAAC;IACxFP,cAAc,CAACY,IAAI,CAACJ,QAAQ,CAACK,MAAM,CAAC;EACtC;EAEA,OAAOtB,uBAAuB,CAAC,GAAGS,cAAc,CAAC;AACnD;AAiBA,OAAO,SAASc,gBAAgBA,CAC9BC,MAAgB,EAChBC,SAAiB,EACjBC,WAAmB,EACnBC,KAAsB,EAChB;EACNP,cAAc,CAACK,SAAS,CAAC,CAACD,MAAM,EAAEE,WAAW,EAAEC,KAAK,CAAC;AACvD;AAGA,MAAMP,cAA6C,GAAG;EACpD,CAAC,EAAE,CAACI,MAAM,EAAEjB,MAAM,EAAEoB,KAAK,KAAK;IAC5BH,MAAM,CAACI,SAAS,CAACrB,MAAM,EAAEsB,MAAM,CAACF,KAAK,CAAC,EAAE,IAAI,CAAC;EAC/C,CAAC;EACD,CAAC,EAAE,CAACH,MAAM,EAAEjB,MAAM,EAAEoB,KAAK,KAAK;IAC5BH,MAAM,CAACM,SAAS,CAACvB,MAAM,EAAEsB,MAAM,CAACF,KAAK,CAAC,EAAE,IAAI,CAAC;EAC/C,CAAC;EACD,CAAC,EAAE,CAACH,MAAM,EAAEjB,MAAM,EAAEoB,KAAK,KAAK;IAC5BH,MAAM,CAACO,YAAY,CAACxB,MAAM,EAAEyB,MAAM,CAACL,KAAK,CAAC,EAAE,IAAI,CAAC;EAClD;AACF,CAAC;AAGD,MAAMhB,YAAY,GAAG,CAEnB;EACEH,IAAI,EAAE,CAAC;EACPQ,OAAO,EAAE,IAAIE,QAAQ,CAACjB,SAAS,CAACqB,MAAM,CAAC,CAACW,SAAS,CAAC,CAAC,EAAE,IAAI;AAC3D,CAAC,EAGD;EACEzB,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,EAGD;EACEP,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,EAGD;EACEP,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,EAGD;EACEP,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,CACF"}
+{"version":3,"file":"zip64-info-generation.js","names":["concatenateArrayBuffers","signature","Uint8Array","createZip64Info","options","optionsToUse","zip64Length","offset","size","arraysToConcat","field","ZIP64_FIELDS","_field$name","_optionsToUse","_field$name2","name","default","newValue","DataView","ArrayBuffer","NUMBER_SETTERS","push","buffer","setFieldToNumber","header","fieldSize","fieldOffset","value","Number","setUint16","setUint32","setBigUint64","BigInt","getUint16"],"sources":["../../src/parse-zip/zip64-info-generation.ts"],"sourcesContent":["import {concatenateArrayBuffers} from '@loaders.gl/loader-utils';\n\nexport const signature = new Uint8Array([0x01, 0x00]);\n\n/** info that can be placed into zip64 field, doc: https://en.wikipedia.org/wiki/ZIP_(file_format)#ZIP64 */\ntype Zip64Options = {\n  /** Original uncompressed file size and Size of compressed data */\n  size?: number;\n  /** Offset of local header record */\n  offset?: number;\n};\n\n/**\n * creates zip64 extra field\n * @param options info that can be placed into zip64 field\n * @returns buffer with field\n */\nexport function createZip64Info(options: Zip64Options): ArrayBuffer {\n  const optionsToUse = {\n    ...options,\n    zip64Length: (options.offset ? 1 : 0) * 8 + (options.size ? 1 : 0) * 16\n  };\n\n  const arraysToConcat: ArrayBuffer[] = [];\n\n  for (const field of ZIP64_FIELDS) {\n    if (!optionsToUse[field.name ?? ''] && !field.default) {\n      continue;\n    }\n    const newValue = new DataView(new ArrayBuffer(field.size));\n    NUMBER_SETTERS[field.size](newValue, 0, optionsToUse[field.name ?? ''] ?? field.default);\n    arraysToConcat.push(newValue.buffer);\n  }\n\n  return concatenateArrayBuffers(...arraysToConcat);\n}\n\n/**\n * Function to write values into buffer\n * @param header buffer where to write a value\n * @param offset offset of the writing start\n * @param value value to be written\n */\ntype NumberSetter = (header: DataView, offset: number, value: number | bigint) => void;\n\n/**\n * Writes values into buffer according to the bytes amount\n * @param header header where to write the data\n * @param fieldSize size of the field in bytes\n * @param fieldOffset offset of the field\n * @param value value to be written\n */\nexport function setFieldToNumber(\n  header: DataView,\n  fieldSize: number,\n  fieldOffset: number | bigint,\n  value: number | bigint\n): void {\n  NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);\n}\n\n/** functions to write values into buffer according to the bytes amount */\nconst NUMBER_SETTERS: {[key: number]: NumberSetter} = {\n  2: (header, offset, value) => {\n    header.setUint16(offset, Number(value), true);\n  },\n  4: (header, offset, value) => {\n    header.setUint32(offset, Number(value), true);\n  },\n  8: (header, offset, value) => {\n    header.setBigUint64(offset, BigInt(value), true);\n  }\n};\n\n/** zip64 info fields description, we need it as a pattern to build a zip64 info */\nconst ZIP64_FIELDS = [\n  // Header ID 0x0001\n  {\n    size: 2,\n    default: new DataView(signature.buffer).getUint16(0, true)\n  },\n\n  // Size of the extra field chunk (8, 16, 24 or 28)\n  {\n    size: 2,\n    name: 'zip64Length'\n  },\n\n  // Original uncompressed file size\n  {\n    size: 8,\n    name: 'size'\n  },\n\n  // Size of compressed data\n  {\n    size: 8,\n    name: 'size'\n  },\n\n  // Offset of local header record\n  {\n    size: 8,\n    name: 'offset'\n  }\n];\n"],"mappings":"AAAA,SAAQA,uBAAuB,QAAO,0BAA0B;AAEhE,OAAO,MAAMC,SAAS,GAAG,IAAIC,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAerD,OAAO,SAASC,eAAeA,CAACC,OAAqB,EAAe;EAClE,MAAMC,YAAY,GAAG;IACnB,GAAGD,OAAO;IACVE,WAAW,EAAE,CAACF,OAAO,CAACG,MAAM,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAACH,OAAO,CAACI,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI;EACvE,CAAC;EAED,MAAMC,cAA6B,GAAG,EAAE;EAExC,KAAK,MAAMC,KAAK,IAAIC,YAAY,EAAE;IAAA,IAAAC,WAAA,EAAAC,aAAA,EAAAC,YAAA;IAChC,IAAI,CAACT,YAAY,EAAAO,WAAA,GAACF,KAAK,CAACK,IAAI,cAAAH,WAAA,cAAAA,WAAA,GAAI,EAAE,CAAC,IAAI,CAACF,KAAK,CAACM,OAAO,EAAE;MACrD;IACF;IACA,MAAMC,QAAQ,GAAG,IAAIC,QAAQ,CAAC,IAAIC,WAAW,CAACT,KAAK,CAACF,IAAI,CAAC,CAAC;IAC1DY,cAAc,CAACV,KAAK,CAACF,IAAI,CAAC,CAACS,QAAQ,EAAE,CAAC,GAAAJ,aAAA,GAAER,YAAY,EAAAS,YAAA,GAACJ,KAAK,CAACK,IAAI,cAAAD,YAAA,cAAAA,YAAA,GAAI,EAAE,CAAC,cAAAD,aAAA,cAAAA,aAAA,GAAIH,KAAK,CAACM,OAAO,CAAC;IACxFP,cAAc,CAACY,IAAI,CAACJ,QAAQ,CAACK,MAAM,CAAC;EACtC;EAEA,OAAOtB,uBAAuB,CAAC,GAAGS,cAAc,CAAC;AACnD;AAiBA,OAAO,SAASc,gBAAgBA,CAC9BC,MAAgB,EAChBC,SAAiB,EACjBC,WAA4B,EAC5BC,KAAsB,EAChB;EACNP,cAAc,CAACK,SAAS,CAAC,CAACD,MAAM,EAAEI,MAAM,CAACF,WAAW,CAAC,EAAEC,KAAK,CAAC;AAC/D;AAGA,MAAMP,cAA6C,GAAG;EACpD,CAAC,EAAE,CAACI,MAAM,EAAEjB,MAAM,EAAEoB,KAAK,KAAK;IAC5BH,MAAM,CAACK,SAAS,CAACtB,MAAM,EAAEqB,MAAM,CAACD,KAAK,CAAC,EAAE,IAAI,CAAC;EAC/C,CAAC;EACD,CAAC,EAAE,CAACH,MAAM,EAAEjB,MAAM,EAAEoB,KAAK,KAAK;IAC5BH,MAAM,CAACM,SAAS,CAACvB,MAAM,EAAEqB,MAAM,CAACD,KAAK,CAAC,EAAE,IAAI,CAAC;EAC/C,CAAC;EACD,CAAC,EAAE,CAACH,MAAM,EAAEjB,MAAM,EAAEoB,KAAK,KAAK;IAC5BH,MAAM,CAACO,YAAY,CAACxB,MAAM,EAAEyB,MAAM,CAACL,KAAK,CAAC,EAAE,IAAI,CAAC;EAClD;AACF,CAAC;AAGD,MAAMhB,YAAY,GAAG,CAEnB;EACEH,IAAI,EAAE,CAAC;EACPQ,OAAO,EAAE,IAAIE,QAAQ,CAACjB,SAAS,CAACqB,MAAM,CAAC,CAACW,SAAS,CAAC,CAAC,EAAE,IAAI;AAC3D,CAAC,EAGD;EACEzB,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,EAGD;EACEP,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,EAGD;EACEP,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,EAGD;EACEP,IAAI,EAAE,CAAC;EACPO,IAAI,EAAE;AACR,CAAC,CACF"}

package/dist/zip-loader.js

@@ -1,5 +1,5 @@
 import JSZip from 'jszip';
-const VERSION = typeof "4.1.0-alpha.3" !== 'undefined' ? "4.1.0-alpha.3" : 'latest';
+const VERSION = typeof "4.1.0-alpha.5" !== 'undefined' ? "4.1.0-alpha.5" : 'latest';
 export const ZipLoader = {
   id: 'zip',
   module: 'zip',

package/dist/zip-writer.js

@@ -1,5 +1,5 @@
 import JSZip from 'jszip';
-const VERSION = typeof "4.1.0-alpha.3" !== 'undefined' ? "4.1.0-alpha.3" : 'latest';
+const VERSION = typeof "4.1.0-alpha.5" !== 'undefined' ? "4.1.0-alpha.5" : 'latest';
 export const ZipWriter = {
   name: 'Zip Archive',
   id: 'zip',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/zip",
-  "version": "4.1.0-alpha.3",
+  "version": "4.1.0-alpha.5",
   "description": "Zip Archive Loader",
   "license": "MIT",
   "type": "module",
@@ -38,11 +38,11 @@
     "build-bundle": "ocular-bundle ./src/index.ts"
   },
   "dependencies": {
-    "@loaders.gl/compression": "4.1.0-alpha.3",
-    "@loaders.gl/crypto": "4.1.0-alpha.3",
-    "@loaders.gl/loader-utils": "4.1.0-alpha.3",
+    "@loaders.gl/compression": "4.1.0-alpha.5",
+    "@loaders.gl/crypto": "4.1.0-alpha.5",
+    "@loaders.gl/loader-utils": "4.1.0-alpha.5",
     "jszip": "^3.1.5",
     "md5": "^2.3.0"
   },
-  "gitHead": "b78075a7cb8d4ecd4aac84805ce74b8ceb400cf7"
+  "gitHead": "3250842d8cc0fc8b76a575168c1fd57e5a66b6ba"
 }

package/src/hash-file-utility.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {MD5Hash} from '@loaders.gl/crypto';
-import {FileProvider} from '@loaders.gl/loader-utils';
+import {FileProvider, concatenateArrayBuffers} from '@loaders.gl/loader-utils';
 import {makeZipCDHeaderIterator} from './parse-zip/cd-file-header';
 
 /**
@@ -55,3 +55,48 @@ export async function makeHashTableFromZipHeaders(
 
   return hashTable;
 }
+
+/**
+ * creates hash file that later can be added to the SLPK archive
+ * @param fileProvider SLPK archive where we need to add hash file
+ * @returns ArrayBuffer containing hash file
+ */
+export async function composeHashFile(fileProvider: FileProvider): Promise<ArrayBuffer> {
+  const hashArray = await makeHashTableFromZipHeaders(fileProvider);
+  const bufferArray = Object.entries(hashArray)
+    .map(([key, value]) => concatenateArrayBuffers(hexStringToBuffer(key), bigintToBuffer(value)))
+    .sort(compareHashes);
+  return concatenateArrayBuffers(...bufferArray);
+}
+
+/**
+ * Function to compare md5 hashes according to https://github.com/Esri/i3s-spec/blob/master/docs/2.0/slpk_hashtable.pcsl.md
+ * @param arrA first hash to compare
+ * @param arrB second hash to compare
+ * @returns 0 if equal, negative number if a<b, pozitive if a>b
+ */
+function compareHashes(arrA: ArrayBuffer, arrB: ArrayBuffer): number {
+  const a = new BigUint64Array(arrA);
+  const b = new BigUint64Array(arrB);
+
+  return Number(a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+}
+
+/**
+ * converts hex string to buffer
+ * @param str hex string to convert
+ * @returns conversion result
+ */
+function hexStringToBuffer(str: string): ArrayBuffer {
+  const byteArray = str.match(/../g)?.map((h) => parseInt(h, 16));
+  return new Uint8Array(byteArray ?? new Array(16)).buffer;
+}
+
+/**
+ * converts bigint to buffer
+ * @param n bigint to convert
+ * @returns convertion result
+ */
+function bigintToBuffer(n: bigint): ArrayBuffer {
+  return new BigUint64Array([n]).buffer;
+}

package/src/index.ts

@@ -19,8 +19,9 @@ export {
 } from './parse-zip/local-file-header';
 export {parseEoCDRecord} from './parse-zip/end-of-central-directory';
 export {searchFromTheEnd} from './parse-zip/search-from-the-end';
+export {addOneFile} from './parse-zip/zip-compozition';
 
 // export type {HashElement} from './hash-file-utility';
-export {parseHashTable, makeHashTableFromZipHeaders} from './hash-file-utility';
+export {parseHashTable, makeHashTableFromZipHeaders, composeHashFile} from './hash-file-utility';
 
 export {ZipFileSystem} from './filesystems/zip-filesystem';

package/src/parse-zip/cd-file-header.ts

@@ -200,7 +200,7 @@ type GenerateCDOptions = {
   /** File size */
   length: number;
   /** Relative offset of local file header */
-  offset: number;
+  offset: bigint;
 };
 
 /**
@@ -220,7 +220,7 @@ export function generateCDHeader(options: GenerateCDOptions): ArrayBuffer {
   const optionsToZip64: any = {};
   if (optionsToUse.offset >= 0xffffffff) {
     optionsToZip64.offset = optionsToUse.offset;
-    optionsToUse.offset = 0xffffffff;
+    optionsToUse.offset = BigInt(0xffffffff);
   }
   if (optionsToUse.length >= 0xffffffff) {
     optionsToZip64.size = optionsToUse.length;
@@ -231,7 +231,7 @@ export function generateCDHeader(options: GenerateCDOptions): ArrayBuffer {
     zip64header = createZip64Info(optionsToZip64);
     optionsToUse.extraLength = zip64header.byteLength;
   }
-  const header = new DataView(new ArrayBuffer(46));
+  const header = new DataView(new ArrayBuffer(Number(CD_FILE_NAME_OFFSET)));
 
   for (const field of ZIP_HEADER_FIELDS) {
     setFieldToNumber(

package/src/parse-zip/end-of-central-directory.ts

@@ -4,6 +4,7 @@
 
 import {FileProvider, compareArrayBuffers} from '@loaders.gl/loader-utils';
 import {ZipSignature, searchFromTheEnd} from './search-from-the-end';
+import {setFieldToNumber} from './zip64-info-generation';
 
 /**
  * End of central directory info
@@ -14,6 +15,18 @@ export type ZipEoCDRecord = {
   cdStartOffset: bigint;
   /** Relative offset of local file header */
   cdRecordsNumber: bigint;
+  offsets: ZipEoCDRecordOffsets;
+};
+
+/**
+ * End of central directory offsets
+ * according to https://en.wikipedia.org/wiki/ZIP_(file_format)
+ */
+export type ZipEoCDRecordOffsets = {
+  zipEoCDOffset: bigint;
+
+  zip64EoCDOffset?: bigint;
+  zip64EoCDLocatorOffset?: bigint;
 };
 
 const eoCDSignature: ZipSignature = new Uint8Array([0x50, 0x4b, 0x05, 0x06]);
@@ -22,9 +35,13 @@ const zip64EoCDSignature = new Uint8Array([0x50, 0x4b, 0x06, 0x06]);
 
 // offsets accroding to https://en.wikipedia.org/wiki/ZIP_(file_format)
 const CD_RECORDS_NUMBER_OFFSET = 8n;
+const CD_RECORDS_NUMBER_ON_DISC_OFFSET = 10n;
+const CD_CD_BYTE_SIZE_OFFSET = 12n;
 const CD_START_OFFSET_OFFSET = 16n;
 const ZIP64_EOCD_START_OFFSET_OFFSET = 8n;
 const ZIP64_CD_RECORDS_NUMBER_OFFSET = 24n;
+const ZIP64_CD_RECORDS_NUMBER_ON_DISC_OFFSET = 32n;
+const ZIP64_CD_CD_BYTE_SIZE_OFFSET = 40n;
 const ZIP64_CD_START_OFFSET_OFFSET = 48n;
 
 /**
@@ -38,14 +55,12 @@ export const parseEoCDRecord = async (file: FileProvider): Promise<ZipEoCDRecord
   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(0xffffffff) || cdRecordsNumber === BigInt(0xffffffff)) {
-    const zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+  let zip64EoCDLocatorOffset = zipEoCDOffset - 20n;
+  let zip64EoCDOffset = 0n;
 
-    const magicBytes = await file.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
-    if (!compareArrayBuffers(magicBytes, zip64EoCDLocatorSignature)) {
-      throw new Error('zip64 EoCD locator not found');
-    }
-    const zip64EoCDOffset = await file.getBigUint64(
+  const magicBytes = await file.slice(zip64EoCDLocatorOffset, zip64EoCDLocatorOffset + 4n);
+  if (compareArrayBuffers(magicBytes, zip64EoCDLocatorSignature)) {
+    zip64EoCDOffset = await file.getBigUint64(
       zip64EoCDLocatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET
     );
 
@@ -56,10 +71,84 @@ export const parseEoCDRecord = async (file: FileProvider): Promise<ZipEoCDRecord
 
     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
+    }
   };
 };
+
+/**
+ * updates EoCD record to add more files to the archieve
+ * @param eocdBody buffer containing header
+ * @param oldEoCDOffsets info read from EoCD record befor updating
+ * @param newCDStartOffset CD start offset to be updated
+ * @param eocdStartOffset EoCD start offset to be updated
+ * @returns new EoCD header
+ */
+export async function updateEoCD(
+  eocdBody: ArrayBuffer,
+  oldEoCDOffsets: ZipEoCDRecordOffsets,
+  newCDStartOffset: bigint,
+  eocdStartOffset: bigint,
+  newCDRecordsNumber: bigint
+): Promise<Uint8Array> {
+  const eocd = new DataView(eocdBody);
+
+  const classicEoCDOffset = oldEoCDOffsets.zip64EoCDOffset
+    ? oldEoCDOffsets.zipEoCDOffset - oldEoCDOffsets.zip64EoCDOffset
+    : 0n;
+
+  // updating classic EoCD record with new CD records number in general and on disc
+  if (Number(newCDRecordsNumber) <= 0xffff) {
+    setFieldToNumber(eocd, 2, classicEoCDOffset + CD_RECORDS_NUMBER_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(
+      eocd,
+      2,
+      classicEoCDOffset + CD_RECORDS_NUMBER_ON_DISC_OFFSET,
+      newCDRecordsNumber
+    );
+  }
+
+  // updating zip64 EoCD record with new size of CD
+  if (eocdStartOffset - newCDStartOffset <= 0xffffffff) {
+    setFieldToNumber(
+      eocd,
+      4,
+      classicEoCDOffset + CD_CD_BYTE_SIZE_OFFSET,
+      eocdStartOffset - newCDStartOffset
+    );
+  }
+
+  // updating classic EoCD record with new CD start offset
+  if (newCDStartOffset < 0xffffffff) {
+    setFieldToNumber(eocd, 4, classicEoCDOffset + CD_START_OFFSET_OFFSET, newCDStartOffset);
+  }
+
+  // updating zip64 EoCD locator and record with new EoCD record start offset and cd records number
+  if (oldEoCDOffsets.zip64EoCDLocatorOffset && oldEoCDOffsets.zip64EoCDOffset) {
+    // updating zip64 EoCD locator with new EoCD record start offset
+    const locatorOffset = oldEoCDOffsets.zip64EoCDLocatorOffset - oldEoCDOffsets.zip64EoCDOffset;
+    setFieldToNumber(eocd, 8, locatorOffset + ZIP64_EOCD_START_OFFSET_OFFSET, eocdStartOffset);
+
+    // updating zip64 EoCD record with new cd start offset
+    setFieldToNumber(eocd, 8, ZIP64_CD_START_OFFSET_OFFSET, newCDStartOffset);
+
+    // updating zip64 EoCD record with new cd records number
+    setFieldToNumber(eocd, 8, ZIP64_CD_RECORDS_NUMBER_OFFSET, newCDRecordsNumber);
+    setFieldToNumber(eocd, 8, ZIP64_CD_RECORDS_NUMBER_ON_DISC_OFFSET, newCDRecordsNumber);
+
+    // updating zip64 EoCD record with new size of CD
+    setFieldToNumber(eocd, 8, ZIP64_CD_CD_BYTE_SIZE_OFFSET, eocdStartOffset - newCDStartOffset);
+  }
+
+  return new Uint8Array(eocd.buffer);
+}

package/src/parse-zip/zip-compozition.ts

@@ -0,0 +1,113 @@
+import {FileHandleFile, concatenateArrayBuffers} from '@loaders.gl/loader-utils';
+import {ZipEoCDRecord, parseEoCDRecord, updateEoCD} from './end-of-central-directory';
+import {CRC32Hash} from '@loaders.gl/crypto';
+import {generateLocalHeader} from './local-file-header';
+import {generateCDHeader} from './cd-file-header';
+
+/**
+ * cut off CD and EoCD records from zip file
+ * @param provider zip file
+ * @returns tuple with three values: CD, EoCD record, EoCD information
+ */
+async function cutTheTailOff(
+  provider: FileHandleFile
+): Promise<[ArrayBuffer, ArrayBuffer, ZipEoCDRecord]> {
+  // define where the body ends
+  const oldEoCDinfo = await parseEoCDRecord(provider);
+  const oldCDStartOffset = oldEoCDinfo.cdStartOffset;
+
+  // define cd length
+  const oldCDLength = Number(
+    oldEoCDinfo.offsets.zip64EoCDOffset
+      ? oldEoCDinfo.offsets.zip64EoCDOffset - oldCDStartOffset
+      : oldEoCDinfo.offsets.zipEoCDOffset - oldCDStartOffset
+  );
+
+  // cut off everything except of archieve body
+  const zipEnding = await provider.slice(oldCDStartOffset, provider.length);
+  await provider.truncate(Number(oldCDStartOffset));
+
+  // divide cd body and eocd record
+  const oldCDBody = zipEnding.slice(0, oldCDLength);
+  const eocdBody = zipEnding.slice(oldCDLength, zipEnding.byteLength);
+
+  return [oldCDBody, eocdBody, oldEoCDinfo];
+}
+
+/**
+ * generates CD and local headers for the file
+ * @param fileName name of the file
+ * @param fileToAdd buffer with the file
+ * @param localFileHeaderOffset offset of the file local header
+ * @returns tuple with two values: local header and file body, cd header
+ */
+async function generateFileHeaders(
+  fileName: string,
+  fileToAdd: ArrayBuffer,
+  localFileHeaderOffset: bigint
+): Promise<[Uint8Array, Uint8Array]> {
+  // generating CRC32 of the content
+  const newFileCRC322 = parseInt(await new CRC32Hash().hash(fileToAdd, 'hex'), 16);
+
+  // generate local header for the file
+  const newFileLocalHeader = generateLocalHeader({
+    crc32: newFileCRC322,
+    fileName,
+    length: fileToAdd.byteLength
+  });
+
+  // generate hash file cd header
+  const newFileCDHeader = generateCDHeader({
+    crc32: newFileCRC322,
+    fileName,
+    offset: localFileHeaderOffset,
+    length: fileToAdd.byteLength
+  });
+  return [
+    new Uint8Array(concatenateArrayBuffers(newFileLocalHeader, fileToAdd)),
+    new Uint8Array(newFileCDHeader)
+  ];
+}
+
+/**
+ * adds one file in the end of the archieve
+ * @param zipUrl path to the file
+ * @param fileToAdd new file body
+ * @param fileName new file name
+ */
+export async function addOneFile(zipUrl: string, fileToAdd: ArrayBuffer, fileName: string) {
+  // init file handler
+  const provider = new FileHandleFile(zipUrl, true);
+
+  const [oldCDBody, eocdBody, oldEoCDinfo] = await cutTheTailOff(provider);
+
+  // remember the new file local header start offset
+  const newFileOffset = provider.length;
+
+  const [localPart, cdHeaderPart] = await generateFileHeaders(fileName, fileToAdd, newFileOffset);
+
+  // write down the file local header
+  await provider.append(localPart);
+
+  // add the file CD header to the CD
+  const newCDBody = concatenateArrayBuffers(oldCDBody, cdHeaderPart);
+
+  // remember the CD start offset
+  const newCDStartOffset = provider.length;
+
+  // write down new CD
+  await provider.append(new Uint8Array(newCDBody));
+
+  // remember where eocd starts
+  const eocdOffset = provider.length;
+
+  await provider.append(
+    await updateEoCD(
+      eocdBody,
+      oldEoCDinfo.offsets,
+      newCDStartOffset,
+      eocdOffset,
+      oldEoCDinfo.cdRecordsNumber + 1n
+    )
+  );
+}

package/src/parse-zip/zip64-info-generation.ts

@@ -53,10 +53,10 @@ type NumberSetter = (header: DataView, offset: number, value: number | bigint) =
 export function setFieldToNumber(
   header: DataView,
   fieldSize: number,
-  fieldOffset: number,
+  fieldOffset: number | bigint,
   value: number | bigint
 ): void {
-  NUMBER_SETTERS[fieldSize](header, fieldOffset, value);
+  NUMBER_SETTERS[fieldSize](header, Number(fieldOffset), value);
 }
 
 /** functions to write values into buffer according to the bytes amount */