@graphty/graph-io 0.2.4 → 0.3.0

package/dist/chunks/{writer-DxSKC7TL.js → writer-BdMak4_J.js}

@@ -19,6 +19,9 @@ const ID_MERGED_CODE = "W_ID_MERGED";
 const SINK_OPTION_CODE = "W_SINK_OPTION";
 const OPTION_IGNORED_CODE = "W_OPTION_IGNORED";
 const INVALID_UTF8_CODE = "E_INVALID_UTF8";
+const INVALID_ENCODING_CODE = "E_INVALID_ENCODING";
+const ENCODING_FALLBACK_CODE = "W_ENCODING_FALLBACK";
+const UNKNOWN_ENCODING_CODE = "W_UNKNOWN_ENCODING";
 const DIRECTION_REFUSED_CODE = "W_DIRECTION_REFUSED";
 const DIRECTION_FORCED_CODE = "W_DIRECTION_FORCED";
 const MIXED_DIRECTION_CODE = "E_MIXED_DIRECTION";
@@ -1277,6 +1280,189 @@ class IdCoercer {
     return coerceId(value, this.mode);
   }
 }
+const HEAD_BYTES = 1024;
+const BOM_BYTES = 3;
+function canonicalEncoding(label) {
+  try {
+    return new TextDecoder(label.trim()).encoding;
+  } catch {
+    return null;
+  }
+}
+function bomEncoding(head) {
+  if (head.byteLength >= 3 && head[0] === 239 && head[1] === 187 && head[2] === 191) {
+    return "utf-8";
+  }
+  if (head.byteLength >= 2 && head[0] === 255 && head[1] === 254) {
+    return "utf-16le";
+  }
+  if (head.byteLength >= 2 && head[0] === 254 && head[1] === 255) {
+    return "utf-16be";
+  }
+  return null;
+}
+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;
+  }
+  /**
+   * 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.
+   * @param head - the first bytes (up to HEAD_BYTES; fewer when the input is shorter)
+   */
+  start(head) {
+    const explicit = this.options.encoding ?? null;
+    if (explicit !== null) {
+      this.use(explicit, false);
+      return;
+    }
+    const bom = bomEncoding(head);
+    if (bom !== null) {
+      this.use(bom, false);
+      return;
+    }
+    const declared = this.options.declaredEncoding?.(new TextDecoder("windows-1252").decode(head)) ?? null;
+    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 !== "utf-8" && !canonical.startsWith("utf-16")) {
+        this.use(canonical, false);
+        return;
+      }
+    }
+    this.use("utf-8", true);
+  }
+  /**
+   * Decode the next bytes.
+   * @param bytes - the bytes
+   * @param stream - whether more bytes follow
+   * @returns the text
+   */
+  decode(bytes, stream) {
+    const decoder = this.decoder;
+    let text;
+    try {
+      text = decoder.decode(bytes, { stream });
+    } catch (err) {
+      if (!(err instanceof TypeError)) {
+        throw err;
+      }
+      text = this.recover(bytes, stream);
+    }
+    if (this.asciiSoFar && this.mayFallBack) {
+      if (/[\u0080-\uffff]/.test(text)) {
+        this.asciiSoFar = false;
+        this.carry = new Uint8Array(0);
+      } else {
+        const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
+        this.carry = all.slice(text.length);
+      }
+    }
+    this.offset += bytes.byteLength;
+    return text;
+  }
+  /**
+   * A decode failed: switch to windows-1252 when allowed, else fail the import.
+   * @param bytes - the bytes that failed
+   * @param stream - whether more bytes follow
+   * @returns the bytes decoded as windows-1252
+   */
+  recover(bytes, stream) {
+    const where = { byteOffset: this.offset };
+    const all = this.carry.byteLength === 0 ? bytes : concatBytes([this.carry, bytes]);
+    if (this.mayFallBack && this.asciiSoFar && !all.includes(0) && !startsWithUtf8(all)) {
+      this.report.warning(
+        "coercion",
+        ENCODING_FALLBACK_CODE,
+        `the input is not valid UTF-8 (near byte ${this.offset}) and declares no encoding; read as windows-1252 (pass the encoding option to choose another)`
+      );
+      this.use("windows-1252", false);
+      return this.decoder.decode(all, { 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 near byte ${this.offset}${after}`,
+        void 0,
+        where
+      );
+    }
+    return this.report.fail(
+      INVALID_ENCODING_CODE,
+      `the bytes near byte ${this.offset} are not valid ${this.encoding}`,
+      void 0,
+      where
+    );
+  }
+  /**
+   * 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 startsWithUtf8(bytes) {
+  const i = bytes.findIndex((b) => b >= 128);
+  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 (i < 0 || length === 0 || i + length > bytes.byteLength) {
+    return false;
+  }
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(i, i + length));
+    return true;
+  } catch {
+    return false;
+  }
+}
+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);
 function isImportInput(input) {
@@ -1339,22 +1525,13 @@ async function* textChunks(input, report, options = {}) {
     onProgress?.(done, total ?? void 0);
     return;
   }
-  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-  const decode = (bytes, stream) => {
-    try {
-      return decoder.decode(bytes, { stream });
-    } catch (err) {
-      if (err instanceof TypeError) {
-        report.fail(INVALID_UTF8_CODE, `invalid UTF-8 near byte ${done}`, void 0, { byteOffset: done });
-      }
-      throw err;
-    }
-  };
+  const decoder = new ByteDecoder(report, options);
   if (input instanceof Uint8Array) {
+    decoder.start(input.subarray(0, HEAD_BYTES));
     for (let offset = 0; offset < input.byteLength; offset += DECODE_SLICE) {
       throwIfAborted(signal);
       const slice = input.subarray(offset, Math.min(offset + DECODE_SLICE, input.byteLength));
-      const text = emit(decode(slice, offset + DECODE_SLICE < input.byteLength));
+      const text = emit(decoder.decode(slice, offset + DECODE_SLICE < input.byteLength));
       done = Math.min(offset + DECODE_SLICE, input.byteLength);
       if (text.length > 0) {
         yield text;
@@ -1366,17 +1543,38 @@ async function* textChunks(input, report, options = {}) {
     }
     return;
   }
+  const needed = options.declaredEncoding === void 0 ? BOM_BYTES : HEAD_BYTES;
+  let head = [];
+  let headLength = 0;
+  const flushHead = (stream) => {
+    const bytes = concatBytes(head);
+    head = [];
+    headLength = 0;
+    decoder.start(bytes.subarray(0, HEAD_BYTES));
+    return decoder.decode(bytes, stream);
+  };
   const chunks = isReadableStream(input) ? streamChunks(input, signal) : input;
   for await (const chunk of chunks) {
     throwIfAborted(signal);
     let text;
     if (typeof chunk === "string") {
-      const pending = decode(new Uint8Array(0), false);
+      let pending = "";
+      if (!decoder.started && headLength > 0) {
+        pending = flushHead(false);
+      } else if (decoder.started) {
+        pending = decoder.decode(new Uint8Array(0), false);
+      }
       text = emit(pending + chunk);
       done += chunk.length;
     } else if (chunk instanceof Uint8Array) {
-      text = emit(decode(chunk, true));
       done += chunk.byteLength;
+      if (decoder.started) {
+        text = emit(decoder.decode(chunk, true));
+      } else {
+        head.push(chunk);
+        headLength += chunk.byteLength;
+        text = headLength >= needed ? emit(flushHead(true)) : "";
+      }
     } else {
       throw new GraphFormatError("E_UNSUPPORTED", "an input chunk must be a string or a Uint8Array", {
         reason: "chunk type",
@@ -1388,7 +1586,13 @@ async function* textChunks(input, report, options = {}) {
     }
     onProgress?.(done);
   }
-  const tail = emit(decode(new Uint8Array(0), false));
+  let tail = "";
+  if (!decoder.started && headLength > 0) {
+    tail = flushHead(false);
+  } else if (decoder.started) {
+    tail = decoder.decode(new Uint8Array(0), false);
+  }
+  tail = emit(tail);
   if (tail.length > 0) {
     yield tail;
   }
@@ -1605,7 +1809,8 @@ function resolveImportOptions(options, defaults) {
     hyperedges: enumOption("hyperedges", o.hyperedges, "skip", HYPEREDGE_POLICIES),
     errorLimit: errorLimitOption(o.errorLimit),
     signal: signalOption(o.signal),
-    onProgress: progressOption(o.onProgress)
+    onProgress: progressOption(o.onProgress),
+    encoding: encodingOption(o.encoding)
   });
 }
 function resolveExportOptions(options) {
@@ -1694,6 +1899,20 @@ function progressOption(value) {
     found: typeof value
   });
 }
+function encodingOption(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  const canonical = typeof value === "string" ? canonicalEncoding(value) : null;
+  if (canonical === null) {
+    throw new GraphFormatError(
+      "E_UNSUPPORTED",
+      `option encoding: ${describe(value)} is not an encoding this platform's TextDecoder knows`,
+      { option: "encoding", found: value }
+    );
+  }
+  return canonical;
+}
 function describe(value) {
   switch (typeof value) {
     case "string":
@@ -1934,7 +2153,7 @@ function formatF32(value) {
     return String(value);
   }
   if (value === 0) {
-    return "0";
+    return Object.is(value, -0) ? "-0" : "0";
   }
   for (let digits = 1; digits <= 9; digits++) {
     const text = value.toPrecision(digits);
@@ -1945,7 +2164,7 @@ function formatF32(value) {
   return String(value);
 }
 function formatF64(value) {
-  return String(value);
+  return Object.is(value, -0) ? "-0" : String(value);
 }
 function formatDecimal(value, dtype = "f64") {
   if (!Number.isFinite(value)) {
@@ -2032,6 +2251,7 @@ function invalidWeight(value, cause) {
     cause: cause instanceof Error ? cause.message : null
   });
 }
+const NEGATIVE_ZERO_TEXT = "-0";
 const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
 function weightFormatter(dtype) {
   switch (dtype) {
@@ -2059,6 +2279,9 @@ function explicitWeights(snapshot) {
           return null;
         }
         const value = shadow.value(e);
+        if (Object.is(value, -0)) {
+          return NEGATIVE_ZERO_TEXT;
+        }
         return integral && Number.isInteger(value) ? formatInteger(value) : format(value);
       }
     };
@@ -2080,6 +2303,9 @@ function explicitWeights(snapshot) {
     value: (e) => weights[e],
     text: (e, integral = false) => {
       const value = weights[e];
+      if (Object.is(value, -0)) {
+        return NEGATIVE_ZERO_TEXT;
+      }
       return integral && Number.isInteger(value) ? formatInteger(value) : formatF32(value);
     }
   };
@@ -2721,99 +2947,102 @@ function toReadableStream(chunks) {
   });
 }
 export {
-  TEMPORAL_TEXT_DROPPED_CODE as $,
-  MUTUAL_COLUMN as A,
+  SYNTAX_CODE as $,
+  MULTIPLE_GRAPHS_CODE as A,
   BAD_DEFAULT_CODE as B,
   COLUMN_RENAMED_CODE as C,
   DEFAULT_CHUNK_BYTES as D,
   EMPTY_COLUMN_DROPPED_CODE as E,
-  MUTUAL_EXPANDED_CODE as F,
-  NO_GRAPH_CODE as G,
+  MUTUAL_AS_UNDIRECTED_CODE as F,
+  MUTUAL_COLUMN as G,
   HYPEREDGE_CODE as H,
   ImportReportBuilder as I,
-  OPTION_IGNORED_CODE as J,
-  PARENTS_DROPPED_CODE as K,
+  MUTUAL_EXPANDED_CODE as J,
+  NO_GRAPH_CODE as K,
   LOSS as L,
   MISSING_ENDPOINT_CODE as M,
   NO_CAPABILITIES as N,
   OPTIONS_GAINED_CODE as O,
-  PAIR_COLUMN as P,
-  PARSE_ERROR_CODE as Q,
-  PRECISION_CODE as R,
-  RENAMED_CODE as S,
-  ROLE_ASSUMED_CODE as T,
-  ROLE_DROPPED_CODE as U,
-  ROLE_TAKEN_CODE as V,
-  SINK_OPTION_CODE as W,
-  STORAGE_CLASS_CODE as X,
-  STRAY_TEXT_CODE as Y,
-  SYNTAX_CODE as Z,
-  TEMPORAL_DROPPED_CODE as _,
+  OPTION_IGNORED_CODE as P,
+  PAIR_COLUMN as Q,
+  PARENTS_DROPPED_CODE as R,
+  PARSE_ERROR_CODE as S,
+  PRECISION_CODE as T,
+  RENAMED_CODE as U,
+  ROLE_ASSUMED_CODE as V,
+  ROLE_DROPPED_CODE as W,
+  ROLE_TAKEN_CODE as X,
+  SINK_OPTION_CODE as Y,
+  STORAGE_CLASS_CODE as Z,
+  STRAY_TEXT_CODE as _,
   throwIfAborted as a,
-  TEXT_INFERRED_CODE as a0,
-  UNKNOWN_ATTR_TYPE_CODE as a1,
-  UNKNOWN_ELEMENT_CODE as a2,
-  UNKNOWN_PARENT_CODE as a3,
-  UNKNOWN_TYPE_CODE as a4,
-  WEIGHT_KEY_CLASH_CODE as a5,
-  XML_ILLEGAL_CHAR_CODE as a6,
-  XML_SYNTAX_CODE as a7,
-  canonicalId as a8,
-  capabilities as a9,
-  reportUnusedOptions as aA,
-  resolveExportOptions as aB,
-  resolveImportOptions as aC,
-  sanitizeIds as aD,
-  toReadableStream as aE,
-  isNameChar as aF,
-  countMixedEdges as aG,
-  weightFromValue as aH,
-  uniqueColumnName as aI,
-  TIME_TEXT_ROLE as aJ,
-  TIME_TEXT_SUFFIX as aK,
-  declareAttribute as aL,
-  parseDeclaredTemporal as aM,
-  parseDeclaredValue as aN,
-  losesPrecision as aO,
-  parseTimeText as aP,
-  splitListText as aQ,
-  timeTextCompanion as aR,
-  parseDecimalText as aS,
-  formatTimeValue as aT,
-  mapDeclaredType as aU,
-  joinListText as aV,
-  formatTemporal as aW,
-  DictHeuristic as aX,
-  DICT_SAMPLE_ROWS as aY,
-  takenIn as aZ,
-  declareOn as a_,
-  checkCapabilities as aa,
-  coerceId as ab,
-  coerceIdText as ac,
-  collectBytes as ad,
-  declareCompanion as ae,
-  declareResolved as af,
-  decodeChunks as ag,
-  encodeChunks as ah,
-  explicitWeights as ai,
-  formatDecimal as aj,
-  formatF32 as ak,
-  formatF64 as al,
-  formatGmlReal as am,
-  formatInteger as an,
-  inputLength as ao,
-  isAbortError as ap,
-  isCanonicalIntegerText as aq,
-  isImportInput as ar,
-  isNmtoken as as,
-  isWeightField as at,
-  joinText as au,
-  mangleNmtoken as av,
-  pairFolding as aw,
-  parseWeightText as ax,
-  readText as ay,
-  reportSinkOptions as az,
+  DICT_SAMPLE_ROWS as a$,
+  TEMPORAL_DROPPED_CODE as a0,
+  TEMPORAL_TEXT_DROPPED_CODE as a1,
+  TEXT_INFERRED_CODE as a2,
+  UNKNOWN_ATTR_TYPE_CODE as a3,
+  UNKNOWN_ELEMENT_CODE as a4,
+  UNKNOWN_ENCODING_CODE as a5,
+  UNKNOWN_PARENT_CODE as a6,
+  UNKNOWN_TYPE_CODE as a7,
+  WEIGHT_KEY_CLASH_CODE as a8,
+  XML_ILLEGAL_CHAR_CODE as a9,
+  parseWeightText as aA,
+  readText as aB,
+  reportSinkOptions as aC,
+  reportUnusedOptions as aD,
+  resolveExportOptions as aE,
+  resolveImportOptions as aF,
+  sanitizeIds as aG,
+  toReadableStream as aH,
+  isNameChar as aI,
+  countMixedEdges as aJ,
+  weightFromValue as aK,
+  uniqueColumnName as aL,
+  TIME_TEXT_ROLE as aM,
+  TIME_TEXT_SUFFIX as aN,
+  declareAttribute as aO,
+  parseDeclaredTemporal as aP,
+  parseDeclaredValue as aQ,
+  losesPrecision as aR,
+  parseTimeText as aS,
+  splitListText as aT,
+  timeTextCompanion as aU,
+  parseDecimalText as aV,
+  formatTimeValue as aW,
+  mapDeclaredType as aX,
+  joinListText as aY,
+  formatTemporal as aZ,
+  DictHeuristic as a_,
+  XML_SYNTAX_CODE as aa,
+  canonicalId as ab,
+  capabilities as ac,
+  checkCapabilities as ad,
+  coerceId as ae,
+  coerceIdText as af,
+  collectBytes as ag,
+  declareCompanion as ah,
+  declareResolved as ai,
+  decodeChunks as aj,
+  encodeChunks as ak,
+  explicitWeights as al,
+  formatDecimal as am,
+  formatF32 as an,
+  formatF64 as ao,
+  formatGmlReal as ap,
+  formatInteger as aq,
+  inputLength as ar,
+  isAbortError as as,
+  isCanonicalIntegerText as at,
+  isImportInput as au,
+  isNmtoken as av,
+  isWeightField as aw,
+  joinText as ax,
+  mangleNmtoken as ay,
+  pairFolding as az,
   BAD_OPTIONS_CODE as b,
+  takenIn as b0,
+  declareOn as b1,
   COLUMN_RENAMED_LOSS_CODE as c,
   COUNT_HINT_CODE as d,
   DEFAULT_ERROR_LIMIT as e,
@@ -2825,18 +3054,18 @@ export {
   DUPLICATE_NODE_CODE as k,
   DirectionResolver as l,
   EMPTY_INPUT_CODE as m,
-  ID_MERGED_CODE as n,
-  ID_TEXT_COLLISION_CODE as o,
-  ID_TEXT_TYPE_CODE as p,
-  INTEGRAL_F64_CODE as q,
-  INVALID_UTF8_CODE as r,
-  IdCoercer as s,
+  ENCODING_FALLBACK_CODE as n,
+  ID_MERGED_CODE as o,
+  ID_TEXT_COLLISION_CODE as p,
+  ID_TEXT_TYPE_CODE as q,
+  INTEGRAL_F64_CODE as r,
+  INVALID_ENCODING_CODE as s,
   textChunks as t,
-  ImportError as u,
-  LineReader as v,
-  MISSING_ID_CODE as w,
-  MIXED_DIRECTION_CODE as x,
-  MULTIPLE_GRAPHS_CODE as y,
-  MUTUAL_AS_UNDIRECTED_CODE as z
+  INVALID_UTF8_CODE as u,
+  IdCoercer as v,
+  ImportError as w,
+  LineReader as x,
+  MISSING_ID_CODE as y,
+  MIXED_DIRECTION_CODE as z
 };
-//# sourceMappingURL=writer-DxSKC7TL.js.map
+//# sourceMappingURL=writer-BdMak4_J.js.map