@graphty/graph-io 0.0.0 → 0.2.1

package/dist/chunks/escape-DyI8JofU.js

@@ -0,0 +1,938 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { aF as isNameChar, a6 as XML_ILLEGAL_CHAR_CODE } from "./writer-DxSKC7TL.js";
+class XmlSyntaxError extends Error {
+  /**
+   * Create the error.
+   * @param message - a plain-ASCII message
+   * @param line - the 1-based line
+   */
+  constructor(message, line) {
+    super(message);
+    this.name = "XmlSyntaxError";
+    this.line = line;
+  }
+}
+const NAMED_ENTITIES = {
+  lt: "<",
+  gt: ">",
+  amp: "&",
+  quot: '"',
+  apos: "'"
+};
+const LT = 60;
+const GT = 62;
+const SLASH = 47;
+const EQUALS = 61;
+const QUOTE = 34;
+const APOS = 39;
+const OPEN_BRACKET = 91;
+const CLOSE_BRACKET = 93;
+const BANG = 33;
+const DASH = 45;
+const MAX_ENTITY_LENGTH = 16;
+const MIN_DECIDABLE_MARKUP = 9;
+function isSpace(c) {
+  return c === 32 || c === 9 || c === 10 || c === 13;
+}
+function isNameStart(cp) {
+  if (!isNameChar(cp)) {
+    return false;
+  }
+  if (cp >= 48 && cp <= 57 || cp === 45 || cp === 46 || cp === 183) {
+    return false;
+  }
+  return !(cp >= 768 && cp <= 879) && cp !== 8255 && cp !== 8256;
+}
+const ASCII_NAME_START = new Uint8Array(128);
+const ASCII_NAME_CHAR = new Uint8Array(128);
+for (let c = 0; c < 128; c++) {
+  ASCII_NAME_START[c] = isNameStart(c) ? 1 : 0;
+  ASCII_NAME_CHAR[c] = isNameChar(c) ? 1 : 0;
+}
+const ILLEGAL_CHAR = new RegExp(
+  `[${String.fromCharCode(0)}-${String.fromCharCode(8)}${String.fromCharCode(11)}${String.fromCharCode(12)}${String.fromCharCode(14)}-${String.fromCharCode(31)}\\uFFFE\\uFFFF\\uD800-\\uDFFF]`,
+  "u"
+);
+function hasIllegalXmlChar(text) {
+  return ILLEGAL_CHAR.test(text);
+}
+function xmlIllegalTextNotes(snapshot) {
+  const notes = [];
+  let ids = 0;
+  for (let i = 0; i < snapshot.nodeCount; i++) {
+    const id = snapshot.ids.idOf(i);
+    if (typeof id === "string" && hasIllegalXmlChar(id)) {
+      ids++;
+    }
+  }
+  if (ids > 0) {
+    notes.push(
+      Object.freeze({
+        code: XML_ILLEGAL_CHAR_CODE,
+        message: `${ids} node id(s) hold a character XML 1.0 cannot carry; export() will throw`,
+        column: null,
+        count: ids
+      })
+    );
+  }
+  for (const [domain, table] of [
+    ["node", snapshot.nodes],
+    ["edge", snapshot.edges],
+    ["graph", snapshot.graph]
+  ]) {
+    for (const column of table) {
+      const bad = countIllegalRows(column);
+      if (bad > 0) {
+        notes.push(
+          Object.freeze({
+            code: XML_ILLEGAL_CHAR_CODE,
+            message: `${domain} column "${column.meta.name}": ${bad} value(s) hold a character XML 1.0 cannot carry; export() will throw`,
+            column: column.meta.name,
+            count: bad
+          })
+        );
+      }
+    }
+  }
+  return notes;
+}
+function countIllegalRows(column) {
+  let bad = 0;
+  if (column.dtype === "string" || column.dtype === "dict") {
+    for (let r = 0; r < column.length; r++) {
+      if (column.isSet(r) && hasIllegalXmlChar(column.value(r))) {
+        bad++;
+      }
+    }
+  } else if (column.dtype === "list" && (column.meta.itemDtype === "string" || column.meta.itemDtype === "dict")) {
+    for (let r = 0; r < column.length; r++) {
+      if (column.isSet(r) && column.sliceOf(r).some((item) => typeof item === "string" && hasIllegalXmlChar(item))) {
+        bad++;
+      }
+    }
+  }
+  return bad;
+}
+function isXmlName(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  let first = true;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (cp === void 0 || (first ? !isNameStart(cp) : !isNameChar(cp))) {
+      return false;
+    }
+    first = false;
+  }
+  return true;
+}
+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) {
+  let amp = raw.indexOf("&");
+  if (amp < 0) {
+    return raw;
+  }
+  let out = "";
+  let start = 0;
+  while (amp >= 0) {
+    out += raw.slice(start, amp);
+    const semi = raw.indexOf(";", amp + 1);
+    if (semi < 0) {
+      throw new XmlSyntaxError("unterminated entity reference", line);
+    }
+    const name = raw.slice(amp + 1, semi);
+    if (name.startsWith("#")) {
+      const hex = name.startsWith("#x") || name.startsWith("#X");
+      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;
+      if (cp < 0 || !isXmlChar(cp)) {
+        throw new XmlSyntaxError(`invalid character reference &${name};`, line);
+      }
+      out += String.fromCodePoint(cp);
+    } else {
+      const value = NAMED_ENTITIES[name];
+      if (value === void 0) {
+        throw new XmlSyntaxError(`unknown entity &${name};`, line);
+      }
+      out += value;
+    }
+    start = semi + 1;
+    amp = raw.indexOf("&", start);
+  }
+  return out + raw.slice(start);
+}
+function isWhitespace(text) {
+  for (let i = 0; i < text.length; i++) {
+    if (!isSpace(text.charCodeAt(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+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);
+  for await (const chunk of chunks) {
+    tokenizer.push(chunk);
+  }
+  tokenizer.finish();
+}
+const TERMINATORS = {
+  comment: "-->",
+  cdata: "]]>",
+  pi: "?>",
+  endtag: ">"
+};
+class XmlTokenizer {
+  /**
+   * Create a tokenizer.
+   * @param handler - the event sink
+   */
+  constructor(handler) {
+    this.buffer = "";
+    this.pending = null;
+    this.line = 1;
+    this.nextBreak = -2;
+    this.pendingCr = false;
+    this.final = false;
+    this.text = "";
+    this.textLine = 1;
+    this.stack = [];
+    this.rootSeen = false;
+    this.rootClosed = false;
+    this.handler = handler;
+  }
+  /**
+   * Feed one chunk and emit every complete token in it.
+   * @param chunk - the text
+   */
+  push(chunk) {
+    let text = chunk;
+    if (this.pendingCr) {
+      text = `\r${text}`;
+      this.pendingCr = false;
+    }
+    if (text.endsWith("\r")) {
+      this.pendingCr = true;
+      text = text.slice(0, -1);
+    }
+    if (text.includes("\r")) {
+      text = text.replace(/\r\n?/g, "\n");
+    }
+    this.feed(text);
+  }
+  /** Signal the end of the input: flush the last text run and check well-formedness. */
+  finish() {
+    this.final = true;
+    if (this.pendingCr) {
+      this.pendingCr = false;
+      this.feed("\n");
+    } else {
+      this.feed("");
+    }
+    if (this.pending !== null || this.buffer.length > 0) {
+      throw new XmlSyntaxError("unexpected end of input inside markup", this.line);
+    }
+    this.flushText();
+    if (this.stack.length > 0) {
+      throw new XmlSyntaxError(`unclosed element <${this.stack[this.stack.length - 1]}>`, this.line);
+    }
+    if (!this.rootSeen) {
+      throw new XmlSyntaxError("no root element", this.line);
+    }
+  }
+  /**
+   * Append normalised text: continue a pending token's terminator scan over the new text alone,
+   * and once the token is complete (or when none is pending) scan the buffer for tokens.
+   * @param text - the text, line breaks normalised
+   */
+  feed(text) {
+    const { pending } = this;
+    if (pending === null) {
+      this.buffer = this.buffer.length === 0 ? text : this.buffer + text;
+      this.nextBreak = -2;
+      this.scan();
+      return;
+    }
+    if (pending.kind === "decl") {
+      this.pending = null;
+      this.buffer = pending.pieces.join("") + text;
+      this.nextBreak = -2;
+      this.scan();
+      return;
+    }
+    const end = this.scanPending(pending, text);
+    if (end < 0) {
+      if (text.length > 0) {
+        pending.pieces.push(text);
+      }
+      if (this.final) {
+        throw new XmlSyntaxError("unexpected end of input inside markup", this.line);
+      }
+      return;
+    }
+    this.pending = null;
+    pending.pieces.push(text.slice(0, end));
+    this.buffer = pending.pieces.join("") + text.slice(end);
+    this.nextBreak = -2;
+    this.scan();
+  }
+  /**
+   * Continue the terminator scan of a pending token over new text.
+   * @param pending - the pending token
+   * @param text - the new text
+   * @returns the index in `text` one past the token's end, or -1 when it does not end there
+   */
+  scanPending(pending, text) {
+    switch (pending.kind) {
+      case "starttag":
+        return this.scanStartTag(pending, text, 0);
+      case "doctype":
+        return this.scanDoctype(pending, text, 0);
+      case "decl":
+        return -1;
+      default: {
+        const terminator = TERMINATORS[pending.kind] ?? ">";
+        const probe = pending.tail + text;
+        const at = probe.indexOf(terminator);
+        if (at < 0) {
+          pending.tail = probe.slice(Math.max(0, probe.length - (terminator.length - 1)));
+          return -1;
+        }
+        return at + terminator.length - pending.tail.length;
+      }
+    }
+  }
+  /**
+   * Scan text for the `>` that ends a start tag, skipping quoted attribute values (the quote
+   * state survives between calls).
+   * @param pending - the pending token
+   * @param text - the text
+   * @param from - where to start
+   * @returns the index one past the `>`, or -1
+   */
+  scanStartTag(pending, text, from) {
+    let { quote } = pending;
+    const n = text.length;
+    let i = from;
+    while (i < n) {
+      if (quote !== 0) {
+        const close = text.indexOf(String.fromCharCode(quote), i);
+        if (close < 0) {
+          break;
+        }
+        quote = 0;
+        i = close + 1;
+        continue;
+      }
+      const c = text.charCodeAt(i);
+      if (c === QUOTE || c === APOS) {
+        quote = c;
+      } else if (c === GT) {
+        pending.quote = 0;
+        return i + 1;
+      }
+      i++;
+    }
+    pending.quote = quote;
+    return -1;
+  }
+  /**
+   * Scan text for the `>` that ends a DOCTYPE declaration, skipping a bracketed internal subset,
+   * quoted literals and comments inside the subset. A character state machine, so the state
+   * (`depth`, `quote`, `comment`, and `run`, the progress through a `<!--` or the dashes before
+   * a `-->`) survives between calls and nothing is re-read.
+   * @param pending - the pending token
+   * @param text - the text
+   * @param from - where to start
+   * @returns the index one past the `>`, or -1
+   */
+  scanDoctype(pending, text, from) {
+    let { quote, depth, comment, run } = pending;
+    for (let i = from; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (comment) {
+        if (c === DASH) {
+          run++;
+        } else if (c === GT && run >= 2) {
+          comment = false;
+          run = 0;
+        } else {
+          run = 0;
+        }
+        continue;
+      }
+      if (quote !== 0) {
+        if (c === quote) {
+          quote = 0;
+        }
+        continue;
+      }
+      if (depth > 0) {
+        if (run === 1 && c === BANG) {
+          run = 2;
+          continue;
+        }
+        if (run === 2 && c === DASH) {
+          run = 3;
+          continue;
+        }
+        if (run === 3 && c === DASH) {
+          comment = true;
+          run = 0;
+          continue;
+        }
+        run = 0;
+        if (c === LT) {
+          run = 1;
+          continue;
+        }
+      }
+      if (c === QUOTE || c === APOS) {
+        quote = c;
+      } else if (c === OPEN_BRACKET) {
+        depth++;
+      } else if (c === CLOSE_BRACKET) {
+        depth--;
+      } else if (c === GT && depth <= 0) {
+        pending.quote = 0;
+        pending.depth = 0;
+        pending.comment = false;
+        pending.run = 0;
+        return i + 1;
+      }
+    }
+    pending.quote = quote;
+    pending.depth = depth;
+    pending.comment = comment;
+    pending.run = run;
+    return -1;
+  }
+  /**
+   * Consume every complete token at the front of the buffer; an incomplete token at its end
+   * becomes the pending token (its text moved out of the buffer), a possibly split entity
+   * reference is held back in the buffer.
+   */
+  scan() {
+    const { buffer } = this;
+    const { length } = buffer;
+    let pos = 0;
+    let incomplete = false;
+    for (; ; ) {
+      const lt = buffer.indexOf("<", pos);
+      if (lt < 0) {
+        let end = length;
+        if (!this.final) {
+          const amp = buffer.lastIndexOf("&");
+          if (amp >= pos && amp >= length - MAX_ENTITY_LENGTH && buffer.indexOf(";", amp) < 0) {
+            end = amp;
+          }
+        }
+        this.takeText(pos, end);
+        pos = end;
+        break;
+      }
+      if (lt > pos) {
+        this.takeText(pos, lt);
+        pos = lt;
+      }
+      const next = this.consumeMarkup(pos);
+      if (next < 0) {
+        incomplete = true;
+        break;
+      }
+      pos = next;
+    }
+    if (incomplete) {
+      this.pending = this.startPending(buffer, pos);
+      this.buffer = "";
+    } else {
+      this.buffer = pos === 0 ? buffer : buffer.slice(pos);
+    }
+    this.nextBreak = -2;
+  }
+  /**
+   * Turn the incomplete markup at `pos` into a pending token, running the terminator scan over
+   * the part already in the buffer so later chunks are scanned alone.
+   * @param buffer - the buffer
+   * @param pos - the index of the `<`
+   * @returns the pending token
+   */
+  startPending(buffer, pos) {
+    const piece = pos === 0 ? buffer : buffer.slice(pos);
+    const pending = {
+      kind: "starttag",
+      pieces: [piece],
+      tail: "",
+      quote: 0,
+      depth: 0,
+      comment: false,
+      run: 0
+    };
+    if (piece.length < MIN_DECIDABLE_MARKUP) {
+      pending.kind = "decl";
+      return pending;
+    }
+    if (piece.startsWith("<!--")) {
+      pending.kind = "comment";
+    } else if (piece.startsWith("<![CDATA[")) {
+      pending.kind = "cdata";
+    } else if (piece.startsWith("<!DOCTYPE")) {
+      pending.kind = "doctype";
+    } else if (piece.startsWith("<!")) {
+      pending.kind = "decl";
+      return pending;
+    } else if (piece.startsWith("<?")) {
+      pending.kind = "pi";
+    } else if (piece.startsWith("</")) {
+      pending.kind = "endtag";
+    }
+    switch (pending.kind) {
+      case "starttag":
+        this.scanStartTag(pending, piece, 1);
+        break;
+      case "doctype":
+        this.scanDoctype(pending, piece, 9);
+        break;
+      default: {
+        const terminator = TERMINATORS[pending.kind] ?? ">";
+        pending.tail = piece.slice(Math.max(0, piece.length - (terminator.length - 1)));
+        break;
+      }
+    }
+    return pending;
+  }
+  /**
+   * Consume the markup starting at `pos` (a `<`).
+   * @param pos - the index of the `<`
+   * @returns the index after the markup, or -1 when the buffer ends before the markup does
+   */
+  consumeMarkup(pos) {
+    const { buffer } = this;
+    if (buffer.startsWith("<!", pos)) {
+      if (buffer.length - pos < MIN_DECIDABLE_MARKUP && !this.final) {
+        return -1;
+      }
+      if (buffer.startsWith("<!--", pos)) {
+        const end2 = buffer.indexOf("-->", pos + 4);
+        if (end2 < 0) {
+          return -1;
+        }
+        this.advanceLine(pos, end2 + 3);
+        return end2 + 3;
+      }
+      if (buffer.startsWith("<![CDATA[", pos)) {
+        const end2 = buffer.indexOf("]]>", pos + 9);
+        if (end2 < 0) {
+          return -1;
+        }
+        if (this.text.length === 0) {
+          this.textLine = this.line;
+        }
+        const cdata = buffer.slice(pos + 9, end2);
+        if (hasIllegalXmlChar(cdata)) {
+          throw new XmlSyntaxError("a character XML 1.0 forbids appears in a CDATA section", this.line);
+        }
+        this.text += cdata;
+        this.advanceLine(pos, end2 + 3);
+        return end2 + 3;
+      }
+      if (!buffer.startsWith("<!DOCTYPE", pos)) {
+        throw new XmlSyntaxError("unexpected markup declaration", this.line);
+      }
+      const state = {
+        kind: "doctype",
+        pieces: [],
+        tail: "",
+        quote: 0,
+        depth: 0,
+        comment: false,
+        run: 0
+      };
+      const end = this.scanDoctype(state, buffer, pos + 9);
+      if (end < 0) {
+        return -1;
+      }
+      this.advanceLine(pos, end);
+      return end;
+    }
+    if (buffer.startsWith("<?", pos)) {
+      const end = buffer.indexOf("?>", pos + 2);
+      if (end < 0) {
+        return -1;
+      }
+      this.advanceLine(pos, end + 2);
+      return end + 2;
+    }
+    if (buffer.startsWith("</", pos)) {
+      const end = buffer.indexOf(">", pos + 2);
+      if (end < 0) {
+        return -1;
+      }
+      const name = buffer.slice(pos + 2, end).trim();
+      if (!isXmlName(name)) {
+        throw new XmlSyntaxError(`malformed end tag </${name}>`, this.line);
+      }
+      this.flushText();
+      this.endElement(name);
+      this.advanceLine(pos, end + 1);
+      return end + 1;
+    }
+    const tag = this.parseStartTag(pos);
+    if (tag === null) {
+      return -1;
+    }
+    this.flushText();
+    this.startElement(tag.name, tag.attrs);
+    if (tag.selfClosing) {
+      this.endElement(tag.name);
+    }
+    this.advanceLine(pos, tag.end);
+    return tag.end;
+  }
+  /**
+   * Parse a start tag at `pos`.
+   * @param pos - the index of the `<`
+   * @returns the tag, or null when the buffer ends inside it
+   */
+  parseStartTag(pos) {
+    const { buffer } = this;
+    const { length } = buffer;
+    let i = pos + 1;
+    const nameEnd = this.readName(i);
+    if (nameEnd < 0) {
+      return null;
+    }
+    if (nameEnd === i) {
+      throw new XmlSyntaxError("expected an element name after <", this.line);
+    }
+    const name = buffer.slice(i, nameEnd);
+    i = nameEnd;
+    const attrs = /* @__PURE__ */ new Map();
+    for (; ; ) {
+      while (i < length && isSpace(buffer.charCodeAt(i))) {
+        i++;
+      }
+      if (i >= length) {
+        return null;
+      }
+      const c = buffer.charCodeAt(i);
+      if (c === GT) {
+        return { name, attrs, selfClosing: false, end: i + 1 };
+      }
+      if (c === SLASH) {
+        if (i + 1 >= length) {
+          return null;
+        }
+        if (buffer.charCodeAt(i + 1) !== GT) {
+          throw new XmlSyntaxError(`unexpected "/" in <${name}>`, this.line);
+        }
+        return { name, attrs, selfClosing: true, end: i + 2 };
+      }
+      const attrEnd = this.readName(i);
+      if (attrEnd < 0) {
+        return null;
+      }
+      if (attrEnd === i) {
+        throw new XmlSyntaxError(`malformed attribute in <${name}>`, this.line);
+      }
+      const attrName = buffer.slice(i, attrEnd);
+      i = attrEnd;
+      while (i < length && isSpace(buffer.charCodeAt(i))) {
+        i++;
+      }
+      if (i >= length) {
+        return null;
+      }
+      if (buffer.charCodeAt(i) !== EQUALS) {
+        throw new XmlSyntaxError(`attribute ${attrName} of <${name}> has no value`, this.line);
+      }
+      i++;
+      while (i < length && isSpace(buffer.charCodeAt(i))) {
+        i++;
+      }
+      if (i >= length) {
+        return null;
+      }
+      const quote = buffer.charCodeAt(i);
+      if (quote !== QUOTE && quote !== APOS) {
+        throw new XmlSyntaxError(`attribute ${attrName} of <${name}> is not quoted`, this.line);
+      }
+      const close = buffer.indexOf(quote === QUOTE ? '"' : "'", i + 1);
+      if (close < 0) {
+        return null;
+      }
+      if (attrs.has(attrName)) {
+        throw new XmlSyntaxError(`duplicate attribute ${attrName} in <${name}>`, this.line);
+      }
+      const raw = buffer.slice(i + 1, close);
+      if (hasIllegalXmlChar(raw)) {
+        throw new XmlSyntaxError(
+          `a character XML 1.0 forbids appears in attribute ${attrName} of <${name}>`,
+          this.line
+        );
+      }
+      attrs.set(attrName, decodeEntities(normalizeAttributeValue(raw), this.line));
+      i = close + 1;
+    }
+  }
+  /**
+   * The end of the XML Name starting at `i` (an ASCII table for the common case, the code point
+   * classes beyond it).
+   * @param i - the start index
+   * @returns the index after the name; `i` when no name starts there; -1 when the name may
+   * continue past the end of the buffer
+   */
+  readName(i) {
+    const { buffer } = this;
+    const { length } = buffer;
+    let j = i;
+    while (j < length) {
+      const c = buffer.charCodeAt(j);
+      if (c < 128) {
+        if ((j === i ? ASCII_NAME_START[c] : ASCII_NAME_CHAR[c]) === 0) {
+          break;
+        }
+        j++;
+        continue;
+      }
+      const cp = buffer.codePointAt(j);
+      if (cp === void 0 || (j === i ? !isNameStart(cp) : !isNameChar(cp))) {
+        break;
+      }
+      j += cp > 65535 ? 2 : 1;
+    }
+    return j >= length && !this.final ? -1 : j;
+  }
+  /**
+   * Move text from the buffer into the current run.
+   * @param start - the start index
+   * @param end - the end index (exclusive)
+   */
+  takeText(start, end) {
+    if (end <= start) {
+      return;
+    }
+    if (this.text.length === 0) {
+      this.textLine = this.line;
+    }
+    const raw = this.buffer.slice(start, end);
+    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.advanceLine(start, end);
+  }
+  /**
+   * Count the newlines of a consumed range. Ranges are consumed in order, so the next line break
+   * is searched for once per buffer and re-searched only after it was passed; a buffer without
+   * a further break is searched once and remembered as such.
+   * @param start - the start index
+   * @param end - the end index (exclusive)
+   */
+  advanceLine(start, end) {
+    let i = this.nextBreak;
+    if (i === -1) {
+      return;
+    }
+    if (i === -2 || i < start) {
+      i = this.buffer.indexOf("\n", start);
+    }
+    while (i >= 0 && i < end) {
+      this.line++;
+      i = this.buffer.indexOf("\n", i + 1);
+    }
+    this.nextBreak = i;
+  }
+  /** Deliver the accumulated text run, if any. */
+  flushText() {
+    if (this.text.length === 0) {
+      return;
+    }
+    const { text } = this;
+    this.text = "";
+    if (this.stack.length === 0) {
+      if (!isWhitespace(text)) {
+        throw new XmlSyntaxError("text outside the root element", this.textLine);
+      }
+      return;
+    }
+    this.handler.text(text, this.textLine);
+  }
+  /**
+   * Open an element.
+   * @param name - the element name
+   * @param attrs - its attributes
+   */
+  startElement(name, attrs) {
+    if (this.stack.length === 0) {
+      if (this.rootClosed) {
+        throw new XmlSyntaxError(`a second root element <${name}> follows the document element`, this.line);
+      }
+      this.rootSeen = true;
+    }
+    this.stack.push(name);
+    this.handler.start(name, attrs, this.line);
+  }
+  /**
+   * Close an element, checking that it matches the innermost open one.
+   * @param name - the element name
+   */
+  endElement(name) {
+    const open = this.stack.length > 0 ? this.stack[this.stack.length - 1] : null;
+    if (open === null) {
+      throw new XmlSyntaxError(`unexpected end tag </${name}>`, this.line);
+    }
+    if (open !== name) {
+      throw new XmlSyntaxError(`end tag </${name}> does not match <${open}>`, this.line);
+    }
+    this.stack.pop();
+    if (this.stack.length === 0) {
+      this.rootClosed = true;
+    }
+    this.handler.end(name, this.line);
+  }
+}
+function normalizeAttributeValue(raw) {
+  return raw.includes("\n") || raw.includes("	") ? raw.replace(/[\n\t]/g, " ") : raw;
+}
+const XML_TEXT_SPECIAL = /[&<>\r]/g;
+const XML_ATTR_SPECIAL = /[&<>"\t\n\r]/g;
+const XML_REPLACEMENTS = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "	": "&#9;",
+  "\n": "&#10;",
+  "\r": "&#13;"
+};
+function escapeXmlText(text) {
+  if (hasIllegalXmlChar(text)) {
+    throw illegalXml(text);
+  }
+  return text.replace(XML_TEXT_SPECIAL, (c) => XML_REPLACEMENTS[c]);
+}
+function escapeXmlAttribute(text) {
+  if (hasIllegalXmlChar(text)) {
+    throw illegalXml(text);
+  }
+  return text.replace(XML_ATTR_SPECIAL, (c) => XML_REPLACEMENTS[c]);
+}
+function illegalXml(text) {
+  return new GraphFormatError("E_COLUMN_TYPE", "the text holds a character XML 1.0 cannot carry", {
+    reason: "xml illegal char",
+    length: text.length
+  });
+}
+const GML_SPECIAL = /["&]|[^ -~]/gu;
+function quoteGmlString(text) {
+  const escaped = text.replace(GML_SPECIAL, (c) => {
+    const code = c.codePointAt(0);
+    if (code === void 0) {
+      return c;
+    }
+    if (code >= 55296 && code <= 57343) {
+      throw new GraphFormatError("E_COLUMN_TYPE", "a lone surrogate cannot be written as a GML string", {
+        reason: "lone surrogate"
+      });
+    }
+    return `&#${code};`;
+  });
+  return `"${escaped}"`;
+}
+const GML_ENTITY = /&(#[0-9]+|#x[0-9a-fA-F]+|amp|quot|lt|gt|apos);/g;
+const GML_NAMED = { amp: "&", quot: '"', lt: "<", gt: ">", apos: "'" };
+function decodeGmlString(body) {
+  return body.replace(GML_ENTITY, (whole, entity) => {
+    if (entity.startsWith("#x")) {
+      return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+    }
+    if (entity.startsWith("#")) {
+      return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+    }
+    return GML_NAMED[entity] ?? whole;
+  });
+}
+const DOT_NUMERAL = /^-?(\.[0-9]+|[0-9]+(\.[0-9]*)?)$/;
+const DOT_KEYWORDS = /* @__PURE__ */ new Set(["node", "edge", "graph", "digraph", "subgraph", "strict"]);
+function isBareDotId(text) {
+  if (DOT_KEYWORDS.has(text.toLowerCase())) {
+    return false;
+  }
+  return isDotIdentifier(text) || DOT_NUMERAL.test(text);
+}
+function isDotIdentifier(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const letter = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c >= 128;
+    const digit = c >= 48 && c <= 57;
+    if (!letter && (i === 0 || !digit)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isWritableDotText(text) {
+  return !text.endsWith("\\") && !text.includes('\\"');
+}
+function quoteDotId(text) {
+  if (isBareDotId(text)) {
+    return text;
+  }
+  return `"${text.replace(/"/g, '\\"')}"`;
+}
+function quoteCsvCell(text, delimiter = ",") {
+  if (text.length === 0) {
+    return '""';
+  }
+  if (!text.includes(delimiter) && !text.includes('"') && !text.includes("\n") && !text.includes("\r") && text === text.trim()) {
+    return text;
+  }
+  return `"${text.replace(/"/g, '""')}"`;
+}
+function isPajekLabel(text) {
+  return !text.includes('"') && !text.includes("\n") && !text.includes("\r");
+}
+function quotePajekLabel(text) {
+  if (!isPajekLabel(text)) {
+    throw new GraphFormatError("E_UNSUPPORTED", "a Pajek label cannot contain a double quote or a line break", {
+      reason: "pajek label",
+      value: text
+    });
+  }
+  if (text.length > 0 && !/[\s"]/.test(text)) {
+    return text;
+  }
+  return `"${text}"`;
+}
+export {
+  XmlSyntaxError as X,
+  XmlTokenizer as a,
+  quoteDotId as b,
+  isWritableDotText as c,
+  isWhitespace as d,
+  escapeXmlText as e,
+  escapeXmlAttribute as f,
+  decodeGmlString as g,
+  hasIllegalXmlChar as h,
+  isPajekLabel as i,
+  quoteGmlString as j,
+  isXmlName as k,
+  localName as l,
+  quoteCsvCell as m,
+  quotePajekLabel as q,
+  tokenizeXml as t,
+  xmlIllegalTextNotes as x
+};
+//# sourceMappingURL=escape-DyI8JofU.js.map