@nika-js/onlymap 0.6.0 → 0.6.2

package/dist/cityjson-D_V5GY8b.js

@@ -0,0 +1,332 @@
+import { C as F, a as q } from "./crs-Ciu7Xs7a.js";
+const j = 0.5;
+function G(e, t) {
+  if (!Array.isArray(e)) return [];
+  const n = t?.scale?.[0] ?? 1, o = t?.scale?.[1] ?? 1, s = t?.scale?.[2] ?? 1, a = t?.translate?.[0] ?? 0, i = t?.translate?.[1] ?? 0, f = t?.translate?.[2] ?? 0, r = new Array(e.length);
+  for (let c = 0; c < e.length; c++) {
+    const u = e[c];
+    r[c] = [u[0] * n + a, u[1] * o + i, (u[2] ?? 0) * s + f];
+  }
+  return r;
+}
+const T = {
+  MultiPoint: 1,
+  MultiLineString: 2,
+  MultiSurface: 3,
+  CompositeSurface: 3,
+  Solid: 4,
+  MultiSolid: 5,
+  CompositeSolid: 5
+};
+function J(e, t) {
+  let n = e;
+  for (let o = 0; o < t; o++) n = n.flat();
+  return n;
+}
+function N(e) {
+  const t = T[e.type ?? ""];
+  return !t || t < 3 || !Array.isArray(e.boundaries) ? [] : J(e.boundaries, t - 3);
+}
+function X(e, t) {
+  const n = new Array(t).fill(void 0), o = T[e.type ?? ""], s = e.semantics?.surfaces, a = e.semantics?.values;
+  if (!o || !Array.isArray(s) || !Array.isArray(a)) return n;
+  const i = J(a, o - 3);
+  for (let f = 0; f < t; f++) {
+    const r = i[f];
+    typeof r == "number" && (n[f] = s[r]?.type);
+  }
+  return n;
+}
+function _(e) {
+  const t = typeof e == "number" ? e : Number.parseFloat(String(e ?? ""));
+  return Number.isFinite(t) ? t : -1;
+}
+function K(e, t) {
+  if (!Array.isArray(e)) return;
+  const n = e.filter((o) => N(o).length > 0);
+  if (n.length !== 0) {
+    if (t !== void 0) {
+      const o = n.find((s) => _(s.lod) === t);
+      if (o) return o;
+    }
+    return n.reduce((o, s) => _(s.lod) > _(o.lod) ? s : o);
+  }
+}
+const Q = /EPSG.*?(\d{4,6})\D*$/i;
+function tt(e) {
+  if (!e) return;
+  const t = Number(Q.exec(e)?.[1]);
+  return Number.isFinite(t) ? t : void 0;
+}
+let P = !1;
+async function U(e, t) {
+  const n = { toLngLat: (r, c) => [r, c], projected: !1 }, o = tt(e);
+  if (o === void 0)
+    return P || (P = !0, console.warn(
+      `[onlymapjs] data="${t}": CityJSON has no metadata.referenceSystem — assuming coordinates are already WGS84 lon/lat. Add a referenceSystem to the file if they are not.`
+    )), n;
+  const s = q[o] ?? o, a = F[s];
+  if (!a)
+    throw new Error(
+      `CityJSON declares EPSG:${o}${s === o ? "" : ` (horizontal component EPSG:${s})`}, which is not one of the bundled coordinate systems (${Object.keys(F).join(", ")}). Reproject the file to EPSG:4326 server-side (cjio --reproject 4326), or claim the URL with OmMap.registerFormat() and supply your own projection.`
+    );
+  if (a.geographic)
+    return a.swapXY ? { toLngLat: (r, c) => [c, r], projected: !1 } : n;
+  const i = (await import("./index-CW1n5LdO.js")).default, f = i(a.def, "+proj=longlat +datum=WGS84 +no_defs");
+  return {
+    toLngLat: (r, c) => {
+      const [u, p] = f.forward(a.swapXY ? [c, r] : [r, c]);
+      return [u, p];
+    },
+    projected: !0
+  };
+}
+function I(e) {
+  let t = 0, n = 0, o = 0;
+  for (let s = 0; s < e.length; s++) {
+    const a = e[s], i = e[(s + 1) % e.length];
+    t += (a[1] - i[1]) * (a[2] + i[2]), n += (a[2] - i[2]) * (a[0] + i[0]), o += (a[0] - i[0]) * (a[1] + i[1]);
+  }
+  return Math.hypot(t, n, o) / 2;
+}
+function et(e) {
+  const t = e.slice().sort((o, s) => o - s), n = t.length >> 1;
+  return t.length % 2 ? t[n] : (t[n - 1] + t[n]) / 2;
+}
+function B(e, t, n, o, s) {
+  const a = K(t.geometry, s);
+  if (!a) return;
+  const i = N(a);
+  if (i.length === 0) return;
+  const f = X(a, i.length), r = i.map(
+    (d) => d.map((y) => y.map((l) => n[l]).filter((l) => l !== void 0))
+  );
+  let c = 1 / 0, u = -1 / 0;
+  for (const d of r)
+    for (const y of d)
+      for (const [, , l] of y)
+        l < c && (c = l), l > u && (u = l);
+  if (!Number.isFinite(c)) return;
+  const p = c, g = f.some((d) => d === "RoofSurface"), h = [];
+  let S = 1 / 0, m = -1 / 0;
+  for (let d = 0; d < r.length; d++)
+    if (!(g && f[d] !== "RoofSurface"))
+      for (const y of r[d])
+        for (const [, , l] of y)
+          (g || l > p + j) && (h.push(l), l < S && (S = l), l > m && (m = l));
+  h.length === 0 && (h.push(u), S = u, m = u);
+  let w = f.indexOf("GroundSurface");
+  if (w < 0) {
+    let d = -1;
+    for (let y = 0; y < r.length; y++) {
+      const l = r[y][0];
+      if (!l || l.length < 3) continue;
+      const b = l.every(([, , R]) => R <= p + j), C = I(l) * (b ? 1e3 : 1);
+      C > d && (d = C, w = y);
+    }
+  }
+  if (w < 0) return;
+  const O = r[w];
+  if (!O[0] || O[0].length < 3) return;
+  const [, k] = o.toLngLat(O[0][0][0], O[0][0][1]), z = 111320 * Math.cos(k * Math.PI / 180), Y = 110540, V = (d) => o.projected ? d : d.map(([y, l, b]) => {
+    const [C, R] = o.toLngLat(y, l);
+    return [C * z, R * Y, b];
+  });
+  let L = 0, E = 0;
+  for (let d = 0; d < r.length; d++) {
+    if (g && f[d] !== "RoofSurface") continue;
+    const y = r[d][0];
+    if (!y || y.length < 3) continue;
+    const l = I(V(y));
+    L += l, E += l * (y.reduce((b, [, , C]) => b + C, 0) / y.length);
+  }
+  const W = L > 0 ? E / L : et(h), H = {
+    cityobject_id: e,
+    cityobject_type: t.type ?? "Unknown",
+    ...t.parents?.[0] !== void 0 ? { parent_id: t.parents[0] } : {},
+    ...a.lod !== void 0 ? { lod: String(a.lod) } : {},
+    ground_height: v(p),
+    roof_height: v(W - p),
+    eaves_height: v(S - p),
+    ridge_height: v(m - p),
+    roof_area: v(L),
+    surface_count: i.length
+  };
+  return { faceRings: r, semantics: f, footprintIndex: w, derived: H };
+}
+function nt(e, t, n, o, s, a) {
+  const i = B(e, t, n, o, a);
+  if (!i) return;
+  const r = i.faceRings[i.footprintIndex].filter((c) => c.length >= 3).map((c) => {
+    const u = c.map(([p, g]) => o.toLngLat(p, g));
+    return u.push(u[0]), u;
+  });
+  return {
+    type: "Feature",
+    id: e,
+    geometry: { type: "Polygon", coordinates: r },
+    // Source attributes first: the derived names are the ones manifests bind
+    // to, so they must be deterministic even against a same-named source field.
+    properties: { ...s, ...t.attributes, ...i.derived }
+  };
+}
+const M = {
+  GroundSurface: "#999999",
+  WallSurface: "#ffffff",
+  RoofSurface: "#ff0000",
+  TrafficArea: "#6e6e6e",
+  AuxiliaryTrafficArea: "#2c8200",
+  Window: "#0059ff",
+  Door: "#640000"
+}, x = {
+  Building: "#7497df",
+  BuildingPart: "#7497df",
+  BuildingInstallation: "#7497df",
+  Bridge: "#999999",
+  BridgePart: "#999999",
+  BridgeInstallation: "#999999",
+  BridgeConstructiveElement: "#999999",
+  CityObjectGroup: "#ffffb3",
+  LandUse: "#ffffb3",
+  CityFurniture: "#cc0000",
+  GenericCityObject: "#cc0000",
+  PlantCover: "#39ac39",
+  SolitaryVegetationObject: "#39ac39",
+  Railway: "#000000",
+  Road: "#999999",
+  TransportSquare: "#999999",
+  TINRelief: "#ffdb99",
+  Tunnel: "#999999",
+  TunnelPart: "#999999",
+  TunnelInstallation: "#999999",
+  WaterBody: "#4da6ff"
+}, ot = "#b0b0b0";
+function rt(e, t) {
+  return e && M[e] ? M[e] : t && x[t] ? x[t] : ot;
+}
+function it(e, t, n, o, s, a) {
+  const i = B(e, t, n, o, a);
+  if (!i) return [];
+  const f = [];
+  for (let r = 0; r < i.faceRings.length; r++) {
+    const c = i.faceRings[r], u = c[0];
+    if (!u || u.length < 3) continue;
+    const p = c.filter((h) => h.length >= 3).map((h) => h.map(([S, m, w]) => [...o.toLngLat(S, m), w])), g = p[0];
+    f.push({
+      ...s,
+      ...t.attributes,
+      ...i.derived,
+      surface_type: i.semantics[r],
+      fill_color: rt(i.semantics[r], t.type),
+      polygon: p,
+      outline: [...g, g[0]]
+    });
+  }
+  return f;
+}
+function v(e) {
+  return Number.isFinite(e) ? Math.round(e * 1e3) / 1e3 : 0;
+}
+function D(e, t, n, o, s = "footprint") {
+  if (!e) return [];
+  const a = (f) => Array.isArray(f.children) && f.children.some((r) => {
+    const c = e[r];
+    return c?.type === `${f.type}Part` && (c.geometry?.some((u) => N(u).length > 0) ?? !1);
+  }), i = [];
+  for (const [f, r] of Object.entries(e)) {
+    if (!r || typeof r != "object" || a(r)) continue;
+    const u = (r.parents?.[0] ? e[r.parents[0]] : void 0)?.attributes ?? {};
+    if (s === "surfaces")
+      i.push(...it(f, r, t, n, u, o));
+    else {
+      const p = nt(f, r, t, n, u, o);
+      p && i.push(p);
+    }
+  }
+  return i;
+}
+function A(e, t, n) {
+  if (e?.type !== n)
+    throw new Error(
+      `expected a ${n} object but found type="${e?.type ?? "undefined"}" — this does not look like CityJSON. If it is a different newline-delimited format, claim the URL with OmMap.registerFormat().`
+    );
+}
+function $(e) {
+  const t = /[?&]om-lod=([^&#]+)/.exec(e)?.[1];
+  if (t === void 0) return;
+  const n = Number.parseFloat(decodeURIComponent(t));
+  if (!Number.isFinite(n)) {
+    console.warn(`[onlymapjs] om-lod="${t}" is not a number — ignoring and using the highest available LoD.`);
+    return;
+  }
+  return n;
+}
+function Z(e) {
+  const t = /[?&]om-surfaces=([^&#]+)/.exec(e)?.[1];
+  if (t === void 0) return !1;
+  const n = decodeURIComponent(t).toLowerCase();
+  return n === "1" || n === "true";
+}
+async function ut(e, t) {
+  const n = await e.json();
+  A(n, t, "CityJSON");
+  const o = await U(n.metadata?.referenceSystem, t), s = G(n.vertices, n.transform), a = Z(t) ? "surfaces" : "footprint";
+  return D(n.CityObjects, s, o, $(t), a);
+}
+const st = 250, at = 512;
+async function* ct(e) {
+  if (!e.body) {
+    for (const s of (await e.text()).split(`
+`)) yield s;
+    return;
+  }
+  const t = e.body.getReader(), n = new TextDecoder();
+  let o = "";
+  for (; ; ) {
+    const { done: s, value: a } = await t.read();
+    if (s) break;
+    o += n.decode(a, { stream: !0 });
+    let i;
+    for (; (i = o.indexOf(`
+`)) >= 0; )
+      yield o.slice(0, i), o = o.slice(i + 1);
+  }
+  o += n.decode(), o.length > 0 && (yield o);
+}
+async function lt(e, t, n) {
+  const o = $(t), s = Z(t) ? "surfaces" : "footprint";
+  let a, i, f = !1;
+  const r = [];
+  let c = 0, u = 0;
+  for await (const p of ct(e)) {
+    const g = p.trim();
+    if (g.length === 0) continue;
+    const h = JSON.parse(g);
+    if (f)
+      A(h, t, "CityJSONFeature");
+    else if (A(h, t, "CityJSON"), i = h.transform, a = await U(h.metadata?.referenceSystem, t), f = !0, h.CityObjects && Object.keys(h.CityObjects).length === 0) continue;
+    const S = G(h.vertices, i);
+    r.push(...D(h.CityObjects, S, a, o, s)), c++;
+    const m = performance.now();
+    (c >= at || m - u >= st) && (c = 0, u = m, n(r.slice()));
+  }
+  if (!f)
+    throw new Error(
+      'CityJSONSeq file is empty or has no header line — the first line must be a CityJSON object carrying "transform" and "metadata", followed by one CityJSONFeature per line.'
+    );
+  return r;
+}
+export {
+  K as chooseGeometry,
+  D as decodeCityObjects,
+  G as decompressVertices,
+  rt as defaultFillColor,
+  X as faceSemantics,
+  N as flattenToFaces,
+  ut as parseCityJsonDocument,
+  lt as parseCityJsonSeq,
+  tt as parseEpsgCode,
+  $ as parseLodPin,
+  Z as parseSurfacesFlag,
+  U as resolveCrs
+};

package/dist/clip-box-controller.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Clip box controller (spec: issue #34 §"Cutting / Clipping" — visible,
+ * draggable box). `clip-box.ts` owns the pure shader/patch math; this file
+ * owns the DOM-touching half: a wireframe box + 6 face-handle gizmos so the
+ * box is something you can SEE and GRAB, not just type numbers into. Same
+ * architecture as `measure-controller.ts`'s volume-mode height gizmo (real
+ * `<om-layer>` elements driven by `core.patchAnimatedProps` on the per-frame
+ * channel) — generalized from that gizmo's one hardcoded vertical axis to 6
+ * axis-constrained handles (one per box face), since a face can move along
+ * lng, lat, OR elevation depending on which one it is.
+ *
+ * Owned per `<om-map>` (the draw/measure precedent) and kept alive for as
+ * long as a clip box is configured, independent of whether the `clip-box`
+ * widget is even mounted — set clip-box-min/max programmatically and the
+ * wireframe still shows up, the same way the box itself still clips content
+ * with no widget present.
+ */
+import type { PickingInfo } from "@deck.gl/core";
+import type { RuntimeCore, GizmoDragEvent } from "./runtime-core";
+export declare class ClipBoxController {
+    private readonly mapEl;
+    private readonly core;
+    private grab;
+    /**
+     * Whether the visual box + drag handles are showing. OFF by default and
+     * OFF whenever a drag/hover isn't in progress — the box's CLIPPING effect
+     * is entirely independent of this (that's driven straight off the
+     * clip-box-min/max attributes, always active once set). This is purely
+     * about the interactive gizmo: reported that its handles — always
+     * pickable once rendered, several of them sitting right around screen
+     * center where a normal pan gesture naturally starts — were hijacking
+     * ordinary map panning. Gating them behind an explicit "Edit box" toggle
+     * (see the clip-box-edit action) means panning is never at risk, and the
+     * gizmo only exists on screen when someone actually asked to adjust it.
+     */
+    private editing;
+    constructor(mapEl: Element, core: RuntimeCore);
+    setEditing(active: boolean): void;
+    isEditing(): boolean;
+    /** Re-reads the current box from `core` and repaints the wireframe + handles — call after ANY change, drag or attribute. */
+    syncVisuals(): void;
+    /**
+     * Repaints the wireframe + handles for a GIVEN box — factored out of
+     * `syncVisuals()` so `handleGizmoDrag` can drive this every mousemove
+     * frame from its own LOCAL `grab.liveBox` without going anywhere near
+     * `core.setClipBox`/DOM attributes (see that method's own doc comment).
+     * `patchAnimatedProps` alone is cheap and frame-rate-safe; this is the
+     * same reason `measure-controller.ts`'s volume gizmo redraws through
+     * `patchAnimatedProps` on every drag frame instead of writing anything
+     * to the DOM until the gesture actually ends.
+     */
+    private renderBox;
+    /**
+     * Grab a face handle. Computes a LOCAL screen-space drag basis for this
+     * handle's axis by projecting a known small step (`AXIS_EPSILON`) along
+     * it — the same linearization trick `measure-controller.ts`'s height
+     * gizmo uses for its one hardcoded vertical axis, generalized to a full
+     * 2D screen vector so it's correct for lng/lat faces too (which project
+     * to some diagonal screen direction depending on the camera's bearing/
+     * pitch, not a pure vertical like elevation).
+     */
+    handleGizmoDragStart(info: PickingInfo, event: GizmoDragEvent): void;
+    /**
+     * Every mousemove during a drag updates ONLY `grab.liveBox` and repaints
+     * the gizmo via `renderBox` (the cheap `patchAnimatedProps` channel) —
+     * it does NOT write clip-box-min/max attributes or call
+     * `core.setClipBox` per frame. Those go through `RuntimeCore.applyLayers`,
+     * which rebuilds the ENTIRE layer list (every layer, not just this box) —
+     * fine for an occasional attribute change, but firing it on every one of
+     * a mousemove's ~60 frames/sec froze the whole map (reported: "dragging
+     * the gizmos ... the whole map just hangs"). The real content stays
+     * clipped to the box's PRE-drag position for the gesture's duration and
+     * catches up in ONE `applyLayers` pass at `handleGizmoDragEnd` — the same
+     * "cheap live preview, expensive commit once at the end" split the proven
+     * volume-measurement gizmo already uses (it never touches the DOM mid-
+     * drag either).
+     */
+    handleGizmoDrag(info: PickingInfo): void;
+    /**
+     * The ONE expensive commit for the whole gesture: write the final
+     * min/max to the authored attributes — same channel the widget's own
+     * number inputs use, so the drag is undoable (history.ts's 500ms
+     * coalesce window merges it with any other same-attribute writes into a
+     * single step) and reflects live in the widget. The map's own
+     * MutationObserver picks this up and calls core.setClipBox, which
+     * re-applies the ACTUAL clip to real layers and (via that same observer
+     * hook) resyncs this controller's own gizmo from the now-authoritative
+     * state.
+     */
+    handleGizmoDragEnd(): void;
+    private ensureLayers;
+}
+export declare function getClipBoxController(mapEl: Element, core: RuntimeCore): ClipBoxController;
+export declare function peekClipBoxController(mapEl: Element): ClipBoxController | undefined;

package/dist/clip-box.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Clip box (spec: issue #34 §"Cutting / Clipping", tier 2 — the geometric
+ * complement to issue #26's clip PLANE). A real oriented... well, AXIS-
+ * ALIGNED (v1 scope, confirmed explicitly — rotation is a documented
+ * follow-up, not this) 3D box: geometry outside it is discarded (or, in
+ * `highlight` mode, dimmed rather than removed — "non-destructive"), so a
+ * dense scene (a BIM model, a point cloud, a city block) can be cut open to
+ * see what's inside.
+ *
+ * Map-level scene state (spec: `<om-map clip-box-min="..." clip-box-max="..."
+ * clip-box-invert clip-box-highlight>`), same architecture as `lighting`/
+ * `terrain`: attribute-backed, undoable, live-editable, applied to every
+ * layer by default with a per-layer `clip="off"` escape hatch — see
+ * `applyClipBox`'s own doc comment for why that default (not opt-in) is
+ * the right one here specifically.
+ *
+ * Three corrections from the original design review, all reflected below:
+ * 1. "Outside the box" is `!inside` (De Morgan's law on the AND of 6
+ *    half-spaces) — NOT a literal OR of 6 flipped half-space tests, which
+ *    would (incorrectly) require re-deriving 6 new inequalities; negating
+ *    the single boolean `inside` result is simpler and exactly equivalent.
+ * 2. Plane/box bounds are expressed in deck's COMMON SPACE (via
+ *    `Layer#projectPosition`, the SAME mechanism the built-in `ClipExtension`
+ *    uses for its own 2D bounds) — never raw lng/lat — so one authored box
+ *    clips layers in different coordinate systems (geographic, meter-offset
+ *    BIM placements, etc.) correctly.
+ * 3. Picking (including the `pickable:'3d'` depth pass) is covered for
+ *    free: `discard` inside `fs:DECKGL_FILTER_COLOR` is the SAME shader
+ *    stage deck's own picking pass reuses — no separate picking-specific
+ *    code needed, confirmed by the built-in `ClipExtension` doing nothing
+ *    extra for picking either.
+ */
+import { LayerExtension } from "@deck.gl/core";
+import type { Layer } from "@deck.gl/core";
+import type { LayerIR } from "./ir";
+export interface ClipBoxIR {
+    /** [lng, lat, elevationMeters] — one corner. Order vs. `max` doesn't matter; both get componentwise min/max'd after projecting. */
+    min: [number, number, number];
+    max: [number, number, number];
+    /** Show OUTSIDE the box instead of inside. */
+    invert: boolean;
+    /** Dim clipped-out geometry instead of discarding it — "non-destructive": nothing disappears, it just de-emphasizes. */
+    highlight: boolean;
+}
+/** `<om-map clip-box-min="[...]" clip-box-max="[...]" clip-box-invert clip-box-highlight>` → `ClipBoxIR`, or `null` when min/max aren't both present/valid (no box = no clipping, not a broken one). */
+export declare function parseClipBoxAttrs(getAttr: (name: string) => string | null): ClipBoxIR | null;
+export interface ClipBoxExtensionProps {
+    clipBoxMin?: [number, number, number];
+    clipBoxMax?: [number, number, number];
+    clipBoxInvert?: boolean;
+    clipBoxHighlight?: boolean;
+}
+/** Fragment-level box clip (targets extruded/mesh geometry — GeoJsonLayer extrusions, Tile3DLayer/BIMLayer triangles — not point/icon anchors, unlike the built-in ClipExtension's dual vertex/fragment modes; this library's clip-box use case is "cut into a 3D scene," not "hide points outside a rect"). */
+export declare class ClipBoxExtension extends LayerExtension {
+    static extensionName: string;
+    static defaultProps: {
+        clipBoxMin: number[];
+        clipBoxMax: number[];
+        clipBoxInvert: boolean;
+        clipBoxHighlight: boolean;
+    };
+    getShaders(): {
+        modules: {
+            readonly name: "clipBox";
+            readonly fs: "\nlayout(std140) uniform clipBoxUniforms {\n  vec3 boxMin;\n  vec3 boxMax;\n  float invert;\n  float highlight;\n  vec4 highlightTint;\n} clipBox;\n\nbool clipBox_isInside(vec3 commonPos) {\n  return commonPos.x >= clipBox.boxMin.x && commonPos.x <= clipBox.boxMax.x\n      && commonPos.y >= clipBox.boxMin.y && commonPos.y <= clipBox.boxMax.y\n      && commonPos.z >= clipBox.boxMin.z && commonPos.z <= clipBox.boxMax.z;\n}\n";
+            readonly uniformTypes: {
+                readonly boxMin: "vec3<f32>";
+                readonly boxMax: "vec3<f32>";
+                readonly invert: "f32";
+                readonly highlight: "f32";
+                readonly highlightTint: "vec4<f32>";
+            };
+        }[];
+        inject: {
+            "vs:#decl": string;
+            "vs:DECKGL_FILTER_GL_POSITION": string;
+            "fs:#decl": string;
+            "fs:DECKGL_FILTER_COLOR": string;
+        };
+    };
+    draw(this: Layer<Required<ClipBoxExtensionProps>>): void;
+}
+export interface ClipBoxLayerPatch {
+    /**
+     * The deck-layer id to construct with. Suffixed `#c<generation>` while a
+     * box is active and this layer is opted in: adding/removing an extension
+     * on a LIVE (already-mounted) layer corrupts DataFilterExtension's
+     * attribute state for some layer types (ColumnLayer, Tile3DLayer/BIMLayer
+     * sublayers — empirically verified: a box present from the FIRST render
+     * works fine, but toggling one on live on an already-mounted filtered
+     * layer silently blanks it, with no console error) — the exact same
+     * "birth-stable extension set" issue `applyTerrain`'s own `deckId`
+     * suffixing already works around. A fresh id forces clean teardown +
+     * rebuild instead of a live prop update.
+     */
+    deckId: string;
+    extraProps: Record<string, unknown>;
+}
+/**
+ * Per-layer clip-box patches, PURE — mirrors `applyTerrain`'s exact shape
+ * (same file this gets merged alongside in runtime-core.ts's `buildLayers`).
+ * Default is APPLIED (every layer gets clipped once a box is configured),
+ * unlike terrain's per-layer OPT-IN default — the clip box's whole point is
+ * cutting into "the scene," and requiring every single layer to opt in
+ * individually would make the common case ("cut through everything, show me
+ * what's inside") the awkward one; `clip="off"` is the escape hatch for the
+ * layers that shouldn't be touched (a basemap, most often).
+ */
+export declare function applyClipBox(irs: readonly LayerIR[], clipBox: ClipBoxIR | null, generation: number): Map<string, ClipBoxLayerPatch>;

package/dist/crs-Ciu7Xs7a.js

@@ -0,0 +1,108 @@
+const c = {
+  7415: 28992,
+  // Amersfoort / RD New + NAP height — the 3DBAG default
+  6697: 6668,
+  // JGD2011 geographic 3D + height — the PLATEAU default
+  5555: 25832,
+  // ETRS89 / UTM 32N + DHHN92 height
+  5556: 25833
+  // ETRS89 / UTM 33N + DHHN92 height
+}, f = [
+  [33, 129.5],
+  [33, 131],
+  [36, 132.166666666667],
+  [33, 133.5],
+  [36, 134.333333333333],
+  [36, 136],
+  [36, 137.166666666667],
+  [36, 138.5],
+  [36, 139.833333333333],
+  [40, 140.833333333333],
+  [44, 140.25],
+  [44, 142.25],
+  [44, 144.25],
+  [26, 142],
+  [26, 127.5],
+  [26, 124],
+  [26, 131],
+  [20, 136],
+  [26, 154]
+], u = {
+  // Netherlands — Amersfoort / RD New (3DBAG).
+  28992: {
+    def: "+proj=sterea +lat_0=52.1561605555556 +lon_0=5.38763888888889 +k=0.9999079 +x_0=155000 +y_0=463000 +ellps=bessel +towgs84=565.4171,50.3319,465.5524,-0.398957,0.343988,-1.8774,4.0725 +units=m +no_defs"
+  },
+  // Switzerland — CH1903+ / LV95.
+  2056: {
+    def: "+proj=somerc +lat_0=46.9524055555556 +lon_0=7.43958333333333 +k_0=1 +x_0=2600000 +y_0=1200000 +ellps=bessel +towgs84=674.374,15.056,405.346,0,0,0,0 +units=m +no_defs"
+  },
+  // Germany — ETRS89 / UTM zones 32N and 33N.
+  25832: { def: "+proj=utm +zone=32 +ellps=GRS80 +units=m +no_defs" },
+  25833: { def: "+proj=utm +zone=33 +ellps=GRS80 +units=m +no_defs" },
+  // Plain WGS84 UTM zones 32N/33N (EPSG:326xx) — the generic, non-European-specific
+  // code many CityJSON files declare instead of the ETRS89 pair above (e.g.
+  // Ingolstadt's own open-data LoD3 export). Numerically near-identical to
+  // 25832/25833 at map-rendering precision (WGS84 vs. ETRS89 differ by ~cm in
+  // Europe), so no +towgs84 shift is needed — same bare projection string.
+  32632: { def: "+proj=utm +zone=32 +datum=WGS84 +units=m +no_defs" },
+  32633: { def: "+proj=utm +zone=33 +datum=WGS84 +units=m +no_defs" },
+  // Austria — MGI / Austria GK West/Central/East (the national cadastral
+  // system's three meridian-strip zones; Vienna sits in GK East). Same
+  // Bessel ellipsoid + towgs84 shift and y_0=-5,000,000 false-northing
+  // convention across all three — proj4 strings verified against epsg.io,
+  // not hand-derived, and cross-checked by reprojecting a real Vienna
+  // open-data file's own extent and confirming it lands in Vienna.
+  31254: { def: "+proj=tmerc +lat_0=0 +lon_0=10.3333333333333 +k=1 +x_0=0 +y_0=-5000000 +ellps=bessel +towgs84=577.326,90.129,463.919,5.137,1.474,5.297,2.4232 +units=m +no_defs" },
+  31255: { def: "+proj=tmerc +lat_0=0 +lon_0=13.3333333333333 +k=1 +x_0=0 +y_0=-5000000 +ellps=bessel +towgs84=577.326,90.129,463.919,5.137,1.474,5.297,2.4232 +units=m +no_defs" },
+  31256: { def: "+proj=tmerc +lat_0=0 +lon_0=16.3333333333333 +k=1 +x_0=0 +y_0=-5000000 +ellps=bessel +towgs84=577.326,90.129,463.919,5.137,1.474,5.297,2.4232 +units=m +no_defs" },
+  // Singapore — SVY21 / Singapore TM (the national grid; NUS's own Singapore
+  // HDB buildings dataset declares this via metadata.referenceSystem
+  // directly, unlike the Austria/3DBAG files, which had none). proj4 string
+  // verified against epsg.io, cross-checked by reprojecting a real dataset's
+  // own extent and confirming it lands in Singapore (103.68-103.99°E,
+  // 1.27-1.46°N — matches).
+  3414: { def: "+proj=tmerc +lat_0=1.36666666666667 +lon_0=103.833333333333 +k=1 +x_0=28001.642 +y_0=38744.572 +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs" },
+  // Japan — JGD2011 geographic 2D. EPSG axis order is (lat, lon).
+  6668: { def: "+proj=longlat +ellps=GRS80 +no_defs", geographic: !0, swapXY: !0 },
+  // WGS 84. Files in the wild store lon/lat despite EPSG's formal (lat, lon).
+  4326: { def: "+proj=longlat +datum=WGS84 +no_defs", geographic: !0 },
+  3857: { def: "+proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +no_defs" }
+};
+for (let t = 0; t < f.length; t++) {
+  const [e, o] = f[t];
+  u[6669 + t] = {
+    def: `+proj=tmerc +lat_0=${e} +lon_0=${o} +k=0.9999 +x_0=0 +y_0=0 +ellps=GRS80 +units=m +no_defs`,
+    swapXY: !0
+  };
+}
+let p = null;
+async function m() {
+  return (await import("./index-CW1n5LdO.js")).default;
+}
+function g() {
+  return p ??= m(), p;
+}
+function j() {
+  return Object.keys(u).map(Number).sort((t, e) => t - e);
+}
+async function i(t, e, o) {
+  const a = c[t] ?? t, n = u[a];
+  if (!n) return null;
+  const [s, l] = n.swapXY ? [o, e] : [e, o];
+  if (n.geographic) return [s, l];
+  const _ = await g(), [r, d] = _(n.def, "+proj=longlat +datum=WGS84 +no_defs").forward([s, l]);
+  return Number.isFinite(r) && Number.isFinite(d) ? [r, d] : null;
+}
+async function w(t, e, o, a = 100) {
+  const n = await i(t, e, o), s = await i(t, e, o + a);
+  if (!n || !s) return null;
+  const l = (n[1] + s[1]) / 2 * Math.PI / 180, _ = (s[0] - n[0]) * Math.cos(l), r = s[1] - n[1];
+  return Math.atan2(_, r) * 180 / Math.PI;
+}
+export {
+  u as C,
+  c as a,
+  j as b,
+  w as g,
+  i as p
+};