@archilogic/floor-plan-sdk 5.1.6 → 5.1.8

package/dist/fpe.js

@@ -2,7 +2,7 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 /*!
-  Archilogic Floor Plan Engine SDK v5.1.6 webgl build 250326-135213-0888be
+  Archilogic Floor Plan Engine SDK v5.1.8 webgl build 250429-111617-277c93
 
   Copyright (c) 2025 Archilogic AG. All rights reserved.
 
@@ -4617,6 +4617,13 @@ function signedArea$1(polygon) {
 function polygonArea(polygon) {
   return Math.abs(signedArea$1(polygon));
 }
+function polygonWithHolesArea(polygons) {
+  let area2 = Math.abs(signedArea$1(polygons[0]));
+  for (let polygon of polygons.slice(1)) {
+    area2 -= Math.abs(signedArea$1(polygon));
+  }
+  return area2;
+}
 function cleanPolygons(polygons, distance = 0.01) {
   let _polygons = getClipperPolygons(polygons);
   let result = ClipperLib$1.Clipper.CleanPolygons(_polygons, distance);
@@ -5343,10 +5350,10 @@ function transformMat2d(out, a2, m2) {
   };
 })();
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x2) {
+function getDefaultExportFromCjs$1(x2) {
   return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
 }
-function getAugmentedNamespace(n2) {
+function getAugmentedNamespace$1(n2) {
   if (n2.__esModule) return n2;
   var f3 = n2.default;
   if (typeof f3 == "function") {
@@ -5794,7 +5801,7 @@ earcut.flatten = function(data) {
   return result;
 };
 var earcutExports = earcut$2.exports;
-const earcut$1 = /* @__PURE__ */ getDefaultExportFromCjs(earcutExports);
+const earcut$1 = /* @__PURE__ */ getDefaultExportFromCjs$1(earcutExports);
 var byteToHex = [];
 for (var i$3 = 0; i$3 < 256; ++i$3) {
   byteToHex.push((i$3 + 256).toString(16).slice(1));
@@ -6400,6 +6407,223 @@ function resolveTransform(position, rotation) {
   }
   return resolvedTransformList;
 }
+function getDefaultExportFromCjs(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+}
+function getAugmentedNamespace(n2) {
+  if (Object.prototype.hasOwnProperty.call(n2, "__esModule")) return n2;
+  var f3 = n2.default;
+  if (typeof f3 == "function") {
+    var a2 = function a22() {
+      if (this instanceof a22) {
+        return Reflect.construct(f3, arguments, this.constructor);
+      }
+      return f3.apply(this, arguments);
+    };
+    a2.prototype = f3.prototype;
+  } else a2 = {};
+  Object.defineProperty(a2, "__esModule", { value: true });
+  Object.keys(n2).forEach(function(k3) {
+    var d2 = Object.getOwnPropertyDescriptor(n2, k3);
+    Object.defineProperty(a2, k3, d2.get ? d2 : {
+      enumerable: true,
+      get: function() {
+        return n2[k3];
+      }
+    });
+  });
+  return a2;
+}
+var polylabel$1$1 = { exports: {} };
+let TinyQueue$1 = class TinyQueue {
+  constructor(data = [], compare = defaultCompare$1) {
+    this.data = data;
+    this.length = this.data.length;
+    this.compare = compare;
+    if (this.length > 0) {
+      for (let i2 = (this.length >> 1) - 1; i2 >= 0; i2--) this._down(i2);
+    }
+  }
+  push(item) {
+    this.data.push(item);
+    this.length++;
+    this._up(this.length - 1);
+  }
+  pop() {
+    if (this.length === 0) return void 0;
+    const top = this.data[0];
+    const bottom = this.data.pop();
+    this.length--;
+    if (this.length > 0) {
+      this.data[0] = bottom;
+      this._down(0);
+    }
+    return top;
+  }
+  peek() {
+    return this.data[0];
+  }
+  _up(pos) {
+    const { data, compare } = this;
+    const item = data[pos];
+    while (pos > 0) {
+      const parent = pos - 1 >> 1;
+      const current = data[parent];
+      if (compare(item, current) >= 0) break;
+      data[pos] = current;
+      pos = parent;
+    }
+    data[pos] = item;
+  }
+  _down(pos) {
+    const { data, compare } = this;
+    const halfLength = this.length >> 1;
+    const item = data[pos];
+    while (pos < halfLength) {
+      let left = (pos << 1) + 1;
+      let best = data[left];
+      const right = left + 1;
+      if (right < this.length && compare(data[right], best) < 0) {
+        left = right;
+        best = data[right];
+      }
+      if (compare(best, item) >= 0) break;
+      data[pos] = best;
+      pos = left;
+    }
+    data[pos] = item;
+  }
+};
+function defaultCompare$1(a2, b2) {
+  return a2 < b2 ? -1 : a2 > b2 ? 1 : 0;
+}
+const tinyqueue$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: TinyQueue$1
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$0$2 = /* @__PURE__ */ getAugmentedNamespace(tinyqueue$1);
+var hasRequiredPolylabel;
+function requirePolylabel() {
+  if (hasRequiredPolylabel) return polylabel$1$1.exports;
+  hasRequiredPolylabel = 1;
+  var Queue2 = require$$0$2;
+  if (Queue2.default) Queue2 = Queue2.default;
+  polylabel$1$1.exports = polylabel2;
+  polylabel$1$1.exports.default = polylabel2;
+  function polylabel2(polygon, precision, debug) {
+    precision = precision || 1;
+    var minX, minY, maxX, maxY;
+    for (var i2 = 0; i2 < polygon[0].length; i2++) {
+      var p2 = polygon[0][i2];
+      if (!i2 || p2[0] < minX) minX = p2[0];
+      if (!i2 || p2[1] < minY) minY = p2[1];
+      if (!i2 || p2[0] > maxX) maxX = p2[0];
+      if (!i2 || p2[1] > maxY) maxY = p2[1];
+    }
+    var width = maxX - minX;
+    var height = maxY - minY;
+    var cellSize = Math.min(width, height);
+    var h2 = cellSize / 2;
+    if (cellSize === 0) {
+      var degeneratePoleOfInaccessibility = [minX, minY];
+      degeneratePoleOfInaccessibility.distance = 0;
+      return degeneratePoleOfInaccessibility;
+    }
+    var cellQueue = new Queue2(void 0, compareMax2);
+    for (var x2 = minX; x2 < maxX; x2 += cellSize) {
+      for (var y2 = minY; y2 < maxY; y2 += cellSize) {
+        cellQueue.push(new Cell2(x2 + h2, y2 + h2, h2, polygon));
+      }
+    }
+    var bestCell = getCentroidCell2(polygon);
+    var bboxCell = new Cell2(minX + width / 2, minY + height / 2, 0, polygon);
+    if (bboxCell.d > bestCell.d) bestCell = bboxCell;
+    var numProbes = cellQueue.length;
+    while (cellQueue.length) {
+      var cell = cellQueue.pop();
+      if (cell.d > bestCell.d) {
+        bestCell = cell;
+        if (debug) console.log("found best %d after %d probes", Math.round(1e4 * cell.d) / 1e4, numProbes);
+      }
+      if (cell.max - bestCell.d <= precision) continue;
+      h2 = cell.h / 2;
+      cellQueue.push(new Cell2(cell.x - h2, cell.y - h2, h2, polygon));
+      cellQueue.push(new Cell2(cell.x + h2, cell.y - h2, h2, polygon));
+      cellQueue.push(new Cell2(cell.x - h2, cell.y + h2, h2, polygon));
+      cellQueue.push(new Cell2(cell.x + h2, cell.y + h2, h2, polygon));
+      numProbes += 4;
+    }
+    if (debug) {
+      console.log("num probes: " + numProbes);
+      console.log("best distance: " + bestCell.d);
+    }
+    var poleOfInaccessibility = [bestCell.x, bestCell.y];
+    poleOfInaccessibility.distance = bestCell.d;
+    return poleOfInaccessibility;
+  }
+  function compareMax2(a2, b2) {
+    return b2.max - a2.max;
+  }
+  function Cell2(x2, y2, h2, polygon) {
+    this.x = x2;
+    this.y = y2;
+    this.h = h2;
+    this.d = pointToPolygonDist2(x2, y2, polygon);
+    this.max = this.d + this.h * Math.SQRT2;
+  }
+  function pointToPolygonDist2(x2, y2, polygon) {
+    var inside = false;
+    var minDistSq = Infinity;
+    for (var k3 = 0; k3 < polygon.length; k3++) {
+      var ring = polygon[k3];
+      for (var i2 = 0, len2 = ring.length, j2 = len2 - 1; i2 < len2; j2 = i2++) {
+        var a2 = ring[i2];
+        var b2 = ring[j2];
+        if (a2[1] > y2 !== b2[1] > y2 && x2 < (b2[0] - a2[0]) * (y2 - a2[1]) / (b2[1] - a2[1]) + a2[0]) inside = !inside;
+        minDistSq = Math.min(minDistSq, getSegDistSq2(x2, y2, a2, b2));
+      }
+    }
+    return minDistSq === 0 ? 0 : (inside ? 1 : -1) * Math.sqrt(minDistSq);
+  }
+  function getCentroidCell2(polygon) {
+    var area2 = 0;
+    var x2 = 0;
+    var y2 = 0;
+    var points = polygon[0];
+    for (var i2 = 0, len2 = points.length, j2 = len2 - 1; i2 < len2; j2 = i2++) {
+      var a2 = points[i2];
+      var b2 = points[j2];
+      var f3 = a2[0] * b2[1] - b2[0] * a2[1];
+      x2 += (a2[0] + b2[0]) * f3;
+      y2 += (a2[1] + b2[1]) * f3;
+      area2 += f3 * 3;
+    }
+    if (area2 === 0) return new Cell2(points[0][0], points[0][1], 0, polygon);
+    return new Cell2(x2 / area2, y2 / area2, 0, polygon);
+  }
+  function getSegDistSq2(px, py, a2, b2) {
+    var x2 = a2[0];
+    var y2 = a2[1];
+    var dx = b2[0] - x2;
+    var dy = b2[1] - y2;
+    if (dx !== 0 || dy !== 0) {
+      var t2 = ((px - x2) * dx + (py - y2) * dy) / (dx * dx + dy * dy);
+      if (t2 > 1) {
+        x2 = b2[0];
+        y2 = b2[1];
+      } else if (t2 > 0) {
+        x2 += dx * t2;
+        y2 += dy * t2;
+      }
+    }
+    dx = px - x2;
+    dy = py - y2;
+    return dx * dx + dy * dy;
+  }
+  return polylabel$1$1.exports;
+}
+var polylabelExports = requirePolylabel();
+const polylabel$2 = /* @__PURE__ */ getDefaultExportFromCjs(polylabelExports);
 function vec2Add(v1, v2) {
   return [v1[0] + v2[0], v1[1] + v2[1]];
 }
@@ -6486,7 +6710,7 @@ function ccw(p1, p2, p3) {
   let d3 = vec2Cross(d1, d2);
   if (d3 > epsilon) {
     return 1;
-  } else if (d3 < -epsilon) {
+  } else if (d3 < -1e-7) {
     return -1;
   } else {
     return 0;
@@ -6573,6 +6797,31 @@ function getSignedArea(points) {
 function getPolygonArea(polygon) {
   return Math.abs(getSignedArea(polygon));
 }
+function getPolygonWithHolesArea(polygonBoundaries) {
+  if (polygonBoundaries.length === 0) {
+    return 0;
+  }
+  let area2 = getPolygonArea(polygonBoundaries[0]);
+  for (let i2 = 1; i2 < polygonBoundaries.length; i2++) {
+    area2 -= getPolygonArea(polygonBoundaries[i2]);
+  }
+  return area2;
+}
+function getPolygonCenter(polygon) {
+  const { min, max: max2 } = polygonBounds([polygon]);
+  return [min[0] + (max2[0] - min[0]) / 2, min[1] + (max2[1] - min[1]) / 2];
+}
+function getPolygonLabelPoint(polygonWithHoles) {
+  let labelPoint;
+  const area2 = getPolygonWithHolesArea(polygonWithHoles);
+  if (area2 < 0.1) {
+    labelPoint = getPolygonCenter(polygonWithHoles[0]);
+  } else {
+    const point = polylabel$2(polygonWithHoles, 0.1);
+    labelPoint = [point[0], point[1]];
+  }
+  return labelPoint;
+}
 function getPolygonPerimeter(points, isClosed = true) {
   let perimeter = 0;
   let pointLength = isClosed ? points.length : points.length - 1;
@@ -8174,6 +8423,13 @@ function getCustomAttributeInputType(schema) {
     }
   }
 }
+function getCustomAttributeResourceTypeCompoundId(customAttributeDefinitionJson) {
+  const {
+    id,
+    attributes: { resourceType }
+  } = customAttributeDefinitionJson;
+  return id.endsWith(`:${resourceType}`) ? id : `${id}:${resourceType}`;
+}
 function getCustomAttributeSchemaFromValueType(attributesJson) {
   if (attributesJson.schema) {
     return JSON.parse(JSON.stringify(attributesJson.schema));
@@ -8185,6 +8441,41 @@ function getCustomAttributeSchemaFromValueType(attributesJson) {
     return { type: "boolean" };
   }
 }
+const layoutToCustomAttributeResourceTypeMap = {
+  "spatialStructure:layout": "layout",
+  "layout:space": "space",
+  "product:static": "product",
+  "spatialStructure:building": "building",
+  "spatialStructure:floor": "floor",
+  "element:asset": "element",
+  "element:beam": "element",
+  "element:casework": "element",
+  "element:column": "element",
+  "element:door": "element",
+  "element:kitchen": "element",
+  "element:railing": "element",
+  "element:ramp": "element",
+  "element:roof": "element",
+  "element:slab": "element",
+  "element:stairs": "element",
+  "element:stairFlight": "element",
+  "element:window": "element",
+  "element:generic": "element",
+  "element:floor": "element",
+  "element:ceiling": "element",
+  "element:boundaryWall": "element",
+  "element:curtainWall": "element",
+  "element:opening": "element",
+  "element:spaceDivider": "element",
+  "element:wall": "element"
+};
+const getCustomAttributeDefinitionIdForNodeType = (customAttributeNodeKey, nodeType) => {
+  const customAttributeResourceType = layoutToCustomAttributeResourceTypeMap[nodeType];
+  if (!customAttributeResourceType) {
+    logger$1.error(`Missing custom attribute resource type for node type: "${nodeType}"`);
+  }
+  return `${customAttributeNodeKey}:${customAttributeResourceType}`;
+};
 function migrateCustomAttributeValue(value, schema) {
   if (schema.type === "boolean" && typeof value === "string") {
     if (value.toLowerCase() === "true") return true;
@@ -8256,17 +8547,18 @@ class SpaceGraphNodeWithCustomAttributesBase extends SpaceGraphNodeBase {
     }
     if (customAttributes && customAttributesById) {
       for (const customAttribute in customAttributes) {
-        const definition = customAttributesById[customAttribute];
-        if (!definition) {
-          error = `Missing custom attribute definition: "${customAttribute}""`;
-          continue;
-        }
         let value = customAttributes[customAttribute];
         if (value === null) {
           delete this.customAttributes[customAttribute];
           attributesChanged = true;
           continue;
         }
+        const attributeId = getCustomAttributeDefinitionIdForNodeType(customAttribute, this.type);
+        const definition = customAttributesById[attributeId];
+        if (!definition) {
+          error = `Missing custom attribute definition for node key: "${customAttribute}", node type: "${this.type}" and definition id: ${attributeId}`;
+          continue;
+        }
         if (!validateCustomAttributeValue(value, definition.attributes.schema)) {
           let migratedValue = migrateCustomAttributeValue(value, definition.attributes.schema);
           if (migratedValue === null) {
@@ -10335,7 +10627,9 @@ function getSpaceFromBoundaries(layout, boundaries, exactMatch) {
 }
 function arePolygonsTheSame(originalSpace, spaces) {
   const insertPolygons = spaces.map((space) => [space.boundaries[0].geometryProfile]);
-  const { polygons: unionPolygons } = polygonWithHolesUnion(insertPolygons);
+  const offsetDistance = 0.01;
+  const { polygons: inflatedPolygons } = polygonWithHolesOffset(insertPolygons, offsetDistance);
+  const { polygons: unionPolygons } = polygonWithHolesOffset(inflatedPolygons, -0.01);
   if (unionPolygons.length === 0) {
     logger$1.warn(`No union polygon, cannot match space ${originalSpace.id}.`);
     return false;
@@ -10345,10 +10639,10 @@ function arePolygonsTheSame(originalSpace, spaces) {
   }
   const outerUnionPolygon = unionPolygons[0][0];
   const removePolygon = originalSpace.boundaries[0].geometryProfile;
-  const diff1 = polygonDifference([removePolygon], [outerUnionPolygon]);
-  const diff2 = polygonDifference([outerUnionPolygon], [removePolygon]);
-  const area1 = diff1.length ? polygonArea(diff1[0]) : 0;
-  const area2 = diff2.length ? polygonArea(diff2[0]) : 0;
+  const diff1 = polygonWithHolesDifference([[removePolygon]], [[outerUnionPolygon]]).polygons;
+  const diff2 = polygonWithHolesDifference([[outerUnionPolygon]], [[removePolygon]]).polygons;
+  const area1 = diff1.length ? polygonWithHolesArea(diff1[0]) : 0;
+  const area2 = diff2.length ? polygonWithHolesArea(diff2[0]) : 0;
   const eps = 0.01;
   return area1 < eps && area2 < eps;
 }
@@ -14137,7 +14431,7 @@ function getCustomAttributesJson(customAttributes) {
   }
   return customAttributesJson;
 }
-const version = "0.20.6";
+const version = "0.21.2";
 const schemaVersion = version;
 class SpaceGraph {
   constructor(sourceSchemaVersion) {
@@ -15055,10 +15349,8 @@ function getFloorFromFloorJson(spaceGraph, floorJson) {
   return floor;
 }
 function getCustomAttributeFromCustomAttributeJson(customAttributeDefinitionJson) {
-  const customAttribute = new SpaceGraphCustomAttribute(
-    customAttributeDefinitionJson.id,
-    customAttributeDefinitionJson.attributes
-  );
+  const customAttributeId = getCustomAttributeResourceTypeCompoundId(customAttributeDefinitionJson);
+  const customAttribute = new SpaceGraphCustomAttribute(customAttributeId, customAttributeDefinitionJson.attributes);
   loadJsonNameAndCustomId(customAttribute, customAttributeDefinitionJson);
   return customAttribute;
 }
@@ -15138,7 +15430,7 @@ function getSpaceGraphFromSpaceGraphJson(spaceGraphJson) {
   loadSpaceGraph(spaceGraph, spaceGraphJson);
   return spaceGraph;
 }
-function log$2(...args) {
+function log$4(...args) {
 }
 function computeGraphEdgePoints(graph) {
   const epsilon = 1e-7;
@@ -15286,10 +15578,10 @@ function computeGraphEdgePolygonSegments(graph, edges) {
     computed.points = cleanPoints;
     computed.selfIntersecting = polygonSelfIntersecting(computed.points);
     computed.valid = computed.points.length >= 3 && !computed.skipped && !computed.selfIntersecting;
-    log$2(`  ${edge.id}`);
-    log$2("    valid", computed.valid);
-    log$2("    skipped", computed.skipped);
-    log$2("    self-intersecting", computed.selfIntersecting);
+    log$4(`  ${edge.id}`);
+    log$4("    valid", computed.valid);
+    log$4("    skipped", computed.skipped);
+    log$4("    self-intersecting", computed.selfIntersecting);
   }
 }
 const defaultVertexJoinStyle = "miter";
@@ -15415,7 +15707,7 @@ function sortVertexEdges(graph) {
 }
 const correctiveActionOuter = "intersectCap";
 const correctiveActionInner = "intersectCap";
-function log$1(...args) {
+function log$3(...args) {
 }
 function valueToFixed(value) {
   let result = value.toFixed(3);
@@ -15436,7 +15728,7 @@ function showPoints(points) {
   if (points.length > 0) {
     for (let i2 = 0; i2 < points.length; i2++) {
       let point = points[i2];
-      log$1(`        ${i2}: [${point[0]}, ${point[1]}]`);
+      log$3(`        ${i2}: [${point[0]}, ${point[1]}]`);
     }
   }
 }
@@ -15508,7 +15800,7 @@ function performCorrectiveAction(fragment2, nextFragment, v2, p1, p2, p3, q1, q2
   }
 }
 function resolveOuter(fragment2, nextFragment, v2, p1, p2, p3, hasGeometry1, q1, q2, q3, hasGeometry2, iteration) {
-  log$1(`  ${iteration}: ${fragment2.edge.id} -> ${nextFragment.edge.id} (outer)`);
+  log$3(`  ${iteration}: ${fragment2.edge.id} -> ${nextFragment.edge.id} (outer)`);
   let ll = getLineIntersection(p1, p2, q1, q2);
   if (ll.tag !== 2) {
     logger$1.warn("Edge side lines do not intersect, ignoring result.", ll);
@@ -15573,11 +15865,11 @@ function resolveOuter(fragment2, nextFragment, v2, p1, p2, p3, hasGeometry1, q1,
       ignoreIntersection(fragment2, nextFragment, v2, p2, q2);
     }
   }
-  log$1(`    s = ${valueToFixed(s2)} [${sMin.toFixed(3)}] ${correctiveActionTextS}`);
-  log$1(`    t = ${valueToFixed(t2)} [${tMin.toFixed(3)}] ${correctiveActionTextT}`);
+  log$3(`    s = ${valueToFixed(s2)} [${sMin.toFixed(3)}] ${correctiveActionTextS}`);
+  log$3(`    t = ${valueToFixed(t2)} [${tMin.toFixed(3)}] ${correctiveActionTextT}`);
 }
 function resolveInner(fragment2, nextFragment, v2, p1, p2, p3, hasGeometry1, q1, q2, q3, hasGeometry2, iteration) {
-  log$1(`  ${iteration}: ${fragment2.edge.id} -> ${nextFragment.edge.id} (inner)`);
+  log$3(`  ${iteration}: ${fragment2.edge.id} -> ${nextFragment.edge.id} (inner)`);
   let ll = getLineIntersection(p1, p2, q1, q2);
   if (ll.tag !== 2) {
     logger$1.warn("Edge side lines do not intersect, ignoring result.", ll);
@@ -15617,8 +15909,8 @@ function resolveInner(fragment2, nextFragment, v2, p1, p2, p3, hasGeometry1, q1,
   } else {
     ignoreIntersection(fragment2, nextFragment, v2, p2, q2);
   }
-  log$1(`    s = ${valueToFixed(s2)} [${sMin.toFixed(3)}] ${correctiveActionTextS}`);
-  log$1(`    t = ${valueToFixed(t2)} [${tMin.toFixed(3)}] ${correctiveActionTextT}`);
+  log$3(`    s = ${valueToFixed(s2)} [${sMin.toFixed(3)}] ${correctiveActionTextS}`);
+  log$3(`    t = ${valueToFixed(t2)} [${tMin.toFixed(3)}] ${correctiveActionTextT}`);
 }
 function resolveSingleEdge(vertexIndex, vertexEdges) {
   let edge = vertexEdges[0];
@@ -15744,7 +16036,7 @@ function computeGraphEdgeIntersections(graph, edges) {
         vertexEdges.push(edge);
       }
     }
-    log$1(`Vertex ${i2}, edge count ${vertexEdges.length}`);
+    log$3(`Vertex ${i2}, edge count ${vertexEdges.length}`);
     if (vertexEdges.length === 1) {
       resolveSingleEdge(i2, vertexEdges);
     } else {
@@ -16001,8 +16293,8 @@ var lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256);
 for (var i$2 = 0; i$2 < chars.length; i$2++) {
   lookup[chars.charCodeAt(i$2)] = i$2;
 }
-var polylabel$2 = { exports: {} };
-class TinyQueue {
+var polylabel$1 = { exports: {} };
+class TinyQueue2 {
   constructor(data = [], compare = defaultCompare) {
     this.data = data;
     this.length = this.data.length;
@@ -16066,13 +16358,13 @@ function defaultCompare(a2, b2) {
 }
 const tinyqueue = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  default: TinyQueue
+  default: TinyQueue2
 }, Symbol.toStringTag, { value: "Module" }));
-const require$$0$1 = /* @__PURE__ */ getAugmentedNamespace(tinyqueue);
+const require$$0$1 = /* @__PURE__ */ getAugmentedNamespace$1(tinyqueue);
 var Queue = require$$0$1;
 if (Queue.default) Queue = Queue.default;
-polylabel$2.exports = polylabel;
-polylabel$2.exports.default = polylabel;
+polylabel$1.exports = polylabel;
+polylabel$1.exports.default = polylabel;
 function polylabel(polygon, precision, debug) {
   precision = precision || 1;
   var minX, minY, maxX, maxY;
@@ -16183,8 +16475,6 @@ function getSegDistSq(px, py, a2, b2) {
   dy = py - y2;
   return dx * dx + dy * dy;
 }
-var polylabelExports = polylabel$2.exports;
-const polylabel$1 = /* @__PURE__ */ getDefaultExportFromCjs(polylabelExports);
 var sphericalmercator = { exports: {} };
 (function(module, exports) {
   var SphericalMercator = function() {
@@ -16326,7 +16616,7 @@ var sphericalmercator = { exports: {} };
   }
 })(sphericalmercator);
 var sphericalmercatorExports = sphericalmercator.exports;
-const pt = /* @__PURE__ */ getDefaultExportFromCjs(sphericalmercatorExports);
+const pt = /* @__PURE__ */ getDefaultExportFromCjs$1(sphericalmercatorExports);
 const te = {
   work: {
     name: "Work",
@@ -16913,11 +17203,11 @@ function Te(e2, t2 = create$4(), i2 = /* @__PURE__ */ new Map(), n2 = true) {
     }
   return r2;
 }
-function Vn(e2, t2, i2) {
+function Hn(e2, t2, i2) {
   let n2 = fromValues(...e2), r2 = fromValues(...t2), l2 = fromValues(...i2), o2 = create$3(), s2 = create$3(), a2 = create$3();
   return subtract(o2, n2, l2), subtract(s2, r2, l2), cross(a2, o2, s2), normalize$2(a2, a2), [...a2];
 }
-function dt(e2) {
+function mt(e2) {
   let { indices: t2, vertices: i2 } = e2, n2 = [], r2 = [], l2 = [], o2 = getBoundingBox(i2);
   for (let c2 = 0; c2 < i2.length; c2 += 3) {
     let u2 = i2[c2], m2 = i2[c2 + 1], E3 = i2[c2 + 2];
@@ -16925,7 +17215,7 @@ function dt(e2) {
   }
   for (let c2 = 0; c2 < t2.length; c2 += 3) {
     let u2 = t2[c2], m2 = t2[c2 + 1], E3 = t2[c2 + 2];
-    Vn(n2[u2], n2[m2], n2[E3])[1] < 0.01 || l2.push([r2[u2], r2[m2], r2[E3]]);
+    Hn(n2[u2], n2[m2], n2[E3])[1] < 0.01 || l2.push([r2[u2], r2[m2], r2[E3]]);
   }
   let s2 = [], a2 = [[]];
   if (!l2.length)
@@ -16936,11 +17226,11 @@ function dt(e2) {
     isCounterClockwise(c2) ? a2[0].push(c2) : s2.push(c2);
   return { outlines: s2, holes: a2, boundingBox: o2 };
 }
-function or(e2, t2 = {}) {
+function rr(e2, t2 = {}) {
   let i2 = t2.applyElementMatrix ? getElementMatrix(e2, t2.parentMatrix) : void 0, n2 = Te(e2, i2, t2.resources), r2 = [];
   for (let l2 of n2)
     for (let o2 of l2.meshes)
-      r2.push(dt(o2));
+      r2.push(mt(o2));
   return r2;
 }
 const REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
@@ -18193,7 +18483,7 @@ function getElementAnnotations(element) {
   return shapes;
 }
 function getShapesFromMesh(element) {
-  const meshContours = or(element).sort((a2, b2) => {
+  const meshContours = rr(element).sort((a2, b2) => {
     if (a2.boundingBox.max[1] < b2.boundingBox.max[1]) return -1;
     else return 1;
   });
@@ -19166,7 +19456,7 @@ var eventemitter3 = { exports: {} };
   }
 })(eventemitter3);
 var eventemitter3Exports = eventemitter3.exports;
-const EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+const EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs$1(eventemitter3Exports);
 var punycode$1 = { exports: {} };
 /*! https://mths.be/punycode v1.4.1 by @mathias */
 punycode$1.exports;
@@ -20043,7 +20333,7 @@ const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Ob
   __proto__: null,
   default: __viteBrowserExternal
 }, Symbol.toStringTag, { value: "Module" }));
-const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace$1(__viteBrowserExternal$1);
 var hasMap = typeof Map === "function" && Map.prototype;
 var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
 var mapSize$1 = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
@@ -33059,12 +33349,12 @@ class BezierUtils {
     const n2 = curves._segmentsCount(
       BezierUtils.curveLength(fromX, fromY, cpX, cpY, cpX2, cpY2, toX, toY)
     );
-    let dt2 = 0, dt22 = 0, dt3 = 0, t2 = 0, t3 = 0;
+    let dt = 0, dt2 = 0, dt3 = 0, t2 = 0, t3 = 0;
     points.push(fromX, fromY);
     for (let i2 = 1, j2 = 0; i2 <= n2; ++i2)
-      j2 = i2 / n2, dt2 = 1 - j2, dt22 = dt2 * dt2, dt3 = dt22 * dt2, t2 = j2 * j2, t3 = t2 * j2, points.push(
-        dt3 * fromX + 3 * dt22 * j2 * cpX + 3 * dt2 * t2 * cpX2 + t3 * toX,
-        dt3 * fromY + 3 * dt22 * j2 * cpY + 3 * dt2 * t2 * cpY2 + t3 * toY
+      j2 = i2 / n2, dt = 1 - j2, dt2 = dt * dt, dt3 = dt2 * dt, t2 = j2 * j2, t3 = t2 * j2, points.push(
+        dt3 * fromX + 3 * dt2 * j2 * cpX + 3 * dt * t2 * cpX2 + t3 * toX,
+        dt3 * fromY + 3 * dt2 * j2 * cpY + 3 * dt * t2 * cpY2 + t3 * toY
       );
   }
 }
@@ -36434,7 +36724,7 @@ var penner = { exports: {} };
   }).call(commonjsGlobal);
 })(penner);
 var pennerExports = penner.exports;
-const Penner = /* @__PURE__ */ getDefaultExportFromCjs(pennerExports);
+const Penner = /* @__PURE__ */ getDefaultExportFromCjs$1(pennerExports);
 Container.prototype._renderCanvas = function(_renderer) {
 };
 Container.prototype.renderCanvas = function(renderer) {
@@ -42778,7 +43068,7 @@ function drawRoomStamp(space, ctx, zoom, settings2) {
   if (profiles.length === 0) {
     return;
   }
-  let textPosition = polylabel$1(profiles);
+  let textPosition = getPolygonLabelPoint(profiles);
   let content = getRoomStampContent(space, settings2);
   let contentStr = content.join("\n");
   const txtGfx = new Text(contentStr, style);
@@ -43891,7 +44181,7 @@ class PolygonHelper extends Helper {
       const polygonWithLimitedPrecision = polygon.map((points) => {
         return points.map((number) => Number(number.toFixed(10)));
       }).slice(0, this.isInAreaMode ? void 0 : 2);
-      const center = this.isInAreaMode ? polylabel$1([polygonWithLimitedPrecision]) : [
+      const center = this.isInAreaMode ? getPolygonLabelPoint([polygonWithLimitedPrecision]) : [
         polygonWithLimitedPrecision[0][0] + (polygonWithLimitedPrecision[1][0] - polygonWithLimitedPrecision[0][0]) / 2,
         polygonWithLimitedPrecision[0][1] + (polygonWithLimitedPrecision[1][1] - polygonWithLimitedPrecision[0][1]) / 2
       ];