@nebula-spatial/cad-loader 0.1.0

package/dist/core/index.js

@@ -0,0 +1,2262 @@
+var ae = Object.defineProperty;
+var ie = (t, n, e) => n in t ? ae(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var mn = (t, n, e) => ie(t, typeof n != "symbol" ? n + "" : n, e);
+class l extends Error {
+  constructor(e, o) {
+    super(o);
+    mn(this, "code");
+    this.name = "GeoLoaderError", this.code = e;
+  }
+}
+const Lt = 4096;
+function To(t, n, e, o, a = "u8") {
+  return {
+    count: o,
+    raw: new Uint8Array(t, n, e - n).slice(),
+    groupLayerEncoding: a
+  };
+}
+function Wt(t) {
+  return t >= 6 ? "u16_lw" : t >= 5 ? "u8_lw" : t >= 4 ? "u16" : "u8";
+}
+function In(t) {
+  return t === "u16_lw" ? 13 : t === "u8_lw" ? 12 : t === "u16" ? 9 : 8;
+}
+function Gn(t, n, e) {
+  return e === "u16" || e === "u16_lw" ? t.getUint16(n + 7, !0) : t.getUint8(n + 7);
+}
+function se(t) {
+  return t === "u16" || t === "u16_lw" ? 2 : 1;
+}
+function Vn(t, n, e) {
+  if (!(e !== "u8_lw" && e !== "u16_lw"))
+    return t.getFloat32(n + 7 + se(e), !0);
+}
+function lt(t, n, e, o, a = t.byteLength, r = "u8") {
+  if (e > a || a > t.byteLength)
+    throw new l("E_GROUP_RANGE", "Group byte range exceeds payload length");
+  let i = e;
+  const c = o * 2, s = c * 4;
+  if (i + s > a)
+    throw new l("E_GROUP_RANGE", "Group position bytes exceed payload length");
+  let u;
+  if (c > 0) {
+    const w = new Uint8Array(t, i, s), y = new Uint8Array(s), m = c;
+    for (let x = 0; x < c; x++)
+      y[x * 4] = w[x], y[x * 4 + 1] = w[m + x], y[x * 4 + 2] = w[m * 2 + x], y[x * 4 + 3] = w[m * 3 + x];
+    u = new Float32Array(y.buffer);
+  } else
+    u = new Float32Array(0);
+  if (i += s, i + 4 > a)
+    throw new l("E_GROUP_RANGE", "Missing seg_count field for group");
+  const h = n.getUint32(i, !0);
+  i += 4;
+  const d = [];
+  let _ = 0;
+  const f = In(r);
+  for (let w = 0; w < h; w++) {
+    if (i + f > a)
+      throw new l("E_GROUP_RANGE", "Segment record exceeds payload length");
+    const y = n.getUint32(i, !0), m = n.getUint8(i + 4), x = n.getUint8(i + 5), G = n.getUint8(i + 6), N = Gn(n, i, r), R = Vn(n, i, r);
+    if (_ + y > o)
+      throw new l("E_SEGMENT_SUM", "Segment vertex_count sum exceeds group count");
+    d.push({
+      startVertex: _,
+      vertexCount: y,
+      color: [m, x, G],
+      layerIndex: N,
+      ...R === void 0 ? {} : { lineweightPx: R }
+    }), i += f;
+    const P = _ * 2;
+    if (y > 1) {
+      let B = u[P], D = u[P + 1];
+      for (let C = 1; C < y; C++) {
+        const $ = P + C * 2;
+        B += u[$], D += u[$ + 1], u[$] = B, u[$ + 1] = D;
+      }
+    }
+    _ += y;
+  }
+  if (_ !== o)
+    throw new l("E_SEGMENT_SUM", `Segment vertex_count sum ${_} does not match group count ${o}`);
+  return {
+    chunk: { pos: u, count: o, segments: d },
+    offset: i
+  };
+}
+function ce(t, n, e, o, a = "u8") {
+  const r = o * 2, i = r * 4;
+  if (e + i > t.byteLength)
+    throw new l("E_GROUP_RANGE", "Group position bytes exceed payload length");
+  const c = new Uint8Array(t, e, i);
+  let s = e + i;
+  if (s + 4 > t.byteLength)
+    throw new l("E_GROUP_RANGE", "Missing seg_count field for group");
+  const u = n.getUint32(s, !0);
+  s += 4;
+  const h = [];
+  let d = 0;
+  const _ = In(a);
+  for (let f = 0; f < u; f++) {
+    if (s + _ > t.byteLength)
+      throw new l("E_GROUP_RANGE", "Segment record exceeds payload length");
+    const w = n.getUint32(s, !0), y = n.getUint8(s + 4), m = n.getUint8(s + 5), x = n.getUint8(s + 6), G = Gn(n, s, a), N = Vn(n, s, a);
+    if (s += _, d + w > o)
+      throw new l("E_SEGMENT_SUM", "Segment vertex_count sum exceeds group count");
+    h.push({
+      startVertex: d,
+      vertexCount: w,
+      color: [y, m, x],
+      layerIndex: G,
+      ...N === void 0 ? {} : { lineweightPx: N }
+    }), d += w;
+  }
+  if (d !== o)
+    throw new l("E_SEGMENT_SUM", `Segment vertex_count sum ${d} does not match group count ${o}`);
+  return {
+    shuffled: c,
+    plane: r,
+    segments: h,
+    offset: s
+  };
+}
+function le(t, n, e, o) {
+  if (o === 0)
+    return new Float32Array(0);
+  const a = new Uint8Array(o * 4);
+  for (let r = 0; r < o; r++)
+    a[r * 4] = t[e + r], a[r * 4 + 1] = t[n + e + r], a[r * 4 + 2] = t[n * 2 + e + r], a[r * 4 + 3] = t[n * 3 + e + r];
+  return new Float32Array(a.buffer);
+}
+function ue(t, n, e, o, a) {
+  const r = le(
+    t.shuffled,
+    t.plane,
+    (n.startVertex + e) * 2,
+    o * 2
+  );
+  let i = (a == null ? void 0 : a[0]) ?? 0, c = (a == null ? void 0 : a[1]) ?? 0;
+  if (o > 0) {
+    e === 0 ? (i = r[0], c = r[1]) : (i += r[0], c += r[1], r[0] = i, r[1] = c);
+    for (let u = 1; u < o; u++) {
+      const h = u * 2;
+      i += r[h], c += r[h + 1], r[h] = i, r[h + 1] = c;
+    }
+  }
+  const s = o > 0 ? [{
+    startVertex: 0,
+    vertexCount: o,
+    color: [n.color[0], n.color[1], n.color[2]],
+    layerIndex: n.layerIndex,
+    ...n.lineweightPx === void 0 ? {} : { lineweightPx: n.lineweightPx }
+  }] : [];
+  return {
+    chunk: { pos: r, count: o, segments: s },
+    lastPoint: o > 0 ? [i, c] : a
+  };
+}
+function* de(t, n, e, o, a = "u8") {
+  const r = ce(t, n, e, o, a);
+  if (o === 0)
+    return yield { pos: new Float32Array(0), count: 0, segments: [] }, r.offset;
+  for (const i of r.segments) {
+    let c = null;
+    for (let s = 0; s < i.vertexCount; s += Lt) {
+      const u = Math.min(Lt, i.vertexCount - s), h = ue(r, i, s, u, c);
+      c = h.lastPoint, yield h.chunk;
+    }
+  }
+  return r.offset;
+}
+function Tn() {
+  const t = globalThis.TextDecoder;
+  if (!t)
+    throw new l("E_HEADER_JSON", "TextDecoder is required to parse CAD pack metadata");
+  return new t();
+}
+function Yt(t) {
+  return t ? {
+    minX: t.minX,
+    minY: t.minY,
+    maxX: t.maxX,
+    maxY: t.maxY
+  } : null;
+}
+function Ft(t) {
+  return !!t && Number.isFinite(t.minX) && Number.isFinite(t.minY) && Number.isFinite(t.maxX) && Number.isFinite(t.maxY);
+}
+function fe(t) {
+  return Ft(t) ? Yt(t) : null;
+}
+function me(t, n) {
+  const e = Ft(t) ? t : null, o = Ft(n) ? n : null;
+  return e ? o ? {
+    minX: Math.min(e.minX, o.minX),
+    minY: Math.min(e.minY, o.minY),
+    maxX: Math.max(e.maxX, o.maxX),
+    maxY: Math.max(e.maxY, o.maxY)
+  } : Yt(e) : Yt(o);
+}
+function bn(t, n) {
+  return !(n.maxX < t.minX || n.minX > t.maxX || n.maxY < t.minY || n.minY > t.maxY);
+}
+function bo(t, n) {
+  return t.minX <= n.minX && t.minY <= n.minY && t.maxX >= n.maxX && t.maxY >= n.maxY;
+}
+function Bo(t, n) {
+  return t === n ? !0 : !t || !n ? !1 : t.minX === n.minX && t.minY === n.minY && t.maxX === n.maxX && t.maxY === n.maxY;
+}
+function _e(t, n) {
+  return bn(t, n) ? {
+    minX: Math.max(t.minX, n.minX),
+    minY: Math.max(t.minY, n.minY),
+    maxX: Math.min(t.maxX, n.maxX),
+    maxY: Math.min(t.maxY, n.maxY)
+  } : null;
+}
+function he(t, n) {
+  const e = Number.isFinite(n) ? Math.max(0, n) : 0, o = Math.max(0, t.maxX - t.minX), a = Math.max(0, t.maxY - t.minY), r = o * e, i = a * e;
+  return {
+    minX: t.minX - r,
+    minY: t.minY - i,
+    maxX: t.maxX + r,
+    maxY: t.maxY + i
+  };
+}
+function Ee(t, n, e, o = 0, a = 1) {
+  if (n <= 0 || e <= 0) return null;
+  let r = Number.POSITIVE_INFINITY, i = Number.POSITIVE_INFINITY, c = Number.NEGATIVE_INFINITY, s = Number.NEGATIVE_INFINITY, u = !1;
+  for (let h = 0; h < n; h += 1) {
+    const d = h * e, _ = t[d + o], f = t[d + a];
+    !Number.isFinite(_) || !Number.isFinite(f) || (_ < r && (r = _), f < i && (i = f), _ > c && (c = _), f > s && (s = f), u = !0);
+  }
+  return u ? { minX: r, minY: i, maxX: c, maxY: s } : null;
+}
+function Bn(t, n) {
+  const e = t.minX, o = t.minY, a = t.maxX, r = t.maxY, { matA: i, matB: c, matC: s, matD: u, tx: h, ty: d } = n;
+  let _ = i * e + s * o + h, f = c * e + u * o + d, w = _, y = f, m = _, x = f;
+  return _ = i * e + s * r + h, f = c * e + u * r + d, _ < w && (w = _), f < y && (y = f), _ > m && (m = _), f > x && (x = f), _ = i * a + s * o + h, f = c * a + u * o + d, _ < w && (w = _), f < y && (y = f), _ > m && (m = _), f > x && (x = f), _ = i * a + s * r + h, f = c * a + u * r + d, _ < w && (w = _), f < y && (y = f), _ > m && (m = _), f > x && (x = f), { minX: w, minY: y, maxX: m, maxY: x };
+}
+function xe(t) {
+  return Math.hypot(t.maxX - t.minX, t.maxY - t.minY);
+}
+function ge(t, n) {
+  const e = (t.minX + t.maxX) / 2, o = (t.minY + t.maxY) / 2, a = (n.minX + n.maxX) / 2, r = (n.minY + n.maxY) / 2;
+  return Math.hypot(e - a, o - r);
+}
+const ye = {};
+function _n(t) {
+  return typeof t == "object" && t !== null;
+}
+function gt(t, n) {
+  return Object.prototype.hasOwnProperty.call(t, n);
+}
+function J(t) {
+  if (t.length === 0) return "$";
+  let n = "";
+  for (const e of t) {
+    if (typeof e == "number") {
+      n += `[${e}]`;
+      continue;
+    }
+    n += n.length === 0 ? e : `.${e}`;
+  }
+  return n;
+}
+function hn(t, n, e, o) {
+  return new l("E_TEXT_ROUNDTRIP", `Text roundtrip mismatch at stage=${t} index=${n} path=${e}: ${o}`);
+}
+function kt(t, n, e) {
+  if (Object.is(t, n)) return null;
+  if (Array.isArray(t)) {
+    if (!Array.isArray(n))
+      return { path: J(e), reason: `expected array but found ${typeof n}` };
+    if (t.length !== n.length)
+      return { path: J([...e, "length"]), reason: `array length ${t.length} !== ${n.length}` };
+    for (let o = 0; o < t.length; o += 1) {
+      const a = kt(t[o], n[o], [...e, o]);
+      if (a) return a;
+    }
+    return null;
+  }
+  if (_n(t)) {
+    if (!_n(n) || Array.isArray(n))
+      return { path: J(e), reason: `expected object but found ${Array.isArray(n) ? "array" : typeof n}` };
+    const o = Object.keys(t), a = Object.keys(n);
+    if (o.length !== a.length) {
+      const r = o.find((c) => !gt(n, c));
+      if (r !== void 0)
+        return {
+          path: J([...e, r]),
+          reason: "missing key on actual"
+        };
+      const i = a.find((c) => !gt(t, c));
+      if (i !== void 0)
+        return {
+          path: J([...e, i]),
+          reason: "extra key on actual"
+        };
+    }
+    for (const r of o) {
+      if (!gt(n, r))
+        return { path: J([...e, r]), reason: "missing key on actual" };
+      const i = kt(t[r], n[r], [...e, r]);
+      if (i) return i;
+    }
+    for (const r of a)
+      if (!gt(t, r))
+        return { path: J([...e, r]), reason: "extra key on actual" };
+    return null;
+  }
+  return { path: J(e), reason: `expected ${String(t)} but found ${String(n)}` };
+}
+function we(t, n) {
+  return kt(t, n, []);
+}
+function En(t) {
+  if (t === !0 || t === "1" || t === "true") return !0;
+  if (t === !1 || t === "0" || t === "false") return !1;
+}
+function Ae() {
+  var a, r;
+  const t = globalThis.process, n = En(
+    ((a = t == null ? void 0 : t.env) == null ? void 0 : a.DXF_STRICT_TEXT_ROUNDTRIP) ?? ((r = t == null ? void 0 : t.env) == null ? void 0 : r.VITE_DXF_STRICT_TEXT_ROUNDTRIP)
+  );
+  if (n !== void 0) return n;
+  const e = ye, o = En(e == null ? void 0 : e.VITE_DXF_STRICT_TEXT_ROUNDTRIP);
+  return o !== void 0 ? o : !1;
+}
+function Uo(t) {
+  return t;
+}
+function Ne(t, n, e) {
+  if (n.length !== e.length)
+    throw hn(t, Math.min(n.length, e.length), "$length", `text count ${n.length} !== ${e.length}`);
+  for (let o = 0; o < n.length; o += 1) {
+    const a = we(n[o], e[o]);
+    if (a)
+      throw hn(t, o, a.path, a.reason);
+  }
+}
+const Re = Tn(), pe = ["left", "center", "right"], Ie = ["top", "middle", "bottom", "alphabetic"];
+function xn(t, n) {
+  if (t > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new l("E_GROUP_RANGE", `${n} exceeds safe integer range`);
+  return Number(t);
+}
+function zt(t, n, e, o) {
+  if (!Number.isInteger(t) || !Number.isInteger(n) || t < 0 || n < 0 || t + n > e)
+    throw new l("E_GROUP_RANGE", `${o} exceeds payload length`);
+}
+function Ge(t) {
+  if (t.byteLength < 4) return !1;
+  const n = new Uint8Array(t, 0, 4);
+  return n[0] === 68 && n[1] === 88 && n[2] === 66 && n[3] === 83;
+}
+function Jt(t) {
+  if (t.byteLength < 20)
+    throw new l("E_HEADER", "DXBS payload too small: missing container header");
+  if (!Ge(t))
+    throw new l("E_HEADER", "DXBS payload missing magic");
+  const n = new DataView(t), e = n.getUint16(4, !0), o = n.getUint16(6, !0), a = n.getUint16(8, !0), r = n.getUint16(10, !0), i = n.getUint16(12, !0), c = n.getUint16(14, !0), s = n.getUint32(16, !0);
+  if (e !== 3 || o < 3 || o > 6)
+    throw new l("E_GROUP_RANGE", `Unsupported DXBS version: ${e}.${o}`);
+  if (a !== 0)
+    throw new l("E_GROUP_RANGE", `Unsupported DXBS sidecar kind: ${a}`);
+  if (c !== 0)
+    throw new l("E_GROUP_RANGE", `Invalid DXBS reserved field: ${c}`);
+  if (r < 24)
+    throw new l("E_GROUP_RANGE", `Invalid DXBS directory entry size: ${r}`);
+  if (s !== r * i)
+    throw new l("E_GROUP_RANGE", "DXBS directory byte size mismatch");
+  const u = 20;
+  zt(u, s, t.byteLength, "DXBS section directory");
+  const h = /* @__PURE__ */ new Map();
+  for (let d = 0; d < i; d += 1) {
+    const _ = u + d * r, f = n.getUint16(_, !0), w = n.getUint16(_ + 2, !0), y = n.getUint32(_ + 4, !0), m = xn(n.getBigUint64(_ + 8, !0), "DXBS section offset"), x = xn(n.getBigUint64(_ + 16, !0), "DXBS section length");
+    if (w !== 0)
+      throw new l("E_GROUP_RANGE", `Unsupported DXBS section flags for type ${f}: ${w}`);
+    if (y !== 0)
+      throw new l("E_GROUP_RANGE", `Invalid DXBS section reserved field for type ${f}: ${y}`);
+    zt(m, x, t.byteLength, `DXBS section ${f}`), h.set(f, { type: f, flags: w, offset: m, length: x });
+  }
+  return { versionMajor: e, versionMinor: o, sections: h };
+}
+function et(t, n, e) {
+  const o = t.sections.get(n);
+  if (!o)
+    throw new l("E_GROUP_RANGE", `Missing DXBS section ${e}`);
+  return o;
+}
+function Ve(t, n, e, o) {
+  return zt(n, e, t.byteLength, o), Re.decode(t.subarray(n, n + e));
+}
+function Ut(t, n, e, o, a, r) {
+  if (e + 4 > o)
+    throw new l("E_GROUP_RANGE", `Missing ${a} vertex_count`);
+  const i = n.getUint32(e, !0), c = lt(t, n, e + 4, i, o, r);
+  if (c.offset > o)
+    throw new l("E_GROUP_RANGE", `${a} exceeds section bounds`);
+  return c;
+}
+function Un(t, n, e, o) {
+  const a = new DataView(t), r = e.offset + e.length, i = Wt(n.versionMinor), c = Ut(t, a, e.offset, r, `${o} line`, i), s = Ut(t, a, c.offset, r, `${o} fill`, i), u = Ut(t, a, s.offset, r, `${o} dot`, i);
+  if (u.offset !== r)
+    throw new l("E_GROUP_RANGE", `${o} has trailing bytes`);
+  return { line: c.chunk, fill: s.chunk, dot: u.chunk };
+}
+function Te(t, n, e) {
+  const o = t.getUint32(n, !0), a = t.getUint32(n + 4, !0), r = t.getUint8(n + 42), i = t.getUint8(n + 43), c = t.getFloat32(n + 24, !0), s = t.getFloat32(n + 28, !0);
+  return {
+    t: Ve(e, o, a, "DXBS text value"),
+    x: t.getFloat32(n + 8, !0),
+    y: t.getFloat32(n + 12, !0),
+    h: t.getFloat32(n + 16, !0),
+    r: t.getFloat32(n + 20, !0),
+    c: [t.getUint8(n + 36), t.getUint8(n + 37), t.getUint8(n + 38)],
+    li: t.getUint16(n + 40, !0),
+    ha: pe[r & 3] ?? "left",
+    va: Ie[r >> 2 & 3] ?? "alphabetic",
+    lh: t.getFloat32(n + 32, !0),
+    ...c ? { w: c } : {},
+    ...s !== 1 ? { wf: s } : {},
+    ...i & 1 ? { mx: !0 } : {},
+    ...i & 2 ? { my: !0 } : {}
+  };
+}
+function Sn(t, n, e, o) {
+  if (n.length % 44 !== 0)
+    throw new l("E_GROUP_RANGE", `${o} length must be a multiple of 44`);
+  const a = new Uint8Array(t, e.offset, e.length), r = [], i = new DataView(t);
+  for (let c = n.offset; c < n.offset + n.length; c += 44)
+    r.push(Te(i, c, a));
+  return r;
+}
+function So(t) {
+  const n = Jt(t), e = et(n, 513, "SCENE_ANNOTATION_GEOMETRY"), o = et(n, 514, "SCENE_ANNOTATION_TEXT_TABLE"), a = et(n, 515, "SCENE_ANNOTATION_STRING_TABLE");
+  return {
+    ...Un(t, n, e, "SCENE_ANNOTATION_GEOMETRY"),
+    texts: Sn(t, o, a, "SCENE_ANNOTATION_TEXT_TABLE")
+  };
+}
+function be(t) {
+  const n = Jt(t), e = et(n, 258, "BLOCK_ANNOTATION_GEOMETRY"), o = et(n, 259, "BLOCK_ANNOTATION_TEXT_TABLE"), a = et(n, 260, "BLOCK_ANNOTATION_STRING_TABLE");
+  return {
+    ...Un(t, n, e, "BLOCK_ANNOTATION_GEOMETRY"),
+    texts: Sn(t, o, a, "BLOCK_ANNOTATION_TEXT_TABLE")
+  };
+}
+function It() {
+  return {
+    pos: new Float32Array(0),
+    count: 0,
+    segments: []
+  };
+}
+function ot(t) {
+  if (t.segments && t.segments.length > 0)
+    return Se(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 Ue(t.col, t.lay, t.count);
+}
+function Be(t) {
+  if (t.col && t.lay)
+    return { col: t.col, lay: t.lay };
+  const n = ot(t), e = new Uint8Array(t.count * 3);
+  let o = 0;
+  for (const r of n)
+    r.layerIndex > o && (o = r.layerIndex);
+  const a = o > 255 ? new Uint16Array(t.count) : new Uint8Array(t.count);
+  for (const r of n) {
+    const i = r.startVertex + r.vertexCount;
+    for (let c = r.startVertex; c < i; c += 1) {
+      const s = c * 3;
+      e[s] = r.color[0], e[s + 1] = r.color[1], e[s + 2] = r.color[2], a[c] = r.layerIndex;
+    }
+  }
+  return { col: e, lay: a };
+}
+function Ht(t, n) {
+  return t.map((e) => ({
+    startVertex: e.startVertex + n,
+    vertexCount: e.vertexCount,
+    color: Gt(e),
+    layerIndex: e.layerIndex,
+    ...e.lineweightPx === void 0 ? {} : { lineweightPx: e.lineweightPx }
+  }));
+}
+function Cn(t, n) {
+  return t.map((e) => ({
+    startVertex: e.startVertex,
+    vertexCount: e.vertexCount,
+    color: Gt(e),
+    layerIndex: n(e.layerIndex),
+    ...e.lineweightPx === void 0 ? {} : { lineweightPx: e.lineweightPx }
+  }));
+}
+function Co(t, n, e) {
+  const o = n + e, a = [];
+  for (const r of t) {
+    const i = r.startVertex, c = r.startVertex + r.vertexCount, s = Math.max(n, i), u = Math.min(o, c);
+    s >= u || a.push({
+      startVertex: s - n,
+      vertexCount: u - s,
+      color: Gt(r),
+      layerIndex: r.layerIndex,
+      ...r.lineweightPx === void 0 ? {} : { lineweightPx: r.lineweightPx }
+    });
+  }
+  return dt(a);
+}
+function dt(t) {
+  const n = [];
+  for (const e of t) {
+    const o = n[n.length - 1];
+    if (o && o.startVertex + o.vertexCount === e.startVertex && o.layerIndex === e.layerIndex && o.color[0] === e.color[0] && o.color[1] === e.color[1] && o.color[2] === e.color[2] && o.lineweightPx === e.lineweightPx) {
+      n[n.length - 1] = {
+        ...o,
+        vertexCount: o.vertexCount + e.vertexCount
+      };
+      continue;
+    }
+    n.push({
+      startVertex: e.startVertex,
+      vertexCount: e.vertexCount,
+      color: Gt(e),
+      layerIndex: e.layerIndex,
+      ...e.lineweightPx === void 0 ? {} : { lineweightPx: e.lineweightPx }
+    });
+  }
+  return n;
+}
+function Ue(t, n, e) {
+  if (t.length < e * 3 || n.length < e)
+    throw new l("E_GROUP_RANGE", "Expanded color/layer metadata is shorter than geometry count");
+  const o = [];
+  let a = 0;
+  for (; a < e; ) {
+    const r = a * 3, i = t[r] ?? 0, c = t[r + 1] ?? 0, s = t[r + 2] ?? 0, u = n[a] ?? 0;
+    let h = a + 1;
+    for (; h < e; ) {
+      const d = h * 3;
+      if (n[h] !== u || t[d] !== i || t[d + 1] !== c || t[d + 2] !== s)
+        break;
+      h += 1;
+    }
+    o.push({
+      startVertex: a,
+      vertexCount: h - a,
+      color: [i, c, s],
+      layerIndex: u
+    }), a = h;
+  }
+  return o;
+}
+function Se(t, n) {
+  let e = 0;
+  for (const o of t) {
+    if (o.vertexCount < 0 || o.startVertex !== e)
+      throw new l("E_SEGMENT_SUM", "Geometry segments must be contiguous and non-negative");
+    e += o.vertexCount;
+  }
+  if (e !== n)
+    throw new l("E_SEGMENT_SUM", `Geometry segment vertex sum ${e} does not match count ${n}`);
+}
+function Gt(t) {
+  return [t.color[0], t.color[1], t.color[2]];
+}
+const Ce = 8e6, Oe = 0.25, $e = 5, Me = 4, Pe = 2048, Zt = Tn(), De = ["left", "center", "right"], ve = ["top", "middle", "bottom", "alphabetic"];
+function At(t, n, e) {
+  for (const o of t)
+    e(o);
+  for (const o of n)
+    e(o);
+}
+const gn = /* @__PURE__ */ new WeakMap();
+function ct(t) {
+  return typeof t == "object" && t !== null;
+}
+function Xe(t) {
+  return Array.isArray(t) ? "array" : t === null ? "null" : typeof t;
+}
+function Le(t) {
+  return !(!ct(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((n) => typeof n == "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 Ye(t) {
+  return t.map((n, e) => ({
+    index: e,
+    name: n.name,
+    color: [...n.color],
+    lw_px: n.lw_px,
+    visible: n.visible ?? !0
+  }));
+}
+function Qt(t) {
+  const n = t.texts, e = Array.isArray(n) ? n : [], o = e.filter(Le), a = Ae();
+  if (a && n !== void 0 && !Array.isArray(n))
+    throw new l(
+      "E_TEXT_ROUNDTRIP",
+      `Text roundtrip mismatch at stage=Boundary-2:header->stream index=0 path=$: expected array but found ${Xe(n)}`
+    );
+  return a && Ne("Boundary-2:header->stream", e, o), {
+    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: o.length,
+    layers: Ye(t.layers ?? []),
+    texts: o
+  };
+}
+function On(t) {
+  const n = t == null ? void 0 : t.maxExpandedInstanceVertices, e = typeof n == "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : Ce;
+  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: e,
+    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 Fe(t) {
+  return t.loadBlocks && !t.suppressExpandedInsertGeometry;
+}
+function Nt(t, n) {
+  return Fe(n) && !n.hiddenInstanceIds.has(t);
+}
+function $n(t, n, e) {
+  if (e <= 0)
+    return;
+  const o = t.expandedInstanceVertices + e;
+  if (o > t.maxExpandedInstanceVertices)
+    throw new l(
+      "E_EXPANSION_BUDGET",
+      `CPU-expanded ${n} instance vertices exceed budget: ${o}/${t.maxExpandedInstanceVertices}. Disable block loading or raise maxExpandedInstanceVertices.`
+    );
+  t.expandedInstanceVertices = o;
+}
+function ke(t, n, e) {
+  return e.loadBlocks ? e.hiddenInstanceIds.size === 0 || e.keepTextsForHiddenInstances ? t : t.filter((o) => {
+    if (!Number.isInteger(o.iv) || !Number.isInteger(o.io))
+      return !0;
+    const a = n.get(`${o.iv}:${o.io}`);
+    return a === void 0 || !e.hiddenInstanceIds.has(a);
+  }) : t.filter((o) => !Number.isInteger(o.iv) || !Number.isInteger(o.io));
+}
+function ze(t, n) {
+  const e = /* @__PURE__ */ new Map();
+  return t.forEach((o, a) => {
+    if (!Number.isInteger(o.iv) || !Number.isInteger(o.io))
+      return;
+    const r = n.get(`${o.iv}:${o.io}`);
+    if (r === void 0)
+      return;
+    const i = e.get(r);
+    i ? i.push(a) : e.set(r, [a]);
+  }), e;
+}
+function He(t, n, e, o, a, r, i) {
+  const c = n.map((s, u) => ({
+    id: s.id,
+    blockName: Mn(s, u),
+    line: e[u].line,
+    fill: e[u].fill,
+    dot: e[u].dot,
+    texts: o.get(s.id) ?? []
+  }));
+  return {
+    layer0Index: t,
+    variants: c,
+    instances: a,
+    textIndexesByInstanceId: ze(r, i),
+    ownerInstanceIdByVariantOrdinal: i
+  };
+}
+function je(t) {
+  if (t.byteLength < 4)
+    throw new l("E_HEADER", "Payload too small: missing header length");
+  const n = new DataView(t), e = n.getUint32(0, !0), o = 4, a = o + e;
+  if (a > t.byteLength)
+    throw new l("E_HEADER", "Header length exceeds payload length");
+  let r;
+  try {
+    r = JSON.parse(Zt.decode(new Uint8Array(t, o, e)));
+  } catch (i) {
+    throw new l("E_HEADER_JSON", `Invalid JSON header: ${i.message}`);
+  }
+  return {
+    meta: r,
+    header: Qt(r),
+    dataOffset: a,
+    view: n
+  };
+}
+function Mn(t, n) {
+  var r, i, c;
+  const e = (r = t.name) == null ? void 0 : r.trim();
+  if (e)
+    return e;
+  const o = (i = t.block_name) == null ? void 0 : i.trim();
+  if (o)
+    return o;
+  const a = (c = t.blockName) == null ? void 0 : c.trim();
+  return a || `block_${n}`;
+}
+function qe(t) {
+  const n = Number(t.version ?? 1), e = String(t.encoding ?? "").toLowerCase();
+  if (n === 2) {
+    const o = e ? ` ${e}` : "";
+    throw new l(
+      "E_UNSUPPORTED_PACK_VERSION",
+      `当前文件是 V2${o} pack，前端不再兼容解析；请升级到最新版本后再打开。`
+    );
+  }
+}
+function tn(t) {
+  const n = je(t);
+  return qe(n.meta), n;
+}
+function rt(t) {
+  if (t.byteLength < 4)
+    return !1;
+  const n = new Uint8Array(t, 0, 4);
+  return n[0] === 68 && n[1] === 88 && n[2] === 66 && n[3] === 51;
+}
+function yn(t, n) {
+  if (t > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new l("E_GROUP_RANGE", `${n} exceeds safe integer range`);
+  return Number(t);
+}
+function ft(t, n, e, o) {
+  if (!Number.isInteger(t) || !Number.isInteger(n) || t < 0 || n < 0 || t + n > e)
+    throw new l("E_GROUP_RANGE", `${o} exceeds payload length`);
+}
+function mt(t) {
+  if (t.byteLength < 20)
+    throw new l("E_HEADER", "V3 payload too small: missing container header");
+  const n = new DataView(t), e = n.getUint16(4, !0), o = n.getUint16(6, !0), a = n.getUint32(8, !0), r = n.getUint16(12, !0), i = n.getUint16(14, !0), c = n.getUint32(16, !0);
+  if (e !== 3 || o > 6)
+    throw new l("E_GROUP_RANGE", `Unsupported V3 version: ${e}.${o}`);
+  if (a !== 0)
+    throw new l("E_GROUP_RANGE", `Unsupported V3 file flags: ${a}`);
+  if (r < 24)
+    throw new l("E_GROUP_RANGE", `Invalid V3 directory entry size: ${r}`);
+  if (c !== r * i)
+    throw new l("E_GROUP_RANGE", "V3 directory byte size mismatch");
+  const s = 20;
+  ft(s, c, t.byteLength, "V3 section directory");
+  const u = /* @__PURE__ */ new Map();
+  for (let h = 0; h < i; h += 1) {
+    const d = s + h * r, _ = n.getUint16(d, !0), f = n.getUint16(d + 2, !0), w = n.getUint32(d + 4, !0), y = yn(n.getBigUint64(d + 8, !0), "V3 section offset"), m = yn(n.getBigUint64(d + 16, !0), "V3 section length");
+    if (f !== 0)
+      throw new l("E_GROUP_RANGE", `Unsupported V3 section flags for type ${_}: ${f}`);
+    if (w !== 0)
+      throw new l("E_GROUP_RANGE", `Invalid V3 section reserved field for type ${_}: ${w}`);
+    ft(y, m, t.byteLength, `V3 section ${_}`), u.set(_, { type: _, flags: f, offset: y, length: m });
+  }
+  return { versionMinor: o, sections: u };
+}
+function X(t, n, e) {
+  const o = t.get(n);
+  if (!o)
+    throw new l("E_GROUP_RANGE", `Missing V3 section ${e}`);
+  return o;
+}
+function ut(t, n) {
+  return t.get(n) ?? { type: n, flags: 0, offset: 0, length: 0 };
+}
+function _t(t, n, e) {
+  try {
+    return JSON.parse(Zt.decode(new Uint8Array(t, n.offset, n.length)));
+  } catch (o) {
+    throw new l("E_HEADER_JSON", `Invalid V3 ${e} JSON: ${o.message}`);
+  }
+}
+function nn(t) {
+  const n = String(t.encoding ?? "").toLowerCase();
+  return n === "nested_instanced_external" || n === "nested_instanced_external_annotations";
+}
+function en(t) {
+  return String(t.encoding ?? "").toLowerCase() === "nested_instanced_external_annotations";
+}
+function Ke(t, n, e) {
+  const o = t.features, a = o && typeof o == "object" && !Array.isArray(o) ? { ...o } : {};
+  return n && (a.has_external_variant_geometry = !0), e && (a.has_external_annotations = !0), Object.keys(a).length ? a : void 0;
+}
+function q(t, n) {
+  if (!Number.isInteger(t) || Number(t) < 0)
+    throw new l("E_HEADER", `${n} must be a non-negative integer`);
+  return Number(t);
+}
+function Pn(t, n) {
+  if (typeof t != "string" || !t.trim())
+    throw new l("E_HEADER", `${n} must be a non-empty string`);
+  return t;
+}
+function wn(t, n) {
+  if (t == null)
+    return null;
+  if (!Array.isArray(t) || t.length !== 4 || t.some((e) => typeof e != "number" || !Number.isFinite(e)))
+    throw new l("E_HEADER", `${n} must be null or [minX, minY, maxX, maxY]`);
+  return [t[0], t[1], t[2], t[3]];
+}
+function jt(t, n) {
+  if (!ct(t) || Array.isArray(t))
+    throw new l("E_HEADER", `${n} must be an object`);
+  return {
+    line_count: q(t.line_count, `${n}.line_count`),
+    fill_count: q(t.fill_count, `${n}.fill_count`),
+    dot_count: q(t.dot_count, `${n}.dot_count`),
+    bbox: wn(t.bbox, `${n}.bbox`),
+    own_bbox: wn(t.own_bbox, `${n}.own_bbox`)
+  };
+}
+function We(t) {
+  return t ? { minX: t[0], minY: t[1], maxX: t[2], maxY: t[3] } : null;
+}
+function Vt(t, n) {
+  const e = t.external_variants;
+  if (!Array.isArray(e))
+    throw new l("E_HEADER", "V3 external SCENE_META.external_variants must be an array");
+  if (e.length !== n)
+    throw new l(
+      "E_GROUP_RANGE",
+      `V3 external variant manifest count mismatch: manifest=${e.length}, table=${n}`
+    );
+  return e.map((o, a) => {
+    if (!ct(o) || Array.isArray(o))
+      throw new l("E_HEADER", `V3 external_variants[${a}] must be an object`);
+    const r = q(o.id, `V3 external_variants[${a}].id`);
+    if (r !== a)
+      throw new l("E_GROUP_RANGE", `V3 external_variants[${a}].id must equal ${a}, found ${r}`);
+    const i = Pn(o.href, `V3 external_variants[${a}].href`), c = q(o.raw_size, `V3 external_variants[${a}].raw_size`);
+    if ("normal" in o || "annotation" in o) {
+      const s = jt(o.annotation, `V3 external_variants[${a}].annotation`);
+      return {
+        id: r,
+        href: i,
+        raw_size: c,
+        normal: jt(o.normal, `V3 external_variants[${a}].normal`),
+        annotation: {
+          ...s,
+          text_count: q(
+            ct(o.annotation) && !Array.isArray(o.annotation) ? o.annotation.text_count : void 0,
+            `V3 external_variants[${a}].annotation.text_count`
+          )
+        }
+      };
+    }
+    return {
+      id: r,
+      href: i,
+      raw_size: c,
+      line_count: q(o.line_count, `V3 external_variants[${a}].line_count`),
+      fill_count: q(o.fill_count, `V3 external_variants[${a}].fill_count`),
+      dot_count: q(o.dot_count, `V3 external_variants[${a}].dot_count`)
+    };
+  });
+}
+function Dn(t) {
+  const n = t.external_annotations;
+  if (n == null) return null;
+  if (!ct(n) || Array.isArray(n))
+    throw new l("E_HEADER", "V3 external_annotations must be an object");
+  const e = n.scene;
+  if (e == null) return {};
+  if (!ct(e) || Array.isArray(e))
+    throw new l("E_HEADER", "V3 external_annotations.scene must be an object");
+  const o = jt(e, "V3 external_annotations.scene");
+  return {
+    scene: {
+      href: Pn(e.href, "V3 external_annotations.scene.href"),
+      raw_size: q(e.raw_size, "V3 external_annotations.scene.raw_size"),
+      ...o,
+      text_count: q(e.text_count, "V3 external_annotations.scene.text_count")
+    }
+  };
+}
+function vn(t) {
+  const { sections: n } = mt(t), e = X(n, 1, "SCENE_META");
+  return _t(t, e, "SCENE_META");
+}
+function Oo(t) {
+  if (!rt(t))
+    return [];
+  const { sections: n } = mt(t), e = X(n, 1, "SCENE_META"), o = X(n, 5, "VARIANT_TABLE"), a = _t(t, e, "SCENE_META");
+  if (!nn(a))
+    return [];
+  if (o.length % 60 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 VARIANT_TABLE length must be a multiple of 60");
+  return Vt(a, o.length / 60);
+}
+function An() {
+  return {
+    manifest: [],
+    requiredVariantIds: [],
+    requiredNormalBytes: 0,
+    totalManifestBytes: 0,
+    skippedVariantIds: []
+  };
+}
+function Je(t, n) {
+  return he(t, n);
+}
+function qt(t, n) {
+  return bn(t, n);
+}
+function Ze(t, n) {
+  return _e(t, n);
+}
+function Qe(t, n, e, o) {
+  if (!n || e === void 0 || !Number.isFinite(e) || e <= 0 || !Number.isFinite(o) || o <= 0) return !1;
+  const a = Ze(n, t);
+  if (!a) return !0;
+  const r = Math.max(0, a.maxX - a.minX) / e, i = Math.max(0, a.maxY - a.minY) / e;
+  return r < o && i < o;
+}
+function Xn(t) {
+  const n = Math.min(t.minX, t.maxX), e = Math.max(t.minX, t.maxX), o = Math.min(t.minY, t.maxY), a = Math.max(t.minY, t.maxY);
+  return [n, e, o, a].every(Number.isFinite) ? { minX: n, minY: o, maxX: e, maxY: a } : null;
+}
+function to(t) {
+  return Math.max(1, Math.abs(t.maxX - t.minX), Math.abs(t.maxY - t.minY));
+}
+function Ln(t, n) {
+  return `${t}:${n}`;
+}
+function no(t) {
+  const n = t.map((o) => o.worldBBox && !o.unknownBBox ? to(o.worldBBox) : 0).filter((o) => Number.isFinite(o) && o > 0).sort((o, a) => o - a), e = n.length > 0 ? n[Math.floor(n.length / 2)] : 1;
+  return Math.max(1, e * Me);
+}
+function eo(t, n) {
+  const e = t.map((i, c) => {
+    const s = n(i), u = s.worldBBox ? Xn(s.worldBBox) : null;
+    return {
+      sceneInstanceId: c,
+      sceneInstance: i,
+      worldBBox: u,
+      unknownBBox: s.unknownBBox || !u
+    };
+  }), o = no(e), a = /* @__PURE__ */ new Map(), r = [];
+  for (const i of e) {
+    if (i.unknownBBox || !i.worldBBox) {
+      r.push(i);
+      continue;
+    }
+    const c = Math.floor(i.worldBBox.minX / o), s = Math.floor(i.worldBBox.maxX / o), u = Math.floor(i.worldBBox.minY / o), h = Math.floor(i.worldBBox.maxY / o), d = (s - c + 1) * (h - u + 1);
+    if (!Number.isFinite(d) || d > Pe) {
+      r.push(i);
+      continue;
+    }
+    for (let _ = c; _ <= s; _ += 1)
+      for (let f = u; f <= h; f += 1) {
+        const w = Ln(_, f), y = a.get(w);
+        y ? y.push(i) : a.set(w, [i]);
+      }
+  }
+  return { cellSize: o, cells: a, overflow: r, records: e };
+}
+function oo(t, n, e) {
+  const o = gn.get(t);
+  if (o && o.records.length === n.length)
+    return o;
+  const a = eo(n, e);
+  return gn.set(t, a), a;
+}
+function ro(t, n) {
+  const e = Xn(n);
+  if (!e)
+    return t.records;
+  const o = /* @__PURE__ */ new Set(), a = Math.floor(e.minX / t.cellSize), r = Math.floor(e.maxX / t.cellSize), i = Math.floor(e.minY / t.cellSize), c = Math.floor(e.maxY / t.cellSize);
+  for (let s = a; s <= r; s += 1)
+    for (let u = i; u <= c; u += 1) {
+      const h = t.cells.get(Ln(s, u));
+      if (h)
+        for (const d of h)
+          d.worldBBox && qt(e, d.worldBBox) && o.add(d);
+    }
+  for (const s of t.overflow)
+    (!s.worldBBox || qt(e, s.worldBBox)) && o.add(s);
+  return Array.from(o).sort((s, u) => s.sceneInstanceId - u.sceneInstanceId);
+}
+function $o(t, n = {}) {
+  if (!rt(t))
+    return An();
+  const e = new DataView(t), { sections: o } = mt(t), a = X(o, 1, "SCENE_META"), r = _t(t, a, "SCENE_META");
+  if (!nn(r))
+    return An();
+  const i = X(o, 5, "VARIANT_TABLE");
+  if (i.length % 60 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 VARIANT_TABLE length must be a multiple of 60");
+  const c = i.length / 60, s = Vt(r, c), u = s.reduce((A, E) => A + E.raw_size, 0), h = n.viewport === void 0 ? void 0 : n.viewport, d = (A, E) => {
+    const p = Array.from(A).sort((U, V) => U - V), b = s.map((U) => U.id).filter((U) => !A.has(U)).sort((U, V) => U - V), S = p.reduce((U, V) => {
+      var k;
+      return U + (((k = s[V]) == null ? void 0 : k.raw_size) ?? 0);
+    }, 0), M = {
+      manifest: s,
+      requiredVariantIds: p,
+      requiredNormalBytes: S,
+      totalManifestBytes: u,
+      skippedVariantIds: b,
+      includedSceneInstanceIds: [...E]
+    };
+    return h === void 0 ? M : { ...M, viewport: h };
+  };
+  if (n.loadBlocks === !1)
+    return d(/* @__PURE__ */ new Set(), []);
+  const _ = X(o, 7, "SCENE_INSTANCE_TABLE"), f = ut(o, 8), w = Z(t, _, "V3 SCENE_INSTANCE_TABLE"), y = Z(t, f, "V3 NESTED_INSTANCE_TABLE");
+  if (Number(r.variant_count ?? c) !== c)
+    throw new l("E_GROUP_RANGE", "V3 variant count mismatch");
+  if (Number(r.scene_instance_count ?? w.length) !== w.length)
+    throw new l("E_GROUP_RANGE", "V3 scene instance count mismatch");
+  if (Number(r.nested_instance_count ?? y.length) !== y.length)
+    throw new l("E_GROUP_RANGE", "V3 nested instance count mismatch");
+  const m = /* @__PURE__ */ new Map(), x = [];
+  for (let A = 0; A < c; A += 1) {
+    const E = i.offset + A * 60, p = e.getUint32(E + 32, !0), b = e.getUint32(E + 36, !0);
+    if (p + b > y.length)
+      throw new l("E_GROUP_RANGE", `V3 variant ${A} nested range exceeds table`);
+    const S = s[A], M = rn(S);
+    x[A] = {
+      id: A,
+      nestedStart: p,
+      nestedCount: b,
+      precisionOriginX: e.getFloat32(E + 48, !0),
+      precisionOriginY: e.getFloat32(E + 52, !0),
+      bbox: M,
+      ownBBox: M
+    };
+    const U = [];
+    for (let V = 0; V < b; V += 1)
+      U.push(y[p + V].variantId);
+    m.set(A, U);
+  }
+  At(w, y, (A) => {
+    if (!s[A.variantId])
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${A.variantId}`);
+  });
+  const G = /* @__PURE__ */ new Set(), N = /* @__PURE__ */ new Set(), R = (A, E, p) => {
+    if (E > 64)
+      throw new l("E_GROUP_RANGE", "V3 nested instance depth exceeds limit");
+    if (p.has(A))
+      throw new l("E_GROUP_RANGE", `V3 nested variant cycle detected at ${A}`);
+    if (!s[A])
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${A}`);
+    if (!N.has(A)) {
+      G.add(A), p.add(A);
+      for (const b of m.get(A) ?? [])
+        R(b, E + 1, p);
+      p.delete(A), N.add(A);
+    }
+  }, P = n.hiddenInstanceIds ?? /* @__PURE__ */ new Set(), B = n.viewport == null ? null : Je(
+    n.viewport,
+    n.viewportPaddingRatio ?? Oe
+  ), D = n.minViewportPixelSize ?? $e, C = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new Set(), O = (A, E, p) => {
+    if (E > 64)
+      throw new l("E_GROUP_RANGE", "V3 nested instance depth exceeds limit");
+    if (p.has(A))
+      throw new l("E_GROUP_RANGE", `V3 nested variant cycle detected at ${A}`);
+    if (C.has(A))
+      return C.get(A) ?? null;
+    const b = x[A];
+    if (!b)
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${A}`);
+    p.add(A);
+    let S = b.ownBBox, M = !1;
+    for (let U = 0; U < b.nestedCount; U += 1) {
+      const V = y[b.nestedStart + U], k = x[V.variantId];
+      if (!k)
+        throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${V.variantId}`);
+      const z = O(V.variantId, E + 1, p);
+      if ((!z || $.has(V.variantId)) && (M = !0), !z)
+        continue;
+      const H = an(V, b, k);
+      S = Rt(S, pt(z, H));
+    }
+    return p.delete(A), C.set(A, S), (!S || M) && $.add(A), S;
+  }, v = [], K = (A, E, p) => {
+    P.has(E) || B && p && (!qt(B, p) || Qe(
+      p,
+      n.viewport ?? null,
+      n.worldUnitsPerPixel,
+      D
+    )) || (v.push(E), R(A.variantId, 0, /* @__PURE__ */ new Set()));
+  };
+  if (B) {
+    const A = oo(t, w, (E) => {
+      const p = O(E.variantId, 0, /* @__PURE__ */ new Set()), b = !p || $.has(E.variantId);
+      return {
+        worldBBox: p ? pt(p, E) : null,
+        unknownBBox: b
+      };
+    });
+    for (const E of ro(A, B))
+      K(E.sceneInstance, E.sceneInstanceId, E.unknownBBox ? null : E.worldBBox);
+  } else
+    w.forEach((A, E) => {
+      K(A, E, null);
+    });
+  return d(G, v);
+}
+function Mo(t) {
+  if (!rt(t))
+    return null;
+  const n = vn(t);
+  return en(n) ? Dn(n) : null;
+}
+function ao(t, n) {
+  if (!Array.isArray(t) || t.length !== 4)
+    throw new l("E_HEADER", `${n} must be a four-number array`);
+  const e = t.map(Number);
+  if (!e.every(Number.isFinite))
+    throw new l("E_HEADER", `${n} must contain finite numbers`);
+  return [e[0], e[1], e[2], e[3]];
+}
+function Tt(t, n, e, o) {
+  return ft(n, e, t.byteLength, o), Zt.decode(t.subarray(n, n + e));
+}
+function Yn(t, n, e) {
+  if (n.length % 20 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 LAYER_TABLE length must be a multiple of 20");
+  const o = new DataView(t), a = [];
+  for (let r = n.offset; r < n.offset + n.length; r += 20) {
+    const i = o.getUint32(r, !0), c = o.getUint32(r + 4, !0);
+    a.push({
+      name: Tt(e, i, c, "V3 layer name"),
+      color: [o.getUint8(r + 8), o.getUint8(r + 9), o.getUint8(r + 10)],
+      visible: o.getUint8(r + 11) !== 0,
+      lw_px: o.getFloat32(r + 12, !0)
+    });
+  }
+  return a;
+}
+function yt(t, n, e, o, a, r) {
+  if (e + 4 > o)
+    throw new l("E_GROUP_RANGE", `Missing ${a} vertex_count`);
+  const i = n.getUint32(e, !0), c = e + 4, s = lt(t, n, c, i, o, r);
+  if (s.offset > o)
+    throw new l("E_GROUP_RANGE", `${a} exceeds section bounds`);
+  return {
+    chunk: s.chunk,
+    offset: s.offset
+  };
+}
+function Fn(t, n, e, o, a, r) {
+  const i = yt(t, n, e, o, a, r), c = e + 4;
+  return {
+    chunk: i.chunk,
+    snapshot: {
+      count: i.chunk.count,
+      raw: new Uint8Array(t, c, i.offset - c).slice(),
+      groupLayerEncoding: r
+    },
+    offset: i.offset
+  };
+}
+function wt(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 io(t = "u8") {
+  return {
+    line: wt(t),
+    fill: wt(t),
+    dot: wt(t)
+  };
+}
+function so(t, n, e) {
+  var o;
+  return !!(n && e && t.deferExternalVariantGeometry && !((o = t.externalVariantBuffers) != null && o.has(n.id)));
+}
+function St(t, n, e, o, a, r, i) {
+  if (a === 0)
+    return wt(i);
+  ft(o, a, e.length, r);
+  const c = e.offset + o, s = c + a, u = Fn(t, n, c, s, r, i);
+  if (u.offset !== s)
+    throw new l("E_GROUP_RANGE", `${r} has trailing bytes`);
+  return { chunk: u.chunk, snapshot: u.snapshot };
+}
+function kn(t, n, e) {
+  if ([
+    t.getUint32(n + 8, !0),
+    t.getUint32(n + 12, !0),
+    t.getUint32(n + 16, !0),
+    t.getUint32(n + 20, !0),
+    t.getUint32(n + 24, !0),
+    t.getUint32(n + 28, !0)
+  ].some((a) => a !== 0))
+    throw new l("E_GROUP_RANGE", `V3 external variant ${e} must use zero inline geometry offsets`);
+}
+function st(t, n, e, o, a, r) {
+  const i = Fn(t, n, e, t.byteLength, a, r);
+  if (i.chunk.count !== o)
+    throw new l(
+      "E_GROUP_RANGE",
+      `${a} vertex_count mismatch: manifest=${o}, sidecar=${i.chunk.count}`
+    );
+  return i;
+}
+function on(t) {
+  return "normal" in t ? t.normal : t;
+}
+function co(t, n, e) {
+  const o = on(t), a = new DataView(n);
+  let r = 0;
+  const i = st(n, a, r, o.line_count, `V3 external variant ${t.id} line blob`, e);
+  r = i.offset;
+  const c = st(n, a, r, o.fill_count, `V3 external variant ${t.id} fill blob`, e);
+  r = c.offset;
+  const s = st(n, a, r, o.dot_count, `V3 external variant ${t.id} dot blob`, e);
+  if (r = s.offset, r !== n.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: c.chunk, snapshot: c.snapshot },
+    dot: { chunk: s.chunk, snapshot: s.snapshot }
+  };
+}
+function lo(t, n) {
+  const e = Jt(n), o = et(e, 257, "BLOCK_NORMAL_GEOMETRY"), a = new DataView(n);
+  let r = o.offset;
+  const i = o.offset + o.length, c = Wt(e.versionMinor), s = st(n, a, r, t.normal.line_count, `V3.3 external variant ${t.id} normal line blob`, c);
+  r = s.offset;
+  const u = st(n, a, r, t.normal.fill_count, `V3.3 external variant ${t.id} normal fill blob`, c);
+  r = u.offset;
+  const h = st(n, a, r, t.normal.dot_count, `V3.3 external variant ${t.id} normal dot blob`, c);
+  if (r = h.offset, r !== i)
+    throw new l("E_GROUP_RANGE", `V3.3 external variant ${t.id} normal geometry section has trailing bytes`);
+  return {
+    line: { chunk: s.chunk, snapshot: s.snapshot },
+    fill: { chunk: u.chunk, snapshot: u.snapshot },
+    dot: { chunk: h.chunk, snapshot: h.snapshot }
+  };
+}
+function uo(t, n, e = "u8") {
+  if (n.byteLength !== t.raw_size)
+    throw new l(
+      "E_GROUP_RANGE",
+      `V3 external variant ${t.id} raw_size mismatch: manifest=${t.raw_size}, sidecar=${n.byteLength}`
+    );
+  return "normal" in t ? lo(t, n) : co(t, n, e);
+}
+function fo(t, n, e) {
+  const o = n == null ? void 0 : n.get(t.id);
+  if (!o)
+    throw new l("E_GROUP_RANGE", `Missing V3 external sidecar buffer for variant ${t.id}`);
+  return uo(t, o, e);
+}
+function Ct(t, n, e, o, a) {
+  if (o === 0)
+    return 0;
+  if (ft(e, o, n.length, a), o < 4)
+    throw new l("E_GROUP_RANGE", `Missing ${a} vertex_count`);
+  return t.getUint32(n.offset + e, !0);
+}
+function mo(t, n, e, o) {
+  const a = e.offset + e.length;
+  let r = e.offset;
+  const i = yt(t, n, r, a, "V3 BASE_GEOMETRY line", o);
+  r = i.offset;
+  const c = yt(t, n, r, a, "V3 BASE_GEOMETRY fill", o);
+  r = c.offset;
+  const s = yt(t, n, r, a, "V3 BASE_GEOMETRY dot", o);
+  if (r = s.offset, r !== a)
+    throw new l("E_GROUP_RANGE", "V3 BASE_GEOMETRY has trailing bytes");
+  return {
+    line: i.chunk,
+    fill: c.chunk,
+    dot: s.chunk
+  };
+}
+function Ot(t) {
+  return Ee(t.pos, t.count, 2);
+}
+function _o(t, n, e) {
+  return Rt(Rt(Ot(t), Ot(n)), Ot(e));
+}
+function rn(t) {
+  return "normal" in t ? We(t.normal.bbox ?? t.normal.own_bbox ?? null) : null;
+}
+function ho(t, n, e, o, a, r, i, c) {
+  if (e.length % 60 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 VARIANT_TABLE length must be a multiple of 60");
+  const s = [], u = /* @__PURE__ */ new Map(), h = [], d = e.length / 60;
+  for (let _ = 0; _ < d; _ += 1) {
+    const f = e.offset + _ * 60, w = n.getUint32(f, !0), y = n.getUint32(f + 4, !0), m = (r == null ? void 0 : r[_]) ?? null, x = !m || !c.requiredExternalVariantIds || c.requiredExternalVariantIds.has(_), G = so(c, m, x), N = m ? (kn(n, f, _), !x || G ? io(i) : fo(m, c.externalVariantBuffers, i)) : {
+      line: St(
+        t,
+        n,
+        o,
+        n.getUint32(f + 8, !0),
+        n.getUint32(f + 12, !0),
+        `V3 variant ${_} line blob`,
+        i
+      ),
+      fill: St(
+        t,
+        n,
+        o,
+        n.getUint32(f + 16, !0),
+        n.getUint32(f + 20, !0),
+        `V3 variant ${_} fill blob`,
+        i
+      ),
+      dot: St(
+        t,
+        n,
+        o,
+        n.getUint32(f + 24, !0),
+        n.getUint32(f + 28, !0),
+        `V3 variant ${_} dot blob`,
+        i
+      )
+    }, R = m ? on(m) : null, P = (R == null ? void 0 : R.line_count) ?? N.line.chunk.count, B = (R == null ? void 0 : R.fill_count) ?? N.fill.chunk.count, D = (R == null ? void 0 : R.dot_count) ?? N.dot.chunk.count, C = m && (!x || G) ? rn(m) : _o(N.line.chunk, N.fill.chunk, N.dot.chunk), $ = {
+      id: _,
+      name: Tt(a, w, y, `V3 variant ${_} name`),
+      line_count: G ? P : N.line.chunk.count,
+      fill_count: G ? B : N.fill.chunk.count,
+      dot_count: G ? D : N.dot.chunk.count,
+      sourceLineCount: P,
+      sourceFillCount: B,
+      sourceDotCount: D,
+      nestedStart: n.getUint32(f + 32, !0),
+      nestedCount: n.getUint32(f + 36, !0),
+      textStart: n.getUint32(f + 40, !0),
+      textCount: n.getUint32(f + 44, !0),
+      precisionOriginX: n.getFloat32(f + 48, !0),
+      precisionOriginY: n.getFloat32(f + 52, !0),
+      lineSnapshot: N.line.snapshot,
+      fillSnapshot: N.fill.snapshot,
+      dotSnapshot: N.dot.snapshot,
+      bbox: C
+    };
+    s.push($), u.set(_, { line: N.line.chunk, fill: N.fill.chunk, dot: N.dot.chunk }), h.push({ line: N.line.snapshot, fill: N.fill.snapshot, dot: N.dot.snapshot });
+  }
+  return { variantsById: s, variants: u, snapshots: h };
+}
+function zn(t, n, e, o, a) {
+  if (n.length % 60 !== 0)
+    throw new l("E_GROUP_RANGE", "V3 VARIANT_TABLE length must be a multiple of 60");
+  const r = [], i = n.length / 60;
+  for (let c = 0; c < i; c += 1) {
+    const s = n.offset + c * 60, u = t.getUint32(s, !0), h = t.getUint32(s + 4, !0), d = (a == null ? void 0 : a[c]) ?? null;
+    d && kn(t, s, c);
+    const _ = d ? on(d) : null, f = t.getFloat32(s + 48, !0), w = t.getFloat32(s + 52, !0);
+    r.push({
+      id: c,
+      name: Tt(o, u, h, `V3 variant ${c} name`),
+      line_count: d ? _.line_count : Ct(
+        t,
+        e,
+        t.getUint32(s + 8, !0),
+        t.getUint32(s + 12, !0),
+        `V3 variant ${c} line blob`
+      ),
+      fill_count: d ? _.fill_count : Ct(
+        t,
+        e,
+        t.getUint32(s + 16, !0),
+        t.getUint32(s + 20, !0),
+        `V3 variant ${c} fill blob`
+      ),
+      dot_count: d ? _.dot_count : Ct(
+        t,
+        e,
+        t.getUint32(s + 24, !0),
+        t.getUint32(s + 28, !0),
+        `V3 variant ${c} dot blob`
+      ),
+      nestedStart: t.getUint32(s + 32, !0),
+      nestedCount: t.getUint32(s + 36, !0),
+      textStart: t.getUint32(s + 40, !0),
+      textCount: t.getUint32(s + 44, !0),
+      precisionOriginX: f,
+      precisionOriginY: w,
+      bbox: d ? rn(d) : null
+    });
+  }
+  return r;
+}
+function Z(t, n, e) {
+  if (n.length % 32 !== 0)
+    throw new l("E_GROUP_RANGE", `${e} length must be a multiple of 32`);
+  const o = new DataView(t), a = [];
+  for (let r = n.offset; r < n.offset + n.length; r += 32) {
+    const i = o.getUint16(r + 30, !0);
+    Ao(i), a.push({
+      variantId: o.getUint32(r, !0),
+      matA: o.getFloat32(r + 4, !0),
+      matB: o.getFloat32(r + 8, !0),
+      matC: o.getFloat32(r + 12, !0),
+      matD: o.getFloat32(r + 16, !0),
+      tx: o.getFloat32(r + 20, !0),
+      ty: o.getFloat32(r + 24, !0),
+      insLayerIdx: o.getUint16(r + 28, !0),
+      flags: i
+    });
+  }
+  return a;
+}
+function Eo(t, n, e) {
+  const o = t.getUint32(n, !0), a = t.getUint32(n + 4, !0), r = t.getUint8(n + 42), i = t.getUint8(n + 43), c = t.getFloat32(n + 24, !0), s = t.getFloat32(n + 28, !0);
+  return {
+    t: Tt(e, o, a, "V3 text value"),
+    x: t.getFloat32(n + 8, !0),
+    y: t.getFloat32(n + 12, !0),
+    h: t.getFloat32(n + 16, !0),
+    r: t.getFloat32(n + 20, !0),
+    c: [t.getUint8(n + 36), t.getUint8(n + 37), t.getUint8(n + 38)],
+    li: t.getUint16(n + 40, !0),
+    ha: De[r & 3] ?? "left",
+    va: ve[r >> 2 & 3] ?? "alphabetic",
+    lh: t.getFloat32(n + 32, !0),
+    ...c ? { w: c } : {},
+    ...s !== 1 ? { wf: s } : {},
+    ...i & 1 ? { mx: !0 } : {},
+    ...i & 2 ? { my: !0 } : {}
+  };
+}
+function $t(t, n, e, o) {
+  if (n.length % 44 !== 0)
+    throw new l("E_GROUP_RANGE", `${o} length must be a multiple of 44`);
+  const a = [], r = new DataView(t);
+  for (let i = n.offset; i < n.offset + n.length; i += 44)
+    a.push(Eo(r, i, e));
+  return a;
+}
+function xo(t, n) {
+  if (t.length % 44 !== 0)
+    throw new l("E_GROUP_RANGE", `${n} length must be a multiple of 44`);
+  return t.length / 44;
+}
+function Hn(t, n, e, o) {
+  return {
+    instanceId: e,
+    variantId: n.variantId,
+    matA: t.matA * n.matA + t.matC * n.matB,
+    matB: t.matB * n.matA + t.matD * n.matB,
+    matC: t.matA * n.matC + t.matC * n.matD,
+    matD: t.matB * n.matC + t.matD * n.matD,
+    tx: t.matA * n.tx + t.matC * n.ty + t.tx,
+    ty: t.matB * n.tx + t.matD * n.ty + t.ty,
+    insLayerIdx: o
+  };
+}
+function jn(t, n, e, o) {
+  var y;
+  const a = ((y = o[n.insLayerIdx]) == null ? void 0 : y.visible) === !1, r = n.matA * t.x + n.matC * t.y + n.tx, i = n.matB * t.x + n.matD * t.y + n.ty, c = Math.hypot(n.matA, n.matB), s = Math.hypot(n.matC, n.matD), u = s > 1e-12 ? s : c > 1e-12 ? c : 1, h = c > 1e-12 && u > 1e-12 ? c / u : 1, d = go(t, n), { mx: _, my: f, ...w } = t;
+  return {
+    ...w,
+    x: r,
+    y: i,
+    h: t.h * u,
+    w: t.w === void 0 ? void 0 : t.w * u,
+    wf: (t.wf ?? 1) * h,
+    r: d.r,
+    ...d.mx ? { mx: !0 } : {},
+    ...d.my ? { my: !0 } : {},
+    li: a || t.li === e ? n.insLayerIdx : t.li
+  };
+}
+function go(t, n) {
+  const e = t.r * Math.PI / 180, o = Math.cos(e), a = Math.sin(e), r = t.mx ? -1 : 1, i = t.my ? -1 : 1, c = r * (n.matA * o + n.matC * a), s = r * (n.matB * o + n.matD * a), u = i * (n.matC * o - n.matA * a), h = i * (n.matD * o - n.matB * a), d = c * h - s * u, _ = Math.atan2(s, c) * 180 / Math.PI;
+  return d < 0 ? { r: Math.atan2(-s, -c) * 180 / Math.PI, mx: !0 } : { r: _ };
+}
+function Mt(t, n, e, o) {
+  var c;
+  if (t.count === 0)
+    return It();
+  const a = new Float32Array(t.count * 2);
+  for (let s = 0; s < t.count; s += 1) {
+    const u = s * 2, h = t.pos[u], d = t.pos[u + 1];
+    a[u] = n.matA * h + n.matC * d + n.tx, a[u + 1] = n.matB * h + n.matD * d + n.ty;
+  }
+  const r = ((c = o[n.insLayerIdx]) == null ? void 0 : c.visible) === !1, i = Cn(
+    ot(t),
+    (s) => r || s === e ? n.insLayerIdx : s
+  );
+  return { pos: a, count: t.count, segments: i };
+}
+function Pt(t) {
+  const n = t.reduce((r, i) => r + i.count, 0);
+  if (n === 0)
+    return It();
+  const e = new Float32Array(n * 2), o = [];
+  let a = 0;
+  for (const r of t)
+    e.set(r.pos, a * 2), o.push(...Ht(ot(r), a)), a += r.count;
+  return { pos: e, count: n, segments: dt(o) };
+}
+function qn(t, n) {
+  return t === n ? n : t;
+}
+function Kn(t, n, e) {
+  return t === e ? n : t;
+}
+function Wn(t, n) {
+  const e = new DataView(t), { versionMinor: o, sections: a } = mt(t), r = Wt(o), i = X(a, 1, "SCENE_META"), c = X(a, 2, "LAYER_TABLE"), s = X(a, 3, "STRING_TABLE"), u = X(a, 4, "BASE_GEOMETRY"), h = X(a, 5, "VARIANT_TABLE"), d = X(a, 6, "VARIANT_GEOMETRY"), _ = X(a, 7, "SCENE_INSTANCE_TABLE"), f = ut(a, 8), w = ut(a, 9), y = ut(a, 10), m = _t(t, i, "SCENE_META"), x = nn(m) ? Vt(m, h.length / 60) : null, G = en(m), N = G ? Dn(m) : null, R = Ke(m, x, G), P = G ? "nested_instanced_external_annotations" : x ? "nested_instanced_external" : "nested_instanced", B = new Uint8Array(t, s.offset, s.length), D = Yn(t, c, B), C = Number(m.layer0_index ?? 0), $ = Qt({
+    bounds: m.bounds ?? [0, 0, 0, 0],
+    entity_count: Number(m.entity_count ?? 0),
+    line_count: Number(m.base_line_count ?? 0),
+    fill_count: Number(m.base_fill_count ?? 0),
+    dot_count: Number(m.base_dot_count ?? 0),
+    layers: D,
+    texts: []
+  });
+  Zn(C, $.layers);
+  const O = mo(t, e, u, r);
+  if (!n.loadBlocks) {
+    const g = zn(e, h, d, B, x), I = Z(t, _, "V3 SCENE_INSTANCE_TABLE"), F = Z(t, f, "V3 NESTED_INSTANCE_TABLE"), L = $t(t, w, B, "V3 SCENE_TEXT_TABLE"), Y = xo(y, "V3 VARIANT_TEXT_TABLE");
+    if (Number(m.variant_count ?? g.length) !== g.length)
+      throw new l("E_GROUP_RANGE", "V3 variant count mismatch");
+    if (Number(m.scene_instance_count ?? I.length) !== I.length)
+      throw new l("E_GROUP_RANGE", "V3 scene instance count mismatch");
+    if (Number(m.nested_instance_count ?? F.length) !== F.length)
+      throw new l("E_GROUP_RANGE", "V3 nested instance count mismatch");
+    if (Number(m.scene_text_count ?? L.length) !== L.length)
+      throw new l("E_GROUP_RANGE", "V3 scene text count mismatch");
+    if (Number(m.variant_text_count ?? Y) !== Y)
+      throw new l("E_GROUP_RANGE", "V3 variant text count mismatch");
+    for (const T of g) {
+      if (T.nestedStart + T.nestedCount > F.length)
+        throw new l("E_GROUP_RANGE", `V3 variant ${T.id} nested range exceeds table`);
+      if (T.textStart + T.textCount > Y)
+        throw new l("E_GROUP_RANGE", `V3 variant ${T.id} text range exceeds table`);
+    }
+    return At(I, F, (T) => {
+      if (!g[T.variantId])
+        throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${T.variantId}`);
+      Kt(T.insLayerIdx, D.length);
+    }), {
+      meta: {
+        bounds: m.bounds ?? [0, 0, 0, 0],
+        entity_count: Number(m.entity_count ?? 0),
+        line_count: O.line.count,
+        fill_count: O.fill.count,
+        dot_count: O.dot.count,
+        version: 3,
+        version_minor: o,
+        encoding: P,
+        ...R ? { features: R } : {},
+        ...x ? { external_variants: [...x] } : {},
+        ...N ? { external_annotations: N } : {},
+        layer0_index: C,
+        block_variants: g.map((T) => ({
+          id: T.id,
+          name: T.name,
+          line_count: T.line_count,
+          fill_count: T.fill_count,
+          dot_count: T.dot_count
+        })),
+        instance_count: I.length,
+        layers: D,
+        texts: L
+      },
+      header: {
+        ...$,
+        lineCount: O.line.count,
+        fillCount: O.fill.count,
+        dotCount: O.dot.count,
+        textCount: L.length,
+        texts: L
+      },
+      decoded: {
+        baseLine: O.line,
+        baseFill: O.fill,
+        baseDot: O.dot,
+        variants: /* @__PURE__ */ new Map(),
+        instances: [],
+        instanceIdByVariantOrdinal: /* @__PURE__ */ new Map()
+      }
+    };
+  }
+  const { variantsById: v, variants: K, snapshots: A } = ho(
+    t,
+    e,
+    h,
+    d,
+    B,
+    x,
+    r,
+    n
+  ), E = Z(t, _, "V3 SCENE_INSTANCE_TABLE"), p = Z(t, f, "V3 NESTED_INSTANCE_TABLE"), b = $t(t, w, B, "V3 SCENE_TEXT_TABLE"), S = $t(t, y, B, "V3 VARIANT_TEXT_TABLE");
+  if (Number(m.variant_count ?? v.length) !== v.length)
+    throw new l("E_GROUP_RANGE", "V3 variant count mismatch");
+  if (Number(m.scene_instance_count ?? E.length) !== E.length)
+    throw new l("E_GROUP_RANGE", "V3 scene instance count mismatch");
+  if (Number(m.nested_instance_count ?? p.length) !== p.length)
+    throw new l("E_GROUP_RANGE", "V3 nested instance count mismatch");
+  if (Number(m.scene_text_count ?? b.length) !== b.length)
+    throw new l("E_GROUP_RANGE", "V3 scene text count mismatch");
+  if (Number(m.variant_text_count ?? S.length) !== S.length)
+    throw new l("E_GROUP_RANGE", "V3 variant text count mismatch");
+  for (const g of v) {
+    if (g.nestedStart + g.nestedCount > p.length)
+      throw new l("E_GROUP_RANGE", `V3 variant ${g.id} nested range exceeds table`);
+    if (g.textStart + g.textCount > S.length)
+      throw new l("E_GROUP_RANGE", `V3 variant ${g.id} text range exceeds table`);
+  }
+  At(E, p, (g) => {
+    if (!v[g.variantId])
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${g.variantId}`);
+    Kt(g.insLayerIdx, D.length);
+  });
+  const M = /* @__PURE__ */ new Map();
+  for (const g of v)
+    M.set(
+      g.id,
+      S.slice(g.textStart, g.textStart + g.textCount)
+    );
+  const U = [], V = n.externalVariantDeltaOnly, k = V ? [] : [...b], z = /* @__PURE__ */ new Map(), H = /* @__PURE__ */ new Map(), ht = /* @__PURE__ */ new Map(), bt = (g, I) => {
+    z.set(g, Rt(z.get(g) ?? null, I));
+  }, Et = (g, I, F, L, Y, Q) => {
+    var fn;
+    if (Y > 64)
+      throw new l("E_GROUP_RANGE", "V3 nested instance depth exceeds limit");
+    if (Q.has(g))
+      throw new l("E_GROUP_RANGE", `V3 nested variant cycle detected at ${g}`);
+    const T = v[g];
+    if (!T)
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${g}`);
+    Q.add(g);
+    const tt = !n.requiredExternalVariantIds || n.requiredExternalVariantIds.has(g), W = V ? ((fn = n.requiredExternalVariantIds) == null ? void 0 : fn.has(g)) === !0 : tt;
+    let j = !1;
+    const dn = !!(T.line_count || T.fill_count || T.dot_count), ne = T.textCount > 0;
+    if (W && (dn || ne) && (U.push({
+      instanceId: I.instanceId,
+      variantId: g,
+      matA: I.matA,
+      matB: I.matB,
+      matC: I.matC,
+      matD: I.matD,
+      tx: I.tx,
+      ty: I.ty,
+      insLayerIdx: I.insLayerIdx
+    }), dn && bt(I.instanceId, T.bbox ? Jn(T.bbox, I) : null), j = !0), W) {
+      T.textCount > 0 && (j = !0);
+      for (let nt = 0; nt < T.textCount; nt += 1) {
+        const at = jn(S[T.textStart + nt], I, C, $.layers);
+        k.push({
+          ...at,
+          iv: F,
+          io: L
+        });
+      }
+    }
+    for (let nt = 0; nt < T.nestedCount; nt += 1) {
+      const at = p[T.nestedStart + nt], ee = Kn(at.insLayerIdx, I.insLayerIdx, C), oe = an(at, T, v[at.variantId]), re = Hn(I, oe, I.instanceId, ee);
+      j = Et(at.variantId, re, F, L, Y + 1, Q) || j;
+    }
+    return Q.delete(g), j;
+  }, Bt = /* @__PURE__ */ new Map();
+  E.forEach((g, I) => {
+    if (!v[g.variantId])
+      throw new l("E_GROUP_RANGE", `Unknown V3 scene variantId ${g.variantId}`);
+    const L = ht.get(g.variantId) ?? 0;
+    ht.set(g.variantId, L + 1), H.set(`${g.variantId}:${L}`, I);
+    const Y = qn(g.insLayerIdx, C), Q = {
+      instanceId: I,
+      variantId: g.variantId,
+      matA: g.matA,
+      matB: g.matB,
+      matC: g.matC,
+      matD: g.matD,
+      tx: g.tx,
+      ty: g.ty,
+      insLayerIdx: Y
+    }, T = Et(g.variantId, Q, g.variantId, L, 0, /* @__PURE__ */ new Set());
+    if (V && !T)
+      return;
+    let tt = Bt.get(Y);
+    tt || (tt = /* @__PURE__ */ new Map(), Bt.set(Y, tt));
+    let W = tt.get(g.variantId);
+    W || (W = { count: 0, bboxes: [], inserts: [] }, tt.set(g.variantId, W)), W.count += 1;
+    const j = z.get(I) ?? null;
+    j && W.bboxes.push(j), W.inserts.push({
+      instanceId: I,
+      variantId: g.variantId,
+      label: `#${I + 1} (${g.tx.toFixed(1)}, ${g.ty.toFixed(1)})`,
+      tx: g.tx,
+      ty: g.ty,
+      canHighlight: j !== null,
+      ...j ? { bbox: j } : {}
+    });
+  });
+  const sn = /* @__PURE__ */ new Map();
+  for (const [g, I] of Bt) {
+    const F = [];
+    for (const [L, Y] of I)
+      F.push({
+        variantId: L,
+        blockName: Mn(v[L], L),
+        instanceCount: Y.count,
+        bboxes: Y.bboxes,
+        inserts: Y.inserts
+      });
+    F.sort((L, Y) => Y.instanceCount - L.instanceCount), sn.set(g, F);
+  }
+  let cn = V ? 0 : O.line.count, ln = V ? 0 : O.fill.count, un = V ? 0 : O.dot.count;
+  for (const g of U) {
+    const I = v[g.variantId];
+    !(n.deferExternalVariantGeometry && I.lineSnapshot.count === 0 && I.fillSnapshot.count === 0 && I.dotSnapshot.count === 0) && !Nt(g.instanceId, n) || (cn += I.line_count, ln += I.fill_count, un += I.dot_count);
+  }
+  const xt = ke(k, H, n), Qn = {
+    bounds: m.bounds ?? [0, 0, 0, 0],
+    entity_count: V ? 0 : Number(m.entity_count ?? 0),
+    line_count: O.line.count,
+    fill_count: O.fill.count,
+    dot_count: O.dot.count,
+    version: 3,
+    version_minor: o,
+    encoding: P,
+    ...R ? { features: R } : {},
+    ...x ? { external_variants: [...x] } : {},
+    ...N ? { external_annotations: N } : {},
+    layer0_index: C,
+    block_variants: v.map((g) => ({
+      id: g.id,
+      name: g.name,
+      line_count: g.sourceLineCount,
+      fill_count: g.sourceFillCount,
+      dot_count: g.sourceDotCount
+    })),
+    instance_count: E.length,
+    layers: D,
+    texts: xt
+  }, te = {
+    ...$,
+    entityCount: V ? 0 : $.entityCount,
+    lineCount: cn,
+    fillCount: ln,
+    dotCount: un,
+    textCount: xt.length,
+    texts: xt,
+    ...n.loadBlocks ? {
+      layerBlockUsages: sn,
+      insertRuntime: He(
+        C,
+        v,
+        A,
+        M,
+        U,
+        xt,
+        H
+      )
+    } : {}
+  };
+  return {
+    meta: Qn,
+    header: te,
+    decoded: {
+      baseLine: V ? Xt() : O.line,
+      baseFill: V ? Xt() : O.fill,
+      baseDot: V ? Xt() : O.dot,
+      variants: K,
+      instances: U,
+      instanceIdByVariantOrdinal: H
+    }
+  };
+}
+function Nn(t) {
+  return "annotation" in t && (t.annotation.line_count > 0 || t.annotation.fill_count > 0 || t.annotation.dot_count > 0 || t.annotation.text_count > 0);
+}
+function yo(t, n) {
+  if (n.line.count !== t.annotation.line_count || n.fill.count !== t.annotation.fill_count || n.dot.count !== t.annotation.dot_count || n.texts.length !== t.annotation.text_count)
+    throw new l(
+      "E_GROUP_RANGE",
+      `V3.3 external variant ${t.id} annotation count mismatch`
+    );
+}
+function wo(t, n, e, o, a, r) {
+  return {
+    line: Mt(t.line, n, e, o),
+    fill: Mt(t.fill, n, e, o),
+    dot: Mt(t.dot, n, e, o),
+    texts: t.texts.map((i) => ({
+      ...jn(i, n, e, o),
+      iv: a,
+      io: r
+    }))
+  };
+}
+function Po(t, n) {
+  if (!rt(t))
+    return null;
+  const e = new DataView(t), { sections: o } = mt(t), a = X(o, 1, "SCENE_META"), r = X(o, 2, "LAYER_TABLE"), i = X(o, 3, "STRING_TABLE"), c = X(o, 5, "VARIANT_TABLE"), s = X(o, 6, "VARIANT_GEOMETRY"), u = X(o, 7, "SCENE_INSTANCE_TABLE"), h = ut(o, 8), d = _t(t, a, "SCENE_META");
+  if (!en(d))
+    return null;
+  const _ = Vt(d, c.length / 60);
+  if (!_.some(Nn))
+    return null;
+  const f = new Uint8Array(t, i.offset, i.length), w = Yn(t, r, f), y = Number(d.layer0_index ?? 0), m = Qt({
+    bounds: d.bounds ?? [0, 0, 0, 0],
+    entity_count: Number(d.entity_count ?? 0),
+    line_count: Number(d.base_line_count ?? 0),
+    fill_count: Number(d.base_fill_count ?? 0),
+    dot_count: Number(d.base_dot_count ?? 0),
+    layers: w,
+    texts: []
+  });
+  Zn(y, m.layers);
+  const x = zn(e, c, s, f, _), G = Z(t, u, "V3 SCENE_INSTANCE_TABLE"), N = Z(t, h, "V3 NESTED_INSTANCE_TABLE");
+  if (Number(d.variant_count ?? x.length) !== x.length)
+    throw new l("E_GROUP_RANGE", "V3 variant count mismatch");
+  if (Number(d.scene_instance_count ?? G.length) !== G.length)
+    throw new l("E_GROUP_RANGE", "V3 scene instance count mismatch");
+  if (Number(d.nested_instance_count ?? N.length) !== N.length)
+    throw new l("E_GROUP_RANGE", "V3 nested instance count mismatch");
+  for (const E of x)
+    if (E.nestedStart + E.nestedCount > N.length)
+      throw new l("E_GROUP_RANGE", `V3 variant ${E.id} nested range exceeds table`);
+  At(G, N, (E) => {
+    if (!x[E.variantId])
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${E.variantId}`);
+    Kt(E.insLayerIdx, w.length);
+  });
+  const R = /* @__PURE__ */ new Map(), P = (E) => {
+    var U;
+    const p = _[E];
+    if (!p || !Nn(p))
+      return null;
+    const b = R.get(E);
+    if (b)
+      return b;
+    const S = (U = n == null ? void 0 : n.externalVariantBuffers) == null ? void 0 : U.get(p.id);
+    if (!S)
+      return null;
+    if (S.byteLength !== p.raw_size)
+      throw new l(
+        "E_GROUP_RANGE",
+        `V3.3 annotation sidecar ${p.id} raw_size mismatch: manifest=${p.raw_size}, sidecar=${S.byteLength}`
+      );
+    const M = be(S);
+    return yo(p, M), R.set(E, M), M;
+  }, B = [], D = [], C = [], $ = [], O = (n == null ? void 0 : n.hiddenInstanceIds) ?? /* @__PURE__ */ new Set(), v = (E, p, b, S) => {
+    const M = wo(
+      E,
+      p,
+      y,
+      m.layers,
+      b,
+      S
+    );
+    B.push(M.line), D.push(M.fill), C.push(M.dot), $.push(...M.texts);
+  }, K = (E, p, b, S, M, U) => {
+    if (M > 64)
+      throw new l("E_GROUP_RANGE", "V3 nested instance depth exceeds limit");
+    if (U.has(E))
+      throw new l("E_GROUP_RANGE", `V3 nested variant cycle detected at ${E}`);
+    const V = x[E];
+    if (!V)
+      throw new l("E_GROUP_RANGE", `Unknown V3 variantId ${E}`);
+    U.add(E);
+    const k = P(E);
+    k && v(k, p, b, S);
+    for (let z = 0; z < V.nestedCount; z += 1) {
+      const H = N[V.nestedStart + z], ht = Kn(H.insLayerIdx, p.insLayerIdx, y), bt = an(H, V, x[H.variantId]), Et = Hn(p, bt, p.instanceId, ht);
+      K(H.variantId, Et, b, S, M + 1, U);
+    }
+    U.delete(E);
+  }, A = /* @__PURE__ */ new Map();
+  return G.forEach((E, p) => {
+    const b = A.get(E.variantId) ?? 0;
+    if (A.set(E.variantId, b + 1), O.has(p))
+      return;
+    const S = qn(E.insLayerIdx, y), M = {
+      instanceId: p,
+      variantId: E.variantId,
+      matA: E.matA,
+      matB: E.matB,
+      matC: E.matC,
+      matD: E.matD,
+      tx: E.tx,
+      ty: E.ty,
+      insLayerIdx: S
+    };
+    K(E.variantId, M, E.variantId, b, 0, /* @__PURE__ */ new Set());
+  }), B.every((E) => E.count === 0) && D.every((E) => E.count === 0) && C.every((E) => E.count === 0) && $.length === 0 ? null : {
+    line: Pt(B),
+    fill: Pt(D),
+    dot: Pt(C),
+    texts: $
+  };
+}
+function Rt(t, n) {
+  return me(t, n);
+}
+function Jn(t, n) {
+  return Bn(t, n);
+}
+function Rn(t) {
+  return xe(t);
+}
+function pn(t, n) {
+  return ge(t, n);
+}
+function pt(t, n) {
+  return Jn(t, {
+    variantId: n.variantId,
+    matA: n.matA,
+    matB: n.matB,
+    matC: n.matC,
+    matD: n.matD,
+    tx: n.tx,
+    ty: n.ty,
+    insLayerIdx: n.insLayerIdx
+  });
+}
+function an(t, n, e) {
+  if (!(e != null && e.bbox) || !n.bbox)
+    return t;
+  const o = n.precisionOriginX, a = n.precisionOriginY;
+  if (!Number.isFinite(o) || !Number.isFinite(a) || o === 0 && a === 0)
+    return t;
+  const r = {
+    ...t,
+    tx: t.tx - o,
+    ty: t.ty - a
+  }, i = pt(e.bbox, t), c = pt(e.bbox, r), s = Math.max(Rn(n.bbox), Rn(e.bbox), 1), u = Math.hypot(o, a), h = Math.hypot(t.tx, t.ty), d = Math.hypot(r.tx, r.ty);
+  if (u <= s * 16 || h <= s * 16)
+    return t;
+  const _ = pn(n.bbox, i), f = pn(n.bbox, c);
+  return _ > s * 16 && f * 4 < _ && d * 4 < h ? r : t;
+}
+function Kt(t, n) {
+  if (t >= n)
+    throw new l("E_GROUP_RANGE", `Instance layer index ${t} exceeds layer count ${n}`);
+}
+function Zn(t, n) {
+  if (!Number.isInteger(t) || t < 0 || t >= n.length)
+    throw new l("E_GROUP_RANGE", `layer0_index out of range: ${t}`);
+  if (n[t].name !== "0")
+    throw new l("E_GROUP_RANGE", `layer0_index must reference layer "0": ${t}`);
+}
+function Ao(t) {
+  if (t !== 0)
+    throw new l("E_GROUP_RANGE", `Instance flags must be zero for Stage 1, found ${t}`);
+}
+function* No(t, n, e, o, a) {
+  let r = e;
+  const i = [
+    { kind: "line", count: o.lineCount },
+    { kind: "fill", count: o.fillCount },
+    { kind: "dot", count: o.dotCount }
+  ];
+  for (const c of i) {
+    const s = de(t, n, r, c.count);
+    for (; ; ) {
+      const u = s.next();
+      if (u.done) {
+        r = u.value;
+        break;
+      }
+      yield { kind: c.kind, payload: u.value };
+    }
+  }
+  if (r !== t.byteLength)
+    throw new l("E_GROUP_RANGE", `Trailing bytes detected: offset=${r}, size=${t.byteLength}`);
+  for (const c of o.texts)
+    yield { kind: "text", payload: c };
+}
+function* Ro(t, n, e, o) {
+  yield* No(t, n, e, o);
+}
+function Dt(t, n, e, o, a, r, i) {
+  let c = t.count, s = 0;
+  for (const f of e) {
+    if (!Nt(f.instanceId, i))
+      continue;
+    const w = n.get(f.variantId);
+    if (!w)
+      throw new l("E_GROUP_RANGE", `Unknown variantId ${f.variantId}`);
+    const y = w[o].count;
+    s += y, c += y;
+  }
+  if ($n(i, o, s), c === 0)
+    return It();
+  const u = new Float32Array(c * 2), h = [];
+  let d = 0;
+  ((f) => {
+    u.set(f.pos, d * 2), h.push(...Ht(ot(f), d)), d += f.count;
+  })(t);
+  for (const f of e) {
+    if (!Nt(f.instanceId, i))
+      continue;
+    const w = n.get(f.variantId);
+    if (!w)
+      throw new l("E_GROUP_RANGE", `Unknown variantId ${f.variantId}`);
+    const y = w[o], m = r[f.insLayerIdx].visible === !1;
+    for (let x = 0; x < y.count; x += 1) {
+      const G = x * 2, R = (d + x) * 2, P = y.pos[G], B = y.pos[G + 1];
+      u[R] = f.matA * P + f.matC * B + f.tx, u[R + 1] = f.matB * P + f.matD * B + f.ty;
+    }
+    h.push(...Ht(
+      Cn(
+        ot(y),
+        (x) => m || x === a ? f.insLayerIdx : x
+      ),
+      d
+    )), d += y.count;
+  }
+  return { pos: u, count: c, segments: dt(h) };
+}
+function* vt(t, n, e, o, a, r, i, c) {
+  if ($n(c, t, Math.max(0, n - e.count)), n === 0) {
+    yield { kind: t, payload: It() };
+    return;
+  }
+  const s = Lt;
+  let u = new Float32Array(s * 2), h = [], d = 0, _ = 0;
+  const f = function* () {
+    if (d <= 0)
+      return;
+    const m = d === s ? { pos: u, count: d, segments: dt(h) } : { pos: u.slice(0, d * 2), count: d, segments: dt(h) };
+    yield { kind: t, payload: m }, _ += d, d = 0, u = new Float32Array(s * 2), h = [];
+  }, w = (m, x, G, N) => {
+    if (m <= 0)
+      return;
+    const R = h[h.length - 1];
+    if (R && R.startVertex + R.vertexCount === d && R.layerIndex === G && R.color[0] === x[0] && R.color[1] === x[1] && R.color[2] === x[2] && R.lineweightPx === N) {
+      h[h.length - 1] = {
+        ...R,
+        vertexCount: R.vertexCount + m
+      };
+      return;
+    }
+    h.push({
+      startVertex: d,
+      vertexCount: m,
+      color: [x[0], x[1], x[2]],
+      layerIndex: G,
+      ...N === void 0 ? {} : { lineweightPx: N }
+    });
+  };
+  yield* function* () {
+    for (const m of ot(e)) {
+      let x = m.startVertex;
+      const G = m.startVertex + m.vertexCount;
+      for (; x < G; ) {
+        const N = Math.min(s - d, G - x), R = x * 2, P = d * 2;
+        u.set(e.pos.subarray(R, R + N * 2), P), w(N, m.color, m.layerIndex, m.lineweightPx), x += N, d += N, d === s && (yield* f());
+      }
+    }
+  }();
+  for (const m of a) {
+    if (!Nt(m.instanceId, c))
+      continue;
+    const x = o.get(m.variantId);
+    if (!x)
+      throw new l("E_GROUP_RANGE", `Unknown variantId ${m.variantId}`);
+    const G = x[t], N = i[m.insLayerIdx].visible === !1;
+    for (const R of ot(G)) {
+      const P = N || R.layerIndex === r ? m.insLayerIdx : R.layerIndex;
+      let B = R.startVertex;
+      const D = R.startVertex + R.vertexCount;
+      for (; B < D; ) {
+        const C = Math.min(s - d, D - B);
+        for (let $ = 0; $ < C; $ += 1) {
+          const O = (B + $) * 2, v = (d + $) * 2, K = G.pos[O], A = G.pos[O + 1];
+          u[v] = m.matA * K + m.matC * A + m.tx, u[v + 1] = m.matB * K + m.matD * A + m.ty;
+        }
+        w(C, R.color, P, R.lineweightPx), B += C, d += C, d === s && (yield* f());
+      }
+    }
+  }
+  if (yield* f(), _ !== n)
+    throw new l("E_GROUP_RANGE", `Expanded ${t} count mismatch: header=${n}, emitted=${_}`);
+}
+function* po(t, n, e, o) {
+  yield* vt(
+    "line",
+    n.lineCount,
+    t.baseLine,
+    t.variants,
+    t.instances,
+    e.layer0_index,
+    n.layers,
+    o
+  ), yield* vt(
+    "fill",
+    n.fillCount,
+    t.baseFill,
+    t.variants,
+    t.instances,
+    e.layer0_index,
+    n.layers,
+    o
+  ), yield* vt(
+    "dot",
+    n.dotCount,
+    t.baseDot,
+    t.variants,
+    t.instances,
+    e.layer0_index,
+    n.layers,
+    o
+  );
+  for (const a of n.texts)
+    yield { kind: "text", payload: a };
+}
+function Io(t, n) {
+  const e = On(n), o = Wn(t, e);
+  return {
+    header: o.header,
+    chunks: po(
+      o.decoded,
+      o.header,
+      { layer0_index: o.meta.layer0_index ?? 0 },
+      e
+    )
+  };
+}
+function Go(t, n) {
+  if (rt(t))
+    return Io(t, n);
+  const e = tn(t);
+  return {
+    header: e.header,
+    chunks: Ro(t, e.view, e.dataOffset, e.header)
+  };
+}
+function Do(t) {
+  if (rt(t)) {
+    const n = vn(t);
+    return ao(n.bounds, "V3 SCENE_META bounds");
+  }
+  return tn(t).header.bounds;
+}
+function* vo(t, n) {
+  const e = Go(t, n);
+  for (const o of e.chunks)
+    yield o;
+  return e.header;
+}
+function Xt() {
+  return {
+    pos: new Float32Array(0),
+    col: new Uint8Array(0),
+    lay: new Uint8Array(0),
+    count: 0
+  };
+}
+function it(t) {
+  const n = Be(t);
+  return {
+    pos: t.pos,
+    col: n.col,
+    lay: n.lay,
+    count: t.count
+  };
+}
+function Xo(t, n) {
+  if (rt(t)) {
+    const c = On(n), s = Wn(t, c), u = Dt(
+      s.decoded.baseLine,
+      s.decoded.variants,
+      s.decoded.instances,
+      "line",
+      s.meta.layer0_index ?? 0,
+      s.header.layers,
+      c
+    ), h = Dt(
+      s.decoded.baseFill,
+      s.decoded.variants,
+      s.decoded.instances,
+      "fill",
+      s.meta.layer0_index ?? 0,
+      s.header.layers,
+      c
+    ), d = Dt(
+      s.decoded.baseDot,
+      s.decoded.variants,
+      s.decoded.instances,
+      "dot",
+      s.meta.layer0_index ?? 0,
+      s.header.layers,
+      c
+    );
+    return {
+      meta: s.meta,
+      line: it(u),
+      fill: it(h),
+      dot: it(d),
+      rawBytes: t.byteLength
+    };
+  }
+  const e = tn(t);
+  let o = e.dataOffset;
+  const a = lt(t, e.view, o, e.header.lineCount);
+  o = a.offset;
+  const r = lt(t, e.view, o, e.header.fillCount);
+  o = r.offset;
+  const i = lt(t, e.view, o, e.header.dotCount);
+  if (o = i.offset, o !== t.byteLength)
+    throw new l("E_GROUP_RANGE", `Trailing bytes detected: offset=${o}, size=${t.byteLength}`);
+  return {
+    meta: e.meta,
+    line: it(a.chunk),
+    fill: it(r.chunk),
+    dot: it(i.chunk),
+    rawBytes: t.byteLength
+  };
+}
+function Lo(t, n) {
+  return t ? fe(Bn(t, n)) : null;
+}
+export {
+  l as CadPackError,
+  l as GeoLoaderError,
+  Lt as STREAM_VERTEX_WINDOW,
+  Ne as assertStrictTextRoundtrip,
+  To as captureGroupSnapshot,
+  Yt as cloneViewportRect,
+  Ee as computeViewportRectFromPositions,
+  It as emptyGeometryChunk,
+  Be as expandGeometryChunkMetadata,
+  he as expandViewportRect,
+  et as getDxbsSection,
+  Wt as groupLayerEncodingForV3Minor,
+  _e as intersectViewportRects,
+  Ge as isDxbsPayload,
+  Ae as isStrictTextRoundtripEnabled,
+  dt as mergeAdjacentSegments,
+  me as mergeViewportRects,
+  ot as normalizeGeometrySegments,
+  fe as normalizeViewportRect,
+  Ht as offsetGeometrySegments,
+  Do as parseBinBounds,
+  Xo as parseBinPayload,
+  Go as parseBinStreaming,
+  vo as parseBinToChunks,
+  be as readBlockAnnotationSidecar,
+  Jt as readDxbsContainer,
+  Mo as readExternalAnnotationManifest,
+  Po as readExternalBlockAnnotations,
+  $o as readExternalVariantDependencyPlan,
+  uo as readExternalVariantGeometrySidecar,
+  Oo as readExternalVariantManifest,
+  lt as readGroup,
+  So as readSceneAnnotationSidecar,
+  Cn as remapGeometrySegmentLayers,
+  Uo as shouldAssertStrictTextRoundtrip,
+  Co as sliceGeometrySegments,
+  de as streamGroupChunks,
+  Lo as transformBBoxByInstance,
+  Bn as transformViewportRect,
+  ge as viewportRectCenterDistance,
+  bo as viewportRectContains,
+  xe as viewportRectDiagonal,
+  Bo as viewportRectEquals,
+  bn as viewportRectIntersects
+};