@graphty/graph-io 0.3.43 → 0.3.45

package/dist/chunks/emit-DZy6JgdA.js

@@ -0,0 +1,3456 @@
+import { a as STYLE_ISSUE, i as num6, l as canonEnum, W as CSS_COLORS, t as StyleNotes, d as canonicalFor, p as plainCell, Q as evalContinuous, R as numberOf, e as degreeValues, L as refSource, B as STYLE_PROPERTIES, O as resolveRules, P as matches } from "./block-CPCHkX42.js";
+const STYLE_WORK_BUDGET = 2e8;
+class StyleBudget {
+  #used = { node: 0, edge: 0 };
+  /**
+   * Creates a budget.
+   * @param limit - operations allowed per target; defaults to `STYLE_WORK_BUDGET`
+   */
+  constructor(limit = STYLE_WORK_BUDGET) {
+    this.limit = limit;
+  }
+  /**
+   * Spends operations for a target.
+   * @param target - nodes or edges
+   * @param operations - how many operations the work costs
+   * @returns true while the target has spent at most `limit` operations
+   */
+  spend(target, operations) {
+    this.#used[target] += operations;
+    return this.#used[target] <= this.limit;
+  }
+  /**
+   * Whether a target has spent more than `limit` operations.
+   * @param target - nodes or edges
+   * @returns true once the target's budget is exhausted
+   */
+  exhausted(target) {
+    return this.#used[target] > this.limit;
+  }
+  /**
+   * How many operations a target has spent.
+   * @param target - nodes or edges
+   * @returns the operations spent so far
+   */
+  used(target) {
+    return this.#used[target];
+  }
+}
+const CYJS_PROPERTY_DEFAULTS = /* @__PURE__ */ new Map([
+  ["background-color", "rgb(153,153,153)"],
+  ["background-opacity", "1"],
+  ["opacity", "1"],
+  ["border-color", "rgb(0,0,0)"],
+  ["border-width", "0px"],
+  ["border-style", "solid"],
+  ["shape", "ellipse"],
+  ["width", "30px"],
+  ["height", "30px"],
+  ["label", ""],
+  ["color", "rgb(0,0,0)"],
+  ["font-size", "16px"],
+  ["font-family", "Helvetica Neue, Helvetica, sans-serif"],
+  ["font-weight", "normal"],
+  ["font-style", "normal"],
+  ["visibility", "visible"],
+  ["display", "element"],
+  ["text-valign", "top"],
+  ["text-halign", "center"],
+  ["line-color", "rgb(153,153,153)"],
+  ["line-style", "solid"],
+  ["target-arrow-shape", "none"],
+  ["source-arrow-shape", "none"],
+  ["target-arrow-color", "rgb(153,153,153)"],
+  ["source-arrow-color", "rgb(153,153,153)"],
+  ["curve-style", "haystack"],
+  ["arrow-scale", "1"],
+  ["source-label", ""],
+  ["target-label", ""]
+]);
+const CYJS_DEFAULT_STYLESHEET = [
+  {
+    selector: ":parent",
+    style: {
+      shape: "rectangle",
+      "background-color": "rgb(238,238,238)",
+      "border-color": "rgb(204,204,204)",
+      "border-width": "1px"
+    }
+  },
+  { selector: "edge", style: { width: "3px" } },
+  { selector: ":loop", style: { "curve-style": "bezier" } },
+  { selector: "edge:compound", style: { "curve-style": "bezier" } },
+  {
+    selector: ":selected",
+    style: {
+      "background-color": "rgb(1,105,217)",
+      "line-color": "rgb(1,105,217)",
+      "source-arrow-color": "rgb(1,105,217)",
+      "target-arrow-color": "rgb(1,105,217)"
+    }
+  },
+  {
+    selector: ":parent:selected",
+    style: { "background-color": "rgb(204,225,249)", "border-color": "rgb(174,200,229)" }
+  }
+];
+const NODE_SHAPES = [
+  "rectangle",
+  "roundrectangle",
+  "round-rectangle",
+  "cutrectangle",
+  "cut-rectangle",
+  "bottomroundrectangle",
+  "bottom-round-rectangle",
+  "barrel",
+  "ellipse",
+  "triangle",
+  "round-triangle",
+  "square",
+  "pentagon",
+  "round-pentagon",
+  "hexagon",
+  "round-hexagon",
+  "concavehexagon",
+  "concave-hexagon",
+  "heptagon",
+  "round-heptagon",
+  "octagon",
+  "round-octagon",
+  "tag",
+  "round-tag",
+  "star",
+  "diamond",
+  "round-diamond",
+  "vee",
+  "rhomboid",
+  "right-rhomboid",
+  "polygon"
+];
+const ARROWS = [
+  "tee",
+  "triangle",
+  "triangle-tee",
+  "circle-triangle",
+  "triangle-cross",
+  "triangle-backcurve",
+  "vee",
+  "square",
+  "circle",
+  "diamond",
+  "chevron",
+  "none"
+];
+const FONT_WEIGHTS = [
+  "normal",
+  "bold",
+  "bolder",
+  "lighter",
+  "100",
+  "200",
+  "300",
+  "400",
+  "500",
+  "600",
+  "800",
+  "900",
+  100,
+  200,
+  300,
+  400,
+  500,
+  600,
+  700,
+  800,
+  900
+];
+const CURVES = [
+  "bezier",
+  "unbundled-bezier",
+  "haystack",
+  "segments",
+  "straight",
+  "straight-triangle",
+  "taxi",
+  "round-segments",
+  "round-taxi"
+];
+const STRAIGHT = /* @__PURE__ */ new Set([
+  "haystack",
+  "straight",
+  "straight-triangle",
+  "segments",
+  "taxi",
+  "round-segments",
+  "round-taxi"
+]);
+const LABEL = [
+  ["label", { property: "label", type: "text" }],
+  ["color", { property: "labelColor", type: "color" }],
+  ["font-size", { property: "labelSize", type: "size" }],
+  ["font-family", { property: "labelFont", type: "fontFamily" }],
+  ["font-weight", { property: "labelWeight", type: "fontWeight" }],
+  ["font-style", { property: "labelItalic", type: "enum", enums: ["italic", "normal", "oblique"] }],
+  ["visibility", { property: "_visibility", type: "enum", enums: ["hidden", "visible"] }],
+  ["display", { property: "_display", type: "enum", enums: ["element", "none"] }],
+  ["opacity", { property: "opacity", type: "zeroOne" }]
+];
+const CYJS_NODE_PROPERTIES = new Map([
+  ["background-color", { property: "fill", type: "color" }],
+  ["background-opacity", { property: "fillOpacity", type: "zeroOne" }],
+  ["border-color", { property: "borderColor", type: "color" }],
+  ["border-width", { property: "borderWidth", type: "size" }],
+  ["border-style", { property: "borderStyle", type: "enum", enums: ["solid", "dotted", "dashed", "double"] }],
+  ["shape", { property: "shape", type: "enum", enums: NODE_SHAPES }],
+  ["corner-radius", { property: "cornerRadius", type: "size" }],
+  ["width", { property: "width", type: "nodeSize" }],
+  ["height", { property: "height", type: "nodeSize" }],
+  [
+    "text-valign",
+    { property: "_valign", type: "enum", enums: ["top", "top-inside", "center", "bottom", "bottom-inside"] }
+  ],
+  [
+    "text-halign",
+    { property: "_halign", type: "enum", enums: ["left", "left-inside", "center", "right", "right-inside"] }
+  ],
+  ...LABEL
+]);
+const CYJS_EDGE_PROPERTIES = new Map([
+  ["line-color", { property: "color", type: "color" }],
+  ["width", { property: "width", type: "nodeSize" }],
+  ["line-style", { property: "lineStyle", type: "enum", enums: ["solid", "dotted", "dashed"] }],
+  ["target-arrow-shape", { property: "targetArrow", type: "enum", enums: ARROWS }],
+  ["source-arrow-shape", { property: "sourceArrow", type: "enum", enums: ARROWS }],
+  ["target-arrow-color", { property: "targetArrowColor", type: "color" }],
+  ["source-arrow-color", { property: "sourceArrowColor", type: "color" }],
+  ["curve-style", { property: "curved", type: "enum", enums: CURVES }],
+  ["arrow-scale", { property: "arrowSize", type: "positive" }],
+  ["source-label", { property: "sourceLabel", type: "text" }],
+  ["target-label", { property: "targetLabel", type: "text" }],
+  ...LABEL
+]);
+function cyjsProperties(target) {
+  return target === "node" ? CYJS_NODE_PROPERTIES : CYJS_EDGE_PROPERTIES;
+}
+function cyjsPropertyName(name) {
+  const dashed = name.replaceAll(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+  return dashed === "content" ? "label" : dashed;
+}
+const CYJS_THROWS = "throws";
+const NUM = String.raw`[-+]?(?:(?:\d+|\d*\.\d+)(?:[Ee][+-]?\d+)?)`;
+const NUMBER_UNITS = new RegExp(`^(${NUM})(px|em)?$`);
+const NUMBER_ONLY = new RegExp(String.raw`^\s*${NUM}\s*$`);
+const RGBA = new RegExp(
+  String.raw`^rgb[a]?\((${NUM}[%]?)\s*,\s*(${NUM}[%]?)\s*,\s*(${NUM}[%]?)(?:\s*,\s*(${NUM}))?\)$`
+);
+const HSLA = new RegExp(String.raw`^hsl[a]?\((${NUM})\s*,\s*(${NUM}[%])\s*,\s*(${NUM}[%])(?:\s*,\s*(${NUM}))?\)$`);
+const MAP_ARG = new RegExp(
+  String.raw`^(?:${NUM}|\w+|rgb[a]?\((?:${NUM}[%]?)\s*,\s*(?:${NUM}[%]?)\s*,\s*(?:${NUM}[%]?)(?:\s*,\s*(?:${NUM}))?\)` + String.raw`|hsl[a]?\((?:${NUM})\s*,\s*(?:${NUM}[%])\s*,\s*(?:${NUM}[%])(?:\s*,\s*(?:${NUM}))?\)` + String.raw`|\#[0-9a-fA-F]{3}|\#[0-9a-fA-F]{6})$`
+);
+const FIELD = /^[\w.]+$/;
+const WORD_FONT = /^[\w\- "]$/;
+function namedColor(name) {
+  if (name === "transparent") {
+    return "#000000";
+  }
+  return name === "rebeccapurple" ? void 0 : CSS_COLORS.get(name);
+}
+function colorTuple(value) {
+  const named = namedColor(value.toLowerCase());
+  if (named !== void 0) {
+    return [
+      Number.parseInt(named.slice(1, 3), 16),
+      Number.parseInt(named.slice(3, 5), 16),
+      Number.parseInt(named.slice(5, 7), 16)
+    ];
+  }
+  if ((value.length === 4 || value.length === 7) && value.startsWith("#")) {
+    const short = value.length === 4;
+    const pair = (k) => Number.parseInt(short ? value[k] + value[k] : value.slice(2 * k - 1, 2 * k + 1), 16);
+    return [pair(1), pair(2), pair(3)];
+  }
+  const m = RGBA.exec(value);
+  return m === null ? hslTuple(value) : rgbaTuple(m);
+}
+function rgbaTuple(m) {
+  const pct = [1, 2, 3].map((k) => m[k].endsWith("%"));
+  if (pct.some(Boolean) && !pct.every(Boolean)) {
+    return null;
+  }
+  const channels = [1, 2, 3].map((k) => {
+    const c = Number.parseFloat(m[k]);
+    return pct[k - 1] ? c / 100 * 255 : c;
+  });
+  if (channels.some((c) => c < 0 || c > 255)) {
+    return null;
+  }
+  const alpha = m.at(4);
+  if (alpha !== void 0 && (Number.parseFloat(alpha) < 0 || Number.parseFloat(alpha) > 1)) {
+    return null;
+  }
+  return [Math.floor(channels[0]), Math.floor(channels[1]), Math.floor(channels[2])];
+}
+function hslTuple(value) {
+  const m = HSLA.exec(value);
+  if (m === null) {
+    return null;
+  }
+  let h = Number.parseInt(m[1], 10);
+  if (h < 0) {
+    h = (360 - -1 * h % 360) % 360;
+  } else if (h > 360) {
+    h = h % 360;
+  }
+  h /= 360;
+  const s = Number.parseFloat(m[2]);
+  const l = Number.parseFloat(m[3]);
+  if (s < 0 || s > 100 || l < 0 || l > 100) {
+    return null;
+  }
+  const alpha = m.at(4);
+  if (alpha !== void 0 && (Number.parseFloat(alpha) < 0 || Number.parseFloat(alpha) > 1)) {
+    return null;
+  }
+  const sn = s / 100;
+  const ln = l / 100;
+  if (sn === 0) {
+    const g = Math.round(ln * 255);
+    return [g, g, g];
+  }
+  const hue = (p2, q2, t0) => {
+    let t = t0;
+    if (t < 0) {
+      t += 1;
+    }
+    if (t > 1) {
+      t -= 1;
+    }
+    if (t < 1 / 6) {
+      return p2 + (q2 - p2) * 6 * t;
+    }
+    if (t < 1 / 2) {
+      return q2;
+    }
+    if (t < 2 / 3) {
+      return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+    }
+    return p2;
+  };
+  const q = ln < 0.5 ? ln * (1 + sn) : ln + sn - ln * sn;
+  const p = 2 * ln - q;
+  return [
+    Math.round(255 * hue(p, q, h + 1 / 3)),
+    Math.round(255 * hue(p, q, h)),
+    Math.round(255 * hue(p, q, h - 1 / 3))
+  ];
+}
+function isFontFamily(value) {
+  const parts = value.split(",");
+  if (parts.length === 1) {
+    return parts[0].length > 0 && allOf(parts[0], isFontChar);
+  }
+  return firstFontPart(parts[0]) && lastFontPart(parts.at(-1) ?? "") && parts.slice(1, -1).every((part) => middleFontPart(part));
+}
+function isFontChar(c) {
+  return WORD_FONT.test(c);
+}
+function isSpace$1(c) {
+  return /\s/.test(c);
+}
+function allOf(text, test) {
+  return Array.from(text).every(test);
+}
+function firstFontPart(part) {
+  let a = 0;
+  while (a < part.length && isFontChar(part[a])) {
+    a++;
+  }
+  return a > 0 && allOf(part.slice(a), isSpace$1);
+}
+function lastFontPart(part) {
+  let b = part.length;
+  while (b > 0 && isFontChar(part[b - 1])) {
+    b--;
+  }
+  return b < part.length && allOf(part.slice(0, b), isSpace$1);
+}
+function middleFontPart(part) {
+  let a = 0;
+  let b = part.length;
+  while (a < b && isSpace$1(part[a])) {
+    a++;
+  }
+  while (b > a && isSpace$1(part[b - 1])) {
+    b--;
+  }
+  return a === b ? part.includes(" ") : allOf(part.slice(a, b), isFontChar);
+}
+function parseFlat(spec, raw, rendered = false) {
+  const value = typeof raw === "string" ? raw.trim() : raw;
+  switch (spec.type) {
+    case "color":
+      return parseColorValue(value);
+    case "zeroOne":
+    case "positive": {
+      const x = Number.parseFloat(String(value));
+      const ok = spec.type === "zeroOne" ? x >= 0 && x <= 1 : x > 0;
+      return ok ? { kind: "number", value: x, units: null, str: String(x) } : null;
+    }
+    case "size":
+    case "nodeSize":
+      return parseSizeValue(spec, value, raw);
+    case "text":
+      return { kind: "word", value: String(value), str: String(value) };
+    case "fontFamily": {
+      const text = String(value);
+      return isFontFamily(text) ? { kind: "word", value: text, str: text } : null;
+    }
+    case "fontWeight":
+    case "enum": {
+      const enums = spec.type === "fontWeight" ? FONT_WEIGHTS : spec.enums ?? [];
+      const e = enums.find((x) => x === value || rendered && String(x) === value);
+      return e === void 0 ? null : { kind: "word", value: e, str: String(e) };
+    }
+    default:
+      return null;
+  }
+}
+function parseColorValue(value) {
+  if (Array.isArray(value)) {
+    const [r, g, b] = value;
+    const t2 = [Number(r), Number(g), Number(b)];
+    return { kind: "color", rgb: t2, str: `rgb(${t2[0]},${t2[1]},${t2[2]})` };
+  }
+  if (typeof value !== "string") {
+    return CYJS_THROWS;
+  }
+  const t = colorTuple(value);
+  return t === null ? null : { kind: "color", rgb: t, str: `rgb(${t[0]},${t[1]},${t[2]})` };
+}
+function parseSizeValue(spec, value, raw) {
+  let units = "px";
+  let text = value;
+  if (typeof value === "string") {
+    const m = NUMBER_UNITS.exec(value);
+    if (m === null) {
+      units = null;
+    } else {
+      text = m[1];
+      units = m.at(2) === "em" ? "em" : "px";
+    }
+  }
+  const x = Number.parseFloat(String(text));
+  if (Number.isNaN(x)) {
+    return spec.type === "nodeSize" && raw === "label" ? { kind: "word", value: "label", str: "label" } : null;
+  }
+  return x < 0 ? null : { kind: "number", value: x, units, str: `${String(x)}${units ?? ""}` };
+}
+function splitArgs(inner) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (c === "(") {
+      depth++;
+    } else if (c === ")") {
+      depth--;
+    } else if (c === "," && depth === 0) {
+      out.push(inner.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(inner.slice(start));
+  return out;
+}
+function callArgs(value, name) {
+  if (!value.startsWith(name) || !value.endsWith(")")) {
+    return null;
+  }
+  let i = name.length;
+  while (i < value.length && /\s/.test(value[i])) {
+    i++;
+  }
+  return value[i] === "(" ? value.slice(i + 1, -1) : null;
+}
+function parseCyjsValue(spec, raw, mode) {
+  if (raw === void 0) {
+    return null;
+  }
+  if (typeof raw === "function") {
+    return mode === "flat" ? null : { kind: "fn" };
+  }
+  const value = typeof raw === "string" ? raw.trim() : raw;
+  if (mode !== "flat" && typeof value === "string" && value.length >= 7 && value[1] === "a") {
+    const mapper = parseMapper(spec, value, mode);
+    if (mapper !== void 0) {
+      return mapper;
+    }
+  }
+  return parseFlat(spec, raw);
+}
+function parseMapper(spec, value, mode) {
+  if (value.startsWith("d")) {
+    const field = callArgs(value, "data")?.trim();
+    if (field === void 0 || !FIELD.test(field)) {
+      return void 0;
+    }
+    return mode === "bypass" ? null : { kind: "data", field };
+  }
+  if (!value.startsWith("m") || value.length < 10) {
+    return void 0;
+  }
+  return parseMapData(spec, value, mode);
+}
+function parseMapData(spec, value, mode) {
+  const inner = callArgs(value, "mapData");
+  if (inner === null) {
+    return void 0;
+  }
+  const args = splitArgs(inner);
+  if (!isMapDataArgs(args)) {
+    return void 0;
+  }
+  if (mode === "bypass") {
+    return null;
+  }
+  const numeric = spec.type === "zeroOne" || spec.type === "positive" || spec.type === "size" || spec.type === "nodeSize";
+  if (spec.type !== "color" && !numeric) {
+    return null;
+  }
+  const min = parseFlat(spec, args[3].trim());
+  const max = parseFlat(spec, args[4].trim());
+  if (min === null || max === null || min === CYJS_THROWS || max === CYJS_THROWS) {
+    return null;
+  }
+  if (min.str === max.str || min.kind === "number" && max.kind === "number" && pfValue(min) === pfValue(max)) {
+    const constant = parseFlat(spec, min.str);
+    return constant === CYJS_THROWS ? null : constant;
+  }
+  return {
+    kind: "mapData",
+    field: args[0].trim(),
+    fieldMin: Number.parseFloat(args[1]),
+    fieldMax: Number.parseFloat(args[2]),
+    min,
+    max
+  };
+}
+function isMapDataArgs(args) {
+  return args.length === 5 && /^[\w.]+\s*$/.test(args[0]) && NUMBER_ONLY.test(args[1]) && NUMBER_ONLY.test(args[2]) && MAP_ARG.test(args[3].trim()) && MAP_ARG.test(args[4].replace(/^\s+/, ""));
+}
+function pfValue(v) {
+  return v.value;
+}
+function mapperField(data, field) {
+  let v = data;
+  for (const step of field.split(".")) {
+    if (!v) {
+      break;
+    }
+    v = v[step];
+  }
+  return v;
+}
+function applyCyjsMapper(spec, m, data) {
+  const v = mapperField(data, m.field);
+  if (v === null || v === void 0) {
+    return null;
+  }
+  if (m.kind === "data") {
+    return parseFlat(spec, v);
+  }
+  if (typeof v !== "number" || Number.isNaN(v)) {
+    return null;
+  }
+  const width = m.fieldMax - m.fieldMin;
+  const p = Math.min(1, Math.max(0, width === 0 ? 0 : (v - m.fieldMin) / width));
+  const { min, max } = m;
+  if (min.kind === "color" && max.kind === "color") {
+    const c = [0, 1, 2].map((k) => Math.round(min.rgb[k] + (max.rgb[k] - min.rgb[k]) * p));
+    return { kind: "color", rgb: c, str: `rgb(${c[0]}, ${c[1]}, ${c[2]})` };
+  }
+  if (min.kind === "number" && max.kind === "number") {
+    return parseFlat(spec, min.value + (max.value - min.value) * p);
+  }
+  return null;
+}
+function cyjsNeutral(spec, v, site) {
+  switch (v.kind) {
+    case "color": {
+      if (v.rgb.some((c) => !Number.isFinite(c) || c < 0 || c > 255)) {
+        site.notes.add(STYLE_ISSUE.BAD_VALUE, site.target, site.property, {
+          sample: v.str,
+          element: site.element
+        });
+        return void 0;
+      }
+      return `#${v.rgb.map((c) => Math.round(c).toString(16).padStart(2, "0")).join("")}`;
+    }
+    case "number":
+      if (v.units === "em") {
+        site.notes.add(STYLE_ISSUE.BAD_VALUE, site.target, site.property, {
+          sample: v.str,
+          element: site.element
+        });
+        return void 0;
+      }
+      return num6(v.value);
+  }
+  const word = v.value;
+  switch (spec.property) {
+    case "width":
+    case "height":
+      site.notes.add(STYLE_ISSUE.BAD_VALUE, site.target, site.property, { sample: v.str, element: site.element });
+      return void 0;
+    case "label":
+    case "sourceLabel":
+    case "targetLabel":
+    case "labelFont":
+      return String(word);
+    case "labelItalic":
+      return word === "italic" || word === "oblique";
+    case "curved":
+      return !STRAIGHT.has(String(word));
+    case "shape":
+      return canonEnum("shape", String(word), "cytoscape-js", site) ?? void 0;
+    case "borderStyle":
+      return canonEnum("borderStyle", String(word), "cytoscape-js", site) ?? void 0;
+    case "lineStyle":
+      return canonEnum("lineStyle", String(word), "cytoscape-js", site) ?? void 0;
+    case "sourceArrow":
+    case "targetArrow":
+      return canonEnum("arrow", String(word), "cytoscape-js", site) ?? void 0;
+    case "labelWeight":
+      return canonEnum("weight", String(word), "cytoscape-js", site) ?? void 0;
+    default:
+      return word;
+  }
+}
+function cyjsRendered(target, name, str, site) {
+  const spec = cyjsProperties(target).get(cyjsPropertyName(name));
+  if (spec === void 0 || typeof str !== "string") {
+    return null;
+  }
+  const v = parseFlat(spec, str, true);
+  if (v === null || v === CYJS_THROWS) {
+    return null;
+  }
+  return cyjsNeutral(spec, v, site);
+}
+const CYJS_STATES = /* @__PURE__ */ new Set([
+  "selected",
+  "unselected",
+  "selectable",
+  "unselectable",
+  "locked",
+  "unlocked",
+  "visible",
+  "hidden",
+  "transparent",
+  "grabbed",
+  "free",
+  "removed",
+  "inside",
+  "grabbable",
+  "ungrabbable",
+  "animated",
+  "unanimated",
+  "parent",
+  "childless",
+  "child",
+  "orphan",
+  "nonorphan",
+  "compound",
+  "loop",
+  "simple",
+  "active",
+  "inactive",
+  "backgrounding",
+  "nonbackgrounding"
+]);
+const MAX_SELECTOR_LENGTH = 1 << 22;
+const META = new Set("!\"#$%&'()*+,./:;<=>?@[]^`{|}~");
+const BASE_OPS = ["!=", ">=", "<=", "*=", "^=", "$=", "=", ">", "<"];
+const META_FIELDS = ["indegree", "outdegree", "degree"];
+function isWord(c) {
+  if (c === void 0) {
+    return false;
+  }
+  const k = c.codePointAt(0) ?? 0;
+  return k >= 48 && k <= 57 || k >= 65 && k <= 90 || k >= 97 && k <= 122 || k === 95;
+}
+function isSpace(c) {
+  return c !== void 0 && /\s/.test(c);
+}
+class Cursor {
+  constructor(text) {
+    this.text = text;
+    this.pos = 0;
+  }
+  /**
+   * The end of a run of whitespace.
+   * @param from - where the run starts
+   * @returns the first position after it
+   */
+  spaceEnd(from) {
+    let i = from;
+    while (i < this.text.length && isSpace(this.text[i])) {
+      i++;
+    }
+    return i;
+  }
+  /**
+   * A name at `from`: word characters, `-`, and `.` when `dots` (Cytoscape.js's variable and id tokens), or a
+   * backslash before a meta character.
+   * @param from - the start
+   * @param dots - whether `.` belongs to the name
+   * @returns the raw name and its end, or null when there is none
+   */
+  name(from, dots) {
+    let i = from;
+    const t = this.text;
+    while (i < t.length) {
+      const c = t[i];
+      if (isWord(c) || c === "-" || dots && c === ".") {
+        i++;
+      } else if (c === "\\" && i + 1 < t.length && META.has(t[i + 1])) {
+        i += 2;
+      } else {
+        break;
+      }
+    }
+    return i > from ? { raw: t.slice(from, i), end: i } : null;
+  }
+  /**
+   * A number literal at `from` (Cytoscape.js's `[-+]?(\d+|\d*\.\d+)([Ee][+-]?\d+)?`). Both readings of the
+   * mantissa are returned, longest first, because the regular expression backtracks to the shorter one.
+   * @param from - the start
+   * @returns the possible ends, longest first
+   */
+  numberEnds(from) {
+    const t = this.text;
+    let i = from;
+    if (t[i] === "+" || t[i] === "-") {
+      i++;
+    }
+    const digits = (k) => {
+      let j = k;
+      while (j < t.length && t[j] >= "0" && t[j] <= "9") {
+        j++;
+      }
+      return j;
+    };
+    const mantissas = [];
+    const intEnd = digits(i);
+    if (intEnd > i) {
+      mantissas.push(intEnd);
+    }
+    if (t[intEnd] === ".") {
+      const fracEnd = digits(intEnd + 1);
+      if (fracEnd > intEnd + 1) {
+        mantissas.unshift(fracEnd);
+      }
+    }
+    const ends = [];
+    for (const m of mantissas) {
+      if (t[m] === "e" || t[m] === "E") {
+        let j = m + 1;
+        if (t[j] === "+" || t[j] === "-") {
+          j++;
+        }
+        const expEnd = digits(j);
+        if (expEnd > j) {
+          ends.push(expEnd);
+        }
+      }
+      ends.push(m);
+    }
+    return ends;
+  }
+  /**
+   * The possible ends of a quoted string at `from`: every quote that may close it, longest first (a quote after a
+   * backslash may also be escaped; the first quote with no backslash before it must close the string).
+   * @param from - the opening quote
+   * @returns the possible ends (after the closing quote), longest first
+   */
+  stringEnds(from) {
+    const t = this.text;
+    const q = t[from];
+    const ends = [];
+    for (let i = from + 1; i < t.length; i++) {
+      if (t[i] !== q) {
+        continue;
+      }
+      ends.push(i + 1);
+      if (t[i - 1] !== "\\" || i - 1 === from) {
+        break;
+      }
+    }
+    return ends.reverse();
+  }
+  /**
+   * A comparison operator at `from`: `!` and `@` flags, then a base operator (`!` before a base that holds `!`
+   * is not allowed).
+   * @param from - the start
+   * @returns the operator text and its end, or null
+   */
+  op(from) {
+    const t = this.text;
+    let i = from;
+    let prefix = "";
+    if (t[i] === "!" && t[i + 1] !== "=") {
+      prefix += "!";
+      i++;
+    }
+    if (t[i] === "@") {
+      prefix += "@";
+      i++;
+    }
+    for (const base of BASE_OPS) {
+      if (t.startsWith(base, i)) {
+        if (prefix.includes("!") && base === "!=") {
+          return null;
+        }
+        return { text: prefix + base, end: i + base.length };
+      }
+    }
+    return null;
+  }
+}
+function cleanMeta(raw) {
+  let out = "";
+  let i = 0;
+  while (i < raw.length) {
+    const escaped = raw[i] === "\\" && i + 1 < raw.length && META.has(raw[i + 1]);
+    out += escaped ? raw[i + 1] : raw[i];
+    i += escaped ? 2 : 1;
+  }
+  return out;
+}
+function splitOp(text) {
+  let op = text;
+  let not = false;
+  let ci = false;
+  if (op.includes("!")) {
+    op = op.replace("!", "");
+    not = true;
+  }
+  if (op.includes("@")) {
+    op = op.replace("@", "");
+    ci = true;
+  }
+  return { op, not, ci };
+}
+function replaceLast(b, q) {
+  b.queries[b.queries.length - 1] = q;
+}
+function lastQuery(b) {
+  return b.queries.at(-1);
+}
+function compoundFill(kind) {
+  return (b, query) => {
+    if (b.subject === null) {
+      const outer2 = { checks: [] };
+      const inner2 = { checks: [] };
+      const left = lastQuery(b);
+      outer2.checks.push(
+        kind === "child" ? { type: "child", parent: left, child: inner2 } : { type: "descendant", ancestor: left, descendant: inner2 }
+      );
+      replaceLast(b, outer2);
+      b.compoundCount++;
+      return inner2;
+    }
+    if (b.subject === query) {
+      const compound = { checks: [] };
+      const left = lastQuery(b);
+      const right = { checks: [] };
+      const subject = { checks: query.checks };
+      const inner2 = { checks: [] };
+      const outer2 = { checks: [{ type: "true" }] };
+      query.checks = [{ type: "true" }];
+      right.checks.push(
+        kind === "child" ? { type: "parent", parent: outer2, child: inner2 } : { type: "ancestor", ancestor: outer2, descendant: inner2 }
+      );
+      compound.checks.push({ type: "split", left, right, subject });
+      replaceLast(b, compound);
+      b.subject = subject;
+      b.compoundCount++;
+      return inner2;
+    }
+    const outer = { checks: query.checks };
+    const inner = { checks: [] };
+    query.checks = [
+      kind === "child" ? { type: "parent", parent: outer, child: inner } : { type: "ancestor", ancestor: outer, descendant: inner }
+    ];
+    b.compoundCount++;
+    return inner;
+  };
+}
+function nextToken(c) {
+  const ch = c.text[c.pos];
+  return groupToken(c) ?? (ch === ":" ? stateToken(c) : null) ?? (ch === "#" || ch === "." ? nameToken(c, ch) : null) ?? (ch === "[" ? dataToken(c, c.pos) : null) ?? separatorToken(c) ?? (ch === "$" ? subjectToken(c) : null);
+}
+function checkToken(end, check) {
+  return {
+    end,
+    fill: (_b, q) => {
+      q.checks.push(check);
+      return null;
+    }
+  };
+}
+function groupToken(c) {
+  const i = c.pos;
+  for (const [g, value] of [
+    ["node", "nodes"],
+    ["edge", "edges"],
+    ["*", "*"]
+  ]) {
+    if (c.text.startsWith(g, i)) {
+      return checkToken(i + g.length, { type: "group", value });
+    }
+  }
+  return null;
+}
+function stateToken(c) {
+  const i = c.pos;
+  let best = null;
+  for (const s of CYJS_STATES) {
+    if (c.text.startsWith(s, i + 1) && (best === null || s.length > best.length)) {
+      best = s;
+    }
+  }
+  return best === null ? null : checkToken(i + 1 + best.length, { type: "state", value: best });
+}
+function nameToken(c, ch) {
+  const n = c.name(c.pos + 1, ch === "#");
+  if (n === null) {
+    return null;
+  }
+  return checkToken(n.end, { type: ch === "#" ? "id" : "class", value: cleanMeta(n.raw) });
+}
+function separatorToken(c) {
+  const t = c.text;
+  const i = c.pos;
+  const ws = c.spaceEnd(i);
+  if (t[ws] === ",") {
+    return { end: c.spaceEnd(ws + 1), fill: nextQuery };
+  }
+  if (ws === i) {
+    return null;
+  }
+  for (const [sep, kind] of [
+    ["->", "directed"],
+    ["<->", "undirected"],
+    [">", "child"]
+  ]) {
+    const after = t.startsWith(sep, ws) ? c.spaceEnd(ws + sep.length) : -1;
+    if (after > ws + sep.length) {
+      return { end: after, fill: kind === "child" ? compoundFill("child") : edgeFill(kind) };
+    }
+  }
+  return { end: ws, fill: compoundFill("descendant") };
+}
+function nextQuery(b) {
+  b.counts.push({ edgeCount: b.edgeCount, compoundCount: b.compoundCount, subject: b.subject });
+  b.subject = null;
+  b.edgeCount = 0;
+  b.compoundCount = 0;
+  const next = { checks: [] };
+  b.queries.push(next);
+  return next;
+}
+function subjectToken(c) {
+  return {
+    end: c.pos + 1,
+    fill: (b, q) => {
+      if (b.subject !== null && b.subject !== q) {
+        return false;
+      }
+      b.subject = q;
+      const top = lastQuery(b);
+      const first = top.checks.at(0);
+      if (first?.type === "directedEdge") {
+        top.checks[0] = { type: "nodeTarget", source: first.source, target: first.target };
+      } else if (first?.type === "undirectedEdge") {
+        top.checks[0] = { type: "nodeNeighbor", node: first.nodes[1], neighbor: first.nodes[0] };
+      }
+      return null;
+    }
+  };
+}
+function edgeFill(kind) {
+  return (b, query) => {
+    const target = { checks: [] };
+    const outer = { checks: [] };
+    if (b.subject === null) {
+      outer.checks.push(
+        kind === "directed" ? { type: "directedEdge", source: query, target } : { type: "undirectedEdge", nodes: [query, target] }
+      );
+      replaceLast(b, outer);
+      b.edgeCount++;
+      return target;
+    }
+    if (kind === "directed") {
+      outer.checks.push({ type: "nodeSource", source: query, target });
+      replaceLast(b, outer);
+      b.edgeCount++;
+      return target;
+    }
+    outer.checks.push({ type: "nodeNeighbor", node: query, neighbor: target });
+    replaceLast(b, outer);
+    return target;
+  };
+}
+function dataToken(c, i) {
+  const inner = c.spaceEnd(i + 1);
+  return compareToken(c, inner) ?? boolToken(c, inner) ?? (c.text[i + 1] === "[" ? metaToken(c, i) : null);
+}
+function compareToken(c, inner) {
+  const t = c.text;
+  const v = c.name(inner, true);
+  if (v === null) {
+    return null;
+  }
+  const field = cleanMeta(v.raw);
+  const afterName = c.spaceEnd(v.end);
+  if (t[afterName] === "]") {
+    return checkToken(afterName + 1, { type: "exist", field });
+  }
+  const op = c.op(afterName);
+  if (op === null) {
+    return null;
+  }
+  const at = c.spaceEnd(op.end);
+  const quoted = t[at] === '"' || t[at] === "'";
+  const end = (quoted ? c.stringEnds(at) : c.numberEnds(at)).find((x) => t[c.spaceEnd(x)] === "]");
+  if (end === void 0) {
+    return null;
+  }
+  const literal2 = t.slice(at, end);
+  const value = quoted ? literal2.slice(1, -1) : Number.parseFloat(literal2);
+  const { op: base, not, ci } = splitOp(op.text);
+  return checkToken(c.spaceEnd(end) + 1, { type: "compare", field, op: base, not, ci, value });
+}
+function boolToken(c, inner) {
+  const t = c.text;
+  const flag = t[inner];
+  if (flag !== "?" && flag !== "!" && flag !== "^") {
+    return null;
+  }
+  const n = c.name(c.spaceEnd(inner + 1), true);
+  const close = n === null ? -1 : c.spaceEnd(n.end);
+  if (n === null || t[close] !== "]") {
+    return null;
+  }
+  return checkToken(close + 1, { type: "bool", field: cleanMeta(n.raw), op: flag });
+}
+function metaToken(c, i) {
+  const t = c.text;
+  const at = c.spaceEnd(i + 2);
+  const field = META_FIELDS.find((f) => t.startsWith(f, at));
+  const op = field === void 0 ? null : c.op(c.spaceEnd(at + field.length));
+  if (field === void 0 || op === null) {
+    return null;
+  }
+  const numAt = c.spaceEnd(op.end);
+  const end = c.numberEnds(numAt).find((x) => {
+    const close = c.spaceEnd(x);
+    return t[close] === "]" && t[close + 1] === "]";
+  });
+  if (end === void 0) {
+    return null;
+  }
+  const value = Number.parseFloat(t.slice(numAt, end));
+  const { op: base, not, ci } = splitOp(op.text);
+  return checkToken(c.spaceEnd(end) + 2, { type: "meta", field, op: base, not, ci, value });
+}
+function isBlank(text) {
+  return /^\s*$/.test(text.length > 1024 ? text.slice(0, 1024) : text) && text.trim() === "";
+}
+function parseCyjsSelector(text) {
+  if (typeof text !== "string" || isBlank(text)) {
+    return { queries: [], invalid: false };
+  }
+  if (text.length > MAX_SELECTOR_LENGTH) {
+    return { queries: [], invalid: true };
+  }
+  const c = new Cursor(text);
+  const first = { checks: [] };
+  const b = { queries: [first], subject: null, edgeCount: 0, compoundCount: 0, counts: [] };
+  let current = first;
+  c.pos = c.spaceEnd(0);
+  for (; ; ) {
+    const tok = nextToken(c);
+    if (tok === null) {
+      return { queries: b.queries, invalid: true };
+    }
+    const next = tok.fill(b, current);
+    if (next === false) {
+      return { queries: b.queries, invalid: true };
+    }
+    if (next !== null) {
+      current = next;
+    }
+    c.pos = tok.end;
+    if (c.spaceEnd(c.pos) >= text.length) {
+      break;
+    }
+  }
+  b.counts.push({ edgeCount: b.edgeCount, compoundCount: b.compoundCount, subject: b.subject });
+  const invalid = b.counts.some((k) => k.compoundCount > 0 && k.edgeCount > 0 || k.edgeCount > 1);
+  return { queries: b.queries, invalid };
+}
+const LINE = /[\n\r\u2028\u2029]/;
+const SPACE = /\s/;
+function stripComments(text) {
+  let out = "";
+  let from = 0;
+  for (; ; ) {
+    const open = text.indexOf("/*", from);
+    if (open < 0) {
+      break;
+    }
+    const close = text.indexOf("*/", open + 3);
+    if (close < 0) {
+      break;
+    }
+    out += text.slice(from, open);
+    from = close + 2;
+  }
+  return out + text.slice(from);
+}
+function skipSpace(s, i) {
+  let j = i;
+  while (j < s.length && SPACE.test(s[j])) {
+    j++;
+  }
+  return j;
+}
+function trimEnd(s) {
+  let e = s.length;
+  while (e > 0 && SPACE.test(s[e - 1])) {
+    e--;
+  }
+  return s.slice(0, e);
+}
+function readProperty(block, from, next) {
+  const len = block.length;
+  const lead = next[from];
+  const colon = block.indexOf(":", lead + 1);
+  if (colon < 0) {
+    return null;
+  }
+  const name = trimEnd(block.slice(lead, colon));
+  if (name === "" || LINE.test(name)) {
+    return null;
+  }
+  const start = next[colon + 1];
+  for (let e = start + 1; e <= len; e++) {
+    if (LINE.test(block[e - 1])) {
+      break;
+    }
+    const nn = next[e];
+    if (nn >= len) {
+      return { name, value: block.slice(start, e), end: len };
+    }
+    if (block[nn] === ";") {
+      return { name, value: block.slice(start, e), end: nn + 1 };
+    }
+  }
+  if (start >= len) {
+    for (let i = colon + 1; i < len; i++) {
+      if (!LINE.test(block[i])) {
+        return { name, value: block[i], end: len };
+      }
+    }
+  }
+  return null;
+}
+function nextNonSpace(s) {
+  const next = new Int32Array(s.length + 1);
+  next[s.length] = s.length;
+  for (let i = s.length - 1; i >= 0; i--) {
+    next[i] = SPACE.test(s[i]) ? next[i + 1] : i;
+  }
+  return next;
+}
+function parseCyjsStylesheetText(text) {
+  const s = stripComments(text);
+  const entries = [];
+  let pos = 0;
+  while (skipSpace(s, pos) < s.length) {
+    const lead = skipSpace(s, pos);
+    let open = s.indexOf("{", lead + 1);
+    let selStart = lead;
+    if (s[lead] === "{") {
+      if (lead > pos) {
+        selStart = lead - 1;
+        open = lead;
+      }
+    }
+    if (open < 0) {
+      return { entries, stop: "NO_BLOCK" };
+    }
+    const close = s.indexOf("}", open + 2);
+    if (close < 0) {
+      return { entries, stop: "NO_BLOCK" };
+    }
+    const selector = trimEnd(s.slice(selStart, open));
+    const block = s.slice(open + 1, close);
+    pos = close + 1;
+    if (selector !== "core" && parseCyjsSelector(selector).invalid) {
+      continue;
+    }
+    const properties = blockProperties(block);
+    if (properties === null) {
+      return { entries, stop: "BAD_PROPERTY" };
+    }
+    entries.push({ selector, properties, dashOnly: true });
+  }
+  return { entries, stop: null };
+}
+function blockProperties(block) {
+  const properties = [];
+  const next = nextNonSpace(block);
+  let from = 0;
+  while (next[from] < block.length) {
+    const p = readProperty(block, from, next);
+    if (p === null) {
+      return null;
+    }
+    properties.push([p.name, p.value]);
+    from = p.end;
+  }
+  return properties;
+}
+function isObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function idText(v) {
+  if (typeof v === "number" && !Number.isNaN(v)) {
+    return String(v);
+  }
+  if (typeof v === "string" && v !== "" && !/^\s+$/.test(v)) {
+    return v;
+  }
+  return null;
+}
+function flags(json, edge) {
+  const pannable = json.pannable === void 0 ? edge : Boolean(json.pannable);
+  const grabbable = json.grabbable === void 0 ? true : Boolean(json.grabbable);
+  return {
+    selected: Boolean(json.selected),
+    selectable: json.selectable === void 0 ? true : Boolean(json.selectable),
+    locked: Boolean(json.locked),
+    grabbable: !pannable && grabbable
+  };
+}
+function classSet(v) {
+  const out = /* @__PURE__ */ new Set();
+  let items = [];
+  if (Array.isArray(v)) {
+    items = v;
+  } else if (typeof v === "string") {
+    items = v.split(/\s+/);
+  }
+  for (const c of items) {
+    if (c) {
+      out.add(c);
+    }
+  }
+  return out;
+}
+function parentsOf(nodes, ids) {
+  const parent = new Int32Array(nodes.length).fill(-1);
+  const children = nodes.map(() => []);
+  const root = Int32Array.from(nodes, (_n, i) => i);
+  const rootOf = (x) => {
+    while (root[x] !== x) {
+      root[x] = root[root[x]];
+      x = root[x];
+    }
+    return x;
+  };
+  for (let i = 0; i < nodes.length; i++) {
+    const raw = nodes[i].data.parent;
+    if (raw === void 0 || raw === null) {
+      continue;
+    }
+    const text = typeof raw === "number" && !Number.isNaN(raw) ? String(raw) : raw;
+    const p = typeof text === "string" ? ids.get(text) : void 0;
+    if (p === void 0 || p < 0) {
+      nodes[i].overrides.set("parent", void 0);
+      continue;
+    }
+    if (typeof raw === "number") {
+      nodes[i].overrides.set("parent", text);
+    }
+    if (rootOf(p) === i) {
+      nodes[i].overrides.set("parent", void 0);
+      continue;
+    }
+    parent[i] = p;
+    root[i] = p;
+    children[p].push(i);
+  }
+  return { parent, children };
+}
+function cyjsGraph(elements) {
+  const { nodeJson, edgeJson } = elementGroups(elements);
+  const ids = /* @__PURE__ */ new Map();
+  const make = elementMaker(ids);
+  const nodes = [];
+  for (const json of nodeJson) {
+    const e = make(json, false, /* @__PURE__ */ new Map());
+    if (e !== null) {
+      ids.set(e.id, nodes.length);
+      nodes.push(e);
+    }
+  }
+  const edges = [];
+  const src = [];
+  const tgt = [];
+  const edgeIds = /* @__PURE__ */ new Set();
+  for (const json of edgeJson) {
+    const overrides = /* @__PURE__ */ new Map();
+    const e = make(json, true, overrides);
+    const ends = e === null || edgeIds.has(e.id) ? null : edgeEnds(e, ids, overrides);
+    if (e !== null && ends !== null) {
+      edgeIds.add(e.id);
+      edges.push(e);
+      src.push(ends[0]);
+      tgt.push(ends[1]);
+    }
+  }
+  for (const id of edgeIds) {
+    ids.set(id, -1);
+  }
+  const { parent, children } = parentsOf(nodes, ids);
+  const incident = nodes.map(() => []);
+  for (let e = 0; e < edges.length; e++) {
+    incident[src[e]].push(e);
+    if (src[e] !== tgt[e]) {
+      incident[tgt[e]].push(e);
+    }
+  }
+  return {
+    nodes,
+    edges,
+    source: Int32Array.from(src),
+    target: Int32Array.from(tgt),
+    parent,
+    children,
+    incident
+  };
+}
+function elementGroups(elements) {
+  const nodeJson = [];
+  const edgeJson = [];
+  const take = (item, group) => {
+    const g = groupOf(item, group);
+    if (g === "nodes") {
+      nodeJson.push(item);
+    } else if (g === "edges") {
+      edgeJson.push(item);
+    }
+  };
+  if (Array.isArray(elements)) {
+    for (const item of elements) {
+      take(item, void 0);
+    }
+  } else if (isObject(elements)) {
+    for (const item of Array.isArray(elements.nodes) ? elements.nodes : []) {
+      take(item, "nodes");
+    }
+    for (const item of Array.isArray(elements.edges) ? elements.edges : []) {
+      take(item, "edges");
+    }
+  }
+  return { nodeJson, edgeJson };
+}
+function groupOf(item, group) {
+  if (!isObject(item)) {
+    return void 0;
+  }
+  const data = item.data ?? {};
+  if (!isObject(data)) {
+    return void 0;
+  }
+  const given = group ?? item.group;
+  if (given !== void 0 && given !== null) {
+    return given;
+  }
+  const ends = data.source !== void 0 && data.source !== null && data.target !== void 0 && data.target !== null;
+  return ends ? "edges" : "nodes";
+}
+function elementMaker(ids) {
+  let generated = 0;
+  return (json, edge, overrides) => {
+    const data = isObject(json.data) ? json.data : {};
+    let id;
+    if (data.id === void 0) {
+      id = `${String.fromCodePoint(0)}generated-${String(generated++)}`;
+      overrides.set("id", id);
+    } else {
+      id = idText(data.id);
+      if (id === null || ids.has(id)) {
+        return null;
+      }
+      if (typeof data.id === "number") {
+        overrides.set("id", id);
+      }
+    }
+    return { json, data, overrides, id, classes: classSet(json.classes), ...flags(json, edge) };
+  };
+}
+function edgeEnds(e, ids, overrides) {
+  const ends = [];
+  for (const field of ["source", "target"]) {
+    const raw = e.data[field];
+    const text = typeof raw === "number" && !Number.isNaN(raw) ? String(raw) : raw;
+    if (typeof raw === "number") {
+      overrides.set(field, text);
+    }
+    const at = typeof text === "string" ? ids.get(text) : void 0;
+    if (at !== void 0) {
+      ends.push(at);
+    }
+  }
+  return ends.length === 2 ? [ends[0], ends[1]] : null;
+}
+function selectorField(e, field) {
+  if (e.overrides.has(field)) {
+    return e.overrides.get(field);
+  }
+  const direct = e.data[field];
+  if (direct !== void 0 || !field.includes(".")) {
+    return direct;
+  }
+  let v = e.data;
+  const path = field.split(".");
+  let k = 0;
+  while (v !== null && v !== void 0 && k < path.length) {
+    v = v[path[k++]];
+  }
+  return k === path.length ? v : void 0;
+}
+function mapperData(e) {
+  if (e.overrides.size === 0) {
+    return e.data;
+  }
+  return new Proxy(e.data, {
+    get: (target, key) => typeof key === "string" && e.overrides.has(key) ? e.overrides.get(key) : target[key]
+  });
+}
+function sheetEntries(style, notes) {
+  if (typeof style === "string") {
+    const { entries, stop } = parseCyjsStylesheetText(style);
+    if (stop !== null) {
+      notes.add(STYLE_ISSUE.UNREADABLE, null, "stylesheet", { sample: stop });
+    }
+    return entries;
+  }
+  if (!Array.isArray(style)) {
+    return [];
+  }
+  const out = [];
+  for (const item of style) {
+    if (!isObject(item)) {
+      continue;
+    }
+    const props = item.style ?? item.css;
+    const properties = [];
+    if (isObject(props)) {
+      for (const name of Object.keys(props)) {
+        properties.push([name, props[name]]);
+      }
+    }
+    out.push({ selector: item.selector, properties, dashOnly: false });
+  }
+  return out;
+}
+const MAX_SELECTOR_NESTING = 64;
+function nesting(q, depth = 0) {
+  if (depth > MAX_SELECTOR_NESTING) {
+    return depth;
+  }
+  let max = depth;
+  for (const c of q.checks) {
+    for (const sub of subQueries(c)) {
+      max = Math.max(max, nesting(sub, depth + 1));
+      if (max > MAX_SELECTOR_NESTING) {
+        return max;
+      }
+    }
+  }
+  return max;
+}
+function subQueries(c) {
+  switch (c.type) {
+    case "child":
+    case "parent":
+      return [c.parent, c.child];
+    case "descendant":
+    case "ancestor":
+      return [c.ancestor, c.descendant];
+    case "split":
+      return [c.left, c.right, c.subject];
+    case "directedEdge":
+    case "nodeSource":
+    case "nodeTarget":
+      return [c.source, c.target];
+    case "undirectedEdge":
+      return [c.nodes[0], c.nodes[1]];
+    case "nodeNeighbor":
+      return [c.node, c.neighbor];
+    default:
+      return [];
+  }
+}
+function valCmp(field, op, not, ci, value) {
+  let a = field;
+  let b = value;
+  const isFieldStr = typeof field === "string";
+  const isFieldNum = typeof field === "number" && !Number.isNaN(field);
+  let fs = null;
+  let vs = null;
+  if (isFieldStr || typeof value === "string" || ci) {
+    fs = !isFieldStr && !isFieldNum ? "" : String(field);
+    vs = String(value);
+  }
+  if (ci && fs !== null && vs !== null) {
+    fs = fs.toLowerCase();
+    vs = vs.toLowerCase();
+    a = fs;
+    b = vs;
+  }
+  let m = false;
+  let ineq = false;
+  switch (op) {
+    case "*=":
+      m = fs !== null && vs !== null && fs.includes(vs);
+      break;
+    case "$=":
+      m = fs !== null && vs !== null && fs.endsWith(vs);
+      break;
+    case "^=":
+      m = fs !== null && vs !== null && fs.startsWith(vs);
+      break;
+    case "=":
+      m = a === b;
+      break;
+    case ">":
+      ineq = true;
+      m = a > b;
+      break;
+    case ">=":
+      ineq = true;
+      m = a >= b;
+      break;
+    case "<":
+      ineq = true;
+      m = a < b;
+      break;
+    case "<=":
+      ineq = true;
+      m = a <= b;
+      break;
+  }
+  if (not && (field !== null && field !== void 0 || !ineq)) {
+    m = !m;
+  }
+  return m;
+}
+const STRUCTURE_CHECKS = /* @__PURE__ */ new Set([
+  "child",
+  "parent",
+  "descendant",
+  "ancestor",
+  "split",
+  "directedEdge",
+  "undirectedEdge",
+  "nodeSource",
+  "nodeTarget",
+  "nodeNeighbor"
+]);
+const RUNTIME_STATES = /* @__PURE__ */ new Set([
+  "active",
+  "inactive",
+  "grabbed",
+  "free",
+  "animated",
+  "unanimated",
+  "visible",
+  "hidden",
+  "transparent",
+  "backgrounding",
+  "nonbackgrounding"
+]);
+class BudgetStop extends Error {
+}
+const CHECK_EVERY = 4096;
+class Matcher {
+  constructor(g, notes) {
+    this.g = g;
+    this.notes = notes;
+    this.work = 0;
+    this.#charge = null;
+    this.#charged = 0;
+    this.#memo = { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map() };
+    const n = g.nodes.length;
+    this.degree = new Int32Array(n);
+    this.indegree = new Int32Array(n);
+    this.outdegree = new Int32Array(n);
+    for (let e = 0; e < g.edges.length; e++) {
+      const s = g.source[e];
+      const t = g.target[e];
+      this.degree[s] += s === t ? 2 : 1;
+      if (s !== t) {
+        this.degree[t]++;
+      }
+      this.outdegree[s]++;
+      this.indegree[t]++;
+    }
+  }
+  #charge;
+  #charged;
+  #memo;
+  /**
+   * Whether an element matches a query.
+   * @param q - the query
+   * @param kind - the element's kind
+   * @param i - the element
+   * @returns true when every check matches
+   */
+  query(q, kind, i) {
+    for (const c of q.checks) {
+      this.work++;
+      if (this.#charge !== null && this.work - this.#charged >= CHECK_EVERY) {
+        this.settle();
+      }
+      if (!this.check(c, kind, i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Starts one selector match: its work is charged to the budget as it runs, and the sub-query answers are fresh.
+   * @param kind - the target the work is charged to
+   * @param budget - the counted budget
+   * @param signal - cancels the match
+   */
+  begin(kind, budget, signal) {
+    this.#charge = { kind, budget, signal };
+    this.#charged = this.work;
+    this.#memo.node.clear();
+    this.#memo.edge.clear();
+  }
+  /** Ends a match: its remaining work is charged (never throwing) and its sub-query answers are dropped. */
+  end() {
+    const charge = this.#charge;
+    this.#charge = null;
+    charge?.budget.spend(charge.kind, this.work - this.#charged);
+    this.#charged = this.work;
+    this.#memo.node.clear();
+    this.#memo.edge.clear();
+  }
+  /**
+   * Charges the work done since the last charge; throws BudgetStop once the budget is exhausted.
+   * @throws BudgetStop - when the target's budget is exhausted
+   */
+  settle() {
+    const charge = this.#charge;
+    if (charge === null) {
+      return;
+    }
+    charge.budget.spend(charge.kind, this.work - this.#charged);
+    this.#charged = this.work;
+    charge.signal?.throwIfAborted();
+    if (charge.budget.exhausted(charge.kind)) {
+      throw new BudgetStop();
+    }
+  }
+  /**
+   * Whether an element matches a nested sub-query, remembered for the rest of the match.
+   * @param q - the sub-query
+   * @param kind - the element's kind
+   * @param i - the element
+   * @returns true when every check matches
+   */
+  sub(q, kind, i) {
+    const memo = this.#memo[kind];
+    let seen = memo.get(q);
+    if (seen === void 0) {
+      seen = new Uint8Array(kind === "node" ? this.g.nodes.length : this.g.edges.length);
+      memo.set(q, seen);
+    }
+    if (seen[i] !== 0) {
+      return seen[i] === 1;
+    }
+    const m = this.query(q, kind, i);
+    seen[i] = m ? 1 : 2;
+    return m;
+  }
+  /**
+   * Whether an element matches one check.
+   * @param c - the check
+   * @param kind - the element's kind
+   * @param i - the element
+   * @returns true when it matches
+   */
+  check(c, kind, i) {
+    return STRUCTURE_CHECKS.has(c.type) ? this.structureCheck(c, kind, i) : this.elementCheck(c, kind, i);
+  }
+  /**
+   * Whether an element matches a check of its own: its group, state, id, classes or data.
+   * @param c - the check
+   * @param kind - the element's kind
+   * @param i - the element
+   * @returns true when it matches
+   */
+  elementCheck(c, kind, i) {
+    const { g } = this;
+    const e = kind === "node" ? g.nodes[i] : g.edges[i];
+    switch (c.type) {
+      case "group":
+        return c.value === "*" || c.value === `${kind}s`;
+      case "state":
+        return this.state(c.value, kind, i, e);
+      case "id":
+        return e.id === c.value;
+      case "class":
+        return e.classes.has(c.value);
+      case "exist":
+        return selectorField(e, c.field) !== void 0;
+      case "bool": {
+        const v = selectorField(e, c.field);
+        if (c.op === "?") {
+          return Boolean(v);
+        }
+        return c.op === "!" ? !v : v === void 0;
+      }
+      case "compare":
+        return valCmp(selectorField(e, c.field), c.op, c.not, c.ci, c.value);
+      case "meta": {
+        const v = kind === "node" ? this[c.field][i] : void 0;
+        return valCmp(v, c.op, c.not, c.ci, c.value);
+      }
+      case "true":
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Whether an element matches a check of its place in the graph: its parents, children and edges.
+   * @param c - the check
+   * @param kind - the element's kind
+   * @param i - the element
+   * @returns true when it matches
+   */
+  structureCheck(c, kind, i) {
+    const { g } = this;
+    switch (c.type) {
+      case "child":
+        return this.sub(c.child, kind, i) && kind === "node" && g.parent[i] >= 0 && this.sub(c.parent, "node", g.parent[i]);
+      case "parent":
+        return this.sub(c.parent, kind, i) && kind === "node" && g.children[i].some((k) => this.sub(c.child, "node", k));
+      case "descendant":
+        return this.sub(c.descendant, kind, i) && kind === "node" && this.someAncestor(i, c.ancestor);
+      case "ancestor":
+        return this.sub(c.ancestor, kind, i) && kind === "node" && this.someDescendant(i, c.descendant);
+      case "split":
+        return this.sub(c.subject, kind, i) && this.sub(c.left, kind, i) && this.sub(c.right, kind, i);
+      case "directedEdge":
+        return kind === "edge" && this.sub(c.source, "node", g.source[i]) && this.sub(c.target, "node", g.target[i]);
+      case "undirectedEdge": {
+        if (kind !== "edge") {
+          return false;
+        }
+        const [a, b] = c.nodes;
+        const s = g.source[i];
+        const t = g.target[i];
+        return this.sub(a, "node", s) && this.sub(b, "node", t) || this.sub(b, "node", s) && this.sub(a, "node", t);
+      }
+      case "nodeSource":
+        return kind === "node" && this.sub(c.source, kind, i) && g.incident[i].some((ed) => g.source[ed] === i && this.sub(c.target, "node", g.target[ed]));
+      case "nodeTarget":
+        return kind === "node" && this.sub(c.target, kind, i) && g.incident[i].some((ed) => g.target[ed] === i && this.sub(c.source, "node", g.source[ed]));
+      case "nodeNeighbor":
+        return kind === "node" && this.sub(c.node, kind, i) && g.incident[i].some((ed) => {
+          const other = g.source[ed] === i ? g.target[ed] : g.source[ed];
+          return this.sub(c.neighbor, "node", other);
+        });
+      default:
+        return false;
+    }
+  }
+  /**
+   * Whether an ancestor of a node matches a query (cycle-safe: parents never form a cycle).
+   * @param i - the node
+   * @param q - the query
+   * @returns true when one does
+   */
+  someAncestor(i, q) {
+    for (let a = this.g.parent[i]; a >= 0; a = this.g.parent[a]) {
+      if (this.sub(q, "node", a)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Whether a descendant of a node matches a query, walked without recursion.
+   * @param i - the node
+   * @param q - the query
+   * @returns true when one does
+   */
+  someDescendant(i, q) {
+    const stack = [...this.g.children[i]];
+    while (stack.length > 0) {
+      const k = stack.pop();
+      if (this.sub(q, "node", k)) {
+        return true;
+      }
+      for (const c of this.g.children[k]) {
+        stack.push(c);
+      }
+    }
+    return false;
+  }
+  /**
+   * A state selector, evaluated as at load.
+   * @param s - the state
+   * @param kind - the element's kind
+   * @param i - the element
+   * @param e - the element
+   * @returns whether the element is in the state
+   */
+  state(s, kind, i, e) {
+    const { g } = this;
+    if (RUNTIME_STATES.has(s)) {
+      this.notes.add(STYLE_ISSUE.STATE_ASSUMED, kind, `:${s}`, { sample: `:${s}` });
+    }
+    const node = kind === "node";
+    switch (s) {
+      case "selected":
+        return e.selected;
+      case "unselected":
+        return !e.selected;
+      case "selectable":
+        return e.selectable;
+      case "unselectable":
+        return !e.selectable;
+      case "locked":
+        return e.locked;
+      case "unlocked":
+        return !e.locked;
+      case "grabbable":
+        return e.grabbable;
+      case "ungrabbable":
+        return !e.grabbable;
+      case "free":
+      case "inside":
+      case "unanimated":
+      case "inactive":
+      case "nonbackgrounding":
+      case "visible":
+        return true;
+      case "parent":
+        return node && g.children[i].length > 0;
+      case "childless":
+        return node && g.children[i].length === 0;
+      case "child":
+      case "nonorphan":
+        return node && g.parent[i] >= 0;
+      case "orphan":
+        return node && g.parent[i] < 0;
+      case "compound":
+        return node ? g.children[i].length > 0 : g.children[g.source[i]].length > 0 || g.children[g.target[i]].length > 0;
+      case "loop":
+        return !node && g.source[i] === g.target[i];
+      case "simple":
+        return !node && g.source[i] !== g.target[i];
+      default:
+        return false;
+    }
+  }
+}
+class Indexes {
+  constructor(elements, spend) {
+    this.elements = elements;
+    this.spend = spend;
+    this.byClass = /* @__PURE__ */ new Map();
+    this.byId = /* @__PURE__ */ new Map();
+    this.byValue = /* @__PURE__ */ new Map();
+    this.stamp = 0;
+    this.marks = new Int32Array(elements.length);
+    for (let i = 0; i < elements.length; i++) {
+      for (const c of elements[i].classes) {
+        let list = this.byClass.get(c);
+        if (list === void 0) {
+          list = [];
+          this.byClass.set(c, list);
+        }
+        list.push(i);
+      }
+      if (!this.byId.has(elements[i].id)) {
+        this.byId.set(elements[i].id, i);
+      }
+    }
+    spend(elements.length);
+  }
+  /**
+   * The elements whose field is `===` a value.
+   * @param field - the field
+   * @param value - the value
+   * @returns the element indexes
+   */
+  equal(field, value) {
+    let m = this.byValue.get(field);
+    if (m === void 0) {
+      m = /* @__PURE__ */ new Map();
+      for (let i = 0; i < this.elements.length; i++) {
+        const v = selectorField(this.elements[i], field);
+        if (typeof v !== "string" && typeof v !== "number") {
+          continue;
+        }
+        const k = `${typeof v}:${String(v)}`;
+        let list = m.get(k);
+        if (list === void 0) {
+          list = [];
+          m.set(k, list);
+        }
+        list.push(i);
+      }
+      this.byValue.set(field, m);
+      this.spend(this.elements.length);
+    }
+    if (typeof value === "number" && Number.isNaN(value)) {
+      return [];
+    }
+    return m.get(`${typeof value}:${String(value)}`) ?? [];
+  }
+}
+function candidates(q, kind, ix) {
+  let best = null;
+  for (const c of q.checks) {
+    let list = null;
+    if (c.type === "group" && c.value !== "*" && c.value !== `${kind}s`) {
+      return [];
+    }
+    if (c.type === "class") {
+      list = ix.byClass.get(c.value) ?? [];
+    } else if (c.type === "id") {
+      const at = ix.byId.get(c.value);
+      list = at === void 0 ? [] : [at];
+    } else if (c.type === "compare" && c.op === "=" && !c.not && !c.ci) {
+      list = ix.equal(c.field, c.value);
+    }
+    if (list !== null && (best === null || list.length < best.length)) {
+      best = list;
+    }
+  }
+  return best;
+}
+const POSITIONS = /* @__PURE__ */ new Map([
+  ["top,left", "top-left"],
+  ["top,center", "top"],
+  ["top,right", "top-right"],
+  ["center,left", "left"],
+  ["center,center", "center"],
+  ["center,right", "right"],
+  ["bottom,left", "bottom-left"],
+  ["bottom,center", "bottom"],
+  ["bottom,right", "bottom-right"]
+]);
+function evaluateCytoscapeJs(input) {
+  const notes = input.notes ?? new StyleNotes();
+  const budget = input.budget ?? new StyleBudget();
+  const graph = cyjsGraph(input.elements);
+  const sheet = [];
+  if (input.toolDefaults !== false) {
+    CYJS_DEFAULT_STYLESHEET.forEach((d, k) => {
+      sheet.push({
+        index: k - CYJS_DEFAULT_STYLESHEET.length,
+        tool: true,
+        text: d.selector,
+        selector: parseCyjsSelector(d.selector),
+        properties: Object.entries(d.style),
+        dashOnly: true
+      });
+    });
+  }
+  const raw = sheetEntries(input.style, notes);
+  let invalid = 0;
+  let deep = 0;
+  raw.forEach((r, k) => {
+    let selector = parseCyjsSelector(r.selector);
+    if (selector.invalid) {
+      invalid++;
+    }
+    if (selector.queries.some((q) => nesting(q) > MAX_SELECTOR_NESTING)) {
+      deep++;
+      selector = { queries: [], invalid: true };
+    }
+    sheet.push({
+      index: k,
+      tool: false,
+      text: typeof r.selector === "string" ? r.selector : "",
+      selector,
+      properties: r.properties,
+      dashOnly: r.dashOnly
+    });
+  });
+  if (invalid > 0) {
+    notes.add(STYLE_ISSUE.SELECTOR, null, "selector", { count: invalid, sample: "invalid" });
+  }
+  if (deep > 0) {
+    notes.add(STYLE_ISSUE.SELECTOR, null, "selector", { count: deep, sample: "nested too deep" });
+  }
+  const matcher = new Matcher(graph, notes);
+  const node = evaluateTarget("node", graph, sheet, matcher, input, notes, budget);
+  const edge = evaluateTarget("edge", graph, sheet, matcher, input, notes, budget);
+  return { node, edge, graph };
+}
+function outputOrder(kind, graph, snapshot, notes) {
+  const els = kind === "node" ? graph.nodes : graph.edges;
+  if (snapshot === void 0) {
+    return Int32Array.from(els, (_e, i) => i);
+  }
+  if (kind === "node") {
+    const order2 = new Int32Array(snapshot.nodeCount).fill(-1);
+    for (let i = 0; i < els.length; i++) {
+      const at = snapshotIndex(snapshot, els[i].id);
+      if (at >= 0 && order2[at] < 0) {
+        order2[at] = i;
+      }
+    }
+    return order2;
+  }
+  const order = new Int32Array(snapshot.edgeCount).fill(-1);
+  const nodeAt = outputOrder("node", graph, snapshot, notes);
+  const coreToSnap = new Int32Array(graph.nodes.length).fill(-1);
+  nodeAt.forEach((c, s) => {
+    if (c >= 0) {
+      coreToSnap[c] = s;
+    }
+  });
+  let j = 0;
+  for (let e = 0; e < els.length && j < snapshot.edgeCount; e++) {
+    if (coreToSnap[graph.source[e]] === snapshot.edgeSource(j) && coreToSnap[graph.target[e]] === snapshot.edgeTarget(j)) {
+      order[j++] = e;
+    }
+  }
+  if (j < snapshot.edgeCount) {
+    notes.add(STYLE_ISSUE.UNRESOLVED, "edge", "elements", { count: snapshot.edgeCount - j, sample: "edge order" });
+  }
+  return order;
+}
+function snapshotIndex(snapshot, id) {
+  if (snapshot.ids.has(id)) {
+    return snapshot.ids.indexOf(id);
+  }
+  const n = Number(id);
+  return id.trim() !== "" && Number.isFinite(n) && snapshot.ids.has(n) ? snapshot.ids.indexOf(n) : -1;
+}
+function cellsOf(cells, name, n) {
+  let c = cells.get(name);
+  if (c === void 0) {
+    c = new Array(n);
+    cells.set(name, c);
+  }
+  return c;
+}
+function evaluateTarget(kind, graph, sheet, matcher, input, notes, budget) {
+  const els = kind === "node" ? graph.nodes : graph.edges;
+  const spend = (ops) => {
+    budget.spend(kind, ops);
+  };
+  const { cells, applied } = cascade(kind, els, sheet, matcher, input, notes, budget);
+  const order = outputOrder(kind, graph, input.snapshot, notes);
+  const coreToOut = new Int32Array(els.length).fill(-1);
+  order.forEach((c, k) => {
+    if (c >= 0) {
+      coreToOut[c] = k;
+    }
+  });
+  applyBypasses(kind, els, cells, coreToOut, notes);
+  if (kind === "edge") {
+    forceLoopCurves(graph, cells.get("curve-style"));
+  }
+  const drawn = drawnValues(kind, els, cells, order, input.rendered, notes, spend);
+  if (kind === "edge") {
+    straightenUnpairedBeziers(graph, curveStyles(graph, cells, input.rendered), coreToOut, drawn.curved);
+  }
+  const built = buildRules(kind, applied, { els, order, coreToOut }, input, drawn, { matcher, notes, spend });
+  return {
+    n: order.length,
+    values: drawn,
+    rules: built.rules,
+    columns: built.columns,
+    rawColumns: built.rawColumns,
+    elements: Array.from(order, (i) => i >= 0 ? els[i] : null)
+  };
+}
+function cascade(kind, els, sheet, matcher, input, notes, budget) {
+  const n = els.length;
+  const specs = cyjsProperties(kind);
+  const spend = (ops) => {
+    budget.spend(kind, ops);
+  };
+  const ix = new Indexes(els, spend);
+  const cells = /* @__PURE__ */ new Map();
+  const notCarried = /* @__PURE__ */ new Map();
+  const applied = [];
+  let stopped = false;
+  for (const entry of sheet) {
+    input.signal?.throwIfAborted();
+    const props = entryProperties(entry, kind, specs, notes, notCarried);
+    if (props.length === 0) {
+      continue;
+    }
+    const list = budget.exhausted(kind) ? null : budgetedMatch(entry.selector, { kind, n }, matcher, ix, input, budget);
+    if (list === null) {
+      stopped = true;
+      break;
+    }
+    spend(list.length);
+    applied.push({ entry, list, props });
+    for (const p of props) {
+      const col = cellsOf(cells, p.name, n);
+      for (const i of list) {
+        col[i] = cellFor(p, els[i]);
+      }
+      spend(list.length);
+    }
+  }
+  if (stopped) {
+    notes.add(STYLE_ISSUE.BUDGET, kind, null, { sample: "stylesheet" });
+  }
+  for (const [name, count] of notCarried) {
+    notes.add(STYLE_ISSUE.NOT_CARRIED, kind, name, { count, sample: name });
+  }
+  return { cells, applied };
+}
+function budgetedMatch(sel, target, matcher, ix, input, budget) {
+  matcher.begin(target.kind, budget, input.signal);
+  try {
+    return matchList(sel, target.kind, target.n, matcher, ix);
+  } catch (error) {
+    if (!(error instanceof BudgetStop)) {
+      throw error;
+    }
+    return null;
+  } finally {
+    matcher.end();
+  }
+}
+function applyBypasses(kind, els, cells, coreToOut, notes) {
+  const specs = cyjsProperties(kind);
+  for (let i = 0; i < els.length; i++) {
+    const { json } = els[i];
+    const bypass = json.style ?? json.css;
+    if (!isObject(bypass)) {
+      continue;
+    }
+    for (const name0 of Object.keys(bypass)) {
+      const name = cyjsPropertyName(name0);
+      const spec = specs.get(name);
+      const value = bypass[name0];
+      if (spec === void 0 || value === "" || value === null) {
+        continue;
+      }
+      const parsed = parseCyjsValue(spec, value, "bypass");
+      if (parsed === null || parsed === CYJS_THROWS || !isFlat(parsed)) {
+        notes.add(STYLE_ISSUE.BAD_VALUE, kind, spec.property, { sample: value, element: coreToOut[i] });
+        continue;
+      }
+      cellsOf(cells, name, els.length)[i] = parsed;
+    }
+  }
+}
+function drawnValues(kind, els, cells, order, rendered, notes, spend) {
+  const out = order.length;
+  const values = {};
+  const words = /* @__PURE__ */ new Map();
+  const drawnOf = { kind, els, cells, order, rendered, notes };
+  for (const [name, spec] of cyjsProperties(kind)) {
+    if (!cells.has(name) && rendered === void 0) {
+      continue;
+    }
+    const col = drawnColumn(drawnOf, name, spec);
+    spend(2 * out);
+    if (spec.property.startsWith("_")) {
+      words.set(
+        spec.property,
+        col.map((v) => typeof v === "string" ? v : null)
+      );
+      continue;
+    }
+    values[spec.property] ??= new Array(out).fill(null);
+    const target = values[spec.property];
+    col.forEach((v, k) => {
+      if (v !== null && v !== void 0) {
+        target[k] = v;
+      }
+    });
+  }
+  combineParts(kind, out, words, values, notes);
+  const drawn = {};
+  for (const [p, col] of Object.entries(values)) {
+    if (col.some((v) => v !== null)) {
+      drawn[p] = col;
+    }
+  }
+  return drawn;
+}
+function drawnColumn(d, name, spec) {
+  const { kind, order, notes, rendered } = d;
+  const out = order.length;
+  const col = new Array(out).fill(null);
+  const cellCol = d.cells.get(name);
+  for (let k = 0; k < out && cellCol !== void 0; k++) {
+    const c = order[k] >= 0 ? cellCol[order[k]] : void 0;
+    if (c !== void 0) {
+      col[k] = neutralOfCell(spec, name, c, { notes, target: kind, property: spec.property, element: k });
+    }
+  }
+  if (rendered !== void 0) {
+    overrideRendered(d, rendered, name, spec, col);
+  }
+  return col;
+}
+function overrideRendered(d, rendered, name, spec, col) {
+  const { kind, order, notes } = d;
+  for (let k = 0; k < order.length; k++) {
+    const r = order[k] >= 0 ? rendered.get(d.els[order[k]].json) : void 0;
+    if (r !== void 0 && Object.hasOwn(r, name)) {
+      const site = { notes, target: kind, property: spec.property, element: k };
+      const v = cyjsRendered(kind, name, r[name], site);
+      col[k] = v === void 0 || v === "" && spec.type === "text" ? null : v;
+    }
+  }
+}
+function curveStyles(graph, cells, rendered) {
+  const col = cells.get("curve-style");
+  return graph.edges.map((el, e) => {
+    const r = rendered?.get(el.json);
+    if (r !== void 0 && Object.hasOwn(r, "curve-style")) {
+      return r["curve-style"];
+    }
+    const c = col?.[e];
+    return typeof c === "object" && c.kind === "word" ? c.value : void 0;
+  });
+}
+function straightenUnpairedBeziers(graph, styles, coreToOut, curved) {
+  if (curved === void 0) {
+    return;
+  }
+  for (const bundle of bezierBundles(graph, styles)) {
+    const k = bundle.length % 2 === 1 ? coreToOut[bundle[(bundle.length - 1) / 2]] : -1;
+    if (k >= 0) {
+      curved[k] = false;
+    }
+  }
+}
+function bezierBundles(graph, styles) {
+  const bundles = /* @__PURE__ */ new Map();
+  for (let e = 0; e < graph.edges.length; e++) {
+    const s = graph.source[e];
+    const t = graph.target[e];
+    if (s === t || styles[e] !== "bezier") {
+      continue;
+    }
+    const key = s < t ? `${s} ${t}` : `${t} ${s}`;
+    const bundle = bundles.get(key);
+    if (bundle === void 0) {
+      bundles.set(key, [e]);
+    } else {
+      bundle.push(e);
+    }
+  }
+  return bundles.values();
+}
+function forceLoopCurves(graph, col) {
+  if (col === void 0) {
+    return;
+  }
+  for (let e = 0; e < graph.edges.length; e++) {
+    const c = col[e];
+    if (graph.source[e] === graph.target[e] && typeof c === "object" && c.kind === "word" && c.value !== "bezier" && c.value !== "haystack") {
+      col[e] = { kind: "word", value: "bezier", str: "bezier" };
+    }
+  }
+}
+function entryProperties(entry, kind, specs, notes, notCarried) {
+  const out = [];
+  for (const [name0, value] of entry.properties) {
+    const name = entry.dashOnly ? dashOnlyName(name0) : cyjsPropertyName(name0);
+    const spec = specs.get(name);
+    if (spec === void 0) {
+      if (kind === "node" && !CYJS_EDGE_ONLY.has(name) && !entry.tool) {
+        notCarried.set(name, (notCarried.get(name) ?? 0) + 1);
+      }
+      continue;
+    }
+    const parsed = parseCyjsValue(spec, value, "rule");
+    if (parsed === null || parsed === CYJS_THROWS) {
+      if (!entry.tool) {
+        notes.add(STYLE_ISSUE.BAD_VALUE, kind, null, { sample: `${name}: ${String(value)}` });
+      }
+      continue;
+    }
+    out.push({ name, spec, parsed });
+  }
+  return out;
+}
+function dashOnlyName(name) {
+  return name === "content" ? "label" : name;
+}
+const CYJS_EDGE_ONLY = /* @__PURE__ */ new Set([
+  "line-color",
+  "line-style",
+  "target-arrow-shape",
+  "source-arrow-shape",
+  "target-arrow-color",
+  "source-arrow-color",
+  "curve-style",
+  "arrow-scale",
+  "source-label",
+  "target-label"
+]);
+function matchList(sel, kind, n, matcher, ix) {
+  if (sel.queries.length === 0) {
+    return [];
+  }
+  const stamp = ++ix.stamp;
+  const marked = ix.marks;
+  const hits = [];
+  let scanned = false;
+  const visit = (q, i) => {
+    if (marked[i] !== stamp && matcher.query(q, kind, i)) {
+      marked[i] = stamp;
+      hits.push(i);
+    }
+  };
+  for (const q of sel.queries) {
+    const cands = candidates(q, kind, ix);
+    if (cands === null) {
+      scanned = true;
+      for (let i = 0; i < n; i++) {
+        visit(q, i);
+      }
+    } else {
+      matcher.work += cands.length;
+      for (const i of cands) {
+        visit(q, i);
+      }
+    }
+  }
+  if (scanned || sel.queries.length > 1) {
+    hits.sort((a, b) => a - b);
+  }
+  matcher.work += hits.length;
+  return hits;
+}
+function cellFor(p, e) {
+  const v = p.parsed;
+  if (v.kind === "data" || v.kind === "mapData") {
+    return applyCyjsMapper(p.spec, v, mapperData(e)) ?? "reset";
+  }
+  if (v.kind === "fn") {
+    return "fn";
+  }
+  return v;
+}
+const DEFAULT_CELLS = /* @__PURE__ */ new Map();
+function defaultCell(name, spec) {
+  const key = `${spec.type}|${name}`;
+  if (!DEFAULT_CELLS.has(key)) {
+    const raw = CYJS_PROPERTY_DEFAULTS.get(name);
+    const parsed = raw === void 0 ? null : parseCyjsValue(spec, raw, "flat");
+    DEFAULT_CELLS.set(key, parsed === null || parsed === CYJS_THROWS || !isFlat(parsed) ? null : parsed);
+  }
+  return DEFAULT_CELLS.get(key) ?? null;
+}
+function isFlat(v) {
+  return v.kind === "color" || v.kind === "number" || v.kind === "word";
+}
+function neutralOfCell(spec, name, c, site) {
+  if (c === CYJS_THROWS) {
+    site.notes.add(STYLE_ISSUE.BAD_VALUE, site.target, site.property, {
+      sample: "unstyleable",
+      element: site.element
+    });
+    return void 0;
+  }
+  if (c === "fn") {
+    site.notes.add(STYLE_ISSUE.LAYER_FLATTENED, site.target, site.property, {
+      sample: "FUNCTION",
+      element: site.element
+    });
+    return void 0;
+  }
+  const flat = c === "reset" ? defaultCell(name, spec) : c;
+  if (flat === null) {
+    return null;
+  }
+  return cyjsNeutral(spec, flat, site);
+}
+function combineParts(kind, n, words, values, notes) {
+  const va = words.get("_valign");
+  const ha = words.get("_halign");
+  if (kind === "node" && (va !== void 0 || ha !== void 0)) {
+    values.labelPosition = Array.from(
+      { length: n },
+      (_, i) => labelPosition(va?.[i] ?? null, ha?.[i] ?? null, (sample) => {
+        notes.add(STYLE_ISSUE.UNKNOWN_VALUE, kind, "labelPosition", { sample, element: i });
+      })
+    );
+  }
+  const vis = words.get("_visibility");
+  const disp = words.get("_display");
+  if (vis !== void 0 || disp !== void 0) {
+    const col = new Array(n).fill(null);
+    for (let i = 0; i < n; i++) {
+      const a = vis?.[i] ?? null;
+      const b = disp?.[i] ?? null;
+      if (a === null && b === null) {
+        continue;
+      }
+      col[i] = a !== "hidden" && b !== "none";
+    }
+    values.visible = col;
+  }
+}
+function labelPosition(v, h, note) {
+  if (v === null && h === null) {
+    return null;
+  }
+  const vv = (v ?? "top").replace("-inside", "");
+  const hh = (h ?? "center").replace("-inside", "");
+  if ((v ?? "").endsWith("-inside") || (h ?? "").endsWith("-inside")) {
+    note(`${v ?? ""} ${h ?? ""}`);
+  }
+  return POSITIONS.get(`${vv},${hh}`) ?? null;
+}
+function buildRules(kind, applied, core, input, truth, env) {
+  const { els, order, coreToOut } = core;
+  const { matcher, notes, spend } = env;
+  const out = order.length;
+  const columns = /* @__PURE__ */ new Map();
+  const raw = /* @__PURE__ */ new Set();
+  const ctx = {
+    kind,
+    els,
+    coreToOut,
+    out,
+    snapshot: input.snapshot,
+    truth: input.rendered === void 0 ? null : truth,
+    matcher,
+    notes,
+    spend,
+    columns,
+    raw,
+    members: /* @__PURE__ */ new Map(),
+    faithful: /* @__PURE__ */ new Map(),
+    degrees: /* @__PURE__ */ new Map()
+  };
+  const drafts = [];
+  for (const a of applied) {
+    const props = a.props.filter((p) => !p.spec.property.startsWith("_"));
+    if (props.length === 0 || a.list.length === 0) {
+      continue;
+    }
+    drafts.push(draftOf(ctx, a.entry, a.list, props));
+  }
+  const rules = collapse(ctx, drafts);
+  return { rules, columns, rawColumns: [...raw] };
+}
+function draftOf(ctx, entry, list, props) {
+  const setting = /* @__PURE__ */ new Map();
+  const mapping = /* @__PURE__ */ new Map();
+  let flattened = false;
+  const id = entry.tool ? `${ctx.kind}.cytoscape-js.${String(entry.index + CYJS_DEFAULT_STYLESHEET.length)}` : `${ctx.kind}.sheet.${String(entry.index)}`;
+  for (const p of props) {
+    setting.delete(p.spec.property);
+    mapping.delete(p.spec.property);
+    const v = p.parsed;
+    if (v.kind === "fn") {
+      const copied = functionCopy(ctx, entry, list, p.spec.property);
+      if (copied !== null) {
+        mapping.set(p.spec.property, copied);
+        flattened = true;
+      }
+    } else if (isFlat(v)) {
+      const neutral = cyjsNeutral(p.spec, v, {
+        notes: new StyleNotes(),
+        target: ctx.kind,
+        property: p.spec.property
+      });
+      if (neutral !== void 0) {
+        setting.set(p.spec.property, neutral);
+      }
+    } else {
+      mapping.set(p.spec.property, mapperMapping(ctx, entry, list, p));
+    }
+  }
+  const set = Object.fromEntries(setting);
+  const map = Object.fromEntries(mapping);
+  const hasMap = mapping.size > 0;
+  const rule = () => {
+    const where = predicateOf(ctx, entry, list);
+    return {
+      id,
+      target: ctx.kind,
+      role: roleOf(hasMap, where),
+      origin: entry.tool ? "tool" : "declared",
+      where,
+      ...setting.size > 0 ? { set } : {},
+      ...hasMap ? { map } : {},
+      facts: flattened ? { elements: list.length, reason: "FUNCTION" } : { elements: list.length }
+    };
+  };
+  return {
+    rule,
+    id,
+    set,
+    tool: entry.tool,
+    single: hasMap || entry.tool ? null : singleTest(entry.selector, ctx.kind),
+    list
+  };
+}
+function functionCopy(ctx, entry, list, property) {
+  const drawn = ctx.truth?.[property];
+  if (drawn === void 0) {
+    return null;
+  }
+  const key = `function.${String(entry.index)}.${property}`;
+  const col = new Array(ctx.out).fill(null);
+  for (const i of list) {
+    const k = ctx.coreToOut[i];
+    if (k >= 0) {
+      col[k] = drawn[k];
+    }
+  }
+  ctx.columns.set(key, col);
+  return { kind: "passthrough", by: { style: key } };
+}
+function roleOf(hasMap, where) {
+  if (hasMap) {
+    return "mapping";
+  }
+  return "all" in where ? "defaults" : "group";
+}
+function singleTest(sel, kind) {
+  if (sel.invalid || sel.queries.length !== 1) {
+    return null;
+  }
+  const checks = sel.queries[0].checks.filter(
+    (c2) => !(c2.type === "group" && (c2.value === "*" || c2.value === `${kind}s`))
+  );
+  const c = checks.at(-1);
+  if (c === void 0 || checks.slice(0, -1).some((x) => x.type !== "compare" && x.type !== "class")) {
+    return null;
+  }
+  const context = JSON.stringify(checks.slice(0, -1));
+  if (c.type === "class" && typeof c.value === "string") {
+    return { sig: `class\0${context}`, key: c.value };
+  }
+  if (c.type === "id") {
+    return { sig: `id\0${context}`, key: c.value };
+  }
+  if (c.type === "compare" && c.op === "=" && !c.not && !c.ci) {
+    return { sig: `eq\0${context}\0${c.field}`, key: c.value };
+  }
+  return null;
+}
+function faithful(ctx, field) {
+  const known = ctx.faithful.get(field);
+  if (known !== void 0) {
+    return known;
+  }
+  let ok = ctx.snapshot !== void 0;
+  const table = ctx.kind === "node" ? ctx.snapshot?.nodes : ctx.snapshot?.edges;
+  const has = table?.names().includes(field) ?? false;
+  for (let c = 0; ok && c < ctx.els.length; c++) {
+    const k = ctx.coreToOut[c];
+    const rv = selectorField(ctx.els[c], field);
+    if (rv === null || rv === false) {
+      ok = false;
+      break;
+    }
+    const gv = k >= 0 && has && table !== void 0 ? plainCell(table.value(field, k)) : null;
+    if (rv === void 0 ? gv !== null : rv !== gv) {
+      ok = false;
+    }
+  }
+  ctx.spend(ctx.els.length);
+  ctx.faithful.set(field, ok);
+  return ok;
+}
+function degreeAgrees(ctx, which) {
+  const known = ctx.degrees.get(which);
+  if (known !== void 0) {
+    return known;
+  }
+  let ok = ctx.snapshot !== void 0 && ctx.kind === "node" && (which === "degree" || ctx.snapshot.directed);
+  if (ok && ctx.snapshot !== void 0) {
+    const mine = degreeValues(ctx.snapshot, which);
+    for (let c = 0; c < ctx.els.length; c++) {
+      const k = ctx.coreToOut[c];
+      if (k < 0 || mine[k] !== ctx.matcher[which][c]) {
+        ok = false;
+        break;
+      }
+    }
+    ok &&= ctx.els.length === ctx.out;
+  }
+  ctx.degrees.set(which, ok);
+  return ok;
+}
+function predicateOf(ctx, entry, list) {
+  const short = shortPredicate(ctx, entry.selector);
+  if (short !== null) {
+    return short;
+  }
+  if (list.length === ctx.els.length && ctx.els.length === ctx.out) {
+    return { all: true };
+  }
+  const sig = `${entry.tool ? "tool" : "file"}\0${entry.text}`;
+  let key = ctx.members.get(sig);
+  if (key === void 0) {
+    key = `member.${String(ctx.members.size + 1)}`;
+    ctx.members.set(sig, key);
+    const col = new Array(ctx.out).fill(null);
+    for (const i of list) {
+      const k = ctx.coreToOut[i];
+      if (k >= 0) {
+        col[k] = true;
+      }
+    }
+    ctx.spend(ctx.out + list.length);
+    ctx.columns.set(key, col);
+    ctx.notes.add(STYLE_ISSUE.SELECTOR_AS_COLUMN, ctx.kind, key, { sample: entry.text });
+  }
+  return { has: { style: key } };
+}
+function shortPredicate(ctx, sel) {
+  if (sel.invalid) {
+    return null;
+  }
+  const alts = [];
+  for (const q of sel.queries) {
+    const terms = queryTerms(ctx, q);
+    if (terms === null) {
+      return null;
+    }
+    if (terms !== "never") {
+      alts.push(terms);
+    }
+  }
+  if (alts.length === 0) {
+    return null;
+  }
+  if (alts.some((t) => t.length === 0)) {
+    return ctx.els.length === ctx.out ? { all: true } : null;
+  }
+  if (alts.length === 1) {
+    const t = alts[0];
+    if (t.length > 8) {
+      return null;
+    }
+    return t.length === 1 ? t[0] : { and: t };
+  }
+  return equalTests(alts);
+}
+function queryTerms(ctx, q) {
+  const terms = [];
+  let never = false;
+  for (const c of q.checks) {
+    if (c.type === "group") {
+      never ||= c.value !== "*" && c.value !== `${ctx.kind}s`;
+      continue;
+    }
+    const t = termOf(ctx, c);
+    if (t === null) {
+      return null;
+    }
+    terms.push(t);
+  }
+  return never ? "never" : terms;
+}
+function equalTests(alts) {
+  if (alts.length > 8 || !alts.every((t) => t.length === 1 && "eq" in t[0])) {
+    return null;
+  }
+  const by = alts[0][0].eq[0];
+  const values = [];
+  for (const t of alts) {
+    const [r, v] = t[0].eq;
+    if (JSON.stringify(r) !== JSON.stringify(by)) {
+      return null;
+    }
+    values.push(v);
+  }
+  return { in: [by, values] };
+}
+function termOf(ctx, c) {
+  switch (c.type) {
+    case "compare":
+      if (c.op !== "=" || c.ci || !faithful(ctx, c.field)) {
+        return null;
+      }
+      return c.not ? { not: { eq: [{ data: c.field }, c.value] } } : { eq: [{ data: c.field }, c.value] };
+    case "exist":
+      return faithful(ctx, c.field) ? { has: { data: c.field } } : null;
+    case "bool":
+      return c.op === "^" && faithful(ctx, c.field) ? { not: { has: { data: c.field } } } : null;
+    case "meta":
+      if (c.ci || !degreeAgrees(ctx, c.field)) {
+        return null;
+      }
+      return degreeTerm(c.field, c.op, c.not, c.value);
+    default:
+      return null;
+  }
+}
+function degreeTerm(field, op, not, value) {
+  const ref = { computed: field };
+  if (op === "=") {
+    return not ? { not: { eq: [ref, value] } } : { eq: [ref, value] };
+  }
+  let below;
+  if (op === ">" || op === "<=") {
+    below = Math.floor(value) + 1;
+  } else if (op === ">=" || op === "<") {
+    below = Math.ceil(value);
+  } else {
+    return null;
+  }
+  if (!Number.isFinite(below) || below < 1 || below > 8) {
+    return null;
+  }
+  const values = Array.from({ length: below }, (_, k) => k);
+  const keeps = op === "<" || op === "<=";
+  const inSet = { in: [ref, values] };
+  return keeps !== not ? inSet : { not: inSet };
+}
+function mapperMapping(ctx, entry, list, p) {
+  const v = p.parsed;
+  const want = new Array(list.length);
+  const site = { notes: new StyleNotes(), target: ctx.kind, property: p.spec.property };
+  for (let k = 0; k < list.length; k++) {
+    const c = cellFor(p, ctx.els[list[k]]);
+    const neutral = neutralOfCell(p.spec, p.name, c, site);
+    want[k] = neutral ?? null;
+  }
+  ctx.spend(list.length * 2);
+  const candidate = candidateMapping(ctx, v, p);
+  if (candidate !== null && ctx.snapshot !== void 0) {
+    const exact2 = givesWanted(
+      ctx,
+      ctx.snapshot,
+      candidate,
+      { field: v.field, property: p.spec.property },
+      list,
+      want
+    );
+    ctx.spend(list.length);
+    if (exact2) {
+      ctx.raw.add(v.field);
+      return candidate;
+    }
+  }
+  const key = `value.${entry.tool ? "tool" : String(entry.index)}.${p.spec.property}`;
+  const col = new Array(ctx.out).fill(null);
+  for (let k = 0; k < list.length; k++) {
+    const o = ctx.coreToOut[list[k]];
+    if (o >= 0) {
+      col[o] = want[k];
+    }
+  }
+  ctx.columns.set(key, col);
+  return { kind: "passthrough", by: { style: key } };
+}
+function givesWanted(ctx, snapshot, candidate, what, list, want) {
+  const table = ctx.kind === "node" ? snapshot.nodes : snapshot.edges;
+  if (!table.names().includes(what.field)) {
+    return false;
+  }
+  const canon = canonicalFor(ctx.kind, what.property);
+  for (let k = 0; k < list.length; k++) {
+    const o = ctx.coreToOut[list[k]];
+    const cell = o < 0 ? null : plainCell(table.value(what.field, o));
+    let got = null;
+    if (cell !== null && !Array.isArray(cell)) {
+      got = candidate.kind === "passthrough" ? canon(cell) : evalContinuous(candidate.points, numberOf(cell));
+    }
+    if (o >= 0 && got !== want[k]) {
+      return false;
+    }
+  }
+  return true;
+}
+function candidateMapping(ctx, v, p) {
+  if (v.kind === "data") {
+    return { kind: "passthrough", by: { data: v.field } };
+  }
+  if (v.fieldMin === v.fieldMax) {
+    return null;
+  }
+  const site = { notes: new StyleNotes(), target: ctx.kind, property: p.spec.property };
+  const a = cyjsNeutral(p.spec, v.min, site);
+  const b = cyjsNeutral(p.spec, v.max, site);
+  if (a === void 0 || b === void 0) {
+    return null;
+  }
+  const lo = { at: v.fieldMin, below: a, value: a, above: a };
+  const hi = { at: v.fieldMax, below: b, value: b, above: b };
+  return { kind: "continuous", by: { data: v.field }, points: v.fieldMin < v.fieldMax ? [lo, hi] : [hi, lo] };
+}
+function collapse(ctx, drafts) {
+  const out = [];
+  let run = 0;
+  let i = 0;
+  while (i < drafts.length) {
+    const sig = drafts[i].single?.sig ?? null;
+    let j = i + 1;
+    while (sig !== null && j < drafts.length && drafts[j].single?.sig === sig) {
+      j++;
+    }
+    if (sig === null || j - i < 3) {
+      for (const d of drafts.slice(i, j)) {
+        const rule = d.rule();
+        if (!(d.tool && "all" in rule.where)) {
+          out.push(rule);
+        }
+      }
+    } else {
+      run++;
+      out.push(runRule(ctx, drafts.slice(i, j), sig, run));
+    }
+    i = j;
+  }
+  return out;
+}
+function runRule(ctx, members, sig, run) {
+  const props = new Set(members.flatMap((d) => Object.keys(d.set)));
+  const parts = sig.split("\0");
+  const field = parts[0] === "eq" && parts[1] === "[]" ? parts[2] : null;
+  const map = {};
+  for (const p of props) {
+    map[p] = runMapping(ctx, members, p, { field, key: `winner.${String(run)}.${p}` });
+  }
+  const first = members[0].id.split(".").pop() ?? "";
+  return {
+    id: `${ctx.kind}.sheet.by.${parts[0] === "eq" ? "value" : parts[0]}.${first}`,
+    target: ctx.kind,
+    role: "mapping",
+    origin: "declared",
+    where: { all: true },
+    map,
+    facts: { elements: members.reduce((sum, d) => sum + d.list.length, 0) }
+  };
+}
+function runMapping(ctx, members, p, names) {
+  const winner = new Array(ctx.out).fill(null);
+  const table = /* @__PURE__ */ new Map();
+  for (const d of members) {
+    const value = d.set[p];
+    if (value === void 0 || d.single === null) {
+      continue;
+    }
+    const { key } = d.single;
+    table.set(`${typeof key}:${String(key)}`, [key, value]);
+    for (const c of d.list) {
+      const k = ctx.coreToOut[c];
+      if (k >= 0) {
+        winner[k] = key;
+      }
+    }
+    ctx.spend(d.list.length);
+  }
+  const entries = [...table.values()];
+  const byKey = new Map(entries.map(([k, v]) => [`${typeof k}:${String(k)}`, v]));
+  const { field } = names;
+  if (field !== null && faithful(ctx, field) && sameByData(ctx, field, winner, byKey)) {
+    return { kind: "discrete", by: { data: field }, table: entries };
+  }
+  ctx.columns.set(names.key, winner);
+  return { kind: "discrete", by: { style: names.key }, table: entries };
+}
+function sameByData(ctx, field, winner, byKey) {
+  const table = ctx.kind === "node" ? ctx.snapshot?.nodes : ctx.snapshot?.edges;
+  if (!table?.names().includes(field)) {
+    return false;
+  }
+  for (let k = 0; k < ctx.out; k++) {
+    const v = plainCell(table.value(field, k));
+    const viaData = typeof v === "string" || typeof v === "number" ? byKey.get(`${typeof v}:${String(v)}`) ?? null : null;
+    const w = winner[k];
+    const viaWinner = w === null ? null : byKey.get(`${typeof w}:${String(w)}`) ?? null;
+    if (viaData !== viaWinner) {
+      return false;
+    }
+  }
+  return true;
+}
+function cytoscapeJsStyles(input) {
+  const notes = input.notes ?? new StyleNotes();
+  const r = evaluateCytoscapeJs({ ...input, notes });
+  const output = (t) => ({ values: t.values, rules: t.rules, columns: t.columns });
+  return {
+    canonical: true,
+    dialect: "cytoscape-js",
+    tool: "cytoscape-js",
+    units: "px",
+    node: output(r.node),
+    edge: output(r.edge),
+    notes: notes.list()
+  };
+}
+const CYTOSCAPE_IMPORT_KEY = "graphty_import";
+function cytoscapeStyleKey(key) {
+  return `graphty_style_${key.replaceAll(/\W/g, "_")}`;
+}
+const PLAIN_NAME = /^[A-Za-z_]\w*$/;
+const SHAPES_TO_CYJS = /* @__PURE__ */ new Map([
+  ["ellipse", "ellipse"],
+  ["rectangle", "rectangle"],
+  ["round-rectangle", "round-rectangle"],
+  ["triangle", "triangle"],
+  ["diamond", "diamond"],
+  ["pentagon", "pentagon"],
+  ["hexagon", "hexagon"],
+  ["octagon", "octagon"],
+  ["parallelogram", "rhomboid"],
+  ["star", "star"],
+  ["vee", "vee"]
+]);
+const ARROWS_TO_CYJS = /* @__PURE__ */ new Map([
+  ["none", "none"],
+  ["triangle", "triangle"],
+  ["vee", "vee"],
+  ["tee", "tee"],
+  ["diamond", "diamond"],
+  ["circle", "circle"],
+  ["square", "square"]
+]);
+const ARROWS_NEAREST = /* @__PURE__ */ new Map([
+  ["triangle-open", "triangle"],
+  ["diamond-open", "diamond"],
+  ["circle-open", "circle"],
+  ["half", "triangle"],
+  ["inverted", "triangle"],
+  ["crow", "vee"]
+]);
+function toCyjs(target, property, value) {
+  const specs = target === "node" ? CYJS_NODE_PROPERTIES : CYJS_EDGE_PROPERTIES;
+  switch (property) {
+    case "visible":
+      return exact({ display: value === false ? "none" : "element" });
+    case "labelItalic":
+      return exact({ "font-style": value === true ? "italic" : "normal" });
+    case "curved":
+      return exact({ "curve-style": value === true ? "unbundled-bezier" : "straight" });
+    case "labelPosition":
+      return labelPositionToCyjs(String(value));
+    case "shape":
+      return enumToCyjs("shape", String(value), SHAPES_TO_CYJS, specs);
+    case "borderStyle":
+      return borderStyleToCyjs(String(value));
+    case "lineStyle":
+      return lineStyleToCyjs(String(value));
+    case "sourceArrow":
+    case "targetArrow":
+      return arrowToCyjs(
+        property === "sourceArrow" ? "source-arrow-shape" : "target-arrow-shape",
+        String(value),
+        specs
+      );
+    case "labelFont":
+      return isFontFamily(String(value)) ? exact({ "font-family": String(value) }) : null;
+    default:
+      return propertyToCyjs(property, value, specs);
+  }
+}
+function exact(props) {
+  return { props, approximate: false };
+}
+function near(props) {
+  return { props, approximate: true };
+}
+function labelPositionToCyjs(text) {
+  const v = ["top", "bottom"].find((x) => text.startsWith(x)) ?? "center";
+  const h = ["left", "right"].find((x) => text.endsWith(x)) ?? "center";
+  return exact({ "text-valign": v, "text-halign": h });
+}
+function enumToCyjs(name, value, table, specs) {
+  const cy = table.get(value);
+  if (cy !== void 0) {
+    return exact({ [name]: cy });
+  }
+  const other = value.startsWith("other:") ? value.slice(6) : null;
+  return other !== null && specs.get(name)?.enums?.includes(other) === true ? exact({ [name]: other }) : null;
+}
+function arrowToCyjs(name, value, specs) {
+  const own = enumToCyjs(name, value, ARROWS_TO_CYJS, specs);
+  if (own !== null) {
+    return own;
+  }
+  const nearest = ARROWS_NEAREST.get(value);
+  return nearest === void 0 ? null : near({ [name]: nearest });
+}
+function borderStyleToCyjs(value) {
+  if (value === "dash-dot") {
+    return near({ "border-style": "dashed" });
+  }
+  return ["solid", "dotted", "dashed", "double"].includes(value) ? exact({ "border-style": value }) : null;
+}
+function lineStyleToCyjs(value) {
+  if (["solid", "dotted", "dashed"].includes(value)) {
+    return exact({ "line-style": value });
+  }
+  return near({ "line-style": value === "dash-dot" || value === "long-dash" ? "dashed" : "solid" });
+}
+function propertyToCyjs(property, value, specs) {
+  const entry = Array.from(specs).find(([, spec2]) => spec2.property === property);
+  if (entry === void 0) {
+    return null;
+  }
+  const [name, spec] = entry;
+  if (spec.type === "positive" && !(typeof value === "number" && value > 0)) {
+    return null;
+  }
+  if (value === "" && /label$/i.test(property)) {
+    return exact({ [name]: " " });
+  }
+  return exact({ [name]: typeof value === "boolean" ? String(value) : value });
+}
+function literal(v) {
+  if (typeof v === "number") {
+    return Number.isFinite(v) ? String(v) : null;
+  }
+  if (typeof v !== "string" || v.includes("\\") || /[\n\r\u2028\u2029]/.test(v)) {
+    return null;
+  }
+  if (!v.includes('"')) {
+    return `"${v}"`;
+  }
+  return v.includes("'") ? null : `'${v}'`;
+}
+function flatKey(e, target, source) {
+  const known = e.keys[target].get(source);
+  if (known !== void 0) {
+    return { key: known, fresh: false };
+  }
+  let key = cytoscapeStyleKey(source);
+  let k = 2;
+  while (e.used[target].has(key)) {
+    key = `${cytoscapeStyleKey(source)}_${String(k)}`;
+    k++;
+  }
+  e.keys[target].set(source, key);
+  e.used[target].add(key);
+  return { key, fresh: true };
+}
+function writeColumn(e, target, key, values) {
+  const rows = e.data[target];
+  for (let i = 0; i < rows.length && i < values.length; i++) {
+    const v = values[i];
+    if (v !== null && v !== void 0 && v !== false) {
+      rows[i][key] = v;
+    }
+  }
+}
+function testsOf(e, target, where) {
+  if ("all" in where) {
+    return where.all ? [""] : null;
+  }
+  if ("has" in where) {
+    const k = keyOf(e, target, where.has);
+    return k === null || !("style" in where.has) ? null : [`[${k}]`];
+  }
+  if ("eq" in where) {
+    return equalTest(e, target, where.eq, "=");
+  }
+  if ("in" in where) {
+    const k = keyOf(e, target, where.in[0]);
+    const values = where.in[1].map((x) => literal(x));
+    if (values.length === 0) {
+      return [];
+    }
+    return k === null || values.includes(null) ? null : values.map((v) => `[${k} = ${String(v)}]`);
+  }
+  if ("not" in where) {
+    return notTests(e, target, where.not);
+  }
+  if ("and" in where) {
+    return andTests(e, target, where.and);
+  }
+  if ("or" in where) {
+    return orTests(e, target, where.or);
+  }
+  return null;
+}
+function equalTest(e, target, eq, op) {
+  const k = keyOf(e, target, eq[0]);
+  const v = literal(eq[1]);
+  return k === null || v === null ? null : [`[${k} ${op} ${v}]`];
+}
+function notTests(e, target, inner) {
+  if ("has" in inner && "style" in inner.has) {
+    const k = keyOf(e, target, inner.has);
+    return k === null ? null : [`[^${k}]`];
+  }
+  return "eq" in inner ? equalTest(e, target, inner.eq, "!=") : null;
+}
+function andTests(e, target, parts) {
+  let alts = [""];
+  for (const p of parts) {
+    const t = testsOf(e, target, p);
+    if (t === null) {
+      return null;
+    }
+    alts = alts.flatMap((a) => t.map((b) => a + b));
+    if (alts.length > 8) {
+      return null;
+    }
+  }
+  return alts;
+}
+function orTests(e, target, parts) {
+  const out = [];
+  for (const p of parts) {
+    const t = testsOf(e, target, p);
+    if (t === null) {
+      return null;
+    }
+    out.push(...t);
+  }
+  return out.length > 8 ? null : out;
+}
+function keyOf(e, target, ref) {
+  if ("style" in ref) {
+    const col = e.extracted.columns[target].get(ref.style);
+    if (col === void 0) {
+      return null;
+    }
+    const { key, fresh } = flatKey(e, target, ref.style);
+    if (fresh) {
+      writeColumn(e, target, key, col);
+    }
+    return key;
+  }
+  if ("data" in ref && PLAIN_NAME.test(ref.data) && ref.data !== CYTOSCAPE_IMPORT_KEY && !ref.data.startsWith("graphty_")) {
+    return ref.data;
+  }
+  return null;
+}
+function selectorsOf(e, rule, index) {
+  const head = `${rule.target}${e.scope}`;
+  const tests = testsOf(e, rule.target, rule.where);
+  if (tests !== null) {
+    return tests.map((t) => head + t);
+  }
+  const src = refSource(
+    rule.target,
+    e.data[rule.target].length,
+    e.extracted.columns[rule.target],
+    e.extracted.features[rule.target]
+  );
+  const { key } = flatKey(e, rule.target, `emit.where.${String(index)}`);
+  const col = new Array(src.n);
+  for (let i = 0; i < src.n; i++) {
+    col[i] = matches(rule.where, src, i) ? true : null;
+  }
+  writeColumn(e, rule.target, key, col);
+  return [`${head}[${key}]`];
+}
+function emitRule(e, rule, index) {
+  const { target } = rule;
+  const selectors = selectorsOf(e, rule, index);
+  const constants = {};
+  for (const [p, v] of Object.entries(rule.set ?? {})) {
+    if (v === void 0) {
+      continue;
+    }
+    const w = written(e, target, p, v);
+    if (w !== null) {
+      Object.assign(constants, w);
+    }
+  }
+  if (Object.keys(constants).length > 0) {
+    for (const sel of selectors) {
+      e.stylesheet.push({ selector: sel, style: constants });
+      if (target === "edge" && constants["curve-style"] === "straight") {
+        e.stylesheet.push({ selector: `${sel}:loop`, style: { "curve-style": "haystack" } });
+      }
+    }
+  }
+  for (const [p, m] of Object.entries(rule.map ?? {})) {
+    if (m !== void 0) {
+      emitMapping(e, rule, index, selectors, p, m);
+    }
+  }
+}
+function cyjsHoldsExactly(target, property, value) {
+  const w = toCyjs(target, property, value);
+  return w !== null && !w.approximate;
+}
+function written(e, target, property, value) {
+  const w = toCyjs(target, property, value);
+  if (w === null) {
+    e.notes.add(STYLE_ISSUE.NOT_WRITTEN, target, property, { sample: value });
+    return null;
+  }
+  if (w.approximate) {
+    e.notes.add(STYLE_ISSUE.APPROXIMATED, target, property, { sample: value });
+  }
+  return w.props;
+}
+function emitMapping(e, rule, index, selectors, property, m) {
+  const { target } = rule;
+  if (m.kind === "discrete") {
+    const key = keyOf(e, target, m.by);
+    const keys = m.table.map(([k]) => literal(k));
+    if (key === null || keys.includes(null)) {
+      emitValues(e, rule, index, selectors, property);
+      return;
+    }
+    m.table.forEach(([, v], j) => {
+      const w = written(e, target, property, v);
+      if (w === null) {
+        return;
+      }
+      for (const sel of selectors) {
+        e.stylesheet.push({ selector: `${sel}[${key} = ${String(keys[j])}]`, style: w });
+      }
+    });
+    return;
+  }
+  if (m.kind === "continuous" && isNumericOutput(target, property)) {
+    const key = numericKey(e, target, m.by, index);
+    if (key !== null) {
+      emitContinuous(e, target, selectors, property, key, m.points);
+      return;
+    }
+  }
+  emitValues(e, rule, index, selectors, property);
+}
+function isNumericOutput(target, property) {
+  const kind = STYLE_PROPERTIES[target].get(property);
+  return kind === "number" || kind === "opacity" || kind === "color";
+}
+function numericKey(e, target, by, index) {
+  const src = refSource(target, e.data[target].length, e.extracted.columns[target], e.extracted.features[target]);
+  const col = src.column(by);
+  if (col === null) {
+    return null;
+  }
+  if ("data" in by && PLAIN_NAME.test(by.data) && !by.data.startsWith("graphty_")) {
+    return by.data;
+  }
+  const { key } = flatKey(e, target, `emit.input.${String(index)}`);
+  const values = new Array(src.n);
+  for (let i = 0; i < src.n; i++) {
+    const v = col[i];
+    values[i] = typeof v === "number" && Number.isFinite(v) ? v : null;
+  }
+  writeColumn(e, target, key, values);
+  return key;
+}
+function emitContinuous(e, target, selectors, property, key, points) {
+  if (points.length === 0) {
+    return;
+  }
+  const lit = String;
+  const push = (test, style) => {
+    if (style === null) {
+      return;
+    }
+    for (const sel of selectors) {
+      e.stylesheet.push({ selector: `${sel}${test}`, style });
+    }
+  };
+  const first = points[0];
+  const last = points.at(-1) ?? first;
+  push(`[${key} < ${lit(first.at)}]`, written(e, target, property, first.below));
+  for (let k = 0; k + 1 < points.length; k++) {
+    const a = points[k];
+    const b = points[k + 1];
+    const wa = written(e, target, property, a.above);
+    const wb = written(e, target, property, b.below);
+    if (wa === null || wb === null) {
+      continue;
+    }
+    const style = {};
+    for (const name of Object.keys(wa)) {
+      style[name] = `mapData(${key}, ${lit(a.at)}, ${lit(b.at)}, ${String(wa[name])}, ${String(wb[name])})`;
+    }
+    push(`[${key} > ${lit(a.at)}][${key} < ${lit(b.at)}]`, style);
+  }
+  push(`[${key} > ${lit(last.at)}]`, written(e, target, property, last.above));
+  for (const p of points) {
+    push(`[${key} = ${lit(p.at)}]`, written(e, target, property, p.value));
+  }
+}
+function emitValues(e, rule, index, selectors, property) {
+  const { target } = rule;
+  const n = e.data[target].length;
+  const src = refSource(target, n, e.extracted.columns[target], e.extracted.features[target]);
+  const mapping = new Map(Object.entries(rule.map ?? {})).get(property);
+  const only = { ...rule, where: { all: true }, set: void 0, map: { [property]: mapping } };
+  const values = resolveRules([only], target, property, src);
+  const names = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const v = values[i];
+    if (v === null) {
+      continue;
+    }
+    const w = written(e, target, property, v);
+    if (w === null) {
+      continue;
+    }
+    for (const [name, x] of Object.entries(w)) {
+      let col = names.get(name);
+      if (col === void 0) {
+        col = new Array(n).fill(null);
+        names.set(name, col);
+      }
+      col[i] = x;
+    }
+  }
+  for (const [name, col] of names) {
+    const { key } = flatKey(e, target, `emit.value.${String(index)}.${name}`);
+    writeColumn(e, target, key, col);
+    for (const sel of selectors) {
+      e.stylesheet.push({ selector: `${sel}[${key}]`, style: { [name]: `data(${key})` } });
+    }
+  }
+}
+function toCytoscapeStylesheet(extracted, options = {}) {
+  const notes = new StyleNotes();
+  const importId = options.importId?.replaceAll(/["'\\\n\r\u2028\u2029]/g, "_");
+  const { nodes } = extracted.fingerprint;
+  const { edges } = extracted.fingerprint;
+  const e = {
+    extracted,
+    notes,
+    scope: importId === void 0 ? "" : `[${CYTOSCAPE_IMPORT_KEY} = "${importId}"]`,
+    stylesheet: [],
+    data: {
+      node: Array.from({ length: nodes }, () => ({})),
+      edge: Array.from({ length: edges }, () => ({}))
+    },
+    keys: { node: /* @__PURE__ */ new Map(), edge: /* @__PURE__ */ new Map() },
+    // a flat key never takes the name of a data field the elements already hold
+    used: {
+      node: /* @__PURE__ */ new Set([CYTOSCAPE_IMPORT_KEY, ...dataNames(extracted, "node")]),
+      edge: /* @__PURE__ */ new Set([CYTOSCAPE_IMPORT_KEY, ...dataNames(extracted, "edge")])
+    }
+  };
+  if (importId !== void 0) {
+    for (const rows2 of [e.data.node, e.data.edge]) {
+      for (const row of rows2) {
+        row[CYTOSCAPE_IMPORT_KEY] = importId;
+      }
+    }
+  }
+  const rules = extracted.styles.source.tool === "cytoscape-js" ? extracted.styles.rules.filter((r) => r.origin !== "tool") : extracted.styles.rules;
+  rules.forEach((rule, k) => {
+    if (rule.role !== "exceptions") {
+      emitRule(e, rule, k);
+    }
+  });
+  const bypass = exactness(e, rules);
+  for (const sel of e.stylesheet) {
+    if (parseCyjsSelector(sel.selector).invalid) {
+      notes.add(STYLE_ISSUE.NOT_WRITTEN, null, "selector", { sample: sel.selector });
+    }
+  }
+  const rows = (list) => list.map((r) => Object.keys(r).length > 0 ? r : null);
+  return {
+    stylesheet: e.stylesheet,
+    elementData: { node: rows(e.data.node), edge: rows(e.data.edge) },
+    bypass,
+    notes: notes.list()
+  };
+}
+function exactness(e, rules) {
+  const { extracted } = e;
+  const nodes = e.data.node.length;
+  const elements = [];
+  for (let i = 0; i < nodes; i++) {
+    elements.push({
+      group: "nodes",
+      data: { ...dataColumns(extracted, "node", i), ...e.data.node[i], id: `n${String(i)}` }
+    });
+  }
+  const far = nodes > 1 ? "n1" : "n0";
+  for (let i = 0; i < e.data.edge.length && nodes > 0; i++) {
+    elements.push({
+      group: "edges",
+      data: {
+        ...dataColumns(extracted, "edge", i),
+        ...e.data.edge[i],
+        id: `e${String(i)}`,
+        source: "n0",
+        target: far
+      }
+    });
+  }
+  const drawn = evaluateCytoscapeJs({ elements, style: e.stylesheet, toolDefaults: false });
+  const out = {
+    node: [],
+    edge: []
+  };
+  for (const target of ["node", "edge"]) {
+    const n = e.data[target].length;
+    const src = refSource(target, n, extracted.columns[target], extracted.features[target]);
+    const rows = new Array(n).fill(null);
+    for (const property of STYLE_PROPERTIES[target].keys()) {
+      const want = resolveRules(rules, target, property, src);
+      addBypasses(rows, target, property, want, drawn[target].values[property]);
+    }
+    out[target] = rows;
+  }
+  return out;
+}
+function addBypasses(rows, target, property, want, got) {
+  for (let i = 0; i < rows.length; i++) {
+    const w = want[i];
+    const conv = w === null || (got?.[i] ?? null) === w ? null : toCyjs(target, property, w);
+    if (conv !== null && !conv.approximate) {
+      rows[i] = { ...rows[i], ...conv.props };
+    }
+  }
+}
+function dataNames(extracted, target) {
+  return extracted.features[target].flatMap((f) => "data" in f.ref ? [f.ref.data] : []);
+}
+function dataColumns(extracted, target, i) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const f of extracted.features[target]) {
+    if ("data" in f.ref && f.values[i] !== null) {
+      out[f.ref.data] = f.values[i];
+    }
+  }
+  return out;
+}
+export {
+  CYTOSCAPE_IMPORT_KEY as C,
+  StyleBudget as S,
+  cyjsHoldsExactly as a,
+  CYJS_EDGE_PROPERTIES as b,
+  cytoscapeJsStyles as c,
+  CYJS_NODE_PROPERTIES as d,
+  evaluateCytoscapeJs as e,
+  toCytoscapeStylesheet as t
+};
+//# sourceMappingURL=emit-DZy6JgdA.js.map