@graphty/graph-io 0.3.43 → 0.3.44

package/dist/chunks/styles-_N-C8S-U.js

@@ -0,0 +1,2102 @@
+import { a as STYLE_ISSUE, j as StyleNotes, H as refSource, J as resolveRules, d as num6, U as degreeValues, v as STYLE_PROPERTIES, O as canonicalFor, w as toolDefaults, i as isStyleValue, L as evalContinuous, N as numberOf, V as discreteLookup, S as STYLE_BLOCK_NAME, m as plainCell, p as parseStyleBlock, k as styleFingerprint, l as blockStyles, r as resolveStyles } from "./block-JQiwViEt.js";
+import { e as escapeXmlAttribute } from "./escape-B1rMftd9.js";
+import { J as JAVA_FONTS, c as colorParser, N as NODE_SIZE_VP, s as sizeParser, C as CYTOSCAPE_LEXICON, i as isUncarriedVp, n as normalizeVisualProperties } from "./lexicon-B-knUi-l.js";
+import { M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, I as ID_MERGED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, h as MULTIPLE_GRAPHS_CODE, b as STRAY_TEXT_CODE, c as UNKNOWN_ELEMENT_CODE, U as UNKNOWN_ATTR_TYPE_CODE, ay as EQUATION_AS_TEXT_CODE, a6 as PARENT_CYCLE_CODE, l as UNKNOWN_PARENT_CODE, k as DUPLICATE_ATTRIBUTE_CODE, e as DANGLING_REFERENCE_CODE, P as PRECISION_CODE, a7 as WIDENED_CODE, Y as BAD_VALUE_CODE, i as DUPLICATE_EDGE_ID_CODE, j as DUPLICATE_NODE_CODE, m as MISSING_ENDPOINT_CODE, n as MISSING_ID_CODE, N as NO_GRAPH_CODE, q as ENCODING_CONFLICT_CODE, r as UNKNOWN_ENCODING_CODE, s as ENCODING_FALLBACK_CODE, t as INVALID_ENCODING_CODE, u as INVALID_UTF8_CODE, E as EMPTY_INPUT_CODE, X as XML_NESTING_CODE, v as XML_SYNTAX_CODE, x as ELEMENT_ISSUE, y as INPUT_ISSUE, aI as STORAGE_CLASS_CODE, aN as WEIGHT_KEY_CLASH_CODE, aa as ROLE_ASSUMED_CODE, at as COLUMN_RENAMED_LOSS_CODE, z as ID_TEXT_TYPE_CODE, aD as MUTUAL_EXPANDED_CODE, F as PARENTS_DROPPED_CODE, A as ROLE_DROPPED_CODE, aK as TEMPORAL_TEXT_DROPPED_CODE, aJ as TEMPORAL_DROPPED_CODE, ac as XML_ILLEGAL_CHAR_CODE } from "./format-GDmO6m6Q.js";
+function emptyCytoscapeStyle() {
+  const target = () => ({
+    defaults: /* @__PURE__ */ new Map(),
+    mappings: /* @__PURE__ */ new Map(),
+    dependencies: /* @__PURE__ */ new Map(),
+    bypassAliases: /* @__PURE__ */ new Map()
+  });
+  return { network: { defaults: /* @__PURE__ */ new Map() }, node: target(), edge: target() };
+}
+const NUMERIC_TYPES = /* @__PURE__ */ new Set(["integer", "long", "double", "float", "int", "short"]);
+const DECIMAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+function typedKey(raw, type) {
+  if (typeof raw === "number") {
+    return Number.isFinite(raw) ? raw : null;
+  }
+  if (typeof raw === "boolean") {
+    return raw;
+  }
+  if (typeof raw !== "string") {
+    return null;
+  }
+  const t = (type ?? "").toLowerCase().replace(/^list_of_/, "").replace(/^java\.lang\./, "");
+  if (NUMERIC_TYPES.has(t) && raw.length <= 64 && DECIMAL.test(raw.trim())) {
+    return Number(raw.trim());
+  }
+  if (t === "boolean") {
+    const b = raw.trim().toLowerCase();
+    if (b === "true" || b === "false") {
+      return b === "true";
+    }
+  }
+  return raw;
+}
+const INDEXED = /* @__PURE__ */ new Set(["K", "V", "L", "E", "G", "OV"]);
+function definitionTokens(def) {
+  const tokens = [];
+  let parts = [];
+  let start = 0;
+  let i = def.indexOf(",");
+  while (i >= 0) {
+    parts.push(def.slice(start, i));
+    if (def[i + 1] === ",") {
+      parts.push(",");
+      i++;
+    } else {
+      tokens.push(parts.join(""));
+      parts = [];
+    }
+    start = i + 1;
+    i = def.indexOf(",", start);
+  }
+  parts.push(def.slice(start));
+  tokens.push(parts.join(""));
+  return tokens;
+}
+function indexedEntry(t) {
+  const eq1 = t.indexOf("=");
+  const eq2 = eq1 < 0 ? -1 : t.indexOf("=", eq1 + 1);
+  const tag = t.slice(0, eq1);
+  if (eq2 < 0 || !INDEXED.has(tag)) {
+    return null;
+  }
+  const indexText = t.slice(eq1 + 1, eq2);
+  return /^\d{1,15}$/.test(indexText) ? { tag, index: Number(indexText), value: t.slice(eq2 + 1) } : null;
+}
+function parseCx1Definition(def, notes, target = null) {
+  const tokens = definitionTokens(def);
+  const entries = /* @__PURE__ */ new Map();
+  let column = null;
+  let type = null;
+  let beyond = 0;
+  for (const t of tokens) {
+    if (t.startsWith("COL=")) {
+      column = t.slice(4);
+      continue;
+    }
+    if (t.startsWith("T=")) {
+      type = t.slice(2);
+      continue;
+    }
+    const indexed = indexedEntry(t);
+    if (indexed === null) {
+      continue;
+    }
+    const { tag, index, value } = indexed;
+    if (index > tokens.length) {
+      beyond++;
+      continue;
+    }
+    let byIndex = entries.get(tag);
+    if (byIndex === void 0) {
+      byIndex = /* @__PURE__ */ new Map();
+      entries.set(tag, byIndex);
+    }
+    byIndex.set(index, value);
+  }
+  if (beyond > 0) {
+    notes?.add(STYLE_ISSUE.BAD_MAPPING, target, column ?? "definition", {
+      sample: `${beyond} entries with an index beyond the definition`,
+      count: beyond
+    });
+  }
+  return { column, type, entries };
+}
+function indexesOf(d, tag) {
+  return Array.from(d.entries.get(tag)?.keys() ?? []).sort((a, b) => a - b);
+}
+function finiteOf(v) {
+  if (typeof v === "number") {
+    return Number.isFinite(v) ? v : null;
+  }
+  if (typeof v === "string" && v.length <= 64 && DECIMAL.test(v.trim())) {
+    return Number(v.trim());
+  }
+  return null;
+}
+function mappingFromCx1(m, notes, target = null) {
+  if (m === null || typeof m !== "object" || typeof m.definition !== "string") {
+    return null;
+  }
+  const { type: kind, definition } = m;
+  const d = parseCx1Definition(definition, notes, target);
+  if (d.column === null) {
+    return null;
+  }
+  const at = (tag, i) => d.entries.get(tag)?.get(i);
+  switch (String(kind).toUpperCase()) {
+    case "PASSTHROUGH":
+      return { kind: "passthrough", column: d.column, type: d.type };
+    case "DISCRETE": {
+      const table = [];
+      for (const i of indexesOf(d, "K")) {
+        const key = typedKey(at("K", i), d.type);
+        const value = at("V", i);
+        if (key !== null && value !== void 0) {
+          table.push([key, value]);
+        }
+      }
+      return { kind: "discrete", column: d.column, type: d.type, table };
+    }
+    case "CONTINUOUS": {
+      const points = [];
+      for (const i of indexesOf(d, "OV")) {
+        const x = finiteOf(at("OV", i));
+        if (x !== null) {
+          points.push({ at: x, below: at("L", i), value: at("E", i), above: at("G", i) });
+        }
+      }
+      return { kind: "continuous", column: d.column, type: d.type, points };
+    }
+    default:
+      return null;
+  }
+}
+function own(o, k) {
+  return o !== null && typeof o === "object" && Object.hasOwn(o, k) ? o[k] : void 0;
+}
+function mappingFromCx2(m) {
+  const def = own(m, "definition");
+  const column = own(def, "attribute");
+  if (typeof column !== "string") {
+    return null;
+  }
+  const declared = own(def, "type");
+  const type = typeof declared === "string" ? declared : null;
+  const map = own(def, "map");
+  const entries = Array.isArray(map) ? map : [];
+  switch (String(own(m, "type")).toUpperCase()) {
+    case "PASSTHROUGH":
+      return { kind: "passthrough", column, type };
+    case "DISCRETE": {
+      const table = [];
+      for (const e of entries) {
+        const key = typedKey(own(e, "v"), type);
+        const value = own(e, "vp");
+        if (key !== null && value !== void 0) {
+          table.push([key, value]);
+        }
+      }
+      return { kind: "discrete", column, type, table };
+    }
+    case "CONTINUOUS":
+      return { kind: "continuous", column, type, points: cx2Points$1(entries) };
+    default:
+      return null;
+  }
+}
+function cx2Points$1(entries) {
+  const byAt = /* @__PURE__ */ new Map();
+  const point = (x) => {
+    let p = byAt.get(x);
+    if (p === void 0) {
+      p = { at: x };
+      byAt.set(x, p);
+    }
+    return p;
+  };
+  for (const iv of entries) {
+    if (iv !== null && typeof iv === "object") {
+      addInterval(iv, point);
+    }
+  }
+  return Array.from(byAt.values()).sort((a, b) => a.at - b.at).map((p) => {
+    const below = p.below ?? p.value ?? p.above;
+    const above = p.above ?? p.value ?? below;
+    return { at: p.at, below, value: p.value ?? below, above };
+  });
+}
+function addInterval(iv, point) {
+  const lo = finiteOf(own(iv, "min"));
+  const hi = finiteOf(own(iv, "max"));
+  const minValue = own(iv, "minVPValue") ?? own(iv, "maxVPValue");
+  const maxValue = own(iv, "maxVPValue") ?? own(iv, "minVPValue");
+  if (lo !== null) {
+    const p = point(lo);
+    p.above = minValue;
+    if (own(iv, "includeMin") !== false) {
+      p.value = minValue;
+    }
+  }
+  if (hi !== null) {
+    const p = point(hi);
+    p.below = maxValue;
+    if (own(iv, "includeMax") !== false && p.value === void 0) {
+      p.value = maxValue;
+    }
+  }
+}
+function record(x) {
+  return x !== null && typeof x === "object" && !Array.isArray(x) ? x : {};
+}
+function cytoscapeStyleFromCx(entries, notes) {
+  const style = emptyCytoscapeStyle();
+  const viewOf = (v) => own(v, "applies_to") ?? own(v, "view") ?? null;
+  const views = [];
+  for (const v of entries) {
+    if (/default|network/.test(String(own(v, "properties_of"))) && !views.includes(viewOf(v))) {
+      views.push(viewOf(v));
+    }
+  }
+  if (views.length > 1) {
+    notes?.add(STYLE_ISSUE.OTHER_VIEWS, null, "cyVisualProperties", {
+      sample: `${views.length - 1} more`,
+      count: views.length - 1
+    });
+  }
+  for (const v of entries) {
+    const target = v !== null && typeof v === "object" && viewOf(v) === views[0] ? CX_SECTIONS.get(String(own(v, "properties_of"))) : void 0;
+    if (target === void 0) {
+      continue;
+    }
+    const props = record(own(v, "properties"));
+    for (const k of Object.keys(props)) {
+      style[target].defaults.set(k, props[k]);
+    }
+    if (target !== "network") {
+      readCxMappings(style, target, v, notes);
+    }
+  }
+  return style;
+}
+const CX_SECTIONS = /* @__PURE__ */ new Map([
+  ["nodes:default", "node"],
+  ["edges:default", "edge"],
+  ["network", "network"]
+]);
+function readCxMappings(style, target, v, notes) {
+  const mappings = record(own(v, "mappings"));
+  for (const vp of Object.keys(mappings)) {
+    const m = mappingFromCx1(mappings[vp], notes, target);
+    if (m === null) {
+      notes?.add(STYLE_ISSUE.BAD_MAPPING, target, vp, { sample: mappings[vp] });
+    } else {
+      style[target].mappings.set(vp, m);
+    }
+  }
+  const deps = record(own(v, "dependencies"));
+  for (const d of Object.keys(deps)) {
+    style[target].dependencies.set(d, String(deps[d]).toLowerCase() === "true");
+  }
+}
+function cytoscapeStyleFromCx2(visualProperties, visualEditorProperties, notes) {
+  const style = emptyCytoscapeStyle();
+  const first = (x) => Array.isArray(x) ? x[0] : x;
+  const vp = record(first(visualProperties));
+  const editor = record(own(record(first(visualEditorProperties)), "properties"));
+  const defaults = record(own(vp, "default"));
+  for (const target of ["network", "node", "edge"]) {
+    const d = record(own(defaults, target));
+    for (const k of Object.keys(d)) {
+      style[target].defaults.set(k, d[k]);
+    }
+  }
+  style.node.dependencies.set("nodeSizeLocked", own(editor, "nodeSizeLocked") === true);
+  style.edge.dependencies.set("arrowColorMatchesEdge", own(editor, "arrowColorMatchesEdge") === true);
+  for (const [target, key] of [
+    ["node", "nodeMapping"],
+    ["edge", "edgeMapping"]
+  ]) {
+    const mappings = record(own(vp, key));
+    for (const name of Object.keys(mappings)) {
+      const m = mappingFromCx2(mappings[name]);
+      if (m === null) {
+        notes?.add(STYLE_ISSUE.BAD_MAPPING, target, name, { sample: mappings[name] });
+      } else {
+        style[target].mappings.set(name, m);
+      }
+    }
+  }
+  lockedSizeFromWidth(style.node);
+  return style;
+}
+function lockedSizeFromWidth(node) {
+  if (node.dependencies.get("nodeSizeLocked") !== true || node.defaults.has("NODE_SIZE") || node.mappings.has("NODE_SIZE")) {
+    return;
+  }
+  if (node.defaults.has("NODE_WIDTH")) {
+    node.defaults.set("NODE_SIZE", node.defaults.get("NODE_WIDTH"));
+  }
+  const width = node.mappings.get("NODE_WIDTH");
+  if (width !== void 0) {
+    node.mappings.set("NODE_SIZE", width);
+  }
+  node.bypassAliases.set("NODE_WIDTH", "NODE_SIZE");
+}
+const colorOut = (v) => String(v).toUpperCase();
+function enumOut(table, near, upper, cytoscape = /* @__PURE__ */ new Set()) {
+  return (v, approx) => {
+    const s = String(v);
+    if (Object.hasOwn(table, s)) {
+      return table[s];
+    }
+    if (s.startsWith("other:") && cytoscape.has(s.slice("other:".length).toLowerCase().replaceAll("_", "-"))) {
+      const raw = s.slice("other:".length);
+      const out = upper ? raw.toUpperCase().replaceAll("-", "_") : raw;
+      if (out !== raw) {
+        approx();
+      }
+      return out;
+    }
+    approx();
+    return Object.hasOwn(near, s) ? near[s] : Object.values(table)[0];
+  };
+}
+const DESKTOP_SHAPES = {
+  ellipse: "ELLIPSE",
+  rectangle: "RECTANGLE",
+  "round-rectangle": "ROUND_RECTANGLE",
+  triangle: "TRIANGLE",
+  diamond: "DIAMOND",
+  hexagon: "HEXAGON",
+  octagon: "OCTAGON",
+  parallelogram: "PARALLELOGRAM",
+  vee: "V"
+};
+const NEAR_SHAPES = {
+  pentagon: "hexagon",
+  star: "octagon",
+  trapezoid: "parallelogram",
+  none: "ellipse",
+  // Graphviz shapes no canonical shape names
+  "other:invtrapezium": "parallelogram",
+  "other:house": "hexagon",
+  "other:invhouse": "hexagon"
+};
+const lower = (t) => Object.fromEntries(Object.entries(t).map(([k, v]) => [k, v === "V" ? "vee" : v.toLowerCase()]));
+const nearIn = (t, near) => Object.fromEntries(Object.entries(near).map(([k, v]) => [k, t[v]]));
+const DESKTOP_BORDERS = {
+  solid: "SOLID",
+  dashed: "EQUAL_DASH",
+  dotted: "DOT",
+  "dash-dot": "DASH_DOT",
+  double: "PARALLEL_LINES"
+};
+const DESKTOP_LINES = { ...DESKTOP_BORDERS, zigzag: "ZIGZAG", sinewave: "SINEWAVE" };
+const CX2_LINES = { solid: "solid", dashed: "dashed", dotted: "dotted", double: "double" };
+const NEAR_LINES = { "dash-dot": "dashed", "long-dash": "dashed", zigzag: "solid", sinewave: "solid" };
+const DESKTOP_ARROWS = {
+  none: "NONE",
+  triangle: "DELTA",
+  vee: "ARROW",
+  tee: "T",
+  diamond: "DIAMOND",
+  circle: "CIRCLE",
+  square: "SQUARE",
+  "triangle-open": "OPEN_DELTA",
+  "diamond-open": "OPEN_DIAMOND",
+  "circle-open": "OPEN_CIRCLE",
+  half: "HALF_TOP"
+};
+const CX2_ARROWS = {
+  none: "none",
+  triangle: "triangle",
+  vee: "vee",
+  tee: "tee",
+  diamond: "diamond",
+  circle: "circle",
+  square: "square",
+  "triangle-open": "open-triangle",
+  "diamond-open": "open-diamond",
+  "circle-open": "open-circle",
+  half: "half-top"
+};
+const NEAR_ARROWS = { crow: "vee", inverted: "triangle" };
+const CY_OTHER_ARROWS = /* @__PURE__ */ new Set(["open-square", "open-half-circle", "half-circle"]);
+const CY_OTHER_LINES = /* @__PURE__ */ new Set([
+  "backward-slash",
+  "forward-slash",
+  "vertical-slash",
+  "separate-arrow",
+  "contiguous-arrow"
+]);
+const CY_OTHER_BORDERS = /* @__PURE__ */ new Set([...CY_OTHER_LINES, "zigzag", "sinewave"]);
+const DESKTOP_POSITIONS = {
+  center: "C,C,c,0.00,0.00",
+  top: "N,S,c,0.00,0.00",
+  bottom: "S,N,c,0.00,0.00",
+  left: "W,E,c,0.00,0.00",
+  right: "E,W,c,0.00,0.00",
+  "top-left": "NW,SE,c,0.00,0.00",
+  "top-right": "NE,SW,c,0.00,0.00",
+  "bottom-left": "SW,NE,c,0.00,0.00",
+  "bottom-right": "SE,NW,c,0.00,0.00"
+};
+const CX2_ANCHORS = {
+  center: ["center", "center"],
+  top: ["center", "top"],
+  bottom: ["center", "bottom"],
+  left: ["left", "center"],
+  right: ["right", "center"],
+  "top-left": ["left", "top"],
+  "top-right": ["right", "top"],
+  "bottom-left": ["left", "bottom"],
+  "bottom-right": ["right", "bottom"]
+};
+const desktopNumber = String;
+const cx2Number = (v) => v;
+const textOut = String;
+const desktopBool = (v) => String(v === true);
+const opacity255 = (v, approx) => {
+  const b = Math.round(Number(v) * 255);
+  if (num6(b / 255) !== v) {
+    approx();
+  }
+  return String(b);
+};
+const WRITERS = {
+  desktop: {
+    node: /* @__PURE__ */ new Map([
+      ["fill", { vp: "NODE_FILL_COLOR", write: colorOut }],
+      ["fillOpacity", { vp: "NODE_TRANSPARENCY", write: opacity255 }],
+      ["borderColor", { vp: "NODE_BORDER_PAINT", write: colorOut }],
+      ["borderWidth", { vp: "NODE_BORDER_WIDTH", write: desktopNumber }],
+      [
+        "borderStyle",
+        {
+          vp: "NODE_BORDER_LINE_TYPE",
+          write: enumOut(DESKTOP_BORDERS, nearIn(DESKTOP_BORDERS, NEAR_LINES), true, CY_OTHER_BORDERS)
+        }
+      ],
+      ["shape", { vp: "NODE_SHAPE", write: enumOut(DESKTOP_SHAPES, nearIn(DESKTOP_SHAPES, NEAR_SHAPES), true) }],
+      ["width", { vp: "NODE_WIDTH", write: desktopNumber }],
+      ["height", { vp: "NODE_HEIGHT", write: desktopNumber }],
+      ["label", { vp: "NODE_LABEL", write: textOut }],
+      ["labelColor", { vp: "NODE_LABEL_COLOR", write: colorOut }],
+      ["labelSize", { vp: "NODE_LABEL_FONT_SIZE", write: desktopNumber }],
+      ["labelPosition", { vp: "NODE_LABEL_POSITION", write: enumOut(DESKTOP_POSITIONS, {}, false) }],
+      ["tooltip", { vp: "NODE_TOOLTIP", write: textOut }],
+      ["visible", { vp: "NODE_VISIBLE", write: desktopBool }]
+    ]),
+    edge: /* @__PURE__ */ new Map([
+      ["color", { vp: "EDGE_STROKE_UNSELECTED_PAINT", write: colorOut }],
+      ["opacity", { vp: "EDGE_TRANSPARENCY", write: opacity255 }],
+      ["width", { vp: "EDGE_WIDTH", write: desktopNumber }],
+      [
+        "lineStyle",
+        {
+          vp: "EDGE_LINE_TYPE",
+          write: enumOut(DESKTOP_LINES, nearIn(DESKTOP_LINES, NEAR_LINES), true, CY_OTHER_LINES)
+        }
+      ],
+      [
+        "sourceArrow",
+        {
+          vp: "EDGE_SOURCE_ARROW_SHAPE",
+          write: enumOut(DESKTOP_ARROWS, nearIn(DESKTOP_ARROWS, NEAR_ARROWS), true, CY_OTHER_ARROWS)
+        }
+      ],
+      [
+        "targetArrow",
+        {
+          vp: "EDGE_TARGET_ARROW_SHAPE",
+          write: enumOut(DESKTOP_ARROWS, nearIn(DESKTOP_ARROWS, NEAR_ARROWS), true, CY_OTHER_ARROWS)
+        }
+      ],
+      ["sourceArrowColor", { vp: "EDGE_SOURCE_ARROW_UNSELECTED_PAINT", write: colorOut }],
+      ["targetArrowColor", { vp: "EDGE_TARGET_ARROW_UNSELECTED_PAINT", write: colorOut }],
+      ["curved", { vp: "EDGE_CURVED", write: desktopBool }],
+      ["label", { vp: "EDGE_LABEL", write: textOut }],
+      ["labelColor", { vp: "EDGE_LABEL_COLOR", write: colorOut }],
+      ["labelSize", { vp: "EDGE_LABEL_FONT_SIZE", write: desktopNumber }],
+      ["tooltip", { vp: "EDGE_TOOLTIP", write: textOut }],
+      ["visible", { vp: "EDGE_VISIBLE", write: desktopBool }]
+    ])
+  },
+  cx2: {
+    node: /* @__PURE__ */ new Map([
+      ["fill", { vp: "NODE_BACKGROUND_COLOR", write: colorOut }],
+      ["fillOpacity", { vp: "NODE_BACKGROUND_OPACITY", write: cx2Number }],
+      ["borderColor", { vp: "NODE_BORDER_COLOR", write: colorOut }],
+      ["borderWidth", { vp: "NODE_BORDER_WIDTH", write: cx2Number }],
+      [
+        "borderStyle",
+        {
+          vp: "NODE_BORDER_STYLE",
+          write: enumOut(CX2_LINES, nearIn(CX2_LINES, NEAR_LINES), false, CY_OTHER_BORDERS)
+        }
+      ],
+      [
+        "shape",
+        {
+          vp: "NODE_SHAPE",
+          write: enumOut(lower(DESKTOP_SHAPES), nearIn(lower(DESKTOP_SHAPES), NEAR_SHAPES), false)
+        }
+      ],
+      ["width", { vp: "NODE_WIDTH", write: cx2Number }],
+      ["height", { vp: "NODE_HEIGHT", write: cx2Number }],
+      ["label", { vp: "NODE_LABEL", write: textOut }],
+      ["labelColor", { vp: "NODE_LABEL_COLOR", write: colorOut }],
+      ["labelSize", { vp: "NODE_LABEL_FONT_SIZE", write: cx2Number }],
+      ["labelPosition", { vp: "NODE_LABEL_POSITION", write: cx2Position }],
+      ["visible", { vp: "NODE_VISIBILITY", write: (v) => v === true ? "element" : "none" }]
+    ]),
+    edge: /* @__PURE__ */ new Map([
+      ["color", { vp: "EDGE_LINE_COLOR", write: colorOut }],
+      ["opacity", { vp: "EDGE_OPACITY", write: cx2Number }],
+      ["width", { vp: "EDGE_WIDTH", write: cx2Number }],
+      [
+        "lineStyle",
+        {
+          vp: "EDGE_LINE_STYLE",
+          write: enumOut(CX2_LINES, nearIn(CX2_LINES, NEAR_LINES), false, CY_OTHER_LINES)
+        }
+      ],
+      [
+        "sourceArrow",
+        {
+          vp: "EDGE_SOURCE_ARROW_SHAPE",
+          write: enumOut(CX2_ARROWS, nearIn(CX2_ARROWS, NEAR_ARROWS), false, CY_OTHER_ARROWS)
+        }
+      ],
+      [
+        "targetArrow",
+        {
+          vp: "EDGE_TARGET_ARROW_SHAPE",
+          write: enumOut(CX2_ARROWS, nearIn(CX2_ARROWS, NEAR_ARROWS), false, CY_OTHER_ARROWS)
+        }
+      ],
+      ["sourceArrowColor", { vp: "EDGE_SOURCE_ARROW_COLOR", write: colorOut }],
+      ["targetArrowColor", { vp: "EDGE_TARGET_ARROW_COLOR", write: colorOut }],
+      ["curved", { vp: "EDGE_CURVED", write: (v) => v === true }],
+      ["label", { vp: "EDGE_LABEL", write: textOut }],
+      ["labelColor", { vp: "EDGE_LABEL_COLOR", write: colorOut }],
+      ["labelSize", { vp: "EDGE_LABEL_FONT_SIZE", write: cx2Number }],
+      ["visible", { vp: "EDGE_VISIBILITY", write: (v) => v === true ? "element" : "none" }]
+    ])
+  }
+};
+function cx2Position(v) {
+  const [h, vert] = Object.hasOwn(CX2_ANCHORS, String(v)) ? CX2_ANCHORS[String(v)] : ["center", "center"];
+  return {
+    HORIZONTAL_ALIGN: "center",
+    VERTICAL_ALIGN: "center",
+    HORIZONTAL_ANCHOR: h,
+    VERTICAL_ANCHOR: vert,
+    MARGIN_X: 0,
+    MARGIN_Y: 0,
+    JUSTIFICATION: "center"
+  };
+}
+const FONT_PROPS = ["labelFont", "labelWeight", "labelItalic"];
+const FONT_VP = { node: "NODE_LABEL_FONT_FACE", edge: "EDGE_LABEL_FONT_FACE" };
+const CSS_TO_JAVA = {
+  "sans-serif": "SansSerif",
+  serif: "Serif",
+  monospace: "Monospaced"
+};
+function fontOut(dialect, family, weight, italic, approx) {
+  const bold = weight === "bold";
+  const it = italic === true;
+  const fam = family === null ? "sans-serif" : String(family);
+  if (dialect === "cx2") {
+    if (fontReadsAs(fam) !== fam) {
+      approx();
+    }
+    return { FONT_FAMILY: fam, FONT_STYLE: it ? "italic" : "normal", FONT_WEIGHT: bold ? "bold" : "normal" };
+  }
+  const first = fam.includes(",") ? fam.split(",")[0].trim() : fam;
+  const java = Object.hasOwn(CSS_TO_JAVA, first) ? CSS_TO_JAVA[first] : first;
+  if (fontReadsAs(java) !== fam) {
+    approx();
+  }
+  return `${java},${javaFontStyle(bold, it)},12`;
+}
+function javaFontStyle(bold, italic) {
+  if (!bold && !italic) {
+    return "plain";
+  }
+  return (bold ? "bold" : "") + (italic ? "italic" : "");
+}
+function fontReadsAs(name) {
+  const family = name.replace(/\.(?:bold|italic|plain|bolditalic)$/i, "");
+  return JAVA_FONTS.get(family.toLowerCase()) ?? family;
+}
+function defaultColumnName(target, ref) {
+  if ("style" in ref) {
+    return `graphty.style.${target}.${ref.style}`;
+  }
+  return `graphty.style.${target}.${"computed" in ref ? ref.computed : ref.data}`;
+}
+const PASSTHROUGH_SAFE = /* @__PURE__ */ new Set(["color", "number", "text", "boolean"]);
+function emitCytoscapeStyle(extracted, snapshot, options) {
+  const notes = options.notes ?? new StyleNotes();
+  const style = emptyCytoscapeStyle();
+  const bypasses = {
+    node: new Array(snapshot.nodeCount).fill(null),
+    edge: new Array(snapshot.edgeCount).fill(null)
+  };
+  const columns = {
+    node: /* @__PURE__ */ new Map(),
+    edge: /* @__PURE__ */ new Map()
+  };
+  for (const target of ["node", "edge"]) {
+    emitTarget(targetEmit(target, extracted, snapshot, options, notes), style, bypasses[target], columns[target]);
+  }
+  const bg = extracted.styles.graph.background;
+  if (bg !== void 0) {
+    style.network.defaults.set(
+      options.dialect === "cx2" ? "NETWORK_BACKGROUND_COLOR" : "NETWORK_BACKGROUND_PAINT",
+      bg.toUpperCase()
+    );
+  }
+  return { style, bypasses, columns };
+}
+function targetEmit(target, extracted, snapshot, options, notes) {
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const src = refSource(target, n, extracted.columns[target], extracted.features[target], snapshot);
+  const rules = extracted.styles.rules.filter((r) => r.target === target);
+  const written = new Set(rules.flatMap((r) => [...Object.keys(r.set ?? {}), ...Object.keys(r.map ?? {})]));
+  const truth = new Map(Array.from(written, (p) => [p, resolveRules(rules, target, p, src)]));
+  return {
+    target,
+    extracted,
+    snapshot,
+    options,
+    notes,
+    n,
+    src,
+    rules,
+    truth,
+    approx: (p) => () => {
+      notes.add(STYLE_ISSUE.APPROXIMATED, target, p);
+    },
+    // a default written as an approximation changes every element that draws it
+    approxDefault: (p, value) => () => {
+      const count = (truth.get(p) ?? []).filter((v) => v === value).length;
+      notes.add(STYLE_ISSUE.APPROXIMATED, target, p, { count: Math.max(count, 1) });
+    }
+  };
+}
+function emitTarget(e, style, bypasses, columns) {
+  const { target, notes, truth } = e;
+  const writers = WRITERS[e.options.dialect][target];
+  for (const [p, values] of truth) {
+    if (!writers.has(p) && !FONT_PROPS.includes(p)) {
+      const count = values.filter((v) => v !== null).length;
+      notes.add(STYLE_ISSUE.NOT_WRITTEN, target, p, { count: Math.max(count, 1) });
+    }
+  }
+  const counted = /* @__PURE__ */ new Set();
+  const carrying = (p) => {
+    if (counted.has(p)) {
+      return 0;
+    }
+    counted.add(p);
+    return Math.max((truth.get(p) ?? []).filter((v) => v !== null).length, 1);
+  };
+  const model = buildModel(target, e.rules, writers, notes, carrying);
+  const s = style[target];
+  s.dependencies.set(target === "node" ? "nodeSizeLocked" : "arrowColorMatchesEdge", false);
+  for (const [p, w] of writers) {
+    if (truth.has(p)) {
+      emitProperty(e, s, model, p, w, columns, carrying);
+    }
+  }
+  addBypasses(e, model, writers, bypasses);
+  emitFont(e, model, s, bypasses);
+}
+function emitProperty(e, s, model, p, w, columns, carrying) {
+  const set = model.set.get(p);
+  if (set !== void 0) {
+    s.defaults.set(w.vp, w.write(set, e.approxDefault(p, set)));
+  }
+  let m = model.map.get(p);
+  if (m === void 0) {
+    return;
+  }
+  if (e.options.dialect === "cx2" && m.kind === "continuous") {
+    m = cx2Points(m, e.approx(p));
+    model.map.set(p, m);
+  }
+  const cm = cytoscapeMapping(e, p, m, w, columns);
+  if (cm === null) {
+    e.notes.add(STYLE_ISSUE.LAYER_FLATTENED, e.target, p, { sample: model.mappedBy.get(p), count: carrying(p) });
+    model.map.delete(p);
+  } else {
+    s.mappings.set(w.vp, cm);
+  }
+}
+function addBypasses(e, model, writers, bypasses) {
+  const { target } = e;
+  const modelRules = [
+    {
+      id: "defaults",
+      target,
+      role: "defaults",
+      origin: "declared",
+      where: { all: true },
+      set: Object.fromEntries(model.set)
+    },
+    {
+      id: "mappings",
+      target,
+      role: "mapping",
+      origin: "declared",
+      where: { all: true },
+      map: Object.fromEntries(model.map)
+    }
+  ];
+  for (const [p, w] of writers) {
+    const want = e.truth.get(p);
+    if (want === void 0) {
+      continue;
+    }
+    const drawn = resolveRules(modelRules, target, p, e.src);
+    for (let i = 0; i < e.n; i++) {
+      const v = want[i];
+      if (v !== null && v !== drawn[i]) {
+        bypasses[i] ??= /* @__PURE__ */ new Map();
+        bypasses[i]?.set(w.vp, w.write(v, e.approx(p)));
+      }
+    }
+  }
+}
+function buildModel(target, rules, writers, notes, carrying) {
+  const model = { set: /* @__PURE__ */ new Map(), map: /* @__PURE__ */ new Map(), mappedBy: /* @__PURE__ */ new Map() };
+  const flatten = (p, id) => {
+    notes.add(STYLE_ISSUE.LAYER_FLATTENED, target, p, { sample: id, count: carrying(p) });
+  };
+  const holds = (p) => writers.has(p) || FONT_PROPS.includes(p);
+  const applySet = (r, all) => {
+    for (const [p, v] of Object.entries(r.set ?? {})) {
+      if (v === void 0 || !holds(p)) {
+        continue;
+      }
+      if (!all) {
+        flatten(p, r.id);
+        continue;
+      }
+      model.set.set(p, v);
+      model.map.delete(p);
+      model.mappedBy.delete(p);
+    }
+  };
+  const applyMap = (r, all) => {
+    for (const [p, m] of Object.entries(r.map ?? {})) {
+      if (m === void 0 || !holds(p)) {
+        continue;
+      }
+      if (!all || FONT_PROPS.includes(p)) {
+        flatten(p, r.id);
+        continue;
+      }
+      const below = model.mappedBy.get(p);
+      if (below !== void 0) {
+        flatten(p, below);
+      }
+      model.map.set(p, m);
+      model.mappedBy.set(p, r.id);
+    }
+  };
+  for (const r of rules) {
+    const all = "all" in r.where && r.where.all;
+    applySet(r, all);
+    applyMap(r, all);
+  }
+  return model;
+}
+function cytoscapeMapping(e, p, m, w, columns) {
+  const column = mappingColumn(e, m.by, columns);
+  if (column === null) {
+    return null;
+  }
+  const approx = e.approx(p);
+  const write = (v) => w.write(v, approx);
+  if (m.kind === "passthrough") {
+    return passthroughMapping(e, p, m.by, column, write);
+  }
+  if (m.kind === "discrete") {
+    return {
+      kind: "discrete",
+      column,
+      type: typeOf(m.table.map(([k]) => k)),
+      table: m.table.map(([k, v]) => [k, write(v)])
+    };
+  }
+  if (m.kind === "continuous") {
+    const points = m.points.map((pt) => ({
+      at: pt.at,
+      below: write(pt.below),
+      value: write(pt.value),
+      above: write(pt.above)
+    }));
+    return { kind: "continuous", column, type: "double", points };
+  }
+  return null;
+}
+function mappingColumn(e, ref, columns) {
+  if ("data" in ref) {
+    return ref.data;
+  }
+  const { target } = e;
+  const column = (e.options.columnName ?? defaultColumnName)(target, ref);
+  let values = null;
+  if ("style" in ref) {
+    values = e.extracted.columns[target].get(ref.style) ?? null;
+  } else if ("computed" in ref && target === "node") {
+    values = degreeValues(e.snapshot, ref.computed);
+  }
+  if (values === null) {
+    return null;
+  }
+  columns.set(column, values);
+  return column;
+}
+function passthroughMapping(e, p, by, column, write) {
+  const { target } = e;
+  const kind = STYLE_PROPERTIES[target].get(p) ?? "";
+  const cells = e.src.column(by) ?? [];
+  if (PASSTHROUGH_SAFE.has(kind)) {
+    return { kind: "passthrough", column, type: typeOf(Array.from(cells)) };
+  }
+  const read = "style" in by ? (v) => isScalar(v) ? v : null : canonicalFor(target, p);
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < cells.length; i++) {
+    const raw = cells[i];
+    const v = isScalar(raw) && !seen.has(raw) ? read(raw) : null;
+    if (v !== null) {
+      seen.set(raw, write(v));
+    }
+  }
+  const table = Array.from(seen);
+  return { kind: "discrete", column, type: typeOf(table.map(([k]) => k)), table };
+}
+function cx2Points(m, approx) {
+  let changed = false;
+  const points = m.points.map((pt) => {
+    if (pt.value === pt.below || pt.value === pt.above) {
+      return pt;
+    }
+    changed = true;
+    return { ...pt, value: pt.below };
+  });
+  if (!changed) {
+    return m;
+  }
+  approx();
+  return { ...m, points };
+}
+function isScalar(v) {
+  return typeof v === "string" || typeof v === "boolean" || typeof v === "number" && Number.isFinite(v);
+}
+function typeOf(values) {
+  let numbers = 0;
+  let integers = 0;
+  let booleans = 0;
+  let all = 0;
+  for (const v of values) {
+    if (v === null || v === void 0) {
+      continue;
+    }
+    all++;
+    if (typeof v === "number") {
+      numbers++;
+      if (Number.isInteger(v)) {
+        integers++;
+      }
+    } else if (typeof v === "boolean") {
+      booleans++;
+    }
+  }
+  if (all > 0 && numbers === all) {
+    return integers === all ? "integer" : "double";
+  }
+  if (all > 0 && booleans === all) {
+    return "boolean";
+  }
+  return "string";
+}
+function emitFont(e, model, s, bypasses) {
+  const { target, truth, n, approx, approxDefault } = e;
+  const { dialect } = e.options;
+  if (!FONT_PROPS.some((p) => truth.has(p))) {
+    return;
+  }
+  const [fd, wd, id] = FONT_PROPS.map((p) => model.set.get(p) ?? null);
+  const vp = FONT_VP[target];
+  if (fd !== null || wd !== null || id !== null) {
+    s.defaults.set(
+      vp,
+      fontOut(dialect, fd, wd, id, fd === null ? approx("labelFont") : approxDefault("labelFont", fd))
+    );
+  }
+  const [ft, wt, it] = FONT_PROPS.map((p) => truth.get(p) ?? null);
+  for (let i = 0; i < n; i++) {
+    const f = ft?.[i] ?? null;
+    const w = wt?.[i] ?? null;
+    const t = it?.[i] ?? null;
+    const differs = f !== null && f !== fd || w !== null && w !== wd || t !== null && t !== id;
+    if (differs) {
+      bypasses[i] ??= /* @__PURE__ */ new Map();
+      bypasses[i]?.set(vp, fontOut(dialect, f ?? fd, w ?? wd, t ?? id, approx("labelFont")));
+    }
+  }
+}
+function defText(v) {
+  return String(v).replaceAll(",", ",,");
+}
+function cx1Definition(m) {
+  const parts = [`COL=${defText(m.column)}`, `T=${m.type ?? "string"}`];
+  if (m.kind === "discrete") {
+    m.table.forEach(([k, v], i) => {
+      parts.push(`K=${i}=${defText(k)}`, `V=${i}=${defText(v)}`);
+    });
+  } else if (m.kind === "continuous") {
+    m.points.forEach((p, i) => {
+      parts.push(
+        `L=${i}=${defText(p.below)}`,
+        `E=${i}=${defText(p.value)}`,
+        `G=${i}=${defText(p.above)}`,
+        `OV=${i}=${p.at}`
+      );
+    });
+  }
+  return parts.join(",");
+}
+function recordOf(map, value) {
+  const out = {};
+  for (const [k, v] of map) {
+    Object.defineProperty(out, k, { value: value(v), enumerable: true, writable: true, configurable: true });
+  }
+  return out;
+}
+function cytoscapeCxAspect(style) {
+  const entry = (of, t) => ({
+    properties_of: of,
+    properties: recordOf(t.defaults, String),
+    dependencies: recordOf(t.dependencies, String),
+    mappings: recordOf(t.mappings, (m) => ({ type: m.kind.toUpperCase(), definition: cx1Definition(m) }))
+  });
+  return [
+    { properties_of: "network", properties: recordOf(style.network.defaults, String) },
+    entry("nodes:default", style.node),
+    entry("edges:default", style.edge)
+  ];
+}
+function cx2Intervals(points) {
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  const out = [];
+  for (let i = 0; i <= points.length; i++) {
+    const lo = points.at(i - 1);
+    const hi = points.at(i);
+    const iv = {};
+    if (i > 0 && lo !== void 0) {
+      iv.min = lo.at;
+      iv.minVPValue = lo.above;
+      iv.includeMin = same(lo.value, lo.above);
+    }
+    if (i < points.length && hi !== void 0) {
+      iv.max = hi.at;
+      iv.maxVPValue = hi.below;
+      iv.includeMax = !same(hi.value, hi.above) && same(hi.value, hi.below);
+    }
+    out.push(iv);
+  }
+  return out;
+}
+function cytoscapeCx2Aspects(style) {
+  const mapping = (m) => {
+    if (m.kind === "passthrough") {
+      return { type: "PASSTHROUGH", definition: { attribute: m.column } };
+    }
+    if (m.kind === "discrete") {
+      return {
+        type: "DISCRETE",
+        definition: { attribute: m.column, map: m.table.map(([v, vp]) => ({ v, vp })) }
+      };
+    }
+    return { type: "CONTINUOUS", definition: { attribute: m.column, map: cx2Intervals(m.points) } };
+  };
+  const id = (v) => v;
+  return {
+    visualProperties: [
+      {
+        default: {
+          network: recordOf(style.network.defaults, id),
+          node: recordOf(style.node.defaults, id),
+          edge: recordOf(style.edge.defaults, id)
+        },
+        nodeMapping: recordOf(style.node.mappings, mapping),
+        edgeMapping: recordOf(style.edge.mappings, mapping)
+      }
+    ],
+    visualEditorProperties: [
+      {
+        properties: {
+          nodeSizeLocked: style.node.dependencies.get("nodeSizeLocked") === true,
+          arrowColorMatchesEdge: style.edge.dependencies.get("arrowColorMatchesEdge") === true
+        }
+      }
+    ]
+  };
+}
+function attr(name, value) {
+  return ` ${name}="${escapeXmlAttribute(String(value))}"`;
+}
+function cytoscapeVizmapXml(style, name) {
+  const lines = [`<visualStyle${attr("name", name)}>`];
+  const section = (tag, defaults, t) => {
+    lines.push(`  <${tag}>`);
+    for (const [dep, on] of t?.dependencies ?? []) {
+      lines.push(`    <dependency${attr("name", dep)}${attr("value", on)}/>`);
+    }
+    const vps = /* @__PURE__ */ new Set([...defaults.keys(), ...t?.mappings.keys() ?? []]);
+    for (const vp of vps) {
+      const d = defaults.has(vp) ? attr("default", defaults.get(vp)) : "";
+      const m = t?.mappings.get(vp);
+      if (m === void 0) {
+        lines.push(`    <visualProperty${attr("name", vp)}${d}/>`);
+      } else {
+        lines.push(`    <visualProperty${attr("name", vp)}${d}>`, ...mappingXml(m), "    </visualProperty>");
+      }
+    }
+    lines.push(`  </${tag}>`);
+  };
+  section("network", style.network.defaults);
+  section("node", style.node.defaults, style.node);
+  section("edge", style.edge.defaults, style.edge);
+  lines.push("</visualStyle>");
+  return lines.join("\n");
+}
+function mappingXml(m) {
+  const head = `${attr("attributeName", m.column)}${attr("attributeType", m.kind === "continuous" ? "float" : m.type ?? "string")}`;
+  if (m.kind === "passthrough") {
+    return [`      <passthroughMapping${head}/>`];
+  }
+  if (m.kind === "discrete") {
+    return [
+      `      <discreteMapping${head}>`,
+      ...m.table.map(
+        ([k, v]) => `        <discreteMappingEntry${attr("attributeValue", k)}${attr("value", v)}/>`
+      ),
+      "      </discreteMapping>"
+    ];
+  }
+  return [
+    `      <continuousMapping${head}>`,
+    ...m.points.map(
+      (p) => `        <continuousMappingPoint${attr("attrValue", p.at)}${attr("lesserValue", p.below)}${attr("equalValue", p.value)}${attr("greaterValue", p.above)}/>`
+    ),
+    "      </continuousMapping>"
+  ];
+}
+function cytoscapeWritableProperties(target, dialect) {
+  return [...WRITERS[dialect][target].keys(), ...FONT_PROPS];
+}
+function cytoscapeElementProperties(target, value, dialect, approx) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [p, w] of WRITERS[dialect][target]) {
+    const v = value(p);
+    if (v !== null) {
+      out.set(
+        w.vp,
+        w.write(v, () => {
+          approx(p);
+        })
+      );
+    }
+  }
+  const [f, wt, it] = FONT_PROPS.map((p) => value(p));
+  if (f !== null || wt !== null || it !== null) {
+    out.set(
+      FONT_VP[target],
+      fontOut(dialect, f, wt, it, () => {
+        approx("labelFont");
+      })
+    );
+  }
+  return out;
+}
+const NODE_SIZE_FALLBACK = 50;
+function vpUsage(style, bypasses) {
+  const bypassed = /* @__PURE__ */ new Set();
+  for (const b of bypasses) {
+    if (b) {
+      for (const k of b.keys()) {
+        bypassed.add(k);
+      }
+    }
+  }
+  for (const [from, to] of style.bypassAliases) {
+    if (bypassed.has(from)) {
+      bypassed.add(to);
+    }
+  }
+  const used = /* @__PURE__ */ new Set([...style.defaults.keys(), ...style.mappings.keys(), ...bypassed]);
+  return { used, bypassed };
+}
+function chooseVps(target, style, used) {
+  const chosen = /* @__PURE__ */ new Map();
+  for (const [prop, list] of CYTOSCAPE_LEXICON[target]) {
+    const hit = list.find(([vp]) => used.has(vp));
+    if (hit !== void 0) {
+      chosen.set(prop, hit);
+    }
+  }
+  if (target === "node" && style.dependencies.get("nodeSizeLocked") === true) {
+    chosen.delete("width");
+    chosen.delete("height");
+  }
+  if (target === "edge" && style.dependencies.get("arrowColorMatchesEdge") === true) {
+    if (used.has("EDGE_UNSELECTED_PAINT")) {
+      chosen.set("color", ["EDGE_UNSELECTED_PAINT", colorParser]);
+    }
+    chosen.delete("sourceArrowColor");
+    chosen.delete("targetArrowColor");
+  }
+  return chosen;
+}
+function parseMapping(m, parse, site) {
+  switch (m.kind) {
+    case "passthrough":
+      return { kind: "passthrough", column: m.column };
+    case "discrete": {
+      const table = [];
+      for (const [k, raw] of m.table) {
+        const v = parse(raw, site);
+        if (v !== null) {
+          table.push([k, v]);
+        }
+      }
+      return { kind: "discrete", column: m.column, table };
+    }
+    default:
+      return { kind: "continuous", column: m.column, points: parsePoints(m.points, parse, site) };
+  }
+}
+function parsePoints(raw, parse, site) {
+  const parsed = [];
+  for (const p of raw) {
+    const below = parse(p.below, site);
+    const value = parse(p.value, site);
+    const above = parse(p.above, site);
+    if (below !== null && value !== null && above !== null) {
+      parsed.push({ at: p.at, below, value, above });
+    }
+  }
+  parsed.sort((a, b) => a.at - b.at);
+  const points = [];
+  for (const p of parsed) {
+    if (points.at(-1)?.at === p.at) {
+      points[points.length - 1] = p;
+    } else {
+      points.push(p);
+    }
+  }
+  return points;
+}
+function evalMapping(m, value, parse, site) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (m.kind) {
+    case "passthrough":
+      return Array.isArray(value) ? null : parse(value, site);
+    case "discrete": {
+      const j = discreteLookup(m.table)(value);
+      return j < 0 ? null : m.table[j][1];
+    }
+    default:
+      return evalContinuous(m.points, numberOf(value));
+  }
+}
+function resolver(target, style, elements, notes, budget) {
+  const bypasses = elements.bypasses ?? [];
+  const parsed = /* @__PURE__ */ new Map();
+  const ruleSite = (property) => ({ notes, target, property, budget });
+  const bypass = (i, vp) => {
+    const b = bypasses[i];
+    if (!b) {
+      return void 0;
+    }
+    const v = b.get(vp);
+    if (v !== void 0 && v !== null) {
+      return v;
+    }
+    for (const [from, to] of style.bypassAliases) {
+      if (to === vp && !b.has(to)) {
+        return b.get(from);
+      }
+    }
+    return void 0;
+  };
+  const mappingOf = (vp, parse, property) => {
+    const raw = style.mappings.get(vp);
+    if (raw === void 0) {
+      return void 0;
+    }
+    const key = `${vp}\0${property}`;
+    let m = parsed.get(key);
+    if (m === void 0) {
+      const entries = raw.kind === "discrete" ? raw.table.length : 0;
+      budget?.spend(target, 1 + entries + (raw.kind === "continuous" ? raw.points.length : 0));
+      m = parseMapping(raw, parse, ruleSite(property));
+      parsed.set(key, m);
+    }
+    return m;
+  };
+  const one = (vp, parse, property, i) => {
+    const site = { notes, target, property, element: i, budget };
+    const b = bypass(i, vp);
+    const fromBypass = b === void 0 || b === null ? null : parse(b, site);
+    if (fromBypass !== null) {
+      return fromBypass;
+    }
+    const m = mappingOf(vp, parse, property);
+    const mapped = m === void 0 ? null : evalMapping(m, elements.value(m.column, i), parse, site);
+    if (mapped !== null) {
+      return mapped;
+    }
+    return style.defaults.has(vp) ? parse(style.defaults.get(vp), ruleSite(property)) : null;
+  };
+  return { bypass, one };
+}
+function resolveCytoscape(target, style, elements, options = {}) {
+  const notes = options.notes ?? new StyleNotes();
+  const s = style[target];
+  const n = elements.count;
+  const { used, bypassed } = vpUsage(s, elements.bypasses ?? []);
+  const chosen = chooseVps(target, s, used);
+  const { one } = resolver(target, s, elements, notes, options.budget);
+  const out = {};
+  const column = (vp, parse, property) => {
+    options.budget?.spend(target, n);
+    const values = new Array(n);
+    for (let i = 0; i < n; i++) {
+      values[i] = one(vp, parse, property, i);
+    }
+    return values;
+  };
+  for (const [prop, [vp, parse]] of chosen) {
+    out[prop] = column(vp, parse, prop);
+  }
+  if (target === "node" && s.dependencies.get("nodeSizeLocked") === true) {
+    const size = column(NODE_SIZE_VP, sizeParser, "width").map((v) => v ?? NODE_SIZE_FALLBACK);
+    out.width = size;
+    out.height = size.slice();
+  }
+  if (target === "edge" && s.dependencies.get("arrowColorMatchesEdge") === true && out.color !== void 0) {
+    out.sourceArrowColor = out.color.slice();
+    out.targetArrowColor = out.color.slice();
+  }
+  noteUncarried(target, s, used, bypassed, notes);
+  fillToolDefaults(target, out, n, options.defaults ?? null);
+  if (target === "edge") {
+    straightenBendless(out, one);
+  }
+  return out;
+}
+function straightenBendless(out, one) {
+  const { curved } = out;
+  if (curved !== void 0) {
+    out.curved = curved.map((c, i) => c === true ? one(EDGE_BEND_VP, bendParser, "curved", i) === true : c);
+  }
+}
+const EDGE_BEND_VP = "EDGE_BEND";
+const bendParser = (raw) => {
+  if (typeof raw === "string") {
+    const text = raw.trim();
+    return text !== "" && text !== '""';
+  }
+  return Array.isArray(raw) ? raw.length > 0 : raw !== null && raw !== void 0 && typeof raw === "object";
+};
+const INERT_DEFAULT = /NullCustomGraphics|^255$|^0(?:\.0+)?$|^$|^C,C,c,0\.00,0\.00$|^false$/;
+function noteUncarried(target, s, used, bypassed, notes) {
+  for (const vp of used) {
+    if (!isUncarriedVp(vp)) {
+      continue;
+    }
+    const d = s.defaults.get(vp);
+    const text = typeof d === "string" || typeof d === "number" || typeof d === "boolean" ? String(d) : "";
+    if (INERT_DEFAULT.test(text.slice(0, 64)) && !s.mappings.has(vp) && !bypassed.has(vp)) {
+      continue;
+    }
+    notes.add(STYLE_ISSUE.NOT_CARRIED, target, vp, { sample: text });
+  }
+}
+function fillToolDefaults(target, out, n, tool) {
+  const d = tool === null ? null : toolDefaults(tool);
+  if (d === null) {
+    return;
+  }
+  for (const [prop, entry] of Object.entries(d[target])) {
+    if (entry === void 0 || !isStyleValue(target, prop, entry.value)) {
+      continue;
+    }
+    const value = entry.value;
+    const values = out[prop] === void 0 ? new Array(n).fill(null) : out[prop].slice();
+    for (let i = 0; i < n; i++) {
+      values[i] ??= value;
+    }
+    out[prop] = values;
+  }
+}
+function cytoscapeBackground(style, notes) {
+  const d = style.network.defaults;
+  const raw = d.get("NETWORK_BACKGROUND_PAINT") ?? d.get("NETWORK_BACKGROUND_COLOR");
+  if (raw === void 0) {
+    return null;
+  }
+  const v = colorParser(raw, { notes: notes ?? new StyleNotes(), target: "graph", property: "background" });
+  return typeof v === "string" ? v : null;
+}
+function resolveCytoscapeBypasses(target, maps, options = {}) {
+  const notes = options.notes ?? new StyleNotes();
+  const style = emptyCytoscapeStyle();
+  const elements = { count: maps.length, value: () => null, bypasses: maps };
+  const out = resolveCytoscape(target, style, elements, { notes, budget: options.budget });
+  if (target === "node" && out.width === void 0) {
+    const size = maps.map((m) => {
+      const raw = m?.get(NODE_SIZE_VP);
+      return raw === void 0 ? null : sizeParser(raw, { notes, target, property: "width" });
+    });
+    if (size.some((v) => v !== null)) {
+      out.width = size;
+      out.height = size.slice();
+    }
+  }
+  for (const m of maps) {
+    if (!m) {
+      continue;
+    }
+    for (const [k, v] of m) {
+      if (k.startsWith("?")) {
+        notes.add(STYLE_ISSUE.NOT_CARRIED, target, k.slice(1), { sample: v });
+      }
+    }
+  }
+  fillToolDefaults(target, out, maps.length, options.defaults ?? null);
+  return out;
+}
+function cytoscapeRules(target, style, elements, options = {}) {
+  const notes = options.notes ?? new StyleNotes();
+  const refOf = options.columnRef ?? ((column) => ({ data: column }));
+  const s = style[target];
+  const { used } = vpUsage(s, elements.bypasses ?? []);
+  const chosen = chooseVps(target, s, used);
+  const site = (property) => ({ notes, target, property, budget: options.budget });
+  const locked = target === "node" && s.dependencies.get("nodeSizeLocked") === true;
+  const matched = target === "edge" && s.dependencies.get("arrowColorMatchesEdge") === true;
+  const set = defaultValues(s, chosen, site, { locked, matched });
+  const columns = /* @__PURE__ */ new Map();
+  const byColumn = /* @__PURE__ */ new Map();
+  const reading = { target, refOf, elements, columns, notes, budget: options.budget };
+  const add = (props, raw, parse) => {
+    const parsed = parseMapping(raw, parse, site(props[0]));
+    const mapping = neutralMapping(parsed, props[0], parse, reading);
+    const key = `${raw.kind}\0${raw.column}`;
+    let rule = byColumn.get(key);
+    if (rule === void 0) {
+      rule = { id: `${target}.${raw.kind}.${raw.column}`, map: {} };
+      byColumn.set(key, rule);
+    }
+    for (const p of props) {
+      rule.map[p] = mapping;
+    }
+  };
+  for (const [prop, [vp, parse]] of chosen) {
+    const raw = s.mappings.get(vp);
+    if (raw !== void 0) {
+      add(matched && prop === "color" ? ["color", "sourceArrowColor", "targetArrowColor"] : [prop], raw, parse);
+    }
+  }
+  const size = locked ? s.mappings.get(NODE_SIZE_VP) : void 0;
+  if (size !== void 0) {
+    add(["width", "height"], size, sizeParser);
+  }
+  const rules = [];
+  if (Object.keys(set).length > 0) {
+    rules.push({
+      id: `${target}.defaults`,
+      target,
+      role: "defaults",
+      origin: "declared",
+      where: { all: true },
+      set
+    });
+  }
+  for (const r of byColumn.values()) {
+    rules.push({ id: r.id, target, role: "mapping", origin: "declared", where: { all: true }, map: r.map });
+  }
+  return { rules, columns };
+}
+function defaultValues(s, chosen, site, deps) {
+  const set = {};
+  for (const [prop, [vp, parse]] of chosen) {
+    const v = s.defaults.has(vp) ? parse(s.defaults.get(vp), site(prop)) : null;
+    if (v !== null) {
+      set[prop] = v;
+    }
+  }
+  if (deps.locked) {
+    const size = s.defaults.has(NODE_SIZE_VP) ? sizeParser(s.defaults.get(NODE_SIZE_VP), site("width")) : null;
+    set.width = size ?? 50;
+    set.height = size ?? 50;
+  }
+  if (deps.matched && set.color !== void 0) {
+    set.sourceArrowColor = set.color;
+    set.targetArrowColor = set.color;
+  }
+  if (set.curved === true && bendParser(s.defaults.get(EDGE_BEND_VP), site("curved")) !== true) {
+    set.curved = false;
+  }
+  return set;
+}
+function neutralMapping(m, property, parse, reading) {
+  const { target, elements, columns, notes, budget } = reading;
+  const by = reading.refOf(m.column);
+  if (m.kind === "discrete") {
+    return { kind: "discrete", by, table: m.table };
+  }
+  if (m.kind === "continuous") {
+    return { kind: "continuous", by, points: m.points };
+  }
+  const plain = "style" in by ? styleCell : canonicalFor(target, property);
+  const n = elements.count;
+  budget?.spend(target, n);
+  const values = new Array(n);
+  let same = true;
+  for (let i = 0; i < n; i++) {
+    const raw = elements.value(m.column, i);
+    const cy = raw === null || raw === void 0 || Array.isArray(raw) ? null : parse(raw, { notes, target, property, element: i });
+    values[i] = cy;
+    if (same && cy !== (raw === null || raw === void 0 || Array.isArray(raw) ? null : plain(raw))) {
+      same = false;
+    }
+  }
+  if (same) {
+    return { kind: "passthrough", by };
+  }
+  const key = `cytoscape.${property}`;
+  columns.set(key, values);
+  return { kind: "passthrough", by: { style: key } };
+}
+function styleCell(raw) {
+  return typeof raw === "string" || typeof raw === "number" || typeof raw === "boolean" ? raw : null;
+}
+const FORMAT = "xgmml";
+const EXTENSIONS = Object.freeze([".xgmml", ".xml"]);
+const MIME_TYPES = Object.freeze(["application/xgmml", "text/xgmml", "text/xgmml+xml"]);
+const XGMML_NAMESPACE = "http://www.cs.rpi.edu/XGMML";
+const CY_NAMESPACE = "http://www.cytoscape.org";
+const XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+const META_KEY = "xgmml";
+const LABEL_COLUMN = "label";
+const EDGE_ID_COLUMN = "id";
+const POSITION_COLUMN = "position";
+const Z_COLUMN = "z";
+const GRAPHICS_COLUMN = "graphics";
+const PARENT_COLUMN = "parent";
+const PARENTS_COLUMN = "parents";
+const SUBGRAPH_COLUMN = "xgmml.subgraph";
+const NESTED_NETWORK_COLUMN = "cytoscape.nestedNetwork";
+const NETWORK_POINTER_COLUMN = "xgmml.networkPointer";
+const NETWORKS_COLUMN = "xgmml.networks";
+const INTERACTION_COLUMN = "interaction";
+const XGMML_ORIGIN_NAMESPACE = "xgmml";
+const CYTOSCAPE_ORIGIN_NAMESPACE = "cytoscape";
+const XGMML_ISSUE = Object.freeze({
+  ...INPUT_ISSUE,
+  ...ELEMENT_ISSUE,
+  /** The input is not well-formed XML. The import stops. */
+  XML_SYNTAX: XML_SYNTAX_CODE,
+  /** Elements are nested more than 100,000 deep. The import stops. */
+  XML_NESTING: XML_NESTING_CODE,
+  /** The input is empty or whitespace only. The import stops. */
+  EMPTY_INPUT: EMPTY_INPUT_CODE,
+  /** The input is not valid UTF-8. The import stops. */
+  INVALID_UTF8: INVALID_UTF8_CODE,
+  /**
+   * Some bytes are not valid in the encoding that was chosen (by a byte order mark, the file's declaration or the
+   * `encoding` option). The import stops.
+   */
+  INVALID_ENCODING: INVALID_ENCODING_CODE,
+  /** Undeclared non-UTF-8 bytes were read as windows-1252. */
+  ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
+  /** A declared encoding the platform cannot decode was ignored. */
+  UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
+  /** A declared encoding the byte order mark contradicts (the mark wins). */
+  ENCODING_CONFLICT: ENCODING_CONFLICT_CODE,
+  /**
+   * The root element is not `<graph>` (it may be an XHTML page with a graph inside, or a GraphML file). The import
+   * stops.
+   */
+  NO_GRAPH: NO_GRAPH_CODE,
+  /**
+   * The file is a Cytoscape session view (`cy:view="1"`), which holds only view settings and no nodes or edges. The
+   * import stops.
+   */
+  VIEW_DOCUMENT: "E_XGMML_VIEW_DOCUMENT",
+  /** A node with neither an id nor a label; it is skipped with its subtree. */
+  MISSING_ID: MISSING_ID_CODE,
+  /** A node without an id; its label is used as the id. */
+  ID_FROM_LABEL: "W_XGMML_ID_FROM_LABEL",
+  /** A node or edge with both an id and an `xlink:href`; it is read as the reference. */
+  ID_AND_HREF: "W_XGMML_ID_AND_HREF",
+  /** An edge without a source or a target that no label alias resolves. */
+  MISSING_ENDPOINT: MISSING_ENDPOINT_CODE,
+  /** An edge endpoint that names no node (addMissingNodes false); the edge is skipped. */
+  UNKNOWN_NODE: "E_UNKNOWN_NODE",
+  /** Endpoints resolved through Cytoscape's `"a (pp) b"` label aliases; interactions filled from labels. */
+  LABEL_ALIAS: "W_XGMML_LABEL_ALIAS",
+  /** A node id declared twice; the declarations are merged. */
+  DUPLICATE_NODE: DUPLICATE_NODE_CODE,
+  /** An edge id used twice; the second edge is skipped. */
+  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE,
+  /**
+   * Cytoscape 2.x writes each edge of a group a second time, inside the group. The repeats are dropped, so every edge
+   * is read once; nothing is lost.
+   */
+  GROUP_DUPLICATE_EDGE: "W_XGMML_GROUP_DUPLICATE_EDGE",
+  /** A `directed` or `cy:directed` value other than 0 / 1. */
+  BAD_DIRECTED: "W_XGMML_BAD_DIRECTED",
+  /** A `documentVersion` that does not parse; the dialect is chosen from the content. */
+  DOCUMENT_VERSION: "W_XGMML_DOCUMENT_VERSION",
+  /** A root `<graph>` with neither the XGMML namespace nor an XGMML DOCTYPE. */
+  NO_NAMESPACE: "W_XGMML_NO_NAMESPACE",
+  /** A malformed `<att>`: a list with a value, a scalar with child atts, an att with no name. */
+  BAD_ATT: "W_XGMML_BAD_ATT",
+  /** A bare `&` read as `&amp;` under repairBareAmpersands. */
+  AMPERSAND_REPAIRED: "W_XGMML_AMPERSAND_REPAIRED",
+  /** Two surrogate character references joined under pairSurrogateReferences. */
+  SURROGATE_PAIRED: "W_XGMML_SURROGATE_PAIRED",
+  /** An empty list whose element type nothing states; a list of strings is assumed. */
+  EMPTY_LIST_TYPE: "W_XGMML_EMPTY_LIST_TYPE",
+  /**
+   * An attribute holds a structure a single column cannot (a list of records, a list of lists, a Cytoscape 2.x map
+   * or XML from another tool). Its value is kept as a JSON value, which a save as XGMML writes back.
+   */
+  RECORD_LIST: "W_XGMML_RECORD_LIST",
+  /** A pointer into another file (`file.xgmml#id`); kept as text. */
+  CROSS_FILE_REFERENCE: "W_XGMML_CROSS_FILE_REFERENCE",
+  /** A graph nested in an edge's att; there is no model for it. */
+  EDGE_NESTED_GRAPH: "W_XGMML_EDGE_NESTED_GRAPH",
+  /**
+   * Some nodes or edges of a Cytoscape session belong to none of its networks (Cytoscape keeps group meta-edges and
+   * the members of collapsed groups this way). They are not read; the message counts them.
+   */
+  ROOT_ONLY_ELEMENTS: "W_XGMML_ROOT_ONLY_ELEMENTS",
+  /** A value that does not parse as its declared type; the cell is unset. */
+  BAD_VALUE: BAD_VALUE_CODE,
+  /**
+   * An attribute's type was widened because a later value did not fit: an integer above 2^31 in an integer column,
+   * or two declared types for one attribute.
+   */
+  WIDENED: WIDENED_CODE,
+  /** An integer beyond 2^53 was stored as the nearest 64-bit float; pass `long: "string"` to keep every digit. */
+  PRECISION: PRECISION_CODE,
+  /** A reference (xlink:href, nested-network pointer) that names nothing. */
+  DANGLING_REFERENCE: DANGLING_REFERENCE_CODE,
+  /** The same attribute twice on one element; the later value wins. */
+  DUPLICATE_ATTRIBUTE: DUPLICATE_ATTRIBUTE_CODE,
+  /** A group membership naming no node. */
+  UNKNOWN_PARENT: UNKNOWN_PARENT_CODE,
+  /** A group membership that would close a parent cycle; that link is dropped. */
+  PARENT_CYCLE: PARENT_CYCLE_CODE,
+  /** A Cytoscape formula kept as its text. */
+  EQUATION_AS_TEXT: EQUATION_AS_TEXT_CODE,
+  /** An att type XGMML and Cytoscape do not define; kept as text. */
+  UNKNOWN_ATTR_TYPE: UNKNOWN_ATTR_TYPE_CODE,
+  /** An element XGMML does not define at that place; skipped with its subtree. */
+  UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
+  /** Character data where XGMML allows only elements, or inside an att. */
+  STRAY_TEXT: STRAY_TEXT_CODE,
+  /**
+   * The file holds several graphs and only the first was read. It is not added when `graphIndex` or `graphName` chose the graph.
+   * `importAllGraphs()` reads every one.
+   */
+  MULTIPLE_GRAPHS: MULTIPLE_GRAPHS_CODE,
+  /** `graphIndex` or `graphName` matches no network in the session. The import stops. */
+  GRAPH_NOT_FOUND: GRAPH_NOT_FOUND_CODE,
+  /** `graphName` matches several networks in the session. The import stops. */
+  AMBIGUOUS_GRAPH_NAME: AMBIGUOUS_GRAPH_NAME_CODE,
+  /**
+   * An attribute was renamed `<name>#<suffix>` because another attribute already has its name, for example
+   * two attributes declared with the same name.
+   */
+  COLUMN_RENAMED: COLUMN_RENAMED_CODE,
+  /**
+   * You read into a graph builder that already has an id, label or position attribute, so this file's one is kept as
+   * a plain attribute.
+   */
+  ROLE_TAKEN: ROLE_TAKEN_CODE,
+  /** Two different id texts became the same number because `ids` is "number", so their nodes were merged. */
+  ID_MERGED: ID_MERGED_CODE,
+  /** You set an option this format does not use; it had no effect. The message names the option. */
+  OPTION_IGNORED: OPTION_IGNORED_CODE,
+  /**
+   * You read into your own graph builder, which was created with a different `addMissingNodes`, `duplicateEdges`,
+   * `selfLoops` or `weightDtype` than the option you passed; the builder's setting applies.
+   */
+  SINK_OPTION: SINK_OPTION_CODE,
+  /**
+   * You read into a graph builder whose direction is already set, or which already holds edges, so the file is read
+   * with the builder's direction instead of its own.
+   */
+  DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
+  /** Edges of the other direction were read with the direction `onMixedDirection` chose. */
+  DIRECTION_FORCED: DIRECTION_FORCED_CODE,
+  /**
+   * The graph has both directed and undirected edges and `onMixedDirection` is "error". An import stops; a save to a
+   * format that holds one direction per file fails with E_DIRECTED. Pass "directed" or "undirected" to read or write
+   * it anyway.
+   */
+  MIXED_DIRECTION: MIXED_DIRECTION_CODE
+});
+const XGMML_LOSS = Object.freeze({
+  /** A json or nested-list column written as a string att. */
+  JSON_AS_STRING: "W_XGMML_JSON_AS_STRING",
+  /**
+   * An attribute type Cytoscape does not have is written as a wider one (a 32-bit float as Double, a large unsigned
+   * integer as Long, a byte as Integer, a dictionary as String).
+   */
+  WIDENED_TYPE: "W_XGMML_WIDENED_TYPE",
+  /** A text value holds a character XML 1.0 forbids (most control characters); the save fails with E_COLUMN_TYPE. */
+  XML_ILLEGAL_CHAR: XML_ILLEGAL_CHAR_CODE,
+  /** A temporal column written as plain numbers. */
+  TEMPORAL_DROPPED: TEMPORAL_DROPPED_CODE,
+  /** A temporal text companion written as a plain string att. */
+  TEMPORAL_TEXT_DROPPED: TEMPORAL_TEXT_DROPPED_CODE,
+  /** An attribute with a role the format has no place for is written as a plain attribute; the role is lost. */
+  ROLE_DROPPED: ROLE_DROPPED_CODE,
+  /**
+   * A `parents` attribute (several parents per node) is not written because the graph also has a `parent` attribute.
+   */
+  PARENTS_DROPPED: PARENTS_DROPPED_CODE,
+  /** A mutual pair written as two directed edges. */
+  MUTUAL_EXPANDED: MUTUAL_EXPANDED_CODE,
+  /** Node ids whose text reads back as the other type. */
+  ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
+  /** Edge ids that are not text are written as text and read back as text. */
+  EDGE_ID_TEXT: "W_XGMML_EDGE_ID_TEXT",
+  /** Strings holding a literal backslash-n or backslash-t read back as newline / tab (Cytoscape's escapes). */
+  BACKSLASH_ESCAPE: "W_XGMML_BACKSLASH_ESCAPE",
+  /** A position that cannot be written as it is: another shape, a non-finite coordinate, a z read back in the z column. */
+  POSITION: "W_XGMML_POSITION",
+  /** Nodes whose parent chain never reaches a root are written at the top level. */
+  PARENT_CYCLE: "W_XGMML_PARENT_CYCLE",
+  /**
+   * An attribute with a role (for example, the label) is written where the format keeps that role, and reads back under the
+   * name the format's importer gives it.
+   */
+  COLUMN_NAME_CHANGED: COLUMN_RENAMED_LOSS_CODE,
+  /**
+   * An attribute without a role is written where the format keeps a role (for example, a `name` column as the label), and
+   * reads back with that role.
+   */
+  ROLE_ASSUMED: ROLE_ASSUMED_CODE,
+  /** An attribute named `weight` without the weight role reads back as the edge weight. */
+  WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,
+  /**
+   * A text attribute reads back as a dictionary attribute, or the reverse, because the importer chooses by how often
+   * its values repeat. The values are the same.
+   */
+  STORAGE_CLASS_CHANGED: STORAGE_CLASS_CODE,
+  /** Edge labels shaped `a (i) b` read back with an `interaction` column (Cytoscape's label alias). */
+  INTERACTION_FROM_LABEL: "W_XGMML_INTERACTION_FROM_LABEL"
+});
+function graphicsColumnOf(table) {
+  for (const col of table) {
+    const { origin } = col.meta;
+    if (col.dtype === "json" && origin?.type === "graphics" && origin.namespace === XGMML_ORIGIN_NAMESPACE) {
+      return col.meta.name;
+    }
+  }
+  return table.get(GRAPHICS_COLUMN)?.dtype === "json" ? GRAPHICS_COLUMN : null;
+}
+function graphicsBypasses(table, target, n, notes) {
+  const out = new Array(n).fill(null);
+  const name = graphicsColumnOf(table);
+  if (name === null) {
+    return out;
+  }
+  for (let i = 0; i < n; i++) {
+    const g = plainCell(table.value(name, i));
+    if (g === null || typeof g !== "object" || Array.isArray(g)) {
+      continue;
+    }
+    const map = normalizeVisualProperties(target, g, notes);
+    const locked = Object.hasOwn(g, "lockedVisualProperties") ? g.lockedVisualProperties : void 0;
+    if (locked !== null && typeof locked === "object") {
+      for (const [k, v] of normalizeVisualProperties(target, locked, notes)) {
+        map.set(k, v);
+      }
+    }
+    out[i] = map.size > 0 ? map : null;
+  }
+  return out;
+}
+function readXgmmlStyles(snapshot, context, settings) {
+  const notes = new StyleNotes();
+  const out = { node: { values: {} }, edge: { values: {} } };
+  for (const target of ["node", "edge"]) {
+    context.signal?.throwIfAborted();
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const maps = graphicsBypasses(table, target, n, notes);
+    const values = maps.some((m) => m !== null) ? resolveCytoscapeBypasses(target, maps, { notes, budget: context.budget }) : {};
+    hiddenToVisible(table, settings.hiddenColumn ?? null, n, values);
+    exactFromBlock(snapshot, target, values);
+    out[target] = { values: nonEmpty(values) };
+  }
+  return {
+    canonical: true,
+    dialect: "cytoscape",
+    tool: settings.tool,
+    units: "px",
+    node: out.node,
+    edge: out.edge,
+    graph: graphStyleOf(snapshot, notes),
+    notes: notes.list()
+  };
+}
+function readXgmmlFileStyles(snapshot, context) {
+  return readXgmmlStyles(snapshot, context, { tool: "cytoscape" });
+}
+function exactFromBlock(snapshot, target, values, dialect = "desktop") {
+  const text = snapshot.graph.has(STYLE_BLOCK_NAME) ? plainCell(snapshot.graph.value(STYLE_BLOCK_NAME, 0)) : null;
+  if (typeof text !== "string") {
+    return;
+  }
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "xgmml") : null;
+  if (ex === null) {
+    return;
+  }
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const want = /* @__PURE__ */ new Map();
+  const exact = (property) => {
+    let held = want.get(property);
+    if (held === void 0) {
+      held = resolveStyles(ex, target, property, snapshot);
+      want.set(property, held);
+    }
+    return held;
+  };
+  const written = Array.from(
+    { length: n },
+    (_v, i) => cytoscapeElementProperties(
+      target,
+      (property) => exact(property)[i] ?? null,
+      dialect,
+      () => void 0
+    )
+  );
+  const readBack = resolveCytoscapeBypasses(target, written, { notes: new StyleNotes() });
+  for (const [property, native] of Object.entries(values)) {
+    const back = readBack[property];
+    if (native !== void 0 && back !== void 0) {
+      values[property] = withBlockValues(native, back, exact(property));
+    }
+  }
+}
+function withBlockValues(native, back, w) {
+  let changed = null;
+  for (let i = 0; i < native.length; i++) {
+    if (w[i] !== null && native[i] !== w[i] && native[i] === back[i]) {
+      changed ??= [...native];
+      changed[i] = w[i];
+    }
+  }
+  return changed ?? native;
+}
+function hiddenToVisible(table, column, n, values) {
+  if (column === null || !table.has(column)) {
+    return;
+  }
+  let visible = null;
+  for (let i = 0; i < n; i++) {
+    if (plainCell(table.value(column, i)) === true) {
+      visible ??= values.visible === void 0 ? new Array(n).fill(null) : [...values.visible];
+      visible[i] = false;
+    }
+  }
+  if (visible !== null) {
+    values.visible = visible;
+  }
+}
+function nonEmpty(values) {
+  const out = {};
+  for (const [p, col] of Object.entries(values)) {
+    if (col?.some((v) => v !== null) === true) {
+      out[p] = col;
+    }
+  }
+  return out;
+}
+function graphStyleOf(snapshot, notes) {
+  const name = graphicsColumnOf(snapshot.graph);
+  const g = name === null ? null : plainCell(snapshot.graph.value(name, 0));
+  if (g === null || typeof g !== "object") {
+    return {};
+  }
+  const style = emptyCytoscapeStyle();
+  for (const [k, v] of normalizeVisualProperties("node", g, notes)) {
+    if (k.startsWith("NETWORK_")) {
+      style.network.defaults.set(k, v);
+    }
+  }
+  const background = cytoscapeBackground(style, notes);
+  return background === null ? {} : { background };
+}
+const XGMML_STYLE_CAPABILITIES = Object.freeze({
+  node: Object.freeze(cytoscapeWritableProperties("node", "desktop")),
+  edge: Object.freeze(cytoscapeWritableProperties("edge", "desktop")),
+  graph: Object.freeze(["background"]),
+  block: "attributes"
+});
+const XML_ATTRIBUTES = {
+  node: [
+    ["NODE_SHAPE", "type"],
+    ["NODE_HEIGHT", "h"],
+    ["NODE_WIDTH", "w"],
+    ["NODE_FILL_COLOR", "fill"],
+    ["NODE_BORDER_WIDTH", "width"],
+    ["NODE_BORDER_PAINT", "outline"]
+  ],
+  edge: [
+    ["EDGE_WIDTH", "width"],
+    ["EDGE_STROKE_UNSELECTED_PAINT", "fill"]
+  ]
+};
+function styledGraphics(target, styles, i, kept) {
+  const vps = cytoscapeElementProperties(
+    target,
+    (p) => styles.picture(target, p)[i] ?? null,
+    "desktop",
+    () => void 0
+  );
+  const out = {};
+  for (const [vp, attribute] of XML_ATTRIBUTES[target]) {
+    if (vps.has(vp)) {
+      out[attribute] = String(vps.get(vp));
+    }
+  }
+  for (const [k, v] of Object.entries(kept ?? {})) {
+    if (k === "Line" || /^[A-Z][A-Z_0-9]+$/.test(k) && !vps.has(k)) {
+      out[k] = v;
+    }
+  }
+  for (const [vp, v] of vps) {
+    out[vp] = String(v);
+  }
+  return Object.keys(out).length === 0 ? null : out;
+}
+function styledGraphicsNotes(styles, snapshot) {
+  const notes = new StyleNotes();
+  for (const target of ["node", "edge"]) {
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    for (let i = 0; i < n; i++) {
+      cytoscapeElementProperties(
+        target,
+        (p) => styles.picture(target, p)[i] ?? null,
+        "desktop",
+        (p) => {
+          notes.add(STYLE_ISSUE.APPROXIMATED, target, p, { element: i });
+        }
+      );
+    }
+  }
+  return notes.list().map(lossOf);
+}
+function styledGraphGraphics(styles, kept) {
+  const { background } = styles.rules.styles.graph;
+  const out = { ...kept };
+  if (background !== void 0) {
+    out.NETWORK_BACKGROUND_PAINT = background.toUpperCase();
+  }
+  return Object.keys(out).length === 0 ? null : out;
+}
+function blockOfAspect(elements) {
+  const first = elements?.[0];
+  if (first === null || typeof first !== "object" || !Object.hasOwn(first, "block")) {
+    return null;
+  }
+  const text = first.block;
+  return typeof text === "string" ? text : null;
+}
+function blockAspect(block) {
+  return [{ block }];
+}
+function snapshotBlock(snapshot) {
+  const column = snapshot.graph.get(STYLE_BLOCK_NAME);
+  const value = column?.isSet(0) ? column.value(0) : null;
+  return typeof value === "string" ? value : null;
+}
+function bypassesOf(table, n, namespace) {
+  const columns = [...table].filter((c) => c.meta.origin?.namespace === namespace);
+  const maps = new Array(n).fill(null);
+  for (let i = 0; i < n; i++) {
+    let m = null;
+    for (const c of columns) {
+      const v = plainCell(c.isSet(i) ? c.value(i) : null);
+      if (v !== null) {
+        m ??= /* @__PURE__ */ new Map();
+        const id = c.meta.origin?.id;
+        m.set(typeof id === "string" && id.length > 0 ? id : c.meta.name, v);
+      }
+    }
+    maps[i] = m;
+  }
+  return { maps, names: columns.map((c) => c.meta.name) };
+}
+function readDeclaredStyles(snapshot, context, style, namespace, notes, dialect = "desktop") {
+  const out = { node: { values: {} }, edge: { values: {} } };
+  const readFrom = { node: [], edge: [] };
+  for (const target of ["node", "edge"]) {
+    context.signal?.throwIfAborted();
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    for (const m of style[target].mappings.values()) {
+      if (!table.has(m.column)) {
+        notes.add(STYLE_ISSUE.MAPPING_COLUMN_MISSING, target, m.column, { sample: m.kind });
+      }
+    }
+    const { maps, names } = bypassesOf(table, n, namespace);
+    readFrom[target] = names;
+    const elements = {
+      count: n,
+      value: (column, i) => table.has(column) ? plainCell(table.value(column, i)) : null,
+      bypasses: maps
+    };
+    const values = resolveCytoscape(target, style, elements, { notes, budget: context.budget });
+    exactFromBlock(snapshot, target, values, dialect);
+    const { rules, columns } = cytoscapeRules(target, style, elements, { notes, budget: context.budget });
+    out[target] = { values: nonEmpty(values), rules, columns };
+  }
+  const background = cytoscapeBackground(style, notes);
+  return {
+    canonical: true,
+    dialect: "cytoscape",
+    tool: "cytoscape",
+    units: "px",
+    node: out.node,
+    edge: out.edge,
+    graph: background === null ? {} : { background },
+    notes: notes.list(),
+    readFrom
+  };
+}
+function readCxStyles(snapshot, context) {
+  const notes = new StyleNotes();
+  const kept = context.kept;
+  const style = cytoscapeStyleFromCx(kept?.entries ?? [], notes);
+  const otherViews = kept?.otherViews ?? 0;
+  if (otherViews > 0) {
+    notes.add(STYLE_ISSUE.OTHER_VIEWS, null, "cyVisualProperties", {
+      sample: `${otherViews} more`,
+      count: otherViews
+    });
+  }
+  return readDeclaredStyles(snapshot, context, style, "cx.bypass", notes);
+}
+function cytoscapeWriteCapabilities(dialect) {
+  return Object.freeze({
+    node: Object.freeze(cytoscapeWritableProperties("node", dialect)),
+    edge: Object.freeze(cytoscapeWritableProperties("edge", dialect)),
+    graph: Object.freeze(["background"]),
+    // graph-io adds the block as a graph attribute (the writer moves it into an aspect of its own) and the style
+    // values the rules read as element attributes
+    block: "attributes"
+  });
+}
+const CX_STYLE_CAPABILITIES = cytoscapeWriteCapabilities("desktop");
+function valuesDtype(col) {
+  const kinds = new Set(col.filter((v) => v !== null).map((v) => typeof v));
+  if (kinds.size === 1 && kinds.has("number")) {
+    return "f64";
+  }
+  return kinds.size === 1 && kinds.has("boolean") ? "bool" : "string";
+}
+function lossOf(n) {
+  return Object.freeze({
+    code: n.code,
+    message: n.message,
+    column: null,
+    count: n.params.count,
+    style: n.params.target === null || n.params.property === null || n.params.target === "graph" ? void 0 : Object.freeze({ target: n.params.target, property: n.params.property })
+  });
+}
+function cytoscapeStyledExport(snapshot, input, dialect) {
+  if (input === void 0) {
+    return null;
+  }
+  const notes = new StyleNotes();
+  const styled = emitCytoscapeStyle(input.rules, snapshot, { dialect, notes });
+  return { snapshot: withMappedColumns(snapshot, styled), styled, notes: notes.list().map(lossOf) };
+}
+function withMappedColumns(snapshot, styled) {
+  const missing = ["node", "edge"].flatMap(
+    (target) => [...styled.columns[target]].filter(([name]) => !(target === "node" ? snapshot.nodes : snapshot.edges).has(name)).map(([name, values]) => ({ target, name, values }))
+  );
+  if (missing.length === 0) {
+    return snapshot;
+  }
+  const out = snapshot.withColumns();
+  for (const { target, name, values } of missing) {
+    const dtype = valuesDtype(values);
+    const col = dtype === "string" ? values.map((v) => v === null ? null : String(v)) : values;
+    (target === "node" ? out.nodes : out.edges).set(name, col, { dtype });
+  }
+  return out;
+}
+export {
+  EXTENSIONS as A,
+  emitCytoscapeStyle as B,
+  CY_NAMESPACE as C,
+  lossOf as D,
+  EDGE_ID_COLUMN as E,
+  FORMAT as F,
+  GRAPHICS_COLUMN as G,
+  cytoscapeVizmapXml as H,
+  INTERACTION_COLUMN as I,
+  readXgmmlStyles as J,
+  cytoscapeBackground as K,
+  LABEL_COLUMN as L,
+  META_KEY as M,
+  NESTED_NETWORK_COLUMN as N,
+  emptyCytoscapeStyle as O,
+  POSITION_COLUMN as P,
+  graphicsBypasses as Q,
+  resolveCytoscape as R,
+  SUBGRAPH_COLUMN as S,
+  hiddenToVisible as T,
+  exactFromBlock as U,
+  cytoscapeRules as V,
+  nonEmpty as W,
+  XGMML_ISSUE as X,
+  typedKey as Y,
+  Z_COLUMN as Z,
+  XGMML_LOSS as a,
+  cytoscapeCx2Aspects as b,
+  cytoscapeStyledExport as c,
+  blockAspect as d,
+  styledGraphicsNotes as e,
+  XGMML_STYLE_CAPABILITIES as f,
+  XLINK_NAMESPACE as g,
+  XGMML_NAMESPACE as h,
+  styledGraphGraphics as i,
+  styledGraphics as j,
+  PARENT_COLUMN as k,
+  PARENTS_COLUMN as l,
+  NETWORK_POINTER_COLUMN as m,
+  NETWORKS_COLUMN as n,
+  XGMML_ORIGIN_NAMESPACE as o,
+  CYTOSCAPE_ORIGIN_NAMESPACE as p,
+  CX_STYLE_CAPABILITIES as q,
+  cytoscapeCxAspect as r,
+  snapshotBlock as s,
+  readCxStyles as t,
+  blockOfAspect as u,
+  cytoscapeWriteCapabilities as v,
+  cytoscapeStyleFromCx2 as w,
+  readDeclaredStyles as x,
+  readXgmmlFileStyles as y,
+  MIME_TYPES as z
+};
+//# sourceMappingURL=styles-_N-C8S-U.js.map