@jax-data-science/sci-image-visualizer 0.10.0 → 0.12.0

package/esm2022/lib/region-import/zarr-codecs.mjs

@@ -0,0 +1,167 @@
+/**
+ * The chunk codecs of the zarr stores label images come in (OME-Zarr `labels/`): Blosc framing
+ * with its lz4, zstd or zlib inner codecs (zarr v2's default, as ome-zarr-py writes), zstd (zarr
+ * v3's default), gzip and zlib. Anything else throws rather than be decoded wrongly. Pure: usable
+ * from workers.
+ *
+ * The Blosc framing follows jit-bioformats' `Blosc` (the decoder JIT validated on SpatialData
+ * stores): `u8 version, u8 versionlz, u8 flags, u8 typesize, u32 nbytes, u32 blocksize,
+ * u32 cbytes`, then `u32 bstarts[nblocks]`, then blocks of `nstreams` sub-streams, each
+ * `i32 csize` + bytes (a stream whose csize equals its decoded size stored raw, a negative one a
+ * run of one byte). Flags: 0x1 byte-shuffle, 0x2 memcpyed, 0x4 bit-shuffle, 0x10 no-split, bits
+ * 5-7 the inner codec.
+ */
+import { decompress as zstdDecompress } from 'fzstd';
+const BLOSC_CODECS = ['blosclz', 'lz4', 'snappy', 'zlib', 'zstd'];
+/** Decode a Blosc frame. */
+export async function bloscDecompress(frame, inflate = platformInflate) {
+    const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+    if (frame.length < 16)
+        throw new Error('blosc: frame too short');
+    const flags = frame[2];
+    const typesize = frame[3];
+    const nbytes = view.getUint32(4, true);
+    const blocksize = view.getUint32(8, true);
+    const out = new Uint8Array(nbytes);
+    if (nbytes === 0)
+        return out;
+    if (flags & 0x2) {
+        out.set(frame.subarray(16, 16 + nbytes));
+        return out;
+    }
+    if (flags & 0x4)
+        throw new Error('blosc: bit-shuffle is not supported');
+    const code = flags >>> 5;
+    const codec = BLOSC_CODECS[code] ?? `code ${code}`;
+    if (codec !== 'lz4' && codec !== 'zstd' && codec !== 'zlib') {
+        throw new Error(`blosc: inner codec ${codec} is not supported (lz4, zstd or zlib)`);
+    }
+    const shuffle = (flags & 0x1) !== 0 && typesize > 1;
+    const noSplit = (flags & 0x10) !== 0;
+    const nblocks = Math.ceil(nbytes / blocksize);
+    const scratch = shuffle ? new Uint8Array(blocksize) : null;
+    for (let blk = 0; blk < nblocks; blk++) {
+        const bsize = Math.min(blocksize, nbytes - blk * blocksize);
+        const leftover = bsize !== blocksize;
+        const nstreams = !noSplit && !leftover ? typesize : 1;
+        const ssize = Math.floor(bsize / nstreams);
+        let p = view.getUint32(16 + blk * 4, true);
+        const block = scratch ?? out;
+        const base = scratch ? 0 : blk * blocksize;
+        for (let s = 0; s < nstreams; s++) {
+            const csize = view.getInt32(p, true);
+            p += 4;
+            const dst = base + s * ssize;
+            if (csize < 0) {
+                block.fill(-csize & 0xff, dst, dst + ssize);
+                continue;
+            }
+            const src = frame.subarray(p, p + csize);
+            if (csize === ssize) {
+                block.set(src, dst);
+            }
+            else {
+                const dec = codec === 'lz4'
+                    ? lz4BlockDecompress(src, ssize)
+                    : codec === 'zstd'
+                        ? zstdDecompress(src)
+                        : await inflate(src, 'deflate');
+                if (dec.length !== ssize)
+                    throw new Error(`blosc: ${codec} produced ${dec.length} of ${ssize} bytes`);
+                block.set(dec, dst);
+            }
+            p += csize;
+        }
+        if (scratch)
+            unshuffle(scratch, bsize, typesize, out, blk * blocksize);
+    }
+    return out;
+}
+/** Decode one LZ4 block (no frame) of `size` bytes. */
+export function lz4BlockDecompress(src, size) {
+    const out = new Uint8Array(size);
+    let i = 0;
+    let o = 0;
+    while (i < src.length) {
+        const token = src[i++];
+        let literals = token >>> 4;
+        if (literals === 15) {
+            let b;
+            do {
+                b = src[i++];
+                literals += b;
+            } while (b === 255);
+        }
+        if (o + literals > size || i + literals > src.length)
+            throw new Error('lz4: literals overrun');
+        out.set(src.subarray(i, i + literals), o);
+        i += literals;
+        o += literals;
+        if (i >= src.length)
+            break; // the last sequence has no match
+        const offset = src[i] | (src[i + 1] << 8);
+        i += 2;
+        if (offset === 0 || offset > o)
+            throw new Error('lz4: bad match offset');
+        let length = (token & 15) + 4;
+        if ((token & 15) === 15) {
+            let b;
+            do {
+                b = src[i++];
+                length += b;
+            } while (b === 255);
+        }
+        if (o + length > size)
+            throw new Error('lz4: match overrun');
+        // Byte by byte: a match may overlap what it copies (a run).
+        for (let k = 0; k < length; k++, o++)
+            out[o] = out[o - offset];
+    }
+    if (o !== size)
+        throw new Error(`lz4: produced ${o} of ${size} bytes`);
+    return out;
+}
+/**
+ * Decode a zarr chunk through `codecs`, outermost last as zarr lists them (v2: the one
+ * `compressor`; v3: the bytes-to-bytes codecs after `bytes`).
+ */
+export async function decodeChunk(bytes, codecs, inflate = platformInflate) {
+    let data = bytes;
+    for (const codec of [...codecs].reverse()) {
+        switch (codec.id) {
+            case 'blosc':
+                data = await bloscDecompress(data, inflate);
+                break;
+            case 'zstd':
+                data = zstdDecompress(data);
+                break;
+            case 'gzip':
+                data = await inflate(data, 'gzip');
+                break;
+            case 'zlib':
+                data = await inflate(data, 'deflate');
+                break;
+            default:
+                throw new Error(`zarr: codec ${codec.id} is not supported (blosc, zstd, gzip, zlib)`);
+        }
+    }
+    return data;
+}
+function unshuffle(src, len, typesize, dst, off) {
+    const n = Math.floor(len / typesize);
+    for (let j = 0; j < typesize; j++) {
+        const base = j * n;
+        for (let i = 0; i < n; i++)
+            dst[off + i * typesize + j] = src[base + i];
+    }
+    // Bytes past the last whole element are not shuffled.
+    for (let k = n * typesize; k < len; k++)
+        dst[off + k] = src[k];
+}
+async function platformInflate(bytes, format) {
+    if (typeof DecompressionStream === 'undefined')
+        throw new Error(`zarr: ${format} chunks need DecompressionStream`);
+    const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream(format));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zarr-codecs.js","sourceRoot":"","sources":["../../../../src/lib/region-import/zarr-codecs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,OAAO,CAAC;AAKrD,MAAM,YAAY,GAAG,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAElE,4BAA4B;AAC5B,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,KAAiB,EAAE,UAAmB,eAAe;IACzF,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAC5E,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;IACjE,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IACvC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IAC1C,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IACnC,IAAI,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAC7B,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC;QAChB,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC;QACzC,OAAO,GAAG,CAAC;IACb,CAAC;IACD,IAAI,KAAK,GAAG,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACxE,MAAM,IAAI,GAAG,KAAK,KAAK,CAAC,CAAC;IACzB,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,QAAQ,IAAI,EAAE,CAAC;IACnD,IAAI,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,sBAAsB,KAAK,uCAAuC,CAAC,CAAC;IACtF,CAAC;IACD,MAAM,OAAO,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,QAAQ,GAAG,CAAC,CAAC;IACpD,MAAM,OAAO,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IACrC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3D,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,EAAE,GAAG,EAAE,EAAE,CAAC;QACvC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAAC,CAAC;QAC5D,MAAM,QAAQ,GAAG,KAAK,KAAK,SAAS,CAAC;QACrC,MAAM,QAAQ,GAAG,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,QAAQ,CAAC,CAAC;QAC3C,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;QAC3C,MAAM,KAAK,GAAG,OAAO,IAAI,GAAG,CAAC;QAC7B,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,SAAS,CAAC;QAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;YAClC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YACrC,CAAC,IAAI,CAAC,CAAC;YACP,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,KAAK,CAAC;YAC7B,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBACd,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC;gBAC5C,SAAS;YACX,CAAC;YACD,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC;YACzC,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;gBACpB,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,GACP,KAAK,KAAK,KAAK;oBACb,CAAC,CAAC,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC;oBAChC,CAAC,CAAC,KAAK,KAAK,MAAM;wBAChB,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC;wBACrB,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;gBACtC,IAAI,GAAG,CAAC,MAAM,KAAK,KAAK;oBAAE,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,aAAa,GAAG,CAAC,MAAM,OAAO,KAAK,QAAQ,CAAC,CAAC;gBACtG,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;YACtB,CAAC;YACD,CAAC,IAAI,KAAK,CAAC;QACb,CAAC;QACD,IAAI,OAAO;YAAE,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,kBAAkB,CAAC,GAAe,EAAE,IAAY;IAC9D,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC;QACtB,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;QACvB,IAAI,QAAQ,GAAG,KAAK,KAAK,CAAC,CAAC;QAC3B,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;YACpB,IAAI,CAAS,CAAC;YACd,GAAG,CAAC;gBACF,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;gBACb,QAAQ,IAAI,CAAC,CAAC;YAChB,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE;QACtB,CAAC;QACD,IAAI,CAAC,GAAG,QAAQ,GAAG,IAAI,IAAI,CAAC,GAAG,QAAQ,GAAG,GAAG,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC/F,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1C,CAAC,IAAI,QAAQ,CAAC;QACd,CAAC,IAAI,QAAQ,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,CAAC,MAAM;YAAE,MAAM,CAAC,iCAAiC;QAC7D,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1C,CAAC,IAAI,CAAC,CAAC;QACP,IAAI,MAAM,KAAK,CAAC,IAAI,MAAM,GAAG,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QACzE,IAAI,MAAM,GAAG,CAAC,KAAK,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC;YACxB,IAAI,CAAS,CAAC;YACd,GAAG,CAAC;gBACF,CAAC,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;gBACb,MAAM,IAAI,CAAC,CAAC;YACd,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE;QACtB,CAAC;QACD,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QAC7D,4DAA4D;QAC5D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE;YAAE,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;IACjE,CAAC;IACD,IAAI,CAAC,KAAK,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,OAAO,IAAI,QAAQ,CAAC,CAAC;IACvE,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,KAAiB,EACjB,MAAuD,EACvD,UAAmB,eAAe;IAElC,IAAI,IAAI,GAAG,KAAK,CAAC;IACjB,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;QAC1C,QAAQ,KAAK,CAAC,EAAE,EAAE,CAAC;YACjB,KAAK,OAAO;gBACV,IAAI,GAAG,MAAM,eAAe,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;gBAC5C,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC5B,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,GAAG,MAAM,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACnC,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,GAAG,MAAM,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;gBACtC,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,eAAe,KAAK,CAAC,EAAE,6CAA6C,CAAC,CAAC;QAC1F,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,SAAS,CAAC,GAAe,EAAE,GAAW,EAAE,QAAgB,EAAE,GAAe,EAAE,GAAW;IAC7F,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,QAAQ,CAAC,CAAC;IACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YAAE,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,QAAQ,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IAC1E,CAAC;IACD,sDAAsD;IACtD,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE;QAAE,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AACjE,CAAC;AAED,KAAK,UAAU,eAAe,CAAC,KAAiB,EAAE,MAA0B;IAC1E,IAAI,OAAO,mBAAmB,KAAK,WAAW;QAC5C,MAAM,IAAI,KAAK,CAAC,SAAS,MAAM,kCAAkC,CAAC,CAAC;IACrE,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,CAAC,KAAiB,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,IAAI,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;IACnG,OAAO,IAAI,UAAU,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;AAClE,CAAC","sourcesContent":["/**\n * The chunk codecs of the zarr stores label images come in (OME-Zarr `labels/`): Blosc framing\n * with its lz4, zstd or zlib inner codecs (zarr v2's default, as ome-zarr-py writes), zstd (zarr\n * v3's default), gzip and zlib. Anything else throws rather than be decoded wrongly. Pure: usable\n * from workers.\n *\n * The Blosc framing follows jit-bioformats' `Blosc` (the decoder JIT validated on SpatialData\n * stores): `u8 version, u8 versionlz, u8 flags, u8 typesize, u32 nbytes, u32 blocksize,\n * u32 cbytes`, then `u32 bstarts[nblocks]`, then blocks of `nstreams` sub-streams, each\n * `i32 csize` + bytes (a stream whose csize equals its decoded size stored raw, a negative one a\n * run of one byte). Flags: 0x1 byte-shuffle, 0x2 memcpyed, 0x4 bit-shuffle, 0x10 no-split, bits\n * 5-7 the inner codec.\n */\nimport { decompress as zstdDecompress } from 'fzstd';\n\n/** Inflate gzip or zlib data (default: the platform's `DecompressionStream`). */\nexport type Inflate = (bytes: Uint8Array, format: 'gzip' | 'deflate') => Promise<Uint8Array>;\n\nconst BLOSC_CODECS = ['blosclz', 'lz4', 'snappy', 'zlib', 'zstd'];\n\n/** Decode a Blosc frame. */\nexport async function bloscDecompress(frame: Uint8Array, inflate: Inflate = platformInflate): Promise<Uint8Array> {\n  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);\n  if (frame.length < 16) throw new Error('blosc: frame too short');\n  const flags = frame[2];\n  const typesize = frame[3];\n  const nbytes = view.getUint32(4, true);\n  const blocksize = view.getUint32(8, true);\n  const out = new Uint8Array(nbytes);\n  if (nbytes === 0) return out;\n  if (flags & 0x2) {\n    out.set(frame.subarray(16, 16 + nbytes));\n    return out;\n  }\n  if (flags & 0x4) throw new Error('blosc: bit-shuffle is not supported');\n  const code = flags >>> 5;\n  const codec = BLOSC_CODECS[code] ?? `code ${code}`;\n  if (codec !== 'lz4' && codec !== 'zstd' && codec !== 'zlib') {\n    throw new Error(`blosc: inner codec ${codec} is not supported (lz4, zstd or zlib)`);\n  }\n  const shuffle = (flags & 0x1) !== 0 && typesize > 1;\n  const noSplit = (flags & 0x10) !== 0;\n  const nblocks = Math.ceil(nbytes / blocksize);\n  const scratch = shuffle ? new Uint8Array(blocksize) : null;\n  for (let blk = 0; blk < nblocks; blk++) {\n    const bsize = Math.min(blocksize, nbytes - blk * blocksize);\n    const leftover = bsize !== blocksize;\n    const nstreams = !noSplit && !leftover ? typesize : 1;\n    const ssize = Math.floor(bsize / nstreams);\n    let p = view.getUint32(16 + blk * 4, true);\n    const block = scratch ?? out;\n    const base = scratch ? 0 : blk * blocksize;\n    for (let s = 0; s < nstreams; s++) {\n      const csize = view.getInt32(p, true);\n      p += 4;\n      const dst = base + s * ssize;\n      if (csize < 0) {\n        block.fill(-csize & 0xff, dst, dst + ssize);\n        continue;\n      }\n      const src = frame.subarray(p, p + csize);\n      if (csize === ssize) {\n        block.set(src, dst);\n      } else {\n        const dec =\n          codec === 'lz4'\n            ? lz4BlockDecompress(src, ssize)\n            : codec === 'zstd'\n              ? zstdDecompress(src)\n              : await inflate(src, 'deflate');\n        if (dec.length !== ssize) throw new Error(`blosc: ${codec} produced ${dec.length} of ${ssize} bytes`);\n        block.set(dec, dst);\n      }\n      p += csize;\n    }\n    if (scratch) unshuffle(scratch, bsize, typesize, out, blk * blocksize);\n  }\n  return out;\n}\n\n/** Decode one LZ4 block (no frame) of `size` bytes. */\nexport function lz4BlockDecompress(src: Uint8Array, size: number): Uint8Array {\n  const out = new Uint8Array(size);\n  let i = 0;\n  let o = 0;\n  while (i < src.length) {\n    const token = src[i++];\n    let literals = token >>> 4;\n    if (literals === 15) {\n      let b: number;\n      do {\n        b = src[i++];\n        literals += b;\n      } while (b === 255);\n    }\n    if (o + literals > size || i + literals > src.length) throw new Error('lz4: literals overrun');\n    out.set(src.subarray(i, i + literals), o);\n    i += literals;\n    o += literals;\n    if (i >= src.length) break; // the last sequence has no match\n    const offset = src[i] | (src[i + 1] << 8);\n    i += 2;\n    if (offset === 0 || offset > o) throw new Error('lz4: bad match offset');\n    let length = (token & 15) + 4;\n    if ((token & 15) === 15) {\n      let b: number;\n      do {\n        b = src[i++];\n        length += b;\n      } while (b === 255);\n    }\n    if (o + length > size) throw new Error('lz4: match overrun');\n    // Byte by byte: a match may overlap what it copies (a run).\n    for (let k = 0; k < length; k++, o++) out[o] = out[o - offset];\n  }\n  if (o !== size) throw new Error(`lz4: produced ${o} of ${size} bytes`);\n  return out;\n}\n\n/**\n * Decode a zarr chunk through `codecs`, outermost last as zarr lists them (v2: the one\n * `compressor`; v3: the bytes-to-bytes codecs after `bytes`).\n */\nexport async function decodeChunk(\n  bytes: Uint8Array,\n  codecs: readonly { id: string; [k: string]: unknown }[],\n  inflate: Inflate = platformInflate,\n): Promise<Uint8Array> {\n  let data = bytes;\n  for (const codec of [...codecs].reverse()) {\n    switch (codec.id) {\n      case 'blosc':\n        data = await bloscDecompress(data, inflate);\n        break;\n      case 'zstd':\n        data = zstdDecompress(data);\n        break;\n      case 'gzip':\n        data = await inflate(data, 'gzip');\n        break;\n      case 'zlib':\n        data = await inflate(data, 'deflate');\n        break;\n      default:\n        throw new Error(`zarr: codec ${codec.id} is not supported (blosc, zstd, gzip, zlib)`);\n    }\n  }\n  return data;\n}\n\nfunction unshuffle(src: Uint8Array, len: number, typesize: number, dst: Uint8Array, off: number): void {\n  const n = Math.floor(len / typesize);\n  for (let j = 0; j < typesize; j++) {\n    const base = j * n;\n    for (let i = 0; i < n; i++) dst[off + i * typesize + j] = src[base + i];\n  }\n  // Bytes past the last whole element are not shuffled.\n  for (let k = n * typesize; k < len; k++) dst[off + k] = src[k];\n}\n\nasync function platformInflate(bytes: Uint8Array, format: 'gzip' | 'deflate'): Promise<Uint8Array> {\n  if (typeof DecompressionStream === 'undefined')\n    throw new Error(`zarr: ${format} chunks need DecompressionStream`);\n  const stream = new Blob([bytes as BlobPart]).stream().pipeThrough(new DecompressionStream(format));\n  return new Uint8Array(await new Response(stream).arrayBuffer());\n}\n"]}

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"]}