@graphty/graph-io 0.3.41 → 0.3.43

package/dist/chunks/{export-DD3Lvw-F.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));
@@ -1697,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, {
@@ -2595,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"]);
@@ -4425,4 +4529,4 @@ export {
   INVALID_ENCODING_CODE as y,
   INVALID_UTF8_CODE as z
 };
-//# sourceMappingURL=export-DD3Lvw-F.js.map
+//# sourceMappingURL=export-rKLeGQMo.js.map