@kerros/schema 0.0.0-stage → 0.1.0-rc.2

package/dist/index.js

@@ -0,0 +1,3735 @@
+var _n = Object.defineProperty;
+var Rn = (e, t, n) => t in e ? _n(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var re = (e, t, n) => Rn(e, typeof t != "symbol" ? t + "" : t, n);
+class dt {
+  constructor(t, n) {
+    this.next = null, this.key = t, this.data = n, this.left = null, this.right = null;
+  }
+}
+function Pn(e, t) {
+  return e > t ? 1 : e < t ? -1 : 0;
+}
+function it(e, t, n) {
+  const s = new dt(null, null);
+  let o = s, i = s;
+  for (; ; ) {
+    const a = n(e, t.key);
+    if (a < 0) {
+      if (t.left === null) break;
+      if (n(e, t.left.key) < 0) {
+        const r = t.left;
+        if (t.left = r.right, r.right = t, t = r, t.left === null) break;
+      }
+      i.left = t, i = t, t = t.left;
+    } else if (a > 0) {
+      if (t.right === null) break;
+      if (n(e, t.right.key) > 0) {
+        const r = t.right;
+        if (t.right = r.left, r.left = t, t = r, t.right === null) break;
+      }
+      o.right = t, o = t, t = t.right;
+    } else break;
+  }
+  return o.right = t.left, i.left = t.right, t.left = s.right, t.right = s.left, t;
+}
+function ae(e, t, n, s) {
+  const o = new dt(e, t);
+  if (n === null)
+    return o.left = o.right = null, o;
+  n = it(e, n, s);
+  const i = s(e, n.key);
+  return i < 0 ? (o.left = n.left, o.right = n, n.left = null) : i >= 0 && (o.right = n.right, o.left = n, n.right = null), o;
+}
+function Ne(e, t, n) {
+  let s = null, o = null;
+  if (t) {
+    t = it(e, t, n);
+    const i = n(t.key, e);
+    i === 0 ? (s = t.left, o = t.right) : i < 0 ? (o = t.right, t.right = null, s = t) : (s = t.left, t.left = null, o = t);
+  }
+  return { left: s, right: o };
+}
+function $n(e, t, n) {
+  return t === null ? e : (e === null || (t = it(e.key, t, n), t.left = e), t);
+}
+function ge(e, t, n, s, o) {
+  if (e) {
+    s(`${t}${n ? "└── " : "├── "}${o(e)}
+`);
+    const i = t + (n ? "    " : "│   ");
+    e.left && ge(e.left, i, !1, s, o), e.right && ge(e.right, i, !0, s, o);
+  }
+}
+class Ee {
+  constructor(t = Pn) {
+    this._root = null, this._size = 0, this._comparator = t;
+  }
+  /**
+   * Inserts a key, allows duplicates
+   */
+  insert(t, n) {
+    return this._size++, this._root = ae(t, n, this._root, this._comparator);
+  }
+  /**
+   * Adds a key, if it is not present in the tree
+   */
+  add(t, n) {
+    const s = new dt(t, n);
+    this._root === null && (s.left = s.right = null, this._size++, this._root = s);
+    const o = this._comparator, i = it(t, this._root, o), a = o(t, i.key);
+    return a === 0 ? this._root = i : (a < 0 ? (s.left = i.left, s.right = i, i.left = null) : a > 0 && (s.right = i.right, s.left = i, i.right = null), this._size++, this._root = s), this._root;
+  }
+  /**
+   * @param  {Key} key
+   * @return {Node|null}
+   */
+  remove(t) {
+    this._root = this._remove(t, this._root, this._comparator);
+  }
+  /**
+   * Deletes i from the tree if it's there
+   */
+  _remove(t, n, s) {
+    let o;
+    return n === null ? null : (n = it(t, n, s), s(t, n.key) === 0 ? (n.left === null ? o = n.right : (o = it(t, n.left, s), o.right = n.right), this._size--, o) : n);
+  }
+  /**
+   * Removes and returns the node with smallest key
+   */
+  pop() {
+    let t = this._root;
+    if (t) {
+      for (; t.left; ) t = t.left;
+      return this._root = it(t.key, this._root, this._comparator), this._root = this._remove(t.key, this._root, this._comparator), { key: t.key, data: t.data };
+    }
+    return null;
+  }
+  /**
+   * Find without splaying
+   */
+  findStatic(t) {
+    let n = this._root;
+    const s = this._comparator;
+    for (; n; ) {
+      const o = s(t, n.key);
+      if (o === 0) return n;
+      o < 0 ? n = n.left : n = n.right;
+    }
+    return null;
+  }
+  find(t) {
+    return this._root && (this._root = it(t, this._root, this._comparator), this._comparator(t, this._root.key) !== 0) ? null : this._root;
+  }
+  contains(t) {
+    let n = this._root;
+    const s = this._comparator;
+    for (; n; ) {
+      const o = s(t, n.key);
+      if (o === 0) return !0;
+      o < 0 ? n = n.left : n = n.right;
+    }
+    return !1;
+  }
+  forEach(t, n) {
+    let s = this._root;
+    const o = [];
+    let i = !1;
+    for (; !i; )
+      s !== null ? (o.push(s), s = s.left) : o.length !== 0 ? (s = o.pop(), t.call(n, s), s = s.right) : i = !0;
+    return this;
+  }
+  /**
+   * Walk key range from `low` to `high`. Stops if `fn` returns a value.
+   */
+  range(t, n, s, o) {
+    const i = [], a = this._comparator;
+    let r = this._root, l;
+    for (; i.length !== 0 || r; )
+      if (r)
+        i.push(r), r = r.left;
+      else {
+        if (r = i.pop(), l = a(r.key, n), l > 0)
+          break;
+        if (a(r.key, t) >= 0 && s.call(o, r))
+          return this;
+        r = r.right;
+      }
+    return this;
+  }
+  /**
+   * Returns array of keys
+   */
+  keys() {
+    const t = [];
+    return this.forEach(({ key: n }) => {
+      t.push(n);
+    }), t;
+  }
+  /**
+   * Returns array of all the data in the nodes
+   */
+  values() {
+    const t = [];
+    return this.forEach(({ data: n }) => {
+      t.push(n);
+    }), t;
+  }
+  min() {
+    return this._root ? this.minNode(this._root).key : null;
+  }
+  max() {
+    return this._root ? this.maxNode(this._root).key : null;
+  }
+  minNode(t = this._root) {
+    if (t) for (; t.left; ) t = t.left;
+    return t;
+  }
+  maxNode(t = this._root) {
+    if (t) for (; t.right; ) t = t.right;
+    return t;
+  }
+  /**
+   * Returns node at given index
+   */
+  at(t) {
+    let n = this._root, s = !1, o = 0;
+    const i = [];
+    for (; !s; )
+      if (n)
+        i.push(n), n = n.left;
+      else if (i.length > 0) {
+        if (n = i.pop(), o === t) return n;
+        o++, n = n.right;
+      } else s = !0;
+    return null;
+  }
+  next(t) {
+    let n = this._root, s = null;
+    if (t.right) {
+      for (s = t.right; s.left; ) s = s.left;
+      return s;
+    }
+    const o = this._comparator;
+    for (; n; ) {
+      const i = o(t.key, n.key);
+      if (i === 0) break;
+      i < 0 ? (s = n, n = n.left) : n = n.right;
+    }
+    return s;
+  }
+  prev(t) {
+    let n = this._root, s = null;
+    if (t.left !== null) {
+      for (s = t.left; s.right; ) s = s.right;
+      return s;
+    }
+    const o = this._comparator;
+    for (; n; ) {
+      const i = o(t.key, n.key);
+      if (i === 0) break;
+      i < 0 ? n = n.left : (s = n, n = n.right);
+    }
+    return s;
+  }
+  clear() {
+    return this._root = null, this._size = 0, this;
+  }
+  toList() {
+    return On(this._root);
+  }
+  /**
+   * Bulk-load items. Both array have to be same size
+   */
+  load(t, n = [], s = !1) {
+    let o = t.length;
+    const i = this._comparator;
+    if (s && Ie(t, n, 0, o - 1, i), this._root === null)
+      this._root = me(t, n, 0, o), this._size = o;
+    else {
+      const a = Bn(
+        this.toList(),
+        Nn(t, n),
+        i
+      );
+      o = this._size + o, this._root = pe({ head: a }, 0, o);
+    }
+    return this;
+  }
+  isEmpty() {
+    return this._root === null;
+  }
+  get size() {
+    return this._size;
+  }
+  get root() {
+    return this._root;
+  }
+  toString(t = (n) => String(n.key)) {
+    const n = [];
+    return ge(this._root, "", !0, (s) => n.push(s), t), n.join("");
+  }
+  update(t, n, s) {
+    const o = this._comparator;
+    let { left: i, right: a } = Ne(t, this._root, o);
+    o(t, n) < 0 ? a = ae(n, s, a, o) : i = ae(n, s, i, o), this._root = $n(i, a, o);
+  }
+  split(t) {
+    return Ne(t, this._root, this._comparator);
+  }
+  *[Symbol.iterator]() {
+    let t = this._root;
+    const n = [];
+    let s = !1;
+    for (; !s; )
+      t !== null ? (n.push(t), t = t.left) : n.length !== 0 ? (t = n.pop(), yield t, t = t.right) : s = !0;
+  }
+}
+function me(e, t, n, s) {
+  const o = s - n;
+  if (o > 0) {
+    const i = n + Math.floor(o / 2), a = e[i], r = t[i], l = new dt(a, r);
+    return l.left = me(e, t, n, i), l.right = me(e, t, i + 1, s), l;
+  }
+  return null;
+}
+function Nn(e, t) {
+  const n = new dt(null, null);
+  let s = n;
+  for (let o = 0; o < e.length; o++)
+    s = s.next = new dt(e[o], t[o]);
+  return s.next = null, n.next;
+}
+function On(e) {
+  let t = e;
+  const n = [];
+  let s = !1;
+  const o = new dt(null, null);
+  let i = o;
+  for (; !s; )
+    t ? (n.push(t), t = t.left) : n.length > 0 ? (t = i = i.next = n.pop(), t = t.right) : s = !0;
+  return i.next = null, o.next;
+}
+function pe(e, t, n) {
+  const s = n - t;
+  if (s > 0) {
+    const o = t + Math.floor(s / 2), i = pe(e, t, o), a = e.head;
+    return a.left = i, e.head = e.head.next, a.right = pe(e, o + 1, n), a;
+  }
+  return null;
+}
+function Bn(e, t, n) {
+  const s = new dt(null, null);
+  let o = s, i = e, a = t;
+  for (; i !== null && a !== null; )
+    n(i.key, a.key) < 0 ? (o.next = i, i = i.next) : (o.next = a, a = a.next), o = o.next;
+  return i !== null ? o.next = i : a !== null && (o.next = a), s.next;
+}
+function Ie(e, t, n, s, o) {
+  if (n >= s) return;
+  const i = e[n + s >> 1];
+  let a = n - 1, r = s + 1;
+  for (; ; ) {
+    do
+      a++;
+    while (o(e[a], i) < 0);
+    do
+      r--;
+    while (o(e[r], i) > 0);
+    if (a >= r) break;
+    let l = e[a];
+    e[a] = e[r], e[r] = l, l = t[a], t[a] = t[r], t[r] = l;
+  }
+  Ie(e, t, n, r, o), Ie(e, t, r + 1, s, o);
+}
+const ot = 11102230246251565e-32, j = 134217729, zn = (3 + 8 * ot) * ot;
+function le(e, t, n, s, o) {
+  let i, a, r, l, d = t[0], u = s[0], c = 0, f = 0;
+  u > d == u > -d ? (i = d, d = t[++c]) : (i = u, u = s[++f]);
+  let h = 0;
+  if (c < e && f < n)
+    for (u > d == u > -d ? (a = d + i, r = i - (a - d), d = t[++c]) : (a = u + i, r = i - (a - u), u = s[++f]), i = a, r !== 0 && (o[h++] = r); c < e && f < n; )
+      u > d == u > -d ? (a = i + d, l = a - i, r = i - (a - l) + (d - l), d = t[++c]) : (a = i + u, l = a - i, r = i - (a - l) + (u - l), u = s[++f]), i = a, r !== 0 && (o[h++] = r);
+  for (; c < e; )
+    a = i + d, l = a - i, r = i - (a - l) + (d - l), d = t[++c], i = a, r !== 0 && (o[h++] = r);
+  for (; f < n; )
+    a = i + u, l = a - i, r = i - (a - l) + (u - l), u = s[++f], i = a, r !== 0 && (o[h++] = r);
+  return (i !== 0 || h === 0) && (o[h++] = i), h;
+}
+function Fn(e, t) {
+  let n = t[0];
+  for (let s = 1; s < e; s++) n += t[s];
+  return n;
+}
+function Gt(e) {
+  return new Float64Array(e);
+}
+const Tn = (3 + 16 * ot) * ot, Cn = (2 + 12 * ot) * ot, Ln = (9 + 64 * ot) * ot * ot, Et = Gt(4), Oe = Gt(8), Be = Gt(12), ze = Gt(16), q = Gt(4);
+function Gn(e, t, n, s, o, i, a) {
+  let r, l, d, u, c, f, h, p, m, I, b, w, g, y, M, _, $, x;
+  const E = e - o, A = n - o, v = t - i, k = s - i;
+  y = E * k, f = j * E, h = f - (f - E), p = E - h, f = j * k, m = f - (f - k), I = k - m, M = p * I - (y - h * m - p * m - h * I), _ = v * A, f = j * v, h = f - (f - v), p = v - h, f = j * A, m = f - (f - A), I = A - m, $ = p * I - (_ - h * m - p * m - h * I), b = M - $, c = M - b, Et[0] = M - (b + c) + (c - $), w = y + b, c = w - y, g = y - (w - c) + (b - c), b = g - _, c = g - b, Et[1] = g - (b + c) + (c - _), x = w + b, c = x - w, Et[2] = w - (x - c) + (b - c), Et[3] = x;
+  let R = Fn(4, Et), P = Cn * a;
+  if (R >= P || -R >= P || (c = e - E, r = e - (E + c) + (c - o), c = n - A, d = n - (A + c) + (c - o), c = t - v, l = t - (v + c) + (c - i), c = s - k, u = s - (k + c) + (c - i), r === 0 && l === 0 && d === 0 && u === 0) || (P = Ln * a + zn * Math.abs(R), R += E * u + k * r - (v * d + A * l), R >= P || -R >= P)) return R;
+  y = r * k, f = j * r, h = f - (f - r), p = r - h, f = j * k, m = f - (f - k), I = k - m, M = p * I - (y - h * m - p * m - h * I), _ = l * A, f = j * l, h = f - (f - l), p = l - h, f = j * A, m = f - (f - A), I = A - m, $ = p * I - (_ - h * m - p * m - h * I), b = M - $, c = M - b, q[0] = M - (b + c) + (c - $), w = y + b, c = w - y, g = y - (w - c) + (b - c), b = g - _, c = g - b, q[1] = g - (b + c) + (c - _), x = w + b, c = x - w, q[2] = w - (x - c) + (b - c), q[3] = x;
+  const O = le(4, Et, 4, q, Oe);
+  y = E * u, f = j * E, h = f - (f - E), p = E - h, f = j * u, m = f - (f - u), I = u - m, M = p * I - (y - h * m - p * m - h * I), _ = v * d, f = j * v, h = f - (f - v), p = v - h, f = j * d, m = f - (f - d), I = d - m, $ = p * I - (_ - h * m - p * m - h * I), b = M - $, c = M - b, q[0] = M - (b + c) + (c - $), w = y + b, c = w - y, g = y - (w - c) + (b - c), b = g - _, c = g - b, q[1] = g - (b + c) + (c - _), x = w + b, c = x - w, q[2] = w - (x - c) + (b - c), q[3] = x;
+  const z = le(O, Oe, 4, q, Be);
+  y = r * u, f = j * r, h = f - (f - r), p = r - h, f = j * u, m = f - (f - u), I = u - m, M = p * I - (y - h * m - p * m - h * I), _ = l * d, f = j * l, h = f - (f - l), p = l - h, f = j * d, m = f - (f - d), I = d - m, $ = p * I - (_ - h * m - p * m - h * I), b = M - $, c = M - b, q[0] = M - (b + c) + (c - $), w = y + b, c = w - y, g = y - (w - c) + (b - c), b = g - _, c = g - b, q[1] = g - (b + c) + (c - _), x = w + b, c = x - w, q[2] = w - (x - c) + (b - c), q[3] = x;
+  const F = le(z, Be, 4, q, ze);
+  return ze[F - 1];
+}
+function Dn(e, t, n, s, o, i) {
+  const a = (t - i) * (n - o), r = (e - o) * (s - i), l = a - r, d = Math.abs(a + r);
+  return Math.abs(l) >= Tn * d ? l : -Gn(e, t, n, s, o, i, d);
+}
+const Pt = (e, t) => e.ll.x <= t.x && t.x <= e.ur.x && e.ll.y <= t.y && t.y <= e.ur.y, be = (e, t) => {
+  if (t.ur.x < e.ll.x || e.ur.x < t.ll.x || t.ur.y < e.ll.y || e.ur.y < t.ll.y) return null;
+  const n = e.ll.x < t.ll.x ? t.ll.x : e.ll.x, s = e.ur.x < t.ur.x ? e.ur.x : t.ur.x, o = e.ll.y < t.ll.y ? t.ll.y : e.ll.y, i = e.ur.y < t.ur.y ? e.ur.y : t.ur.y;
+  return {
+    ll: {
+      x: n,
+      y: o
+    },
+    ur: {
+      x: s,
+      y: i
+    }
+  };
+};
+let rt = Number.EPSILON;
+rt === void 0 && (rt = Math.pow(2, -52));
+const Un = rt * rt, Fe = (e, t) => {
+  if (-rt < e && e < rt && -rt < t && t < rt)
+    return 0;
+  const n = e - t;
+  return n * n < Un * e * t ? 0 : e < t ? -1 : 1;
+};
+class Zn {
+  constructor() {
+    this.reset();
+  }
+  reset() {
+    this.xRounder = new Te(), this.yRounder = new Te();
+  }
+  round(t, n) {
+    return {
+      x: this.xRounder.round(t),
+      y: this.yRounder.round(n)
+    };
+  }
+}
+class Te {
+  constructor() {
+    this.tree = new Ee(), this.round(0);
+  }
+  // Note: this can rounds input values backwards or forwards.
+  //       You might ask, why not restrict this to just rounding
+  //       forwards? Wouldn't that allow left endpoints to always
+  //       remain left endpoints during splitting (never change to
+  //       right). No - it wouldn't, because we snap intersections
+  //       to endpoints (to establish independence from the segment
+  //       angle for t-intersections).
+  round(t) {
+    const n = this.tree.add(t), s = this.tree.prev(n);
+    if (s !== null && Fe(n.key, s.key) === 0)
+      return this.tree.remove(t), s.key;
+    const o = this.tree.next(n);
+    return o !== null && Fe(n.key, o.key) === 0 ? (this.tree.remove(t), o.key) : t;
+  }
+}
+const Bt = new Zn(), Yt = (e, t) => e.x * t.y - e.y * t.x, en = (e, t) => e.x * t.x + e.y * t.y, Ce = (e, t, n) => {
+  const s = Dn(e.x, e.y, t.x, t.y, n.x, n.y);
+  return s > 0 ? -1 : s < 0 ? 1 : 0;
+}, Jt = (e) => Math.sqrt(en(e, e)), Hn = (e, t, n) => {
+  const s = {
+    x: t.x - e.x,
+    y: t.y - e.y
+  }, o = {
+    x: n.x - e.x,
+    y: n.y - e.y
+  };
+  return Yt(o, s) / Jt(o) / Jt(s);
+}, Wn = (e, t, n) => {
+  const s = {
+    x: t.x - e.x,
+    y: t.y - e.y
+  }, o = {
+    x: n.x - e.x,
+    y: n.y - e.y
+  };
+  return en(o, s) / Jt(o) / Jt(s);
+}, Le = (e, t, n) => t.y === 0 ? null : {
+  x: e.x + t.x / t.y * (n - e.y),
+  y: n
+}, Ge = (e, t, n) => t.x === 0 ? null : {
+  x: n,
+  y: e.y + t.y / t.x * (n - e.x)
+}, jn = (e, t, n, s) => {
+  if (t.x === 0) return Ge(n, s, e.x);
+  if (s.x === 0) return Ge(e, t, n.x);
+  if (t.y === 0) return Le(n, s, e.y);
+  if (s.y === 0) return Le(e, t, n.y);
+  const o = Yt(t, s);
+  if (o == 0) return null;
+  const i = {
+    x: n.x - e.x,
+    y: n.y - e.y
+  }, a = Yt(i, t) / o, r = Yt(i, s) / o, l = e.x + r * t.x, d = n.x + a * s.x, u = e.y + r * t.y, c = n.y + a * s.y, f = (l + d) / 2, h = (u + c) / 2;
+  return {
+    x: f,
+    y: h
+  };
+};
+class J {
+  // for ordering sweep events in the sweep event queue
+  static compare(t, n) {
+    const s = J.comparePoints(t.point, n.point);
+    return s !== 0 ? s : (t.point !== n.point && t.link(n), t.isLeft !== n.isLeft ? t.isLeft ? 1 : -1 : lt.compare(t.segment, n.segment));
+  }
+  // for ordering points in sweep line order
+  static comparePoints(t, n) {
+    return t.x < n.x ? -1 : t.x > n.x ? 1 : t.y < n.y ? -1 : t.y > n.y ? 1 : 0;
+  }
+  // Warning: 'point' input will be modified and re-used (for performance)
+  constructor(t, n) {
+    t.events === void 0 ? t.events = [this] : t.events.push(this), this.point = t, this.isLeft = n;
+  }
+  link(t) {
+    if (t.point === this.point)
+      throw new Error("Tried to link already linked events");
+    const n = t.point.events;
+    for (let s = 0, o = n.length; s < o; s++) {
+      const i = n[s];
+      this.point.events.push(i), i.point = this.point;
+    }
+    this.checkForConsuming();
+  }
+  /* Do a pass over our linked events and check to see if any pair
+   * of segments match, and should be consumed. */
+  checkForConsuming() {
+    const t = this.point.events.length;
+    for (let n = 0; n < t; n++) {
+      const s = this.point.events[n];
+      if (s.segment.consumedBy === void 0)
+        for (let o = n + 1; o < t; o++) {
+          const i = this.point.events[o];
+          i.consumedBy === void 0 && s.otherSE.point.events === i.otherSE.point.events && s.segment.consume(i.segment);
+        }
+    }
+  }
+  getAvailableLinkedEvents() {
+    const t = [];
+    for (let n = 0, s = this.point.events.length; n < s; n++) {
+      const o = this.point.events[n];
+      o !== this && !o.segment.ringOut && o.segment.isInResult() && t.push(o);
+    }
+    return t;
+  }
+  /**
+   * Returns a comparator function for sorting linked events that will
+   * favor the event that will give us the smallest left-side angle.
+   * All ring construction starts as low as possible heading to the right,
+   * so by always turning left as sharp as possible we'll get polygons
+   * without uncessary loops & holes.
+   *
+   * The comparator function has a compute cache such that it avoids
+   * re-computing already-computed values.
+   */
+  getLeftmostComparator(t) {
+    const n = /* @__PURE__ */ new Map(), s = (o) => {
+      const i = o.otherSE;
+      n.set(o, {
+        sine: Hn(this.point, t.point, i.point),
+        cosine: Wn(this.point, t.point, i.point)
+      });
+    };
+    return (o, i) => {
+      n.has(o) || s(o), n.has(i) || s(i);
+      const {
+        sine: a,
+        cosine: r
+      } = n.get(o), {
+        sine: l,
+        cosine: d
+      } = n.get(i);
+      return a >= 0 && l >= 0 ? r < d ? 1 : r > d ? -1 : 0 : a < 0 && l < 0 ? r < d ? -1 : r > d ? 1 : 0 : l < a ? -1 : l > a ? 1 : 0;
+    };
+  }
+}
+let Yn = 0;
+class lt {
+  /* This compare() function is for ordering segments in the sweep
+   * line tree, and does so according to the following criteria:
+   *
+   * Consider the vertical line that lies an infinestimal step to the
+   * right of the right-more of the two left endpoints of the input
+   * segments. Imagine slowly moving a point up from negative infinity
+   * in the increasing y direction. Which of the two segments will that
+   * point intersect first? That segment comes 'before' the other one.
+   *
+   * If neither segment would be intersected by such a line, (if one
+   * or more of the segments are vertical) then the line to be considered
+   * is directly on the right-more of the two left inputs.
+   */
+  static compare(t, n) {
+    const s = t.leftSE.point.x, o = n.leftSE.point.x, i = t.rightSE.point.x, a = n.rightSE.point.x;
+    if (a < s) return 1;
+    if (i < o) return -1;
+    const r = t.leftSE.point.y, l = n.leftSE.point.y, d = t.rightSE.point.y, u = n.rightSE.point.y;
+    if (s < o) {
+      if (l < r && l < d) return 1;
+      if (l > r && l > d) return -1;
+      const c = t.comparePoint(n.leftSE.point);
+      if (c < 0) return 1;
+      if (c > 0) return -1;
+      const f = n.comparePoint(t.rightSE.point);
+      return f !== 0 ? f : -1;
+    }
+    if (s > o) {
+      if (r < l && r < u) return -1;
+      if (r > l && r > u) return 1;
+      const c = n.comparePoint(t.leftSE.point);
+      if (c !== 0) return c;
+      const f = t.comparePoint(n.rightSE.point);
+      return f < 0 ? 1 : f > 0 ? -1 : 1;
+    }
+    if (r < l) return -1;
+    if (r > l) return 1;
+    if (i < a) {
+      const c = n.comparePoint(t.rightSE.point);
+      if (c !== 0) return c;
+    }
+    if (i > a) {
+      const c = t.comparePoint(n.rightSE.point);
+      if (c < 0) return 1;
+      if (c > 0) return -1;
+    }
+    if (i !== a) {
+      const c = d - r, f = i - s, h = u - l, p = a - o;
+      if (c > f && h < p) return 1;
+      if (c < f && h > p) return -1;
+    }
+    return i > a ? 1 : i < a || d < u ? -1 : d > u ? 1 : t.id < n.id ? -1 : t.id > n.id ? 1 : 0;
+  }
+  /* Warning: a reference to ringWindings input will be stored,
+   *  and possibly will be later modified */
+  constructor(t, n, s, o) {
+    this.id = ++Yn, this.leftSE = t, t.segment = this, t.otherSE = n, this.rightSE = n, n.segment = this, n.otherSE = t, this.rings = s, this.windings = o;
+  }
+  static fromRing(t, n, s) {
+    let o, i, a;
+    const r = J.comparePoints(t, n);
+    if (r < 0)
+      o = t, i = n, a = 1;
+    else if (r > 0)
+      o = n, i = t, a = -1;
+    else throw new Error(`Tried to create degenerate segment at [${t.x}, ${t.y}]`);
+    const l = new J(o, !0), d = new J(i, !1);
+    return new lt(l, d, [s], [a]);
+  }
+  /* When a segment is split, the rightSE is replaced with a new sweep event */
+  replaceRightSE(t) {
+    this.rightSE = t, this.rightSE.segment = this, this.rightSE.otherSE = this.leftSE, this.leftSE.otherSE = this.rightSE;
+  }
+  bbox() {
+    const t = this.leftSE.point.y, n = this.rightSE.point.y;
+    return {
+      ll: {
+        x: this.leftSE.point.x,
+        y: t < n ? t : n
+      },
+      ur: {
+        x: this.rightSE.point.x,
+        y: t > n ? t : n
+      }
+    };
+  }
+  /* A vector from the left point to the right */
+  vector() {
+    return {
+      x: this.rightSE.point.x - this.leftSE.point.x,
+      y: this.rightSE.point.y - this.leftSE.point.y
+    };
+  }
+  isAnEndpoint(t) {
+    return t.x === this.leftSE.point.x && t.y === this.leftSE.point.y || t.x === this.rightSE.point.x && t.y === this.rightSE.point.y;
+  }
+  /* Compare this segment with a point.
+   *
+   * A point P is considered to be colinear to a segment if there
+   * exists a distance D such that if we travel along the segment
+   * from one * endpoint towards the other a distance D, we find
+   * ourselves at point P.
+   *
+   * Return value indicates:
+   *
+   *   1: point lies above the segment (to the left of vertical)
+   *   0: point is colinear to segment
+   *  -1: point lies below the segment (to the right of vertical)
+   */
+  comparePoint(t) {
+    if (this.isAnEndpoint(t)) return 0;
+    const n = this.leftSE.point, s = this.rightSE.point, o = this.vector();
+    if (n.x === s.x)
+      return t.x === n.x ? 0 : t.x < n.x ? 1 : -1;
+    const i = (t.y - n.y) / o.y, a = n.x + i * o.x;
+    if (t.x === a) return 0;
+    const r = (t.x - n.x) / o.x, l = n.y + r * o.y;
+    return t.y === l ? 0 : t.y < l ? -1 : 1;
+  }
+  /**
+   * Given another segment, returns the first non-trivial intersection
+   * between the two segments (in terms of sweep line ordering), if it exists.
+   *
+   * A 'non-trivial' intersection is one that will cause one or both of the
+   * segments to be split(). As such, 'trivial' vs. 'non-trivial' intersection:
+   *
+   *   * endpoint of segA with endpoint of segB --> trivial
+   *   * endpoint of segA with point along segB --> non-trivial
+   *   * endpoint of segB with point along segA --> non-trivial
+   *   * point along segA with point along segB --> non-trivial
+   *
+   * If no non-trivial intersection exists, return null
+   * Else, return null.
+   */
+  getIntersection(t) {
+    const n = this.bbox(), s = t.bbox(), o = be(n, s);
+    if (o === null) return null;
+    const i = this.leftSE.point, a = this.rightSE.point, r = t.leftSE.point, l = t.rightSE.point, d = Pt(n, r) && this.comparePoint(r) === 0, u = Pt(s, i) && t.comparePoint(i) === 0, c = Pt(n, l) && this.comparePoint(l) === 0, f = Pt(s, a) && t.comparePoint(a) === 0;
+    if (u && d)
+      return f && !c ? a : !f && c ? l : null;
+    if (u)
+      return c && i.x === l.x && i.y === l.y ? null : i;
+    if (d)
+      return f && a.x === r.x && a.y === r.y ? null : r;
+    if (f && c) return null;
+    if (f) return a;
+    if (c) return l;
+    const h = jn(i, this.vector(), r, t.vector());
+    return h === null || !Pt(o, h) ? null : Bt.round(h.x, h.y);
+  }
+  /**
+   * Split the given segment into multiple segments on the given points.
+   *  * Each existing segment will retain its leftSE and a new rightSE will be
+   *    generated for it.
+   *  * A new segment will be generated which will adopt the original segment's
+   *    rightSE, and a new leftSE will be generated for it.
+   *  * If there are more than two points given to split on, new segments
+   *    in the middle will be generated with new leftSE and rightSE's.
+   *  * An array of the newly generated SweepEvents will be returned.
+   *
+   * Warning: input array of points is modified
+   */
+  split(t) {
+    const n = [], s = t.events !== void 0, o = new J(t, !0), i = new J(t, !1), a = this.rightSE;
+    this.replaceRightSE(i), n.push(i), n.push(o);
+    const r = new lt(o, a, this.rings.slice(), this.windings.slice());
+    return J.comparePoints(r.leftSE.point, r.rightSE.point) > 0 && r.swapEvents(), J.comparePoints(this.leftSE.point, this.rightSE.point) > 0 && this.swapEvents(), s && (o.checkForConsuming(), i.checkForConsuming()), n;
+  }
+  /* Swap which event is left and right */
+  swapEvents() {
+    const t = this.rightSE;
+    this.rightSE = this.leftSE, this.leftSE = t, this.leftSE.isLeft = !0, this.rightSE.isLeft = !1;
+    for (let n = 0, s = this.windings.length; n < s; n++)
+      this.windings[n] *= -1;
+  }
+  /* Consume another segment. We take their rings under our wing
+   * and mark them as consumed. Use for perfectly overlapping segments */
+  consume(t) {
+    let n = this, s = t;
+    for (; n.consumedBy; ) n = n.consumedBy;
+    for (; s.consumedBy; ) s = s.consumedBy;
+    const o = lt.compare(n, s);
+    if (o !== 0) {
+      if (o > 0) {
+        const i = n;
+        n = s, s = i;
+      }
+      if (n.prev === s) {
+        const i = n;
+        n = s, s = i;
+      }
+      for (let i = 0, a = s.rings.length; i < a; i++) {
+        const r = s.rings[i], l = s.windings[i], d = n.rings.indexOf(r);
+        d === -1 ? (n.rings.push(r), n.windings.push(l)) : n.windings[d] += l;
+      }
+      s.rings = null, s.windings = null, s.consumedBy = n, s.leftSE.consumedBy = n.leftSE, s.rightSE.consumedBy = n.rightSE;
+    }
+  }
+  /* The first segment previous segment chain that is in the result */
+  prevInResult() {
+    return this._prevInResult !== void 0 ? this._prevInResult : (this.prev ? this.prev.isInResult() ? this._prevInResult = this.prev : this._prevInResult = this.prev.prevInResult() : this._prevInResult = null, this._prevInResult);
+  }
+  beforeState() {
+    if (this._beforeState !== void 0) return this._beforeState;
+    if (!this.prev) this._beforeState = {
+      rings: [],
+      windings: [],
+      multiPolys: []
+    };
+    else {
+      const t = this.prev.consumedBy || this.prev;
+      this._beforeState = t.afterState();
+    }
+    return this._beforeState;
+  }
+  afterState() {
+    if (this._afterState !== void 0) return this._afterState;
+    const t = this.beforeState();
+    this._afterState = {
+      rings: t.rings.slice(0),
+      windings: t.windings.slice(0),
+      multiPolys: []
+    };
+    const n = this._afterState.rings, s = this._afterState.windings, o = this._afterState.multiPolys;
+    for (let r = 0, l = this.rings.length; r < l; r++) {
+      const d = this.rings[r], u = this.windings[r], c = n.indexOf(d);
+      c === -1 ? (n.push(d), s.push(u)) : s[c] += u;
+    }
+    const i = [], a = [];
+    for (let r = 0, l = n.length; r < l; r++) {
+      if (s[r] === 0) continue;
+      const d = n[r], u = d.poly;
+      if (a.indexOf(u) === -1)
+        if (d.isExterior) i.push(u);
+        else {
+          a.indexOf(u) === -1 && a.push(u);
+          const c = i.indexOf(d.poly);
+          c !== -1 && i.splice(c, 1);
+        }
+    }
+    for (let r = 0, l = i.length; r < l; r++) {
+      const d = i[r].multiPoly;
+      o.indexOf(d) === -1 && o.push(d);
+    }
+    return this._afterState;
+  }
+  /* Is this segment part of the final result? */
+  isInResult() {
+    if (this.consumedBy) return !1;
+    if (this._isInResult !== void 0) return this._isInResult;
+    const t = this.beforeState().multiPolys, n = this.afterState().multiPolys;
+    switch (K.type) {
+      case "union": {
+        const s = t.length === 0, o = n.length === 0;
+        this._isInResult = s !== o;
+        break;
+      }
+      case "intersection": {
+        let s, o;
+        t.length < n.length ? (s = t.length, o = n.length) : (s = n.length, o = t.length), this._isInResult = o === K.numMultiPolys && s < o;
+        break;
+      }
+      case "xor": {
+        const s = Math.abs(t.length - n.length);
+        this._isInResult = s % 2 === 1;
+        break;
+      }
+      case "difference": {
+        const s = (o) => o.length === 1 && o[0].isSubject;
+        this._isInResult = s(t) !== s(n);
+        break;
+      }
+      default:
+        throw new Error(`Unrecognized operation type found ${K.type}`);
+    }
+    return this._isInResult;
+  }
+}
+class De {
+  constructor(t, n, s) {
+    if (!Array.isArray(t) || t.length === 0)
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    if (this.poly = n, this.isExterior = s, this.segments = [], typeof t[0][0] != "number" || typeof t[0][1] != "number")
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    const o = Bt.round(t[0][0], t[0][1]);
+    this.bbox = {
+      ll: {
+        x: o.x,
+        y: o.y
+      },
+      ur: {
+        x: o.x,
+        y: o.y
+      }
+    };
+    let i = o;
+    for (let a = 1, r = t.length; a < r; a++) {
+      if (typeof t[a][0] != "number" || typeof t[a][1] != "number")
+        throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+      let l = Bt.round(t[a][0], t[a][1]);
+      l.x === i.x && l.y === i.y || (this.segments.push(lt.fromRing(i, l, this)), l.x < this.bbox.ll.x && (this.bbox.ll.x = l.x), l.y < this.bbox.ll.y && (this.bbox.ll.y = l.y), l.x > this.bbox.ur.x && (this.bbox.ur.x = l.x), l.y > this.bbox.ur.y && (this.bbox.ur.y = l.y), i = l);
+    }
+    (o.x !== i.x || o.y !== i.y) && this.segments.push(lt.fromRing(i, o, this));
+  }
+  getSweepEvents() {
+    const t = [];
+    for (let n = 0, s = this.segments.length; n < s; n++) {
+      const o = this.segments[n];
+      t.push(o.leftSE), t.push(o.rightSE);
+    }
+    return t;
+  }
+}
+class Vn {
+  constructor(t, n) {
+    if (!Array.isArray(t))
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    this.exteriorRing = new De(t[0], this, !0), this.bbox = {
+      ll: {
+        x: this.exteriorRing.bbox.ll.x,
+        y: this.exteriorRing.bbox.ll.y
+      },
+      ur: {
+        x: this.exteriorRing.bbox.ur.x,
+        y: this.exteriorRing.bbox.ur.y
+      }
+    }, this.interiorRings = [];
+    for (let s = 1, o = t.length; s < o; s++) {
+      const i = new De(t[s], this, !1);
+      i.bbox.ll.x < this.bbox.ll.x && (this.bbox.ll.x = i.bbox.ll.x), i.bbox.ll.y < this.bbox.ll.y && (this.bbox.ll.y = i.bbox.ll.y), i.bbox.ur.x > this.bbox.ur.x && (this.bbox.ur.x = i.bbox.ur.x), i.bbox.ur.y > this.bbox.ur.y && (this.bbox.ur.y = i.bbox.ur.y), this.interiorRings.push(i);
+    }
+    this.multiPoly = n;
+  }
+  getSweepEvents() {
+    const t = this.exteriorRing.getSweepEvents();
+    for (let n = 0, s = this.interiorRings.length; n < s; n++) {
+      const o = this.interiorRings[n].getSweepEvents();
+      for (let i = 0, a = o.length; i < a; i++)
+        t.push(o[i]);
+    }
+    return t;
+  }
+}
+class Ue {
+  constructor(t, n) {
+    if (!Array.isArray(t))
+      throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
+    try {
+      typeof t[0][0][0] == "number" && (t = [t]);
+    } catch {
+    }
+    this.polys = [], this.bbox = {
+      ll: {
+        x: Number.POSITIVE_INFINITY,
+        y: Number.POSITIVE_INFINITY
+      },
+      ur: {
+        x: Number.NEGATIVE_INFINITY,
+        y: Number.NEGATIVE_INFINITY
+      }
+    };
+    for (let s = 0, o = t.length; s < o; s++) {
+      const i = new Vn(t[s], this);
+      i.bbox.ll.x < this.bbox.ll.x && (this.bbox.ll.x = i.bbox.ll.x), i.bbox.ll.y < this.bbox.ll.y && (this.bbox.ll.y = i.bbox.ll.y), i.bbox.ur.x > this.bbox.ur.x && (this.bbox.ur.x = i.bbox.ur.x), i.bbox.ur.y > this.bbox.ur.y && (this.bbox.ur.y = i.bbox.ur.y), this.polys.push(i);
+    }
+    this.isSubject = n;
+  }
+  getSweepEvents() {
+    const t = [];
+    for (let n = 0, s = this.polys.length; n < s; n++) {
+      const o = this.polys[n].getSweepEvents();
+      for (let i = 0, a = o.length; i < a; i++)
+        t.push(o[i]);
+    }
+    return t;
+  }
+}
+class Kt {
+  /* Given the segments from the sweep line pass, compute & return a series
+   * of closed rings from all the segments marked to be part of the result */
+  static factory(t) {
+    const n = [];
+    for (let s = 0, o = t.length; s < o; s++) {
+      const i = t[s];
+      if (!i.isInResult() || i.ringOut) continue;
+      let a = null, r = i.leftSE, l = i.rightSE;
+      const d = [r], u = r.point, c = [];
+      for (; a = r, r = l, d.push(r), r.point !== u; )
+        for (; ; ) {
+          const f = r.getAvailableLinkedEvents();
+          if (f.length === 0) {
+            const m = d[0].point, I = d[d.length - 1].point;
+            throw new Error(`Unable to complete output ring starting at [${m.x}, ${m.y}]. Last matching segment found ends at [${I.x}, ${I.y}].`);
+          }
+          if (f.length === 1) {
+            l = f[0].otherSE;
+            break;
+          }
+          let h = null;
+          for (let m = 0, I = c.length; m < I; m++)
+            if (c[m].point === r.point) {
+              h = m;
+              break;
+            }
+          if (h !== null) {
+            const m = c.splice(h)[0], I = d.splice(m.index);
+            I.unshift(I[0].otherSE), n.push(new Kt(I.reverse()));
+            continue;
+          }
+          c.push({
+            index: d.length,
+            point: r.point
+          });
+          const p = r.getLeftmostComparator(a);
+          l = f.sort(p)[0].otherSE;
+          break;
+        }
+      n.push(new Kt(d));
+    }
+    return n;
+  }
+  constructor(t) {
+    this.events = t;
+    for (let n = 0, s = t.length; n < s; n++)
+      t[n].segment.ringOut = this;
+    this.poly = null;
+  }
+  getGeom() {
+    let t = this.events[0].point;
+    const n = [t];
+    for (let d = 1, u = this.events.length - 1; d < u; d++) {
+      const c = this.events[d].point, f = this.events[d + 1].point;
+      Ce(c, t, f) !== 0 && (n.push(c), t = c);
+    }
+    if (n.length === 1) return null;
+    const s = n[0], o = n[1];
+    Ce(s, t, o) === 0 && n.shift(), n.push(n[0]);
+    const i = this.isExteriorRing() ? 1 : -1, a = this.isExteriorRing() ? 0 : n.length - 1, r = this.isExteriorRing() ? n.length : -1, l = [];
+    for (let d = a; d != r; d += i) l.push([n[d].x, n[d].y]);
+    return l;
+  }
+  isExteriorRing() {
+    if (this._isExteriorRing === void 0) {
+      const t = this.enclosingRing();
+      this._isExteriorRing = t ? !t.isExteriorRing() : !0;
+    }
+    return this._isExteriorRing;
+  }
+  enclosingRing() {
+    return this._enclosingRing === void 0 && (this._enclosingRing = this._calcEnclosingRing()), this._enclosingRing;
+  }
+  /* Returns the ring that encloses this one, if any */
+  _calcEnclosingRing() {
+    let t = this.events[0];
+    for (let o = 1, i = this.events.length; o < i; o++) {
+      const a = this.events[o];
+      J.compare(t, a) > 0 && (t = a);
+    }
+    let n = t.segment.prevInResult(), s = n ? n.prevInResult() : null;
+    for (; ; ) {
+      if (!n) return null;
+      if (!s) return n.ringOut;
+      if (s.ringOut !== n.ringOut)
+        return s.ringOut.enclosingRing() !== n.ringOut ? n.ringOut : n.ringOut.enclosingRing();
+      n = s.prevInResult(), s = n ? n.prevInResult() : null;
+    }
+  }
+}
+class Ze {
+  constructor(t) {
+    this.exteriorRing = t, t.poly = this, this.interiorRings = [];
+  }
+  addInterior(t) {
+    this.interiorRings.push(t), t.poly = this;
+  }
+  getGeom() {
+    const t = [this.exteriorRing.getGeom()];
+    if (t[0] === null) return null;
+    for (let n = 0, s = this.interiorRings.length; n < s; n++) {
+      const o = this.interiorRings[n].getGeom();
+      o !== null && t.push(o);
+    }
+    return t;
+  }
+}
+class Xn {
+  constructor(t) {
+    this.rings = t, this.polys = this._composePolys(t);
+  }
+  getGeom() {
+    const t = [];
+    for (let n = 0, s = this.polys.length; n < s; n++) {
+      const o = this.polys[n].getGeom();
+      o !== null && t.push(o);
+    }
+    return t;
+  }
+  _composePolys(t) {
+    const n = [];
+    for (let s = 0, o = t.length; s < o; s++) {
+      const i = t[s];
+      if (!i.poly)
+        if (i.isExteriorRing()) n.push(new Ze(i));
+        else {
+          const a = i.enclosingRing();
+          a.poly || n.push(new Ze(a)), a.poly.addInterior(i);
+        }
+    }
+    return n;
+  }
+}
+class qn {
+  constructor(t) {
+    let n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : lt.compare;
+    this.queue = t, this.tree = new Ee(n), this.segments = [];
+  }
+  process(t) {
+    const n = t.segment, s = [];
+    if (t.consumedBy)
+      return t.isLeft ? this.queue.remove(t.otherSE) : this.tree.remove(n), s;
+    const o = t.isLeft ? this.tree.add(n) : this.tree.find(n);
+    if (!o) throw new Error(`Unable to find segment #${n.id} [${n.leftSE.point.x}, ${n.leftSE.point.y}] -> [${n.rightSE.point.x}, ${n.rightSE.point.y}] in SweepLine tree.`);
+    let i = o, a = o, r, l;
+    for (; r === void 0; )
+      i = this.tree.prev(i), i === null ? r = null : i.key.consumedBy === void 0 && (r = i.key);
+    for (; l === void 0; )
+      a = this.tree.next(a), a === null ? l = null : a.key.consumedBy === void 0 && (l = a.key);
+    if (t.isLeft) {
+      let d = null;
+      if (r) {
+        const c = r.getIntersection(n);
+        if (c !== null && (n.isAnEndpoint(c) || (d = c), !r.isAnEndpoint(c))) {
+          const f = this._splitSafely(r, c);
+          for (let h = 0, p = f.length; h < p; h++)
+            s.push(f[h]);
+        }
+      }
+      let u = null;
+      if (l) {
+        const c = l.getIntersection(n);
+        if (c !== null && (n.isAnEndpoint(c) || (u = c), !l.isAnEndpoint(c))) {
+          const f = this._splitSafely(l, c);
+          for (let h = 0, p = f.length; h < p; h++)
+            s.push(f[h]);
+        }
+      }
+      if (d !== null || u !== null) {
+        let c = null;
+        d === null ? c = u : u === null ? c = d : c = J.comparePoints(d, u) <= 0 ? d : u, this.queue.remove(n.rightSE), s.push(n.rightSE);
+        const f = n.split(c);
+        for (let h = 0, p = f.length; h < p; h++)
+          s.push(f[h]);
+      }
+      s.length > 0 ? (this.tree.remove(n), s.push(t)) : (this.segments.push(n), n.prev = r);
+    } else {
+      if (r && l) {
+        const d = r.getIntersection(l);
+        if (d !== null) {
+          if (!r.isAnEndpoint(d)) {
+            const u = this._splitSafely(r, d);
+            for (let c = 0, f = u.length; c < f; c++)
+              s.push(u[c]);
+          }
+          if (!l.isAnEndpoint(d)) {
+            const u = this._splitSafely(l, d);
+            for (let c = 0, f = u.length; c < f; c++)
+              s.push(u[c]);
+          }
+        }
+      }
+      this.tree.remove(n);
+    }
+    return s;
+  }
+  /* Safely split a segment that is currently in the datastructures
+   * IE - a segment other than the one that is currently being processed. */
+  _splitSafely(t, n) {
+    this.tree.remove(t);
+    const s = t.rightSE;
+    this.queue.remove(s);
+    const o = t.split(n);
+    return o.push(s), t.consumedBy === void 0 && this.tree.add(t), o;
+  }
+}
+const He = typeof process < "u" && process.env.POLYGON_CLIPPING_MAX_QUEUE_SIZE || 1e6, Jn = typeof process < "u" && process.env.POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS || 1e6;
+class Kn {
+  run(t, n, s) {
+    K.type = t, Bt.reset();
+    const o = [new Ue(n, !0)];
+    for (let c = 0, f = s.length; c < f; c++)
+      o.push(new Ue(s[c], !1));
+    if (K.numMultiPolys = o.length, K.type === "difference") {
+      const c = o[0];
+      let f = 1;
+      for (; f < o.length; )
+        be(o[f].bbox, c.bbox) !== null ? f++ : o.splice(f, 1);
+    }
+    if (K.type === "intersection")
+      for (let c = 0, f = o.length; c < f; c++) {
+        const h = o[c];
+        for (let p = c + 1, m = o.length; p < m; p++)
+          if (be(h.bbox, o[p].bbox) === null) return [];
+      }
+    const i = new Ee(J.compare);
+    for (let c = 0, f = o.length; c < f; c++) {
+      const h = o[c].getSweepEvents();
+      for (let p = 0, m = h.length; p < m; p++)
+        if (i.insert(h[p]), i.size > He)
+          throw new Error("Infinite loop when putting segment endpoints in a priority queue (queue size too big).");
+    }
+    const a = new qn(i);
+    let r = i.size, l = i.pop();
+    for (; l; ) {
+      const c = l.key;
+      if (i.size === r) {
+        const h = c.segment;
+        throw new Error(`Unable to pop() ${c.isLeft ? "left" : "right"} SweepEvent [${c.point.x}, ${c.point.y}] from segment #${h.id} [${h.leftSE.point.x}, ${h.leftSE.point.y}] -> [${h.rightSE.point.x}, ${h.rightSE.point.y}] from queue.`);
+      }
+      if (i.size > He)
+        throw new Error("Infinite loop when passing sweep line over endpoints (queue size too big).");
+      if (a.segments.length > Jn)
+        throw new Error("Infinite loop when passing sweep line over endpoints (too many sweep line segments).");
+      const f = a.process(c);
+      for (let h = 0, p = f.length; h < p; h++) {
+        const m = f[h];
+        m.consumedBy === void 0 && i.insert(m);
+      }
+      r = i.size, l = i.pop();
+    }
+    Bt.reset();
+    const d = Kt.factory(a.segments);
+    return new Xn(d).getGeom();
+  }
+}
+const K = new Kn(), Qn = function(e) {
+  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), s = 1; s < t; s++)
+    n[s - 1] = arguments[s];
+  return K.run("union", e, n);
+}, to = function(e) {
+  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), s = 1; s < t; s++)
+    n[s - 1] = arguments[s];
+  return K.run("intersection", e, n);
+}, eo = function(e) {
+  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), s = 1; s < t; s++)
+    n[s - 1] = arguments[s];
+  return K.run("xor", e, n);
+}, no = function(e) {
+  for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), s = 1; s < t; s++)
+    n[s - 1] = arguments[s];
+  return K.run("difference", e, n);
+};
+var ct = {
+  union: Qn,
+  intersection: to,
+  xor: eo,
+  difference: no
+};
+const oo = [
+  "zone",
+  "room",
+  "parcel",
+  "building",
+  "office",
+  "container",
+  "storage",
+  "door",
+  "window",
+  "gate",
+  "turnstile",
+  "reader",
+  "camera",
+  "elevator",
+  "stairs",
+  "poi",
+  "fixture",
+  "light",
+  "landscape",
+  "sensor",
+  "alarm",
+  "equipment",
+  "evacuation"
+], so = ["silent", "office", "backrooms", "plant", "baths", "elevator"], H = () => crypto.randomUUID(), pt = (e) => ["zone", "room", "parcel", "building", "office", "container", "storage", "evacuation"].includes(e), Rs = (e) => ["door", "gate", "turnstile", "reader", "camera", "elevator", "sensor", "alarm", "equipment"].includes(e), nn = (e) => e === "door" || e === "window" || e === "gate", et = (e) => pt(e) || e === "elevator" || e === "stairs", mt = (e, t) => JSON.stringify([e, t].sort());
+function on(e) {
+  var o;
+  const t = new Map((e.virtualBoundaries ?? []).map((i) => [i.id, i]));
+  if (!t.size) return [];
+  const n = /* @__PURE__ */ new Map();
+  for (const i of e.objects)
+    if (!(!et(i.kind) || ((o = i.geometry) == null ? void 0 : o.mode) !== "boundaries"))
+      for (const a of i.geometry.loops)
+        for (const r of a) {
+          const l = t.get(r.edgeId);
+          if (!l || l.floorId !== i.floorId) continue;
+          const d = n.get(l.id) ?? [];
+          d.some((u) => u.id === i.id) || d.push({ id: i.id, reversed: !!r.reversed }), n.set(l.id, d);
+        }
+  const s = /* @__PURE__ */ new Map();
+  for (const i of n.values())
+    for (let a = 0; a < i.length; a++)
+      for (let r = a + 1; r < i.length; r++) {
+        if (i[a].reversed === i[r].reversed) continue;
+        const [l, d] = [i[a].id, i[r].id].sort();
+        s.set(mt(l, d), { id: `open:${l}:${d}`, a: l, b: d, attests: "none" });
+      }
+  return [...s.values()];
+}
+function Dt(e) {
+  const t = on(e), n = new Set(t.map((l) => mt(l.a, l.b))), s = new Set(e.objects.filter((l) => {
+    var d;
+    return ((d = l.geometry) == null ? void 0 : d.mode) === "boundaries";
+  }).map((l) => l.id)), o = (e.portals ?? []).filter(
+    (l) => !l.id.startsWith("open:") || !s.has(l.a) || !s.has(l.b) || n.has(mt(l.a, l.b))
+  ), i = new Set(
+    o.filter((l) => !l.id.startsWith("open:") && !l.id.startsWith("inferred:")).map((l) => mt(l.a, l.b))
+  ), a = o.filter((l) => !l.id.startsWith("open:") || !i.has(mt(l.a, l.b))), r = new Set(a.map((l) => mt(l.a, l.b)));
+  return [...a, ...t.filter((l) => !r.has(mt(l.a, l.b)))];
+}
+function Ps(e, t) {
+  const n = e.passage ?? "both";
+  return n === "none" ? null : e.b === t && n !== "b-to-a" ? "a-to-b" : e.a === t && n !== "a-to-b" ? "b-to-a" : null;
+}
+const ee = (e, t, n = /* @__PURE__ */ new Set()) => {
+  var o;
+  if (n.has(t.id)) return /* @__PURE__ */ new Set();
+  n.add(t.id);
+  const s = new Set(t.spaceIds);
+  for (const i of t.childZoneIds ?? []) {
+    const a = (o = e.zones) == null ? void 0 : o.find((r) => r.id === i);
+    if (a) for (const r of ee(e, a, n)) s.add(r);
+  }
+  return s;
+}, io = (e, t) => [...ee(e, t)];
+function $s(e, t) {
+  const n = ee(e, t);
+  return Dt(e).filter((s) => n.has(s.a) !== n.has(s.b));
+}
+function Ns(e, t) {
+  const n = ee(e, t);
+  return Dt(e).filter((s) => n.has(s.a) && n.has(s.b));
+}
+function ro(e, t, n, s) {
+  const o = {
+    id: H(),
+    name: t,
+    spaceIds: [...new Set(n)].filter((i) => e.objects.some((a) => a.id === i && et(a.kind)))
+  };
+  return s && (o.purpose = s), (e.zones ?? (e.zones = [])).push(o), o;
+}
+function ao(e, t) {
+  var n;
+  e.zones = (e.zones ?? []).filter((s) => s.id !== t);
+  for (const s of e.zones)
+    (n = s.childZoneIds) != null && n.includes(t) && (s.childZoneIds = s.childZoneIds.filter((o) => o !== t));
+}
+function lo(e, t, n, s) {
+  var r;
+  const o = (r = e.zones) == null ? void 0 : r.find((l) => l.id === t);
+  if (!o) return;
+  const i = n.filter((l) => e.objects.some((d) => d.id === l && et(d.kind))), a = new Set(o.spaceIds);
+  for (const l of i)
+    s ? a.add(l) : a.delete(l);
+  o.spaceIds = [...a];
+}
+function co(e, t, n) {
+  var i, a;
+  const s = (i = e.zones) == null ? void 0 : i.find((r) => r.id === t);
+  if (!s || t === n || !((a = e.zones) != null && a.some((r) => r.id === n))) return !1;
+  const o = (r, l, d = /* @__PURE__ */ new Set()) => {
+    var u, c;
+    return r === l ? !0 : d.has(r) ? !1 : (d.add(r), (((c = (u = e.zones) == null ? void 0 : u.find((f) => f.id === r)) == null ? void 0 : c.childZoneIds) ?? []).some((f) => o(f, l, d)));
+  };
+  return o(n, t) ? !1 : (s.childZoneIds = [.../* @__PURE__ */ new Set([...s.childZoneIds ?? [], n])], !0);
+}
+function fo(e, t, n) {
+  e.portals = Dt(e);
+  const s = {
+    id: H(),
+    name: t,
+    portalIds: [...new Set(n)].filter((o) => (e.portals ?? []).some((i) => i.id === o))
+  };
+  return (e.portalGroups ?? (e.portalGroups = [])).push(s), s;
+}
+function uo(e, t) {
+  e.portalGroups = (e.portalGroups ?? []).filter((n) => n.id !== t);
+}
+function ho(e, t, n, s) {
+  var r;
+  const o = (r = e.portalGroups) == null ? void 0 : r.find((l) => l.id === t);
+  if (!o) return;
+  e.portals = Dt(e);
+  const i = n.filter((l) => (e.portals ?? []).some((d) => d.id === l)), a = new Set(o.portalIds);
+  for (const l of i)
+    s ? a.add(l) : a.delete(l);
+  o.portalIds = [...a];
+}
+function Nt(e) {
+  const t = new Set(e.objects.map((o) => o.id)), n = new Set(e.objects.filter((o) => et(o.kind)).map((o) => o.id));
+  e.portals && (e.portals = e.portals.filter(
+    (o) => n.has(o.a) && n.has(o.b) && (!o.openingId || t.has(o.openingId))
+  ));
+  const s = new Set((e.portals ?? []).map((o) => o.id));
+  if (e.zones) {
+    const o = new Set(e.zones.map((i) => i.id));
+    for (const i of e.zones)
+      i.spaceIds = i.spaceIds.filter((a) => n.has(a)), i.childZoneIds && (i.childZoneIds = i.childZoneIds.filter((a) => o.has(a)));
+  }
+  if (e.portalGroups)
+    for (const o of e.portalGroups) o.portalIds = o.portalIds.filter((i) => s.has(i));
+}
+const Me = /* @__PURE__ */ new Set(["door", "gate", "turnstile"]), go = (e) => `space:${e}`;
+function mo(e, t, n) {
+  const s = e.floorId === t.floorId;
+  return !s && e.floorId !== null && t.floorId !== null ? e.kind === "elevator" || t.kind === "elevator" ? "elevator" : "stairs" : s ? n && Me.has(n.kind) ? "door" : "walk" : "door";
+}
+function po(e) {
+  const t = new Map(e.objects.map((r) => [r.id, r])), n = new Map(e.floors.map((r) => [r.id, r])), s = /* @__PURE__ */ new Map(), o = (r) => {
+    const l = go(r.id), d = s.get(l);
+    if (d) return d;
+    const u = { id: l, floorId: r.floorId, position: ds(e, r), objectId: r.id };
+    return s.set(l, u), u;
+  };
+  for (const r of e.objects) et(r.kind) && o(r);
+  const i = [], a = (r, l, d, u, c, f = !1) => {
+    if (d.id === u.id) return;
+    const h = { id: r, kind: l, aId: o(d).id, bId: o(u).id };
+    c && (h.objectId = c), f && (h.directed = !0), i.push(h);
+  };
+  for (const r of Dt(e)) {
+    if ((r.passage ?? "both") === "none") continue;
+    const l = t.get(r.a), d = t.get(r.b);
+    if (!l || !d) continue;
+    const u = r.openingId ? t.get(r.openingId) : void 0, c = mo(l, d, u), f = u && (c === "door" ? Me.has(u.kind) : c === "walk" ? !1 : u.kind === c), h = r.passage ?? "both", [p, m] = h === "b-to-a" ? [d, l] : [l, d];
+    a(`portal:${r.id}`, c, p, m, f ? u.id : void 0, h !== "both");
+  }
+  for (const r of e.zones ?? []) {
+    if (!r.connects) continue;
+    const l = io(e, r).map((c) => t.get(c)).filter((c) => !!c && c.floorId !== null).sort((c, f) => {
+      var h, p;
+      return (((h = n.get(c.floorId)) == null ? void 0 : h.elevation) ?? 0) - (((p = n.get(f.floorId)) == null ? void 0 : p.elevation) ?? 0);
+    }), d = l.some((c) => c.kind === "elevator") ? "elevator" : "stairs", u = r.connects === "up" || r.connects === "down";
+    for (let c = 1; c < l.length; c++)
+      for (let f = r.connects === "all" ? 0 : c - 1; f < c; f++)
+        l[f].floorId !== l[c].floorId && a(
+          `zone:${r.id}:${f}:${c}`,
+          d,
+          r.connects === "down" ? l[c] : l[f],
+          r.connects === "down" ? l[f] : l[c],
+          l[c].kind === d ? l[c].id : void 0,
+          u
+        );
+  }
+  return { nodes: [...s.values()], edges: i };
+}
+const We = /* @__PURE__ */ new WeakMap();
+function sn(e) {
+  const t = We.get(e);
+  if (t) return t;
+  const n = po(e);
+  return We.set(e, n), n;
+}
+const zt = (e) => e === "stairs" || e === "elevator", It = (e) => `${e.kind}|${e.name}|${e.position[0].toFixed(2)}|${e.position[1].toFixed(2)}`;
+function wt(e, t) {
+  const n = It(t), s = e.objects.filter((o) => zt(o.kind) && It(o) === n).flatMap((o) => {
+    var i;
+    return (i = o.servedFloorIds) != null && i.length ? o.servedFloorIds : o.floorId ? [o.floorId] : [];
+  });
+  return [...new Set(s.length ? s : t.floorId ? [t.floorId] : [])].map((o) => e.floors.find((i) => i.id === o)).filter((o) => !!o).sort((o, i) => o.elevation - i.elevation);
+}
+function Se(e, t) {
+  const n = wt(e, t), s = [];
+  for (let o = 1; o < n.length; o++)
+    s.push({ from: n[o - 1], to: n[o], rise: n[o].elevation - n[o - 1].elevation });
+  return s;
+}
+const Os = (e, t, n) => n !== null && (t.floorId === n || wt(e, t).some((s) => s.id === n));
+function Bs(e, t, n) {
+  const s = Se(e, t);
+  return {
+    up: s.find((o) => o.from.id === n),
+    down: s.find((o) => o.to.id === n)
+  };
+}
+function zs(e, t) {
+  const n = wt(e, t);
+  return n.length < 2 ? null : { bottom: n[0].elevation, top: n[n.length - 1].elevation };
+}
+const rn = { escalator: 30, stairs: 32 }, Io = (e, t = rn.stairs) => e / Math.tan(t * Math.PI / 180), bo = (e, t) => t > 0 ? Math.atan(e / t) * 180 / Math.PI : 90, yo = 0.32, wo = 0.175, vo = 2.1;
+function xo(e, t) {
+  const n = Math.max(2, Math.min(24, Math.round(e / wo)));
+  return { steps: n, going: Math.min(yo, t / n) };
+}
+function Eo(e, t) {
+  if (t.stairModel) return t.stairModel;
+  const n = Se(e, t)[0];
+  return n && bo(n.rise, Math.max(0.6, t.depth)) > 38 ? "switchback" : "straight";
+}
+const Mo = (e, t) => e === "escalator" && t % 2 === 1;
+function So(e, t, n, s, o = 0) {
+  const i = yt(e, t), a = xn(e, t) + (Mo(s, o) ? 180 : 0), r = a * Math.PI / 180, l = Math.sin(r), d = -Math.cos(r), u = (I) => [i[0] + l * I, i[1] + d * I], c = Math.max(0.6, t.depth), f = c / 2;
+  if (s === "escalator") {
+    const I = Math.min(1, c / 4), b = Math.min(c - I * 2, Math.max(0.4, Io(n, rn.escalator)));
+    return { rotation: a, at: u, length: c, half: f, pad: I, incline: b, topT: -f + I, footT: -f + I + b };
+  }
+  const { steps: h, going: p } = xo(n, c), m = Math.min(c, h * p);
+  return { rotation: a, at: u, length: c, half: f, pad: 0, incline: m, topT: f - m, footT: f };
+}
+function ko(e, t, n, s) {
+  const o = t > 0.01 ? e.incline / t : e.incline, a = Math.min(e.footT, Math.max(e.topT + 0.6, e.footT - n * o + vo * o)) - e.topT;
+  return C(Zt(e.at(e.topT + a / 2), s, a, e.rotation));
+}
+function Fs(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e.objects) {
+    if (!zt(n.kind)) continue;
+    const s = It(n), o = t.get(s), i = (a) => {
+      var r;
+      return ((r = e.floors.find((l) => l.id === a.floorId)) == null ? void 0 : r.elevation) ?? 0;
+    };
+    (!o || i(n) < i(o)) && t.set(s, n);
+  }
+  return new Set([...t.values()].map((n) => n.id));
+}
+function Ao(e, t, n) {
+  const s = e.floors.find((i) => i.id === n);
+  if (!s) return !1;
+  const o = wt(e, t);
+  return o.some((i) => i.elevation < s.elevation - 0.01) && o.some((i) => i.elevation >= s.elevation - 0.01);
+}
+function _o(e, t, n) {
+  const s = e.floors.find((i) => i.id === n);
+  if (!s) return !1;
+  const o = wt(e, t);
+  return o.some((i) => i.elevation <= s.elevation + 0.01) && o.some((i) => i.elevation > s.elevation + 0.01);
+}
+const Ts = (e, t, n) => Ao(e, t, n) && _o(e, t, n);
+function Cs(e, t, n, s = {}) {
+  const o = e.floors.find((d) => d.id === t);
+  if (!o) return [];
+  const i = s.through === "ceiling", a = s.lowest ?? -1 / 0, r = [], l = /* @__PURE__ */ new Map();
+  for (const d of e.objects) {
+    if (!zt(d.kind) || n && !n.has(d.id)) continue;
+    const u = Se(e, d), c = i ? u.findIndex((m) => m.from.elevation <= o.elevation + 0.01 && m.to.elevation > o.elevation + 0.01) : u.findIndex((m) => m.from.elevation < o.elevation - 0.01 && m.to.elevation >= o.elevation - 0.01);
+    if (c < 0) continue;
+    const f = u[c];
+    if (f.from.elevation < a) continue;
+    if (d.kind === "stairs" && d.wellGroup) {
+      const m = l.get(d.wellGroup) ?? [];
+      m.push(d), l.set(d.wellGroup, m);
+      continue;
+    }
+    const h = Eo(e, d);
+    if (d.kind === "stairs" && (h === "straight" || h === "escalator")) {
+      const m = So(e, d, f.rise, h, c), I = o.elevation + (i ? o.height : 0) - f.from.elevation;
+      r.push(ko(m, f.rise, I, d.width));
+      continue;
+    }
+    const p = W(d)[0];
+    p != null && p.length && r.push(C(p.map((m) => [m[0], m[1]])));
+  }
+  for (const d of l.values()) {
+    const u = xn(e, d[0]), c = d.flatMap((w) => W(w)[0]).map((w) => Lt(w, -u)), f = c.map((w) => w[0]), h = c.map((w) => w[1]), p = Math.min(...f), m = Math.max(...f), I = Math.min(...h), b = Math.max(...h);
+    r.push(Zt(Lt([(p + m) / 2, (I + b) / 2], u), m - p, b - I, u));
+  }
+  return r;
+}
+const Ot = 0.4, Vt = (e, t = 0) => [
+  Math.min(...e.map((n) => n[0])) - t,
+  Math.min(...e.map((n) => n[1])) - t,
+  Math.max(...e.map((n) => n[0])) + t,
+  Math.max(...e.map((n) => n[1])) + t
+], de = (e, t) => e[0] <= t[2] && e[2] >= t[0] && e[1] <= t[3] && e[3] >= t[1], Ro = (e, t, n, s) => Qt(e, t, n, s) ? 0 : Math.min(
+  G(e, n, s).distance,
+  G(t, n, s).distance,
+  G(n, e, t).distance,
+  G(s, e, t).distance
+);
+function an(e) {
+  const t = new Map(e.junctions.map((i) => [i.id, i.position])), n = /* @__PURE__ */ new Map();
+  for (const i of e.objects) {
+    if (!i.barrierId || i.kind !== "door" && i.kind !== "gate") continue;
+    const a = n.get(i.barrierId) ?? [];
+    a.push([(i.offset ?? 0) - i.width / 2, (i.offset ?? 0) + i.width / 2]), n.set(i.barrierId, a);
+  }
+  const s = /* @__PURE__ */ new Map();
+  for (const i of e.barriers) {
+    const a = t.get(i.startId), r = t.get(i.endId);
+    if (!a || !r) continue;
+    const l = S(a, r);
+    if (!l) continue;
+    const d = (m) => [a[0] + (r[0] - a[0]) * m / l, a[1] + (r[1] - a[1]) * m / l], u = s.get(i.floorId) ?? [], c = (a[1] - r[1]) / l * i.thickness / 2, f = (r[0] - a[0]) / l * i.thickness / 2, h = (m, I) => {
+      if (I <= m) return;
+      const b = d(m), w = d(I), g = [
+        [b[0] + c, b[1] + f],
+        [w[0] + c, w[1] + f],
+        [w[0] - c, w[1] - f],
+        [b[0] - c, b[1] - f]
+      ];
+      u.push({ ring: g, bounds: Vt(g, Ot) });
+    };
+    let p = 0;
+    for (const [m, I] of (n.get(i.id) ?? []).sort((b, w) => b[0] - w[0]))
+      h(p, Math.min(l, Math.max(0, m))), p = Math.max(p, Math.min(l, I));
+    h(p, l), s.set(i.floorId, u);
+  }
+  const o = /* @__PURE__ */ new Map();
+  for (const i of e.objects) {
+    const a = i.water ? W(i).slice(0, 1) : i.kind === "room" || i.kind === "zone" ? W(i).slice(1) : [], r = o.get(i.floorId) ?? [];
+    for (const l of a) r.push({ ring: T(l), bounds: Vt(l, Ot) });
+    o.set(i.floorId, r);
+  }
+  return (i, a) => {
+    const r = (s.get(i) ?? []).filter((u) => !a || de(a, u.bounds)), l = (o.get(i) ?? []).filter((u) => !a || de(a, u.bounds)), d = [...r, ...l];
+    return (u, c) => {
+      const f = Vt([u, c]);
+      for (const h of d)
+        if (de(f, h.bounds)) {
+          if (D(u, h.ring) || D(c, h.ring)) return !1;
+          for (let p = 0; p < h.ring.length; p++)
+            if (Ro(u, c, h.ring[p], h.ring[(p + 1) % h.ring.length]) < Ot - 1e-7) return !1;
+        }
+      return !0;
+    };
+  };
+}
+const je = /* @__PURE__ */ new WeakMap();
+function Po(e) {
+  let t = je.get(e);
+  return t || (t = an(e), je.set(e, t)), t;
+}
+const $o = 25, No = 1, Oo = 5, Bo = 1.5, zo = 0.25, Ft = (e) => e.navNodes ?? sn(e).nodes, ln = (e) => e.navEdges ?? sn(e).edges, dn = (e, t) => t === null ? null : e.floors.find((n) => n.id === t) ?? null, ft = (e, t) => {
+  var n;
+  return ((n = dn(e, t)) == null ? void 0 : n.elevation) ?? 0;
+};
+function cn(e, t, n, s) {
+  e.navNodes ?? (e.navNodes = []);
+  const o = e.navNodes.find((a) => a.floorId === t && S(a.position, n) < zo);
+  if (o)
+    return s && !o.objectId && (o.objectId = s), o;
+  const i = { id: H(), floorId: t, position: [n[0], n[1]] };
+  return s && (i.objectId = s), e.navNodes.push(i), i;
+}
+function fn(e, t, n, s, o) {
+  e.navEdges ?? (e.navEdges = []);
+  const i = e.navEdges.find(
+    (r) => r.kind === t && (r.aId === n.id && r.bId === s.id || r.aId === s.id && r.bId === n.id)
+  );
+  if (i)
+    return o && !i.objectId && (i.objectId = o), i;
+  const a = { id: H(), kind: t, aId: n.id, bId: s.id };
+  return o && (a.objectId = o), e.navEdges.push(a), a;
+}
+function Ls(e, t, n) {
+  const s = n.map((o) => cn(e, t, o));
+  for (let o = 1; o < s.length; o++) s[o - 1].id !== s[o].id && fn(e, "walk", s[o - 1], s[o]);
+  return s;
+}
+function Gs(e, t) {
+  const n = t.kind === "elevator" ? "elevator" : "stairs", s = t.stairModel === "escalator" ? t.travel ?? "up" : null, o = wt(e, t), i = It(t), a = /* @__PURE__ */ new Map();
+  for (const d of e.objects)
+    d.kind === t.kind && It(d) === i && !a.has(d.floorId) && a.set(d.floorId, d);
+  const r = (d) => a.get(d) ?? t, l = o.map((d) => {
+    const u = r(d.id);
+    return cn(e, d.id, yt(e, u), u.id);
+  });
+  for (let d = 1; d < l.length; d++)
+    for (let u = n === "elevator" ? 0 : d - 1; u < d; u++) {
+      if (l[u].id === l[d].id) continue;
+      const [c, f] = s === "down" ? [l[d], l[u]] : [l[u], l[d]], h = fn(e, n, c, f, r(l[d].floorId).id);
+      s && (h.directed = !0);
+    }
+  return l;
+}
+const Ds = "@here";
+function Ye(e, t, n, s) {
+  if (t.weight !== void 0) return t.weight;
+  const o = S(n.position, s.position), i = Math.abs(ft(e, n.floorId) - ft(e, s.floorId));
+  return t.kind === "elevator" ? $o + i * No : t.kind === "stairs" ? o + i * Oo : o + (t.kind === "door" ? Bo : 0);
+}
+function Xt(e, t, n, s) {
+  const o = t.kind === "stairs" || t.kind === "elevator" ? Math.abs(ft(e, n.floorId) - ft(e, s.floorId)) : 0;
+  return S(n.position, s.position) + o;
+}
+function Fo(e, t) {
+  const n = Ft(e).filter((r) => r.objectId === t.id);
+  if (n.length) return n.map((r) => ({ node: r, cost: 0 }));
+  const s = yt(e, t), o = Ft(e).filter((r) => r.floorId === t.floorId), i = t.rings ? o.filter(
+    (r) => D(r.position, t.rings[0]) && !t.rings.slice(1).some((l) => D(r.position, l))
+  ) : [];
+  if (i.length) return i.map((r) => ({ node: r, cost: S(s, r.position) }));
+  const a = o.map((r) => ({ node: r, cost: S(s, r.position) })).sort((r, l) => r.cost - l.cost)[0];
+  return a ? [a] : [];
+}
+function Ve(e, t, n) {
+  if (typeof t == "string") {
+    const d = e.objects.find((u) => u.id === t);
+    return d ? { place: d, anchors: Fo(e, d), extraNodes: [], extraEdges: [] } : null;
+  }
+  const s = { id: `@${n}`, floorId: t.floorId, position: t.position }, o = Ft(e).filter((d) => d.floorId === t.floorId), i = ve(e, t.floorId, t.position), a = Po(e)(t.floorId);
+  let r = i ? o.filter((d) => Rt(i, d.position) && a(t.position, d.position)) : [];
+  if (!i) {
+    const d = o.filter((u) => a(t.position, u.position)).sort((u, c) => S(u.position, t.position) - S(c.position, t.position))[0];
+    r = d ? [d] : [];
+  }
+  const l = r.map(
+    (d, u) => ({
+      id: `@${n}-${u}`,
+      kind: "walk",
+      aId: s.id,
+      bId: d.id,
+      weight: S(t.position, d.position)
+    })
+  );
+  return {
+    place: {
+      id: `@${n}`,
+      kind: "poi",
+      name: t.name ?? "Where you are",
+      floorId: t.floorId,
+      position: t.position
+    },
+    anchors: [{ node: s, cost: 0 }],
+    extraNodes: [s],
+    extraEdges: l
+  };
+}
+function Us(e, t, n, s = {}) {
+  var $;
+  const o = Ve(e, t, "from"), i = Ve(e, n, "to");
+  if (!o || !i) return null;
+  const a = o.place, r = i.place, l = o.anchors, d = i.anchors;
+  if (!l.length || !d.length) return null;
+  const u = [...Ft(e), ...o.extraNodes, ...i.extraNodes], c = new Map(u.map((x) => [x.id, x])), f = /* @__PURE__ */ new Map();
+  for (const x of [...ln(e), ...o.extraEdges, ...i.extraEdges]) {
+    const E = c.get(x.aId), A = c.get(x.bId);
+    if (!E || !A) continue;
+    const v = x.kind === "stairs" && x.objectId ? e.objects.find((R) => R.id === x.objectId && R.stairModel === "escalator") : void 0, k = v != null && v.feedId ? ($ = s.statuses) == null ? void 0 : $.get(v.feedId) : void 0;
+    if (v && (k != null && k.travel || (k == null ? void 0 : k.running) === !1)) {
+      const R = ft(e, A.floorId) > ft(e, E.floorId), P = (k.travel ?? v.travel ?? "up") === (R ? "up" : "down");
+      (k.running === !1 || P) && (f.get(E.id) ?? f.set(E.id, []).get(E.id)).push({ edge: x, other: A }), (k.running === !1 || !P) && (f.get(A.id) ?? f.set(A.id, []).get(A.id)).push({ edge: x, other: E });
+      continue;
+    }
+    (f.get(E.id) ?? f.set(E.id, []).get(E.id)).push({ edge: x, other: A }), x.directed || (f.get(A.id) ?? f.set(A.id, []).get(A.id)).push({ edge: x, other: E });
+  }
+  const h = new To(), p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Set();
+  for (const x of l)
+    x.cost < (p.get(x.node.id) ?? 1 / 0) && (p.set(x.node.id, x.cost), h.push(x.node.id, x.cost));
+  const b = new Map(d.map((x) => [x.node.id, x.cost]));
+  let w = 1 / 0;
+  for (; ; ) {
+    const x = h.pop();
+    if (!x || x.cost > w) break;
+    const { id: E, cost: A } = x;
+    if (I.has(E)) continue;
+    I.add(E), b.has(E) && (w = Math.min(w, A + b.get(E)));
+    const v = c.get(E);
+    for (const { edge: k, other: R } of f.get(E) ?? []) {
+      const P = A + Ye(e, k, v, R);
+      P < (p.get(R.id) ?? 1 / 0) && (p.set(R.id, P), m.set(R.id, { node: v, edge: k }), h.push(R.id, P));
+    }
+  }
+  const g = d.map((x) => ({ ...x, total: (p.get(x.node.id) ?? 1 / 0) + x.cost })).sort((x, E) => x.total - E.total)[0];
+  if (!g || !Number.isFinite(g.total)) return null;
+  const y = [];
+  for (let x = g.node; ; ) {
+    const E = m.get(x.id);
+    if (!E) break;
+    y.unshift({ edge: E.edge, from: E.node, to: x, cost: Ye(e, E.edge, E.node, x) }), x = E.node;
+  }
+  const M = [y.length ? y[0].from : g.node, ...y.map((x) => x.to)], _ = y.reduce((x, E) => x + Xt(e, E.edge, E.from, E.to), 0);
+  return {
+    from: a,
+    to: r,
+    nodes: M,
+    legs: y,
+    steps: Co(e, a, r, M, y),
+    distance: _,
+    cost: g.total
+  };
+}
+class To {
+  constructor() {
+    re(this, "items", []);
+    re(this, "order", 0);
+  }
+  before(t, n) {
+    return t.cost < n.cost || t.cost === n.cost && t.order < n.order;
+  }
+  push(t, n) {
+    const s = { id: t, cost: n, order: this.order++ };
+    let o = this.items.length;
+    for (this.items.push(s); o > 0; ) {
+      const i = o - 1 >> 1;
+      if (!this.before(s, this.items[i])) break;
+      this.items[o] = this.items[i], o = i;
+    }
+    this.items[o] = s;
+  }
+  pop() {
+    const t = this.items[0], n = this.items.pop();
+    if (this.items.length && n) {
+      let s = 0;
+      for (; s * 2 + 1 < this.items.length; ) {
+        let o = s * 2 + 1;
+        if (o + 1 < this.items.length && this.before(this.items[o + 1], this.items[o]) && o++, !this.before(this.items[o], n)) break;
+        this.items[s] = this.items[o], s = o;
+      }
+      this.items[s] = n;
+    }
+    return t;
+  }
+}
+function ce(e, t) {
+  const n = dn(e, t);
+  return n ? n.code ? `${n.name} (level ${n.code})` : n.name : "outside";
+}
+const fe = (e, t, n) => {
+  var s;
+  return ((s = e.objects.find((o) => o.id === t.edge.objectId)) == null ? void 0 : s.name) ?? n;
+};
+function Co(e, t, n, s, o) {
+  const i = [
+    {
+      kind: "depart",
+      text: `Start at ${t.name}${t.floorId !== null ? ` on ${ce(e, t.floorId)}` : ""}`,
+      floorId: t.floorId,
+      nodeIds: s.length ? [s[0].id] : []
+    }
+  ];
+  for (let a = 0; a < o.length; a++) {
+    const r = o[a];
+    if (r.edge.kind === "walk") {
+      let l = Xt(e, r.edge, r.from, r.to);
+      const d = [r.from.id, r.to.id];
+      for (; a + 1 < o.length && o[a + 1].edge.kind === "walk"; )
+        a++, l += Xt(e, o[a].edge, o[a].from, o[a].to), d.push(o[a].to.id);
+      i.push({
+        kind: "walk",
+        text: `Walk ${Math.max(1, Math.round(l))} m ${o[a].to.floorId === null ? "outside" : `along ${ce(e, r.from.floorId)}`}`,
+        floorId: r.from.floorId,
+        nodeIds: d,
+        distance: l
+      });
+    } else if (r.edge.kind === "door") {
+      const l = fe(e, r, "the door"), d = r.to.floorId === null && r.from.floorId !== null ? `Exit through ${l}` : r.from.floorId === null && r.to.floorId !== null ? `Enter through ${l}` : `Go through ${l}`;
+      i.push({
+        kind: "door",
+        text: d,
+        floorId: r.to.floorId,
+        nodeIds: [r.from.id, r.to.id],
+        objectId: r.edge.objectId,
+        distance: Xt(e, r.edge, r.from, r.to)
+      });
+    } else {
+      const l = r.edge.kind, d = fe(e, r, l === "elevator" ? "the lift" : "the stairs"), u = [r.from.id, r.to.id], c = r.from;
+      let f = r.to, h = r.edge.objectId;
+      for (; a + 1 < o.length && o[a + 1].edge.kind === l && fe(e, o[a + 1], d) === d; )
+        a++, f = o[a].to, u.push(f.id), h = o[a].edge.objectId ?? h;
+      const p = ft(e, f.floorId) - ft(e, c.floorId), m = l === "stairs" && !/\b(up|down)\b/i.test(d) ? `${p > 0 ? "up " : "down "}` : "";
+      i.push({
+        kind: l,
+        text: `Take ${d} ${m}to ${ce(e, f.floorId)}`,
+        floorId: f.floorId,
+        nodeIds: u,
+        objectId: h
+      });
+    }
+  }
+  return i.push({
+    kind: "arrive",
+    text: `Arrive at ${n.name}`,
+    floorId: n.floorId,
+    nodeIds: s.length ? [s[s.length - 1].id] : []
+  }), i;
+}
+const Lo = {
+  limestone: { name: "Limestone", material: "stone", color: "#e2e4e6" },
+  brick: { name: "Warm brick", material: "brick", color: "#9b705b" },
+  darkBrick: { name: "Dark brick", material: "brick", color: "#7a4636" },
+  plaster: { name: "Ivory render", material: "plaster", color: "#e0ddd4" },
+  timber: { name: "Cedar cladding", material: "timber", color: "#ab8b68" }
+}, N = 1e-6, ut = 1e-3, un = 0.01, ne = 1e-3, kt = 1, ke = 1e-8, at = 1e4, Go = 1e5, B = (e) => typeof e == "number" && Number.isFinite(e), St = (e) => Array.isArray(e) && e.length === 2 && e.every((t) => B(t) && Math.abs(t) <= Go), st = (e) => !!e && typeof e == "object" && !Array.isArray(e), Y = (e) => typeof e == "string" && e.length > 0, Mt = (e) => new Set(e).size === e.length;
+function hn(e, t = 1e-3, n = 0.01) {
+  if (!e.length) return "Draw an outer boundary first.";
+  for (const s of e) {
+    const o = T(s);
+    if (o.length < 3 || V(o) < n) return "An area needs at least three vertices and a non-zero area.";
+    for (let i = 0; i < o.length; i++) {
+      if (S(o[i], o[(i + 1) % o.length]) < t) return "Remove duplicate vertices.";
+      for (let a = i + 1; a < o.length; a++)
+        if (!(a === i + 1 || i === 0 && a === o.length - 1) && Qt(o[i], o[(i + 1) % o.length], o[a], o[(a + 1) % o.length]))
+          return "Area boundaries cannot cross themselves.";
+    }
+  }
+  for (let s = 1; s < e.length; s++) {
+    if (!e[s].every((o) => D(o, e[0]))) return "A hole must be completely inside the outer boundary.";
+    for (let o = 0; o < s; o++) {
+      const i = T(e[s]), a = T(e[o]);
+      for (let r = 0; r < i.length; r++)
+        for (let l = 0; l < a.length; l++)
+          if (Qt(i[r], i[(r + 1) % i.length], a[l], a[(l + 1) % a.length]))
+            return "Hole boundaries must not touch or overlap.";
+      if (o > 0 && (D(i[0], a) || D(a[0], i))) return "Holes cannot overlap.";
+    }
+  }
+  return null;
+}
+function Do(e) {
+  var o;
+  const t = new Map(e.objects.map((i) => [i.id, i])), n = new Map(e.barriers.map((i) => [i.id, i])), s = /* @__PURE__ */ new Map();
+  for (const i of e.objects) {
+    if (!i.barrierId) continue;
+    const a = s.get(i.barrierId) ?? [];
+    a.push(i), s.set(i.barrierId, a);
+  }
+  for (const i of e.barriers) {
+    const [a, r] = X(e, i);
+    if (S(a, r) < tt - 1e-6) return `A wall or fence must be at least ${tt} m long.`;
+  }
+  for (const i of e.objects) {
+    if (i.rings) {
+      const a = ((o = i.geometry) == null ? void 0 : o.mode) === "boundaries", r = hn(i.rings, a ? 1e-6 : 1e-3, a ? ke : 0.01);
+      if (r) return r;
+    }
+    if (i.parentId) {
+      const a = t.get(i.parentId);
+      if (!(a != null && a.rings) || !i.rings || a.floorId !== i.floorId || !is(i.rings, a.rings))
+        return "A nested zone must remain inside its parent on the same floor.";
+      const r = /* @__PURE__ */ new Set([i.id]);
+      let l = a;
+      for (; l; ) {
+        if (r.has(l.id)) return "Zone parents cannot form a cycle.";
+        r.add(l.id), l = l.parentId ? t.get(l.parentId) : void 0;
+      }
+    }
+    if (i.barrierId) {
+      if (!nn(i.kind)) return "Only a door, window or gate can sit in a barrier.";
+      const a = n.get(i.barrierId);
+      if (!a || a.floorId !== i.floorId)
+        return "Opening references a missing barrier or a different floor.";
+      const [r, l] = X(e, a);
+      if (S(r, l) < te - 1e-6)
+        return `A door, window or gate needs a segment at least ${te} m long to sit in.`;
+      const d = i.offset ?? 0;
+      if (d - i.width / 2 < -1e-3 || d + i.width / 2 > S(r, l) + 1e-3)
+        return `The barrier is too short for its attached opening. Opening "${i.name || i.id}" (${i.id}) on barrier ${a.id}: width ${i.width.toFixed(2)} m, centre offset ${d.toFixed(2)} m, segment length ${S(r, l).toFixed(2)} m. The centre offset must be between ${(i.width / 2).toFixed(2)} and ${(S(r, l) - i.width / 2).toFixed(2)} m; if that interval is empty, choose a longer host segment.`;
+      if (s.get(a.id).some((u) => u.id !== i.id && Math.abs((u.offset ?? 0) - d) < (u.width + i.width) / 2 - 1e-3))
+        return "Attached openings cannot overlap.";
+    }
+  }
+  return null;
+}
+function Uo(e) {
+  const t = Ft(e), n = new Map(t.map((i) => [i.id, i])), s = new Map(e.objects.map((i) => [i.id, i])), o = new Set(e.floors.map((i) => i.id));
+  for (const i of t) {
+    if (!St(i.position)) return "A route node needs a valid position.";
+    if (i.floorId !== null && !o.has(i.floorId)) return "A route node references an unknown floor.";
+    if (i.objectId !== void 0 && !s.has(i.objectId)) return "A route node references a missing object.";
+  }
+  for (const i of ln(e)) {
+    if (!["walk", "door", "stairs", "elevator"].includes(i.kind)) return "Unknown route edge kind.";
+    const a = n.get(i.aId), r = n.get(i.bId);
+    if (!a || !r || i.aId === i.bId) return "A route edge must join two different route nodes.";
+    if (i.weight !== void 0 && (typeof i.weight != "number" || !Number.isFinite(i.weight) || i.weight <= 0))
+      return "A route edge weight must be a positive number.";
+    const l = i.kind === "stairs" || i.kind === "elevator";
+    if (l && a.floorId === r.floorId) return "Stairs and elevator edges must join different floors.";
+    if (i.kind === "walk" && a.floorId !== r.floorId) return "Walk edges must stay on one floor.";
+    if (i.kind === "door" && a.floorId !== r.floorId && a.floorId !== null && r.floorId !== null)
+      return "Door edges must stay on one floor or step outside.";
+    if (i.objectId === void 0) continue;
+    const d = s.get(i.objectId);
+    if (!d) return "A route edge references a missing object.";
+    if (i.kind === "door" && !["door", "gate", "turnstile"].includes(d.kind))
+      return "A door edge must bind a door, gate or turnstile.";
+    if (l && d.kind !== i.kind) return "A vertical edge must bind a matching stairs or elevator object.";
+    if (l && d.servedFloorIds && [a, r].some((u) => u.floorId !== null && !d.servedFloorIds.includes(u.floorId)))
+      return "A vertical edge joins a floor its stairs or elevator does not serve.";
+  }
+  return null;
+}
+function Ae(e) {
+  const t = (g) => {
+    throw new Error(`Invalid project: ${g}`);
+  };
+  (!st(e) || e.schemaVersion !== 1) && t(
+    "unsupported schema version (expected 1). The schema is still changing before release — re-create the project."
+  );
+  const n = e, s = (g) => Array.isArray(g) && (g.length === 2 || g.length === 3) && g.every(B) && Math.abs(g[0]) <= 180 && Math.abs(g[1]) <= 90;
+  (!Y(n.id) || !Y(n.name) || !s(n.origin) || typeof n.description != "string" || typeof n.datum != "string" || !Y(n.updatedAt)) && t("missing project metadata.");
+  for (const g of ["buildings", "floors", "junctions", "barriers", "objects", "drawings"])
+    (!Array.isArray(n[g]) || n[g].some((y) => !st(y) || !Y(y.id))) && t(`malformed ${g}.`);
+  for (const g of ["navNodes", "navEdges", "zones", "portals", "portalGroups", "virtualBoundaries"])
+    n[g] !== void 0 && (!Array.isArray(n[g]) || n[g].some((y) => !st(y) || !Y(y.id))) && t(`malformed ${g}.`);
+  const o = n, i = [
+    ...o.buildings,
+    ...o.floors,
+    ...o.junctions,
+    ...o.barriers,
+    ...o.virtualBoundaries ?? [],
+    ...o.objects,
+    ...o.drawings,
+    ...o.navNodes ?? [],
+    ...o.navEdges ?? [],
+    ...o.zones ?? [],
+    ...o.portals ?? [],
+    ...o.portalGroups ?? []
+  ];
+  new Set(i.map((g) => g.id)).size !== i.length && t("duplicate entity IDs.");
+  const a = new Set(o.floors.map((g) => g.id)), r = new Set(o.buildings.map((g) => g.id));
+  (!o.buildings.length || o.buildings.some(
+    (g) => !Y(g.name) || g.sourceId !== void 0 && !Y(g.sourceId) && !B(g.sourceId)
+  ) || !o.floors.length || o.floors.some(
+    (g) => !r.has(g.buildingId) || !Y(g.name) || !B(g.elevation) || !B(g.height) || g.height <= 0
+  )) && t("invalid buildings or floors."), o.objects.some((g) => g.travel !== void 0 && (g.kind !== "stairs" || g.travel !== "up" && g.travel !== "down")) && t("travel belongs to an escalator and must be up or down."), o.floors.some(
+    (g) => g.light !== void 0 && (!B(g.light.kelvin) || g.light.kelvin < 1e3 || g.light.kelvin > 12e3 || !B(g.light.level) || g.light.level < 0 || g.light.level > 1 || g.light.tint !== void 0 && (typeof g.light.tint != "string" || !/^#[0-9a-f]{6}$/i.test(g.light.tint)))
+  ) && t("a floor names a light that is not a lamp.");
+  const l = (g) => g !== void 0 && (!so.includes(g.preset) || g.level !== void 0 && (!B(g.level) || g.level < 0 || g.level > 1));
+  (o.floors.some((g) => l(g.ambience)) || o.objects.some((g) => l(g.ambience))) && t("an ambience names a preset that does not exist, or a level outside 0..1."), o.initialFloorId !== void 0 && o.initialFloorId !== null && !o.floors.some((g) => g.id === o.initialFloorId) && t("initialFloorId names a floor that does not exist."), o.buildings.some((g) => g.exteriorPreset !== void 0 && !Object.hasOwn(Lo, g.exteriorPreset)) && t("unknown exterior preset.");
+  for (const g of [...o.junctions, ...o.barriers, ...o.objects, ...o.drawings])
+    g.floorId !== null && !a.has(g.floorId) && t("unknown floor reference.");
+  o.junctions.some((g) => !St(g.position)) && t("invalid junction coordinates.");
+  for (const g of o.virtualBoundaries ?? []) {
+    const y = o.junctions.find((_) => _.id === g.startId), M = o.junctions.find((_) => _.id === g.endId);
+    (!y || !M || y.floorId !== g.floorId || M.floorId !== g.floorId || S(y.position, M.position) < 1e-3 - 1e-6) && t("invalid virtual boundary.");
+  }
+  o.barriers.some(
+    (g) => !["wall", "fence"].includes(g.kind) || !Y(g.name) || !o.junctions.some((y) => y.id === g.startId && y.floorId === g.floorId) || !o.junctions.some((y) => y.id === g.endId && y.floorId === g.floorId) || g.startId === g.endId || !B(g.height) || g.height <= 0 || !B(g.thickness) || g.thickness <= 0
+  ) && t("invalid barrier.");
+  const d = /* @__PURE__ */ new Map();
+  for (const g of o.objects)
+    g.floorId && pt(g.kind) && Array.isArray(g.rings) && Array.isArray(g.rings[0]) && d.set(g.floorId, [...d.get(g.floorId) ?? [], g]);
+  for (const g of o.objects) {
+    if ((!oo.includes(g.kind) || !Y(g.name) || !St(g.position) || !B(g.rotation) || !B(g.width) || g.width <= 0 || !B(g.depth) || g.depth <= 0 || !B(g.height) || g.height < 0) && t("invalid object dimensions or type."), g.rings && (!Array.isArray(g.rings) || g.rings.some((y) => !Array.isArray(y) || y.some((M) => !St(M)))) && t("invalid polygon coordinates."), g.servedFloorIds && (!Array.isArray(g.servedFloorIds) || g.servedFloorIds.some((y) => !a.has(y))) && t("unknown served floor."), g.servedFloorIds && !Mt(g.servedFloorIds) && t("served floors must be listed once each."), g.servedFloorIds && (g.kind === "stairs" || g.kind === "elevator")) {
+      const M = g.servedFloorIds.map((_) => d.get(_)).filter((_) => !!(_ != null && _.length)).map((_) => _.some(($) => D(g.position, $.rings[0])));
+      M.some(Boolean) && !M.every(Boolean) && t("a stair or lift serves a level it does not stand on — its landing there opens onto nothing.");
+    }
+    if ((g.doorHinge !== void 0 || g.doorSwing !== void 0 || g.doorType !== void 0) && (g.kind !== "door" && t("only doors carry mechanism, hinge and swing settings."), g.doorType !== void 0 && !["hinged", "sliding", "double"].includes(g.doorType) && t("door type must be hinged, sliding or double."), g.doorHinge !== void 0 && !["left", "right"].includes(g.doorHinge) && t("door hinge must be left or right."), g.doorSwing !== void 0 && g.doorSwing !== 1 && g.doorSwing !== -1 && t("door swing must be 1 or -1.")), g.doorSides !== void 0 && (g.kind !== "elevator" && t("only an elevator lists door sides."), (!Array.isArray(g.doorSides) || !g.doorSides.length || g.doorSides.some((y) => !["front", "back", "left", "right"].includes(y)) || !Mt(g.doorSides)) && t("door sides are front, back, left or right, listed once each.")), g.wellGroup !== void 0 && (g.kind !== "stairs" || !Y(g.wellGroup) || !g.wellGroup.trim()) && t("only stairs carry a non-empty shared well group."), g.stairModel !== void 0 && (g.kind !== "stairs" && t("only stairs carry a stair model."), ["straight", "switchback", "dogleg", "spiral", "escalator"].includes(g.stairModel) || t("a stair model is straight, switchback, dogleg, spiral or escalator.")), g.light !== void 0 || g.kind === "light") {
+      const y = g.light;
+      (g.kind !== "light" || !st(y) || y.mountHeight !== void 0 && (!B(y.mountHeight) || y.mountHeight < -20 || y.mountHeight > 100) || !B(y.kelvin) || y.kelvin < 1e3 || y.kelvin > 12e3 || !B(y.intensity) || y.intensity < 0 || y.intensity > 1e4 || !B(y.range) || y.range <= 0 || y.range > 100 || y.flicker !== void 0 && (!B(y.flicker) || y.flicker < 0 || y.flicker > 1)) && t("a light needs a valid colour temperature, intensity, range and optional flicker.");
+    }
+    if (g.watchedIds && (!Array.isArray(g.watchedIds) || g.watchedIds.some((y) => !o.objects.some((M) => M.id === y))) && t("unknown watched object."), g.watchedIds && !Mt(g.watchedIds) && t("watched objects must be listed once each."), g.ceilingHeight !== void 0 && (!["room", "zone"].includes(g.kind) || !B(g.ceilingHeight) || g.ceilingHeight <= 0) && t("a space ceiling height must be positive."), g.baseHeight !== void 0 && (g.kind !== "fixture" || !B(g.baseHeight) || g.baseHeight < 0 || g.baseHeight > 100) && t("a raised fixture needs a base height between 0 and 100 m."), g.water !== void 0) {
+      const y = g.water;
+      (!["room", "zone"].includes(g.kind) || !g.rings || !st(y) || !B(y.depth) || y.depth <= 0 || y.depth > 20 || y.ripple !== void 0 && (!B(y.ripple) || y.ripple < 0 || y.ripple > 0.1)) && t("water needs an area, a depth up to 20 m and ripples up to 10 cm.");
+    }
+    if (g.slide !== void 0) {
+      const y = g.slide;
+      (g.kind !== "fixture" || !st(y) || !B(y.radius) || y.radius <= 0 || !Array.isArray(y.path) || y.path.length < 2 || y.path.length > 100 || !y.path.every((M) => Array.isArray(M) && M.length === 3 && M.every(B) && M[2] >= 0)) && t("a water slide needs a positive radius and a finite path above its floor.");
+    }
+    if (g.slope !== void 0) {
+      const y = g.slope;
+      (!st(y) || !Array.isArray(y.axis) || y.axis.length !== 2 || !y.axis.every(St) || !B(y.high) || !B(y.low) || S(y.axis[0], y.axis[1]) < 0.01 || y.high < y.low) && t("invalid slope: needs a downhill two-point axis (high >= low) of non-zero length."), g.rings || t("a sloped object must be an area with a footprint.");
+    }
+    g.category !== void 0 && !Y(g.category) && t("object category must be a string."), g.metadata !== void 0 && !st(g.metadata) && t("object metadata must be an object."), g.barrierId && !B(g.offset) && t("missing opening offset."), g.feedId !== void 0 && typeof g.feedId != "string" && t("invalid feed binding."), g.coverageRange !== void 0 && (!B(g.coverageRange) || g.coverageRange <= 0) && t("invalid camera range."), g.coverageAngle !== void 0 && (!B(g.coverageAngle) || g.coverageAngle <= 0 || g.coverageAngle > 360) && t("invalid camera angle.");
+  }
+  for (const g of o.drawings)
+    (!Y(g.assetId) || !Y(g.name) || !St(g.origin) || !B(g.scale) || g.scale <= 0 || !B(g.width) || g.width <= 0 || !B(g.height) || g.height <= 0 || !B(g.rotation) || !B(g.opacity) || g.opacity < 0 || g.opacity > 1 || typeof g.visible != "boolean" || typeof g.locked != "boolean") && t("invalid reference drawing.");
+  const u = new Set(o.objects.filter((g) => et(g.kind)).map((g) => g.id)), c = new Map(o.objects.map((g) => [g.id, g.kind])), f = new Set((o.zones ?? []).map((g) => g.id));
+  for (const g of o.zones ?? [])
+    (!Y(g.name) || !Array.isArray(g.spaceIds)) && t("a zone needs a name and a list of spaces."), g.spaceIds.some((y) => !u.has(y)) && t("a zone lists a space that is not an area object."), Mt(g.spaceIds) || t("a zone must list each space once — membership is a set."), g.childZoneIds && g.childZoneIds.some((y) => !f.has(y)) && t("a zone nests a zone that does not exist."), g.childZoneIds && !Mt(g.childZoneIds) && t("a zone must nest each child once."), g.connects !== void 0 && !["all", "adjacent", "up", "down"].includes(g.connects) && t("a zone's connects must be 'all', 'adjacent', 'up' or 'down'.");
+  const h = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set(), m = (g) => {
+    var M;
+    if (p.has(g)) return !1;
+    if (h.has(g)) return !0;
+    h.add(g);
+    const y = (((M = (o.zones ?? []).find((_) => _.id === g)) == null ? void 0 : M.childZoneIds) ?? []).some(m);
+    return h.delete(g), p.add(g), y;
+  };
+  [...f].some(m) && t("zones cannot contain themselves.");
+  for (const g of o.portals ?? [])
+    (!u.has(g.a) || !u.has(g.b)) && t("a portal must join two areas that exist on the plan."), g.a === g.b && t("a portal must join two different spaces."), g.openingId && !["door", "gate", "turnstile"].includes(c.get(g.openingId) ?? "") && t("a portal's opening must be a door, gate or turnstile."), g.passage !== void 0 && !["both", "a-to-b", "b-to-a", "none"].includes(g.passage) && t("invalid portal passage direction."), g.attests !== void 0 && !["confirmed", "assumed", "none"].includes(g.attests) && t("invalid portal attestation.");
+  const I = new Set((o.portals ?? []).map((g) => g.id));
+  for (const g of o.portalGroups ?? [])
+    (!Y(g.name) || !Array.isArray(g.portalIds) || g.portalIds.some((y) => !I.has(y))) && t("a portal group needs a name and must list portals that exist."), Mt(g.portalIds) || t("a portal group must list each portal once.");
+  const b = Do(o);
+  b && t(b), ns(o);
+  const w = Uo(o);
+  return w && t(w), o;
+}
+function Zo(e) {
+  const t = (n) => {
+    if (n && typeof n == "object" && !Object.isFrozen(n)) {
+      Object.freeze(n);
+      for (const s of Object.values(n)) t(s);
+    }
+  };
+  return t(e), e;
+}
+function Ho(e, t, n) {
+  try {
+    const s = structuredClone(e);
+    t(s), es(e, s);
+    for (const o of s.objects)
+      if (pt(o.kind) && nt(o) < kt) {
+        const i = e.objects.find((a) => a.id === o.id && pt(a.kind));
+        if (!i || nt(i) !== nt(o))
+          throw new Error(
+            `A space needs at least ${kt} m² of usable area. "${o.name || o.id}" (${o.id}) has ${nt(o).toFixed(3)} m².`
+          );
+      }
+    return Ae(s), { ok: !0, project: (n == null ? void 0 : n.freeze) === !1 ? s : Zo(s) };
+  } catch (s) {
+    return { ok: !1, error: s instanceof Error ? s.message : String(s) };
+  }
+}
+const Z = (e) => [...e.barriers, ...e.virtualBoundaries ?? []], Zs = (e) => {
+  var t;
+  return ((t = e.geometry) == null ? void 0 : t.mode) === "boundaries";
+}, ht = (e, t) => {
+  const n = e.junctions.find((o) => o.id === t.startId), s = e.junctions.find((o) => o.id === t.endId);
+  if (!n || !s) throw new Error("A space boundary references a missing junction.");
+  return [n.position, s.position];
+}, gn = (e) => [...e].reverse().map((t) => ({ edgeId: t.edgeId, reversed: !t.reversed })), bt = (e) => e.reduce((t, n, s) => {
+  const o = e[(s + 1) % e.length];
+  return t + n[0] * o[1] - o[0] * n[1];
+}, 0) / 2, Q = (e) => V(e[0]) - e.slice(1).reduce((t, n) => t + V(n), 0), mn = (e) => e.reduce((t, n) => t + Q(n), 0), pn = (e) => e.map(
+  (t) => C(t).map(
+    (n) => [Math.round(n[0] * at) / at, Math.round(n[1] * at) / at]
+  )
+);
+function _e(e, ...t) {
+  const n = (a) => a.map((r) => C(r).map((l) => [Math.round(l[0] * at), Math.round(l[1] * at)])), s = n(e), o = t.map(n);
+  let i;
+  try {
+    i = ct.difference(s, ...o);
+  } catch {
+    i = [s];
+    for (const a of o) {
+      if (!i.length) break;
+      i = ct.difference(i, a);
+    }
+  }
+  return i.map(
+    (a) => a.map(
+      (r) => r.map(
+        (l) => [Math.round(l[0] / at * 1e10) / 1e10, Math.round(l[1] / at * 1e10) / 1e10]
+      )
+    )
+  );
+}
+function Re(e, t, n) {
+  var s;
+  for (const o of e.objects)
+    ((s = o.geometry) == null ? void 0 : s.mode) === "boundaries" && (o.geometry.loops = o.geometry.loops.map(
+      (i) => i.flatMap((a) => a.edgeId !== t ? [a] : a.reversed ? gn(n) : n)
+    ));
+}
+function At(e, t, n) {
+  const s = new Map(Z(e).map((o) => [o.id, o]));
+  return t.map((o) => {
+    if (o.length < 3) throw new Error("A space boundary must form a closed loop.");
+    const i = [];
+    for (let a = 0; a < o.length; a++) {
+      const r = o[a], l = o[(a + 1) % o.length], d = s.get(r.edgeId), u = s.get(l.edgeId);
+      if (!d || !u || d.floorId !== n || u.floorId !== n)
+        throw new Error("A space boundary references a missing edge or another floor.");
+      if ((r.reversed ? d.startId : d.endId) !== (l.reversed ? u.endId : u.startId))
+        throw new Error("Space boundary edges must share their junctions in order.");
+      i.push(ht(e, d)[r.reversed ? 1 : 0]);
+    }
+    return C(i);
+  });
+}
+function In(e, t, n) {
+  const [s, o] = ht(e, t), i = S(s, o), a = n.filter((f) => f.t > N / i && f.t < 1 - N / i).sort((f, h) => f.t - h.t), r = a.filter((f, h) => h === 0 || f.id !== a[h - 1].id);
+  if (!r.length) return;
+  const l = [{ t: 0, id: t.startId }, ...r, { t: 1, id: t.endId }], d = e.objects.filter((f) => f.barrierId === t.id);
+  for (const f of r)
+    for (const h of d)
+      if (Math.abs((h.offset ?? 0) - f.t * i) < h.width / 2 - N)
+        throw new Error("A junction cannot split an opening.");
+  const u = "kind" in t, c = l.slice(1).map((f, h) => {
+    const p = l[h];
+    if ((f.t - p.t) * i < (u ? un : ne) - N)
+      throw new Error(
+        `That crossing would leave a boundary segment too short. "${"name" in t ? t.name : t.id}" would be ${((f.t - p.t) * i).toFixed(4)} m long.`
+      );
+    return { ...t, id: h === 0 ? t.id : H(), startId: p.id, endId: f.id };
+  });
+  for (const f of d) {
+    const h = (f.offset ?? 0) / i, p = l.slice(1).findIndex((m) => h <= m.t + N);
+    f.barrierId = c[p].id, f.offset = (f.offset ?? 0) - l[p].t * i;
+  }
+  Re(
+    e,
+    t.id,
+    c.map((f) => ({ edgeId: f.id }))
+  ), Object.assign(t, c[0]), u ? e.barriers.push(...c.slice(1)) : (e.virtualBoundaries ?? (e.virtualBoundaries = [])).push(...c.slice(1));
+}
+function Tt(e, t) {
+  const n = Z(e).filter((h) => h.floorId === t), s = e.junctions.filter((h) => h.floorId === t), o = /* @__PURE__ */ new Map(), i = [];
+  for (const h of s) {
+    const p = i.find((m) => S(m.position, h.position) <= N);
+    p ? o.set(h.id, p.id) : i.push(h);
+  }
+  for (const h of n)
+    h.startId = o.get(h.startId) ?? h.startId, h.endId = o.get(h.endId) ?? h.endId;
+  e.junctions = e.junctions.filter((h) => !o.has(h.id));
+  const a = new Map(e.junctions.map((h) => [h.id, h.position])), r = n.map((h) => ({
+    points: [a.get(h.startId), a.get(h.endId)],
+    box: ye([a.get(h.startId), a.get(h.endId)])
+  })), l = /* @__PURE__ */ new Map(), d = (h, p) => {
+    const [m, I] = ht(e, h), b = G(p, m, I);
+    let w = e.junctions.find((y) => y.floorId === t && S(y.position, p) <= N);
+    w || (w = { id: H(), floorId: t, position: p }, e.junctions.push(w));
+    const g = l.get(h.id) ?? [];
+    g.push({ t: b.t, id: w.id }), l.set(h.id, g);
+  };
+  for (let h = 0; h < n.length; h++)
+    for (let p = h + 1; p < n.length; p++) {
+      if (!bn(r[h].box, r[p].box)) continue;
+      const m = n[h], I = n[p], [b, w] = r[h].points, [g, y] = r[p].points, M = w[0] - b[0], _ = w[1] - b[1], $ = y[0] - g[0], x = y[1] - g[1], E = M * x - _ * $;
+      if (!(m.startId === I.startId || m.startId === I.endId || m.endId === I.startId || m.endId === I.endId) && Math.abs(E) > 1e-12 * Math.hypot(M, _) * Math.hypot($, x)) {
+        const v = ((g[0] - b[0]) * x - (g[1] - b[1]) * $) / E, k = ((g[0] - b[0]) * _ - (g[1] - b[1]) * M) / E;
+        if (v >= -N / Math.hypot(M, _) && v <= 1 + N / Math.hypot(M, _) && k >= -N / Math.hypot($, x) && k <= 1 + N / Math.hypot($, x)) {
+          const R = [b[0] + Math.max(0, Math.min(1, v)) * M, b[1] + Math.max(0, Math.min(1, v)) * _];
+          d(m, R), d(I, R);
+        }
+      } else {
+        for (const v of [b, w])
+          G(v, g, y).distance <= N && (d(m, v), d(I, v));
+        for (const v of [g, y])
+          G(v, b, w).distance <= N && (d(m, v), d(I, v));
+      }
+    }
+  for (const h of n) In(e, h, l.get(h.id) ?? []);
+  const u = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Set();
+  for (const h of Z(e).filter((p) => p.floorId === t)) {
+    const p = [h.startId, h.endId].sort().join("|"), m = u.get(p);
+    if (!m) {
+      u.set(p, h);
+      continue;
+    }
+    const I = h.startId !== m.startId;
+    Re(e, h.id, [{ edgeId: m.id, reversed: I }]);
+    for (const b of e.objects.filter((w) => w.barrierId === h.id))
+      b.barrierId = m.id, I && (b.offset = S(...ht(e, m)) - (b.offset ?? 0), b.kind === "door" && (b.doorHinge = b.doorHinge === "right" ? "left" : "right", b.doorSwing = b.doorSwing === -1 ? 1 : -1));
+    c.add(h.id);
+  }
+  e.barriers = e.barriers.filter((h) => !c.has(h.id)), e.virtualBoundaries && (e.virtualBoundaries = e.virtualBoundaries.filter((h) => !c.has(h.id)));
+  const f = new Set(Z(e).flatMap((h) => [h.startId, h.endId]));
+  e.junctions = e.junctions.filter((h) => !o.has(h.id) || f.has(h.id));
+}
+function oe(e, t) {
+  const n = Z(e).filter((h) => h.floorId === t), s = /* @__PURE__ */ new Map();
+  for (const h of n)
+    for (const [p, m] of [
+      [h.startId, h.endId],
+      [h.endId, h.startId]
+    ]) {
+      const I = s.get(p) ?? [];
+      I.push({ edge: h, to: m }), s.set(p, I);
+    }
+  const o = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set();
+  let r = 0;
+  const l = (h, p) => {
+    o.set(h, ++r), i.set(h, r);
+    for (const { edge: m, to: I } of s.get(h) ?? [])
+      m.id !== p && (o.has(I) ? i.set(h, Math.min(i.get(h), o.get(I))) : (l(I, m.id), i.set(h, Math.min(i.get(h), i.get(I))), i.get(I) > o.get(h) && a.add(m.id)));
+  };
+  for (const h of s.keys()) o.has(h) || l(h);
+  const d = new Map(e.junctions.map((h) => [h.id, h.position]));
+  for (const [h, p] of s) {
+    const m = d.get(h);
+    s.set(
+      h,
+      p.filter((I) => !a.has(I.edge.id)).sort((I, b) => {
+        const w = d.get(I.to), g = d.get(b.to);
+        return Math.atan2(w[1] - m[1], w[0] - m[0]) - Math.atan2(g[1] - m[1], g[0] - m[0]);
+      })
+    );
+  }
+  const u = /* @__PURE__ */ new Set(), c = [];
+  for (const h of n.filter((p) => !a.has(p.id)))
+    for (const p of [!1, !0]) {
+      let m = { edgeId: h.id, reversed: p }, I = h;
+      const b = `${h.id}:${p}`, w = [], g = [];
+      if (!u.has(b)) {
+        for (let y = 0; y <= n.length * 2; y++) {
+          const M = `${m.edgeId}:${!!m.reversed}`;
+          if (u.has(M)) break;
+          u.add(M), w.push(m);
+          const _ = m.reversed ? I.endId : I.startId, $ = m.reversed ? I.startId : I.endId;
+          g.push(d.get(_));
+          const x = s.get($), E = x.findIndex((v) => v.edge.id === I.id);
+          if (I = x[(E + x.length - 1) % x.length].edge, m = { edgeId: I.id, reversed: I.endId === $ }, `${m.edgeId}:${!!m.reversed}` === b) break;
+        }
+        bt(g) >= ke && c.push({ loop: w, ring: C(g) });
+      }
+    }
+  const f = c.map(
+    (h, p) => {
+      var m;
+      return (m = c.map((I, b) => ({ j: b, candidate: I })).filter(
+        ({ candidate: I, j: b }) => b !== p && V(I.ring) > V(h.ring) + N && h.ring.every((w) => D(w, I.ring)) && !h.loop.some((w) => I.loop.some((g) => g.edgeId === w.edgeId))
+      ).sort((I, b) => V(I.candidate.ring) - V(b.candidate.ring))[0]) == null ? void 0 : m.j;
+    }
+  );
+  return c.map((h, p) => {
+    const m = c.filter((I, b) => f[b] === p);
+    return {
+      loops: [h.loop, ...m.map((I) => gn(I.loop))],
+      rings: [h.ring, ...m.map((I) => C([...T(I.ring)].reverse()))]
+    };
+  });
+}
+function Wo(e, t) {
+  const n = new Map(e.junctions.map((o) => [o.id, o.position])), s = e.barriers.filter((o) => o.floorId === t).map((o) => ({
+    points: [n.get(o.startId), n.get(o.endId)],
+    thickness: o.thickness
+  }));
+  for (let o = 0; o < s.length; o++) {
+    let i = !0;
+    for (; i; ) {
+      i = !1;
+      for (let a = o + 1; a < s.length; a++) {
+        const r = s[o], l = s[a];
+        if (r.thickness !== l.thickness) continue;
+        const [d, u] = r.points, [c, f] = l.points, h = S(d, u), p = S(c, f);
+        if (Math.abs((u[0] - d[0]) * (f[1] - c[1]) - (u[1] - d[1]) * (f[0] - c[0])) > N * h * p) continue;
+        const m = [
+          [d, c, u, f],
+          [d, f, u, c],
+          [u, c, d, f],
+          [u, f, d, c]
+        ].find(([I, b]) => S(I, b) <= N);
+        if (m) {
+          r.points = [m[2], m[3]], s.splice(a, 1), i = !0;
+          break;
+        }
+      }
+    }
+  }
+  return s.map(({ points: [o, i], thickness: a }) => {
+    (o[0] > i[0] || o[0] === i[0] && o[1] > i[1]) && ([o, i] = [i, o]);
+    const r = S(o, i);
+    return pn([
+      Zt(
+        [(o[0] + i[0]) / 2, (o[1] + i[1]) / 2],
+        r + a,
+        a,
+        Math.atan2(i[1] - o[1], i[0] - o[0]) * 180 / Math.PI
+      )
+    ]);
+  });
+}
+function jo(e) {
+  const t = [];
+  for (const n of T(e)) (!t.length || S(t.at(-1), n) >= N) && t.push(n);
+  return t.length > 1 && S(t[0], t.at(-1)) < N && t.pop(), C(t);
+}
+const ye = (e) => {
+  let t = 1 / 0, n = 1 / 0, s = -1 / 0, o = -1 / 0;
+  for (const [i, a] of e)
+    t = Math.min(t, i), n = Math.min(n, a), s = Math.max(s, i), o = Math.max(o, a);
+  return { minX: t, minY: n, maxX: s, maxY: o };
+}, bn = (e, t) => e.minX <= t.maxX + N && e.maxX + N >= t.minX && e.minY <= t.maxY + N && e.maxY + N >= t.minY;
+function Pe(e) {
+  const t = /* @__PURE__ */ new Map();
+  return (n, s, o = !1) => {
+    let i = t.get(n);
+    i || (i = Wo(e, n).map((l) => ({ rings: l, box: ye(l[0]) })), t.set(n, i));
+    const a = ye(s[0]), r = i.filter((l) => bn(l.box, a)).map((l) => l.rings);
+    return Yo(s, r, o);
+  };
+}
+function Yo(e, t, n = !1) {
+  const s = t.length ? _e(e, ...t) : [pn(e)], o = s.filter((i) => Q(i) >= kt);
+  if (!o.length && n) return [];
+  if (!o.length)
+    throw new Error(
+      `A space needs at least ${kt} m² of usable area. Largest region after subtracting walls: ${Math.max(0, ...s.map((i) => Q(i))).toFixed(3)} m².`
+    );
+  if (o.length !== 1)
+    throw new Error(
+      `The wall would leave ${o.length} disconnected usable regions (${o.map((i) => Q(i).toFixed(2)).join(", ")} m²). Extend it to a boundary to divide the space.`
+    );
+  return o[0].map(jo);
+}
+function se(e, t) {
+  var n;
+  return ((n = t.geometry) == null ? void 0 : n.mode) !== "boundaries" ? W(t) : Pe(e)(t.floorId, At(e, t.geometry.loops, t.floorId));
+}
+function Ct(e, t) {
+  e.rings = t, e.position = vt(t[0]), e.rotation = 0;
+  const n = t[0].map((o) => o[0]), s = t[0].map((o) => o[1]);
+  e.width = Math.max(...n) - Math.min(...n), e.depth = Math.max(...s) - Math.min(...s);
+}
+function yn(e, t, n) {
+  if (!pt(t.kind)) throw new Error("Only a drawn area can use shared boundaries.");
+  t.geometry = { mode: "boundaries", loops: structuredClone(n.loops) }, Ct(t, se(e, t));
+}
+function Vo(e, t, n) {
+  return oe(e, t).filter((s) => D(n, s.rings[0]) && !s.rings.slice(1).some((o) => D(n, o))).sort((s, o) => Q(s.rings) - Q(o.rings))[0] ?? null;
+}
+function we(e, t, n) {
+  const s = e.junctions.find((i) => i.floorId === t && S(i.position, n) <= N);
+  if (s) return s.id;
+  const o = H();
+  return e.junctions.push({ id: o, floorId: t, position: n }), o;
+}
+function Ut(e, t, n, s) {
+  if (S(n, s) < ne) throw new Error("A space boundary is too short.");
+  const o = we(e, t, n), i = we(e, t, s), a = Z(e).find(
+    (l) => l.floorId === t && (l.startId === o && l.endId === i || l.startId === i && l.endId === o)
+  );
+  if (a) return a.id;
+  const r = H();
+  return (e.virtualBoundaries ?? (e.virtualBoundaries = [])).push({ id: r, floorId: t, startId: o, endId: i }), r;
+}
+function Xo(e, t, n, s) {
+  const o = S(n, s);
+  if (o < ne) throw new Error("A space boundary is too short.");
+  const i = (a) => Math.abs((s[0] - n[0]) * (a[1] - n[1]) - (s[1] - n[1]) * (a[0] - n[0])) / o <= N;
+  for (const a of [...e.barriers].filter((r) => r.floorId === t)) {
+    const [r, l] = ht(e, a);
+    if (!i(r) || !i(l)) continue;
+    const d = [n, s].flatMap((u) => {
+      const c = G(u, r, l);
+      return c.distance <= N && c.t > 0 && c.t < 1 ? [{ t: c.t, id: we(e, t, c.point) }] : [];
+    });
+    In(e, a, d);
+  }
+  for (const a of [...e.barriers].filter((r) => r.floorId === t))
+    ht(e, a).every((r) => G(r, n, s).distance <= N) && ((e.virtualBoundaries ?? (e.virtualBoundaries = [])).push({ id: a.id, floorId: t, startId: a.startId, endId: a.endId }), En(e, a.id));
+  return Ut(e, t, n, s);
+}
+function qo(e, t, n = "outline") {
+  var i;
+  const s = e.objects.find((a) => a.id === t);
+  if (!s || !pt(s.kind)) throw new Error("Select an area to connect to boundaries.");
+  if (n === "walls") {
+    Tt(e, s.floorId);
+    const a = W(s), r = Q(a), l = oe(e, s.floorId).map((u) => ({
+      region: u,
+      overlap: r - mn(_e(a, u.rings))
+    })).filter((u) => u.overlap > N).sort((u, c) => c.overlap - u.overlap);
+    if (l.length > 1 && Math.abs(l[0].overlap - l[1].overlap) < N)
+      throw new Error("More than one region matches this outline. Use Space from walls inside the intended region.");
+    const d = (i = l[0]) == null ? void 0 : i.region;
+    if (!d) throw new Error("No closed wall boundary surrounds this space.");
+    yn(e, s, d);
+    return;
+  }
+  const o = W(s).map((a, r) => {
+    let l = T(a);
+    return bt(l) > 0 != (r === 0) && (l = [...l].reverse()), l.map((d, u) => {
+      const c = l[(u + 1) % l.length], f = Ut(e, s.floorId, d, c), h = Z(e).find((p) => p.id === f);
+      return { edgeId: f, reversed: S(ht(e, h)[0], d) > N };
+    });
+  });
+  s.geometry = { mode: "boundaries", loops: o }, Tt(e, s.floorId), Ct(s, se(e, s));
+}
+function Jo(e, t) {
+  const n = e.objects.find((s) => s.id === t);
+  n && (n.geometry = { mode: "independent" });
+}
+function Ko(e, t, n) {
+  var i;
+  if (((i = t.geometry) == null ? void 0 : i.mode) !== "boundaries") throw new Error("Select a space with shared boundaries.");
+  let s = T(n);
+  bt(s) > 0 && (s = [...s].reverse());
+  const o = s.map((a, r) => {
+    const l = Ut(e, t.floorId, a, s[(r + 1) % s.length]), d = Z(e).find((u) => u.id === l);
+    return { edgeId: l, reversed: S(ht(e, d)[0], a) > N };
+  });
+  t.geometry.loops.push(o);
+}
+function Qo(e, t, n, s, o = !0) {
+  var c;
+  if (((c = t.geometry) == null ? void 0 : c.mode) !== "boundaries") throw new Error("This space has no shared boundaries.");
+  const i = S(n, s);
+  if (i < N) throw new Error("Draw a line across the space.");
+  const a = (s[0] - n[0]) / i, r = (s[1] - n[1]) / i, l = [];
+  for (const f of At(e, t.geometry.loops, t.floorId)) {
+    const h = T(f);
+    for (let p = 0; p < h.length; p++) {
+      const m = h[p], I = h[(p + 1) % h.length], b = I[0] - m[0], w = I[1] - m[1], g = a * w - r * b;
+      if (Math.abs(g) < 1e-12) continue;
+      const y = ((m[0] - n[0]) * r - (m[1] - n[1]) * a) / g;
+      y >= -N && y <= 1 + N && l.push(((m[0] - n[0]) * w - (m[1] - n[1]) * b) / g);
+    }
+  }
+  l.sort((f, h) => f - h);
+  const d = l.filter((f, h) => h === 0 || f - l[h - 1] > N);
+  for (let f = 0; f + 1 < d.length; f += 2) {
+    const h = [n[0] + d[f] * a, n[1] + d[f] * r], p = [n[0] + d[f + 1] * a, n[1] + d[f + 1] * r];
+    if (o) {
+      const m = ie(e, h, p, t.floorId, "wall");
+      m && (m.name = "Partition", m.thickness = 0.18);
+    } else Ut(e, t.floorId, h, p);
+  }
+  Tt(e, t.floorId);
+  const u = vn(e);
+  if (!u.length) throw new Error("The cut must divide the space into usable regions.");
+  return u[0];
+}
+function ts(e, t, n) {
+  var d, u;
+  if (((d = t.geometry) == null ? void 0 : d.mode) !== "boundaries" || ((u = n.geometry) == null ? void 0 : u.mode) !== "boundaries")
+    throw new Error("Connect both spaces to shared boundaries before merging their boundaries.");
+  const s = t.geometry.loops.flat(), o = n.geometry.loops.flat(), i = new Set(
+    s.filter((c) => o.some((f) => f.edgeId === c.edgeId && !!f.reversed != !!c.reversed)).map((c) => c.edgeId)
+  );
+  if (!i.size) return !1;
+  if (e.barriers.some((c) => i.has(c.id))) throw new Error("Remove the dividing wall before merging these spaces.");
+  const a = new Map(Z(e).map((c) => [c.id, c])), r = [...s, ...o].filter((c) => !i.has(c.edgeId)), l = [];
+  for (; r.length; ) {
+    const c = [r.shift()], f = a.get(c[0].edgeId), h = c[0].reversed ? f.endId : f.startId;
+    let p = c[0].reversed ? f.startId : f.endId;
+    for (; p !== h; ) {
+      const m = r.findIndex((w) => {
+        const g = a.get(w.edgeId);
+        return (w.reversed ? g.endId : g.startId) === p;
+      });
+      if (m < 0) throw new Error("The merged space boundary is not closed.");
+      const I = r.splice(m, 1)[0], b = a.get(I.edgeId);
+      c.push(I), p = I.reversed ? b.startId : b.endId;
+    }
+    l.push(c);
+  }
+  return l.sort(
+    (c, f) => bt(T(At(e, [f], t.floorId)[0])) - bt(T(At(e, [c], t.floorId)[0]))
+  ), t.geometry = { mode: "boundaries", loops: l }, e.virtualBoundaries = (e.virtualBoundaries ?? []).filter(
+    (c) => !i.has(c.id) || e.objects.some(
+      (f) => {
+        var h;
+        return f.id !== n.id && ((h = f.geometry) == null ? void 0 : h.mode) === "boundaries" && f.geometry.loops.some((p) => p.some((m) => m.edgeId === c.id));
+      }
+    )
+  ), Ct(t, se(e, t)), !0;
+}
+function wn(e, t) {
+  e.objects.some(
+    (n) => {
+      var s;
+      return ((s = n.geometry) == null ? void 0 : s.mode) === "boundaries" && n.geometry.loops.some((o) => o.some((i) => i.edgeId === t.id));
+    }
+  ) && ((e.virtualBoundaries ?? []).some((n) => n.id === t.id) || (e.virtualBoundaries ?? (e.virtualBoundaries = [])).push({ id: t.id, floorId: t.floorId, startId: t.startId, endId: t.endId }));
+}
+function vn(e, t) {
+  var i;
+  const n = [], s = /* @__PURE__ */ new Map(), o = Pe(e);
+  for (const a of [...e.objects]) {
+    if (((i = a.geometry) == null ? void 0 : i.mode) !== "boundaries") continue;
+    const r = At(e, a.geometry.loops, a.floorId);
+    if (t && !t.has(a.floorId)) {
+      Ct(a, o(a.floorId, r));
+      continue;
+    }
+    s.has(a.floorId) || s.set(a.floorId, oe(e, a.floorId));
+    const l = s.get(a.floorId).filter((u) => mn(_e(u.rings, r)) < N);
+    if (!l.length) throw new Error("The space boundaries no longer form a closed region.");
+    l.sort((u, c) => Q(c.rings) - Q(u.rings));
+    const d = l.map((u) => ({ region: u, rings: o(a.floorId, u.rings, l.length > 1) })).filter((u) => u.rings.length).sort((u, c) => Q(c.rings) - Q(u.rings));
+    if (!d.length) throw new Error("The walls would remove all usable area from this space.");
+    for (let u = 0; u < d.length; u++) {
+      const c = u === 0 ? a : { ...structuredClone(a), id: H(), name: `${a.name} ${u + 1}`, feedId: void 0 };
+      if (c.geometry = { mode: "boundaries", loops: structuredClone(d[u].region.loops) }, Ct(c, d[u].rings), u > 0) {
+        e.objects.push(c), n.push(c.id);
+        for (const f of e.zones ?? []) f.spaceIds.includes(a.id) && f.spaceIds.push(c.id);
+      }
+    }
+  }
+  return n;
+}
+function es(e, t) {
+  for (const l of ["barriers", "junctions", "objects", "virtualBoundaries", "zones"]) {
+    const d = t[l];
+    d && (Object.isFrozen(d) || d.some((u) => Object.isFrozen(u))) && Object.assign(t, { [l]: structuredClone(d) });
+  }
+  const n = Z(t), s = new Set(n.map((l) => l.id));
+  for (const l of Z(e))
+    if (!s.has(l.id) && (wn(t, l), (t.virtualBoundaries ?? []).some((d) => d.id === l.id))) {
+      for (const d of [l.startId, l.endId])
+        if (!t.junctions.some((u) => u.id === d)) {
+          const u = e.junctions.find((c) => c.id === d);
+          u && t.junctions.push(structuredClone(u));
+        }
+    }
+  const o = (l, d) => JSON.stringify([
+    Z(l).filter((u) => u.floorId === d).map((u) => [u.id, u.startId, u.endId]),
+    l.junctions.filter((u) => u.floorId === d).map((u) => [u.id, u.position])
+  ]), i = new Set(Z(t).map((l) => l.floorId));
+  for (const l of i) o(e, l) !== o(t, l) && Tt(t, l);
+  const a = (l, d) => JSON.stringify(
+    Z(l).filter((u) => u.floorId === d).map((u) => [u.id, u.startId, u.endId])
+  ), r = new Set([...i].filter((l) => a(e, l) !== a(t, l)));
+  vn(t, r);
+}
+function ns(e) {
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map(), s = Pe(e), o = (i) => i.flat().map((a) => `${a.edgeId}:${!!a.reversed}`).sort().join("|");
+  for (const i of e.objects) {
+    if (i.geometry === void 0) continue;
+    if (!i.geometry || !["independent", "boundaries"].includes(i.geometry.mode))
+      throw new Error("Unknown space geometry mode.");
+    if (i.geometry.mode === "independent") continue;
+    if (!pt(i.kind) || !Array.isArray(i.geometry.loops) || !i.geometry.loops.length || i.geometry.loops.some(
+      (c) => !Array.isArray(c) || c.some(
+        (f) => !f || typeof f.edgeId != "string" || f.reversed !== void 0 && typeof f.reversed != "boolean"
+      )
+    ))
+      throw new Error("Malformed space boundary loops.");
+    const a = At(e, i.geometry.loops, i.floorId), r = hn(a, N, ke);
+    if (r) throw new Error(r);
+    if (bt(T(a[0])) <= 0 || a.slice(1).some((c) => bt(T(c)) >= 0))
+      throw new Error("Space boundary loops must keep the space on their left.");
+    if (n.has(i.floorId) || n.set(i.floorId, new Set(oe(e, i.floorId).map((c) => o(c.loops)))), !n.get(i.floorId).has(o(i.geometry.loops)))
+      throw new Error("A connected space must follow one face of the boundary network.");
+    for (const c of i.geometry.loops)
+      for (const f of c) {
+        const h = `${f.edgeId}:${!!f.reversed}`;
+        if (t.has(h)) throw new Error("Two spaces cannot occupy the same side of a shared boundary.");
+        t.add(h);
+      }
+    const l = s(i.floorId, a);
+    if (!i.rings || l.length !== i.rings.length || l.some(
+      (c, f) => c.length !== i.rings[f].length || c.some((h, p) => S(h, i.rings[f][p]) > N)
+    ))
+      throw new Error("The space footprint is stale. Update it through a geometry transaction.");
+    const d = l[0].map((c) => c[0]), u = l[0].map((c) => c[1]);
+    if (S(i.position, vt(l[0])) > N || Math.abs(i.width - (Math.max(...d) - Math.min(...d))) > N || Math.abs(i.depth - (Math.max(...u) - Math.min(...u))) > N || i.rotation !== 0)
+      throw new Error("A boundary-driven space has stale calculated dimensions.");
+  }
+}
+const S = (e, t) => Math.hypot(e[0] - t[0], e[1] - t[1]), Lt = (e, t) => {
+  const n = t * Math.PI / 180;
+  return [e[0] * Math.cos(n) - e[1] * Math.sin(n), e[0] * Math.sin(n) + e[1] * Math.cos(n)];
+}, Wt = Math.PI / 180, Xe = 6378137, ue = 0.00669437999014, $e = (e) => {
+  const t = Math.sin(e * Wt) ** 2;
+  return {
+    lng: Wt * (Xe / Math.sqrt(1 - ue * t)) * Math.cos(e * Wt),
+    lat: Wt * (Xe * (1 - ue)) / (1 - ue * t) ** 1.5
+  };
+}, Hs = (e, t = 0) => t ? [e[0], e[1], t] : [e[0], e[1]], Ws = (e, t, n) => {
+  const s = $e(e[1]), o = [e[0] + t / s.lng, e[1] + n / s.lat];
+  return e[2] ? [o[0], o[1], e[2]] : o;
+}, js = (e, t) => {
+  const n = $e(t[1]), s = [(e[0] - t[0]) * n.lng, (e[1] - t[1]) * n.lat];
+  return t[2] ? Lt(s, t[2]) : s;
+}, Ys = (e, t) => {
+  const n = $e(t[1]), s = t[2] ? Lt(e, -t[2]) : e;
+  return [t[0] + s[0] / n.lng, t[1] + s[1] / n.lat];
+}, os = (e, t) => [e[0] + t[0], e[1] + t[1]], C = (e) => e.length ? S(e[0], e[e.length - 1]) < 1e-8 ? e : [...e, e[0]] : [], T = (e) => e.length > 1 && S(e[0], e[e.length - 1]) < 1e-8 ? e.slice(0, -1) : e, V = (e) => Math.abs(
+  e.reduce((t, n, s) => {
+    const o = e[(s + 1) % e.length];
+    return t + n[0] * o[1] - o[0] * n[1];
+  }, 0)
+) / 2, nt = (e) => e.rings ? V(e.rings[0]) - e.rings.slice(1).reduce((t, n) => t + V(n), 0) : e.width * e.depth, vt = (e) => {
+  const t = T(e);
+  return [t.reduce((n, s) => n + s[0], 0) / t.length, t.reduce((n, s) => n + s[1], 0) / t.length];
+}, Zt = (e, t, n, s = 0) => C(
+  [
+    [-t / 2, -n / 2],
+    [t / 2, -n / 2],
+    [t / 2, n / 2],
+    [-t / 2, n / 2]
+  ].map((o) => os(e, Lt(o, s)))
+);
+function ss(e, t, n, s) {
+  const o = (u, c, f) => (c[0] - u[0]) * (f[1] - u[1]) - (c[1] - u[1]) * (f[0] - u[0]), [i, a, r, l] = [o(e, t, n), o(e, t, s), o(n, s, e), o(n, s, t)], d = 1e-9;
+  return (i > d && a < -d || i < -d && a > d) && (r > d && l < -d || r < -d && l > d);
+}
+function G(e, t, n) {
+  const s = S(t, n), o = s ? Math.max(0, Math.min(1, ((e[0] - t[0]) * (n[0] - t[0]) + (e[1] - t[1]) * (n[1] - t[1])) / s ** 2)) : 0, i = [t[0] + (n[0] - t[0]) * o, t[1] + (n[1] - t[1]) * o];
+  return { point: i, t: o, distance: S(e, i), length: s };
+}
+function Vs(e, t) {
+  const { t: n } = G(t, e.axis[0], e.axis[1]);
+  return e.high + (e.low - e.high) * n;
+}
+const W = (e) => e.rings ?? [Zt(e.position, e.width, e.depth, e.rotation)], qe = /* @__PURE__ */ new WeakMap();
+function Je(e, t) {
+  var i;
+  let n = qe.get(e);
+  const s = n == null ? void 0 : n.ids.get(t);
+  if (!n || n.length !== e.length || s === void 0 || ((i = e[s]) == null ? void 0 : i.id) !== t) {
+    const a = /* @__PURE__ */ new Map();
+    e.forEach((r, l) => {
+      a.has(r.id) || a.set(r.id, l);
+    }), n = { length: e.length, ids: a }, qe.set(e, n);
+  }
+  const o = n.ids.get(t);
+  return o === void 0 ? void 0 : e[o];
+}
+function X(e, t) {
+  return [
+    Je(e.junctions, t.startId).position,
+    Je(e.junctions, t.endId).position
+  ];
+}
+function yt(e, t) {
+  const n = e.barriers.find((r) => r.id === t.barrierId);
+  if (!n) return t.position;
+  const [s, o] = X(e, n), i = S(s, o), a = i ? (t.offset ?? i / 2) / i : 0;
+  return [s[0] + (o[0] - s[0]) * a, s[1] + (o[1] - s[1]) * a];
+}
+function xn(e, t) {
+  const n = e.barriers.find((i) => i.id === t.barrierId);
+  if (!n) return t.rotation;
+  const [s, o] = X(e, n);
+  return Math.atan2(o[1] - s[1], o[0] - s[0]) * 180 / Math.PI;
+}
+function D(e, t) {
+  let n = !1;
+  for (let s = 0, o = t.length - 1; s < t.length; o = s++) {
+    const i = t[s], a = t[o];
+    i[1] > e[1] != a[1] > e[1] && e[0] < (a[0] - i[0]) * (e[1] - i[1]) / (a[1] - i[1]) + i[0] && (n = !n);
+  }
+  return n;
+}
+const $t = (e, t, n) => (t[0] - e[0]) * (n[1] - e[1]) - (t[1] - e[1]) * (n[0] - e[0]);
+function Qt(e, t, n, s) {
+  const o = (i, a, r) => Math.abs($t(a, r, i)) < 1e-8 * S(a, r) && i[0] >= Math.min(a[0], r[0]) - 1e-8 && i[0] <= Math.max(a[0], r[0]) + 1e-8 && i[1] >= Math.min(a[1], r[1]) - 1e-8 && i[1] <= Math.max(a[1], r[1]) + 1e-8;
+  return $t(e, t, n) * $t(e, t, s) < 0 && $t(n, s, e) * $t(n, s, t) < 0 || o(n, e, t) || o(s, e, t) || o(e, n, s) || o(t, n, s);
+}
+function is(e, t) {
+  try {
+    return ct.difference(e, t).every((n) => V(n[0]) < 1e-3);
+  } catch {
+    return !1;
+  }
+}
+const tt = un, te = tt;
+function _t(e, t, n) {
+  const s = e.junctions.find((o) => o.floorId === n && S(o.position, t) < ut);
+  if (s) return s.position;
+  for (const o of e.barriers) {
+    if (o.floorId !== n) continue;
+    const [i, a] = X(e, o), r = G(t, i, a);
+    if (r.distance > ut) continue;
+    const l = r.t <= 0.5 ? i : a;
+    if (S(r.point, l) < tt - 1e-6) return l;
+  }
+  return t;
+}
+function qt(e, t, n) {
+  if (t = _t(e, t, n), e.junctions.some((s) => s.floorId === n && S(s.position, t) < ut)) return null;
+  for (const s of e.barriers.filter((o) => o.floorId === n)) {
+    const [o, i] = X(e, s), a = G(t, o, i);
+    if (a.distance > ut || a.t <= 0 || a.t >= 1) continue;
+    const r = S(o, t);
+    for (const l of e.objects.filter((d) => d.barrierId === s.id)) {
+      if (Math.abs((l.offset ?? 0) - r) < l.width / 2) return "A junction cannot split an opening.";
+      if (((l.offset ?? 0) < r ? r : S(t, i)) < te - 1e-6)
+        return `Leave at least ${te} m of wall around an opening.`;
+    }
+  }
+  return null;
+}
+function rs(e, t, n, s) {
+  t = _t(e, t, s), n = _t(e, n, s);
+  const o = qt(e, t, s) ?? qt(e, n, s);
+  if (o) return o;
+  const i = n[0] - t[0], a = n[1] - t[1], r = S(t, n), l = [0, r], d = (u, c) => u > N && u < c - N;
+  for (const u of Z(e).filter((c) => c.floorId === s)) {
+    const [c, f] = X(e, u), h = f[0] - c[0], p = f[1] - c[1], m = i * p - a * h;
+    if (Math.abs(m) < 1e-12 * r * S(c, f)) {
+      for (const g of [c, f]) {
+        const y = G(g, t, n);
+        y.distance <= N && l.push(y.t * r);
+      }
+      continue;
+    }
+    const I = ((c[0] - t[0]) * p - (c[1] - t[1]) * h) / m, b = ((c[0] - t[0]) * a - (c[1] - t[1]) * i) / m;
+    if (I < 0 || I > 1 || b < 0 || b > 1) continue;
+    if (l.push(I * r), d(Math.min(b, 1 - b) * S(c, f), "kind" in u ? tt : ne))
+      return "That crossing would leave a boundary segment too short.";
+    const w = qt(e, [t[0] + I * i, t[1] + I * a], s);
+    if (w) return w;
+  }
+  return l.sort((u, c) => u - c), l.some((u, c) => c > 0 && d(u - l[c - 1], tt)) ? "That crossing would leave a boundary segment too short." : null;
+}
+function Ke(e, t, n) {
+  t = _t(e, t, n);
+  const s = e.junctions.find((a) => a.floorId === n && S(a.position, t) < ut);
+  if (s) return s.id;
+  const o = qt(e, t, n);
+  if (o) throw new Error(o);
+  const i = H();
+  e.junctions.push({ id: i, floorId: n, position: t });
+  for (const a of [...e.barriers].filter((r) => r.floorId === n)) {
+    const [r, l] = X(e, a), d = G(t, r, l);
+    if (d.distance > ut || d.t <= 0 || d.t >= 1) continue;
+    const u = S(r, t), c = e.objects.filter((p) => p.barrierId === a.id), f = H(), h = a.endId;
+    a.endId = i, e.barriers.push({ ...a, id: f, startId: i, endId: h }), Re(e, a.id, [{ edgeId: a.id }, { edgeId: f }]), c.forEach((p) => {
+      (p.offset ?? 0) > u && (p.barrierId = f, p.offset = (p.offset ?? 0) - u);
+    });
+  }
+  return i;
+}
+function En(e, t) {
+  var o;
+  const n = e.barriers.find((i) => i.id === t);
+  n && wn(e, n);
+  const s = new Set(e.objects.filter((i) => i.barrierId === t).map((i) => i.id));
+  e.objects = e.objects.filter((i) => !s.has(i.id));
+  for (const i of e.objects) i.parentId && s.has(i.parentId) && (i.parentId = void 0);
+  if (e.barriers = e.barriers.filter((i) => i.id !== t), e.junctions = e.junctions.filter(
+    (i) => Z(e).some((a) => a.startId === i.id || a.endId === i.id)
+  ), (o = e.navNodes) != null && o.length) {
+    const i = new Set(e.objects.map((r) => r.id));
+    e.navNodes = e.navNodes.filter((r) => r.objectId === void 0 || i.has(r.objectId));
+    const a = new Set(e.navNodes.map((r) => r.id));
+    e.navEdges = (e.navEdges ?? []).filter(
+      (r) => a.has(r.aId) && a.has(r.bId) && (r.objectId === void 0 || i.has(r.objectId))
+    );
+  }
+}
+function ie(e, t, n, s, o) {
+  if (S(t, n) < tt - 1e-6) throw new Error(`A segment must be at least ${tt} m long.`);
+  if (t = _t(e, t, s), n = _t(e, n, s), S(t, n) < tt - 1e-6) return;
+  const i = Ke(e, t, s), a = Ke(e, n, s);
+  if (i === a || e.barriers.some(
+    (l) => l.floorId === s && l.kind === o && (l.startId === i && l.endId === a || l.startId === a && l.endId === i)
+  ))
+    return;
+  const r = {
+    id: H(),
+    floorId: s,
+    startId: i,
+    endId: a,
+    kind: o,
+    name: o === "wall" ? "Wall" : "Site fence",
+    thickness: o === "wall" ? 0.3 : 0.1,
+    height: o === "wall" ? 3.5 : 2
+  };
+  return e.barriers.push(r), r;
+}
+function Mn(e, t, n, s, o = !0) {
+  var E, A;
+  const i = e.objects.find((v) => v.id === t);
+  if (!((E = i == null ? void 0 : i.rings) != null && E.length)) throw new Error("Pick a room or zone to split.");
+  if (((A = i.geometry) == null ? void 0 : A.mode) === "boundaries") return Qo(e, i, n, s, o);
+  const a = S(n, s);
+  if (a < 1e-6) throw new Error("Draw a line across the room to split it.");
+  const r = [(s[0] - n[0]) / a, (s[1] - n[1]) / a], l = [r[1], -r[0]], d = i.rings.map(C), u = Math.max(a, ...d.flat().map((v) => S(n, v))) * 4 + 10, c = [n[0] - r[0] * u, n[1] - r[1] * u], f = [n[0] + r[0] * u, n[1] + r[1] * u], h = (v) => C([
+    c,
+    f,
+    [f[0] + l[0] * u * v, f[1] + l[1] * u * v],
+    [c[0] + l[0] * u * v, c[1] + l[1] * u * v]
+  ]), p = (v) => {
+    const k = ct.intersection(d, [h(v)]);
+    if (!k.length) throw new Error("The cut must cross the room from one wall to the opposite wall.");
+    const R = (O) => V(O[0]) - O.slice(1).reduce((z, F) => z + V(F), 0), P = k.filter((O) => R(O) >= kt).sort((O, z) => R(z) - R(O));
+    if (!P.length) throw new Error(`Each split space needs at least ${kt} m² of usable area.`);
+    if (P.length > 1)
+      throw new Error("That cut would leave disconnected pieces — draw a single straight line across the room.");
+    return P[0].map(C);
+  }, m = (v) => `${v[0].toFixed(4)},${v[1].toFixed(4)}`, I = new Set(d.flat().map(m)), b = (v) => v.map((k) => {
+    const R = T(k), P = R.filter((z, F) => {
+      if (I.has(m(z))) return !0;
+      const U = R[(F + R.length - 1) % R.length], L = R[(F + 1) % R.length];
+      return !(I.has(m(U)) && S(z, U) < ut || I.has(m(L)) && S(z, L) < ut);
+    }), O = P.some(
+      (z, F) => P.some(
+        (U, L) => L > F + 1 && !(F === 0 && L === P.length - 1) && Qt(z, P[(F + 1) % P.length], U, P[(L + 1) % P.length])
+      )
+    );
+    return P.length >= 3 && V(P) >= 0.01 && !O ? C(P) : k;
+  }), w = b(p(1)), g = b(p(-1)), y = (v, k) => {
+    v.rings = k, v.position = vt(k[0]);
+    const R = T(k[0]), P = R.map((z) => z[0]), O = R.map((z) => z[1]);
+    v.width = Math.max(...P) - Math.min(...P), v.depth = Math.max(...O) - Math.min(...O);
+  }, M = structuredClone(i);
+  if (M.id = H(), M.name = `${i.name} 2`, M.feedId = void 0, y(i, w), y(M, g), e.objects.push(M), !o) return M.id;
+  const _ = [];
+  for (const v of d) {
+    const k = T(v);
+    for (let R = 0; R < k.length; R++) {
+      const P = k[R], O = k[(R + 1) % k.length], z = [O[0] - P[0], O[1] - P[1]], F = r[0] * z[1] - r[1] * z[0];
+      if (Math.abs(F) < 1e-12) continue;
+      const U = [P[0] - n[0], P[1] - n[1]], L = (U[0] * r[1] - U[1] * r[0]) / F;
+      L < -1e-9 || L > 1 + 1e-9 || _.push((U[0] * z[1] - U[1] * z[0]) / F);
+    }
+  }
+  _.sort((v, k) => v - k);
+  const $ = _.filter((v, k) => k === 0 || v - _[k - 1] > 1e-4), x = e.barriers.length;
+  for (let v = 0; v + 1 < $.length; v += 2) {
+    const k = [n[0] + r[0] * $[v], n[1] + r[1] * $[v]], R = [n[0] + r[0] * $[v + 1], n[1] + r[1] * $[v + 1]];
+    S(k, R) >= tt - 1e-6 && ie(e, k, R, i.floorId, "wall");
+  }
+  return e.barriers.slice(x).forEach((v) => {
+    v.name = "Partition", v.thickness = 0.18;
+  }), M.id;
+}
+function as(e, t) {
+  var r;
+  if (!e.floors.find((l) => l.id === t)) throw new Error("That floor is not part of this project.");
+  if (e.floors.length <= 1) throw new Error("A project needs at least one floor.");
+  const s = new Set(e.objects.filter((l) => l.floorId === t).map((l) => l.id)), o = new Set(e.barriers.filter((l) => l.floorId === t).map((l) => l.id)), i = [t, ...s, ...o];
+  e.floors = e.floors.filter((l) => l.id !== t), e.junctions = e.junctions.filter((l) => l.floorId !== t), e.barriers = e.barriers.filter((l) => l.floorId !== t), e.virtualBoundaries && (e.virtualBoundaries = e.virtualBoundaries.filter((l) => l.floorId !== t)), e.objects = e.objects.filter((l) => l.floorId !== t), e.drawings = e.drawings.filter((l) => l.floorId !== t);
+  for (const l of e.objects)
+    l.barrierId && o.has(l.barrierId) && (l.barrierId = void 0, l.offset = void 0), l.parentId && s.has(l.parentId) && (l.parentId = void 0), l.watchedIds && (l.watchedIds = l.watchedIds.filter((d) => !s.has(d)), l.watchedIds.length || (l.watchedIds = void 0)), l.servedFloorIds && (l.servedFloorIds = l.servedFloorIds.filter((d) => d !== t), l.servedFloorIds.length || (l.servedFloorIds = void 0));
+  if (e.navNodes) {
+    const l = new Set(
+      e.navNodes.filter((d) => d.floorId === t || d.objectId && s.has(d.objectId)).map((d) => d.id)
+    );
+    e.navNodes = e.navNodes.filter((d) => !l.has(d.id)), e.navEdges = (e.navEdges ?? []).filter(
+      (d) => !l.has(d.aId) && !l.has(d.bId) && !(d.objectId && s.has(d.objectId))
+    );
+  }
+  e.portals && (e.portals = e.portals.filter(
+    (l) => !s.has(l.a) && !s.has(l.b) && !(l.openingId && s.has(l.openingId))
+  ));
+  const a = new Set((e.portals ?? []).map((l) => l.id));
+  for (const l of e.zones ?? []) l.spaceIds = l.spaceIds.filter((d) => !s.has(d));
+  for (const l of e.portalGroups ?? []) l.portalIds = l.portalIds.filter((d) => a.has(d));
+  for (const l of e.buildings) ((r = l.roof) == null ? void 0 : r.floorId) === t && (l.roof = void 0);
+  return e.initialFloorId === t && (e.initialFloorId = void 0), i;
+}
+function ls(e, t) {
+  var a, r, l;
+  const n = e.floors.find((d) => d.id === t), s = H(), o = /* @__PURE__ */ new Map(), i = (d) => (o.has(d) || o.set(d, H()), o.get(d));
+  return e.floors.push({
+    ...n,
+    id: s,
+    name: `${n.name} copy`,
+    elevation: Math.max(
+      ...e.floors.filter((d) => d.buildingId === n.buildingId).map((d) => d.elevation + d.height)
+    )
+  }), e.junctions.filter((d) => d.floorId === t).forEach((d) => e.junctions.push({ ...structuredClone(d), id: i(d.id), floorId: s })), e.barriers.filter((d) => d.floorId === t).forEach(
+    (d) => e.barriers.push({
+      ...d,
+      id: i(d.id),
+      floorId: s,
+      startId: i(d.startId),
+      endId: i(d.endId)
+    })
+  ), e.objects.filter((d) => d.floorId === t).forEach(
+    (d) => {
+      var u, c;
+      return e.objects.push({
+        ...structuredClone(d),
+        id: i(d.id),
+        floorId: s,
+        feedId: void 0,
+        parentId: d.parentId ? i(d.parentId) : void 0,
+        barrierId: d.barrierId ? i(d.barrierId) : void 0,
+        servedFloorIds: (u = d.servedFloorIds) == null ? void 0 : u.map((f) => f === t ? s : f),
+        geometry: ((c = d.geometry) == null ? void 0 : c.mode) === "boundaries" ? {
+          mode: "boundaries",
+          loops: d.geometry.loops.map((f) => f.map((h) => ({ ...h, edgeId: i(h.edgeId) })))
+        } : d.geometry
+      });
+    }
+  ), (a = e.virtualBoundaries) == null || a.filter((d) => d.floorId === t).forEach(
+    (d) => e.virtualBoundaries.push({
+      ...d,
+      id: i(d.id),
+      floorId: s,
+      startId: i(d.startId),
+      endId: i(d.endId)
+    })
+  ), e.drawings.filter((d) => d.floorId === t).forEach((d) => e.drawings.push({ ...d, id: H(), floorId: s })), (r = e.navNodes) == null || r.filter((d) => d.floorId === t).forEach(
+    (d) => e.navNodes.push({
+      ...structuredClone(d),
+      id: i(d.id),
+      floorId: s,
+      objectId: d.objectId && o.has(d.objectId) ? o.get(d.objectId) : void 0
+    })
+  ), (l = e.navEdges) == null || l.filter((d) => o.has(d.aId) && o.has(d.bId)).forEach(
+    (d) => e.navEdges.push({
+      ...d,
+      id: i(d.id),
+      aId: o.get(d.aId),
+      bId: o.get(d.bId),
+      objectId: d.objectId && o.has(d.objectId) ? o.get(d.objectId) : void 0
+    })
+  ), s;
+}
+function Xs(e, t, n) {
+  let s = null;
+  for (const o of Sn(e, t))
+    D(n, o) && (!s || Math.abs(V(o)) < Math.abs(V(s))) && (s = o);
+  return s;
+}
+function Sn(e, t, n = 1) {
+  const s = e.barriers.filter((m) => m.floorId === t);
+  if (!s.length) return [];
+  const o = s.flatMap((m) => X(e, m)), i = 2, a = Math.min(...o.map((m) => m[0])) - i, r = Math.max(...o.map((m) => m[0])) + i, l = Math.min(...o.map((m) => m[1])) - i, d = Math.max(...o.map((m) => m[1])) + i, u = [
+    [a, l],
+    [r, l],
+    [r, d],
+    [a, d],
+    [a, l]
+  ], c = s.map((m) => {
+    const [I, b] = X(e, m), w = S(I, b) || 1e-3, g = Math.atan2(b[1] - I[1], b[0] - I[0]) * 180 / Math.PI, y = [(I[0] + b[0]) / 2, (I[1] + b[1]) / 2];
+    return [
+      C(Zt(y, w + m.thickness, m.thickness, g)).map(
+        (M) => [Math.round(M[0] * 1e4) / 1e4, Math.round(M[1] * 1e4) / 1e4]
+      )
+    ];
+  });
+  let f;
+  try {
+    f = ct.difference([u], ...c);
+  } catch {
+    return [];
+  }
+  const h = (m) => Math.abs(
+    m.reduce((I, b, w) => {
+      const g = m[(w + 1) % m.length];
+      return I + b[0] * g[1] - g[0] * b[1];
+    }, 0) / 2
+  ), p = (m) => {
+    const b = [];
+    for (const g of m) (!b.length || S(b[b.length - 1], g) > 1e-3) && b.push(g);
+    b.length > 1 && S(b[0], b[b.length - 1]) <= 1e-3 && b.pop();
+    const w = [];
+    for (let g = 0; g < b.length; g++) {
+      const y = b[(g + b.length - 1) % b.length], M = b[g], _ = b[(g + 1) % b.length], $ = M[0] - y[0], x = M[1] - y[1], E = _[0] - M[0], A = _[1] - M[1];
+      Math.abs($ * A - x * E) / (Math.hypot($, x) * Math.hypot(E, A) || 1) > 1e-4 && w.push(M);
+    }
+    return w.length >= 3 ? w : b;
+  };
+  return f.filter((m) => !m[0].some((I) => I[0] <= a + 1e-6 || I[0] >= r - 1e-6 || I[1] <= l + 1e-6 || I[1] >= d - 1e-6)).map((m) => p(T(m[0]))).filter((m) => m.length >= 3 && h(m) >= n).sort((m, I) => h(I) - h(m));
+}
+function qs(e, t, n) {
+  var l, d;
+  if (!n.length) return 0;
+  const s = Sn(e, t), o = (u, c) => {
+    try {
+      const f = ct.intersection([C(u)], [C(c)]), h = ct.union([C(u)], [C(c)]), p = (I) => I.reduce((b, w) => b + Math.abs(V(w[0])), 0), m = p(h);
+      return m > 0 ? p(f) / m : 0;
+    } catch {
+      return 0;
+    }
+  }, i = (u, c) => c.find((f) => o(u, f) > 0.95), a = [];
+  for (const u of e.objects) {
+    if (u.floorId !== t || u.kind !== "room" || !((l = u.rings) != null && l.length) || u.geometry !== void 0 || !i(u.rings[0], n)) continue;
+    const c = (d = s.map((f) => ({ r: f, score: o(u.rings[0], f) })).filter((f) => f.score > 0.2).sort((f, h) => h.score - f.score)[0]) == null ? void 0 : d.r;
+    c && a.push({ room: u, ring: c });
+  }
+  let r = 0;
+  for (const { room: u, ring: c } of a) {
+    if (a.some((m) => m.room !== u && m.ring === c)) continue;
+    const f = u.rings.slice(1);
+    u.rings = [C(c), ...f], u.position = vt(c);
+    const h = c.map((m) => m[0]), p = c.map((m) => m[1]);
+    u.width = Math.max(...h) - Math.min(...h), u.depth = Math.max(...p) - Math.min(...p), r++;
+  }
+  return r;
+}
+const Js = (e) => e.objects.filter((t) => et(t.kind));
+function ds(e, t) {
+  const n = W(t)[0];
+  return n != null && n.length ? vt(n) : yt(e, t);
+}
+function Rt(e, t) {
+  const [n, ...s] = W(e);
+  return !!n && D(t, n) && !s.some((o) => D(t, o));
+}
+function ve(e, t, n) {
+  let s = null, o = Number.POSITIVE_INFINITY;
+  for (const i of e.objects) {
+    if (i.floorId !== t || !et(i.kind) || !Rt(i, n)) continue;
+    const a = nt(i);
+    a >= o || (o = a, s = i);
+  }
+  return s;
+}
+const cs = 0.35;
+function fs(e) {
+  const t = new Map(e.barriers.map((s) => [s.id, s])), n = [];
+  for (const s of e.objects) {
+    if (!Me.has(s.kind)) continue;
+    const o = yt(e, s);
+    let i, a, r = cs;
+    const l = s.barrierId ? t.get(s.barrierId) : void 0;
+    if (l) {
+      const [f, h] = X(e, l), p = S(f, h) || 1;
+      i = (h[1] - f[1]) / p, a = -(h[0] - f[0]) / p, r += l.thickness / 2;
+    } else {
+      const f = (s.rotation ?? 0) * Math.PI / 180;
+      i = -Math.sin(f), a = Math.cos(f), r += s.depth / 2;
+    }
+    const d = (f) => {
+      const h = [o[0] + i * r * f, o[1] + a * r * f];
+      return ve(e, s.floorId, h) ?? (s.floorId === null ? null : ve(e, null, h));
+    }, u = d(1), c = d(-1);
+    !u || !c || u.id === c.id || n.push({ id: `inferred:${s.id}`, openingId: s.id, a: u.id, b: c.id, attests: "assumed" });
+  }
+  return n;
+}
+const us = 1, jt = 0.45, hs = 1.2;
+function xe(e) {
+  var c, f;
+  const t = /* @__PURE__ */ new Map(), n = (h, p) => {
+    const m = t.get(p);
+    m ? m.push(h) : t.set(p, [h]);
+  }, s = /* @__PURE__ */ new Map();
+  for (const h of e.objects) {
+    if (!zt(h.kind) || !h.floorId) continue;
+    const p = It(h), m = s.get(p);
+    m ? m.add(h.floorId) : s.set(p, /* @__PURE__ */ new Set([h.floorId]));
+  }
+  for (const h of e.objects) {
+    if (!et(h.kind) || (n(h, h.floorId ?? ""), !zt(h.kind))) continue;
+    const p = s.get(It(h));
+    for (const m of wt(e, h))
+      m.id !== h.floorId && !(p != null && p.has(m.id)) && n(h, m.id);
+  }
+  const o = (h, p = 0) => {
+    const m = [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+    for (const [I, b] of h)
+      m[0] = Math.min(m[0], I - p), m[1] = Math.min(m[1], b - p), m[2] = Math.max(m[2], I + p), m[3] = Math.max(m[3], b + p);
+    return m;
+  }, i = (h, p, m) => p >= h[0] && m >= h[1] && p <= h[2] && m <= h[3], a = new Map(
+    [...t.values()].flat().map((h) => {
+      const p = W(h);
+      return [h.id, { rings: p, bounds: o(p[0] ?? []) }];
+    })
+  ), r = (h, p) => {
+    const m = a.get(h.id);
+    return i(m.bounds, ...p) && !!m.rings[0] && D(p, m.rings[0]) && !m.rings.slice(1).some((I) => D(p, I));
+  }, l = /* @__PURE__ */ new Map();
+  for (const h of e.barriers) {
+    const p = h.floorId ?? "", m = l.get(p), I = X(e, h), b = { ends: I, bounds: o(I, jt) };
+    m ? m.push(b) : l.set(p, [b]);
+  }
+  const d = /* @__PURE__ */ new Map();
+  for (const [h, p] of t) {
+    const m = l.get(h) ?? [], I = [...p].sort((b, w) => nt(b) - nt(w));
+    for (const b of p)
+      for (const w of a.get(b.id).rings) {
+        if (!(w != null && w.length)) continue;
+        const g = T(w);
+        for (let y = 0; y < g.length; y++) {
+          const M = g[y], _ = g[(y + 1) % g.length], $ = S(M, _);
+          if ($ < 0.05) continue;
+          const x = (_[0] - M[0]) / $, E = (_[1] - M[1]) / $, A = E, v = -x, k = Math.max(1, Math.round($ / us));
+          for (let R = 0; R < k; R++) {
+            const P = (R + 0.5) / k * $, O = M[0] + x * P, z = M[1] + E * P;
+            if (!m.some((F) => i(F.bounds, O, z) && G([O, z], ...F.ends).distance < jt))
+              for (const F of [1, -1]) {
+                const U = [O + A * jt * F, z + v * jt * F];
+                if (r(b, U)) continue;
+                const L = I.find((Ht) => Ht.id !== b.id && r(Ht, U));
+                if (!L || ((c = b.geometry) == null ? void 0 : c.mode) === "boundaries" && ((f = L.geometry) == null ? void 0 : f.mode) === "boundaries") continue;
+                const xt = b.id < L.id ? `${b.id}|${L.id}` : `${L.id}|${b.id}`;
+                d.set(xt, (d.get(xt) ?? 0) + $ / k);
+              }
+          }
+        }
+      }
+  }
+  const u = on(e);
+  for (const [h, p] of d) {
+    if (p < hs) continue;
+    const [m, I] = h.split("|");
+    u.push({ id: `open:${m}:${I}`, a: m, b: I, attests: "none" });
+  }
+  return u;
+}
+const Qe = (e) => e.startsWith("inferred:") || e.startsWith("open:");
+function gs(e) {
+  const t = e.portals ?? [], n = t.filter((r) => !Qe(r.id)), s = new Set(n.flatMap((r) => r.openingId ? [r.openingId] : [])), o = new Set(n.map((r) => JSON.stringify([r.a, r.b].sort()))), i = new Map(t.filter((r) => Qe(r.id)).map((r) => [r.id, r])), a = [...fs(e), ...xe(e)].filter((r) => !r.openingId || !s.has(r.openingId)).filter((r) => !r.id.startsWith("open:") || !o.has(JSON.stringify([r.a, r.b].sort()))).map((r) => {
+    const l = i.get(r.id);
+    return l && (l.passage !== void 0 && (r.passage = l.passage), l.attests !== void 0 && (r.attests = l.attests), l.name !== void 0 && (r.name = l.name), l.metadata !== void 0 && (r.metadata = l.metadata)), r;
+  });
+  return e.portals = [...n, ...a], a.length;
+}
+function ms(e, t, n, s) {
+  var i;
+  const o = [];
+  for (const a of e.objects) {
+    if (a.floorId !== t || !et(a.kind) || ((i = a.geometry) == null ? void 0 : i.mode) === "boundaries" || e.objects.some((c) => c.parentId === a.id)) continue;
+    const r = W(a)[0];
+    if (!(r != null && r.length)) continue;
+    const l = (c) => Rt(a, c) && !W(a).some((f) => {
+      const h = T(f);
+      return h.some((p, m) => G(c, p, h[(m + 1) % h.length]).distance < 1e-6);
+    });
+    if (l(n) || l(s)) continue;
+    const d = Math.max(8, Math.min(200, Math.round(S(n, s) / 0.25)));
+    let u = !1;
+    for (let c = 1; c < d && !u; c++) {
+      const f = c / d;
+      u = Rt(a, [n[0] + (s[0] - n[0]) * f, n[1] + (s[1] - n[1]) * f]);
+    }
+    u && o.push(a);
+  }
+  return o;
+}
+function kn(e, t, n, s) {
+  const o = [];
+  for (const i of ms(e, t, n, s))
+    try {
+      o.push(Mn(e, i.id, n, s, !1));
+    } catch {
+    }
+  return o;
+}
+function Ks(e, t) {
+  if (!e.barriers.find((i) => i.id === t)) return null;
+  const s = { ...e, barriers: e.barriers.filter((i) => i.id !== t) }, o = new Set(xe(e).map((i) => [i.a, i.b].sort().join("|")));
+  for (const i of xe(s)) {
+    if (o.has([i.a, i.b].sort().join("|"))) continue;
+    const a = e.objects.find((l) => l.id === i.a), r = e.objects.find((l) => l.id === i.b);
+    if (a && r) return [a, r];
+  }
+  return null;
+}
+function ps(e, t, n) {
+  var i, a;
+  const s = e.objects.find((r) => r.id === t), o = e.objects.find((r) => r.id === n);
+  if (!s || !o || s.id === o.id) return !1;
+  if (((i = s.geometry) == null ? void 0 : i.mode) === "boundaries" || ((a = o.geometry) == null ? void 0 : a.mode) === "boundaries") {
+    if (!ts(e, s, o)) return !1;
+  } else {
+    const r = ct.union(W(s).map(C), W(o).map(C));
+    if (r.length !== 1) return !1;
+    s.rings = r[0].map((l) => C(l));
+  }
+  e.objects = e.objects.filter((r) => r.id !== n);
+  for (const r of e.objects) r.parentId === n && (r.parentId = t);
+  for (const r of e.portals ?? [])
+    r.a === n && (r.a = t), r.b === n && (r.b = t);
+  e.portals = (e.portals ?? []).filter((r) => r.a !== r.b);
+  for (const r of e.zones ?? [])
+    r.spaceIds = [...new Set(r.spaceIds.map((l) => l === n ? t : l))];
+  return Nt(e), !0;
+}
+function Qs(e, t = "Untitled site", n = "Site ground level = 0 m") {
+  return {
+    schemaVersion: 1,
+    id: crypto.randomUUID(),
+    name: t,
+    description: t,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    origin: e,
+    datum: n,
+    buildings: [{ id: "building-main", name: "Main building" }],
+    floors: [{ id: "floor-ground", buildingId: "building-main", name: "Ground floor", elevation: 0, height: 3.5 }],
+    junctions: [],
+    barriers: [],
+    objects: [],
+    drawings: []
+  };
+}
+function An(e, t, n, s) {
+  const o = {
+    door: [1, 0.2, 2.1],
+    window: [1.2, 0.15, 1.6],
+    gate: [4, 0.15, 2],
+    turnstile: [1, 1, 1.1],
+    elevator: [2.6, 2.6, 2.5],
+    stairs: [2.5, 4.5, 2.7],
+    office: [6, 3, 2.6],
+    container: [6, 2.4, 2.6],
+    storage: [8, 6, 0.1],
+    camera: [0.5, 0.5, 2.4],
+    sensor: [0.35, 0.35, 0.25],
+    light: [1.2, 0.3, 2.8],
+    alarm: [0.4, 0.4, 0.4],
+    equipment: [1.4, 0.9, 1.4]
+  }, [i, a, r] = o[e] ?? [1, 1, 0];
+  return {
+    id: crypto.randomUUID(),
+    kind: e,
+    floorId: n,
+    name: s ?? e[0].toUpperCase() + e.slice(1),
+    position: t,
+    rotation: 0,
+    width: i,
+    depth: a,
+    height: r,
+    symbol: e === "poi" ? "personnel" : void 0,
+    coverageAngle: e === "camera" ? 70 : void 0,
+    coverageRange: e === "camera" ? 12 : void 0,
+    servedFloorIds: e === "stairs" || e === "elevator" ? n ? [n] : [] : void 0,
+    ...e === "light" ? { light: { kelvin: 4e3, intensity: 45, range: 12 } } : {}
+  };
+}
+const Is = 12, bs = 70;
+function ti(e, t) {
+  var d;
+  const n = t.coverageRange ?? Is, s = (t.coverageAngle ?? bs) / 2, o = yt(e, t), i = t.rotation ?? 0, a = e.barriers.filter((u) => u.floorId === t.floorId), r = new Map(a.map((u) => [u.id, X(e, u)])), l = [];
+  for (const u of e.objects) {
+    if (u.id === t.id || u.floorId !== t.floorId || !et(u.kind) && !nn(u.kind)) continue;
+    if ((d = u.rings) != null && d.length && D(o, u.rings[0])) {
+      l.push(u.id);
+      continue;
+    }
+    const c = yt(e, u), f = S(o, c);
+    if (f < 0.01 || f > n) continue;
+    const h = Math.atan2(c[1] - o[1], c[0] - o[0]) * 180 / Math.PI;
+    if (Math.abs(((h - i) % 360 + 540) % 360 - 180) > s) continue;
+    a.some((I) => {
+      if (I.id === u.barrierId) return !1;
+      const [b, w] = r.get(I.id);
+      return ss(o, c, b, w);
+    }) || l.push(u.id);
+  }
+  return l;
+}
+function ei(e) {
+  const t = structuredClone(e);
+  return t.id = crypto.randomUUID(), t.name = `${e.name} copy`, t.updatedAt = (/* @__PURE__ */ new Date()).toISOString(), t.objects.forEach((n) => {
+    delete n.feedId;
+  }), t;
+}
+function ni(e) {
+  var n, s;
+  const t = e.initialFloorId;
+  return t === null ? null : t !== void 0 && e.floors.some((o) => o.id === t) ? t : ((n = e.floors.find((o) => o.elevation === 0)) == null ? void 0 : n.id) ?? ((s = e.floors[0]) == null ? void 0 : s.id) ?? null;
+}
+async function ys(e) {
+  return new Promise((t, n) => {
+    const s = new FileReader();
+    s.onload = () => t(String(s.result)), s.onerror = () => n(s.error), s.readAsDataURL(e);
+  });
+}
+async function oi(e, t) {
+  const n = {};
+  for (const s of new Set(e.drawings.map((o) => o.assetId))) {
+    const o = await t.get(s);
+    if (!o) throw new Error("A reference drawing is missing. Reattach it or remove its reference before exporting.");
+    n[s] = await ys(o);
+  }
+  return JSON.stringify({ ...e, embeddedAssets: n }, null, 2);
+}
+async function si(e, t) {
+  const n = JSON.parse(e), s = Ae(n), o = n.embeddedAssets ?? {}, i = [];
+  for (const r of new Set(s.drawings.map((l) => l.assetId))) {
+    const l = o[r];
+    if (typeof l != "string" || !/^data:image\/(png|jpeg|webp);base64,/.test(l))
+      throw new Error("Project export is missing a supported reference image.");
+    const d = await fetch(l);
+    i.push([r, await d.blob()]);
+  }
+  const a = structuredClone(s);
+  delete a.embeddedAssets;
+  for (const [r, l] of i) {
+    const d = crypto.randomUUID();
+    await t.put(d, l), a.drawings.filter((u) => u.assetId === r).forEach((u) => {
+      u.assetId = d;
+    });
+  }
+  return a.id = crypto.randomUUID(), a.updatedAt = (/* @__PURE__ */ new Date()).toISOString(), a;
+}
+function ii(e) {
+  const t = JSON.parse(e), n = Ae(t), s = t.embeddedAssets ?? {}, o = structuredClone(n);
+  return delete o.embeddedAssets, { project: o, assets: { get: async (a) => {
+    const r = s[a];
+    if (!(typeof r != "string" || !/^data:image\/(png|jpeg|webp);base64,/.test(r)))
+      return (await fetch(r)).blob();
+  }, put: async () => {
+  }, delete: async () => {
+  } } };
+}
+function ws(e, t, n, s, o = "wall") {
+  if (S(n, s) < tt - 1e-6) return;
+  const i = rs(e, n, s, t);
+  if (i) throw new Error(i);
+  const a = ie(e, n, s, t, o);
+  return a && o === "wall" && kn(e, t, ...X(e, a)), a;
+}
+function vs(e, t, n) {
+  Tt(e, t);
+  const s = Vo(e, t, n);
+  if (!s) return null;
+  const o = s.rings[0], i = e.objects.filter((u) => u.floorId === t && u.kind === "room" && Rt(u, n)).sort((u, c) => nt(u) - nt(c))[0], a = i ?? An("room", vt(o), t, "Room"), r = { ...a, geometry: { mode: "boundaries", loops: s.loops } };
+  if (r.rings = se(e, r), !Rt(r, n)) return null;
+  const l = (u) => u.flat().map((c) => `${c.edgeId}:${!!c.reversed}`).sort().join("|"), d = e.objects.find(
+    (u) => {
+      var c;
+      return ((c = u.geometry) == null ? void 0 : c.mode) === "boundaries" && l(u.geometry.loops) === l(s.loops);
+    }
+  );
+  return d ? { room: d, existing: !0 } : (yn(e, a, s), i || e.objects.push(a), { room: a, existing: !!i });
+}
+function xs(e, t) {
+  for (const n of e.barriers) {
+    if (!t.has(n.startId) && !t.has(n.endId)) continue;
+    const s = S(...X(e, n)), o = e.objects.filter((r) => r.barrierId === n.id).sort((r, l) => (r.offset ?? 0) - (l.offset ?? 0));
+    let i = s;
+    for (const r of [...o].reverse())
+      r.offset = Math.min(r.offset ?? 0, i - r.width / 2), i = r.offset - r.width / 2;
+    let a = 0;
+    for (const r of o)
+      r.offset = Math.max(r.offset ?? 0, a + r.width / 2), a = r.offset + r.width / 2;
+  }
+}
+function Es(e, t) {
+  var o, i, a, r;
+  const n = /* @__PURE__ */ new Map();
+  let s;
+  if (t.kind === "junction") {
+    const l = e.junctions.find((d) => d.id === t.id);
+    if (!l) return;
+    n.set(l.id, [t.point[0] - l.position[0], t.point[1] - l.position[1]]);
+  } else if (t.kind === "barrier") {
+    const l = Z(e).find((m) => m.id === t.id);
+    if (!l) return;
+    const [d, u] = X(e, l), c = S(d, u), f = -(u[1] - d[1]) / c, h = (u[0] - d[0]) / c, p = (t.point[0] - (d[0] + u[0]) / 2) * f + (t.point[1] - (d[1] + u[1]) / 2) * h;
+    for (const m of [l.startId, l.endId]) n.set(m, [f * p, h * p]);
+  } else {
+    const l = (i = (o = e.objects.find((d) => d.id === t.id)) == null ? void 0 : o.rings) == null ? void 0 : i[t.ringIndex];
+    if (((r = (a = e.objects.find((d) => d.id === t.id)) == null ? void 0 : a.geometry) == null ? void 0 : r.mode) === "boundaries" || (s = l && T(l)[t.index], !s)) return;
+  }
+  return (l, d) => {
+    for (const u of l.junctions) {
+      const c = n.get(u.id);
+      c && (u.position = [u.position[0] + c[0] * d, u.position[1] + c[1] * d]);
+    }
+    if (t.kind === "ring") {
+      const u = l.objects.find((f) => f.id === t.id), c = T(u.rings[t.ringIndex]);
+      c[t.index] = [
+        s[0] + (t.point[0] - s[0]) * d,
+        s[1] + (t.point[1] - s[1]) * d
+      ], u.rings[t.ringIndex] = C(c), u.position = vt(u.rings[0]);
+    } else
+      xs(l, new Set(n.keys()));
+  };
+}
+function Ms(e, t) {
+  var n;
+  (n = Es(e, t)) == null || n(e, 1);
+}
+const Ss = (e, t) => {
+  var n, s, o, i;
+  switch (t.kind) {
+    case "addBuilding":
+      return e.buildings.push(structuredClone(t.building)), t.building.id;
+    case "patchBuilding":
+      return gt(e.buildings, t.buildingId, t.set, ["id"]);
+    case "addFloor":
+      return e.floors.push(structuredClone(t.floor)), t.floor.id;
+    case "patchFloor":
+      return gt(e.floors, t.floorId, t.set, ["id", "buildingId"]);
+    case "removeFloor":
+      return as(e, t.floorId);
+    case "duplicateFloor":
+      if (!e.floors.some((a) => a.id === t.floorId)) throw new Error("No such floor.");
+      return ls(e, t.floorId);
+    case "patchProject":
+      for (const a of Object.keys(t.set))
+        if (!["name", "description", "datum", "initialFloorId"].includes(a))
+          throw new Error(`Cannot patch project ${a}.`);
+      return Object.assign(e, t.set), e.id;
+    case "patchBarrier":
+      return gt(e.barriers, t.barrierId, t.set, ["id", "startId", "endId", "floorId"]);
+    case "removeBarrier":
+      En(e, t.barrierId), Nt(e);
+      return;
+    case "moveGeometry":
+      return Ms(e, t.move), t.move.id;
+    case "drawBoundary":
+      return Xo(e, t.floorId, t.a, t.b);
+    case "drawBarrier":
+      return (n = ws(e, t.floorId, t.a, t.b, t.barrierKind)) == null ? void 0 : n.id;
+    case "encloseRoom": {
+      const a = vs(e, t.floorId, t.point);
+      if (!a) throw new Error("No enclosed region at that point. Complete its walls or virtual boundaries first.");
+      return t.name && (a.room.name = t.name), a.room.id;
+    }
+    case "addHole": {
+      const a = e.objects.find((r) => r.id === t.objectId);
+      if (!((s = a == null ? void 0 : a.rings) != null && s.length)) throw new Error("Select an area with a footprint.");
+      return ((o = a.geometry) == null ? void 0 : o.mode) === "boundaries" ? Ko(e, a, t.ring) : a.rings.push(structuredClone(t.ring)), a.id;
+    }
+    case "patchZone":
+      for (const a of Object.keys(t.set))
+        if (!["name", "purpose", "connects", "metadata"].includes(a)) throw new Error(`Cannot patch zone ${a}.`);
+      return gt(e.zones ?? [], t.zoneId, t.set, ["id"]);
+    case "addPortal": {
+      const a = H();
+      return (e.portals ?? (e.portals = [])).push({ ...structuredClone(t.portal), id: a }), a;
+    }
+    case "removePortal":
+      e.portals = (e.portals ?? []).filter((a) => a.id !== t.portalId), Nt(e);
+      return;
+    case "setNavigation":
+      e.navNodes = structuredClone(t.nodes), e.navEdges = structuredClone(t.edges);
+      return;
+    case "addZone":
+      return ro(e, t.name, t.spaceIds, t.purpose);
+    case "removeZone":
+      ao(e, t.zoneId);
+      return;
+    case "setZoneMembers":
+      lo(e, t.zoneId, t.spaceIds, t.member);
+      return;
+    case "nestZone": {
+      if (!co(e, t.parentId, t.childId)) throw new Error("That nesting would make a zone contain itself.");
+      return !0;
+    }
+    case "addPortalGroup":
+      return fo(e, t.name, t.portalIds);
+    case "removePortalGroup":
+      uo(e, t.groupId);
+      return;
+    case "setPortalGroupMembers":
+      ho(e, t.groupId, t.portalIds, t.member);
+      return;
+    case "patchPortal":
+      return gt(e.portals ?? [], t.portalId, t.set, ["id", "a", "b", "openingId"]);
+    case "patchObject":
+      return gt(e.objects, t.objectId, t.set, ["id", "kind"]);
+    case "addObject": {
+      const a = An(t.objectKind, t.position, t.floorId, t.name);
+      return t.set && gt([a], a.id, t.set, ["id", "kind"]), e.objects.push(a), a.id;
+    }
+    case "removeObjects": {
+      const a = new Set(t.ids), r = e.objects.length;
+      if (e.objects = e.objects.filter((l) => !a.has(l.id)), e.navNodes) {
+        const l = new Set(e.navNodes.filter((d) => d.objectId && a.has(d.objectId)).map((d) => d.id));
+        e.navNodes = e.navNodes.filter((d) => !l.has(d.id)), e.navEdges = (e.navEdges ?? []).filter(
+          (d) => !l.has(d.aId) && !l.has(d.bId) && (!d.objectId || !a.has(d.objectId))
+        );
+      }
+      return Nt(e), r - e.objects.length;
+    }
+    case "refreshPortals":
+      return gs(e);
+    case "pruneOntology":
+      Nt(e);
+      return;
+    case "addBarrier":
+      return (i = ie(e, t.a, t.b, t.floorId, t.barrierKind)) == null ? void 0 : i.id;
+    case "addBoundary":
+      return Ut(e, t.floorId, t.a, t.b);
+    case "connectSpace":
+      return qo(e, t.objectId, t.source), t.objectId;
+    case "disconnectSpace":
+      return Jo(e, t.objectId), t.objectId;
+    case "splitRoom":
+      return Mn(e, t.roomId, t.a, t.b, t.wall);
+    case "divideSpaces":
+      return kn(e, t.floorId, t.a, t.b);
+    case "setOrigin":
+      return e.origin = [...t.origin], e.origin.join(",");
+    case "mergeSpaces": {
+      if (!ps(e, t.keepId, t.absorbedId))
+        throw new Error("Those spaces do not touch, so there is nothing to merge.");
+      return !0;
+    }
+    default:
+      throw new Error(`Unknown mutation: ${String(t.kind)}`);
+  }
+};
+function gt(e, t, n, s) {
+  const o = e.find((i) => i.id === t);
+  if (!o) throw new Error(`No such entity: ${t}`);
+  for (const i of Object.keys(n))
+    if (s.includes(i) || ["__proto__", "constructor", "prototype"].includes(i))
+      throw new Error(`Cannot patch ${i}.`);
+  return Object.assign(o, structuredClone(n)), t;
+}
+const ri = (e, t) => ks(e, [t]);
+function ks(e, t) {
+  const n = [], s = Ho(e, (o) => {
+    for (const [i, a] of t.entries())
+      try {
+        n.push(Ss(o, a));
+      } catch (r) {
+        throw new Error(
+          `Mutation #${i + 1} (${a.kind}): ${r instanceof Error ? r.message : String(r)}`
+        );
+      }
+  });
+  return s.ok ? { ...s, outcomes: n } : s;
+}
+const he = "@room-nav:", tn = (e) => Math.sign(
+  e.reduce((t, n, s) => {
+    const o = e[(s + 1) % e.length];
+    return t + n[0] * o[1] - o[0] * n[1];
+  }, 0)
+) || 1;
+function ai(e, t, n = { nodes: [], edges: [] }) {
+  var c;
+  const s = e.objects.filter((f) => {
+    var h;
+    return f.kind === "room" && ((h = W(f)[0]) == null ? void 0 : h.length);
+  }), o = n.nodes.filter((f) => !f.id.startsWith(he)).map((f) => ({ ...f, position: [...f.position] })), i = n.edges.filter((f) => !f.id.startsWith(he)), a = new Map(o.map((f) => [f.id, f])), r = new Map(s.map((f) => [f.id, []])), l = new Map(s.map((f) => [f.id, f.floorId]));
+  for (const f of o)
+    f.objectId && l.get(f.objectId) === f.floorId && ((c = r.get(f.objectId)) == null || c.push(f));
+  for (const { spaceId: f, nodeId: h } of t) {
+    const p = a.get(h), m = r.get(f);
+    p && m && l.get(f) === p.floorId && !m.includes(p) && m.push(p);
+  }
+  const d = /* @__PURE__ */ new Map();
+  for (const f of e.objects)
+    if (f.water && f.parentId) {
+      const h = d.get(f.parentId) ?? [];
+      h.push(...W(f).slice(0, 1)), d.set(f.parentId, h);
+    }
+  const u = an(e);
+  for (const f of s) {
+    const h = `${he}${encodeURIComponent(f.id)}:`, p = r.get(f.id), [m, ...I] = W(f), b = u(f.floorId, Vt(m)), w = (E, A) => As(E, A, m) && b(E, A), g = [...I, ...d.get(f.id) ?? []], y = (E) => {
+      if (!w(E, E) || p.some((v) => S(v.position, E) < 0.01)) return;
+      const A = { id: `${h}point:${p.length}`, floorId: f.floorId, position: E };
+      o.push(A), p.push(A);
+    }, M = (E, A) => {
+      const v = T(E), k = tn(E), R = (P, O) => {
+        const z = S(P, O) || 1;
+        return [k * (P[1] - O[1]) / z, k * (O[0] - P[0]) / z];
+      };
+      for (let P = 0; P < v.length; P++) {
+        const O = v[P], z = v[(P + v.length - 1) % v.length], F = v[(P + 1) % v.length], U = R(z, O), L = R(O, F), xt = 1 + U[0] * L[0] + U[1] * L[1], Ht = k * ((O[0] - z[0]) * (F[1] - O[1]) - (O[1] - z[1]) * (F[0] - O[0]));
+        A > 0 && Ht >= 0 || (xt > 0.05 && y([O[0] + A * (U[0] + L[0]) / xt, O[1] + A * (U[1] + L[1]) / xt]), A < 0 && y([(O[0] + F[0]) / 2 + A * L[0], (O[1] + F[1]) / 2 + A * L[1]]));
+      }
+    };
+    M(m, Ot + 0.2);
+    for (const E of g) M(E, -Ot - 0.1);
+    const _ = T(m), $ = tn(m);
+    for (const E of [...p])
+      for (let A = 0; A < _.length; A++) {
+        const v = _[A], k = _[(A + 1) % _.length], R = S(v, k);
+        R && G(E.position, v, k).distance < 0.01 && y([
+          E.position[0] + $ * (v[1] - k[1]) / R * 0.9,
+          E.position[1] + $ * (k[0] - v[0]) / R * 0.9
+        ]);
+      }
+    let x = p.find((E) => E.objectId === f.id);
+    if (x || (x = { id: `${h}anchor`, floorId: f.floorId, position: [...f.position], objectId: f.id }, o.push(x), p.push(x)), !w(x.position, x.position)) {
+      const E = p.filter((A) => w(A.position, A.position)).sort((A, v) => S(A.position, f.position) - S(v.position, f.position))[0];
+      E && (x.position = [...E.position]);
+    }
+    for (let E = 0; E < p.length; E++)
+      for (let A = E + 1; A < p.length; A++) {
+        const v = p[E], k = p[A];
+        w(v.position, k.position) && i.push({ id: `${h}edge:${E}:${A}`, kind: "walk", aId: v.id, bId: k.id });
+      }
+  }
+  return { nodes: o, edges: i };
+}
+function As(e, t, n) {
+  const s = T(n), o = (d) => D(d, s) || s.some((u, c) => G(d, u, s[(c + 1) % s.length]).distance < 1e-7);
+  if (!o(e) || !o(t)) return !1;
+  const i = t[0] - e[0], a = t[1] - e[1];
+  if (S(e, t) < 1e-8) return !0;
+  const l = [0, 1];
+  for (let d = 0; d < s.length; d++) {
+    const u = s[d], c = s[(d + 1) % s.length], f = c[0] - u[0], h = c[1] - u[1], p = i * h - a * f;
+    if (Math.abs(p) < 1e-9)
+      for (const m of [u, c]) G(m, e, t).distance < 1e-7 && l.push(G(m, e, t).t);
+    else {
+      const m = ((u[0] - e[0]) * h - (u[1] - e[1]) * f) / p, I = ((u[0] - e[0]) * a - (u[1] - e[1]) * i) / p;
+      m > 0 && m < 1 && I >= 0 && I <= 1 && l.push(m);
+    }
+  }
+  return l.sort((d, u) => d - u), l.slice(1).every((d, u) => o([e[0] + i * (d + l[u]) / 2, e[1] + a * (d + l[u]) / 2]));
+}
+export {
+  Go as COORD_LIMIT,
+  bs as DEFAULT_FOV,
+  Is as DEFAULT_RANGE,
+  Bo as DOOR_COST,
+  $o as ELEVATOR_BASE,
+  No as ELEVATOR_PER_METRE,
+  Lo as EXTERIOR_PRESETS,
+  Ds as HERE,
+  tt as MIN_SEGMENT,
+  zo as NAV_WELD,
+  oo as OBJECT_KINDS,
+  te as OPENING_MIN_SEGMENT,
+  rn as PITCH,
+  Oo as STAIR_CLIMB_FACTOR,
+  ie as addBarrier,
+  Ko as addBoundaryHole,
+  fn as addNavEdge,
+  cn as addNavNode,
+  fo as addPortalGroup,
+  Ut as addVirtualBoundary,
+  ro as addZone,
+  ri as applyMutation,
+  ks as applyMutations,
+  X as barrierEnds,
+  yn as bindSpaceToRegion,
+  ys as blobDataUrl,
+  Z as boundaryEdges,
+  Vo as boundaryRegionAt,
+  oe as boundaryRegions,
+  At as boundaryRings,
+  ai as buildRoomNavigation,
+  Ns as captive,
+  vt as centroid,
+  Gs as chainVertical,
+  C as closeRing,
+  qo as connectSpace,
+  ei as copyProject,
+  ti as coverageOf,
+  An as createObject,
+  po as derivedGraph,
+  se as derivedSpaceRings,
+  Jo as disconnectSpace,
+  S as distance,
+  kn as divideSpaces,
+  Xo as drawVirtualBoundary,
+  ls as duplicateFloor,
+  Ye as edgeCost,
+  Xt as edgeLength,
+  Dt as effectivePortals,
+  Qs as emptyProject,
+  Xs as enclosedRegion,
+  Sn as enclosedRegions,
+  Ps as entryInto,
+  oi as exportProject,
+  Us as findRoute,
+  Se as flights,
+  Bs as flightsAt,
+  ce as floorPhrase,
+  Zs as followsBoundaries,
+  W as footprint,
+  Zo as freezeProject,
+  Hs as geoOrigin,
+  si as importProject,
+  Rt as inSpace,
+  xe as inferOpenBoundaries,
+  fs as inferPortals,
+  pt as isArea,
+  Rs as isDevice,
+  nn as isOpening,
+  et as isSpace,
+  zt as isVertical,
+  ps as mergeSpaces,
+  Ws as moveOrigin,
+  ln as navEdges,
+  Ft as navNodes,
+  Ls as navPath,
+  co as nestZone,
+  Tt as normalizeBoundaries,
+  nt as objectArea,
+  yt as objectPosition,
+  xn as objectRotation,
+  T as openRing,
+  ni as openingFloorId,
+  ii as parseExport,
+  Ts as passesThrough,
+  $s as perimeter,
+  bo as pitchOf,
+  D as pointInRing,
+  Fs as primaryShafts,
+  Nt as pruneOntology,
+  Os as reaches,
+  Zt as rectangle,
+  qs as refitEnclosedRooms,
+  vn as refreshBoundarySpaces,
+  gs as refreshPortals,
+  as as removeFloor,
+  uo as removePortalGroup,
+  ao as removeZone,
+  V as ringArea,
+  Lt as rotate,
+  Fo as routeAnchors,
+  Co as routeSteps,
+  Io as runFor,
+  G as segmentProjection,
+  ss as segmentsCross,
+  wt as servedFloors,
+  ho as setPortalGroupMembers,
+  lo as setZoneMembers,
+  It as shaftKey,
+  Cs as shaftVoids,
+  on as sharedBoundaryPortals,
+  Vs as slopeElevation,
+  ve as spaceAt,
+  ds as spacePoint,
+  Js as spaces,
+  ms as spacesDividedBy,
+  Ks as spacesRejoinedBy,
+  zs as span,
+  Ys as toLngLat,
+  js as toLocal,
+  Ho as transact,
+  H as uid,
+  Uo as validateNavigation,
+  Ae as validateProject,
+  Do as validateRelationships,
+  hn as validateRings,
+  io as zoneSpaces
+};
+//# sourceMappingURL=index.js.map