@graphty/graph-io 0.3.47 → 0.3.48

package/dist/chunks/{export-BvqAXCKh.js → export-CZ7VRm4I.js}

@@ -1,5 +1,7 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { aR as withArticle, C as COLUMN_RENAMED_CODE, U as UNKNOWN_ATTR_TYPE_CODE, R as ROLE_TAKEN_CODE, B as BAD_DEFAULT_CODE, ae as BAD_OPTIONS_CODE, D as DIRECTION_FORCED_CODE, b as DIRECTION_REFUSED_CODE, M as MIXED_DIRECTION_CODE, O as OPTION_IGNORED_CODE, au as CONTROL_CHARACTER_CODE, E as EMPTY_INPUT_CODE, a1 as TOO_LARGE_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, az as FOREIGN_FORMAT_CODE, N as NO_GRAPH_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, p as plural, S as SINK_OPTION_CODE, ad as formatInteger, $ as formatF32, a0 as formatF64, P as PRECISION_CODE, aM as WEIGHTS_DROPPED_CODE, aE as NONFINITE_AS_NULL_CODE, aF as OPTIONS_GAINED_CODE, ac as XML_ILLEGAL_CHAR_CODE, aL as TEXT_INFERRED_CODE, aB as INTEGRAL_F64_CODE, aI as STORAGE_CLASS_CODE, ax as EMPTY_COLUMN_DROPPED_CODE, at as COLUMN_RENAMED_LOSS_CODE, aa as ROLE_ASSUMED_CODE, aN as WEIGHT_KEY_CLASH_CODE, aA as ID_TEXT_COLLISION_CODE, A as ID_TEXT_TYPE_CODE, J as MUTUAL_AS_UNDIRECTED_CODE, aD as MUTUAL_EXPANDED_CODE, G as PARENTS_DROPPED_CODE, F as ROLE_DROPPED_CODE, aK as TEMPORAL_TEXT_DROPPED_CODE, aJ as TEMPORAL_DROPPED_CODE, as as COLUMN_DROPPED_CODE, a as agree } from "./format-BpQBx8MZ.js";
+import { ai as withArticle, C as COLUMN_RENAMED_CODE, R as ROLE_TAKEN_CODE, U as UNKNOWN_ATTR_TYPE_CODE, B as BAD_DEFAULT_CODE, ac as BAD_OPTIONS_CODE, D as DIRECTION_FORCED_CODE, b as DIRECTION_REFUSED_CODE, M as MIXED_DIRECTION_CODE, O as OPTION_IGNORED_CODE, S as SINK_OPTION_CODE, N as NO_GRAPH_CODE, W as AMBIGUOUS_GRAPH_NAME_CODE, Y as GRAPH_NOT_FOUND_CODE, p as plural, P as PRECISION_CODE, aL as WEIGHTS_DROPPED_CODE, aG as NONFINITE_AS_NULL_CODE, aH as OPTIONS_GAINED_CODE, ab as XML_ILLEGAL_CHAR_CODE, aK as TEXT_INFERRED_CODE, aE as INTEGRAL_F64_CODE, ap as STORAGE_CLASS_CODE, aD as EMPTY_COLUMN_DROPPED_CODE, aq as COLUMN_RENAMED_LOSS_CODE, a9 as ROLE_ASSUMED_CODE, ak as WEIGHT_KEY_CLASH_CODE, aj as ID_TEXT_COLLISION_CODE, A as ID_TEXT_TYPE_CODE, J as MUTUAL_AS_UNDIRECTED_CODE, al as MUTUAL_EXPANDED_CODE, G as PARENTS_DROPPED_CODE, F as ROLE_DROPPED_CODE, ar as TEMPORAL_TEXT_DROPPED_CODE, as as TEMPORAL_DROPPED_CODE, aA as COLUMN_DROPPED_CODE, a as agree } from "./report-CgdsL9Hb.js";
+import { d as canonicalEncoding } from "./input-Ccg9I22A.js";
+import { c as formatInteger, f as formatF32, a as formatF64 } from "./format-BMS-1Nxb.js";
 const TIME_TEXT_ROLE = "timeText";
 const TIME_TEXT_SUFFIX = ".text";
 const DATE_TIME$1 = /^(-?\d{4,})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?)?(Z|z|[+-]\d{2}(?::?\d{2})?)?$/;
@@ -1258,1383 +1260,6 @@ class IdCoercer {
     return coerceId(value, this.mode);
   }
 }
-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;
-  }
-}
 const ID_COERCIONS = /* @__PURE__ */ new Set(["keep", "canonical", "string", "number"]);
 const NODE_ID_SOURCES = /* @__PURE__ */ new Set(["id", "label", "index"]);
 const DUPLICATE_POLICIES = /* @__PURE__ */ new Set(["keep", "error", "first", "last", "sum", "min", "max"]);
@@ -3856,81 +2481,66 @@ function mangleNmtoken(text) {
   return out.length === 0 ? "_" : out;
 }
 export {
-  PAIR_COLUMN as $,
-  losesPrecision as A,
-  parseTimeText as B,
-  splitListText as C,
+  MUTUAL_COLUMN as $,
+  timeTextCompanion as A,
+  parseDecimalText as B,
+  sanitizeIds as C,
   DictHeuristic as D,
-  timeTextCompanion as E,
-  parseDecimalText as F,
-  sanitizeIds as G,
-  formatTimeValue as H,
+  formatTimeValue as E,
+  mapDeclaredType as F,
+  joinListText as G,
+  formatTemporal as H,
   IdCoercer as I,
-  mapDeclaredType as J,
-  joinListText as K,
+  isCanonicalIntegerText as J,
+  declareOn as K,
   LOSS as L,
-  MAX_TEXT_LENGTH as M,
-  formatTemporal as N,
-  isCanonicalIntegerText as O,
-  LineReader as P,
-  describe as Q,
+  takenIn as M,
+  parseTemporal as N,
+  canonicalId as O,
+  coerceIdText as P,
+  DICT_SAMPLE_ROWS as Q,
   RENAMED_CODE as R,
-  normalizeInput as S,
+  otherFormatDialect as S,
   TIME_TEXT_ROLE as T,
-  foreignKind as U,
-  lockReader as V,
-  abortable as W,
-  DEFAULT_ERROR_LIMIT as X,
-  DIRECTED_COLUMN as Y,
-  MUTUAL_COLUMN as Z,
-  NO_CAPABILITIES as _,
+  countMixedEdges as U,
+  reportWeightPrecision as V,
+  isNmtoken as W,
+  mangleNmtoken as X,
+  describe as Y,
+  DEFAULT_ERROR_LIMIT as Z,
+  DIRECTED_COLUMN as _,
   checkCapabilities as a,
-  UNKNOWN_TYPE_CODE as a0,
-  canonicalId as a1,
-  coerceId as a2,
-  coerceIdText as a3,
-  decodeEntryName as a4,
-  edgeWeights as a5,
-  forDecodedText as a6,
-  inputLength as a7,
-  isImportInput as a8,
-  isNmtoken as a9,
-  mangleNmtoken as aa,
-  readText as ab,
-  refusedSave as ac,
-  declareOn as ad,
-  takenIn as ae,
-  parseTemporal as af,
-  DICT_SAMPLE_ROWS as ag,
-  otherFormatDialect as ah,
-  countMixedEdges as ai,
-  canonicalEncoding as aj,
-  reportWeightPrecision as ak,
-  readBytes as al,
-  tooLarge as b,
+  NO_CAPABILITIES as a0,
+  PAIR_COLUMN as a1,
+  UNKNOWN_TYPE_CODE as a2,
+  coerceId as a3,
+  edgeWeights as a4,
+  forDecodedText as a5,
+  refusedSave as a6,
+  chooseGraph as b,
   capabilities as c,
-  declareResolved as d,
+  resolveImportOptions as d,
   explicitWeights as e,
-  chooseGraph as f,
-  resolveImportOptions as g,
-  throwIfAborted as h,
-  reportUnusedOptions as i,
-  reportSinkOptions as j,
-  graphChosen as k,
-  DirectionResolver as l,
-  TIME_TEXT_SUFFIX as m,
-  isNameChar as n,
-  isWeightField as o,
+  reportUnusedOptions as f,
+  reportSinkOptions as g,
+  graphChosen as h,
+  DirectionResolver as i,
+  declareResolved as j,
+  TIME_TEXT_SUFFIX as k,
+  isNameChar as l,
+  isWeightField as m,
+  declareAttribute as n,
+  parseWeightText as o,
   pairFolding as p,
-  declareAttribute as q,
+  overflowsToInfinity as q,
   resolveExportOptions as r,
-  parseWeightText as s,
-  textChunks as t,
+  parseDeclaredTemporal as s,
+  declareCompanion as t,
   uniqueColumnName as u,
-  overflowsToInfinity as v,
+  parseDeclaredValue as v,
   weightFromValue as w,
-  parseDeclaredTemporal as x,
-  declareCompanion as y,
-  parseDeclaredValue as z
+  losesPrecision as x,
+  parseTimeText as y,
+  splitListText as z
 };
-//# sourceMappingURL=export-BvqAXCKh.js.map
+//# sourceMappingURL=export-CZ7VRm4I.js.map