@ifc-lite/viewer 1.19.0 → 1.21.0

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

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