@graphty/graph-io 0.3.47 → 0.3.49

package/dist/chunks/styles-yed-UMFdNqze.js

@@ -0,0 +1,1213 @@
+import { t as toNeutral, a as toFilePositions } from "./convert-Ct2zelbQ.js";
+import { n as nodeOffsetsToPoints, b as bendsToPoints, f as flattenCubic, a as flattenQuadSpline, c as canonNodeOffsets, d as canonBends } from "./bends-BGXjv_U4.js";
+import { p as plainCell, c as canonNumber, a as canonEnum, n as noteAt, b as STYLE_ISSUE, d as canonColor, e as colorOpacity, M as MAX_STYLE_VALUE_LENGTH, f as canonText, g as canonSigned, h as StyleNotes } from "./block-iptrlMBb.js";
+import { J as JAVA_MONO, a as JAVA_SERIF, b as JAVA_SANS, j as javaFamily } from "./lexicon-Clf4QIyl.js";
+import { S as StyleApproximations } from "./approximations-Bzn3L-je.js";
+import { e as elementValues, t as takeFromBlock } from "./round-trip-Zm3_ivgq.js";
+function isTree(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function localOf(name) {
+  const colon = name.indexOf(":");
+  return colon < 0 ? name : name.slice(colon + 1);
+}
+function treeChildren(node, local) {
+  const out = [];
+  if (!isTree(node)) {
+    return out;
+  }
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_") || key === "#text" || localOf(key) !== local) {
+      continue;
+    }
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        out.push(item);
+      }
+    } else {
+      out.push(value);
+    }
+  }
+  return out;
+}
+function treeChild(node, local) {
+  if (!isTree(node)) {
+    return void 0;
+  }
+  for (const key of Object.keys(node)) {
+    if (!key.startsWith("@_") && key !== "#text" && localOf(key) === local) {
+      const value = node[key];
+      return Array.isArray(value) ? value[0] : value;
+    }
+  }
+  return void 0;
+}
+function treeAttr(node, name) {
+  if (!isTree(node) || !Object.hasOwn(node, `@_${name}`)) {
+    return void 0;
+  }
+  const value = node[`@_${name}`];
+  return typeof value === "string" ? value : void 0;
+}
+function treeText(node) {
+  if (typeof node === "string") {
+    return node;
+  }
+  if (isTree(node) && Object.hasOwn(node, "#text")) {
+    const text = node["#text"];
+    return typeof text === "string" ? text : null;
+  }
+  return null;
+}
+function treeColumns(table) {
+  const out = [];
+  for (const col of table) {
+    if (col.dtype === "json" && col.meta.origin?.namespace === "yfiles") {
+      out.push(col.meta.name);
+    }
+  }
+  return out;
+}
+function yfilesColumns(table) {
+  const out = [];
+  for (const col of table) {
+    if (col.meta.origin?.namespace === "yfiles") {
+      out.push(col.meta.name);
+    }
+  }
+  return out;
+}
+const NODE_REALIZERS = /* @__PURE__ */ new Set([
+  "ShapeNode",
+  "GenericNode",
+  "GroupNode",
+  "GenericGroupNode",
+  "SVGNode",
+  "ImageNode",
+  "TableNode",
+  "UMLClassNode",
+  "UMLNoteNode",
+  "ProxyAutoBoundsNode"
+]);
+const EDGE_REALIZERS = /* @__PURE__ */ new Set([
+  "PolyLineEdge",
+  "ArcEdge",
+  "BezierEdge",
+  "QuadCurveEdge",
+  "SplineEdge",
+  "GenericEdge"
+]);
+function realizerOf(tree, names) {
+  if (!isTree(tree)) {
+    return null;
+  }
+  for (const key of Object.keys(tree)) {
+    const type = localOf(key);
+    if (key.startsWith("@_") || !names.has(type)) {
+      continue;
+    }
+    const value = tree[key];
+    const r = Array.isArray(value) ? value[0] : value;
+    return type === "ProxyAutoBoundsNode" ? activeRealizer(r) : { type, r };
+  }
+  return null;
+}
+function activeRealizer(proxy) {
+  const realizers = treeChild(proxy, "Realizers");
+  const all = [];
+  if (isTree(realizers)) {
+    for (const k of Object.keys(realizers).filter((key) => !key.startsWith("@_") && key !== "#text")) {
+      for (const item of treeChildren(realizers, localOf(k))) {
+        all.push({ type: localOf(k), r: item });
+      }
+    }
+  }
+  const active = Number(treeAttr(realizers, "active") ?? "0");
+  return all[Number.isInteger(active) && active >= 0 && active < all.length ? active : 0] ?? null;
+}
+function arcPoints(cx, cy, rx, ry, from, to, steps = 12) {
+  return Array.from({ length: steps + 1 }, (_, i) => {
+    const t = from + (to - from) * i / steps;
+    return pointText(cx + rx * Math.cos(t), cy + ry * Math.sin(t));
+  });
+}
+function wavePoints(y0, amp, x0, x1) {
+  const steps = 16;
+  return Array.from({ length: steps + 1 }, (_, i) => {
+    const x = x0 + (x1 - x0) * i / steps;
+    return pointText(x, y0 + amp * Math.sin(Math.PI * x));
+  });
+}
+function pointText(x, y) {
+  const r = (v) => String(Math.round(v * 1e3) / 1e3 + 0);
+  return `${r(x)},${r(y)}`;
+}
+const HALF_PI = Math.PI / 2;
+const CLOUD = Array.from({ length: 72 }, (_, i) => {
+  const t = 2 * Math.PI * i / 72;
+  const r = 0.86 + 0.14 * Math.abs(Math.cos(4 * t));
+  return pointText(r * Math.cos(t), r * Math.sin(t));
+}).join(" ");
+const STADIUM = [
+  ...arcPoints(0.5, 0, 0.5, 1, -HALF_PI, HALF_PI),
+  ...arcPoints(-0.5, 0, 0.5, 1, HALF_PI, 3 * HALF_PI)
+].join(" ");
+const YED_CONFIGURATIONS = /* @__PURE__ */ new Map([
+  ["flowchart.process", { shape: "rectangle" }],
+  ["flowchart.predefinedprocess", { shape: "rectangle" }],
+  ["flowchart.internalstorage", { shape: "rectangle" }],
+  ["flowchart.decision", { shape: "diamond" }],
+  ["flowchart.terminator", { shape: "round-rectangle" }],
+  ["flowchart.start1", { shape: "ellipse" }],
+  ["flowchart.start2", { shape: "ellipse" }],
+  ["flowchart.onpagereference", { shape: "ellipse" }],
+  ["flowchart.sequentialdata", { shape: "ellipse" }],
+  ["flowchart.data", { shape: "parallelogram" }],
+  ["flowchart.preparation", { shape: "hexagon" }],
+  ["flowchart.database", { shape: "other:database" }],
+  ["flowchart.looplimit", { shape: "polygon", points: "-1,-1 1,-1 1,0.5 0.8,1 -0.8,1 -1,0.5" }],
+  ["flowchart.looplimitend", { shape: "polygon", points: "-1,1 -1,-0.5 -0.8,-1 0.8,-1 1,-0.5 1,1" }],
+  ["flowchart.manualinput", { shape: "polygon", points: "-1,-1 1,-1 1,1 -1,0.4" }],
+  ["flowchart.card", { shape: "polygon", points: "-1,-1 1,-1 1,1 -0.6,1 -1,0.6" }],
+  ["flowchart.manualoperation", { shape: "polygon", points: "-1,1 -0.7,-1 0.7,-1 1,1" }],
+  ["flowchart.offpagereference", { shape: "polygon", points: "-1,1 -1,0 0,-1 1,0 1,1" }],
+  ["flowchart.usermessage", { shape: "polygon", points: "-1,1 -1,-1 0.6,-1 1,0 0.6,1" }],
+  ["flowchart.networkmessage", { shape: "polygon", points: "-1,1 -0.6,0 -1,-1 1,-1 1,1" }],
+  ["flowchart.document", { shape: "polygon", points: ["-1,1", ...wavePoints(-0.75, 0.2, -1, 1), "1,1"].join(" ") }],
+  [
+    "flowchart.papertype",
+    {
+      shape: "polygon",
+      points: [...wavePoints(-0.8, 0.2, -1, 1), ...wavePoints(0.8, 0.2, 1, -1)].join(" ")
+    }
+  ],
+  [
+    "flowchart.delay",
+    { shape: "polygon", points: ["-1,-1", ...arcPoints(0, 0, 1, 1, -HALF_PI, HALF_PI), "-1,1"].join(" ") }
+  ],
+  [
+    "flowchart.display",
+    {
+      shape: "polygon",
+      points: ["-1,0", "-0.6,-1", ...arcPoints(0.6, 0, 0.4, 1, -HALF_PI, HALF_PI), "-0.6,1"].join(" ")
+    }
+  ],
+  [
+    "flowchart.storeddata",
+    {
+      shape: "polygon",
+      points: [
+        ...arcPoints(1, 0, -0.2, 1, -HALF_PI, HALF_PI),
+        ...arcPoints(-0.8, 0, 0.2, 1, HALF_PI, 3 * HALF_PI)
+      ].join(" ")
+    }
+  ],
+  [
+    "flowchart.directdata",
+    {
+      shape: "polygon",
+      points: [
+        ...arcPoints(0.8, 0, 0.2, 1, -HALF_PI, HALF_PI),
+        ...arcPoints(-0.8, 0, 0.2, 1, HALF_PI, 3 * HALF_PI)
+      ].join(" ")
+    }
+  ],
+  ["flowchart.cloud", { shape: "polygon", points: CLOUD }],
+  ["entityrelationship.relationship", { shape: "diamond" }],
+  ["entityrelationship.attribute", { shape: "ellipse" }],
+  ["bpmn.conversation", { shape: "hexagon" }],
+  ["sbgn.unspecifiedentity", { shape: "ellipse" }],
+  ["sbgn.simplechemical", { shape: "ellipse" }],
+  ["sbgn.emptyset", { shape: "ellipse" }],
+  ["sbgn.operator", { shape: "ellipse" }],
+  ["sbgn.macromolecule", { shape: "round-rectangle" }],
+  ["sbgn.phenotype", { shape: "hexagon" }],
+  ["sbgn.process", { shape: "rectangle" }],
+  ["sbgn.submap", { shape: "rectangle" }],
+  ["sbgn.unitofinformation", { shape: "rectangle" }],
+  ["sbgn.statevariable", { shape: "polygon", points: STADIUM }],
+  ["sbgn.tag", { shape: "polygon", points: "-1,1 -1,-1 0.6,-1 1,0 0.6,1" }]
+]);
+function configurationOutline(configuration) {
+  const key = configuration.slice(0, MAX_STYLE_VALUE_LENGTH).toLowerCase().replace(/^com\.yworks\./, "").replace(/\.withshadow$/, "");
+  return YED_CONFIGURATIONS.get(key) ?? null;
+}
+const GENERIC_SHAPES = [
+  // yEd's BPMN and entity-relationship palettes: a task is a rounded box, an event a circle, a
+  // gateway a diamond, an attribute an ellipse
+  ["bpmn.activity", "round-rectangle"],
+  ["bpmn.event", "ellipse"],
+  ["bpmn.gateway", "diamond"],
+  ["entityrelationship.attribute", "ellipse"],
+  ["ellipse", "ellipse"],
+  ["circle", "ellipse"],
+  ["oval", "ellipse"],
+  ["diamond", "diamond"],
+  ["decision", "diamond"],
+  ["hexagon", "hexagon"],
+  ["octagon", "octagon"],
+  ["triangle", "triangle"],
+  ["rect", "rectangle"],
+  ["process", "rectangle"],
+  ["box", "rectangle"]
+];
+const YED_POSITIONS = /* @__PURE__ */ new Map([
+  ["c", "center"],
+  ["t", "top"],
+  ["b", "bottom"],
+  ["l", "left"],
+  ["r", "right"],
+  ["tl", "top-left"],
+  ["tr", "top-right"],
+  ["bl", "bottom-left"],
+  ["br", "bottom-right"],
+  ["n", "top"],
+  ["s", "bottom"],
+  ["e", "right"],
+  ["w", "left"],
+  ["nw", "top-left"],
+  ["ne", "top-right"],
+  ["sw", "bottom-left"],
+  ["se", "bottom-right"]
+]);
+const FONT_STYLES = /* @__PURE__ */ new Map([
+  ["plain", ["normal", false]],
+  ["bold", ["bold", false]],
+  ["italic", ["normal", true]],
+  ["bolditalic", ["bold", true]]
+]);
+function readColor(raw, property, opacity, put, at) {
+  const c = canonColor(raw, "yed", at(property));
+  if (c === null) {
+    return;
+  }
+  put(property, c.color);
+  const alpha = colorOpacity(c, null, at(property), opacity !== null);
+  if (opacity !== null) {
+    put(opacity, alpha);
+  }
+}
+function readLabels(labels, node, put, at, geometry) {
+  let label = void 0;
+  let text = "";
+  let extra = 0;
+  for (const l of labels) {
+    const t = treeText(l)?.trim() ?? "";
+    if (t.length === 0 || treeAttr(l, "visible") === "false" || treeAttr(l, "hasText") === "false") {
+      continue;
+    }
+    if (label === void 0) {
+      label = l;
+      text = t;
+    } else {
+      extra++;
+    }
+  }
+  if (label === void 0) {
+    return;
+  }
+  if (extra > 0) {
+    noteAt(at("label"), STYLE_ISSUE.EXTRA_LABELS, `${String(extra + 1)} labels`);
+  }
+  put("label", canonText(text, at("label")));
+  readLabelLook(label, node, put, at, geometry);
+}
+function readLabelLook(label, node, put, at, geometry) {
+  readColor(treeAttr(label, "textColor"), "labelColor", null, put, at);
+  if (treeAttr(label, "hasBackgroundColor") !== "false") {
+    readColor(treeAttr(label, "backgroundColor"), "labelBackground", null, put, at);
+  }
+  if (treeAttr(label, "hasLineColor") !== "false" && treeAttr(label, "lineColor") !== void 0) {
+    readColor(treeAttr(label, "lineColor"), "labelBorderColor", null, put, at);
+    put("labelBorderWidth", 1);
+  }
+  put("labelSize", canonNumber(treeAttr(label, "fontSize"), at("labelSize")));
+  const font = canonText(treeAttr(label, "fontFamily"), at("labelFont"));
+  put("labelFont", font === null ? null : javaFamily(font));
+  const style = treeAttr(label, "fontStyle");
+  if (style !== void 0) {
+    const known = FONT_STYLES.get(style.trim().toLowerCase());
+    if (known === void 0) {
+      noteAt(at("labelWeight"), STYLE_ISSUE.UNKNOWN_VALUE, style.slice(0, MAX_STYLE_VALUE_LENGTH));
+    } else {
+      put("labelWeight", known[0]);
+      put("labelItalic", known[1]);
+    }
+  }
+  readRotation(label, put, at);
+  if (node) {
+    const position = nodeLabelPosition(label, geometry, at);
+    put("labelPosition", position);
+    readInsideInset(label, geometry, position, put);
+    readOutsideOffset(label, geometry, position, put);
+  }
+}
+function readRotation(label, put, at) {
+  const angle = canonSigned(treeAttr(label, "rotationAngle"), at("labelRotation"));
+  if (angle === null) {
+    return;
+  }
+  const turn = (angle % 360 + 360) % 360;
+  put("labelRotation", turn === 0 ? null : turn);
+}
+function readOutsideOffset(label, geometry, position, put) {
+  const model = treeAttr(label, "modelName");
+  const free = position === "center" && model !== void 0 && model !== "internal";
+  if (position === null || position.startsWith("inside-") || position === "center" && !free) {
+    return;
+  }
+  if (Number(treeAttr(label, "rotationAngle") ?? 0) % 360 !== 0) {
+    return;
+  }
+  const num = (o, k) => Number(treeAttr(o, k) ?? Number.NaN);
+  const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => num(label, k));
+  const [nw, nh] = [num(geometry, "width"), num(geometry, "height")];
+  if (![x, y, w, h, nw, nh].every(Number.isFinite)) {
+    return;
+  }
+  const signed = (value) => {
+    const r = Math.round(value * 1e3) / 1e3;
+    return r === 0 ? null : r;
+  };
+  const offset = (lo, size, extent, before, after) => {
+    if (before) {
+      return signed(lo + size);
+    }
+    return after ? signed(lo - extent) : signed(lo + size / 2 - extent / 2);
+  };
+  put("labelOffsetX", offset(x, w, nw, position.includes("left"), position.includes("right")));
+  put("labelOffsetY", offset(y, h, nh, position.includes("top"), position.includes("bottom")));
+}
+function readInsideInset(label, geometry, position, put) {
+  const sized = treeAttr(label, "autoSizePolicy")?.startsWith("node_") === true;
+  if (position?.startsWith("inside-") !== true || sized) {
+    return;
+  }
+  const num = (o, k) => Number(treeAttr(o, k) ?? Number.NaN);
+  const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => num(label, k));
+  const [nw, nh] = [num(geometry, "width"), num(geometry, "height")];
+  const inset = (value) => Number.isFinite(value) && value > 0 ? Math.round(value * 1e3) / 1e3 : null;
+  if (position.includes("left")) {
+    put("labelOffsetX", inset(x));
+  } else if (position.includes("right")) {
+    const gap = inset(nw - x - w);
+    put("labelOffsetX", gap === null ? null : -gap);
+  }
+  if (position.includes("top")) {
+    put("labelOffsetY", inset(y));
+  } else if (position.includes("bottom")) {
+    const gap = inset(nh - y - h);
+    put("labelOffsetY", gap === null ? null : -gap);
+  }
+}
+function nodeLabelPosition(label, geometry, at) {
+  const outside = boxPosition(label, geometry);
+  if (outside !== null && outside !== "center") {
+    return outside;
+  }
+  const position = treeAttr(label, "modelPosition");
+  const model = treeAttr(label, "modelName");
+  if (model === "internal") {
+    return insidePosition(label, position);
+  }
+  if (model === "custom") {
+    return customPosition(label, outside, at);
+  }
+  if (outside !== null || position === void 0) {
+    return outside;
+  }
+  const known = YED_POSITIONS.get(position.trim().toLowerCase());
+  if (known === void 0) {
+    noteAt(at("labelPosition"), STYLE_ISSUE.UNKNOWN_VALUE, position.slice(0, MAX_STYLE_VALUE_LENGTH));
+  }
+  return known ?? null;
+}
+function customPosition(label, outside, at) {
+  const smart = treeChild(treeChild(label, "ModelParameter"), "SmartNodeLabelModelParameter");
+  if (smart === void 0) {
+    noteAt(at("labelPosition"), STYLE_ISSUE.UNKNOWN_VALUE, "custom");
+    return outside;
+  }
+  return outside ?? smartPosition(smart);
+}
+function smartPosition(smart) {
+  const ratio = (name) => {
+    const n = Number(treeAttr(smart, name));
+    return Number.isFinite(n) ? n : 0;
+  };
+  const h = sideOf(ratio("nodeRatioX"), "left", "right");
+  const v = sideOf(ratio("nodeRatioY"), "top", "bottom");
+  if (v === "top" && h === "" && ratio("labelRatioY") <= 0) {
+    return "inside-top";
+  }
+  if (v === "" || h === "") {
+    return v + h || "center";
+  }
+  return `${v}-${h}`;
+}
+function sideOf(ratio, low, high) {
+  if (ratio < 0) {
+    return low;
+  }
+  return ratio > 0 ? high : "";
+}
+function boxPosition(label, geometry) {
+  const num = (o, k) => Number(treeAttr(o, k) ?? Number.NaN);
+  const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => num(label, k));
+  const [nw, nh] = [num(geometry, "width"), num(geometry, "height")];
+  if (![x, y, w, h, nw, nh].every(Number.isFinite)) {
+    return null;
+  }
+  const side = (lo, size, extent) => {
+    if (lo + size <= 0) {
+      return -1;
+    }
+    return lo >= extent ? 1 : 0;
+  };
+  return BOX_POSITIONS[side(y, h, nh) + 1][side(x, w, nw) + 1];
+}
+function insidePosition(label, position) {
+  const inside = INTERNAL_POSITIONS.get((position ?? "c").trim().toLowerCase()) ?? "center";
+  const align = treeAttr(label, "alignment");
+  const across = treeAttr(label, "autoSizePolicy") === "node_width" && (align === "left" || align === "right");
+  return across && (inside === "inside-top" || inside === "inside-bottom") ? `${inside}-${align}` : inside;
+}
+const INTERNAL_POSITIONS = /* @__PURE__ */ new Map([
+  ["c", "center"],
+  ["t", "inside-top"],
+  ["b", "inside-bottom"],
+  ["l", "inside-left"],
+  ["r", "inside-right"],
+  ["tl", "inside-top-left"],
+  ["tr", "inside-top-right"],
+  ["bl", "inside-bottom-left"],
+  ["br", "inside-bottom-right"]
+]);
+const BOX_POSITIONS = [
+  ["top-left", "top", "top-right"],
+  ["left", "center", "right"],
+  ["bottom-left", "bottom", "bottom-right"]
+];
+function realizerShape(real, at) {
+  const shape = treeChild(real.r, "Shape");
+  if (shape !== void 0) {
+    return canonEnum("shape", treeAttr(shape, "type"), "yed", at("shape"));
+  }
+  if (real.type === "ShapeNode" || real.type === "GroupNode" || real.type === "GenericGroupNode") {
+    return null;
+  }
+  if (real.type === "TableNode") {
+    return canonEnum("shape", "rectangle", "yed", at("shape"));
+  }
+  if (real.type === "GenericNode") {
+    const conf = treeAttr(real.r, "configuration") ?? "";
+    const known = configurationOutline(conf);
+    if (known !== null) {
+      return known.shape;
+    }
+    const lower = conf.slice(0, MAX_STYLE_VALUE_LENGTH).toLowerCase();
+    for (const [word, value] of GENERIC_SHAPES) {
+      if (lower.includes(word)) {
+        return value;
+      }
+    }
+    if (lower.length === 0) {
+      return null;
+    }
+    noteAt(at("shape"), STYLE_ISSUE.UNKNOWN_VALUE, lower);
+    return `other:${lower}`;
+  }
+  noteAt(at("shape"), STYLE_ISSUE.UNKNOWN_VALUE, real.type);
+  return `other:${real.type}`;
+}
+const YED_GRADIENT_ANGLE = 45;
+function readFill(real, put, at) {
+  const fill = treeChild(real.r, "Fill");
+  if (fill === void 0) {
+    return;
+  }
+  if (treeAttr(fill, "hasColor") === "false" || treeAttr(fill, "transparent") === "true") {
+    noteAt(at("fill"), STYLE_ISSUE.NO_FILL, "transparent");
+    put("fillOpacity", 0);
+    return;
+  }
+  readColor(treeAttr(fill, "color"), "fill", "fillOpacity", put, at);
+  const second = canonColor(treeAttr(fill, "color2"), "yed", at("fillGradient"));
+  if (second !== null) {
+    put("fillGradient", second.color);
+    put("fillGradientAngle", YED_GRADIENT_ANGLE);
+  }
+}
+function tableColor(real, name, at) {
+  const props = treeChildren(treeChild(real.r, "StyleProperties"), "Property");
+  const prop = props.find((p) => treeAttr(p, "name") === name);
+  return prop === void 0 ? null : canonColor(treeAttr(prop, "value"), "yed", at("stripeColors"))?.color ?? null;
+}
+function readTable(real, put, at) {
+  const table = treeChild(real.r, "Table");
+  const rows = treeChildren(treeChild(table, "Rows"), "Row");
+  const columns = treeChildren(treeChild(table, "Columns"), "Column");
+  const across = columns.length > 1 && rows.length <= 1;
+  const lanes = (across ? columns : rows).map((l) => Number(treeAttr(l, across ? "width" : "height")));
+  const insets = treeChild(table, "Insets");
+  const inset = (side) => Math.max(0, Number(treeAttr(insets, side) ?? 0) || 0);
+  const [head, tail] = across ? [inset("left"), inset("right")] : [inset("top"), inset("bottom")];
+  const sizes = [head, ...lanes, tail];
+  const total = sizes.reduce((a, b) => a + b, 0);
+  if (lanes.length === 0 || !sizes.every(Number.isFinite) || total <= 0) {
+    return;
+  }
+  const fill = canonColor(treeAttr(treeChild(real.r, "Fill"), "color"), "yed", at("stripeColors"))?.color ?? "#ffffff";
+  const main = tableColor(real, "yed.table.lane.color.main", at) ?? fill;
+  const alternating = tableColor(real, "yed.table.lane.color.alternating", at) ?? main;
+  const header = tableColor(real, "yed.table.header.color.main", at) ?? fill;
+  const bands = [[head, header], ...lanes.map((size, i) => [size, i % 2 === 0 ? main : alternating]), [tail, fill]].filter(([size]) => size > 0);
+  put("stripeColors", bands.map(([, color]) => color).join(" "));
+  put("stripeSizes", bands.map(([size]) => String(Number((size / total).toFixed(6)))).join(" "));
+  if (across) {
+    put("stripeDirection", "right");
+  }
+}
+function yedResources(snapshot) {
+  const out = /* @__PURE__ */ new Map();
+  for (const col of snapshot.graph) {
+    if (col.dtype !== "json" || col.meta.origin?.namespace !== "yfiles") {
+      continue;
+    }
+    addYedResources(plainCell(snapshot.graph.value(col.meta.name, 0)), out);
+  }
+  return out;
+}
+function addYedResources(root, out) {
+  for (const resources of treeChildren(root, "Resources")) {
+    for (const r of treeChildren(resources, "Resource")) {
+      const id = treeAttr(r, "id");
+      const url = id === void 0 || out.has(id) ? null : yedResourceUrl(r);
+      if (id !== void 0 && url !== null) {
+        out.set(id, url);
+      }
+    }
+  }
+}
+function yedResourceUrl(r) {
+  const text = treeText(r)?.trim() ?? "";
+  if (text === "") {
+    return null;
+  }
+  const type = treeAttr(r, "type") ?? "";
+  if (type.endsWith("BufferedImage")) {
+    return `data:image/png;base64,${text.replaceAll(/\s+/g, "")}`;
+  }
+  if (text.includes("<svg")) {
+    return `data:image/svg+xml;utf8,${encodeURIComponent(text)}`;
+  }
+  return null;
+}
+function readPicture(real, resources, put) {
+  const ref = real.type === "ImageNode" ? treeAttr(treeChild(real.r, "Image"), "refid") : treeAttr(treeChild(treeChild(real.r, "SVGModel"), "SVGContent"), "refid");
+  const src = ref === void 0 ? void 0 : resources.get(ref);
+  if (src === void 0) {
+    return;
+  }
+  put("image", src);
+  put("imageFit", "fill");
+  put("imageClip", "none");
+}
+function readNode(real, put, at, resources) {
+  const { r } = real;
+  readFill(real, put, at);
+  const border = treeChild(r, "BorderStyle");
+  if (border !== void 0) {
+    if (treeAttr(border, "hasColor") === "false") {
+      put("borderWidth", 0);
+    } else {
+      readColor(treeAttr(border, "color"), "borderColor", null, put, at);
+      put("borderWidth", canonNumber(treeAttr(border, "width"), at("borderWidth")));
+    }
+    put("borderStyle", canonEnum("borderStyle", treeAttr(border, "type"), "yed", at("borderStyle")));
+  }
+  const geometry = treeChild(r, "Geometry");
+  put("width", canonNumber(treeAttr(geometry, "width"), at("width")));
+  put("height", canonNumber(treeAttr(geometry, "height"), at("height")));
+  put("shape", realizerShape(real, at));
+  const points = real.type === "GenericNode" ? configurationOutline(treeAttr(r, "configuration") ?? "")?.points : void 0;
+  if (points !== void 0) {
+    put("shapePoints", points);
+  }
+  if (real.type === "TableNode") {
+    readTable(real, put, at);
+  }
+  if (resources !== void 0 && (real.type === "ImageNode" || real.type === "SVGNode")) {
+    readPicture(real, resources, put);
+  }
+  readLabels(treeChildren(r, "NodeLabel"), true, put, at, geometry);
+}
+function readEdge(real, put, at) {
+  const { r } = real;
+  const line = treeChild(r, "LineStyle");
+  if (line !== void 0) {
+    readColor(treeAttr(line, "color"), "color", "opacity", put, at);
+    put("width", canonNumber(treeAttr(line, "width"), at("width")));
+    put("lineStyle", canonEnum("lineStyle", treeAttr(line, "type"), "yed", at("lineStyle")));
+  }
+  const arrows = treeChild(r, "Arrows");
+  if (arrows !== void 0) {
+    put("sourceArrow", canonEnum("arrow", treeAttr(arrows, "source"), "yed", at("sourceArrow")));
+    put("targetArrow", canonEnum("arrow", treeAttr(arrows, "target"), "yed", at("targetArrow")));
+  }
+  put("curved", edgeCurved(real));
+  if (real.type === "ArcEdge") {
+    put("bendCurve", "arc");
+  }
+  readLabels(treeChildren(r, "EdgeLabel"), false, put, at);
+}
+function edgeCurved(real) {
+  if (real.type === "ArcEdge") {
+    return true;
+  }
+  const points = treeChildren(treeChild(real.r, "Path"), "Point").length;
+  if (real.type === "QuadCurveEdge") {
+    return false;
+  }
+  if (real.type === "BezierEdge") {
+    return points > 0 && (points + 1) % 3 !== 0;
+  }
+  const bent = points > 0;
+  if (real.type !== "PolyLineEdge" && real.type !== "GenericEdge") {
+    return bent;
+  }
+  const smoothed = treeAttr(treeChild(real.r, "BendStyle"), "smoothed");
+  return smoothed === void 0 ? null : smoothed === "true" && bent;
+}
+function readEdgeRoute(real, nodes, source, target, put) {
+  const path = treeChild(real.r, "Path");
+  const at = (k) => [nodes[4 * k], nodes[4 * k + 1]];
+  const size = (k) => [nodes[4 * k + 2], nodes[4 * k + 3]];
+  const offset = (key) => Number(treeAttr(path, key) ?? 0) || 0;
+  const ends = [
+    [at(source)[0] + offset("sx"), at(source)[1] + offset("sy")],
+    [at(target)[0] + offset("tx"), at(target)[1] + offset("ty")]
+  ];
+  const port = (k, end) => end[0] === at(k)[0] && end[1] === at(k)[1] ? null : canonNodeOffsets(at(k), size(k), [end], true);
+  put("sourcePort", port(source, ends[0]));
+  put("targetPort", port(target, ends[1]));
+  let points = treeChildren(path, "Point").map((p) => [
+    Number(treeAttr(p, "x")),
+    Number(treeAttr(p, "y"))
+  ]);
+  if (points.length > 0 && (real.type === "BezierEdge" || real.type === "QuadCurveEdge")) {
+    const controls = [ends[0], ...points, ends[1]];
+    const curve = real.type === "BezierEdge" ? flattenCubic(controls) : flattenQuadSpline(controls, Number(treeAttr(real.r, "straightness") ?? YED_STRAIGHTNESS));
+    points = (curve ?? controls).slice(1, -1);
+  }
+  put(
+    "bends",
+    source === target ? canonNodeOffsets(at(source), size(source), points, true) : canonBends(at(source), at(target), points, true)
+  );
+}
+const YED_STRAIGHTNESS = 0.1;
+function valueColumns(n) {
+  const values = /* @__PURE__ */ Object.create(null);
+  return {
+    values,
+    put(i, property, value) {
+      if (value !== null) {
+        values[property] ??= new Array(n).fill(null);
+        values[property][i] = value;
+      }
+    }
+  };
+}
+function readYedStyles(snapshot, notes, budget) {
+  let found = false;
+  const resources = yedResources(snapshot);
+  const boxes = new Float64Array(4 * snapshot.nodeCount).fill(Number.NaN);
+  const read = (target) => {
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const names = target === "node" ? NODE_REALIZERS : EDGE_REALIZERS;
+    const columns = treeColumns(table);
+    const out = valueColumns(n);
+    if (columns.length === 0) {
+      return out.values;
+    }
+    for (let i = 0; i < n; i++) {
+      budget.spend(target, columns.length);
+      let real = null;
+      for (let c = 0; c < columns.length && real === null; c++) {
+        real = realizerOf(plainCell(table.value(columns[c], i)), names);
+      }
+      if (real === null) {
+        continue;
+      }
+      found = true;
+      const at = (property) => ({ notes, target, property, element: i, budget });
+      const put = (property, value) => {
+        out.put(i, property, value);
+      };
+      if (target === "node") {
+        readNode(real, put, at, resources);
+        const geometry = treeChild(real.r, "Geometry");
+        const [w, h] = [Number(treeAttr(geometry, "width")), Number(treeAttr(geometry, "height"))];
+        boxes.set(
+          [Number(treeAttr(geometry, "x")) + w / 2, Number(treeAttr(geometry, "y")) + h / 2, w, h],
+          4 * i
+        );
+      } else {
+        readEdge(real, put, at);
+        readEdgeRoute(real, boxes, snapshot.edgeSource(i), snapshot.edgeTarget(i), put);
+      }
+    }
+    return out.values;
+  };
+  const node = read("node");
+  const edge = read("edge");
+  return found ? { node, edge } : null;
+}
+const GRAPHML_STYLE_CAPABILITIES = Object.freeze({
+  tool: "yed",
+  node: Object.freeze([
+    "fill",
+    "fillOpacity",
+    "fillGradient",
+    "fillGradientAngle",
+    "borderColor",
+    "borderWidth",
+    "borderStyle",
+    "shape",
+    "width",
+    "height",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic",
+    "labelPosition"
+  ]),
+  edge: Object.freeze([
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "sourceArrow",
+    "targetArrow",
+    "curved",
+    "bends",
+    "sourcePort",
+    "targetPort",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic"
+  ]),
+  block: "attributes"
+});
+const YED_SHAPES = /* @__PURE__ */ new Map([
+  ["ellipse", "ellipse"],
+  ["rectangle", "rectangle"],
+  ["round-rectangle", "roundrectangle"],
+  ["triangle", "triangle"],
+  ["diamond", "diamond"],
+  ["hexagon", "hexagon"],
+  ["octagon", "octagon"],
+  ["parallelogram", "parallelogram"],
+  ["trapezoid", "trapezoid"],
+  ["star", "star5"]
+]);
+const YED_LINES = /* @__PURE__ */ new Map([
+  ["solid", "line"],
+  ["dashed", "dashed"],
+  ["dotted", "dotted"],
+  ["dash-dot", "dashed_dotted"]
+]);
+const YED_ARROWS = /* @__PURE__ */ new Map([
+  ["none", "none"],
+  ["triangle", "standard"],
+  ["triangle-open", "white_delta"],
+  ["vee", "concave"],
+  ["tee", "t_shape"],
+  ["diamond", "diamond"],
+  ["diamond-open", "white_diamond"],
+  ["circle", "circle"],
+  ["circle-open", "white_circle"],
+  ["square", "skewed_dash"],
+  ["crow", "crows_foot_many"]
+]);
+const INTERNAL_MODEL_POSITIONS = new Map(
+  [...INTERNAL_POSITIONS].map(([model, position]) => [position, model])
+);
+const YED_MODEL_POSITIONS = /* @__PURE__ */ new Map([
+  ["top", "n"],
+  ["bottom", "s"],
+  ["left", "w"],
+  ["right", "e"],
+  ["top-left", "nw"],
+  ["top-right", "ne"],
+  ["bottom-left", "sw"],
+  ["bottom-right", "se"]
+]);
+function yedValue(table, value, nearest) {
+  const exact = table.get(value);
+  if (exact !== void 0) {
+    return { value: exact, exact: true };
+  }
+  return value.startsWith("other:") ? { value: value.slice(6), exact: true } : { value: nearest, exact: false };
+}
+function yedColor(color, opacity) {
+  const hex = color.toUpperCase();
+  if (typeof opacity !== "number" || opacity >= 1) {
+    return hex;
+  }
+  return hex + Math.round(Math.max(0, opacity) * 255).toString(16).toUpperCase().padStart(2, "0");
+}
+function yedSpelled(table, value, nearest, property, approximate) {
+  const w = yedValue(table, value, nearest);
+  if (!w.exact) {
+    approximate(property, value);
+  }
+  return w.value;
+}
+const JAVA_LOGICAL = {
+  [JAVA_SANS]: "Dialog",
+  [JAVA_SERIF]: "Serif",
+  [JAVA_MONO]: "Monospaced"
+};
+function yedFontName(family) {
+  return Object.hasOwn(JAVA_LOGICAL, family) ? JAVA_LOGICAL[family] : family.split(",")[0].trim();
+}
+function labelFontTree(get) {
+  const label = {};
+  const font = get("labelFont");
+  if (typeof font === "string") {
+    label["@_fontFamily"] = yedFontName(font);
+  }
+  const size = get("labelSize");
+  if (typeof size === "number") {
+    label["@_fontSize"] = String(size);
+  }
+  const weight = get("labelWeight");
+  const italic = get("labelItalic");
+  if (weight !== null || italic !== null) {
+    const style = (weight === "bold" ? "bold" : "") + (italic === true ? "italic" : "");
+    label["@_fontStyle"] = style.length === 0 ? "plain" : style;
+  }
+  return label;
+}
+function labelTree(get, node, approximate) {
+  const text = get("label");
+  if (typeof text !== "string" || text.trim().length === 0) {
+    return null;
+  }
+  const label = labelFontTree(get);
+  const color = get("labelColor");
+  if (typeof color === "string") {
+    label["@_textColor"] = color.toUpperCase();
+  }
+  const position = node ? get("labelPosition") : null;
+  if (typeof position === "string") {
+    const inside = INTERNAL_MODEL_POSITIONS.get(position);
+    const outside = YED_MODEL_POSITIONS.get(position);
+    if (inside === void 0 && outside === void 0) {
+      approximate("labelPosition", position);
+    }
+    label["@_modelName"] = outside === void 0 ? "internal" : "eight_pos";
+    label["@_modelPosition"] = outside ?? inside ?? "c";
+  }
+  label["#text"] = text;
+  return label;
+}
+function shapeNodeTree(get, at, approximate) {
+  const node = {};
+  node["y:Geometry"] = geometryTree(get, at);
+  const fill = get("fill");
+  const fillOpacity = get("fillOpacity");
+  if (typeof fill === "string") {
+    node["y:Fill"] = { "@_color": yedColor(fill, fillOpacity), "@_transparent": "false" };
+    const second = get("fillGradient");
+    if (typeof second === "string") {
+      node["y:Fill"]["@_color2"] = second.toUpperCase();
+      const angle = get("fillGradientAngle");
+      if (angle !== YED_GRADIENT_ANGLE) {
+        approximate("fillGradientAngle", angle ?? 0);
+      }
+    }
+  } else if (fillOpacity === 0) {
+    node["y:Fill"] = { "@_hasColor": "false", "@_transparent": "false" };
+  }
+  const border = lineTree(get, ["borderColor", "borderWidth", "borderStyle"], approximate);
+  if (border !== null) {
+    node["y:BorderStyle"] = border;
+  }
+  const label = labelTree(get, true, approximate);
+  if (label !== null) {
+    node["y:NodeLabel"] = label;
+  }
+  const shape = get("shape");
+  if (typeof shape === "string") {
+    node["y:Shape"] = {
+      "@_type": yedSpelled(YED_SHAPES, shape, shape === "vee" ? "triangle" : "rectangle", "shape", approximate)
+    };
+  }
+  return { "y:ShapeNode": node };
+}
+function geometryTree(get, at) {
+  const geometry = {};
+  const height = get("height");
+  const width = get("width");
+  if (typeof height === "number") {
+    geometry["@_height"] = String(height);
+  }
+  if (typeof width === "number") {
+    geometry["@_width"] = String(width);
+  }
+  if (at !== null) {
+    geometry["@_x"] = at[0];
+    geometry["@_y"] = at[1];
+  }
+  return geometry;
+}
+function lineTree(get, properties, approximate, opacity) {
+  const [colorKey, widthKey, styleKey] = properties;
+  const color = get(colorKey);
+  const width = get(widthKey);
+  const style = get(styleKey);
+  if (color === null && width === null && style === null) {
+    return null;
+  }
+  const line = {};
+  if (typeof color === "string") {
+    line["@_color"] = opacity === void 0 ? color.toUpperCase() : yedColor(color, opacity);
+  }
+  if (typeof style === "string") {
+    const nearest = styleKey === "lineStyle" && style === "long-dash" ? "dashed" : "line";
+    line["@_type"] = yedSpelled(YED_LINES, style, nearest, styleKey, approximate);
+  }
+  if (typeof width === "number") {
+    line["@_width"] = String(width);
+  }
+  return line;
+}
+function polyLineEdgeTree(get, path, approximate) {
+  const edge = {};
+  if (path !== void 0) {
+    edge["y:Path"] = path;
+  }
+  const line = lineTree(get, ["color", "width", "lineStyle"], approximate, get("opacity"));
+  if (line !== null) {
+    edge["y:LineStyle"] = line;
+  }
+  const source = get("sourceArrow");
+  const target = get("targetArrow");
+  if (source !== null || target !== null) {
+    const arrow = (property, value) => typeof value === "string" ? yedSpelled(YED_ARROWS, value, "standard", property, approximate) : "none";
+    edge["y:Arrows"] = { "@_source": arrow("sourceArrow", source), "@_target": arrow("targetArrow", target) };
+  }
+  const label = labelTree(get, false, approximate);
+  if (label !== null) {
+    edge["y:EdgeLabel"] = label;
+  }
+  const curved = get("curved");
+  if (typeof curved === "boolean") {
+    edge["y:BendStyle"] = { "@_smoothed": String(curved) };
+  }
+  return { "y:PolyLineEdge": edge };
+}
+function exactFromBlock(snapshot, text, read) {
+  const notes = new StyleNotes();
+  takeFromBlock(snapshot, text, "graphml", (target) => ({
+    values: read[target],
+    properties: GRAPHML_STYLE_CAPABILITIES[target],
+    writes: GRAPHML_STYLE_CAPABILITIES[target],
+    readBack: (_i, want) => {
+      const back = writtenAndReadBack(target, want, notes);
+      return back === null ? null : (property) => back.get(property) ?? null;
+    }
+  }));
+}
+function writtenAndReadBack(target, want, notes) {
+  const ignore = () => void 0;
+  const tree = target === "node" ? shapeNodeTree(want, null, ignore) : polyLineEdgeTree(want, void 0, ignore);
+  const real = realizerOf(tree, target === "node" ? NODE_REALIZERS : EDGE_REALIZERS);
+  if (real === null) {
+    return null;
+  }
+  const back = /* @__PURE__ */ new Map();
+  const at = (property) => ({ notes, target, property });
+  const put = (property, value) => {
+    if (value !== null) {
+      back.set(property, value);
+    }
+  };
+  if (target === "node") {
+    readNode(real, put, at);
+  } else {
+    readEdge(real, put, at);
+  }
+  return back;
+}
+const GRAPHICS_TYPES = { node: "nodegraphics", edge: "edgegraphics" };
+function keptPosition(table, columns, i) {
+  for (const name of columns) {
+    const tree = plainCell(table.value(name, i));
+    const real = realizerOf(tree, NODE_REALIZERS);
+    const geometry = real === null ? treeChild(tree, "RectD") : treeChild(real.r, "Geometry");
+    const x = treeAttr(geometry, real === null ? "X" : "x");
+    const y = treeAttr(geometry, real === null ? "Y" : "y");
+    if (x !== void 0 && y !== void 0) {
+      return [x, y];
+    }
+  }
+  return null;
+}
+function columnPosition(snapshot, i, get) {
+  const column = snapshot.nodes.byRole("position");
+  if (column === null || column.meta.components < 2 || !column.isSet(i)) {
+    return null;
+  }
+  const v = column.value(i);
+  const width = get("width");
+  const height = get("height");
+  const size = [typeof width === "number" ? width : 0, typeof height === "number" ? height : 0];
+  const p = [v[0], v[1], 0];
+  toNeutral(p, column.meta.extra ?? {}, size, false);
+  const [x, y] = toFilePositions(Float64Array.from(p), YED_SPELLING, {
+    width: Float64Array.of(size[0]),
+    height: Float64Array.of(size[1])
+  });
+  return Number.isFinite(x) && Number.isFinite(y) ? [String(x), String(y)] : null;
+}
+const YED_SPELLING = { yAxis: "down", anchor: "top-left" };
+function keptPath(table, columns, e) {
+  for (const name of columns) {
+    const real = realizerOf(plainCell(table.value(name, e)), EDGE_REALIZERS);
+    const path = real === null ? void 0 : treeChild(real.r, "Path");
+    if (path !== void 0) {
+      return path;
+    }
+  }
+  return void 0;
+}
+function pathWithRoute(kept, get, ends, loop) {
+  const bends = get("bends");
+  const [[c0, size0], [c1]] = ends;
+  let points = null;
+  if (typeof bends === "string") {
+    points = loop ? nodeOffsetsToPoints(c0, size0, bends) : bendsToPoints(c0, c1, bends);
+  }
+  const ports = ["sourcePort", "targetPort"].map((property, k) => {
+    const value = get(property);
+    const [center, size] = ends[k];
+    const at = typeof value === "string" ? nodeOffsetsToPoints(center, size, value) : null;
+    return at === null ? null : [at[0][0] - center[0], at[0][1] - center[1]];
+  });
+  if (points === null && ports.every((p) => p === null)) {
+    return kept;
+  }
+  const path = {};
+  ["sx", "sy", "tx", "ty"].forEach((key, k) => {
+    const port = ports[k >> 1];
+    path[`@_${key}`] = port === null ? treeAttr(kept, key) ?? "0.0" : String(port[k & 1]);
+  });
+  const written = points ?? treeChildren(kept, "Point").map((q) => [Number(treeAttr(q, "x")), Number(treeAttr(q, "y"))]);
+  path["y:Point"] = written.map(([x, y]) => ({ "@_x": String(x), "@_y": String(y) }));
+  return path;
+}
+function freeName(table, base) {
+  let name = base;
+  let k = 2;
+  while (table.has(name)) {
+    name = `${base}#${String(k)}`;
+    k++;
+  }
+  return name;
+}
+function graphmlStyledExport(snapshot, input) {
+  if (input === void 0) {
+    return null;
+  }
+  const approximated = new StyleApproximations();
+  const approximateFor = (target) => (property, value) => {
+    approximated.add(target, property, value);
+  };
+  const picture = (target, property) => input.picture(target, property);
+  const nodeColumns = treeColumns(snapshot.nodes);
+  const edgeColumns = treeColumns(snapshot.edges);
+  const getNode = elementValues(picture, "node", GRAPHML_STYLE_CAPABILITIES.node);
+  const getEdge = elementValues(picture, "edge", GRAPHML_STYLE_CAPABILITIES.edge);
+  const nodeTrees = [];
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const get = getNode(i);
+    const at = keptPosition(snapshot.nodes, nodeColumns, i) ?? columnPosition(snapshot, i, get);
+    nodeTrees.push(shapeNodeTree(get, at, approximateFor("node")));
+  }
+  const boxes = nodeTrees.map((tree) => {
+    const geometry = treeChild(treeChild(tree, "ShapeNode"), "Geometry");
+    const at = (k) => Number(treeAttr(geometry, k) ?? Number.NaN);
+    return [
+      [at("x") + at("width") / 2, at("y") + at("height") / 2],
+      [at("width"), at("height")]
+    ];
+  });
+  const edgeTrees = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    const get = getEdge(e);
+    const [source, target] = [snapshot.edgeSource(e), snapshot.edgeTarget(e)];
+    const path = pathWithRoute(
+      keptPath(snapshot.edges, edgeColumns, e),
+      get,
+      [boxes[source], boxes[target]],
+      source === target
+    );
+    edgeTrees.push(polyLineEdgeTree(get, path, approximateFor("edge")));
+  }
+  const out = snapshot.withColumns();
+  for (const [table, trees, target] of [
+    [out.nodes, nodeTrees, "node"],
+    [out.edges, edgeTrees, "edge"]
+  ]) {
+    for (const name2 of yfilesColumns(table)) {
+      table.remove(name2);
+    }
+    const name = freeName(table, GRAPHICS_TYPES[target]);
+    table.set(name, trees, {
+      dtype: "json",
+      nullable: true,
+      origin: { format: "graphml", id: null, title: null, type: GRAPHICS_TYPES[target], namespace: "yfiles" }
+    });
+  }
+  const yfiles3 = [...out.graph].filter(
+    (col) => col.meta.origin?.namespace === "yfiles" && (col.meta.origin.type ?? "").includes("://")
+  );
+  for (const col of yfiles3) {
+    out.graph.remove(col.meta.name);
+  }
+  return { snapshot: out, notes: approximated.notes("yEd") };
+}
+export {
+  FONT_STYLES as F,
+  GRAPHML_STYLE_CAPABILITIES as G,
+  YED_SHAPES as Y,
+  yedColor as a,
+  yedSpelled as b,
+  yedFontName as c,
+  YED_LINES as d,
+  configurationOutline as e,
+  YED_ARROWS as f,
+  graphmlStyledExport as g,
+  treeAttr as h,
+  isTree as i,
+  treeChild as j,
+  treeText as k,
+  localOf as l,
+  yfilesColumns as m,
+  exactFromBlock as n,
+  readYedStyles as r,
+  treeChildren as t,
+  valueColumns as v,
+  yedValue as y
+};
+//# sourceMappingURL=styles-yed-UMFdNqze.js.map