@nebula-spatial/cad-loader 0.1.0

package/dist/workers/geo-prepare.worker.js

@@ -0,0 +1,2166 @@
+var Fe = Object.defineProperty;
+var jt = (t) => {
+  throw TypeError(t);
+};
+var Xe = (t, e, n) => e in t ? Fe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var J = (t, e, n) => Xe(t, typeof e != "symbol" ? e + "" : e, n), Ye = (t, e, n) => e.has(t) || jt("Cannot " + n);
+var et = (t, e, n) => (Ye(t, e, "read from private field"), n ? n.call(t) : e.get(t)), Wt = (t, e, n) => e.has(t) ? jt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, n);
+class l extends Error {
+  constructor(n, r) {
+    super(r);
+    J(this, "code");
+    this.name = "GeoLoaderError", this.code = n;
+  }
+}
+const Ut = 4096;
+function ye(t) {
+  return t >= 6 ? "u16_lw" : t >= 5 ? "u8_lw" : t >= 4 ? "u16" : "u8";
+}
+function xe(t) {
+  return t === "u16_lw" ? 13 : t === "u8_lw" ? 12 : t === "u16" ? 9 : 8;
+}
+function _e(t, e, n) {
+  return n === "u16" || n === "u16_lw" ? t.getUint16(e + 7, !0) : t.getUint8(e + 7);
+}
+function ze(t) {
+  return t === "u16" || t === "u16_lw" ? 2 : 1;
+}
+function Ee(t, e, n) {
+  if (!(n !== "u8_lw" && n !== "u16_lw"))
+    return t.getFloat32(e + 7 + ze(n), !0);
+}
+function we(t, e, n, r, o = t.byteLength, s = "u8") {
+  if (n > o || o > t.byteLength)
+    throw new l("E_GROUP_RANGE", "Group byte range exceeds payload length");
+  let i = n;
+  const a = r * 2, c = a * 4;
+  if (i + c > o)
+    throw new l("E_GROUP_RANGE", "Group position bytes exceed payload length");
+  let u;
+  if (a > 0) {
+    const w = new Uint8Array(t, i, c), y = new Uint8Array(c), f = a;
+    for (let _ = 0; _ < a; _++)
+      y[_ * 4] = w[_], y[_ * 4 + 1] = w[f + _], y[_ * 4 + 2] = w[f * 2 + _], y[_ * 4 + 3] = w[f * 3 + _];
+    u = new Float32Array(y.buffer);
+  } else
+    u = new Float32Array(0);
+  if (i += c, i + 4 > o)
+    throw new l("E_GROUP_RANGE", "Missing seg_count field for group");
+  const m = e.getUint32(i, !0);
+  i += 4;
+  const g = [];
+  let d = 0;
+  const h = xe(s);
+  for (let w = 0; w < m; w++) {
+    if (i + h > o)
+      throw new l("E_GROUP_RANGE", "Segment record exceeds payload length");
+    const y = e.getUint32(i, !0), f = e.getUint8(i + 4), _ = e.getUint8(i + 5), b = e.getUint8(i + 6), E = _e(e, i, s), p = Ee(e, i, s);
+    if (d + y > r)
+      throw new l("E_SEGMENT_SUM", "Segment vertex_count sum exceeds group count");
+    g.push({
+      startVertex: d,
+      vertexCount: y,
+      color: [f, _, b],
+      layerIndex: E,
+      ...p === void 0 ? {} : { lineweightPx: p }
+    }), i += h;
+    const S = d * 2;
+    if (y > 1) {
+      let N = u[S], C = u[S + 1];
+      for (let G = 1; G < y; G++) {
+        const U = S + G * 2;
+        N += u[U], C += u[U + 1], u[U] = N, u[U + 1] = C;
+      }
+    }
+    d += y;
+  }
+  if (d !== r)
+    throw new l("E_SEGMENT_SUM", `Segment vertex_count sum ${d} does not match group count ${r}`);
+  return {
+    chunk: { pos: u, count: r, segments: g },
+    offset: i
+  };
+}
+function He(t, e, n, r, o = "u8") {
+  const s = r * 2, i = s * 4;
+  if (n + i > t.byteLength)
+    throw new l("E_GROUP_RANGE", "Group position bytes exceed payload length");
+  const a = new Uint8Array(t, n, i);
+  let c = n + i;
+  if (c + 4 > t.byteLength)
+    throw new l("E_GROUP_RANGE", "Missing seg_count field for group");
+  const u = e.getUint32(c, !0);
+  c += 4;
+  const m = [];
+  let g = 0;
+  const d = xe(o);
+  for (let h = 0; h < u; h++) {
+    if (c + d > t.byteLength)
+      throw new l("E_GROUP_RANGE", "Segment record exceeds payload length");
+    const w = e.getUint32(c, !0), y = e.getUint8(c + 4), f = e.getUint8(c + 5), _ = e.getUint8(c + 6), b = _e(e, c, o), E = Ee(e, c, o);
+    if (c += d, g + w > r)
+      throw new l("E_SEGMENT_SUM", "Segment vertex_count sum exceeds group count");
+    m.push({
+      startVertex: g,
+      vertexCount: w,
+      color: [y, f, _],
+      layerIndex: b,
+      ...E === void 0 ? {} : { lineweightPx: E }
+    }), g += w;
+  }
+  if (g !== r)
+    throw new l("E_SEGMENT_SUM", `Segment vertex_count sum ${g} does not match group count ${r}`);
+  return {
+    shuffled: a,
+    plane: s,
+    segments: m,
+    offset: c
+  };
+}
+function Ke(t, e, n, r) {
+  if (r === 0)
+    return new Float32Array(0);
+  const o = new Uint8Array(r * 4);
+  for (let s = 0; s < r; s++)
+    o[s * 4] = t[n + s], o[s * 4 + 1] = t[e + n + s], o[s * 4 + 2] = t[e * 2 + n + s], o[s * 4 + 3] = t[e * 3 + n + s];
+  return new Float32Array(o.buffer);
+}
+function je(t, e, n, r, o) {
+  const s = Ke(
+    t.shuffled,
+    t.plane,
+    (e.startVertex + n) * 2,
+    r * 2
+  );
+  let i = (o == null ? void 0 : o[0]) ?? 0, a = (o == null ? void 0 : o[1]) ?? 0;
+  if (r > 0) {
+    n === 0 ? (i = s[0], a = s[1]) : (i += s[0], a += s[1], s[0] = i, s[1] = a);
+    for (let u = 1; u < r; u++) {
+      const m = u * 2;
+      i += s[m], a += s[m + 1], s[m] = i, s[m + 1] = a;
+    }
+  }
+  const c = r > 0 ? [{
+    startVertex: 0,
+    vertexCount: r,
+    color: [e.color[0], e.color[1], e.color[2]],
+    layerIndex: e.layerIndex,
+    ...e.lineweightPx === void 0 ? {} : { lineweightPx: e.lineweightPx }
+  }] : [];
+  return {
+    chunk: { pos: s, count: r, segments: c },
+    lastPoint: r > 0 ? [i, a] : o
+  };
+}
+function* We(t, e, n, r, o = "u8") {
+  const s = He(t, e, n, r, o);
+  if (r === 0)
+    return yield { pos: new Float32Array(0), count: 0, segments: [] }, s.offset;
+  for (const i of s.segments) {
+    let a = null;
+    for (let c = 0; c < i.vertexCount; c += Ut) {
+      const u = Math.min(Ut, i.vertexCount - c), m = je(s, i, c, u, a);
+      a = m.lastPoint, yield m.chunk;
+    }
+  }
+  return s.offset;
+}
+function pe() {
+  const t = globalThis.TextDecoder;
+  if (!t)
+    throw new l("E_HEADER_JSON", "TextDecoder is required to parse CAD pack metadata");
+  return new t();
+}
+function ot(t) {
+  return t ? {
+    minX: t.minX,
+    minY: t.minY,
+    maxX: t.maxX,
+    maxY: t.maxY
+  } : null;
+}
+function Ct(t) {
+  return !!t && Number.isFinite(t.minX) && Number.isFinite(t.minY) && Number.isFinite(t.maxX) && Number.isFinite(t.maxY);
+}
+function mt(t) {
+  return Ct(t) ? ot(t) : null;
+}
+function be(t, e) {
+  const n = Ct(t) ? t : null, r = Ct(e) ? e : null;
+  return n ? r ? {
+    minX: Math.min(n.minX, r.minX),
+    minY: Math.min(n.minY, r.minY),
+    maxX: Math.max(n.maxX, r.maxX),
+    maxY: Math.max(n.maxY, r.maxY)
+  } : ot(n) : ot(r);
+}
+function qe(t, e, n, r = 0, o = 1) {
+  if (e <= 0 || n <= 0) return null;
+  let s = Number.POSITIVE_INFINITY, i = Number.POSITIVE_INFINITY, a = Number.NEGATIVE_INFINITY, c = Number.NEGATIVE_INFINITY, u = !1;
+  for (let m = 0; m < e; m += 1) {
+    const g = m * n, d = t[g + r], h = t[g + o];
+    !Number.isFinite(d) || !Number.isFinite(h) || (d < s && (s = d), h < i && (i = h), d > a && (a = d), h > c && (c = h), u = !0);
+  }
+  return u ? { minX: s, minY: i, maxX: a, maxY: c } : null;
+}
+function Ae(t, e) {
+  const n = t.minX, r = t.minY, o = t.maxX, s = t.maxY, { matA: i, matB: a, matC: c, matD: u, tx: m, ty: g } = e;
+  let d = i * n + c * r + m, h = a * n + u * r + g, w = d, y = h, f = d, _ = h;
+  return d = i * n + c * s + m, h = a * n + u * s + g, d < w && (w = d), h < y && (y = h), d > f && (f = d), h > _ && (_ = h), d = i * o + c * r + m, h = a * o + u * r + g, d < w && (w = d), h < y && (y = h), d > f && (f = d), h > _ && (_ = h), d = i * o + c * s + m, h = a * o + u * s + g, d < w && (w = d), h < y && (y = h), d > f && (f = d), h > _ && (_ = h), { minX: w, minY: y, maxX: f, maxY: _ };
+}
+function Je(t) {
+  return Math.hypot(t.maxX - t.minX, t.maxY - t.minY);
+}
+function Ze(t, e) {
+  const n = (t.minX + t.maxX) / 2, r = (t.minY + t.maxY) / 2, o = (e.minX + e.maxX) / 2, s = (e.minY + e.maxY) / 2;
+  return Math.hypot(n - o, r - s);
+}
+const Qe = {};
+function qt(t) {
+  return typeof t == "object" && t !== null;
+}
+function ut(t, e) {
+  return Object.prototype.hasOwnProperty.call(t, e);
+}
+function H(t) {
+  if (t.length === 0) return "$";
+  let e = "";
+  for (const n of t) {
+    if (typeof n == "number") {
+      e += `[${n}]`;
+      continue;
+    }
+    e += e.length === 0 ? n : `.${n}`;
+  }
+  return e;
+}
+function Jt(t, e, n, r) {
+  return new l("E_TEXT_ROUNDTRIP", `Text roundtrip mismatch at stage=${t} index=${e} path=${n}: ${r}`);
+}
+function Pt(t, e, n) {
+  if (Object.is(t, e)) return null;
+  if (Array.isArray(t)) {
+    if (!Array.isArray(e))
+      return { path: H(n), reason: `expected array but found ${typeof e}` };
+    if (t.length !== e.length)
+      return { path: H([...n, "length"]), reason: `array length ${t.length} !== ${e.length}` };
+    for (let r = 0; r < t.length; r += 1) {
+      const o = Pt(t[r], e[r], [...n, r]);
+      if (o) return o;
+    }
+    return null;
+  }
+  if (qt(t)) {
+    if (!qt(e) || Array.isArray(e))
+      return { path: H(n), reason: `expected object but found ${Array.isArray(e) ? "array" : typeof e}` };
+    const r = Object.keys(t), o = Object.keys(e);
+    if (r.length !== o.length) {
+      const s = r.find((a) => !ut(e, a));
+      if (s !== void 0)
+        return {
+          path: H([...n, s]),
+          reason: "missing key on actual"
+        };
+      const i = o.find((a) => !ut(t, a));
+      if (i !== void 0)
+        return {
+          path: H([...n, i]),
+          reason: "extra key on actual"
+        };
+    }
+    for (const s of r) {
+      if (!ut(e, s))
+        return { path: H([...n, s]), reason: "missing key on actual" };
+      const i = Pt(t[s], e[s], [...n, s]);
+      if (i) return i;
+    }
+    for (const s of o)
+      if (!ut(t, s))
+        return { path: H([...n, s]), reason: "extra key on actual" };
+    return null;
+  }
+  return { path: H(n), reason: `expected ${String(t)} but found ${String(e)}` };
+}
+function tn(t, e) {
+  return Pt(t, e, []);
+}
+function Zt(t) {
+  if (t === !0 || t === "1" || t === "true") return !0;
+  if (t === !1 || t === "0" || t === "false") return !1;
+}
+function en() {
+  var o, s;
+  const t = globalThis.process, e = Zt(
+    ((o = t == null ? void 0 : t.env) == null ? void 0 : o.DXF_STRICT_TEXT_ROUNDTRIP) ?? ((s = t == null ? void 0 : t.env) == null ? void 0 : s.VITE_DXF_STRICT_TEXT_ROUNDTRIP)
+  );
+  if (e !== void 0) return e;
+  const n = Qe, r = Zt(n == null ? void 0 : n.VITE_DXF_STRICT_TEXT_ROUNDTRIP);
+  return r !== void 0 ? r : !1;
+}
+function nn(t, e, n) {
+  if (e.length !== n.length)
+    throw Jt(t, Math.min(e.length, n.length), "$length", `text count ${e.length} !== ${n.length}`);
+  for (let r = 0; r < e.length; r += 1) {
+    const o = tn(e[r], n[r]);
+    if (o)
+      throw Jt(t, r, o.path, o.reason);
+  }
+}
+pe();
+function Qt(t, e) {
+  if (t > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new l("E_GROUP_RANGE", `${e} exceeds safe integer range`);
+  return Number(t);
+}
+function te(t, e, n, r) {
+  if (!Number.isInteger(t) || !Number.isInteger(e) || t < 0 || e < 0 || t + e > n)
+    throw new l("E_GROUP_RANGE", `${r} exceeds payload length`);
+}
+function rn(t) {
+  if (t.byteLength < 4) return !1;
+  const e = new Uint8Array(t, 0, 4);
+  return e[0] === 68 && e[1] === 88 && e[2] === 66 && e[3] === 83;
+}
+function on(t) {
+  if (t.byteLength < 20)
+    throw new l("E_HEADER", "DXBS payload too small: missing container header");
+  if (!rn(t))
+    throw new l("E_HEADER", "DXBS payload missing magic");
+  const e = new DataView(t), n = e.getUint16(4, !0), r = e.getUint16(6, !0), o = e.getUint16(8, !0), s = e.getUint16(10, !0), i = e.getUint16(12, !0), a = e.getUint16(14, !0), c = e.getUint32(16, !0);
+  if (n !== 3 || r < 3 || r > 6)
+    throw new l("E_GROUP_RANGE", `Unsupported DXBS version: ${n}.${r}`);
+  if (o !== 0)
+    throw new l("E_GROUP_RANGE", `Unsupported DXBS sidecar kind: ${o}`);
+  if (a !== 0)
+    throw new l("E_GROUP_RANGE", `Invalid DXBS reserved field: ${a}`);
+  if (s < 24)
+    throw new l("E_GROUP_RANGE", `Invalid DXBS directory entry size: ${s}`);
+  if (c !== s * i)
+    throw new l("E_GROUP_RANGE", "DXBS directory byte size mismatch");
+  const u = 20;
+  te(u, c, t.byteLength, "DXBS section directory");
+  const m = /* @__PURE__ */ new Map();
+  for (let g = 0; g < i; g += 1) {
+    const d = u + g * s, h = e.getUint16(d, !0), w = e.getUint16(d + 2, !0), y = e.getUint32(d + 4, !0), f = Qt(e.getBigUint64(d + 8, !0), "DXBS section offset"), _ = Qt(e.getBigUint64(d + 16, !0), "DXBS section length");
+    if (w !== 0)
+      throw new l("E_GROUP_RANGE", `Unsupported DXBS section flags for type ${h}: ${w}`);
+    if (y !== 0)
+      throw new l("E_GROUP_RANGE", `Invalid DXBS section reserved field for type ${h}: ${y}`);
+    te(f, _, t.byteLength, `DXBS section ${h}`), m.set(h, { type: h, flags: w, offset: f, length: _ });
+  }
+  return { versionMajor: n, versionMinor: r, sections: m };
+}
+function sn(t, e, n) {
+  const r = t.sections.get(e);
+  if (!r)
+    throw new l("E_GROUP_RANGE", `Missing DXBS section ${n}`);
+  return r;
+}
+function an() {
+  return {
+    pos: new Float32Array(0),
+    count: 0,
+    segments: []
+  };
+}
+function St(t) {
+  if (t.segments && t.segments.length > 0)
+    return un(t.segments, t.count), t.segments;
+  if (t.count <= 0) return [];
+  if (!t.col || !t.lay)
+    throw new l("E_GROUP_RANGE", "Geometry chunk is missing segment or expanded color/layer metadata");
+  return cn(t.col, t.lay, t.count);
+}
+function ee(t) {
+  const e = [];
+  for (const n of t) {
+    const r = e[e.length - 1];
+    if (r && r.startVertex + r.vertexCount === n.startVertex && r.layerIndex === n.layerIndex && r.color[0] === n.color[0] && r.color[1] === n.color[1] && r.color[2] === n.color[2] && r.lineweightPx === n.lineweightPx) {
+      e[e.length - 1] = {
+        ...r,
+        vertexCount: r.vertexCount + n.vertexCount
+      };
+      continue;
+    }
+    e.push({
+      startVertex: n.startVertex,
+      vertexCount: n.vertexCount,
+      color: ln(n),
+      layerIndex: n.layerIndex,
+      ...n.lineweightPx === void 0 ? {} : { lineweightPx: n.lineweightPx }
+    });
+  }
+  return e;
+}
+function cn(t, e, n) {
+  if (t.length < n * 3 || e.length < n)
+    throw new l("E_GROUP_RANGE", "Expanded color/layer metadata is shorter than geometry count");
+  const r = [];
+  let o = 0;
+  for (; o < n; ) {
+    const s = o * 3, i = t[s] ?? 0, a = t[s + 1] ?? 0, c = t[s + 2] ?? 0, u = e[o] ?? 0;
+    let m = o + 1;
+    for (; m < n; ) {
+      const g = m * 3;
+      if (e[m] !== u || t[g] !== i || t[g + 1] !== a || t[g + 2] !== c)
+        break;
+      m += 1;
+    }
+    r.push({
+      startVertex: o,
+      vertexCount: m - o,
+      color: [i, a, c],
+      layerIndex: u
+    }), o = m;
+  }
+  return r;
+}
+function un(t, e) {
+  let n = 0;
+  for (const r of t) {
+    if (r.vertexCount < 0 || r.startVertex !== n)
+      throw new l("E_SEGMENT_SUM", "Geometry segments must be contiguous and non-negative");
+    n += r.vertexCount;
+  }
+  if (n !== e)
+    throw new l("E_SEGMENT_SUM", `Geometry segment vertex sum ${n} does not match count ${e}`);
+}
+function ln(t) {
+  return [t.color[0], t.color[1], t.color[2]];
+}
+const fn = 8e6, Ot = pe(), dn = ["left", "center", "right"], mn = ["top", "middle", "bottom", "alphabetic"];
+function ne(t, e, n) {
+  for (const r of t)
+    n(r);
+  for (const r of e)
+    n(r);
+}
+function rt(t) {
+  return typeof t == "object" && t !== null;
+}
+function hn(t) {
+  return Array.isArray(t) ? "array" : t === null ? "null" : typeof t;
+}
+function gn(t) {
+  return !(!rt(t) || Array.isArray(t) || typeof t.t != "string" || typeof t.x != "number" || typeof t.y != "number" || typeof t.h != "number" || typeof t.r != "number" || !Array.isArray(t.c) || t.c.length !== 3 || !t.c.every((e) => typeof e == "number") || typeof t.li != "number" || t.ha !== "left" && t.ha !== "center" && t.ha !== "right" || t.va !== "top" && t.va !== "middle" && t.va !== "bottom" && t.va !== "alphabetic" || typeof t.lh != "number" || t.w !== void 0 && typeof t.w != "number" || t.wf !== void 0 && typeof t.wf != "number" || t.iv !== void 0 && typeof t.iv != "number" || t.io !== void 0 && typeof t.io != "number" || t.mx !== void 0 && t.mx !== !0 || t.my !== void 0 && t.my !== !0);
+}
+function yn(t) {
+  return t.map((e, n) => ({
+    index: n,
+    name: e.name,
+    color: [...e.color],
+    lw_px: e.lw_px,
+    visible: e.visible ?? !0
+  }));
+}
+function Ie(t) {
+  const e = t.texts, n = Array.isArray(e) ? e : [], r = n.filter(gn), o = en();
+  if (o && e !== void 0 && !Array.isArray(e))
+    throw new l(
+      "E_TEXT_ROUNDTRIP",
+      `Text roundtrip mismatch at stage=Boundary-2:header->stream index=0 path=$: expected array but found ${hn(e)}`
+    );
+  return o && nn("Boundary-2:header->stream", n, r), {
+    bounds: [...t.bounds],
+    entityCount: Number(t.entity_count || 0),
+    lineCount: Number(t.line_count || 0),
+    fillCount: Number(t.fill_count || 0),
+    dotCount: Number(t.dot_count || 0),
+    textCount: r.length,
+    layers: yn(t.layers ?? []),
+    texts: r
+  };
+}
+function xn(t) {
+  const e = t == null ? void 0 : t.maxExpandedInstanceVertices, n = typeof e == "number" && Number.isFinite(e) && e >= 0 ? Math.floor(e) : fn;
+  return {
+    hiddenInstanceIds: t != null && t.hiddenInstanceIds ? new Set(t.hiddenInstanceIds) : /* @__PURE__ */ new Set(),
+    keepTextsForHiddenInstances: (t == null ? void 0 : t.keepTextsForHiddenInstances) === !0,
+    loadBlocks: (t == null ? void 0 : t.loadBlocks) !== !1,
+    suppressExpandedInsertGeometry: (t == null ? void 0 : t.suppressExpandedInsertGeometry) === !0,
+    maxExpandedInstanceVertices: n,
+    expandedInstanceVertices: 0,
+    externalVariantBuffers: t == null ? void 0 : t.externalVariantBuffers,
+    requiredExternalVariantIds: t == null ? void 0 : t.requiredExternalVariantIds,
+    externalVariantDeltaOnly: (t == null ? void 0 : t.externalVariantDeltaOnly) === !0,
+    deferExternalVariantGeometry: (t == null ? void 0 : t.deferExternalVariantGeometry) === !0
+  };
+}
+function _n(t) {
+  return t.loadBlocks && !t.suppressExpandedInsertGeometry;
+}
+function Re(t, e) {
+  return _n(e) && !e.hiddenInstanceIds.has(t);
+}
+function En(t, e, n) {
+  if (n <= 0)
+    return;
+  const r = t.expandedInstanceVertices + n;
+  if (r > t.maxExpandedInstanceVertices)
+    throw new l(
+      "E_EXPANSION_BUDGET",
+      `CPU-expanded ${e} instance vertices exceed budget: ${r}/${t.maxExpandedInstanceVertices}. Disable block loading or raise maxExpandedInstanceVertices.`
+    );
+  t.expandedInstanceVertices = r;
+}
+function wn(t, e, n) {
+  return n.loadBlocks ? n.hiddenInstanceIds.size === 0 || n.keepTextsForHiddenInstances ? t : t.filter((r) => {
+    if (!Number.isInteger(r.iv) || !Number.isInteger(r.io))
+      return !0;
+    const o = e.get(`${r.iv}:${r.io}`);
+    return o === void 0 || !n.hiddenInstanceIds.has(o);
+  }) : t.filter((r) => !Number.isInteger(r.iv) || !Number.isInteger(r.io));
+}
+function pn(t, e) {
+  const n = /* @__PURE__ */ new Map();
+  return t.forEach((r, o) => {
+    if (!Number.isInteger(r.iv) || !Number.isInteger(r.io))
+      return;
+    const s = e.get(`${r.iv}:${r.io}`);
+    if (s === void 0)
+      return;
+    const i = n.get(s);
+    i ? i.push(o) : n.set(s, [o]);
+  }), n;
+}
+function bn(t, e, n, r, o, s, i) {
+  const a = e.map((c, u) => ({
+    id: c.id,
+    blockName: Ve(c, u),
+    line: n[u].line,
+    fill: n[u].fill,
+    dot: n[u].dot,
+    texts: r.get(c.id) ?? []
+  }));
+  return {
+    layer0Index: t,
+    variants: a,
+    instances: o,
+    textIndexesByInstanceId: pn(s, i),
+    ownerInstanceIdByVariantOrdinal: i
+  };
+}
+function An(t) {
+  if (t.byteLength < 4)
+    throw new l("E_HEADER", "Payload too small: missing header length");
+  const e = new DataView(t), n = e.getUint32(0, !0), r = 4, o = r + n;
+  if (o > t.byteLength)
+    throw new l("E_HEADER", "Header length exceeds payload length");
+  let s;
+  try {
+    s = JSON.parse(Ot.decode(new Uint8Array(t, r, n)));
+  } catch (i) {
+    throw new l("E_HEADER_JSON", `Invalid JSON header: ${i.message}`);
+  }
+  return {
+    meta: s,
+    header: Ie(s),
+    dataOffset: o,
+    view: e
+  };
+}
+function Ve(t, e) {
+  var s, i, a;
+  const n = (s = t.name) == null ? void 0 : s.trim();
+  if (n)
+    return n;
+  const r = (i = t.block_name) == null ? void 0 : i.trim();
+  if (r)
+    return r;
+  const o = (a = t.blockName) == null ? void 0 : a.trim();
+  return o || `block_${e}`;
+}
+function In(t) {
+  const e = Number(t.version ?? 1), n = String(t.encoding ?? "").toLowerCase();
+  if (e === 2) {
+    const r = n ? ` ${n}` : "";
+    throw new l(
+      "E_UNSUPPORTED_PACK_VERSION",
+      `当前文件是 V2${r} pack，前端不再兼容解析；请升级到最新版本后再打开。`
+    );
+  }
+}
+function Rn(t) {
+  const e = An(t);
+  return In(e.meta), e;
+}
+function Vn(t) {
+  if (t.byteLength < 4)
+    return !1;
+  const e = new Uint8Array(t, 0, 4);
+  return e[0] === 68 && e[1] === 88 && e[2] === 66 && e[3] === 51;
+}
+function re(t, e) {
+  if (t > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new l("E_GROUP_RANGE", `${e} exceeds safe integer range`);
+  return Number(t);
+}
+function st(t, e, n, r) {
+  if (!Number.isInteger(t) || !Number.isInteger(e) || t < 0 || e < 0 || t + e > n)
+    throw new l("E_GROUP_RANGE", `${r} exceeds payload length`);
+}
+function Nn(t) {
+  if (t.byteLength < 20)
+    throw new l("E_HEADER", "V3 payload too small: missing container header");
+  const e = new DataView(t), n = e.getUint16(4, !0), r = e.getUint16(6, !0), o = e.getUint32(8, !0), s = e.getUint16(12, !0), i = e.getUint16(14, !0), a = e.getUint32(16, !0);
+  if (n !== 3 || r > 6)
+    throw new l("E_GROUP_RANGE", `Unsupported V3 version: ${n}.${r}`);
+  if (o !== 0)
+    throw new l("E_GROUP_RANGE", `Unsupported V3 file flags: ${o}`);
+  if (s < 24)
+    throw new l("E_GROUP_RANGE", `Invalid V3 directory entry size: ${s}`);
+  if (a !== s * i)
+    throw new l("E_GROUP_RANGE", "V3 directory byte size mismatch");
+  const c = 20;
+  st(c, a, t.byteLength, "V3 section directory");
+  const u = /* @__PURE__ */ new Map();
+  for (let m = 0; m < i; m += 1) {
+    const g = c + m * s, d = e.getUint16(g, !0), h = e.getUint16(g + 2, !0), w = e.getUint32(g + 4, !0), y = re(e.getBigUint64(g + 8, !0), "V3 section offset"), f = re(e.getBigUint64(g + 16, !0), "V3 section length");
+    if (h !== 0)
+      throw new l("E_GROUP_RANGE", `Unsupported V3 section flags for type ${d}: ${h}`);
+    if (w !== 0)
+      throw new l("E_GROUP_RANGE", `Invalid V3 section reserved field for type ${d}: ${w}`);
+    st(y, f, t.byteLength, `V3 section ${d}`), u.set(d, { type: d, flags: h, offset: y, length: f });
+  }
+  return { versionMinor: r, sections: u };
+}
+function Z(t, e, n) {
+  const r = t.get(e);
+  if (!r)
+    throw new l("E_GROUP_RANGE", `Missing V3 section ${n}`);
+  return r;
+}
+function xt(t, e) {
+  return t.get(e) ?? { type: e, flags: 0, offset: 0, length: 0 };
+}
+function Gn(t, e, n) {
+  try {
+    return JSON.parse(Ot.decode(new Uint8Array(t, e.offset, e.length)));
+  } catch (r) {
+    throw new l("E_HEADER_JSON", `Invalid V3 ${n} JSON: ${r.message}`);
+  }
+}
+function Un(t) {
+  const e = String(t.encoding ?? "").toLowerCase();
+  return e === "nested_instanced_external" || e === "nested_instanced_external_annotations";
+}
+function Cn(t) {
+  return String(t.encoding ?? "").toLowerCase() === "nested_instanced_external_annotations";
+}
+function Pn(t, e, n) {
+  const r = t.features, o = r && typeof r == "object" && !Array.isArray(r) ? { ...r } : {};
+  return e && (o.has_external_variant_geometry = !0), n && (o.has_external_annotations = !0), Object.keys(o).length ? o : void 0;
+}
+function k(t, e) {
+  if (!Number.isInteger(t) || Number(t) < 0)
+    throw new l("E_HEADER", `${e} must be a non-negative integer`);
+  return Number(t);
+}
+function Ne(t, e) {
+  if (typeof t != "string" || !t.trim())
+    throw new l("E_HEADER", `${e} must be a non-empty string`);
+  return t;
+}
+function oe(t, e) {
+  if (t == null)
+    return null;
+  if (!Array.isArray(t) || t.length !== 4 || t.some((n) => typeof n != "number" || !Number.isFinite(n)))
+    throw new l("E_HEADER", `${e} must be null or [minX, minY, maxX, maxY]`);
+  return [t[0], t[1], t[2], t[3]];
+}
+function Tt(t, e) {
+  if (!rt(t) || Array.isArray(t))
+    throw new l("E_HEADER", `${e} must be an object`);
+  return {
+    line_count: k(t.line_count, `${e}.line_count`),
+    fill_count: k(t.fill_count, `${e}.fill_count`),
+    dot_count: k(t.dot_count, `${e}.dot_count`),
+    bbox: oe(t.bbox, `${e}.bbox`),
+    own_bbox: oe(t.own_bbox, `${e}.own_bbox`)
+  };
+}
+function Sn(t) {
+  return t ? { minX: t[0], minY: t[1], maxX: t[2], maxY: t[3] } : null;
+}
+function Tn(t, e) {
+  const n = t.external_variants;
+  if (!Array.isArray(n))
+    throw new l("E_HEADER", "V3 external SCENE_META.external_variants must be an array");
+  if (n.length !== e)
+    throw new l(
+      "E_GROUP_RANGE",
+      `V3 external variant manifest count mismatch: manifest=${n.length}, table=${e}`
+    );
+  return n.map((r, o) => {
+    if (!rt(r) || Array.isArray(r))
+      throw new l("E_HEADER", `V3 external_variants[${o}] must be an object`);
+    const s = k(r.id, `V3 external_variants[${o}].id`);
+    if (s !== o)
+      throw new l("E_GROUP_RANGE", `V3 external_variants[${o}].id must equal ${o}, found ${s}`);
+    const i = Ne(r.href, `V3 external_variants[${o}].href`), a = k(r.raw_size, `V3 external_variants[${o}].raw_size`);
+    if ("normal" in r || "annotation" in r) {
+      const c = Tt(r.annotation, `V3 external_variants[${o}].annotation`);
+      return {
+        id: s,
+        href: i,
+        raw_size: a,
+        normal: Tt(r.normal, `V3 external_variants[${o}].normal`),
+        annotation: {
+          ...c,
+          text_count: k(
+            rt(r.annotation) && !Array.isArray(r.annotation) ? r.annotation.text_count : void 0,
+            `V3 external_variants[${o}].annotation.text_count`
+          )
+        }
+      };
+    }
+    return {
+      id: s,
+      href: i,
+      raw_size: a,
+      line_count: k(r.line_count, `V3 external_variants[${o}].line_count`),
+      fill_count: k(r.fill_count, `V3 external_variants[${o}].fill_count`),
+      dot_count: k(r.dot_count, `V3 external_variants[${o}].dot_count`)
+    };
+  });
+}
+function Bn(t) {
+  const e = t.external_annotations;
+  if (e == null) return null;
+  if (!rt(e) || Array.isArray(e))
+    throw new l("E_HEADER", "V3 external_annotations must be an object");
+  const n = e.scene;
+  if (n == null) return {};
+  if (!rt(n) || Array.isArray(n))
+    throw new l("E_HEADER", "V3 external_annotations.scene must be an object");
+  const r = Tt(n, "V3 external_annotations.scene");
+  return {
+    scene: {
+      href: Ne(n.href, "V3 external_annotations.scene.href"),
+      raw_size: k(n.raw_size, "V3 external_annotations.scene.raw_size"),
+      ...r,
+      text_count: k(n.text_count, "V3 external_annotations.scene.text_count")
+    }
+  };
+}
+function ht(t, e, n, r) {
+  return st(e, n, t.byteLength, r), Ot.decode(t.subarray(e, e + n));
+}
+function $n(t, e, n) {
+  if (e.length % 20 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 LAYER_TABLE length must be a multiple of 20");
+  const r = new DataView(t), o = [];
+  for (let s = e.offset; s < e.offset + e.length; s += 20) {
+    const i = r.getUint32(s, !0), a = r.getUint32(s + 4, !0);
+    o.push({
+      name: ht(n, i, a, "V3 layer name"),
+      color: [r.getUint8(s + 8), r.getUint8(s + 9), r.getUint8(s + 10)],
+      visible: r.getUint8(s + 11) !== 0,
+      lw_px: r.getFloat32(s + 12, !0)
+    });
+  }
+  return o;
+}
+function ft(t, e, n, r, o, s) {
+  if (n + 4 > r)
+    throw new l("E_GROUP_RANGE", `Missing ${o} vertex_count`);
+  const i = e.getUint32(n, !0), a = n + 4, c = we(t, e, a, i, r, s);
+  if (c.offset > r)
+    throw new l("E_GROUP_RANGE", `${o} exceeds section bounds`);
+  return {
+    chunk: c.chunk,
+    offset: c.offset
+  };
+}
+function Ge(t, e, n, r, o, s) {
+  const i = ft(t, e, n, r, o, s), a = n + 4;
+  return {
+    chunk: i.chunk,
+    snapshot: {
+      count: i.chunk.count,
+      raw: new Uint8Array(t, a, i.offset - a).slice(),
+      groupLayerEncoding: s
+    },
+    offset: i.offset
+  };
+}
+function dt(t = "u8") {
+  return {
+    chunk: { pos: new Float32Array(0), col: new Uint8Array(0), lay: new Uint8Array(0), count: 0 },
+    snapshot: { count: 0, raw: new Uint8Array(0), groupLayerEncoding: t }
+  };
+}
+function On(t = "u8") {
+  return {
+    line: dt(t),
+    fill: dt(t),
+    dot: dt(t)
+  };
+}
+function vn(t, e, n) {
+  var r;
+  return !!(e && n && t.deferExternalVariantGeometry && !((r = t.externalVariantBuffers) != null && r.has(e.id)));
+}
+function _t(t, e, n, r, o, s, i) {
+  if (o === 0)
+    return dt(i);
+  st(r, o, n.length, s);
+  const a = n.offset + r, c = a + o, u = Ge(t, e, a, c, s, i);
+  if (u.offset !== c)
+    throw new l("E_GROUP_RANGE", `${s} has trailing bytes`);
+  return { chunk: u.chunk, snapshot: u.snapshot };
+}
+function Ue(t, e, n) {
+  if ([
+    t.getUint32(e + 8, !0),
+    t.getUint32(e + 12, !0),
+    t.getUint32(e + 16, !0),
+    t.getUint32(e + 20, !0),
+    t.getUint32(e + 24, !0),
+    t.getUint32(e + 28, !0)
+  ].some((o) => o !== 0))
+    throw new l("E_GROUP_RANGE", `V3 external variant ${n} must use zero inline geometry offsets`);
+}
+function nt(t, e, n, r, o, s) {
+  const i = Ge(t, e, n, t.byteLength, o, s);
+  if (i.chunk.count !== r)
+    throw new l(
+      "E_GROUP_RANGE",
+      `${o} vertex_count mismatch: manifest=${r}, sidecar=${i.chunk.count}`
+    );
+  return i;
+}
+function vt(t) {
+  return "normal" in t ? t.normal : t;
+}
+function Mn(t, e, n) {
+  const r = vt(t), o = new DataView(e);
+  let s = 0;
+  const i = nt(e, o, s, r.line_count, `V3 external variant ${t.id} line blob`, n);
+  s = i.offset;
+  const a = nt(e, o, s, r.fill_count, `V3 external variant ${t.id} fill blob`, n);
+  s = a.offset;
+  const c = nt(e, o, s, r.dot_count, `V3 external variant ${t.id} dot blob`, n);
+  if (s = c.offset, s !== e.byteLength)
+    throw new l("E_GROUP_RANGE", `V3 external variant ${t.id} sidecar has trailing bytes`);
+  return {
+    line: { chunk: i.chunk, snapshot: i.snapshot },
+    fill: { chunk: a.chunk, snapshot: a.snapshot },
+    dot: { chunk: c.chunk, snapshot: c.snapshot }
+  };
+}
+function Dn(t, e) {
+  const n = on(e), r = sn(n, 257, "BLOCK_NORMAL_GEOMETRY"), o = new DataView(e);
+  let s = r.offset;
+  const i = r.offset + r.length, a = ye(n.versionMinor), c = nt(e, o, s, t.normal.line_count, `V3.3 external variant ${t.id} normal line blob`, a);
+  s = c.offset;
+  const u = nt(e, o, s, t.normal.fill_count, `V3.3 external variant ${t.id} normal fill blob`, a);
+  s = u.offset;
+  const m = nt(e, o, s, t.normal.dot_count, `V3.3 external variant ${t.id} normal dot blob`, a);
+  if (s = m.offset, s !== i)
+    throw new l("E_GROUP_RANGE", `V3.3 external variant ${t.id} normal geometry section has trailing bytes`);
+  return {
+    line: { chunk: c.chunk, snapshot: c.snapshot },
+    fill: { chunk: u.chunk, snapshot: u.snapshot },
+    dot: { chunk: m.chunk, snapshot: m.snapshot }
+  };
+}
+function kn(t, e, n = "u8") {
+  if (e.byteLength !== t.raw_size)
+    throw new l(
+      "E_GROUP_RANGE",
+      `V3 external variant ${t.id} raw_size mismatch: manifest=${t.raw_size}, sidecar=${e.byteLength}`
+    );
+  return "normal" in t ? Dn(t, e) : Mn(t, e, n);
+}
+function Ln(t, e, n) {
+  const r = e == null ? void 0 : e.get(t.id);
+  if (!r)
+    throw new l("E_GROUP_RANGE", `Missing V3 external sidecar buffer for variant ${t.id}`);
+  return kn(t, r, n);
+}
+function Et(t, e, n, r, o) {
+  if (r === 0)
+    return 0;
+  if (st(n, r, e.length, o), r < 4)
+    throw new l("E_GROUP_RANGE", `Missing ${o} vertex_count`);
+  return t.getUint32(e.offset + n, !0);
+}
+function Fn(t, e, n, r) {
+  const o = n.offset + n.length;
+  let s = n.offset;
+  const i = ft(t, e, s, o, "V3 BASE_GEOMETRY line", r);
+  s = i.offset;
+  const a = ft(t, e, s, o, "V3 BASE_GEOMETRY fill", r);
+  s = a.offset;
+  const c = ft(t, e, s, o, "V3 BASE_GEOMETRY dot", r);
+  if (s = c.offset, s !== o)
+    throw new l("E_GROUP_RANGE", "V3 BASE_GEOMETRY has trailing bytes");
+  return {
+    line: i.chunk,
+    fill: a.chunk,
+    dot: c.chunk
+  };
+}
+function wt(t) {
+  return qe(t.pos, t.count, 2);
+}
+function Xn(t, e, n) {
+  return Bt(Bt(wt(t), wt(e)), wt(n));
+}
+function Ce(t) {
+  return "normal" in t ? Sn(t.normal.bbox ?? t.normal.own_bbox ?? null) : null;
+}
+function Yn(t, e, n, r, o, s, i, a) {
+  if (n.length % 60 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 VARIANT_TABLE length must be a multiple of 60");
+  const c = [], u = /* @__PURE__ */ new Map(), m = [], g = n.length / 60;
+  for (let d = 0; d < g; d += 1) {
+    const h = n.offset + d * 60, w = e.getUint32(h, !0), y = e.getUint32(h + 4, !0), f = (s == null ? void 0 : s[d]) ?? null, _ = !f || !a.requiredExternalVariantIds || a.requiredExternalVariantIds.has(d), b = vn(a, f, _), E = f ? (Ue(e, h, d), !_ || b ? On(i) : Ln(f, a.externalVariantBuffers, i)) : {
+      line: _t(
+        t,
+        e,
+        r,
+        e.getUint32(h + 8, !0),
+        e.getUint32(h + 12, !0),
+        `V3 variant ${d} line blob`,
+        i
+      ),
+      fill: _t(
+        t,
+        e,
+        r,
+        e.getUint32(h + 16, !0),
+        e.getUint32(h + 20, !0),
+        `V3 variant ${d} fill blob`,
+        i
+      ),
+      dot: _t(
+        t,
+        e,
+        r,
+        e.getUint32(h + 24, !0),
+        e.getUint32(h + 28, !0),
+        `V3 variant ${d} dot blob`,
+        i
+      )
+    }, p = f ? vt(f) : null, S = (p == null ? void 0 : p.line_count) ?? E.line.chunk.count, N = (p == null ? void 0 : p.fill_count) ?? E.fill.chunk.count, C = (p == null ? void 0 : p.dot_count) ?? E.dot.chunk.count, G = f && (!_ || b) ? Ce(f) : Xn(E.line.chunk, E.fill.chunk, E.dot.chunk), U = {
+      id: d,
+      name: ht(o, w, y, `V3 variant ${d} name`),
+      line_count: b ? S : E.line.chunk.count,
+      fill_count: b ? N : E.fill.chunk.count,
+      dot_count: b ? C : E.dot.chunk.count,
+      sourceLineCount: S,
+      sourceFillCount: N,
+      sourceDotCount: C,
+      nestedStart: e.getUint32(h + 32, !0),
+      nestedCount: e.getUint32(h + 36, !0),
+      textStart: e.getUint32(h + 40, !0),
+      textCount: e.getUint32(h + 44, !0),
+      precisionOriginX: e.getFloat32(h + 48, !0),
+      precisionOriginY: e.getFloat32(h + 52, !0),
+      lineSnapshot: E.line.snapshot,
+      fillSnapshot: E.fill.snapshot,
+      dotSnapshot: E.dot.snapshot,
+      bbox: G
+    };
+    c.push(U), u.set(d, { line: E.line.chunk, fill: E.fill.chunk, dot: E.dot.chunk }), m.push({ line: E.line.snapshot, fill: E.fill.snapshot, dot: E.dot.snapshot });
+  }
+  return { variantsById: c, variants: u, snapshots: m };
+}
+function zn(t, e, n, r, o) {
+  if (e.length % 60 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 VARIANT_TABLE length must be a multiple of 60");
+  const s = [], i = e.length / 60;
+  for (let a = 0; a < i; a += 1) {
+    const c = e.offset + a * 60, u = t.getUint32(c, !0), m = t.getUint32(c + 4, !0), g = (o == null ? void 0 : o[a]) ?? null;
+    g && Ue(t, c, a);
+    const d = g ? vt(g) : null, h = t.getFloat32(c + 48, !0), w = t.getFloat32(c + 52, !0);
+    s.push({
+      id: a,
+      name: ht(r, u, m, `V3 variant ${a} name`),
+      line_count: g ? d.line_count : Et(
+        t,
+        n,
+        t.getUint32(c + 8, !0),
+        t.getUint32(c + 12, !0),
+        `V3 variant ${a} line blob`
+      ),
+      fill_count: g ? d.fill_count : Et(
+        t,
+        n,
+        t.getUint32(c + 16, !0),
+        t.getUint32(c + 20, !0),
+        `V3 variant ${a} fill blob`
+      ),
+      dot_count: g ? d.dot_count : Et(
+        t,
+        n,
+        t.getUint32(c + 24, !0),
+        t.getUint32(c + 28, !0),
+        `V3 variant ${a} dot blob`
+      ),
+      nestedStart: t.getUint32(c + 32, !0),
+      nestedCount: t.getUint32(c + 36, !0),
+      textStart: t.getUint32(c + 40, !0),
+      textCount: t.getUint32(c + 44, !0),
+      precisionOriginX: h,
+      precisionOriginY: w,
+      bbox: g ? Ce(g) : null
+    });
+  }
+  return s;
+}
+function lt(t, e, n) {
+  if (e.length % 32 !== 0)
+    throw new l("E_GROUP_RANGE", `${n} length must be a multiple of 32`);
+  const r = new DataView(t), o = [];
+  for (let s = e.offset; s < e.offset + e.length; s += 32) {
+    const i = r.getUint16(s + 30, !0);
+    nr(i), o.push({
+      variantId: r.getUint32(s, !0),
+      matA: r.getFloat32(s + 4, !0),
+      matB: r.getFloat32(s + 8, !0),
+      matC: r.getFloat32(s + 12, !0),
+      matD: r.getFloat32(s + 16, !0),
+      tx: r.getFloat32(s + 20, !0),
+      ty: r.getFloat32(s + 24, !0),
+      insLayerIdx: r.getUint16(s + 28, !0),
+      flags: i
+    });
+  }
+  return o;
+}
+function Hn(t, e, n) {
+  const r = t.getUint32(e, !0), o = t.getUint32(e + 4, !0), s = t.getUint8(e + 42), i = t.getUint8(e + 43), a = t.getFloat32(e + 24, !0), c = t.getFloat32(e + 28, !0);
+  return {
+    t: ht(n, r, o, "V3 text value"),
+    x: t.getFloat32(e + 8, !0),
+    y: t.getFloat32(e + 12, !0),
+    h: t.getFloat32(e + 16, !0),
+    r: t.getFloat32(e + 20, !0),
+    c: [t.getUint8(e + 36), t.getUint8(e + 37), t.getUint8(e + 38)],
+    li: t.getUint16(e + 40, !0),
+    ha: dn[s & 3] ?? "left",
+    va: mn[s >> 2 & 3] ?? "alphabetic",
+    lh: t.getFloat32(e + 32, !0),
+    ...a ? { w: a } : {},
+    ...c !== 1 ? { wf: c } : {},
+    ...i & 1 ? { mx: !0 } : {},
+    ...i & 2 ? { my: !0 } : {}
+  };
+}
+function pt(t, e, n, r) {
+  if (e.length % 44 !== 0)
+    throw new l("E_GROUP_RANGE", `${r} length must be a multiple of 44`);
+  const o = [], s = new DataView(t);
+  for (let i = e.offset; i < e.offset + e.length; i += 44)
+    o.push(Hn(s, i, n));
+  return o;
+}
+function Kn(t, e) {
+  if (t.length % 44 !== 0)
+    throw new l("E_GROUP_RANGE", `${e} length must be a multiple of 44`);
+  return t.length / 44;
+}
+function jn(t, e, n, r) {
+  return {
+    instanceId: n,
+    variantId: e.variantId,
+    matA: t.matA * e.matA + t.matC * e.matB,
+    matB: t.matB * e.matA + t.matD * e.matB,
+    matC: t.matA * e.matC + t.matC * e.matD,
+    matD: t.matB * e.matC + t.matD * e.matD,
+    tx: t.matA * e.tx + t.matC * e.ty + t.tx,
+    ty: t.matB * e.tx + t.matD * e.ty + t.ty,
+    insLayerIdx: r
+  };
+}
+function Wn(t, e, n, r) {
+  var y;
+  const o = ((y = r[e.insLayerIdx]) == null ? void 0 : y.visible) === !1, s = e.matA * t.x + e.matC * t.y + e.tx, i = e.matB * t.x + e.matD * t.y + e.ty, a = Math.hypot(e.matA, e.matB), c = Math.hypot(e.matC, e.matD), u = c > 1e-12 ? c : a > 1e-12 ? a : 1, m = a > 1e-12 && u > 1e-12 ? a / u : 1, g = qn(t, e), { mx: d, my: h, ...w } = t;
+  return {
+    ...w,
+    x: s,
+    y: i,
+    h: t.h * u,
+    w: t.w === void 0 ? void 0 : t.w * u,
+    wf: (t.wf ?? 1) * m,
+    r: g.r,
+    ...g.mx ? { mx: !0 } : {},
+    ...g.my ? { my: !0 } : {},
+    li: o || t.li === n ? e.insLayerIdx : t.li
+  };
+}
+function qn(t, e) {
+  const n = t.r * Math.PI / 180, r = Math.cos(n), o = Math.sin(n), s = t.mx ? -1 : 1, i = t.my ? -1 : 1, a = s * (e.matA * r + e.matC * o), c = s * (e.matB * r + e.matD * o), u = i * (e.matC * r - e.matA * o), m = i * (e.matD * r - e.matB * o), g = a * m - c * u, d = Math.atan2(c, a) * 180 / Math.PI;
+  return g < 0 ? { r: Math.atan2(-c, -a) * 180 / Math.PI, mx: !0 } : { r: d };
+}
+function Jn(t, e) {
+  return t === e ? e : t;
+}
+function Zn(t, e, n) {
+  return t === n ? e : t;
+}
+function Qn(t, e) {
+  const n = new DataView(t), { versionMinor: r, sections: o } = Nn(t), s = ye(r), i = Z(o, 1, "SCENE_META"), a = Z(o, 2, "LAYER_TABLE"), c = Z(o, 3, "STRING_TABLE"), u = Z(o, 4, "BASE_GEOMETRY"), m = Z(o, 5, "VARIANT_TABLE"), g = Z(o, 6, "VARIANT_GEOMETRY"), d = Z(o, 7, "SCENE_INSTANCE_TABLE"), h = xt(o, 8), w = xt(o, 9), y = xt(o, 10), f = Gn(t, i, "SCENE_META"), _ = Un(f) ? Tn(f, m.length / 60) : null, b = Cn(f), E = b ? Bn(f) : null, p = Pn(f, _, b), S = b ? "nested_instanced_external_annotations" : _ ? "nested_instanced_external" : "nested_instanced", N = new Uint8Array(t, c.offset, c.length), C = $n(t, a, N), G = Number(f.layer0_index ?? 0), U = Ie({
+    bounds: f.bounds ?? [0, 0, 0, 0],
+    entity_count: Number(f.entity_count ?? 0),
+    line_count: Number(f.base_line_count ?? 0),
+    fill_count: Number(f.base_fill_count ?? 0),
+    dot_count: Number(f.base_dot_count ?? 0),
+    layers: C,
+    texts: []
+  });
+  er(G, U.layers);
+  const R = Fn(t, n, u, s);
+  if (!e.loadBlocks) {
+    const x = zn(n, m, g, N, _), A = lt(t, d, "V3 SCENE_INSTANCE_TABLE"), O = lt(t, h, "V3 NESTED_INSTANCE_TABLE"), P = pt(t, w, N, "V3 SCENE_TEXT_TABLE"), T = Kn(y, "V3 VARIANT_TEXT_TABLE");
+    if (Number(f.variant_count ?? x.length) !== x.length)
+      throw new l("E_GROUP_RANGE", "V3 variant count mismatch");
+    if (Number(f.scene_instance_count ?? A.length) !== A.length)
+      throw new l("E_GROUP_RANGE", "V3 scene instance count mismatch");
+    if (Number(f.nested_instance_count ?? O.length) !== O.length)
+      throw new l("E_GROUP_RANGE", "V3 nested instance count mismatch");
+    if (Number(f.scene_text_count ?? P.length) !== P.length)
+      throw new l("E_GROUP_RANGE", "V3 scene text count mismatch");
+    if (Number(f.variant_text_count ?? T) !== T)
+      throw new l("E_GROUP_RANGE", "V3 variant text count mismatch");
+    for (const I of x) {
+      if (I.nestedStart + I.nestedCount > O.length)
+        throw new l("E_GROUP_RANGE", `V3 variant ${I.id} nested range exceeds table`);
+      if (I.textStart + I.textCount > T)
+        throw new l("E_GROUP_RANGE", `V3 variant ${I.id} text range exceeds table`);
+    }
+    return ne(A, O, (I) => {
+      if (!x[I.variantId])
+        throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${I.variantId}`);
+      ce(I.insLayerIdx, C.length);
+    }), {
+      meta: {
+        bounds: f.bounds ?? [0, 0, 0, 0],
+        entity_count: Number(f.entity_count ?? 0),
+        line_count: R.line.count,
+        fill_count: R.fill.count,
+        dot_count: R.dot.count,
+        version: 3,
+        version_minor: r,
+        encoding: S,
+        ...p ? { features: p } : {},
+        ..._ ? { external_variants: [..._] } : {},
+        ...E ? { external_annotations: E } : {},
+        layer0_index: G,
+        block_variants: x.map((I) => ({
+          id: I.id,
+          name: I.name,
+          line_count: I.line_count,
+          fill_count: I.fill_count,
+          dot_count: I.dot_count
+        })),
+        instance_count: A.length,
+        layers: C,
+        texts: P
+      },
+      header: {
+        ...U,
+        lineCount: R.line.count,
+        fillCount: R.fill.count,
+        dotCount: R.dot.count,
+        textCount: P.length,
+        texts: P
+      },
+      decoded: {
+        baseLine: R.line,
+        baseFill: R.fill,
+        baseDot: R.dot,
+        variants: /* @__PURE__ */ new Map(),
+        instances: [],
+        instanceIdByVariantOrdinal: /* @__PURE__ */ new Map()
+      }
+    };
+  }
+  const { variantsById: V, variants: L, snapshots: F } = Yn(
+    t,
+    n,
+    m,
+    g,
+    N,
+    _,
+    s,
+    e
+  ), z = lt(t, d, "V3 SCENE_INSTANCE_TABLE"), $ = lt(t, h, "V3 NESTED_INSTANCE_TABLE"), v = pt(t, w, N, "V3 SCENE_TEXT_TABLE"), B = pt(t, y, N, "V3 VARIANT_TEXT_TABLE");
+  if (Number(f.variant_count ?? V.length) !== V.length)
+    throw new l("E_GROUP_RANGE", "V3 variant count mismatch");
+  if (Number(f.scene_instance_count ?? z.length) !== z.length)
+    throw new l("E_GROUP_RANGE", "V3 scene instance count mismatch");
+  if (Number(f.nested_instance_count ?? $.length) !== $.length)
+    throw new l("E_GROUP_RANGE", "V3 nested instance count mismatch");
+  if (Number(f.scene_text_count ?? v.length) !== v.length)
+    throw new l("E_GROUP_RANGE", "V3 scene text count mismatch");
+  if (Number(f.variant_text_count ?? B.length) !== B.length)
+    throw new l("E_GROUP_RANGE", "V3 variant text count mismatch");
+  for (const x of V) {
+    if (x.nestedStart + x.nestedCount > $.length)
+      throw new l("E_GROUP_RANGE", `V3 variant ${x.id} nested range exceeds table`);
+    if (x.textStart + x.textCount > B.length)
+      throw new l("E_GROUP_RANGE", `V3 variant ${x.id} text range exceeds table`);
+  }
+  ne(z, $, (x) => {
+    if (!V[x.variantId])
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${x.variantId}`);
+    ce(x.insLayerIdx, C.length);
+  });
+  const Mt = /* @__PURE__ */ new Map();
+  for (const x of V)
+    Mt.set(
+      x.id,
+      B.slice(x.textStart, x.textStart + x.textCount)
+    );
+  const it = [], M = e.externalVariantDeltaOnly, Dt = M ? [] : [...v], gt = /* @__PURE__ */ new Map(), at = /* @__PURE__ */ new Map(), kt = /* @__PURE__ */ new Map(), $e = (x, A) => {
+    gt.set(x, Bt(gt.get(x) ?? null, A));
+  }, Lt = (x, A, O, P, T, j) => {
+    var Kt;
+    if (T > 64)
+      throw new l("E_GROUP_RANGE", "V3 nested instance depth exceeds limit");
+    if (j.has(x))
+      throw new l("E_GROUP_RANGE", `V3 nested variant cycle detected at ${x}`);
+    const I = V[x];
+    if (!I)
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${x}`);
+    j.add(x);
+    const W = !e.requiredExternalVariantIds || e.requiredExternalVariantIds.has(x), X = M ? ((Kt = e.requiredExternalVariantIds) == null ? void 0 : Kt.has(x)) === !0 : W;
+    let D = !1;
+    const Ht = !!(I.line_count || I.fill_count || I.dot_count), Me = I.textCount > 0;
+    if (X && (Ht || Me) && (it.push({
+      instanceId: A.instanceId,
+      variantId: x,
+      matA: A.matA,
+      matB: A.matB,
+      matC: A.matC,
+      matD: A.matD,
+      tx: A.tx,
+      ty: A.ty,
+      insLayerIdx: A.insLayerIdx
+    }), Ht && $e(A.instanceId, I.bbox ? Pe(I.bbox, A) : null), D = !0), X) {
+      I.textCount > 0 && (D = !0);
+      for (let q = 0; q < I.textCount; q += 1) {
+        const tt = Wn(B[I.textStart + q], A, G, U.layers);
+        Dt.push({
+          ...tt,
+          iv: O,
+          io: P
+        });
+      }
+    }
+    for (let q = 0; q < I.nestedCount; q += 1) {
+      const tt = $[I.nestedStart + q], De = Zn(tt.insLayerIdx, A.insLayerIdx, G), ke = tr(tt, I, V[tt.variantId]), Le = jn(A, ke, A.instanceId, De);
+      D = Lt(tt.variantId, Le, O, P, T + 1, j) || D;
+    }
+    return j.delete(x), D;
+  }, yt = /* @__PURE__ */ new Map();
+  z.forEach((x, A) => {
+    if (!V[x.variantId])
+      throw new l("E_GROUP_RANGE", `Unknown V3 scene variantId ${x.variantId}`);
+    const P = kt.get(x.variantId) ?? 0;
+    kt.set(x.variantId, P + 1), at.set(`${x.variantId}:${P}`, A);
+    const T = Jn(x.insLayerIdx, G), j = {
+      instanceId: A,
+      variantId: x.variantId,
+      matA: x.matA,
+      matB: x.matB,
+      matC: x.matC,
+      matD: x.matD,
+      tx: x.tx,
+      ty: x.ty,
+      insLayerIdx: T
+    }, I = Lt(x.variantId, j, x.variantId, P, 0, /* @__PURE__ */ new Set());
+    if (M && !I)
+      return;
+    let W = yt.get(T);
+    W || (W = /* @__PURE__ */ new Map(), yt.set(T, W));
+    let X = W.get(x.variantId);
+    X || (X = { count: 0, bboxes: [], inserts: [] }, W.set(x.variantId, X)), X.count += 1;
+    const D = gt.get(A) ?? null;
+    D && X.bboxes.push(D), X.inserts.push({
+      instanceId: A,
+      variantId: x.variantId,
+      label: `#${A + 1} (${x.tx.toFixed(1)}, ${x.ty.toFixed(1)})`,
+      tx: x.tx,
+      ty: x.ty,
+      canHighlight: D !== null,
+      ...D ? { bbox: D } : {}
+    });
+  });
+  const Ft = /* @__PURE__ */ new Map();
+  for (const [x, A] of yt) {
+    const O = [];
+    for (const [P, T] of A)
+      O.push({
+        variantId: P,
+        blockName: Ve(V[P], P),
+        instanceCount: T.count,
+        bboxes: T.bboxes,
+        inserts: T.inserts
+      });
+    O.sort((P, T) => T.instanceCount - P.instanceCount), Ft.set(x, O);
+  }
+  let Xt = M ? 0 : R.line.count, Yt = M ? 0 : R.fill.count, zt = M ? 0 : R.dot.count;
+  for (const x of it) {
+    const A = V[x.variantId];
+    !(e.deferExternalVariantGeometry && A.lineSnapshot.count === 0 && A.fillSnapshot.count === 0 && A.dotSnapshot.count === 0) && !Re(x.instanceId, e) || (Xt += A.line_count, Yt += A.fill_count, zt += A.dot_count);
+  }
+  const ct = wn(Dt, at, e), Oe = {
+    bounds: f.bounds ?? [0, 0, 0, 0],
+    entity_count: M ? 0 : Number(f.entity_count ?? 0),
+    line_count: R.line.count,
+    fill_count: R.fill.count,
+    dot_count: R.dot.count,
+    version: 3,
+    version_minor: r,
+    encoding: S,
+    ...p ? { features: p } : {},
+    ..._ ? { external_variants: [..._] } : {},
+    ...E ? { external_annotations: E } : {},
+    layer0_index: G,
+    block_variants: V.map((x) => ({
+      id: x.id,
+      name: x.name,
+      line_count: x.sourceLineCount,
+      fill_count: x.sourceFillCount,
+      dot_count: x.sourceDotCount
+    })),
+    instance_count: z.length,
+    layers: C,
+    texts: ct
+  }, ve = {
+    ...U,
+    entityCount: M ? 0 : U.entityCount,
+    lineCount: Xt,
+    fillCount: Yt,
+    dotCount: zt,
+    textCount: ct.length,
+    texts: ct,
+    ...e.loadBlocks ? {
+      layerBlockUsages: Ft,
+      insertRuntime: bn(
+        G,
+        V,
+        F,
+        Mt,
+        it,
+        ct,
+        at
+      )
+    } : {}
+  };
+  return {
+    meta: Oe,
+    header: ve,
+    decoded: {
+      baseLine: M ? At() : R.line,
+      baseFill: M ? At() : R.fill,
+      baseDot: M ? At() : R.dot,
+      variants: L,
+      instances: it,
+      instanceIdByVariantOrdinal: at
+    }
+  };
+}
+function Bt(t, e) {
+  return be(t, e);
+}
+function Pe(t, e) {
+  return Ae(t, e);
+}
+function se(t) {
+  return Je(t);
+}
+function ie(t, e) {
+  return Ze(t, e);
+}
+function ae(t, e) {
+  return Pe(t, {
+    variantId: e.variantId,
+    matA: e.matA,
+    matB: e.matB,
+    matC: e.matC,
+    matD: e.matD,
+    tx: e.tx,
+    ty: e.ty,
+    insLayerIdx: e.insLayerIdx
+  });
+}
+function tr(t, e, n) {
+  if (!(n != null && n.bbox) || !e.bbox)
+    return t;
+  const r = e.precisionOriginX, o = e.precisionOriginY;
+  if (!Number.isFinite(r) || !Number.isFinite(o) || r === 0 && o === 0)
+    return t;
+  const s = {
+    ...t,
+    tx: t.tx - r,
+    ty: t.ty - o
+  }, i = ae(n.bbox, t), a = ae(n.bbox, s), c = Math.max(se(e.bbox), se(n.bbox), 1), u = Math.hypot(r, o), m = Math.hypot(t.tx, t.ty), g = Math.hypot(s.tx, s.ty);
+  if (u <= c * 16 || m <= c * 16)
+    return t;
+  const d = ie(e.bbox, i), h = ie(e.bbox, a);
+  return d > c * 16 && h * 4 < d && g * 4 < m ? s : t;
+}
+function ce(t, e) {
+  if (t >= e)
+    throw new l("E_GROUP_RANGE", `Instance layer index ${t} exceeds layer count ${e}`);
+}
+function er(t, e) {
+  if (!Number.isInteger(t) || t < 0 || t >= e.length)
+    throw new l("E_GROUP_RANGE", `layer0_index out of range: ${t}`);
+  if (e[t].name !== "0")
+    throw new l("E_GROUP_RANGE", `layer0_index must reference layer "0": ${t}`);
+}
+function nr(t) {
+  if (t !== 0)
+    throw new l("E_GROUP_RANGE", `Instance flags must be zero for Stage 1, found ${t}`);
+}
+function* rr(t, e, n, r, o) {
+  let s = n;
+  const i = [
+    { kind: "line", count: r.lineCount },
+    { kind: "fill", count: r.fillCount },
+    { kind: "dot", count: r.dotCount }
+  ];
+  for (const a of i) {
+    const c = We(t, e, s, a.count);
+    for (; ; ) {
+      const u = c.next();
+      if (u.done) {
+        s = u.value;
+        break;
+      }
+      yield { kind: a.kind, payload: u.value };
+    }
+  }
+  if (s !== t.byteLength)
+    throw new l("E_GROUP_RANGE", `Trailing bytes detected: offset=${s}, size=${t.byteLength}`);
+  for (const a of r.texts)
+    yield { kind: "text", payload: a };
+}
+function* or(t, e, n, r) {
+  yield* rr(t, e, n, r);
+}
+function* bt(t, e, n, r, o, s, i, a) {
+  if (En(a, t, Math.max(0, e - n.count)), e === 0) {
+    yield { kind: t, payload: an() };
+    return;
+  }
+  const c = Ut;
+  let u = new Float32Array(c * 2), m = [], g = 0, d = 0;
+  const h = function* () {
+    if (g <= 0)
+      return;
+    const f = g === c ? { pos: u, count: g, segments: ee(m) } : { pos: u.slice(0, g * 2), count: g, segments: ee(m) };
+    yield { kind: t, payload: f }, d += g, g = 0, u = new Float32Array(c * 2), m = [];
+  }, w = (f, _, b, E) => {
+    if (f <= 0)
+      return;
+    const p = m[m.length - 1];
+    if (p && p.startVertex + p.vertexCount === g && p.layerIndex === b && p.color[0] === _[0] && p.color[1] === _[1] && p.color[2] === _[2] && p.lineweightPx === E) {
+      m[m.length - 1] = {
+        ...p,
+        vertexCount: p.vertexCount + f
+      };
+      return;
+    }
+    m.push({
+      startVertex: g,
+      vertexCount: f,
+      color: [_[0], _[1], _[2]],
+      layerIndex: b,
+      ...E === void 0 ? {} : { lineweightPx: E }
+    });
+  };
+  yield* function* () {
+    for (const f of St(n)) {
+      let _ = f.startVertex;
+      const b = f.startVertex + f.vertexCount;
+      for (; _ < b; ) {
+        const E = Math.min(c - g, b - _), p = _ * 2, S = g * 2;
+        u.set(n.pos.subarray(p, p + E * 2), S), w(E, f.color, f.layerIndex, f.lineweightPx), _ += E, g += E, g === c && (yield* h());
+      }
+    }
+  }();
+  for (const f of o) {
+    if (!Re(f.instanceId, a))
+      continue;
+    const _ = r.get(f.variantId);
+    if (!_)
+      throw new l("E_GROUP_RANGE", `Unknown variantId ${f.variantId}`);
+    const b = _[t], E = i[f.insLayerIdx].visible === !1;
+    for (const p of St(b)) {
+      const S = E || p.layerIndex === s ? f.insLayerIdx : p.layerIndex;
+      let N = p.startVertex;
+      const C = p.startVertex + p.vertexCount;
+      for (; N < C; ) {
+        const G = Math.min(c - g, C - N);
+        for (let U = 0; U < G; U += 1) {
+          const R = (N + U) * 2, V = (g + U) * 2, L = b.pos[R], F = b.pos[R + 1];
+          u[V] = f.matA * L + f.matC * F + f.tx, u[V + 1] = f.matB * L + f.matD * F + f.ty;
+        }
+        w(G, p.color, S, p.lineweightPx), N += G, g += G, g === c && (yield* h());
+      }
+    }
+  }
+  if (yield* h(), d !== e)
+    throw new l("E_GROUP_RANGE", `Expanded ${t} count mismatch: header=${e}, emitted=${d}`);
+}
+function* sr(t, e, n, r) {
+  yield* bt(
+    "line",
+    e.lineCount,
+    t.baseLine,
+    t.variants,
+    t.instances,
+    n.layer0_index,
+    e.layers,
+    r
+  ), yield* bt(
+    "fill",
+    e.fillCount,
+    t.baseFill,
+    t.variants,
+    t.instances,
+    n.layer0_index,
+    e.layers,
+    r
+  ), yield* bt(
+    "dot",
+    e.dotCount,
+    t.baseDot,
+    t.variants,
+    t.instances,
+    n.layer0_index,
+    e.layers,
+    r
+  );
+  for (const o of e.texts)
+    yield { kind: "text", payload: o };
+}
+function ir(t, e) {
+  const n = xn(e), r = Qn(t, n);
+  return {
+    header: r.header,
+    chunks: sr(
+      r.decoded,
+      r.header,
+      { layer0_index: r.meta.layer0_index ?? 0 },
+      n
+    )
+  };
+}
+function ar(t, e) {
+  if (Vn(t))
+    return ir(t, e);
+  const n = Rn(t);
+  return {
+    header: n.header,
+    chunks: or(t, n.view, n.dataOffset, n.header)
+  };
+}
+function At() {
+  return {
+    pos: new Float32Array(0),
+    col: new Uint8Array(0),
+    lay: new Uint8Array(0),
+    count: 0
+  };
+}
+function cr(t, e) {
+  return t ? mt(Ae(t, e)) : null;
+}
+async function ur(t) {
+  const e = ue(), n = t.fetchImpl ?? fetch, r = new Map(
+    t.entries.map((u) => [u.id, u])
+  ), o = Array.from(new Set(t.requiredVariantIds)).sort((u, m) => u - m), s = /* @__PURE__ */ new Map(), i = lr(t.concurrency);
+  let a = 0;
+  async function c() {
+    for (; a < o.length; ) {
+      const u = o[a++], m = r.get(u);
+      if (!m)
+        throw new Error(`External block ${u} is missing from manifest`);
+      const g = new URL(m.href, t.baseUrl).href, d = await n(g, { signal: t.signal });
+      if (!d.ok) {
+        const w = "status" in d ? d.status : void 0, y = "statusText" in d ? d.statusText : void 0, f = [w, y].filter((_) => _ !== void 0 && _ !== "").join(" ");
+        throw new Error(`External block ${u} fetch failed${f ? `: ${f}` : ""}`);
+      }
+      const h = await d.arrayBuffer();
+      if (h.byteLength !== m.raw_size)
+        throw new Error(
+          `External block ${u} raw_size mismatch: manifest=${m.raw_size}, response=${h.byteLength}`
+        );
+      s.set(u, h);
+    }
+  }
+  return await Promise.all(Array.from({ length: Math.min(i, o.length) }, c)), { buffers: s, fetchMs: ue() - e };
+}
+function lr(t) {
+  const e = Math.floor(t ?? 3);
+  return Number.isFinite(e) ? Math.max(1, Math.min(e, 8)) : 3;
+}
+function ue() {
+  var t, e;
+  return ((e = (t = globalThis.performance) == null ? void 0 : t.now) == null ? void 0 : e.call(t)) ?? Date.now();
+}
+var K;
+class fr {
+  constructor() {
+    Wt(this, K, /* @__PURE__ */ new Map());
+  }
+  get size() {
+    return et(this, K).size;
+  }
+  append(e) {
+    let n = 0;
+    for (const r of e) {
+      if (r.count <= 0) continue;
+      const o = $t(r.layerIndex, r.lineweightPx);
+      let s = et(this, K).get(o), i = r.pos, a = r.positionItemSize;
+      const c = r.linePositionKind ?? null;
+      s ? s.positionItemSize !== a && (le(s), a !== 3 && (i = Te(i, r.count, a)), s.positionItemSize = 3, a = 3, s.linePositionKind = null) : (s = {
+        layerIndex: r.layerIndex,
+        ...r.lineweightPx === void 0 ? {} : { lineweightPx: r.lineweightPx },
+        posParts: [],
+        positionItemSize: a,
+        colParts: [],
+        colorRunParts: [],
+        linePositionKind: c,
+        count: 0,
+        bbox: null
+      }, et(this, K).set(o, s));
+      const u = s.count > 0;
+      s.posParts.push(i), s.colParts.push(r.col);
+      const m = Er(
+        r.colorRuns ?? wr(r.col),
+        s.count
+      );
+      s.colorRunParts.push(m), s.linePositionKind !== c && (s.linePositionKind = null), s.positionItemSize === 2 && s.linePositionKind === null && le(s), s.count += r.count, s.bbox = u && s.bbox === null ? null : mr(s.bbox, r.bbox), n += r.count;
+    }
+    return n;
+  }
+  drain() {
+    const e = [];
+    for (const n of et(this, K).values()) {
+      if (n.count <= 0) continue;
+      const r = n.posParts.length === 1 ? n.posParts[0] : xr(n.posParts, n.count * n.positionItemSize), o = n.colParts.length === 1 ? n.colParts[0] : _r(n.colParts, n.count * 3), s = Be(n.colorRunParts.flat()), i = {
+        layerIndex: n.layerIndex,
+        pos: r,
+        positionItemSize: n.positionItemSize,
+        col: o,
+        count: n.count,
+        bbox: mt(n.bbox),
+        colorRuns: s
+      };
+      n.lineweightPx !== void 0 && (i.lineweightPx = n.lineweightPx), n.linePositionKind && (i.linePositionKind = n.linePositionKind), e.push(i);
+    }
+    return et(this, K).clear(), e;
+  }
+}
+K = new WeakMap();
+function It() {
+  return new fr();
+}
+function dr() {
+  return {
+    line: It(),
+    fill: It(),
+    dot: It()
+  };
+}
+function mr(t, e) {
+  const n = mt(e);
+  return t ? n ? {
+    minX: Math.min(t.minX, n.minX),
+    minY: Math.min(t.minY, n.minY),
+    maxX: Math.max(t.maxX, n.maxX),
+    maxY: Math.max(t.maxY, n.maxY)
+  } : null : n;
+}
+function Se(t, e = {}) {
+  if (t.count <= 0) return [];
+  const n = St(t), r = [], o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = e.markLinePositionXy === !0 || e.splitLineweight === !0;
+  for (const y of n) {
+    if (y.vertexCount <= 0) continue;
+    const f = y.layerIndex, _ = a ? y.lineweightPx : void 0, b = $t(f, _), E = o.get(b);
+    E === void 0 ? (o.set(b, y.vertexCount), s.set(b, f), i.set(b, _), r.push(b)) : o.set(b, E + y.vertexCount);
+  }
+  const c = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Set(), d = e.markLinePositionXy === !0 ? "xy-zero-z" : void 0, h = d ? 2 : 3;
+  for (const y of r) {
+    const f = s.get(y), _ = i.get(y), b = o.get(y) ?? 0, E = {
+      layerIndex: f,
+      ..._ === void 0 ? {} : { lineweightPx: _ },
+      pos: new Float32Array(b * h),
+      positionItemSize: h,
+      col: new Uint8Array(b * 3),
+      count: b,
+      bbox: null,
+      colorRuns: []
+    };
+    d && (E.linePositionKind = d), c.set(y, E), u.set(y, 0), m.set(y, null);
+  }
+  for (const y of n) {
+    if (y.vertexCount <= 0) continue;
+    const f = y.layerIndex, _ = a ? y.lineweightPx : void 0, b = $t(f, _), E = c.get(b), p = u.get(b), S = p, N = y.color[0], C = y.color[1], G = y.color[2];
+    for (let U = 0; U < y.vertexCount; U += 1) {
+      const R = y.startVertex + U, V = p + U, L = V * h, F = V * 3, z = R * 2, $ = t.pos[z], v = t.pos[z + 1];
+      E.pos[L] = $, E.pos[L + 1] = v, h === 3 && (E.pos[L + 2] = 0), E.col[F] = N, E.col[F + 1] = C, E.col[F + 2] = G;
+      const B = m.get(b);
+      !Number.isFinite($) || !Number.isFinite(v) ? g.add(b) : B ? ($ < B.minX && (B.minX = $), v < B.minY && (B.minY = v), $ > B.maxX && (B.maxX = $), v > B.maxY && (B.maxY = v)) : m.set(b, { minX: $, minY: v, maxX: $, maxY: v });
+    }
+    E.colorRuns.push({
+      startVertex: S,
+      vertexCount: y.vertexCount,
+      color: [N, C, G]
+    }), u.set(b, p + y.vertexCount);
+  }
+  const w = [];
+  for (const y of r) {
+    const f = c.get(y);
+    f && (f.bbox = g.has(y) ? null : mt(m.get(y) ?? null), f.colorRuns = Be(f.colorRuns ?? []), w.push(f));
+  }
+  return w;
+}
+function $t(t, e) {
+  return e === void 0 ? `${t}:` : `${t}:${e}`;
+}
+function hr(t, e) {
+  return t.append(e);
+}
+function gr(t) {
+  return t.drain();
+}
+function yr(t) {
+  const e = [], n = /* @__PURE__ */ new Set();
+  for (const r of t)
+    fe(e, n, r.pos.buffer), fe(e, n, r.col.buffer);
+  return e;
+}
+function xr(t, e) {
+  const n = new Float32Array(e);
+  let r = 0;
+  for (const o of t)
+    n.set(o, r), r += o.length;
+  return n;
+}
+function Te(t, e, n) {
+  if (n === 3) return t;
+  const r = new Float32Array(e * 3);
+  for (let o = 0; o < e; o += 1) {
+    const s = o * 2, i = o * 3;
+    r[i] = t[s] ?? 0, r[i + 1] = t[s + 1] ?? 0, r[i + 2] = 0;
+  }
+  return r;
+}
+function le(t) {
+  if (t.positionItemSize === 3) return;
+  const e = t.positionItemSize;
+  t.posParts = t.posParts.map((n) => Te(n, n.length / e, e)), t.positionItemSize = 3, t.linePositionKind = null;
+}
+function _r(t, e) {
+  const n = new Uint8Array(e);
+  let r = 0;
+  for (const o of t)
+    n.set(o, r), r += o.length;
+  return n;
+}
+function Er(t, e) {
+  return t.map((n) => ({
+    startVertex: n.startVertex + e,
+    vertexCount: n.vertexCount,
+    color: [n.color[0], n.color[1], n.color[2]]
+  }));
+}
+function Be(t) {
+  const e = [];
+  for (const n of t) {
+    const r = e[e.length - 1];
+    if (r && r.startVertex + r.vertexCount === n.startVertex && r.color[0] === n.color[0] && r.color[1] === n.color[1] && r.color[2] === n.color[2]) {
+      e[e.length - 1] = {
+        ...r,
+        vertexCount: r.vertexCount + n.vertexCount
+      };
+      continue;
+    }
+    e.push({
+      startVertex: n.startVertex,
+      vertexCount: n.vertexCount,
+      color: [n.color[0], n.color[1], n.color[2]]
+    });
+  }
+  return e;
+}
+function wr(t) {
+  const e = Math.floor(t.length / 3), n = [];
+  let r = 0;
+  for (; r < e; ) {
+    const o = r * 3, s = t[o] ?? 0, i = t[o + 1] ?? 0, a = t[o + 2] ?? 0;
+    let c = r + 1;
+    for (; c < e; ) {
+      const u = c * 3;
+      if (t[u] !== s || t[u + 1] !== i || t[u + 2] !== a) break;
+      c += 1;
+    }
+    n.push({ startVertex: r, vertexCount: c - r, color: [s, i, a] }), r = c;
+  }
+  return n;
+}
+function fe(t, e, n) {
+  n instanceof ArrayBuffer && (e.has(n) || (e.add(n), t.push(n)));
+}
+function pr(t, e, n = "u8") {
+  if (e <= 0 && t.byteLength === 0)
+    return { pos: new Float32Array(0), count: 0, segments: [] };
+  const { buffer: r, startOffset: o, endOffset: s } = Rr(t), i = new DataView(r), a = we(r, i, o, e, s, n);
+  if (a.offset !== s)
+    throw new l(
+      "E_GROUP_RANGE",
+      `Insert runtime geometry chunk has trailing bytes: offset=${a.offset - o}, length=${t.byteLength}`
+    );
+  return a.chunk;
+}
+function br(t) {
+  const e = (n) => {
+    const r = t[n], o = pr(
+      r.raw,
+      r.count,
+      r.groupLayerEncoding
+    ), s = Se(o, { splitLineweight: n === "line" }), i = /* @__PURE__ */ new Map();
+    for (const a of s)
+      i.set(Ar(a.layerIndex, a.lineweightPx), {
+        layerIndex: a.layerIndex,
+        ...a.lineweightPx === void 0 ? {} : { lineweightPx: a.lineweightPx },
+        pos: a.pos,
+        col: a.col,
+        count: a.count,
+        bbox: ot(a.bbox)
+      });
+    return i;
+  };
+  return {
+    line: e("line"),
+    fill: e("fill"),
+    dot: e("dot")
+  };
+}
+function Ar(t, e) {
+  return e === void 0 ? `${t}:` : `${t}:${e}`;
+}
+function Ir(t, e) {
+  let n = e ? ot(e) : null;
+  for (const r of ["line", "fill", "dot"])
+    for (const o of t[r].values())
+      n = be(n, o.bbox);
+  return n;
+}
+function Rr(t) {
+  if (t.buffer instanceof ArrayBuffer)
+    return {
+      buffer: t.buffer,
+      startOffset: t.byteOffset,
+      endOffset: t.byteOffset + t.byteLength
+    };
+  const e = Uint8Array.from(t);
+  return {
+    buffer: e.buffer,
+    startOffset: e.byteOffset,
+    endOffset: e.byteOffset + e.byteLength
+  };
+}
+function Vr(t) {
+  const e = t.insertRuntime;
+  if (!e || e.instances.length === 0) return null;
+  const n = [], r = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set();
+  for (const c of e.variants) {
+    const u = br(c), m = Rt(u.line), g = Rt(u.fill), d = Rt(u.dot), h = m.length > 0 || g.length > 0 || d.length > 0;
+    r.set(c.id, h ? Ir(u, null) : null), h && (o.add(c.id), n.push({
+      variantId: c.id,
+      line: m,
+      fill: g,
+      dot: d
+    }));
+  }
+  const s = e.instances.filter((c) => o.has(c.variantId));
+  if (s.length === 0) return null;
+  const i = Ur(s, r), a = Pr(n, i);
+  return {
+    variants: n,
+    instances: i,
+    bytes: a,
+    cost: i.count
+  };
+}
+function Nr(t) {
+  const e = [], n = /* @__PURE__ */ new Set(), r = (o) => {
+    n.has(o) || (n.add(o), e.push(o));
+  };
+  r(t.instances.meta.buffer), r(t.instances.mats.buffer), r(t.instances.bboxes.buffer);
+  for (const o of t.variants)
+    Nt(o.line, r), Nt(o.fill, r), Nt(o.dot, r);
+  return e;
+}
+function Rt(t) {
+  const e = [];
+  for (const n of t.values())
+    n.count <= 0 || e.push(Gr(n));
+  return e;
+}
+function Gr(t) {
+  return {
+    pos: t.pos,
+    col: t.col,
+    count: t.count,
+    layerIndex: t.layerIndex,
+    ...t.lineweightPx === void 0 ? {} : { lineweightPx: t.lineweightPx },
+    bbox: t.bbox
+  };
+}
+function Ur(t, e) {
+  const n = t.length, r = new Uint32Array(n * 3), o = new Float32Array(n * 6), s = new Float32Array(n * 4);
+  for (let i = 0; i < n; i += 1) {
+    const a = t[i], c = i * 3;
+    r[c] = a.instanceId, r[c + 1] = a.variantId, r[c + 2] = a.insLayerIdx;
+    const u = i * 6;
+    o[u] = a.matA, o[u + 1] = a.matB, o[u + 2] = a.matC, o[u + 3] = a.matD, o[u + 4] = a.tx, o[u + 5] = a.ty;
+    const m = cr(e.get(a.variantId) ?? null, a);
+    Cr(s, i * 4, m);
+  }
+  return { meta: r, mats: o, bboxes: s, count: n };
+}
+function Cr(t, e, n) {
+  if (!n) {
+    t[e] = Number.POSITIVE_INFINITY, t[e + 1] = Number.POSITIVE_INFINITY, t[e + 2] = Number.NEGATIVE_INFINITY, t[e + 3] = Number.NEGATIVE_INFINITY;
+    return;
+  }
+  t[e] = n.minX, t[e + 1] = n.minY, t[e + 2] = n.maxX, t[e + 3] = n.maxY;
+}
+function Pr(t, e) {
+  let n = e.meta.byteLength + e.mats.byteLength + e.bboxes.byteLength;
+  for (const r of t)
+    n += Vt(r.line), n += Vt(r.fill), n += Vt(r.dot);
+  return n;
+}
+function Vt(t) {
+  return t.reduce((e, n) => e + n.pos.byteLength + n.col.byteLength, 0);
+}
+function Nt(t, e) {
+  for (const n of t)
+    e(n.pos.buffer), e(n.col.buffer);
+}
+function de() {
+  return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+class Sr {
+  constructor() {
+    J(this, "geometryCredits", 0);
+    J(this, "textCredits", 0);
+    J(this, "cancelled", !1);
+    J(this, "geometryWaiters", []);
+    J(this, "textWaiters", []);
+  }
+  grant(e) {
+    this.cancelled || (this.geometryCredits += Math.max(0, e.geometryCredits), this.textCredits += Math.max(0, e.textCredits), this.flushWaiters());
+  }
+  cancel() {
+    if (!this.cancelled) {
+      this.cancelled = !0, this.geometryCredits = 0, this.textCredits = 0;
+      for (const e of this.geometryWaiters.splice(0, this.geometryWaiters.length))
+        e(!1);
+      for (const e of this.textWaiters.splice(0, this.textWaiters.length))
+        e(!1);
+    }
+  }
+  take(e) {
+    return this.cancelled ? Promise.resolve(!1) : e === "geometry" && this.geometryCredits > 0 ? (this.geometryCredits -= 1, Promise.resolve(!0)) : e === "text" && this.textCredits > 0 ? (this.textCredits -= 1, Promise.resolve(!0)) : new Promise((n) => {
+      this.getWaiters(e).push(n);
+    });
+  }
+  flushWaiters() {
+    this.flushKind("geometry"), this.flushKind("text");
+  }
+  flushKind(e) {
+    const n = this.getWaiters(e);
+    for (; n.length > 0 && this.getCredits(e) > 0; ) {
+      this.setCredits(e, this.getCredits(e) - 1);
+      const r = n.shift();
+      r == null || r(!0);
+    }
+  }
+  getCredits(e) {
+    return e === "geometry" ? this.geometryCredits : this.textCredits;
+  }
+  setCredits(e, n) {
+    if (e === "geometry") {
+      this.geometryCredits = n;
+      return;
+    }
+    this.textCredits = n;
+  }
+  getWaiters(e) {
+    return e === "geometry" ? this.geometryWaiters : this.textWaiters;
+  }
+}
+const me = 262144, Tr = Number.MAX_SAFE_INTEGER, he = 524288, Br = Number.MAX_SAFE_INTEGER, $r = 5e6, Or = 64, Q = self;
+let Y = null;
+async function Gt(t, e, n) {
+  const r = gr(e);
+  if (!r.length || !await n.take("geometry")) return 0;
+  const s = r.reduce((a, c) => a + c.count, 0), i = {
+    type: "geometry",
+    kind: t,
+    layers: r,
+    cost: s
+  };
+  return Q.postMessage(i, yr(r)), s;
+}
+async function vr(t, e) {
+  return await Gt("line", t.line, e) + await Gt("fill", t.fill, e) + await Gt("dot", t.dot, e);
+}
+async function ge(t, e) {
+  if (!t.length || !await e.take("text")) return 0;
+  const r = t.slice();
+  t.length = 0;
+  const o = {
+    type: "text",
+    texts: r,
+    cost: r.length
+  };
+  return Q.postMessage(o), r.length;
+}
+function Mr(t) {
+  return t.lineCount + t.fillCount + t.dotCount;
+}
+function Dr(t, e) {
+  return Mr(t) >= $r ? {
+    initial: he,
+    steady: e ? he : Br
+  } : {
+    initial: me,
+    steady: e ? me : Tr
+  };
+}
+function kr(t) {
+  return t instanceof Error ? t : new Error(String(t));
+}
+function Lr(t) {
+  if (!(!t || t.length === 0))
+    return new Map(t.map((e) => [e.variantId, e.buffer]));
+}
+function Fr(t) {
+  if (t !== void 0)
+    return new Set(t);
+}
+async function Xr(t, e, n) {
+  const r = Lr(e);
+  if (!t || !n || n.length === 0)
+    return r;
+  const o = Array.from(new Set(n)).filter((a) => !(r != null && r.has(a))).sort((a, c) => a - c);
+  if (o.length === 0)
+    return r;
+  const s = await ur({
+    baseUrl: t.baseUrl,
+    entries: t.entries,
+    requiredVariantIds: o
+  }), i = new Map(r ?? []);
+  for (const [a, c] of s.buffers)
+    i.set(a, c);
+  return i;
+}
+async function Yr(t, e, n, r, o = !0, s, i, a, c, u, m, g, d) {
+  const h = dr(), w = [];
+  let y = 0, f = !1;
+  const _ = c === !0, b = typeof i == "number" && Number.isFinite(i) && i >= 0, E = await Xr(
+    a,
+    u,
+    g
+  ), p = Fr(m), S = n && n.length > 0 || r === !0 || o === !1 || s === !0 || b || _ || E || p !== void 0 || d === !0 ? {
+    ...n && n.length > 0 ? { hiddenInstanceIds: new Set(n) } : {},
+    ...r === !0 ? { keepTextsForHiddenInstances: !0 } : {},
+    ...o === !1 ? { loadBlocks: !1 } : {},
+    ...s === !0 ? { suppressExpandedInsertGeometry: !0 } : {},
+    ...b ? { maxExpandedInstanceVertices: i } : {},
+    ..._ ? { deferExternalVariantGeometry: !0 } : {},
+    ...E ? { externalVariantBuffers: E } : {},
+    ...p !== void 0 ? { requiredExternalVariantIds: p } : {},
+    ...d === !0 ? { externalVariantDeltaOnly: !0 } : {}
+  } : void 0, N = ar(t, S), C = Dr(N.header, d === !0);
+  Q.postMessage({
+    type: "header",
+    header: N.header
+  });
+  const G = async () => {
+    const V = await vr(h, e);
+    return y = 0, V > 0 && (f = !0), V;
+  };
+  for (const V of N.chunks) {
+    if (V.kind === "text") {
+      w.push(V.payload), w.length >= Or && await ge(w, e);
+      continue;
+    }
+    const L = Se(V.payload, {
+      markLinePositionXy: V.kind === "line"
+    });
+    y += hr(h[V.kind], L);
+    const F = f ? C.steady : C.initial;
+    y >= F && await G();
+  }
+  await G(), await ge(w, e), Q.postMessage({ type: "done" });
+  const U = de(), R = Vr(N.header);
+  R && Q.postMessage(
+    {
+      type: "insertModel",
+      variants: R.variants,
+      instances: R.instances,
+      cost: R.cost,
+      bytes: R.bytes,
+      planMs: de() - U
+    },
+    Nr(R)
+  ), Q.postMessage({ type: "complete" });
+}
+self.addEventListener("message", (t) => {
+  const e = t.data;
+  if (!e) return;
+  if (e.type === "grant") {
+    Y == null || Y.grant({
+      geometryCredits: e.geometryCredits,
+      textCredits: e.textCredits
+    });
+    return;
+  }
+  if (e.type === "cancel") {
+    Y == null || Y.cancel();
+    return;
+  }
+  if (e.type !== "parse") return;
+  const n = new Sr();
+  Y = n, Yr(
+    e.buffer,
+    n,
+    e.hiddenInstanceIds,
+    e.keepTextsForHiddenInstances,
+    e.loadBlocks,
+    e.suppressExpandedInsertGeometry,
+    e.maxExpandedInstanceVertices,
+    e.externalVariantFetchSource,
+    e.deferExternalVariantGeometry,
+    e.externalVariantBuffers,
+    e.requiredExternalVariantIds,
+    e.externalVariantGeometryFetchIds,
+    e.externalVariantDeltaOnly
+  ).catch((r) => {
+    const o = kr(r), s = o.code;
+    Q.postMessage({
+      type: "error",
+      message: o.message,
+      code: typeof s == "string" ? s : void 0
+    });
+  }).finally(() => {
+    Y === n && (Y = null);
+  });
+});