@graphty/graph-io 0.2.4 → 0.3.0

package/README.md

@@ -75,8 +75,27 @@ for await (const chunk of csvExporter.export(snapshot, { dialect: "gephi" })) {
 ```
 
 Inputs may be a `string`, a `Uint8Array`, a `ReadableStream<Uint8Array>` (a `File.stream()`, a fetch
-body) or an async iterable of text or byte chunks. Bytes are decoded as UTF-8 with `fatal: true`, so
-an invalid sequence is a `parse-error`, never a silent U+FFFD.
+body) or an async iterable of text or byte chunks. Bytes are decoded by one shared layer, whatever
+the format. The encoding is, in order: the `encoding` option (any WHATWG label, such as
+`"windows-1252"` or `"utf-16le"`); a byte order mark (UTF-8, UTF-16LE, UTF-16BE); the encoding the
+file declares (the XML prolog of GEXF and GraphML, DOT's `charset` attribute); else UTF-8. Decoding
+is strict, never a silent U+FFFD. Undeclared bytes that are not UTF-8 are read as windows-1252 with
+the warning `W_ENCODING_FALLBACK` (Excel, Pajek and older tools write it); invalid UTF-8 after valid
+non-ASCII UTF-8, or binary data, is the `parse-error` `E_INVALID_UTF8`.
+
+Some files hold several graphs: a DOT file with several `graph { }` blocks, a Pajek project (`.paj`)
+with several networks, a GML file with several `graph [ ]` blocks, a JGF document with a `graphs`
+array. `importGraph()` (and each importer's `import()`) reads the first and records the warning
+`W_MULTIPLE_GRAPHS`, which says how many it skipped. `importAllGraphs()` (and `importer.importAll()`
+where a format can hold several) returns every graph, each frozen on its own:
+
+```ts
+import { importAllGraphs } from "@graphty/graph-io";
+
+for (const { snapshot, report } of await importAllGraphs(bytes, { filename: "project.paj" })) {
+    console.log(snapshot.meta.name, snapshot.nodeCount, report.warningCount);
+}
+```
 
 ### Common import options
 
@@ -95,6 +114,7 @@ an invalid sequence is a `parse-error`, never a silent U+FFFD.
 | `hyperedges`                  | `"skip"`                                                              | GraphML / JGF hyperedges: `"error"`, `"skip"` with a report entry, `"star"` or `"clique"`.                                                                                  |
 | `errorLimit`                  | `100`                                                                 | Recoverable errors tolerated before the importer throws `ImportError` with the partial report.                                                                              |
 | `signal`, `onProgress`        |                                                                       | Cancellation (rejects with the signal's reason) and byte progress (`bytesTotal` known for in-memory input).                                                                 |
+| `encoding`                    | detected                                                              | The encoding of byte input; overrides the byte order mark and the file's declaration. Ignored for text input.                                                               |
 
 On a caller's builder the builder-policy options (`addMissingNodes`, `duplicateEdges`, `selfLoops`,
 `weightDtype`) are read from the sink; an explicit request the sink does not honour is reported once
@@ -169,7 +189,7 @@ losses and format rules, in addition to the table:
 - **DOT**: a Graphviz-faithful parser (grammar violations are fatal, as in Graphviz); clusters are
   container nodes with the `parent` role; ports are kept; HTML strings keep their brackets; `pos`
   maps to the position role. Mixed direction is folded per `onMixedDirection`; a text with a
-  backslash before a quote or at its end cannot be written (`E_DOT_TRAILING_BACKSLASH`: Graphviz's
+  backslash before a quote or a line break, or at its end, cannot be written (`E_DOT_TRAILING_BACKSLASH`: Graphviz's
   scanner consumes backslash pairs, so such a text has no quoted spelling).
 - **Pajek**: `*Vertices N` bounds the id space (ids 1..N; a 0-based file is detected and reported;
   a count the sink cannot reserve is fatal); `*Arcs` / `*Edges` sections give per-section
@@ -240,17 +260,19 @@ Issue categories are `parse-error`, `missing-value`, `validation-error`, `unsupp
 (`GEXF_ISSUE`, `GRAPHML_ISSUE`, `GML_ISSUE`, `DOT_ISSUE`, `PAJEK_ISSUE`, `CSV_ISSUE`,
 `JSON_ISSUE`, `NEO4J_ISSUE`) and shared across formats (`SINK_OPTION_CODE`, `ID_MERGED_CODE`,
 `DIRECTION_REFUSED_CODE`, `DIRECTION_FORCED_CODE`, `RENAMED_CODE`, `PRECISION_CODE`,
-`INVALID_UTF8_CODE`, `PARSE_ERROR_CODE`). The builder throws on the first hard error; the importer
+`INVALID_UTF8_CODE`, `INVALID_ENCODING_CODE`, `ENCODING_FALLBACK_CODE`, `UNKNOWN_ENCODING_CODE`,
+`PARSE_ERROR_CODE`). The builder throws on the first hard error; the importer
 catches it per element, records an issue, skips the element and continues until `errorLimit`, then
 throws `ImportError` (`code === "E_IMPORT"`) carrying the partial report. An input that cannot be
-read at all (invalid UTF-8, malformed XML, no recognisable format) is an `ImportError` at once.
+read at all (bytes invalid in the chosen encoding, malformed XML, no recognisable format) is an
+`ImportError` at once.
 
 ## Writing a plugin
 
 `GraphImporter` and `GraphExporter` (design section 12.4) are plain objects; the helpers every
 built-in format is built on are exported for third-party plugins: `ImportReportBuilder` (issues,
-error limit, `warnOnce`, `ImportError`), `textChunks` / `readText` / `LineReader` (streaming UTF-8
-input with cancellation and progress), `tokenizeXml` / `XmlTokenizer` (the streaming XML tokenizer
+error limit, `warnOnce`, `ImportError`), `textChunks` / `readText` / `LineReader` (streaming
+input decoded by the shared encoding rules, with cancellation and progress), `tokenizeXml` / `XmlTokenizer` (the streaming XML tokenizer
 behind GEXF and GraphML), `resolveImportOptions` / `resolveExportOptions` / `reportSinkOptions` /
 `reportUnusedOptions`, `DirectionResolver` (the mixed-direction rules of section 8.4) and
 `pairFolding` (its inverse for exporters), `IdCoercer`, `parseTextCell` and `TextCellWriter` (the

package/dist/chunks/{escape-DyI8JofU.js → escape-CKied3Ri.js}

@@ -1,5 +1,5 @@
 import { GraphFormatError } from "@graphty/graph-format";
-import { aF as isNameChar, a6 as XML_ILLEGAL_CHAR_CODE } from "./writer-DxSKC7TL.js";
+import { aI as isNameChar, a9 as XML_ILLEGAL_CHAR_CODE } from "./writer-BdMak4_J.js";
 class XmlSyntaxError extends Error {
   /**
    * Create the error.
@@ -113,6 +113,11 @@ function countIllegalRows(column) {
   }
   return bad;
 }
+const XML_DECLARED_ENCODING = /^<\?xml\s[^>]*?\bencoding\s*=\s*["']([A-Za-z][A-Za-z0-9._-]*)["']/;
+function xmlDeclaredEncoding(head) {
+  const match = XML_DECLARED_ENCODING.exec(head);
+  return match === null ? null : match[1];
+}
 function isXmlName(text) {
   if (text.length === 0) {
     return false;
@@ -884,7 +889,7 @@ function isDotIdentifier(text) {
   return true;
 }
 function isWritableDotText(text) {
-  return !text.endsWith("\\") && !text.includes('\\"');
+  return !text.endsWith("\\") && !text.includes('\\"') && !/\\[\r\n]/.test(text);
 }
 function quoteDotId(text) {
   if (isBareDotId(text)) {
@@ -921,18 +926,19 @@ export {
   XmlTokenizer as a,
   quoteDotId as b,
   isWritableDotText as c,
-  isWhitespace as d,
-  escapeXmlText as e,
-  escapeXmlAttribute as f,
-  decodeGmlString as g,
+  xmlDeclaredEncoding as d,
+  isWhitespace as e,
+  escapeXmlText as f,
+  escapeXmlAttribute as g,
   hasIllegalXmlChar as h,
   isPajekLabel as i,
-  quoteGmlString as j,
-  isXmlName as k,
+  decodeGmlString as j,
+  quoteGmlString as k,
   localName as l,
-  quoteCsvCell as m,
+  isXmlName as m,
+  quoteCsvCell as n,
   quotePajekLabel as q,
   tokenizeXml as t,
   xmlIllegalTextNotes as x
 };
-//# sourceMappingURL=escape-DyI8JofU.js.map
+//# sourceMappingURL=escape-CKied3Ri.js.map

package/dist/chunks/escape-CKied3Ri.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape-CKied3Ri.js","sources":["../../src/common/xml.ts","../../src/common/escape.ts"],"sourcesContent":["/**\n * The streaming XML tokenizer shared by the GEXF and GraphML importers (design sections 8.2 and\n * 8.4): SAX-style start / end / text events over the text chunks of the common reader, so both\n * importers run in one pass with bounded memory and every issue carries a line number.\n *\n * Cost model: every character of the input is scanned once. A token that spans many chunks (a\n * long attribute value, comment, CDATA section or name) resumes where the previous chunk left off\n * instead of re-reading the token from its `<`, and line numbers are counted from a cached next\n * line-break position, so a document without line breaks costs the same as one with them.\n *\n * What it handles: the XML declaration and processing instructions (skipped), comments (skipped),\n * CDATA sections (text), a DOCTYPE with an internal subset (skipped; entity declarations are not\n * expanded, so an unknown entity reference is a syntax error), the five predefined entities and\n * numeric character references (decimal and hexadecimal) in text and attribute values, attribute\n * value whitespace normalisation, end-of-line normalisation (CR LF and lone CR become LF), and\n * well-formedness: matching end tags, one root element, no text outside it, no duplicate\n * attributes, no unterminated markup at the end of the input. Namespaces are not resolved; element\n * and attribute names are reported as written (with their prefix).\n *\n * Why not fast-xml-parser: its XMLParser accepts mismatched and unclosed tags without error, does\n * not decode numeric character references unless the deprecated `htmlEntities` option is set, and\n * its validator (`XMLValidator`, the `parse(xml, true)` overload) and `XMLBuilder` are deprecated in\n * 5.x, which the root lint's `no-deprecated` rule forbids using; so the malformed corpus could not\n * be rejected and attribute values written by the common `escapeXmlAttribute` (`&#10;`) could not\n * be read back.\n */\n\nimport { type Column, type GraphSnapshot } from \"@graphty/graph-format\";\n\nimport { type LossNote } from \"../types.js\";\nimport { XML_ILLEGAL_CHAR_CODE } from \"./codes.js\";\nimport { isNameChar } from \"./export.js\";\n\n/** The events of the tokenizer; every callback is synchronous. */\nexport interface XmlHandler {\n    /**\n     * An element starts (a self-closing element produces start then end).\n     * @param name - the element name as written, prefix included\n     * @param attrs - the attributes, entities decoded, in document order\n     * @param line - the 1-based line of the `<`\n     */\n    start(name: string, attrs: ReadonlyMap<string, string>, line: number): void;\n    /**\n     * An element ends.\n     * @param name - the element name\n     * @param line - the 1-based line of the end tag (or of the self-closing start tag)\n     */\n    end(name: string, line: number): void;\n    /**\n     * Character data between two tags (entities decoded, CDATA included), one call per run;\n     * whitespace-only runs are delivered too.\n     * @param text - the text\n     * @param line - the 1-based line where the run starts\n     */\n    text(text: string, line: number): void;\n}\n\n/** A well-formedness or syntax error, with the line it was found on. */\nexport class XmlSyntaxError extends Error {\n    /** The 1-based line. */\n    readonly line: number;\n\n    /**\n     * Create the error.\n     * @param message - a plain-ASCII message\n     * @param line - the 1-based line\n     */\n    constructor(message: string, line: number) {\n        super(message);\n        this.name = \"XmlSyntaxError\";\n        this.line = line;\n    }\n}\n\nconst NAMED_ENTITIES: Readonly<Record<string, string>> = {\n    lt: \"<\",\n    gt: \">\",\n    amp: \"&\",\n    quot: '\"',\n    apos: \"'\",\n};\n\nconst LT = 60;\nconst GT = 62;\nconst SLASH = 47;\nconst EQUALS = 61;\nconst QUOTE = 34;\nconst APOS = 39;\nconst OPEN_BRACKET = 91;\nconst CLOSE_BRACKET = 93;\nconst BANG = 33;\nconst DASH = 45;\n\n/** The longest entity reference held back at a chunk boundary (`&#x10FFFF;` is 10 characters). */\nconst MAX_ENTITY_LENGTH = 16;\n\n/** Markup shorter than this (`<![CDATA[` is 9 characters) cannot be classified yet. */\nconst MIN_DECIDABLE_MARKUP = 9;\n\n/**\n * Whether a char code is XML whitespace (space, tab, LF, CR).\n * @param c - the char code\n * @returns true for whitespace\n */\nfunction isSpace(c: number): boolean {\n    return c === 32 || c === 9 || c === 10 || c === 13;\n}\n\n/**\n * Whether a code point may start an XML Name: a NameChar that is not a digit, `-`, `.`, U+00B7,\n * a combining character (U+0300..U+036F) or U+203F / U+2040.\n * @param cp - the code point\n * @returns true for a NameStartChar\n */\nfunction isNameStart(cp: number): boolean {\n    if (!isNameChar(cp)) {\n        return false;\n    }\n    if ((cp >= 0x30 && cp <= 0x39) || cp === 0x2d || cp === 0x2e || cp === 0xb7) {\n        return false;\n    }\n    return !(cp >= 0x300 && cp <= 0x36f) && cp !== 0x203f && cp !== 0x2040;\n}\n\n/** ASCII code -> whether it is a NameStartChar / NameChar, for the fast path of readName(). */\nconst ASCII_NAME_START = new Uint8Array(128);\nconst ASCII_NAME_CHAR = new Uint8Array(128);\nfor (let c = 0; c < 128; c++) {\n    ASCII_NAME_START[c] = isNameStart(c) ? 1 : 0;\n    ASCII_NAME_CHAR[c] = isNameChar(c) ? 1 : 0;\n}\n\n/**\n * Characters XML 1.0 forbids in a document (the Char production): C0 controls other than tab, LF\n * and CR, U+FFFE / U+FFFF, and lone surrogates (the `u` flag makes the surrogate class match only\n * an unpaired one). Built from char codes so no control character appears in the source.\n */\nconst ILLEGAL_CHAR = new RegExp(\n    `[${String.fromCharCode(0)}-${String.fromCharCode(8)}${String.fromCharCode(11)}${String.fromCharCode(12)}` +\n        `${String.fromCharCode(14)}-${String.fromCharCode(31)}\\\\uFFFE\\\\uFFFF\\\\uD800-\\\\uDFFF]`,\n    \"u\",\n);\n\n/**\n * Whether a text holds a character XML 1.0 forbids (see ILLEGAL_CHAR); such a character cannot be\n * written even as a character reference, so a conforming parser rejects the whole document.\n * @param text - the text\n * @returns true when the text cannot appear in an XML 1.0 document\n */\nexport function hasIllegalXmlChar(text: string): boolean {\n    return ILLEGAL_CHAR.test(text);\n}\n\n/**\n * The loss notes of the texts a snapshot holds that no XML 1.0 document can carry (see\n * hasIllegalXmlChar): one E_XML_ILLEGAL_CHAR note per column (node, edge and graph string / dict /\n * list-of-text columns) and one for the ids, each counting the affected rows; export() throws on\n * the first such text. Shared by the GEXF and GraphML exporters' check().\n * @param snapshot - the snapshot\n * @returns the notes, empty when every text is writable\n */\nexport function xmlIllegalTextNotes(snapshot: GraphSnapshot): LossNote[] {\n    const notes: LossNote[] = [];\n    let ids = 0;\n    for (let i = 0; i < snapshot.nodeCount; i++) {\n        const id = snapshot.ids.idOf(i);\n        if (typeof id === \"string\" && hasIllegalXmlChar(id)) {\n            ids++;\n        }\n    }\n    if (ids > 0) {\n        notes.push(\n            Object.freeze({\n                code: XML_ILLEGAL_CHAR_CODE,\n                message: `${ids} node id(s) hold a character XML 1.0 cannot carry; export() will throw`,\n                column: null,\n                count: ids,\n            }),\n        );\n    }\n    for (const [domain, table] of [\n        [\"node\", snapshot.nodes],\n        [\"edge\", snapshot.edges],\n        [\"graph\", snapshot.graph],\n    ] as const) {\n        for (const column of table) {\n            const bad = countIllegalRows(column);\n            if (bad > 0) {\n                notes.push(\n                    Object.freeze({\n                        code: XML_ILLEGAL_CHAR_CODE,\n                        message: `${domain} column \"${column.meta.name}\": ${bad} value(s) hold a character XML 1.0 cannot carry; export() will throw`,\n                        column: column.meta.name,\n                        count: bad,\n                    }),\n                );\n            }\n        }\n    }\n    return notes;\n}\n\n/**\n * How many set rows of a text column hold an XML-illegal character.\n * @param column - the column\n * @returns the count; 0 for a non-text column\n */\nfunction countIllegalRows(column: Column): number {\n    let bad = 0;\n    if (column.dtype === \"string\" || column.dtype === \"dict\") {\n        for (let r = 0; r < column.length; r++) {\n            if (column.isSet(r) && hasIllegalXmlChar(column.value(r) as string)) {\n                bad++;\n            }\n        }\n    } else if (column.dtype === \"list\" && (column.meta.itemDtype === \"string\" || column.meta.itemDtype === \"dict\")) {\n        for (let r = 0; r < column.length; r++) {\n            if (\n                column.isSet(r) &&\n                column.sliceOf(r).some((item) => typeof item === \"string\" && hasIllegalXmlChar(item))\n            ) {\n                bad++;\n            }\n        }\n    }\n    return bad;\n}\n\n/** The encoding pseudo-attribute of an XML declaration at the very start of a document. */\nconst XML_DECLARED_ENCODING = /^<\\?xml\\s[^>]*?\\bencoding\\s*=\\s*[\"']([A-Za-z][A-Za-z0-9._-]*)[\"']/;\n\n/**\n * The encoding an XML document declares in its prolog (`<?xml version=\"1.0\" encoding=\"...\"?>`),\n * for the shared byte decoder (common/input.ts).\n * @param head - the start of the document, decoded as windows-1252\n * @returns the declared label, or null when there is no declaration or it names no encoding\n */\nexport function xmlDeclaredEncoding(head: string): string | null {\n    const match = XML_DECLARED_ENCODING.exec(head);\n    return match === null ? null : match[1];\n}\n\n/**\n * Whether a text is an XML Name.\n * @param text - the text\n * @returns true for a well-formed name\n */\nexport function isXmlName(text: string): boolean {\n    if (text.length === 0) {\n        return false;\n    }\n    let first = true;\n    for (const ch of text) {\n        const cp = ch.codePointAt(0);\n        if (cp === undefined || (first ? !isNameStart(cp) : !isNameChar(cp))) {\n            return false;\n        }\n        first = false;\n    }\n    return true;\n}\n\n/**\n * Whether a code point is a legal XML 1.0 character.\n * @param cp - the code point\n * @returns true when a character reference may produce it\n */\nfunction isXmlChar(cp: number): boolean {\n    return (\n        cp === 0x9 ||\n        cp === 0xa ||\n        cp === 0xd ||\n        (cp >= 0x20 && cp <= 0xd7ff) ||\n        (cp >= 0xe000 && cp <= 0xfffd) ||\n        (cp >= 0x10000 && cp <= 0x10ffff)\n    );\n}\n\n/**\n * Decode the predefined entities and character references of a text.\n * @param raw - the text as written\n * @param line - the line, for errors\n * @returns the decoded text\n */\nexport function decodeEntities(raw: string, line: number): string {\n    let amp = raw.indexOf(\"&\");\n    if (amp < 0) {\n        return raw;\n    }\n    let out = \"\";\n    let start = 0;\n    while (amp >= 0) {\n        out += raw.slice(start, amp);\n        const semi = raw.indexOf(\";\", amp + 1);\n        if (semi < 0) {\n            throw new XmlSyntaxError(\"unterminated entity reference\", line);\n        }\n        const name = raw.slice(amp + 1, semi);\n        if (name.startsWith(\"#\")) {\n            const hex = name.startsWith(\"#x\") || name.startsWith(\"#X\");\n            const digits = name.slice(hex ? 2 : 1);\n            const ok = hex ? /^[0-9a-fA-F]{1,6}$/.test(digits) : /^[0-9]{1,7}$/.test(digits);\n            const cp = ok ? Number.parseInt(digits, hex ? 16 : 10) : -1;\n            if (cp < 0 || !isXmlChar(cp)) {\n                throw new XmlSyntaxError(`invalid character reference &${name};`, line);\n            }\n            out += String.fromCodePoint(cp);\n        } else {\n            const value = NAMED_ENTITIES[name];\n            if (value === undefined) {\n                throw new XmlSyntaxError(`unknown entity &${name};`, line);\n            }\n            out += value;\n        }\n        start = semi + 1;\n        amp = raw.indexOf(\"&\", start);\n    }\n    return out + raw.slice(start);\n}\n\n/**\n * Whether a text is whitespace only.\n * @param text - the text\n * @returns true when every character is XML whitespace (also for an empty text)\n */\nexport function isWhitespace(text: string): boolean {\n    for (let i = 0; i < text.length; i++) {\n        if (!isSpace(text.charCodeAt(i))) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/**\n * The local part of a possibly prefixed XML name.\n * @param name - the name as written\n * @returns the text after the last colon, or the name itself\n */\nexport function localName(name: string): string {\n    const colon = name.lastIndexOf(\":\");\n    return colon < 0 ? name : name.slice(colon + 1);\n}\n\n/**\n * Tokenize XML text arriving in chunks and deliver events to a handler. Throws XmlSyntaxError on\n * malformed input; any error the handler throws propagates unchanged.\n * @param chunks - the text (already UTF-8 decoded, BOM removed)\n * @param handler - the event sink\n */\nexport async function tokenizeXml(chunks: AsyncIterable<string>, handler: XmlHandler): Promise<void> {\n    const tokenizer = new XmlTokenizer(handler);\n    for await (const chunk of chunks) {\n        tokenizer.push(chunk);\n    }\n    tokenizer.finish();\n}\n\n/** The result of parsing one start tag out of the buffer. */\ninterface StartTag {\n    /** The element name. */\n    readonly name: string;\n    /** The attributes. */\n    readonly attrs: Map<string, string>;\n    /** Whether the tag ends with `/>`. */\n    readonly selfClosing: boolean;\n    /** The buffer index one past the `>`. */\n    readonly end: number;\n}\n\n/** The kinds of markup whose end may lie in a later chunk. */\ntype PendingKind = \"decl\" | \"comment\" | \"cdata\" | \"pi\" | \"endtag\" | \"doctype\" | \"starttag\";\n\n/** The terminator of each fixed-terminator markup kind. */\nconst TERMINATORS: Readonly<Partial<Record<PendingKind, string>>> = {\n    comment: \"-->\",\n    cdata: \"]]>\",\n    pi: \"?>\",\n    endtag: \">\",\n};\n\n/**\n * An incomplete piece of markup at the end of the input so far: its text pieces (never joined\n * until the end is found, so a token spanning many chunks costs its length once) and the state\n * the terminator scan is in. `tail` holds the last characters of the pieces a fixed terminator\n * could straddle; `quote` is the open quote character (0 outside a value) of a start tag or a\n * DOCTYPE; `depth`, `comment` and `run` track a DOCTYPE's internal subset.\n */\ninterface Pending {\n    kind: PendingKind;\n    readonly pieces: string[];\n    tail: string;\n    quote: number;\n    depth: number;\n    comment: boolean;\n    run: number;\n}\n\n/**\n * The tokenizer state: the unconsumed tail of the input, the current line, the open element\n * stack and the text run being accumulated. `push()` chunks, then `finish()`.\n */\nexport class XmlTokenizer {\n    private readonly handler: XmlHandler;\n\n    /** Unconsumed input that is not part of a pending token: at most a held-back entity or the last chunk. */\n    private buffer = \"\";\n\n    /** The markup whose end has not arrived yet, or null. */\n    private pending: Pending | null = null;\n\n    /** The line number at the start of `buffer` (or of the pending markup). */\n    private line = 1;\n\n    /**\n     * The index of the next line break in `buffer` at or after the last counted position: -2\n     * when not yet searched for the current buffer, -1 when the buffer holds no further break.\n     */\n    private nextBreak = -2;\n\n    /** A CR held back from the end of the previous chunk (it may be the first half of CR LF). */\n    private pendingCr = false;\n\n    /** Whether the input has ended (an incomplete token is then an error, not a wait). */\n    private final = false;\n\n    /** The text run being accumulated (entities decoded), and the line it started on. */\n    private text = \"\";\n\n    private textLine = 1;\n\n    private readonly stack: string[] = [];\n\n    private rootSeen = false;\n\n    private rootClosed = false;\n\n    /**\n     * Create a tokenizer.\n     * @param handler - the event sink\n     */\n    constructor(handler: XmlHandler) {\n        this.handler = handler;\n    }\n\n    /**\n     * Feed one chunk and emit every complete token in it.\n     * @param chunk - the text\n     */\n    push(chunk: string): void {\n        let text = chunk;\n        if (this.pendingCr) {\n            text = `\\r${text}`;\n            this.pendingCr = false;\n        }\n        if (text.endsWith(\"\\r\")) {\n            this.pendingCr = true;\n            text = text.slice(0, -1);\n        }\n        if (text.includes(\"\\r\")) {\n            text = text.replace(/\\r\\n?/g, \"\\n\");\n        }\n        this.feed(text);\n    }\n\n    /** Signal the end of the input: flush the last text run and check well-formedness. */\n    finish(): void {\n        this.final = true;\n        if (this.pendingCr) {\n            this.pendingCr = false;\n            this.feed(\"\\n\");\n        } else {\n            this.feed(\"\");\n        }\n        if (this.pending !== null || this.buffer.length > 0) {\n            throw new XmlSyntaxError(\"unexpected end of input inside markup\", this.line);\n        }\n        this.flushText();\n        if (this.stack.length > 0) {\n            throw new XmlSyntaxError(`unclosed element <${this.stack[this.stack.length - 1]}>`, this.line);\n        }\n        if (!this.rootSeen) {\n            throw new XmlSyntaxError(\"no root element\", this.line);\n        }\n    }\n\n    /**\n     * Append normalised text: continue a pending token's terminator scan over the new text alone,\n     * and once the token is complete (or when none is pending) scan the buffer for tokens.\n     * @param text - the text, line breaks normalised\n     */\n    private feed(text: string): void {\n        const { pending } = this;\n        if (pending === null) {\n            this.buffer = this.buffer.length === 0 ? text : this.buffer + text;\n            this.nextBreak = -2;\n            this.scan();\n            return;\n        }\n        if (pending.kind === \"decl\") {\n            // fewer than MIN_DECIDABLE_MARKUP characters of markup: the kind is decided once enough arrived\n            this.pending = null;\n            this.buffer = pending.pieces.join(\"\") + text;\n            this.nextBreak = -2;\n            this.scan();\n            return;\n        }\n        const end = this.scanPending(pending, text);\n        if (end < 0) {\n            if (text.length > 0) {\n                pending.pieces.push(text);\n            }\n            if (this.final) {\n                throw new XmlSyntaxError(\"unexpected end of input inside markup\", this.line);\n            }\n            return;\n        }\n        this.pending = null;\n        pending.pieces.push(text.slice(0, end));\n        this.buffer = pending.pieces.join(\"\") + text.slice(end);\n        this.nextBreak = -2;\n        this.scan();\n    }\n\n    /**\n     * Continue the terminator scan of a pending token over new text.\n     * @param pending - the pending token\n     * @param text - the new text\n     * @returns the index in `text` one past the token's end, or -1 when it does not end there\n     */\n    private scanPending(pending: Pending, text: string): number {\n        switch (pending.kind) {\n            case \"starttag\":\n                return this.scanStartTag(pending, text, 0);\n            case \"doctype\":\n                return this.scanDoctype(pending, text, 0);\n            case \"decl\":\n                return -1;\n            default: {\n                const terminator = TERMINATORS[pending.kind] ?? \">\";\n                const probe = pending.tail + text;\n                const at = probe.indexOf(terminator);\n                if (at < 0) {\n                    pending.tail = probe.slice(Math.max(0, probe.length - (terminator.length - 1)));\n                    return -1;\n                }\n                return at + terminator.length - pending.tail.length;\n            }\n        }\n    }\n\n    /**\n     * Scan text for the `>` that ends a start tag, skipping quoted attribute values (the quote\n     * state survives between calls).\n     * @param pending - the pending token\n     * @param text - the text\n     * @param from - where to start\n     * @returns the index one past the `>`, or -1\n     */\n    private scanStartTag(pending: Pending, text: string, from: number): number {\n        let { quote } = pending;\n        const n = text.length;\n        let i = from;\n        while (i < n) {\n            if (quote !== 0) {\n                // inside an attribute value: jump to its closing quote\n                const close = text.indexOf(String.fromCharCode(quote), i);\n                if (close < 0) {\n                    break;\n                }\n                quote = 0;\n                i = close + 1;\n                continue;\n            }\n            const c = text.charCodeAt(i);\n            if (c === QUOTE || c === APOS) {\n                quote = c;\n            } else if (c === GT) {\n                pending.quote = 0;\n                return i + 1;\n            }\n            i++;\n        }\n        pending.quote = quote;\n        return -1;\n    }\n\n    /**\n     * Scan text for the `>` that ends a DOCTYPE declaration, skipping a bracketed internal subset,\n     * quoted literals and comments inside the subset. A character state machine, so the state\n     * (`depth`, `quote`, `comment`, and `run`, the progress through a `<!--` or the dashes before\n     * a `-->`) survives between calls and nothing is re-read.\n     * @param pending - the pending token\n     * @param text - the text\n     * @param from - where to start\n     * @returns the index one past the `>`, or -1\n     */\n    private scanDoctype(pending: Pending, text: string, from: number): number {\n        let { quote, depth, comment, run } = pending;\n        for (let i = from; i < text.length; i++) {\n            const c = text.charCodeAt(i);\n            if (comment) {\n                if (c === DASH) {\n                    run++;\n                } else if (c === GT && run >= 2) {\n                    comment = false;\n                    run = 0;\n                } else {\n                    run = 0;\n                }\n                continue;\n            }\n            if (quote !== 0) {\n                if (c === quote) {\n                    quote = 0;\n                }\n                continue;\n            }\n            if (depth > 0) {\n                if (run === 1 && c === BANG) {\n                    run = 2;\n                    continue;\n                }\n                if (run === 2 && c === DASH) {\n                    run = 3;\n                    continue;\n                }\n                if (run === 3 && c === DASH) {\n                    comment = true;\n                    run = 0;\n                    continue;\n                }\n                run = 0;\n                if (c === LT) {\n                    run = 1;\n                    continue;\n                }\n            }\n            if (c === QUOTE || c === APOS) {\n                quote = c;\n            } else if (c === OPEN_BRACKET) {\n                depth++;\n            } else if (c === CLOSE_BRACKET) {\n                depth--;\n            } else if (c === GT && depth <= 0) {\n                pending.quote = 0;\n                pending.depth = 0;\n                pending.comment = false;\n                pending.run = 0;\n                return i + 1;\n            }\n        }\n        pending.quote = quote;\n        pending.depth = depth;\n        pending.comment = comment;\n        pending.run = run;\n        return -1;\n    }\n\n    /**\n     * Consume every complete token at the front of the buffer; an incomplete token at its end\n     * becomes the pending token (its text moved out of the buffer), a possibly split entity\n     * reference is held back in the buffer.\n     */\n    private scan(): void {\n        const { buffer } = this;\n        const { length } = buffer;\n        let pos = 0;\n        let incomplete = false;\n        for (;;) {\n            const lt = buffer.indexOf(\"<\", pos);\n            if (lt < 0) {\n                let end = length;\n                if (!this.final) {\n                    // an entity reference may be split across chunks: hold back from its \"&\"\n                    const amp = buffer.lastIndexOf(\"&\");\n                    if (amp >= pos && amp >= length - MAX_ENTITY_LENGTH && buffer.indexOf(\";\", amp) < 0) {\n                        end = amp;\n                    }\n                }\n                this.takeText(pos, end);\n                pos = end;\n                break;\n            }\n            if (lt > pos) {\n                this.takeText(pos, lt);\n                pos = lt;\n            }\n            const next = this.consumeMarkup(pos);\n            if (next < 0) {\n                incomplete = true;\n                break;\n            }\n            pos = next;\n        }\n        if (incomplete) {\n            this.pending = this.startPending(buffer, pos);\n            this.buffer = \"\";\n        } else {\n            this.buffer = pos === 0 ? buffer : buffer.slice(pos);\n        }\n        this.nextBreak = -2;\n    }\n\n    /**\n     * Turn the incomplete markup at `pos` into a pending token, running the terminator scan over\n     * the part already in the buffer so later chunks are scanned alone.\n     * @param buffer - the buffer\n     * @param pos - the index of the `<`\n     * @returns the pending token\n     */\n    private startPending(buffer: string, pos: number): Pending {\n        const piece = pos === 0 ? buffer : buffer.slice(pos);\n        const pending: Pending = {\n            kind: \"starttag\",\n            pieces: [piece],\n            tail: \"\",\n            quote: 0,\n            depth: 0,\n            comment: false,\n            run: 0,\n        };\n        if (piece.length < MIN_DECIDABLE_MARKUP) {\n            // too short to tell a comment from a start tag: wait for more before choosing a scan\n            pending.kind = \"decl\";\n            return pending;\n        }\n        if (piece.startsWith(\"<!--\")) {\n            pending.kind = \"comment\";\n        } else if (piece.startsWith(\"<![CDATA[\")) {\n            pending.kind = \"cdata\";\n        } else if (piece.startsWith(\"<!DOCTYPE\")) {\n            pending.kind = \"doctype\";\n        } else if (piece.startsWith(\"<!\")) {\n            pending.kind = \"decl\";\n            return pending;\n        } else if (piece.startsWith(\"<?\")) {\n            pending.kind = \"pi\";\n        } else if (piece.startsWith(\"</\")) {\n            pending.kind = \"endtag\";\n        }\n        // the part in the buffer holds no terminator (consumeMarkup said so); record the scan state\n        switch (pending.kind) {\n            case \"starttag\":\n                this.scanStartTag(pending, piece, 1);\n                break;\n            case \"doctype\":\n                this.scanDoctype(pending, piece, 9);\n                break;\n            default: {\n                const terminator = TERMINATORS[pending.kind] ?? \">\";\n                pending.tail = piece.slice(Math.max(0, piece.length - (terminator.length - 1)));\n                break;\n            }\n        }\n        return pending;\n    }\n\n    /**\n     * Consume the markup starting at `pos` (a `<`).\n     * @param pos - the index of the `<`\n     * @returns the index after the markup, or -1 when the buffer ends before the markup does\n     */\n    private consumeMarkup(pos: number): number {\n        const { buffer } = this;\n        if (buffer.startsWith(\"<!\", pos)) {\n            if (buffer.length - pos < MIN_DECIDABLE_MARKUP && !this.final) {\n                // \"<![CDATA[\" is 9 characters; wait until the kind of declaration is decidable\n                return -1;\n            }\n            if (buffer.startsWith(\"<!--\", pos)) {\n                const end = buffer.indexOf(\"-->\", pos + 4);\n                if (end < 0) {\n                    return -1;\n                }\n                this.advanceLine(pos, end + 3);\n                return end + 3;\n            }\n            if (buffer.startsWith(\"<![CDATA[\", pos)) {\n                const end = buffer.indexOf(\"]]>\", pos + 9);\n                if (end < 0) {\n                    return -1;\n                }\n                if (this.text.length === 0) {\n                    this.textLine = this.line;\n                }\n                const cdata = buffer.slice(pos + 9, end);\n                if (hasIllegalXmlChar(cdata)) {\n                    throw new XmlSyntaxError(\"a character XML 1.0 forbids appears in a CDATA section\", this.line);\n                }\n                this.text += cdata;\n                this.advanceLine(pos, end + 3);\n                return end + 3;\n            }\n            if (!buffer.startsWith(\"<!DOCTYPE\", pos)) {\n                throw new XmlSyntaxError(\"unexpected markup declaration\", this.line);\n            }\n            const state: Pending = {\n                kind: \"doctype\",\n                pieces: [],\n                tail: \"\",\n                quote: 0,\n                depth: 0,\n                comment: false,\n                run: 0,\n            };\n            const end = this.scanDoctype(state, buffer, pos + 9);\n            if (end < 0) {\n                return -1;\n            }\n            this.advanceLine(pos, end);\n            return end;\n        }\n        if (buffer.startsWith(\"<?\", pos)) {\n            const end = buffer.indexOf(\"?>\", pos + 2);\n            if (end < 0) {\n                return -1;\n            }\n            this.advanceLine(pos, end + 2);\n            return end + 2;\n        }\n        if (buffer.startsWith(\"</\", pos)) {\n            const end = buffer.indexOf(\">\", pos + 2);\n            if (end < 0) {\n                return -1;\n            }\n            const name = buffer.slice(pos + 2, end).trim();\n            if (!isXmlName(name)) {\n                throw new XmlSyntaxError(`malformed end tag </${name}>`, this.line);\n            }\n            this.flushText();\n            this.endElement(name);\n            this.advanceLine(pos, end + 1);\n            return end + 1;\n        }\n        const tag = this.parseStartTag(pos);\n        if (tag === null) {\n            return -1;\n        }\n        this.flushText();\n        this.startElement(tag.name, tag.attrs);\n        if (tag.selfClosing) {\n            this.endElement(tag.name);\n        }\n        this.advanceLine(pos, tag.end);\n        return tag.end;\n    }\n\n    /**\n     * Parse a start tag at `pos`.\n     * @param pos - the index of the `<`\n     * @returns the tag, or null when the buffer ends inside it\n     */\n    private parseStartTag(pos: number): StartTag | null {\n        const { buffer } = this;\n        const { length } = buffer;\n        let i = pos + 1;\n        const nameEnd = this.readName(i);\n        if (nameEnd < 0) {\n            return null;\n        }\n        if (nameEnd === i) {\n            throw new XmlSyntaxError(\"expected an element name after <\", this.line);\n        }\n        const name = buffer.slice(i, nameEnd);\n        i = nameEnd;\n        const attrs = new Map<string, string>();\n        for (;;) {\n            while (i < length && isSpace(buffer.charCodeAt(i))) {\n                i++;\n            }\n            if (i >= length) {\n                return null;\n            }\n            const c = buffer.charCodeAt(i);\n            if (c === GT) {\n                return { name, attrs, selfClosing: false, end: i + 1 };\n            }\n            if (c === SLASH) {\n                if (i + 1 >= length) {\n                    return null;\n                }\n                if (buffer.charCodeAt(i + 1) !== GT) {\n                    throw new XmlSyntaxError(`unexpected \"/\" in <${name}>`, this.line);\n                }\n                return { name, attrs, selfClosing: true, end: i + 2 };\n            }\n            const attrEnd = this.readName(i);\n            if (attrEnd < 0) {\n                return null;\n            }\n            if (attrEnd === i) {\n                throw new XmlSyntaxError(`malformed attribute in <${name}>`, this.line);\n            }\n            const attrName = buffer.slice(i, attrEnd);\n            i = attrEnd;\n            while (i < length && isSpace(buffer.charCodeAt(i))) {\n                i++;\n            }\n            if (i >= length) {\n                return null;\n            }\n            if (buffer.charCodeAt(i) !== EQUALS) {\n                throw new XmlSyntaxError(`attribute ${attrName} of <${name}> has no value`, this.line);\n            }\n            i++;\n            while (i < length && isSpace(buffer.charCodeAt(i))) {\n                i++;\n            }\n            if (i >= length) {\n                return null;\n            }\n            const quote = buffer.charCodeAt(i);\n            if (quote !== QUOTE && quote !== APOS) {\n                throw new XmlSyntaxError(`attribute ${attrName} of <${name}> is not quoted`, this.line);\n            }\n            const close = buffer.indexOf(quote === QUOTE ? '\"' : \"'\", i + 1);\n            if (close < 0) {\n                return null;\n            }\n            if (attrs.has(attrName)) {\n                throw new XmlSyntaxError(`duplicate attribute ${attrName} in <${name}>`, this.line);\n            }\n            const raw = buffer.slice(i + 1, close);\n            if (hasIllegalXmlChar(raw)) {\n                throw new XmlSyntaxError(\n                    `a character XML 1.0 forbids appears in attribute ${attrName} of <${name}>`,\n                    this.line,\n                );\n            }\n            attrs.set(attrName, decodeEntities(normalizeAttributeValue(raw), this.line));\n            i = close + 1;\n        }\n    }\n\n    /**\n     * The end of the XML Name starting at `i` (an ASCII table for the common case, the code point\n     * classes beyond it).\n     * @param i - the start index\n     * @returns the index after the name; `i` when no name starts there; -1 when the name may\n     * continue past the end of the buffer\n     */\n    private readName(i: number): number {\n        const { buffer } = this;\n        const { length } = buffer;\n        let j = i;\n        while (j < length) {\n            const c = buffer.charCodeAt(j);\n            if (c < 0x80) {\n                if ((j === i ? ASCII_NAME_START[c] : ASCII_NAME_CHAR[c]) === 0) {\n                    break;\n                }\n                j++;\n                continue;\n            }\n            const cp = buffer.codePointAt(j);\n            if (cp === undefined || (j === i ? !isNameStart(cp) : !isNameChar(cp))) {\n                break;\n            }\n            j += cp > 0xffff ? 2 : 1;\n        }\n        return j >= length && !this.final ? -1 : j;\n    }\n\n    /**\n     * Move text from the buffer into the current run.\n     * @param start - the start index\n     * @param end - the end index (exclusive)\n     */\n    private takeText(start: number, end: number): void {\n        if (end <= start) {\n            return;\n        }\n        if (this.text.length === 0) {\n            this.textLine = this.line;\n        }\n        const raw = this.buffer.slice(start, end);\n        if (hasIllegalXmlChar(raw)) {\n            throw new XmlSyntaxError(\"a character XML 1.0 forbids appears in character data\", this.line);\n        }\n        this.text += decodeEntities(raw, this.line);\n        this.advanceLine(start, end);\n    }\n\n    /**\n     * Count the newlines of a consumed range. Ranges are consumed in order, so the next line break\n     * is searched for once per buffer and re-searched only after it was passed; a buffer without\n     * a further break is searched once and remembered as such.\n     * @param start - the start index\n     * @param end - the end index (exclusive)\n     */\n    private advanceLine(start: number, end: number): void {\n        let i = this.nextBreak;\n        if (i === -1) {\n            return;\n        }\n        if (i === -2 || i < start) {\n            i = this.buffer.indexOf(\"\\n\", start);\n        }\n        while (i >= 0 && i < end) {\n            this.line++;\n            i = this.buffer.indexOf(\"\\n\", i + 1);\n        }\n        this.nextBreak = i;\n    }\n\n    /** Deliver the accumulated text run, if any. */\n    private flushText(): void {\n        if (this.text.length === 0) {\n            return;\n        }\n        const { text } = this;\n        this.text = \"\";\n        if (this.stack.length === 0) {\n            if (!isWhitespace(text)) {\n                throw new XmlSyntaxError(\"text outside the root element\", this.textLine);\n            }\n            return;\n        }\n        this.handler.text(text, this.textLine);\n    }\n\n    /**\n     * Open an element.\n     * @param name - the element name\n     * @param attrs - its attributes\n     */\n    private startElement(name: string, attrs: Map<string, string>): void {\n        if (this.stack.length === 0) {\n            if (this.rootClosed) {\n                throw new XmlSyntaxError(`a second root element <${name}> follows the document element`, this.line);\n            }\n            this.rootSeen = true;\n        }\n        this.stack.push(name);\n        this.handler.start(name, attrs, this.line);\n    }\n\n    /**\n     * Close an element, checking that it matches the innermost open one.\n     * @param name - the element name\n     */\n    private endElement(name: string): void {\n        const open = this.stack.length > 0 ? this.stack[this.stack.length - 1] : null;\n        if (open === null) {\n            throw new XmlSyntaxError(`unexpected end tag </${name}>`, this.line);\n        }\n        if (open !== name) {\n            throw new XmlSyntaxError(`end tag </${name}> does not match <${open}>`, this.line);\n        }\n        this.stack.pop();\n        if (this.stack.length === 0) {\n            this.rootClosed = true;\n        }\n        this.handler.end(name, this.line);\n    }\n}\n\n/**\n * Attribute value normalisation (XML 1.0 section 3.3.3): a literal tab or line break becomes a\n * space; a character reference to one is kept, which is why this runs before entity decoding.\n * @param raw - the value between the quotes\n * @returns the normalised value\n */\nfunction normalizeAttributeValue(raw: string): string {\n    return raw.includes(\"\\n\") || raw.includes(\"\\t\") ? raw.replace(/[\\n\\t]/g, \" \") : raw;\n}\n","/**\n * Id, label and value escaping for the text formats (design section 8.5), one function per\n * syntax, with the inverse where the importer needs it: XML attribute and element text (GEXF,\n * GraphML), GML quoted strings (`\"` and `&` and non-ASCII as `&#NN;` character entities, the\n * NetworkX convention), DOT ids (bare when the grammar allows, quoted with `\\\"` otherwise), RFC\n * 4180 CSV cells and Pajek labels.\n */\n\nimport { GraphFormatError } from \"@graphty/graph-format\";\n\nimport { hasIllegalXmlChar } from \"./xml.js\";\n\nconst XML_TEXT_SPECIAL = /[&<>\\r]/g;\nconst XML_ATTR_SPECIAL = /[&<>\"\\t\\n\\r]/g;\nconst XML_REPLACEMENTS: Readonly<Record<string, string>> = {\n    \"&\": \"&amp;\",\n    \"<\": \"&lt;\",\n    \">\": \"&gt;\",\n    '\"': \"&quot;\",\n    \"\\t\": \"&#9;\",\n    \"\\n\": \"&#10;\",\n    \"\\r\": \"&#13;\",\n};\n\n/**\n * Escape text for an XML element body: `&`, `<`, `>` and a carriage return (which XML\n * end-of-line handling would turn into a line feed on every read) as character references. A\n * character XML 1.0 forbids (a C0 control other than tab / LF / CR, U+FFFE, U+FFFF, a lone\n * surrogate) has no XML spelling at all and is E_COLUMN_TYPE; the exporters' check() counts them.\n * @param text - the text\n * @returns the escaped text\n */\nexport function escapeXmlText(text: string): string {\n    if (hasIllegalXmlChar(text)) {\n        throw illegalXml(text);\n    }\n    return text.replace(XML_TEXT_SPECIAL, (c) => XML_REPLACEMENTS[c]);\n}\n\n/**\n * Escape text for a double-quoted XML attribute value: `&`, `<`, `>`, `\"` and the whitespace\n * characters attribute normalisation would fold; a character XML 1.0 forbids is E_COLUMN_TYPE.\n * @param text - the text\n * @returns the escaped text\n */\nexport function escapeXmlAttribute(text: string): string {\n    if (hasIllegalXmlChar(text)) {\n        throw illegalXml(text);\n    }\n    return text.replace(XML_ATTR_SPECIAL, (c) => XML_REPLACEMENTS[c]);\n}\n\n/**\n * The error of a text no XML 1.0 document can carry.\n * @param text - the text\n * @returns the error\n */\nfunction illegalXml(text: string): GraphFormatError {\n    return new GraphFormatError(\"E_COLUMN_TYPE\", \"the text holds a character XML 1.0 cannot carry\", {\n        reason: \"xml illegal char\",\n        length: text.length,\n    });\n}\n\nconst GML_SPECIAL = /[\"&]|[^ -~]/gu;\n\n/**\n * Quote a GML string value: double quotes around the text with `\"`, `&` and every character\n * outside printable ASCII written as `&#NN;` (NetworkX's writer convention, which its reader and\n * Gephi's decode).\n * A lone surrogate cannot be written and is E_COLUMN_TYPE.\n * @param text - the text\n * @returns the quoted GML string\n */\nexport function quoteGmlString(text: string): string {\n    const escaped = text.replace(GML_SPECIAL, (c) => {\n        const code = c.codePointAt(0);\n        if (code === undefined) {\n            return c;\n        }\n        if (code >= 0xd800 && code <= 0xdfff) {\n            throw new GraphFormatError(\"E_COLUMN_TYPE\", \"a lone surrogate cannot be written as a GML string\", {\n                reason: \"lone surrogate\",\n            });\n        }\n        return `&#${code};`;\n    });\n    return `\"${escaped}\"`;\n}\n\nconst GML_ENTITY = /&(#[0-9]+|#x[0-9a-fA-F]+|amp|quot|lt|gt|apos);/g;\nconst GML_NAMED: Readonly<Record<string, string>> = { amp: \"&\", quot: '\"', lt: \"<\", gt: \">\", apos: \"'\" };\n\n/**\n * Decode the character entities of a GML string body (the inverse of quoteGmlString on the text\n * between the quotes). An unknown entity is left as written.\n * @param body - the text between the quotes\n * @returns the decoded text\n */\nexport function decodeGmlString(body: string): string {\n    return body.replace(GML_ENTITY, (whole, entity: string) => {\n        if (entity.startsWith(\"#x\")) {\n            return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));\n        }\n        if (entity.startsWith(\"#\")) {\n            return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));\n        }\n        return GML_NAMED[entity] ?? whole;\n    });\n}\n\nconst DOT_NUMERAL = /^-?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)$/;\nconst DOT_KEYWORDS: ReadonlySet<string> = new Set([\"node\", \"edge\", \"graph\", \"digraph\", \"subgraph\", \"strict\"]);\n\n/**\n * Whether a text is a DOT ID that needs no quotes: an alphanumeric identifier not starting with\n * a digit, or a numeral, and not a keyword (case-insensitive).\n * @param text - the text\n * @returns true when the text can be written bare\n */\nexport function isBareDotId(text: string): boolean {\n    if (DOT_KEYWORDS.has(text.toLowerCase())) {\n        return false;\n    }\n    return isDotIdentifier(text) || DOT_NUMERAL.test(text);\n}\n\n/**\n * Whether a text is a DOT identifier: a letter, underscore or any character of code 128 and\n * above, followed by letters, digits, underscores or such characters.\n * @param text - the text\n * @returns true for a bare identifier\n */\nfunction isDotIdentifier(text: string): boolean {\n    if (text.length === 0) {\n        return false;\n    }\n    for (let i = 0; i < text.length; i++) {\n        const c = text.charCodeAt(i);\n        const letter = (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95 || c >= 128;\n        const digit = c >= 48 && c <= 57;\n        if (!letter && (i === 0 || !digit)) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/**\n * Whether a text can be written as a DOT ID at all. Graphviz's scanner consumes a backslash pair\n * `\\\\` as one unit, `\\\"` as an escaped quote and a backslash before a line break as a line\n * continuation (both removed), left to right, so a backslash that precedes a double quote or a\n * line break, or ends the text, cannot be written: the written `\\\\\"` reads as a pair and a closing\n * quote, a backslash before a line break vanishes with the break, and a trailing backslash escapes\n * the closing quote. Every other text is writable; quoteDotId() writes it.\n * @param text - the id, name or value text\n * @returns true when quoteDotId(text) reads back as `text`\n */\nexport function isWritableDotText(text: string): boolean {\n    return !text.endsWith(\"\\\\\") && !text.includes('\\\\\"') && !/\\\\[\\r\\n]/.test(text);\n}\n\n/**\n * Write a DOT ID: bare when the grammar allows, otherwise double-quoted with `\"` escaped as `\\\"`.\n * In DOT quoted strings the dyad `\\\"` is the only escape; every other character, a backslash and\n * a raw line break included, is kept as written, so nothing else is rewritten. A text ending in a\n * backslash has no DOT spelling (isWritableDotText); the caller refuses it before writing.\n * @param text - the id or label text\n * @returns the DOT ID\n */\nexport function quoteDotId(text: string): string {\n    if (isBareDotId(text)) {\n        return text;\n    }\n    return `\"${text.replace(/\"/g, '\\\\\"')}\"`;\n}\n\n/**\n * Write a set CSV cell per RFC 4180: quoted with `\"` doubled when the text contains the\n * delimiter, a quote, a CR or LF, or leading / trailing whitespace; bare otherwise. The empty\n * string is written as the quoted empty cell `\"\"`, so the importers can tell a set empty string\n * (and an empty-string node id, legal under design section 4.1) from an unset cell, which every\n * exporter writes as nothing between the delimiters.\n * @param text - the cell text of a set cell\n * @param delimiter - the field delimiter (default \",\")\n * @returns the cell as written\n */\nexport function quoteCsvCell(text: string, delimiter = \",\"): string {\n    if (text.length === 0) {\n        return '\"\"';\n    }\n    if (\n        !text.includes(delimiter) &&\n        !text.includes('\"') &&\n        !text.includes(\"\\n\") &&\n        !text.includes(\"\\r\") &&\n        text === text.trim()\n    ) {\n        return text;\n    }\n    return `\"${text.replace(/\"/g, '\"\"')}\"`;\n}\n\n/**\n * Whether a text can be a Pajek label: Pajek has no escape mechanism inside its double-quoted\n * labels, so a text containing a double quote, a CR or an LF cannot be written.\n * @param text - the label text\n * @returns true when quotePajekLabel() can write it\n */\nexport function isPajekLabel(text: string): boolean {\n    return !text.includes('\"') && !text.includes(\"\\n\") && !text.includes(\"\\r\");\n}\n\n/**\n * Write a Pajek label: bare when it is a single run of non-space, non-quote characters, otherwise\n * double-quoted. E_UNSUPPORTED (reason \"pajek label\") for a text isPajekLabel() rejects; the\n * exporter's check() counts those.\n * @param text - the label text\n * @returns the label as written\n */\nexport function quotePajekLabel(text: string): string {\n    if (!isPajekLabel(text)) {\n        throw new GraphFormatError(\"E_UNSUPPORTED\", \"a Pajek label cannot contain a double quote or a line break\", {\n            reason: \"pajek label\",\n            value: text,\n        });\n    }\n    if (text.length > 0 && !/[\\s\"]/.test(text)) {\n        return text;\n    }\n    return `\"${text}\"`;\n}\n"],"names":["end"],"mappings":"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"}

package/dist/chunks/{importer-DbnGYr3_.js → importer-C6QcIRIb.js}

@@ -1,8 +1,8 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
 import { c as childrenCsr } from "./children-CL3Cy0ez.js";
-import { L as LOSS, au as joinText, ah as encodeChunks, aB as resolveExportOptions, aa as checkCapabilities, a9 as capabilities, aG as countMixedEdges, ai as explicitWeights, aw as pairFolding, aD as sanitizeIds, ak as formatF32, al as formatF64, aj as formatDecimal, an as formatInteger, a8 as canonicalId, x as MIXED_DIRECTION_CODE, g as DIRECTION_FORCED_CODE, h as DIRECTION_REFUSED_CODE, W as SINK_OPTION_CODE, n as ID_MERGED_CODE, J as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, V as ROLE_TAKEN_CODE, y as MULTIPLE_GRAPHS_CODE, r as INVALID_UTF8_CODE, m as EMPTY_INPUT_CODE, Z as SYNTAX_CODE, aC as resolveImportOptions, I as ImportReportBuilder, aA as reportUnusedOptions, az as reportSinkOptions, ay as readText, a as throwIfAborted, s as IdCoercer, l as DirectionResolver, ax as parseWeightText, af as declareResolved } from "./writer-DxSKC7TL.js";
-import { b as quoteDotId, c as isWritableDotText } from "./escape-DyI8JofU.js";
-import { i as inferTextDtype, W as WIDENING_UNSUPPORTED_CODE, p as parseTextCell, T as TextCellWriter } from "./text-CajMdVFy.js";
+import { L as LOSS, ax as joinText, ak as encodeChunks, aE as resolveExportOptions, ad as checkCapabilities, ac as capabilities, aJ as countMixedEdges, al as explicitWeights, az as pairFolding, aG as sanitizeIds, an as formatF32, ao as formatF64, am as formatDecimal, aq as formatInteger, ab as canonicalId, z as MIXED_DIRECTION_CODE, g as DIRECTION_FORCED_CODE, h as DIRECTION_REFUSED_CODE, Y as SINK_OPTION_CODE, o as ID_MERGED_CODE, P as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, X as ROLE_TAKEN_CODE, A as MULTIPLE_GRAPHS_CODE, a5 as UNKNOWN_ENCODING_CODE, n as ENCODING_FALLBACK_CODE, s as INVALID_ENCODING_CODE, u as INVALID_UTF8_CODE, m as EMPTY_INPUT_CODE, $ as SYNTAX_CODE, aF as resolveImportOptions, I as ImportReportBuilder, aD as reportUnusedOptions, aB as readText, aC as reportSinkOptions, a as throwIfAborted, v as IdCoercer, l as DirectionResolver, aA as parseWeightText, ai as declareResolved } from "./writer-BdMak4_J.js";
+import { b as quoteDotId, c as isWritableDotText } from "./escape-CKied3Ri.js";
+import { i as inferTextDtype, W as WIDENING_UNSUPPORTED_CODE, p as parseTextCell, T as TextCellWriter } from "./text-Dr0Ifpag.js";
 const DOT_FORMAT = "dot";
 const DOT_ORIGIN = Object.freeze({ format: DOT_FORMAT });
 const CLUSTER_COLUMN = "graphty.cluster";
@@ -15,7 +15,7 @@ const KEY_ATTRIBUTE = "key";
 const PIN_ATTRIBUTE = "pin";
 const DOT_META_KEY = "dot";
 const DOT_LOSS = Object.freeze({
-  /** An id, name or text with a backslash before a quote or at its end cannot be written as a DOT quoted string; export() throws. */
+  /** An id, name or text with a backslash before a quote or a line break, or at its end, cannot be written as a DOT quoted string; export() throws. */
   TRAILING_BACKSLASH: "E_DOT_TRAILING_BACKSLASH",
   /** A non-finite f32 / f64 cell has no numeric DOT spelling and reads back as text. */
   NON_FINITE: "W_DOT_NON_FINITE",
@@ -301,7 +301,7 @@ class ExportPlan {
     if (unwritable > 0) {
       note(
         DOT_LOSS.TRAILING_BACKSLASH,
-        `${unwritable} id(s), name(s) or text value(s) hold a backslash before a quote or at the end, which a DOT quoted string cannot carry; export() will throw`,
+        `${unwritable} id(s), name(s) or text value(s) hold a backslash before a quote or a line break, or at the end, which a DOT quoted string cannot carry; export() will throw`,
         null,
         unwritable
       );
@@ -420,7 +420,7 @@ class ExportPlan {
     if (first !== null) {
       throw new GraphFormatError(
         first.kind === "id" ? "E_INVALID_ID" : "E_COLUMN_TYPE",
-        `${first.kind} ${JSON.stringify(first.text)} ends in a backslash, which a DOT quoted string cannot carry`,
+        `${first.kind} ${JSON.stringify(first.text)} holds a backslash before a quote or a line break, or at its end, which a DOT quoted string cannot carry`,
         { reason: "trailing backslash", kind: first.kind, value: first.text }
       );
     }
@@ -1112,6 +1112,12 @@ const DOT_ISSUE = Object.freeze({
   EMPTY_INPUT: EMPTY_INPUT_CODE,
   /** The input holds invalid UTF-8 (fatal). */
   INVALID_UTF8: INVALID_UTF8_CODE,
+  /** Invalid bytes in the encoding a BOM, a declaration or the encoding option chose (fatal). */
+  INVALID_ENCODING: INVALID_ENCODING_CODE,
+  /** Bytes that are not UTF-8 and declare no encoding were read as windows-1252. */
+  ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
+  /** A declared encoding the platform cannot decode was ignored. */
+  UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
   /** Subgraphs or braces nested deeper than the parser's limit; fatal. */
   NESTING: "E_DOT_NESTING",
   /** An edge operator contradicting the graph keyword (warning under "operator" / "header"). */
@@ -1210,20 +1216,117 @@ const dotImporter = Object.freeze({
     const report = new ImportReportBuilder(DOT_FORMAT, resolved.errorLimit);
     reportUnusedOptions(options, report, USED_OPTIONS);
     reportSinkOptions(sink, options, report);
-    const text = await readText(input, report, resolved);
-    const parser = new DotParser(text, sink, report, resolved, mismatch);
-    try {
-      parser.parse();
-    } catch (err) {
-      if (err instanceof DotSyntaxError) {
-        report.fail(SYNTAX_CODE, err.message, { line: err.line }, { line: err.line });
-      }
-      throw err;
+    const text = await readText(input, report, { ...resolved, declaredEncoding: dotCharset });
+    const reports = { current: report };
+    const lexer = dotLexer(text, reports);
+    const first = guard(report, () => lexer.next());
+    const trailing = parseGraph(new DotParser(lexer, sink, report, resolved, mismatch), report, first);
+    if (trailing.kind !== "eof") {
+      const skipped = guard(report, () => countGraphs(lexer, trailing));
+      report.warning(
+        "unsupported",
+        MULTIPLE_GRAPHS_CODE,
+        `the input holds ${skipped} more graph(s) after the first; import() reads the first, importAll() reads every one`,
+        { line: trailing.line }
+      );
     }
     throwIfAborted(resolved.signal);
     return report.finish();
+  },
+  /**
+   * Read every graph of a DOT file (Graphviz renders each one), each into its own sink.
+   * @param input - the text, bytes or stream
+   * @param sinkFor - the sink of the graph with this index, called before its first push
+   * @param options - format-specific and common options
+   * @returns one report per graph; ImportError (E_IMPORT) on a syntax error anywhere
+   */
+  async importAll(input, sinkFor, options) {
+    const resolved = resolveImportOptions(options, {
+      ids: "canonical",
+      defaultDirected: true,
+      weightFrom: "weight"
+    });
+    const mismatch = mismatchOption(options?.mismatchedEdgeOperator);
+    const first = new ImportReportBuilder(DOT_FORMAT, resolved.errorLimit);
+    reportUnusedOptions(options, first, USED_OPTIONS);
+    const text = await readText(input, first, { ...resolved, declaredEncoding: dotCharset });
+    const reports = { current: first };
+    const lexer = dotLexer(text, reports);
+    const done = [];
+    let token = guard(first, () => lexer.next());
+    do {
+      const report = done.length === 0 ? first : new ImportReportBuilder(DOT_FORMAT, resolved.errorLimit);
+      reports.current = report;
+      const sink = sinkFor(done.length);
+      reportSinkOptions(sink, options, report);
+      token = parseGraph(new DotParser(lexer, sink, report, resolved, mismatch), report, token);
+      throwIfAborted(resolved.signal);
+      done.push(report.finish());
+    } while (token.kind !== "eof");
+    return done;
   }
 });
+function dotLexer(text, reports) {
+  return new DotTokenizer(text, (numeral, line) => {
+    reports.current.warning(
+      "validation-error",
+      DOT_ISSUE.NUMERAL_AMBIGUITY,
+      `badly delimited number ${JSON.stringify(numeral)} splits into two tokens (Graphviz warns the same)`,
+      { line, element: numeral }
+    );
+  });
+}
+function guard(report, step) {
+  try {
+    return step();
+  } catch (err) {
+    if (err instanceof DotSyntaxError) {
+      report.fail(SYNTAX_CODE, err.message, { line: err.line }, { line: err.line });
+    }
+    throw err;
+  }
+}
+function parseGraph(parser, report, first) {
+  return guard(report, () => parser.parse(first));
+}
+function countGraphs(lexer, first) {
+  let count = 0;
+  let token = first;
+  while (token.kind !== "eof") {
+    if (isKeyword(token, "strict")) {
+      token = lexer.next();
+    }
+    if (!isKeyword(token, "graph") && !isKeyword(token, "digraph")) {
+      throw new DotSyntaxError(`expected "graph" or "digraph", found ${describeToken(token)}`, token.line);
+    }
+    token = lexer.next();
+    if (token.kind === "id") {
+      token = lexer.next();
+    }
+    if (!isPunct(token, "{")) {
+      throw new DotSyntaxError(`expected "{" after the graph header, found ${describeToken(token)}`, token.line);
+    }
+    for (let depth = 1; depth > 0; ) {
+      token = lexer.next();
+      if (token.kind === "eof") {
+        throw new DotSyntaxError('missing "}" at the end of a graph', token.line);
+      }
+      if (isPunct(token, "{")) {
+        depth++;
+      } else if (isPunct(token, "}")) {
+        depth--;
+      }
+    }
+    count++;
+    token = lexer.next();
+  }
+  return count;
+}
+const DOT_CHARSET = /\bcharset\s*=\s*"?([A-Za-z][A-Za-z0-9._-]*)/i;
+function dotCharset(head) {
+  const match = DOT_CHARSET.exec(head);
+  return match === null ? null : match[1].replace(/^(latin|big)-/i, "$1");
+}
 function mismatchOption(value) {
   if (value === void 0) {
     return "operator";
@@ -1280,14 +1383,14 @@ function isClusterName(name) {
 }
 class DotParser {
   /**
-   * Create a parser over one document.
-   * @param text - the DOT text
+   * Create a parser for one graph of a document.
+   * @param lexer - the document's tokenizer, positioned at the graph
    * @param sink - the sink
    * @param report - the report
    * @param options - the resolved common options
    * @param mismatch - the resolved mismatchedEdgeOperator option
    */
-  constructor(text, sink, report, options, mismatch) {
+  constructor(lexer, sink, report, options, mismatch) {
     this.directed = true;
     this.strict = false;
     this.statements = 0;
@@ -1308,14 +1411,7 @@ class DotParser {
     this.depth = 0;
     this.nodeWriters = /* @__PURE__ */ new Map();
     this.edgeWriters = /* @__PURE__ */ new Map();
-    this.lexer = new DotTokenizer(text, (numeral, line) => {
-      report.warning(
-        "validation-error",
-        DOT_ISSUE.NUMERAL_AMBIGUITY,
-        `badly delimited number ${JSON.stringify(numeral)} splits into two tokens (Graphviz warns the same)`,
-        { line, element: numeral }
-      );
-    });
+    this.lexer = lexer;
     this.sink = sink;
     this.report = report;
     this.options = options;
@@ -1324,11 +1420,13 @@ class DotParser {
     this.resolver = new DirectionResolver(sink, report, options.onMixedDirection);
   }
   /**
-   * Parse the whole document: `[strict] (graph | digraph) [ID] { stmt_list }`.
+   * Parse one graph: `[strict] (graph | digraph) [ID] { stmt_list }`.
+   * @param first - the graph's first token (already read from the tokenizer)
+   * @returns the token after the closing brace (eof when the document ends there)
    */
-  parse() {
+  parse(first) {
     const { lexer } = this;
-    let token = lexer.next();
+    let token = first;
     if (token.kind === "eof") {
       this.report.fail(EMPTY_INPUT_CODE, "the input holds no graph (empty or only comments)", {
         line: token.line
@@ -1363,15 +1461,7 @@ class DotParser {
     });
     const root = this.newScope(null, headerLine, true, null);
     this.statementList(root);
-    const trailing = lexer.next();
-    if (trailing.kind !== "eof") {
-      this.report.warning(
-        "unsupported",
-        MULTIPLE_GRAPHS_CODE,
-        `content after the closing brace of the graph (${describeToken(trailing)}) was not read; one graph per input`,
-        { line: trailing.line }
-      );
-    }
+    return lexer.next();
   }
   /**
    * Create a scope.
@@ -2339,4 +2429,4 @@ export {
   dotImporter as b,
   dotExporter as d
 };
-//# sourceMappingURL=importer-DbnGYr3_.js.map
+//# sourceMappingURL=importer-C6QcIRIb.js.map