@eyeon/map 2.0.1 → 2.0.2

package/dist/core/import/svgTransform.d.ts

@@ -0,0 +1,49 @@
+import { Vec2 } from '../types';
+/**
+ * 2D affine matrix in SVG order:
+ *
+ * ```
+ * | a c e |
+ * | b d f |
+ * | 0 0 1 |
+ * ```
+ */
+export interface Matrix2D {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+export declare const IDENTITY_MATRIX: Matrix2D;
+/**
+ * Matrix product `outer × inner`: the returned matrix applies `inner` first,
+ * then `outer`. SVG composes `transform="A B"` the same way — the rightmost
+ * transform is applied to the geometry first, and an ancestor `<g>` transform
+ * is the outer one relative to its descendants.
+ */
+export declare function multiplyMatrix(outer: Matrix2D, inner: Matrix2D): Matrix2D;
+export declare function applyMatrix(m: Matrix2D, p: Vec2): Vec2;
+export declare function isIdentityMatrix(m: Matrix2D, epsilon?: number): boolean;
+/**
+ * Parse an SVG `transform` attribute into a single affine matrix.
+ * Unknown functions are skipped. Returns identity for empty / unparseable input.
+ */
+export declare function parseTransform(raw: string | null | undefined): Matrix2D;
+/**
+ * Bake an affine matrix into a path `d` string, emitting absolute commands.
+ *
+ * Flattening a bezier commutes with an affine map (control points transform
+ * independently, sampling parameters do not change), so
+ * `pathToPolygons(transformPathD(d, m))` equals `pathToPolygons(d)` mapped
+ * through `m`. That is what keeps `geometry.paths[].d` and `geometry.polygons`
+ * in the same coordinate space.
+ *
+ * Arcs commute exactly under a similarity (translate / rotate / uniform scale /
+ * mirror), which covers Illustrator output. A shear or non-uniform scale maps
+ * the same curve but reparameterises it, so individual sample points may shift
+ * along the outline even though the outline itself is right.
+ */
+export declare function transformPathD(d: string, m: Matrix2D): string;
+//# sourceMappingURL=svgTransform.d.ts.map

package/dist/core/import/svgTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svgTransform.d.ts","sourceRoot":"","sources":["../../../src/core/import/svgTransform.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGrC;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,eAAO,MAAM,eAAe,EAAE,QAAiD,CAAC;AAEhF;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,QAAQ,CASzE;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAKtD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,SAAO,GAAG,OAAO,CASrE;AAmDD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,QAAQ,CAmBvE;AA+CD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CA8J7D"}

package/dist/core/index.d.ts

@@ -1,7 +1,10 @@
 export * from './types';
+export * from './hostChrome';
+export * from './layerStyles';
 export * from './geometry';
 export * from './import';
 export * from './routing/graph-tools';
 export * from './routing/pathfinding';
 export * from './publish';
+export * from './stacking';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}

package/dist/core/index.js

@@ -1,282 +1,223 @@
-import { b as w, g as I, c as y, e as S, f as E } from "../chunks/pathfinding.js";
-import { D as K, F as U, I as z, h as B, i as W, j as G, k as V, l as H, m as j, d as X, o as Z, q as Y, r as q, s as Q, n as J, a as ee, t as ne, p as ie, u as se, v as te } from "../chunks/pathfinding.js";
-import { a as re, b as ae, f as ce, i as de, u as le, w as pe } from "../chunks/graph-tools.js";
-const P = [
-  { prefix: "walkable", kind: "walkable" },
-  { prefix: "void", kind: "void" },
-  { prefix: "unit", kind: "unit" },
-  { prefix: "store", kind: "unit" },
-  // v1 compatibility
-  { prefix: "wall", kind: "wall" },
-  { prefix: "boundary", kind: "boundary" },
-  { prefix: "outer-wall", kind: "wall" },
-  { prefix: "amenity-", kind: "amenity" },
-  { prefix: "kiosk-", kind: "kiosk_screen" },
-  { prefix: "escalator-", kind: "connector" },
-  { prefix: "elevator-", kind: "connector" },
-  { prefix: "stairs-", kind: "connector" },
-  { prefix: "entrance-", kind: "entrance" },
-  { prefix: "zone-", kind: "zone" },
-  { prefix: "label-", kind: "label" },
-  { prefix: "floorplate", kind: "floorplate" },
-  { prefix: "base", kind: "floorplate" },
-  { prefix: "decor", kind: "decor" },
-  { prefix: "special-shape", kind: "decor" },
-  { prefix: "overlay", kind: "decor" }
-], $ = [
-  { prefix: "parking-zone", kind: "parking_zone" },
-  { prefix: "parking-lane", kind: "parking_zone" },
-  { prefix: "parking-line", kind: "decor" },
-  { prefix: "parking-icon", kind: "parking_icon" },
-  { prefix: "green-area", kind: "green_area" },
-  { prefix: "water", kind: "water" },
-  { prefix: "decor", kind: "decor" },
-  { prefix: "entrance-", kind: "entrance" },
-  { prefix: "unit", kind: "unit" },
-  { prefix: "store", kind: "unit" },
-  { prefix: "interactive-", kind: "unit" },
-  { prefix: "walkable", kind: "walkable" },
-  { prefix: "amenity-", kind: "amenity" }
-], A = "route-path";
-function L(n, t = "floor") {
-  const o = n.toLowerCase(), a = t === "base" ? $ : P;
-  for (const { prefix: l, kind: p } of a)
-    if (o === l || o.startsWith(l))
-      return { kind: p, guessed: !1 };
-  return o.startsWith("interactive") ? { kind: "unit", guessed: !0 } : { kind: null, guessed: !1 };
-}
-function v(n) {
-  const t = n.trim().split(/[\s,]+/).map(Number);
-  if (t.length < 4) return "";
-  let o = `M ${t[0]} ${t[1]}`;
-  for (let a = 2; a < t.length; a += 2)
-    o += ` L ${t[a]} ${t[a + 1]}`;
-  return o += " Z", o;
-}
-function _(n, t, o, a) {
-  return `M ${n} ${t} L ${o} ${a}`;
-}
-function C(n) {
-  const t = n.match(/viewBox\s*=\s*["']([^"']+)["']/i), o = y(t == null ? void 0 : t[1]), a = [], l = [], p = /<(path|polygon|polyline|line|rect|g)\b([^>]*)(?:\/>|>([\s\S]*?)<\/\1>)/gi;
-  let i;
-  for (; (i = p.exec(n)) !== null; ) {
-    const e = i[1].toLowerCase(), c = i[2] ?? "", k = c.match(/\bid\s*=\s*["']([^"']+)["']/i);
-    if (!k) continue;
-    const f = k[1], g = /\bdata-interactive\s*=\s*["']?(true|1|yes)/i.test(c);
-    if (f.toLowerCase().startsWith(A)) {
-      const s = c.match(/\bd\s*=\s*["']([^"']+)["']/i);
-      s && l.push(s[1]);
-      const r = c.match(/\bpoints\s*=\s*["']([^"']+)["']/i);
-      r && l.push(v(r[1]).replace(/ Z$/, ""));
+import { D as g, n as L, d as A, p as S, a as T } from "../chunks/stacking.js";
+import { b as F, F as O, I as R, c as N, e as B, f as $, S as G, g as Y, h as H, j as V, k as j, l as K, o as U, q as W, r as X, s as z, t as Q, u as q, w as J, x as Z, y as ee, z as ne, A as te, B as oe, C as se, E as ae, G as ie, H as re, J as de, K as ce, L as le, M as fe, N as ue, O as he, P as pe, Q as me, R as Ie, i as ye, T as xe, U as ge, V as Ae, m as Se, W as ve, X as Le, Y as Te, Z as we, _ as Ee, $ as be, a0 as Me, a1 as Pe, a2 as ke, a3 as De, a4 as _e, a5 as Ce, a6 as Fe, a7 as Oe, a8 as Re, a9 as Ne, aa as Be, ab as $e, ac as Ge, ad as Ye, v as He, ae as Ve } from "../chunks/stacking.js";
+function E(a, f, i, r = g) {
+  const e = a.filter((n) => i.includes(n.id));
+  if (e.length < 2) return null;
+  const t = e.reduce((n, c) => c.id < n.id ? c : n), o = [];
+  for (const n of e)
+    n.id !== t.id && A(n, t) <= r && o.push(n.id);
+  if (o.length === 0) return null;
+  const d = new Set(o), h = [];
+  for (const n of f) {
+    let c = !1;
+    if (d.has(n.fromAnchorId) && (n.fromAnchorId = t.id, c = !0), d.has(n.toAnchorId) && (n.toAnchorId = t.id, c = !0), n.fromAnchorId === n.toAnchorId) {
+      h.push(n.id);
       continue;
     }
-    const d = { id: f, tag: e, interactive: g };
-    if (e === "path") {
-      const s = c.match(/\bd\s*=\s*["']([^"']+)["']/i);
-      s && (d.d = s[1]);
-    } else if (e === "polygon" || e === "polyline") {
-      const s = c.match(/\bpoints\s*=\s*["']([^"']+)["']/i);
-      s && (d.d = v(s[1]));
-    } else if (e === "line") {
-      const s = (r) => {
-        const u = c.match(new RegExp(`\\b${r}\\s*=\\s*["']?(-?[\\d.]+)`, "i"));
-        return u ? Number(u[1]) : 0;
-      };
-      d.d = _(s("x1"), s("y1"), s("x2"), s("y2"));
-    } else if (e === "rect") {
-      const s = (b) => {
-        const m = c.match(new RegExp(`\\b${b}\\s*=\\s*["']?(-?[\\d.]+)`, "i"));
-        return m ? Number(m[1]) : 0;
-      }, r = s("x"), u = s("y"), h = s("width"), x = s("height");
-      d.d = `M ${r} ${u} L ${r + h} ${u} L ${r + h} ${u + x} L ${r} ${u + x} Z`;
-    } else if (e === "g") {
-      const s = i[3] ?? "", r = [], u = /<(path|polygon|polyline|line|rect)\b([^>]*)\/?>/gi;
-      let h;
-      for (; (h = u.exec(s)) !== null; ) {
-        const x = h[1].toLowerCase(), b = h[2] ?? "";
-        if (x === "path") {
-          const m = b.match(/\bd\s*=\s*["']([^"']+)["']/i);
-          m && r.push(m[1]);
-        } else if (x === "polygon" || x === "polyline") {
-          const m = b.match(/\bpoints\s*=\s*["']([^"']+)["']/i);
-          m && r.push(v(m[1]));
-        }
-      }
-      r.length > 0 && (d.d = r.join(" "));
-    }
-    (d.d || e === "g") && a.push(d);
+    c && h.push(n.id);
   }
-  return { viewbox: o, elements: a, routePathDs: l };
-}
-function N(n) {
-  return n.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+  return {
+    survivingAnchorId: t.id,
+    removedAnchorIds: o,
+    rewiredEdgeIds: h
+  };
 }
-function O(n, t = "floor") {
-  const o = C(n), a = [], l = [], p = [], i = [], e = [];
-  let c = 0, k = 0, f = 0;
-  for (const g of o.elements) {
-    let { kind: d, guessed: s } = L(g.id, t);
-    g.interactive && !d && (d = "unit", s = !0);
-    const r = {
-      sourceSvgId: g.id,
-      kind: d,
-      guessed: s
-    };
-    if (!d) {
-      l.push(g.id), r.message = "No matching prefix; skipped", a.push(r);
-      continue;
-    }
-    if (!g.d) {
-      i.push(`Element ${g.id} has no drawable geometry`);
-      continue;
-    }
-    s && (p.push(r), r.message = "Guessed kind from interactive/fallback rule"), a.push(r), d === "walkable" && c++, d === "void" && k++, d === "unit" && f++;
-    const u = w([g.d], o.viewbox, !0), h = I(u);
-    e.push({
-      key: N(g.id),
-      kind: d,
-      geometry: u,
-      bbox: h,
-      sourceSvgId: g.id,
-      style: {}
-    });
+function b(a, f = g) {
+  const i = [], r = /* @__PURE__ */ new Set();
+  for (let e = 0; e < a.length; e++) {
+    if (r.has(a[e].id)) continue;
+    const t = [a[e].id];
+    for (let o = e + 1; o < a.length; o++)
+      r.has(a[o].id) || a[e].levelId === a[o].levelId && A(a[e], a[o]) <= f && (t.push(a[o].id), r.add(a[o].id));
+    t.length > 1 && (r.add(a[e].id), i.push(t));
   }
-  return t === "floor" && c === 0 && i.push(
-    "No walkable layer found — auto-skeleton will be unavailable for this level"
-  ), {
-    report: {
-      classified: a,
-      unrecognized: l,
-      guessed: p,
-      walkableCount: c,
-      voidCount: k,
-      unitCount: f,
-      warnings: i
-    },
-    shapes: e,
-    viewbox: o.viewbox,
-    routePathDs: o.routePathDs
-  };
+  return i;
 }
-function T(n, t, o) {
-  const a = new Map(
-    t.filter((i) => i.sourceSvgId).map((i) => [i.sourceSvgId, i])
-  ), l = /* @__PURE__ */ new Set(), p = [];
-  for (const i of n) {
-    const e = a.get(i.sourceSvgId);
-    l.add(i.sourceSvgId), e ? e.kind !== i.kind ? p.push({
-      sourceSvgId: i.sourceSvgId,
-      change: "kind_changed",
-      existingShapeId: e.id,
-      existingKind: e.kind,
-      newKind: i.kind,
-      preserve: { key: e.key, assignment: !0, anchors: !0 }
-    }) : p.push({
-      sourceSvgId: i.sourceSvgId,
-      change: "unchanged",
-      existingShapeId: e.id,
-      existingKind: e.kind,
-      newKind: i.kind,
-      preserve: { key: e.key, assignment: !0, anchors: !0 }
-    }) : p.push({
-      sourceSvgId: i.sourceSvgId,
-      change: "added",
-      newKind: i.kind
-    });
+function M(a, f, i, r = g) {
+  let e = null;
+  for (const o of f) {
+    const d = L(a, o);
+    d && (!e || d.distance < e.distance) && (e = { point: d.point, distance: d.distance });
   }
-  for (const i of t)
-    i.sourceSvgId && !l.has(i.sourceSvgId) && p.push({
-      sourceSvgId: i.sourceSvgId,
-      change: "removed",
-      existingShapeId: i.id,
-      existingKind: i.kind
-    });
+  if (!e) return null;
+  const t = i.find(
+    (o) => o.levelId === a.levelId && A(o, e.point) <= r
+  );
   return {
-    items: p,
-    shapes: n,
-    viewbox: o
+    unitAnchorId: a.id,
+    junctionAnchor: t ? { x: t.x, y: t.y, existingId: t.id } : { x: e.point.x, y: e.point.y },
+    edge: {
+      fromAnchorId: a.id,
+      toAnchorId: t == null ? void 0 : t.id
+    }
   };
 }
-function F(n) {
-  const t = { ...S, ...n.theme }, o = new Map(
-    n.assignments.map((e) => [e.shapeId, e])
-  ), a = n.resolveSvgUrl ?? ((e) => e), l = n.levels.filter((e) => e.isActive).sort((e, c) => e.ordering - c.ordering).map((e) => {
-    const c = n.shapes.filter((f) => f.levelId === e.id).map((f) => ({
-      ...f,
-      assignment: o.get(f.id) ?? null
-    })), k = n.anchors.filter((f) => f.levelId === e.id);
-    return {
-      id: e.id,
-      buildingId: e.buildingId,
-      kind: e.kind,
-      name: e.name,
-      levelIndex: e.levelIndex,
-      ordering: e.ordering,
-      sourceSvgUrl: a(e.sourceSvgKey),
-      viewbox: e.sourceViewbox,
-      transform: e.transform,
-      shapes: c,
-      anchors: k
-    };
-  }), { nodes: p, edges: i } = E(
-    n.anchors,
-    n.edges,
-    n.connectors
-  );
+function P(a, f, i, r) {
+  if (i.length === 0) return null;
+  const e = i.flat();
+  if (e.length === 0) return null;
+  let t = 0, o = 0;
+  for (const n of e)
+    t += n.x, o += n.y;
+  const d = { x: t / e.length, y: o / e.length }, h = S(d, i) ? d : e[0];
   return {
-    version: 2,
-    revisionId: n.revisionId,
-    revisionNumber: n.revisionNumber,
-    centerId: n.centerId,
-    mapId: n.mapId,
-    theme: t,
-    baseSvgUrl: n.baseSvgUrl,
-    baseViewbox: n.baseViewbox,
-    buildings: n.buildings,
-    levels: l,
-    connectors: n.connectors,
-    amenities: n.amenities.filter((e) => e.isActive),
-    graph: { nodes: p, edges: i },
-    responsiveOverrides: n.responsiveOverrides,
-    publishedAt: n.publishedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    id: r,
+    levelId: f,
+    shapeId: a,
+    kind: "unit",
+    x: h.x,
+    y: h.y,
+    connectorId: null
+  };
+}
+function k(a, f, i = 20) {
+  if (a.length === 0)
+    return { anchors: [], edges: [] };
+  let r = 1 / 0, e = 1 / 0, t = -1 / 0, o = -1 / 0;
+  for (const s of a)
+    for (const l of s)
+      r = Math.min(r, l.x), e = Math.min(e, l.y), t = Math.max(t, l.x), o = Math.max(o, l.y);
+  const d = Math.max(1, Math.ceil((t - r) / i)), h = Math.max(1, Math.ceil((o - e) / i)), n = [];
+  for (let s = 0; s < h; s++)
+    for (let l = 0; l < d; l++) {
+      const I = r + (l + 0.5) * i, x = e + (s + 0.5) * i, y = { x: I, y: x };
+      S(y, a) && (f.length > 0 && S(y, f) || n.push({ key: `${l},${s}`, x: I, y: x, col: l, row: s }));
+    }
+  const c = new Map(n.map((s) => [s.key, s])), p = n.map((s) => ({
+    tempId: s.key,
+    x: s.x,
+    y: s.y,
+    kind: "junction"
+  })), u = [], m = /* @__PURE__ */ new Set();
+  for (const s of n) {
+    const l = [
+      [s.col + 1, s.row],
+      [s.col, s.row + 1]
+    ];
+    for (const [I, x] of l) {
+      const y = `${I},${x}`;
+      if (!c.has(y)) continue;
+      const v = s.key < y ? `${s.key}|${y}` : `${y}|${s.key}`;
+      m.has(v) || (m.add(v), u.push({ fromTempId: s.key, toTempId: y }));
+    }
+  }
+  return { anchors: p, edges: u };
+}
+function D(a, f, i, r, e = g) {
+  const t = [], o = [];
+  let d = r;
+  const h = (n, c) => {
+    const p = t.find(
+      (m) => A(m, { x: n, y: c }) <= e
+    );
+    if (p) return p.id;
+    const u = d++;
+    return t.push({
+      id: u,
+      levelId: f,
+      shapeId: null,
+      kind: "junction",
+      x: n,
+      y: c,
+      connectorId: null
+    }), u;
   };
+  for (const n of a) {
+    const c = T(n);
+    for (const p of c)
+      for (let u = 0; u < p.length - 1; u++) {
+        const m = h(p[u].x, p[u].y), s = h(p[u + 1].x, p[u + 1].y);
+        m === s || o.some(
+          (I) => I.fromAnchorId === m && I.toAnchorId === s || I.fromAnchorId === s && I.toAnchorId === m
+        ) || o.push({
+          id: d++,
+          mapId: i,
+          fromAnchorId: m,
+          toAnchorId: s,
+          weight: null,
+          directed: !1,
+          accessible: !0,
+          kind: "walk"
+        });
+      }
+  }
+  return { anchors: t, edges: o, nextId: d };
 }
 export {
-  S as DEFAULT_THEME,
-  K as DEFAULT_WELD_TOLERANCE,
-  U as FLOOR_CHANGE_PENALTY,
-  z as INTERACTIVE_SHAPE_KINDS,
-  B as angleFromWall,
-  W as approximateCubic,
-  G as approximateQuadratic,
-  re as autoConnectUnitAnchor,
-  V as bboxOf,
-  H as bboxUnion,
-  ae as buildAutoSkeleton,
-  w as buildGeometryFromPaths,
-  j as centroid,
-  L as classifyId,
-  F as compileDocument,
-  E as compileGraph,
-  T as diffImport,
-  X as distance,
-  Z as findNearestAmenityPath,
-  Y as findPath,
-  ce as findWeldCandidates,
-  q as flipY,
-  I as geometryBBox,
-  Q as geometryCentroid,
-  de as importRoutePaths,
-  O as importSvg,
-  J as nearestPointOnPolyline,
-  C as parseSvgString,
-  y as parseViewBox,
-  ee as pathToPolygons,
-  ne as pointInPolygon,
-  ie as pointInPolygons,
-  se as projectOntoSegment,
-  te as snapAngle,
-  le as unitAnchorFromShape,
-  pe as weldAnchors
+  F as DEFAULT_THEME,
+  g as DEFAULT_WELD_TOLERANCE,
+  O as FLOOR_CHANGE_PENALTY,
+  R as IDENTITY_MATRIX,
+  N as IMPORT_DRIFT_THRESHOLD,
+  B as IMPORT_PERSISTED_KINDS,
+  $ as INTERACTIVE_SHAPE_KINDS,
+  G as STATIC_LAYER_STYLES,
+  Y as angleFromWall,
+  H as applyMatrix,
+  V as approximateArc,
+  j as approximateCubic,
+  K as approximateQuadratic,
+  M as autoConnectUnitAnchor,
+  U as bboxOf,
+  W as bboxUnion,
+  X as boundsFromStackedLevels,
+  k as buildAutoSkeleton,
+  z as buildGeometryFromPaths,
+  Q as centroid,
+  q as classifyId,
+  J as compareBuildingFloors,
+  Z as compileDocument,
+  ee as compileGraph,
+  ne as defaultViewerLevelId,
+  te as diffImport,
+  A as distance,
+  oe as expandBounds,
+  se as findNearestAmenityPath,
+  ae as findPath,
+  b as findWeldCandidates,
+  ie as flipY,
+  re as floorSwitcherDisplayLevels,
+  de as floorSwitcherLevels,
+  ce as geometryBBox,
+  le as geometryCentroid,
+  D as importRoutePaths,
+  fe as importSvg,
+  ue as inlineSvgStyles,
+  he as isGeometrySpaceStale,
+  pe as isIdentityMatrix,
+  me as isInteractiveGroupLabel,
+  Ie as isLayerContainerLabel,
+  ye as isMapViewerHost,
+  xe as isNonInteractiveGroupLabel,
+  ge as isOutdoorLevel,
+  Ae as isStoreFolderLabel,
+  Se as mapSurface,
+  ve as mergePresentationStyle,
+  Le as mergeTheme,
+  Te as multiplyMatrix,
+  L as nearestPointOnPolyline,
+  we as normalizeGeometrySpace,
+  Ee as normalizeLayerLabel,
+  be as normalizeLayerName,
+  Me as normalizePublishedDocument,
+  Pe as parseSvgString,
+  ke as parseTransform,
+  De as parseViewBox,
+  T as pathToPolygons,
+  _e as pointInPolygon,
+  S as pointInPolygons,
+  Ce as projectOntoSegment,
+  Fe as readPresentationStyle,
+  Oe as resolveLayerStyle,
+  Re as shouldShowFloorSwitcher,
+  Ne as snapAngle,
+  Be as tokenizePathData,
+  $e as transformPathD,
+  Ge as unionViewBox,
+  P as unitAnchorFromShape,
+  Ye as viewBoxToBounds,
+  He as viewerChrome,
+  Ve as viewerLevelStack,
+  E as weldAnchors
 };
 //# sourceMappingURL=index.js.map