stickyflow 0.0.0-stage → 0.2.0

package/dist/chunk-6JKNT2YC.js

@@ -0,0 +1,4685 @@
+// src/model/chart/supportedTypes.ts
+var CHART_TYPES = [
+  "bar",
+  "line",
+  "scatter",
+  "radar",
+  "radial",
+  "field",
+  "heatmap",
+  "boxplot",
+  "sankey",
+  "treemap",
+  "mekko",
+  "hexbin",
+  "pie",
+  "radialBar",
+  "polarArea",
+  "custom"
+];
+function isChartType(value) {
+  return value !== void 0 && CHART_TYPES.includes(value);
+}
+
+// src/model/isometricObject/geometry.ts
+var VISIBLE_ISOMETRIC_FACES = /* @__PURE__ */ new Set(["top", "front", "right"]);
+var AXIS_ANGLE = Math.PI / 6;
+var AXIS_COS = Math.cos(AXIS_ANGLE);
+var AXIS_SIN = Math.sin(AXIS_ANGLE);
+function isometricBounds(object) {
+  const width = Math.max(0, object.width);
+  const height = Math.max(0, object.height);
+  const depth = Math.max(0, object.depth);
+  return {
+    x: object.x,
+    y: object.y,
+    width: (width + depth) * AXIS_COS,
+    height: height + (width + depth) * AXIS_SIN
+  };
+}
+function isometricTopFaceCenter(object) {
+  const width = Math.max(0, object.width);
+  const depth = Math.max(0, object.depth);
+  return {
+    x: object.x + (width + depth) * AXIS_COS / 2,
+    y: object.y + (width + depth) * AXIS_SIN / 2
+  };
+}
+function faceCenter(corners) {
+  return {
+    x: (corners[0].x + corners[1].x + corners[2].x + corners[3].x) / 4,
+    y: (corners[0].y + corners[1].y + corners[2].y + corners[3].y) / 4
+  };
+}
+function isometricFaceCenter(object, face) {
+  return faceCenter(isometricFaces(object)[face]);
+}
+function isometricFaces(object) {
+  const { x, y } = object;
+  const width = Math.max(0, object.width);
+  const height = Math.max(0, object.height);
+  const depth = Math.max(0, object.depth);
+  const apex = { x: x + depth * AXIS_COS, y };
+  const toRight = { x: width * AXIS_COS, y: width * AXIS_SIN };
+  const toLeft = { x: -depth * AXIS_COS, y: depth * AXIS_SIN };
+  const down = { x: 0, y: height };
+  const right = { x: apex.x + toRight.x, y: apex.y + toRight.y };
+  const left = { x: apex.x + toLeft.x, y: apex.y + toLeft.y };
+  const center = { x: apex.x + toRight.x + toLeft.x, y: apex.y + toRight.y + toLeft.y };
+  const apexDown = { x: apex.x + down.x, y: apex.y + down.y };
+  const bottom = { x: center.x + down.x, y: center.y + down.y };
+  const bottomLeft = { x: left.x + down.x, y: left.y + down.y };
+  const bottomRight = { x: right.x + down.x, y: right.y + down.y };
+  return {
+    top: [apex, right, center, left],
+    bottom: [apexDown, bottomRight, bottom, bottomLeft],
+    front: [left, center, bottom, bottomLeft],
+    back: [apex, right, bottomRight, apexDown],
+    right: [center, right, bottomRight, bottom],
+    left: [apex, left, bottomLeft, apexDown]
+  };
+}
+
+// src/model/isometricObject/shading.ts
+function clamp255(value) {
+  return Math.max(0, Math.min(255, Math.round(value)));
+}
+function hexToRgb(hex) {
+  const match = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim());
+  if (!match) {
+    return null;
+  }
+  const n = Number.parseInt(match[1], 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function rgbToHex(r, g, b) {
+  return `#${[r, g, b].map((channel) => clamp255(channel).toString(16).padStart(2, "0")).join("")}`;
+}
+function multiply(hex, factor) {
+  const rgb = hexToRgb(hex);
+  if (!rgb) {
+    return hex;
+  }
+  const [r, g, b] = rgb;
+  return rgbToHex(r * factor, g * factor, b * factor);
+}
+function deriveFaceFills(fill) {
+  return {
+    topFill: fill,
+    frontFill: multiply(fill, 0.95),
+    sideFill: multiply(fill, 0.88)
+  };
+}
+
+// src/sflLanguage/lexing/cursor.ts
+var SourceCursor = class {
+  constructor(input) {
+    this.input = input;
+  }
+  input;
+  offset = 0;
+  line = 1;
+  col = 1;
+  get done() {
+    return this.offset >= this.input.length;
+  }
+  peek(ahead = 0) {
+    return this.input[this.offset + ahead];
+  }
+  startsWith(value) {
+    return this.input.startsWith(value, this.offset);
+  }
+  position() {
+    return { line: this.line, col: this.col };
+  }
+  advance() {
+    const character = this.input[this.offset];
+    if (character === void 0) {
+      throw new Error("Cannot advance beyond the end of the SFL source.");
+    }
+    this.offset++;
+    if (character === "\n" || character === "\r" && this.peek() !== "\n") {
+      this.line++;
+      this.col = 1;
+    } else {
+      this.col++;
+    }
+    return character;
+  }
+};
+
+// src/sflLanguage/lexing/error.ts
+var SflLexError = class extends Error {
+  constructor(message, line, col) {
+    super(`SFL lex error (${line}:${col}): ${message}`);
+    this.line = line;
+    this.col = col;
+    this.name = "SflLexError";
+  }
+  line;
+  col;
+};
+
+// src/sflLanguage/lexing/characters.ts
+var isLetter = (character) => character !== void 0 && /^[A-Za-z_]$/.test(character);
+var isDigit = (character) => character !== void 0 && character >= "0" && character <= "9";
+var isIdentPart = (character) => character !== void 0 && /^[A-Za-z0-9_]$/.test(character);
+
+// src/sflLanguage/lexing/tokenCreation.ts
+function createToken(type, value, start, detail = {}) {
+  return {
+    type,
+    value,
+    line: start.line,
+    col: start.col,
+    endLine: start.line,
+    endCol: start.col,
+    ...detail
+  };
+}
+function withTokenEnd(token, cursor) {
+  return {
+    ...token,
+    endLine: cursor.line,
+    endCol: cursor.col
+  };
+}
+
+// src/sflLanguage/lexing/identifiers.ts
+function startsIdentifier(cursor) {
+  return isLetter(cursor.peek());
+}
+function readIdentifier(cursor, start) {
+  let value = "";
+  while (isIdentPart(cursor.peek())) {
+    value += cursor.advance();
+  }
+  return createToken("ident", value, start);
+}
+
+// src/sflLanguage/lexing/lineBreak.ts
+function isLineBreak(character) {
+  return character === "\r" || character === "\n";
+}
+function readLineBreak(cursor, start) {
+  const firstCharacter = cursor.advance();
+  if (firstCharacter === "\r" && cursor.peek() === "\n") {
+    cursor.advance();
+  }
+  return createToken("newline", "\n", start);
+}
+
+// src/sflLanguage/lexing/lineComment.ts
+function startsLineComment(cursor) {
+  return cursor.peek() === "/" && cursor.peek(1) === "/";
+}
+function consumeLineComment(cursor) {
+  while (!cursor.done && cursor.peek() !== "\n" && cursor.peek() !== "\r") {
+    cursor.advance();
+  }
+}
+
+// src/sflLanguage/lexing/numbers.ts
+function startsNumber(cursor) {
+  const character = cursor.peek();
+  return isDigit(character) || character === "-" && isDigit(cursor.peek(1));
+}
+function readNumber(cursor, start) {
+  let value = "";
+  if (cursor.peek() === "-") {
+    value += cursor.advance();
+  }
+  while (isDigit(cursor.peek())) {
+    value += cursor.advance();
+  }
+  if (cursor.peek() === "." && isDigit(cursor.peek(1))) {
+    value += cursor.advance();
+    while (isDigit(cursor.peek())) {
+      value += cursor.advance();
+    }
+  }
+  return createToken("number", value, start, { numberValue: Number(value) });
+}
+
+// src/sflLanguage/lexing/operators.ts
+var OPERATORS = [
+  ["<->", "bind2"],
+  ["<-", "bind"],
+  ["->", "action"],
+  ["&&", "op"],
+  ["||", "op"],
+  [">=", "op"],
+  ["<=", "op"],
+  ["==", "op"],
+  ["!=", "op"],
+  ["+", "op"],
+  ["-", "op"],
+  ["*", "op"],
+  ["/", "op"],
+  [">", "op"],
+  ["<", "op"],
+  ["!", "op"]
+];
+var startsNumber2 = (character) => character !== void 0 && /[\d.]/.test(character);
+function readOperator(cursor, start) {
+  const match = OPERATORS.find(([text2]) => cursor.startsWith(text2));
+  if (!match) {
+    return null;
+  }
+  const [text, type] = match;
+  if (text === "-" && startsNumber2(cursor.peek(1))) {
+    return null;
+  }
+  for (let index = 0; index < text.length; index++) {
+    cursor.advance();
+  }
+  return createToken(type, text, start);
+}
+
+// src/sflLanguage/lexing/punctuation.ts
+var PUNCTUATION = {
+  "{": "lbrace",
+  "}": "rbrace",
+  "[": "lbracket",
+  "]": "rbracket",
+  "(": "lparen",
+  ")": "rparen",
+  ":": "colon",
+  ",": "comma",
+  ";": "semi",
+  ".": "dot",
+  "&": "amp"
+};
+function readPunctuation(cursor, start) {
+  const character = cursor.peek();
+  const type = character ? PUNCTUATION[character] : void 0;
+  if (!character || !type || character === "&" && cursor.peek(1) === "&") {
+    return null;
+  }
+  cursor.advance();
+  return createToken(type, character, start);
+}
+
+// src/sflLanguage/lexing/spacing.ts
+function isSpacing(character) {
+  return character === " " || character === "	";
+}
+function consumeSpacing(cursor) {
+  cursor.advance();
+}
+
+// src/sflLanguage/lexing/strings.ts
+function indentationWidth(line) {
+  let width = 0;
+  while (line[width] === " " || line[width] === "	") {
+    width++;
+  }
+  return width;
+}
+function dedent(text) {
+  const lines = text.split("\n");
+  let margin = Infinity;
+  for (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+    margin = Math.min(margin, indentationWidth(line));
+  }
+  if (!Number.isFinite(margin) || margin === 0) {
+    return text;
+  }
+  return lines.map((line) => line.trim() ? line.slice(margin) : line).join("\n");
+}
+function readLongString(cursor, start) {
+  consumeLongStringDelimiter(cursor);
+  let body = "";
+  while (!cursor.done) {
+    if (cursor.startsWith('"""')) {
+      consumeLongStringDelimiter(cursor);
+      return dedent(body.replace(/^\r?\n/, "").replace(/\r?\n[ \t]*$/, ""));
+    }
+    body += cursor.advance();
+  }
+  throw new SflLexError("unterminated long string", start.line, start.col);
+}
+function consumeLongStringDelimiter(cursor) {
+  cursor.advance();
+  cursor.advance();
+  cursor.advance();
+}
+function readShortString(cursor, start) {
+  cursor.advance();
+  let value = "";
+  while (!cursor.done) {
+    const character = cursor.advance();
+    if (character === '"') {
+      return value;
+    }
+    if (character === "\n" || character === "\r") {
+      throw new SflLexError('newline in short string (use """ for multiline)', start.line, start.col);
+    }
+    value += character === "\\" ? readEscapedCharacter(cursor, start) : character;
+  }
+  throw new SflLexError("unterminated string", start.line, start.col);
+}
+function readEscapedCharacter(cursor, start) {
+  if (cursor.done) {
+    throw new SflLexError("unterminated escape sequence", start.line, start.col);
+  }
+  const escaped = cursor.advance();
+  switch (escaped) {
+    case '"':
+      return '"';
+    case "\\":
+      return "\\";
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    default:
+      throw new SflLexError(`invalid escape '\\${escaped}'`, start.line, start.col);
+  }
+}
+function readString(cursor, start) {
+  return cursor.startsWith('"""') ? readLongString(cursor, start) : readShortString(cursor, start);
+}
+function readStringToken(cursor, start) {
+  return createToken("string", readString(cursor, start), start);
+}
+
+// src/sflLanguage/lexing/nextToken.ts
+function readNextToken(cursor) {
+  const character = cursor.peek();
+  if (character === void 0) {
+    return null;
+  }
+  const start = cursor.position();
+  if (isLineBreak(character)) {
+    return readLineBreak(cursor, start);
+  }
+  if (consumeLexerTrivia(cursor, character)) {
+    return null;
+  }
+  const token = readSymbolToken(cursor, character, start) ?? readWordToken(cursor, start);
+  if (token) {
+    return token;
+  }
+  throw new SflLexError(`unexpected character '${character}'`, start.line, start.col);
+}
+function consumeLexerTrivia(cursor, character) {
+  if (isSpacing(character)) {
+    consumeSpacing(cursor);
+    return true;
+  }
+  if (startsLineComment(cursor)) {
+    consumeLineComment(cursor);
+    return true;
+  }
+  return false;
+}
+function readSymbolToken(cursor, character, start) {
+  const punctuation = readPunctuation(cursor, start);
+  if (punctuation) {
+    return punctuation;
+  }
+  if (character === '"') {
+    return readStringToken(cursor, start);
+  }
+  return readOperator(cursor, start);
+}
+function readWordToken(cursor, start) {
+  if (startsNumber(cursor)) {
+    return readNumber(cursor, start);
+  }
+  if (startsIdentifier(cursor)) {
+    return readIdentifier(cursor, start);
+  }
+  return null;
+}
+
+// src/sflLanguage/lexing/tokenizer.ts
+function tokenizeSource(input) {
+  const cursor = new SourceCursor(input);
+  const tokens = [];
+  while (!cursor.done) {
+    const token = readNextToken(cursor);
+    if (token) {
+      tokens.push(withTokenEnd(token, cursor));
+    }
+  }
+  tokens.push(withTokenEnd(createToken("eof", "", cursor.position()), cursor));
+  return tokens;
+}
+
+// src/sflLanguage/parsing/error.ts
+var SflParseError = class extends Error {
+  constructor(message, line, col) {
+    super(`SFL parse error (${line}:${col}): ${message}`);
+    this.line = line;
+    this.col = col;
+    this.name = "SflParseError";
+  }
+  line;
+  col;
+};
+
+// src/sflLanguage/parsing/cursor.ts
+var TokenCursor = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  position = 0;
+  peek(offset = 0) {
+    return this.tokens[Math.min(this.position + offset, this.tokens.length - 1)];
+  }
+  at(type) {
+    return this.peek().type === type;
+  }
+  next() {
+    return this.tokens[this.position++];
+  }
+  expect(type, description) {
+    const token = this.peek();
+    if (token.type !== type) {
+      throw new SflParseError(`expected ${description}, got '${token.value || token.type}'`, token.line, token.col);
+    }
+    return this.next();
+  }
+  expectNumber(description) {
+    const token = this.expect("number", description);
+    if (token.numberValue === void 0) {
+      throw new SflParseError(`expected ${description} to contain a numeric value`, token.line, token.col);
+    }
+    return token.numberValue;
+  }
+  skipNewlines() {
+    while (this.at("newline")) {
+      this.next();
+    }
+  }
+};
+
+// src/sflLanguage/ast.ts
+var NAMED_BLOCK_KINDS = [
+  "Project",
+  "Model",
+  "Group",
+  "Entity",
+  "Container",
+  "Path",
+  "Chart",
+  "Widget",
+  "Shape",
+  "Text",
+  "Isometric",
+  "Link",
+  "Connection",
+  "Layout",
+  "Style",
+  "Shader",
+  "Axis",
+  "Series",
+  "Rule",
+  "Net",
+  "Symbol",
+  "Port",
+  "DataSource"
+];
+var SIDES = ["top", "bottom", "left", "right"];
+var isSide = (s) => SIDES.includes(s);
+var isNamedBlockKind = (s) => NAMED_BLOCK_KINDS.includes(s);
+
+// src/sflLanguage/parsing/values.ts
+function parsePathSegments(cursor) {
+  const segments = [cursor.expect("ident", "path identifier").value];
+  while (cursor.at("dot")) {
+    cursor.next();
+    segments.push(cursor.expect("ident", 'identifier after "."').value);
+  }
+  return segments;
+}
+function parseEndpoint(cursor) {
+  const segments = parsePathSegments(cursor);
+  let side;
+  let fraction;
+  if (cursor.at("comma")) {
+    cursor.next();
+    const sideToken = cursor.expect("ident", 'side after ","');
+    if (!isSide(sideToken.value)) {
+      throw new SflParseError(
+        `expected a side (top/right/bottom/left), got '${sideToken.value}'`,
+        sideToken.line,
+        sideToken.col
+      );
+    }
+    side = sideToken.value;
+    if (cursor.at("lparen")) {
+      cursor.next();
+      fraction = cursor.expectNumber('fraction inside "("');
+      cursor.expect("rparen", "')'");
+    }
+  }
+  return { type: "endpoint", segments, side, fraction };
+}
+function parseList(cursor) {
+  cursor.expect("lbracket", "'['");
+  const values = [];
+  cursor.skipNewlines();
+  if (!cursor.at("rbracket")) {
+    values.push(parseValue(cursor, false));
+    cursor.skipNewlines();
+    while (cursor.at("comma")) {
+      cursor.next();
+      cursor.skipNewlines();
+      if (cursor.at("rbracket")) {
+        break;
+      }
+      values.push(parseValue(cursor, false));
+      cursor.skipNewlines();
+    }
+  }
+  cursor.expect("rbracket", "']'");
+  return { type: "list", values };
+}
+function parseValue(cursor, allowTuple = true) {
+  const token = cursor.peek();
+  switch (token.type) {
+    case "string":
+      cursor.next();
+      return { type: "string", value: token.value };
+    case "lbracket":
+      return parseList(cursor);
+    case "number": {
+      const firstValue = cursor.expectNumber("number");
+      if (!allowTuple || !cursor.at("comma")) {
+        return { type: "number", value: firstValue };
+      }
+      const values = [firstValue];
+      while (cursor.at("comma")) {
+        cursor.next();
+        values.push(cursor.expectNumber("number in tuple"));
+      }
+      return { type: "tuple", values };
+    }
+    case "ident":
+      return { type: "ident", segments: parsePathSegments(cursor) };
+    default:
+      throw new SflParseError(`expected a value, got '${token.value || token.type}'`, token.line, token.col);
+  }
+}
+
+// src/sflLanguage/parsing/expressions.ts
+var COMPARISONS = /* @__PURE__ */ new Set([">", "<", ">=", "<=", "==", "!="]);
+function atOperator(cursor, operators) {
+  const token = cursor.peek();
+  return token.type === "op" && operators.has(token.value);
+}
+function parseBinaryLevel(cursor, operators, parseOperand) {
+  let left = parseOperand(cursor);
+  while (atOperator(cursor, operators)) {
+    const operator = cursor.next().value;
+    left = { kind: "binary", operator, left, right: parseOperand(cursor) };
+  }
+  return left;
+}
+var OR = /* @__PURE__ */ new Set(["||"]);
+var AND = /* @__PURE__ */ new Set(["&&"]);
+var ADDITIVE = /* @__PURE__ */ new Set(["+", "-"]);
+var MULTIPLICATIVE = /* @__PURE__ */ new Set(["*", "/"]);
+function parseExpression(cursor) {
+  return parseBinaryLevel(cursor, OR, parseAnd);
+}
+function parseAnd(cursor) {
+  return parseBinaryLevel(cursor, AND, parseComparison);
+}
+function parseComparison(cursor) {
+  return parseBinaryLevel(cursor, COMPARISONS, parseAdditive);
+}
+function parseAdditive(cursor) {
+  return parseBinaryLevel(cursor, ADDITIVE, parseMultiplicative);
+}
+function parseMultiplicative(cursor) {
+  return parseBinaryLevel(cursor, MULTIPLICATIVE, parseUnary);
+}
+function parseUnary(cursor) {
+  const token = cursor.peek();
+  if (token.type === "op" && (token.value === "!" || token.value === "-")) {
+    cursor.next();
+    return { kind: "unary", operator: token.value, operand: parseUnary(cursor) };
+  }
+  return parsePrimary(cursor);
+}
+function parseCallArguments(cursor) {
+  cursor.expect("lparen", "'('");
+  const args = [];
+  cursor.skipNewlines();
+  while (!cursor.at("rparen")) {
+    args.push(parseExpression(cursor));
+    cursor.skipNewlines();
+    if (cursor.at("comma")) {
+      cursor.next();
+      cursor.skipNewlines();
+    } else if (!cursor.at("rparen")) {
+      const token = cursor.peek();
+      throw new SflParseError(`expected ',' or ')', got '${token.value || token.type}'`, token.line, token.col);
+    }
+  }
+  cursor.expect("rparen", "')'");
+  return args;
+}
+function parsePrimary(cursor) {
+  const token = cursor.peek();
+  switch (token.type) {
+    case "number":
+      return { kind: "number", value: cursor.expectNumber("number") };
+    case "string":
+      cursor.next();
+      return { kind: "string", value: token.value };
+    case "lparen": {
+      cursor.next();
+      const inner = parseExpression(cursor);
+      cursor.expect("rparen", "')'");
+      return inner;
+    }
+    case "ident": {
+      const path = parsePathSegments(cursor);
+      if (path.length === 1 && (path[0] === "true" || path[0] === "false")) {
+        return { kind: "boolean", value: path[0] === "true" };
+      }
+      return cursor.at("lparen") ? { kind: "call", callee: path, args: parseCallArguments(cursor) } : { kind: "ref", path };
+    }
+    default:
+      throw new SflParseError(`expected an expression, got '${token.value || token.type}'`, token.line, token.col);
+  }
+}
+var BINDING_OPERATORS = ["bind", "bind2", "action"];
+function atBinding(cursor) {
+  return cursor.peek().type === "ident" && cursor.peek(1).type === "colon" && BINDING_OPERATORS.includes(cursor.peek(2).type);
+}
+function parseBinding(cursor) {
+  const key = cursor.expect("ident", "bound property");
+  cursor.expect("colon", "':'");
+  const operator = cursor.next().value;
+  const expr = parseExpression(cursor);
+  const next = cursor.peek();
+  if (!["newline", "semi", "rbrace", "eof"].includes(next.type)) {
+    throw new SflParseError(`unexpected '${next.value || next.type}' after binding`, next.line, next.col);
+  }
+  return { key: key.value, operator, expr, line: key.line, col: key.col };
+}
+function parseAssignment(cursor) {
+  const start = cursor.peek();
+  const target = parsePathSegments(cursor);
+  cursor.expect("bind", "'<-'");
+  const expr = parseExpression(cursor);
+  return { target, expr, line: start.line, col: start.col };
+}
+function atHandler(cursor) {
+  const token = cursor.peek();
+  return token.type === "ident" && /^on[A-Z]/.test(token.value) && ["colon", "lbrace"].includes(cursor.peek(1).type);
+}
+function parseHandler(cursor) {
+  const event = cursor.expect("ident", "event name");
+  const assignments = [];
+  if (cursor.at("colon")) {
+    cursor.next();
+    assignments.push(parseAssignment(cursor));
+    expectEnd(cursor, "handler");
+  } else {
+    cursor.expect("lbrace", "'{'");
+    cursor.skipNewlines();
+    while (!cursor.at("rbrace")) {
+      if (cursor.at("eof")) {
+        throw new SflParseError(`unterminated handler '${event.value}'`, event.line, event.col);
+      }
+      assignments.push(parseAssignment(cursor));
+      expectEnd(cursor, "assignment");
+      cursor.skipNewlines();
+    }
+    cursor.expect("rbrace", "'}'");
+  }
+  return { event: event.value, assignments, line: event.line, col: event.col };
+}
+function expectEnd(cursor, what) {
+  const next = cursor.peek();
+  if (!["newline", "semi", "rbrace", "eof"].includes(next.type)) {
+    throw new SflParseError(`unexpected '${next.value || next.type}' after ${what}`, next.line, next.col);
+  }
+  if (next.type === "semi") {
+    cursor.next();
+  }
+}
+
+// src/sflLanguage/parsing/properties.ts
+var PropertyParser = class {
+  constructor(cursor) {
+    this.cursor = cursor;
+  }
+  cursor;
+  parseLayout() {
+    this.cursor.next();
+    return { properties: this.parsePropertyBlock("layout") };
+  }
+  parseStyle() {
+    this.cursor.next();
+    this.cursor.skipNewlines();
+    this.cursor.expect("lbrace", "'{'");
+    const properties = [];
+    const bindings = [];
+    this.cursor.skipNewlines();
+    while (!this.cursor.at("rbrace")) {
+      if (this.cursor.at("eof")) {
+        const token = this.cursor.peek();
+        throw new SflParseError("unterminated style block", token.line, token.col);
+      }
+      if (atBinding(this.cursor)) {
+        bindings.push(parseBinding(this.cursor));
+        if (this.cursor.at("newline") || this.cursor.at("semi")) {
+          this.cursor.next();
+        }
+      } else {
+        properties.push(this.parseProperty());
+      }
+      this.cursor.skipNewlines();
+    }
+    this.cursor.expect("rbrace", "'}'");
+    return bindings.length ? { properties, bindings } : { properties };
+  }
+  parseFields() {
+    this.cursor.next();
+    return this.parsePropertyBlock("fields");
+  }
+  parseProperty() {
+    const key = this.cursor.expect("ident", "property key").value;
+    this.cursor.expect("colon", "':'");
+    const value = key === "from" || key === "to" ? parseEndpoint(this.cursor) : parseValue(this.cursor);
+    this.consumeTerminator();
+    return { key, value };
+  }
+  parsePropertyBlock(kind) {
+    this.cursor.skipNewlines();
+    this.cursor.expect("lbrace", "'{'");
+    const properties = [];
+    this.cursor.skipNewlines();
+    while (!this.cursor.at("rbrace")) {
+      if (this.cursor.at("eof")) {
+        const token = this.cursor.peek();
+        throw new SflParseError(`unterminated ${kind} block`, token.line, token.col);
+      }
+      properties.push(this.parseProperty());
+      this.cursor.skipNewlines();
+    }
+    this.cursor.expect("rbrace", "'}'");
+    return properties;
+  }
+  consumeTerminator() {
+    if (this.cursor.at("newline") || this.cursor.at("semi")) {
+      this.cursor.next();
+      return;
+    }
+    if (this.cursor.at("rbrace") || this.cursor.at("eof")) {
+      return;
+    }
+    const token = this.cursor.peek();
+    throw new SflParseError(`unexpected '${token.value || token.type}' after property value`, token.line, token.col);
+  }
+};
+
+// src/sflLanguage/parsing/blocks.ts
+var BlockParser = class {
+  constructor(cursor) {
+    this.cursor = cursor;
+    this.properties = new PropertyParser(cursor);
+  }
+  cursor;
+  properties;
+  parseBlock() {
+    const kind = this.cursor.expect("ident", "block kind");
+    if (!isNamedBlockKind(kind.value)) {
+      throw new SflParseError(`unknown block kind '${kind.value}'`, kind.line, kind.col);
+    }
+    const name = this.cursor.expect("ident", "block name");
+    const composition = this.parseComposition();
+    const entries = this.parseBlockEntries();
+    return { kind: kind.value, name: name.value, composition, entries };
+  }
+  parseComposition() {
+    if (!this.cursor.at("colon")) {
+      return [];
+    }
+    this.cursor.next();
+    const composition = [this.cursor.expect("ident", 'reference name after ":"').value];
+    while (this.cursor.at("amp")) {
+      this.cursor.next();
+      composition.push(this.cursor.expect("ident", 'reference name after "&"').value);
+    }
+    return composition;
+  }
+  parseBlockEntries() {
+    return this.parseEntries(() => this.parseBlockEntry());
+  }
+  parseDataEntries() {
+    return this.parseEntries(() => this.parseDataEntry());
+  }
+  parseEntries(parseEntry) {
+    this.cursor.skipNewlines();
+    this.cursor.expect("lbrace", "'{'");
+    const entries = [];
+    this.cursor.skipNewlines();
+    while (!this.cursor.at("rbrace")) {
+      if (this.cursor.at("eof")) {
+        const token = this.cursor.peek();
+        throw new SflParseError('unterminated block (missing "}")', token.line, token.col);
+      }
+      entries.push(parseEntry());
+      if (this.cursor.at("semi")) {
+        this.cursor.next();
+      }
+      this.cursor.skipNewlines();
+    }
+    this.cursor.expect("rbrace", "'}'");
+    return entries;
+  }
+  parseBlockEntry() {
+    const token = this.cursor.peek();
+    if (token.type !== "ident") {
+      throw new SflParseError(
+        `expected property, block, layout, or style \u2014 got '${token.value || token.type}'`,
+        token.line,
+        token.col
+      );
+    }
+    if (isNamedBlockKind(token.value) && this.cursor.peek(1).type === "ident") {
+      return { type: "block", block: this.parseBlock() };
+    }
+    if (token.value === "layout" && this.cursor.peek(1).type === "lbrace") {
+      return { type: "layout", layout: this.properties.parseLayout() };
+    }
+    if (token.value === "style" && this.cursor.peek(1).type === "lbrace") {
+      return { type: "style", style: this.properties.parseStyle() };
+    }
+    if (token.value === "fields" && this.cursor.peek(1).type === "lbrace") {
+      return { type: "fields", fields: this.properties.parseFields() };
+    }
+    if (atBinding(this.cursor)) {
+      return { type: "binding", binding: parseBinding(this.cursor) };
+    }
+    if (atHandler(this.cursor)) {
+      return { type: "handler", handler: parseHandler(this.cursor) };
+    }
+    if (token.value === "data" && this.cursor.peek(1).type === "lbrace") {
+      return { type: "data", data: this.parseDataBlock() };
+    }
+    return { type: "property", property: this.properties.parseProperty() };
+  }
+  parseDataEntry() {
+    const token = this.cursor.peek();
+    if (token.type === "ident" && !isNamedBlockKind(token.value) && this.looksLikeSeriesEntry()) {
+      return { type: "block", block: this.parseSeriesEntry() };
+    }
+    return this.parseBlockEntry();
+  }
+  parseDataBlock() {
+    this.cursor.next();
+    return { kind: "data", name: "", composition: [], entries: this.parseDataEntries() };
+  }
+  looksLikeSeriesEntry() {
+    if (this.cursor.peek(1).type === "lbrace") {
+      return true;
+    }
+    if (this.cursor.peek(1).type !== "colon") {
+      return false;
+    }
+    let offset = 2;
+    if (this.cursor.peek(offset).type !== "ident") {
+      return false;
+    }
+    offset++;
+    while (this.cursor.peek(offset).type === "amp") {
+      offset++;
+      if (this.cursor.peek(offset).type !== "ident") {
+        return false;
+      }
+      offset++;
+    }
+    return this.cursor.peek(offset).type === "lbrace";
+  }
+  parseSeriesEntry() {
+    const name = this.cursor.expect("ident", "series name");
+    const composition = this.parseComposition();
+    const entries = this.parseBlockEntries();
+    return { kind: "Series", name: name.value, composition, entries };
+  }
+};
+
+// src/sflLanguage/parsing/document.ts
+var DocumentParser = class {
+  constructor(cursor) {
+    this.cursor = cursor;
+    this.blocks = new BlockParser(cursor);
+  }
+  cursor;
+  blocks;
+  parseDocument() {
+    this.cursor.skipNewlines();
+    const header = this.cursor.expect("ident", "'sfl' header");
+    if (header.value !== "sfl") {
+      throw new SflParseError(`document must start with 'sfl', got '${header.value}'`, header.line, header.col);
+    }
+    const version = this.cursor.expect("number", "version number");
+    this.cursor.skipNewlines();
+    const blocks = [];
+    while (!this.cursor.at("eof")) {
+      blocks.push(this.blocks.parseBlock());
+      this.cursor.skipNewlines();
+    }
+    return { version: version.value, blocks };
+  }
+};
+
+// src/sflLanguage/parsing/parser.ts
+function parseSource(input) {
+  return new DocumentParser(new TokenCursor(tokenizeSource(input))).parseDocument();
+}
+
+// src/sflLanguage/emitting/blockEntries.ts
+function collectBlockEntries(block2) {
+  const entries = {
+    properties: [],
+    blocks: [],
+    layouts: [],
+    styles: [],
+    dataBlocks: [],
+    fields: [],
+    bindings: [],
+    handlers: []
+  };
+  for (const entry of block2.entries) {
+    if (entry.type === "property") {
+      entries.properties.push(entry.property);
+    } else if (entry.type === "block") {
+      entries.blocks.push(entry.block);
+    } else if (entry.type === "layout") {
+      entries.layouts.push(entry.layout);
+    } else if (entry.type === "style") {
+      entries.styles.push(entry.style);
+    } else if (entry.type === "fields") {
+      entries.fields.push(entry.fields);
+    } else if (entry.type === "binding") {
+      entries.bindings.push(entry.binding);
+    } else if (entry.type === "handler") {
+      entries.handlers.push(entry.handler);
+    } else {
+      entries.dataBlocks.push(entry.data);
+    }
+  }
+  return entries;
+}
+
+// src/sflLanguage/emitting/composition.ts
+function emitComposition(composition) {
+  if (!composition.length) {
+    return "";
+  }
+  return ` : ${composition.join(" & ")}`;
+}
+
+// src/sflLanguage/emitting/values.ts
+function formatNumber(value) {
+  if (Object.is(value, -0)) {
+    return "0";
+  }
+  return String(value);
+}
+function emitString(value) {
+  const escaped = value.replace(/\r\n?/g, "\n").replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+  return `"${escaped}"`;
+}
+function emitValue(value) {
+  switch (value.type) {
+    case "string":
+      return emitString(value.value);
+    case "number":
+      return formatNumber(value.value);
+    case "tuple":
+      return value.values.map(formatNumber).join(", ");
+    case "list":
+      return `[${value.values.map(emitValue).join(", ")}]`;
+    case "ident":
+      return value.segments.join(".");
+    case "endpoint": {
+      let output = value.segments.join(".");
+      if (value.side) {
+        output += `, ${value.side}`;
+        if (value.fraction !== void 0) {
+          output += ` (${formatNumber(value.fraction)})`;
+        }
+      }
+      return output;
+    }
+  }
+}
+var emitProperty = (property) => `${property.key}: ${emitValue(property.value)}`;
+
+// src/sflLanguage/emitting/expressions.ts
+var PRECEDENCE = {
+  "||": 1,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  "+": 4,
+  "-": 4,
+  "*": 5,
+  "/": 5
+};
+function emitExpression(expr, parentPrecedence = 0) {
+  switch (expr.kind) {
+    case "number":
+      return String(expr.value);
+    case "string":
+      return emitValue({ type: "string", value: expr.value });
+    case "boolean":
+      return String(expr.value);
+    case "ref":
+      return expr.path.join(".");
+    case "unary":
+      return `${expr.operator}${emitExpression(expr.operand, 6)}`;
+    case "call":
+      return `${expr.callee.join(".")}(${expr.args.map((arg) => emitExpression(arg)).join(", ")})`;
+    case "binary": {
+      const precedence = PRECEDENCE[expr.operator];
+      const text = `${emitExpression(expr.left, precedence)} ${expr.operator} ${emitExpression(expr.right, precedence + 1)}`;
+      return precedence < parentPrecedence ? `(${text})` : text;
+    }
+  }
+}
+var emitAssignment = (assignment) => `${assignment.target.join(".")} <- ${emitExpression(assignment.expr)}`;
+function emitHandler(handler, pad) {
+  if (handler.assignments.length === 1) {
+    return `${pad}${handler.event}: ${emitAssignment(handler.assignments[0])}`;
+  }
+  const lines = handler.assignments.map((assignment) => `${pad}  ${emitAssignment(assignment)}`);
+  return [`${pad}${handler.event} {`, ...lines, `${pad}}`].join("\n");
+}
+var emitBinding = (binding) => `${binding.key}: ${binding.operator} ${emitExpression(binding.expr)}`;
+
+// src/sflLanguage/emitting/propertyOrder.ts
+var LAYOUT_ORDER = ["position", "size", "rotation", "order"];
+var STYLE_ORDER = [
+  "shape",
+  "fill",
+  "stroke",
+  "strokeWidth",
+  "strokeStyle",
+  "textColor",
+  "color",
+  "fontSize",
+  "fontWeight",
+  "fontFamily",
+  "textAlign",
+  "verticalAlign",
+  "cornerRadius",
+  "dash",
+  "shadow",
+  "opacity",
+  "icon",
+  "route",
+  "marker",
+  "markerStart",
+  "markerEnd",
+  "asset"
+];
+var alphabetical = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function compareProps(a, b) {
+  const rank = (key) => key === "id" ? 0 : key === "kind" ? 1 : key === "text" ? 2 : 3;
+  return rank(a) - rank(b) || alphabetical(a, b);
+}
+function compareByOrder(order, a, b) {
+  const aIndex = order.indexOf(a);
+  const bIndex = order.indexOf(b);
+  const aRank = aIndex === -1 ? order.length : aIndex;
+  const bRank = bIndex === -1 ? order.length : bIndex;
+  return aRank - bRank || alphabetical(a, b);
+}
+var compareLayoutProps = (a, b) => compareByOrder(LAYOUT_ORDER, a, b);
+var compareStyleProps = (a, b) => compareByOrder(STYLE_ORDER, a, b);
+
+// src/sflLanguage/emitting/propertyBlock.ts
+var INDENT = "  ";
+function emitPropertyBlock(name, properties, depth, bindings = []) {
+  const pad = INDENT.repeat(depth);
+  const innerPad = INDENT.repeat(depth + 1);
+  const compare = name === "layout" ? compareLayoutProps : compareStyleProps;
+  const lines = [...properties].sort((left, right) => compare(left.key, right.key)).map((property) => `${innerPad}${emitProperty(property)}`);
+  lines.push(...bindings.map((binding) => `${innerPad}${emitBinding(binding)}`));
+  if (!lines.length) {
+    return `${pad}${name} {
+${pad}}`;
+  }
+  return `${pad}${name} {
+${lines.join("\n")}
+${pad}}`;
+}
+
+// src/sflLanguage/emitting/blocks.ts
+var INDENT2 = "  ";
+var COMPACT_MAX_PROPS = 3;
+function propertyComparator(kind) {
+  if (kind === "Layout") {
+    return compareLayoutProps;
+  }
+  if (kind === "Style") {
+    return compareStyleProps;
+  }
+  return compareProps;
+}
+function joinSiblingBlocks(blocks, depth) {
+  const pad = INDENT2.repeat(depth);
+  const layouts = blocks.filter((block2) => block2.kind === "Layout");
+  const styles = blocks.filter((block2) => block2.kind === "Style");
+  const others = blocks.filter((block2) => block2.kind !== "Layout" && block2.kind !== "Style");
+  const groups = [];
+  if (layouts.length) {
+    groups.push(`${pad}// Layout Definition
+${layouts.map((block2) => emitBlock(block2, depth)).join("\n")}`);
+  }
+  if (styles.length) {
+    groups.push(`${pad}// Style Definition
+${styles.map((block2) => emitBlock(block2, depth)).join("\n")}`);
+  }
+  others.forEach((block2) => {
+    groups.push(emitBlock(block2, depth));
+  });
+  return groups.join("\n\n");
+}
+function emitBlock(block2, depth) {
+  const pad = INDENT2.repeat(depth);
+  const header = `${block2.kind} ${block2.name}${emitComposition(block2.composition)} {`;
+  const entries = collectBlockEntries(block2);
+  const properties = orderedProperties(block2.kind, entries.properties);
+  if (usesCompactBlockForm(block2.kind, entries, properties.length)) {
+    return emitCompactBlock(pad, header, properties);
+  }
+  const body = emitExpandedBlockBody(entries, properties, depth);
+  return emitExpandedBlock(pad, header, body);
+}
+function orderedProperties(kind, properties) {
+  return [...properties].sort((left, right) => propertyComparator(kind)(left.key, right.key));
+}
+function usesCompactBlockForm(kind, entries, propertyCount) {
+  const supportsCompactForm = kind === "Layout" || kind === "Style";
+  const hasNestedContent = entries.blocks.length > 0 || entries.layouts.length > 0 || entries.styles.length > 0 || entries.dataBlocks.length > 0 || entries.fields.length > 0 || entries.bindings.length > 0 || entries.handlers.length > 0;
+  return supportsCompactForm && !hasNestedContent && propertyCount <= COMPACT_MAX_PROPS;
+}
+function emitCompactBlock(pad, header, properties) {
+  const body = properties.map(emitProperty).join("; ");
+  return body ? `${pad}${header} ${body} }` : `${pad}${header} }`;
+}
+function emitExpandedBlockBody(entries, properties, depth) {
+  const primaryEntries = emitPrimaryBlockEntries(entries, properties, depth);
+  const propertyBlocks = emitAttachedPropertyBlocks(entries, depth);
+  return [primaryEntries, propertyBlocks].filter(Boolean).join("\n");
+}
+function emitPrimaryBlockEntries(entries, properties, depth) {
+  const innerPad = INDENT2.repeat(depth + 1);
+  const propertyLines = [
+    ...properties.map((property) => `${innerPad}${emitProperty(property)}`),
+    ...entries.bindings.map((binding) => `${innerPad}${emitBinding(binding)}`),
+    ...entries.handlers.map((handler) => emitHandler(handler, innerPad))
+  ].join("\n");
+  const nestedBlocks = joinSiblingBlocks(entries.blocks, depth + 1);
+  return [propertyLines, nestedBlocks].filter(Boolean).join("\n\n");
+}
+function emitAttachedPropertyBlocks(entries, depth) {
+  const fields = entries.fields.map((properties) => emitFieldsBlock(properties, depth + 1));
+  const dataBlocks = entries.dataBlocks.map((data) => emitDataBlock(data, depth + 1));
+  const layouts = entries.layouts.map((layout) => emitPropertyBlock("layout", layout.properties, depth + 1));
+  const styles = entries.styles.map((style) => emitPropertyBlock("style", style.properties, depth + 1, style.bindings));
+  return [...fields, ...dataBlocks, ...layouts, ...styles].join("\n");
+}
+function emitFieldsBlock(properties, depth) {
+  const pad = INDENT2.repeat(depth);
+  const lines = properties.map((property) => `${pad}${INDENT2}${emitProperty(property)}`);
+  return lines.length ? `${pad}fields {
+${lines.join("\n")}
+${pad}}` : `${pad}fields {
+${pad}}`;
+}
+function emitDataBlock(data, depth) {
+  const pad = INDENT2.repeat(depth);
+  const entries = collectBlockEntries(data);
+  const properties = orderedProperties(data.kind, entries.properties);
+  const body = emitExpandedBlockBody(entries, properties, depth);
+  return emitExpandedBlock(pad, "data {", body);
+}
+function emitExpandedBlock(pad, header, body) {
+  return body ? `${pad}${header}
+${body}
+${pad}}` : `${pad}${header}
+${pad}}`;
+}
+
+// src/sflLanguage/emitting/document.ts
+function emitDocument(doc) {
+  const body = joinSiblingBlocks(doc.blocks, 0);
+  const output = body ? `sfl ${doc.version}
+
+${body}` : `sfl ${doc.version}`;
+  const trimmed = output.split("\n").map((line) => line.replace(/[ \t]+$/, "")).join("\n");
+  return `${trimmed}
+`;
+}
+
+// src/sflLanguage/canonicalize.ts
+function canonicalizeSource(sflText) {
+  return emitDocument(parseSource(sflText));
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/types.ts
+function isChartObject(canvasObject) {
+  return canvasObject.objectType === "chart" && canvasObject.chart !== void 0;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/isometric/types.ts
+function isIsometricObject(canvasObject) {
+  return canvasObject.objectType === "isometric" && canvasObject.isometric !== void 0;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/path/types.ts
+function isPathObject(canvasObject) {
+  return canvasObject.objectType === "path" && canvasObject.path !== void 0;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/swimlane/types.ts
+function isSwimlaneObject(canvasObject) {
+  return canvasObject.objectType === "swimlane" && canvasObject.swimlane !== void 0;
+}
+
+// src/sflSemantic/ast/valueAccess.ts
+function asString(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (value.type === "string") {
+    return value.value;
+  }
+  if (value.type === "ident") {
+    return value.segments.join(".");
+  }
+  if (value.type === "number") {
+    return String(value.value);
+  }
+  return void 0;
+}
+function asNumber(value) {
+  return value?.type === "number" ? value.value : void 0;
+}
+function tupleValues(value) {
+  return value?.type === "tuple" ? value.values : void 0;
+}
+function listNumbers(value) {
+  return value?.type === "list" ? value.values.flatMap((item) => item.type === "number" ? [item.value] : []) : void 0;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/links/endpointReader.ts
+function namedPortReference(segments, context) {
+  if (segments.length < 2) {
+    return null;
+  }
+  const portName = segments[segments.length - 1];
+  const canvasObjectName = segments[segments.length - 2];
+  const canvasObjectId = context.idByName.get(canvasObjectName);
+  const canvasObject = canvasObjectId ? context.canvasObjectById.get(canvasObjectId) : void 0;
+  if (!canvasObject?.symbol?.ports?.some((port) => port.name === portName)) {
+    return null;
+  }
+  return { id: canvasObjectId, port: portName };
+}
+function readLinkEndpoint(value, context) {
+  if (value?.type !== "endpoint") {
+    return {};
+  }
+  const namedPort = namedPortReference(value.segments, context);
+  if (namedPort) {
+    return namedPort;
+  }
+  const endpointName = value.segments[value.segments.length - 1];
+  return {
+    id: context.idByName.get(endpointName) ?? endpointName,
+    side: value.side,
+    fraction: value.fraction
+  };
+}
+
+// src/sflSemantic/ast/blockEntries.ts
+function directProperties(block2) {
+  const properties = /* @__PURE__ */ new Map();
+  for (const entry of block2.entries) {
+    if (entry.type === "property") {
+      properties.set(entry.property.key, entry.property.value);
+    }
+  }
+  return properties;
+}
+function styleProperties(block2) {
+  const properties = /* @__PURE__ */ new Map();
+  for (const entry of block2.entries) {
+    if (entry.type === "style") {
+      for (const property of entry.style.properties) {
+        properties.set(property.key, property.value);
+      }
+    }
+  }
+  return properties;
+}
+function layoutProperties(block2) {
+  const properties = /* @__PURE__ */ new Map();
+  for (const entry of block2.entries) {
+    if (entry.type === "layout") {
+      for (const property of entry.layout.properties) {
+        properties.set(property.key, property.value);
+      }
+    }
+  }
+  return properties;
+}
+function childBlocks(block2) {
+  return block2.entries.flatMap((entry) => entry.type === "block" ? [entry.block] : []);
+}
+function dataEntryBlock(block2) {
+  for (const entry of block2.entries) {
+    if (entry.type === "data") {
+      return entry.data;
+    }
+  }
+  return void 0;
+}
+function contentChildren(block2) {
+  const data = dataEntryBlock(block2);
+  return data ? [...childBlocks(block2), ...childBlocks(data)] : childBlocks(block2);
+}
+function contentProperty(block2, key) {
+  const direct = directProperties(block2).get(key);
+  if (direct !== void 0) {
+    return direct;
+  }
+  const data = dataEntryBlock(block2);
+  return data ? directProperties(data).get(key) : void 0;
+}
+
+// src/sflSemantic/canvasObjects/processing/blockKinds.ts
+var CANVAS_OBJECT_BLOCK_KINDS = [
+  "Entity",
+  "Shape",
+  "Text",
+  "Container",
+  "Path",
+  "Chart",
+  "Widget",
+  "Isometric"
+];
+var canvasObjectBlockKinds = new Set(CANVAS_OBJECT_BLOCK_KINDS);
+function isCanvasObjectBlockKind(kind) {
+  return canvasObjectBlockKinds.has(kind);
+}
+
+// src/sflSemantic/canvasObjects/artifacts/links/nameIndex.ts
+function indexLinkableNames(blocks, idByName) {
+  for (const block2 of blocks) {
+    if (isCanvasObjectBlockKind(block2.kind)) {
+      idByName.set(block2.name, asString(directProperties(block2).get("id")) ?? block2.name);
+    }
+    indexLinkableNames(childBlocks(block2), idByName);
+  }
+}
+function buildLinkNameIndex(model) {
+  const idByName = /* @__PURE__ */ new Map();
+  if (model) {
+    indexLinkableNames(childBlocks(model), idByName);
+  }
+  return idByName;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/links/presentation.ts
+var STRUCTURAL_LINK_PROPERTIES = /* @__PURE__ */ new Set(["id", "from", "to", "text", "order", "segments"]);
+function readLinkPresentation(properties) {
+  const presentation = {};
+  for (const [key, value] of properties) {
+    if (STRUCTURAL_LINK_PROPERTIES.has(key)) {
+      continue;
+    }
+    const text = asString(value);
+    if (text !== void 0) {
+      presentation[key] = text;
+    }
+  }
+  return presentation;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/connections/reader.ts
+var FACES = /* @__PURE__ */ new Set(["top", "bottom", "front", "back", "left", "right"]);
+function readFace(value) {
+  return value !== void 0 && FACES.has(value) ? value : "front";
+}
+function readConnections(model, connectionBlocks, canvasObjects, context, sourceIndexes = []) {
+  const endpointContext = {
+    idByName: buildLinkNameIndex(model),
+    canvasObjectById: new Map(canvasObjects.map((canvasObject) => [canvasObject.id, canvasObject]))
+  };
+  return connectionBlocks.map((block2, index) => {
+    const properties = context.mergedProps(block2);
+    return {
+      id: asString(properties.get("id")) ?? block2.name,
+      fromId: readLinkEndpoint(properties.get("from"), endpointContext).id,
+      toId: readLinkEndpoint(properties.get("to"), endpointContext).id,
+      fromFace: readFace(asString(properties.get("fromFace"))),
+      toFace: readFace(asString(properties.get("toFace"))),
+      order: asNumber(properties.get("order")),
+      sourceIndex: sourceIndexes[index],
+      props: readLinkPresentation(properties)
+    };
+  });
+}
+
+// src/sflSemantic/canvasObjects/artifacts/links/blockReader.ts
+function readLinkBlock(block2, canvasObjectContext, endpointContext) {
+  const properties = canvasObjectContext.mergedProps(block2);
+  const from = readLinkEndpoint(properties.get("from"), endpointContext);
+  const to = readLinkEndpoint(properties.get("to"), endpointContext);
+  return {
+    id: asString(properties.get("id")) ?? block2.name,
+    fromId: from.id,
+    toId: to.id,
+    text: asString(properties.get("text")),
+    fromSide: from.side,
+    fromFraction: from.fraction,
+    toSide: to.side,
+    toFraction: to.fraction,
+    fromPort: from.port,
+    toPort: to.port,
+    order: asNumber(properties.get("order")),
+    segments: listNumbers(properties.get("segments")),
+    props: readLinkPresentation(properties)
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/links/reader.ts
+function readLinks(model, linkBlocks, canvasObjects, context, sourceIndexes = []) {
+  const endpointContext = {
+    idByName: buildLinkNameIndex(model),
+    canvasObjectById: new Map(canvasObjects.map((canvasObject) => [canvasObject.id, canvasObject]))
+  };
+  return linkBlocks.map((block2, index) => ({
+    ...readLinkBlock(block2, context, endpointContext),
+    sourceIndex: sourceIndexes[index]
+  }));
+}
+
+// src/sflSemantic/canvasObjects/artifacts/links/netExpansion.ts
+function netMembers(block2, context) {
+  const membersValue = context.mergedProps(block2).get("members");
+  return membersValue?.type === "list" ? membersValue.values.flatMap((value) => value.type === "ident" ? [value.segments] : []) : [];
+}
+function netLink(block2, from, to, index, text) {
+  const entries = [
+    { type: "property", property: { key: "from", value: { type: "endpoint", segments: from } } },
+    { type: "property", property: { key: "to", value: { type: "endpoint", segments: to } } }
+  ];
+  if (text) {
+    entries.push({
+      type: "property",
+      property: { key: "text", value: { type: "string", value: text } }
+    });
+  }
+  return { kind: "Link", name: `${block2.name}_${index + 1}`, composition: [], entries };
+}
+function expandNetLinks(block2, context) {
+  const members = netMembers(block2, context);
+  if (members.length < 2) {
+    return [];
+  }
+  const text = asString(context.mergedProps(block2).get("text"));
+  return members.slice(1).map((member, index) => netLink(block2, members[0], member, index, text));
+}
+
+// src/sflSemantic/canvasObjects/processing/layout/flow.ts
+function createFlowPositioner(block2, context) {
+  const axis = asString(context.layoutProp(block2, "flow"));
+  const gap = asNumber(context.layoutProp(block2, "gap")) ?? 0;
+  let cursor = 0;
+  return (size) => {
+    if (axis !== "horizontal" && axis !== "vertical") {
+      return void 0;
+    }
+    const position = axis === "horizontal" ? [cursor, 0] : [0, cursor];
+    cursor += (axis === "horizontal" ? size[0] : size[1]) + gap;
+    return position;
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/values.ts
+function numberList(value) {
+  if (value?.type !== "list") {
+    return void 0;
+  }
+  const numbers = value.values.flatMap((item) => {
+    const number = asNumber(item);
+    return number === void 0 ? [] : [number];
+  });
+  return numbers.length > 0 ? numbers : void 0;
+}
+function stringList(value) {
+  if (value?.type !== "list") {
+    return void 0;
+  }
+  return value.values.flatMap((item) => {
+    const text = asString(item);
+    return text === void 0 ? [] : [text];
+  });
+}
+function readBoolean(value) {
+  const text = asString(value);
+  if (text === void 0) {
+    return void 0;
+  }
+  return text === "true";
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/axis.ts
+function readAxis(block2) {
+  const properties = block2 ? directProperties(block2) : /* @__PURE__ */ new Map();
+  return {
+    min: asNumber(properties.get("min")) ?? 0,
+    max: asNumber(properties.get("max")) ?? 10,
+    step: asNumber(properties.get("step")) ?? 1,
+    label: asString(properties.get("label")),
+    unit: asString(properties.get("unit")),
+    thresholds: numberList(properties.get("thresholds"))
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/rules.ts
+function readChartRules(block2) {
+  return contentChildren(block2).filter((child) => child.kind === "Rule").map((rule) => {
+    const properties = directProperties(rule);
+    return {
+      id: rule.name,
+      at: asNumber(properties.get("at")) ?? 0,
+      text: asString(properties.get("text")),
+      color: asString(properties.get("color")),
+      strokeWidth: asNumber(properties.get("strokeWidth")),
+      dash: numberList(properties.get("dash"))
+    };
+  });
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/seriesValues.ts
+function asComponents(value) {
+  if (value.type !== "list" || value.values.length < 2) {
+    return void 0;
+  }
+  const components = value.values.map(asNumber);
+  return components.every((part) => part !== void 0) ? components : void 0;
+}
+function readSeriesValues(value) {
+  if (value?.type !== "list") {
+    return [];
+  }
+  const shape = firstSeriesValueShape(value.values);
+  return shape === "tuple" ? readTupleSeriesValues(value.values) : readScalarSeriesValues(value.values);
+}
+function firstSeriesValueShape(values) {
+  for (const value of values) {
+    if (value.type === "number") {
+      return "scalar";
+    }
+    if (asComponents(value)) {
+      return "tuple";
+    }
+  }
+  return void 0;
+}
+function readScalarSeriesValues(values) {
+  return values.flatMap((value) => value.type === "number" ? [value.value] : []);
+}
+function readTupleSeriesValues(values) {
+  return values.flatMap((value) => {
+    const components = asComponents(value);
+    return components ? [components] : [];
+  });
+}
+function readSeriesErrors(value) {
+  if (value?.type !== "list") {
+    return void 0;
+  }
+  return value.values.map(readSeriesError);
+}
+function readSeriesError(value) {
+  if (value.type === "ident" && value.segments.join(".") === "none") {
+    return null;
+  }
+  if (value.type === "number") {
+    return value.value;
+  }
+  return readSeriesErrorRange(value);
+}
+function readSeriesErrorRange(value) {
+  if (value.type !== "list" || value.values.length < 2) {
+    return null;
+  }
+  const low = asNumber(value.values[0]);
+  const high = asNumber(value.values[1]);
+  return low !== void 0 && high !== void 0 ? [low, high] : null;
+}
+function readSeriesColors(value) {
+  if (value?.type !== "list") {
+    return void 0;
+  }
+  return value.values.map(readSeriesColor);
+}
+function readSeriesColor(value) {
+  if (value.type === "ident" && value.segments.join(".") === "none") {
+    return null;
+  }
+  return asString(value) ?? null;
+}
+function readSeriesSymbol(value, symbolDefs) {
+  if (value?.type === "list") {
+    const points = value.values.flatMap(readSeriesSymbolPoint);
+    return points.length > 0 ? { points } : void 0;
+  }
+  const name = asString(value);
+  const definition = name ? symbolDefs.get(name) : void 0;
+  if (!definition) {
+    return void 0;
+  }
+  return { points: definition.points, normalized: true, tension: definition.tension };
+}
+function readSeriesSymbolPoint(value) {
+  if (value.type !== "list" || value.values.length < 2) {
+    return [];
+  }
+  const x = asNumber(value.values[0]);
+  const y = asNumber(value.values[1]);
+  return x === void 0 || y === void 0 ? [] : [[x, y]];
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/series.ts
+function readSeries(block2, symbolDefs, mergedProps) {
+  const properties = mergedProps(block2);
+  return {
+    id: block2.name,
+    label: asString(properties.get("label")) ?? block2.name,
+    color: asString(properties.get("color")),
+    colors: readSeriesColors(properties.get("colors")),
+    opacity: asNumber(properties.get("opacity")),
+    group: asString(properties.get("group")),
+    values: readSeriesValues(properties.get("values")),
+    error: readSeriesErrors(properties.get("error")),
+    source: asString(properties.get("source")),
+    target: asString(properties.get("target")),
+    size: asNumber(properties.get("size")),
+    symbol: readSeriesSymbol(properties.get("symbol"), symbolDefs),
+    stroke: asString(properties.get("stroke")),
+    strokeWidth: asNumber(properties.get("strokeWidth")),
+    dash: numberList(properties.get("dash")),
+    offset: asNumber(properties.get("offset")),
+    labelOffsetX: asNumber(properties.get("labelOffsetX")),
+    labelOffsetY: asNumber(properties.get("labelOffsetY"))
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/zones.ts
+function readChartZones(value) {
+  if (value?.type !== "list") {
+    return void 0;
+  }
+  const zones = value.values.flatMap((item) => {
+    if (item.type !== "list") {
+      return [];
+    }
+    const label = asString(item.values[0]);
+    if (label === void 0) {
+      return [];
+    }
+    return [
+      {
+        label,
+        color: asString(item.values[1]),
+        offsetX: asNumber(item.values[2]),
+        offsetY: asNumber(item.values[3])
+      }
+    ];
+  });
+  return zones.length > 0 ? zones : void 0;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/reader.ts
+var STACKED_MODES = ["none", "true", "percent", "waterfall"];
+function asChartType(value) {
+  return isChartType(value) ? value : "bar";
+}
+function asStackedMode(value) {
+  return STACKED_MODES.find((mode) => mode === value);
+}
+function readChart(block2, properties, symbolDefs, mergedProps) {
+  const children = contentChildren(block2);
+  const axes = children.filter((child) => child.kind === "Axis");
+  const stacked = asString(properties.get("stacked"));
+  return {
+    chartType: asChartType(asString(properties.get("type"))),
+    categories: stringList(contentProperty(block2, "categories")),
+    areaOpacity: asNumber(properties.get("areaOpacity")),
+    stacked: asStackedMode(stacked),
+    scale: asString(properties.get("scale")),
+    interpolate: asString(properties.get("interpolate")) === "idw" ? "idw" : void 0,
+    idwPower: asNumber(properties.get("idwPower")),
+    isolines: numberList(properties.get("isolines")),
+    zones: readChartZones(properties.get("zones")),
+    boxWidth: asNumber(properties.get("boxWidth")),
+    orientation: asString(properties.get("orientation")) === "horizontal" ? "horizontal" : void 0,
+    lineTension: asNumber(properties.get("lineTension")),
+    highlightPoints: numberList(properties.get("highlightPoints")),
+    barCornerRadius: asNumber(properties.get("barCornerRadius")),
+    showBoxplotPoints: readBoolean(properties.get("showBoxplotPoints")),
+    barBorderColor: asString(properties.get("barBorderColor")),
+    barBorderWidth: asNumber(properties.get("barBorderWidth")),
+    barGroupGap: asNumber(properties.get("barGroupGap")),
+    barGlow: asNumber(properties.get("barGlow")),
+    barGap: asNumber(properties.get("barGap")),
+    mekkoVaryHeight: readBoolean(properties.get("mekkoVaryHeight")),
+    hexRadius: asNumber(properties.get("hexRadius")),
+    innerRadius: asNumber(properties.get("innerRadius")),
+    pieCornerRadius: asNumber(properties.get("pieCornerRadius")),
+    pieSliceGap: asNumber(properties.get("pieSliceGap")),
+    ringThickness: asNumber(properties.get("ringThickness")),
+    ringGap: asNumber(properties.get("ringGap")),
+    cellGap: asNumber(properties.get("cellGap")),
+    showValues: readBoolean(properties.get("showValues")),
+    squareCells: readBoolean(properties.get("squareCells")),
+    headerColor: asString(properties.get("headerColor")),
+    tileGradient: readBoolean(properties.get("tileGradient")),
+    showColumnBackdrop: readBoolean(properties.get("showColumnBackdrop")),
+    labelPosition: asString(properties.get("labelPosition")) === "inside" ? "inside" : void 0,
+    labelOrientation: asString(properties.get("labelOrientation")) === "vertical" ? "vertical" : void 0,
+    labelColor: asString(properties.get("labelColor")),
+    linkGradient: readBoolean(properties.get("linkGradient")),
+    connectPoints: readBoolean(properties.get("connectPoints")),
+    reverseComparison: readBoolean(properties.get("reverseComparison")),
+    axisX: readAxis(axes.find((axis) => axis.name === "x")),
+    axisY: readAxis(axes.find((axis) => axis.name === "y" || axis.name === "value")),
+    series: children.filter((child) => child.kind === "Series").map((child) => readSeries(child, symbolDefs, mergedProps)),
+    rules: readChartRules(block2)
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/chart/resolver.ts
+function resolveChartObject(base, block2, properties, symbolDefinitions, mergedProperties) {
+  return {
+    ...base,
+    objectType: "chart",
+    chart: readChart(block2, properties, symbolDefinitions, mergedProperties)
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/isometric/reader.ts
+function readIsometric(properties, depth) {
+  return {
+    depth,
+    icon: asString(properties.get("icon"))
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/isometric/resolver.ts
+function resolveIsometricObject(base, block2, properties, layoutProperty) {
+  const size = tupleValues(layoutProperty(block2, "size"));
+  return {
+    ...base,
+    objectType: "isometric",
+    isometric: readIsometric(properties, size?.[2] ?? 24)
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/path/reader.ts
+function readPath(p, origin) {
+  const pointsValue = p.get("points");
+  const points = pointsValue?.type === "list" ? pointsValue.values.flatMap((value) => {
+    if (value.type !== "list" || value.values.length < 2) {
+      return [];
+    }
+    const x = asNumber(value.values[0]);
+    const y = asNumber(value.values[1]);
+    return x !== void 0 && y !== void 0 ? [{ x: origin.x + x, y: origin.y + y }] : [];
+  }) : [];
+  return {
+    points,
+    tension: asNumber(p.get("tension")),
+    startMarker: asString(p.get("startMarker")),
+    endMarker: asString(p.get("endMarker")),
+    closed: asString(p.get("closed")) === "true",
+    value: asNumber(p.get("value"))
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/path/resolver.ts
+function resolvePathObject(base, properties, origin) {
+  return {
+    ...base,
+    objectType: "path",
+    path: readPath(properties, origin)
+  };
+}
+
+// src/sflSemantic/canvasObjects/artifacts/swimlane/reader.ts
+function readSwimlane(p) {
+  const orientation = asString(p.get("orientation")) === "vertical" ? "vertical" : "horizontal";
+  const lanesValue = p.get("lanes");
+  const lanes = lanesValue?.type === "list" ? lanesValue.values.flatMap((value, index) => {
+    if (value.type !== "list") {
+      return [];
+    }
+    const label = asString(value.values[0]);
+    const size = asNumber(value.values[1]);
+    if (label === void 0 || size === void 0) {
+      return [];
+    }
+    const color = asString(value.values[2]);
+    return [{ id: `lane-${index + 1}`, label, size, ...color ? { color } : {} }];
+  }) : [];
+  const swimlaneData = { orientation, lanes };
+  return swimlaneData;
+}
+
+// src/sflSemantic/canvasObjects/artifacts/swimlane/resolver.ts
+function resolveSwimlaneObject(base, properties) {
+  return {
+    ...base,
+    objectType: "swimlane",
+    swimlane: readSwimlane(properties)
+  };
+}
+
+// src/sflSemantic/canvasObjects/processing/classification.ts
+function declaredCanvasObjectKind(block2, properties) {
+  if (block2.kind === "Path") {
+    return "path";
+  }
+  if (block2.kind === "Chart") {
+    return "chart";
+  }
+  if (block2.kind === "Widget") {
+    return asString(properties.get("type")) ?? "widget";
+  }
+  if (block2.kind === "Text") {
+    return "text";
+  }
+  if (block2.kind === "Isometric") {
+    return "isometric";
+  }
+  return asString(properties.get("kind")) ?? "";
+}
+function canvasObjectTypeForKind(kind) {
+  if (kind === "frame") {
+    return "frame";
+  }
+  if (kind === "swimlane") {
+    return "swimlane";
+  }
+  if (kind === "path") {
+    return "path";
+  }
+  if (kind === "chart") {
+    return "chart";
+  }
+  if (kind === "rollingNumber" || kind === "tickScale" || kind === "ruler") {
+    return "widget";
+  }
+  if (kind === "isometric") {
+    return "isometric";
+  }
+  return "shape";
+}
+function classifyCanvasObject(block2, properties, symbolDefinitions) {
+  const kind = declaredCanvasObjectKind(block2, properties);
+  const shapeReference = asString(properties.get("shape"));
+  const symbol = shapeReference ? symbolDefinitions.get(shapeReference) : void 0;
+  return {
+    objectType: block2.kind === "Widget" ? "widget" : canvasObjectTypeForKind(kind),
+    kind,
+    shapeType: symbol ? "symbol" : shapeReference,
+    symbol
+  };
+}
+
+// src/sflSemantic/canvasObjects/processing/layout/geometry.ts
+function readCanvasObjectGeometry(block2, origin, layoutProperty, positionOverride) {
+  const position = positionOverride ?? tupleValues(layoutProperty(block2, "position")) ?? [0, 0];
+  const size = tupleValues(layoutProperty(block2, "size")) ?? [0, 0];
+  return {
+    x: origin.x + (position[0] ?? 0),
+    y: origin.y + (position[1] ?? 0),
+    width: size[0] ?? 0,
+    height: size[1] ?? 0,
+    rotation: asNumber(layoutProperty(block2, "rotation")),
+    order: asNumber(layoutProperty(block2, "order"))
+  };
+}
+
+// src/sflSemantic/canvasObjects/processing/presentation.ts
+var STRUCTURAL_PROPERTIES = /* @__PURE__ */ new Set(["id", "kind", "text", "shape", "parent", "order", "orientation", "lanes"]);
+function readCanvasObjectPresentation(properties) {
+  const presentation = {};
+  for (const [key, value] of properties) {
+    if (STRUCTURAL_PROPERTIES.has(key)) {
+      continue;
+    }
+    const text = asString(value);
+    if (text !== void 0) {
+      presentation[key] = text;
+    }
+  }
+  return presentation;
+}
+
+// src/sflSemantic/canvasObjects/processing/resolver.ts
+function resolveCanvasObject(block2, origin, context, frameId, positionOverride) {
+  const { mergedProps, layoutProp, symbolDefs } = context;
+  const properties = mergedProps(block2);
+  const classification = classifyCanvasObject(block2, properties, symbolDefs);
+  const geometry = readCanvasObjectGeometry(block2, origin, layoutProp, positionOverride);
+  const base = {
+    id: asString(properties.get("id")) ?? block2.name,
+    kind: classification.kind,
+    text: asString(properties.get("text")),
+    ...geometry,
+    parentFrameId: frameId ?? asString(properties.get("parent")),
+    props: readCanvasObjectPresentation(properties)
+  };
+  switch (classification.objectType) {
+    case "chart":
+      return resolveChartObject(base, block2, properties, symbolDefs, mergedProps);
+    case "isometric":
+      return resolveIsometricObject(base, block2, properties, layoutProp);
+    case "path":
+      return resolvePathObject(base, properties, origin);
+    case "swimlane":
+      return resolveSwimlaneObject(base, properties);
+    case "frame":
+      return { ...base, objectType: "frame" };
+    case "widget":
+      return {
+        ...base,
+        objectType: "widget",
+        widget: {
+          type: asString(properties.get("type")) ?? "rollingNumber",
+          value: asString(properties.get("value")) ?? "0",
+          digits: asNumber(properties.get("digits")),
+          duration: asNumber(properties.get("duration")),
+          min: asNumber(properties.get("min")),
+          max: asNumber(properties.get("max")),
+          label: asString(properties.get("label"))
+        }
+      };
+    case "shape":
+      return {
+        ...base,
+        objectType: "shape",
+        shapeType: classification.shapeType,
+        symbol: classification.symbol
+      };
+  }
+}
+
+// src/sflSemantic/groups/members.ts
+function directGroupMemberIds(block2) {
+  return childBlocks(block2).filter((child) => isCanvasObjectBlockKind(child.kind)).map((child) => asString(directProperties(child).get("id")) ?? child.name);
+}
+
+// src/sflSemantic/canvasTree/resolver.ts
+var CanvasTreeResolver = class {
+  #context;
+  #canvasObjects = [];
+  #linkBlocks = [];
+  #connectionBlocks = [];
+  #linkSourceIndexes = [];
+  #connectionSourceIndexes = [];
+  #sequence = 0;
+  constructor(resolution) {
+    this.#context = resolution.canvasObjectResolutionContext;
+  }
+  resolve(model) {
+    const groups = model ? this.#resolveChildren(model, { origin: { x: 0, y: 0 } }) : [];
+    return {
+      canvasObjects: this.#canvasObjects,
+      groups,
+      linkBlocks: this.#linkBlocks,
+      connectionBlocks: this.#connectionBlocks,
+      linkSourceIndexes: this.#linkSourceIndexes,
+      connectionSourceIndexes: this.#connectionSourceIndexes
+    };
+  }
+  #resolveChildren(block2, location) {
+    const groups = [];
+    const nextFlowPosition = createFlowPositioner(block2, this.#context);
+    for (const child of childBlocks(block2)) {
+      groups.push(...this.#resolveChild(child, location, nextFlowPosition));
+    }
+    return groups;
+  }
+  #resolveChild(child, location, nextFlowPosition) {
+    const sourceIndex = this.#sequence++;
+    if (child.kind === "Container") {
+      return this.#resolveContainer(child, location, nextFlowPosition, sourceIndex);
+    }
+    if (isCanvasObjectBlockKind(child.kind)) {
+      this.#resolveCanvasObject(child, location, nextFlowPosition, sourceIndex);
+      return [];
+    }
+    switch (child.kind) {
+      case "Group":
+        return [this.#resolveGroup(child, location)];
+      case "Link":
+        this.#linkBlocks.push(child);
+        this.#linkSourceIndexes.push(sourceIndex);
+        return [];
+      case "Connection":
+        this.#connectionBlocks.push(child);
+        this.#connectionSourceIndexes.push(sourceIndex);
+        return [];
+      case "Net": {
+        const expanded = expandNetLinks(child, this.#context);
+        this.#linkBlocks.push(...expanded);
+        this.#linkSourceIndexes.push(...expanded.map(() => sourceIndex));
+        return [];
+      }
+      default:
+        return [];
+    }
+  }
+  #resolveContainer(block2, location, nextFlowPosition, sourceIndex) {
+    const canvasObject = this.#resolvePositionedCanvasObject(block2, location, nextFlowPosition, sourceIndex);
+    this.#canvasObjects.push(canvasObject);
+    return this.#resolveChildren(block2, {
+      origin: { x: canvasObject.x, y: canvasObject.y },
+      frameId: canvasObject.id
+    });
+  }
+  #resolveCanvasObject(block2, location, nextFlowPosition, sourceIndex) {
+    this.#canvasObjects.push(this.#resolvePositionedCanvasObject(block2, location, nextFlowPosition, sourceIndex));
+  }
+  #resolvePositionedCanvasObject(block2, location, nextFlowPosition, sourceIndex) {
+    const size = tupleValues(this.#context.layoutProp(block2, "size")) ?? [0, 0];
+    return {
+      ...resolveCanvasObject(block2, location.origin, this.#context, location.frameId, nextFlowPosition(size)),
+      sourceIndex
+    };
+  }
+  #resolveGroup(block2, location) {
+    const properties = this.#context.mergedProps(block2);
+    return {
+      id: asString(properties.get("id")) ?? block2.name,
+      name: asString(properties.get("text")) ?? block2.name,
+      color: asString(properties.get("color")),
+      icon: asString(properties.get("icon")),
+      canvasObjectIds: directGroupMemberIds(block2),
+      subGroups: this.#resolveChildren(block2, location),
+      parentFrameId: location.frameId ?? asString(properties.get("parent"))
+    };
+  }
+};
+function resolveCanvasTree(model, resolution) {
+  return new CanvasTreeResolver(resolution).resolve(model);
+}
+
+// src/sflSemantic/definitions/shaders.ts
+function readShaderDefinition(block2) {
+  const properties = directProperties(block2);
+  const program = asString(properties.get("program"));
+  if (!program) {
+    return void 0;
+  }
+  const parameters = {};
+  for (const [key, value] of properties) {
+    if (key === "program") {
+      continue;
+    }
+    const number = asNumber(value);
+    const text = asString(value);
+    if (number !== void 0) {
+      parameters[key] = number;
+    } else if (text !== void 0) {
+      parameters[key] = text === "true" ? true : text === "false" ? false : text;
+    }
+  }
+  return { name: block2.name, program, parameters };
+}
+
+// src/sflSemantic/definitions/symbols.ts
+function readSymbolPoints(block2) {
+  const value = directProperties(block2).get("points");
+  if (value?.type !== "list") {
+    return [];
+  }
+  return value.values.flatMap((item) => {
+    if (item.type !== "list" || item.values.length < 2) {
+      return [];
+    }
+    const x = asNumber(item.values[0]);
+    const y = asNumber(item.values[1]);
+    return x === void 0 || y === void 0 ? [] : [[x, y]];
+  });
+}
+function readSymbolPorts(block2) {
+  const ports = childBlocks(block2).filter((child) => child.kind === "Port").flatMap((port) => {
+    const position = tupleValues(directProperties(port).get("at"));
+    if (typeof position?.[0] !== "number" || typeof position[1] !== "number") {
+      return [];
+    }
+    return [{ name: port.name, at: [position[0], position[1]] }];
+  });
+  return ports.length > 0 ? ports : void 0;
+}
+function readSymbolDefinition(block2) {
+  const points = readSymbolPoints(block2);
+  if (points.length < 2) {
+    return void 0;
+  }
+  return {
+    name: block2.name,
+    points,
+    tension: asNumber(directProperties(block2).get("tension")),
+    ports: readSymbolPorts(block2)
+  };
+}
+
+// src/sflSemantic/definitions/collection.ts
+function projectModel(block2) {
+  return childBlocks(block2).find((child) => child.kind === "Model");
+}
+function collectCanvasDefinitions(sflDocument) {
+  return {
+    styles: collectStyleDefinitions(sflDocument),
+    layouts: collectLayoutDefinitions(sflDocument),
+    symbols: collectSymbolDefinitions(sflDocument),
+    shaders: collectShaderDefinitions(sflDocument),
+    model: findCanvasModel(sflDocument)
+  };
+}
+function collectShaderDefinitions(sflDocument) {
+  const shaders = /* @__PURE__ */ new Map();
+  for (const block2 of sflDocument.blocks) {
+    if (block2.kind !== "Shader") {
+      continue;
+    }
+    const shader = readShaderDefinition(block2);
+    if (shader) {
+      shaders.set(block2.name, shader);
+    }
+  }
+  return shaders;
+}
+function collectStyleDefinitions(sflDocument) {
+  const styles = /* @__PURE__ */ new Map();
+  for (const block2 of sflDocument.blocks) {
+    if (block2.kind === "Style") {
+      styles.set(block2.name, block2);
+    }
+  }
+  return styles;
+}
+function collectLayoutDefinitions(sflDocument) {
+  const layouts = /* @__PURE__ */ new Map();
+  for (const block2 of sflDocument.blocks) {
+    if (block2.kind === "Layout") {
+      layouts.set(block2.name, block2);
+    }
+  }
+  return layouts;
+}
+function collectSymbolDefinitions(sflDocument) {
+  const symbols = /* @__PURE__ */ new Map();
+  for (const block2 of sflDocument.blocks) {
+    if (block2.kind !== "Symbol") {
+      continue;
+    }
+    const symbol = readSymbolDefinition(block2);
+    if (symbol) {
+      symbols.set(block2.name, symbol);
+    }
+  }
+  return symbols;
+}
+function findCanvasModel(sflDocument) {
+  for (const block2 of sflDocument.blocks) {
+    if (block2.kind === "Model") {
+      return block2;
+    }
+    if (block2.kind === "Project") {
+      const model = projectModel(block2);
+      if (model) {
+        return model;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/sflSemantic/definitions/compositionReferences.ts
+function classifyCompositionReferences(composition, styleBlocks, layoutBlocks) {
+  let styleRef;
+  let layoutRef;
+  for (const reference of composition) {
+    if (styleBlocks.has(reference)) {
+      styleRef = reference;
+    } else if (layoutBlocks.has(reference)) {
+      layoutRef = reference;
+    }
+  }
+  return { styleRef, layoutRef };
+}
+function collectBlockDiagnostics(block2, styleBlocks, layoutBlocks, diagnostics) {
+  for (const reference of block2.composition) {
+    if (!styleBlocks.has(reference) && !layoutBlocks.has(reference)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "unresolved-style-or-layout",
+        ownerId: block2.name,
+        message: `"${reference}" is not a Style or Layout defined at the top level of the document \xC3\xA2\xE2\u201A\xAC\xE2\u20AC\x9D "${block2.name}" gets no shape, fill, or stroke from it.`
+      });
+    }
+  }
+  for (const child of childBlocks(block2)) {
+    collectBlockDiagnostics(child, styleBlocks, layoutBlocks, diagnostics);
+  }
+}
+function collectUnresolvedCompositionReferences(sflDocument, styleBlocks, layoutBlocks) {
+  const diagnostics = [];
+  for (const block2 of sflDocument.blocks) {
+    collectBlockDiagnostics(block2, styleBlocks, layoutBlocks, diagnostics);
+  }
+  return diagnostics;
+}
+
+// src/sflSemantic/definitions/inheritance.ts
+function resolveDefinitionInheritance(definitions, parentName) {
+  return new DefinitionInheritanceResolver(definitions, parentName).resolveAll();
+}
+var DefinitionInheritanceResolver = class {
+  #definitions;
+  #parentName;
+  #resolved = /* @__PURE__ */ new Map();
+  constructor(definitions, parentName) {
+    this.#definitions = definitions;
+    this.#parentName = parentName;
+  }
+  resolveAll() {
+    for (const name of this.#definitions.keys()) {
+      this.#resolveDefinition(name, /* @__PURE__ */ new Set());
+    }
+    return this.#resolved;
+  }
+  #resolveDefinition(name, ancestry) {
+    const cached = this.#resolved.get(name);
+    if (cached) {
+      return cached;
+    }
+    const block2 = this.#definitions.get(name);
+    if (!block2 || ancestry.has(name)) {
+      return /* @__PURE__ */ new Map();
+    }
+    const values = this.#inheritedProperties(block2, /* @__PURE__ */ new Set([...ancestry, name]));
+    for (const [key, value] of directProperties(block2)) {
+      values.set(key, value);
+    }
+    this.#resolved.set(name, values);
+    return values;
+  }
+  #inheritedProperties(block2, ancestry) {
+    const parent = this.#parentName(block2);
+    return parent ? new Map(this.#resolveDefinition(parent, ancestry)) : /* @__PURE__ */ new Map();
+  }
+};
+
+// src/sflSemantic/definitions/propertyReaders.ts
+function createCanvasObjectPropertyReaders(definitions) {
+  const { styles, layouts, symbols, shaders } = definitions;
+  const references = (block2) => classifyCompositionReferences(block2.composition, styles, layouts);
+  const resolvedStyles = resolveDefinitionInheritance(styles, (block2) => references(block2).styleRef);
+  const resolvedLayouts = resolveDefinitionInheritance(layouts, (block2) => references(block2).layoutRef);
+  const mergedProps = (block2) => {
+    const merged = new Map(resolvedStyles.get(references(block2).styleRef ?? "") ?? []);
+    for (const [key, value] of directProperties(block2)) {
+      merged.set(key, value);
+    }
+    for (const [key, value] of styleProperties(block2)) {
+      merged.set(key, value);
+    }
+    return merged;
+  };
+  const layoutProp = (block2, key) => {
+    const localProperties = layoutProperties(block2);
+    if (localProperties.has(key)) {
+      return localProperties.get(key);
+    }
+    const reference = references(block2).layoutRef;
+    return reference ? resolvedLayouts.get(reference)?.get(key) : void 0;
+  };
+  return { mergedProps, layoutProp, symbolDefs: symbols, shaderDefs: shaders };
+}
+
+// src/sflSemantic/diagnostics/charts.ts
+var NATIVE_CIRCULAR_CHART_TYPES = /* @__PURE__ */ new Set(["radar", "radial"]);
+var OPTIONAL_CIRCULAR_GRID_CHART_TYPES = /* @__PURE__ */ new Set(["scatter", "custom", "hexbin"]);
+function collectUnsupportedChartTypes(doc) {
+  const diagnostics = [];
+  const visit = (block2) => {
+    if (block2.kind === "Chart") {
+      const declared = asString(directProperties(block2).get("type"));
+      if (declared !== void 0 && !isChartType(declared)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "unsupported-chart-type",
+          ownerId: block2.name,
+          message: `Unsupported chart type '${declared}' \xC3\u0192\xC2\xA2\xC3\xA2\xE2\u20AC\u0161\xC2\xAC\xC3\xA2\xE2\u201A\xAC\xC2\x9D drawn as a plain series plot. Supported: ${CHART_TYPES.join(", ")}.`
+        });
+      }
+    }
+    for (const child of childBlocks(block2)) {
+      visit(child);
+    }
+  };
+  for (const block2 of doc.blocks) {
+    visit(block2);
+  }
+  return diagnostics;
+}
+function collectEmptySeries(doc) {
+  const diagnostics = [];
+  const visit = (block2) => {
+    if (block2.kind === "Chart") {
+      for (const series of contentChildren(block2).filter((child) => child.kind === "Series")) {
+        if (!directProperties(series).has("values")) {
+          diagnostics.push({
+            severity: "warning",
+            code: "series-without-values",
+            ownerId: series.name,
+            message: `Series '${series.name}' has no values. If this was meant to be an Axis or Rule, it needs that keyword in front of the name \xC3\u0192\xC2\xA2\xC3\xA2\xE2\u20AC\u0161\xC2\xAC\xC3\xA2\xE2\u201A\xAC\xC2\x9D inside data{}, a bare name is read as a Series.`
+          });
+        }
+      }
+    }
+    for (const child of childBlocks(block2)) {
+      visit(child);
+    }
+  };
+  for (const block2 of doc.blocks) {
+    visit(block2);
+  }
+  return diagnostics;
+}
+function collectUnsupportedGridShapes(doc) {
+  const diagnostics = [];
+  const visit = (block2) => {
+    if (block2.kind === "Chart") {
+      const declared = asString(directProperties(block2).get("type"));
+      const chartType = isChartType(declared) ? declared : "bar";
+      const gridShape = asString(styleProperties(block2).get("gridShape"));
+      if (gridShape === "circle" && !OPTIONAL_CIRCULAR_GRID_CHART_TYPES.has(chartType) && !NATIVE_CIRCULAR_CHART_TYPES.has(chartType)) {
+        diagnostics.push({
+          severity: "warning",
+          code: "unsupported-grid-shape",
+          ownerId: block2.name,
+          message: `gridShape: circle isn't supported on '${chartType}' \xC3\u0192\xC2\xA2\xC3\xA2\xE2\u20AC\u0161\xC2\xAC\xC3\xA2\xE2\u201A\xAC\xC2\x9D drawn with the standard rectangular grid instead. Supported: ${[...OPTIONAL_CIRCULAR_GRID_CHART_TYPES].join(", ")}.`
+        });
+      }
+    }
+    for (const child of childBlocks(block2)) {
+      visit(child);
+    }
+  };
+  for (const block2 of doc.blocks) {
+    visit(block2);
+  }
+  return diagnostics;
+}
+
+// src/sflSemantic/diagnostics/widgets.ts
+function collectUnsupportedWidgetTypes(sflDocument) {
+  const diagnostics = [];
+  const visit = (block2) => {
+    if (block2.kind === "Widget") {
+      const type = asString(directProperties(block2).get("type")) ?? "rollingNumber";
+      if (type !== "rollingNumber" && type !== "tickScale" && type !== "ruler") {
+        diagnostics.push({
+          severity: "warning",
+          code: "unsupported-widget-type",
+          ownerId: block2.name,
+          message: `Unsupported widget type '${type}'. Supported: rollingNumber, tickScale, ruler.`
+        });
+      }
+    }
+    for (const child of childBlocks(block2)) {
+      visit(child);
+    }
+  };
+  for (const block2 of sflDocument.blocks) {
+    visit(block2);
+  }
+  return diagnostics;
+}
+
+// src/sflSemantic/canvasState/resolution.ts
+function createCanvasResolution(doc) {
+  const definitions = collectCanvasDefinitions(doc);
+  return {
+    model: definitions.model,
+    diagnostics: [
+      ...collectUnresolvedCompositionReferences(doc, definitions.styles, definitions.layouts),
+      ...collectUnsupportedChartTypes(doc),
+      ...collectUnsupportedGridShapes(doc),
+      ...collectEmptySeries(doc),
+      ...collectUnsupportedWidgetTypes(doc)
+    ],
+    canvasObjectResolutionContext: createCanvasObjectPropertyReaders(definitions)
+  };
+}
+
+// src/sflSemantic/canvasState/resolver.ts
+function resolveCanvasState(document) {
+  const resolution = createCanvasResolution(document);
+  const { canvasObjects, groups, linkBlocks, connectionBlocks, linkSourceIndexes, connectionSourceIndexes } = resolveCanvasTree(resolution.model, resolution);
+  const links = readLinks(
+    resolution.model,
+    linkBlocks,
+    canvasObjects,
+    resolution.canvasObjectResolutionContext,
+    linkSourceIndexes
+  );
+  const connections = readConnections(
+    resolution.model,
+    connectionBlocks,
+    canvasObjects,
+    resolution.canvasObjectResolutionContext,
+    connectionSourceIndexes
+  );
+  return {
+    canvasObjects,
+    groups,
+    links,
+    connections,
+    diagnostics: resolution.diagnostics,
+    shaders: [...resolution.canvasObjectResolutionContext.shaderDefs.values()]
+  };
+}
+
+// src/sflSemantic/sflToCanvasState.ts
+function sflToCanvasState(source) {
+  return resolveCanvasState(parseSource(source));
+}
+
+// src/svg/domContract/version.ts
+var DOM_CONTRACT_VERSION = 1;
+
+// src/model/geometry/ports/rectangleCoordinates.ts
+var DEGREES_TO_RADIANS = Math.PI / 180;
+function rotatePoint(point, degrees) {
+  const radians = degrees * DEGREES_TO_RADIANS;
+  const cosine = Math.cos(radians);
+  const sine = Math.sin(radians);
+  return { x: point.x * cosine - point.y * sine, y: point.x * sine + point.y * cosine };
+}
+function rectangleCenter(rectangle) {
+  return { x: rectangle.x + rectangle.width / 2, y: rectangle.y + rectangle.height / 2 };
+}
+function worldPointToRectangle(rectangle, worldPoint) {
+  const center = rectangleCenter(rectangle);
+  const pointRelativeToCenter = { x: worldPoint.x - center.x, y: worldPoint.y - center.y };
+  return rectangle.rotation ? rotatePoint(pointRelativeToCenter, -rectangle.rotation) : pointRelativeToCenter;
+}
+function rectanglePointToWorld(rectangle, rectanglePoint) {
+  const center = rectangleCenter(rectangle);
+  const rotatedPoint = rectangle.rotation ? rotatePoint(rectanglePoint, rectangle.rotation) : rectanglePoint;
+  return { x: center.x + rotatedPoint.x, y: center.y + rotatedPoint.y };
+}
+
+// src/model/geometry/ports/coordinates.ts
+function portPointInRectangle(rectangle, port) {
+  const offset = Math.max(0, Math.min(1, port.offset));
+  const halfWidth = rectangle.width / 2;
+  const halfHeight = rectangle.height / 2;
+  switch (port.side) {
+    case "top":
+      return { x: (offset - 0.5) * rectangle.width, y: -halfHeight };
+    case "right":
+      return { x: halfWidth, y: (offset - 0.5) * rectangle.height };
+    case "bottom":
+      return { x: (offset - 0.5) * rectangle.width, y: halfHeight };
+    case "left":
+      return { x: -halfWidth, y: (offset - 0.5) * rectangle.height };
+  }
+}
+function pointAtPort(rectangle, port) {
+  return rectanglePointToWorld(rectangle, portPointInRectangle(rectangle, port));
+}
+function pointAtNormalizedPort(rectangle, normalizedPosition) {
+  return rectanglePointToWorld(rectangle, {
+    x: (normalizedPosition[0] - 0.5) * rectangle.width,
+    y: (normalizedPosition[1] - 0.5) * rectangle.height
+  });
+}
+function relativeOffsetOnRectangleSide(rectangle, side, worldPoint) {
+  const rectanglePoint = worldPointToRectangle(rectangle, worldPoint);
+  switch (side) {
+    case "top":
+    case "bottom":
+      return (rectanglePoint.x + rectangle.width / 2) / rectangle.width;
+    case "left":
+    case "right":
+      return (rectanglePoint.y + rectangle.height / 2) / rectangle.height;
+  }
+}
+
+// src/renderScene/scene/bounds.ts
+var EMPTY_BOUNDS = { minX: 0, minY: 0, maxX: 100, maxY: 100 };
+function boxBounds(frame, extra = 0) {
+  return {
+    minX: frame.x - extra,
+    minY: frame.y - extra,
+    maxX: frame.x + frame.width + extra,
+    maxY: frame.y + frame.height + extra
+  };
+}
+function rotatedBounds(frame, degrees, extra = 0) {
+  if (!degrees) {
+    return boxBounds(frame, extra);
+  }
+  return boundsAroundPoints(rotateFrameCorners(frame, degrees), extra);
+}
+function rotateFrameCorners(frame, degrees) {
+  const centerX = frame.x + frame.width / 2;
+  const centerY = frame.y + frame.height / 2;
+  const angle = degrees * Math.PI / 180;
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  return frameCorners(frame).map((point) => ({
+    x: centerX + (point.x - centerX) * cos - (point.y - centerY) * sin,
+    y: centerY + (point.x - centerX) * sin + (point.y - centerY) * cos
+  }));
+}
+function frameCorners(frame) {
+  return [
+    { x: frame.x, y: frame.y },
+    { x: frame.x + frame.width, y: frame.y },
+    { x: frame.x + frame.width, y: frame.y + frame.height },
+    { x: frame.x, y: frame.y + frame.height }
+  ];
+}
+function boundsAroundPoints(points, extra) {
+  return {
+    minX: Math.min(...points.map((point) => point.x)) - extra,
+    minY: Math.min(...points.map((point) => point.y)) - extra,
+    maxX: Math.max(...points.map((point) => point.x)) + extra,
+    maxY: Math.max(...points.map((point) => point.y)) + extra
+  };
+}
+
+// src/renderScene/scene/order.ts
+function stackRank(object) {
+  const key = object.order_key ?? object.orderKey;
+  if (!key) {
+    return object.order ?? 0;
+  }
+  let rank = 0;
+  for (let index = 0; index < Math.min(key.length, 8); index++) {
+    rank = rank * 128 + key.charCodeAt(index);
+  }
+  return rank;
+}
+function stackSequence(object, fallback) {
+  return object.sourceIndex ?? fallback;
+}
+
+// src/renderScene/artifacts/link/roundedOrthogonalPathData.ts
+function roundedOrthogonalPathData(segments, radius) {
+  if (segments.length === 0) {
+    return "";
+  }
+  const raw = [segments[0].start, ...segments.map((segment) => segment.end)];
+  const points = raw.filter(
+    (point, index) => index === 0 || point.x !== raw[index - 1].x || point.y !== raw[index - 1].y
+  );
+  const corners = points.filter((point, index) => {
+    if (index === 0 || index === points.length - 1) {
+      return true;
+    }
+    const previous = points[index - 1];
+    const next = points[index + 1];
+    return !(previous.x === point.x && point.x === next.x || previous.y === point.y && point.y === next.y);
+  });
+  if (corners.length < 2) {
+    return "";
+  }
+  let pathData = `M ${corners[0].x} ${corners[0].y}`;
+  for (let index = 1; index < corners.length - 1; index++) {
+    const previous = corners[index - 1];
+    const corner = corners[index];
+    const next = corners[index + 1];
+    const incoming = Math.hypot(corner.x - previous.x, corner.y - previous.y);
+    const outgoing = Math.hypot(next.x - corner.x, next.y - corner.y);
+    if (incoming === 0 || outgoing === 0) {
+      pathData += ` L ${corner.x} ${corner.y}`;
+      continue;
+    }
+    const cornerRadius = Math.min(radius, incoming * 0.4, outgoing * 0.4);
+    const before = {
+      x: corner.x + (previous.x - corner.x) / incoming * cornerRadius,
+      y: corner.y + (previous.y - corner.y) / incoming * cornerRadius
+    };
+    const after = {
+      x: corner.x + (next.x - corner.x) / outgoing * cornerRadius,
+      y: corner.y + (next.y - corner.y) / outgoing * cornerRadius
+    };
+    pathData += ` L ${before.x} ${before.y} Q ${corner.x} ${corner.y} ${after.x} ${after.y}`;
+  }
+  const last = corners[corners.length - 1];
+  return `${pathData} L ${last.x} ${last.y}`;
+}
+
+// src/renderScene/charts/propPath.ts
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function block(kind, id, property) {
+  return IDENT.test(id) ? `${kind}[${id}].${property}` : void 0;
+}
+var CHART_TITLE_PROP = "text";
+function axisLabelProp(axis) {
+  return `Axis[${axis}].label`;
+}
+function categoryProp(index) {
+  return Number.isInteger(index) && index >= 0 ? `categories[${index}]` : void 0;
+}
+function seriesLabelProp(id) {
+  return block("Series", id, "label");
+}
+function seriesColorProp(id) {
+  return block("Series", id, "color");
+}
+function seriesLabelOffsetXProp(id) {
+  return block("Series", id, "labelOffsetX");
+}
+function seriesLabelOffsetYProp(id) {
+  return block("Series", id, "labelOffsetY");
+}
+function seriesValueProp(id, index) {
+  return Number.isInteger(index) && index >= 0 ? block("Series", id, `values[${index}]`) : void 0;
+}
+function seriesValueColorProp(id, index) {
+  return Number.isInteger(index) && index >= 0 ? block("Series", id, `colors[${index}]`) : void 0;
+}
+function ruleTextProp(id) {
+  return block("Rule", id, "text");
+}
+function ruleAtProp(id) {
+  return block("Rule", id, "at");
+}
+
+// src/renderScene/scene/freeformPath.ts
+function freeformPathData(geometry) {
+  if (geometry.points.length === 0) {
+    return "";
+  }
+  if (geometry.points.length < 3 || geometry.tension <= 0) {
+    return linearPathData(geometry);
+  }
+  return smoothPathData(geometry);
+}
+function linearPathData(geometry) {
+  const [first, ...remaining] = geometry.points;
+  const segments = remaining.map((point) => `L ${point.x} ${point.y}`).join(" ");
+  return `M ${first.x} ${first.y} ${segments}${geometry.closed ? " Z" : ""}`;
+}
+function smoothPathData(geometry) {
+  const first = geometry.points[0];
+  const segmentCount = geometry.closed ? geometry.points.length : geometry.points.length - 1;
+  const commands = [`M ${first.x} ${first.y}`];
+  for (let index = 0; index < segmentCount; index++) {
+    commands.push(curveSegmentCommand(geometry, index));
+  }
+  if (geometry.closed) {
+    commands.push("Z");
+  }
+  return commands.join(" ");
+}
+function curveSegmentCommand(geometry, index) {
+  const previous = freeformPointAt(geometry, index - 1);
+  const start = freeformPointAt(geometry, index);
+  const end = freeformPointAt(geometry, index + 1);
+  const next = freeformPointAt(geometry, index + 2);
+  const factor = geometry.tension / 6;
+  const firstControl = { x: start.x + (end.x - previous.x) * factor, y: start.y + (end.y - previous.y) * factor };
+  const secondControl = { x: end.x - (next.x - start.x) * factor, y: end.y - (next.y - start.y) * factor };
+  return `C ${firstControl.x} ${firstControl.y} ${secondControl.x} ${secondControl.y} ${end.x} ${end.y}`;
+}
+function freeformPointAt(geometry, index) {
+  if (geometry.closed) {
+    return geometry.points[(index + geometry.points.length) % geometry.points.length];
+  }
+  return geometry.points[Math.max(0, Math.min(geometry.points.length - 1, index))];
+}
+
+// src/renderScene/charts/primitives/radarShape.ts
+var START_ANGLE = -Math.PI / 2;
+var CURVED_TENSION = 0.5;
+var LABEL_FREE_MARGIN = 6;
+function radarLabelSpace(fontSize) {
+  return Math.max(38, fontSize * 3.2);
+}
+function radarRadius(plotWidth, plotHeight, fontSize, hasLabels = true) {
+  const margin = hasLabels ? radarLabelSpace(fontSize) : LABEL_FREE_MARGIN;
+  return Math.max(8, Math.min(plotWidth, plotHeight) / 2 - margin);
+}
+function radarCategoryCount(configuredCount, dataCount) {
+  return Math.max(3, configuredCount || dataCount);
+}
+function radarAngleAt(count, index) {
+  return START_ANGLE + index * Math.PI * 2 / count;
+}
+function angleForAxisValue(min, max, value) {
+  const ratio = max === min ? 0 : (value - min) / (max - min);
+  return START_ANGLE + ratio * Math.PI * 2;
+}
+function radarPointAt(frame, index, pointRadius) {
+  const angle = radarAngleAt(frame.count, index);
+  return {
+    x: frame.centerX + Math.cos(angle) * pointRadius,
+    y: frame.centerY + Math.sin(angle) * pointRadius
+  };
+}
+function radarRadiusForValue(frame, value) {
+  const range = frame.max - frame.min;
+  const ratio = range === 0 ? 0 : Math.max(0, Math.min(1, (value - frame.min) / range));
+  return ratio * frame.radius;
+}
+function radarVertexPoint(frame, index, value) {
+  return radarPointAt(frame, index, radarRadiusForValue(frame, value));
+}
+function radarValueAtPoint(frame, index, px, py) {
+  const angle = radarAngleAt(frame.count, index);
+  const projected = (px - frame.centerX) * Math.cos(angle) + (py - frame.centerY) * Math.sin(angle);
+  const ratio = frame.radius === 0 ? 0 : Math.max(0, Math.min(1, projected / frame.radius));
+  return frame.min + ratio * (frame.max - frame.min);
+}
+function radarSeriesPath(points, curved) {
+  if (points.length === 0) {
+    return "";
+  }
+  if (curved) {
+    return freeformPathData({ points, tension: CURVED_TENSION, closed: true });
+  }
+  const commands = points.map((point, index) => `${index ? "L " : ""}${point.x} ${point.y}`);
+  return `M ${commands.join(" ")} Z`;
+}
+
+// src/svg/domContract/attributes.ts
+var SYMBOL_POINTS_ATTR = "data-sf-symbol-points";
+var SYMBOL_TENSION_ATTR = "data-sf-symbol-tension";
+var SYMBOL_BOUNDS_ATTR = "data-sf-symbol-bounds";
+var CORNER_RADIUS_ATTR = "data-sf-corner-radius";
+var SQUARE_CORNER_ATTR = "data-sf-square-corner";
+var PATH_POINTS_ATTR = "data-sf-path-points";
+var PATH_TENSION_ATTR = "data-sf-path-tension";
+var PATH_CLOSED_ATTR = "data-sf-path-closed";
+var PATH_POINT_INDEX_ATTR = "data-sf-path-point";
+var ISOMETRIC_SIZE_ATTR = "data-sf-isometric-size";
+var ISOMETRIC_LABEL_OFFSET_ATTR = "data-sf-isometric-label-offset";
+
+// src/model/geometry/rectangle/edgePoint.ts
+function elementCenter(rect) {
+  return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+}
+function edgePointToward(rect, other) {
+  const center = elementCenter(rect);
+  const otherCenter = elementCenter(other);
+  const angle = Math.atan2(otherCenter.y - center.y, otherCenter.x - center.x);
+  if (angle >= -Math.PI / 4 && angle < Math.PI / 4) {
+    return { x: rect.x + rect.width, y: center.y };
+  }
+  if (angle >= Math.PI / 4 && angle < 3 * Math.PI / 4) {
+    return { x: center.x, y: rect.y + rect.height };
+  }
+  if (angle >= -3 * Math.PI / 4 && angle < -Math.PI / 4) {
+    return { x: center.x, y: rect.y };
+  }
+  return { x: rect.x, y: center.y };
+}
+
+// src/renderScene/scene/tagging.ts
+function tag(nodes, role, id, kind, label, parentFrameId) {
+  nodes.forEach((node, index) => {
+    node.identity = {
+      role,
+      id,
+      ...kind ? { kind } : {},
+      ...index === 0 ? { primary: true } : {},
+      ...index === 0 && label ? { label } : {},
+      ...index === 0 && parentFrameId ? { parentFrameId } : {}
+    };
+  });
+  return nodes;
+}
+
+// src/renderScene/scene/numbers.ts
+function finite(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+// src/renderScene/scene/textStyle.ts
+var DEFAULT_FONT = "Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
+
+// src/renderScene/scene/paint.ts
+function paint(value, diagnostics, ownerId) {
+  if (!value) {
+    return { kind: "none" };
+  }
+  if (typeof value === "string") {
+    return { kind: "solid", color: value };
+  }
+  if (value.type === "gradient") {
+    return {
+      kind: "linear-gradient",
+      angle: value.angle,
+      stops: value.stops.map((stop) => ({ offset: stop.position, color: stop.color }))
+    };
+  }
+  if (value.points.length === 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "empty-mesh-gradient",
+      ownerId,
+      message: "Mesh gradient has no color points."
+    });
+    return { kind: "none" };
+  }
+  return {
+    kind: "mesh-gradient",
+    points: value.points.map((point) => ({ x: point.x, y: point.y, color: point.color }))
+  };
+}
+
+// src/renderScene/scene/roundedRectPath.ts
+function topRoundedRectPath(x, y, width, height, radius) {
+  const clampedRadius = Math.max(0, Math.min(radius, width / 2, height));
+  if (clampedRadius === 0) {
+    return `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`;
+  }
+  return `M ${x} ${y + clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x + clampedRadius} ${y} H ${x + width - clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x + width} ${y + clampedRadius} V ${y + height} H ${x} Z`;
+}
+function bottomRoundedRectPath(x, y, width, height, radius) {
+  const clampedRadius = Math.max(0, Math.min(radius, width / 2, height));
+  if (clampedRadius === 0) {
+    return `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`;
+  }
+  return `M ${x} ${y} H ${x + width} V ${y + height - clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x + width - clampedRadius} ${y + height} H ${x + clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x} ${y + height - clampedRadius} Z`;
+}
+function leftRoundedRectPath(x, y, width, height, radius) {
+  const clampedRadius = Math.max(0, Math.min(radius, width / 2, height / 2));
+  if (clampedRadius === 0) {
+    return `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`;
+  }
+  return `M ${x} ${y + clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x + clampedRadius} ${y} H ${x + width} V ${y + height} H ${x + clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x} ${y + height - clampedRadius} Z`;
+}
+function rightRoundedRectPath(x, y, width, height, radius) {
+  const clampedRadius = Math.max(0, Math.min(radius, width / 2, height / 2));
+  if (clampedRadius === 0) {
+    return `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`;
+  }
+  return `M ${x} ${y} H ${x + width - clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x + width} ${y + clampedRadius} V ${y + height - clampedRadius} A ${clampedRadius} ${clampedRadius} 0 0 1 ${x + width - clampedRadius} ${y + height} H ${x} Z`;
+}
+function cornersRoundedRectPath(x, y, width, height, radii) {
+  const max = Math.max(0, Math.min(width, height) / 2);
+  const tl = Math.max(0, Math.min(radii.topLeft, max));
+  const tr = Math.max(0, Math.min(radii.topRight, max));
+  const br = Math.max(0, Math.min(radii.bottomRight, max));
+  const bl = Math.max(0, Math.min(radii.bottomLeft, max));
+  const arcTo = (r, toX, toY) => r > 0 ? `A ${r} ${r} 0 0 1 ${toX} ${toY} ` : "";
+  return `M ${x + tl} ${y} H ${x + width - tr} ` + arcTo(tr, x + width, y + tr) + `V ${y + height - br} ` + arcTo(br, x + width - br, y + height) + `H ${x + bl} ` + arcTo(bl, x, y + height - bl) + `V ${y + tl} ` + arcTo(tl, x + tl, y) + "Z";
+}
+
+// src/renderScene/scene/roundedPolygonPath.ts
+function distance(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function toward(from, to, distanceFromStart) {
+  const length = distance(from, to);
+  if (length === 0) {
+    return from;
+  }
+  const ratio = distanceFromStart / length;
+  return {
+    x: from.x + (to.x - from.x) * ratio,
+    y: from.y + (to.y - from.y) * ratio
+  };
+}
+function roundedCorner(previous, vertex, next, requestedRadius) {
+  const radius = Math.max(0, Math.min(requestedRadius, distance(vertex, previous) / 2, distance(vertex, next) / 2));
+  return {
+    vertex,
+    start: toward(vertex, previous, radius),
+    end: toward(vertex, next, radius)
+  };
+}
+function roundedPolygonPath(points, radius) {
+  if (points.length < 3) {
+    return "";
+  }
+  const radiusAt = (index) => typeof radius === "number" ? radius : radius[index] ?? 0;
+  if (points.every((_, index) => radiusAt(index) <= 0)) {
+    const [first2, ...rest] = points;
+    return `M ${first2.x} ${first2.y} ${rest.map((point) => `L ${point.x} ${point.y}`).join(" ")} Z`;
+  }
+  const corners = points.map(
+    (vertex, index) => roundedCorner(
+      points[(index - 1 + points.length) % points.length],
+      vertex,
+      points[(index + 1) % points.length],
+      radiusAt(index)
+    )
+  );
+  const commands = [`M ${corners[0].end.x} ${corners[0].end.y}`];
+  for (let index = 1; index < corners.length; index++) {
+    const corner = corners[index];
+    commands.push(
+      `L ${corner.start.x} ${corner.start.y}`,
+      `Q ${corner.vertex.x} ${corner.vertex.y} ${corner.end.x} ${corner.end.y}`
+    );
+  }
+  const first = corners[0];
+  commands.push(
+    `L ${first.start.x} ${first.start.y}`,
+    `Q ${first.vertex.x} ${first.vertex.y} ${first.end.x} ${first.end.y}`,
+    "Z"
+  );
+  return commands.join(" ");
+}
+
+// src/renderScene/scene/textLayout.ts
+var PLAIN_CHAR_FACTOR = 0.58;
+var BOLD_CHAR_FACTOR = 0.64;
+function wrapText(text, width, fontSize, metrics) {
+  const maxChars = Math.max(1, Math.floor(width / Math.max(1, fontSize * PLAIN_CHAR_FACTOR)));
+  const fits = metrics ? (line, word) => metrics.measure(line, false) + metrics.spaceWidth + metrics.measure(word, false) <= width : (line, word) => `${line} ${word}`.length <= maxChars;
+  const result = [];
+  for (const rawLine of text.split("\n")) {
+    const words = rawLine.split(/\s+/).filter(Boolean);
+    if (!words.length) {
+      result.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of words) {
+      if (!line) {
+        line = word;
+      } else if (fits(line, word)) {
+        line += ` ${word}`;
+      } else {
+        result.push(line);
+        line = word;
+      }
+    }
+    result.push(line);
+  }
+  return result;
+}
+function estimateTextWidth(text, fontSize, bold) {
+  return text.length * fontSize * (bold ? BOLD_CHAR_FACTOR : PLAIN_CHAR_FACTOR);
+}
+function heuristicRichMeasure(fontSize) {
+  return {
+    measure: (text, bold) => estimateTextWidth(text, fontSize, bold),
+    spaceWidth: fontSize * PLAIN_CHAR_FACTOR
+  };
+}
+
+// src/renderScene/artifacts/link/geometry/routing/sideNormal.ts
+function sideNormal(side) {
+  switch (side) {
+    case "top":
+      return [0, -1];
+    case "right":
+      return [1, 0];
+    case "bottom":
+      return [0, 1];
+    case "left":
+      return [-1, 0];
+  }
+}
+
+// src/renderScene/artifacts/link/geometry/routing/cubic.ts
+function controlDistances(from, to, fromNormal, toNormal, options) {
+  const minimum = options?.min;
+  const maximum = options?.max;
+  const perpendicularScale = options?.perpendicularScale;
+  const deltaX = to.x - from.x;
+  const deltaY = to.y - from.y;
+  const alongFrom = Math.abs(deltaX * fromNormal[0] + deltaY * fromNormal[1]);
+  const alongTo = Math.abs(deltaX * toNormal[0] + deltaY * toNormal[1]);
+  const perpendicularFrom = Math.abs(deltaX * fromNormal[1] - deltaY * fromNormal[0]);
+  const perpendicularTo = Math.abs(deltaX * toNormal[1] - deltaY * toNormal[0]);
+  const parallel = fromNormal[0] === toNormal[0] && fromNormal[1] === toNormal[1] || fromNormal[0] === -toNormal[0] && fromNormal[1] === -toNormal[1];
+  let fromDistance = Math.max(minimum, Math.min(maximum, Math.max(alongFrom, perpendicularFrom * perpendicularScale)));
+  let toDistance = Math.max(minimum, Math.min(maximum, Math.max(alongTo, perpendicularTo * perpendicularScale)));
+  if (parallel) {
+    fromDistance = Math.min(maximum, fromDistance + perpendicularFrom * 0.75);
+    toDistance = Math.min(maximum, toDistance + perpendicularTo * 0.75);
+  }
+  return { fromDistance, toDistance };
+}
+function routeCubic(from, to, fromSide, toSide, options) {
+  const fromNormal = sideNormal(fromSide);
+  const toNormal = sideNormal(toSide);
+  const { fromDistance, toDistance } = controlDistances(from, to, fromNormal, toNormal, options);
+  return {
+    p0: [from.x, from.y],
+    p1: [from.x + fromNormal[0] * fromDistance, from.y + fromNormal[1] * fromDistance],
+    p2: [to.x + toNormal[0] * toDistance, to.y + toNormal[1] * toDistance],
+    p3: [to.x, to.y]
+  };
+}
+
+// src/renderScene/artifacts/link/geometry/routing/curvedRoute.ts
+function calculateCurvedLinkRoute(from, to, fromSide, toSide) {
+  const { p0, p1, p2, p3 } = routeCubic(from, to, fromSide, toSide, {
+    min: 35,
+    max: 90,
+    perpendicularScale: 0.5
+  });
+  return { points: [...p0, ...p1, ...p2, ...p3], segments: [] };
+}
+
+// src/renderScene/artifacts/link/geometry/routing/orthogonalPlan.ts
+function snapAlignedEndpoints(from, to, fromSide, toSide) {
+  const threshold = 6;
+  const verticalPair = ["top", "bottom"].includes(fromSide) && ["top", "bottom"].includes(toSide);
+  const horizontalPair = ["left", "right"].includes(fromSide) && ["left", "right"].includes(toSide);
+  if (verticalPair && Math.abs(to.x - from.x) < threshold) {
+    return [from, { ...to, x: from.x }];
+  }
+  if (horizontalPair && Math.abs(to.y - from.y) < threshold) {
+    return [from, { ...to, y: from.y }];
+  }
+  return [from, to];
+}
+function chooseInitialOrientation(from, to, endpointEdges) {
+  if (endpointEdges?.toEdge) {
+    return endpointEdges.toEdge === "left" || endpointEdges.toEdge === "right";
+  }
+  if (endpointEdges?.fromEdge) {
+    return endpointEdges.fromEdge === "left" || endpointEdges.fromEdge === "right";
+  }
+  return Math.abs(to.x - from.x) > Math.abs(to.y - from.y);
+}
+function stepOutDistances(from, to, fromNormal, toNormal, horizontalFirst) {
+  let fromDistance = 40;
+  let toDistance = 40;
+  const axis = horizontalFirst ? 0 : 1;
+  const delta = horizontalFirst ? to.x - from.x : to.y - from.y;
+  if (fromNormal[axis] !== 0 && fromNormal[axis] === -toNormal[axis]) {
+    const gap = delta * fromNormal[axis];
+    if (gap > 0 && gap < fromDistance + toDistance) {
+      fromDistance = gap / 2;
+      toDistance = gap / 2;
+    }
+  } else if (fromNormal[axis] === 0) {
+    const gap = delta * -toNormal[axis];
+    if (gap > 0 && gap < toDistance) {
+      toDistance = gap;
+    }
+  }
+  return [fromDistance, toDistance];
+}
+function chooseBend(route) {
+  const { fromConnection, toConnection, to, horizontalFirst } = route;
+  const fromStub = fromConnection.stub;
+  const toStub = toConnection.stub;
+  let x = (fromStub[0] + toStub[0]) / 2;
+  let y = (fromStub[1] + toStub[1]) / 2;
+  const fromHorizontal = isHorizontalSide(fromConnection.side);
+  const toHorizontal = isHorizontalSide(toConnection.side);
+  if (fromHorizontal !== toHorizontal) {
+    if (horizontalFirst) {
+      x = (fromStub[0] - to.x) * toConnection.normal[0] >= 0 ? fromStub[0] : toStub[0];
+    } else {
+      y = (fromStub[1] - to.y) * toConnection.normal[1] >= 0 ? fromStub[1] : toStub[1];
+    }
+  } else if (fromConnection.side === toConnection.side) {
+    if (horizontalFirst) {
+      x = fromConnection.normal[0] < 0 ? Math.min(fromStub[0], toStub[0]) : Math.max(fromStub[0], toStub[0]);
+    } else {
+      y = fromConnection.normal[1] < 0 ? Math.min(fromStub[1], toStub[1]) : Math.max(fromStub[1], toStub[1]);
+    }
+  }
+  return [x, y];
+}
+function isHorizontalSide(side) {
+  return side === "left" || side === "right";
+}
+
+// src/renderScene/artifacts/link/geometry/routing/orthogonalPoints.ts
+function segmentMidpoints(points) {
+  const midpoints = [];
+  for (let index = 0; index < points.length - 2; index += 2) {
+    midpoints.push({
+      x: (points[index] + points[index + 2]) / 2,
+      y: (points[index + 1] + points[index + 3]) / 2
+    });
+  }
+  return midpoints;
+}
+function baseOrthogonalPoints(route, bend) {
+  const { from, to, fromConnection, toConnection, horizontalFirst } = route;
+  const fromStub = fromConnection.stub;
+  const toStub = toConnection.stub;
+  const points = [from.x, from.y, fromStub[0], fromStub[1]];
+  if (horizontalFirst) {
+    points.push(bend[0], fromStub[1], bend[0], toStub[1]);
+  } else {
+    points.push(fromStub[0], bend[1], toStub[0], bend[1]);
+  }
+  points.push(toStub[0], toStub[1], to.x, to.y);
+  return points;
+}
+function movableInnerSegments(horizontalFirst, fromSide, toSide) {
+  const fixedSides = horizontalFirst ? ["left", "right"] : ["top", "bottom"];
+  return [!fixedSides.includes(fromSide), !fixedSides.includes(toSide)];
+}
+function offsetOrthogonalPoints(route, bend, segmentOffsets, movable) {
+  const { from, to, fromConnection, toConnection, horizontalFirst } = route;
+  const fromStub = fromConnection.stub;
+  const toStub = toConnection.stub;
+  const first = movable[0] ? segmentOffsets?.[1] || 0 : 0;
+  const middle = segmentOffsets?.[2] || 0;
+  const last = movable[1] ? segmentOffsets?.[3] || 0 : 0;
+  if (horizontalFirst) {
+    const fromY = fromStub[1] + first;
+    const bendX = bend[0] + middle;
+    const toY = toStub[1] + last;
+    return [from.x, from.y, fromStub[0], fromY, bendX, fromY, bendX, toY, toStub[0], toY, to.x, to.y];
+  }
+  const fromX = fromStub[0] + first;
+  const bendY = bend[1] + middle;
+  const toX = toStub[0] + last;
+  return [from.x, from.y, fromX, fromStub[1], fromX, bendY, toX, bendY, toX, toStub[1], to.x, to.y];
+}
+
+// src/renderScene/artifacts/link/geometry/routing/orthogonalSegments.ts
+function describeSegments(points, originalMidpoints, canMoveFirstInner, canMoveLastInner) {
+  const totalSegments = (points.length - 2) / 2;
+  return originalMidpoints.map((originalMidpoint, segmentIndex) => {
+    const offset = segmentIndex * 2;
+    const start = { x: points[offset], y: points[offset + 1] };
+    const end = { x: points[offset + 2], y: points[offset + 3] };
+    const midpoint = { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 };
+    const isInner = segmentIndex > 0 && segmentIndex < totalSegments - 1;
+    const isMovableEdge = segmentIndex === 1 ? canMoveFirstInner : segmentIndex === totalSegments - 2 ? canMoveLastInner : true;
+    const hasLength = Math.hypot(end.x - start.x, end.y - start.y) >= 1;
+    return {
+      start,
+      end,
+      midpoint,
+      originalMidpoint,
+      isHorizontal: Math.abs(end.x - start.x) > Math.abs(end.y - start.y),
+      canMove: isInner && isMovableEdge && hasLength
+    };
+  });
+}
+
+// src/renderScene/artifacts/link/geometry/routing/rounding.ts
+var CORNER_SAMPLE_COUNT = 8;
+function roundOrthogonalPoints(coordinates, maximumRadius) {
+  if (coordinates.length < 6) {
+    return coordinates;
+  }
+  const points = coordinatePoints(coordinates);
+  const roundedPoints = [points[0]];
+  for (let index = 1; index < points.length - 1; index++) {
+    const corner = createRoundedCorner(points[index - 1], points[index], points[index + 1], maximumRadius);
+    roundedPoints.push(...corner ? sampleRoundedCorner(corner) : [points[index]]);
+  }
+  roundedPoints.push(points[points.length - 1]);
+  return roundedPoints.flatMap((point) => [point.x, point.y]);
+}
+function createRoundedCorner(previous, corner, next, maximumRadius) {
+  const incoming = { x: corner.x - previous.x, y: corner.y - previous.y };
+  const outgoing = { x: next.x - corner.x, y: next.y - corner.y };
+  const incomingIsAxisAligned = incoming.x === 0 || incoming.y === 0;
+  const outgoingIsAxisAligned = outgoing.x === 0 || outgoing.y === 0;
+  const isStraight = incoming.x === 0 && outgoing.x === 0 || incoming.y === 0 && outgoing.y === 0;
+  if (!incomingIsAxisAligned || !outgoingIsAxisAligned || isStraight) {
+    return null;
+  }
+  const radius = Math.min(maximumRadius, axisLength(incoming) * 0.4, axisLength(outgoing) * 0.4);
+  if (radius <= 0) {
+    return null;
+  }
+  const incomingDirection = axisDirection(incoming);
+  const outgoingDirection = axisDirection(outgoing);
+  const entry = offsetPoint(corner, incomingDirection, -radius);
+  const exit = offsetPoint(corner, outgoingDirection, radius);
+  const center = offsetPoint(entry, outgoingDirection, radius);
+  const startAngle = Math.atan2(entry.y - center.y, entry.x - center.x);
+  const endAngle = Math.atan2(exit.y - center.y, exit.x - center.x);
+  return { entry, exit, center, radius, startAngle, angleSweep: normalizedAngleSweep(endAngle - startAngle) };
+}
+function offsetPoint(point, direction, distance2) {
+  return { x: point.x + direction.x * distance2, y: point.y + direction.y * distance2 };
+}
+function axisLength(vector) {
+  return Math.abs(vector.x) + Math.abs(vector.y);
+}
+function axisDirection(vector) {
+  return { x: vector.x !== 0 ? Math.sign(vector.x) : 0, y: vector.y !== 0 ? Math.sign(vector.y) : 0 };
+}
+function normalizedAngleSweep(angle) {
+  if (angle > Math.PI) {
+    return angle - 2 * Math.PI;
+  }
+  if (angle < -Math.PI) {
+    return angle + 2 * Math.PI;
+  }
+  return angle;
+}
+function sampleRoundedCorner(corner) {
+  const points = [corner.entry];
+  for (let sampleIndex = 1; sampleIndex < CORNER_SAMPLE_COUNT - 1; sampleIndex++) {
+    const progress = sampleIndex / (CORNER_SAMPLE_COUNT - 1);
+    const angle = corner.startAngle + corner.angleSweep * progress;
+    points.push({
+      x: corner.center.x + Math.cos(angle) * corner.radius,
+      y: corner.center.y + Math.sin(angle) * corner.radius
+    });
+  }
+  points.push(corner.exit);
+  return points;
+}
+function coordinatePoints(coordinates) {
+  const points = [];
+  for (let index = 0; index < coordinates.length; index += 2) {
+    points.push({ x: coordinates[index], y: coordinates[index + 1] });
+  }
+  return points;
+}
+
+// src/renderScene/artifacts/link/geometry/routing/orthogonal.ts
+function routeOrthogonal(request) {
+  const routeDraft = createOrthogonalRouteDraft(request);
+  const bend = chooseBend(routeDraft);
+  const originalPoints = baseOrthogonalPoints(routeDraft, bend);
+  const originalSegmentMidpoints = segmentMidpoints(originalPoints);
+  const movableSegments = movableInnerSegments(routeDraft.horizontalFirst, request.fromSide, request.toSide);
+  const points = offsetOrthogonalPoints(routeDraft, bend, request.segmentOffsets, movableSegments);
+  const segments = describeSegments(points, originalSegmentMidpoints, movableSegments[0], movableSegments[1]);
+  return { points: roundOrthogonalPoints(points, 10), segments };
+}
+function createOrthogonalRouteDraft(request) {
+  const [alignedFrom, alignedTo] = snapAlignedEndpoints(request.from, request.to, request.fromSide, request.toSide);
+  const fromNormal = sideNormal(request.fromSide);
+  const toNormal = sideNormal(request.toSide);
+  const horizontalFirst = chooseInitialOrientation(alignedFrom, alignedTo, request.endpointEdges);
+  const [fromDistance, toDistance] = stepOutDistances(alignedFrom, alignedTo, fromNormal, toNormal, horizontalFirst);
+  return {
+    from: alignedFrom,
+    to: alignedTo,
+    fromConnection: createRouteConnection(alignedFrom, request.fromSide, fromNormal, fromDistance),
+    toConnection: createRouteConnection(alignedTo, request.toSide, toNormal, toDistance),
+    horizontalFirst
+  };
+}
+function createRouteConnection(point, side, normal, distance2) {
+  return { side, normal, stub: [point.x + normal[0] * distance2, point.y + normal[1] * distance2] };
+}
+
+// src/renderScene/artifacts/link/geometry/routing/waypoints.ts
+var ORTHOGONAL_EPSILON = 0.5;
+function pathFromWaypoints(from, waypoints, to) {
+  const corners = [from, ...waypoints, to];
+  const points = [];
+  for (const point of corners) {
+    points.push(point.x, point.y);
+  }
+  const segments = [];
+  for (let index = 0; index < points.length - 2; index += 2) {
+    const start = { x: points[index], y: points[index + 1] };
+    const end = { x: points[index + 2], y: points[index + 3] };
+    const midpoint = { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 };
+    segments.push({
+      start,
+      end,
+      midpoint,
+      originalMidpoint: midpoint,
+      isHorizontal: Math.abs(end.x - start.x) > Math.abs(end.y - start.y),
+      canMove: false
+    });
+  }
+  return { points: roundOrthogonalPoints(points, 10), segments };
+}
+function isAxisAligned(segments) {
+  return segments.every((segment) => {
+    const dx = Math.abs(segment.end.x - segment.start.x);
+    const dy = Math.abs(segment.end.y - segment.start.y);
+    return dx <= ORTHOGONAL_EPSILON || dy <= ORTHOGONAL_EPSILON;
+  });
+}
+
+// src/renderScene/artifacts/link/geometry/routing/orthogonalRoute.ts
+function calculateOrthogonalLinkRoute(link, from, to, fromSide, toSide) {
+  if (link.waypoints && link.waypoints.length > 0) {
+    const waypointResult = pathFromWaypoints(from, link.waypoints, to);
+    if (isAxisAligned(waypointResult.segments)) {
+      return waypointResult;
+    }
+  }
+  const endpointEdges = { fromEdge: fromSide, toEdge: toSide };
+  const request = { from, to, fromSide, toSide, segmentOffsets: link.segmentOffsets, endpointEdges };
+  const route = routeOrthogonal(request);
+  if (isAxisAligned(route.segments)) {
+    return route;
+  }
+  return routeOrthogonal({ ...request, segmentOffsets: void 0 });
+}
+
+// src/renderScene/artifacts/link/geometry/routing/sides.ts
+function facingSide(from, to) {
+  const angle = Math.atan2(to.y - from.y, to.x - from.x);
+  if (angle >= -Math.PI / 4 && angle < Math.PI / 4) {
+    return "right";
+  }
+  if (angle >= Math.PI / 4 && angle < 3 * Math.PI / 4) {
+    return "bottom";
+  }
+  if (angle >= -3 * Math.PI / 4 && angle < -Math.PI / 4) {
+    return "top";
+  }
+  return "left";
+}
+function connectionSides(link, from, to) {
+  const fromSide = link.fromPoint?.kind === "side" ? link.fromPoint.side : facingSide(from, to);
+  const toSide = link.toPoint?.kind === "side" ? link.toPoint.side : facingSide(to, from);
+  return { fromSide, toSide };
+}
+
+// src/renderScene/artifacts/link/geometry/routing/straightRoute.ts
+function calculateStraightLinkRoute(from, to) {
+  return { points: [from.x, from.y, to.x, to.y], segments: [] };
+}
+
+// src/renderScene/artifacts/link/geometry/routing.ts
+function calculateLinkRoute(link, effectiveFrom, effectiveTo, pathType) {
+  const { fromSide, toSide } = connectionSides(link, effectiveFrom, effectiveTo);
+  if (pathType === "curved") {
+    return calculateCurvedLinkRoute(effectiveFrom, effectiveTo, fromSide, toSide);
+  }
+  if (pathType === "orthogonal") {
+    return calculateOrthogonalLinkRoute(link, effectiveFrom, effectiveTo, fromSide, toSide);
+  }
+  return calculateStraightLinkRoute(effectiveFrom, effectiveTo);
+}
+
+// src/renderScene/artifacts/shape/geometry/roundedForms.ts
+var KAPPA = 0.5523;
+var CYLINDER_CAP_OF_HEIGHT = 0.22;
+var CYLINDER_CAP_OF_WIDTH = 0.2;
+var PERSON_BODY_IN_HEADS = 2;
+var PERSON_NECK_IN_HEADS = 0.35;
+var PERSON_WIDTH_IN_HEADS = 2 * PERSON_BODY_IN_HEADS;
+var PERSON_HEIGHT_IN_HEADS = 2 + PERSON_NECK_IN_HEADS + PERSON_BODY_IN_HEADS;
+function cylinderPath(x, y, width, height) {
+  const cap = Math.min(height * CYLINDER_CAP_OF_HEIGHT, width * CYLINDER_CAP_OF_WIDTH);
+  const rx = width / 2;
+  const cx = x + rx;
+  const left = x;
+  const right = x + width;
+  const lidY = y + cap;
+  const floorY = y + height - cap;
+  const lid = `M ${left} ${lidY} C ${left} ${lidY + KAPPA * cap} ${cx - KAPPA * rx} ${lidY + cap} ${cx} ${lidY + cap} C ${cx + KAPPA * rx} ${lidY + cap} ${right} ${lidY + KAPPA * cap} ${right} ${lidY} C ${right} ${lidY - KAPPA * cap} ${cx + KAPPA * rx} ${y} ${cx} ${y} C ${cx - KAPPA * rx} ${y} ${left} ${lidY - KAPPA * cap} ${left} ${lidY} Z`;
+  const wall = `M ${left} ${lidY} L ${left} ${floorY} C ${left} ${floorY + KAPPA * cap} ${cx - KAPPA * rx} ${y + height} ${cx} ${y + height} C ${cx + KAPPA * rx} ${y + height} ${right} ${floorY + KAPPA * cap} ${right} ${floorY} L ${right} ${lidY}`;
+  return `${lid} ${wall}`;
+}
+function personFigure(x, y, width, height) {
+  const scale = Math.min(width / PERSON_WIDTH_IN_HEADS, height / PERSON_HEIGHT_IN_HEADS);
+  const head = scale;
+  const body = scale * PERSON_BODY_IN_HEADS;
+  const figureHeight = scale * PERSON_HEIGHT_IN_HEADS;
+  const top = y + (height - figureHeight) / 2;
+  return { head, body, centerX: x + width / 2, headCenterY: top + head, bottom: top + figureHeight };
+}
+function personLabelArea(x, y, width, height) {
+  const { body, centerX, bottom } = personFigure(x, y, width, height);
+  return { x: centerX - body, y: bottom - body, width: body * 2, height: body };
+}
+function personPath(x, y, width, height) {
+  const { head, body, centerX, headCenterY, bottom } = personFigure(x, y, width, height);
+  const skull = `M ${centerX} ${headCenterY - head} C ${centerX + KAPPA * head} ${headCenterY - head} ${centerX + head} ${headCenterY - KAPPA * head} ${centerX + head} ${headCenterY} C ${centerX + head} ${headCenterY + KAPPA * head} ${centerX + KAPPA * head} ${headCenterY + head} ${centerX} ${headCenterY + head} C ${centerX - KAPPA * head} ${headCenterY + head} ${centerX - head} ${headCenterY + KAPPA * head} ${centerX - head} ${headCenterY} C ${centerX - head} ${headCenterY - KAPPA * head} ${centerX - KAPPA * head} ${headCenterY - head} ${centerX} ${headCenterY - head} Z`;
+  const dome = `M ${centerX - body} ${bottom} C ${centerX - body} ${bottom - KAPPA * body} ${centerX - KAPPA * body} ${bottom - body} ${centerX} ${bottom - body} C ${centerX + KAPPA * body} ${bottom - body} ${centerX + body} ${bottom - KAPPA * body} ${centerX + body} ${bottom} Z`;
+  return `${skull} ${dome}`;
+}
+
+// src/renderScene/charts/primitives/barLabel.ts
+var BAR_LABEL = { padX: 8, padY: 3, charWidth: 0.58, lineHeight: 1.2, gap: 4 };
+function formatBarLabel(value, template) {
+  return (template || "{value}").replace("{value}", String(Math.round(value * 100) / 100));
+}
+function barLabelSize(text, fontSize, pill) {
+  const padX = pill ? BAR_LABEL.padX : 0;
+  const padY = pill ? BAR_LABEL.padY : 0;
+  const lineHeight = fontSize * BAR_LABEL.lineHeight;
+  return {
+    width: text.length * fontSize * BAR_LABEL.charWidth + padX * 2,
+    height: lineHeight + padY * 2,
+    lineHeight,
+    padX,
+    padY
+  };
+}
+function pillPath(x, y, width, height) {
+  const r = height / 2;
+  return `M ${x + r} ${y} H ${x + width - r} A ${r} ${r} 0 0 1 ${x + width - r} ${y + height} H ${x + r} A ${r} ${r} 0 0 1 ${x + r} ${y} Z`;
+}
+
+// src/renderScene/charts/primitives/barShape.ts
+function barShapePath(x, y, width, height, radius) {
+  const r = Math.max(0, Math.min(radius, width / 2, height));
+  if (r === 0) {
+    return `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`;
+  }
+  return `M ${x} ${y + r} Q ${x} ${y} ${x + r} ${y} H ${x + width - r} Q ${x + width} ${y} ${x + width} ${y + r} V ${y + height} H ${x} Z`;
+}
+function roundedBarPath(x, y, width, height, radius) {
+  const r = Math.max(0, Math.min(radius, width / 2, height / 2));
+  if (r === 0) {
+    return `M ${x} ${y} H ${x + width} V ${y + height} H ${x} Z`;
+  }
+  return `M ${x + r} ${y} H ${x + width - r} Q ${x + width} ${y} ${x + width} ${y + r} V ${y + height - r} Q ${x + width} ${y + height} ${x + width - r} ${y + height} H ${x + r} Q ${x} ${y + height} ${x} ${y + height - r} V ${y + r} Q ${x} ${y} ${x + r} ${y} Z`;
+}
+function barPath(x, y, width, height, radius, roundedBottom) {
+  return roundedBottom ? roundedBarPath(x, y, width, height, radius) : barShapePath(x, y, width, height, radius);
+}
+
+// src/renderScene/charts/primitives/linePath.ts
+function linePathData(points, tension) {
+  if (tension > 0) {
+    return freeformPathData({ points, tension, closed: false });
+  }
+  const commands = points.map((point, index) => `${index ? "L" : ""} ${point.x} ${point.y}`);
+  return `M ${commands.join(" ")}`;
+}
+
+// src/renderScene/charts/primitives/pieShape.ts
+function resolvePieRadii(plotWidth, plotHeight, configInnerRadius, configCornerRadius) {
+  const rawOuterRadius = Math.max(1, Math.min(plotWidth, plotHeight) / 2 - 4);
+  const rawInnerRadius = Math.max(0, Math.min(configInnerRadius ?? 0, rawOuterRadius - 1));
+  const cornerRadius = Math.max(0, Math.min(configCornerRadius ?? 0, rawOuterRadius / 2));
+  const outerRadius = Math.max(1, rawOuterRadius - cornerRadius);
+  const innerRadius = rawInnerRadius > 0 ? Math.min(rawInnerRadius + cornerRadius, outerRadius - 1) : 0;
+  return { outerRadius, innerRadius, cornerRadius };
+}
+function pieArcPoint(geometry, angle, radius) {
+  return {
+    x: geometry.centerX + radius * Math.cos(angle),
+    y: geometry.centerY + radius * Math.sin(angle)
+  };
+}
+function clipSegmentToRect(from, to, halfWidth, halfHeight) {
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  let tMin = 0;
+  let tMax = 1;
+  if (Math.abs(dx) > 1e-6) {
+    const tx1 = (to.x - halfWidth - from.x) / dx;
+    const tx2 = (to.x + halfWidth - from.x) / dx;
+    tMin = Math.max(tMin, Math.min(tx1, tx2));
+    tMax = Math.min(tMax, Math.max(tx1, tx2));
+  }
+  if (Math.abs(dy) > 1e-6) {
+    const ty1 = (to.y - halfHeight - from.y) / dy;
+    const ty2 = (to.y + halfHeight - from.y) / dy;
+    tMin = Math.max(tMin, Math.min(ty1, ty2));
+    tMax = Math.min(tMax, Math.max(ty1, ty2));
+  }
+  const t = tMin <= tMax ? tMin : 1;
+  return { x: from.x + t * dx, y: from.y + t * dy };
+}
+function largeArcFlag(a, b) {
+  return Math.abs(b - a) > Math.PI ? 1 : 0;
+}
+function gapInsetAngle(halfGap, radius) {
+  if (halfGap <= 0 || radius <= 0) {
+    return 0;
+  }
+  return Math.asin(Math.min(1, halfGap / radius));
+}
+function insetAngles(angles, inset) {
+  return { start: angles.start + inset, end: angles.end - inset };
+}
+function pieApexRadius(halfGap, sweep, outerRadius) {
+  if (halfGap <= 0) {
+    return 0;
+  }
+  const halfSweep = Math.min(Math.abs(sweep) / 2, Math.PI / 2);
+  const denominator = Math.sin(halfSweep);
+  return denominator <= 1e-6 ? outerRadius : Math.min(halfGap / denominator, outerRadius);
+}
+function apexSlicePath(geometry, outerAngles, apex) {
+  const start = pieArcPoint(geometry, outerAngles.start, geometry.outerRadius);
+  const end = pieArcPoint(geometry, outerAngles.end, geometry.outerRadius);
+  return [
+    `M ${apex.x} ${apex.y}`,
+    `L ${start.x} ${start.y}`,
+    `A ${geometry.outerRadius} ${geometry.outerRadius} 0 ${largeArcFlag(outerAngles.start, outerAngles.end)} 1 ${end.x} ${end.y}`,
+    "Z"
+  ].join(" ");
+}
+function donutSlicePath(geometry, innerRadius, outerAngles, innerAngles) {
+  const outerStart = pieArcPoint(geometry, outerAngles.start, geometry.outerRadius);
+  const outerEnd = pieArcPoint(geometry, outerAngles.end, geometry.outerRadius);
+  const innerEnd = pieArcPoint(geometry, innerAngles.end, innerRadius);
+  const innerStart = pieArcPoint(geometry, innerAngles.start, innerRadius);
+  return [
+    `M ${outerStart.x} ${outerStart.y}`,
+    `A ${geometry.outerRadius} ${geometry.outerRadius} 0 ${largeArcFlag(outerAngles.start, outerAngles.end)} 1 ${outerEnd.x} ${outerEnd.y}`,
+    `L ${innerEnd.x} ${innerEnd.y}`,
+    `A ${innerRadius} ${innerRadius} 0 ${largeArcFlag(innerAngles.start, innerAngles.end)} 0 ${innerStart.x} ${innerStart.y}`,
+    "Z"
+  ].join(" ");
+}
+var CORNER_ANGLE_HEADROOM = 0.82;
+function pieFillet(geometry, circleRadius, filletCenterRadius, edgeAngle, cornerRadius, sign) {
+  const ratio = Math.min(1, cornerRadius / filletCenterRadius);
+  const angle = edgeAngle + sign * Math.asin(ratio);
+  const d = Math.sqrt(Math.max(0, filletCenterRadius * filletCenterRadius - cornerRadius * cornerRadius));
+  return {
+    lineTangent: { x: geometry.centerX + d * Math.cos(edgeAngle), y: geometry.centerY + d * Math.sin(edgeAngle) },
+    arcTangent: pieArcPoint(geometry, angle, circleRadius),
+    angle
+  };
+}
+function maxPieCornerRadius(outerRadius, innerRadius, sweep) {
+  const halfSweep = Math.min(Math.abs(sweep) / 2, Math.PI / 2);
+  const angleFactor = Math.sin(halfSweep * CORNER_ANGLE_HEADROOM);
+  const outerLimit = outerRadius * angleFactor;
+  const innerLimit = innerRadius > 0 ? innerRadius * angleFactor : Number.POSITIVE_INFINITY;
+  const ringLimit = innerRadius > 0 ? (outerRadius - innerRadius) / 2 : outerRadius / 2;
+  return Math.max(0, Math.min(outerLimit, innerLimit, ringLimit));
+}
+function maxApexCornerRadius(outerRadius, apexRadius, sweep) {
+  const halfSweep = Math.min(Math.abs(sweep) / 2, Math.PI / 2);
+  const angleFactor = Math.sin(halfSweep * CORNER_ANGLE_HEADROOM);
+  const outerLimit = outerRadius * angleFactor;
+  const depthLimit = (outerRadius * outerRadius - apexRadius * apexRadius) / (2 * outerRadius);
+  return Math.max(0, Math.min(outerLimit, depthLimit));
+}
+function roundedApexSlicePath(geometry, outerAngles, cornerRadius, apex) {
+  const { outerRadius } = geometry;
+  const outerFilletCenterRadius = outerRadius - cornerRadius;
+  const start = pieFillet(geometry, outerRadius, outerFilletCenterRadius, outerAngles.start, cornerRadius, 1);
+  const end = pieFillet(geometry, outerRadius, outerFilletCenterRadius, outerAngles.end, cornerRadius, -1);
+  return [
+    `M ${apex.x} ${apex.y}`,
+    `L ${start.lineTangent.x} ${start.lineTangent.y}`,
+    `A ${cornerRadius} ${cornerRadius} 0 0 1 ${start.arcTangent.x} ${start.arcTangent.y}`,
+    `A ${outerRadius} ${outerRadius} 0 ${largeArcFlag(start.angle, end.angle)} 1 ${end.arcTangent.x} ${end.arcTangent.y}`,
+    `A ${cornerRadius} ${cornerRadius} 0 0 1 ${end.lineTangent.x} ${end.lineTangent.y}`,
+    "Z"
+  ].join(" ");
+}
+function roundedDonutSlicePath(geometry, innerRadius, outerAngles, innerAngles, cornerRadius) {
+  const { outerRadius } = geometry;
+  const outerFilletCenterRadius = outerRadius - cornerRadius;
+  const outerStart = pieFillet(geometry, outerRadius, outerFilletCenterRadius, outerAngles.start, cornerRadius, 1);
+  const outerEnd = pieFillet(geometry, outerRadius, outerFilletCenterRadius, outerAngles.end, cornerRadius, -1);
+  const innerFilletCenterRadius = innerRadius + cornerRadius;
+  const innerStart = pieFillet(geometry, innerRadius, innerFilletCenterRadius, innerAngles.start, cornerRadius, 1);
+  const innerEnd = pieFillet(geometry, innerRadius, innerFilletCenterRadius, innerAngles.end, cornerRadius, -1);
+  return [
+    `M ${outerStart.lineTangent.x} ${outerStart.lineTangent.y}`,
+    `A ${cornerRadius} ${cornerRadius} 0 0 1 ${outerStart.arcTangent.x} ${outerStart.arcTangent.y}`,
+    `A ${outerRadius} ${outerRadius} 0 ${largeArcFlag(outerStart.angle, outerEnd.angle)} 1 ${outerEnd.arcTangent.x} ${outerEnd.arcTangent.y}`,
+    `A ${cornerRadius} ${cornerRadius} 0 0 1 ${outerEnd.lineTangent.x} ${outerEnd.lineTangent.y}`,
+    `L ${innerEnd.lineTangent.x} ${innerEnd.lineTangent.y}`,
+    `A ${cornerRadius} ${cornerRadius} 0 0 1 ${innerEnd.arcTangent.x} ${innerEnd.arcTangent.y}`,
+    `A ${innerRadius} ${innerRadius} 0 ${largeArcFlag(innerEnd.angle, innerStart.angle)} 0 ${innerStart.arcTangent.x} ${innerStart.arcTangent.y}`,
+    `A ${cornerRadius} ${cornerRadius} 0 0 1 ${innerStart.lineTangent.x} ${innerStart.lineTangent.y}`,
+    "Z"
+  ].join(" ");
+}
+function pieUsesInnerArc(geometry, angles, gapPx) {
+  const halfGap = Math.max(0, gapPx) / 2;
+  const apexRadius = pieApexRadius(halfGap, angles.end - angles.start, geometry.outerRadius);
+  return geometry.innerRadius > 0 && geometry.innerRadius >= apexRadius;
+}
+function createPieSlicePath(geometry, angles, cornerRadius = 0, gapPx = 0) {
+  const halfGap = Math.max(0, gapPx) / 2;
+  const outerAngles = insetAngles(angles, gapInsetAngle(halfGap, geometry.outerRadius));
+  if (!pieUsesInnerArc(geometry, angles, gapPx)) {
+    const apexRadius = pieApexRadius(halfGap, angles.end - angles.start, geometry.outerRadius);
+    const apex = pieArcPoint(geometry, (angles.start + angles.end) / 2, apexRadius);
+    return cornerRadius > 0 ? roundedApexSlicePath(geometry, outerAngles, cornerRadius, apex) : apexSlicePath(geometry, outerAngles, apex);
+  }
+  const innerAngles = insetAngles(angles, gapInsetAngle(halfGap, geometry.innerRadius));
+  return cornerRadius > 0 ? roundedDonutSlicePath(geometry, geometry.innerRadius, outerAngles, innerAngles, cornerRadius) : donutSlicePath(geometry, geometry.innerRadius, outerAngles, innerAngles);
+}
+
+// src/model/color/conversion.ts
+var hexToRgb2 = (hex) => {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i.exec(hex);
+  if (!result) {
+    return { r: 255, g: 255, b: 255, a: 1 };
+  }
+  return {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16),
+    a: result[4] === void 0 ? 1 : parseInt(result[4], 16) / 255
+  };
+};
+var rgbToHex2 = (r, g, b, a) => {
+  const channel = (x) => {
+    const hex = Math.max(0, Math.min(255, Math.round(x))).toString(16);
+    return hex.length === 1 ? `0${hex}` : hex;
+  };
+  const alphaChannel = a === void 0 || a >= 1 ? "" : channel(a * 255);
+  return `#${channel(r)}${channel(g)}${channel(b)}${alphaChannel}`;
+};
+
+// src/model/color/interpolation.ts
+function mixHexColors(start, end, ratio) {
+  const startRgb = hexToRgb2(start);
+  const endRgb = hexToRgb2(end);
+  const startAlpha = startRgb.a ?? 1;
+  const endAlpha = endRgb.a ?? 1;
+  return rgbToHex2(
+    Math.round(startRgb.r + (endRgb.r - startRgb.r) * ratio),
+    Math.round(startRgb.g + (endRgb.g - startRgb.g) * ratio),
+    Math.round(startRgb.b + (endRgb.b - startRgb.b) * ratio),
+    startAlpha + (endAlpha - startAlpha) * ratio
+  );
+}
+function interpolateHexColorStops(stops, position) {
+  const sortedStops = [...stops].sort((first2, second) => first2.position - second.position);
+  const first = sortedStops[0];
+  const last = sortedStops[sortedStops.length - 1];
+  if (position <= first.position) {
+    return first.color;
+  }
+  if (position >= last.position) {
+    return last.color;
+  }
+  for (let index = 0; index < sortedStops.length - 1; index++) {
+    const start = sortedStops[index];
+    const end = sortedStops[index + 1];
+    if (position >= start.position && position <= end.position) {
+      const range = end.position - start.position;
+      const ratio = range === 0 ? 0 : (position - start.position) / range;
+      return mixHexColors(start.color, end.color, ratio);
+    }
+  }
+  return last.color;
+}
+
+// src/renderScene/charts/primitives/defaults.ts
+var CHART_COLORS = ["#7c3aed", "#0ea5e9", "#f97316", "#10b981", "#ec4899", "#eab308"];
+var DEFAULT_ZONE_FILL = "#94a3b8";
+var DEFAULT_HEATMAP_ZONES = [
+  { label: "Low", color: "#ddd6fe" },
+  { label: "Medium", color: "#a78bfa" },
+  { label: "High", color: "#6d28d9" }
+];
+var DEFAULT_HEX_RADIUS = 14;
+
+// src/renderScene/charts/primitives/axis.ts
+function mapChartValue(value, axis, extent) {
+  if (axis.max === axis.min) {
+    return 0;
+  }
+  return (value - axis.min) / (axis.max - axis.min) * extent;
+}
+function chartTicks(axis) {
+  if (!(axis.step > 0)) {
+    return axis.min === axis.max ? [axis.min] : [axis.min, axis.max];
+  }
+  const ascending = axis.min <= axis.max;
+  const step = ascending ? axis.step : -axis.step;
+  const ticks = [];
+  for (let value = axis.min; (ascending ? value <= axis.max + 1e-9 : value >= axis.max - 1e-9) && ticks.length < 1e3; value += step) {
+    ticks.push(Math.round(value * 1e3) / 1e3);
+  }
+  return ticks;
+}
+function axisBands(axis) {
+  const thresholds = [...axis.thresholds ?? []].filter((threshold) => threshold > axis.min && threshold < axis.max).sort((a, b) => a - b);
+  return [axis.min, ...thresholds, axis.max];
+}
+function zoneColorAtValue(value, bands, zones) {
+  const bandCount = Math.max(0, bands.length - 1);
+  const stops = zones.slice(0, bandCount).map((zone, index) => ({
+    position: bands[index + 1] ?? bands[bands.length - 1],
+    color: zone.color ?? DEFAULT_ZONE_FILL
+  }));
+  if (!stops.length) {
+    return DEFAULT_ZONE_FILL;
+  }
+  return interpolateHexColorStops(stops, value);
+}
+
+// src/renderScene/charts/primitives/barCategories.ts
+function barCategoryCount(chart) {
+  return Math.max(1, chart.config?.categories?.length ?? 0, ...chart.series.map((series) => series.values.length));
+}
+
+// src/renderScene/charts/primitives/boxplot.ts
+function quantile(sorted, probability) {
+  if (sorted.length === 1) {
+    return sorted[0];
+  }
+  const position = (sorted.length - 1) * probability;
+  const lowerIndex = Math.floor(position);
+  const upperIndex = Math.ceil(position);
+  if (lowerIndex === upperIndex) {
+    return sorted[lowerIndex];
+  }
+  return sorted[lowerIndex] + (position - lowerIndex) * (sorted[upperIndex] - sorted[lowerIndex]);
+}
+function computeBoxplotStats(values) {
+  if (!values?.length) {
+    return null;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  return {
+    min: sorted[0],
+    q1: quantile(sorted, 0.25),
+    median: quantile(sorted, 0.5),
+    q3: quantile(sorted, 0.75),
+    max: sorted[sorted.length - 1]
+  };
+}
+
+// src/renderScene/color.ts
+function hexToRgb3(hex) {
+  if (hex?.[0] !== "#") {
+    return void 0;
+  }
+  const channels = hex.length === 4 ? hex.slice(1).split("").map((channel) => parseInt(channel + channel, 16)) : [1, 3, 5].map((index) => parseInt(hex.slice(index, index + 2), 16));
+  const [red, green, blue] = channels;
+  return [red, green, blue].some((channel) => Number.isNaN(channel)) ? void 0 : [red, green, blue];
+}
+function colorWithAlpha(hex, alpha) {
+  const rgb = hexToRgb3(hex);
+  const clamped = Math.max(0, Math.min(1, alpha));
+  if (!rgb) {
+    return clamped <= 0 ? "transparent" : hex ?? "transparent";
+  }
+  const [red, green, blue] = rgb;
+  return `rgba(${red}, ${green}, ${blue}, ${clamped})`;
+}
+function rgbToHex3(red, green, blue) {
+  const channel = (value) => Math.round(Math.max(0, Math.min(255, value))).toString(16).padStart(2, "0");
+  return `#${channel(red)}${channel(green)}${channel(blue)}`;
+}
+function rgbToHsl(red, green, blue) {
+  const r = red / 255;
+  const g = green / 255;
+  const b = blue / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const lightness = (max + min) / 2;
+  const delta = max - min;
+  if (delta === 0) {
+    return [0, 0, lightness];
+  }
+  const saturation = delta / (1 - Math.abs(2 * lightness - 1));
+  let hue;
+  if (max === r) {
+    hue = (g - b) / delta % 6;
+  } else if (max === g) {
+    hue = (b - r) / delta + 2;
+  } else {
+    hue = (r - g) / delta + 4;
+  }
+  hue *= 60;
+  if (hue < 0) {
+    hue += 360;
+  }
+  return [hue, saturation, lightness];
+}
+function hslToRgb(hue, saturation, lightness) {
+  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  const x = chroma * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = lightness - chroma / 2;
+  let [r, g, b] = [0, 0, 0];
+  if (hue < 60) {
+    [r, g, b] = [chroma, x, 0];
+  } else if (hue < 120) {
+    [r, g, b] = [x, chroma, 0];
+  } else if (hue < 180) {
+    [r, g, b] = [0, chroma, x];
+  } else if (hue < 240) {
+    [r, g, b] = [0, x, chroma];
+  } else if (hue < 300) {
+    [r, g, b] = [x, 0, chroma];
+  } else {
+    [r, g, b] = [chroma, 0, x];
+  }
+  return [(r + m) * 255, (g + m) * 255, (b + m) * 255];
+}
+function relativeLuminance(red, green, blue) {
+  const linear = (channel) => {
+    const normalized = channel / 255;
+    return normalized <= 0.03928 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * linear(red) + 0.7152 * linear(green) + 0.0722 * linear(blue);
+}
+function contrastRatio(luminanceA, luminanceB) {
+  const lighter = Math.max(luminanceA, luminanceB);
+  const darker = Math.min(luminanceA, luminanceB);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+var SAME_HUE_LIGHTNESS_GAP = 0.35;
+var SAME_HUE_MIN_LIGHTNESS = 0.08;
+var SAME_HUE_MAX_LIGHTNESS = 0.22;
+var SAME_HUE_LIGHT_MIN_LIGHTNESS = 0.78;
+var SAME_HUE_LIGHT_MAX_LIGHTNESS = 0.92;
+var SAME_HUE_MIN_CONTRAST = 3;
+function contrastTextColor(hex) {
+  const rgb = hexToRgb3(hex);
+  if (!rgb) {
+    return "#0f172a";
+  }
+  const [red, green, blue] = rgb;
+  const fallback = (0.299 * red + 0.587 * green + 0.114 * blue) / 255 > 0.6 ? "#0f172a" : "#ffffff";
+  const [hue, saturation, lightness] = rgbToHsl(red, green, blue);
+  if (saturation === 0) {
+    return fallback;
+  }
+  const targetLightness = lightness > 0.5 ? Math.max(SAME_HUE_MIN_LIGHTNESS, Math.min(lightness - SAME_HUE_LIGHTNESS_GAP, SAME_HUE_MAX_LIGHTNESS)) : Math.min(
+    SAME_HUE_LIGHT_MAX_LIGHTNESS,
+    Math.max(lightness + SAME_HUE_LIGHTNESS_GAP, SAME_HUE_LIGHT_MIN_LIGHTNESS)
+  );
+  const variant = hslToRgb(hue, saturation, targetLightness);
+  const ratio = contrastRatio(relativeLuminance(red, green, blue), relativeLuminance(...variant));
+  return ratio >= SAME_HUE_MIN_CONTRAST ? rgbToHex3(...variant) : fallback;
+}
+function sameHueContrastColor(hex, fallback) {
+  const rgb = hexToRgb3(hex);
+  if (!rgb) {
+    return fallback;
+  }
+  const [red, green, blue] = rgb;
+  const [hue, saturation, lightness] = rgbToHsl(red, green, blue);
+  if (saturation === 0) {
+    return fallback;
+  }
+  const targetLightness = lightness > 0.5 ? Math.max(SAME_HUE_MIN_LIGHTNESS, Math.min(lightness - SAME_HUE_LIGHTNESS_GAP, SAME_HUE_MAX_LIGHTNESS)) : Math.min(
+    SAME_HUE_LIGHT_MAX_LIGHTNESS,
+    Math.max(lightness + SAME_HUE_LIGHTNESS_GAP, SAME_HUE_LIGHT_MIN_LIGHTNESS)
+  );
+  return rgbToHex3(...hslToRgb(hue, saturation, targetLightness));
+}
+function isLightColor(hex) {
+  const rgb = hexToRgb3(hex);
+  return rgb ? rgbToHsl(...rgb)[2] > 0.5 : false;
+}
+function sameHueTint(hex, targetLightness) {
+  const rgb = hexToRgb3(hex);
+  if (!rgb) {
+    return void 0;
+  }
+  const [hue, saturation] = rgbToHsl(...rgb);
+  if (saturation === 0) {
+    return void 0;
+  }
+  return rgbToHex3(...hslToRgb(hue, saturation, targetLightness));
+}
+
+// src/renderScene/charts/primitives/colors.ts
+function representativeColor(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value.type === "gradient") {
+    return value.stops[0]?.color ?? fallback;
+  }
+  return value.points[0]?.color ?? fallback;
+}
+
+// src/renderScene/charts/primitives/errors.ts
+var ERROR_CAP_HALF = 5;
+function errorBarRange(value, error) {
+  return Array.isArray(error) ? [value - error[0], value + error[1]] : [value - error, value + error];
+}
+function createVerticalErrorWhiskerNode(whisker) {
+  return {
+    type: "path",
+    id: whisker.id,
+    order: whisker.order,
+    bounds: whisker.bounds,
+    d: verticalErrorWhiskerPath(whisker.geometry),
+    detail: {
+      of: "chartValue",
+      series: whisker.valueReference.seriesId,
+      valueIndex: whisker.valueReference.valueIndex
+    },
+    style: { fill: { kind: "none" }, stroke: { kind: "solid", color: whisker.color }, strokeWidth: 1 }
+  };
+}
+function verticalErrorWhiskerPath(geometry) {
+  const { centerX, startY, endY } = geometry;
+  const capStartX = centerX - ERROR_CAP_HALF;
+  const capEndX = centerX + ERROR_CAP_HALF;
+  return `M ${centerX} ${startY} L ${centerX} ${endY} M ${capStartX} ${startY} L ${capEndX} ${startY} M ${capStartX} ${endY} L ${capEndX} ${endY}`;
+}
+
+// src/renderScene/charts/primitives/format.ts
+function formatFieldValue(value) {
+  return Number.isInteger(value) ? String(value) : value.toFixed(2).replace(/\.?0+$/, "");
+}
+
+// src/renderScene/charts/primitives/horizontalBars.ts
+var CATEGORY_LABEL_ROW = 18;
+var settings = (chart) => chart.config;
+function isHorizontalBar(chart) {
+  return chart.chartType === "bar" && settings(chart)?.orientation === "horizontal";
+}
+function horizontalRows(chart, plot) {
+  const count = barCategoryCount({ series: chart.series, config: settings(chart) });
+  const slotHeight = plot.height / count;
+  const groupGap = Math.min(Math.max(0, finite(settings(chart)?.barGroupGap, 8)), Math.max(0, slotHeight - 1));
+  const labelRow = chart.categoryAlign === "left" ? CATEGORY_LABEL_ROW : 0;
+  const available = Math.max(1, slotHeight - groupGap - labelRow);
+  const thickness = finite(settings(chart)?.barThickness, 0);
+  const barsHeight = thickness > 0 ? Math.min(available, thickness) : available;
+  return { count, slotHeight, groupGap, labelRow, barsHeight, offset: (available - barsHeight) / 2 };
+}
+function rowTop(rows, plot, index) {
+  return plot.y + index * rows.slotHeight + rows.groupGap / 2 + rows.offset;
+}
+
+// src/renderScene/charts/primitives/segments.ts
+function segmentedBarPath(frame, orientation, count, gap, radius, fraction, snap) {
+  const horizontal = orientation === "horizontal";
+  const length = horizontal ? frame.width : frame.height;
+  const segment = Math.max(1, (length - gap * (count - 1)) / count);
+  const filled = Math.min(count, Math.max(0, fraction * count));
+  const units = snap ? Math.round(filled) : filled;
+  const parts = [];
+  for (let index = 0; index < count; index++) {
+    const visible = Math.min(1, Math.max(0, units - index)) * segment;
+    if (visible < 0.5) {
+      continue;
+    }
+    const offset = index * (segment + gap);
+    parts.push(
+      horizontal ? roundedBarPath(frame.x + offset, frame.y, visible, frame.height, radius) : roundedBarPath(frame.x, frame.y + frame.height - offset - visible, frame.width, visible, radius)
+    );
+  }
+  return parts.join(" ");
+}
+
+// src/renderScene/charts/primitives/shadow.ts
+function resolveChartShadow(shadow) {
+  if (!shadow?.enabled) {
+    return void 0;
+  }
+  const angle = finite(shadow.angle, 45) * Math.PI / 180;
+  const distance2 = finite(shadow.distance, 5);
+  return {
+    color: shadow.color ?? "#000000",
+    opacity: finite(shadow.opacity, 0.25),
+    blur: finite(shadow.blur, 10),
+    dx: Math.cos(angle) * distance2,
+    dy: Math.sin(angle) * distance2
+  };
+}
+
+// src/renderScene/charts/primitives/stacking.ts
+function stackedSegment(chart, mode, categoryIndex, seriesIndex, plotHeight) {
+  const value = chart.series[seriesIndex].values[categoryIndex] ?? 0;
+  if (mode === "waterfall") {
+    return waterfallSegment(chart, categoryIndex, seriesIndex, plotHeight, value);
+  }
+  if (mode === "percent") {
+    return percentSegment(chart, categoryIndex, seriesIndex, plotHeight, value);
+  }
+  return cumulativeSegment(chart, categoryIndex, seriesIndex, plotHeight, value);
+}
+function waterfallSegment(chart, categoryIndex, seriesIndex, plotHeight, value) {
+  let running = 0;
+  for (let index = 0; index < categoryIndex; index++) {
+    running += chart.series[seriesIndex].values[index] ?? 0;
+  }
+  return mappedSegment(value, running, running + value, chart, plotHeight);
+}
+function percentSegment(chart, categoryIndex, seriesIndex, plotHeight, value) {
+  const total = chart.series.reduce((sum, series) => sum + Math.abs(series.values[categoryIndex] ?? 0), 0) || 1;
+  let cumulative = 0;
+  for (let index = 0; index < seriesIndex; index++) {
+    cumulative += Math.abs(chart.series[index].values[categoryIndex] ?? 0);
+  }
+  const magnitude = Math.abs(value);
+  return {
+    value,
+    pixelStart: cumulative / total * plotHeight,
+    pixelEnd: (cumulative + magnitude) / total * plotHeight
+  };
+}
+function cumulativeSegment(chart, categoryIndex, seriesIndex, plotHeight, value) {
+  let cumulative = 0;
+  for (let index = 0; index < seriesIndex; index++) {
+    cumulative += chart.series[index].values[categoryIndex] ?? 0;
+  }
+  return mappedSegment(value, cumulative, cumulative + value, chart, plotHeight);
+}
+function mappedSegment(value, start, end, chart, plotHeight) {
+  return {
+    value,
+    pixelStart: mapChartValue(start, chart.axisY, plotHeight),
+    pixelEnd: mapChartValue(end, chart.axisY, plotHeight)
+  };
+}
+
+// src/renderScene/charts/primitives/text.ts
+function chartText(options) {
+  const { chart, frame } = options;
+  return {
+    type: "text",
+    id: options.id,
+    order: options.order,
+    bounds: options.bounds,
+    ...frame,
+    lines: [options.text],
+    fontFamily: (options.role === "axis" ? chart.axisFontFamily : void 0) ?? chart.fontFamily ?? DEFAULT_FONT,
+    fontSize: Math.max(
+      9,
+      finite(options.role === "axis" ? chart.axisFontSize ?? chart.fontSize : chart.fontSize, 12)
+    ),
+    fontWeight: "normal",
+    color: (options.role === "axis" ? chart.axisLabelColor : options.role === "legend" ? chart.legendColor : void 0) ?? chart.textColor ?? "#0f172a",
+    align: options.align ?? "left",
+    verticalAlign: "top",
+    lineHeight: 1.2,
+    rotation: options.rotation,
+    rotationCenter: options.rotation ? { x: frame.x, y: frame.y } : void 0
+  };
+}
+
+// src/renderScene/charts/renderers/pie/geometry.ts
+function createPieGeometry(context) {
+  const { chart, plot } = context;
+  const resolved = resolvePieRadii(plot.width, plot.height, chart.config?.innerRadius, chart.config?.pieCornerRadius);
+  const outside = chart.config?.pieLabelPosition === "outside" && chart.showAxisLabels !== false;
+  const room = outside ? chart.config?.pieLabelContent === "inline" ? 0.6 : 0.7 : 1;
+  const outerRadius = resolved.outerRadius * room;
+  const innerRadius = resolved.innerRadius * room;
+  const cornerRadius = resolved.cornerRadius;
+  return {
+    centerX: plot.x + plot.width / 2,
+    centerY: plot.y + plot.height / 2,
+    outerRadius,
+    innerRadius,
+    cornerRadius,
+    total: chart.series.reduce((sum, series) => sum + Math.max(0, finite(series.values[0], 0)), 0) || 1
+  };
+}
+
+// src/renderScene/charts/renderers/pie/labels.ts
+var MIN_LABEL_SWEEP = 14 * Math.PI / 180;
+var LABEL_WIDTH = 80;
+var LABEL_RADIUS_FRACTION = 0.62;
+var OUTSIDE_GAP = 14;
+var LEADER_INSET = 3;
+var OUTSIDE_TINT_LIGHTNESS = 0.32;
+var OUTSIDE_FALLBACK_COLOR = "#334155";
+function renderPieLabels(context, geometry, marks) {
+  if (context.chart.showAxisLabels === false) {
+    return [];
+  }
+  return marks.filter((mark) => mark.end - mark.start >= MIN_LABEL_SWEEP).flatMap((mark) => createPieLabel(context, geometry, mark));
+}
+function labelTextPair(context, mark, point, color, fontSize, percent, outside, midAngle) {
+  const { chart, bounds, nextOrder } = context;
+  const lineHeight = fontSize * 1.2;
+  const content = chart.config?.pieLabelContent ?? "both";
+  const width = content === "inline" ? LABEL_WIDTH * 1.9 : LABEL_WIDTH;
+  const base = {
+    bounds,
+    x: point.x - width / 2,
+    width,
+    height: lineHeight,
+    fontFamily: chart.fontFamily ?? DEFAULT_FONT,
+    fontSize,
+    align: "center",
+    verticalAlign: "middle",
+    lineHeight: 1.2,
+    color
+  };
+  const detail = (extra) => ({
+    of: "chartSeries",
+    series: mark.seriesId,
+    mark: "pie-label",
+    pulled: outside || void 0,
+    midAngle,
+    ...extra
+  });
+  const nameText = {
+    type: "text",
+    id: `chart-pie-label-name-${chart.id}-${mark.seriesId}`,
+    order: nextOrder(),
+    ...base,
+    y: content === "name" ? point.y - lineHeight / 2 : point.y - lineHeight,
+    lines: [content === "inline" ? `${mark.label}, ${percent}%` : mark.label],
+    fontWeight: "bold",
+    detail: detail({}),
+    prop: seriesLabelProp(mark.seriesId)
+  };
+  const valueText = {
+    type: "text",
+    id: `chart-pie-label-value-${chart.id}-${mark.seriesId}`,
+    order: nextOrder(),
+    ...base,
+    y: content === "percent" ? point.y - lineHeight / 2 : point.y,
+    lines: [`${percent}%`],
+    fontWeight: "normal",
+    detail: detail({}),
+    prop: seriesValueProp(mark.seriesId, 0),
+    propKind: "value"
+  };
+  if (content === "inline" || content === "name") {
+    return [nameText];
+  }
+  return content === "percent" ? [valueText] : [nameText, valueText];
+}
+function createTick(context, mark, tickStart, tickEnd, color, outside) {
+  const { chart, bounds, nextOrder } = context;
+  return {
+    type: "path",
+    id: `chart-pie-label-tick-${chart.id}-${mark.seriesId}`,
+    order: nextOrder(),
+    bounds,
+    d: `M ${tickStart.x} ${tickStart.y} L ${tickEnd.x} ${tickEnd.y}`,
+    detail: { of: "chartSeries", series: mark.seriesId, mark: "pie-label-tick" },
+    style: outside ? { stroke: { kind: "solid", color }, strokeWidth: 1.5 } : { stroke: { kind: "none" } }
+  };
+}
+function createPieLabel(context, base, mark) {
+  const config = context.chart.config;
+  const geometry = { ...base, centerX: base.centerX + mark.shift.dx, centerY: base.centerY + mark.shift.dy };
+  const mid = (mark.start + mark.end) / 2;
+  const fontSize = Math.max(9, finite(context.chart.fontSize, 12));
+  const percent = Math.round(mark.share * 100);
+  const lineHeight = fontSize * 1.2;
+  const tickStart = pieArcPoint(geometry, mid, geometry.outerRadius + LEADER_INSET);
+  const ringThickness = geometry.outerRadius - geometry.innerRadius;
+  const tooThin = ringThickness < lineHeight * 2 + 6;
+  const hasManualOffset = mark.labelOffsetX !== 0 || mark.labelOffsetY !== 0;
+  const position = config?.pieLabelPosition ?? "auto";
+  const outside = hasManualOffset || position === "outside" || position === "auto" && tooThin;
+  if (outside) {
+    const point2 = hasManualOffset ? addOffset(pieArcPoint(geometry, mid, geometry.outerRadius), mark.labelOffsetX, mark.labelOffsetY) : pieArcPoint(
+      geometry,
+      mid,
+      geometry.outerRadius + OUTSIDE_GAP + (position === "outside" ? Math.abs(Math.cos(mid)) * (config?.pieLabelContent === "inline" ? LABEL_WIDTH * 0.95 : LABEL_WIDTH / 2) : 0)
+    );
+    const tickEnd = clipSegmentToRect(tickStart, point2, LABEL_WIDTH / 2, lineHeight);
+    const color2 = config?.pieLabelColor ?? sameHueTint(representativeColor(mark.color, OUTSIDE_FALLBACK_COLOR), OUTSIDE_TINT_LIGHTNESS) ?? OUTSIDE_FALLBACK_COLOR;
+    const tick2 = createTick(context, mark, tickStart, tickEnd, color2, true);
+    return [tick2, ...labelTextPair(context, mark, point2, color2, fontSize, percent, true, mid)];
+  }
+  const labelRadius = geometry.innerRadius + ringThickness * LABEL_RADIUS_FRACTION;
+  const point = pieArcPoint(geometry, mid, labelRadius);
+  const sliceColor = representativeColor(mark.color, "#0f172a");
+  const color = config?.pieLabelColor ?? sameHueContrastColor(sliceColor, contrastTextColor(sliceColor));
+  const tick = createTick(context, mark, tickStart, tickStart, color, false);
+  return [tick, ...labelTextPair(context, mark, point, color, fontSize, percent, false, mid)];
+}
+function addOffset(point, dx, dy) {
+  return { x: point.x + dx, y: point.y + dy };
+}
+
+// src/renderScene/artifacts/link/geometry/label/pathMetrics.ts
+var lerpPoint = (a, b, t) => ({
+  x: a.x + (b.x - a.x) * t,
+  y: a.y + (b.y - a.y) * t
+});
+function cubicBezierPoint(p0, p1, p2, p3, t) {
+  const mt = 1 - t;
+  return {
+    x: mt * mt * mt * p0.x + 3 * mt * mt * t * p1.x + 3 * mt * t * t * p2.x + t * t * t * p3.x,
+    y: mt * mt * mt * p0.y + 3 * mt * mt * t * p1.y + 3 * mt * t * t * p2.y + t * t * t * p3.y
+  };
+}
+function splitCubicBezier(p0, p1, p2, p3, t) {
+  const a = lerpPoint(p0, p1, t);
+  const b = lerpPoint(p1, p2, t);
+  const c = lerpPoint(p2, p3, t);
+  const d = lerpPoint(a, b, t);
+  const e = lerpPoint(b, c, t);
+  const f = lerpPoint(d, e, t);
+  return { left: [p0, a, d, f], right: [f, e, c, p3] };
+}
+function pointAtArcLength(points, targetLength) {
+  const lastIndex = points.length - 2;
+  if (targetLength <= 0) {
+    return { point: { x: points[0], y: points[1] }, segmentIndex: 0 };
+  }
+  let accumulated = 0;
+  for (let index = 0; index < lastIndex; index += 2) {
+    const start = { x: points[index], y: points[index + 1] };
+    const end = { x: points[index + 2], y: points[index + 3] };
+    const length = Math.hypot(end.x - start.x, end.y - start.y);
+    if (accumulated + length >= targetLength) {
+      const ratio = length === 0 ? 0 : (targetLength - accumulated) / length;
+      return { point: lerpPoint(start, end, ratio), segmentIndex: index };
+    }
+    accumulated += length;
+  }
+  return { point: { x: points[lastIndex], y: points[lastIndex + 1] }, segmentIndex: lastIndex };
+}
+function polylineLength(points) {
+  let total = 0;
+  for (let index = 0; index < points.length - 2; index += 2) {
+    total += Math.hypot(points[index + 2] - points[index], points[index + 3] - points[index + 1]);
+  }
+  return total;
+}
+function bezierArcLength(p0, p1, p2, p3, samples = 40) {
+  let total = 0;
+  let previous = p0;
+  for (let index = 1; index <= samples; index++) {
+    const point = cubicBezierPoint(p0, p1, p2, p3, index / samples);
+    total += Math.hypot(point.x - previous.x, point.y - previous.y);
+    previous = point;
+  }
+  return total;
+}
+
+// src/renderScene/artifacts/link/geometry/label/curvedGap.ts
+var SAMPLES = 40;
+function sampledArcLengths(points) {
+  const lengths = [0];
+  let previous = points[0];
+  for (let index = 1; index <= SAMPLES; index++) {
+    const point = cubicBezierPoint(...points, index / SAMPLES);
+    lengths.push(lengths[index - 1] + Math.hypot(point.x - previous.x, point.y - previous.y));
+    previous = point;
+  }
+  return lengths;
+}
+function parameterAtLength(lengths, target) {
+  const total = lengths[SAMPLES];
+  if (target <= 0) {
+    return 0;
+  }
+  if (target >= total) {
+    return 1;
+  }
+  for (let index = 1; index <= SAMPLES; index++) {
+    if (lengths[index] >= target) {
+      const fraction = (target - lengths[index - 1]) / (lengths[index] - lengths[index - 1] || 1);
+      return (index - 1 + fraction) / SAMPLES;
+    }
+  }
+  return 1;
+}
+function projectedGapHalfLength(points, clearance, maximum) {
+  const [p0, p1, p2, p3] = points;
+  const dx = 0.75 * (p1.x - p0.x) + 1.5 * (p2.x - p1.x) + 0.75 * (p3.x - p2.x);
+  const dy = 0.75 * (p1.y - p0.y) + 1.5 * (p2.y - p1.y) + 0.75 * (p3.y - p2.y);
+  const length = Math.hypot(dx, dy);
+  const ux = length === 0 ? 1 : Math.abs(dx) / length;
+  const uy = length === 0 ? 0 : Math.abs(dy) / length;
+  return Math.min(clearance.halfWidth * ux + clearance.halfHeight * uy, maximum);
+}
+function splitCurvedPath(flatPoints, clearance) {
+  if (flatPoints.length < 8) {
+    return null;
+  }
+  const points = curvedControlPoints(flatPoints);
+  const lengths = sampledArcLengths(points);
+  const total = lengths[SAMPLES];
+  if (total === 0) {
+    return null;
+  }
+  const half = total / 2;
+  const maximumGap = Math.max(0, half - clearance.minimumVisibleStub);
+  const gapHalfLength = projectedGapHalfLength(points, clearance, maximumGap);
+  const beforeParameter = parameterAtLength(lengths, half - gapHalfLength);
+  const afterParameter = parameterAtLength(lengths, half + gapHalfLength);
+  return {
+    before: curvedPathBeforeGap(points, beforeParameter),
+    after: curvedPathAfterGap(points, afterParameter),
+    bezier: true
+  };
+}
+function curvedControlPoints(flatPoints) {
+  return [
+    { x: flatPoints[0], y: flatPoints[1] },
+    { x: flatPoints[2], y: flatPoints[3] },
+    { x: flatPoints[4], y: flatPoints[5] },
+    { x: flatPoints[6], y: flatPoints[7] }
+  ];
+}
+function curvedPathBeforeGap(points, parameter) {
+  if (parameter <= 0.01) {
+    return null;
+  }
+  return splitCubicBezier(...points, parameter).left.flatMap((point) => [point.x, point.y]);
+}
+function curvedPathAfterGap(points, parameter) {
+  if (parameter >= 0.99) {
+    return null;
+  }
+  return splitCubicBezier(...points, parameter).right.flatMap((point) => [point.x, point.y]);
+}
+
+// src/renderScene/artifacts/link/geometry/label/polylineGap.ts
+function splitPolylinePath(points, clearance) {
+  if (points.length < 4) {
+    return null;
+  }
+  const total = polylineLength(points);
+  if (total === 0) {
+    return null;
+  }
+  const placement = polylineGapPlacement(points, total, clearance);
+  return {
+    before: polylineBeforeGap(points, placement.beforeLength),
+    after: polylineAfterGap(points, placement.afterLength, total),
+    bezier: false
+  };
+}
+function polylineGapPlacement(points, totalLength, clearance) {
+  const half = totalLength / 2;
+  const midpoint = pointAtArcLength(points, half);
+  const start = { x: points[midpoint.segmentIndex], y: points[midpoint.segmentIndex + 1] };
+  const end = { x: points[midpoint.segmentIndex + 2], y: points[midpoint.segmentIndex + 3] };
+  const gapHalfLength = projectedPolylineGap(start, end, clearance, half);
+  return { beforeLength: half - gapHalfLength, afterLength: half + gapHalfLength };
+}
+function projectedPolylineGap(start, end, clearance, halfLength) {
+  const segmentLength = Math.hypot(end.x - start.x, end.y - start.y);
+  const horizontalShare = segmentLength === 0 ? 1 : Math.abs(end.x - start.x) / segmentLength;
+  const verticalShare = segmentLength === 0 ? 0 : Math.abs(end.y - start.y) / segmentLength;
+  const projectedClearance = clearance.halfWidth * horizontalShare + clearance.halfHeight * verticalShare;
+  return Math.min(projectedClearance, Math.max(0, halfLength - clearance.minimumVisibleStub));
+}
+function polylineBeforeGap(points, splitLength) {
+  if (splitLength <= 0.5) {
+    return null;
+  }
+  const split = pointAtArcLength(points, splitLength);
+  return [...points.slice(0, split.segmentIndex + 2), split.point.x, split.point.y];
+}
+function polylineAfterGap(points, splitLength, totalLength) {
+  if (splitLength >= totalLength - 0.5) {
+    return null;
+  }
+  const split = pointAtArcLength(points, splitLength);
+  return [split.point.x, split.point.y, ...points.slice(split.segmentIndex + 2)];
+}
+
+// src/renderScene/artifacts/link/geometry/label/gap.ts
+var LABEL_GAP_PADDING = 3;
+var MIN_VISIBLE_STUB = 10;
+function bezierPoints(points) {
+  return [
+    { x: points[0], y: points[1] },
+    { x: points[2], y: points[3] },
+    { x: points[4], y: points[5] },
+    { x: points[6], y: points[7] }
+  ];
+}
+function pathLength(points, bezier) {
+  if (bezier) {
+    return bezierArcLength(...bezierPoints(points));
+  }
+  return polylineLength(points);
+}
+function splitPathAroundLabel(points, pathType, gapWidth, gapHeight) {
+  const clearance = {
+    halfWidth: (gapWidth + LABEL_GAP_PADDING) / 2,
+    halfHeight: (gapHeight + LABEL_GAP_PADDING) / 2,
+    minimumVisibleStub: MIN_VISIBLE_STUB
+  };
+  if (pathType === "curved") {
+    return splitCurvedPath(points, clearance);
+  }
+  return splitPolylinePath(points, clearance);
+}
+function labelGapDash(points, pathType, gapWidth, gapHeight) {
+  const split = splitPathAroundLabel(points, pathType, gapWidth, gapHeight);
+  if (!split || !split.before && !split.after) {
+    return null;
+  }
+  const totalLength = pathLength(points, split.bezier);
+  const dashBefore = split.before ? pathLength(split.before, split.bezier) : 0;
+  const afterLength = split.after ? pathLength(split.after, split.bezier) : 0;
+  const gapLength = Math.max(0, totalLength - dashBefore - afterLength);
+  if (gapLength <= 0) {
+    return null;
+  }
+  return { dashBefore, gapLength };
+}
+
+// src/renderScene/artifacts/link/geometry/markers/midpoint.ts
+function curvedMidpoint(points) {
+  const [x0, y0, x1, y1, x2, y2, x3, y3] = points;
+  const t = 0.5;
+  const mt = 1 - t;
+  return {
+    x: mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3,
+    y: mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3
+  };
+}
+function orthogonalMidpoint(points, fallback) {
+  let totalLength = 0;
+  const segments = [];
+  for (let index = 0; index < points.length - 2; index += 2) {
+    const start = { x: points[index], y: points[index + 1] };
+    const end = { x: points[index + 2], y: points[index + 3] };
+    const length = Math.sqrt((end.x - start.x) ** 2 + (end.y - start.y) ** 2);
+    totalLength += length;
+    segments.push({ start, end, length });
+  }
+  const halfLength = totalLength / 2;
+  let accumulatedLength = 0;
+  for (const segment of segments) {
+    if (accumulatedLength + segment.length >= halfLength) {
+      const ratio = (halfLength - accumulatedLength) / segment.length;
+      return {
+        x: segment.start.x + ratio * (segment.end.x - segment.start.x),
+        y: segment.start.y + ratio * (segment.end.y - segment.start.y)
+      };
+    }
+    accumulatedLength += segment.length;
+  }
+  return fallback;
+}
+function getLineMidpoint(points, pathType, effectiveFrom, effectiveTo) {
+  if (pathType === "curved") {
+    return curvedMidpoint(points);
+  }
+  const fallback = {
+    x: (effectiveFrom.x + effectiveTo.x) / 2,
+    y: (effectiveFrom.y + effectiveTo.y) / 2
+  };
+  if (pathType === "orthogonal") {
+    return orthogonalMidpoint(points, fallback);
+  }
+  return fallback;
+}
+
+// src/renderScene/artifacts/shape/geometry/cloud.ts
+var CLOUD_LOBES = [
+  [30, 64, 24],
+  [52, 40, 22],
+  [86, 32, 28],
+  [118, 42, 24],
+  [132, 64, 24]
+];
+var QUARTER_TURN = Math.PI / 2;
+var FULL_TURN = 4 * QUARTER_TURN;
+var BOTTOM_ANGLE = Math.PI / 2;
+var EPSILON = 1e-9;
+function pointOnLobe([centerX, centerY, radius], angle) {
+  return [centerX + radius * Math.cos(angle), centerY + radius * Math.sin(angle)];
+}
+function angleOnLobe([centerX, centerY], point) {
+  return Math.atan2(point[1] - centerY, point[0] - centerX);
+}
+function outerCusp(first, second, centroid) {
+  const dx = second[0] - first[0];
+  const dy = second[1] - first[1];
+  const distance2 = Math.hypot(dx, dy);
+  const along = (first[2] ** 2 - second[2] ** 2 + distance2 ** 2) / (2 * distance2);
+  const across = Math.sqrt(Math.max(0, first[2] ** 2 - along ** 2));
+  const footX = first[0] + along * dx / distance2;
+  const footY = first[1] + along * dy / distance2;
+  const candidates = [
+    [footX - across * dy / distance2, footY + across * dx / distance2],
+    [footX + across * dy / distance2, footY - across * dx / distance2]
+  ];
+  const fromCentroid = (point) => Math.hypot(point[0] - centroid[0], point[1] - centroid[1]);
+  return fromCentroid(candidates[0]) > fromCentroid(candidates[1]) ? candidates[0] : candidates[1];
+}
+function lobeArcs(lobes) {
+  const centroid = [
+    lobes.reduce((sum, lobe) => sum + lobe[0], 0) / lobes.length,
+    lobes.reduce((sum, lobe) => sum + lobe[1], 0) / lobes.length
+  ];
+  return lobes.map((lobe, index) => {
+    const from = index === 0 ? BOTTOM_ANGLE : angleOnLobe(lobe, outerCusp(lobes[index - 1], lobe, centroid));
+    const isLast = index === lobes.length - 1;
+    let to = isLast ? BOTTOM_ANGLE : angleOnLobe(lobe, outerCusp(lobe, lobes[index + 1], centroid));
+    while (to <= from) {
+      to += FULL_TURN;
+    }
+    return { lobe, from, to };
+  });
+}
+function quarterStops(from, to) {
+  const stops = [];
+  for (let turn = Math.floor(from / QUARTER_TURN) + 1; turn * QUARTER_TURN < to - EPSILON; turn++) {
+    stops.push(turn * QUARTER_TURN);
+  }
+  return [...stops, to];
+}
+function arcCurves({ lobe, from, to }) {
+  const start = pointOnLobe(lobe, from);
+  const curves = [];
+  let angle = from;
+  for (const stop of quarterStops(from, to)) {
+    const reach = 4 / 3 * Math.tan((stop - angle) / 4) * lobe[2];
+    const begin = pointOnLobe(lobe, angle);
+    const end = pointOnLobe(lobe, stop);
+    curves.push([
+      [begin[0] - reach * Math.sin(angle), begin[1] + reach * Math.cos(angle)],
+      [end[0] + reach * Math.sin(stop), end[1] - reach * Math.cos(stop)],
+      end
+    ]);
+    angle = stop;
+  }
+  return { start, curves };
+}
+function normalizedCloudOutline() {
+  const arcs = lobeArcs(CLOUD_LOBES).map(arcCurves);
+  const start = arcs[0].start;
+  const curves = arcs.flatMap((arc) => arc.curves);
+  const anchors = [start, ...curves.map((curve) => curve[2])];
+  const minX = Math.min(...anchors.map((point) => point[0]));
+  const maxX = Math.max(...anchors.map((point) => point[0]));
+  const minY = Math.min(...anchors.map((point) => point[1]));
+  const maxY = Math.max(...anchors.map((point) => point[1]));
+  const unit = (point) => [(point[0] - minX) / (maxX - minX), (point[1] - minY) / (maxY - minY)];
+  return {
+    start: unit(start),
+    curves: curves.map(([first, second, end]) => [unit(first), unit(second), unit(end)])
+  };
+}
+var CLOUD_OUTLINE = normalizedCloudOutline();
+function cloudPath(x, y, width, height) {
+  const at = ([u, v]) => `${x + u * width} ${y + v * height}`;
+  const curves = CLOUD_OUTLINE.curves.map(([first, second, end]) => `C ${at(first)} ${at(second)} ${at(end)}`);
+  return `M ${at(CLOUD_OUTLINE.start)} ${curves.join(" ")} Z`;
+}
+
+// src/renderScene/artifacts/shape/geometry/pathCalculation.ts
+var polygonPath = (points) => points.length < 4 ? "" : `M ${points[0]} ${points[1]} ${points.slice(2).reduce((s, n, i) => s + (i % 2 ? ` ${n}` : ` L ${n}`), "")} Z`;
+var DOCUMENT_WAVE_AMPLITUDE = 0.1;
+var QUARTER_SINE_SLOPE = Math.PI / 6;
+var NOTE_FOLD_RATIO = 0.25;
+var PREDEFINED_PROCESS_BAR_RATIO = 0.15;
+function pillCornerRadius(width, height) {
+  return Math.min(width, height) / 2;
+}
+function localShapePath(type, x, y, width, height) {
+  const p = (...coords) => polygonPath(coords);
+  switch (type) {
+    case "diamond":
+      return p(x + width / 2, y, x + width, y + height / 2, x + width / 2, y + height, x, y + height / 2);
+    case "triangle":
+      return p(x + width / 2, y, x, y + height, x + width, y + height);
+    case "parallelogram":
+      return p(x + width * 0.15, y, x + width, y, x + width * 0.85, y + height, x, y + height);
+    case "trapezoid":
+      return p(x + width * 0.2, y, x + width * 0.8, y, x + width, y + height, x, y + height);
+    case "hexagon": {
+      const cut = Math.min(width, height) / 4;
+      return p(
+        x + cut,
+        y,
+        x + width - cut,
+        y,
+        x + width,
+        y + height / 2,
+        x + width - cut,
+        y + height,
+        x + cut,
+        y + height,
+        x,
+        y + height / 2
+      );
+    }
+    case "document": {
+      const amplitude = height * DOCUMENT_WAVE_AMPLITUDE;
+      const mid = y + height - amplitude;
+      const quarter = width / 4;
+      const slope = amplitude * QUARTER_SINE_SLOPE;
+      return `M ${x} ${y} L ${x + width} ${y} L ${x + width} ${mid} C ${x + width - quarter / 3} ${mid - slope} ${x + width - quarter * 2 / 3} ${mid - amplitude} ${x + width - quarter} ${mid - amplitude} C ${x + width - quarter - quarter / 3} ${mid - amplitude} ${x + width / 2 + quarter / 3} ${mid - slope} ${x + width / 2} ${mid} C ${x + width / 2 - quarter / 3} ${mid + slope} ${x + width / 2 - quarter * 2 / 3} ${mid + amplitude} ${x + quarter} ${mid + amplitude} C ${x + quarter - quarter / 3} ${mid + amplitude} ${x + quarter / 3} ${mid + slope} ${x} ${mid} Z`;
+    }
+    case "note": {
+      const fold = Math.min(width, height) * NOTE_FOLD_RATIO;
+      return `M ${x} ${y} L ${x + width - fold} ${y} L ${x + width} ${y + fold} L ${x + width} ${y + height} L ${x} ${y + height} Z M ${x + width} ${y + fold} L ${x + width - fold} ${y + fold} L ${x + width - fold} ${y}`;
+    }
+    case "cloud":
+      return cloudPath(x, y, width, height);
+    case "cylinder":
+      return cylinderPath(x, y, width, height);
+    case "person":
+      return personPath(x, y, width, height);
+    case "predefined_process": {
+      const bar = Math.min(width, height) * PREDEFINED_PROCESS_BAR_RATIO;
+      return `M ${x} ${y} L ${x + width} ${y} L ${x + width} ${y + height} L ${x} ${y + height} Z M ${x + bar} ${y} L ${x + bar} ${y + height} M ${x + width - bar} ${y} L ${x + width - bar} ${y + height}`;
+    }
+    default:
+      return null;
+  }
+}
+
+export { AXIS_COS, AXIS_SIN, BAR_LABEL, CATEGORY_LABEL_ROW, CHART_COLORS, CHART_TITLE_PROP, CHART_TYPES, CORNER_RADIUS_ATTR, DEFAULT_FONT, DEFAULT_HEATMAP_ZONES, DEFAULT_HEX_RADIUS, DEFAULT_ZONE_FILL, DOM_CONTRACT_VERSION, EMPTY_BOUNDS, ISOMETRIC_LABEL_OFFSET_ATTR, ISOMETRIC_SIZE_ATTR, LABEL_WIDTH, LEADER_INSET, PATH_CLOSED_ATTR, PATH_POINTS_ATTR, PATH_POINT_INDEX_ATTR, PATH_TENSION_ATTR, SQUARE_CORNER_ATTR, SYMBOL_BOUNDS_ATTR, SYMBOL_POINTS_ATTR, SYMBOL_TENSION_ATTR, VISIBLE_ISOMETRIC_FACES, angleForAxisValue, axisBands, axisLabelProp, barCategoryCount, barLabelSize, barPath, barShapePath, bottomRoundedRectPath, boxBounds, calculateLinkRoute, canonicalizeSource, categoryProp, chartText, chartTicks, clipSegmentToRect, colorWithAlpha, computeBoxplotStats, contrastTextColor, cornersRoundedRectPath, createPieGeometry, createPieSlicePath, createVerticalErrorWhiskerNode, deriveFaceFills, edgePointToward, elementCenter, errorBarRange, estimateTextWidth, finite, formatBarLabel, formatFieldValue, freeformPathData, gapInsetAngle, getLineMidpoint, heuristicRichMeasure, horizontalRows, interpolateHexColorStops, isChartObject, isHorizontalBar, isIsometricObject, isLightColor, isPathObject, isSwimlaneObject, isometricBounds, isometricFaceCenter, isometricFaces, isometricTopFaceCenter, labelGapDash, leftRoundedRectPath, linePathData, localShapePath, mapChartValue, maxApexCornerRadius, maxPieCornerRadius, paint, parseSource, personLabelArea, pieApexRadius, pieArcPoint, pieUsesInnerArc, pillCornerRadius, pillPath, pointAtNormalizedPort, pointAtPort, radarCategoryCount, radarPointAt, radarRadius, radarRadiusForValue, radarSeriesPath, radarValueAtPoint, radarVertexPoint, relativeOffsetOnRectangleSide, renderPieLabels, representativeColor, resolveChartShadow, resolvePieRadii, rightRoundedRectPath, rotatedBounds, roundedBarPath, roundedOrthogonalPathData, roundedPolygonPath, rowTop, ruleAtProp, ruleTextProp, sameHueContrastColor, sameHueTint, segmentedBarPath, seriesColorProp, seriesLabelOffsetXProp, seriesLabelOffsetYProp, seriesLabelProp, seriesValueColorProp, seriesValueProp, sflToCanvasState, stackRank, stackSequence, stackedSegment, tag, tokenizeSource, topRoundedRectPath, wrapText, zoneColorAtValue };
+//# sourceMappingURL=chunk-6JKNT2YC.js.map
+//# sourceMappingURL=chunk-6JKNT2YC.js.map