@graphty/graph-io 0.3.47 → 0.3.49

package/dist/chunks/input-CAxt_aV-.js

@@ -0,0 +1,1397 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { O as OPTION_IGNORED_CODE, a6 as CONTROL_CHARACTER_CODE, E as EMPTY_INPUT_CODE, u as INVALID_ENCODING_CODE, s as UNKNOWN_ENCODING_CODE, r as ENCODING_CONFLICT_CODE, v as INVALID_UTF8_CODE, t as ENCODING_FALLBACK_CODE, a7 as FOREIGN_FORMAT_CODE, V as TOO_LARGE_CODE } from "./report-CwMfYa9J.js";
+const HEAD_BYTES = 1024;
+const BOM_BYTES = 4;
+function canonicalEncoding(label) {
+  try {
+    return new TextDecoder(label.trim()).encoding;
+  } catch {
+    return null;
+  }
+}
+function bomEncoding(head) {
+  if (startsWithBytes(head, [255, 254, 0, 0])) {
+    return "utf-32le";
+  }
+  if (startsWithBytes(head, [0, 0, 254, 255])) {
+    return "utf-32be";
+  }
+  if (startsWithBytes(head, [239, 187, 191])) {
+    return "utf-8";
+  }
+  if (startsWithBytes(head, [255, 254])) {
+    return "utf-16le";
+  }
+  if (startsWithBytes(head, [254, 255])) {
+    return "utf-16be";
+  }
+  return null;
+}
+function startsWithBytes(bytes, signature) {
+  return bytes.byteLength >= signature.length && signature.every((b, i) => bytes[i] === b);
+}
+function bomlessUtf16(head) {
+  const pairs = Math.min(head.byteLength >> 1, 512);
+  if (pairs < 2) {
+    return null;
+  }
+  let le = 0;
+  let be = 0;
+  for (let i = 0; i < pairs; i++) {
+    const even = head[2 * i];
+    const odd = head[2 * i + 1];
+    if (even !== 0 && odd === 0) {
+      le++;
+    } else if (even === 0 && odd !== 0) {
+      be++;
+    }
+  }
+  if (le >= pairs * 0.9) {
+    return "utf-16le";
+  }
+  return be >= pairs * 0.9 ? "utf-16be" : null;
+}
+function xmlDeclarationUtf16(head) {
+  if (startsWithBytes(head, [60, 0, 63, 0])) {
+    return "utf-16le";
+  }
+  return startsWithBytes(head, [0, 60, 0, 63]) ? "utf-16be" : null;
+}
+function foreignKind(head) {
+  if (typeof head !== "string") {
+    if (startsWithBytes(head, [31, 139])) {
+      return "gzip-compressed data (decompress it first)";
+    }
+    if (startsWithBytes(head, [80, 75, 3, 4]) || startsWithBytes(head, [80, 75, 5, 6])) {
+      return "a zip archive (a Cytoscape session (.cys) is read by the cys importer; extract any other graph file from it first)";
+    }
+    if (startsWithBytes(head, [137, 80, 78, 71])) {
+      return "a PNG image";
+    }
+  }
+  const text = typeof head === "string" ? head.slice(0, 64) : String.fromCodePoint(...head.subarray(0, 64));
+  const utf8Bom = String.fromCodePoint(239, 187, 191);
+  let body = text.startsWith(utf8Bom) ? text.slice(3) : text;
+  body = body.startsWith(BOM) ? body.slice(1) : body;
+  if (body.startsWith("%PDF-")) {
+    return "a PDF document";
+  }
+  if (/^\s*(<!doctype\s+html[\s>]|<html[\s>])/i.test(body)) {
+    return "an HTML document (likely an error page saved in place of the file)";
+  }
+  return null;
+}
+function refuseForeign(head, report, options) {
+  const foreign = foreignKind(head);
+  if (foreign !== null && !(options.xml === true && foreign.startsWith("an HTML"))) {
+    report.fail(FOREIGN_FORMAT_CODE, `the input is ${foreign}, not ${report.format} text`);
+  }
+}
+function sameFamily(a, b) {
+  return a === b || a.startsWith("utf-16") && b.startsWith("utf-16");
+}
+class ByteDecoder {
+  /**
+   * Create the decoder of one import.
+   * @param report - where warnings and the fatal decode error go
+   * @param options - the encoding option and the format's declaration reader
+   */
+  constructor(report, options) {
+    this.report = report;
+    this.options = options;
+    this.decoder = null;
+    this.encoding = "utf-8";
+    this.mayFallBack = false;
+    this.asciiSoFar = true;
+    this.carry = new Uint8Array(0);
+    this.offset = 0;
+    this.fellBack = false;
+    this.control = null;
+    this.subAt = -1;
+    this.textFollows = false;
+    this.declaredUtf8 = false;
+    this.mixedPending = false;
+  }
+  /**
+   * Whether start() ran.
+   * @returns true once the encoding is chosen
+   */
+  get started() {
+    return this.decoder !== null;
+  }
+  /**
+   * Choose the encoding from the first bytes of the input: a BOM, else the option, else the
+   * declaration, else UTF-8 (see the module comment), warning where two of them disagree.
+   * @param head - the first bytes (up to the declaration size; fewer when the input is shorter)
+   */
+  start(head) {
+    refuseForeign(head, this.report, this.options);
+    const explicit = this.options.encoding ?? null;
+    const bom = bomEncoding(head);
+    if (bom === "utf-32le" || bom === "utf-32be") {
+      this.report.fail(
+        INVALID_ENCODING_CODE,
+        `the input starts with a ${bom.toUpperCase()} byte order mark; UTF-32 is not supported (convert the file to UTF-8)`,
+        void 0,
+        { byteOffset: 0 }
+      );
+    }
+    if (bom !== null) {
+      const option = explicit === null ? null : canonicalEncoding(explicit);
+      if (option !== null && option !== bom) {
+        this.conflict(`the encoding option says ${option} but the byte order mark says ${bom}; read as ${bom}`);
+      }
+      this.checkDeclaration(head, bom, "its byte order mark says");
+      this.use(bom, false);
+      return;
+    }
+    if (explicit !== null) {
+      this.use(explicit, false);
+      this.checkDeclaration(head, this.encoding, "the encoding option says");
+      return;
+    }
+    const xmlUtf16 = xmlDeclarationUtf16(head);
+    if (xmlUtf16 !== null) {
+      this.checkDeclaration(head, xmlUtf16, "its XML declaration's byte pattern says");
+      this.use(xmlUtf16, false);
+      return;
+    }
+    const utf16 = bomlessUtf16(head);
+    if (utf16 !== null && this.options.bomlessUtf16 === true) {
+      this.use(utf16, false);
+      return;
+    }
+    if (utf16 !== null) {
+      this.report.fail(
+        INVALID_ENCODING_CODE,
+        `the input looks like ${utf16} text without a byte order mark (every other byte is 0); pass the encoding option ${JSON.stringify(utf16)} to read it`,
+        void 0,
+        { byteOffset: 0 }
+      );
+    }
+    const declared = this.declared(head, "windows-1252");
+    if (declared !== null) {
+      const canonical = canonicalEncoding(declared);
+      if (canonical === null) {
+        this.report.warning(
+          "unsupported",
+          UNKNOWN_ENCODING_CODE,
+          `the input declares the encoding ${JSON.stringify(declared)}, which this platform cannot decode; reading it as UTF-8`,
+          { element: declared }
+        );
+      } else if (canonical.startsWith("utf-16")) {
+        this.conflict(
+          `the input declares ${JSON.stringify(declared)} but has no byte order mark and its bytes are not UTF-16; read as UTF-8`
+        );
+      } else if (canonical === "utf-8") {
+        this.declaredUtf8 = true;
+      } else {
+        this.use(canonical, false);
+        return;
+      }
+    }
+    this.use("utf-8", true);
+  }
+  /**
+   * The encoding the head declares, read through the format's declaration reader.
+   * @param head - the first bytes
+   * @param encoding - the encoding to read the head in for the reader
+   * @returns the declared label, or null (also for a format without declarations)
+   */
+  declared(head, encoding) {
+    const reader = this.options.declaredEncoding;
+    return reader === void 0 ? null : reader(new TextDecoder(encoding).decode(head));
+  }
+  /**
+   * Warn when the file declares an encoding other than the one a BOM or the option chose.
+   * @param head - the first bytes
+   * @param chosen - the encoding the input is read in
+   * @param why - what chose it, for the message
+   */
+  checkDeclaration(head, chosen, why) {
+    const declared = this.declared(head, chosen);
+    const canonical = declared === null ? null : canonicalEncoding(declared);
+    if (canonical !== null && !sameFamily(canonical, chosen)) {
+      this.conflict(
+        `the input declares the encoding ${JSON.stringify(declared)} but ${why} ${chosen}; read as ${chosen}`
+      );
+    }
+  }
+  /**
+   * Record a W_ENCODING_CONFLICT warning.
+   * @param message - which sources disagree and which applies
+   */
+  conflict(message) {
+    this.report.warning("coercion", ENCODING_CONFLICT_CODE, message);
+  }
+  /**
+   * Decode the next bytes.
+   * @param input - the bytes
+   * @param stream - whether more bytes follow
+   * @returns the text
+   */
+  decode(input, stream) {
+    const bytes = typeof SharedArrayBuffer === "function" && input.buffer instanceof SharedArrayBuffer ? input.slice() : input;
+    const decoder = this.decoder;
+    if (this.fellBack || this.mayFallBack && this.asciiSoFar) {
+      this.watch(bytes, !stream);
+      if (this.fellBack && this.control !== null) {
+        this.binary(this.control);
+      }
+    }
+    const text = this.decodeOrRecover(decoder, bytes, stream);
+    if (this.mixedPending) {
+      this.reportUtf8After(bytes, this.offset);
+    }
+    if (this.asciiSoFar && this.mayFallBack) {
+      this.trackAscii(bytes, text);
+    }
+    if (this.mayFallBack && this.options.nulIsBinary === true && text.includes("\0")) {
+      this.binary({ at: this.offset + bytes.indexOf(0), byte: 0 });
+    }
+    this.offset += bytes.byteLength;
+    return text;
+  }
+  /**
+   * Decode bytes, recovering from bytes that are not valid in the encoding.
+   * @param decoder - the decoder
+   * @param bytes - the bytes
+   * @param stream - whether more bytes follow
+   * @returns the text
+   */
+  decodeOrRecover(decoder, bytes, stream) {
+    try {
+      return decoder.decode(bytes, { stream });
+    } catch (err) {
+      if (!(err instanceof TypeError)) {
+        throw err;
+      }
+      return this.recover(bytes, stream);
+    }
+  }
+  /**
+   * Track whether the input is ASCII so far. While it is, every character is one byte, so the
+   * bytes not yet emitted are held back for a fallback.
+   * @param bytes - the bytes just decoded
+   * @param text - their text
+   */
+  trackAscii(bytes, text) {
+    if (/[\u0080-\uffff]/.test(text)) {
+      this.asciiSoFar = false;
+      this.carry = new Uint8Array(0);
+      return;
+    }
+    const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
+    this.carry = all.slice(text.length);
+  }
+  /**
+   * Flush the bytes held back because a text chunk follows (the input switches from bytes to
+   * strings): a multi-byte sequence cut there is invalid UTF-8, never windows-1252 text.
+   * @param flush - the flush to run (the decoder's own, or the head's)
+   * @returns the text of the held-back bytes
+   */
+  flushBeforeText(flush) {
+    this.textFollows = true;
+    try {
+      return flush();
+    } finally {
+      this.textFollows = false;
+    }
+  }
+  /**
+   * A decode failed: switch to windows-1252 when allowed, else fail the import with the position
+   * of the first byte that is not valid.
+   * @param bytes - the bytes that failed
+   * @param stream - whether more bytes follow
+   * @returns the bytes decoded as windows-1252
+   */
+  recover(bytes, stream) {
+    const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
+    const base = this.offset - this.carry.byteLength;
+    const bad = this.encoding === "utf-8" ? invalidUtf8(all) : null;
+    const at = base + (bad === null ? 0 : bad.index);
+    if (this.mayFallBack && this.asciiSoFar) {
+      const text = this.fallBack(all, bad, at, base, stream);
+      if (text !== null) {
+        return text;
+      }
+    }
+    return this.failDecode(bytes, at, base, stream);
+  }
+  /**
+   * Undeclared input that was ASCII so far failed to decode: fail on binary data or a cut
+   * sequence, else switch to windows-1252 with a warning unless the bytes start with valid
+   * non-ASCII UTF-8.
+   * @param all - the held-back bytes followed by the bytes that failed
+   * @param bad - the first invalid UTF-8 sequence, or null when the encoding is not UTF-8
+   * @param at - the byte offset of the first invalid byte
+   * @param base - the byte offset of `all`
+   * @param stream - whether more bytes follow
+   * @returns the bytes decoded as windows-1252, or null when they do not fall back
+   */
+  fallBack(all, bad, at, base, stream) {
+    if (this.control !== null) {
+      return this.binary(this.control);
+    }
+    if (this.textFollows && bad?.cut === true) {
+      return this.report.fail(
+        INVALID_UTF8_CODE,
+        `invalid UTF-8 at byte ${at}: a byte chunk ends inside a multi-byte sequence and a text chunk follows`,
+        void 0,
+        { byteOffset: at }
+      );
+    }
+    if (!stream && bad?.truncated === true) {
+      return this.report.fail(
+        INVALID_UTF8_CODE,
+        `the input ends in the middle of a UTF-8 sequence at byte ${at} (it may be truncated)`,
+        void 0,
+        { byteOffset: at }
+      );
+    }
+    if (startsWithUtf8(all)) {
+      return null;
+    }
+    const cutNote = !stream && bad?.cut === true ? ": it ends inside a multi-byte UTF-8 sequence, so it may be truncated" : "";
+    this.report.warning(
+      "coercion",
+      ENCODING_FALLBACK_CODE,
+      this.declaredUtf8 ? `the input declares UTF-8 but is not valid UTF-8 (at byte ${at}); everything before was ASCII, so it is read as windows-1252 (pass the encoding option to choose another)` : `the input is not valid UTF-8 (at byte ${at}${cutNote}) and declares no encoding; read as windows-1252 (pass the encoding option to choose another)`
+    );
+    this.use("windows-1252", false);
+    this.fellBack = true;
+    this.mixedPending = true;
+    this.reportUtf8After(all, base);
+    return this.decoder.decode(all, { stream });
+  }
+  /**
+   * Fail the import on bytes that are not valid in the encoding.
+   * @param bytes - the bytes that failed
+   * @param at - the byte offset of the first invalid UTF-8 byte
+   * @param base - the byte offset of the held-back bytes and these
+   * @param stream - whether more bytes follow
+   * @returns never: it throws
+   */
+  failDecode(bytes, at, base, stream) {
+    if (this.encoding === "utf-8") {
+      const after = this.mayFallBack ? " after valid non-ASCII UTF-8 text; pass the encoding option" : "";
+      return this.report.fail(INVALID_UTF8_CODE, `invalid UTF-8 at byte ${at}${after}`, void 0, {
+        byteOffset: at
+      });
+    }
+    const end = this.offset + bytes.byteLength;
+    const odd = !stream && this.encoding.startsWith("utf-16") && end % 2 === 1;
+    return this.report.fail(
+      INVALID_ENCODING_CODE,
+      odd ? `the input ends with half a ${this.encoding} code unit at byte ${end - 1} (it may be truncated)` : `the bytes near byte ${base} are not valid ${this.encoding}`,
+      void 0,
+      { byteOffset: odd ? end - 1 : base }
+    );
+  }
+  /**
+   * After the windows-1252 fallback, report once that later bytes hold a valid multi-byte UTF-8
+   * sequence: the input mixes encodings, and those characters are read as two or three
+   * windows-1252 characters each.
+   * @param bytes - bytes being decoded as windows-1252
+   * @param start - the byte offset of the first of them
+   */
+  reportUtf8After(bytes, start) {
+    const at = utf8SequenceIndex(bytes);
+    if (at < 0) {
+      return;
+    }
+    this.mixedPending = false;
+    this.report.warning(
+      "coercion",
+      ENCODING_FALLBACK_CODE,
+      `bytes read as windows-1252 hold valid UTF-8 (at byte ${start + at}): the input mixes encodings, and its UTF-8 characters are read as windows-1252 (pass the encoding option to choose one)`
+    );
+  }
+  /**
+   * Note the first control byte of the next bytes (see `control`).
+   * @param bytes - the bytes, starting at `offset`
+   * @param final - whether they end the input
+   */
+  watch(bytes, final) {
+    if (this.control !== null || bytes.byteLength === 0) {
+      return;
+    }
+    if (this.subAt >= 0) {
+      this.control = { at: this.subAt, byte: 26 };
+      return;
+    }
+    const index = controlByte(bytes, true);
+    if (index >= 0) {
+      this.control = { at: this.offset + index, byte: bytes[index] };
+    } else if (!final && bytes[bytes.byteLength - 1] === 26) {
+      this.subAt = this.offset + bytes.byteLength - 1;
+    }
+  }
+  /**
+   * Fail the import as binary data.
+   * @param control - the control byte that shows it
+   * @param control.at - its offset
+   * @param control.byte - its value
+   * @returns never
+   */
+  binary(control) {
+    const hex = control.byte.toString(16).padStart(2, "0");
+    return this.report.fail(
+      INVALID_UTF8_CODE,
+      `the input is binary data, not text: control byte 0x${hex} at byte ${control.at}`,
+      void 0,
+      { byteOffset: control.at }
+    );
+  }
+  /**
+   * Switch to an encoding.
+   * @param label - the encoding label
+   * @param mayFallBack - whether a UTF-8 failure may switch to windows-1252
+   */
+  use(label, mayFallBack) {
+    this.decoder = new TextDecoder(label, { fatal: true, ignoreBOM: true });
+    this.encoding = this.decoder.encoding;
+    this.mayFallBack = mayFallBack;
+  }
+}
+function utf8SequenceIndex(bytes) {
+  for (let i = 0; i < bytes.byteLength; i++) {
+    if (bytes[i] >= 194 && isUtf8SequenceAt(bytes, i)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function startsWithUtf8(bytes) {
+  const i = bytes.findIndex((b) => b >= 128);
+  return i >= 0 && isUtf8SequenceAt(bytes, i);
+}
+const STRICT_UTF8 = new TextDecoder("utf-8", { fatal: true });
+function isUtf8SequenceAt(bytes, i) {
+  const lead = bytes[i];
+  let length = 0;
+  if (lead >= 194 && lead <= 223) {
+    length = 2;
+  } else if (lead >= 224 && lead <= 239) {
+    length = 3;
+  } else if (lead >= 240 && lead <= 244) {
+    length = 4;
+  }
+  if (length === 0 || i + length > bytes.byteLength) {
+    return false;
+  }
+  try {
+    STRICT_UTF8.decode(bytes.subarray(i, i + length));
+    return true;
+  } catch {
+    return false;
+  }
+}
+const CP437_HIGH = [
+  199,
+  252,
+  233,
+  226,
+  228,
+  224,
+  229,
+  231,
+  234,
+  235,
+  232,
+  239,
+  238,
+  236,
+  196,
+  197,
+  201,
+  230,
+  198,
+  244,
+  246,
+  242,
+  251,
+  249,
+  255,
+  214,
+  220,
+  162,
+  163,
+  165,
+  8359,
+  402,
+  225,
+  237,
+  243,
+  250,
+  241,
+  209,
+  170,
+  186,
+  191,
+  8976,
+  172,
+  189,
+  188,
+  161,
+  171,
+  187,
+  9617,
+  9618,
+  9619,
+  9474,
+  9508,
+  9569,
+  9570,
+  9558,
+  9557,
+  9571,
+  9553,
+  9559,
+  9565,
+  9564,
+  9563,
+  9488,
+  9492,
+  9524,
+  9516,
+  9500,
+  9472,
+  9532,
+  9566,
+  9567,
+  9562,
+  9556,
+  9577,
+  9574,
+  9568,
+  9552,
+  9580,
+  9575,
+  9576,
+  9572,
+  9573,
+  9561,
+  9560,
+  9554,
+  9555,
+  9579,
+  9578,
+  9496,
+  9484,
+  9608,
+  9604,
+  9612,
+  9616,
+  9600,
+  945,
+  223,
+  915,
+  960,
+  931,
+  963,
+  181,
+  964,
+  934,
+  920,
+  937,
+  948,
+  8734,
+  966,
+  949,
+  8745,
+  8801,
+  177,
+  8805,
+  8804,
+  8992,
+  8993,
+  247,
+  8776,
+  176,
+  8729,
+  183,
+  8730,
+  8319,
+  178,
+  9632,
+  160
+];
+function invalidUtf8(bytes) {
+  let i = 0;
+  while (i < bytes.byteLength) {
+    const lead = bytes[i];
+    const sequence = lead < 128 ? ASCII_SEQUENCE : utf8Sequence(lead);
+    if (sequence === null) {
+      return { index: i, truncated: false, cut: false };
+    }
+    const problem = checkContinuation(bytes, i, sequence);
+    if (problem !== null) {
+      return problem;
+    }
+    i += sequence.need + 1;
+  }
+  return { index: 0, truncated: false, cut: false };
+}
+const ASCII_SEQUENCE = { need: 0, low: 128, high: 191 };
+function utf8Sequence(lead) {
+  if (lead >= 194 && lead <= 223) {
+    return { need: 1, low: 128, high: 191 };
+  }
+  if (lead >= 224 && lead <= 239) {
+    return { need: 2, low: lead === 224 ? 160 : 128, high: lead === 237 ? 159 : 191 };
+  }
+  if (lead >= 240 && lead <= 244) {
+    return { need: 3, low: lead === 240 ? 144 : 128, high: lead === 244 ? 143 : 191 };
+  }
+  return null;
+}
+function checkContinuation(bytes, i, sequence) {
+  for (let k = 1; k <= sequence.need; k++) {
+    if (i + k >= bytes.byteLength) {
+      return { index: i, truncated: k > 1, cut: true };
+    }
+    const next = bytes[i + k];
+    const low = k === 1 ? sequence.low : 128;
+    const high = k === 1 ? sequence.high : 191;
+    if (next < low || next > high) {
+      return { index: i, truncated: false, cut: false };
+    }
+  }
+  return null;
+}
+function controlByte(bytes, final) {
+  const last = bytes.byteLength - 1;
+  for (let i = 0; i <= last; i++) {
+    const b = bytes[i];
+    if (b < 32 && b !== 9 && b !== 10 && b !== 12 && b !== 13 && !(b === 26 && final && i === last)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function decodeEntryName(bytes, cp437 = false) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    if (!cp437) {
+      return new TextDecoder("windows-1252").decode(bytes);
+    }
+    let out = "";
+    for (const byte of bytes) {
+      out += String.fromCodePoint(byte < 128 ? byte : CP437_HIGH[byte - 128]);
+    }
+    return out;
+  }
+}
+function concatBytes(chunks) {
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  const out = new Uint8Array(chunks.reduce((sum, c) => sum + c.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+const DECODE_SLICE = 256 * 1024;
+const BOM = String.fromCharCode(65279);
+const SUB = String.fromCodePoint(26);
+const MAX_TEXT_LENGTH = 2 ** 29 - 24;
+const CONTROL_CHARACTER = new RegExp(
+  `[${String.fromCodePoint(0)}-${String.fromCodePoint(8, 11, 14)}-${String.fromCodePoint(31, 127)}-${String.fromCodePoint(159)}${BOM}]`
+);
+function isImportInput(input) {
+  if (typeof input === "string" || asBytes(input) !== null) {
+    return true;
+  }
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+  return typeof input.getReader === "function" || Symbol.asyncIterator in input;
+}
+function asBytes(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (ArrayBuffer.isView(value) && Object.prototype.toString.call(value) === "[object Uint8Array]") {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  return null;
+}
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  const bytes = asBytes(input);
+  if (bytes !== null) {
+    return bytes;
+  }
+  if (isImportInput(input)) {
+    return input;
+  }
+  const tag = Object.prototype.toString.call(input).slice(8, -1);
+  let found = input === null ? "null" : typeof input;
+  let fix = "";
+  if (tag === "ArrayBuffer" || tag === "SharedArrayBuffer") {
+    found = `an ${tag}`;
+    fix = "; wrap it as new Uint8Array(buffer)";
+  } else if (ArrayBuffer.isView(input)) {
+    found = `a ${tag}`;
+    fix = "; pass new Uint8Array(view.buffer, view.byteOffset, view.byteLength)";
+  } else if (typeof input === "object" && input !== null) {
+    const object = input;
+    if (typeof object.stream === "function" && typeof object.size === "number") {
+      found = "a Blob or File";
+      fix = "; pass blob.stream()";
+    } else if ("body" in object && typeof object.arrayBuffer === "function") {
+      found = "a fetch Response";
+      fix = "; pass response.body";
+    } else {
+      found = `an object (${tag})`;
+    }
+  }
+  throw new GraphFormatError(
+    "E_UNSUPPORTED",
+    `the input is ${found}; an importer reads a string, a Uint8Array, a ReadableStream or an async iterable of strings and Uint8Arrays${fix}`,
+    { reason: "input type", found }
+  );
+}
+function inputLength(input) {
+  if (typeof input === "string") {
+    return input.length;
+  }
+  if (input instanceof Uint8Array) {
+    return input.byteLength;
+  }
+  return null;
+}
+function utf8Length(text) {
+  let bytes = 0;
+  let i = 0;
+  while (i < text.length) {
+    const c = text.charCodeAt(i);
+    const pair = c >= 55296 && c <= 56319 && (text.charCodeAt(i + 1) & 64512) === 56320;
+    if (c < 128) {
+      bytes++;
+    } else if (c < 2048) {
+      bytes += 2;
+    } else {
+      bytes += pair ? 4 : 3;
+    }
+    i += pair ? 2 : 1;
+  }
+  return bytes;
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) {
+    return;
+  }
+  const { reason } = signal;
+  if (reason === void 0) {
+    throw abortError();
+  }
+  throw reason;
+}
+function abortError() {
+  const message = "The import was aborted";
+  if (typeof DOMException === "function") {
+    return new DOMException(message, "AbortError");
+  }
+  const err = new Error(message);
+  err.name = "AbortError";
+  return err;
+}
+function abortable(promise, signal) {
+  if (signal === null || typeof signal.addEventListener !== "function") {
+    return promise;
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      try {
+        throwIfAborted(signal);
+      } catch (err) {
+        reject(err);
+      }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+function lockReader(stream) {
+  if (stream.locked) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      "the input ReadableStream is locked: another reader holds it (release it, or pass a fresh stream)",
+      { reason: "stream locked" }
+    );
+  }
+  return stream.getReader();
+}
+class TextFilter {
+  /**
+   * Create the filter of one import.
+   * @param report - where the warnings and the fatal errors go
+   * @param options - whether an empty input is valid, whether the format is XML
+   */
+  constructor(report, options) {
+    this.report = report;
+    this.options = options;
+    this.first = true;
+    this.content = false;
+    this.heldSub = false;
+    this.warned = false;
+    this.strayBom = false;
+  }
+  /**
+   * Filter the next decoded text.
+   * @param chunk - the text
+   * @returns the text to hand on
+   */
+  push(chunk) {
+    let text = this.heldSub ? SUB + chunk : chunk;
+    this.heldSub = false;
+    if (text.length === 0) {
+      return text;
+    }
+    if (this.first) {
+      text = this.skipByteOrderMarks(text);
+      if (text.length === 0) {
+        return text;
+      }
+      this.first = false;
+      refuseForeign(text, this.report, this.options);
+    }
+    if (text.endsWith(SUB)) {
+      this.heldSub = true;
+      text = text.slice(0, -1);
+    }
+    if (!this.content && /\S/.test(text)) {
+      this.content = true;
+    }
+    if (!this.warned) {
+      this.warnControl(text);
+    }
+    return text;
+  }
+  /**
+   * Drop the byte order marks the input starts with, warning when there is more than one.
+   * @param text - the first text
+   * @returns the text without them
+   */
+  skipByteOrderMarks(text) {
+    let start = 0;
+    while (text.codePointAt(start) === 65279) {
+      start++;
+    }
+    if (start > 1 && !this.strayBom) {
+      this.strayBom = true;
+      this.report.warning(
+        "validation-error",
+        CONTROL_CHARACTER_CODE,
+        `the input starts with ${start} byte order marks (U+FEFF); the extra ones were ignored`,
+        { element: "U+FEFF" }
+      );
+    }
+    return text.slice(start);
+  }
+  /**
+   * Warn, once, about the first control character the text holds.
+   * @param text - the text
+   */
+  warnControl(text) {
+    const match = CONTROL_CHARACTER.exec(text);
+    if (match === null) {
+      return;
+    }
+    this.warned = true;
+    const code = (match[0].codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0");
+    const around = JSON.stringify(text.slice(Math.max(0, match.index - 20), match.index + 20));
+    this.report.warning(
+      "validation-error",
+      CONTROL_CHARACTER_CODE,
+      `the input holds the control character U+${code} (in ${around}); it is kept in the id or value it is part of`,
+      { element: `U+${code}` }
+    );
+  }
+  /** The input ended: drop a held Ctrl-Z with a warning, and refuse an input without content. */
+  end() {
+    if (this.heldSub) {
+      this.report.warning(
+        "validation-error",
+        CONTROL_CHARACTER_CODE,
+        "the input ends with a Ctrl-Z (0x1A), the DOS end-of-file marker; it was ignored",
+        { element: "U+001A" }
+      );
+    }
+    if (!this.content && this.options.allowEmpty !== true) {
+      this.report.fail(EMPTY_INPUT_CODE, this.first ? "the input is empty" : "the input holds only whitespace");
+    }
+  }
+}
+function reportTextEncoding(report, encoding) {
+  if (encoding !== null && encoding !== void 0) {
+    report.warning(
+      "unsupported",
+      OPTION_IGNORED_CODE,
+      "option encoding has no effect on text input, which is already decoded",
+      { element: "encoding" }
+    );
+  }
+}
+async function* textChunks(rawInput, report, options = {}) {
+  const input = normalizeInput(rawInput);
+  const signal = options.signal ?? null;
+  const filter = new TextFilter(report, options);
+  throwIfAborted(signal);
+  if (typeof input === "string") {
+    reportTextEncoding(report, options.encoding);
+    yield* stringTextChunks(input, filter, options);
+    return;
+  }
+  const decoder = new ByteDecoder(report, options);
+  if (input instanceof Uint8Array) {
+    yield* byteTextChunks(input, filter, decoder, options);
+    return;
+  }
+  const stream = new StreamText(filter, decoder, options);
+  for await (const chunk of isReadableStream(input) ? streamChunks(input, signal) : input) {
+    throwIfAborted(signal);
+    const text = stream.push(chunk);
+    if (text.length > 0) {
+      yield text;
+    }
+    options.onProgress?.(stream.done);
+  }
+  const tail = stream.end();
+  if (tail.length > 0) {
+    yield tail;
+  }
+  filter.end();
+  options.onProgress?.(stream.done, stream.done);
+}
+function stringSliceEnd(input, start) {
+  const end = Math.min(start + DECODE_SLICE, input.length);
+  const highSurrogate = (input.charCodeAt(end - 1) & 64512) === 55296;
+  return end < input.length && highSurrogate ? end + 1 : end;
+}
+function* stringTextChunks(input, filter, options) {
+  const signal = options.signal ?? null;
+  const onProgress = options.onProgress ?? null;
+  const total = onProgress === null ? 0 : utf8Length(input);
+  let done = 0;
+  let start = 0;
+  while (start < input.length) {
+    throwIfAborted(signal);
+    const end = stringSliceEnd(input, start);
+    const piece = start === 0 && end === input.length ? input : input.slice(start, end);
+    start = end;
+    const text = filter.push(piece);
+    if (text.length > 0) {
+      yield text;
+    }
+    if (onProgress !== null) {
+      done += utf8Length(piece);
+      onProgress(done, total);
+    }
+  }
+  if (input.length === 0) {
+    onProgress?.(0, 0);
+  }
+  filter.end();
+}
+function* byteTextChunks(input, filter, decoder, options) {
+  const signal = options.signal ?? null;
+  const length = input.byteLength;
+  decoder.start(input.subarray(0, headByteCount(options)));
+  for (let offset = 0; offset < length; offset += DECODE_SLICE) {
+    throwIfAborted(signal);
+    if (input.byteLength !== length) {
+      throw new GraphFormatError(
+        "E_UNSUPPORTED",
+        "the input's buffer was detached (transferred) or resized during the import",
+        { reason: "detached" }
+      );
+    }
+    const slice = input.subarray(offset, Math.min(offset + DECODE_SLICE, length));
+    const text = filter.push(decoder.decode(slice, offset + DECODE_SLICE < length));
+    if (text.length > 0) {
+      yield text;
+    }
+    options.onProgress?.(Math.min(offset + DECODE_SLICE, length), length);
+  }
+  if (length === 0) {
+    options.onProgress?.(0, 0);
+  }
+  filter.end();
+}
+function headByteCount(options) {
+  return Math.max(options.declarationBytes ?? HEAD_BYTES, BOM_BYTES);
+}
+class StreamText {
+  /**
+   * Create the reader of one stream input.
+   * @param filter - the text checks
+   * @param decoder - the byte decoder
+   * @param options - progress, the declaration reader and its size
+   */
+  constructor(filter, decoder, options) {
+    this.filter = filter;
+    this.decoder = decoder;
+    this.done = 0;
+    this.head = [];
+    this.headLength = 0;
+    this.headBytes = headByteCount(options);
+    this.needed = options.declaredEncoding === void 0 ? BOM_BYTES : this.headBytes;
+    this.counting = (options.onProgress ?? null) !== null;
+  }
+  /**
+   * Read the next chunk.
+   * @param chunk - a string or a Uint8Array (anything else is E_UNSUPPORTED)
+   * @returns its filtered text; empty while bytes are held back
+   */
+  push(chunk) {
+    if (typeof chunk === "string") {
+      this.done += this.counting ? utf8Length(chunk) : 0;
+      return this.filter.push(this.beforeText() + chunk);
+    }
+    const bytes = asBytes(chunk);
+    if (bytes === null) {
+      throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
+        reason: "chunk type",
+        found: typeof chunk
+      });
+    }
+    this.done += bytes.byteLength;
+    if (this.decoder.started) {
+      return this.filter.push(this.decoder.decode(bytes, true));
+    }
+    this.head.push(bytes);
+    this.headLength += bytes.byteLength;
+    return this.headLength >= this.needed ? this.filter.push(this.flushHead(true)) : "";
+  }
+  /**
+   * The input ended: the filtered text of whatever is still held or pending.
+   * @returns the text
+   */
+  end() {
+    let tail = "";
+    if (this.headLength > 0) {
+      tail = this.flushHead(false);
+    } else if (this.decoder.started) {
+      tail = this.decoder.decode(new Uint8Array(0), false);
+    }
+    return this.filter.push(tail);
+  }
+  /**
+   * Start the decoder on the held bytes and decode them.
+   * @param stream - whether more bytes follow
+   * @returns their text
+   */
+  flushHead(stream) {
+    const bytes = concatBytes(this.head);
+    this.head = [];
+    this.headLength = 0;
+    this.decoder.start(bytes.subarray(0, this.headBytes));
+    return this.decoder.decode(bytes, stream);
+  }
+  /**
+   * A text chunk follows: finish any byte sequence still pending in the decoder before switching
+   * to text. The BOM and declaration checks apply to the start of the input only, so bytes after
+   * text are never taken for a BOM.
+   * @returns the text of the pending bytes
+   */
+  beforeText() {
+    if (this.headLength > 0) {
+      return this.decoder.flushBeforeText(() => this.flushHead(false));
+    }
+    if (this.decoder.started) {
+      return this.decoder.flushBeforeText(() => this.decoder.decode(new Uint8Array(0), false));
+    }
+    this.decoder.start(new Uint8Array(0));
+    return "";
+  }
+}
+function isReadableStream(input) {
+  return typeof input.getReader === "function";
+}
+async function* streamChunks(stream, signal) {
+  const reader = lockReader(stream);
+  let finished = false;
+  try {
+    for (; ; ) {
+      throwIfAborted(signal);
+      const { done, value } = await abortable(reader.read(), signal);
+      if (done) {
+        finished = true;
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    if (!finished) {
+      await reader.cancel(signal?.reason).catch(() => void 0);
+    }
+    reader.releaseLock();
+  }
+}
+async function readBytes(rawInput, options = {}) {
+  const input = normalizeInput(rawInput);
+  const signal = options.signal ?? null;
+  throwIfAborted(signal);
+  if (typeof input === "string") {
+    return null;
+  }
+  if (input instanceof Uint8Array) {
+    options.onProgress?.(input.byteLength, input.byteLength);
+    return input;
+  }
+  const parts = [];
+  let done = 0;
+  for await (const chunk of isReadableStream(input) ? streamChunks(input, signal) : input) {
+    throwIfAborted(signal);
+    if (typeof chunk === "string") {
+      return null;
+    }
+    const bytes = asBytes(chunk);
+    if (bytes === null) {
+      throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
+        reason: "chunk type",
+        found: typeof chunk
+      });
+    }
+    parts.push(bytes);
+    done += bytes.byteLength;
+    options.onProgress?.(done);
+  }
+  options.onProgress?.(done, done);
+  return parts.length === 0 ? new Uint8Array(0) : concatBytes(parts);
+}
+function tooLarge(report, message, line) {
+  report.failWith("unsupported", TOO_LARGE_CODE, message, line === void 0 ? void 0 : { line });
+}
+async function readText(rawInput, report, options = {}) {
+  const input = normalizeInput(rawInput);
+  if (typeof input === "string") {
+    throwIfAborted(options.signal);
+    reportTextEncoding(report, options.encoding);
+    const filter = new TextFilter(report, options);
+    const text = filter.push(input);
+    filter.end();
+    if (options.onProgress !== null && options.onProgress !== void 0) {
+      const total = utf8Length(input);
+      options.onProgress(total, total);
+    }
+    return text;
+  }
+  const parts = [];
+  let length = 0;
+  for await (const chunk of textChunks(input, report, options)) {
+    length += chunk.length;
+    if (length > MAX_TEXT_LENGTH) {
+      tooLarge(
+        report,
+        `the document is longer than ${MAX_TEXT_LENGTH} characters, the most one JavaScript string holds`
+      );
+    }
+    parts.push(chunk);
+  }
+  return parts.length === 1 ? parts[0] : parts.join("");
+}
+class LineReader {
+  /**
+   * Create a reader over an input; nothing is read until iteration starts.
+   * @param input - the input
+   * @param report - the report decode errors are recorded in
+   * @param options - cancellation and progress
+   */
+  constructor(input, report, options = {}) {
+    this.lineNumber = 0;
+    this.input = input;
+    this.report = report;
+    this.options = options;
+  }
+  /**
+   * The 1-based number of the line most recently yielded.
+   * @returns the line number; 0 before the first line
+   */
+  get line() {
+    return this.lineNumber;
+  }
+  /**
+   * The E_TOO_LARGE message of a line longer than one string.
+   * @returns the message
+   */
+  lineTooLong() {
+    return `a line is longer than ${MAX_TEXT_LENGTH} characters, the most one JavaScript string holds`;
+  }
+  /**
+   * Iterate the lines.
+   * @yields one line at a time, terminator removed
+   * @returns nothing
+   */
+  async *[Symbol.asyncIterator]() {
+    const pending = new PendingLine((line) => tooLarge(this.report, this.lineTooLong(), line));
+    let trailingCr = false;
+    for await (const chunk of textChunks(this.input, this.report, this.options)) {
+      let start = 0;
+      if (trailingCr) {
+        trailingCr = false;
+        this.lineNumber++;
+        yield pending.take().slice(0, -1);
+        if (chunk.charCodeAt(0) === 10) {
+          start = 1;
+        }
+      }
+      const breaks = new LineBreaks(chunk, start);
+      while (breaks.advance()) {
+        this.lineNumber++;
+        yield pending.finish(chunk.slice(start, breaks.cut), this.lineNumber);
+        start = breaks.next;
+      }
+      if (start < chunk.length) {
+        pending.appendRest(chunk, start, this.lineNumber + 1);
+        trailingCr = chunk.codePointAt(chunk.length - 1) === 13;
+      }
+    }
+    if (!pending.empty) {
+      this.lineNumber++;
+      const joined = pending.take();
+      yield joined.endsWith("\r") ? joined.slice(0, -1) : joined;
+    }
+  }
+}
+class PendingLine {
+  /**
+   * Start an empty line.
+   * @param tooLong - fails the import when the line grows longer than one string can hold
+   */
+  constructor(tooLong) {
+    this.pieces = [];
+    this.length = 0;
+    this.tooLong = tooLong;
+  }
+  /**
+   * Whether no piece is held.
+   * @returns true when the line in progress is empty
+   */
+  get empty() {
+    return this.pieces.length === 0;
+  }
+  /**
+   * Hold the rest of a chunk from `start`: the line goes on in the next chunk.
+   * @param chunk - the chunk
+   * @param start - where the unfinished line starts in it
+   * @param line - the 1-based number of the line, for the too-long error
+   */
+  appendRest(chunk, start, line) {
+    this.append(start === 0 ? chunk : chunk.slice(start), line);
+  }
+  /**
+   * End the line with its last piece.
+   * @param piece - the text from the start of the chunk (or the last break) to the line break
+   * @param line - the 1-based number of the line, for the too-long error
+   * @returns the whole line
+   */
+  finish(piece, line) {
+    if (this.pieces.length === 0) {
+      return piece;
+    }
+    this.append(piece, line);
+    return this.take();
+  }
+  /**
+   * Join the held pieces and start a new line.
+   * @returns the joined text
+   */
+  take() {
+    const joined = this.pieces.join("");
+    this.pieces.length = 0;
+    this.length = 0;
+    return joined;
+  }
+  /**
+   * Hold one more piece.
+   * @param piece - the piece
+   * @param line - the 1-based number of the line, for the too-long error
+   */
+  append(piece, line) {
+    this.length += piece.length;
+    if (this.length > MAX_TEXT_LENGTH) {
+      this.tooLong(line);
+    }
+    this.pieces.push(piece);
+  }
+}
+class LineBreaks {
+  /**
+   * Scan a chunk from a position.
+   * @param chunk - the chunk
+   * @param start - where scanning starts
+   */
+  constructor(chunk, start) {
+    this.cut = 0;
+    this.chunk = chunk;
+    this.next = start;
+    this.nl = chunk.indexOf("\n", start);
+    this.cr = chunk.indexOf("\r", start);
+  }
+  /**
+   * Find the next line break.
+   * @returns false when none is left, or the only one left is a trailing `\r` (it may be the first
+   * half of a `\r\n` split across chunks)
+   */
+  advance() {
+    const { chunk, next } = this;
+    if (this.nl >= 0 && this.nl < next) {
+      this.nl = chunk.indexOf("\n", next);
+    }
+    if (this.cr >= 0 && this.cr < next) {
+      this.cr = chunk.indexOf("\r", next);
+    }
+    const { nl, cr } = this;
+    if (cr >= 0 && (nl < 0 || cr < nl)) {
+      if (cr === chunk.length - 1) {
+        return false;
+      }
+      this.cut = cr;
+      this.next = chunk.codePointAt(cr + 1) === 10 ? cr + 2 : cr + 1;
+      return true;
+    }
+    if (nl < 0) {
+      return false;
+    }
+    this.cut = nl;
+    this.next = nl + 1;
+    return true;
+  }
+}
+export {
+  LineReader as L,
+  MAX_TEXT_LENGTH as M,
+  tooLarge as a,
+  throwIfAborted as b,
+  canonicalEncoding as c,
+  inputLength as d,
+  decodeEntryName as e,
+  readBytes as f,
+  foreignKind as g,
+  abortable as h,
+  isImportInput as i,
+  lockReader as l,
+  normalizeInput as n,
+  readText as r,
+  textChunks as t
+};
+//# sourceMappingURL=input-CAxt_aV-.js.map