@graphty/graph-io 0.3.40 → 0.3.42

package/dist/chunks/{export-B-aVCwyG.js → export-rKLeGQMo.js}

@@ -638,21 +638,9 @@ function splitBracketed(text) {
     }
     let item = "";
     if (i < n && (inner[i] === '"' || inner[i] === "'")) {
-      const quote = inner[i];
-      i++;
-      while (i < n) {
-        if (inner[i] === quote) {
-          if (inner[i + 1] === quote) {
-            item += quote;
-            i += 2;
-            continue;
-          }
-          i++;
-          break;
-        }
-        item += inner[i];
-        i++;
-      }
+      const quoted = readQuoted(inner, i);
+      item = quoted.text;
+      i = quoted.end;
     }
     let end = inner.indexOf(",", i);
     if (end < 0) {
@@ -671,6 +659,24 @@ function splitBracketed(text) {
     }
   }
 }
+function readQuoted(inner, open) {
+  const quote = inner[open];
+  const n = inner.length;
+  let text = "";
+  let i = open + 1;
+  while (i < n) {
+    if (inner[i] !== quote) {
+      text += inner[i];
+      i++;
+    } else if (inner[i + 1] === quote) {
+      text += quote;
+      i += 2;
+    } else {
+      return { text, end: i + 1 };
+    }
+  }
+  return { text, end: i };
+}
 function isSpace(c) {
   return c === 32 || c === 9 || c === 13 || c === 10;
 }
@@ -686,22 +692,7 @@ const DICT_SAMPLE_ROWS = 1024;
 function declareAttribute(input) {
   const issues = [];
   const listSyntax = input.listSyntax ?? "gexf";
-  let spec;
-  if (input.type === null) {
-    spec = stringSpec(null);
-  } else {
-    const mapped = mapDeclaredType(input.format, input.type, input.long);
-    if (mapped === null) {
-      spec = stringSpec(input.type);
-      issues.push({
-        category: "unsupported",
-        code: UNKNOWN_TYPE_CODE,
-        message: `${input.format} type "${input.type}" is not supported; values kept as text`
-      });
-    } else {
-      spec = mapped;
-    }
-  }
+  let spec = declaredSpec(input, issues);
   const { name, renamed } = resolveName(input);
   if (renamed) {
     issues.push({
@@ -733,20 +724,7 @@ function declareAttribute(input) {
   }
   const optionsText = input.optionsText ?? null;
   if (optionsText !== null) {
-    try {
-      const options = splitListText(optionsText, listSyntax).map((item) => parseItem(item, spec));
-      decl.options = options;
-      if (spec.dtype === "string" && !spec.list && options.every((o) => typeof o === "string")) {
-        decl.dtype = "dict";
-        spec = { ...spec, dtype: "dict" };
-      }
-    } catch (err) {
-      issues.push({
-        category: "validation-error",
-        code: BAD_OPTIONS_CODE,
-        message: `options "${optionsText}" of attribute "${name}" do not parse as ${spec.declared}: ${messageOf$1(err)}`
-      });
-    }
+    spec = declareOptions(decl, spec, optionsText, listSyntax, issues);
   }
   const defaultText = input.defaultText ?? null;
   if (defaultText !== null) {
@@ -763,6 +741,38 @@ function declareAttribute(input) {
   const companion = spec.temporal !== null && !spec.list ? timeTextCompanion(name) : null;
   return { decl, spec, listSyntax, companion, renamed, issues };
 }
+function declaredSpec(input, issues) {
+  if (input.type === null) {
+    return stringSpec(null);
+  }
+  const mapped = mapDeclaredType(input.format, input.type, input.long);
+  if (mapped !== null) {
+    return mapped;
+  }
+  issues.push({
+    category: "unsupported",
+    code: UNKNOWN_TYPE_CODE,
+    message: `${input.format} type "${input.type}" is not supported; values kept as text`
+  });
+  return stringSpec(input.type);
+}
+function declareOptions(decl, spec, optionsText, listSyntax, issues) {
+  try {
+    const options = splitListText(optionsText, listSyntax).map((item) => parseItem(item, spec));
+    decl.options = options;
+    if (spec.dtype === "string" && !spec.list && options.every((o) => typeof o === "string")) {
+      decl.dtype = "dict";
+      return { ...spec, dtype: "dict" };
+    }
+  } catch (err) {
+    issues.push({
+      category: "validation-error",
+      code: BAD_OPTIONS_CODE,
+      message: `options "${optionsText}" of attribute "${decl.name}" do not parse as ${spec.declared}: ${messageOf$1(err)}`
+    });
+  }
+  return spec;
+}
 function parseDeclaredValue(text, spec, listSyntax) {
   if (spec.list) {
     return splitListText(text, listSyntax).map((item) => parseItem(item, spec));
@@ -804,29 +814,12 @@ function declareResolved(sink, domain, decl, report, where) {
         throw err;
       }
       if (err.code === "E_COLUMN_EXISTS" && !renamed) {
-        const taken = takenIn(sink, domain);
-        const id = current.origin?.id ?? null;
-        const name = uniqueColumnName(current.name, id, taken);
-        report.warning(
-          "coercion",
-          COLUMN_RENAMED_CODE,
-          `${domain} column "${current.name}" renamed to "${name}": the sink already holds that name with another shape`,
-          { ...where, element: where?.element ?? current.name }
-        );
-        current = { ...current, name };
+        current = renameColumn(sink, domain, current, report, where);
         renamed = true;
         continue;
       }
       if (err.code === "E_DUPLICATE_ROLE" && current.role !== void 0 && !roleDropped) {
-        const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
-        report.warning(
-          "coercion",
-          ROLE_TAKEN_CODE,
-          `${domain} column "${current.name}" loses the ${current.role} role: "${holder}" already holds it`,
-          { ...where, element: where?.element ?? current.name }
-        );
-        const { role: _role, ...withoutRole } = current;
-        current = withoutRole;
+        current = dropRole(err, domain, current, current.role, report, where);
         roleDropped = true;
         continue;
       }
@@ -834,6 +827,29 @@ function declareResolved(sink, domain, decl, report, where) {
     }
   }
 }
+function renameColumn(sink, domain, decl, report, where) {
+  const taken = takenIn(sink, domain);
+  const id = decl.origin?.id ?? null;
+  const name = uniqueColumnName(decl.name, id, taken);
+  report.warning(
+    "coercion",
+    COLUMN_RENAMED_CODE,
+    `${domain} column "${decl.name}" renamed to "${name}": the sink already holds that name with another shape`,
+    { ...where, element: where?.element ?? decl.name }
+  );
+  return { ...decl, name };
+}
+function dropRole(err, domain, decl, role, report, where) {
+  const holder = typeof err.details.holder === "string" ? err.details.holder : "another column";
+  report.warning(
+    "coercion",
+    ROLE_TAKEN_CODE,
+    `${domain} column "${decl.name}" loses the ${role} role: "${holder}" already holds it`,
+    { ...where, element: where?.element ?? decl.name }
+  );
+  const { role: _role, ...withoutRole } = decl;
+  return withoutRole;
+}
 function declareCompanion(sink, domain, companion, report) {
   try {
     return declareOn(sink, domain, companion);
@@ -1691,39 +1707,68 @@ class ByteDecoder {
     const bad = this.encoding === "utf-8" ? invalidUtf8(all) : null;
     const at = base + (bad === null ? 0 : bad.index);
     if (this.mayFallBack && this.asciiSoFar) {
-      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)) {
-        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 });
+      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, {
@@ -2300,124 +2345,175 @@ function reportTextEncoding(report, encoding) {
 async function* textChunks(rawInput, report, options = {}) {
   const input = normalizeInput(rawInput);
   const signal = options.signal ?? null;
-  const onProgress = options.onProgress ?? null;
   const filter = new TextFilter(report, options);
   throwIfAborted(signal);
   if (typeof input === "string") {
     reportTextEncoding(report, options.encoding);
-    const total = onProgress === null ? 0 : utf8Length(input);
-    let done2 = 0;
-    let start = 0;
-    while (start < input.length) {
-      throwIfAborted(signal);
-      let end = Math.min(start + DECODE_SLICE, input.length);
-      const highSurrogate = (input.charCodeAt(end - 1) & 64512) === 55296;
-      if (end < input.length && highSurrogate) {
-        end++;
-      }
-      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) {
-        done2 += utf8Length(piece);
-        onProgress(done2, total);
-      }
-    }
-    if (input.length === 0) {
-      onProgress?.(0, 0);
-    }
-    filter.end();
+    yield* stringTextChunks(input, filter, options);
     return;
   }
   const decoder = new ByteDecoder(report, options);
-  const headBytes = Math.max(options.declarationBytes ?? HEAD_BYTES, BOM_BYTES);
   if (input instanceof Uint8Array) {
-    const length = input.byteLength;
-    decoder.start(input.subarray(0, headBytes));
-    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;
-      }
-      onProgress?.(Math.min(offset + DECODE_SLICE, length), length);
-    }
-    if (length === 0) {
-      onProgress?.(0, 0);
-    }
-    filter.end();
+    yield* byteTextChunks(input, filter, decoder, options);
     return;
   }
-  const needed = options.declaredEncoding === void 0 ? BOM_BYTES : headBytes;
+  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 head = [];
-  let headLength = 0;
-  const flushHead = (stream) => {
-    const bytes = concatBytes(head);
-    head = [];
-    headLength = 0;
-    decoder.start(bytes.subarray(0, headBytes));
-    return decoder.decode(bytes, stream);
-  };
-  const chunks = isReadableStream(input) ? streamChunks(input, signal) : input;
-  for await (const chunk of chunks) {
+  let start = 0;
+  while (start < input.length) {
     throwIfAborted(signal);
-    let text;
-    const bytes = typeof chunk === "string" ? null : asBytes(chunk);
+    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") {
-      let pending = "";
-      if (headLength > 0) {
-        pending = decoder.flushBeforeText(() => flushHead(false));
-      } else if (decoder.started) {
-        pending = decoder.flushBeforeText(() => decoder.decode(new Uint8Array(0), false));
-      } else {
-        decoder.start(new Uint8Array(0));
-      }
-      text = filter.push(pending + chunk);
-      done += onProgress === null ? 0 : utf8Length(chunk);
-    } else if (bytes !== null) {
-      done += bytes.byteLength;
-      if (decoder.started) {
-        text = filter.push(decoder.decode(bytes, true));
-      } else {
-        head.push(bytes);
-        headLength += bytes.byteLength;
-        text = headLength >= needed ? filter.push(flushHead(true)) : "";
-      }
-    } else {
+      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
       });
     }
-    if (text.length > 0) {
-      yield text;
+    this.done += bytes.byteLength;
+    if (this.decoder.started) {
+      return this.filter.push(this.decoder.decode(bytes, true));
     }
-    onProgress?.(done);
+    this.head.push(bytes);
+    this.headLength += bytes.byteLength;
+    return this.headLength >= this.needed ? this.filter.push(this.flushHead(true)) : "";
   }
-  let tail = "";
-  if (headLength > 0) {
-    tail = flushHead(false);
-  } else if (decoder.started) {
-    tail = decoder.decode(new Uint8Array(0), false);
+  /**
+   * 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);
   }
-  tail = filter.push(tail);
-  if (tail.length > 0) {
-    yield 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 "";
   }
-  filter.end();
-  onProgress?.(done, done);
 }
 function isReadableStream(input) {
   return typeof input.getReader === "function";
@@ -2538,76 +2634,141 @@ class LineReader {
    * @returns nothing
    */
   async *[Symbol.asyncIterator]() {
-    const pending = [];
-    let pendingLength = 0;
+    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;
-      const end = chunk.length;
       if (trailingCr) {
         trailingCr = false;
         this.lineNumber++;
-        const joined = pending.join("");
-        pending.length = 0;
-        pendingLength = 0;
-        yield joined.slice(0, -1);
+        yield pending.take().slice(0, -1);
         if (chunk.charCodeAt(0) === 10) {
           start = 1;
         }
       }
-      let nl = chunk.indexOf("\n", start);
-      let cr = chunk.indexOf("\r", start);
-      while (nl >= 0 || cr >= 0) {
-        let cut;
-        let next;
-        if (cr >= 0 && (nl < 0 || cr < nl)) {
-          if (cr === end - 1) {
-            break;
-          }
-          cut = cr;
-          next = chunk.charCodeAt(cr + 1) === 10 ? cr + 2 : cr + 1;
-        } else {
-          cut = nl;
-          next = nl + 1;
-        }
+      const breaks = new LineBreaks(chunk, start);
+      while (breaks.advance()) {
         this.lineNumber++;
-        const piece = chunk.slice(start, cut);
-        if (pending.length === 0) {
-          yield piece;
-        } else {
-          if (pendingLength + piece.length > MAX_TEXT_LENGTH) {
-            tooLarge(this.report, this.lineTooLong(), this.lineNumber);
-          }
-          pending.push(piece);
-          const joined = pending.join("");
-          pending.length = 0;
-          pendingLength = 0;
-          yield joined;
-        }
-        start = next;
-        if (nl >= 0 && nl < next) {
-          nl = chunk.indexOf("\n", next);
-        }
-        if (cr >= 0 && cr < next) {
-          cr = chunk.indexOf("\r", next);
-        }
+        yield pending.finish(chunk.slice(start, breaks.cut), this.lineNumber);
+        start = breaks.next;
       }
-      if (start < end) {
-        pendingLength += end - start;
-        if (pendingLength > MAX_TEXT_LENGTH) {
-          tooLarge(this.report, this.lineTooLong(), this.lineNumber + 1);
-        }
-        pending.push(start === 0 ? chunk : chunk.slice(start));
-        trailingCr = chunk.charCodeAt(end - 1) === 13;
+      if (start < chunk.length) {
+        pending.appendRest(chunk, start, this.lineNumber + 1);
+        trailingCr = chunk.codePointAt(chunk.length - 1) === 13;
       }
     }
-    if (pending.length > 0) {
+    if (!pending.empty) {
       this.lineNumber++;
-      const joined = pending.join("");
+      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"]);
@@ -4368,4 +4529,4 @@ export {
   INVALID_ENCODING_CODE as y,
   INVALID_UTF8_CODE as z
 };
-//# sourceMappingURL=export-B-aVCwyG.js.map
+//# sourceMappingURL=export-rKLeGQMo.js.map