@graphty/graph-io 0.3.24 → 0.3.26

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

@@ -1,6 +1,5 @@
 import { GraphFormatError } from "@graphty/graph-format";
-import { a0 as XML_ILLEGAL_CHAR_CODE } from "./report-B1z4WT9e.js";
-import { b as isNameChar } from "./export-Bh60Dv-n.js";
+import { aw as isNameChar, ax as XML_ILLEGAL_CHAR_CODE, b as plural, $ as agree } from "./export-BTI4yQgy.js";
 class XmlSyntaxError extends Error {
   /**
    * Create the error.
@@ -13,6 +12,16 @@ class XmlSyntaxError extends Error {
     this.line = line;
   }
 }
+class XmlEmptyInputError extends XmlSyntaxError {
+  /**
+   * Create the error.
+   * @param line - the 1-based line where the input ended
+   */
+  constructor(line) {
+    super("the input is empty: no root element", line);
+    this.name = "XmlEmptyInputError";
+  }
+}
 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}));$/;
@@ -33,6 +42,7 @@ const OPEN_BRACKET = 91;
 const CLOSE_BRACKET = 93;
 const BANG = 33;
 const DASH = 45;
+const QUESTION = 63;
 const MAX_ENTITY_LENGTH = 16;
 const MIN_DECIDABLE_MARKUP = 9;
 function isSpace(c) {
@@ -60,6 +70,10 @@ const ILLEGAL_CHAR = new RegExp(
 function hasIllegalXmlChar(text) {
   return ILLEGAL_CHAR.test(text);
 }
+function illegalCharIndex(text) {
+  const match = ILLEGAL_CHAR.exec(text);
+  return match === null ? -1 : match.index;
+}
 function xmlIllegalTextNotes(snapshot) {
   const notes = [];
   let ids = 0;
@@ -73,7 +87,7 @@ function xmlIllegalTextNotes(snapshot) {
     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`,
+        message: `${ids} node id${plural(ids)} ${agree(ids, "holds", "hold")} a character XML 1.0 cannot carry; the save fails`,
         column: null,
         count: ids
       })
@@ -90,7 +104,7 @@ function xmlIllegalTextNotes(snapshot) {
         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`,
+            message: `${domain} column "${column.meta.name}": ${bad} value${plural(bad)} ${agree(bad, "holds", "hold")} a character XML 1.0 cannot carry; the save fails`,
             column: column.meta.name,
             count: bad
           })
@@ -122,6 +136,15 @@ function xmlDeclaredEncoding(head) {
   const match = XML_DECLARED_ENCODING.exec(head);
   return match === null ? null : match[1];
 }
+function sniffXmlText(head) {
+  let label = "utf-8";
+  if (head[0] === 255 && head[1] === 254 || head[0] === 60 && head[1] === 0 && head[2] === 63) {
+    label = "utf-16le";
+  } else if (head[0] === 254 && head[1] === 255 || head[0] === 0 && head[1] === 60 && head[3] === 63) {
+    label = "utf-16be";
+  }
+  return new TextDecoder(label, { fatal: false }).decode(head);
+}
 function isXmlName(text) {
   if (text.length === 0) {
     return false;
@@ -158,13 +181,13 @@ function decodeEntities(raw, line, repairs) {
       continue;
     }
     if (semi < 0) {
-      throw new XmlSyntaxError("unterminated entity reference", line);
+      throw new XmlSyntaxError("unterminated entity reference", lineAt(raw, amp, 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 ok = hex ? /^0*[\da-fA-F]{1,6}$/.test(digits) : /^0*\d{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) {
@@ -175,13 +198,13 @@ function decodeEntities(raw, line, repairs) {
         continue;
       }
       if (cp < 0 || !isXmlChar(cp)) {
-        throw new XmlSyntaxError(`invalid character reference &${name};`, line);
+        throw new XmlSyntaxError(`invalid character reference &${name};`, lineAt(raw, amp, line));
       }
       out += String.fromCodePoint(cp);
     } else {
       const value = NAMED_ENTITIES[name];
       if (value === void 0) {
-        throw new XmlSyntaxError(`unknown entity &${name};`, line);
+        throw new XmlSyntaxError(`unknown entity &${name};`, lineAt(raw, amp, line));
       }
       out += value;
     }
@@ -222,10 +245,38 @@ function localName(name) {
 }
 async function tokenizeXml(chunks, handler, repairs) {
   const tokenizer = new XmlTokenizer(handler, repairs);
-  for await (const chunk of chunks) {
-    tokenizer.push(chunk);
+  let skipped = 0;
+  let lines = 1;
+  let leading = true;
+  try {
+    for await (const chunk of chunks) {
+      if (leading) {
+        const start = chunk.search(/\S/);
+        const blank = start < 0 ? chunk : chunk.slice(0, start);
+        skipped += blank.length;
+        lines += blank.split("\n").length - 1;
+        if (start >= 0) {
+          leading = false;
+          if (skipped > 0 && /^<\?xml\s/.test(chunk.slice(start, start + 6))) {
+            throw new XmlSyntaxError(
+              "the XML declaration must be at the very start of the document; whitespace precedes it",
+              lines
+            );
+          }
+        }
+      }
+      tokenizer.push(chunk);
+    }
+    tokenizer.finish();
+  } catch (err) {
+    if (err instanceof XmlSyntaxError && tokenizer.declaresXml11 && !err.message.includes("XML 1.1")) {
+      throw new XmlSyntaxError(
+        `${err.message}; the document declares XML 1.1, which graph-io does not read (it reads XML 1.0)`,
+        err.line
+      );
+    }
+    throw err;
   }
-  tokenizer.finish();
 }
 const TERMINATORS = {
   comment: "-->",
@@ -233,6 +284,8 @@ const TERMINATORS = {
   pi: "?>",
   endtag: ">"
 };
+const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+const DECLARATION_OPENERS = ["<!--", "<![CDATA[", "<!DOCTYPE"];
 class XmlTokenizer {
   /**
    * Create a tokenizer.
@@ -251,15 +304,39 @@ class XmlTokenizer {
     this.stack = [];
     this.rootSeen = false;
     this.rootClosed = false;
+    this.markupSeen = false;
+    this.atStart = true;
+    this.doctypeSeen = false;
+    this.version = null;
+    this.textTail = "";
+    this.pendingHigh = "";
+    this.bindings = [];
     this.handler = handler;
     this.repairs = repairs;
   }
+  /**
+   * Whether the document's XML declaration says version 1.1 (read by the XML 1.0 rules all the
+   * same; the syntax error of a 1.1-only construct then says why).
+   * @returns true after a `<?xml version="1.1"?>` declaration
+   */
+  get declaresXml11() {
+    return this.version === "1.1";
+  }
   /**
    * Feed one chunk and emit every complete token in it.
    * @param chunk - the text
    */
   push(chunk) {
     let text = chunk;
+    if (this.pendingHigh.length > 0) {
+      text = this.pendingHigh + text;
+      this.pendingHigh = "";
+    }
+    const last = text.charCodeAt(text.length - 1);
+    if (last >= 55296 && last <= 56319) {
+      this.pendingHigh = text.slice(-1);
+      text = text.slice(0, -1);
+    }
     if (this.pendingCr) {
       text = `\r${text}`;
       this.pendingCr = false;
@@ -276,11 +353,14 @@ class XmlTokenizer {
   /** Signal the end of the input: flush the last text run and check well-formedness. */
   finish() {
     this.final = true;
+    const held = this.pendingHigh;
+    this.pendingHigh = "";
     if (this.pendingCr) {
       this.pendingCr = false;
-      this.feed("\n");
+      this.feed(`
+${held}`);
     } else {
-      this.feed("");
+      this.feed(held);
     }
     if (this.pending !== null || this.buffer.length > 0) {
       throw new XmlSyntaxError("unexpected end of input inside markup", this.line);
@@ -290,13 +370,16 @@ class XmlTokenizer {
       throw new XmlSyntaxError(`unclosed element <${this.stack[this.stack.length - 1]}>`, this.line);
     }
     if (!this.rootSeen) {
+      if (!this.markupSeen) {
+        throw new XmlEmptyInputError(this.line);
+      }
       throw new XmlSyntaxError("no root element", this.line);
     }
   }
   /**
-   * Append normalised text: continue a pending token's terminator scan over the new text alone,
+   * Append normalized 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
+   * @param text - the text, line breaks normalized
    */
   feed(text) {
     const { pending } = this;
@@ -400,9 +483,18 @@ class XmlTokenizer {
    * @returns the index one past the `>`, or -1
    */
   scanDoctype(pending, text, from) {
-    let { quote, depth, comment, run } = pending;
+    let { quote, depth, comment, pi, run } = pending;
     for (let i = from; i < text.length; i++) {
       const c = text.charCodeAt(i);
+      if (pi) {
+        if (c === GT && run === 1) {
+          pi = false;
+          run = 0;
+        } else {
+          run = c === QUESTION ? 1 : 0;
+        }
+        continue;
+      }
       if (comment) {
         if (c === DASH) {
           run++;
@@ -434,6 +526,11 @@ class XmlTokenizer {
           run = 0;
           continue;
         }
+        if (run === 1 && c === QUESTION) {
+          pi = true;
+          run = 0;
+          continue;
+        }
         run = 0;
         if (c === LT) {
           run = 1;
@@ -450,6 +547,7 @@ class XmlTokenizer {
         pending.quote = 0;
         pending.depth = 0;
         pending.comment = false;
+        pending.pi = false;
         pending.run = 0;
         return i + 1;
       }
@@ -457,6 +555,7 @@ class XmlTokenizer {
     pending.quote = quote;
     pending.depth = depth;
     pending.comment = comment;
+    pending.pi = pi;
     pending.run = run;
     return -1;
   }
@@ -476,7 +575,9 @@ class XmlTokenizer {
         let end = length;
         if (!this.final) {
           const amp = buffer.lastIndexOf("&");
-          if (amp >= pos && amp >= length - MAX_ENTITY_LENGTH && buffer.indexOf(";", amp) < 0) {
+          if (amp >= pos && !buffer.includes(";", amp) && // ponytail: a zero-padded reference longer than MAX_ENTITY_LENGTH is held back
+          // whole, so an absurdly long run of zeros is re-scanned once per chunk
+          (amp >= length - MAX_ENTITY_LENGTH || /^&#[xX]?0[\da-fA-F]*$/.test(buffer.slice(amp)))) {
             end = amp;
           }
           if (this.repairs?.surrogatePair !== void 0) {
@@ -522,6 +623,7 @@ class XmlTokenizer {
       quote: 0,
       depth: 0,
       comment: false,
+      pi: false,
       run: 0
     };
     if (piece.length < MIN_DECIDABLE_MARKUP) {
@@ -563,59 +665,30 @@ class XmlTokenizer {
    * @returns the index after the markup, or -1 when the buffer ends before the markup does
    */
   consumeMarkup(pos) {
+    const end = this.markupEnd(pos);
+    if (end >= 0) {
+      this.markupSeen = true;
+      this.atStart = false;
+      this.textTail = "";
+    }
+    return end;
+  }
+  /**
+   * Read the markup starting at `pos` (a `<`) and deliver what it means.
+   * @param pos - the index of the `<`
+   * @returns the index after the markup, or -1 when the buffer ends before the markup does
+   */
+  markupEnd(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;
+      return this.declarationEnd(pos);
     }
     if (buffer.startsWith("<?", pos)) {
       const end = buffer.indexOf("?>", pos + 2);
       if (end < 0) {
         return -1;
       }
+      this.processingInstruction(pos, end);
       this.advanceLine(pos, end + 2);
       return end + 2;
     }
@@ -624,7 +697,7 @@ class XmlTokenizer {
       if (end < 0) {
         return -1;
       }
-      const name = buffer.slice(pos + 2, end).trim();
+      const name = buffer.slice(pos + 2, end).trimEnd();
       if (!isXmlName(name)) {
         throw new XmlSyntaxError(`malformed end tag </${name}>`, this.line);
       }
@@ -638,13 +711,160 @@ class XmlTokenizer {
       return -1;
     }
     this.flushText();
-    this.startElement(tag.name, tag.attrs);
+    this.startElement(tag.name, tag.attrs, tag.declaresNamespace);
     if (tag.selfClosing) {
       this.endElement(tag.name);
     }
     this.advanceLine(pos, tag.end);
     return tag.end;
   }
+  /**
+   * Read the CDATA section at `pos` into the text.
+   * @param pos - the index of the `<`
+   * @returns the index after the section, or -1 when the buffer ends before the section does
+   */
+  cdataEnd(pos) {
+    const end = this.buffer.indexOf("]]>", pos + 9);
+    if (end < 0) {
+      return -1;
+    }
+    if (this.text.length === 0) {
+      this.textLine = this.line;
+    }
+    const cdata = this.buffer.slice(pos + 9, end);
+    const bad = illegalCharIndex(cdata);
+    if (bad >= 0) {
+      throw new XmlSyntaxError(
+        "a character XML 1.0 forbids appears in a CDATA section",
+        this.lineIn(pos, pos + 9 + bad)
+      );
+    }
+    this.text += cdata;
+    this.advanceLine(pos, end + 3);
+    return end + 3;
+  }
+  /**
+   * Read the `<!...>` markup at `pos`: a comment, a CDATA section or the DOCTYPE.
+   * @param pos - the index of the `<`
+   * @returns the index after the markup, or -1 when the buffer ends before the markup does
+   */
+  declarationEnd(pos) {
+    const { buffer } = this;
+    if (buffer.length - pos < MIN_DECIDABLE_MARKUP) {
+      const head = buffer.slice(pos);
+      if (!this.final || DECLARATION_OPENERS.some((opener) => opener.startsWith(head))) {
+        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)) {
+      return this.cdataEnd(pos);
+    }
+    if (!buffer.startsWith("<!DOCTYPE", pos)) {
+      if (buffer.slice(pos + 2, pos + 9).toUpperCase() === "DOCTYPE") {
+        throw new XmlSyntaxError(
+          `<!${buffer.slice(pos + 2, pos + 9)}> is not XML (it must be written <!DOCTYPE>); the input looks like an HTML document`,
+          this.line
+        );
+      }
+      throw new XmlSyntaxError("unexpected markup declaration", this.line);
+    }
+    if (this.rootSeen || this.doctypeSeen) {
+      throw new XmlSyntaxError("a DOCTYPE declaration is allowed once, before the root element", this.line);
+    }
+    const state = {
+      kind: "doctype",
+      pieces: [],
+      tail: "",
+      quote: 0,
+      depth: 0,
+      comment: false,
+      pi: false,
+      run: 0
+    };
+    const end = this.scanDoctype(state, buffer, pos + 9);
+    if (end < 0) {
+      return -1;
+    }
+    this.doctypeSeen = true;
+    this.handler.doctype?.(buffer.slice(pos, end), this.line);
+    this.advanceLine(pos, end);
+    return end;
+  }
+  /**
+   * Check a processing instruction `<?target ...?>` (skipped otherwise): its target must be a
+   * name, and the reserved target `xml` is the XML declaration, allowed only at the very start
+   * of the document with a 1.x version.
+   * @param pos - the index of the `<`
+   * @param end - the index of the `?>`
+   */
+  processingInstruction(pos, end) {
+    const body = this.buffer.slice(pos + 2, end);
+    const target = /^[^\s]*/.exec(body)?.[0] ?? "";
+    if (!isXmlName(target)) {
+      throw new XmlSyntaxError(`a processing instruction needs a target name, not "${target}"`, this.line);
+    }
+    if (target.toLowerCase() !== "xml") {
+      return;
+    }
+    if (target !== "xml") {
+      throw new XmlSyntaxError(
+        `<?${target} is not an XML declaration (which is written <?xml in lower case); the target is reserved`,
+        this.line
+      );
+    }
+    if (!this.atStart || pos !== 0) {
+      throw new XmlSyntaxError(
+        "an XML declaration (<?xml ...?>) may appear only at the very start of the document; the target xml is reserved",
+        this.line
+      );
+    }
+    const version = /\bversion\s*=\s*(["'])([^"']*)\1/.exec(body)?.[2];
+    if (version === void 0) {
+      throw new XmlSyntaxError("the XML declaration has no version", this.line);
+    }
+    if (!/^1\.\d+$/.test(version)) {
+      throw new XmlSyntaxError(`XML version ${version} is not supported (only 1.x)`, this.line);
+    }
+    this.version = version;
+  }
+  /**
+   * The line of a buffer position after `start`, the position the current line count refers to.
+   * Used on the error path only.
+   * @param start - a position on line `this.line`
+   * @param at - the position
+   * @returns its line
+   */
+  lineIn(start, at) {
+    return lineAt(this.buffer.slice(start, at), at - start, this.line);
+  }
+  /**
+   * Decode the entities of a text, naming XML 1.1 when a character reference XML 1.0 forbids
+   * appears in a document that declares version 1.1.
+   * @param raw - the text as written
+   * @param line - the line the text starts on
+   * @returns the decoded text
+   */
+  decode(raw, line) {
+    try {
+      return decodeEntities(raw, line, this.repairs);
+    } catch (err) {
+      if (err instanceof XmlSyntaxError && this.version !== null && this.version !== "1.0") {
+        throw new XmlSyntaxError(
+          `${err.message} (the document declares XML ${this.version}, whose character rules are not supported; it is read as XML 1.0)`,
+          err.line
+        );
+      }
+      throw err;
+    }
+  }
   /**
    * Parse a start tag at `pos`.
    * @param pos - the index of the `<`
@@ -664,7 +884,9 @@ class XmlTokenizer {
     const name = buffer.slice(i, nameEnd);
     i = nameEnd;
     const attrs = /* @__PURE__ */ new Map();
+    let declaresNamespace = false;
     for (; ; ) {
+      const before = i;
       while (i < length && isSpace(buffer.charCodeAt(i))) {
         i++;
       }
@@ -673,23 +895,29 @@ class XmlTokenizer {
       }
       const c = buffer.charCodeAt(i);
       if (c === GT) {
-        return { name, attrs, selfClosing: false, end: i + 1 };
+        return { name, attrs, selfClosing: false, declaresNamespace, 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);
+          throw new XmlSyntaxError(`unexpected "/" in <${name}>`, this.lineIn(pos, i));
         }
-        return { name, attrs, selfClosing: true, end: i + 2 };
+        return { name, attrs, selfClosing: true, declaresNamespace, end: i + 2 };
+      }
+      if (i === before) {
+        throw new XmlSyntaxError(
+          `the attributes of <${name}> must be separated by whitespace`,
+          this.lineIn(pos, i)
+        );
       }
       const attrEnd = this.readName(i);
       if (attrEnd < 0) {
         return null;
       }
       if (attrEnd === i) {
-        throw new XmlSyntaxError(`malformed attribute in <${name}>`, this.line);
+        throw new XmlSyntaxError(`malformed attribute in <${name}>`, this.lineIn(pos, i));
       }
       const attrName = buffer.slice(i, attrEnd);
       i = attrEnd;
@@ -700,7 +928,7 @@ class XmlTokenizer {
         return null;
       }
       if (buffer.charCodeAt(i) !== EQUALS) {
-        throw new XmlSyntaxError(`attribute ${attrName} of <${name}> has no value`, this.line);
+        throw new XmlSyntaxError(`attribute ${attrName} of <${name}> has no value`, this.lineIn(pos, i));
       }
       i++;
       while (i < length && isSpace(buffer.charCodeAt(i))) {
@@ -711,23 +939,30 @@ class XmlTokenizer {
       }
       const quote = buffer.charCodeAt(i);
       if (quote !== QUOTE && quote !== APOS) {
-        throw new XmlSyntaxError(`attribute ${attrName} of <${name}> is not quoted`, this.line);
+        throw new XmlSyntaxError(`attribute ${attrName} of <${name}> is not quoted`, this.lineIn(pos, i));
       }
       const close = buffer.indexOf(quote === QUOTE ? '"' : "'", i + 1);
       if (close < 0) {
         return null;
       }
+      const line = this.lineIn(pos, i);
       if (attrs.has(attrName)) {
-        throw new XmlSyntaxError(`duplicate attribute ${attrName} in <${name}>`, this.line);
+        throw new XmlSyntaxError(`duplicate attribute ${attrName} in <${name}>`, 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
+          line
         );
       }
-      attrs.set(attrName, decodeEntities(normalizeAttributeValue(raw), this.line, this.repairs));
+      if (raw.includes("<")) {
+        throw new XmlSyntaxError(`a "<" in the value of attribute ${attrName} of <${name}> (write &lt;)`, line);
+      }
+      if (attrName.startsWith("xmlns")) {
+        declaresNamespace = true;
+      }
+      attrs.set(attrName, this.decode(normalizeAttributeValue(raw), line));
       i = close + 1;
     }
   }
@@ -788,10 +1023,26 @@ class XmlTokenizer {
       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);
+    const bad = illegalCharIndex(raw);
+    if (bad >= 0) {
+      throw new XmlSyntaxError(
+        "a character XML 1.0 forbids appears in character data",
+        lineAt(raw, bad, this.line)
+      );
+    }
+    if (raw.includes(">")) {
+      const probe = this.textTail + raw;
+      const close = probe.indexOf("]]>");
+      if (close >= 0) {
+        throw new XmlSyntaxError(
+          '"]]>" is not allowed in character data (write ]]&gt;)',
+          lineAt(raw, Math.max(0, close - this.textTail.length), this.line)
+        );
+      }
     }
-    this.text += decodeEntities(raw, this.line, this.repairs);
+    this.textTail = raw.length >= 2 ? raw.slice(-2) : (this.textTail + raw).slice(-2);
+    this.atStart = false;
+    this.text += this.decode(raw, this.line);
     this.advanceLine(start, end);
   }
   /**
@@ -834,16 +1085,48 @@ class XmlTokenizer {
    * Open an element.
    * @param name - the element name
    * @param attrs - its attributes
+   * @param declaresNamespace - whether an attribute name starts with `xmlns`
    */
-  startElement(name, attrs) {
+  startElement(name, attrs, declaresNamespace) {
     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;
     }
+    if (declaresNamespace) {
+      for (const [key, uri] of attrs) {
+        if (key === "xmlns") {
+          this.bindings.push({ prefix: "", uri, depth: this.stack.length });
+        } else if (key.startsWith("xmlns:")) {
+          this.bindings.push({ prefix: key.slice(6), uri, depth: this.stack.length });
+        }
+      }
+    }
     this.stack.push(name);
-    this.handler.start(name, attrs, this.line);
+    this.handler.start(name, attrs, this.line, this.namespaceOf(name));
+  }
+  /**
+   * The namespace an element name is in (Namespaces in XML 1.0 section 6).
+   * @param name - the element name as written
+   * @returns the URI; "" for no namespace; null for an undeclared prefix or a name that is not
+   * namespace-well-formed
+   */
+  namespaceOf(name) {
+    const colon = name.indexOf(":");
+    if (colon >= 0 && (colon === 0 || colon === name.length - 1 || name.includes(":", colon + 1))) {
+      return null;
+    }
+    const prefix = colon < 0 ? "" : name.slice(0, colon);
+    for (let i = this.bindings.length - 1; i >= 0; i--) {
+      if (this.bindings[i].prefix === prefix) {
+        return this.bindings[i].uri;
+      }
+    }
+    if (prefix === "xml") {
+      return XML_NAMESPACE;
+    }
+    return prefix === "" ? "" : null;
   }
   /**
    * Close an element, checking that it matches the innermost open one.
@@ -858,6 +1141,9 @@ class XmlTokenizer {
       throw new XmlSyntaxError(`end tag </${name}> does not match <${open}>`, this.line);
     }
     this.stack.pop();
+    while ((this.bindings.at(-1)?.depth ?? -1) >= this.stack.length) {
+      this.bindings.pop();
+    }
     if (this.stack.length === 0) {
       this.rootClosed = true;
     }
@@ -929,11 +1215,13 @@ const GML_NAMED = (() => {
 })();
 function decodeGmlString(body, onUnknown) {
   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));
+      const code = entity.startsWith("#x") ? Number.parseInt(entity.slice(2), 16) : Number(entity.slice(1));
+      if (code <= 1114111) {
+        return String.fromCodePoint(code);
+      }
+      onUnknown?.(whole);
+      return whole;
     }
     const known = GML_NAMED.get(entity);
     if (known === void 0) {
@@ -974,14 +1262,14 @@ function quoteDotId(text) {
   }
   return `"${text.replace(/"/g, '\\"')}"`;
 }
-function quoteCsvCell(text, delimiter = ",") {
+function quoteCsvCell(text, delimiter = ",", quote = '"') {
   if (text.length === 0) {
-    return '""';
+    return quote + quote;
   }
-  if (!text.includes(delimiter) && !text.includes('"') && !text.includes("\n") && !text.includes("\r") && text === text.trim()) {
+  if (!text.includes(delimiter) && !text.includes(quote) && !text.includes("\n") && !text.includes("\r") && text === text.trim()) {
     return text;
   }
-  return `"${text.replace(/"/g, '""')}"`;
+  return `${quote}${text.split(quote).join(quote + quote)}${quote}`;
 }
 function isPajekLabel(text) {
   return !text.includes('"') && !text.includes("\n") && !text.includes("\r");
@@ -993,7 +1281,7 @@ function quotePajekLabel(text) {
       value: text
     });
   }
-  if (text.length > 0 && !/[\s"]/.test(text) && !text.startsWith("[")) {
+  if (text.length > 0 && !/[\s"]/.test(text) && !text.startsWith("[") && !text.startsWith("%")) {
     return text;
   }
   return `"${text}"`;
@@ -1006,16 +1294,18 @@ export {
   isWritableDotText as d,
   escapeXmlAttribute as e,
   xmlDeclaredEncoding as f,
-  isWhitespace as g,
+  XmlEmptyInputError as g,
   hasIllegalXmlChar as h,
   isPajekLabel as i,
-  decodeGmlString as j,
-  quoteGmlString as k,
+  isWhitespace as j,
+  decodeGmlString as k,
   localName as l,
-  quoteCsvCell as m,
+  quoteGmlString as m,
   isXmlName as n,
+  quoteCsvCell as o,
   quotePajekLabel as q,
+  sniffXmlText as s,
   tokenizeXml as t,
   xmlIllegalTextNotes as x
 };
-//# sourceMappingURL=escape-B-tkk_Cl.js.map
+//# sourceMappingURL=escape-D0g6NNUy.js.map