@ifc-lite/viewer 1.18.0 → 1.19.1

package/dist/assets/decode-worker-Collf_X_.js

@@ -0,0 +1,1320 @@
+(async ()=>{
+    function Et(n) {
+        const t = n.positions.buffer, e = [
+            t
+        ], o = {
+            positions: t,
+            pointCount: n.pointCount,
+            bbox: n.bbox
+        };
+        if (n.colors) {
+            const r = n.colors.buffer;
+            o.colors = r, e.push(r);
+        }
+        if (n.classifications) {
+            const r = n.classifications.buffer;
+            o.classifications = r, e.push(r);
+        }
+        if (n.intensities) {
+            const r = n.intensities.buffer;
+            o.intensities = r, e.push(r);
+        }
+        return {
+            payload: o,
+            transfer: e
+        };
+    }
+    const Ft = 1179861324, rt = {
+        0: 20,
+        1: 28,
+        2: 26,
+        3: 34,
+        4: 57,
+        5: 63,
+        6: 30,
+        7: 36,
+        8: 38,
+        9: 59,
+        10: 67
+    }, It = new Set([
+        1,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ]), At = new Set([
+        2,
+        3,
+        5,
+        7,
+        8,
+        10
+    ]);
+    function ft(n) {
+        const t = n instanceof Uint8Array ? n : new Uint8Array(n);
+        if (t.length < 227) throw new Error("LAS: header truncated");
+        const e = new DataView(t.buffer, t.byteOffset, t.byteLength);
+        if (e.getUint32(0, !0) !== Ft) throw new Error('LAS: bad magic — expected "LASF"');
+        const o = e.getUint8(24), r = e.getUint8(25), a = e.getUint16(94, !0), l = e.getUint32(96, !0), c = e.getUint32(100, !0), i = e.getUint8(104) & 63, s = e.getUint16(105, !0);
+        let g = e.getUint32(107, !0);
+        if (o >= 1 && r >= 4 && t.length >= 255) {
+            const x = Lt(e, 247);
+            x > 0 && (g = x);
+        }
+        if (!Number.isFinite(g) || g < 0) throw new Error("LAS: invalid point count");
+        const h = [
+            e.getFloat64(131, !0),
+            e.getFloat64(139, !0),
+            e.getFloat64(147, !0)
+        ], p = [
+            e.getFloat64(155, !0),
+            e.getFloat64(163, !0),
+            e.getFloat64(171, !0)
+        ], f = e.getFloat64(179, !0), d = e.getFloat64(187, !0), m = e.getFloat64(195, !0), w = e.getFloat64(203, !0), b = e.getFloat64(211, !0), C = e.getFloat64(219, !0), F = {
+            min: [
+                d,
+                w,
+                C
+            ],
+            max: [
+                f,
+                m,
+                b
+            ]
+        };
+        if (rt[i] === void 0) throw new Error(`LAS: unsupported point data format ${i}`);
+        const E = rt[i];
+        if (s < E) throw new Error(`LAS: header point-record length (${s}) smaller than format ${i} baseline (${E})`);
+        return {
+            versionMajor: o,
+            versionMinor: r,
+            headerSize: a,
+            pointDataOffset: l,
+            numberOfVlrs: c,
+            pointDataFormatId: i,
+            pointRecordLength: s,
+            pointCount: g,
+            scale: h,
+            offset: p,
+            bbox: F,
+            hasGpsTime: It.has(i),
+            hasRgb: At.has(i)
+        };
+    }
+    function G(n, t, e, o = t.pointRecordLength, r = 1) {
+        if (n.length < e * o) throw new Error(`LAS: decode expects ${e * o} bytes, got ${n.length}`);
+        const a = new DataView(n.buffer, n.byteOffset, n.byteLength), l = new Float32Array(e * 3), c = new Uint16Array(e), i = new Uint8Array(e), s = t.hasRgb ? new Float32Array(e * 3) : void 0, u = dt(t.pointDataFormatId), g = t.pointDataFormatId >= 6 ? 16 : 15;
+        let h = 1 / 0, p = 1 / 0, f = 1 / 0, d = -1 / 0, m = -1 / 0, w = -1 / 0;
+        for(let b = 0; b < e; b++){
+            const C = b * o, F = a.getInt32(C, !0) * t.scale[0] + t.offset[0], E = a.getInt32(C + 4, !0) * t.scale[1] + t.offset[1], x = a.getInt32(C + 8, !0) * t.scale[2] + t.offset[2];
+            if (l[b * 3] = F, l[b * 3 + 1] = E, l[b * 3 + 2] = x, F < h && (h = F), F > d && (d = F), E < p && (p = E), E > m && (m = E), x < f && (f = x), x > w && (w = x), c[b] = a.getUint16(C + 12, !0), i[b] = t.pointDataFormatId >= 6 ? a.getUint8(C + g) : a.getUint8(C + g) & 31, s && u >= 0) {
+                const L = a.getUint16(C + u, !0), A = a.getUint16(C + u + 2, !0), Z = a.getUint16(C + u + 4, !0);
+                s[b * 3] = L * r / 65535, s[b * 3 + 1] = A * r / 65535, s[b * 3 + 2] = Z * r / 65535;
+            }
+        }
+        return {
+            positions: l,
+            colors: s,
+            classifications: i,
+            intensities: c,
+            pointCount: e,
+            bbox: {
+                min: [
+                    h,
+                    p,
+                    f
+                ],
+                max: [
+                    d,
+                    m,
+                    w
+                ]
+            }
+        };
+    }
+    function ut(n, t, e = 1024) {
+        if (!t.hasRgb) return 0;
+        const o = t.pointRecordLength, r = Math.min(t.pointCount, Math.floor(n.length / o));
+        if (r === 0) return 0;
+        const a = new DataView(n.buffer, n.byteOffset, n.byteLength), l = dt(t.pointDataFormatId);
+        if (l < 0) return 0;
+        const c = Math.max(1, Math.floor(r / Math.min(e, r)));
+        let i = 0;
+        for(let s = 0; s < r; s += c){
+            const u = s * o, g = a.getUint16(u + l, !0), h = a.getUint16(u + l + 2, !0), p = a.getUint16(u + l + 4, !0);
+            g > i && (i = g), h > i && (i = h), p > i && (i = p);
+        }
+        return i;
+    }
+    function dt(n) {
+        switch(n){
+            case 2:
+                return 20;
+            case 3:
+                return 28;
+            case 5:
+                return 28;
+            case 7:
+                return 30;
+            case 8:
+                return 30;
+            case 10:
+                return 30;
+            default:
+                return -1;
+        }
+    }
+    function Lt(n, t) {
+        const e = n.getUint32(t, !0);
+        return n.getUint32(t + 4, !0) * 4294967296 + e;
+    }
+    class Pt {
+        constructor(t){
+            this.blob = t;
+        }
+        get size() {
+            return this.blob.size;
+        }
+        async read(t, e) {
+            const o = Math.max(0, t), r = Math.min(e, this.blob.size);
+            if (r <= o) return new Uint8Array(0);
+            const l = await this.blob.slice(o, r).arrayBuffer();
+            return new Uint8Array(l);
+        }
+    }
+    const St = 1024, Mt = 4096;
+    class Ut {
+        bytes;
+        header = null;
+        cursor = 0;
+        rgbScale = 1;
+        downsample;
+        label;
+        constructor(t, e = {}){
+            this.bytes = new Pt(t), this.downsample = e.downsample ?? {
+                stride: 1
+            }, this.label = e.label;
+        }
+        async open(t) {
+            if (this.header) return this.toInfo(this.header);
+            z(t);
+            const e = await this.bytes.read(0, St);
+            z(t);
+            const o = ft(e);
+            let r = 1;
+            if (o.hasRgb) {
+                const a = Math.min(Mt * o.pointRecordLength, Math.max(0, this.bytes.size - o.pointDataOffset));
+                if (a > 0) {
+                    const l = await this.bytes.read(o.pointDataOffset, o.pointDataOffset + a);
+                    z(t);
+                    const c = ut(l, o);
+                    r = c > 0 && c <= 255 ? 65535 / 255 : 1;
+                }
+            }
+            return this.header = o, this.rgbScale = r, this.cursor = 0, this.toInfo(o);
+        }
+        async next(t, e) {
+            if (z(e), !Number.isFinite(t) || t <= 0) throw new Error(`LasStreamingSource: maxPoints must be > 0 (got ${t})`);
+            if (!this.header) throw new Error("LasStreamingSource: open() must be awaited before next()");
+            const o = Math.max(1, this.downsample.stride | 0);
+            if (this.cursor >= this.header.pointCount) return null;
+            if (o === 1) {
+                const p = this.header.pointCount - this.cursor, f = Math.min(t, p), d = this.header.pointDataOffset + this.cursor * this.header.pointRecordLength, m = d + f * this.header.pointRecordLength, w = await this.bytes.read(d, m);
+                z(e);
+                const b = G(w, this.header, f, this.header.pointRecordLength, this.rgbScale);
+                return this.cursor += f, b;
+            }
+            const r = this.header.pointCount - this.cursor, a = Math.min(t * o, r), l = Math.ceil(a / o), c = this.header.pointDataOffset + this.cursor * this.header.pointRecordLength, i = c + a * this.header.pointRecordLength, s = await this.bytes.read(c, i);
+            z(e);
+            const u = new Uint8Array(l * this.header.pointRecordLength);
+            let g = 0;
+            for(let p = 0; p < l; p++){
+                const f = p * o * this.header.pointRecordLength;
+                u.set(s.subarray(f, f + this.header.pointRecordLength), g), g += this.header.pointRecordLength;
+            }
+            const h = G(u, this.header, l, this.header.pointRecordLength, this.rgbScale);
+            return this.cursor += a, h;
+        }
+        close() {
+            this.header = null, this.cursor = 0;
+        }
+        toInfo(t) {
+            const e = Math.max(1, this.downsample.stride | 0);
+            return {
+                totalPointCount: e === 1 ? t.pointCount : Math.ceil(t.pointCount / e),
+                bbox: t.bbox,
+                hasColor: t.hasRgb,
+                hasClassification: !0,
+                hasIntensity: !0,
+                label: this.label
+            };
+        }
+    }
+    function z(n) {
+        if (n?.aborted) throw new DOMException("Aborted", "AbortError");
+    }
+    let X = null;
+    async function zt() {
+        return X || (X = (async ()=>{
+            const n = await import("./index-XwKzDuw6.js").then(function(r) {
+                return r.i;
+            }), t = n.default, o = [
+                n.createLazPerf,
+                typeof t == "object" && t !== null ? t.createLazPerf : void 0,
+                t,
+                n
+            ].find((r)=>typeof r == "function");
+            if (!o) {
+                const r = Object.keys(n).join(", ");
+                throw new Error(`laz-perf: could not find createLazPerf factory (saw keys: ${r || "<empty>"})`);
+            }
+            return o();
+        })()), X;
+    }
+    class Ot {
+        blob;
+        downsample;
+        label;
+        mod = null;
+        laszip = null;
+        header = null;
+        fileBytes = null;
+        filePtr = 0;
+        pointPtr = 0;
+        pointBuffer = null;
+        cursor = 0;
+        rgbScale = 1;
+        constructor(t, e = {}){
+            this.blob = t, this.downsample = e.downsample ?? {
+                stride: 1
+            }, this.label = e.label;
+        }
+        async open(t) {
+            if (this.header) return this.toInfo(this.header);
+            N(t);
+            let e, o = 0, r = 0, a;
+            try {
+                const l = await this.blob.arrayBuffer();
+                N(t);
+                const c = new Uint8Array(l), i = ft(c);
+                e = await zt(), N(t), o = e._malloc(c.byteLength), e.HEAPU8.set(c, o), a = new e.LASZip, a.open(o, c.byteLength);
+                const s = a.getPointLength();
+                r = e._malloc(s);
+                const u = new Uint8Array(s);
+                let g = 1;
+                if (i.hasRgb) {
+                    const h = Math.min(4096, i.pointCount), p = new Uint8Array(h * s);
+                    for(let d = 0; d < h; d++)a.getPoint(r), p.set(e.HEAPU8.subarray(r, r + s), d * s);
+                    const f = ut(p, i);
+                    g = f > 0 && f <= 255 ? 65535 / 255 : 1, a.delete(), a = new e.LASZip, a.open(o, c.byteLength);
+                }
+                return this.fileBytes = c, this.mod = e, this.filePtr = o, this.laszip = a, this.pointPtr = r, this.pointBuffer = u, this.rgbScale = g, this.header = i, this.cursor = 0, this.toInfo(i);
+            } catch (l) {
+                try {
+                    a?.delete();
+                } catch  {}
+                if (e && r) try {
+                    e._free(r);
+                } catch  {}
+                if (e && o) try {
+                    e._free(o);
+                } catch  {}
+                throw l;
+            }
+        }
+        async next(t, e) {
+            if (N(e), !Number.isFinite(t) || t <= 0) throw new Error(`LazStreamingSource: maxPoints must be > 0 (got ${t})`);
+            if (!this.header || !this.mod || !this.laszip || !this.pointBuffer) throw new Error("LazStreamingSource: open() must be awaited before next()");
+            const o = Math.max(1, this.downsample.stride | 0);
+            if (this.cursor >= this.header.pointCount) return null;
+            const r = this.pointBuffer.byteLength, a = this.header.pointCount - this.cursor, l = Math.min(o === 1 ? t : t * o, a), c = o === 1 ? l : Math.ceil(l / o), i = new Uint8Array(c * r);
+            let s = 0;
+            for(let u = 0; u < l; u++)this.laszip.getPoint(this.pointPtr), (o === 1 || u % o === 0) && (i.set(this.mod.HEAPU8.subarray(this.pointPtr, this.pointPtr + r), s * r), s++);
+            return this.cursor += l, G(i, this.header, c, r, this.rgbScale);
+        }
+        close() {
+            try {
+                this.laszip?.delete();
+            } catch  {}
+            if (this.mod && this.pointPtr) try {
+                this.mod._free(this.pointPtr);
+            } catch  {}
+            if (this.mod && this.filePtr) try {
+                this.mod._free(this.filePtr);
+            } catch  {}
+            this.laszip = null, this.mod = null, this.header = null, this.fileBytes = null, this.pointBuffer = null, this.filePtr = 0, this.pointPtr = 0, this.cursor = 0;
+        }
+        toInfo(t) {
+            const e = Math.max(1, this.downsample.stride | 0);
+            return {
+                totalPointCount: e === 1 ? t.pointCount : Math.ceil(t.pointCount / e),
+                bbox: t.bbox,
+                hasColor: t.hasRgb,
+                hasClassification: !0,
+                hasIntensity: !0,
+                label: this.label
+            };
+        }
+    }
+    function N(n) {
+        if (n?.aborted) throw new DOMException("Aborted", "AbortError");
+    }
+    const Dt = {
+        char: 1,
+        int8: 1,
+        uchar: 1,
+        uint8: 1,
+        short: 2,
+        int16: 2,
+        ushort: 2,
+        uint16: 2,
+        int: 4,
+        int32: 4,
+        uint: 4,
+        uint32: 4,
+        float: 4,
+        float32: 4,
+        double: 8,
+        float64: 8
+    }, ht = new TextDecoder;
+    function pt(n) {
+        const t = Math.min(65536, n.length), e = ht.decode(n.subarray(0, t));
+        if (!e.startsWith("ply")) throw new Error('PLY: missing magic — file does not start with "ply"');
+        const o = e.indexOf("end_header");
+        if (o < 0) throw new Error("PLY: missing end_header line in first " + t + " bytes");
+        const r = e.indexOf(`
+`, o);
+        if (r < 0) throw new Error("PLY: end_header line not terminated by newline");
+        const a = e.slice(0, r + 1), l = r + 1, c = a.split(`
+`).map((h)=>h.trim()).filter((h)=>h.length > 0);
+        let i = null, s = "1.0";
+        const u = [];
+        let g = null;
+        for (const h of c)if (!(h === "ply" || h === "end_header") && !h.startsWith("comment") && !h.startsWith("obj_info")) {
+            if (h.startsWith("format ")) {
+                const p = h.split(/\s+/), f = p[1];
+                if (s = p[2] ?? "1.0", f === "ascii" || f === "binary_little_endian" || f === "binary_big_endian") i = f;
+                else throw new Error(`PLY: unsupported format "${f}"`);
+                continue;
+            }
+            if (h.startsWith("element ")) {
+                const p = h.split(/\s+/);
+                g = {
+                    name: p[1],
+                    count: parseInt(p[2], 10),
+                    properties: [],
+                    recordSize: 0
+                }, u.push(g);
+                continue;
+            }
+            if (h.startsWith("property ")) {
+                if (!g) throw new Error(`PLY: property declared before any element: "${h}"`);
+                const p = h.split(/\s+/);
+                if (p[1] === "list") continue;
+                const f = p[1], d = p[2], m = Dt[f];
+                if (m === void 0) throw new Error(`PLY: unknown property type "${f}"`);
+                g.properties.push({
+                    name: d,
+                    type: f,
+                    size: m,
+                    offset: g.recordSize
+                }), g.recordSize += m;
+                continue;
+            }
+        }
+        if (!i) throw new Error("PLY: missing `format` line in header");
+        if (!u.some((h)=>h.name === "vertex")) throw new Error("PLY: missing `vertex` element");
+        return {
+            format: i,
+            version: s,
+            elements: u,
+            bodyOffset: l
+        };
+    }
+    function $t(n) {
+        const t = pt(n), e = t.elements.find((d)=>d.name === "vertex");
+        if (!e) throw new Error("PLY: no vertex element");
+        if (t.elements[0] !== e) throw new Error(`PLY: vertex element must appear first; saw "${t.elements[0]?.name}" first`);
+        const o = e.properties.find((d)=>d.name === "x"), r = e.properties.find((d)=>d.name === "y"), a = e.properties.find((d)=>d.name === "z");
+        if (!o || !r || !a) throw new Error("PLY: vertex element must define x, y, z properties");
+        const l = e.properties.find((d)=>d.name === "red" || d.name === "r"), c = e.properties.find((d)=>d.name === "green" || d.name === "g"), i = e.properties.find((d)=>d.name === "blue" || d.name === "b"), s = !!(l && c && i), u = e.properties.find((d)=>d.name === "intensity" || d.name === "scalar_Intensity"), g = e.count, h = new Float32Array(g * 3), p = s ? new Float32Array(g * 3) : void 0, f = u ? new Uint16Array(g) : void 0;
+        return t.format === "ascii" ? Bt(n, t, e, h, p, f) : Rt(n, t, e, h, p, f, t.format === "binary_little_endian"), {
+            positions: h,
+            colors: p,
+            intensities: f,
+            pointCount: g,
+            bbox: _t(h)
+        };
+    }
+    function Bt(n, t, e, o, r, a) {
+        const l = ht.decode(n.subarray(t.bodyOffset)), c = e.properties.findIndex((m)=>m.name === "x"), i = e.properties.findIndex((m)=>m.name === "y"), s = e.properties.findIndex((m)=>m.name === "z"), u = e.properties.findIndex((m)=>m.name === "red" || m.name === "r"), g = e.properties.findIndex((m)=>m.name === "green" || m.name === "g"), h = e.properties.findIndex((m)=>m.name === "blue" || m.name === "b"), p = e.properties.findIndex((m)=>m.name === "intensity" || m.name === "scalar_Intensity");
+        let f = 0, d = 0;
+        for(; d < e.count && f < l.length;){
+            let m = l.indexOf(`
+`, f);
+            m < 0 && (m = l.length);
+            const w = l.slice(f, m).trim();
+            if (f = m + 1, !w) continue;
+            const b = w.split(/\s+/);
+            o[d * 3] = Number(b[c]), o[d * 3 + 1] = Number(b[i]), o[d * 3 + 2] = Number(b[s]), r && u >= 0 && g >= 0 && h >= 0 && (r[d * 3] = $(Number(b[u]) / 255), r[d * 3 + 1] = $(Number(b[g]) / 255), r[d * 3 + 2] = $(Number(b[h]) / 255)), a && p >= 0 && (a[d] = Math.min(65535, Math.max(0, Number(b[p]) | 0))), d++;
+        }
+        if (d !== e.count) throw new Error(`PLY ascii: expected ${e.count} vertex lines, got ${d}`);
+    }
+    function Rt(n, t, e, o, r, a, l) {
+        const c = e.recordSize, i = e.count * c;
+        if (n.length < t.bodyOffset + i) throw new Error(`PLY binary: expected ${i} body bytes, got ${n.length - t.bodyOffset}`);
+        const s = new DataView(n.buffer, n.byteOffset + t.bodyOffset, i), u = e.properties.find((w)=>w.name === "x"), g = e.properties.find((w)=>w.name === "y"), h = e.properties.find((w)=>w.name === "z"), p = r ? e.properties.find((w)=>w.name === "red" || w.name === "r") : void 0, f = r ? e.properties.find((w)=>w.name === "green" || w.name === "g") : void 0, d = r ? e.properties.find((w)=>w.name === "blue" || w.name === "b") : void 0, m = a ? e.properties.find((w)=>w.name === "intensity" || w.name === "scalar_Intensity") : void 0;
+        for(let w = 0; w < e.count; w++){
+            const b = w * c;
+            o[w * 3] = M(s, b + u.offset, u, l), o[w * 3 + 1] = M(s, b + g.offset, g, l), o[w * 3 + 2] = M(s, b + h.offset, h, l), r && p && f && d && (r[w * 3] = $(M(s, b + p.offset, p, l) / 255), r[w * 3 + 1] = $(M(s, b + f.offset, f, l) / 255), r[w * 3 + 2] = $(M(s, b + d.offset, d, l) / 255)), a && m && (a[w] = Math.min(65535, Math.max(0, M(s, b + m.offset, m, l) | 0)));
+        }
+    }
+    function M(n, t, e, o) {
+        switch(e.type){
+            case "char":
+            case "int8":
+                return n.getInt8(t);
+            case "uchar":
+            case "uint8":
+                return n.getUint8(t);
+            case "short":
+            case "int16":
+                return n.getInt16(t, o);
+            case "ushort":
+            case "uint16":
+                return n.getUint16(t, o);
+            case "int":
+            case "int32":
+                return n.getInt32(t, o);
+            case "uint":
+            case "uint32":
+                return n.getUint32(t, o);
+            case "float":
+            case "float32":
+                return n.getFloat32(t, o);
+            case "double":
+            case "float64":
+                return n.getFloat64(t, o);
+            default:
+                throw new Error(`PLY: cannot read scalar of type "${e.type}"`);
+        }
+    }
+    function $(n) {
+        return n < 0 ? 0 : n > 1 ? 1 : n;
+    }
+    function _t(n) {
+        let t = 1 / 0, e = 1 / 0, o = 1 / 0, r = -1 / 0, a = -1 / 0, l = -1 / 0;
+        for(let c = 0; c < n.length; c += 3){
+            const i = n[c], s = n[c + 1], u = n[c + 2];
+            i < t && (t = i), i > r && (r = i), s < e && (e = s), s > a && (a = s), u < o && (o = u), u > l && (l = u);
+        }
+        return {
+            min: [
+                t,
+                e,
+                o
+            ],
+            max: [
+                r,
+                a,
+                l
+            ]
+        };
+    }
+    class Tt {
+        blob;
+        downsample;
+        label;
+        chunk = null;
+        served = !1;
+        constructor(t, e = {}){
+            this.blob = t, this.downsample = e.downsample ?? {
+                stride: 1
+            }, this.label = e.label;
+        }
+        async open(t) {
+            V(t);
+            const e = await this.blob.arrayBuffer();
+            V(t);
+            const o = new Uint8Array(e), a = pt(o).elements.find((s)=>s.name === "vertex");
+            if (!a) throw new Error("PLY: no vertex element");
+            const l = !!a.properties.find((s)=>s.name === "red" || s.name === "r") && !!a.properties.find((s)=>s.name === "green" || s.name === "g") && !!a.properties.find((s)=>s.name === "blue" || s.name === "b"), c = !!a.properties.find((s)=>s.name === "intensity" || s.name === "scalar_Intensity"), i = $t(o);
+            return this.chunk = Yt(i, this.downsample.stride), {
+                totalPointCount: this.chunk.pointCount,
+                bbox: this.chunk.bbox,
+                hasColor: l,
+                hasClassification: !1,
+                hasIntensity: c,
+                label: this.label
+            };
+        }
+        async next(t, e) {
+            return V(e), !this.chunk || this.served ? null : (this.served = !0, this.chunk);
+        }
+        close() {
+            this.chunk = null, this.served = !1;
+        }
+    }
+    function Yt(n, t) {
+        const e = Math.max(1, t | 0);
+        if (e === 1) return n;
+        const o = Math.ceil(n.pointCount / e), r = new Float32Array(o * 3), a = n.colors ? new Float32Array(o * 3) : void 0, l = n.classifications ? new Uint8Array(o) : void 0, c = n.intensities ? new Uint16Array(o) : void 0;
+        let i = 0;
+        for(let s = 0; s < n.pointCount; s += e)r[i * 3] = n.positions[s * 3], r[i * 3 + 1] = n.positions[s * 3 + 1], r[i * 3 + 2] = n.positions[s * 3 + 2], a && n.colors && (a[i * 3] = n.colors[s * 3], a[i * 3 + 1] = n.colors[s * 3 + 1], a[i * 3 + 2] = n.colors[s * 3 + 2]), l && n.classifications && (l[i] = n.classifications[s]), c && n.intensities && (c[i] = n.intensities[s]), i++;
+        return {
+            positions: r,
+            colors: a,
+            classifications: l,
+            intensities: c,
+            pointCount: o,
+            bbox: n.bbox
+        };
+    }
+    function V(n) {
+        if (n?.aborted) throw new DOMException("Aborted", "AbortError");
+    }
+    function vt(n, t) {
+        const e = new Uint8Array(t);
+        let o = 0, r = 0;
+        const a = n.length;
+        for(; o < a;){
+            let l = n[o++];
+            if (l < 32) {
+                const c = l + 1;
+                if (o + c > a) throw new Error("LZF: literal run exceeds input bounds");
+                if (r + c > t) throw new Error("LZF: literal run exceeds output bounds");
+                e.set(n.subarray(o, o + c), r), o += c, r += c;
+            } else {
+                let c = l >> 5;
+                if (c === 7) {
+                    if (o >= a) throw new Error("LZF: truncated extended length");
+                    c += n[o++];
+                }
+                if (c += 2, o >= a) throw new Error("LZF: truncated back-reference offset");
+                const i = r - ((l & 31) << 8) - n[o++] - 1;
+                if (i < 0) throw new Error("LZF: back-reference points before output start");
+                if (r + c > t) throw new Error("LZF: back-reference exceeds output bounds");
+                for(let s = 0; s < c; s++)e[r + s] = e[i + s];
+                r += c;
+            }
+        }
+        if (r !== t) throw new Error(`LZF: decompressed ${r} bytes, expected ${t}`);
+        return e;
+    }
+    const mt = new TextDecoder;
+    function Nt(n) {
+        const t = Zt(n);
+        let e, o;
+        return t.data === "ascii" ? { positions: e, colors: o } = kt(n, t) : t.data === "binary" ? { positions: e, colors: o } = Vt(n, t) : { positions: e, colors: o } = qt(n, t), {
+            positions: e,
+            colors: o,
+            pointCount: t.pointCount,
+            bbox: jt(e)
+        };
+    }
+    function Zt(n) {
+        const t = Math.min(65536, n.length), e = mt.decode(n.subarray(0, t)), o = e.search(/^DATA\s+(\S+)/m);
+        if (o < 0) throw new Error("PCD: missing DATA line in header (scanned first " + t + " bytes)");
+        const r = e.slice(0, o), a = e.slice(o).match(/^DATA\s+(\S+)\s*\n/);
+        if (!a) throw new Error("PCD: malformed DATA line");
+        const l = a[1].toLowerCase();
+        if (l !== "ascii" && l !== "binary" && l !== "binary_compressed") throw new Error(`PCD: unsupported DATA kind "${l}"`);
+        const c = o + a[0].length, i = new Map;
+        for (const E of r.split(`
+`)){
+            const x = E.replace(/#.*$/, "").trim();
+            if (!x) continue;
+            const L = x.split(/\s+/), A = L[0].toUpperCase();
+            i.set(A, L.slice(1));
+        }
+        const s = i.get("FIELDS") ?? [], u = (i.get("SIZE") ?? []).map(Number), g = i.get("TYPE") ?? [], h = (i.get("COUNT") ?? []).map(Number), p = i.get("WIDTH")?.[0], f = i.get("HEIGHT")?.[0], d = i.get("POINTS")?.[0];
+        if (s.length === 0) throw new Error("PCD: missing FIELDS");
+        if (u.length !== s.length) throw new Error("PCD: SIZE/FIELDS length mismatch");
+        if (g.length !== s.length) throw new Error("PCD: TYPE/FIELDS length mismatch");
+        const m = [];
+        let w = 0;
+        for(let E = 0; E < s.length; E++){
+            const x = h[E] ?? 1, L = u[E], A = g[E];
+            if (A !== "F" && A !== "I" && A !== "U") throw new Error(`PCD: unsupported field TYPE "${A}"`);
+            m.push({
+                name: s[E],
+                size: L,
+                type: A,
+                count: x,
+                offset: w
+            }), w += L * x;
+        }
+        const b = p !== void 0 ? parseInt(p, 10) : 0, C = f !== void 0 ? parseInt(f, 10) : 1, F = d !== void 0 ? parseInt(d, 10) : b * C;
+        if (!Number.isFinite(F) || F <= 0) throw new Error("PCD: invalid point count");
+        return {
+            version: i.get("VERSION")?.[0] ?? "0.7",
+            fields: m,
+            width: b,
+            height: C,
+            pointCount: F,
+            pointStride: w,
+            data: l,
+            bodyOffset: c
+        };
+    }
+    function K(n) {
+        const t = {};
+        for (const e of n.fields){
+            const o = e.name.toLowerCase();
+            o === "x" ? t.xField = e : o === "y" ? t.yField = e : o === "z" ? t.zField = e : (o === "rgb" || o === "rgba") && (t.rgbField = e);
+        }
+        if (!t.xField || !t.yField || !t.zField) throw new Error("PCD: x/y/z fields are required");
+        return t;
+    }
+    function kt(n, t) {
+        const e = K(t), o = mt.decode(n.subarray(t.bodyOffset)), r = new Float32Array(t.pointCount * 3), a = e.rgbField ? new Float32Array(t.pointCount * 3) : void 0, l = Xt(t, e);
+        let c = 0, i = 0, s = 0;
+        for(; s < t.pointCount && i < o.length;){
+            let u = o.indexOf(`
+`, i);
+            u < 0 && (u = o.length);
+            const g = o.slice(i, u).trim();
+            if (i = u + 1, !g) continue;
+            const h = g.split(/\s+/);
+            if (r[c * 3] = Number(h[l.xCol]), r[c * 3 + 1] = Number(h[l.yCol]), r[c * 3 + 2] = Number(h[l.zCol]), a && l.rgbCol >= 0) {
+                const p = Gt(h[l.rgbCol], e.rgbField);
+                a[c * 3] = (p >> 16 & 255) / 255, a[c * 3 + 1] = (p >> 8 & 255) / 255, a[c * 3 + 2] = (p & 255) / 255;
+            }
+            c++, s++;
+        }
+        if (s !== t.pointCount) throw new Error(`PCD ascii: expected ${t.pointCount} points, got ${s}`);
+        return {
+            positions: r,
+            colors: a
+        };
+    }
+    function Xt(n, t) {
+        let e = 0, o = -1, r = -1, a = -1, l = -1;
+        for (const c of n.fields)c === t.xField && (o = e), c === t.yField && (r = e), c === t.zField && (a = e), c === t.rgbField && (l = e), e += c.count;
+        return {
+            xCol: o,
+            yCol: r,
+            zCol: a,
+            rgbCol: l
+        };
+    }
+    function Vt(n, t) {
+        const e = K(t), o = new DataView(n.buffer, n.byteOffset + t.bodyOffset, t.pointCount * t.pointStride), r = new Float32Array(t.pointCount * 3), a = e.rgbField ? new Float32Array(t.pointCount * 3) : void 0;
+        for(let l = 0; l < t.pointCount; l++){
+            const c = l * t.pointStride;
+            if (r[l * 3] = B(o, c + e.xField.offset, e.xField), r[l * 3 + 1] = B(o, c + e.yField.offset, e.yField), r[l * 3 + 2] = B(o, c + e.zField.offset, e.zField), a && e.rgbField) {
+                const i = o.getUint32(c + e.rgbField.offset, !0);
+                a[l * 3] = (i >> 16 & 255) / 255, a[l * 3 + 1] = (i >> 8 & 255) / 255, a[l * 3 + 2] = (i & 255) / 255;
+            }
+        }
+        return {
+            positions: r,
+            colors: a
+        };
+    }
+    function qt(n, t) {
+        if (n.length < t.bodyOffset + 8) throw new Error("PCD binary_compressed: truncated size header");
+        const e = new DataView(n.buffer, n.byteOffset + t.bodyOffset, 8), o = e.getUint32(0, !0), r = e.getUint32(4, !0), a = t.pointCount * t.pointStride;
+        if (r !== a) throw new Error(`PCD binary_compressed: declared uncompressed=${r} does not match fields*points=${a}`);
+        const l = n.subarray(t.bodyOffset + 8, t.bodyOffset + 8 + o), c = vt(l, r), i = K(t), s = new Map;
+        let u = 0;
+        for (const b of t.fields)s.set(b, u), u += t.pointCount * b.size * b.count;
+        const g = new DataView(c.buffer, c.byteOffset, c.byteLength), h = new Float32Array(t.pointCount * 3), p = i.rgbField ? new Float32Array(t.pointCount * 3) : void 0, f = s.get(i.xField), d = s.get(i.yField), m = s.get(i.zField), w = i.rgbField ? s.get(i.rgbField) : 0;
+        for(let b = 0; b < t.pointCount; b++)if (h[b * 3] = B(g, f + b * i.xField.size, i.xField), h[b * 3 + 1] = B(g, d + b * i.yField.size, i.yField), h[b * 3 + 2] = B(g, m + b * i.zField.size, i.zField), p && i.rgbField) {
+            const C = g.getUint32(w + b * i.rgbField.size, !0);
+            p[b * 3] = (C >> 16 & 255) / 255, p[b * 3 + 1] = (C >> 8 & 255) / 255, p[b * 3 + 2] = (C & 255) / 255;
+        }
+        return {
+            positions: h,
+            colors: p
+        };
+    }
+    function B(n, t, e) {
+        if (e.type === "F") return e.size === 8 ? n.getFloat64(t, !0) : n.getFloat32(t, !0);
+        if (e.type === "U") {
+            if (e.size === 1) return n.getUint8(t);
+            if (e.size === 2) return n.getUint16(t, !0);
+            if (e.size === 4) return n.getUint32(t, !0);
+        } else {
+            if (e.size === 1) return n.getInt8(t);
+            if (e.size === 2) return n.getInt16(t, !0);
+            if (e.size === 4) return n.getInt32(t, !0);
+        }
+        throw new Error(`PCD: unsupported field width ${e.size} for type ${e.type}`);
+    }
+    const gt = new ArrayBuffer(4), Ht = new Float32Array(gt), Wt = new Uint32Array(gt);
+    function Gt(n, t) {
+        return t.type === "F" ? (Ht[0] = Number(n), Wt[0]) : Number(n) >>> 0;
+    }
+    function jt(n) {
+        let t = 1 / 0, e = 1 / 0, o = 1 / 0, r = -1 / 0, a = -1 / 0, l = -1 / 0;
+        for(let c = 0; c < n.length; c += 3){
+            const i = n[c], s = n[c + 1], u = n[c + 2];
+            i < t && (t = i), i > r && (r = i), s < e && (e = s), s > a && (a = s), u < o && (o = u), u > l && (l = u);
+        }
+        return {
+            min: [
+                t,
+                e,
+                o
+            ],
+            max: [
+                r,
+                a,
+                l
+            ]
+        };
+    }
+    class Kt {
+        blob;
+        downsample;
+        label;
+        chunk = null;
+        served = !1;
+        constructor(t, e = {}){
+            this.blob = t, this.downsample = e.downsample ?? {
+                stride: 1
+            }, this.label = e.label;
+        }
+        async open(t) {
+            q(t);
+            const e = await this.blob.arrayBuffer();
+            q(t);
+            const o = Nt(new Uint8Array(e));
+            return this.chunk = Jt(o, this.downsample.stride), {
+                totalPointCount: this.chunk.pointCount,
+                bbox: this.chunk.bbox,
+                hasColor: !!this.chunk.colors,
+                hasClassification: !!this.chunk.classifications,
+                hasIntensity: !!this.chunk.intensities,
+                label: this.label
+            };
+        }
+        async next(t, e) {
+            return q(e), !this.chunk || this.served ? null : (this.served = !0, this.chunk);
+        }
+        close() {
+            this.chunk = null, this.served = !1;
+        }
+    }
+    function Jt(n, t) {
+        const e = Math.max(1, t | 0);
+        if (e === 1) return n;
+        const o = Math.ceil(n.pointCount / e), r = new Float32Array(o * 3), a = n.colors ? new Float32Array(o * 3) : void 0, l = n.classifications ? new Uint8Array(o) : void 0, c = n.intensities ? new Uint16Array(o) : void 0;
+        let i = 0;
+        for(let s = 0; s < n.pointCount; s += e)r[i * 3] = n.positions[s * 3], r[i * 3 + 1] = n.positions[s * 3 + 1], r[i * 3 + 2] = n.positions[s * 3 + 2], a && n.colors && (a[i * 3] = n.colors[s * 3], a[i * 3 + 1] = n.colors[s * 3 + 1], a[i * 3 + 2] = n.colors[s * 3 + 2]), l && n.classifications && (l[i] = n.classifications[s]), c && n.intensities && (c[i] = n.intensities[s]), i++;
+        return {
+            positions: r,
+            colors: a,
+            classifications: l,
+            intensities: c,
+            pointCount: o,
+            bbox: n.bbox
+        };
+    }
+    function q(n) {
+        if (n?.aborted) throw new DOMException("Aborted", "AbortError");
+    }
+    function Qt(n) {
+        const t = {
+            name: "",
+            attrs: new Map,
+            children: [],
+            text: ""
+        }, e = [
+            t
+        ];
+        let o = 0;
+        const r = n.length;
+        let a = -1;
+        const l = (c)=>{
+            if (a < 0 || a >= c) {
+                a = -1;
+                return;
+            }
+            const i = n.slice(a, c).trim();
+            if (i.length > 0) {
+                const s = e[e.length - 1];
+                s.children.length === 0 && (s.text = s.text + bt(i));
+            }
+            a = -1;
+        };
+        for(; o < r;){
+            if (n.charCodeAt(o) !== 60) {
+                a < 0 && (a = o), o++;
+                continue;
+            }
+            if (l(o), n.startsWith("<?", o)) {
+                const m = n.indexOf("?>", o + 2);
+                o = m < 0 ? r : m + 2;
+                continue;
+            }
+            if (n.startsWith("<!--", o)) {
+                const m = n.indexOf("-->", o + 4);
+                o = m < 0 ? r : m + 3;
+                continue;
+            }
+            if (n.startsWith("<![CDATA[", o)) {
+                const m = n.indexOf("]]>", o + 9), w = n.slice(o + 9, m < 0 ? r : m), b = e[e.length - 1];
+                b.children.length === 0 && (b.text = b.text + w), o = m < 0 ? r : m + 3;
+                continue;
+            }
+            if (n.startsWith("<!", o)) {
+                const m = n.indexOf(">", o + 2);
+                o = m < 0 ? r : m + 1;
+                continue;
+            }
+            if (n.charCodeAt(o + 1) === 47) {
+                const m = n.indexOf(">", o + 2);
+                if (m < 0) throw new Error("XML: unterminated closing tag");
+                const w = n.slice(o + 2, m).trim(), b = e[e.length - 1];
+                if (b.name !== w) throw new Error(`XML: mismatched closing tag </${w}> (expected </${b.name}>)`);
+                e.pop(), o = m + 1;
+                continue;
+            }
+            const i = te(n, o + 1);
+            if (i < 0) throw new Error("XML: unterminated tag");
+            let s = n.slice(o + 1, i).trim(), u = !1;
+            s.endsWith("/") && (u = !0, s = s.slice(0, -1).trim());
+            const g = s.match(/^([A-Za-z_][\w:.\-]*)/);
+            if (!g) {
+                o = i + 1;
+                continue;
+            }
+            const h = g[1], p = s.slice(h.length).trim(), f = ee(p), d = {
+                name: h,
+                attrs: f,
+                children: [],
+                text: ""
+            };
+            e.length === 1 && t.name === "" ? (t.name = h, t.attrs = f, u || e.push(t)) : (e[e.length - 1].children.push(d), u || e.push(d)), o = i + 1;
+        }
+        if (l(r), e.length !== 1) throw new Error(`XML: unclosed tag <${e[e.length - 1].name}>`);
+        if (t.name === "") throw new Error("XML: missing root element");
+        return t;
+    }
+    function te(n, t) {
+        let e = !1;
+        for(let o = t; o < n.length; o++){
+            const r = n.charCodeAt(o);
+            if (r === 34) e = !e;
+            else if (r === 62 && !e) return o;
+        }
+        return -1;
+    }
+    const it = /([A-Za-z_][\w:.\-]*)\s*=\s*"([^"]*)"/g;
+    function ee(n) {
+        const t = new Map;
+        if (!n) return t;
+        let e;
+        for(it.lastIndex = 0; (e = it.exec(n)) !== null;)t.set(e[1], bt(e[2]));
+        return t;
+    }
+    function bt(n) {
+        return n.indexOf("&") < 0 ? n : n.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#(\d+);/g, (t, e)=>String.fromCharCode(parseInt(e, 10))).replace(/&#x([0-9a-fA-F]+);/g, (t, e)=>String.fromCharCode(parseInt(e, 16))).replace(/&amp;/g, "&");
+    }
+    function R(n, t) {
+        for (const e of n.children)if (e.name === t) return e;
+        return null;
+    }
+    function ne(n, t) {
+        return n.children.filter((e)=>e.name === t);
+    }
+    function st(n, t) {
+        const e = R(n, t);
+        if (!e) return null;
+        const o = e.text.trim();
+        return o.length > 0 ? o : null;
+    }
+    const at = "ASTM-E57";
+    function oe(n) {
+        if (n.length < 48) throw new Error("E57: header truncated (need 48 bytes)");
+        const t = String.fromCharCode(...n.subarray(0, 8));
+        if (t !== at) throw new Error(`E57: bad magic "${t}" (expected "${at}")`);
+        const e = new DataView(n.buffer, n.byteOffset, n.byteLength);
+        return {
+            majorVersion: e.getUint32(8, !0),
+            minorVersion: e.getUint32(12, !0),
+            fileLogicalSize: O(e, 16),
+            xmlLogicalOffset: j(O(e, 24), O(e, 40)),
+            xmlLogicalLength: O(e, 32),
+            pageSize: O(e, 40)
+        };
+    }
+    function re(n, t) {
+        if (t <= 4) throw new Error("E57: pageSize too small");
+        const e = t - 4, o = Math.floor(n.length / t), r = n.length - o * t, a = new Uint8Array(o * e + Math.max(0, r - 4));
+        let l = 0;
+        for(let c = 0; c < o; c++){
+            const i = c * t;
+            a.set(n.subarray(i, i + e), l), l += e;
+        }
+        if (r > 4) {
+            const c = o * t;
+            a.set(n.subarray(c, c + r - 4), l);
+        }
+        return a;
+    }
+    function j(n, t) {
+        const e = t - 4, o = Math.floor(n / t), r = n - o * t;
+        return o * e + r;
+    }
+    function ie(n, t, e) {
+        const o = j(t, e);
+        if (o + 32 > n.length) throw new Error(`E57: CompressedVector section header at logical ${o} runs past end of file (length ${n.length})`);
+        const r = new DataView(n.buffer, n.byteOffset + o, 32), a = r.getUint8(0);
+        if (a !== 1) throw new Error(`E57: expected CompressedVector section (id=1) at physical ${t}, got id=${a}`);
+        const l = O(r, 16);
+        return j(l, e);
+    }
+    const se = new TextDecoder;
+    function ae(n) {
+        const t = Qt(n);
+        if (t.name !== "e57Root") throw new Error(`E57: XML root is not <e57Root> (saw <${t.name || "?"}>)`);
+        const e = R(t, "data3D");
+        if (!e) return [];
+        const o = [];
+        for (const r of ne(e, "vectorChild")){
+            const a = R(r, "points");
+            if (!a || a.attrs.get("type") !== "CompressedVector") continue;
+            const l = a.attrs.get("fileOffset"), c = a.attrs.get("recordCount");
+            if (!l || !c) continue;
+            const i = R(a, "prototype");
+            if (!i) continue;
+            const s = [];
+            for (const u of i.children){
+                const g = u.attrs.get("type") ?? "";
+                g === "Float" ? s.push({
+                    name: u.name,
+                    kind: "Float",
+                    precision: u.attrs.get("precision") === "single" ? "single" : "double"
+                }) : g === "ScaledInteger" ? s.push({
+                    name: u.name,
+                    kind: "ScaledInteger",
+                    scale: Number(u.attrs.get("scale") ?? "1"),
+                    offset: Number(u.attrs.get("offset") ?? "0"),
+                    minimum: Number(u.attrs.get("minimum") ?? "0"),
+                    maximum: Number(u.attrs.get("maximum") ?? "0")
+                }) : g === "Integer" && s.push({
+                    name: u.name,
+                    kind: "Integer",
+                    minimum: Number(u.attrs.get("minimum") ?? "0"),
+                    maximum: Number(u.attrs.get("maximum") ?? "0")
+                });
+            }
+            o.push({
+                guid: st(r, "guid") ?? "",
+                name: st(r, "name") ?? void 0,
+                recordCount: Number(c),
+                binaryFileOffset: Number(l),
+                prototype: s,
+                hasPose: R(r, "pose") !== null
+            });
+        }
+        return o;
+    }
+    function ce(n, t) {
+        const e = U(t.prototype, "cartesianX"), o = U(t.prototype, "cartesianY"), r = U(t.prototype, "cartesianZ");
+        if (!e || !o || !r) throw new Error("E57: prototype missing cartesianX/Y/Z");
+        for (const m of [
+            e,
+            o,
+            r
+        ])if (m.kind !== "Float") throw new Error(`E57: cartesianX/Y/Z encoded as ${m.kind} (only Float supported in this build)`);
+        const a = U(t.prototype, "colorRed"), l = U(t.prototype, "colorGreen"), c = U(t.prototype, "colorBlue"), i = !!(a && l && c), s = U(t.prototype, "intensity");
+        if (s && s.kind === "ScaledInteger") throw new Error("E57: intensity encoded as ScaledInteger (bit-packed integer codec not yet supported)");
+        const u = new Float32Array(t.recordCount * 3), g = i ? new Float32Array(t.recordCount * 3) : void 0, h = s && (s.kind === "Float" || s.kind === "Integer") ? new Uint16Array(t.recordCount) : void 0;
+        let p = t.binaryFileOffset;
+        const f = new DataView(n.buffer, n.byteOffset, n.byteLength);
+        let d = 0;
+        for(; d < t.recordCount && p < n.length;){
+            if (p + 4 > n.length) throw new Error("E57: truncated DataPacket header");
+            const m = f.getUint8(p), w = f.getUint16(p + 2, !0) + 1;
+            if (m !== 1) {
+                p += w;
+                continue;
+            }
+            const b = p + w;
+            if (b > n.length) throw new Error("E57: DataPacket runs past end of logical bytes");
+            const C = f.getUint16(p + 4, !0);
+            if (C !== t.prototype.length) throw new Error(`E57: packet bytestreamCount (${C}) ≠ prototype length (${t.prototype.length})`);
+            const F = [];
+            let E = p + 6;
+            for(let y = 0; y < C; y++)F.push(f.getUint16(E, !0)), E += 2;
+            const x = new Map;
+            let L = E;
+            for(let y = 0; y < C; y++)x.set(t.prototype[y].name, {
+                start: L,
+                length: F[y]
+            }), L += F[y];
+            const A = e.precision === "single" ? 4 : 8, Z = o.precision === "single" ? 4 : 8, yt = r.precision === "single" ? 4 : 8, k = Math.floor(x.get("cartesianX").length / A);
+            if (k !== Math.floor(x.get("cartesianY").length / Z) || k !== Math.floor(x.get("cartesianZ").length / yt)) throw new Error("E57: cartesianX/Y/Z bytestream lengths disagree on point count");
+            const I = Math.min(k, t.recordCount - d), Q = x.get("cartesianX").start, tt = x.get("cartesianY").start, et = x.get("cartesianZ").start;
+            if (e.precision === "single") for(let y = 0; y < I; y++)u[(d + y) * 3] = f.getFloat32(Q + y * 4, !0);
+            else for(let y = 0; y < I; y++)u[(d + y) * 3] = f.getFloat64(Q + y * 8, !0);
+            if (o.precision === "single") for(let y = 0; y < I; y++)u[(d + y) * 3 + 1] = f.getFloat32(tt + y * 4, !0);
+            else for(let y = 0; y < I; y++)u[(d + y) * 3 + 1] = f.getFloat64(tt + y * 8, !0);
+            if (r.precision === "single") for(let y = 0; y < I; y++)u[(d + y) * 3 + 2] = f.getFloat32(et + y * 4, !0);
+            else for(let y = 0; y < I; y++)u[(d + y) * 3 + 2] = f.getFloat64(et + y * 8, !0);
+            if (g && a && l && c && (H(f, x.get("colorRed").start, a, g, d, I, 0), H(f, x.get("colorGreen").start, l, g, d, I, 1), H(f, x.get("colorBlue").start, c, g, d, I, 2)), h && s) {
+                const y = x.get("intensity").start;
+                if (s.kind === "Float") {
+                    const P = s.precision === "single" ? 4 : 8;
+                    for(let S = 0; S < I; S++){
+                        const T = P === 4 ? f.getFloat32(y + S * P, !0) : f.getFloat64(y + S * P, !0);
+                        h[d + S] = Math.min(65535, Math.max(0, Math.round(T * 65535)));
+                    }
+                } else {
+                    const P = s.minimum ?? 0, S = s.maximum ?? 65535, T = S - P, xt = T > 0 ? 1 / T : 1, nt = Math.max(Math.abs(P), Math.abs(S)) > 255 ? 2 : 1, ot = P < 0;
+                    for(let Y = 0; Y < I; Y++){
+                        const v = y + Y * nt, Ct = ((nt === 2 ? ot ? f.getInt16(v, !0) : f.getUint16(v, !0) : ot ? f.getInt8(v) : f.getUint8(v)) - P) * xt;
+                        h[d + Y] = Math.min(65535, Math.max(0, Math.round(Ct * 65535)));
+                    }
+                }
+            }
+            d += I, p = b;
+        }
+        return d < t.recordCount ? ct(u.subarray(0, d * 3), g?.subarray(0, d * 3), h?.subarray(0, d), d) : ct(u, g, h, t.recordCount);
+    }
+    function H(n, t, e, o, r, a, l) {
+        if (e.kind === "Float") {
+            const c = e.precision === "single" ? 4 : 8;
+            for(let i = 0; i < a; i++){
+                const s = c === 4 ? n.getFloat32(t + i * c, !0) : n.getFloat64(t + i * c, !0);
+                o[(r + i) * 3 + l] = lt(s);
+            }
+        } else if (e.kind === "Integer") {
+            const c = e.minimum ?? 0, i = e.maximum ?? 255, s = i - c, u = s > 0 ? 1 / s : 1, h = Math.max(Math.abs(c), Math.abs(i)) > 255 ? 2 : 1, p = c < 0;
+            for(let f = 0; f < a; f++){
+                const d = t + f * h, m = h === 2 ? p ? n.getInt16(d, !0) : n.getUint16(d, !0) : p ? n.getInt8(d) : n.getUint8(d);
+                o[(r + f) * 3 + l] = lt((m - c) * u);
+            }
+        } else throw new Error("E57: ScaledInteger color encoding not yet supported");
+    }
+    function ct(n, t, e, o) {
+        return {
+            positions: new Float32Array(n),
+            colors: t ? new Float32Array(t) : void 0,
+            intensities: e ? new Uint16Array(e) : void 0,
+            pointCount: o,
+            bbox: wt(n)
+        };
+    }
+    function U(n, t) {
+        return n.find((e)=>e.name === t);
+    }
+    function O(n, t) {
+        const e = n.getUint32(t, !0);
+        return n.getUint32(t + 4, !0) * 4294967296 + e;
+    }
+    function lt(n) {
+        return n < 0 ? 0 : n > 1 ? 1 : n;
+    }
+    function wt(n) {
+        let t = 1 / 0, e = 1 / 0, o = 1 / 0, r = -1 / 0, a = -1 / 0, l = -1 / 0;
+        for(let c = 0; c < n.length; c += 3){
+            const i = n[c], s = n[c + 1], u = n[c + 2];
+            i < t && (t = i), i > r && (r = i), s < e && (e = s), s > a && (a = s), u < o && (o = u), u > l && (l = u);
+        }
+        return {
+            min: [
+                t,
+                e,
+                o
+            ],
+            max: [
+                r,
+                a,
+                l
+            ]
+        };
+    }
+    function le(n) {
+        const t = oe(n), e = re(n, t.pageSize), o = e.subarray(t.xmlLogicalOffset, t.xmlLogicalOffset + t.xmlLogicalLength), r = se.decode(o), a = ae(r);
+        if (a.length === 0) return null;
+        if (a.length > 1 && a.some((f)=>f.hasPose)) throw new Error(`E57: file contains ${a.length} scans with per-scan poses (registered multi-scan). Multi-scan pose merging is not yet supported — please re-export as a single merged scan.`);
+        const l = a.map((f)=>{
+            const d = ie(e, f.binaryFileOffset, t.pageSize);
+            return ce(e, {
+                ...f,
+                binaryFileOffset: d
+            });
+        });
+        if (l.length === 1) return l[0];
+        let c = 0;
+        for (const f of l)c += f.pointCount;
+        const i = new Float32Array(c * 3), s = l.some((f)=>f.colors), u = l.some((f)=>f.intensities), g = s ? new Float32Array(c * 3) : void 0, h = u ? new Uint16Array(c) : void 0;
+        let p = 0;
+        for (const f of l)i.set(f.positions, p * 3), g && f.colors && g.set(f.colors, p * 3), h && f.intensities && h.set(f.intensities, p), p += f.pointCount;
+        return {
+            positions: i,
+            colors: g,
+            intensities: h,
+            pointCount: c,
+            bbox: wt(i)
+        };
+    }
+    class fe {
+        blob;
+        downsample;
+        label;
+        chunk = null;
+        served = !1;
+        constructor(t, e = {}){
+            this.blob = t, this.downsample = e.downsample ?? {
+                stride: 1
+            }, this.label = e.label;
+        }
+        async open(t) {
+            W(t);
+            const e = await this.blob.arrayBuffer();
+            W(t);
+            const o = le(new Uint8Array(e));
+            if (!o) throw new Error("E57: file contains no Data3D scans");
+            return this.chunk = ue(o, this.downsample.stride), {
+                totalPointCount: this.chunk.pointCount,
+                bbox: this.chunk.bbox,
+                hasColor: !!this.chunk.colors,
+                hasClassification: !1,
+                hasIntensity: !!this.chunk.intensities,
+                label: this.label
+            };
+        }
+        async next(t, e) {
+            return W(e), !this.chunk || this.served ? null : (this.served = !0, this.chunk);
+        }
+        close() {
+            this.chunk = null, this.served = !1;
+        }
+    }
+    function ue(n, t) {
+        const e = Math.max(1, t | 0);
+        if (e === 1) return n;
+        const o = Math.ceil(n.pointCount / e), r = new Float32Array(o * 3), a = n.colors ? new Float32Array(o * 3) : void 0, l = n.intensities ? new Uint16Array(o) : void 0;
+        let c = 0;
+        for(let i = 0; i < n.pointCount; i += e)r[c * 3] = n.positions[i * 3], r[c * 3 + 1] = n.positions[i * 3 + 1], r[c * 3 + 2] = n.positions[i * 3 + 2], a && n.colors && (a[c * 3] = n.colors[i * 3], a[c * 3 + 1] = n.colors[i * 3 + 1], a[c * 3 + 2] = n.colors[i * 3 + 2]), l && n.intensities && (l[c] = n.intensities[i]), c++;
+        return {
+            positions: r,
+            colors: a,
+            intensities: l,
+            pointCount: o,
+            bbox: n.bbox
+        };
+    }
+    function W(n) {
+        if (n?.aborted) throw new DOMException("Aborted", "AbortError");
+    }
+    const _ = new Map;
+    let de = 1;
+    self.onmessage = (n)=>{
+        const t = n.data;
+        switch(t.kind){
+            case "open":
+                he(t);
+                return;
+            case "next":
+                pe(t);
+                return;
+            case "close":
+                me(t.sourceId);
+                return;
+            case "abort":
+                ge(t.sourceId);
+                return;
+        }
+    };
+    async function he(n) {
+        try {
+            const t = be(n.format, n.blob, {
+                label: n.label,
+                downsample: {
+                    stride: Math.max(1, n.stride | 0)
+                }
+            }), e = new AbortController, o = await t.open(e.signal), r = de++;
+            _.set(r, {
+                source: t,
+                abort: e
+            }), D({
+                kind: "opened",
+                requestId: n.requestId,
+                sourceId: r,
+                info: o
+            });
+        } catch (t) {
+            D({
+                kind: "error",
+                requestId: n.requestId,
+                message: J(t)
+            });
+        }
+    }
+    async function pe(n) {
+        const t = _.get(n.sourceId);
+        if (!t) {
+            D({
+                kind: "error",
+                requestId: n.requestId,
+                message: `Unknown sourceId ${n.sourceId}`
+            });
+            return;
+        }
+        try {
+            const e = await t.source.next(n.maxPoints, t.abort.signal);
+            if (!e) {
+                D({
+                    kind: "chunk",
+                    requestId: n.requestId,
+                    sourceId: n.sourceId,
+                    chunk: null
+                });
+                return;
+            }
+            const { payload: o, transfer: r } = Et(e);
+            D({
+                kind: "chunk",
+                requestId: n.requestId,
+                sourceId: n.sourceId,
+                chunk: o
+            }, r);
+        } catch (e) {
+            D({
+                kind: "error",
+                requestId: n.requestId,
+                message: J(e)
+            });
+        }
+    }
+    function me(n) {
+        const t = _.get(n);
+        if (t) {
+            try {
+                t.abort.abort(), t.source.close();
+            } catch (e) {
+                console.warn("[decode-worker] close failed:", J(e));
+            }
+            _.delete(n);
+        }
+    }
+    function ge(n) {
+        const t = _.get(n);
+        t && t.abort.abort();
+    }
+    function be(n, t, e) {
+        if (n === "las") return new Ut(t, e);
+        if (n === "laz") return new Ot(t, e);
+        if (n === "ply") return new Tt(t, e);
+        if (n === "pcd") return new Kt(t, e);
+        if (n === "e57") return new fe(t, e);
+        throw new Error(`decode-worker: unknown format "${n}"`);
+    }
+    function D(n, t = []) {
+        self.postMessage(n, t);
+    }
+    function J(n) {
+        return n instanceof Error ? n.message : String(n);
+    }
+})();