@crystaldesign/planner-2d-core 26.11.0-beta.10

package/build/cjs/index.js

@@ -0,0 +1,3402 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@babel/runtime/helpers/createClass');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var serialize = require('w3c-xmlserializer');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
+var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var serialize__default = /*#__PURE__*/_interopDefaultLegacy(serialize);
+var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
+var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
+
+(function() {
+    const env = {"STAGE":"production"};
+    try {
+        if (process) {
+            process.env = Object.assign({}, process.env);
+            Object.assign(process.env, env);
+            return;
+        }
+    } catch (e) {} // avoid ReferenceError: process is not defined
+    globalThis.process = { env:env };
+})();
+
+/**
+ * SVG user units per centimeter in DIVA planner SVGs. Hand-synced copy of DivaUtils.UnitRecalc in
+ * @crystaldesign/diva-utils, not recomputed from 72/25.4 (which would differ); keep both values equal.
+ */
+var UNIT_RECALC = 2.834637306;
+
+/** 2D vector in planner coordinates. The math must stay identical to web-planner-logic's wcVectors — docking positions depend on it. */
+var Vector2 = /*#__PURE__*/function () {
+  function Vector2(x, y) {
+    _classCallCheck__default["default"](this, Vector2);
+    _defineProperty__default["default"](this, "x", void 0);
+    _defineProperty__default["default"](this, "y", void 0);
+    this.x = x;
+    this.y = y;
+  }
+  return _createClass__default["default"](Vector2, [{
+    key: "toString",
+    value: function toString() {
+      return 'x: ' + this.x + ', y: ' + this.y;
+    }
+  }], [{
+    key: "add",
+    value: function add(vec1, vec2) {
+      return new Vector2(vec1.x + vec2.x, vec1.y + vec2.y);
+    }
+
+    /** Direction vector pointing from fromVec to toVec — note the reversed argument order. */
+  }, {
+    key: "getDirection",
+    value: function getDirection(toVec, fromVec) {
+      return new Vector2(toVec.x - fromVec.x, toVec.y - fromVec.y);
+    }
+  }, {
+    key: "getDistance",
+    value: function getDistance(vec1, vec2) {
+      return Math.sqrt(Math.pow(vec2.x - vec1.x, 2) + Math.pow(vec2.y - vec1.y, 2));
+    }
+  }, {
+    key: "getLength",
+    value: function getLength(vec) {
+      return Math.sqrt(Math.pow(vec.x, 2) + Math.pow(vec.y, 2));
+    }
+  }, {
+    key: "divNum",
+    value: function divNum(vec1, num) {
+      return new Vector2(vec1.x / num, vec1.y / num);
+    }
+  }, {
+    key: "mulNum",
+    value: function mulNum(vec1, num) {
+      return new Vector2(vec1.x * num, vec1.y * num);
+    }
+
+    /** Normalized dot product (cosine of the enclosed angle). */
+  }, {
+    key: "dotProduct",
+    value: function dotProduct(vec1, vec2) {
+      var magVec1 = Math.sqrt(vec1.x * vec1.x + vec1.y * vec1.y);
+      var magVec2 = Math.sqrt(vec2.x * vec2.x + vec2.y * vec2.y);
+      return (vec1.x * vec2.x + vec1.y * vec2.y) / (magVec1 * magVec2);
+    }
+
+    /** Rotates a position around the coordinate-system origin, angle in degrees. */
+  }, {
+    key: "rotateOrigin",
+    value: function rotateOrigin(vec, angleDeg) {
+      var angleRad = angleDeg * (Math.PI / 180);
+      var result = new Vector2(0, 0);
+      result.x = Math.cos(angleRad) * vec.x - Math.sin(angleRad) * vec.y;
+      result.y = Math.sin(angleRad) * vec.x + Math.cos(angleRad) * vec.y;
+      return result;
+    }
+
+    /** Enclosed angle between the two vectors in radians. */
+  }, {
+    key: "angleRad",
+    value: function angleRad(vec1, vec2) {
+      return Math.acos(this.dotProduct(vec1, vec2));
+    }
+
+    /** Enclosed angle between the two vectors in degrees. */
+  }, {
+    key: "angleDeg",
+    value: function angleDeg(vec1, vec2) {
+      return this.angleRad(vec1, vec2) * 180 / Math.PI;
+    }
+  }, {
+    key: "normalize",
+    value: function normalize(vec1) {
+      var distance = Math.sqrt(Math.pow(vec1.x, 2) + Math.pow(vec1.y, 2));
+      return new Vector2(vec1.x / distance, vec1.y / distance);
+    }
+  }]);
+}();
+
+/** 3D vector in planner world coordinates (x/z = ground plane, y = height). */
+var Vector3 = /*#__PURE__*/function () {
+  function Vector3(x, y, z) {
+    _classCallCheck__default["default"](this, Vector3);
+    _defineProperty__default["default"](this, "x", void 0);
+    _defineProperty__default["default"](this, "y", void 0);
+    _defineProperty__default["default"](this, "z", void 0);
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  return _createClass__default["default"](Vector3, [{
+    key: "toString",
+    value: function toString() {
+      return 'Vector3 x: ' + this.x + ', y: ' + this.y + ', z: ' + this.z;
+    }
+  }], [{
+    key: "add",
+    value: function add(vec1, vec2) {
+      return new Vector3(vec1.x + vec2.x, vec1.y + vec2.y, vec1.z + vec2.z);
+    }
+  }, {
+    key: "divNum",
+    value: function divNum(vec1, num) {
+      return new Vector3(vec1.x / num, vec1.y / num, vec1.z / num);
+    }
+  }, {
+    key: "mulNum",
+    value: function mulNum(vec1, num) {
+      return new Vector3(vec1.x * num, vec1.y * num, vec1.z * num);
+    }
+  }]);
+}();
+
+/** Logging surface this package emits to; matches the shape of loggers created by DivaUtils.initLog. */
+
+var noopLogger = {
+  trace: function trace() {
+    return undefined;
+  },
+  debug: function debug() {
+    return undefined;
+  },
+  info: function info() {
+    return undefined;
+  },
+  warn: function warn() {
+    return undefined;
+  },
+  error: function error() {
+    return undefined;
+  }
+};
+var activeLogger = noopLogger;
+
+/** Injects the logger used by this package. Defaults to a no-op, so the package has no logging dependency. */
+function setPlanner2DLogger(logger) {
+  activeLogger = logger;
+}
+function getPlanner2DLogger() {
+  return activeLogger;
+}
+
+/** Minimal DOM services this package needs — satisfied by browser globals and by a jsdom window. */
+
+var configuredDom;
+
+/** Provides the DOM implementation used for XML parsing. Optional in Node: without a call, jsdom is loaded lazily as fallback. */
+function configureDom(services) {
+  configuredDom = services;
+}
+
+/** Lazily loads a jsdom window in Node. The indirect require keeps browser bundlers from following/bundling jsdom. */
+function tryLoadJsdomServices() {
+  if (typeof window !== 'undefined') return undefined;
+  try {
+    var nodeRequire = eval('require');
+    var _nodeRequire = nodeRequire('jsdom'),
+      JSDOM = _nodeRequire.JSDOM;
+    var jsdomWindow = new JSDOM('').window;
+    return {
+      DOMParser: jsdomWindow.DOMParser,
+      XMLSerializer: jsdomWindow.XMLSerializer
+    };
+  } catch (_unused) {
+    return undefined;
+  }
+}
+function resolveDomParser() {
+  var _configuredDom;
+  if ((_configuredDom = configuredDom) !== null && _configuredDom !== void 0 && _configuredDom.DOMParser) return configuredDom.DOMParser;
+  if (typeof DOMParser !== 'undefined') return DOMParser;
+  var jsdomServices = tryLoadJsdomServices();
+  if (jsdomServices) {
+    configuredDom = jsdomServices;
+    return jsdomServices.DOMParser;
+  }
+  throw new Error("planner-2d-core: no DOMParser available — in Node install jsdom or call configureDom(new JSDOM('').window) once at startup");
+}
+function parseXml(content) {
+  var mimeType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'application/xml';
+  var Parser = resolveDomParser();
+  return new Parser().parseFromString(content, mimeType);
+}
+function serializeXml(document) {
+  var _configuredDom$XMLSer, _configuredDom2;
+  var Serializer = (_configuredDom$XMLSer = (_configuredDom2 = configuredDom) === null || _configuredDom2 === void 0 ? void 0 : _configuredDom2.XMLSerializer) !== null && _configuredDom$XMLSer !== void 0 ? _configuredDom$XMLSer : typeof XMLSerializer !== 'undefined' ? XMLSerializer : undefined;
+  if (Serializer) return new Serializer().serializeToString(document);
+  return serialize__default["default"](document);
+}
+
+/** Every connector type the planner knows. */
+var DOCKING_TYPES = ['AVR', 'AVL', 'AVC', 'AVO', 'AVU', 'AVS', 'AVN'];
+/** Narrows an untrusted string to a DockingType. */
+function isDockingType(value) {
+  return typeof value === 'string' && DOCKING_TYPES.includes(value);
+}
+
+/** A raw AV docking line as drawn in an article SVG (SVG user units, not yet minBorder-corrected). */
+
+/** Minimum x/y over all non-AV geometry of an SVG — the offset docking-point coordinates are corrected by. */
+
+function _createForOfIteratorHelper$7(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$7(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$7(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$7(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$7(r, a) : void 0; } }
+function _arrayLikeToArray$7(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var COMMAND_PARAM_COUNT = {
+  M: 2,
+  L: 2,
+  H: 1,
+  V: 1,
+  C: 6,
+  S: 4,
+  Q: 4,
+  T: 2,
+  A: 7,
+  Z: 0
+};
+
+/** Parameter indices (within one A group) that are single-digit flags per SVG spec. */
+var ARC_FLAG_INDICES = [3, 4];
+var NUMBER_PATTERN = /^[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/;
+function isSeparator(ch) {
+  return ch === ' ' || ch === ',' || ch === '\t' || ch === '\n' || ch === '\r' || ch === '\f';
+}
+function isCommandLetter(ch) {
+  return ch.toUpperCase() in COMMAND_PARAM_COUNT;
+}
+
+/**
+ * Tokenizes an SVG path `d` attribute into absolute/relative commands with their numeric parameters, covering
+ * the full command set, implicit command repetition, scientific notation and unspaced arc flags.
+ * Throws on unknown commands and malformed numbers.
+ */
+function parsePathCommands(d) {
+  var commands = [];
+  var i = 0;
+  var pendingCommand = '';
+  var skipSeparators = function skipSeparators() {
+    while (i < d.length && isSeparator(d[i])) i++;
+  };
+  var readNumber = function readNumber(isFlag) {
+    skipSeparators();
+    if (isFlag) {
+      var ch = d[i];
+      if (ch !== '0' && ch !== '1') throw new Error("invalid arc flag '".concat(ch, "' at position ").concat(i, " in path data"));
+      i++;
+      return Number(ch);
+    }
+    var match = NUMBER_PATTERN.exec(d.substring(i));
+    if (!match) throw new Error("expected number at position ".concat(i, " in path data"));
+    i += match[0].length;
+    return Number(match[0]);
+  };
+  while (i < d.length) {
+    skipSeparators();
+    if (i >= d.length) break;
+    var ch = d[i];
+    if (isCommandLetter(ch)) {
+      pendingCommand = ch;
+      i++;
+      if (ch.toUpperCase() === 'Z') {
+        commands.push({
+          command: ch,
+          params: []
+        });
+        pendingCommand = '';
+      }
+      continue;
+    }
+    if (/[a-zA-Z]/.test(ch)) throw new Error("unsupported path command '".concat(ch, "' at position ").concat(i));
+    if (!pendingCommand) throw new Error("number without a preceding command at position ".concat(i, " in path data"));
+    var paramCount = COMMAND_PARAM_COUNT[pendingCommand.toUpperCase()];
+    var isArc = pendingCommand.toUpperCase() === 'A';
+    var params = [];
+    for (var p = 0; p < paramCount; p++) {
+      params.push(readNumber(isArc && ARC_FLAG_INDICES.includes(p)));
+    }
+    commands.push({
+      command: pendingCommand,
+      params: params
+    });
+
+    // Per spec, further coordinate groups after M/m continue as L/l; all other commands repeat themselves.
+    if (pendingCommand === 'M') pendingCommand = 'L';else if (pendingCommand === 'm') pendingCommand = 'l';
+  }
+  return commands;
+}
+function cubicAxisExtrema(p0, p1, p2, p3) {
+  // The derivative of a cubic Bezier is the quadratic a*t^2 + b*t + c.
+  var a = -p0 + 3 * p1 - 3 * p2 + p3;
+  var b = 2 * (p0 - 2 * p1 + p2);
+  var c = p1 - p0;
+  var roots = [];
+  if (Math.abs(a) < 1e-12) {
+    if (Math.abs(b) > 1e-12) roots.push(-c / b);
+  } else {
+    var discriminant = b * b - 4 * a * c;
+    if (discriminant >= 0) {
+      var sqrtD = Math.sqrt(discriminant);
+      roots.push((-b + sqrtD) / (2 * a), (-b - sqrtD) / (2 * a));
+    }
+  }
+  return roots.filter(function (t) {
+    return t > 0 && t < 1;
+  });
+}
+function cubicAxisValue(t, p0, p1, p2, p3) {
+  var mt = 1 - t;
+  return mt * mt * mt * p0 + 3 * mt * mt * t * p1 + 3 * mt * t * t * p2 + t * t * t * p3;
+}
+function quadraticAxisExtremum(p0, p1, p2) {
+  var denominator = p0 - 2 * p1 + p2;
+  if (Math.abs(denominator) < 1e-12) return undefined;
+  var t = (p0 - p1) / denominator;
+  return t > 0 && t < 1 ? t : undefined;
+}
+function quadraticAxisValue(t, p0, p1, p2) {
+  var mt = 1 - t;
+  return mt * mt * p0 + 2 * mt * t * p1 + t * t * p2;
+}
+var TWO_PI = Math.PI * 2;
+function normalizeAngle(angle) {
+  var result = angle % TWO_PI;
+  if (result < 0) result += TWO_PI;
+  return result;
+}
+
+/** Expands the bounds by the extrema of an elliptical arc (SVG endpoint parameterization, spec section F.6.5). */
+function expandArcBounds(from, rx, ry, rotationDeg, largeArc, sweep, to, expand) {
+  rx = Math.abs(rx);
+  ry = Math.abs(ry);
+  if (rx === 0 || ry === 0) return; // degenerate arc is a straight line - endpoints already expanded
+
+  var phi = rotationDeg * Math.PI / 180;
+  var cosPhi = Math.cos(phi);
+  var sinPhi = Math.sin(phi);
+  var dx2 = (from.x - to.x) / 2;
+  var dy2 = (from.y - to.y) / 2;
+  var x1p = cosPhi * dx2 + sinPhi * dy2;
+  var y1p = -sinPhi * dx2 + cosPhi * dy2;
+
+  // Scale up radii that are too small to span the endpoints (spec F.6.6).
+  var lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+  if (lambda > 1) {
+    var scale = Math.sqrt(lambda);
+    rx *= scale;
+    ry *= scale;
+  }
+  var rxSq = rx * rx;
+  var rySq = ry * ry;
+  var radicand = rxSq * rySq - rxSq * y1p * y1p - rySq * x1p * x1p;
+  if (radicand < 0) radicand = 0;
+  var coefficient = (largeArc !== sweep ? 1 : -1) * Math.sqrt(radicand / (rxSq * y1p * y1p + rySq * x1p * x1p));
+  var cxp = coefficient * (rx * y1p) / ry;
+  var cyp = coefficient * (-ry * x1p) / rx;
+  var cx = cosPhi * cxp - sinPhi * cyp + (from.x + to.x) / 2;
+  var cy = sinPhi * cxp + cosPhi * cyp + (from.y + to.y) / 2;
+  var angleOf = function angleOf(vx, vy) {
+    return Math.atan2(vy, vx);
+  };
+  var theta1 = angleOf((x1p - cxp) / rx, (y1p - cyp) / ry);
+  var theta2 = angleOf((-x1p - cxp) / rx, (-y1p - cyp) / ry);
+  var deltaTheta = theta2 - theta1;
+  if (sweep === 0 && deltaTheta > 0) deltaTheta -= TWO_PI;else if (sweep === 1 && deltaTheta < 0) deltaTheta += TWO_PI;
+  var isOnArc = function isOnArc(theta) {
+    if (deltaTheta >= 0) return normalizeAngle(theta - theta1) <= deltaTheta;
+    return normalizeAngle(theta1 - theta) <= -deltaTheta;
+  };
+  var pointAt = function pointAt(theta) {
+    return {
+      x: cx + rx * Math.cos(theta) * cosPhi - ry * Math.sin(theta) * sinPhi,
+      y: cy + rx * Math.cos(theta) * sinPhi + ry * Math.sin(theta) * cosPhi
+    };
+  };
+
+  // Angles where dx/dtheta = 0 resp. dy/dtheta = 0 (extrema of the rotated ellipse).
+  var thetaXExtremum = Math.atan2(-ry * sinPhi, rx * cosPhi);
+  var thetaYExtremum = Math.atan2(ry * cosPhi, rx * sinPhi);
+  var candidates = [thetaXExtremum, thetaXExtremum + Math.PI, thetaYExtremum, thetaYExtremum + Math.PI];
+  for (var _i = 0, _candidates = candidates; _i < _candidates.length; _i++) {
+    var theta = _candidates[_i];
+    if (!isOnArc(theta)) continue;
+    var point = pointAt(theta);
+    expand(point.x, point.y);
+  }
+}
+
+/** Exact bounding box of an SVG path `d` attribute, honoring Bezier extrema and elliptical arcs. Undefined for empty path data. */
+function pathBoundingBox(d) {
+  var commands = parsePathCommands(d);
+  if (commands.length === 0) return undefined;
+  var minX = Number.POSITIVE_INFINITY;
+  var minY = Number.POSITIVE_INFINITY;
+  var maxX = Number.NEGATIVE_INFINITY;
+  var maxY = Number.NEGATIVE_INFINITY;
+  var expand = function expand(x, y) {
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  };
+  var current = {
+    x: 0,
+    y: 0
+  };
+  var subpathStart = {
+    x: 0,
+    y: 0
+  };
+  var previousCubicControl;
+  var previousQuadraticControl;
+  var previousCommand = '';
+  var hasGeometry = false;
+  var _iterator = _createForOfIteratorHelper$7(commands),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var _step$value = _step.value,
+        command = _step$value.command,
+        params = _step$value.params;
+      var upper = command.toUpperCase();
+      var isRelative = command !== upper;
+      var absolute = function absolute(index, axisBase) {
+        return isRelative ? axisBase + params[index] : params[index];
+      };
+      var nextCubicControl;
+      var nextQuadraticControl;
+      switch (upper) {
+        case 'M':
+          {
+            current = {
+              x: absolute(0, current.x),
+              y: absolute(1, current.y)
+            };
+            subpathStart = current;
+            expand(current.x, current.y);
+            hasGeometry = true;
+            break;
+          }
+        case 'L':
+          {
+            expand(current.x, current.y);
+            current = {
+              x: absolute(0, current.x),
+              y: absolute(1, current.y)
+            };
+            expand(current.x, current.y);
+            hasGeometry = true;
+            break;
+          }
+        case 'H':
+          {
+            expand(current.x, current.y);
+            current = {
+              x: isRelative ? current.x + params[0] : params[0],
+              y: current.y
+            };
+            expand(current.x, current.y);
+            hasGeometry = true;
+            break;
+          }
+        case 'V':
+          {
+            expand(current.x, current.y);
+            current = {
+              x: current.x,
+              y: isRelative ? current.y + params[0] : params[0]
+            };
+            expand(current.x, current.y);
+            hasGeometry = true;
+            break;
+          }
+        case 'C':
+        case 'S':
+          {
+            var control1;
+            var control2;
+            var end;
+            if (upper === 'C') {
+              control1 = {
+                x: absolute(0, current.x),
+                y: absolute(1, current.y)
+              };
+              control2 = {
+                x: absolute(2, current.x),
+                y: absolute(3, current.y)
+              };
+              end = {
+                x: absolute(4, current.x),
+                y: absolute(5, current.y)
+              };
+            } else {
+              var reflects = previousCommand === 'C' || previousCommand === 'S';
+              control1 = reflects && previousCubicControl ? {
+                x: 2 * current.x - previousCubicControl.x,
+                y: 2 * current.y - previousCubicControl.y
+              } : {
+                x: current.x,
+                y: current.y
+              };
+              control2 = {
+                x: absolute(0, current.x),
+                y: absolute(1, current.y)
+              };
+              end = {
+                x: absolute(2, current.x),
+                y: absolute(3, current.y)
+              };
+            }
+            expand(current.x, current.y);
+            expand(end.x, end.y);
+            var _iterator2 = _createForOfIteratorHelper$7(cubicAxisExtrema(current.x, control1.x, control2.x, end.x)),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var t = _step2.value;
+                expand(cubicAxisValue(t, current.x, control1.x, control2.x, end.x), cubicAxisValue(t, current.y, control1.y, control2.y, end.y));
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            var _iterator3 = _createForOfIteratorHelper$7(cubicAxisExtrema(current.y, control1.y, control2.y, end.y)),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _t = _step3.value;
+                expand(cubicAxisValue(_t, current.x, control1.x, control2.x, end.x), cubicAxisValue(_t, current.y, control1.y, control2.y, end.y));
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+            nextCubicControl = control2;
+            current = end;
+            hasGeometry = true;
+            break;
+          }
+        case 'Q':
+        case 'T':
+          {
+            var control;
+            var _end;
+            if (upper === 'Q') {
+              control = {
+                x: absolute(0, current.x),
+                y: absolute(1, current.y)
+              };
+              _end = {
+                x: absolute(2, current.x),
+                y: absolute(3, current.y)
+              };
+            } else {
+              var _reflects = previousCommand === 'Q' || previousCommand === 'T';
+              control = _reflects && previousQuadraticControl ? {
+                x: 2 * current.x - previousQuadraticControl.x,
+                y: 2 * current.y - previousQuadraticControl.y
+              } : {
+                x: current.x,
+                y: current.y
+              };
+              _end = {
+                x: absolute(0, current.x),
+                y: absolute(1, current.y)
+              };
+            }
+            expand(current.x, current.y);
+            expand(_end.x, _end.y);
+            var tx = quadraticAxisExtremum(current.x, control.x, _end.x);
+            if (tx !== undefined) expand(quadraticAxisValue(tx, current.x, control.x, _end.x), quadraticAxisValue(tx, current.y, control.y, _end.y));
+            var ty = quadraticAxisExtremum(current.y, control.y, _end.y);
+            if (ty !== undefined) expand(quadraticAxisValue(ty, current.x, control.x, _end.x), quadraticAxisValue(ty, current.y, control.y, _end.y));
+            nextQuadraticControl = control;
+            current = _end;
+            hasGeometry = true;
+            break;
+          }
+        case 'A':
+          {
+            var _end2 = {
+              x: absolute(5, current.x),
+              y: absolute(6, current.y)
+            };
+            expand(current.x, current.y);
+            expand(_end2.x, _end2.y);
+            expandArcBounds(current, params[0], params[1], params[2], params[3], params[4], _end2, expand);
+            current = _end2;
+            hasGeometry = true;
+            break;
+          }
+        case 'Z':
+          {
+            current = subpathStart;
+            break;
+          }
+      }
+      previousCommand = upper;
+      previousCubicControl = nextCubicControl;
+      previousQuadraticControl = nextQuadraticControl;
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (!hasGeometry) return undefined;
+  return {
+    minX: minX,
+    minY: minY,
+    maxX: maxX,
+    maxY: maxY
+  };
+}
+
+function _createForOfIteratorHelper$6(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$6(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$6(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$6(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$6(r, a) : void 0; } }
+function _arrayLikeToArray$6(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/** XPathResult.ORDERED_NODE_SNAPSHOT_TYPE — used numerically because XML documents do not always expose the constant. */
+var ORDERED_NODE_SNAPSHOT_TYPE = 7;
+
+/** All elements whose id starts with the given prefix, in document order. */
+function snapshotByIdPrefix(xmlDocument, idPrefix) {
+  var result = xmlDocument.evaluate("//*[starts-with(@id,'".concat(idPrefix, "')]"), xmlDocument, null, ORDERED_NODE_SNAPSHOT_TYPE, null);
+  var elements = [];
+  for (var i = 0; i < result.snapshotLength; i++) elements.push(result.snapshotItem(i));
+  return elements;
+}
+
+/**
+ * Extracts all AV docking lines of an article SVG, AVL sorted first (the planner relies on that order).
+ * Throws for AV elements that are not `<line>`.
+ */
+function getDockingPointLines(content) {
+  var dockingPointLines = [];
+  var xmlDocument = parseXml(content);
+  var _iterator = _createForOfIteratorHelper$6(snapshotByIdPrefix(xmlDocument, 'AV')),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _element$getAttribute, _element$getAttribute2;
+      var element = _step.value;
+      if (element.nodeName !== 'line') throw new Error('nodename type: ' + element.nodeName + ' not implemented');
+      dockingPointLines.push({
+        x1: Number(element.getAttribute('x1')),
+        y1: Number(element.getAttribute('y1')),
+        x2: Number(element.getAttribute('x2')),
+        y2: Number(element.getAttribute('y2')),
+        dockingName: (_element$getAttribute = element.getAttribute('id')) !== null && _element$getAttribute !== void 0 ? _element$getAttribute : '',
+        dockingType: ((_element$getAttribute2 = element.getAttribute('id')) !== null && _element$getAttribute2 !== void 0 ? _element$getAttribute2 : '').substring(0, 3)
+      });
+    }
+
+    // Deliberately non-transitive comparator: the order it produces is a planner contract.
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  dockingPointLines.sort(function (a, b) {
+    if (a.dockingType === 'AVL') return -1;
+    if (a.dockingType === 'AVR' && ['AVR', 'AVC', 'AVU', 'AVO', 'AVS', 'AVN'].includes(b.dockingType)) return -1;
+    return 0;
+  });
+  return dockingPointLines;
+}
+
+/**
+ * Returns the points of the single `<polygon>` whose id starts with idPrefix: undefined when zero or more
+ * than one id matches, empty array when the match is not a polygon.
+ */
+function getPolygonPoints(content, idPrefix) {
+  var points = [];
+  var xmlDocument = parseXml(content);
+  var matches = snapshotByIdPrefix(xmlDocument, idPrefix);
+  if (matches.length !== 1) return undefined;
+  var element = matches[0];
+  if (element.nodeName === 'polygon') {
+    var pointsAsString = element.getAttribute('points');
+    if (!pointsAsString) return undefined;
+    var _iterator2 = _createForOfIteratorHelper$6(pointsAsString.split(' ')),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var pair = _step2.value;
+        var xAndY = pair.split(',');
+        if (xAndY.length !== 2) continue;
+        points.push(new Vector2(Number(xAndY[0]), Number(xAndY[1])));
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  return points;
+}
+function getBoundingBoxOfPoints(points) {
+  var xValues = points.map(function (point) {
+    return point.x;
+  });
+  var yValues = points.map(function (point) {
+    return point.y;
+  });
+  var minX = Math.min.apply(Math, _toConsumableArray__default["default"](xValues));
+  var minY = Math.min.apply(Math, _toConsumableArray__default["default"](yValues));
+  return {
+    minX: minX,
+    minY: minY,
+    width: Math.max.apply(Math, _toConsumableArray__default["default"](xValues)) - minX,
+    height: Math.max.apply(Math, _toConsumableArray__default["default"](yValues)) - minY
+  };
+}
+function parsePointsAttribute(pointsAttribute) {
+  return pointsAttribute.split(/\s+/).reduce(function (accumulator, pair) {
+    var _pair$split = pair.split(','),
+      _pair$split2 = _slicedToArray__default["default"](_pair$split, 2),
+      x = _pair$split2[0],
+      y = _pair$split2[1];
+    if (x != null && y != null && x !== '') accumulator.push(new Vector2(Number(x), Number(y)));
+    return accumulator;
+  }, []);
+}
+function geometryOfFirstShape(content, idPrefix) {
+  var xmlDocument = parseXml(content);
+  var _iterator3 = _createForOfIteratorHelper$6(snapshotByIdPrefix(xmlDocument, idPrefix)),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var element = _step3.value;
+      warnOnTransform(element, "".concat(idPrefix, " geometry"));
+      if (element.nodeName === 'rect') {
+        var _element$getAttribute3, _element$getAttribute4, _element$getAttribute5, _element$getAttribute6;
+        return {
+          minX: parseFloat((_element$getAttribute3 = element.getAttribute('x')) !== null && _element$getAttribute3 !== void 0 ? _element$getAttribute3 : '0'),
+          minY: parseFloat((_element$getAttribute4 = element.getAttribute('y')) !== null && _element$getAttribute4 !== void 0 ? _element$getAttribute4 : '0'),
+          width: parseFloat((_element$getAttribute5 = element.getAttribute('width')) !== null && _element$getAttribute5 !== void 0 ? _element$getAttribute5 : '0'),
+          height: parseFloat((_element$getAttribute6 = element.getAttribute('height')) !== null && _element$getAttribute6 !== void 0 ? _element$getAttribute6 : '0')
+        };
+      }
+      if (element.nodeName === 'polygon') {
+        var pointsAttribute = element.getAttribute('points');
+        if (!pointsAttribute) continue;
+        var points = parsePointsAttribute(pointsAttribute);
+        if (points.length) return getBoundingBoxOfPoints(points);
+      }
+      if (element.nodeName === 'path') {
+        var bounds = safePathBounds(element);
+        if (bounds) return {
+          minX: bounds.minX,
+          minY: bounds.minY,
+          width: bounds.maxX - bounds.minX,
+          height: bounds.maxY - bounds.minY
+        };
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return undefined;
+}
+
+/**
+ * Returns the OLF geometry from SVG attributes (untransformed) — rect, polygon and path.
+ * A `<g id="OLF…">` wrapper yields undefined: only shape elements are measured, never a group's children.
+ * Widening that would change which articles get an OLF offset.
+ */
+function getOlfGeometry(content) {
+  return geometryOfFirstShape(content, 'OLF');
+}
+
+/** Returns the OLT geometry from SVG attributes (untransformed) — rect, polygon and path. A `<g id="OLT…">` wrapper yields undefined. */
+function getOltGeometry(content) {
+  var geometry = geometryOfFirstShape(content, 'OLT');
+  if (!geometry) return undefined;
+  return {
+    x: geometry.minX,
+    y: geometry.minY,
+    width: geometry.width,
+    height: geometry.height
+  };
+}
+
+/** Removes all VIF and OLF nodes so only the OLT view remains. */
+function removeOlf(content) {
+  var xmlDocument = parseXml(content);
+  for (var _i = 0, _arr = [].concat(_toConsumableArray__default["default"](snapshotByIdPrefix(xmlDocument, 'VIF')), _toConsumableArray__default["default"](snapshotByIdPrefix(xmlDocument, 'OLF'))); _i < _arr.length; _i++) {
+    var _element$parentElemen;
+    var element = _arr[_i];
+    (_element$parentElemen = element.parentElement) === null || _element$parentElemen === void 0 || _element$parentElemen.removeChild(element);
+  }
+  return serializeXml(xmlDocument);
+}
+
+/**
+ * Removes `<mask>` elements and every node carrying a mask attribute. Uses DOM traversal rather than XPath
+ * because jsdom's XPath engine does not support local-name() comparisons.
+ */
+function removeMask(content) {
+  if (content.toLowerCase().indexOf('<mask') < 0) return content;
+  var xmlDocument = parseXml(content, 'image/svg+xml');
+  var allElements = _toConsumableArray__default["default"](xmlDocument.getElementsByTagName('*'));
+  var _iterator4 = _createForOfIteratorHelper$6(allElements),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var element = _step4.value;
+      if (element.localName === 'mask' || element.hasAttribute('mask')) {
+        var _element$parentElemen2;
+        (_element$parentElemen2 = element.parentElement) === null || _element$parentElemen2 === void 0 || _element$parentElemen2.removeChild(element);
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return serializeXml(xmlDocument);
+}
+var NON_GEOMETRY_CONTAINERS = ['defs', 'mask', 'clipPath', 'symbol', 'style', 'title', 'desc', 'metadata'];
+
+/** Measures a path defensively: malformed decorative path data must not break article parsing. */
+function safePathBounds(element) {
+  var d = element.getAttribute('d');
+  if (!d) return undefined;
+  try {
+    return pathBoundingBox(d);
+  } catch (error) {
+    var _element$getAttribute7;
+    getPlanner2DLogger().warn("planner-2d-core: skipping unparsable path (id: ".concat((_element$getAttribute7 = element.getAttribute('id')) !== null && _element$getAttribute7 !== void 0 ? _element$getAttribute7 : '-', "): ").concat(error.message));
+    return undefined;
+  }
+}
+/**
+ * Warns when a measured element sits under a `transform`. Planner article SVGs are exported with baked-in
+ * coordinates, and this package reads attributes directly, so a transform would silently displace every
+ * measurement taken from it — the connector positions above all. fabric used to apply it, so this is the one
+ * place where "no transforms" changes from an assumption into something the caller hears about.
+ */
+function warnOnTransform(element, measurement) {
+  var node = element;
+  while (node) {
+    if (node.getAttribute('transform')) {
+      var _node$getAttribute;
+      getPlanner2DLogger().warn("planner-2d-core: ".concat(measurement, " ignores the transform on <").concat(node.nodeName, " id=\"").concat((_node$getAttribute = node.getAttribute('id')) !== null && _node$getAttribute !== void 0 ? _node$getAttribute : '-', "\">; ") + 'article SVGs are expected to use untransformed coordinates');
+      return;
+    }
+    node = node.parentElement;
+  }
+}
+function elementBounds(element) {
+  var attr = function attr(name) {
+    var _element$getAttribute8;
+    return parseFloat((_element$getAttribute8 = element.getAttribute(name)) !== null && _element$getAttribute8 !== void 0 ? _element$getAttribute8 : '0');
+  };
+  switch (element.nodeName) {
+    case 'rect':
+      {
+        var x = attr('x');
+        var y = attr('y');
+        return {
+          minX: x,
+          minY: y,
+          maxX: x + attr('width'),
+          maxY: y + attr('height')
+        };
+      }
+    case 'image':
+    case 'use':
+      {
+        // A <use>/<image> without width/height is a symbol reference and describes no geometry: counting it
+        // as a (0,0) box would drag the content bounds to the origin and shift every docking-point position.
+        var width = attr('width');
+        var height = attr('height');
+        if (!width && !height) return undefined;
+        var _x = attr('x');
+        var _y = attr('y');
+        return {
+          minX: _x,
+          minY: _y,
+          maxX: _x + width,
+          maxY: _y + height
+        };
+      }
+    case 'line':
+      return {
+        minX: Math.min(attr('x1'), attr('x2')),
+        minY: Math.min(attr('y1'), attr('y2')),
+        maxX: Math.max(attr('x1'), attr('x2')),
+        maxY: Math.max(attr('y1'), attr('y2'))
+      };
+    case 'polygon':
+    case 'polyline':
+      {
+        var _element$getAttribute9;
+        var points = parsePointsAttribute((_element$getAttribute9 = element.getAttribute('points')) !== null && _element$getAttribute9 !== void 0 ? _element$getAttribute9 : '');
+        if (!points.length) return undefined;
+        var bbox = getBoundingBoxOfPoints(points);
+        return {
+          minX: bbox.minX,
+          minY: bbox.minY,
+          maxX: bbox.minX + bbox.width,
+          maxY: bbox.minY + bbox.height
+        };
+      }
+    case 'circle':
+      return {
+        minX: attr('cx') - attr('r'),
+        minY: attr('cy') - attr('r'),
+        maxX: attr('cx') + attr('r'),
+        maxY: attr('cy') + attr('r')
+      };
+    case 'ellipse':
+      return {
+        minX: attr('cx') - attr('rx'),
+        minY: attr('cy') - attr('ry'),
+        maxX: attr('cx') + attr('rx'),
+        maxY: attr('cy') + attr('ry')
+      };
+    case 'path':
+      return safePathBounds(element);
+    default:
+      return undefined;
+  }
+}
+
+/** Reads a presentation attribute from the element, its `style` or the nearest ancestor that sets it. */
+function inheritedPresentation(element, name) {
+  for (var node = element; node; node = node.parentElement) {
+    var attribute = node.getAttribute(name);
+    if (attribute) return attribute;
+    var style = node.getAttribute('style');
+    var match = style ? new RegExp("(?:^|;)\\s*".concat(name, "\\s*:\\s*([^;]+)")).exec(style) : null;
+    if (match) return match[1].trim();
+  }
+  return undefined;
+}
+
+/**
+ * Half the stroke width, i.e. how far a shape's painted edge lies outside its geometry. fabric anchored every
+ * parsed object on that edge and applied a default width of 1 even to shapes declaring no stroke; minBorder feeds
+ * every docking-point position, so it must keep reporting the same edge or connectors drift by half a stroke.
+ */
+function strokeOverhang(element) {
+  var declared = inheritedPresentation(element, 'stroke-width');
+  var width = declared === undefined ? 1 : parseFloat(declared);
+  return Number.isFinite(width) ? width / 2 : 0.5;
+}
+function collectBounds(content, includeElement, options) {
+  var xmlDocument = parseXml(content);
+  var minX = Number.POSITIVE_INFINITY;
+  var minY = Number.POSITIVE_INFINITY;
+  var maxX = Number.NEGATIVE_INFINITY;
+  var maxY = Number.NEGATIVE_INFINITY;
+  var _visit = function visit(element) {
+    if (NON_GEOMETRY_CONTAINERS.includes(element.nodeName)) return;
+    if (includeElement(element)) {
+      if (options !== null && options !== void 0 && options.measurement) warnOnTransform(element, options.measurement);
+      var raw = elementBounds(element);
+      var overhang = raw && options !== null && options !== void 0 && options.includeStroke ? strokeOverhang(element) : 0;
+      var bounds = raw && overhang ? {
+        minX: raw.minX - overhang,
+        minY: raw.minY - overhang,
+        maxX: raw.maxX + overhang,
+        maxY: raw.maxY + overhang
+      } : raw;
+      if (bounds) {
+        if (bounds.minX < minX) minX = bounds.minX;
+        if (bounds.minY < minY) minY = bounds.minY;
+        if (bounds.maxX > maxX) maxX = bounds.maxX;
+        if (bounds.maxY > maxY) maxY = bounds.maxY;
+      }
+    }
+    for (var i = 0; i < element.children.length; i++) _visit(element.children[i]);
+  };
+  if (xmlDocument.documentElement) _visit(xmlDocument.documentElement);
+  if (!Number.isFinite(minX) || !Number.isFinite(minY)) return undefined;
+  return {
+    minX: minX,
+    minY: minY,
+    maxX: maxX,
+    maxY: maxY
+  };
+}
+
+/**
+ * Minimum x/y over all non-AV geometry — the offset that docking-point coordinates are corrected by.
+ * `transform` attributes are not applied; an element carrying one is reported through the package logger
+ * rather than measured wrongly in silence.
+ */
+function getMinBorder(content) {
+  // Stroke-inclusive on purpose: this is the origin the planner anchors docking points against.
+  var bounds = collectBounds(content, function (element) {
+    var _element$getAttribute10;
+    return !((_element$getAttribute10 = element.getAttribute('id')) !== null && _element$getAttribute10 !== void 0 ? _element$getAttribute10 : '').startsWith('AV');
+  }, {
+    includeStroke: true,
+    measurement: 'getMinBorder'
+  });
+  if (!bounds) return {
+    minX: 0,
+    minY: 0
+  };
+  return {
+    minX: bounds.minX,
+    minY: bounds.minY
+  };
+}
+
+/**
+ * Bounding box over ALL drawing geometry including AV lines — the ink extent of the article.
+ * This is not an article's width/depth: use {@link getRootSize} for that.
+ */
+function getContentBounds(content) {
+  return collectBounds(content, function () {
+    return true;
+  });
+}
+
+/** The declared canvas size of the SVG root in user units — the value an article's width/depth is derived from. */
+function getRootSize(content) {
+  var _root$getAttribute, _root$getAttribute2;
+  var root = parseXml(content).documentElement;
+  if (!root) return undefined;
+  var width = parseFloat((_root$getAttribute = root.getAttribute('width')) !== null && _root$getAttribute !== void 0 ? _root$getAttribute : '');
+  var height = parseFloat((_root$getAttribute2 = root.getAttribute('height')) !== null && _root$getAttribute2 !== void 0 ? _root$getAttribute2 : '');
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return undefined;
+  return {
+    width: width,
+    height: height
+  };
+}
+
+function _createForOfIteratorHelper$5(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$5(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$5(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$5(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$5(r, a) : void 0; } }
+function _arrayLikeToArray$5(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Polygon `points` tokenizer: the pair separator is ',' when the string contains one, ' ' otherwise, so both
+ * "x,y x,y" and "x y x y" parse. An all-comma list keeps the legacy misparse on purpose.
+ */
+function parsePolygonPoints(pointsText) {
+  var points = [];
+  var separator = pointsText.includes(',') ? ',' : ' ';
+  var text = pointsText.trim();
+  var readingX = true;
+  var x = '';
+  var y = '';
+  var _iterator = _createForOfIteratorHelper$5(text),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var character = _step.value;
+      if (!readingX && character === ' ') {
+        if (x !== '') {
+          points.push({
+            x: parseFloat(x),
+            y: parseFloat(y)
+          });
+          x = '';
+          y = '';
+          readingX = true;
+        }
+        continue;
+      }
+      if (character === separator) {
+        readingX = false;
+        continue;
+      }
+      if (readingX) x += character;else y += character;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (x !== '') points.push({
+    x: parseFloat(x),
+    y: parseFloat(y)
+  });
+  return points;
+}
+
+/** Legacy points format: "x,y " pairs with a trailing space. */
+function serializePolygonPoints(points) {
+  var result = '';
+  var _iterator2 = _createForOfIteratorHelper$5(points),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var point = _step2.value;
+      result += point.x + ',' + point.y + ' ';
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return result;
+}
+
+/** Coordinate rounding to 3 decimals — every transformed coordinate goes through this. */
+function round3(value) {
+  return Math.round(value * 1000) / 1000;
+}
+
+/** Result rounding to 2 decimals — used for the root size and the viewBox. */
+function round2(value) {
+  return Math.round(value * 100) / 100;
+}
+
+function _createForOfIteratorHelper$4(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$4(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$4(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$4(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$4(r, a) : void 0; } }
+function _arrayLikeToArray$4(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+
+/** One stretch area projected onto the active axis; end is pre-rounded, as the legacy engine rounded it. */
+
+/**
+ * Which scale factor applies to each param of a command, case-insensitively. `null` marks a param that is
+ * not a coordinate: an arc's x-axis-rotation and its two flags. `z` carries no params at all.
+ */
+var SCALE_PARAM_AXES = {
+  m: ['x', 'y'],
+  l: ['x', 'y'],
+  h: ['x'],
+  v: ['y'],
+  c: ['x', 'y', 'x', 'y', 'x', 'y'],
+  s: ['x', 'y', 'x', 'y'],
+  q: ['x', 'y', 'x', 'y'],
+  t: ['x', 'y'],
+  a: ['x', 'y', null, null, null, 'x', 'y'],
+  z: []
+};
+
+/** Index of an arc's x-axis-rotation param; a rotated arc cannot be scaled exactly along separate axes. */
+var ARC_ROTATION_PARAM = 2;
+
+/** Legacy `d` format: bare command letters, params joined with ',', no separators between commands. */
+function serializePathCommands(commands) {
+  return commands.map(function (command) {
+    return command.command + command.params.join(',');
+  }).join('');
+}
+function parsePathSafely(d, warn) {
+  try {
+    return parsePathCommands(d);
+  } catch (error) {
+    warn("stretch: unparsable path data left untouched (".concat(error instanceof Error ? error.message : String(error), ")"));
+    return undefined;
+  }
+}
+
+/**
+ * Applies the stretch-area shifts of one axis to a path `d` attribute, including the legacy relative-command
+ * quirks. Commands that do not move the pen along this axis (H/h vertically, V/v horizontally, Z/z) carry no
+ * mapping and are skipped; the parser has already rejected anything that is not a valid SVG command.
+ */
+function stretchPathData(d, areas, axis, warn) {
+  var commands = parsePathSafely(d, warn);
+  if (!commands) return d;
+  var _iterator = _createForOfIteratorHelper$4(areas),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var area = _step.value;
+      var delta = area.end - area.begin;
+      // NaN start reproduces the legacy undefined `last` (all comparisons false, arithmetic stays NaN until an absolute command).
+      var last = Number.NaN;
+      var _iterator2 = _createForOfIteratorHelper$4(commands),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _step2.value,
+            command = _step2$value.command,
+            params = _step2$value.params;
+          var absolute = axis.absolute[command];
+          if (absolute) {
+            var value = params[absolute.track];
+            if (value > area.begin) {
+              var _iterator3 = _createForOfIteratorHelper$4(absolute.shift),
+                _step3;
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  var index = _step3.value;
+                  params[index] = round3(params[index] + delta);
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+            }
+            last = value;
+            continue;
+          }
+          var relative = axis.relative[command];
+          if (relative) {
+            var help = params[relative.help];
+            if ((!relative.requireNonNegativeForward || help >= 0) && last < area.begin && last + help > area.begin) {
+              var _iterator4 = _createForOfIteratorHelper$4(relative.shift),
+                _step4;
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  var _index = _step4.value;
+                  params[_index] = round3(params[_index] + delta);
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+            } else if (help < 0 && last >= area.begin && last + params[relative.backwardProbe] < area.begin) {
+              var _iterator5 = _createForOfIteratorHelper$4(relative.shift),
+                _step5;
+              try {
+                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                  var _index2 = _step5.value;
+                  params[_index2] = round3(params[_index2] + relative.backwardSign * delta);
+                }
+              } catch (err) {
+                _iterator5.e(err);
+              } finally {
+                _iterator5.f();
+              }
+            }
+            last += help;
+            continue;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return serializePathCommands(commands);
+}
+
+/** Scales all path coordinates by per-axis factors — rounded for the global-scale mode, unrounded for the viewBox normalization. */
+function scalePathData(d, widthFactor, heightFactor, roundResults, warn) {
+  var commands = parsePathSafely(d, warn);
+  if (!commands) return d;
+  var _iterator6 = _createForOfIteratorHelper$4(commands),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var _step6$value = _step6.value,
+        command = _step6$value.command,
+        params = _step6$value.params;
+      var paramAxes = SCALE_PARAM_AXES[command.toLowerCase()];
+      if (command.toLowerCase() === 'a' && params[ARC_ROTATION_PARAM] !== 0 && widthFactor !== heightFactor) {
+        // A rotated ellipse under different x/y factors is no longer an ellipse with these radii; scaling them
+        // separately is an approximation, so it is worth saying out loud rather than drifting silently.
+        warn("stretch: rotated arc scaled with different x/y factors \u2014 its radii are approximated");
+      }
+      for (var i = 0; i < paramAxes.length; i++) {
+        if (paramAxes[i] === null) continue;
+        var scaled = params[i] * (paramAxes[i] === 'x' ? widthFactor : heightFactor);
+        params[i] = roundResults ? round3(scaled) : scaled;
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  return serializePathCommands(commands);
+}
+
+/** Creates the initial pipeline state for one stretch run. */
+function createStretchState(document, root, useGlobalScale, targetWidthOlt, targetHeightOlt) {
+  return {
+    document: document,
+    root: root,
+    useGlobalScale: useGlobalScale,
+    targetWidthOlt: targetWidthOlt,
+    targetHeightOlt: targetHeightOlt,
+    widthOlt: 0,
+    heightOlt: 0,
+    widthOlf: 0,
+    heightOlf: 0,
+    startWidthOlt: 0,
+    startHeightOlt: 0,
+    startWidthOlf: 0,
+    startHeightOlf: 0,
+    hasOlf: false,
+    deltaOlfWidth: 0,
+    deltaOlfHeight: 0,
+    origOltWidth: 0,
+    origOltHeight: 0,
+    sah: [],
+    sav: [],
+    ratioSah: [],
+    ratioSav: [],
+    // NaN mirrors the legacy undefined factors: a pass with only one changed dimension propagates NaN the same way.
+    globalScaleFactorWidth: Number.NaN,
+    globalScaleFactorHeight: Number.NaN,
+    warnings: [],
+    warned: new Set()
+  };
+}
+
+/** Records a warning once (deduplicated per run) and mirrors it to the package logger. */
+function addWarning(state, message) {
+  if (state.warned.has(message)) return;
+  state.warned.add(message);
+  state.warnings.push(message);
+  getPlanner2DLogger().warn(message);
+}
+function currentSizes(state) {
+  return {
+    widthOLT: state.widthOlt,
+    heightOLT: state.heightOlt,
+    widthOLF: state.widthOlf,
+    heightOLF: state.heightOlf
+  };
+}
+
+function _createForOfIteratorHelper$3(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$3(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$3(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$3(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$3(r, a) : void 0; } }
+function _arrayLikeToArray$3(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+
+/** ViewBox-to-attribute scale of the root element (1:1 for planner-conform articles). */
+
+/** Legacy length parsing: mm converts to user units, px strips the suffix, anything else parses as-is. */
+function parseSvgLength(text) {
+  if (text.indexOf('mm') > 0) return parseFloat(text.substring(0, text.length - 2)) * UNIT_RECALC;
+  if (text.indexOf('px') > 0) return parseFloat(text.substring(0, text.length - 2));
+  return parseFloat(text);
+}
+
+/** Derives missing width/height from the viewBox, normalizes units and defaults the viewBox. */
+function normalizeRootSize(root) {
+  var viewBox = root.getAttribute('viewBox');
+  if (viewBox && root.getAttribute('width') == null) root.setAttribute('width', viewBox.split(' ')[2]);
+  if (viewBox && root.getAttribute('height') == null) root.setAttribute('height', viewBox.split(' ')[3]);
+  var widthText = root.getAttribute('width');
+  var heightText = root.getAttribute('height');
+  if (widthText == null || heightText == null) {
+    throw new Error('stretchArticleSvg: root <svg> carries neither width/height attributes nor a viewBox');
+  }
+  var width = parseSvgLength(widthText);
+  var height = parseSvgLength(heightText);
+  root.setAttribute('width', width.toString());
+  root.setAttribute('height', height.toString());
+  if (!viewBox) root.setAttribute('viewBox', '0 0 ' + width + ' ' + height);
+}
+function viewBoxScaleFactor(root) {
+  var viewBox = root.getAttribute('viewBox');
+  if (viewBox == null) return {
+    x: 1,
+    y: 1
+  };
+  var pieces = viewBox.split(' ');
+  return {
+    x: Number(root.getAttribute('width')) / Number(pieces[2]),
+    y: Number(root.getAttribute('height')) / Number(pieces[3])
+  };
+}
+
+/** Rewrites the viewBox with ceiled root size and origin. */
+function rewriteViewBoxToCeiledInts(root) {
+  var _root$getAttribute, _root$getAttribute2;
+  if (root.getAttribute('viewBox') == null) return;
+  var width = Math.ceil(parseFloat((_root$getAttribute = root.getAttribute('width')) !== null && _root$getAttribute !== void 0 ? _root$getAttribute : ''));
+  var height = Math.ceil(parseFloat((_root$getAttribute2 = root.getAttribute('height')) !== null && _root$getAttribute2 !== void 0 ? _root$getAttribute2 : ''));
+  var xText = root.getAttribute('x');
+  var yText = root.getAttribute('y');
+  var originX = xText ? Math.ceil(parseSvgLength(xText)) : 0;
+  var originY = yText ? Math.ceil(parseSvgLength(yText)) : 0;
+  root.setAttribute('viewBox', originX + ' ' + originY + ' ' + width + ' ' + height);
+}
+function scaleRectAttributes(rect, scale) {
+  var _rect$getAttribute, _rect$getAttribute2, _rect$getAttribute3, _rect$getAttribute4;
+  var x = (_rect$getAttribute = rect.getAttribute('x')) !== null && _rect$getAttribute !== void 0 ? _rect$getAttribute : '0';
+  var y = (_rect$getAttribute2 = rect.getAttribute('y')) !== null && _rect$getAttribute2 !== void 0 ? _rect$getAttribute2 : '0';
+  rect.setAttribute('x', String(parseFloat(x) * scale.x));
+  rect.setAttribute('y', String(parseFloat(y) * scale.y));
+  rect.setAttribute('width', String(parseFloat((_rect$getAttribute3 = rect.getAttribute('width')) !== null && _rect$getAttribute3 !== void 0 ? _rect$getAttribute3 : '') * scale.x));
+  rect.setAttribute('height', String(parseFloat((_rect$getAttribute4 = rect.getAttribute('height')) !== null && _rect$getAttribute4 !== void 0 ? _rect$getAttribute4 : '') * scale.y));
+}
+function scaleLineAttributes(line, scale) {
+  var _line$getAttribute, _line$getAttribute2, _line$getAttribute3, _line$getAttribute4;
+  var x1 = (_line$getAttribute = line.getAttribute('x1')) !== null && _line$getAttribute !== void 0 ? _line$getAttribute : '0';
+  var y1 = (_line$getAttribute2 = line.getAttribute('y1')) !== null && _line$getAttribute2 !== void 0 ? _line$getAttribute2 : '0';
+  line.setAttribute('x1', String(parseFloat(x1) * scale.x));
+  line.setAttribute('y1', String(parseFloat(y1) * scale.y));
+  line.setAttribute('x2', String(parseFloat((_line$getAttribute3 = line.getAttribute('x2')) !== null && _line$getAttribute3 !== void 0 ? _line$getAttribute3 : '') * scale.x));
+  line.setAttribute('y2', String(parseFloat((_line$getAttribute4 = line.getAttribute('y2')) !== null && _line$getAttribute4 !== void 0 ? _line$getAttribute4 : '') * scale.y));
+}
+function scalePolygonAttributes(polygon, scale) {
+  var _polygon$getAttribute;
+  var points = parsePolygonPoints((_polygon$getAttribute = polygon.getAttribute('points')) !== null && _polygon$getAttribute !== void 0 ? _polygon$getAttribute : '');
+  var _iterator = _createForOfIteratorHelper$3(points),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var point = _step.value;
+      point.x *= scale.x;
+      point.y *= scale.y;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  polygon.setAttribute('points', serializePolygonPoints(points));
+}
+
+/** Numeric width/height declarations inside a `<style>` scale with the viewBox factors. */
+function scaleStyleDimension(part, property, factor) {
+  var propertyIndex = part.indexOf(property);
+  if (propertyIndex < 0) return part;
+  var value = '';
+  var startIndex = -1;
+  var endIndex = -1;
+  for (var i = propertyIndex + property.length; i < part.length; i++) {
+    var character = part[i];
+    if (character === ';' || character === '}') {
+      endIndex = i;
+      break;
+    }
+    if (startIndex > -1) value += character;
+    if (character === ':') startIndex = i;
+  }
+  return part.substring(0, startIndex + 1) + parseFloat(value) * factor + part.substring(endIndex);
+}
+function scaleStyleElement(styleElement, scale) {
+  var _styleElement$textCon;
+  var parts = ((_styleElement$textCon = styleElement.textContent) !== null && _styleElement$textCon !== void 0 ? _styleElement$textCon : '').split('{');
+  var result = '';
+  for (var i = 0; i < parts.length; i++) {
+    var part = scaleStyleDimension(parts[i], 'width', scale.x);
+    part = scaleStyleDimension(part, 'height', scale.y);
+    result += part;
+    if (i < parts.length - 1) result += '{';
+  }
+  styleElement.textContent = result;
+}
+
+/**
+ * Scales all drawing geometry from viewBox units into root-attribute units. Every element — SAH/SAV rects
+ * included — is scaled exactly once, unlike the legacy engine, which double-scaled the stretch-area rects.
+ */
+function applyViewBoxScale(state, scale) {
+  if (scale.x === 1 && scale.y === 1) return;
+  var _visit = function visit(parent) {
+    var _child$getAttribute;
+    var children = parent.children;
+    if (!children) return;
+    for (var i = 0; i < children.length; i++) {
+      var child = children[i];
+      switch (child.tagName) {
+        case 'rect':
+          scaleRectAttributes(child, scale);
+          break;
+        case 'polygon':
+          scalePolygonAttributes(child, scale);
+          break;
+        case 'path':
+          child.setAttribute('d', scalePathData((_child$getAttribute = child.getAttribute('d')) !== null && _child$getAttribute !== void 0 ? _child$getAttribute : '', scale.x, scale.y, false, function (message) {
+            return addWarning(state, message);
+          }));
+          break;
+        case 'line':
+          scaleLineAttributes(child, scale);
+          break;
+        case 'style':
+          scaleStyleElement(child, scale);
+          break;
+      }
+      _visit(child);
+    }
+  };
+  _visit(state.root);
+}
+
+/** Tags the technical group as TE when missing and hides every TE group. */
+function ensureTeDisplayNone(document) {
+  var teElements = snapshotByIdPrefix(document, 'TE');
+  if (teElements.length === 0) {
+    var _iterator2 = _createForOfIteratorHelper$3(snapshotByIdPrefix(document, 'OLT')),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var olt = _step2.value;
+        if (olt.nodeName === 'g') continue;
+        var parent = olt.parentElement;
+        if ((parent === null || parent === void 0 ? void 0 : parent.tagName) === 'g') parent.setAttribute('id', 'TE');
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    teElements = snapshotByIdPrefix(document, 'TE');
+  }
+  var _iterator3 = _createForOfIteratorHelper$3(teElements),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var teElement = _step3.value;
+      if (teElement.nodeName === 'g') teElement.setAttribute('display', 'none');
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+}
+
+/** Per-axis parameter routing for an absolute path command. */
+
+/** Per-axis routing for a relative path command, including the legacy branch quirks. */
+
+/** Everything the element and path transformers need to work on one axis ('x' = SAH passes, 'y' = SAV passes). */
+
+var HORIZONTAL_AXIS = {
+  axis: 'x',
+  pos: 'x',
+  size: 'width',
+  linePoint1: 'x1',
+  linePoint2: 'x2',
+  pointKey: 'x',
+  absolute: {
+    M: {
+      track: 0,
+      shift: [0]
+    },
+    L: {
+      track: 0,
+      shift: [0]
+    },
+    H: {
+      track: 0,
+      shift: [0]
+    },
+    C: {
+      track: 4,
+      shift: [4, 0, 2]
+    },
+    S: {
+      track: 2,
+      shift: [0, 2]
+    },
+    Q: {
+      track: 2,
+      shift: [0, 2]
+    },
+    T: {
+      track: 0,
+      shift: [0]
+    },
+    // Params 0/1 of an arc are radii, not positions: displacing an arc moves its endpoint and keeps its shape.
+    A: {
+      track: 5,
+      shift: [5]
+    }
+  },
+  relative: {
+    m: {
+      help: 0,
+      shift: [0],
+      requireNonNegativeForward: true,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    l: {
+      help: 0,
+      shift: [0],
+      requireNonNegativeForward: true,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    h: {
+      help: 0,
+      shift: [0],
+      requireNonNegativeForward: true,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    c: {
+      help: 4,
+      shift: [4, 0, 2],
+      requireNonNegativeForward: false,
+      backwardProbe: 0,
+      backwardSign: 1
+    },
+    s: {
+      help: 2,
+      shift: [0, 2],
+      requireNonNegativeForward: false,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    q: {
+      help: 2,
+      shift: [0, 2],
+      requireNonNegativeForward: false,
+      backwardProbe: 2,
+      backwardSign: -1
+    },
+    t: {
+      help: 0,
+      shift: [0],
+      requireNonNegativeForward: false,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    a: {
+      help: 5,
+      shift: [5],
+      requireNonNegativeForward: false,
+      backwardProbe: 5,
+      backwardSign: -1
+    }
+  }
+};
+var VERTICAL_AXIS = {
+  axis: 'y',
+  pos: 'y',
+  size: 'height',
+  linePoint1: 'y1',
+  linePoint2: 'y2',
+  pointKey: 'y',
+  absolute: {
+    M: {
+      track: 1,
+      shift: [1]
+    },
+    L: {
+      track: 1,
+      shift: [1]
+    },
+    V: {
+      track: 0,
+      shift: [0]
+    },
+    C: {
+      track: 5,
+      shift: [5, 1, 3]
+    },
+    S: {
+      track: 3,
+      shift: [1, 3]
+    },
+    Q: {
+      track: 3,
+      shift: [1, 3]
+    },
+    T: {
+      track: 1,
+      shift: [1]
+    },
+    A: {
+      track: 6,
+      shift: [6]
+    }
+  },
+  relative: {
+    m: {
+      help: 1,
+      shift: [1],
+      requireNonNegativeForward: false,
+      backwardProbe: 1,
+      backwardSign: -1
+    },
+    l: {
+      help: 1,
+      shift: [1],
+      requireNonNegativeForward: false,
+      backwardProbe: 1,
+      backwardSign: -1
+    },
+    v: {
+      help: 0,
+      shift: [0],
+      requireNonNegativeForward: false,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    c: {
+      help: 5,
+      shift: [5, 1, 3],
+      requireNonNegativeForward: false,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    s: {
+      help: 3,
+      shift: [1, 3],
+      requireNonNegativeForward: false,
+      backwardProbe: 0,
+      backwardSign: -1
+    },
+    q: {
+      help: 3,
+      shift: [1, 3],
+      requireNonNegativeForward: false,
+      backwardProbe: 3,
+      backwardSign: -1
+    },
+    t: {
+      help: 1,
+      shift: [1],
+      requireNonNegativeForward: false,
+      backwardProbe: 1,
+      backwardSign: -1
+    },
+    a: {
+      help: 6,
+      shift: [6],
+      requireNonNegativeForward: false,
+      backwardProbe: 6,
+      backwardSign: -1
+    }
+  }
+};
+
+function _createForOfIteratorHelper$2(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$2(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$2(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$2(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : void 0; } }
+function _arrayLikeToArray$2(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/** Elements that carry coordinates but have no transformer — they keep their position, which is worth a warning. */
+var UNTRANSFORMED_COORDINATE_ELEMENTS = ['circle', 'ellipse', 'text', 'tspan', 'use'];
+
+/** The stretch areas of one axis projected to begin/end ranges. */
+function areaRanges(state, axis) {
+  var areas = axis.axis === 'x' ? state.sah : state.sav;
+  return areas.map(function (area) {
+    var _area$getAttribute, _area$getAttribute2;
+    var begin = parseFloat((_area$getAttribute = area.getAttribute(axis.pos)) !== null && _area$getAttribute !== void 0 ? _area$getAttribute : '');
+    return {
+      begin: begin,
+      end: round3(begin + parseFloat((_area$getAttribute2 = area.getAttribute(axis.size)) !== null && _area$getAttribute2 !== void 0 ? _area$getAttribute2 : ''))
+    };
+  });
+}
+function stretchRect(rect, ranges, axis) {
+  var _iterator = _createForOfIteratorHelper$2(ranges),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _rect$getAttribute, _rect$getAttribute2;
+      var range = _step.value;
+      var rectBegin = parseFloat((_rect$getAttribute = rect.getAttribute(axis.pos)) !== null && _rect$getAttribute !== void 0 ? _rect$getAttribute : '');
+      var rectEnd = round3(rectBegin + parseFloat((_rect$getAttribute2 = rect.getAttribute(axis.size)) !== null && _rect$getAttribute2 !== void 0 ? _rect$getAttribute2 : ''));
+      if (rectBegin <= range.begin && rectEnd >= range.begin) {
+        rect.setAttribute(axis.size, String(round3(rectEnd - rectBegin + (range.end - range.begin))));
+      } else if (rectBegin > range.begin) {
+        rect.setAttribute(axis.pos, String(round3(rectBegin + (range.end - range.begin))));
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+function scaleRect(rect, state) {
+  var _rect$getAttribute3, _rect$getAttribute4, _rect$getAttribute5, _rect$getAttribute6;
+  var x = parseFloat((_rect$getAttribute3 = rect.getAttribute('x')) !== null && _rect$getAttribute3 !== void 0 ? _rect$getAttribute3 : '');
+  var width = parseFloat((_rect$getAttribute4 = rect.getAttribute('width')) !== null && _rect$getAttribute4 !== void 0 ? _rect$getAttribute4 : '');
+  var y = parseFloat((_rect$getAttribute5 = rect.getAttribute('y')) !== null && _rect$getAttribute5 !== void 0 ? _rect$getAttribute5 : '');
+  var height = parseFloat((_rect$getAttribute6 = rect.getAttribute('height')) !== null && _rect$getAttribute6 !== void 0 ? _rect$getAttribute6 : '');
+  rect.setAttribute('x', String(round3(x * state.globalScaleFactorWidth)));
+  rect.setAttribute('width', String(round3(width * state.globalScaleFactorWidth)));
+  rect.setAttribute('y', String(round3(y * state.globalScaleFactorHeight)));
+  rect.setAttribute('height', String(round3(height * state.globalScaleFactorHeight)));
+}
+function stretchLine(line, ranges, axis) {
+  var _iterator2 = _createForOfIteratorHelper$2(ranges),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _line$getAttribute, _line$getAttribute2;
+      var range = _step2.value;
+      var point1 = parseFloat((_line$getAttribute = line.getAttribute(axis.linePoint1)) !== null && _line$getAttribute !== void 0 ? _line$getAttribute : '');
+      var point2 = parseFloat((_line$getAttribute2 = line.getAttribute(axis.linePoint2)) !== null && _line$getAttribute2 !== void 0 ? _line$getAttribute2 : '');
+      if (point1 > range.begin) {
+        line.setAttribute(axis.linePoint1, String(round3(point1 + (range.end - range.begin))));
+        line.setAttribute(axis.linePoint2, String(round3(point2 + (range.end - range.begin))));
+      } else if (point1 < range.begin && point2 > range.begin) {
+        line.setAttribute(axis.linePoint2, String(round3(point2 + (range.end - range.begin))));
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+}
+function scaleLine(line, state) {
+  var _line$getAttribute3, _line$getAttribute4, _line$getAttribute5, _line$getAttribute6;
+  var x1 = parseFloat((_line$getAttribute3 = line.getAttribute('x1')) !== null && _line$getAttribute3 !== void 0 ? _line$getAttribute3 : '');
+  var x2 = parseFloat((_line$getAttribute4 = line.getAttribute('x2')) !== null && _line$getAttribute4 !== void 0 ? _line$getAttribute4 : '');
+  var y1 = parseFloat((_line$getAttribute5 = line.getAttribute('y1')) !== null && _line$getAttribute5 !== void 0 ? _line$getAttribute5 : '');
+  var y2 = parseFloat((_line$getAttribute6 = line.getAttribute('y2')) !== null && _line$getAttribute6 !== void 0 ? _line$getAttribute6 : '');
+  line.setAttribute('x1', String(round3(x1 * state.globalScaleFactorWidth)));
+  line.setAttribute('x2', String(round3(x2 * state.globalScaleFactorWidth)));
+  line.setAttribute('y1', String(round3(y1 * state.globalScaleFactorHeight)));
+  line.setAttribute('y2', String(round3(y2 * state.globalScaleFactorHeight)));
+}
+function transformPoints(element, mode, state) {
+  var _element$getAttribute;
+  var points = parsePolygonPoints((_element$getAttribute = element.getAttribute('points')) !== null && _element$getAttribute !== void 0 ? _element$getAttribute : '');
+  if (mode === 'GLOBAL_SCALE') {
+    var _iterator3 = _createForOfIteratorHelper$2(points),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var point = _step3.value;
+        point.x *= state.globalScaleFactorWidth;
+        point.y *= state.globalScaleFactorHeight;
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  } else {
+    var axis = mode === 'SAH' ? HORIZONTAL_AXIS : VERTICAL_AXIS;
+    var _iterator4 = _createForOfIteratorHelper$2(areaRanges(state, axis)),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var range = _step4.value;
+        var _iterator5 = _createForOfIteratorHelper$2(points),
+          _step5;
+        try {
+          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+            var _point = _step5.value;
+            if (_point[axis.pointKey] > range.begin) _point[axis.pointKey] += range.end - range.begin;
+          }
+        } catch (err) {
+          _iterator5.e(err);
+        } finally {
+          _iterator5.f();
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  }
+  element.setAttribute('points', serializePolygonPoints(points));
+}
+
+/** Legacy image handling: never moves x/y, resizes via the OLT target ratio, and has no global-scale branch. */
+function transformImage(image, mode, state) {
+  image.setAttribute('preserveAspectRatio', 'none');
+  if (mode === 'SAH') {
+    var _image$getAttribute;
+    var width = parseInt((_image$getAttribute = image.getAttribute('width')) !== null && _image$getAttribute !== void 0 ? _image$getAttribute : '', 10);
+    image.setAttribute('width', Math.round(width * (state.targetWidthOlt / state.origOltWidth)) + 'px');
+  } else if (mode === 'SAV') {
+    var _image$getAttribute2;
+    var height = parseInt((_image$getAttribute2 = image.getAttribute('height')) !== null && _image$getAttribute2 !== void 0 ? _image$getAttribute2 : '', 10);
+    image.setAttribute('height', Math.round(height * (state.targetHeightOlt / state.origOltHeight)) + 'px');
+  }
+}
+function transformPathElement(element, mode, state) {
+  var _element$getAttribute2;
+  var d = (_element$getAttribute2 = element.getAttribute('d')) !== null && _element$getAttribute2 !== void 0 ? _element$getAttribute2 : '';
+  var warn = function warn(message) {
+    return addWarning(state, message);
+  };
+  if (mode === 'GLOBAL_SCALE') {
+    element.setAttribute('d', scalePathData(d, state.globalScaleFactorWidth, state.globalScaleFactorHeight, true, warn));
+    return;
+  }
+  var axis = mode === 'SAH' ? HORIZONTAL_AXIS : VERTICAL_AXIS;
+  element.setAttribute('d', stretchPathData(d, areaRanges(state, axis), axis, warn));
+}
+function transformElement(element, id, mode, outline, state) {
+  switch (element.localName) {
+    case 'g':
+      return;
+    case 'rect':
+      {
+        if (id.substring(0, 3) === 'SAV' || id.substring(0, 3) === 'SAH') return;
+        if (mode === 'GLOBAL_SCALE') {
+          scaleRect(element, state);
+          return;
+        }
+        var axis = mode === 'SAH' ? HORIZONTAL_AXIS : VERTICAL_AXIS;
+        stretchRect(element, areaRanges(state, axis), axis);
+        return;
+      }
+    case 'path':
+      transformPathElement(element, mode, state);
+      return;
+    case 'line':
+      {
+        // Legacy quirk: docking-point lines move only in the OLT pass, every other line in both passes.
+        if (id.substring(0, 2) === 'AV' && outline !== 'OLT') return;
+        if (mode === 'GLOBAL_SCALE') {
+          scaleLine(element, state);
+          return;
+        }
+        var _axis = mode === 'SAH' ? HORIZONTAL_AXIS : VERTICAL_AXIS;
+        stretchLine(element, areaRanges(state, _axis), _axis);
+        return;
+      }
+    case 'polygon':
+    case 'polyline':
+      transformPoints(element, mode, state);
+      return;
+    case 'image':
+      transformImage(element, mode, state);
+      return;
+    default:
+      if (UNTRANSFORMED_COORDINATE_ELEMENTS.includes(element.localName)) {
+        addWarning(state, "stretch: <".concat(element.localName, "> has no stretch transformer and keeps its position"));
+      }
+  }
+}
+
+/**
+ * One resize pass over the DOM: OLT passes ignore the OLF/VIF subtrees, OLF passes ignore OLT/VIT —
+ * geometry outside those subtrees is deliberately processed in BOTH passes.
+ */
+function applyStretchPass(state, mode, outline) {
+  var ignoredViewId = outline === 'OLT' ? 'VIF' : 'VIT';
+  var ignoredOutlineId = outline === 'OLT' ? 'OLF' : 'OLT';
+  var _walk = function walk(parent) {
+    var children = parent.children;
+    for (var i = 0; i < children.length; i++) {
+      var child = children[i];
+      var id = child.getAttribute('id');
+      if (id === ignoredViewId || id === ignoredOutlineId) continue;
+      transformElement(child, id !== null && id !== void 0 ? id : '', mode, outline, state);
+      _walk(child);
+    }
+  };
+  _walk(state.root);
+}
+
+function setOutlineWidth(state, outline, width) {
+  if (outline === 'OLT') state.widthOlt = width;else state.widthOlf = width;
+}
+function setOutlineHeight(state, outline, height) {
+  if (outline === 'OLT') state.heightOlt = height;else state.heightOlf = height;
+}
+
+/**
+ * Lays the stretch areas out for the new size (SAV first, then SAH) and runs the element passes; in
+ * global-scale mode it scales instead. Called once for the OLT and, when present, once for the OLF.
+ */
+function resizeOutline(state, newWidth, newHeight, outline) {
+  var currentWidth = outline === 'OLT' ? state.widthOlt : state.widthOlf;
+  var currentHeight = outline === 'OLT' ? state.heightOlt : state.heightOlf;
+  if (!state.useGlobalScale && state.sav.length > 0 && newHeight !== currentHeight) {
+    setOutlineHeight(state, outline, newHeight);
+    var deltaY = round3(newHeight - currentHeight);
+    var offset = 0;
+    for (var i = 0; i < state.sav.length; i++) {
+      var _area$getAttribute;
+      var area = state.sav[i];
+      // Legacy quirk: SAV positions shift in the OLT AND the OLF pass, SAH positions only in the OLT pass.
+      area.setAttribute('y', String(round3(parseFloat((_area$getAttribute = area.getAttribute('y')) !== null && _area$getAttribute !== void 0 ? _area$getAttribute : '') + offset)));
+      area.setAttribute('height', String(round3(deltaY * state.ratioSav[i])));
+      offset += round3(deltaY * state.ratioSav[i]);
+    }
+    applyStretchPass(state, 'SAV', outline);
+  }
+  if (!state.useGlobalScale && newWidth !== currentWidth && state.sah.length > 0) {
+    setOutlineWidth(state, outline, newWidth);
+    var deltaX = round3(newWidth - currentWidth);
+    var _offset = 0;
+    for (var _i = 0; _i < state.sah.length; _i++) {
+      var _area = state.sah[_i];
+      if (outline === 'OLT') {
+        var _area$getAttribute2;
+        _area.setAttribute('x', String(round3(parseFloat((_area$getAttribute2 = _area.getAttribute('x')) !== null && _area$getAttribute2 !== void 0 ? _area$getAttribute2 : '') + _offset)));
+        _offset += round3(deltaX * state.ratioSah[_i]);
+      }
+      _area.setAttribute('width', String(round3(deltaX * state.ratioSah[_i])));
+    }
+    applyStretchPass(state, 'SAH', outline);
+  }
+  var scale = false;
+  if (state.useGlobalScale && newHeight !== currentHeight) {
+    state.globalScaleFactorHeight = newHeight / currentHeight;
+    scale = true;
+    setOutlineHeight(state, outline, newHeight);
+  }
+  if (state.useGlobalScale && newWidth !== currentWidth) {
+    state.globalScaleFactorWidth = newWidth / currentWidth;
+    scale = true;
+    setOutlineWidth(state, outline, newWidth);
+  }
+  if (scale) applyStretchPass(state, 'GLOBAL_SCALE', outline);
+}
+
+function _createForOfIteratorHelper$1(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray$1(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray$1(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$1(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0; } }
+function _arrayLikeToArray$1(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/** Replaces a polygon stretch area by its bounding rect; only the id is carried over. */
+function convertPolygonToRect(polygon, document) {
+  var _polygon$getAttribute, _polygon$getAttribute2, _polygon$parentElemen, _polygon$parentElemen2;
+  var points = parsePolygonPoints((_polygon$getAttribute = polygon.getAttribute('points')) !== null && _polygon$getAttribute !== void 0 ? _polygon$getAttribute : '');
+  if (points.length === 0) return undefined;
+  var rect = document.createElementNS(polygon.namespaceURI, 'rect');
+  rect.setAttribute('id', (_polygon$getAttribute2 = polygon.getAttribute('id')) !== null && _polygon$getAttribute2 !== void 0 ? _polygon$getAttribute2 : '');
+  var minX = points[0].x;
+  var maxX = points[0].x;
+  var minY = points[0].y;
+  var maxY = points[0].y;
+  var _iterator = _createForOfIteratorHelper$1(points),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var point = _step.value;
+      if (point.x < minX) minX = point.x;else if (point.x > maxX) maxX = point.x;
+      if (point.y < minY) minY = point.y;else if (point.y > maxY) maxY = point.y;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  rect.setAttribute('x', String(minX));
+  rect.setAttribute('y', String(minY));
+  rect.setAttribute('width', String(maxX - minX));
+  rect.setAttribute('height', String(maxY - minY));
+  (_polygon$parentElemen = polygon.parentElement) === null || _polygon$parentElemen === void 0 || _polygon$parentElemen.appendChild(rect);
+  (_polygon$parentElemen2 = polygon.parentElement) === null || _polygon$parentElemen2 === void 0 || _polygon$parentElemen2.removeChild(polygon);
+  return rect;
+}
+
+/**
+ * Normalizes one stretch-area element to a rect. Unsupported representations (e.g. a `<path>` stretch area,
+ * which drove the legacy math into NaN) are ignored with a warning instead.
+ */
+function normalizeStretchArea(element, state) {
+  var rect = element;
+  if (element.nodeName === 'polygon') rect = convertPolygonToRect(element, state.document);
+  if (rect === undefined || rect.nodeName !== 'rect') {
+    var _element$getAttribute;
+    addWarning(state, "stretch: stretch area '".concat((_element$getAttribute = element.getAttribute('id')) !== null && _element$getAttribute !== void 0 ? _element$getAttribute : '', "' is an unsupported <").concat(element.nodeName, "> and is ignored"));
+    return undefined;
+  }
+  rect.setAttribute('style', 'fill:none;');
+  return rect;
+}
+
+/** Legacy selection sort, kept because it is NOT stable and the resulting stretch-area order is position-relevant. */
+function selectionSortByAttribute(elements, attribute) {
+  for (var j = 0; j < elements.length; j++) {
+    var minPos = j;
+    for (var i = j + 1; i < elements.length; i++) {
+      var _elements$i$getAttrib, _elements$minPos$getA;
+      if (parseFloat((_elements$i$getAttrib = elements[i].getAttribute(attribute)) !== null && _elements$i$getAttrib !== void 0 ? _elements$i$getAttrib : '') < parseFloat((_elements$minPos$getA = elements[minPos].getAttribute(attribute)) !== null && _elements$minPos$getA !== void 0 ? _elements$minPos$getA : '')) minPos = i;
+    }
+    if (minPos > j) {
+      var swap = elements[j];
+      elements[j] = elements[minPos];
+      elements[minPos] = swap;
+    }
+  }
+}
+
+/** Measures one OLT/OLF element (rect, polygon, path or the first child of a group). */
+function measureOutline(element, name, state) {
+  switch (element.localName) {
+    case 'rect':
+      {
+        var _element$getAttribute2, _element$getAttribute3;
+        // Legacy quirk: only a missing x attribute is defaulted (the y check was dead code), positions are not recorded.
+        if (!element.hasAttribute('x')) element.setAttribute('x', '0');
+        var width = parseFloat((_element$getAttribute2 = element.getAttribute('width')) !== null && _element$getAttribute2 !== void 0 ? _element$getAttribute2 : '');
+        var height = parseFloat((_element$getAttribute3 = element.getAttribute('height')) !== null && _element$getAttribute3 !== void 0 ? _element$getAttribute3 : '');
+        if (name === 'OLT') {
+          state.widthOlt = width;
+          state.heightOlt = height;
+        } else {
+          state.widthOlf = width;
+          state.heightOlf = height;
+        }
+        return;
+      }
+    case 'polygon':
+      {
+        var _element$getAttribute4;
+        var points = parsePolygonPoints((_element$getAttribute4 = element.getAttribute('points')) !== null && _element$getAttribute4 !== void 0 ? _element$getAttribute4 : '');
+        // Legacy quirk: max starts at 0 (not at the first point), so all-negative outlines measure against 0.
+        var maxX = 0;
+        var maxY = 0;
+        var minX = Number.NaN;
+        var minY = Number.NaN;
+        if (points[0]) {
+          minX = points[0].x;
+          minY = points[0].y;
+        }
+        var _iterator2 = _createForOfIteratorHelper$1(points),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var point = _step2.value;
+            if (point.x > maxX) maxX = point.x;
+            if (point.y > maxY) maxY = point.y;
+            if (point.x < minX) minX = point.x;
+            if (point.y < minY) minY = point.y;
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        if (name === 'OLT') {
+          state.widthOlt = maxX - minX;
+          state.heightOlt = maxY - minY;
+          state.startWidthOlt = minX;
+          state.startHeightOlt = minY;
+        } else {
+          state.widthOlf = maxX - minX;
+          state.heightOlf = maxY - minY;
+          state.startWidthOlf = minX;
+          state.startHeightOlf = minY;
+        }
+        return;
+      }
+    case 'path':
+      {
+        // A malformed OLT/OLF `d` must skip the outline measurement, never throw out of the article load.
+        var bounds;
+        try {
+          var _element$getAttribute5;
+          bounds = pathBoundingBox((_element$getAttribute5 = element.getAttribute('d')) !== null && _element$getAttribute5 !== void 0 ? _element$getAttribute5 : '');
+        } catch (error) {
+          var _element$getAttribute6;
+          addWarning(state, "stretch: outline '".concat((_element$getAttribute6 = element.getAttribute('id')) !== null && _element$getAttribute6 !== void 0 ? _element$getAttribute6 : '', "' has unparsable path data and is ignored: ").concat(error.message));
+          return;
+        }
+        if (!bounds) return;
+        if (name === 'OLT') {
+          state.widthOlt = bounds.maxX - bounds.minX;
+          state.heightOlt = bounds.maxY - bounds.minY;
+        } else {
+          state.widthOlf = bounds.maxX - bounds.minX;
+          state.heightOlf = bounds.maxY - bounds.minY;
+        }
+        return;
+      }
+    case 'g':
+      {
+        var children = element.children;
+        element.setAttribute('id', '');
+        // Legacy quirk: only the FIRST child of a wrapper group is inspected.
+        for (var i = 0; i < children.length; i++) {
+          switch (children[i].localName) {
+            case 'rect':
+            case 'path':
+            case 'polygon':
+              children[i].setAttribute('id', name);
+              measureOutline(children[i], name, state);
+              break;
+          }
+          break;
+        }
+        return;
+      }
+  }
+}
+
+/**
+ * Collects and normalizes the SAH/SAV areas, measures OLT/OLF, sorts the areas by position, derives their
+ * stretch ratios and zeroes their sizes — the resize passes re-grow them by the delta.
+ */
+function prepareStretchGeometry(state) {
+  var sahWidth = 0;
+  var _iterator3 = _createForOfIteratorHelper$1(snapshotByIdPrefix(state.document, 'SAH')),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _rect$getAttribute;
+      var element = _step3.value;
+      var rect = normalizeStretchArea(element, state);
+      if (!rect) continue;
+      sahWidth += parseFloat((_rect$getAttribute = rect.getAttribute('width')) !== null && _rect$getAttribute !== void 0 ? _rect$getAttribute : '');
+      state.sah.push(rect);
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  var savHeight = 0;
+  var _iterator4 = _createForOfIteratorHelper$1(snapshotByIdPrefix(state.document, 'SAV')),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _rect$getAttribute2;
+      var _element = _step4.value;
+      var _rect = normalizeStretchArea(_element, state);
+      if (!_rect) continue;
+      savHeight += parseFloat((_rect$getAttribute2 = _rect.getAttribute('height')) !== null && _rect$getAttribute2 !== void 0 ? _rect$getAttribute2 : '');
+      state.sav.push(_rect);
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  var _iterator5 = _createForOfIteratorHelper$1(snapshotByIdPrefix(state.document, 'OLF')),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var _element2 = _step5.value;
+      state.hasOlf = true;
+      measureOutline(_element2, 'OLF', state);
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  var oltElements = snapshotByIdPrefix(state.document, 'OLT');
+  var _iterator6 = _createForOfIteratorHelper$1(oltElements),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var _element3$parentEleme;
+      var _element3 = _step6.value;
+      if (oltElements.length > 1 && ((_element3$parentEleme = _element3.parentElement) === null || _element3$parentEleme === void 0 ? void 0 : _element3$parentEleme.getAttribute('id')) !== 'TE') continue;
+      measureOutline(_element3, 'OLT', state);
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  if (state.hasOlf) {
+    state.deltaOlfWidth = state.widthOlf - state.widthOlt;
+    state.deltaOlfHeight = state.heightOlf - state.heightOlt;
+  }
+  state.origOltWidth = state.widthOlt;
+  state.origOltHeight = state.heightOlt;
+  selectionSortByAttribute(state.sah, 'x');
+  selectionSortByAttribute(state.sav, 'y');
+  if (sahWidth > 0) state.ratioSah = state.sah.map(function (area) {
+    var _area$getAttribute;
+    return parseFloat((_area$getAttribute = area.getAttribute('width')) !== null && _area$getAttribute !== void 0 ? _area$getAttribute : '') / sahWidth;
+  });
+  if (savHeight > 0) state.ratioSav = state.sav.map(function (area) {
+    var _area$getAttribute2;
+    return parseFloat((_area$getAttribute2 = area.getAttribute('height')) !== null && _area$getAttribute2 !== void 0 ? _area$getAttribute2 : '') / savHeight;
+  });
+  var _iterator7 = _createForOfIteratorHelper$1(state.sah),
+    _step7;
+  try {
+    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+      var area = _step7.value;
+      area.setAttribute('width', '0');
+    }
+  } catch (err) {
+    _iterator7.e(err);
+  } finally {
+    _iterator7.f();
+  }
+  var _iterator8 = _createForOfIteratorHelper$1(state.sav),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var _area = _step8.value;
+      _area.setAttribute('height', '0');
+    }
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+}
+
+/**
+ * Writes the stretched extent (max of OLT and OLF span) into the root size, shifts the viewBox origin by the
+ * minBorder and mirrors the viewBox into enable-background/style.
+ */
+function fixViewBox(state, minBorderX, minBorderY) {
+  var root = state.root;
+  var oltExtentX = state.startWidthOlt + state.widthOlt;
+  var oltExtentY = state.startHeightOlt + state.heightOlt;
+  var olfExtentX = state.startWidthOlf + state.widthOlf;
+  var olfExtentY = state.startHeightOlf + state.heightOlf;
+  var maxWidth = olfExtentX > oltExtentX ? olfExtentX : oltExtentX;
+  var maxHeight = olfExtentY > oltExtentY ? olfExtentY : oltExtentY;
+  root.setAttribute('height', String(round2(maxHeight)));
+  root.setAttribute('width', String(round2(maxWidth)));
+  var borderX = round2(minBorderX);
+  var borderY = round2(minBorderY);
+  var viewBox;
+  if (root.hasAttribute('x') && root.hasAttribute('y')) {
+    var _root$getAttribute, _root$getAttribute2;
+    // Legacy quirk: the root x/y values lose their last two characters (the 'px' suffix of planner exports).
+    var xText = (_root$getAttribute = root.getAttribute('x')) !== null && _root$getAttribute !== void 0 ? _root$getAttribute : '';
+    var yText = (_root$getAttribute2 = root.getAttribute('y')) !== null && _root$getAttribute2 !== void 0 ? _root$getAttribute2 : '';
+    viewBox = "".concat(Number.parseFloat(xText.substring(0, xText.length - 2)) + borderX, " ").concat(Number.parseFloat(yText.substring(0, yText.length - 2)) + borderY, " ").concat(round2(maxWidth), " ").concat(round2(maxHeight));
+  } else {
+    var _root$getAttribute3;
+    var pieces = ((_root$getAttribute3 = root.getAttribute('viewBox')) !== null && _root$getAttribute3 !== void 0 ? _root$getAttribute3 : '').split(' ');
+    // Legacy quirk: without stretch areas on an axis the old viewBox extent is kept (pure scaling display).
+    viewBox = "".concat(Number.parseFloat(pieces[0]) + borderX, " ").concat(Number.parseFloat(pieces[1]) + borderY);
+    viewBox += ' ' + (state.sah.length > 0 ? String(round2(maxWidth)) : pieces[2]);
+    viewBox += ' ' + (state.sav.length > 0 ? String(round2(maxHeight)) : pieces[3]);
+  }
+  root.setAttribute('x', String(borderX));
+  root.setAttribute('y', String(borderY));
+  root.setAttribute('viewBox', viewBox);
+  root.setAttribute('enable-background', 'new ' + viewBox);
+  root.setAttribute('style', 'enable-background:new ' + viewBox + ';');
+}
+
+/**
+ * Stretches a planner article SVG to the given OLT target size (cm) by widening its SAH/SAV stretch areas,
+ * or by scaling uniformly with `useGlobalScale`. Behavior-faithful to the legacy ccCheckStretchAreas engine
+ * including its OLT-then-OLF double pass and rounding rules. Deliberate deviations — unknown path commands
+ * survive untransformed, unsupported stretch-area elements are ignored, viewBox-scaled documents are
+ * normalized exactly once — are reported in `warnings`.
+ */
+function stretchArticleSvg(svg, targetWidthCm, targetDepthCm) {
+  var _root$getAttribute, _root$getAttribute2, _root$getAttribute3, _root$getAttribute4, _options$minBorderX, _options$minBorderY;
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var xmlDocument = parseXml(svg);
+  var root = xmlDocument.documentElement;
+  if (!root) throw new Error('stretchArticleSvg: the SVG has no root element');
+  var state = createStretchState(xmlDocument, root, options.useGlobalScale === true, targetWidthCm * UNIT_RECALC, targetDepthCm * UNIT_RECALC);
+  normalizeRootSize(root);
+  var viewBoxScale = viewBoxScaleFactor(root);
+  rewriteViewBoxToCeiledInts(root);
+  // Geometry is normalized to root units exactly once, and the target stays in root units.
+  applyViewBoxScale(state, viewBoxScale);
+  var origWidthCm = round2(parseFloat((_root$getAttribute = root.getAttribute('width')) !== null && _root$getAttribute !== void 0 ? _root$getAttribute : '') / UNIT_RECALC);
+  var origDepthCm = round2(parseFloat((_root$getAttribute2 = root.getAttribute('height')) !== null && _root$getAttribute2 !== void 0 ? _root$getAttribute2 : '') / UNIT_RECALC);
+  // Legacy zero-target quirks, kept verbatim including their asymmetry.
+  if (state.targetWidthOlt === 0) origWidthCm = parseFloat((_root$getAttribute3 = root.getAttribute('width')) !== null && _root$getAttribute3 !== void 0 ? _root$getAttribute3 : '');
+  if (state.targetHeightOlt === 0) state.targetHeightOlt = parseFloat((_root$getAttribute4 = root.getAttribute('height')) !== null && _root$getAttribute4 !== void 0 ? _root$getAttribute4 : '');
+  ensureTeDisplayNone(xmlDocument);
+  prepareStretchGeometry(state);
+  if (targetWidthCm === origWidthCm && targetDepthCm === origDepthCm) {
+    return {
+      svg: serializeXml(xmlDocument),
+      sizes: currentSizes(state),
+      warnings: state.warnings
+    };
+  }
+  resizeOutline(state, state.targetWidthOlt, state.targetHeightOlt, 'OLT');
+  if (state.hasOlf) resizeOutline(state, state.targetWidthOlt + state.deltaOlfWidth, state.targetHeightOlt + state.deltaOlfHeight, 'OLF');
+  fixViewBox(state, (_options$minBorderX = options.minBorderX) !== null && _options$minBorderX !== void 0 ? _options$minBorderX : 0, (_options$minBorderY = options.minBorderY) !== null && _options$minBorderY !== void 0 ? _options$minBorderY : 0);
+  return {
+    svg: serializeXml(xmlDocument),
+    sizes: currentSizes(state),
+    warnings: state.warnings
+  };
+}
+
+/**
+ * One AV connector of a planner element. Name parsing supports the legacy underscore form (AVC_2) and the
+ * IDM form (AVC2); AVR/AVL and names containing _IL always ignore the layer check.
+ */
+var DockingPoint = /*#__PURE__*/function () {
+  function DockingPoint(elementId, type, name, localPos, rotDeg, layer, plannerConfig, filter) {
+    _classCallCheck__default["default"](this, DockingPoint);
+    _defineProperty__default["default"](this, "dockingPoint", void 0);
+    _defineProperty__default["default"](this, "layer", void 0);
+    _defineProperty__default["default"](this, "isDisabled", void 0);
+    _defineProperty__default["default"](this, "plannerConfig", void 0);
+    this.plannerConfig = plannerConfig;
+    this.isDisabled = false;
+    var number = -1;
+    var splittedAV = name.split('_');
+    if (splittedAV.length >= 2) {
+      for (var i = 1; i < splittedAV.length; i++) {
+        var part = parseInt(splittedAV[i]);
+        if (!isNaN(part)) {
+          number = part;
+          break;
+        }
+      }
+    } else if (name.length > 3) {
+      var _part = parseInt(name.substring(3));
+      if (!isNaN(_part)) {
+        number = _part;
+      }
+    }
+    this.dockingPoint = {
+      dpId: type + '_' + name,
+      elementId: elementId,
+      type: type,
+      name: name,
+      ignoreLayer: type === 'AVR' || type === 'AVL' || name.indexOf('_IL') >= 0,
+      localWorldPos: localPos,
+      rotDeg: rotDeg,
+      isDocking: false,
+      dpFilter: filter
+    };
+    if (number >= 0) {
+      this.dockingPoint.number = number;
+    }
+    this.layer = layer;
+  }
+
+  /** Clones the docking point including its docking state. */
+  return _createClass__default["default"](DockingPoint, [{
+    key: "clone",
+    value: function clone() {
+      var dpClone = new DockingPoint(this.dockingPoint.elementId, this.dockingPoint.type, this.dockingPoint.name, this.dockingPoint.localWorldPos, this.dockingPoint.rotDeg, this.layer, this.plannerConfig, this.dockingPoint.dpFilter);
+      dpClone.dockingPoint.dpId = this.dockingPoint.dpId;
+      dpClone.dockingPoint.ignoreLayer = this.dockingPoint.ignoreLayer;
+      dpClone.dockingPoint.isDocking = this.dockingPoint.isDocking;
+      dpClone.dockingPoint.number = this.dockingPoint.number;
+      dpClone.dockingPoint.onDP = this.dockingPoint.onDP;
+      dpClone.dockingPoint.onElementId = this.dockingPoint.onElementId;
+      return dpClone;
+    }
+  }, {
+    key: "ElementId",
+    get: function get() {
+      return this.dockingPoint.elementId;
+    }
+  }, {
+    key: "Name",
+    get: function get() {
+      return this.dockingPoint.name;
+    }
+  }, {
+    key: "LocalWorldPos",
+    get: function get() {
+      return this.dockingPoint.localWorldPos;
+    }
+  }, {
+    key: "RotDeg",
+    get: function get() {
+      return this.dockingPoint.rotDeg;
+    }
+  }, {
+    key: "Type",
+    get: function get() {
+      return this.dockingPoint.type;
+    }
+  }, {
+    key: "IsDocking",
+    get: function get() {
+      return this.dockingPoint.isDocking;
+    }
+  }, {
+    key: "Layer",
+    get: function get() {
+      return this.layer;
+    }
+  }, {
+    key: "IgnoreLayer",
+    get: function get() {
+      return this.dockingPoint.ignoreLayer;
+    }
+  }, {
+    key: "HasNumber",
+    get: function get() {
+      return this.dockingPoint.number != undefined;
+    }
+  }, {
+    key: "Number",
+    get: function get() {
+      return this.dockingPoint.number;
+    }
+  }, {
+    key: "PlannerConfig",
+    get: function get() {
+      return this.plannerConfig;
+    }
+  }, {
+    key: "IsDisabled",
+    get: function get() {
+      return this.isDisabled;
+    }
+  }, {
+    key: "DPFilter",
+    get: function get() {
+      return this.dockingPoint.dpFilter;
+    }
+
+    /** Marks this docking point as docked onto refDockingPoint of the element refElementId. */
+  }, {
+    key: "doDock",
+    value: function doDock(refDockingPoint, refElementId) {
+      this.dockingPoint.isDocking = true;
+      this.dockingPoint.onDP = refDockingPoint;
+      this.dockingPoint.onElementId = refElementId;
+    }
+  }, {
+    key: "undock",
+    value: function undock() {
+      this.dockingPoint.isDocking = false;
+      this.dockingPoint.onDP = undefined;
+      this.dockingPoint.onElementId = undefined;
+    }
+
+    /** Temporarily disables the docking point so the planner ignores it. */
+  }, {
+    key: "disableDP",
+    value: function disableDP(doDisable) {
+      this.isDisabled = doDisable;
+    }
+  }, {
+    key: "OnDP",
+    get: function get() {
+      return this.dockingPoint.onDP;
+    }
+  }, {
+    key: "OnElementId",
+    get: function get() {
+      return this.dockingPoint.onElementId;
+    }
+  }, {
+    key: "DpId",
+    get: function get() {
+      return this.dockingPoint.dpId;
+    }
+  }]);
+}();
+
+/** A dockable pair found by an area search, with its ground-plane distance in cm. */
+
+/** Stateless docking domain logic: AV line parsing, pairing rules and dock/undock bookkeeping. */
+var DockingPointHandler = /*#__PURE__*/function () {
+  function DockingPointHandler() {
+    _classCallCheck__default["default"](this, DockingPointHandler);
+  }
+  return _createClass__default["default"](DockingPointHandler, [{
+    key: "getRotOfDP",
+    value: /** Clockwise rotation in degrees of the vector pos1 -> pos2, where 0 points downwards: down 0, left 90, up 180, right 270. */
+    function getRotOfDP(pos1, pos2) {
+      var directionVec = Vector2.getDirection(pos2, pos1);
+      var refDirection = new Vector2(0, 1);
+      var smallAngle = Vector2.angleDeg(refDirection, directionVec);
+      if (directionVec.x > 0) {
+        return 360 - smallAngle;
+      }
+      return smallAngle;
+    }
+
+    /** The counterpart type a docking point type pairs with: AVR<->AVL, AVO<->AVU, AVS<->AVN, AVC<->AVC. */
+  }, {
+    key: "getReferenceDPType",
+    value: function getReferenceDPType(dpType) {
+      switch (dpType) {
+        case 'AVR':
+          return 'AVL';
+        case 'AVL':
+          return 'AVR';
+        case 'AVO':
+          return 'AVU';
+        case 'AVU':
+          return 'AVO';
+        case 'AVC':
+          return 'AVC';
+        case 'AVS':
+          return 'AVN';
+        case 'AVN':
+          return 'AVS';
+      }
+      return '';
+    }
+  }, {
+    key: "sortDockingPoints",
+    value: function sortDockingPoints(dir, dockingPoints) {
+      if (dir === 'LEFT_TO_RIGHT') return dockingPoints.sort(function (a, b) {
+        return a.LocalWorldPos.x > b.LocalWorldPos.x ? 1 : -1;
+      });
+      return dockingPoints.sort(function (a, b) {
+        return a.LocalWorldPos.x < b.LocalWorldPos.x ? 1 : -1;
+      });
+    }
+  }, {
+    key: "checkDPAVLFilterDoMatch",
+    value: function checkDPAVLFilterDoMatch(plannerElement1, plannerElement2) {
+      var avrFilter1 = plannerElement1.FilterAVR;
+      var avlFilter2 = plannerElement2.FilterAVL;
+
+      // An empty filter on either side means "no connector restriction" -> always dockable.
+      if (avlFilter2.length === 0 || avrFilter1.length === 0) return true;
+      for (var i = 0; i < avrFilter1.length; i++) {
+        for (var j = 0; j < avlFilter2.length; j++) {
+          if (avrFilter1[i] === avlFilter2[j]) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+  }, {
+    key: "checkDPAVRFilterDoMatch",
+    value: function checkDPAVRFilterDoMatch(plannerElement1, plannerElement2) {
+      var avlFilter1 = plannerElement1.FilterAVL;
+      var avrFilter2 = plannerElement2.FilterAVR;
+
+      // An empty filter on either side means "no connector restriction" -> always dockable.
+      if (avlFilter1.length === 0 || avrFilter2.length === 0) return true;
+      for (var i = 0; i < avlFilter1.length; i++) {
+        for (var j = 0; j < avrFilter2.length; j++) {
+          if (avlFilter1[i] === avrFilter2[j]) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    /**
+     * The central pairing gate: connector filters, counterpart type, both points free, layer inequality
+     * (with the catalog overrides ignoreLayerAVC / ignoreLayerAVOAVU / ignoreLayerAVNAVS) and number equality.
+     */
+  }, {
+    key: "checkDPsDoMatch",
+    value: function checkDPsDoMatch(dp1, dp2, sourcePlannerElement, targetElement) {
+      var avrDockable = this.checkDPAVRFilterDoMatch(sourcePlannerElement, targetElement);
+      var avlDockable = this.checkDPAVLFilterDoMatch(sourcePlannerElement, targetElement);
+      var refDPType = this.getReferenceDPType(dp1.Type);
+      if (refDPType === 'AVL' && !avlDockable) {
+        return false;
+      }
+      if (refDPType === 'AVR' && !avrDockable) {
+        return false;
+      }
+      if (dp2.Type !== refDPType) {
+        return false;
+      }
+      if (dp1.IsDocking || dp2.IsDocking) {
+        return false;
+      }
+      if (!dp1.IgnoreLayer || !dp2.IgnoreLayer) {
+        var doCheckLayer = true;
+        if (dp1.PlannerConfig.ignoreLayerAVC && (dp1.Type === 'AVC' || dp2.Type === 'AVC')) {
+          doCheckLayer = false;
+        }
+        if (dp1.PlannerConfig.ignoreLayerAVOAVU && (dp1.Type === 'AVO' || dp1.Type === 'AVU') && (dp2.Type === 'AVO' || dp2.Type === 'AVU')) {
+          doCheckLayer = false;
+        }
+        if (dp1.PlannerConfig.ignoreLayerAVNAVS && (dp1.Type === 'AVN' || dp1.Type === 'AVS') && (dp2.Type === 'AVN' || dp2.Type === 'AVS')) {
+          doCheckLayer = false;
+        }
+        if (doCheckLayer && dp2.Layer === dp1.Layer) {
+          return false;
+        }
+      }
+      if (!dp1.PlannerConfig.ignoreDockingNumber && dp1.HasNumber && dp2.HasNumber && dp1.Number !== dp2.Number) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "doDock",
+    value: function doDock(dp1, dp2, elemId1, elemId2) {
+      dp1.doDock(dp2, elemId2);
+      dp2.doDock(dp1, elemId1);
+    }
+
+    /**
+     * (Re-)initializes all docking points of an element from its SVG AV lines: saves the current docking state for
+     * later redocking, converts line coordinates to minBorder-corrected cm and derives each point's rotation.
+     */
+  }, {
+    key: "initDockingPointsFromSvg",
+    value: function initDockingPointsFromSvg(plannerElement, dockingVectors, minBorder, plannerConfig) {
+      plannerElement.saveCurrentDPState();
+      this.removeDockingPointRelations(plannerElement);
+      plannerElement.clearAllDockingPoints();
+      for (var i = 0; i < dockingVectors.length; i++) {
+        var dockingVector = dockingVectors[i];
+        var localWorldPos1 = new Vector2((dockingVector.x1 - minBorder.minX) / UNIT_RECALC, (dockingVector.y1 - minBorder.minY) / UNIT_RECALC);
+        var localWorldPos2 = new Vector2((dockingVector.x2 - minBorder.minX) / UNIT_RECALC, (dockingVector.y2 - minBorder.minY) / UNIT_RECALC);
+        var angle = this.getRotOfDP(localWorldPos1, localWorldPos2);
+        var dockingFilter = undefined;
+        if (dockingVector.dockingType === 'AVL') dockingFilter = plannerElement.getFilterAVL();else if (dockingVector.dockingType === 'AVR') dockingFilter = plannerElement.getFilterAVR();
+        var dockingPoint = new DockingPoint(plannerElement.getElementId(), dockingVector.dockingType, dockingVector.dockingName, new Vector3(localWorldPos1.x, 0, localWorldPos1.y), angle, plannerElement.Layer, plannerConfig, dockingFilter);
+        plannerElement.addDockingPoint(dockingPoint);
+      }
+    }
+
+    /** Removes all docking relations of the element, also on the docked counterparts (used when deleting an element). */
+  }, {
+    key: "removeDockingPointRelations",
+    value: function removeDockingPointRelations(plannerElement) {
+      var dockingPoints = plannerElement.getDockingPoints();
+      for (var i = 0; i < dockingPoints.length; i++) {
+        var dockingPoint = dockingPoints[i];
+        if (dockingPoint.IsDocking) {
+          var refDockingPoint = dockingPoint.OnDP;
+          refDockingPoint.undock();
+          dockingPoint.undock();
+        }
+      }
+    }
+
+    /**
+     * Removes all docking relations of the given types, also on the docked counterparts.
+     * @returns the element ids that lost a relation
+     */
+  }, {
+    key: "removeDockingPointRelationsByType",
+    value: function removeDockingPointRelationsByType(plannerElement, dpTypeList) {
+      var undockedFromElements = [];
+      var dockingPoints = plannerElement.getDockingPoints();
+      for (var i = 0; i < dockingPoints.length; i++) {
+        var dockingPoint = dockingPoints[i];
+        if (dpTypeList.indexOf(dockingPoint.Type) > -1 && dockingPoint.IsDocking) {
+          var refDockingPoint = dockingPoint.OnDP;
+          undockedFromElements.push(refDockingPoint.ElementId);
+          refDockingPoint.undock();
+          dockingPoint.undock();
+        }
+      }
+      return undockedFromElements;
+    }
+
+    /**
+     * Searches all dockable pairs between the source element and the targets within the given ground-plane distance,
+     * keeping only the nearest pair per source docking point type.
+     * @param autoDockingDistance 0 -> never dock, Infinity -> dock at any distance
+     */
+  }, {
+    key: "searchDockableElementsInArea",
+    value: function searchDockableElementsInArea(sourceElement, targetElements, autoDockingDistance) {
+      var sourceDPs = sourceElement.getAllDockingPoints();
+      var dockableDPPairs = new Map();
+      for (var i = 0; i < targetElements.length; i++) {
+        var targetElement = targetElements[i];
+        if (sourceElement.getElementId() === targetElement.getElementId()) continue;
+        for (var di = 0; di < sourceDPs.length; di++) {
+          var sourceDP = sourceDPs[di];
+          var targetType = this.getReferenceDPType(sourceDP.Type);
+          var targetDPs = targetElement.getFreeDockingPointsByType(targetType);
+          for (var j = 0; j < targetDPs.length; j++) {
+            var targetDP = targetDPs[j];
+            if (!this.checkDPsDoMatch(sourceDP, targetDP, sourceElement, targetElement)) continue;
+            var worldPosSourceDP = sourceElement.getWorldPosOfDP(sourceDP.DpId);
+            var worldPosTargetDP = targetElement.getWorldPosOfDP(targetDP.DpId);
+            var distance = Math.sqrt(Math.pow(worldPosSourceDP.x - worldPosTargetDP.x, 2) + Math.pow(worldPosSourceDP.z - worldPosTargetDP.z, 2));
+            if (autoDockingDistance !== 0 && (autoDockingDistance === Infinity || distance < autoDockingDistance)) {
+              var existingPair = dockableDPPairs.get(sourceDP.Type);
+              if (!existingPair || distance < existingPair.distance) {
+                dockableDPPairs.set(sourceDP.Type, {
+                  sourceDP: sourceDP,
+                  targetDP: targetDP,
+                  distance: distance
+                });
+              }
+            }
+          }
+        }
+      }
+      return dockableDPPairs;
+    }
+
+    /**
+     * Tries to dock the source element with a docking point of the given type onto any of the target elements.
+     * Non-accessories never dock onto foreign accessories; accessories only dock onto articles listing their codex.
+     * @returns the docked source docking point, or false
+     */
+  }, {
+    key: "tryDockElement",
+    value: function tryDockElement(sourcePlannerElement, sourceDPType, targetElements) {
+      var dockingPoints = sourcePlannerElement.getDockingPointsByType(sourceDPType);
+      if (!dockingPoints) {
+        return false;
+      }
+      var refDPType = this.getReferenceDPType(sourceDPType);
+      for (var i = 0; i < targetElements.length; i++) {
+        var targetElement = targetElements[i];
+        if (targetElement.ElementId === sourcePlannerElement.ElementId) continue;
+        if (!sourcePlannerElement.IsAccessoire && targetElement.IsAccessoire && targetElement.getParentElementId() !== sourcePlannerElement.getElementId()) continue;
+        if (sourcePlannerElement.IsAccessoire && !targetElement.getAccessoires().includes(sourcePlannerElement.ArticleCodex)) continue;
+        var targetDockingPoints = targetElement.getDockingPointsByType(refDPType);
+        if (sourcePlannerElement.getIsDockedAccessoire() || sourcePlannerElement.IsAccessoire) {
+          targetDockingPoints = this.sortDockingPoints('LEFT_TO_RIGHT', targetDockingPoints);
+        }
+        if (!targetDockingPoints) continue;
+        for (var j = 0; j < targetDockingPoints.length; j++) {
+          var targetDockingPoint = targetDockingPoints[j];
+          for (var dpNr = 0; dpNr < dockingPoints.length; dpNr++) {
+            var dockingPoint = dockingPoints[dpNr];
+            if (this.checkDPsDoMatch(dockingPoint, targetDockingPoint, sourcePlannerElement, targetElement)) {
+              this.doDock(dockingPoint, targetDockingPoint, sourcePlannerElement.ElementId, targetElement.ElementId);
+              return dockingPoint;
+            }
+          }
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Tries to dock the source element onto one specific docking point of the target element.
+     * @returns the docked source docking point, or false
+     */
+  }, {
+    key: "tryDockElementToDP",
+    value: function tryDockElementToDP(sourcePlannerElement, targetElement, targetDP) {
+      var sourceDPType = this.getReferenceDPType(targetDP.Type);
+      var dockingPoints = sourcePlannerElement.getFreeDockingPointsByType(sourceDPType);
+      if (!dockingPoints) {
+        return false;
+      }
+      for (var i = 0; i < dockingPoints.length; i++) {
+        if (this.checkDPsDoMatch(dockingPoints[i], targetDP, sourcePlannerElement, targetElement)) {
+          this.doDock(dockingPoints[i], targetDP, sourcePlannerElement.ElementId, targetElement.ElementId);
+          return dockingPoints[i];
+        }
+      }
+      return false;
+    }
+
+    /** Tries to dock one specific pair of docking points. */
+  }, {
+    key: "tryDockElementDPToDP",
+    value: function tryDockElementDPToDP(sourcePlannerElement, targetElement, sourceDP, targetDP) {
+      if (this.checkDPsDoMatch(sourceDP, targetDP, sourcePlannerElement, targetElement)) {
+        this.doDock(sourceDP, targetDP, sourcePlannerElement.getElementId(), targetElement.getElementId());
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Restores docking relations after one or more SVGs were reloaded, based on the state saved by
+     * saveCurrentDPState, including the fallback for changed docking point numbers.
+     * @returns the elements that lost their docking relation
+     */
+  }, {
+    key: "updateDockingRelations",
+    value: function updateDockingRelations(plannerElements) {
+      var sortedPlannerElementsByPosNr = [];
+      var accessoryElements = [];
+      plannerElements.forEach(function (plannerElement) {
+        if (!plannerElement.IsDockedAccessoire) {
+          sortedPlannerElementsByPosNr[plannerElement.PosNr - 1] = plannerElement;
+        } else {
+          accessoryElements.push(plannerElement);
+        }
+      });
+      sortedPlannerElementsByPosNr = sortedPlannerElementsByPosNr.concat(accessoryElements);
+      var elementsLostDockingRelation = [];
+      for (var i = 0; i < sortedPlannerElementsByPosNr.length; i++) {
+        if (!sortedPlannerElementsByPosNr[i]) continue;
+        var element = sortedPlannerElementsByPosNr[i];
+        var tempDPs = element.getTempDockingPoints();
+        for (var j = 0; j < tempDPs.length; j++) {
+          var tempDP = tempDPs[j];
+          if (!tempDP.IsDocking || !tempDP.OnElementId) continue;
+          var dp = element.getDockingPointById(tempDP.DpId);
+          if (dp == undefined) {
+            // The previously docked point no longer exists after the reload.
+            var targetElement = plannerElements.get(tempDP.OnElementId);
+
+            // A resize can renumber connectors (AVO_1/AVU_1 becoming AVO_2/AVU_2), so when both sides have
+            // exactly one free point of the type, redock those.
+            var dockingPointsCurElement = element.getFreeDockingPointsByType(tempDP.Type);
+            if (dockingPointsCurElement.length === 1) {
+              var dockingPointsToDockElement = targetElement === null || targetElement === void 0 ? void 0 : targetElement.getFreeDockingPointsByType(this.getReferenceDPType(tempDP.Type));
+              if (targetElement && (dockingPointsToDockElement === null || dockingPointsToDockElement === void 0 ? void 0 : dockingPointsToDockElement.length) === 1) {
+                this.tryDockElementDPToDP(element, targetElement, dockingPointsCurElement[0], dockingPointsToDockElement[0]);
+                continue;
+              }
+            }
+            if (targetElement) elementsLostDockingRelation.push(targetElement);
+            continue;
+          }
+          if (plannerElements.has(tempDP.OnElementId)) {
+            var _targetElement = plannerElements.get(tempDP.OnElementId);
+            var targetDP = tempDP.OnDP ? _targetElement === null || _targetElement === void 0 ? void 0 : _targetElement.getDockingPointById(tempDP.OnDP.DpId) : undefined;
+            if (_targetElement && targetDP) this.tryDockElementDPToDP(element, _targetElement, dp, targetDP);
+          }
+        }
+      }
+      for (var _i = 0; _i < sortedPlannerElementsByPosNr.length; _i++) {
+        if (sortedPlannerElementsByPosNr[_i]) sortedPlannerElementsByPosNr[_i].clearTempDockingPoints();
+      }
+      return elementsLostDockingRelation;
+    }
+
+    /**
+     * Docks the source's free docking point of the given type to the nearest matching point of the target element
+     * (used when initializing a planning where only the pair of elements and the type are known).
+     */
+  }, {
+    key: "initDockingPointRelationByArea",
+    value: function initDockingPointRelationByArea(sourcePlannerElement, targetPlannerElement, sourceDPType) {
+      var freeSourceDPs = sourcePlannerElement.getFreeDockingPointsByType(sourceDPType);
+      if (freeSourceDPs.length === 0) return;
+      var allDockingPairs = this.searchDockableElementsInArea(sourcePlannerElement, [targetPlannerElement], Infinity);
+      var dockingPair = allDockingPairs.get(sourceDPType);
+      if (!dockingPair) return;
+      var success = this.tryDockElementDPToDP(sourcePlannerElement, targetPlannerElement, dockingPair.sourceDP, dockingPair.targetDP);
+      if (!success) {
+        getPlanner2DLogger().debug('Error when initializing docking Points. Two dockingpoints could not be matched. sourceDP: ' + dockingPair.sourceDP.DpId + '; sourceElementId: ' + dockingPair.sourceDP.ElementId + '; targetDP: ' + dockingPair.targetDP.DpId + ' targetElemId: ' + dockingPair.targetDP.ElementId);
+      }
+    }
+
+    /** True when the two elements are docked to each other. */
+  }, {
+    key: "checkElementsAreDocking",
+    value: function checkElementsAreDocking(element1, element2) {
+      var allDockingDockingPoints = element1.getDockingDockingPoints();
+      for (var i = 0; i < allDockingDockingPoints.length; i++) {
+        if (allDockingDockingPoints[i].OnElementId === element2.getElementId()) return true;
+      }
+      return false;
+    }
+  }]);
+}();
+
+/** Shared instance; the handler carries no state, so one serves all scenes. */
+var dockingPointHandler = new DockingPointHandler();
+
+/** The transform-relevant surface of a planner element. */
+
+/**
+ * World transform of an element after docking its point `dp` onto `refDP` of `refElement`: the rotation is
+ * refElement.RotDeg + refDP.RotDeg - dp.RotDeg, the position aligns the two docking points via their rotated
+ * local vectors. A docking point's LocalWorldPos is OLF-corner-relative when the element has an OLF polygon,
+ * hence the OLT-corner conversion for the ignore-OLF variant.
+ */
+function computeDockedTransform(refElement, refDP, element, dp) {
+  var refDPLocalOlt = refElement.HasOLFPolygon ? new Vector2(refDP.LocalWorldPos.x - refElement.getOltLeft(), refDP.LocalWorldPos.z - refElement.getOltTop()) : new Vector2(refDP.LocalWorldPos.x, refDP.LocalWorldPos.z);
+  var newDPLocalOlt = element.HasOLFPolygon ? new Vector2(dp.LocalWorldPos.x - element.getOltLeft(), dp.LocalWorldPos.z - element.getOltTop()) : new Vector2(dp.LocalWorldPos.x, dp.LocalWorldPos.z);
+  var rotatedLocalRefDP = Vector2.rotateOrigin(new Vector2(refDP.LocalWorldPos.x, refDP.LocalWorldPos.z), refElement.RotDeg);
+  var rotDeg = refElement.RotDeg + refDP.RotDeg - dp.RotDeg;
+  var refWorldPosCor = refElement.WorldPosCorner;
+  // Without an OLF there is no OLF/OLT split, so both alignments share the same corner.
+  var refWorldPosCorIgnoreOLF = refElement.HasOLFPolygon ? refElement.WorldPosCornerIgnoreOLF : refWorldPosCor;
+  var rotatedLocalDP2D = Vector2.rotateOrigin(new Vector2(dp.LocalWorldPos.x, dp.LocalWorldPos.z), rotDeg);
+  var worldPosCorner = new Vector3(refWorldPosCor.x + rotatedLocalRefDP.x - rotatedLocalDP2D.x, refWorldPosCor.y + refDP.LocalWorldPos.y - dp.LocalWorldPos.y, refWorldPosCor.z + rotatedLocalRefDP.y - rotatedLocalDP2D.y);
+  var rotatedRefDPOlt = Vector2.rotateOrigin(refDPLocalOlt, refElement.RotDeg);
+  var rotatedNewDPOlt = Vector2.rotateOrigin(newDPLocalOlt, rotDeg);
+  var worldPosCornerIgnoreOLF = new Vector3(refWorldPosCorIgnoreOLF.x + rotatedRefDPOlt.x - rotatedNewDPOlt.x, refWorldPosCorIgnoreOLF.y + refDP.LocalWorldPos.y - dp.LocalWorldPos.y, refWorldPosCorIgnoreOLF.z + rotatedRefDPOlt.y - rotatedNewDPOlt.y);
+  return {
+    rotDeg: rotDeg,
+    worldPosCorner: worldPosCorner,
+    worldPosCornerIgnoreOLF: worldPosCornerIgnoreOLF
+  };
+}
+
+/**
+ * True when the two segments properly intersect, endpoint touches included. Parallel and collinear-overlapping
+ * segments report false on purpose (fabric reported those as 'Parallel'/'Coincident'), perpendicular corner
+ * touches count as an intersection.
+ */
+function segmentsIntersect(a1, a2, b1, b2) {
+  var uaT = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x);
+  var ubT = (a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x);
+  var uB = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);
+  if (uB === 0) return false;
+  var ua = uaT / uB;
+  var ub = ubT / uB;
+  return ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1;
+}
+
+/** True when any edge of polygon1 intersects any edge of polygon2. */
+function polygonEdgesIntersect(polygonPoints1, polygonPoints2) {
+  for (var i = 0; i < polygonPoints1.length; i++) {
+    var start1 = polygonPoints1[i];
+    var end1 = polygonPoints1[(i + 1) % polygonPoints1.length];
+    for (var j = 0; j < polygonPoints2.length; j++) {
+      var start2 = polygonPoints2[j];
+      var end2 = polygonPoints2[(j + 1) % polygonPoints2.length];
+      if (segmentsIntersect(start1, end1, start2, end2)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * True when polygon1 lies completely inside polygon2 (ray casting with a horizontal ray per vertex),
+ * including the legacy early exit as soon as vertices fall on both sides.
+ */
+function polygonInsidePolygon(polygonPoints1, polygonPoints2) {
+  var pointOutsideCount = 0;
+  var pointInsideCount = 0;
+  for (var i = 0; i < polygonPoints1.length; i++) {
+    var start1 = polygonPoints1[i];
+    var end1 = new Vector2(start1.x + 999999, start1.y);
+    var intersectionCount = 0;
+    for (var j = 0; j < polygonPoints2.length; j++) {
+      var start2 = polygonPoints2[j];
+      var end2 = polygonPoints2[(j + 1) % polygonPoints2.length];
+      if (segmentsIntersect(start1, end1, start2, end2)) intersectionCount++;
+    }
+    if (intersectionCount % 2 === 0) {
+      pointOutsideCount++;
+    } else {
+      pointInsideCount++;
+    }
+    if (pointOutsideCount > 0 && pointInsideCount > 0) return false;
+  }
+  return pointInsideCount === polygonPoints1.length;
+}
+
+/**
+ * Core collision decision of the 2D planner: when the bounding-box outlines intersect, the detail polygons
+ * decide; otherwise one outline lying completely inside the other counts as collision. Layer filtering
+ * stays with the caller.
+ */
+function outlinesCollide(bboxOutline1, bboxOutline2, detailPolygon1, detailPolygon2) {
+  if (polygonEdgesIntersect(bboxOutline1, bboxOutline2)) {
+    return polygonEdgesIntersect(detailPolygon1, detailPolygon2);
+  }
+  return polygonInsidePolygon(bboxOutline1, bboxOutline2);
+}
+
+/** Article-level data of a testbed element. */
+
+/**
+ * Reference implementation of the element surface the docking logic needs — no DivaSet, no engine.
+ * WorldPosCorner is the world position of the SVG's minBorder-corrected local origin, matching how docking
+ * point LocalWorldPos values are stored; the ignore-OLF corner tracks the OLT origin.
+ */
+var SimplePlannerElement = /*#__PURE__*/function () {
+  function SimplePlannerElement(elementId, data) {
+    var _data$layer, _data$articleCodex, _data$isAccessoire, _data$filterAVL, _data$filterAVR, _data$parentElementId, _data$accessoires;
+    _classCallCheck__default["default"](this, SimplePlannerElement);
+    _defineProperty__default["default"](this, "ElementId", void 0);
+    _defineProperty__default["default"](this, "Layer", void 0);
+    _defineProperty__default["default"](this, "ArticleCodex", void 0);
+    _defineProperty__default["default"](this, "IsAccessoire", void 0);
+    _defineProperty__default["default"](this, "FilterAVL", void 0);
+    _defineProperty__default["default"](this, "FilterAVR", void 0);
+    _defineProperty__default["default"](this, "PosNr", void 0);
+    _defineProperty__default["default"](this, "IsDockedAccessoire", false);
+    _defineProperty__default["default"](this, "RotDeg", 0);
+    _defineProperty__default["default"](this, "WorldPosCorner", new Vector3(0, 0, 0));
+    _defineProperty__default["default"](this, "WorldPosCornerIgnoreOLF", new Vector3(0, 0, 0));
+    _defineProperty__default["default"](this, "HasOLFPolygon", false);
+    _defineProperty__default["default"](this, "oltLeftCm", 0);
+    _defineProperty__default["default"](this, "oltTopCm", 0);
+    _defineProperty__default["default"](this, "parentElementId", void 0);
+    _defineProperty__default["default"](this, "accessoires", void 0);
+    _defineProperty__default["default"](this, "dockingPoints", []);
+    _defineProperty__default["default"](this, "tempDockingPoints", []);
+    this.ElementId = elementId;
+    this.PosNr = elementId;
+    this.Layer = (_data$layer = data === null || data === void 0 ? void 0 : data.layer) !== null && _data$layer !== void 0 ? _data$layer : 0;
+    this.ArticleCodex = (_data$articleCodex = data === null || data === void 0 ? void 0 : data.articleCodex) !== null && _data$articleCodex !== void 0 ? _data$articleCodex : "ARTICLE-".concat(elementId);
+    this.IsAccessoire = (_data$isAccessoire = data === null || data === void 0 ? void 0 : data.isAccessoire) !== null && _data$isAccessoire !== void 0 ? _data$isAccessoire : false;
+    this.FilterAVL = (_data$filterAVL = data === null || data === void 0 ? void 0 : data.filterAVL) !== null && _data$filterAVL !== void 0 ? _data$filterAVL : [];
+    this.FilterAVR = (_data$filterAVR = data === null || data === void 0 ? void 0 : data.filterAVR) !== null && _data$filterAVR !== void 0 ? _data$filterAVR : [];
+    this.parentElementId = (_data$parentElementId = data === null || data === void 0 ? void 0 : data.parentElementId) !== null && _data$parentElementId !== void 0 ? _data$parentElementId : -1;
+    this.accessoires = (_data$accessoires = data === null || data === void 0 ? void 0 : data.accessoires) !== null && _data$accessoires !== void 0 ? _data$accessoires : [];
+  }
+
+  /** Registers the OLT origin offset within the OLF (cm) and flags the element as OLF-carrying. */
+  return _createClass__default["default"](SimplePlannerElement, [{
+    key: "setupOlfOffset",
+    value: function setupOlfOffset(oltLeftCm, oltTopCm) {
+      this.HasOLFPolygon = true;
+      this.oltLeftCm = oltLeftCm;
+      this.oltTopCm = oltTopCm;
+    }
+  }, {
+    key: "getElementId",
+    value: function getElementId() {
+      return this.ElementId;
+    }
+  }, {
+    key: "getParentElementId",
+    value: function getParentElementId() {
+      return this.parentElementId;
+    }
+  }, {
+    key: "getAccessoires",
+    value: function getAccessoires() {
+      return this.accessoires;
+    }
+  }, {
+    key: "getIsDockedAccessoire",
+    value: function getIsDockedAccessoire() {
+      return this.IsDockedAccessoire;
+    }
+  }, {
+    key: "saveCurrentDPState",
+    value: function saveCurrentDPState() {
+      if (this.dockingPoints.length === 0) return;
+      this.tempDockingPoints = this.dockingPoints.map(function (dockingPoint) {
+        return dockingPoint.clone();
+      });
+    }
+  }, {
+    key: "clearAllDockingPoints",
+    value: function clearAllDockingPoints() {
+      this.dockingPoints = [];
+    }
+  }, {
+    key: "addDockingPoint",
+    value: function addDockingPoint(dockingPoint) {
+      this.dockingPoints.push(dockingPoint);
+    }
+  }, {
+    key: "getDockingPoints",
+    value: function getDockingPoints() {
+      return this.dockingPoints;
+    }
+  }, {
+    key: "getAllDockingPoints",
+    value: function getAllDockingPoints() {
+      return this.dockingPoints;
+    }
+  }, {
+    key: "getDockingPointsByType",
+    value: function getDockingPointsByType(type) {
+      return this.dockingPoints.filter(function (dockingPoint) {
+        return dockingPoint.Type === type;
+      });
+    }
+  }, {
+    key: "getFreeDockingPointsByType",
+    value: function getFreeDockingPointsByType(type) {
+      return this.dockingPoints.filter(function (dockingPoint) {
+        return dockingPoint.Type === type && !dockingPoint.IsDocking;
+      });
+    }
+  }, {
+    key: "getDockingPointById",
+    value: function getDockingPointById(dpId) {
+      return this.dockingPoints.find(function (dockingPoint) {
+        return dockingPoint.DpId === dpId;
+      });
+    }
+  }, {
+    key: "getDockingDockingPoints",
+    value: function getDockingDockingPoints() {
+      return this.dockingPoints.filter(function (dockingPoint) {
+        return dockingPoint.IsDocking;
+      });
+    }
+  }, {
+    key: "getFilterAVL",
+    value: function getFilterAVL() {
+      return this.FilterAVL.length ? this.FilterAVL : undefined;
+    }
+  }, {
+    key: "getFilterAVR",
+    value: function getFilterAVR() {
+      return this.FilterAVR.length ? this.FilterAVR : undefined;
+    }
+  }, {
+    key: "getWorldPosOfDP",
+    value: function getWorldPosOfDP(dpId) {
+      var dockingPoint = this.getDockingPointById(dpId);
+      if (!dockingPoint) return new Vector3(0, 0, 0);
+      var rotated = Vector2.rotateOrigin(new Vector2(dockingPoint.LocalWorldPos.x, dockingPoint.LocalWorldPos.z), this.RotDeg);
+      return new Vector3(this.WorldPosCorner.x + rotated.x, this.WorldPosCorner.y, this.WorldPosCorner.z + rotated.y);
+    }
+  }, {
+    key: "getTempDockingPoints",
+    value: function getTempDockingPoints() {
+      return this.tempDockingPoints;
+    }
+  }, {
+    key: "clearTempDockingPoints",
+    value: function clearTempDockingPoints() {
+      this.tempDockingPoints = [];
+    }
+  }, {
+    key: "getOltLeft",
+    value: function getOltLeft() {
+      return this.oltLeftCm;
+    }
+  }, {
+    key: "getOltTop",
+    value: function getOltTop() {
+      return this.oltTopCm;
+    }
+  }]);
+}();
+
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var DEFAULT_DOCKING_CONFIG = {
+  ignoreLayerAVC: false,
+  ignoreLayerAVOAVU: false,
+  ignoreLayerAVNAVS: false,
+  ignoreDockingNumber: false
+};
+var DOCK_TYPE_TRY_ORDER = ['AVL', 'AVR', 'AVO', 'AVU', 'AVN', 'AVS', 'AVC'];
+
+/**
+ * Standalone docking testbed: article SVGs in, docking points, pairings and world positions out. No catalog
+ * API, no browser, no engine. In Node a jsdom window is loaded lazily; configureDom is only needed for a custom DOM.
+ */
+var DockingScene = /*#__PURE__*/function () {
+  function DockingScene(options) {
+    _classCallCheck__default["default"](this, DockingScene);
+    _defineProperty__default["default"](this, "handler", new DockingPointHandler());
+    _defineProperty__default["default"](this, "dockingConfig", void 0);
+    _defineProperty__default["default"](this, "elements", new Map());
+    _defineProperty__default["default"](this, "nextElementId", 1);
+    this.dockingConfig = _objectSpread(_objectSpread({}, DEFAULT_DOCKING_CONFIG), options === null || options === void 0 ? void 0 : options.dockingConfig);
+  }
+
+  /** Parses the article SVG (docking lines, minBorder, OLT/OLF geometry) and adds it as a new element at the world origin. */
+  return _createClass__default["default"](DockingScene, [{
+    key: "addArticle",
+    value: function addArticle(svg, data) {
+      var element = new SimplePlannerElement(this.nextElementId++, data);
+      var olt = getOltGeometry(svg);
+      var olf = getOlfGeometry(svg);
+      if (olt && olf) {
+        element.setupOlfOffset((olt.x - olf.minX) / UNIT_RECALC, (olt.y - olf.minY) / UNIT_RECALC);
+      }
+      this.handler.initDockingPointsFromSvg(element, getDockingPointLines(svg), getMinBorder(svg), this.dockingConfig);
+      this.elements.set(element.ElementId, element);
+      return element;
+    }
+  }, {
+    key: "getElement",
+    value: function getElement(elementId) {
+      return this.elements.get(elementId);
+    }
+  }, {
+    key: "getElements",
+    value: function getElements() {
+      return _toConsumableArray__default["default"](this.elements.values());
+    }
+
+    /**
+     * Tries to dock the source element onto the target and, on success, moves the source to its docked world transform.
+     * Without an explicit sourceDpType all types are tried in planner order (AVL first).
+     */
+  }, {
+    key: "tryDock",
+    value: function tryDock(source, target, sourceDpType) {
+      var typesToTry = sourceDpType ? [sourceDpType] : DOCK_TYPE_TRY_ORDER;
+      for (var _i = 0, _typesToTry = typesToTry; _i < _typesToTry.length; _i++) {
+        var type = _typesToTry[_i];
+        var sourceDP = this.handler.tryDockElement(source, type, [target]);
+        if (!sourceDP) continue;
+        var targetDP = sourceDP.OnDP;
+        var transform = computeDockedTransform(target, targetDP, source, sourceDP);
+        source.RotDeg = transform.rotDeg;
+        source.WorldPosCorner = transform.worldPosCorner;
+        source.WorldPosCornerIgnoreOLF = transform.worldPosCornerIgnoreOLF;
+        return {
+          docked: true,
+          dockingType: sourceDP.Type,
+          sourceDpId: sourceDP.DpId,
+          targetDpId: targetDP.DpId,
+          rotDeg: transform.rotDeg,
+          worldPosCorner: transform.worldPosCorner
+        };
+      }
+      return {
+        docked: false
+      };
+    }
+
+    /** All free (not yet docked) docking points of the element. */
+  }, {
+    key: "freeDockingPoints",
+    value: function freeDockingPoints(element) {
+      return element.getAllDockingPoints().filter(function (dockingPoint) {
+        return !dockingPoint.IsDocking;
+      });
+    }
+
+    /** All docked pairs in the scene, one entry per relation; the source side is the element that docked onto the other. */
+  }, {
+    key: "dockedPairs",
+    value: function dockedPairs() {
+      var pairs = [];
+      var seen = new Set();
+      var _iterator = _createForOfIteratorHelper(this.elements.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var element = _step.value;
+          var _iterator2 = _createForOfIteratorHelper(element.getDockingDockingPoints()),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var _dockingPoint$OnDP, _dockingPoint$OnDP2;
+              var dockingPoint = _step2.value;
+              var key = [element.ElementId, dockingPoint.DpId, dockingPoint.OnElementId, (_dockingPoint$OnDP = dockingPoint.OnDP) === null || _dockingPoint$OnDP === void 0 ? void 0 : _dockingPoint$OnDP.DpId].join('|');
+              var reverseKey = [dockingPoint.OnElementId, (_dockingPoint$OnDP2 = dockingPoint.OnDP) === null || _dockingPoint$OnDP2 === void 0 ? void 0 : _dockingPoint$OnDP2.DpId, element.ElementId, dockingPoint.DpId].join('|');
+              if (seen.has(reverseKey)) continue;
+              seen.add(key);
+              pairs.push({
+                sourceElementId: element.ElementId,
+                sourceDpId: dockingPoint.DpId,
+                targetElementId: dockingPoint.OnElementId,
+                targetDpId: dockingPoint.OnDP.DpId
+              });
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return pairs;
+    }
+  }]);
+}();
+
+exports.DOCKING_TYPES = DOCKING_TYPES;
+exports.DockingPoint = DockingPoint;
+exports.DockingPointHandler = DockingPointHandler;
+exports.DockingScene = DockingScene;
+exports.SimplePlannerElement = SimplePlannerElement;
+exports.UNIT_RECALC = UNIT_RECALC;
+exports.Vector2 = Vector2;
+exports.Vector3 = Vector3;
+exports.computeDockedTransform = computeDockedTransform;
+exports.configureDom = configureDom;
+exports.dockingPointHandler = dockingPointHandler;
+exports.getBoundingBoxOfPoints = getBoundingBoxOfPoints;
+exports.getContentBounds = getContentBounds;
+exports.getDockingPointLines = getDockingPointLines;
+exports.getMinBorder = getMinBorder;
+exports.getOlfGeometry = getOlfGeometry;
+exports.getOltGeometry = getOltGeometry;
+exports.getPlanner2DLogger = getPlanner2DLogger;
+exports.getPolygonPoints = getPolygonPoints;
+exports.getRootSize = getRootSize;
+exports.isDockingType = isDockingType;
+exports.outlinesCollide = outlinesCollide;
+exports.parsePathCommands = parsePathCommands;
+exports.parseXml = parseXml;
+exports.pathBoundingBox = pathBoundingBox;
+exports.polygonEdgesIntersect = polygonEdgesIntersect;
+exports.polygonInsidePolygon = polygonInsidePolygon;
+exports.removeMask = removeMask;
+exports.removeOlf = removeOlf;
+exports.segmentsIntersect = segmentsIntersect;
+exports.serializeXml = serializeXml;
+exports.setPlanner2DLogger = setPlanner2DLogger;
+exports.stretchArticleSvg = stretchArticleSvg;