@jax-data-science/sci-image-visualizer 0.11.0 → 0.12.1

package/esm2022/lib/region-import/zip.mjs

@@ -0,0 +1,157 @@
+const EOCD = 0x06054b50;
+const ZIP64_LOCATOR = 0x07064b50;
+const ZIP64_EOCD = 0x06064b50;
+const CENTRAL = 0x02014b50;
+const LOCAL = 0x04034b50;
+const U32 = 0xffffffff;
+/** Whether a file name is a zip archive. */
+export function isZipName(name) {
+    return /\.zip$/i.test(name);
+}
+/** The members of the archive in `bytes` (directories and macOS metadata left out). */
+export function readZip(bytes, inflateRaw = platformInflateRaw) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const eocd = findEocd(view);
+    let count = view.getUint16(eocd + 10, true);
+    let dirOffset = view.getUint32(eocd + 16, true);
+    if (count === 0xffff || dirOffset === U32) {
+        const locator = eocd - 20;
+        if (locator < 0 || view.getUint32(locator, true) !== ZIP64_LOCATOR)
+            throw new Error('zip: ZIP64 locator missing');
+        const z64 = num(view, locator + 8);
+        if (view.getUint32(z64, true) !== ZIP64_EOCD)
+            throw new Error('zip: ZIP64 directory end missing');
+        count = num(view, z64 + 32);
+        dirOffset = num(view, z64 + 48);
+    }
+    const entries = [];
+    let at = dirOffset;
+    for (let i = 0; i < count; i++) {
+        if (view.getUint32(at, true) !== CENTRAL)
+            throw new Error('zip: bad central directory');
+        const flags = view.getUint16(at + 8, true);
+        const method = view.getUint16(at + 10, true);
+        const crc = view.getUint32(at + 16, true);
+        let compressed = view.getUint32(at + 20, true);
+        let size = view.getUint32(at + 24, true);
+        const nameLen = view.getUint16(at + 28, true);
+        const extraLen = view.getUint16(at + 30, true);
+        const commentLen = view.getUint16(at + 32, true);
+        let local = view.getUint32(at + 42, true);
+        const nameBytes = bytes.subarray(at + 46, at + 46 + nameLen);
+        const name = (flags & 0x800 ? new TextDecoder() : new TextDecoder('latin1'))
+            .decode(nameBytes)
+            .replace(/\\/g, '/');
+        // ZIP64: the 32-bit fields that overflowed are in the extra field, in this order.
+        let x = at + 46 + nameLen;
+        const extraEnd = x + extraLen;
+        while (x + 4 <= extraEnd) {
+            const id = view.getUint16(x, true);
+            const len = view.getUint16(x + 2, true);
+            if (id === 0x0001) {
+                let p = x + 4;
+                if (size === U32)
+                    ((size = num(view, p)), (p += 8));
+                if (compressed === U32)
+                    ((compressed = num(view, p)), (p += 8));
+                if (local === U32)
+                    local = num(view, p);
+            }
+            x += 4 + len;
+        }
+        at = extraEnd + commentLen;
+        if (name.endsWith('/') || /(^|\/)__MACOSX\//.test(name) || /(^|\/)\.DS_Store$/.test(name))
+            continue;
+        const entry = { flags, method, crc, compressed, size, local };
+        entries.push({ name, size, bytes: () => readMember(bytes, view, name, entry, inflateRaw) });
+    }
+    return entries;
+}
+/**
+ * `files` with every `.zip` among them replaced by its members, named by their paths in it (a
+ * single top folder the archive wraps everything in is kept, as a folder pick would keep it).
+ */
+export async function expandZips(files, inflateRaw) {
+    const out = [];
+    for (const file of files) {
+        if (!isZipName(file.name)) {
+            out.push(file);
+            continue;
+        }
+        for (const entry of readZip(await file.bytes(), inflateRaw)) {
+            out.push({
+                name: entry.name,
+                bytes: () => entry.bytes(),
+                text: async () => new TextDecoder().decode(await entry.bytes()),
+            });
+        }
+    }
+    return out;
+}
+async function readMember(bytes, view, name, m, inflateRaw) {
+    if (m.flags & 0x1)
+        throw new Error(`zip: ${name} is encrypted`);
+    if (view.getUint32(m.local, true) !== LOCAL)
+        throw new Error(`zip: ${name}: bad local header`);
+    const start = m.local + 30 + view.getUint16(m.local + 26, true) + view.getUint16(m.local + 28, true);
+    const raw = bytes.subarray(start, start + m.compressed);
+    if (raw.length !== m.compressed)
+        throw new Error(`zip: ${name} is truncated`);
+    let out;
+    if (m.method === 0)
+        out = raw;
+    else if (m.method === 8)
+        out = await inflateRaw(raw);
+    else
+        throw new Error(`zip: ${name} uses compression method ${m.method}, not stored or deflate`);
+    if (out.length !== m.size)
+        throw new Error(`zip: ${name} is ${out.length} bytes, expected ${m.size}`);
+    if (crc32(out) !== m.crc)
+        throw new Error(`zip: ${name} fails its CRC check`);
+    return out;
+}
+/** The end-of-central-directory record: the last one, within the 64 KiB a comment may take. */
+function findEocd(view) {
+    const stop = Math.max(0, view.byteLength - 22 - 0xffff);
+    for (let at = view.byteLength - 22; at >= stop; at--) {
+        if (view.getUint32(at, true) === EOCD)
+            return at;
+    }
+    throw new Error('zip: not a zip archive (no central directory)');
+}
+/** A little-endian u64 that fits a double (archives under 8 PB). */
+function num(view, at) {
+    return view.getUint32(at, true) + view.getUint32(at + 4, true) * 0x100000000;
+}
+let crcTable = null;
+/** CRC-32 (IEEE), as zip records it. */
+export function crc32(data) {
+    if (!crcTable) {
+        crcTable = new Uint32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++)
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            crcTable[n] = c >>> 0;
+        }
+    }
+    let c = 0xffffffff;
+    for (let i = 0; i < data.length; i++)
+        c = crcTable[(c ^ data[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+async function platformInflateRaw(bytes) {
+    if (typeof DecompressionStream === 'undefined')
+        throw new Error('zip: deflated members need DecompressionStream');
+    let inflater;
+    try {
+        // Compression Streams' raw DEFLATE (Chrome 103, Firefox 113, Safari 16.4 on).
+        inflater = new DecompressionStream('deflate-raw');
+    }
+    catch {
+        throw new Error('zip: this browser cannot inflate zip members (no DecompressionStream "deflate-raw")');
+    }
+    const stream = new Blob([bytes]).stream().pipeThrough(inflater);
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zip.js","sourceRoot":"","sources":["../../../../src/lib/region-import/zip.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The members of a `.zip`, read in the browser: annotations handed over as one archive (a folder\n * of per-slice GeoJSON, a label volume with its ontology, an OME-Zarr store's labels).\n *\n * Only what such archives use: stored or deflated members, ZIP64 sizes and offsets, UTF-8 or\n * legacy names. An encrypted or otherwise compressed member throws when it is read, rather than be\n * read wrongly; a member's CRC-32 is checked. Members are read on demand, so an archive of many\n * chunks (a zarr store) is not inflated whole. Pure: usable from workers.\n */\nimport type { RegionImportFile } from './region-import';\n\n/** One member of an archive. */\nexport interface ZipEntry {\n  /** Its path in the archive, '/'-separated. */\n  name: string;\n  /** Its uncompressed size, in bytes. */\n  size: number;\n  bytes(): Promise<Uint8Array>;\n}\n\n/** Inflate raw DEFLATE data (default: the platform's `DecompressionStream('deflate-raw')`). */\nexport type InflateRaw = (bytes: Uint8Array) => Promise<Uint8Array>;\n\nconst EOCD = 0x06054b50;\nconst ZIP64_LOCATOR = 0x07064b50;\nconst ZIP64_EOCD = 0x06064b50;\nconst CENTRAL = 0x02014b50;\nconst LOCAL = 0x04034b50;\nconst U32 = 0xffffffff;\n\n/** Whether a file name is a zip archive. */\nexport function isZipName(name: string): boolean {\n  return /\\.zip$/i.test(name);\n}\n\n/** The members of the archive in `bytes` (directories and macOS metadata left out). */\nexport function readZip(bytes: Uint8Array, inflateRaw: InflateRaw = platformInflateRaw): ZipEntry[] {\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const eocd = findEocd(view);\n  let count = view.getUint16(eocd + 10, true);\n  let dirOffset = view.getUint32(eocd + 16, true);\n  if (count === 0xffff || dirOffset === U32) {\n    const locator = eocd - 20;\n    if (locator < 0 || view.getUint32(locator, true) !== ZIP64_LOCATOR)\n      throw new Error('zip: ZIP64 locator missing');\n    const z64 = num(view, locator + 8);\n    if (view.getUint32(z64, true) !== ZIP64_EOCD) throw new Error('zip: ZIP64 directory end missing');\n    count = num(view, z64 + 32);\n    dirOffset = num(view, z64 + 48);\n  }\n  const entries: ZipEntry[] = [];\n  let at = dirOffset;\n  for (let i = 0; i < count; i++) {\n    if (view.getUint32(at, true) !== CENTRAL) throw new Error('zip: bad central directory');\n    const flags = view.getUint16(at + 8, true);\n    const method = view.getUint16(at + 10, true);\n    const crc = view.getUint32(at + 16, true);\n    let compressed = view.getUint32(at + 20, true);\n    let size = view.getUint32(at + 24, true);\n    const nameLen = view.getUint16(at + 28, true);\n    const extraLen = view.getUint16(at + 30, true);\n    const commentLen = view.getUint16(at + 32, true);\n    let local = view.getUint32(at + 42, true);\n    const nameBytes = bytes.subarray(at + 46, at + 46 + nameLen);\n    const name = (flags & 0x800 ? new TextDecoder() : new TextDecoder('latin1'))\n      .decode(nameBytes)\n      .replace(/\\\\/g, '/');\n    // ZIP64: the 32-bit fields that overflowed are in the extra field, in this order.\n    let x = at + 46 + nameLen;\n    const extraEnd = x + extraLen;\n    while (x + 4 <= extraEnd) {\n      const id = view.getUint16(x, true);\n      const len = view.getUint16(x + 2, true);\n      if (id === 0x0001) {\n        let p = x + 4;\n        if (size === U32) ((size = num(view, p)), (p += 8));\n        if (compressed === U32) ((compressed = num(view, p)), (p += 8));\n        if (local === U32) local = num(view, p);\n      }\n      x += 4 + len;\n    }\n    at = extraEnd + commentLen;\n    if (name.endsWith('/') || /(^|\\/)__MACOSX\\//.test(name) || /(^|\\/)\\.DS_Store$/.test(name)) continue;\n    const entry = { flags, method, crc, compressed, size, local };\n    entries.push({ name, size, bytes: () => readMember(bytes, view, name, entry, inflateRaw) });\n  }\n  return entries;\n}\n\n/**\n * `files` with every `.zip` among them replaced by its members, named by their paths in it (a\n * single top folder the archive wraps everything in is kept, as a folder pick would keep it).\n */\nexport async function expandZips(\n  files: readonly RegionImportFile[],\n  inflateRaw?: InflateRaw,\n): Promise<RegionImportFile[]> {\n  const out: RegionImportFile[] = [];\n  for (const file of files) {\n    if (!isZipName(file.name)) {\n      out.push(file);\n      continue;\n    }\n    for (const entry of readZip(await file.bytes(), inflateRaw)) {\n      out.push({\n        name: entry.name,\n        bytes: () => entry.bytes(),\n        text: async () => new TextDecoder().decode(await entry.bytes()),\n      });\n    }\n  }\n  return out;\n}\n\ninterface Member {\n  flags: number;\n  method: number;\n  crc: number;\n  compressed: number;\n  size: number;\n  local: number;\n}\n\nasync function readMember(\n  bytes: Uint8Array,\n  view: DataView,\n  name: string,\n  m: Member,\n  inflateRaw: InflateRaw,\n): Promise<Uint8Array> {\n  if (m.flags & 0x1) throw new Error(`zip: ${name} is encrypted`);\n  if (view.getUint32(m.local, true) !== LOCAL) throw new Error(`zip: ${name}: bad local header`);\n  const start = m.local + 30 + view.getUint16(m.local + 26, true) + view.getUint16(m.local + 28, true);\n  const raw = bytes.subarray(start, start + m.compressed);\n  if (raw.length !== m.compressed) throw new Error(`zip: ${name} is truncated`);\n  let out: Uint8Array;\n  if (m.method === 0) out = raw;\n  else if (m.method === 8) out = await inflateRaw(raw);\n  else throw new Error(`zip: ${name} uses compression method ${m.method}, not stored or deflate`);\n  if (out.length !== m.size) throw new Error(`zip: ${name} is ${out.length} bytes, expected ${m.size}`);\n  if (crc32(out) !== m.crc) throw new Error(`zip: ${name} fails its CRC check`);\n  return out;\n}\n\n/** The end-of-central-directory record: the last one, within the 64 KiB a comment may take. */\nfunction findEocd(view: DataView): number {\n  const stop = Math.max(0, view.byteLength - 22 - 0xffff);\n  for (let at = view.byteLength - 22; at >= stop; at--) {\n    if (view.getUint32(at, true) === EOCD) return at;\n  }\n  throw new Error('zip: not a zip archive (no central directory)');\n}\n\n/** A little-endian u64 that fits a double (archives under 8 PB). */\nfunction num(view: DataView, at: number): number {\n  return view.getUint32(at, true) + view.getUint32(at + 4, true) * 0x100000000;\n}\n\nlet crcTable: Uint32Array | null = null;\n\n/** CRC-32 (IEEE), as zip records it. */\nexport function crc32(data: Uint8Array): number {\n  if (!crcTable) {\n    crcTable = new Uint32Array(256);\n    for (let n = 0; n < 256; n++) {\n      let c = n;\n      for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;\n      crcTable[n] = c >>> 0;\n    }\n  }\n  let c = 0xffffffff;\n  for (let i = 0; i < data.length; i++) c = crcTable[(c ^ data[i]) & 0xff] ^ (c >>> 8);\n  return (c ^ 0xffffffff) >>> 0;\n}\n\nasync function platformInflateRaw(bytes: Uint8Array): Promise<Uint8Array> {\n  if (typeof DecompressionStream === 'undefined')\n    throw new Error('zip: deflated members need DecompressionStream');\n  let inflater: DecompressionStream;\n  try {\n    // Compression Streams' raw DEFLATE (Chrome 103, Firefox 113, Safari 16.4 on).\n    inflater = new DecompressionStream('deflate-raw');\n  } catch {\n    throw new Error('zip: this browser cannot inflate zip members (no DecompressionStream \"deflate-raw\")');\n  }\n  const stream = new Blob([bytes as BlobPart]).stream().pipeThrough(inflater);\n  return new Uint8Array(await new Response(stream).arrayBuffer());\n}\n"]}