@graphty/graph-io 0.3.25 → 0.3.27

package/dist/chunks/{importer-vi3bSdtw.js → importer-BVRE--Un.js}

@@ -1,32 +1,277 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { T as TOO_LARGE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, Y as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, P as PRECISION_CODE, b as ID_TEXT_TYPE_CODE, c as DUPLICATE_EDGE_ID_CODE, d as DUPLICATE_NODE_CODE, e as MISSING_ENDPOINT_CODE, f as MISSING_ID_CODE, i as DUPLICATE_ATTRIBUTE_CODE, j as DANGLING_REFERENCE_CODE, k as UNKNOWN_ATTR_TYPE_CODE, Z as BAD_DEFAULT_CODE, B as BAD_VALUE_CODE, l as COUNT_MISMATCH_CODE, m as ASPECT_ORDER_CODE, n as BAD_ASPECT_BLOCK_CODE, g as STYLES_NOT_IMPORTED_CODE, o as STATUS_WARNING_CODE, p as STATUS_FAILED_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE, t as SYNTAX_CODE, u as EMPTY_INPUT_CODE, v as resolveImportOptions, w as ImportReportBuilder, F as reportSinkOptions, z as reportUnusedOptions, y as throwIfAborted, x as textChunks, J as DirectionResolver, K as IdCoercer, L as declareResolved, Q as uniqueColumnName } from "./report-B1z4WT9e.js";
-import { s as scanAspects, r as reportTooDeep, C as CxStructure, i as isRecord, J as JsonScanError, p as plainJson, c as cxId, z as zDecl, a as positionDecl, f as flipY, d as declareFresh, E as ExactInteger, b as inexactLiteral } from "./json-elements-DDS8N2Dd.js";
-import { w as weightFromValue } from "./weights-Dzba96G3.js";
+import { b as plural, $ as agree, L as LOSS, ad as TOO_LARGE_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, g as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, P as PRECISION_CODE, J as ID_TEXT_TYPE_CODE, m as DUPLICATE_EDGE_ID_CODE, n as DUPLICATE_NODE_CODE, s as MISSING_ENDPOINT_CODE, t as MISSING_ID_CODE, o as DUPLICATE_ATTRIBUTE_CODE, i as DANGLING_REFERENCE_CODE, U as UNKNOWN_ATTR_TYPE_CODE, B as BAD_DEFAULT_CODE, a3 as BAD_VALUE_CODE, j as COUNT_MISMATCH_CODE, Y as ASPECT_ORDER_CODE, V as BAD_ASPECT_BLOCK_CODE, ah as STYLES_NOT_IMPORTED_CODE, a2 as JSON_NONSTANDARD_NUMBER_CODE, W as MULTI_ASPECT_FRAGMENT_CODE, ag as SINGLE_OBJECT_ASPECT_CODE, _ as STATUS_WARNING_CODE, Z as STATUS_FAILED_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, ak as SYNTAX_CODE, E as EMPTY_INPUT_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, am as throwIfAborted, a4 as textChunks, aq as DirectionResolver, ar as IdCoercer, a1 as declareResolved, a0 as uniqueColumnName, as as weightFromValue } from "./export-CHd4tQE2.js";
+import { h as headText, s as scanAspects, r as reportTooDeep, C as CxStructure, a as reportSharedBlock, J as JsonScanError, i as isRecord, j as setOwn, p as plainJson, c as cxId, f as fitsF32, z as zDecl, d as positionDecl, b as flipY, e as declareFresh, E as ExactInteger, g as inexactLiteral, k as keptPrecision } from "./json-elements-BAmNBZok.js";
+const RAW = `${String.fromCodePoint(0)}cx:`;
+const RAW_JSON = /"\\u0000cx:(-?\d+)"/g;
+const BIG_INTEGER_TEXT = /^-?[1-9]\d{15,}$/;
+function writableId(id) {
+  return typeof id === "number" ? Number.isSafeInteger(id) : BIG_INTEGER_TEXT.test(id) && !Number.isSafeInteger(Number(id));
+}
+function writtenIds(snapshot, mode, format) {
+  const { ids } = snapshot;
+  const bad = [];
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ids.size; i++) {
+    const id = ids.idOf(i);
+    if (!writableId(id)) {
+      bad.push(i);
+    } else if (typeof id === "number") {
+      used.add(id);
+    }
+  }
+  if (bad.length > 0 && mode === "error") {
+    const first = ids.idOf(bad[0]);
+    throw new GraphFormatError(
+      "E_INVALID_ID",
+      `${bad.length} node id${plural(bad.length)} cannot be written as ${format} integers (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
+      { reason: "charset", charset: "integer", count: bad.length, index: bad[0] }
+    );
+  }
+  const renumbered = /* @__PURE__ */ new Map();
+  let next = 0;
+  for (const i of bad) {
+    while (used.has(next)) {
+      next++;
+    }
+    used.add(next);
+    renumbered.set(i, next);
+  }
+  return {
+    changed: bad.length,
+    idAt: (i) => {
+      const id = renumbered.get(i) ?? ids.idOf(i);
+      return typeof id === "string" ? `${RAW}${id}` : id;
+    },
+    isChanged: (i) => renumbered.has(i),
+    originalAt: (i) => ids.idOf(i)
+  };
+}
+function nextNodeId(ids, count) {
+  let max = -1n;
+  for (let i = 0; i < count; i++) {
+    const id = ids.idAt(i);
+    const value = typeof id === "number" ? BigInt(id) : BigInt(id.slice(RAW.length));
+    if (value > max) {
+      max = value;
+    }
+  }
+  const next = max + 1n;
+  return next <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(next) : `${RAW}${next.toString()}`;
+}
+function unwritableIds(snapshot) {
+  let count = 0;
+  for (let i = 0; i < snapshot.ids.size; i++) {
+    if (!writableId(snapshot.ids.idOf(i))) {
+      count++;
+    }
+  }
+  return count;
+}
+function planNodeIds(snapshot, common, format, attribute, note) {
+  const unwritable = unwritableIds(snapshot);
+  if (unwritable > 0) {
+    note(
+      common.sanitizeIds === "mangle" ? LOSS.ID_MANGLED : LOSS.ID_CHARSET,
+      common.sanitizeIds === "mangle" ? `${unwritable} node id${plural(unwritable)} ${agree(unwritable, "is", "are")} not integers, so they are renumbered; the original ids are written to the ${attribute} attribute, and an import with restoreMangledIds: true reads them back` : `${unwritable} node id${plural(unwritable)} ${agree(unwritable, "is", "are")} not integers, so the save fails unless sanitizeIds is "mangle"`,
+      null,
+      unwritable
+    );
+  }
+  try {
+    return writtenIds(snapshot, common.sanitizeIds, format);
+  } catch (err) {
+    if (err instanceof GraphFormatError) {
+      return err;
+    }
+    throw err;
+  }
+}
+function scalarType(dtype, longOrigin) {
+  switch (dtype) {
+    case "f64":
+      return longOrigin ? "long" : "double";
+    case "f32":
+      return "double";
+    case "i32":
+    case "u8":
+      return "integer";
+    case "u32":
+      return "long";
+    case "bool":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function allIntegral(column) {
+  for (let i = 0; i < column.length; i++) {
+    if (column.isSet(i) && !Number.isSafeInteger(column.value(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+function declaredType(column) {
+  const { meta } = column;
+  const origin = meta.origin?.type ?? null;
+  const longOrigin = origin !== null && origin.endsWith("long") && (meta.dtype !== "f64" || allIntegral(column));
+  if (meta.dtype === "list") {
+    return meta.itemDtype === null || meta.itemDtype === "json" ? "string" : `list_of_${scalarType(meta.itemDtype, longOrigin)}`;
+  }
+  return meta.components > 1 ? `list_of_${scalarType(meta.dtype, false)}` : scalarType(meta.dtype, longOrigin);
+}
+function nonFinitePositions(position) {
+  let count = 0;
+  for (let i = 0; i < position.length; i++) {
+    if (position.isSet(i)) {
+      const p = position.value(i);
+      if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function planEdgeIds(snapshot, note) {
+  const column = snapshot.edges.byRole("id");
+  const used = /* @__PURE__ */ new Set();
+  let generated = 0;
+  const ids = keptEdgeIds(column, snapshot.edgeCount, used);
+  let next = 0;
+  const out = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    let id = ids[e];
+    if (id === null) {
+      while (used.has(next)) {
+        next++;
+      }
+      id = next;
+      used.add(next);
+      generated++;
+    }
+    out.push(id);
+  }
+  if (column !== null && generated > 0) {
+    note(
+      LOSS.EDGE_IDS_GENERATED,
+      `${generated} edge${plural(generated)} ${agree(generated, "has", "have")} no distinct integer id in "${column.meta.name}"; they are written with generated ids`,
+      column.meta.name,
+      generated
+    );
+  }
+  if (column !== null && column.dtype !== "f64") {
+    note(
+      LOSS.DTYPE,
+      `edge id column "${column.meta.name}" is ${column.dtype}; CX edge ids are integers and read back as f64`,
+      column.meta.name,
+      snapshot.edgeCount - column.nullCount
+    );
+  }
+  return out;
+}
+function keptEdgeIds(column, edgeCount, used) {
+  const ids = new Array(edgeCount).fill(null);
+  if (column === null) {
+    return ids;
+  }
+  for (let e = 0; e < edgeCount; e++) {
+    const value = column.isSet(e) ? column.value(e) : void 0;
+    const n = typeof value === "number" || typeof value === "string" ? Number(value) : Number.NaN;
+    if (Number.isSafeInteger(n) && !used.has(n)) {
+      ids[e] = n === 0 ? 0 : n;
+      used.add(n);
+    }
+  }
+  return ids;
+}
+function directionNotes(snapshot, folding, common, undirectedCode, note) {
+  if (!snapshot.directed) {
+    note(
+      undirectedCode,
+      `the snapshot is undirected; every edge is written as a directed edge (${snapshot.edgeCount} edge${plural(snapshot.edgeCount)})`,
+      null,
+      snapshot.edgeCount
+    );
+  } else if (common.onMixedDirection !== "error") {
+    let undirected = 0;
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      if (!folding.folded(e) && !folding.sourceDirected(e)) {
+        undirected++;
+      }
+    }
+    if (undirected > 0) {
+      note(
+        undirectedCode,
+        `${undirected} undirected edge${plural(undirected)} ${agree(undirected, "is", "are")} written as one directed edge each (a pair folded to its primary); CX has no undirected edge`,
+        null,
+        undirected
+      );
+    }
+  }
+  if (folding.mutualCount > 0) {
+    note(
+      LOSS.MUTUAL_EXPANDED,
+      `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two directed edges; the mutual mark is lost`,
+      null,
+      folding.mutualCount
+    );
+  }
+}
+function noteList() {
+  const notes = [];
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  return { notes, note };
+}
+function stringify(value) {
+  const text = JSON.stringify(value, (_key, v) => Object.is(v, -0) ? `${RAW}-0` : v);
+  return text.includes(String.raw`\u0000cx:`) ? text.replaceAll(RAW_JSON, "$1") : text;
+}
+function* aspectBlock(aspect, elements) {
+  yield `{${JSON.stringify(aspect)}:[`;
+  let first = true;
+  for (const element of elements) {
+    yield first ? `
+${element}` : `,
+${element}`;
+    first = false;
+  }
+  yield "]},\n";
+}
 const CX2_FORMAT = "cx2";
 const ORIGINAL_ID_ATTRIBUTE = "graphty:originalId";
 const BYPASS_NAMESPACE = "cx2.bypass";
 const CX2_ISSUE = Object.freeze({
-  /** The input is empty (fatal). */
+  ...INPUT_ISSUE,
+  ...ELEMENT_ISSUE,
+  /** The input is empty. The import stops. */
   EMPTY_INPUT: EMPTY_INPUT_CODE,
-  /** The text is not JSON (fatal). */
+  /** The text is not valid JSON. The import stops. */
   SYNTAX: SYNTAX_CODE,
-  /** Invalid UTF-8 (fatal). */
+  /** The input is not valid UTF-8. The import stops. */
   INVALID_UTF8: INVALID_UTF8_CODE,
-  /** Invalid bytes in the encoding a BOM or the encoding option chose (fatal). */
+  /**
+   * Some bytes are not valid in the encoding that was chosen (by a byte order mark or the `encoding` option). The
+   * import stops.
+   */
   INVALID_ENCODING: INVALID_ENCODING_CODE,
   /** Bytes that are not UTF-8 were read as windows-1252. */
   ENCODING_FALLBACK: ENCODING_FALLBACK_CODE,
   /** An encoding the platform cannot decode was ignored. */
   UNKNOWN_ENCODING: UNKNOWN_ENCODING_CODE,
-  /** The document is not an array or does not start with a descriptor holding CXVersion (fatal). */
+  /**
+   * The document is not a JSON array, or its first element is not the CX2 descriptor with `CXVersion`. The import
+   * stops.
+   */
   NO_DESCRIPTOR: "E_CX2_NO_DESCRIPTOR",
-  /** CXVersion names a major version other than 2 (fatal); "1.x" says the file is CX1. */
+  /** `CXVersion` names a version other than 2 ("1.x" means the file is CX1; read it as `cx`). The import stops. */
   VERSION: "E_CX2_VERSION",
   /** CXVersion is a 2.x other than "2.0" (or not a string); the document is read. */
   MINOR_VERSION: "W_CX2_MINOR_VERSION",
   /** The document has no status block, or a malformed one. */
   NO_STATUS: "E_CX2_NO_STATUS",
-  /** The producer marked the document as failed (fatal). */
+  /** The program that wrote the file marked it as failed, so it is incomplete. The import stops. */
   STATUS_FAILED: STATUS_FAILED_CODE,
   /** The producer marked the document as successful with an error text. */
   STATUS_WARNING: STATUS_WARNING_CODE,
@@ -50,9 +295,18 @@ const CX2_ISSUE = Object.freeze({
   ALIAS_BYPASSED: "W_CX2_ALIAS_BYPASSED",
   /** A CX1 cartesianLayout aspect next to node coordinates; kept, not applied. */
   LEGACY_LAYOUT: "W_CX2_LEGACY_LAYOUT",
-  /** The file's style rules are not applied (issue #706). */
+  /** An aspect CX2 defines as an array of elements written as one object; read as one element. */
+  SINGLE_OBJECT_ASPECT: SINGLE_OBJECT_ASPECT_CODE,
+  /** A member holding several aspects; each array-valued key is read as its own block. */
+  MULTI_ASPECT_FRAGMENT: MULTI_ASPECT_FRAGMENT_CODE,
+  /** The bare tokens NaN / Infinity / -Infinity (Python's json writes them), read as numbers. */
+  JSON_NONSTANDARD_NUMBER: JSON_NONSTANDARD_NUMBER_CODE,
+  /** The file's style rules are not applied; they are kept so a CX2 export writes them back. */
   STYLES_NOT_IMPORTED: STYLES_NOT_IMPORTED_CODE,
-  /** A member of the top-level array that is not a one-key aspect block, or an element that is not an object. */
+  /**
+   * A member of the file's top-level array that is not a block with one key (`{"nodes": [...]}`), or an element of a
+   * block that is not an object. It is skipped; the rest of the file is read.
+   */
   BAD_ASPECT_BLOCK: BAD_ASPECT_BLOCK_CODE,
   /** An aspect out of its place (after the post-metadata or the status, a third metaData, late declarations). */
   ASPECT_ORDER: ASPECT_ORDER_CODE,
@@ -84,25 +338,37 @@ const CX2_ISSUE = Object.freeze({
   INVALID_WEIGHT: "E_INVALID_WEIGHT",
   /** An id spelled as a string or a non-integer literal; read as the integer. */
   ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,
-  /** An integer beyond 2^53: an id kept as its digits, a value stored as the nearest f64. */
+  /** An integer beyond 2^53 was stored as the nearest 64-bit float; pass `long: "string"` to keep every digit. */
   PRECISION: PRECISION_CODE,
   /** Two id texts merged under `ids: "number"`. */
   ID_MERGED: ID_MERGED_CODE,
   /** An element key CX2 does not define. */
   UNKNOWN_ELEMENT: UNKNOWN_ELEMENT_CODE,
-  /** A column renamed because its name was taken. */
+  /**
+   * An attribute was renamed `<name>#<suffix>` because another attribute already has its name, for example
+   * two attributes declared with the same name.
+   */
   COLUMN_RENAMED: COLUMN_RENAMED_CODE,
-  /** A column that lost its role because another column holds it. */
+  /**
+   * You read into a graph builder that already has an id, label or position attribute, so this file's one is kept as
+   * a plain attribute.
+   */
   ROLE_TAKEN: ROLE_TAKEN_CODE,
-  /** The sink refused the direction. */
+  /**
+   * You read into a graph builder whose direction is already set, or which already holds edges, so the file is read
+   * with the builder's direction instead of its own.
+   */
   DIRECTION_REFUSED: DIRECTION_REFUSED_CODE,
-  /** Edges forced to the policy's direction. */
+  /** Edges of the other direction were read with the direction `onMixedDirection` chose. */
   DIRECTION_FORCED: DIRECTION_FORCED_CODE,
-  /** A common option CX2 has no use for. */
+  /** You set an option this format does not use; it had no effect. The message names the option. */
   OPTION_IGNORED: OPTION_IGNORED_CODE,
-  /** A builder option the caller's sink does not honour. */
+  /**
+   * You read into your own graph builder, which was created with a different `addMissingNodes`, `duplicateEdges`,
+   * `selfLoops` or `weightDtype` than the option you passed; the builder's setting applies.
+   */
   SINK_OPTION: SINK_OPTION_CODE,
-  /** The input is beyond a size limit (fatal). */
+  /** The input is larger than graph-io's size limit. The import stops. */
   TOO_LARGE: TOO_LARGE_CODE
 });
 const USED_OPTIONS = /* @__PURE__ */ new Set([
@@ -137,20 +403,30 @@ const STYLE_ASPECTS = [
   "cyTableVisualProperties"
 ];
 const STRUCTURE_ASPECTS = /* @__PURE__ */ new Set(["metaData", "status"]);
-const SCALARS = {
-  string: "string",
-  long: "long",
-  integer: "integer",
-  double: "double",
-  boolean: "boolean",
-  str: "string",
-  int: "integer",
-  bool: "boolean",
-  float: "double"
-};
+const ARRAY_ASPECTS = /* @__PURE__ */ new Set([
+  "nodes",
+  "edges",
+  "attributeDeclarations",
+  "networkAttributes",
+  "nodeBypasses",
+  "edgeBypasses",
+  "status",
+  "metaData"
+]);
+const SCALARS = /* @__PURE__ */ new Map([
+  ["string", "string"],
+  ["long", "long"],
+  ["integer", "integer"],
+  ["double", "double"],
+  ["boolean", "boolean"],
+  ["str", "string"],
+  ["int", "integer"],
+  ["bool", "boolean"],
+  ["float", "double"]
+]);
 function cx2Type(d) {
   const list = d.startsWith("list_of_");
-  const scalar = SCALARS[list ? d.slice("list_of_".length) : d];
+  const scalar = SCALARS.get(list ? d.slice("list_of_".length) : d);
   if (scalar === void 0) {
     return null;
   }
@@ -185,6 +461,7 @@ function convertScalar(value, scalar, long, onPrecision) {
       return typeof value === "boolean" ? value : BAD;
     case "double":
       if (value instanceof ExactInteger) {
+        onPrecision(value.digits);
         return Number(value.digits);
       }
       return typeof value === "number" ? value : BAD;
@@ -235,13 +512,13 @@ function shown(value) {
   }
   return text.length > 60 ? `${text.slice(0, 57)}...` : text;
 }
-function inexactBits(text, keys) {
+function inexactBits(text, keys, depth = 1) {
   if (!/[0-9][.eE]/.test(text)) {
     return 0;
   }
   let bits = 0;
   keys.forEach((key, i) => {
-    if (inexactLiteral(text, key)) {
+    if (inexactLiteral(text, key, depth)) {
       bits |= 1 << i;
     }
   });
@@ -265,16 +542,17 @@ async function readDocument(input, report, options) {
   let descriptor = false;
   let elementsSeen = false;
   let sinceCheck = 0;
-  const collect = (aspect, value, text, line, exact) => {
+  const opaquePrecision = keptPrecision(report, "meta.extra.cx2.opaque");
+  const collect = (aspect, value, text, line, exact, depth = 1) => {
     structure.element(aspect, value, line);
     switch (aspect) {
       case "nodes":
         elementsSeen = true;
-        doc.nodes.push({ value, line, inexact: inexactBits(text, ["id"]) });
+        doc.nodes.push({ value, line, inexact: inexactBits(text, ["id"], depth) });
         return;
       case "edges":
         elementsSeen = true;
-        doc.edges.push({ value, line, inexact: inexactBits(text, ["id", "s", "t"]) });
+        doc.edges.push({ value, line, inexact: inexactBits(text, ["id", "s", "t"], depth) });
         return;
       case "attributeDeclarations":
         if (elementsSeen) {
@@ -286,7 +564,7 @@ async function readDocument(input, report, options) {
             `${ASPECT_ORDER_CODE}:declarations`
           );
         }
-        doc.declarations.push({ value: plainJson(value), line, inexact: 0 });
+        doc.declarations.push({ value, line, inexact: 0 });
         return;
       case "networkAttributes":
         elementsSeen = true;
@@ -308,11 +586,11 @@ async function readDocument(input, report, options) {
         if (!doc.opaque.has(aspect)) {
           doc.opaque.set(aspect, []);
         }
-        doc.opaque.get(aspect)?.push(exact ? plainJson(value, () => void 0) : value);
+        doc.opaque.get(aspect)?.push(exact ? plainJson(value, opaquePrecision) : value);
     }
   };
   try {
-    for await (const event of scanAspects(textChunks(input, report, options))) {
+    for await (const event of scanAspects(textChunks(input, report, options), report)) {
       if (++sinceCheck >= ABORT_CHECK_INTERVAL) {
         sinceCheck = 0;
         throwIfAborted(options.signal);
@@ -321,7 +599,7 @@ async function readDocument(input, report, options) {
         case "root":
           report.fail(
             CX2_ISSUE.NO_DESCRIPTOR,
-            `a CX2 document is a JSON array; found ${isRecord(event.value) ? "an object" : shown(event.value)}`,
+            `a CX2 document is a JSON array; found ${event.object ? "an object" : shown(event.value)}`,
             { line: event.line }
           );
           break;
@@ -332,10 +610,11 @@ async function readDocument(input, report, options) {
             break;
           }
           memberAspect(event.value, event.line, structure, report, (aspect, value) => {
-            collect(aspect, value, JSON.stringify(value) ?? "", event.line, event.exact);
+            collect(aspect, value, event.text, event.line, event.exact, 2);
           });
           break;
         case "block":
+          reportSharedBlock(report, event);
           if (!descriptor) {
             report.fail(
               CX2_ISSUE.NO_DESCRIPTOR,
@@ -358,7 +637,7 @@ async function readDocument(input, report, options) {
           report.error(
             "parse-error",
             BAD_ASPECT_BLOCK_CODE,
-            `the "${event.aspect}" block holds more keys (${event.keys.join(", ")}); an aspect block has one key, the others are skipped`,
+            `the "${event.aspect}" block holds more keys (${event.keys.join(", ")}) whose values are not arrays; an aspect block has one key, the others are skipped`,
             { line: event.line, element: event.aspect }
           );
           break;
@@ -388,8 +667,8 @@ function readDescriptor(value, line, doc, report) {
   }
   const raw = value.CXVersion;
   const text = typeof raw === "string" || typeof raw === "number" ? String(raw) : "";
-  const match = /^([0-9]+)(?:\.([0-9]+))?$/.exec(text);
-  const major = match === null ? NaN : Number(match[1]);
+  const match = /^\s*(\d+)(?=$|[.\s-])/.exec(text);
+  const major = match === null ? Number.NaN : Number(match[1]);
   if (major === 1) {
     report.fail(
       CX2_ISSUE.VERSION,
@@ -432,6 +711,14 @@ function readDescriptor(value, line, doc, report) {
 function memberAspect(value, line, structure, report, collect) {
   const keys = isRecord(value) ? Object.keys(value) : [];
   if (isRecord(value) && keys.length === 1 && isRecord(value[keys[0]])) {
+    if (ARRAY_ASPECTS.has(keys[0])) {
+      report.warning(
+        "validation-error",
+        CX2_ISSUE.SINGLE_OBJECT_ASPECT,
+        `the "${keys[0]}" aspect is one object, not an array of elements; read as one element`,
+        { line, element: keys[0] }
+      );
+    }
     structure.block(keys[0], line);
     collect(keys[0], value[keys[0]]);
     return;
@@ -505,7 +792,14 @@ class DeclarationTable {
     return decl === void 0 ? null : { decl, viaAlias: false };
   }
 }
-const DECLARATION_KEYS = { nodes: "node", edges: "edge", networkAttributes: "network" };
+const DECLARATION_KEYS = /* @__PURE__ */ new Map([
+  ["nodes", "node"],
+  ["edges", "edge"],
+  ["networkAttributes", "network"]
+]);
+function hasOwn(record, key) {
+  return Object.hasOwn(record, key);
+}
 class Cx2Reader {
   /**
    * Create the reader.
@@ -524,6 +818,7 @@ class Cx2Reader {
     };
     this.nodeRows = /* @__PURE__ */ new Map();
     this.sinkIds = /* @__PURE__ */ new Map();
+    this.restored = /* @__PURE__ */ new Set();
     this.edgeRows = /* @__PURE__ */ new Map();
     this.positionHandle = INVALID_INDEX;
     this.zHandle = INVALID_INDEX;
@@ -557,7 +852,7 @@ class Cx2Reader {
       report.warnOnce(
         "missing-value",
         CX2_ISSUE.PARTIAL_LAYOUT,
-        `${this.nodeRows.size - this.positioned.size} of ${this.nodeRows.size} node(s) have no coordinates; their positions are unset`,
+        `${this.nodeRows.size - this.positioned.size} of ${this.nodeRows.size} node${plural(this.nodeRows.size)} ${agree(this.nodeRows.size - this.positioned.size, "has", "have")} no coordinates; their positions are unset`,
         { element: "nodes" }
       );
     }
@@ -571,7 +866,7 @@ class Cx2Reader {
       report.warning(
         "validation-error",
         DANGLING_REFERENCE_CODE,
-        `${count} ${kind} name(s) no element; ignored`,
+        `${count} ${kind}${plural(count)} ${agree(count, "names", "name")} no element; ignored`,
         { element: kind }
       );
     }
@@ -596,9 +891,21 @@ class Cx2Reader {
         continue;
       }
       for (const [key, table] of Object.entries(held.value)) {
-        const domain = DECLARATION_KEYS[key];
+        const domain = DECLARATION_KEYS.get(key);
         if (domain === void 0) {
-          this.decls.other[key] = table;
+          report.warning(
+            "unsupported",
+            UNKNOWN_ELEMENT_CODE,
+            `attributeDeclarations holds the table "${key}", which CX2 does not define; kept in meta.extra.cx2.declarations, not applied`,
+            { line: held.line, element: key }
+          );
+          setOwn(
+            this.decls.other,
+            key,
+            plainJson(table, (digits) => {
+              this.precision(key, digits);
+            })
+          );
           continue;
         }
         if (!isRecord(table)) {
@@ -636,7 +943,7 @@ class Cx2Reader {
       }
       for (const [key, raw] of Object.entries(value.v)) {
         const resolved = table.resolve(key);
-        if (resolved !== null && resolved.decl.type !== null || raw === null || raw === void 0) {
+        if (key === "" || resolved !== null && resolved.decl.type !== null || raw === null || raw === void 0) {
           continue;
         }
         const name = resolved?.decl.name ?? key;
@@ -682,6 +989,15 @@ class Cx2Reader {
     const { report } = this;
     const table = this.decls[domain];
     const where = { line, element: name };
+    if (name === "") {
+      report.error(
+        "validation-error",
+        BAD_VALUE_CODE,
+        `a ${domain} attribute declaration has an empty name; ignored`,
+        where
+      );
+      return;
+    }
     if (!isRecord(raw)) {
       report.error(
         "validation-error",
@@ -723,6 +1039,14 @@ class Cx2Reader {
       }
       return;
     }
+    if (raw.a !== void 0 && raw.a !== null && typeof raw.a !== "string") {
+      report.error(
+        "validation-error",
+        BAD_VALUE_CODE,
+        `the alias ${shown(raw.a)} of "${name}" is not a string; ignored`,
+        where
+      );
+    }
     let alias = typeof raw.a === "string" ? raw.a : null;
     let hasDefault = raw.v !== void 0 && raw.v !== null;
     if (domain === "network" && (raw.a !== void 0 || raw.v !== void 0)) {
@@ -763,7 +1087,9 @@ class Cx2Reader {
    * @returns the default, or BAD when dropped
    */
   convertDefault(name, value, type, where) {
-    const converted = convertValue(value, type, this.options.long, () => void 0);
+    const converted = convertValue(value, type, this.options.long, (digits) => {
+      this.precision(name, digits);
+    });
     if (converted !== BAD) {
       return converted;
     }
@@ -879,10 +1205,11 @@ class Cx2Reader {
    * @param raw - the parsed id
    * @param inexact - whether the literal was not a plain integer
    * @param element - the element name for issues
+   * @param line - the element's line
    * @param edgeId - whether this is an edge's own id (stored in the f64 id column, not kept as digits)
    * @returns the id, or null when it was reported
    */
-  idOf(raw, inexact, element, edgeId = false) {
+  idOf(raw, inexact, element, line, edgeId = false) {
     let id;
     try {
       const parsed = cxId(raw, inexact);
@@ -891,14 +1218,14 @@ class Cx2Reader {
           "coercion",
           ID_TEXT_TYPE_CODE,
           `${element}: the id ${shown(raw)} is not written as an integer; read as ${String(parsed.id)}`,
-          { element }
+          { line, element }
         );
       } else if (parsed.note === "precision" && edgeId) {
         this.report.warnOnce(
           "precision",
           PRECISION_CODE,
           `${element}: the edge id ${String(parsed.id)} is beyond 2^53; the id column holds the nearest double`,
-          { element },
+          { line, element },
           `${PRECISION_CODE}:edge`
         );
       } else if (parsed.note === "precision") {
@@ -907,12 +1234,12 @@ class Cx2Reader {
           "precision",
           PRECISION_CODE,
           `${element}: the id ${String(parsed.id)} is beyond 2^53; kept as its digits (a string id)`,
-          { element }
+          { line, element }
         );
       }
       id = this.options.ids === "keep" ? parsed.id : this.coercer.value(parsed.id);
     } catch (err) {
-      this.report.recordError(err, { element });
+      this.report.recordError(err, { line, element });
       return null;
     }
     return id;
@@ -970,7 +1297,7 @@ class Cx2Reader {
       return;
     }
     const element = `node ${shown(value.id)}`;
-    const cx = this.idOf(value.id, (held.inexact & 1) !== 0, element);
+    const cx = this.idOf(value.id, (held.inexact & 1) !== 0, element, line);
     if (cx === null) {
       report.counts.skippedNodes++;
       return;
@@ -991,7 +1318,19 @@ class Cx2Reader {
         { line, element }
       );
     } else {
-      const original = this.originalIdOf(attrs);
+      let original = this.originalIdOf(attrs, element, line);
+      if (original !== null && this.restored.has(original)) {
+        report.warning(
+          "merged",
+          DUPLICATE_NODE_CODE,
+          `${element}: its original id ${shown(original)} is already another node's; it keeps its CX id`,
+          { line, element }
+        );
+        original = null;
+      }
+      if (original !== null) {
+        this.restored.add(original);
+      }
       this.idTypeOf(original ?? cx);
       try {
         row = sink.addNode(original ?? cx);
@@ -1012,14 +1351,24 @@ class Cx2Reader {
   /**
    * The original id the exporter's `sanitizeIds: "mangle"` kept, when it is to be restored.
    * @param attrs - the node's v
+   * @param element - the element name for issues
+   * @param line - its line
    * @returns the original id, or null
    */
-  originalIdOf(attrs) {
+  originalIdOf(attrs, element, line) {
     if (attrs === null || !this.options.restoreMangledIds) {
       return null;
     }
     const alias = this.decls.node.byName.get(ORIGINAL_ID_ATTRIBUTE)?.alias ?? null;
     const raw = attrs[ORIGINAL_ID_ATTRIBUTE] ?? (alias === null ? void 0 : attrs[alias]);
+    if (raw !== void 0 && raw !== null && typeof raw !== "string") {
+      this.report.error(
+        "validation-error",
+        BAD_VALUE_CODE,
+        `${element}: ${ORIGINAL_ID_ATTRIBUTE} is ${shown(raw)}, not a string; the node keeps its CX id`,
+        { line, element }
+      );
+    }
     return typeof raw === "string" ? raw : null;
   }
   /**
@@ -1074,7 +1423,14 @@ class Cx2Reader {
         `${CX2_ISSUE.PARTIAL_LAYOUT}:z`
       );
     }
-    if (x !== null && y !== null) {
+    if (x !== null && y !== null && (!fitsF32(x) || !fitsF32(y))) {
+      this.report.error(
+        "validation-error",
+        BAD_VALUE_CODE,
+        `${element}: the coordinates ${String(x)}, ${String(y)} are beyond what the f32 position column holds; the position is unset`,
+        { line, element }
+      );
+    } else if (x !== null && y !== null) {
       this.setPosition(row, x, y, z);
     }
     if (z !== null && this.zAs === "column") {
@@ -1120,11 +1476,13 @@ class Cx2Reader {
       this.report.warning(
         "unsupported",
         CX2_ISSUE.LEGACY_LAYOUT,
-        `a CX1 cartesianLayout aspect (${cartesianLayout.length} element(s)) next to node coordinates; the node coordinates are used, the aspect is kept in meta.extra.cx2`,
+        `a CX1 cartesianLayout aspect (${cartesianLayout.length} element${plural(cartesianLayout.length)}) next to node coordinates; the node coordinates are used, the aspect is kept in meta.extra.cx2`,
         { element: "cartesianLayout" }
       );
       return;
     }
+    let view;
+    const seen = /* @__PURE__ */ new Set();
     for (const held of cartesianLayout) {
       const entry = held.value;
       if (!isRecord(entry) || typeof entry.x !== "number" || typeof entry.y !== "number") {
@@ -1141,6 +1499,31 @@ class Cx2Reader {
         this.dangle("cartesianLayout entry");
         continue;
       }
+      view ??= entry.view ?? null;
+      if ((entry.view ?? null) !== view) {
+        this.doc.opaque.set(
+          "cartesianLayout",
+          cartesianLayout.map((h) => plainJson(h.value))
+        );
+        this.report.warnOnce(
+          "validation-error",
+          DUPLICATE_ATTRIBUTE_CODE,
+          `the cartesianLayout aspect names several views; view ${shown(view)} is read, the aspect is kept in meta.extra.cx2`,
+          { line: held.line, element: "cartesianLayout" },
+          `${DUPLICATE_ATTRIBUTE_CODE}:layout:view`
+        );
+        continue;
+      }
+      if (seen.has(row)) {
+        this.report.warnOnce(
+          "validation-error",
+          DUPLICATE_ATTRIBUTE_CODE,
+          `node ${shown(entry.node)} has two cartesianLayout entries; the later wins`,
+          { line: held.line, element: "cartesianLayout" },
+          `${DUPLICATE_ATTRIBUTE_CODE}:layout`
+        );
+      }
+      seen.add(row);
       const z = typeof entry.z === "number" ? entry.z : null;
       this.setPosition(row, entry.x, entry.y, z);
       if (z !== null && this.zAs === "column") {
@@ -1186,6 +1569,15 @@ class Cx2Reader {
     const table = this.decls[domain];
     for (const key of Object.keys(attrs)) {
       const value = attrs[key];
+      if (key === "") {
+        report.error(
+          "validation-error",
+          BAD_VALUE_CODE,
+          `${element}: v holds an attribute with an empty name; skipped`,
+          { line, element }
+        );
+        continue;
+      }
       const resolved = table.resolve(key);
       const name = resolved?.decl.name ?? key;
       if (domain === "node" && this.options.restoreMangledIds && name === ORIGINAL_ID_ATTRIBUTE) {
@@ -1204,7 +1596,7 @@ class Cx2Reader {
         );
       }
       if (resolved !== null && !resolved.viaAlias && resolved.decl.alias !== null && resolved.decl.alias !== key) {
-        if (resolved.decl.alias in attrs) {
+        if (hasOwn(attrs, resolved.decl.alias)) {
           report.warning(
             "validation-error",
             DUPLICATE_ATTRIBUTE_CODE,
@@ -1307,9 +1699,9 @@ class Cx2Reader {
         return;
       }
     }
-    const id = this.idOf(value.id, (held.inexact & 1) !== 0, element, true);
-    const s = id === null ? null : this.idOf(value.s, (held.inexact & 2) !== 0, element);
-    const t = s === null ? null : this.idOf(value.t, (held.inexact & 4) !== 0, element);
+    const id = this.idOf(value.id, (held.inexact & 1) !== 0, element, line, true);
+    const s = id === null ? null : this.idOf(value.s, (held.inexact & 2) !== 0, element, line);
+    const t = s === null ? null : this.idOf(value.t, (held.inexact & 4) !== 0, element, line);
     if (id === null || s === null || t === null) {
       report.counts.skippedEdges++;
       return;
@@ -1331,6 +1723,12 @@ class Cx2Reader {
       return;
     }
     const attrs = isRecord(value.v) ? value.v : null;
+    if (value.v !== void 0 && value.v !== null && attrs === null) {
+      report.error("validation-error", BAD_VALUE_CODE, `${element}: v is ${shown(value.v)}, not an object`, {
+        line,
+        element
+      });
+    }
     let weight;
     const weightKey = this.weightKey(attrs);
     try {
@@ -1370,10 +1768,10 @@ class Cx2Reader {
       return null;
     }
     const alias = this.decls.edge.byName.get(weightFrom)?.alias ?? null;
-    if (alias !== null && alias in attrs) {
+    if (alias !== null && hasOwn(attrs, alias)) {
       return alias;
     }
-    return weightFrom in attrs ? weightFrom : null;
+    return hasOwn(attrs, weightFrom) ? weightFrom : null;
   }
   /**
    * The sink id of an edge endpoint: a known node, or a node created under addMissingNodes.
@@ -1516,13 +1914,38 @@ class Cx2Reader {
         if (raw === null || raw === void 0) {
           continue;
         }
+        if (property === "") {
+          this.report.error(
+            "validation-error",
+            BAD_VALUE_CODE,
+            `a ${domain}Bypasses element holds a visual property with an empty name; skipped`,
+            { line, element: `${domain}Bypasses` }
+          );
+          continue;
+        }
         let column = columns.get(property);
         if (column === void 0) {
-          column = { rows: [], values: [] };
+          column = { rows: [], values: [], at: /* @__PURE__ */ new Map() };
           columns.set(property, column);
         }
-        column.rows.push(row);
-        column.values.push(plainJson(raw));
+        const plain = plainJson(raw);
+        const index = column.at.get(row);
+        if (index === void 0) {
+          column.at.set(row, column.rows.length);
+          column.rows.push(row);
+          column.values.push(plain);
+          continue;
+        }
+        if (JSON.stringify(column.values[index]) !== JSON.stringify(plain)) {
+          this.report.warnOnce(
+            "validation-error",
+            DUPLICATE_ATTRIBUTE_CODE,
+            `a ${domain} has the visual property "${property}" in two ${domain}Bypasses elements; the later wins`,
+            { line, element: property },
+            `${DUPLICATE_ATTRIBUTE_CODE}:bypass:${domain}:${property}`
+          );
+        }
+        column.values[index] = plain;
       }
     }
     for (const [property, { rows: targets, values }] of columns) {
@@ -1559,7 +1982,7 @@ class Cx2Reader {
       report.warning(
         "unsupported",
         STYLES_NOT_IMPORTED_CODE,
-        `the file's style rules are not applied (${styles.join("; ")}); they are kept in meta.extra.cx2.opaque (style import is issue #706)`,
+        `the file's style rules are not applied (${styles.join("; ")}); they are kept in meta.extra.cx2.opaque`,
         { element: STYLE_ASPECTS.filter((a) => doc.opaque.has(a)).join(",") }
       );
     }
@@ -1652,9 +2075,9 @@ function describeStyle(aspect, elements) {
   if (aspect === "visualProperties" && isRecord(first)) {
     const count = (key) => isRecord(first[key]) ? Object.keys(first[key]).length : 0;
     const defaults = isRecord(first.default) ? Object.values(first.default).reduce((n, v) => n + (isRecord(v) ? Object.keys(v).length : 0), 0) : 0;
-    return `visualProperties: ${defaults} default(s), ${count("nodeMapping")} node mapping(s), ${count("edgeMapping")} edge mapping(s)`;
+    return `visualProperties: ${defaults} default${plural(defaults)}, ${count("nodeMapping")} node mapping${plural(count("nodeMapping"))}, ${count("edgeMapping")} edge mapping${plural(count("edgeMapping"))}`;
   }
-  return `${aspect}: ${elements.length} element(s)`;
+  return `${aspect}: ${elements.length} element${plural(elements.length)}`;
 }
 function zAsOption(value) {
   if (value === void 0) {
@@ -1670,6 +2093,7 @@ function zAsOption(value) {
 }
 const cx2Importer = Object.freeze({
   format: CX2_FORMAT,
+  options: Object.freeze(["zAs"]),
   extensions: Object.freeze([".cx2"]),
   mimeTypes: Object.freeze(["application/json"]),
   /**
@@ -1679,7 +2103,7 @@ const cx2Importer = Object.freeze({
    * @returns the confidence
    */
   sniff(head) {
-    const text = new TextDecoder("utf-8").decode(head.subarray(0, 1024)).replace(/^\uFEFF/, "");
+    const text = headText(head);
     return /^\s*\[\s*\{(?:\s*"[^"]*"\s*:\s*(?:true|false|"[^"]*"|[0-9.]+)\s*,)*\s*"CXVersion"\s*:/.test(text) ? 0.97 : 0;
   },
   /**
@@ -1706,8 +2130,17 @@ export {
   CX2_ISSUE as C,
   ORIGINAL_ID_ATTRIBUTE as O,
   CX2_FORMAT as a,
-  cx2Type as b,
+  planEdgeIds as b,
   cx2Importer as c,
+  directionNotes as d,
+  cx2Type as e,
+  aspectBlock as f,
+  declaredType as g,
+  nextNodeId as h,
+  noteList as i,
+  nonFinitePositions as n,
+  planNodeIds as p,
+  stringify as s,
   zAsOption as z
 };
-//# sourceMappingURL=importer-vi3bSdtw.js.map
+//# sourceMappingURL=importer-BVRE--Un.js.map