@graphty/graph-io 0.3.42 → 0.3.44

package/src/formats/gml/syntax.ts

@@ -154,6 +154,12 @@ export class GmlTokens {
     /** The number of tokens. */
     count = 0;
 
+    /**
+     * Whether a backslash escapes the next character inside a string (`\"`, `\\`): set for files OGDF wrote, whose
+     * writer escapes quotes that way. Plain GML has no escape mechanism.
+     */
+    backslashEscapes = false;
+
     /** Called by stringOf() with each named entity it cannot decode and the token's line, when set. */
     onUnknownEntity: ((entity: string, line: number) => void) | null = null;
 
@@ -209,6 +215,9 @@ export class GmlTokens {
             // a line break inside a string is part of it, as LF whatever the file's line ends
             text = text.replaceAll(/\r\n?/g, "\n");
         }
+        if (this.backslashEscapes && text.includes("\\")) {
+            text = text.replaceAll(/\\([\s\S])/g, "$1");
+        }
         if (!text.includes("&")) {
             return text;
         }
@@ -279,67 +288,144 @@ export class GmlTokens {
  */
 export function tokenizeGml(text: string): GmlTokens {
     const tokens = new GmlTokens(text, Math.max(1024, text.length >>> 3));
-    const n = text.length;
+    tokens.backslashEscapes = writtenByOgdf(text);
+    const lex: GmlLex = { 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;
+}
+
+/** Where tokenizeGml() is. */
+interface GmlLex {
+    readonly text: string;
+    readonly tokens: GmlTokens;
+    /** The offset of the next character. */
+    i: number;
+    /** The line of the next character. */
+    line: number;
+    /** The opening line of the first string that spans lines: where a missing quote most likely is; 0 for none. */
+    spanningLine: number;
+}
+
+/**
+ * Skips one line break, space or comment.
+ * @param lex - the lexer
+ * @param c - the char code at the offset
+ * @returns false when the character starts a token
+ */
+function skipSpace(lex: GmlLex, c: number): boolean {
+    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 === 0xfeff) {
+        // a BOM left inside by concatenated files is whitespace; the shared text check reports it
+        lex.i++;
+    } else if (c === 35) {
+        lex.i = endOfLine(text, lex.i);
+    } else {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Lexes a string starting at the offset (its opening quote).
+ * @param lex - the lexer
+ */
+function lexString(lex: GmlLex): void {
+    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;
+}
+
+/**
+ * Lexes a bare token (a key, a number) starting at the offset.
+ * @param lex - the lexer
+ */
+function lexBare(lex: GmlLex): void {
+    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;
+}
+
+/**
+ * Whether OGDF wrote the file: its first key is `Creator "ogdf::..."`, after any whitespace and
+ * comment lines. A plain scan, so a banner of `#` characters costs time linear in its length.
+ * @param text - the GML text
+ * @returns true when the file opens with an OGDF creator line
+ */
+function writtenByOgdf(text: string): boolean {
+    const end = Math.min(text.length, 512);
     let i = 0;
-    let line = 1;
-    // the opening line of the first string that spans lines: where a missing quote most likely is
-    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) {
+            // '#': a comment runs to the next line break
+            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 === 0xfeff) {
-            // a BOM left inside by concatenated files is whitespace; the shared text check reports it
+        } 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));
+}
+
+/**
+ * The offset of the quote closing a string whose backslashes escape the next character, or -1.
+ * @param text - the text
+ * @param from - the offset after the opening quote
+ * @returns the offset of the closing quote
+ */
+function escapedClose(text: string, from: number): number {
+    let k = from;
+    while (k < text.length) {
+        const c = text.codePointAt(k);
+        if (c === 34) {
+            return k;
+        }
+        // a backslash escapes the next character
+        k += c === 92 ? 2 : 1;
+    }
+    return -1;
 }
 
 /**
@@ -447,15 +533,8 @@ function validateStructure(tokens: GmlTokens): void {
                 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;
     }
@@ -470,6 +549,31 @@ function validateStructure(tokens: GmlTokens): void {
     tokens.match = match;
 }
 
+/**
+ * Checks the value of a key: a number, a string, `INF` / `NAN` or an opening bracket. Gephi writes its name
+ * unquoted (`Creator Gephi`): the word is read as the string it means.
+ * @param tokens - the lexed tokens
+ * @param key - the key's token index (its value follows it)
+ * @returns the value's kind
+ */
+function checkValue(tokens: GmlTokens, key: number): TokenKind {
+    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] as TokenKind;
+}
+
 /**
  * A short description of a token for messages.
  * @param tokens - the tokens
@@ -528,6 +632,13 @@ export function isGmlKey(text: string): boolean {
     return STRICT_KEY_TEXT.test(text);
 }
 
+/**
+ * Keys rewritten under sanitizeKeys "mangle", or a data column renamed because its key would read back as one of
+ * graphty's style values.
+ * @category Issue and loss codes
+ */
+export const KEY_MANGLED_CODE = "W_GML_KEY_MANGLED";
+
 /**
  * Rewrite a text as a GML key: every character outside `[0-9A-Za-z_]` becomes `_` and a leading
  * non-letter is prefixed with `x` (the exporter's `sanitizeKeys: "mangle"`).

package/src/formats/graphml/constants.ts

@@ -45,6 +45,7 @@ import {
     UNKNOWN_ENCODING_CODE,
     UNKNOWN_PARENT_CODE,
     UNKNOWN_XML_ATTRIBUTE_CODE,
+    XML_NESTING_CODE,
     XML_SYNTAX_CODE,
 } from "../../common/codes.js";
 
@@ -190,6 +191,8 @@ export const GRAPHML_ISSUE = Object.freeze({
     COLUMN_TYPE: COLUMN_TYPE_CODE,
     /** The input is not well-formed XML. The import stops. */
     XML_SYNTAX: XML_SYNTAX_CODE,
+    /** Elements are nested more than 100,000 deep. The import stops. */
+    XML_NESTING: XML_NESTING_CODE,
     /** The input is not valid UTF-8. The import stops. */
     INVALID_UTF8: INVALID_UTF8_CODE,
     /**
@@ -245,6 +248,8 @@ export const GRAPHML_ISSUE = Object.freeze({
     HYPEREDGE_DATA_DROPPED: "W_GRAPHML_HYPEREDGE_DATA_DROPPED",
     /** Nested elements in the `<data>` of a typed (non-yfiles) key. */
     DATA_NESTED: "E_GRAPHML_DATA_NESTED",
+    /** Nested elements in the `<data>` of an untyped key; they are kept as their XML text. */
+    DATA_STRUCTURED: "W_GRAPHML_DATA_STRUCTURED",
     /** A `<node>` declared twice. */
     DUPLICATE_NODE: DUPLICATE_NODE_CODE,
     /** An edge id already used by another edge. */

package/src/formats/graphml/exporter.ts

@@ -37,6 +37,7 @@ import { agree, plural } from "../../common/plural.js";
 import { type ExplicitWeights, explicitWeights } from "../../common/weights.js";
 import { encodeChunks, joinText } from "../../common/writer.js";
 import { xmlIllegalTextNotes } from "../../common/xml.js";
+import type { ExporterStyleOptions } from "../../styles/io/writer.js";
 import { type CommonExportOptions, type ExportCapabilities, type GraphExporter, type LossNote } from "../../types.js";
 import {
     EDGE_ID_COLUMN,
@@ -56,9 +57,13 @@ import {
     XSI_NAMESPACE,
     YFILES_NAMESPACE,
 } from "./constants.js";
+import { GRAPHML_STYLE_CAPABILITIES, graphmlStyledExport } from "./styles-yed.js";
 import { treeProblem, writeXmlTree } from "./tree.js";
 import { isGraphicsColumn, staleGraphicsRows } from "./yfiles.js";
 
+/** What the writer takes: the format's options, the common ones and the styles. */
+type GraphmlWriteOptions = GraphmlExportOptions & CommonExportOptions & ExporterStyleOptions;
+
 /**
  * The format-specific options of the GraphML exporter.
  * @category Built-in formats
@@ -236,6 +241,8 @@ interface Plan {
     readonly hierarchy: Hierarchy;
     readonly meta: GraphmlMeta | null;
     readonly needsOriginalIdKey: boolean;
+    /** Styles are written: the `y` prefix is yEd's namespace, whatever the file the graph came from bound it to. */
+    readonly yedGraphics?: boolean;
 }
 
 /** The resolved format-specific options. */
@@ -301,9 +308,15 @@ function graphmlMetaOf(snapshot: GraphSnapshot): GraphmlMeta | null {
  * @param snapshot - the snapshot
  * @param options - the resolved common options
  * @param format - the resolved format options
+ * @param keyOrdered - write each element's data in the order of the keys (styled exports)
  * @returns the plan
  */
-function planExport(snapshot: GraphSnapshot, options: ResolvedExportOptions, format: FormatOptions): Plan {
+function planExport(
+    snapshot: GraphSnapshot,
+    options: ResolvedExportOptions,
+    format: FormatOptions,
+    keyOrdered = false,
+): Plan {
     // the generic json note is replaced by planTable()'s (yfiles trees are kept, other json is
     // text); columns mapped from a yfiles tree are never written: planTable() notes the ones
     // that no longer match their tree, the rest lose nothing
@@ -325,6 +338,16 @@ function planExport(snapshot: GraphSnapshot, options: ResolvedExportOptions, for
     const nodeColumns = planTable(snapshot.nodes, "node", notes, note);
     const edgeColumns = planTable(snapshot.edges, "edge", notes, note);
     const keys = planKeys([...graphColumns, ...nodeColumns, ...edgeColumns], keyIds);
+    if (keyOrdered) {
+        // an element's data in the order of its keys, as a re-import orders its columns, so that exporting what a
+        // styled export reads back gives the same bytes. ponytail: styled exports only, so an export without
+        // styles keeps its bytes; extend it to every export when that change is wanted on its own.
+        const keyOrder = new Map(keys.map((k, i) => [k.id, i]));
+        const byKey = (a: ColumnPlan, b: ColumnPlan): number =>
+            (keyOrder.get(a.keyId) ?? 0) - (keyOrder.get(b.keyId) ?? 0);
+        nodeColumns.sort(byKey);
+        edgeColumns.sort(byKey);
+    }
     reservedNameNotes(nodeColumns, RESERVED_NODE_NAMES, note);
     reservedNameNotes(edgeColumns, RESERVED_EDGE_NAMES, note);
     const weight = planWeight(snapshot, edgeColumns, keyIds, keys, note);
@@ -1193,7 +1216,9 @@ function keyElement(key: KeyPlan, indent: string): string {
         text += ` attr.type="${escapeXmlAttribute(key.attrType)}"`;
     }
     if (key.yfilesType !== null) {
-        text += ` yfiles.type="${escapeXmlAttribute(key.yfilesType)}"`;
+        // a yFiles 3 key is identified by its attr.uri, which the importer keeps as the column's type
+        const uri = key.yfilesType.includes("://");
+        text += ` ${uri ? "y:attr.uri" : "yfiles.type"}="${escapeXmlAttribute(key.yfilesType)}"`;
     }
     const { column } = key;
     const desc = column?.meta.extra.desc;
@@ -1274,25 +1299,7 @@ function* writeGraphml(snapshot: GraphSnapshot, plan: Plan): Generator<string, v
     const step = plan.pretty ? "  " : "";
 
     yield '<?xml version="1.0" encoding="UTF-8"?>\n';
-    let root = `<graphml xmlns="${GRAPHML_NAMESPACE}"`;
-    const namespaces: Record<string, string> = { ...plan.meta?.namespaces };
-    if (
-        (plan.nodeColumns.some((c) => c.yfiles) ||
-            plan.edgeColumns.some((c) => c.yfiles) ||
-            plan.graphColumns.some((c) => c.yfiles)) &&
-        !Object.values(namespaces).includes(YFILES_NAMESPACE)
-    ) {
-        namespaces.y = YFILES_NAMESPACE;
-    }
-    if (!Object.values(namespaces).includes(XSI_NAMESPACE)) {
-        namespaces.xsi = XSI_NAMESPACE;
-    }
-    for (const [prefix, uri] of Object.entries(namespaces)) {
-        root += ` xmlns:${prefix}="${escapeXmlAttribute(uri)}"`;
-    }
-    const xsiPrefix = Object.entries(namespaces).find(([, uri]) => uri === XSI_NAMESPACE)?.[0] ?? "xsi";
-    root += ` ${xsiPrefix}:schemaLocation="${SCHEMA_LOCATION}">\n`;
-    yield root;
+    yield rootElement(plan);
 
     for (const key of plan.keys) {
         yield keyElement(key, i1);
@@ -1329,54 +1336,116 @@ function* writeGraphml(snapshot: GraphSnapshot, plan: Plan): Generator<string, v
 
     // edges: primaries only, in index order
     const list = snapshot.edgeList();
-    const { folding } = plan;
     for (let e = 0; e < snapshot.edgeCount; e++) {
-        if (folding.folded(e)) {
-            continue;
+        if (!plan.folding.folded(e)) {
+            const start = edgeStartTag(snapshot, plan, e, String(ids.idAt(list.src[e])), String(ids.idAt(list.dst[e])));
+            yield edgeElement(plan, e, edgeIds[e], start, [i2, i3]);
         }
-        const parts: string[] = [`\n${i2}<edge`];
-        const id = edgeIds[e];
-        if (id !== null) {
-            parts.push(` id="${escapeXmlAttribute(id)}"`);
-        }
-        parts.push(
-            ` source="${escapeXmlAttribute(String(ids.idAt(list.src[e])))}" target="${escapeXmlAttribute(String(ids.idAt(list.dst[e])))}"`,
-        );
-        const directed = snapshot.directed && isDirectedEdge(folding, e);
-        if (directed !== (plan.edgedefault === "directed")) {
-            parts.push(` directed="${directed ? "true" : "false"}"`);
-        }
-        const sourcePort = portText(plan.sourcePortColumn, e);
-        if (sourcePort !== null) {
-            parts.push(` sourceport="${escapeXmlAttribute(sourcePort)}"`);
-        }
-        const targetPort = portText(plan.targetPortColumn, e);
-        if (targetPort !== null) {
-            parts.push(` targetport="${escapeXmlAttribute(targetPort)}"`);
-        }
-        const open = parts.length;
-        if (plan.weight !== null) {
-            const { keyId, attrType } = plan.weight;
-            const weight = plan.weight.weights.text(e, attrType === "int" || attrType === "long");
-            if (weight !== null) {
-                parts.push(`\n${i3}<data key="${keyId}">${escapeXmlText(weight)}</data>`);
-            }
-        }
-        for (const column of plan.edgeColumns) {
-            writeData(column, e, i3, parts);
-        }
-        if (parts.length === open) {
-            parts.push("/>");
-        } else {
-            parts.splice(open, 0, ">");
-            parts.push(`\n${i2}</edge>`);
-        }
-        yield parts.join("");
     }
 
     yield `\n${i1}</graph>\n</graphml>\n`;
 }
 
+/**
+ * The opening `<graphml>` tag with its namespaces: the kept ones, yFiles' where graphics or yFiles columns are written,
+ * and XML Schema's for the schema location.
+ * @param plan - the plan
+ * @returns the tag
+ */
+function rootElement(plan: Plan): string {
+    const namespaces: Record<string, string> = { ...plan.meta?.namespaces };
+    const yfilesColumns =
+        plan.nodeColumns.some((c) => c.yfiles) ||
+        plan.edgeColumns.some((c) => c.yfiles) ||
+        plan.graphColumns.some((c) => c.yfiles);
+    if (
+        plan.yedGraphics === true ||
+        (yfilesColumns &&
+            !Object.values(namespaces).includes(YFILES_NAMESPACE) &&
+            // a yFiles 3 file binds `y` to its own namespace, which its kept trees are written in
+            namespaces.y === undefined)
+    ) {
+        namespaces.y = YFILES_NAMESPACE;
+    }
+    if (!Object.values(namespaces).includes(XSI_NAMESPACE)) {
+        namespaces.xsi = XSI_NAMESPACE;
+    }
+    let root = `<graphml xmlns="${GRAPHML_NAMESPACE}"`;
+    for (const [prefix, uri] of Object.entries(namespaces)) {
+        root += ` xmlns:${prefix}="${escapeXmlAttribute(uri)}"`;
+    }
+    const xsiPrefix = Object.entries(namespaces).find(([, uri]) => uri === XSI_NAMESPACE)?.[0] ?? "xsi";
+    return `${root} ${xsiPrefix}:schemaLocation="${SCHEMA_LOCATION}">\n`;
+}
+
+/**
+ * An edge's attributes after `<edge`: its source and target, a `directed` that differs from the default, its ports.
+ * @param snapshot - the snapshot
+ * @param plan - the plan
+ * @param e - the edge
+ * @param source - the source's written id
+ * @param target - the target's written id
+ * @returns the attribute text
+ */
+function edgeStartTag(snapshot: GraphSnapshot, plan: Plan, e: number, source: string, target: string): string {
+    let text = ` source="${escapeXmlAttribute(source)}" target="${escapeXmlAttribute(target)}"`;
+    const directed = snapshot.directed && isDirectedEdge(plan.folding, e);
+    if (directed !== (plan.edgedefault === "directed")) {
+        text += ` directed="${directed ? "true" : "false"}"`;
+    }
+    const sourcePort = portText(plan.sourcePortColumn, e);
+    if (sourcePort !== null) {
+        text += ` sourceport="${escapeXmlAttribute(sourcePort)}"`;
+    }
+    const targetPort = portText(plan.targetPortColumn, e);
+    if (targetPort !== null) {
+        text += ` targetport="${escapeXmlAttribute(targetPort)}"`;
+    }
+    return text;
+}
+
+/**
+ * One `<edge>` element with its weight and data.
+ * @param plan - the plan
+ * @param e - the edge
+ * @param id - its written id, or null
+ * @param start - its attributes after the id
+ * @param indents - the edge's indentation and its data's
+ * @returns the element text
+ */
+function edgeElement(
+    plan: Plan,
+    e: number,
+    id: string | null,
+    start: string,
+    indents: readonly [string, string],
+): string {
+    const [i2, i3] = indents;
+    const parts: string[] = [`\n${i2}<edge`];
+    if (id !== null) {
+        parts.push(` id="${escapeXmlAttribute(id)}"`);
+    }
+    parts.push(start);
+    const open = parts.length;
+    if (plan.weight !== null) {
+        const { keyId, attrType } = plan.weight;
+        const weight = plan.weight.weights.text(e, attrType === "int" || attrType === "long");
+        if (weight !== null) {
+            parts.push(`\n${i3}<data key="${keyId}">${escapeXmlText(weight)}</data>`);
+        }
+    }
+    for (const column of plan.edgeColumns) {
+        writeData(column, e, i3, parts);
+    }
+    if (parts.length === open) {
+        parts.push("/>");
+    } else {
+        parts.splice(open, 0, ">");
+        parts.push(`\n${i2}</edge>`);
+    }
+    return parts.join("");
+}
+
 /**
  * The text of a port reference cell.
  * @param column - the sourcePort / targetPort column, or null
@@ -1497,15 +1566,16 @@ export const graphmlExporter: GraphExporter<GraphmlExportOptions> = Object.freez
     format: FORMAT,
     options: Object.freeze(["edgedefault", "pretty"]),
     capabilities: CAPABILITIES,
+    styles: Object.freeze({ capabilities: GRAPHML_STYLE_CAPABILITIES }),
     /**
      * Pre-flight: every loss the export would incur.
      * @param snapshot - the snapshot
      * @param options - format-specific and common options
      * @returns the notes
      */
-    check(snapshot: GraphSnapshot, options?: GraphmlExportOptions & CommonExportOptions): readonly LossNote[] {
-        const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
-        return Object.freeze(plan.notes);
+    check(snapshot: GraphSnapshot, options?: GraphmlWriteOptions): readonly LossNote[] {
+        const { plan, styled } = prepare(snapshot, options);
+        return Object.freeze([...plan.notes, ...(styled?.notes ?? [])]);
     },
     /**
      * Write the document as UTF-8 chunks.
@@ -1513,9 +1583,9 @@ export const graphmlExporter: GraphExporter<GraphmlExportOptions> = Object.freez
      * @param options - format-specific and common options
      * @returns the chunks
      */
-    export(snapshot: GraphSnapshot, options?: GraphmlExportOptions & CommonExportOptions): AsyncIterable<Uint8Array> {
-        const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
-        return encodeChunks(writeGraphml(snapshot, plan));
+    export(snapshot: GraphSnapshot, options?: GraphmlWriteOptions): AsyncIterable<Uint8Array> {
+        const { plan, written } = prepare(snapshot, options);
+        return encodeChunks(writeGraphml(written, plan));
     },
     /**
      * Write the document as one string.
@@ -1523,8 +1593,30 @@ export const graphmlExporter: GraphExporter<GraphmlExportOptions> = Object.freez
      * @param options - format-specific and common options
      * @returns the document
      */
-    exportToString(snapshot: GraphSnapshot, options?: GraphmlExportOptions & CommonExportOptions): Promise<string> {
-        const plan = planExport(snapshot, resolveExportOptions(options), resolveFormatOptions(options));
-        return joinText(writeGraphml(snapshot, plan));
+    exportToString(snapshot: GraphSnapshot, options?: GraphmlWriteOptions): Promise<string> {
+        const { plan, written } = prepare(snapshot, options);
+        return joinText(writeGraphml(written, plan));
     },
 });
+
+/**
+ * The plan of an export, with styles: the graph to write with yEd graphics in place of its yFiles columns.
+ * @param snapshot - the snapshot
+ * @param options - format-specific and common options
+ * @returns the plan, the graph to write and the styled export (null without styles)
+ */
+function prepare(
+    snapshot: GraphSnapshot,
+    options: GraphmlWriteOptions | undefined,
+): { plan: Plan; written: GraphSnapshot; styled: ReturnType<typeof graphmlStyledExport> } {
+    const styled = graphmlStyledExport(snapshot, options?.styles);
+    const written = styled?.snapshot ?? snapshot;
+    const plan = planExport(written, resolveExportOptions(options), resolveFormatOptions(options), styled !== null);
+    if (styled === null) {
+        return { plan, written, styled };
+    }
+    // the yEd graphics carry each node's position in its y:Geometry, so the position column is not lost
+    const position = written.nodes.byRole("position")?.meta.name;
+    const notes = plan.notes.filter((n) => n.code !== LOSS.POSITIONS || n.column !== position);
+    return { plan: { ...plan, notes, yedGraphics: true }, written, styled };
+}