@graphty/graph-io 0.3.18 → 0.3.20

package/README.md

@@ -8,8 +8,8 @@
 Importers and exporters for the [@graphty/graph-format](https://www.npmjs.com/package/@graphty/graph-format)
 snapshot: GEXF, GraphML, GML, DOT (Graphviz), Pajek NET, CSV / TSV, JSON (NetworkX node-link, d3,
 JSON Graph Format, Cytoscape, graphology, vis.js; NetworkX adjacency_data and tree_data and OBO
-Graphs are read only), Neo4j (`neo4j-admin import` CSV) and OBO, the ontology format of the Gene
-Ontology (read only).
+Graphs are read only), Neo4j (`neo4j-admin import` CSV), CX2 (the NDEx / Cytoscape exchange format;
+its version 1, CX, is read only) and OBO, the ontology format of the Gene Ontology (read only).
 
 Every importer streams its input into a `GraphSink` (a `GraphBuilder` or your own sink) one scalar at
 a time and reports what it could not represent instead of dropping it; every exporter says what it
@@ -122,6 +122,14 @@ On a caller's builder the builder-policy options (`addMissingNodes`, `duplicateE
 `weightDtype`) are read from the sink; an explicit request the sink does not honour is reported once
 as a `W_SINK_OPTION` warning. `importGraph()` seeds its own builder from them.
 
+Every attribute is stored as a column with one slot per node (or edge), so a file whose nodes each
+carry a differently named attribute would need nodes x attributes memory: a few hundred kilobytes
+could take gigabytes. `importGraph()` and `importAllGraphs()` therefore stop with an `ImportError`
+(code `E_TOO_MANY_EMPTY_CELLS`) once the columns would hold more than `maxEmptyCells` slots without
+a value (default 2^24, 16,777,216; `Infinity` turns the check off). A file where most elements have
+most attributes is never stopped, however large. An importer used directly on a caller's builder
+does not apply the limit.
+
 ### Common export options
 
 `sanitizeIds: "error" | "mangle"` (default `"error"`: an exporter never silently renames a node;
@@ -147,6 +155,9 @@ reports every column or feature outside it):
 | JSON    | `@graphty/graph-io/json`    | `.json`                            | per dialect | yes         | per dialect | any           | f64 i32 bool string (no declarations)  | no    | yes  | no       | Cytoscape | none           | per dialect | Cytoscape | no  |
 | Neo4j   | `@graphty/graph-io/neo4j`   | `.csv` `.tsv`                      | no          | yes         | none        | any           | f32 f64 i32 bool string                | yes   | no   | no       | no        | none           | no          | no        | no  |
 | OBO     | `@graphty/graph-io/obo`     | `.obo`                             | read only   | -           | -           | -             | -                                      | -     | -    | -        | -         | -              | -           | -         | -   |
+| CX2     | `@graphty/graph-io/cx2`     | `.cx2`                             | no          | yes         | required    | integer       | f64 i32 bool string                    | yes   | no   | yes      | no        | none           | yes         | yes       | no  |
+| XGMML   | `@graphty/graph-io/xgmml`   | `.xgmml` `.xml`                    | yes         | yes         | optional    | any           | f64 i32 bool string (long as Long)     | yes   | no   | no       | yes       | none           | yes         | yes       | no  |
+| Session | `@graphty/graph-io/cys`     | `.cys`                             | read only   | read only   | read only   | read only     | read only                              | -     | -    | -        | -         | -              | -           | -         | -   |
 
 Every importer reads the whole corpus of research note 07 with the manifest counts and every
 exporter round-trips it (import -> export -> import gives the same ids, topology, orientation,
@@ -296,6 +307,73 @@ losses and format rules, in addition to the table:
   written with a `W_NEO4J_UNDIRECTED_AS_DIRECTED` note); `.text` companions keep the source text of
   temporal values whose canonical form differs; a dict column reads back as string and a position
   or visual column as a plain property.
+- **XGMML**: one reader for the 1.0 draft, the Cytoscape 2.x and 3.x exports and the Cytoscape 3
+  session network files. Direction follows the DTD (root `directed`, default 0), then `cy:directed`
+  per edge; ids stay strings (`"1"` and `"01"` are two nodes); atts are typed by `cy:type`, then
+  `type` (the XGMML `integer` is `i32`, widening to `f64` with `W_WIDENED` because pre-3.3
+  Cytoscape wrote Longs that way, while a value beyond i32 under `cy:type="Integer"` or in a
+  session's `java.lang.Integer` column is `E_BAD_VALUE`; Long `f64` or a string under
+  `long: "string"`, lists of their element type, record lists, lists of lists and RDF as `json`);
+  groups become `parent` / `parents`, other node-nested graphs the `cytoscape.nestedNetwork`
+  pointer; `graphics` x and y are the position, stored y-up (Cytoscape writes screen coordinates;
+  the exporter flips y back), z the separate `z` column (`zAs: "position"` makes it a coordinate),
+  every other graphics value a `json` column `graphics`. Cytoscape's `\n` / `\t` escapes, label
+  aliases (`a (pp) b`) and the two writer bugs Cytoscape repairs (`repairBareAmpersands`,
+  `pairSurrogateReferences`, both off by default) are options. A session network document lists
+  its registered networks through `listGraphs()`; `graphIndex` / `graphName` choose one. Dangling
+  endpoints are `E_UNKNOWN_NODE` unless `addMissingNodes: true`. The exporter writes the Cytoscape
+  3 dialect (`type` plus `cy:type` on every att): f32, u8, u32 and dict are written as wider
+  Cytoscape types, json as text, and graphty's visual roles are not translated into graphics.
+- **Cytoscape sessions (`.cys`)**: read only (Cytoscape opens the XGMML graph-io writes). A
+  session is a zip of every network of a Cytoscape desktop, read with no dependency (the central
+  directory, zip64, data descriptors, stored and deflate entries inflated through
+  `DecompressionStream`; encryption and other methods are refused by name). One snapshot per
+  registered network: `import()` reads the first (`graphIndex` / `graphName` choose another,
+  `listGraphs()` lists them with their counts), `importAll()` every one. 3.x: the network file's
+  topology, the network's CyCSV tables as columns (shared columns joined in by `cytables.xml`,
+  HIDDEN and app tables as hidden columns under their namespace), positions from its first view
+  (y-up; further views as `position@2`, ...) and the view's per-element values as the `graphics`
+  column; 2.x: one XGMML per network, with `cysession.xml`'s selection and hidden state as
+  `cytoscape.selected` / `cytoscape.hidden`. Expanded groups become `parent` / `parents`, a
+  collapsed group's members are listed in `meta.extra.cytoscape.groups`, nested-network pointers
+  name their network in `cytoscape.nestedNetwork`. Styles are not applied (`W_STYLES_NOT_IMPORTED`,
+  issue #706); apps, properties and images are skipped with `W_CYS_ENTRY_SKIPPED`. Text input is
+  refused (`E_CYS_NOT_ZIP`: pass the bytes). `maxUncompressedBytes` (default 2 GiB) and a 1000:1
+  ratio limit stop zip bombs (`E_TOO_LARGE`).
+
+- **CX2**: the JSON exchange format of NDEx, Cytoscape 3.10+ and Cytoscape Web, read element by
+  element so a document longer than one JavaScript string still loads. Every edge is directed;
+  node ids are integers (an id beyond 2^53 keeps its digits as a string id, `W_PRECISION`; `"5"` and
+  `5.0` read as 5, `W_ID_TEXT_TYPE`). Declared attributes become typed columns under their full
+  names (the alias in `origin.id`, the default in `meta.default`); an undeclared attribute is typed
+  from its values (`W_CX2_UNDECLARED_ATTRIBUTE`), a value of the wrong type is `E_BAD_VALUE` and its
+  cell is unset. `name` is the label; `x` / `y` are the position, stored y-up (y negated, as for every
+  Cytoscape-family format) and negated back on export; `z` is a stacking order in the `z` column
+  (`zAs: "position"` puts it in the position). Per-element visual values (`nodeBypasses`,
+  `edgeBypasses`) are one column per visual property (origin namespace `cx2.bypass`); style rules
+  (`visualProperties`, `visualEditorProperties`) and opaque aspects are kept verbatim in
+  `meta.extra.cx2.opaque` and written back, but not applied (`W_STYLES_NOT_IMPORTED`). A missing
+  `status` is `E_CX2_NO_STATUS`, `success: false` is fatal (`E_STATUS_FAILED`), an edge to an unknown
+  node is `E_UNKNOWN_NODE` (`addMissingNodes: true` creates it, as Cytoscape does). The exporter
+  refuses non-integer node ids unless `sanitizeIds: "mangle"`, which keeps the original in a
+  `graphty:originalId` attribute the importer turns back into the id; NaN and the infinities are
+  written as null (`W_CX2_NONFINITE_AS_NULL`), nested values as JSON text (`W_CX2_JSON_AS_STRING`).
+
+- **CX** (version 1, `@graphty/graph-io/cx`, `.cx`; read only -- CX2 is what NDEx and Cytoscape
+  write today): aspect fragments in any order, read element by element. Ids follow the CX2 rule;
+  `n` is the `name` label, `r` is `represents`, `i` is `interaction`; attributes are typed by their
+  `d` with Cytoscape's value rule (`""` and `"null"` are unset, `"NaN"` is NaN in a double), several
+  types for one name widen (`W_WIDENED`). A collection (several `cySubNetworks`) is one graph per
+  subnetwork: `listGraphs()` lists them, `import()` reads the one `graphIndex` / `graphName` picks
+  (the first by default, `W_MULTIPLE_GRAPHS`), `importAll()` reads them all; a subnetwork's own
+  values (`s`) beat the shared ones, and nodes or edges no subnetwork holds are not read
+  (`W_CX_ROOT_ONLY`). Positions come from the subnetwork's view (y negated to y-up,
+  other views as `position@2`, ...); `cyGroups` give `parent` or `parents` (a group whose id is
+  not a node gets one, `W_CX_GROUP_NODE_ADDED`); per-element `cyVisualProperties` of that view are
+  one column per property (origin namespace `cx.bypass`) and style rules are kept in `meta.extra.cx`
+  (`W_STYLES_NOT_IMPORTED`); citations and supports become the extension tables `cx:citations` /
+  `cx:supports`. Old aspect names (`visualProperties`, `subNetworks`, ...) are read with
+  `W_CX_OLD_ASPECT_NAME`; a CX2 document is refused naming the CX2 importer (`E_CX_NOT_CX`).
 
 ## Format detection
 

package/dist/chunks/{escape-D-gZWO26.js → escape-B-tkk_Cl.js}

@@ -1,6 +1,6 @@
 import { GraphFormatError } from "@graphty/graph-format";
-import { al as XML_ILLEGAL_CHAR_CODE } from "./report-BOk0p5y8.js";
-import { q as isNameChar } from "./writer-GAdltGmC.js";
+import { a0 as XML_ILLEGAL_CHAR_CODE } from "./report-B1z4WT9e.js";
+import { b as isNameChar } from "./export-Bh60Dv-n.js";
 class XmlSyntaxError extends Error {
   /**
    * Create the error.
@@ -13,6 +13,9 @@ class XmlSyntaxError extends Error {
     this.line = line;
   }
 }
+const BARE_AMPERSAND_LOOKAHEAD = 7;
+const CHAR_REFERENCE = /^&#(?:[xX]([0-9a-fA-F]{1,6})|([0-9]{1,7}));/;
+const TRAILING_CHAR_REFERENCE = /&#(?:[xX]([0-9a-fA-F]{1,6})|([0-9]{1,7}));$/;
 const NAMED_ENTITIES = {
   lt: "<",
   gt: ">",
@@ -136,7 +139,7 @@ function isXmlName(text) {
 function isXmlChar(cp) {
   return cp === 9 || cp === 10 || cp === 13 || cp >= 32 && cp <= 55295 || cp >= 57344 && cp <= 65533 || cp >= 65536 && cp <= 1114111;
 }
-function decodeEntities(raw, line) {
+function decodeEntities(raw, line, repairs) {
   let amp = raw.indexOf("&");
   if (amp < 0) {
     return raw;
@@ -146,6 +149,14 @@ function decodeEntities(raw, line) {
   while (amp >= 0) {
     out += raw.slice(start, amp);
     const semi = raw.indexOf(";", amp + 1);
+    if (repairs?.bareAmpersand !== void 0 && (semi < 0 || semi - amp > BARE_AMPERSAND_LOOKAHEAD) && // a well-formed character reference longer than the lookahead (&#128512;) is not bare
+    !CHAR_REFERENCE.test(raw.slice(amp, amp + 12))) {
+      repairs.bareAmpersand(lineAt(raw, amp, line));
+      out += "&";
+      start = amp + 1;
+      amp = raw.indexOf("&", start);
+      continue;
+    }
     if (semi < 0) {
       throw new XmlSyntaxError("unterminated entity reference", line);
     }
@@ -155,6 +166,14 @@ function decodeEntities(raw, line) {
       const digits = name.slice(hex ? 2 : 1);
       const ok = hex ? /^[0-9a-fA-F]{1,6}$/.test(digits) : /^[0-9]{1,7}$/.test(digits);
       const cp = ok ? Number.parseInt(digits, hex ? 16 : 10) : -1;
+      const low = cp >= 55296 && cp <= 56319 ? lowSurrogateAfter(raw, semi + 1, repairs) : null;
+      if (low !== null) {
+        repairs?.surrogatePair?.(lineAt(raw, amp, line));
+        out += String.fromCharCode(cp, low.unit);
+        start = low.end;
+        amp = raw.indexOf("&", start);
+        continue;
+      }
       if (cp < 0 || !isXmlChar(cp)) {
         throw new XmlSyntaxError(`invalid character reference &${name};`, line);
       }
@@ -171,6 +190,24 @@ function decodeEntities(raw, line) {
   }
   return out + raw.slice(start);
 }
+function lineAt(raw, at, line) {
+  let n = line;
+  for (let i = raw.indexOf("\n"); i >= 0 && i < at; i = raw.indexOf("\n", i + 1)) {
+    n++;
+  }
+  return n;
+}
+function lowSurrogateAfter(raw, at, repairs) {
+  if (repairs?.surrogatePair === void 0 || raw.charCodeAt(at) !== 38) {
+    return null;
+  }
+  const match = CHAR_REFERENCE.exec(raw.slice(at, at + 12));
+  if (match === null) {
+    return null;
+  }
+  const unit = match[1] === void 0 ? Number.parseInt(match[2], 10) : Number.parseInt(match[1], 16);
+  return unit >= 56320 && unit <= 57343 ? { unit, end: at + match[0].length } : null;
+}
 function isWhitespace(text) {
   for (let i = 0; i < text.length; i++) {
     if (!isSpace(text.charCodeAt(i))) {
@@ -183,8 +220,8 @@ function localName(name) {
   const colon = name.lastIndexOf(":");
   return colon < 0 ? name : name.slice(colon + 1);
 }
-async function tokenizeXml(chunks, handler) {
-  const tokenizer = new XmlTokenizer(handler);
+async function tokenizeXml(chunks, handler, repairs) {
+  const tokenizer = new XmlTokenizer(handler, repairs);
   for await (const chunk of chunks) {
     tokenizer.push(chunk);
   }
@@ -200,8 +237,9 @@ class XmlTokenizer {
   /**
    * Create a tokenizer.
    * @param handler - the event sink
+   * @param repairs - the opt-in repairs (XGMML only); none by default
    */
-  constructor(handler) {
+  constructor(handler, repairs) {
     this.buffer = "";
     this.pending = null;
     this.line = 1;
@@ -214,6 +252,7 @@ class XmlTokenizer {
     this.rootSeen = false;
     this.rootClosed = false;
     this.handler = handler;
+    this.repairs = repairs;
   }
   /**
    * Feed one chunk and emit every complete token in it.
@@ -440,6 +479,9 @@ class XmlTokenizer {
           if (amp >= pos && amp >= length - MAX_ENTITY_LENGTH && buffer.indexOf(";", amp) < 0) {
             end = amp;
           }
+          if (this.repairs?.surrogatePair !== void 0) {
+            end = this.holdHighSurrogate(pos, end);
+          }
         }
         this.takeText(pos, end);
         pos = end;
@@ -685,7 +727,7 @@ class XmlTokenizer {
           this.line
         );
       }
-      attrs.set(attrName, decodeEntities(normalizeAttributeValue(raw), this.line));
+      attrs.set(attrName, decodeEntities(normalizeAttributeValue(raw), this.line, this.repairs));
       i = close + 1;
     }
   }
@@ -717,6 +759,22 @@ class XmlTokenizer {
     }
     return j >= length && !this.final ? -1 : j;
   }
+  /**
+   * Under the surrogate-pair repair, hold back a high-surrogate character reference that ends
+   * the text taken so far, so it is decoded together with the low one the next chunk may start with.
+   * @param pos - the start of the text
+   * @param end - the end of the text that would be taken
+   * @returns the end to take up to
+   */
+  holdHighSurrogate(pos, end) {
+    const tail = this.buffer.slice(Math.max(pos, end - 12), end);
+    const match = TRAILING_CHAR_REFERENCE.exec(tail);
+    if (match === null) {
+      return end;
+    }
+    const unit = match[1] === void 0 ? Number.parseInt(match[2], 10) : Number.parseInt(match[1], 16);
+    return unit >= 55296 && unit <= 56319 ? end - match[0].length : end;
+  }
   /**
    * Move text from the buffer into the current run.
    * @param start - the start index
@@ -733,7 +791,7 @@ class XmlTokenizer {
     if (hasIllegalXmlChar(raw)) {
       throw new XmlSyntaxError("a character XML 1.0 forbids appears in character data", this.line);
     }
-    this.text += decodeEntities(raw, this.line);
+    this.text += decodeEntities(raw, this.line, this.repairs);
     this.advanceLine(start, end);
   }
   /**
@@ -942,13 +1000,13 @@ function quotePajekLabel(text) {
 }
 export {
   XmlSyntaxError as X,
-  XmlTokenizer as a,
-  quoteDotId as b,
-  isWritableDotText as c,
-  xmlDeclaredEncoding as d,
-  isWhitespace as e,
-  escapeXmlText as f,
-  escapeXmlAttribute as g,
+  escapeXmlText as a,
+  XmlTokenizer as b,
+  quoteDotId as c,
+  isWritableDotText as d,
+  escapeXmlAttribute as e,
+  xmlDeclaredEncoding as f,
+  isWhitespace as g,
   hasIllegalXmlChar as h,
   isPajekLabel as i,
   decodeGmlString as j,
@@ -960,4 +1018,4 @@ export {
   tokenizeXml as t,
   xmlIllegalTextNotes as x
 };
-//# sourceMappingURL=escape-D-gZWO26.js.map
+//# sourceMappingURL=escape-B-tkk_Cl.js.map

package/dist/chunks/escape-B-tkk_Cl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape-B-tkk_Cl.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\n/**\n * Opt-in repairs of two defects the Cytoscape XGMML writer is known to produce (research note\n * `research-xgmml.md` 3.8 and 5). Each is off unless its callback is given; GEXF and GraphML never\n * pass them, so their documents stay strictly well-formed. The callback is told the line of each\n * repair, so the importer can warn per occurrence.\n */\nexport interface XmlRepairs {\n    /**\n     * Read an `&` that is not followed by a `;` within the next 7 characters as `&amp;` (Cytoscape's\n     * `cytoscape.xgmml.repair.bare.ampersands` lookahead); an `&name;` that does end in time is\n     * still decoded, and still fatal when the entity is unknown. A complete numeric character\n     * reference is decoded whatever its length (`&#128512;`), where Cytoscape's byte lookahead\n     * would turn it into text.\n     */\n    readonly bareAmpersand?: ((line: number) => void) | undefined;\n    /**\n     * Join a high-surrogate character reference immediately followed by a low-surrogate one\n     * (`&#xd83d;&#xde00;`, which XML 1.0 forbids but Cytoscape writes for astral characters) into\n     * the one character they encode; a lone surrogate stays fatal.\n     */\n    readonly surrogatePair?: ((line: number) => void) | undefined;\n}\n\n/** How far Cytoscape's bare-ampersand repair looks for the `;` that ends an entity reference. */\nconst BARE_AMPERSAND_LOOKAHEAD = 7;\n\n/** A numeric character reference at the start of a text: `&#123;` or `&#x1F;`. */\nconst CHAR_REFERENCE = /^&#(?:[xX]([0-9a-fA-F]{1,6})|([0-9]{1,7}));/;\n\n/** A numeric character reference at the end of a text. */\nconst TRAILING_CHAR_REFERENCE = /&#(?:[xX]([0-9a-fA-F]{1,6})|([0-9]{1,7}));$/;\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 * @param repairs - the opt-in repairs (XGMML only); none by default\n * @returns the decoded text\n */\nexport function decodeEntities(raw: string, line: number, repairs?: XmlRepairs): 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 (\n            repairs?.bareAmpersand !== undefined &&\n            (semi < 0 || semi - amp > BARE_AMPERSAND_LOOKAHEAD) &&\n            // a well-formed character reference longer than the lookahead (&#128512;) is not bare\n            !CHAR_REFERENCE.test(raw.slice(amp, amp + 12))\n        ) {\n            repairs.bareAmpersand(lineAt(raw, amp, line));\n            out += \"&\";\n            start = amp + 1;\n            amp = raw.indexOf(\"&\", start);\n            continue;\n        }\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            const low = cp >= 0xd800 && cp <= 0xdbff ? lowSurrogateAfter(raw, semi + 1, repairs) : null;\n            if (low !== null) {\n                repairs?.surrogatePair?.(lineAt(raw, amp, line));\n                out += String.fromCharCode(cp, low.unit);\n                start = low.end;\n                amp = raw.indexOf(\"&\", start);\n                continue;\n            }\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 * The line of a position inside a text that starts on a known line.\n * @param raw - the text\n * @param at - the position\n * @param line - the line the text starts on\n * @returns the line of the position\n */\nfunction lineAt(raw: string, at: number, line: number): number {\n    let n = line;\n    for (let i = raw.indexOf(\"\\n\"); i >= 0 && i < at; i = raw.indexOf(\"\\n\", i + 1)) {\n        n++;\n    }\n    return n;\n}\n\n/**\n * The low-surrogate character reference that may follow a high-surrogate one, when the\n * surrogate-pair repair is on.\n * @param raw - the text\n * @param at - where the next reference would start\n * @param repairs - the repairs in force\n * @returns the low surrogate code unit and the index after its reference, or null\n */\nfunction lowSurrogateAfter(\n    raw: string,\n    at: number,\n    repairs: XmlRepairs | undefined,\n): { readonly unit: number; readonly end: number } | null {\n    if (repairs?.surrogatePair === undefined || raw.charCodeAt(at) !== 38) {\n        return null;\n    }\n    const match = CHAR_REFERENCE.exec(raw.slice(at, at + 12));\n    if (match === null) {\n        return null;\n    }\n    const unit = match[1] === undefined ? Number.parseInt(match[2], 10) : Number.parseInt(match[1], 16);\n    return unit >= 0xdc00 && unit <= 0xdfff ? { unit, end: at + match[0].length } : null;\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 * @param repairs - the opt-in repairs (XGMML only); none by default\n */\nexport async function tokenizeXml(\n    chunks: AsyncIterable<string>,\n    handler: XmlHandler,\n    repairs?: XmlRepairs,\n): Promise<void> {\n    const tokenizer = new XmlTokenizer(handler, repairs);\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    private readonly repairs: XmlRepairs | undefined;\n\n    /**\n     * Create a tokenizer.\n     * @param handler - the event sink\n     * @param repairs - the opt-in repairs (XGMML only); none by default\n     */\n    constructor(handler: XmlHandler, repairs?: XmlRepairs) {\n        this.handler = handler;\n        this.repairs = repairs;\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                    if (this.repairs?.surrogatePair !== undefined) {\n                        end = this.holdHighSurrogate(pos, end);\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, this.repairs));\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     * Under the surrogate-pair repair, hold back a high-surrogate character reference that ends\n     * the text taken so far, so it is decoded together with the low one the next chunk may start with.\n     * @param pos - the start of the text\n     * @param end - the end of the text that would be taken\n     * @returns the end to take up to\n     */\n    private holdHighSurrogate(pos: number, end: number): number {\n        const tail = this.buffer.slice(Math.max(pos, end - 12), end);\n        const match = TRAILING_CHAR_REFERENCE.exec(tail);\n        if (match === null) {\n            return end;\n        }\n        const unit = match[1] === undefined ? Number.parseInt(match[2], 10) : Number.parseInt(match[1], 16);\n        return unit >= 0xd800 && unit <= 0xdbff ? end - match[0].length : end;\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, this.repairs);\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]+|[A-Za-z][A-Za-z0-9]*);/g;\n\n/** The XML entities and the ISO-8859-1 HTML entities (U+00A0..U+00FF), which GML uses for characters above 127. */\nconst GML_NAMED: ReadonlyMap<string, string> = (() => {\n    const table = new Map<string, string>([\n        [\"amp\", \"&\"],\n        [\"quot\", '\"'],\n        [\"lt\", \"<\"],\n        [\"gt\", \">\"],\n        [\"apos\", \"'\"],\n    ]);\n    const latin1 = (\n        \"nbsp iexcl cent pound curren yen brvbar sect uml copy ordf laquo not shy reg macr deg plusmn sup2 \" +\n        \"sup3 acute micro para middot cedil sup1 ordm raquo frac14 frac12 frac34 iquest Agrave Aacute Acirc \" +\n        \"Atilde Auml Aring AElig Ccedil Egrave Eacute Ecirc Euml Igrave Iacute Icirc Iuml ETH Ntilde Ograve \" +\n        \"Oacute Ocirc Otilde Ouml times Oslash Ugrave Uacute Ucirc Uuml Yacute THORN szlig agrave aacute \" +\n        \"acirc atilde auml aring aelig ccedil egrave eacute ecirc euml igrave iacute icirc iuml eth ntilde \" +\n        \"ograve oacute ocirc otilde ouml divide oslash ugrave uacute ucirc uuml yacute thorn yuml\"\n    ).split(\" \");\n    latin1.forEach((name, i) => {\n        table.set(name, String.fromCharCode(0xa0 + i));\n    });\n    return table;\n})();\n\n/**\n * Decode the character entities of a GML string body (the inverse of quoteGmlString on the text\n * between the quotes): numeric references, the XML entities and the ISO-8859-1 HTML entities. An\n * unknown named entity is left as written and handed to `onUnknown`.\n * @param body - the text between the quotes\n * @param onUnknown - called with each unknown named entity (`&name;`), when given\n * @returns the decoded text\n */\nexport function decodeGmlString(body: string, onUnknown?: (entity: string) => void): 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        const known = GML_NAMED.get(entity);\n        if (known === undefined) {\n            onUnknown?.(whole);\n            return whole;\n        }\n        return known;\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 that does\n * not start with `[` (a bare `[` opens a time set, which the reader groups up to its `]`),\n * otherwise double-quoted. E_UNSUPPORTED (reason \"pajek label\") for a text isPajekLabel() rejects;\n * the 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) && !text.startsWith(\"[\")) {\n        return text;\n    }\n    return `\"${text}\"`;\n}\n"],"names":["end"],"mappings":"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"}