@seatlayer/core 0.29.0 → 0.30.0

package/dist/chunk-FGS67GT3.js

@@ -0,0 +1,1252 @@
+// src/core/types.ts
+var ACCESSIBILITY_TYPES = [
+  { key: "wheelchair", label: "Wheelchair space", short: "Wheelchair", icon: "\u267F" },
+  { key: "companion", label: "Companion seat", short: "Companion", icon: "\u{1F9D1}\u200D\u{1F91D}\u200D\u{1F9D1}" },
+  { key: "semi-ambulatory", label: "Semi-ambulatory (limited mobility)", short: "Limited mobility", icon: "\u{1F9AF}" },
+  { key: "hearing", label: "Assistive listening", short: "Hearing", icon: "\u{1F9BB}" },
+  { key: "cart", label: "CART live-caption view", short: "CART captions", icon: "CC" },
+  { key: "sign-language", label: "Sign-language view", short: "Sign language", icon: "\u{1F91F}" },
+  { key: "plus-size", label: "Plus-size seat", short: "Plus-size", icon: "\u{1F4BA}" },
+  { key: "lift-armrest", label: "Lift-up armrest", short: "Lift armrest", icon: "\u2195\uFE0F" }
+];
+var ACCESSIBILITY_LABEL = new Map(ACCESSIBILITY_TYPES.map((a) => [a.key, a]));
+function accessibilityMeta(key) {
+  return ACCESSIBILITY_LABEL.get(key);
+}
+var ACCESSIBILITY_RING_COLOR = {
+  wheelchair: "#3b82f6",
+  companion: "#8b5cf6",
+  "semi-ambulatory": "#0ea5e9",
+  hearing: "#14b8a6",
+  cart: "#7c3aed",
+  "sign-language": "#f59e0b",
+  "plus-size": "#ec4899",
+  "lift-armrest": "#22c55e"
+};
+function accessibilityRingColor(types) {
+  const primary = types?.[0];
+  return primary && ACCESSIBILITY_RING_COLOR[primary] || "#3b82f6";
+}
+var LABEL_STYLE_MIN_SIZE = 8;
+var LABEL_STYLE_MAX_SIZE = 24;
+var SURROUNDINGS_SHAPE_ROLES = [
+  "reference-focal",
+  "bar",
+  "entrance",
+  "exit",
+  "restroom",
+  "screen",
+  "sound",
+  "concession",
+  "coat",
+  "wall"
+];
+var SURROUNDINGS_SHAPE_ROLE_SET = new Set(SURROUNDINGS_SHAPE_ROLES);
+function layerOf(obj) {
+  switch (obj.type) {
+    case "row":
+    case "table":
+    case "gaArea":
+    case "booth":
+    case "section":
+      return "interactive";
+    // Raster décor follows its explicit authored z-layer. Absence retains the
+    // legacy Background default; bitmap content is never guessed semantically.
+    case "decorImage":
+      return obj.layer === "foreground" ? "foreground" : "background";
+    // Source-backed focal geometry and curated venue landmarks help an author
+    // orient around the sellable plan. A stage and an ordinary authored shape
+    // remain Background even when they carry an arbitrary/custom role.
+    case "shape":
+      return obj.role && SURROUNDINGS_SHAPE_ROLE_SET.has(obj.role) ? "surroundings" : "background";
+    // Free text — including semantic icon text — is background furniture.
+    case "text":
+      return "background";
+    default:
+      return "interactive";
+  }
+}
+var CHART_STORAGE_KEY = "seatmap.chart";
+
+// src/core/units.ts
+var METRES_PER_CHART_UNIT = 0.55 / 24;
+var CHART_UNITS_PER_METRE = 1 / METRES_PER_CHART_UNIT;
+var LIFT_PER_STEP_WORLD = 58;
+var TIER_HEIGHT_M = LIFT_PER_STEP_WORLD * METRES_PER_CHART_UNIT;
+var SECTION_ELEVATION_TIER_MIN = 0;
+var SECTION_ELEVATION_TIER_MAX = 3;
+var SECTION_HEIGHT_MIN_M = 0;
+var SECTION_HEIGHT_MAX_M = 120;
+var SECTION_RAKE_MIN_DEG = 0;
+var SECTION_RAKE_MAX_DEG = 45;
+var LEGACY_SECTION_ELEVATION_TIER_MAX = 7;
+var SEATED_EYE_HEIGHT_M = 1.2;
+function finiteClamped(value, min, max, fallback) {
+  return Number.isFinite(value) ? Math.max(min, Math.min(max, value)) : fallback;
+}
+function sectionElevationTier(value) {
+  if (!Number.isFinite(value)) return SECTION_ELEVATION_TIER_MIN;
+  return Math.max(
+    SECTION_ELEVATION_TIER_MIN,
+    Math.min(SECTION_ELEVATION_TIER_MAX, Math.round(value))
+  );
+}
+function compatibleAutomaticTier(value) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) return 0;
+  if (value <= LEGACY_SECTION_ELEVATION_TIER_MAX) return value;
+  return SECTION_ELEVATION_TIER_MAX;
+}
+function sectionGeometry(section, context = {}) {
+  const floorBaseHeightM = finiteClamped(
+    context.floorBaseHeightM,
+    SECTION_HEIGHT_MIN_M,
+    SECTION_HEIGHT_MAX_M,
+    0
+  );
+  const automaticHeight = Math.min(
+    SECTION_HEIGHT_MAX_M,
+    floorBaseHeightM + compatibleAutomaticTier(section.elevation) * TIER_HEIGHT_M
+  );
+  const height = section.height === void 0 ? automaticHeight : finiteClamped(section.height, SECTION_HEIGHT_MIN_M, SECTION_HEIGHT_MAX_M, automaticHeight);
+  const rake = finiteClamped(section.rake, SECTION_RAKE_MIN_DEG, SECTION_RAKE_MAX_DEG, 0);
+  return { height, rake };
+}
+
+// src/core/complexGeometry.ts
+function cubicPoint(path, t) {
+  const u = 1 - t;
+  const a = u * u * u;
+  const b = 3 * u * u * t;
+  const c = 3 * u * t * t;
+  const d = t * t * t;
+  return {
+    x: a * path.start.x + b * path.control1.x + c * path.control2.x + d * path.end.x,
+    y: a * path.start.y + b * path.control1.y + c * path.control2.y + d * path.end.y
+  };
+}
+function distributeAlongCubic(path, count, resolution = 192) {
+  if (!Number.isInteger(count) || count < 1) throw new Error("Path point count must be a positive integer");
+  if (count === 1) return [cubicPoint(path, 0.5)];
+  const samples = Array.from({ length: resolution + 1 }, (_, index) => cubicPoint(path, index / resolution));
+  const lengths = new Float64Array(samples.length);
+  for (let index = 1; index < samples.length; index += 1) {
+    const dx = samples[index].x - samples[index - 1].x;
+    const dy = samples[index].y - samples[index - 1].y;
+    lengths[index] = lengths[index - 1] + Math.hypot(dx, dy);
+  }
+  const total = lengths[lengths.length - 1];
+  if (total <= 1e-9) return Array.from({ length: count }, () => ({ ...path.start }));
+  const output = [];
+  let segment = 1;
+  for (let index = 0; index < count; index += 1) {
+    const target = total * index / (count - 1);
+    while (segment < lengths.length - 1 && lengths[segment] < target) segment += 1;
+    const before = lengths[segment - 1];
+    const after = lengths[segment];
+    const ratio = after === before ? 0 : (target - before) / (after - before);
+    output.push({
+      x: samples[segment - 1].x + (samples[segment].x - samples[segment - 1].x) * ratio,
+      y: samples[segment - 1].y + (samples[segment].y - samples[segment - 1].y) * ratio
+    });
+  }
+  return output;
+}
+
+// src/core/sectionPath.ts
+var TAU = Math.PI * 2;
+function translateSectionOutlinePath(path, dx, dy) {
+  const translate = (point) => ({ x: point.x + dx, y: point.y + dy });
+  return transformSectionOutlinePath(path, translate);
+}
+function transformSectionOutlinePath(path, transform, radiusScale = 1, reflected = false) {
+  return {
+    ...path,
+    start: transform(path.start),
+    segments: path.segments.map((segment) => segment.kind === "line" ? { ...segment, end: transform(segment.end) } : segment.kind === "arc" ? {
+      ...segment,
+      center: transform(segment.center),
+      radius: segment.radius * Math.abs(radiusScale),
+      clockwise: reflected ? !segment.clockwise : segment.clockwise,
+      end: transform(segment.end)
+    } : {
+      ...segment,
+      control1: transform(segment.control1),
+      control2: transform(segment.control2),
+      end: transform(segment.end)
+    })
+  };
+}
+var SAGITTA_TO_CONTROL = 4 / 3;
+
+// src/core/labeling.ts
+var FULL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var LOWER_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+function toBijectiveBase(index, alphabet) {
+  const base = alphabet.length;
+  let n = index + 1;
+  let out = "";
+  while (n > 0) {
+    n -= 1;
+    const rem = n % base;
+    out = alphabet[rem] + out;
+    n = Math.floor(n / base);
+  }
+  return out;
+}
+function toLetters(value, lower = false) {
+  const alphabet = lower ? LOWER_ALPHABET : FULL_ALPHABET;
+  return toBijectiveBase(Math.max(0, Math.floor(value) - 1), alphabet);
+}
+var ROMAN_TABLE = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function toRoman(value) {
+  if (!Number.isFinite(value) || value <= 0) return String(value);
+  let remaining = Math.floor(value);
+  let out = "";
+  for (const [n, sym] of ROMAN_TABLE) {
+    while (remaining >= n) {
+      out += sym;
+      remaining -= n;
+    }
+  }
+  return out;
+}
+
+// src/core/venueStructure.ts
+var BLOCK_LINK_RATIO = 1.8;
+function probesOf(pts) {
+  const n = pts.length;
+  if (n <= 3) return [...pts];
+  return [pts[Math.floor(n * 0.25)], pts[Math.floor(n * 0.5)], pts[Math.floor(n * 0.75)]];
+}
+function distanceToPolyline(pts, x, y) {
+  if (!pts.length) return Infinity;
+  if (pts.length === 1) return Math.hypot(x - pts[0].x, y - pts[0].y);
+  let best = Infinity;
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const a = pts[i], b = pts[i + 1];
+    const vx = b.x - a.x, vy = b.y - a.y;
+    const len2 = vx * vx + vy * vy;
+    let t = len2 > 1e-12 ? ((x - a.x) * vx + (y - a.y) * vy) / len2 : 0;
+    if (t < 0) t = 0;
+    else if (t > 1) t = 1;
+    const d = Math.hypot(x - (a.x + t * vx), y - (a.y + t * vy));
+    if (d < best) best = d;
+  }
+  return best;
+}
+function boundOf(pts) {
+  let cx = 0, cy = 0;
+  for (const p of pts) {
+    cx += p.x;
+    cy += p.y;
+  }
+  const n = pts.length || 1;
+  cx /= n;
+  cy /= n;
+  let r = 0;
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > r) r = d;
+  }
+  return { cx, cy, r };
+}
+function boundGap(a, b) {
+  return Math.hypot(a.cx - b.cx, a.cy - b.cy) - a.r - b.r;
+}
+function rowGap(a, b) {
+  let best = Infinity;
+  for (const p of probesOf(a)) {
+    const d = distanceToPolyline(b, p.x, p.y);
+    if (d < best) best = d;
+  }
+  for (const p of probesOf(b)) {
+    const d = distanceToPolyline(a, p.x, p.y);
+    if (d < best) best = d;
+  }
+  return best;
+}
+function orderAlongRow(pts, indices) {
+  if (pts.length < 3) return { pts, seatIndices: indices };
+  let cx = 0, cy = 0;
+  for (const p of pts) {
+    cx += p.x;
+    cy += p.y;
+  }
+  cx /= pts.length;
+  cy /= pts.length;
+  let far = -1, ax = pts[0];
+  for (const p of pts) {
+    const d = Math.hypot(p.x - cx, p.y - cy);
+    if (d > far) {
+      far = d;
+      ax = p;
+    }
+  }
+  let dx = ax.x - cx, dy = ax.y - cy;
+  const len = Math.hypot(dx, dy);
+  if (len > 1e-9) {
+    dx /= len;
+    dy /= len;
+  } else {
+    dx = 1;
+    dy = 0;
+  }
+  const order = pts.map((p, i) => ({ p, i, t: (p.x - cx) * dx + (p.y - cy) * dy })).sort((u, v) => u.t - v.t);
+  return { pts: order.map((o) => o.p), seatIndices: order.map((o) => indices[o.i]) };
+}
+function fitCircle(pts) {
+  const n = pts.length;
+  if (n < 3) return null;
+  let mx = 0, my = 0;
+  for (const p of pts) {
+    mx += p.x;
+    my += p.y;
+  }
+  mx /= n;
+  my /= n;
+  let suu = 0, suv = 0, svv = 0, suuu = 0, svvv = 0, suvv = 0, svuu = 0;
+  for (const p of pts) {
+    const u = p.x - mx, v = p.y - my;
+    suu += u * u;
+    svv += v * v;
+    suv += u * v;
+    suuu += u * u * u;
+    svvv += v * v * v;
+    suvv += u * v * v;
+    svuu += v * u * u;
+  }
+  const det = suu * svv - suv * suv;
+  if (Math.abs(det) < 1e-9) return null;
+  const b1 = (suuu + suvv) / 2;
+  const b2 = (svvv + svuu) / 2;
+  const uc = (b1 * svv - b2 * suv) / det;
+  const vc = (b2 * suu - b1 * suv) / det;
+  const cx = uc + mx, cy = vc + my;
+  if (!Number.isFinite(cx) || !Number.isFinite(cy)) return null;
+  return { cx, cy };
+}
+var CIRCLE_ROW_SPREAD_LIMIT = 0.15;
+function fitBlockAxis(group) {
+  if (group.length < 2) return null;
+  const cents = group.map((r) => {
+    let x = 0, y = 0;
+    for (const p of r.pts) {
+      x += p.x;
+      y += p.y;
+    }
+    return { x: x / r.pts.length, y: y / r.pts.length };
+  });
+  let ox = 0, oy = 0;
+  for (const c of cents) {
+    ox += c.x;
+    oy += c.y;
+  }
+  ox /= cents.length;
+  oy /= cents.length;
+  let sxx = 0, sxy = 0, syy = 0;
+  for (const c of cents) {
+    const dx = c.x - ox, dy = c.y - oy;
+    sxx += dx * dx;
+    sxy += dx * dy;
+    syy += dy * dy;
+  }
+  const tr = sxx + syy;
+  const det = sxx * syy - sxy * sxy;
+  const lambda = tr / 2 + Math.sqrt(Math.max(0, tr * tr / 4 - det));
+  let ax, ay;
+  if (Math.abs(sxy) > 1e-12) {
+    ax = lambda - syy;
+    ay = sxy;
+  } else if (sxx >= syy) {
+    ax = 1;
+    ay = 0;
+  } else {
+    ax = 0;
+    ay = 1;
+  }
+  const len = Math.hypot(ax, ay);
+  if (!(len > 1e-12)) return null;
+  ax /= len;
+  ay /= len;
+  let lo = Infinity, hi = -Infinity;
+  const widths = [];
+  for (const r of group) {
+    let rlo = Infinity, rhi = -Infinity;
+    for (const p of r.pts) {
+      const t = p.x * ax + p.y * ay;
+      if (t < rlo) rlo = t;
+      if (t > rhi) rhi = t;
+      if (t < lo) lo = t;
+      if (t > hi) hi = t;
+    }
+    widths.push(rhi - rlo);
+  }
+  const range = hi - lo;
+  if (!(range > 1e-9)) return null;
+  widths.sort((a, b) => a - b);
+  const p90 = widths[Math.min(widths.length - 1, Math.floor(widths.length * 0.9))];
+  return p90 / range <= AXIS_ROW_WIDTH_LIMIT ? { x: ax, y: ay } : null;
+}
+var AXIS_ROW_WIDTH_LIMIT = 0.35;
+function resolveSection(sectionId, seats, seatIndices, focal) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const i of seatIndices) {
+    const s = seats[i];
+    const key = s.rowId || `__seat-${i}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { pts: [], idx: [] };
+      groups.set(key, g);
+    }
+    g.pts.push({ x: s.x, y: s.y });
+    g.idx.push(i);
+  }
+  if (!groups.size) return { sectionId, rows: [], blockCount: 0 };
+  const rows = [];
+  for (const [id, g] of groups) {
+    const ordered = orderAlongRow(g.pts, g.idx);
+    let sum = 0;
+    for (const p of ordered.pts) sum += Math.hypot(p.x - focal.x, p.y - focal.y);
+    rows.push({
+      id,
+      pts: ordered.pts,
+      seatIndices: ordered.seatIndices,
+      blockId: -1,
+      ordinal: 0,
+      blockDepth: 0,
+      focalDistance: sum / ordered.pts.length
+    });
+  }
+  const bounds = rows.map((r) => boundOf(r.pts));
+  const nearest = [];
+  for (let i = 0; i < rows.length; i++) {
+    let best = Infinity;
+    for (let j = 0; j < rows.length; j++) {
+      if (i === j) continue;
+      if (boundGap(bounds[i], bounds[j]) >= best) continue;
+      const d = rowGap(rows[i].pts, rows[j].pts);
+      if (d < best) best = d;
+    }
+    if (Number.isFinite(best)) nearest.push(best);
+  }
+  nearest.sort((a, b) => a - b);
+  const typicalGap = nearest.length ? nearest[Math.floor(nearest.length / 2)] : 1;
+  const linkDistance = Math.max(typicalGap * BLOCK_LINK_RATIO, 1e-6);
+  const adjacency = rows.map(() => []);
+  for (let i = 0; i < rows.length; i++) {
+    for (let j = i + 1; j < rows.length; j++) {
+      if (boundGap(bounds[i], bounds[j]) > linkDistance) continue;
+      if (rowGap(rows[i].pts, rows[j].pts) <= linkDistance) {
+        adjacency[i].push(j);
+        adjacency[j].push(i);
+      }
+    }
+  }
+  let blockCount = 0;
+  for (let i = 0; i < rows.length; i++) {
+    if (rows[i].blockId !== -1) continue;
+    const id = blockCount++;
+    const stack = [i];
+    rows[i].blockId = id;
+    while (stack.length) {
+      const k = stack.pop();
+      for (const n of adjacency[k]) {
+        if (rows[n].blockId !== -1) continue;
+        rows[n].blockId = id;
+        stack.push(n);
+      }
+    }
+  }
+  const byBlock = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const a = byBlock.get(r.blockId) ?? [];
+    a.push(r);
+    byBlock.set(r.blockId, a);
+  }
+  const centres = [];
+  for (const r of rows) {
+    if (r.pts.length < 4) continue;
+    const c = fitCircle(r.pts);
+    if (!c) continue;
+    if (!Number.isFinite(c.cx) || !Number.isFinite(c.cy)) continue;
+    centres.push({ x: c.cx, y: c.cy });
+  }
+  const centre = centres.length >= 2 ? (() => {
+    const xs = centres.map((c) => c.x).sort((a, b) => a - b);
+    const ys = centres.map((c) => c.y).sort((a, b) => a - b);
+    const mid = Math.floor(centres.length / 2);
+    return { cx: xs[mid], cy: ys[mid] };
+  })() : null;
+  if (centre) {
+    const radiusOf = (p) => Math.hypot(p.x - centre.cx, p.y - centre.cy);
+    let lo = Infinity, hi = -Infinity;
+    const spreads = [];
+    for (const r of rows) {
+      let rlo = Infinity, rhi = -Infinity;
+      for (const p of r.pts) {
+        const d = radiusOf(p);
+        if (d < rlo) rlo = d;
+        if (d > rhi) rhi = d;
+      }
+      spreads.push(rhi - rlo);
+      if (rlo < lo) lo = rlo;
+      if (rhi > hi) hi = rhi;
+    }
+    const range = hi - lo;
+    spreads.sort((a, b) => a - b);
+    const p90 = spreads[Math.min(spreads.length - 1, Math.floor(spreads.length * 0.9))];
+    if (range > 1e-9 && p90 / range <= CIRCLE_ROW_SPREAD_LIMIT) {
+      const withRadius = rows.map((r) => {
+        let sum = 0;
+        for (const p of r.pts) sum += radiusOf(p);
+        return { row: r, radius: sum / r.pts.length };
+      });
+      let minR = Infinity;
+      for (const w of withRadius) if (w.radius < minR) minR = w.radius;
+      withRadius.sort((a, b) => a.radius - b.radius);
+      let ordinal = -1, lastRadius = -Infinity;
+      const tolerance = range / Math.max(1, withRadius.length) * 0.5;
+      const ordered = [];
+      for (const w of withRadius) {
+        if (w.radius - lastRadius > tolerance) {
+          ordinal++;
+          lastRadius = w.radius;
+        }
+        w.row.ordinal = ordinal;
+        w.row.blockDepth = w.radius - minR;
+        ordered.push(w.row);
+      }
+      return { sectionId, rows: ordered, blockCount };
+    }
+  }
+  const out = [];
+  for (const [, group] of byBlock) {
+    const axis = fitBlockAxis(group);
+    if (axis) {
+      const key = (r) => {
+        let sum = 0;
+        for (const p of r.pts) sum += p.x * axis.x + p.y * axis.y;
+        return sum / r.pts.length;
+      };
+      group.sort((a, b) => key(a) - key(b));
+      let depth = 0;
+      for (let i = 0; i < group.length; i++) {
+        if (i > 0) depth += rowGap(group[i - 1].pts, group[i].pts);
+        group[i].ordinal = i;
+        group[i].blockDepth = depth;
+        out.push(group[i]);
+      }
+    } else {
+      let front = Infinity;
+      for (const r of group) if (r.focalDistance < front) front = r.focalDistance;
+      group.sort((a, b) => a.focalDistance - b.focalDistance);
+      for (let i = 0; i < group.length; i++) {
+        group[i].ordinal = i;
+        group[i].blockDepth = Math.max(0, group[i].focalDistance - front);
+        out.push(group[i]);
+      }
+    }
+  }
+  return { sectionId, rows: out, blockCount };
+}
+
+// src/core/layout.ts
+function overrideAccessibility(o) {
+  if (!o) return [];
+  if (o.accessibility && o.accessibility.length) {
+    return o.wheelchairSpaceType && !o.accessibility.includes("wheelchair") ? ["wheelchair", ...o.accessibility] : o.accessibility;
+  }
+  if (o.wheelchairSpaceType) return ["wheelchair"];
+  return o.accessible ? ["wheelchair"] : [];
+}
+var DEG = Math.PI / 180;
+var SEAT_R = 9;
+var TABLE_SEAT_OFFSET = 16;
+function place(lx, ly, deg, origin) {
+  const a = deg * DEG;
+  const cos = Math.cos(a);
+  const sin = Math.sin(a);
+  return {
+    x: origin.x + lx * cos - ly * sin,
+    y: origin.y + lx * sin + ly * cos
+  };
+}
+function rowSeatPositions(row) {
+  const { seatCount, seatSpacing, curve, rotation, origin } = row;
+  const out = [];
+  if (row.path) return distributeAlongCubic(row.path, seatCount);
+  if (seatCount <= 1) {
+    if (seatCount === 1) out.push({ x: origin.x, y: origin.y });
+    return out;
+  }
+  if (curve === 0) {
+    for (let i = 0; i < seatCount; i++) out.push(place(i * seatSpacing, 0, rotation, origin));
+    return out;
+  }
+  const arcStep = curve / (seatCount - 1) * DEG;
+  const radius = seatSpacing / (2 * Math.sin(Math.abs(arcStep) / 2));
+  for (let i = 0; i < seatCount; i++) {
+    const phi = i * arcStep;
+    const lx = radius * Math.sin(phi);
+    const ly = -radius + radius * Math.cos(phi);
+    out.push(place(lx, ly, rotation, origin));
+  }
+  return out;
+}
+function overrideMap(row) {
+  const m = /* @__PURE__ */ new Map();
+  if (row.overrides) for (const o of row.overrides) m.set(o.index, o);
+  return m;
+}
+function rowInventoryCount(row) {
+  const skipped = new Set((row.overrides ?? []).filter((override) => override.skip && Number.isInteger(override.index) && override.index >= 0 && override.index < row.seatCount).map((override) => override.index));
+  return Math.max(0, row.seatCount - skipped.size);
+}
+function centerRank(n) {
+  const rank = new Array(n);
+  Array.from({ length: n }, (_, i) => i).sort((a, b) => Math.abs(2 * a - (n - 1)) - Math.abs(2 * b - (n - 1)) || a - b).forEach((idx, k) => rank[idx] = k);
+  return rank;
+}
+function seatLabelPart(row, i) {
+  const rawStart = row.seatLabelStart ?? 1;
+  const dir = row.seatNumbering?.direction ?? "ltr";
+  const step = row.seatNumbering?.step ?? 1;
+  const scheme = row.seatNumbering?.scheme ?? "decimal";
+  const prefix = row.seatNumbering?.prefix ?? "";
+  const endAt = row.seatNumbering?.endAt;
+  const n = row.seatCount;
+  if (scheme === "updown" || scheme === "updown-descending") {
+    const half = Math.ceil(n / 2);
+    const core2 = scheme === "updown" ? i < half ? rawStart + 2 * i : rawStart - 1 + 2 * (n - i) : i < half ? rawStart + 2 * (half - 1 - i) : rawStart + 1 + 2 * (i - half);
+    return `${prefix}${core2}`;
+  }
+  const effStep = scheme === "odd" || scheme === "even" ? 2 : step;
+  const start = endAt != null && Number.isFinite(endAt) ? endAt - (n - 1) * effStep : rawStart;
+  const p = dir === "center" ? centerRank(n)[i] : dir === "rtl" ? n - 1 - i : i;
+  let core;
+  switch (scheme) {
+    case "odd": {
+      const firstOdd = start % 2 === 1 ? start : start + 1;
+      core = String(firstOdd + p * 2);
+      break;
+    }
+    case "even": {
+      const firstEven = start % 2 === 0 ? start : start + 1;
+      core = String(firstEven + p * 2);
+      break;
+    }
+    case "roman":
+      core = toRoman(start + p * step);
+      break;
+    case "letters-upper":
+      core = toLetters(start + p * step, false);
+      break;
+    case "letters-lower":
+      core = toLetters(start + p * step, true);
+      break;
+    case "decimal":
+    default:
+      core = String(start + p * step);
+      break;
+  }
+  return `${prefix}${core}`;
+}
+function expandRowSlots(row) {
+  const ov = overrideMap(row);
+  return rowSeatPositions(row).map((p, i) => {
+    const o = ov.get(i);
+    const accessibility = overrideAccessibility(o);
+    const part = seatLabelPart(row, i);
+    const inventoryLabel = o?.label ?? `${row.label}-${part}`;
+    const displayPrefix = row.displayLabel ?? row.label;
+    const commercial = { ...row.commercial, ...o?.commercial };
+    return {
+      index: i,
+      x: p.x + (o?.dx ?? 0),
+      y: p.y + (o?.dy ?? 0),
+      label: inventoryLabel,
+      displayLabel: o?.displayLabel ?? `${displayPrefix}-${part}`,
+      categoryKey: o?.categoryKey ?? row.categoryKey,
+      skipped: !!o?.skip,
+      accessible: accessibility.length > 0,
+      accessibility,
+      wheelchairSpaceType: o?.wheelchairSpaceType,
+      commercial: Object.values(commercial).some((value) => value !== void 0 && value !== false && value !== "") ? commercial : void 0,
+      viewUrl: o?.viewFromSeatUrl ?? row.viewFromSeatUrl,
+      labelStyle: o?.labelStyle
+    };
+  });
+}
+function expandRow(row) {
+  const seats = [];
+  for (const slot of expandRowSlots(row)) {
+    if (slot.skipped) continue;
+    seats.push({
+      id: `${row.id}:${slot.index}`,
+      label: slot.label,
+      displayLabel: slot.displayLabel === slot.label ? void 0 : slot.displayLabel,
+      x: slot.x,
+      y: slot.y,
+      rowId: row.id,
+      categoryKey: slot.categoryKey,
+      accessible: slot.accessible || void 0,
+      accessibility: slot.accessibility.length ? slot.accessibility : void 0,
+      wheelchairSpaceType: slot.wheelchairSpaceType,
+      commercial: slot.commercial,
+      viewUrl: slot.viewUrl,
+      labelStyle: slot.labelStyle
+    });
+  }
+  return seats;
+}
+function tableSeatCountsBySide(t) {
+  if (t.seatCountsBySide) return { ...t.seatCountsBySide };
+  const enabled = t.sides && t.sides.length ? t.sides : ["top", "bottom"];
+  const order = ["top", "bottom", "left", "right"].filter((side) => enabled.includes(side));
+  const counts = { top: 0, bottom: 0, left: 0, right: 0 };
+  if (!order.length) return counts;
+  const n = Math.max(0, Math.round(t.seatCount));
+  for (let index = 0; index < n; index++) counts[order[index % order.length]] += 1;
+  return counts;
+}
+function expandTableSlots(t) {
+  const seats = [];
+  const n = Math.max(0, Math.round(t.seatCount));
+  if (n === 0) return seats;
+  const overrides = new Map((t.overrides ?? []).map((override) => [override.index, override]));
+  const mk = (index, x, y, side) => {
+    const override = overrides.get(index);
+    const accessibility = overrideAccessibility(override);
+    const label = override?.label ?? `${t.label}-${index + 1}`;
+    const displayPrefix = t.displayLabel ?? t.label;
+    return {
+      index,
+      label,
+      displayLabel: override?.displayLabel ?? `${displayPrefix}-${index + 1}`,
+      x: x + (override?.dx ?? 0),
+      y: y + (override?.dy ?? 0),
+      categoryKey: override?.categoryKey ?? t.categoryKey,
+      skipped: !!override?.skip,
+      accessible: accessibility.length > 0,
+      accessibility,
+      wheelchairSpaceType: override?.wheelchairSpaceType,
+      commercial: override?.commercial,
+      viewUrl: override?.viewFromSeatUrl,
+      labelStyle: override?.labelStyle,
+      ...side ? { side } : {}
+    };
+  };
+  if (t.shape === "round") {
+    const R = (t.radius ?? 40) + TABLE_SEAT_OFFSET;
+    const base = t.rotation * DEG;
+    const arc = Math.max(0, Math.min(360, t.seatArc ?? 360));
+    if (arc >= 360 || n === 1) {
+      for (let i = 0; i < n; i++) {
+        const a = base + i / n * 2 * Math.PI;
+        seats.push(mk(i, t.center.x + R * Math.cos(a), t.center.y + R * Math.sin(a)));
+      }
+      return seats;
+    }
+    const arcRad = arc * DEG;
+    const halfGap = (2 * Math.PI - arcRad) / 2;
+    const start = base + halfGap;
+    for (let i = 0; i < n; i++) {
+      const a = start + i / (n - 1) * arcRad;
+      seats.push(mk(i, t.center.x + R * Math.cos(a), t.center.y + R * Math.sin(a)));
+    }
+    return seats;
+  }
+  const w = t.width ?? 80;
+  const h = t.height ?? 50;
+  const counts = tableSeatCountsBySide(t);
+  const order = ["top", "bottom", "left", "right"];
+  let idx = 0;
+  for (const side of order) {
+    const count = counts[side];
+    for (let j = 0; j < count; j++) {
+      let localX;
+      let localY;
+      if (side === "top") {
+        localX = -w / 2 + (j + 0.5) * w / count;
+        localY = -h / 2 - TABLE_SEAT_OFFSET;
+      } else if (side === "bottom") {
+        localX = -w / 2 + (j + 0.5) * w / count;
+        localY = h / 2 + TABLE_SEAT_OFFSET;
+      } else if (side === "left") {
+        localX = -w / 2 - TABLE_SEAT_OFFSET;
+        localY = -h / 2 + (j + 0.5) * h / count;
+      } else {
+        localX = w / 2 + TABLE_SEAT_OFFSET;
+        localY = -h / 2 + (j + 0.5) * h / count;
+      }
+      const point = place(localX, localY, t.rotation, t.center);
+      seats.push(mk(idx++, point.x, point.y, side));
+    }
+  }
+  return seats;
+}
+function tableInventoryCount(t) {
+  if (t.bookAsWhole || t.variableOccupancy) return Math.max(0, Math.round(t.seatCount));
+  return expandTableSlots(t).filter((slot) => !slot.skipped).length;
+}
+function expandTable(t) {
+  return expandTableSlots(t).filter((slot) => !slot.skipped).map((slot) => ({
+    id: `${t.id}:${slot.index}`,
+    label: slot.label,
+    ...slot.displayLabel !== slot.label ? { displayLabel: slot.displayLabel } : {},
+    x: slot.x,
+    y: slot.y,
+    rowId: t.id,
+    categoryKey: slot.categoryKey,
+    ...slot.accessible ? { accessible: true } : {},
+    ...slot.accessibility.length ? { accessibility: slot.accessibility } : {},
+    ...slot.wheelchairSpaceType ? { wheelchairSpaceType: slot.wheelchairSpaceType } : {},
+    ...slot.commercial ? { commercial: slot.commercial } : {},
+    ...slot.viewUrl ? { viewUrl: slot.viewUrl } : {},
+    ...slot.labelStyle ? { labelStyle: slot.labelStyle } : {}
+  }));
+}
+function expandBooth(b) {
+  return [
+    {
+      id: `${b.id}:0`,
+      label: b.label,
+      ...b.displayLabel && b.displayLabel !== b.label ? { displayLabel: b.displayLabel } : {},
+      x: b.center.x,
+      y: b.center.y,
+      rowId: b.id,
+      categoryKey: b.categoryKey,
+      kind: "booth"
+    }
+  ];
+}
+function pointInPolygon(p, poly) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const xi = poly[i].x;
+    const yi = poly[i].y;
+    const xj = poly[j].x;
+    const yj = poly[j].y;
+    const hit = yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi;
+    if (hit) inside = !inside;
+  }
+  return inside;
+}
+function pointOnPolygonBoundary(p, poly) {
+  return poly.some((start, index) => {
+    const end = poly[(index + 1) % poly.length];
+    const cross = (p.y - start.y) * (end.x - start.x) - (p.x - start.x) * (end.y - start.y);
+    if (Math.abs(cross) > 1e-7) return false;
+    const dot = (p.x - start.x) * (end.x - start.x) + (p.y - start.y) * (end.y - start.y);
+    const lengthSquared = (end.x - start.x) ** 2 + (end.y - start.y) ** 2;
+    return dot >= -1e-7 && dot <= lengthSquared + 1e-7;
+  });
+}
+function pointInPolygonWithHoles(p, outer, holes) {
+  return pointInPolygon(p, outer) && !(holes ?? []).some((hole) => pointInPolygon(p, hole) || pointOnPolygonBoundary(p, hole));
+}
+function polygonLabelPoint(outer, holes) {
+  if (!outer.length) return { x: 0, y: 0 };
+  const xs = outer.map((point) => point.x);
+  const ys = outer.map((point) => point.y);
+  const bounds = { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys) };
+  const centroid = polygonCentroid(outer);
+  if (pointInPolygonWithHoles(centroid, outer, holes)) return centroid;
+  let best = outer[0];
+  let bestScore = -Infinity;
+  const rings = [outer, ...holes ?? []];
+  for (let row = 1; row < 24; row += 1) {
+    for (let column = 1; column < 24; column += 1) {
+      const point = {
+        x: bounds.minX + (bounds.maxX - bounds.minX) * column / 24,
+        y: bounds.minY + (bounds.maxY - bounds.minY) * row / 24
+      };
+      if (!pointInPolygonWithHoles(point, outer, holes)) continue;
+      const score = Math.min(...rings.flatMap((ring) => ring.map((start, index) => {
+        const end = ring[(index + 1) % ring.length];
+        const dx = end.x - start.x;
+        const dy = end.y - start.y;
+        const denominator = dx * dx + dy * dy;
+        const projection = denominator ? ((point.x - start.x) * dx + (point.y - start.y) * dy) / denominator : 0;
+        const t = Math.max(0, Math.min(1, projection));
+        return Math.hypot(point.x - (start.x + t * dx), point.y - (start.y + t * dy));
+      })));
+      if (score > bestScore) {
+        best = point;
+        bestScore = score;
+      }
+    }
+  }
+  return best;
+}
+function polygonCentroid(pts) {
+  if (!pts.length) return { x: 0, y: 0 };
+  let x = 0;
+  let y = 0;
+  for (const p of pts) {
+    x += p.x;
+    y += p.y;
+  }
+  return { x: x / pts.length, y: y / pts.length };
+}
+function objectCenter(o) {
+  switch (o.type) {
+    case "row": {
+      const seats = expandRow(o);
+      if (!seats.length) return { x: o.origin.x, y: o.origin.y };
+      let x = 0;
+      let y = 0;
+      for (const s of seats) {
+        x += s.x;
+        y += s.y;
+      }
+      return { x: x / seats.length, y: y / seats.length };
+    }
+    case "table":
+    case "booth":
+      return { x: o.center.x, y: o.center.y };
+    case "gaArea":
+      return polygonCentroid(o.points);
+    case "section":
+      return polygonCentroid(o.outline);
+    case "text":
+      return { x: o.position.x, y: o.position.y };
+    case "shape":
+      if (o.points && o.points.length) return polygonCentroid(o.points);
+      if (o.x != null && o.y != null && o.width != null && o.height != null) {
+        return { x: o.x + o.width / 2, y: o.y + o.height / 2 };
+      }
+      return { x: o.x ?? 0, y: o.y ?? 0 };
+    case "decorImage":
+      return { x: o.x + o.width / 2, y: o.y + o.height / 2 };
+  }
+}
+function samePoints(left, right) {
+  return left.length === right.length && left.every((point, index) => point.x === right[index].x && point.y === right[index].y);
+}
+function sameGASurfaceAsSection(object, section) {
+  if (object.type !== "gaArea" || !samePoints(object.points, section.outline)) return false;
+  const objectHoles = object.holes ?? [];
+  const sectionHoles = section.holes ?? [];
+  return objectHoles.length === sectionHoles.length && objectHoles.every((hole, index) => samePoints(hole, sectionHoles[index]));
+}
+function owningSectionForObject(objects, object) {
+  const sections = objects.filter((candidate) => candidate.type === "section");
+  const referencedLogicalId = "referenceInventorySource" in object ? object.referenceInventorySource?.logicalSectionId : void 0;
+  const center = objectCenter(object);
+  const referencedOwner = referencedLogicalId ? sections.find((section) => (section.logicalSectionId ?? section.id) === referencedLogicalId && (sameGASurfaceAsSection(object, section) || pointInPolygonWithHoles(center, section.outline, section.holes))) : void 0;
+  return referencedOwner ?? sections.find((section) => pointInPolygonWithHoles(center, section.outline, section.holes));
+}
+function floorsOf(doc) {
+  if (doc.floors && doc.floors.length) return doc.floors;
+  return [{
+    id: "floor-0",
+    name: "Main",
+    objects: doc.objects,
+    focalPoint: doc.focalPoint,
+    referenceImage: doc.referenceImage,
+    backgroundImage: doc.backgroundImage
+  }];
+}
+function floorObjects(doc, floorId) {
+  const floors = floorsOf(doc);
+  return (floorId ? floors.find((f) => f.id === floorId) : floors[0])?.objects ?? [];
+}
+function allObjects(doc) {
+  return doc.floors && doc.floors.length ? doc.floors.flatMap((f) => f.objects) : doc.objects;
+}
+function translateObject(o, dx, dy) {
+  const p = (pt) => ({ x: pt.x + dx, y: pt.y + dy });
+  const pts = (a) => a.map(p);
+  switch (o.type) {
+    case "row":
+      return { ...o, origin: p(o.origin) };
+    case "table":
+    case "booth":
+      return { ...o, center: p(o.center) };
+    case "gaArea":
+      return { ...o, points: pts(o.points), ...o.holes ? { holes: o.holes.map(pts) } : {} };
+    case "section":
+      return {
+        ...o,
+        outline: pts(o.outline),
+        ...o.outlinePath ? { outlinePath: translateSectionOutlinePath(o.outlinePath, dx, dy) } : {},
+        ...o.holes ? { holes: o.holes.map(pts) } : {}
+      };
+    case "text":
+      return { ...o, position: p(o.position) };
+    case "shape":
+      return {
+        ...o,
+        ...o.points ? { points: pts(o.points) } : {},
+        ...o.x != null ? { x: o.x + dx } : {},
+        ...o.y != null ? { y: o.y + dy } : {}
+      };
+    case "decorImage":
+      return { ...o, x: o.x + dx, y: o.y + dy };
+  }
+}
+function stackFloors(doc, spread = 900) {
+  if (!doc.floors || doc.floors.length < 2) return doc;
+  const objects = [];
+  doc.floors.forEach((f, i) => {
+    const dy = -i * spread;
+    for (const o of f.objects) objects.push(dy === 0 ? o : translateObject(o, 0, dy));
+  });
+  return { ...doc, objects, floors: void 0 };
+}
+function expandFloorObjects(objects, zones, fallbackFocal, viewFallback) {
+  const out = [];
+  const segmented = /* @__PURE__ */ new Map();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const object of objects) {
+    if (object.type !== "row" || !object.segmentedRow) continue;
+    const list = grouped.get(object.segmentedRow.groupId) ?? [];
+    list.push(object);
+    grouped.set(object.segmentedRow.groupId, list);
+  }
+  for (const [groupId, members] of grouped) {
+    const ordered = members.slice().sort((left, right) => left.segmentedRow.componentIndex - right.segmentedRow.componentIndex);
+    const expectedCount = ordered[0]?.segmentedRow?.componentCount ?? 0;
+    const first = ordered[0]?.segmentedRow;
+    if (!first) continue;
+    const valid = expectedCount >= 2 && ordered.length === expectedCount && first?.boundaryBefore === "start" && ordered.every((row, index) => row.segmentedRow?.kind === "segmented-row-v1" && row.segmentedRow.groupId === groupId && row.segmentedRow.componentCount === expectedCount && row.segmentedRow.componentIndex === index && (index === 0 ? row.segmentedRow.boundaryBefore === "start" : row.segmentedRow.boundaryBefore !== "start") && row.segmentedRow.displayLabel === first.displayLabel);
+    if (!valid) continue;
+    const totalSeats = ordered.reduce((sum, row) => sum + row.seatCount, 0);
+    let adjacencyOffset = 0;
+    let displayOffset = 0;
+    for (const row of ordered) {
+      if (row.segmentedRow.boundaryBefore === "break") adjacencyOffset += 1;
+      segmented.set(row.id, {
+        groupId,
+        adjacencyOffset,
+        displayOffset,
+        displayLabel: first.displayLabel,
+        totalSeats,
+        canonical: ordered[0],
+        viewFromSeatUrl: first.viewFromSeatUrl
+      });
+      adjacencyOffset += row.seatCount;
+      displayOffset += row.seatCount;
+    }
+  }
+  for (const obj of objects) {
+    let seats = [];
+    if (obj.type === "row") seats = expandRow(obj);
+    else if (obj.type === "table") seats = expandTable(obj);
+    else if (obj.type === "booth") seats = expandBooth(obj);
+    if (!seats.length) continue;
+    if (obj.type === "row") {
+      const logical = segmented.get(obj.id);
+      if (logical) {
+        const overrides = new Map((obj.overrides ?? []).map((override) => [override.index, override]));
+        for (const seat of seats) {
+          const physicalIndex = Number(seat.id.slice(seat.id.lastIndexOf(":") + 1));
+          if (!Number.isInteger(physicalIndex)) continue;
+          const displayOrdinal = logical.displayOffset + physicalIndex;
+          seat.logicalRowId = logical.groupId;
+          seat.logicalSeatIndex = logical.adjacencyOffset + physicalIndex;
+          if (!overrides.get(physicalIndex)?.displayLabel) {
+            const numberingRow = {
+              ...logical.canonical,
+              seatCount: logical.totalSeats,
+              label: logical.displayLabel,
+              displayLabel: logical.displayLabel
+            };
+            seat.displayLabel = `${logical.displayLabel}-${seatLabelPart(numberingRow, displayOrdinal)}`;
+          }
+          seat.viewUrl ??= logical.viewFromSeatUrl;
+        }
+      }
+    }
+    const owner = owningSectionForObject(objects, obj);
+    const inheritedView = owner?.viewFromSeatUrl;
+    const zone = owner?.zone ? zones?.find((candidate) => candidate.id === owner.zone) : void 0;
+    const resolvedFocal = zone?.focalPoint ?? fallbackFocal;
+    for (const seat of seats) {
+      if (inheritedView) seat.viewUrl ??= inheritedView;
+      if (viewFallback) seat.viewUrl ??= viewFallback;
+      if (owner) seat.sectionId = owner.logicalSectionId ?? owner.id;
+      if (owner?.zone) seat.zoneId = owner.zone;
+      if (resolvedFocal) seat.focalPoint = { ...resolvedFocal };
+    }
+    out.push(...seats);
+  }
+  return out;
+}
+function expandChart(doc, options = {}) {
+  if (doc.floors?.length) {
+    const out2 = [];
+    for (const floor of doc.floors) {
+      const floorFocal = floor.focalPoint ?? doc.focalPoint;
+      const floorView = floor.viewFromSeatUrl ?? doc.viewFromSeatUrl;
+      const seats = expandFloorObjects(floor.objects, doc.zones, floorFocal, floorView);
+      assignEyeHeights(floor.objects, floor.focalPoint ?? doc.focalPoint, floor.baseHeightM ?? 0, seats);
+      out2.push(...seats);
+    }
+    return out2;
+  }
+  const out = expandFloorObjects(doc.objects, doc.zones, doc.focalPoint, doc.viewFromSeatUrl);
+  assignEyeHeights(doc.objects, doc.focalPoint, options.floorBaseHeightM ?? 0, out);
+  return out;
+}
+function assignEyeHeights(objects, focal, floorBaseHeightM, seats) {
+  const sections = objects.filter((o) => o.type === "section");
+  const hasGeometry = floorBaseHeightM > 0 || sections.some((s) => s.height !== void 0 || s.rake !== void 0 || (s.elevation ?? 0) > 0);
+  if (!sections.length || !hasGeometry || !focal) {
+    for (const seat of seats) seat.eyeHeightM = floorBaseHeightM + SEATED_EYE_HEIGHT_M;
+    return;
+  }
+  const owner = new Array(seats.length);
+  const geo = /* @__PURE__ */ new Map();
+  const seatsBySection = /* @__PURE__ */ new Map();
+  for (let i = 0; i < seats.length; i++) {
+    const seat = seats[i];
+    const sec = sections.find((s) => pointInPolygonWithHoles({ x: seat.x, y: seat.y }, s.outline, s.holes)) ?? null;
+    owner[i] = sec;
+    if (!sec) continue;
+    if (!geo.has(sec.id)) geo.set(sec.id, sectionGeometry(sec, { floorBaseHeightM }));
+    const list = seatsBySection.get(sec.id);
+    if (list) list.push(i);
+    else seatsBySection.set(sec.id, [i]);
+  }
+  const seatLevel = new Array(seats.length).fill(void 0);
+  for (const [secId, indices] of seatsBySection) {
+    const g = geo.get(secId);
+    if (!g) continue;
+    const rakeTan = g.rake > 0 ? Math.tan(g.rake * Math.PI / 180) : 0;
+    const structure = resolveSection(secId, seats, indices, focal);
+    for (const row of structure.rows) {
+      const riseM = row.blockDepth * METRES_PER_CHART_UNIT * rakeTan;
+      const level = g.height + riseM;
+      for (const si of row.seatIndices) seatLevel[si] = level;
+    }
+  }
+  for (let i = 0; i < seats.length; i++) {
+    const seat = seats[i];
+    const sec = owner[i];
+    if (!sec) {
+      seat.eyeHeightM = floorBaseHeightM + SEATED_EYE_HEIGHT_M;
+      continue;
+    }
+    const g = geo.get(sec.id);
+    seat.eyeHeightM = (seatLevel[i] ?? g.height) + SEATED_EYE_HEIGHT_M;
+  }
+}
+var PAD = 40;
+function chartBounds(doc) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const acc = (x, y) => {
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  };
+  for (const s of expandChart(doc)) acc(s.x, s.y);
+  for (const obj of allObjects(doc)) {
+    if (obj.type === "gaArea") {
+      for (const p of obj.points) acc(p.x, p.y);
+    } else if (obj.type === "section") {
+      for (const p of obj.outline) acc(p.x, p.y);
+    } else if (obj.type === "decorImage") {
+      acc(obj.x, obj.y);
+      acc(obj.x + obj.width, obj.y + obj.height);
+    } else if (obj.type === "shape") {
+      if (obj.points && obj.points.length) {
+        for (const p of obj.points) acc(p.x, p.y);
+      } else if (obj.x != null && obj.y != null && obj.width != null && obj.height != null) {
+        acc(obj.x, obj.y);
+        acc(obj.x + obj.width, obj.y + obj.height);
+      }
+    } else if (obj.type === "table") {
+      const off = TABLE_SEAT_OFFSET + SEAT_R;
+      const ext = obj.shape === "round" ? (obj.radius ?? 40) + off : Math.max((obj.width ?? 80) / 2, (obj.height ?? 50) / 2) + off;
+      acc(obj.center.x - ext, obj.center.y - ext);
+      acc(obj.center.x + ext, obj.center.y + ext);
+    } else if (obj.type === "booth") {
+      const ext = Math.max(obj.width, obj.height) / 2;
+      acc(obj.center.x - ext, obj.center.y - ext);
+      acc(obj.center.x + ext, obj.center.y + ext);
+    } else if (obj.type === "text") {
+      const w = obj.fontSize * obj.text.length * 0.6;
+      acc(obj.position.x, obj.position.y);
+      acc(obj.position.x + w, obj.position.y + obj.fontSize);
+    }
+  }
+  for (const image of [doc.referenceImage, doc.backgroundImage]) {
+    if (!image) continue;
+    const { center, width } = image;
+    const bh = width * 3 / 4;
+    acc(center.x - width / 2, center.y - bh / 2);
+    acc(center.x + width / 2, center.y + bh / 2);
+  }
+  if (!isFinite(minX)) {
+    const f = doc.focalPoint ?? { x: 0, y: 0 };
+    return { x: f.x - 200, y: f.y - 200, width: 400, height: 400 };
+  }
+  return {
+    x: minX - PAD,
+    y: minY - PAD,
+    width: maxX - minX + PAD * 2,
+    height: maxY - minY + PAD * 2
+  };
+}
+
+export {
+  ACCESSIBILITY_TYPES,
+  accessibilityMeta,
+  ACCESSIBILITY_RING_COLOR,
+  accessibilityRingColor,
+  LABEL_STYLE_MIN_SIZE,
+  LABEL_STYLE_MAX_SIZE,
+  SURROUNDINGS_SHAPE_ROLES,
+  layerOf,
+  CHART_STORAGE_KEY,
+  METRES_PER_CHART_UNIT,
+  CHART_UNITS_PER_METRE,
+  TIER_HEIGHT_M,
+  SEATED_EYE_HEIGHT_M,
+  sectionElevationTier,
+  sectionGeometry,
+  distanceToPolyline,
+  resolveSection,
+  rowSeatPositions,
+  rowInventoryCount,
+  seatLabelPart,
+  expandRowSlots,
+  expandRow,
+  tableSeatCountsBySide,
+  expandTableSlots,
+  tableInventoryCount,
+  expandTable,
+  expandBooth,
+  pointInPolygon,
+  pointInPolygonWithHoles,
+  polygonLabelPoint,
+  objectCenter,
+  owningSectionForObject,
+  floorsOf,
+  floorObjects,
+  allObjects,
+  stackFloors,
+  expandChart,
+  chartBounds
+};
+//# sourceMappingURL=chunk-FGS67GT3.js.map