@graphty/graph-io 0.3.43 → 0.3.45

package/dist/gml.js

@@ -1,8 +1,17 @@
-import { ak as SYNTAX_CODE, b as plural, a as checkCapabilities, L as LOSS, p as pairFolding, $ as agree, c as capabilities, r as resolveExportOptions, ac as DictHeuristic, aG as formatInteger, bv as formatGmlReal, aE as sanitizeIds, bD as countMixedEdges, e as explicitWeights, bU as DICT_SAMPLE_ROWS, R as ROLE_TAKEN_CODE$1, aj as WIDENED_CODE$1, P as PRECISION_CODE$1, n as DUPLICATE_NODE_CODE$1, s as MISSING_ENDPOINT_CODE$1, t as MISSING_ID_CODE$1, l as MULTIPLE_GRAPHS_CODE, N as NO_GRAPH_CODE$1, al as resolveImportOptions, a8 as ImportReportBuilder, an as reportUnusedOptions, bB as readText, am as throwIfAborted, ao as reportSinkOptions, ap as graphChosen, ar as IdCoercer, aq as DirectionResolver, a0 as uniqueColumnName, C as COLUMN_RENAMED_CODE, as as weightFromValue, bV as reportWeightPrecision, aK as parseWeightText, a1 as declareResolved, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, I as ID_MERGED_CODE, ae as AMBIGUOUS_GRAPH_NAME_CODE, af as GRAPH_NOT_FOUND_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-rKLeGQMo.js";
+import { a8 as SYNTAX_CODE, p as plural, a as agree, ad as formatInteger, aP as formatGmlReal, R as ROLE_TAKEN_CODE$1, a7 as WIDENED_CODE$1, P as PRECISION_CODE$1, k as DUPLICATE_NODE_CODE$1, n as MISSING_ENDPOINT_CODE$1, o as MISSING_ID_CODE$1, i as MULTIPLE_GRAPHS_CODE, N as NO_GRAPH_CODE$1, Z as ImportReportBuilder, C as COLUMN_RENAMED_CODE, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, b as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, I as ID_MERGED_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, s as UNKNOWN_ENCODING_CODE, t as ENCODING_FALLBACK_CODE, u as INVALID_ENCODING_CODE, v as INVALID_UTF8_CODE, y as ELEMENT_ISSUE, z as INPUT_ISSUE } from "./chunks/format-BpQBx8MZ.js";
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { k as decodeGmlString, m as quoteGmlString } from "./chunks/escape-B62ZGM_a.js";
+import { c as capabilities, a as checkCapabilities, L as LOSS, p as pairFolding, G as sanitizeIds, ai as countMixedEdges, e as explicitWeights, r as resolveExportOptions, D as DictHeuristic, ag as DICT_SAMPLE_ROWS, g as resolveImportOptions, i as reportUnusedOptions, ab as readText, h as throwIfAborted, j as reportSinkOptions, k as graphChosen, I as IdCoercer, l as DirectionResolver, u as uniqueColumnName, w as weightFromValue, ak as reportWeightPrecision, s as parseWeightText, d as declareResolved } from "./chunks/export-BvqAXCKh.js";
+import { n as decodeGmlString, o as quoteGmlString } from "./chunks/escape-CgzxiYPg.js";
 import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
-import { i as importChosenGraph } from "./chunks/choose-DvpbdRuz.js";
+import { y as yedValue, a as yedColor, b as yedSpelled, c as bendsToPoints, Y as YED_SHAPES, d as YED_LINES, v as valueColumns, e as canonBends, f as flowchartShape, F as FONT_STYLES, g as YED_ARROWS } from "./chunks/styles-yed-Cz9rLBCP.js";
+import { w as writeStyleBlock, c as styleBlockLosses, t as StyleNotes, b as styleTag, p as plainCell, u as parseStyleBlock, s as styleFingerprint, v as blockStyles, o as canonText, r as resolveStyles, h as canonNumber, l as canonEnum, n as noteAt, M as MAX_STYLE_VALUE_LENGTH, a as STYLE_ISSUE, g as canonColor, x as colorOpacity, k as scalarText, S as STYLE_BLOCK_NAME } from "./chunks/block-CPCHkX42.js";
+import { C as CYTOSCAPE_LEXICON } from "./chunks/lexicon-WMsNddyU.js";
+import { S as StyleApproximations } from "./chunks/approximations-DJMHdDvv.js";
+import { d as dataRead } from "./chunks/writer-gQ8kx99H.js";
+import { r as gephiRules } from "./chunks/styles-DvoFBKCK.js";
+import { i as importChosenGraph } from "./chunks/choose--jM0yYCo.js";
+import { t as toolOf } from "./chunks/units-XMZFIFe1.js";
+import { m as median } from "./chunks/convert-BcQ8_jMo.js";
 const TOKEN_WORD = 0;
 const TOKEN_INT = 1;
 const TOKEN_REAL = 2;
@@ -45,6 +54,7 @@ class GmlTokens {
    */
   constructor(text, capacity = 1024) {
     this.count = 0;
+    this.backslashEscapes = false;
     this.onUnknownEntity = null;
     this.text = text;
     this.kind = new Uint8Array(capacity);
@@ -88,6 +98,9 @@ class GmlTokens {
     if (text.includes("\r")) {
       text = text.replaceAll(/\r\n?/g, "\n");
     }
+    if (this.backslashEscapes && text.includes("\\")) {
+      text = text.replaceAll(/\\([\s\S])/g, "$1");
+    }
     if (!text.includes("&")) {
       return text;
     }
@@ -135,62 +148,95 @@ class GmlTokens {
 }
 function tokenizeGml(text) {
   const tokens = new GmlTokens(text, Math.max(1024, text.length >>> 3));
-  const n = text.length;
+  tokens.backslashEscapes = writtenByOgdf(text);
+  const lex = { text, tokens, i: 0, line: 1, spanningLine: 0 };
+  while (lex.i < text.length) {
+    const c = text.codePointAt(lex.i) ?? 0;
+    if (c === 34) {
+      lexString(lex);
+    } else if (c === 91 || c === 93) {
+      tokens.push(c === 91 ? TOKEN_OPEN : TOKEN_CLOSE, lex.i, lex.i + 1, lex.line);
+      lex.i++;
+    } else if (!skipSpace(lex, c)) {
+      lexBare(lex);
+    }
+  }
+  validateStructure(tokens);
+  return tokens;
+}
+function skipSpace(lex, c) {
+  const { text } = lex;
+  if (c === 10 || c === 13) {
+    lex.line++;
+    lex.i++;
+    if (c === 13 && lex.i < text.length && text.codePointAt(lex.i) === 10) {
+      lex.i++;
+    }
+  } else if (c === 32 || c === 9 || c === 11 || c === 12 || c === 65279) {
+    lex.i++;
+  } else if (c === 35) {
+    lex.i = endOfLine(text, lex.i);
+  } else {
+    return false;
+  }
+  return true;
+}
+function lexString(lex) {
+  const { text, tokens, i } = lex;
+  const close = tokens.backslashEscapes ? escapedClose(text, i + 1) : text.indexOf('"', i + 1);
+  if (close < 0) {
+    const hint = lex.spanningLine === 0 ? "" : `; the string opened at line ${lex.spanningLine} spans lines, so a quote may be missing there`;
+    throw new GmlSyntaxError(SYNTAX_STRING_CODE, `unclosed string opened at line ${lex.line}${hint}`, lex.line);
+  }
+  tokens.push(TOKEN_STRING, i + 1, close, lex.line);
+  const opened = lex.line;
+  for (let k = i + 1; k < close; k++) {
+    const d = text.codePointAt(k);
+    if (d === 10 || d === 13 && text.codePointAt(k + 1) !== 10) {
+      lex.line++;
+    }
+  }
+  if (lex.line !== opened && lex.spanningLine === 0) {
+    lex.spanningLine = opened;
+  }
+  lex.i = close + 1;
+}
+function lexBare(lex) {
+  const { text, i } = lex;
+  let j = i + 1;
+  while (j < text.length && !isDelimiter(text.codePointAt(j) ?? 0)) {
+    j++;
+  }
+  lex.tokens.push(classifyBare(text, i, j, lex.line), i, j, lex.line);
+  lex.i = j;
+}
+function writtenByOgdf(text) {
+  const end = Math.min(text.length, 512);
   let i = 0;
-  let line = 1;
-  let spanningLine = 0;
-  while (i < n) {
-    const c = text.charCodeAt(i);
-    if (c === 10) {
-      line++;
-      i++;
-    } else if (c === 13) {
-      line++;
-      i++;
-      if (i < n && text.charCodeAt(i) === 10) {
+  while (i < end) {
+    const c = text.codePointAt(i);
+    if (c === 35) {
+      while (i < end && text.codePointAt(i) !== 10 && text.codePointAt(i) !== 13) {
         i++;
       }
-    } else if (c === 32 || c === 9 || c === 11 || c === 12) {
-      i++;
-    } else if (c === 65279) {
+    } else if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || c === 11) {
       i++;
-    } else if (c === 35) {
-      i = endOfLine(text, i);
-    } else if (c === 91) {
-      tokens.push(TOKEN_OPEN, i, i + 1, line);
-      i++;
-    } else if (c === 93) {
-      tokens.push(TOKEN_CLOSE, i, i + 1, line);
-      i++;
-    } else if (c === 34) {
-      const close = text.indexOf('"', i + 1);
-      if (close < 0) {
-        const hint = spanningLine === 0 ? "" : `; the string opened at line ${spanningLine} spans lines, so a quote may be missing there`;
-        throw new GmlSyntaxError(SYNTAX_STRING_CODE, `unclosed string opened at line ${line}${hint}`, line);
-      }
-      tokens.push(TOKEN_STRING, i + 1, close, line);
-      const opened = line;
-      for (let k = i + 1; k < close; k++) {
-        const d = text.codePointAt(k);
-        if (d === 10 || d === 13 && text.codePointAt(k + 1) !== 10) {
-          line++;
-        }
-      }
-      if (line !== opened && spanningLine === 0) {
-        spanningLine = opened;
-      }
-      i = close + 1;
     } else {
-      let j = i + 1;
-      while (j < n && !isDelimiter(text.charCodeAt(j))) {
-        j++;
-      }
-      tokens.push(classifyBare(text, i, j, line), i, j, line);
-      i = j;
+      break;
     }
   }
-  validateStructure(tokens);
-  return tokens;
+  return /^Creator\s+"ogdf::/.test(text.slice(i, i + 64));
+}
+function escapedClose(text, from) {
+  let k = from;
+  while (k < text.length) {
+    const c = text.codePointAt(k);
+    if (c === 34) {
+      return k;
+    }
+    k += c === 92 ? 2 : 1;
+  }
+  return -1;
 }
 function endOfLine(text, from) {
   const n = text.length;
@@ -258,15 +304,8 @@ function validateStructure(tokens) {
         tokens.line[i]
       );
     }
-    const vk = kind[value];
-    if (vk === TOKEN_OPEN) {
+    if (checkValue(tokens, i) === TOKEN_OPEN) {
       stack.push(value);
-    } else if (vk === TOKEN_CLOSE || vk === TOKEN_WORD && !NON_FINITE_WORD.test(tokens.textOf(value))) {
-      throw new GmlSyntaxError(
-        SYNTAX_STRUCTURE_CODE,
-        `expected a value for key "${tokens.textOf(i)}" at line ${tokens.line[i]}, found ${describeToken(tokens, value)}`,
-        tokens.line[value]
-      );
     }
     i = value + 1;
   }
@@ -280,6 +319,23 @@ function validateStructure(tokens) {
   }
   tokens.match = match;
 }
+function checkValue(tokens, key) {
+  const { kind } = tokens;
+  const value = key + 1;
+  const word = kind[value] === TOKEN_WORD && !NON_FINITE_WORD.test(tokens.textOf(value));
+  if (word && tokens.textOf(key) === "Creator") {
+    kind[value] = TOKEN_STRING;
+    return TOKEN_STRING;
+  }
+  if (kind[value] === TOKEN_CLOSE || word) {
+    throw new GmlSyntaxError(
+      SYNTAX_STRUCTURE_CODE,
+      `expected a value for key "${tokens.textOf(key)}" at line ${tokens.line[key]}, found ${describeToken(tokens, value)}`,
+      tokens.line[value]
+    );
+  }
+  return kind[value];
+}
 function describeToken(tokens, i) {
   switch (tokens.kind[i]) {
     case TOKEN_OPEN:
@@ -305,6 +361,7 @@ function numberOfText(text) {
 function isGmlKey(text) {
   return STRICT_KEY_TEXT.test(text);
 }
+const KEY_MANGLED_CODE = "W_GML_KEY_MANGLED";
 function mangleGmlKey(text) {
   const body = text.replaceAll(/\W/g, "_");
   return /^[A-Za-z]/.test(body) ? body : `x${body}`;
@@ -367,6 +424,758 @@ function storeValue(frame, key, value) {
 function scalarOrRecord(tokens, v) {
   return tokens.kind[v] === TOKEN_OPEN ? parseRecord(tokens, v) : numberOfText(tokens.textOf(v));
 }
+const WRITERS = [
+  [
+    /^\s*(yfiles|yed)\b/i,
+    { dialect: "yed", tool: "yed", vocabulary: "yed", spelling: "yed", units: "px", labelKey: false }
+  ],
+  [
+    /^\s*cytoscape\b/i,
+    {
+      dialect: "cytoscape",
+      tool: "cytoscape",
+      vocabulary: "cytoscape",
+      spelling: "cytoscape",
+      units: "px",
+      labelKey: true
+    }
+  ],
+  [
+    /^\s*gephi\b/i,
+    {
+      dialect: "gephi",
+      tool: "gephi",
+      vocabulary: "graphlet",
+      spelling: "css",
+      units: "relative",
+      labelKey: false
+    }
+  ],
+  [
+    /^\s*ogdf::/i,
+    { dialect: "ogdf", tool: "ogdf", vocabulary: "ogdf", spelling: "css", units: "px", labelKey: true }
+  ],
+  // igraph writes a Creator line, but no drawing defaults of igraph's are stated by a primary source
+  [
+    /^\s*igraph\b/i,
+    { dialect: "igraph", tool: null, vocabulary: "graphlet", spelling: "css", units: "px", labelKey: true }
+  ]
+];
+const UNKNOWN_WRITER = {
+  dialect: "gml",
+  tool: null,
+  vocabulary: "graphlet",
+  spelling: "css",
+  units: "px",
+  labelKey: true
+};
+const GRAPHTY_WRITER = { ...WRITERS[0][1], tool: null };
+const GML_STYLE_BLOCK_KEY = mangleGmlKey(STYLE_BLOCK_NAME);
+const TAG_PREFIX = mangleGmlKey("graphty.style.");
+function tagKey(target, key) {
+  return mangleGmlKey(styleTag(target, key));
+}
+function graphText(snapshot, name) {
+  if (!snapshot.graph.has(name)) {
+    return null;
+  }
+  const v = plainCell(snapshot.graph.value(name, 0));
+  if (typeof v === "string") {
+    return v;
+  }
+  return typeof v === "number" ? String(v) : null;
+}
+function writerOf(snapshot) {
+  if (snapshot.graph.has(GML_STYLE_BLOCK_KEY)) {
+    return GRAPHTY_WRITER;
+  }
+  const creator = snapshot.meta.creator ?? graphText(snapshot, "Creator") ?? "";
+  for (const [pattern, writer] of WRITERS) {
+    if (pattern.test(creator)) {
+      return writer;
+    }
+  }
+  return UNKNOWN_WRITER;
+}
+const ARROW_ENDS = /* @__PURE__ */ new Map([
+  ["none", ["none", "none"]],
+  ["last", ["none", "triangle"]],
+  ["first", ["triangle", "none"]],
+  ["both", ["triangle", "triangle"]]
+]);
+const OGDF_STROKES = ["none", "solid", "dashed", "dotted", "dash-dot", "dash-dot"];
+const OGDF_SHAPES = /* @__PURE__ */ new Map([
+  ["rect", "rectangle"],
+  ["rhomb", "diamond"],
+  ["trapeze", "trapezoid"],
+  ["invtrapeze", "trapezoid"],
+  ["invtriangle", "triangle"],
+  ["invparallelogram", "parallelogram"]
+]);
+const YED_LABEL_KEYS = [
+  "outline",
+  "autoSizePolicy",
+  "model",
+  "configuration",
+  "borderDistance",
+  "modelName",
+  "modelPosition"
+];
+const cytoscapeArrow = CYTOSCAPE_LEXICON.edge.get("targetArrow")?.[0]?.[1];
+function sampleOf(raw) {
+  return typeof raw === "string" || typeof raw === "number" ? String(raw).slice(0, MAX_STYLE_VALUE_LENGTH) : "a record";
+}
+function isRec(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function first(r, ...keys) {
+  for (const k of keys) {
+    if (Object.hasOwn(r, k) && r[k] !== void 0) {
+      return r[k];
+    }
+  }
+  return void 0;
+}
+function readColor(raw, property, opacity, writer, put, at) {
+  if (raw === void 0) {
+    return;
+  }
+  const c = canonColor(raw, writer.spelling, at(property));
+  if (c === null) {
+    return;
+  }
+  put(property, c.color);
+  const alpha = colorOpacity(c, null, at(property), opacity !== null);
+  if (opacity !== null) {
+    put(opacity, alpha);
+  }
+}
+function strokeStyle(raw, kind, writer, at) {
+  if (raw === void 0) {
+    return null;
+  }
+  if (writer.vocabulary === "ogdf") {
+    const stroke = OGDF_STROKES[Number(raw)];
+    if (stroke === void 0 || stroke === "none") {
+      noteAt(at, STYLE_ISSUE.UNKNOWN_VALUE, sampleOf(raw));
+      return null;
+    }
+    return stroke;
+  }
+  return canonEnum(kind, raw, writer.spelling, at);
+}
+function readNodeGraphics(g, writer, put, at) {
+  const v = writer.vocabulary;
+  readNodeFill(g, writer, put, at);
+  readNodeOutline(g, writer, put, at);
+  put(
+    "borderStyle",
+    strokeStyle(v === "ogdf" ? g.stipple : g.outlineStyle, "borderStyle", writer, at("borderStyle"))
+  );
+  put("width", g.w === void 0 ? null : canonNumber(g.w, at("width")));
+  put("height", g.h === void 0 ? null : canonNumber(g.h, at("height")));
+  if (g.type !== void 0) {
+    const raw = v === "ogdf" && typeof g.type === "string" ? OGDF_SHAPES.get(g.type.toLowerCase()) ?? g.type : g.type;
+    put("shape", canonEnum("shape", raw, writer.spelling, at("shape")));
+  } else if (v === "yed" && typeof g.customconfiguration === "string") {
+    put("shape", flowchartShape(g.customconfiguration));
+  }
+}
+function readNodeFill(g, writer, put, at) {
+  if (writer.vocabulary === "yed" && Number(g.hasFill) === 0) {
+    noteAt(at("fill"), STYLE_ISSUE.NO_FILL, "hasFill 0");
+    put("fillOpacity", 0);
+    return;
+  }
+  readColor(g.fill, "fill", "fillOpacity", writer, put, at);
+  if (g.fill2 !== void 0) {
+    noteAt(at("fill"), STYLE_ISSUE.GRADIENT, sampleOf(g.fill2));
+  }
+}
+function readNodeOutline(g, writer, put, at) {
+  const v = writer.vocabulary;
+  if (v === "yed" && Number(g.hasOutline) === 0) {
+    put("borderWidth", 0);
+    return;
+  }
+  readColor(v === "ogdf" ? g.line : g.outline, "borderColor", null, writer, put, at);
+  const width = outlineWidthOf(g, v);
+  put("borderWidth", width === void 0 ? null : canonNumber(width, at("borderWidth")));
+}
+function outlineWidthOf(g, v) {
+  switch (v) {
+    case "yed":
+      return g.outlineWidth;
+    case "cytoscape":
+      return first(g, "outline_width", "width");
+    case "ogdf":
+      return g.lineWidth;
+    default:
+      return first(g, "width", "outlineWidth");
+  }
+}
+function readEdgeGraphics(g, writer, put, at) {
+  const v = writer.vocabulary;
+  readColor(g.fill, "color", "opacity", writer, put, at);
+  const width = v === "ogdf" ? first(g, "lineWidth", "width") : g.width;
+  put("width", width === void 0 ? null : canonNumber(width, at("width")));
+  put("lineStyle", strokeStyle(v === "ogdf" ? g.stipple : g.style, "lineStyle", writer, at("lineStyle")));
+  if (typeof g.arrow === "string") {
+    const ends = ARROW_ENDS.get(g.arrow.trim().toLowerCase());
+    if (ends === void 0) {
+      noteAt(at("targetArrow"), STYLE_ISSUE.UNKNOWN_VALUE, g.arrow.slice(0, MAX_STYLE_VALUE_LENGTH));
+    } else {
+      put("sourceArrow", ends[0]);
+      put("targetArrow", ends[1]);
+    }
+  }
+  for (const [keys, property] of [
+    [["sourceArrow", "source_arrow"], "sourceArrow"],
+    [["targetArrow", "target_arrow"], "targetArrow"]
+  ]) {
+    const raw = first(g, ...keys);
+    if (raw === void 0) {
+      continue;
+    }
+    put(
+      property,
+      v === "cytoscape" && cytoscapeArrow !== void 0 ? cytoscapeArrow(raw, at(property)) : canonEnum("arrow", raw, writer.spelling, at(property))
+    );
+  }
+  if (v === "yed") {
+    readYedCurve(g, put);
+  }
+}
+function readYedCurve(g, put) {
+  if (g.smoothBends !== void 0) {
+    const points = isRec(g.Line) ? g.Line.point : void 0;
+    put("curved", Number(g.smoothBends) === 1 && Array.isArray(points) && points.length > 2);
+  }
+}
+function readLabelGraphics(raw, writer, put, at) {
+  const visible = (Array.isArray(raw) ? raw : [raw]).filter((l) => isRec(l) && Number(l.visible) !== 0);
+  const lg = visible.at(0);
+  if (lg === void 0) {
+    return;
+  }
+  const extra = visible.slice(1).filter((l) => l.text !== void 0).length;
+  if (extra > 0) {
+    noteAt(at("label"), STYLE_ISSUE.EXTRA_LABELS, `${String(extra + 1)} labels`);
+  }
+  if (lg.text !== void 0) {
+    put("label", canonText(lg.text, at("label")));
+  }
+  const yedLabel = writer.vocabulary === "yed" || YED_LABEL_KEYS.some((k) => Object.hasOwn(lg, k));
+  if (lg.color !== void 0) {
+    readColor(lg.color, "labelColor", null, writer, put, at);
+  } else if (lg.fill !== void 0 && !yedLabel) {
+    readColor(lg.fill, "labelColor", null, writer, put, at);
+  }
+  if (lg.fill !== void 0 && yedLabel) {
+    noteAt(at("label"), STYLE_ISSUE.NOT_CARRIED, "label background");
+  }
+  readLabelFont(lg, put, at);
+}
+function readLabelFont(lg, put, at) {
+  put("labelSize", lg.fontSize === void 0 ? null : canonNumber(lg.fontSize, at("labelSize")));
+  put("labelFont", lg.fontName === void 0 ? null : canonText(lg.fontName, at("labelFont")));
+  const style = scalarText(lg.fontStyle, at("labelWeight"))?.trim().toLowerCase();
+  if (style !== void 0) {
+    const known = FONT_STYLES.get(style);
+    if (known === void 0) {
+      noteAt(at("labelWeight"), STYLE_ISSUE.UNKNOWN_VALUE, style.slice(0, MAX_STYLE_VALUE_LENGTH));
+    } else {
+      put("labelWeight", known[0]);
+      put("labelItalic", known[1]);
+    }
+  }
+}
+function readElement(target, g, lg, label, writer, put, at) {
+  let text = false;
+  const putLabel = (property, value) => {
+    text ||= property === "label" && value !== null;
+    put(property, value);
+  };
+  if (isRec(g)) {
+    (target === "node" ? readNodeGraphics : readEdgeGraphics)(g, writer, put, at);
+  }
+  if (lg !== null && lg !== void 0) {
+    readLabelGraphics(lg, writer, putLabel, at);
+  }
+  const drawn = writer.vocabulary === "cytoscape" ? target === "node" : writer.labelKey && (isRec(g) || lg !== void 0);
+  if (!text && drawn && label !== null && label !== void 0) {
+    put("label", canonText(label, at("label")));
+  }
+}
+function cellOf(table, name, i) {
+  if (!table.has(name)) {
+    return void 0;
+  }
+  const v = plainCell(table.value(name, i));
+  return v ?? void 0;
+}
+function centerOf(snapshot, i) {
+  const column = snapshot.nodes.byRole("position");
+  const v = column?.isSet(i) === true ? column.value(i) : null;
+  return v === null ? [Number.NaN, Number.NaN] : [v[0], v[1]];
+}
+function lineBends(snapshot, g, e) {
+  const raw = isRec(g) && isRec(g.Line) ? g.Line.point : void 0;
+  if (!Array.isArray(raw) || raw.length < 3) {
+    return null;
+  }
+  const points = raw.slice(1, -1).map((p) => isRec(p) ? [Number(p.x), Number(p.y)] : [Number.NaN, 0]);
+  return canonBends(
+    centerOf(snapshot, snapshot.edgeSource(e)),
+    centerOf(snapshot, snapshot.edgeTarget(e)),
+    points
+  );
+}
+function readValues(snapshot, writer, notes, context) {
+  let found = false;
+  const read = (target) => {
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const out = valueColumns(n);
+    if (!table.has("graphics") && !table.has("LabelGraphics") && writer.vocabulary !== "cytoscape") {
+      return out.values;
+    }
+    for (let i = 0; i < n; i++) {
+      context.budget.spend(target, 1);
+      const at = (property) => ({ notes, target, property, element: i, budget: context.budget });
+      readElement(
+        target,
+        cellOf(table, "graphics", i),
+        cellOf(table, "LabelGraphics", i),
+        cellOf(table, "label", i),
+        writer,
+        (property, value) => {
+          if (value !== null) {
+            found = true;
+            out.put(i, property, value);
+          }
+        },
+        at
+      );
+      if (target === "edge") {
+        const bends = lineBends(snapshot, cellOf(table, "graphics", i), i);
+        if (bends !== null) {
+          found = true;
+          out.put(i, "bends", bends);
+        }
+      }
+    }
+    return out.values;
+  };
+  const node = read("node");
+  const edge = read("edge");
+  return { node, edge, found };
+}
+function blockWithValues(snapshot, text) {
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  if (!parsed.ok || parsed.block.values !== void 0) {
+    return text;
+  }
+  const node = tagValues(snapshot, "node", parsed.block.columns.node);
+  const edge = tagValues(snapshot, "edge", parsed.block.columns.edge);
+  if (node === null || edge === null) {
+    return text;
+  }
+  const raw = JSON.parse(text);
+  return JSON.stringify({ ...raw, values: { node, edge } });
+}
+function tagValues(snapshot, target, keys) {
+  const table = target === "node" ? snapshot.nodes : snapshot.edges;
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const values = {};
+  for (const key of keys) {
+    const name = tagKey(target, key);
+    if (!table.has(name)) {
+      return null;
+    }
+    values[key] = Array.from({ length: n }, (_, i) => {
+      const v = plainCell(table.value(name, i));
+      return typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? v : null;
+    });
+  }
+  return values;
+}
+function styleColumns(table) {
+  return [...table.names()].filter((c) => c === "graphics" || c === "LabelGraphics" || c.startsWith(TAG_PREFIX));
+}
+function gmlStyles(snapshot, context) {
+  const notes = new StyleNotes();
+  const writer = writerOf(snapshot);
+  const values = readValues(snapshot, writer, notes, context);
+  const blockText = graphText(snapshot, GML_STYLE_BLOCK_KEY);
+  const block = blockText === null ? null : blockWithValues(snapshot, blockText);
+  if (block !== null) {
+    exactFromBlock(snapshot, block, values);
+  }
+  if (writer.tool === null && !values.found && block === null) {
+    return null;
+  }
+  const gephi = writer.tool === "gephi" ? gephiRules(snapshot, values.node.fill, values.edge.color, context.budget, values.edge.width) : { rules: [], columns: /* @__PURE__ */ new Map() };
+  return {
+    canonical: true,
+    dialect: writer.dialect,
+    tool: writer.tool,
+    units: writer.units,
+    node: { values: values.node },
+    edge: { values: values.edge, rules: gephi.rules, columns: gephi.columns },
+    notes: notes.list(),
+    opacityInColor: true,
+    block,
+    // the graphics records and the per-element style values of a file graphty wrote hold styles, not data
+    readFrom: { node: styleColumns(snapshot.nodes), edge: styleColumns(snapshot.edges) }
+  };
+}
+const GML_STYLE_CAPABILITIES = Object.freeze({
+  node: Object.freeze([
+    "fill",
+    "fillOpacity",
+    "borderColor",
+    "borderWidth",
+    "borderStyle",
+    "shape",
+    "width",
+    "height",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic"
+  ]),
+  edge: Object.freeze([
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "sourceArrow",
+    "targetArrow",
+    "curved",
+    "bends",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic"
+  ]),
+  block: "native"
+});
+const OWNED = {
+  node: /* @__PURE__ */ new Set([
+    "fill",
+    "fill2",
+    "hasFill",
+    "outline",
+    "hasOutline",
+    "outlineWidth",
+    "outline_width",
+    "outlineStyle",
+    "width",
+    "line",
+    "lineWidth",
+    "stipple",
+    "w",
+    "h",
+    "type"
+  ]),
+  edge: /* @__PURE__ */ new Set([
+    "fill",
+    "width",
+    "lineWidth",
+    "style",
+    "stipple",
+    "arrow",
+    "sourceArrow",
+    "targetArrow",
+    "source_arrow",
+    "target_arrow",
+    "smoothBends"
+  ]),
+  label: /* @__PURE__ */ new Set(["text", "color", "fill", "fontSize", "fontName", "fontStyle", "visible"])
+};
+function nodeGraphics(get, approximate) {
+  const g = {};
+  const width = get("width");
+  const height = get("height");
+  if (typeof width === "number") {
+    g.w = width;
+  }
+  if (typeof height === "number") {
+    g.h = height;
+  }
+  const shape = get("shape");
+  if (typeof shape === "string") {
+    const w = yedValue(YED_SHAPES, shape, shape === "vee" ? "triangle" : "rectangle");
+    if (!w.exact) {
+      approximate("shape", shape);
+    }
+    g.type = w.value;
+  }
+  const fill = get("fill");
+  const fillOpacity = get("fillOpacity");
+  if (typeof fill === "string") {
+    g.fill = yedColor(fill, fillOpacity);
+  } else if (fillOpacity === 0) {
+    g.hasFill = 0;
+  }
+  const borderColor = get("borderColor");
+  const borderWidth = get("borderWidth");
+  const borderStyle = get("borderStyle");
+  if (typeof borderColor === "string") {
+    g.outline = borderColor.toUpperCase();
+  }
+  if (typeof borderStyle === "string") {
+    const w = yedValue(YED_LINES, borderStyle, "line");
+    if (!w.exact) {
+      approximate("borderStyle", borderStyle);
+    }
+    g.outlineStyle = w.value;
+  }
+  if (borderWidth === 0) {
+    g.hasOutline = 0;
+  } else if (typeof borderWidth === "number") {
+    g.outlineWidth = borderWidth;
+  }
+  return g;
+}
+function edgeGraphics(get, approximate) {
+  const g = {};
+  const color = get("color");
+  if (typeof color === "string") {
+    g.fill = yedColor(color, get("opacity"));
+  }
+  const width = get("width");
+  if (typeof width === "number") {
+    g.width = width;
+  }
+  const lineStyle = get("lineStyle");
+  if (typeof lineStyle === "string") {
+    g.style = yedSpelled(
+      YED_LINES,
+      lineStyle,
+      lineStyle === "long-dash" ? "dashed" : "line",
+      "lineStyle",
+      approximate
+    );
+  }
+  for (const property of ["sourceArrow", "targetArrow"]) {
+    const arrow = get(property);
+    if (typeof arrow === "string") {
+      g[property] = yedSpelled(YED_ARROWS, arrow, "standard", property, approximate);
+    }
+  }
+  const curved = get("curved");
+  if (typeof curved === "boolean") {
+    g.smoothBends = curved ? 1 : 0;
+  }
+  return g;
+}
+function labelGraphics(get) {
+  const text = get("label");
+  if (typeof text !== "string" || text.trim().length === 0) {
+    return null;
+  }
+  const lg = { text };
+  const color = get("labelColor");
+  if (typeof color === "string") {
+    lg.color = color.toUpperCase();
+  }
+  const size = get("labelSize");
+  if (typeof size === "number") {
+    lg.fontSize = size;
+  }
+  const font = get("labelFont");
+  if (typeof font === "string") {
+    lg.fontName = font;
+  }
+  const weight = get("labelWeight");
+  const italic = get("labelItalic");
+  if (weight !== null || italic !== null) {
+    const style = (weight === "bold" ? "bold" : "") + (italic === true ? "italic" : "");
+    lg.fontStyle = style.length === 0 ? "plain" : style;
+  }
+  return lg;
+}
+function merged(old, owned, written) {
+  const out = {};
+  if (isRec(old)) {
+    for (const [k, v] of Object.entries(old)) {
+      if (!owned.has(k)) {
+        out[k] = v;
+      }
+    }
+  }
+  Object.assign(out, written);
+  return Object.keys(out).length === 0 ? void 0 : out;
+}
+function mergedLabels(old, written) {
+  const labels = Array.isArray(old) ? old : [old];
+  const head = merged(labels[0], OWNED.label, written ?? {});
+  const rest = labels.slice(1).filter((l) => l !== null && l !== void 0);
+  if (rest.length === 0) {
+    return head;
+  }
+  return head === void 0 ? rest : [head, ...rest];
+}
+function getter(picture, target) {
+  const columns = /* @__PURE__ */ new Map();
+  for (const p of GML_STYLE_CAPABILITIES[target]) {
+    columns.set(p, picture(target, p));
+  }
+  return (i) => (property) => columns.get(property)?.[i] ?? null;
+}
+function exactFromBlock(snapshot, text, read) {
+  const parsed = parseStyleBlock(text, styleFingerprint(snapshot));
+  const ex = parsed.ok ? blockStyles(parsed.block, snapshot, "gml") : null;
+  if (ex === null) {
+    return;
+  }
+  const notes = new StyleNotes();
+  for (const target of ["node", "edge"]) {
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const get = getter((t, p) => resolveStyles(ex, t, p, snapshot), target);
+    const values = read[target];
+    for (let i = 0; i < n; i++) {
+      const want = get(i);
+      const back = writtenAndReadBack(target, want, notes);
+      for (const property of GML_STYLE_CAPABILITIES[target]) {
+        const native = values[property]?.[i] ?? null;
+        const w = want(property);
+        if (native !== w && native === (back.get(property) ?? null)) {
+          values[property] ??= new Array(n).fill(null);
+          values[property][i] = w;
+        }
+      }
+    }
+  }
+}
+function writtenAndReadBack(target, want, notes) {
+  const ignore = () => void 0;
+  const g = target === "node" ? nodeGraphics(want, ignore) : edgeGraphics(want, ignore);
+  const back = /* @__PURE__ */ new Map();
+  readElement(
+    target,
+    g,
+    labelGraphics(want) ?? void 0,
+    void 0,
+    GRAPHTY_WRITER,
+    (property, value) => {
+      if (value !== null) {
+        back.set(property, value);
+      }
+    },
+    (property) => ({ notes, target, property })
+  );
+  return back;
+}
+function gmlStyledExport(snapshot, input) {
+  if (input === void 0) {
+    return null;
+  }
+  const approximated = new StyleApproximations();
+  const out = snapshot.withColumns();
+  const renames = [];
+  for (const target of ["node", "edge"]) {
+    const table = target === "node" ? out.nodes : out.edges;
+    writeGraphicsColumns(snapshot, input, target, table, approximated);
+    const read = dataRead(input.rules.styles.rules, target);
+    for (const name of table.names().filter((c) => mangleGmlKey(c).startsWith(TAG_PREFIX))) {
+      const col = table.get(name);
+      table.remove(name);
+      if (col !== null && !(name.startsWith(TAG_PREFIX) && !read.has(name))) {
+        renames.push(renameDataColumn(table, target, name, col));
+      }
+    }
+  }
+  let { block } = input;
+  const keys = [...input.rules.columns.node.keys()].map((k) => tagKey("node", k));
+  const edgeKeys = [...input.rules.columns.edge.keys()].map((k) => tagKey("edge", k));
+  if (new Set(keys).size !== keys.length || new Set(edgeKeys).size !== edgeKeys.length) {
+    block = writeStyleBlock(input.rules, { inlineColumns: true, snapshot });
+  } else {
+    setTagColumns(out, input);
+  }
+  out.graph.set(GML_STYLE_BLOCK_KEY, [block], { dtype: "string" });
+  const notes = [
+    ...renames,
+    ...block === input.block ? [] : styleBlockLosses(block, input.rules.styles.rules.length, "size"),
+    ...approximated.notes("yEd's GML")
+  ];
+  return { snapshot: out, notes };
+}
+function writeGraphicsColumns(snapshot, input, target, table, approximated) {
+  const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+  const approximate = (property, value) => {
+    approximated.add(target, property, value);
+  };
+  const get = getter((t, p) => input.picture(t, p), target);
+  const graphics = [];
+  const labels = [];
+  for (let i = 0; i < n; i++) {
+    const g = target === "node" ? nodeGraphics(get(i), approximate) : edgeGraphics(get(i), approximate);
+    if (target === "edge") {
+      const line = bendsLine(snapshot, get(i)("bends"), i);
+      if (line !== null) {
+        g.Line = line;
+      }
+    }
+    graphics.push(merged(cellOf(table, "graphics", i), OWNED[target], g));
+    labels.push(mergedLabels(cellOf(table, "LabelGraphics", i), labelGraphics(get(i))));
+  }
+  for (const [name, cells] of [
+    ["graphics", graphics],
+    ["LabelGraphics", labels]
+  ]) {
+    if (cells.some((c) => c !== void 0)) {
+      table.set(name, cells, { dtype: "json", nullable: true });
+    } else if (table.has(name)) {
+      table.remove(name);
+    }
+  }
+}
+function bendsLine(snapshot, bends, e) {
+  const source = centerOf(snapshot, snapshot.edgeSource(e));
+  const target = centerOf(snapshot, snapshot.edgeTarget(e));
+  const points = typeof bends === "string" ? bendsToPoints(source, target, bends) : null;
+  if (points === null || ![...source, ...target].every(Number.isFinite)) {
+    return null;
+  }
+  return { point: [source, ...points, target].map(([x, y]) => ({ x, y })) };
+}
+function renameDataColumn(table, target, name, col) {
+  let renamed = `data_${name}`;
+  let k = 2;
+  while (table.has(renamed)) {
+    renamed = `data_${name}_${String(k)}`;
+    k++;
+  }
+  table.set(renamed, col);
+  return Object.freeze({
+    code: KEY_MANGLED_CODE,
+    message: `${target} column "${name}" is written as "${renamed}": keys starting with ${TAG_PREFIX} hold graphty's style values`,
+    column: name,
+    count: null
+  });
+}
+function setTagColumns(out, input) {
+  for (const target of ["node", "edge"]) {
+    const table = target === "node" ? out.nodes : out.edges;
+    for (const [key, col] of input.rules.columns[target]) {
+      const kinds = new Set(col.filter((v) => v !== null).map((v) => typeof v));
+      const text = kinds.size > 1 || kinds.has("string");
+      let dtype = kinds.has("boolean") ? "bool" : "f64";
+      if (text) {
+        dtype = "string";
+      }
+      table.set(tagKey(target, key), text ? col.map((v) => v === null ? null : String(v)) : col, { dtype });
+    }
+  }
+}
 const RECORD_NUMBER_TYPE_CODE = "W_GML_RECORD_NUMBER_TYPE";
 const RECORD_BOOLEAN_CODE = "W_GML_RECORD_BOOLEAN";
 const RECORD_NULL_CODE = "W_GML_RECORD_NULL";
@@ -374,7 +1183,6 @@ const NESTED_ARRAY_CODE = "E_GML_NESTED_ARRAY";
 const JSON_ARRAY_CODE = "W_GML_JSON_ARRAY";
 const INVALID_KEY_CODE = "E_GML_INVALID_KEY";
 const RESERVED_KEY_CODE = "E_GML_RESERVED_KEY";
-const KEY_MANGLED_CODE = "W_GML_KEY_MANGLED";
 const POSITION_COMPONENTS_CODE = "W_GML_POSITION_COMPONENTS";
 const GRAPHICS_OVERRIDDEN_CODE = "W_GML_GRAPHICS_OVERRIDDEN";
 const GRAPHICS_CONFLICT_CODE = "E_GML_GRAPHICS_CONFLICT";
@@ -1330,7 +2138,21 @@ const gmlExporter = Object.freeze({
   format: "gml",
   options: Object.freeze(["sanitizeKeys", "weightKey"]),
   capabilities: GML_CAPABILITIES,
-  check,
+  styles: Object.freeze({ capabilities: GML_STYLE_CAPABILITIES }),
+  /**
+   * Pre-flight: the common capability notes, the GML-specific ones and, with styles, the values written as the
+   * nearest ones yEd's GML has.
+   * @param snapshot - the snapshot
+   * @param options - the options
+   * @returns the notes, empty when the export is exact
+   */
+  check(snapshot, options) {
+    const styled = gmlStyledExport(snapshot, options?.styles);
+    if (styled === null) {
+      return check(snapshot, options);
+    }
+    return Object.freeze([...check(styled.snapshot, options), ...styled.notes]);
+  },
   /**
    * Write the snapshot as UTF-8 chunks; the context is resolved on the first pull, so the
    * errors check() announced surface from the iteration.
@@ -1352,7 +2174,34 @@ const gmlExporter = Object.freeze({
   }
 });
 function* lazyParts(snapshot, options) {
-  yield* gmlParts(contextOf(snapshot, options));
+  yield* gmlParts(contextOf(gmlStyledExport(snapshot, options?.styles)?.snapshot ?? snapshot, options));
+}
+const GRAPHICS_COLUMN = "graphics";
+function gmlPositions(snapshot) {
+  if (snapshot.nodes.byRole("position") === null) {
+    return null;
+  }
+  const tool = toolOf(snapshot.meta.creator);
+  return {
+    units: "px",
+    // a z that is the same on every node collapses to 2D
+    sourceDims: 3,
+    yAxis: tool === "gephi" || tool === "tulip" ? "up" : "down",
+    tool,
+    medianNodeSize: graphicsMedian(snapshot)
+  };
+}
+function graphicsMedian(snapshot) {
+  const graphics = snapshot.nodes.get(GRAPHICS_COLUMN);
+  const sizes = [];
+  for (let row = 0; graphics !== null && row < graphics.length; row++) {
+    const g = graphics.isSet(row) ? graphics.value(row) : void 0;
+    const { w, h } = typeof g === "object" && g !== null ? g : {};
+    if (typeof w === "number" && typeof h === "number") {
+      sizes.push((w + h) / 2);
+    }
+  }
+  return median(sizes);
 }
 const NO_GRAPH_CODE = NO_GRAPH_CODE$1;
 const SECOND_GRAPH_CODE = MULTIPLE_GRAPHS_CODE;
@@ -2507,13 +3356,13 @@ class GmlImport {
     const t = this.requireTokens();
     const { sink } = this;
     const values = vs.map((v) => t.kind[v] === TOKEN_OPEN ? parseRecord(t, v) : this.scalarOf(plan, v));
-    const first = values[0];
+    const first2 = values[0];
     const positionPlan = plan.position;
-    let rest = first;
-    if (isRecord(first) && positionPlan !== null) {
-      const left = this.writePosition(positionPlan, index, this.keepPositionSource ? { ...first } : first, where);
-      rest = this.keepPositionSource ? first : left;
-    } else if (!isRecord(first)) {
+    let rest = first2;
+    if (isRecord(first2) && positionPlan !== null) {
+      const left = this.writePosition(positionPlan, index, this.keepPositionSource ? { ...first2 } : first2, where);
+      rest = this.keepPositionSource ? first2 : left;
+    } else if (!isRecord(first2)) {
       this.graphicsWarning("scalar", `node ${where.element}'s graphics is not a record`, where);
     }
     if (values.length > 1) {
@@ -2827,6 +3676,8 @@ const gmlImporter = Object.freeze({
   extensions: Object.freeze([".gml"]),
   mimeTypes: Object.freeze(["text/x-gml", "text/plain"]),
   sniff: sniffGml,
+  styles: gmlStyles,
+  positions: gmlPositions,
   /**
    * Read a GML text into a sink.
    * @param input - the text, bytes or stream
@@ -2866,14 +3717,14 @@ const gmlImporter = Object.freeze({
    */
   async importAll(input, sinkFor, options) {
     const resolved = resolveImportOptions(options, FORMAT_DEFAULTS);
-    const first = new ImportReportBuilder("gml", resolved.errorLimit);
-    reportUnusedOptions(options, first, USED_OPTIONS);
-    const tokens = tokenize(await readText(input, first, resolved), first);
+    const first2 = new ImportReportBuilder("gml", resolved.errorLimit);
+    reportUnusedOptions(options, first2, USED_OPTIONS);
+    const tokens = tokenize(await readText(input, first2, resolved), first2);
     const reports = [];
     let count = 1;
     for (let i = 0; i < count; i++) {
       throwIfAborted(resolved.signal);
-      const report = i === 0 ? first : new ImportReportBuilder("gml", resolved.errorLimit);
+      const report = i === 0 ? first2 : new ImportReportBuilder("gml", resolved.errorLimit);
       const sink = sinkFor(i);
       reportSinkOptions(sink, options, report);
       const gml = new GmlImport(sink, report, resolved, options, i);
@@ -3016,7 +3867,7 @@ const GML_LOSS = Object.freeze({
   INVALID_KEY: INVALID_KEY_CODE,
   /** A column named like a structural key. */
   RESERVED_KEY: RESERVED_KEY_CODE,
-  /** A key rewritten under sanitizeKeys "mangle". */
+  /** A key rewritten under sanitizeKeys "mangle", or a column renamed because its key would read back as a style value. */
   KEY_MANGLED: KEY_MANGLED_CODE,
   /** A position column with more than three components. */
   POSITION_COMPONENTS: POSITION_COMPONENTS_CODE,
@@ -3028,6 +3879,8 @@ const GML_LOSS = Object.freeze({
 export {
   GML_ISSUE,
   GML_LOSS,
+  GML_STYLE_BLOCK_KEY,
+  GML_STYLE_CAPABILITIES,
   gmlExporter,
   gmlImporter
 };