@graphty/graph-io 0.3.43 → 0.3.44

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

@@ -1,143 +1,5 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-const FETCH_CODE = "E_FETCH";
-const MISSING_ID_CODE = "E_MISSING_ID";
-const MISSING_ENDPOINT_CODE = "E_MISSING_ENDPOINT";
-const DUPLICATE_NODE_CODE = "W_DUPLICATE_NODE";
-const NO_GRAPH_CODE = "E_NO_GRAPH";
-const MULTIPLE_GRAPHS_CODE = "W_MULTIPLE_GRAPHS";
-const EMPTY_INPUT_CODE = "E_EMPTY_INPUT";
-const SYNTAX_CODE = "E_SYNTAX";
-const XML_SYNTAX_CODE = "E_XML_SYNTAX";
-const UNKNOWN_ELEMENT_CODE = "W_UNKNOWN_ELEMENT";
-const STRAY_TEXT_CODE = "W_STRAY_TEXT";
-const UNKNOWN_PARENT_CODE = "E_UNKNOWN_PARENT";
-const HYPEREDGE_CODE = "E_HYPEREDGE";
-const DUPLICATE_KEY_CODE = "E_DUPLICATE_KEY";
-const COLUMN_RENAMED_CODE = "W_COLUMN_RENAMED";
-const COLUMN_DROPPED_CODE = "W_COLUMN_DROPPED";
-const ROLE_TAKEN_CODE = "W_ROLE_TAKEN";
-const PRECISION_CODE = "W_PRECISION";
-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 ENCODING_CONFLICT_CODE = "W_ENCODING_CONFLICT";
-const CONTROL_CHARACTER_CODE = "W_CONTROL_CHARACTER";
-const FOREIGN_FORMAT_CODE = "E_FOREIGN_FORMAT";
-const ISSUES_SUPPRESSED_CODE = "W_ISSUES_SUPPRESSED";
-const UNKNOWN_XML_ATTRIBUTE_CODE = "W_UNKNOWN_XML_ATTRIBUTE";
-const DIRECTION_REFUSED_CODE = "W_DIRECTION_REFUSED";
-const DIRECTION_FORCED_CODE = "W_DIRECTION_FORCED";
-const MIXED_DIRECTION_CODE = "E_MIXED_DIRECTION";
-const COUNT_HINT_CODE = "W_COUNT_HINT";
-const UNKNOWN_ATTR_TYPE_CODE = "W_UNKNOWN_ATTR_TYPE";
-const BAD_DEFAULT_CODE = "W_BAD_DEFAULT";
-const BAD_OPTIONS_CODE = "W_BAD_OPTIONS";
-const DUPLICATE_EDGE_ID_CODE = "E_DUPLICATE_EDGE_ID";
-const BAD_VALUE_CODE = "E_BAD_VALUE";
-const WIDENED_CODE = "W_WIDENED";
-const DANGLING_REFERENCE_CODE = "W_DANGLING_REFERENCE";
-const DUPLICATE_ATTRIBUTE_CODE = "W_DUPLICATE_ATTRIBUTE";
-const PARENT_CYCLE_CODE = "E_PARENT_CYCLE";
-const EQUATION_AS_TEXT_CODE = "W_EQUATION_AS_TEXT";
-const STYLES_NOT_IMPORTED_CODE = "W_STYLES_NOT_IMPORTED";
-const BAD_ASPECT_BLOCK_CODE = "E_BAD_ASPECT_BLOCK";
-const MULTI_ASPECT_FRAGMENT_CODE = "W_MULTI_ASPECT_FRAGMENT";
-const SINGLE_OBJECT_ASPECT_CODE = "W_SINGLE_OBJECT_ASPECT";
-const JSON_NONSTANDARD_NUMBER_CODE = "W_JSON_NONSTANDARD_NUMBER";
-const ASPECT_ORDER_CODE = "W_ASPECT_ORDER";
-const COUNT_MISMATCH_CODE = "W_COUNT_MISMATCH";
-const STATUS_FAILED_CODE = "E_STATUS_FAILED";
-const STATUS_WARNING_CODE = "W_STATUS_WARNING";
-const TOO_LARGE_CODE = "E_TOO_LARGE";
-const COLUMN_TYPE_CODE = "E_COLUMN_TYPE";
-const GRAPH_NOT_FOUND_CODE = "E_GRAPH_NOT_FOUND";
-const AMBIGUOUS_GRAPH_NAME_CODE = "E_AMBIGUOUS_GRAPH_NAME";
-const DUPLICATE_EDGE_CODE = "E_DUPLICATE_EDGE";
-const SELF_LOOP_CODE = "E_SELF_LOOP";
-const EDGES_MERGED_CODE = "W_EDGES_MERGED";
-const SELF_LOOPS_DROPPED_CODE = "W_SELF_LOOPS_DROPPED";
-const UNKNOWN_OPTION_CODE = "W_UNKNOWN_OPTION";
-const BAD_LINE_CODE = "E_BAD_LINE";
-const WEIGHT_NOT_FOUND_CODE = "W_WEIGHT_NOT_FOUND";
-const ROLE_DROPPED_CODE = "W_ROLE_DROPPED";
-const PARENTS_DROPPED_CODE = "W_PARENTS_DROPPED";
-const TEMPORAL_DROPPED_CODE = "W_TEMPORAL_DROPPED";
-const MUTUAL_EXPANDED_CODE = "W_MUTUAL_EXPANDED";
-const MUTUAL_AS_UNDIRECTED_CODE = "W_MUTUAL_AS_UNDIRECTED";
-const ID_TEXT_TYPE_CODE = "W_ID_TEXT_TYPE";
-const ID_TEXT_COLLISION_CODE = "E_ID_TEXT_COLLISION";
-const TEMPORAL_TEXT_DROPPED_CODE = "W_TEMPORAL_TEXT_DROPPED";
-const WEIGHTS_DROPPED_CODE = "W_WEIGHTS_DROPPED";
-const WEIGHT_KEY_CLASH_CODE = "W_WEIGHT_KEY_CLASH";
-const ROLE_ASSUMED_CODE = "W_ROLE_ASSUMED";
-const COLUMN_RENAMED_LOSS_CODE = "W_COLUMN_NAME_CHANGED";
-const EMPTY_COLUMN_DROPPED_CODE = "W_EMPTY_COLUMN_DROPPED";
-const STORAGE_CLASS_CODE = "W_STORAGE_CLASS_CHANGED";
-const INTEGRAL_F64_CODE = "W_INTEGRAL_F64_AS_I32";
-const TEXT_INFERRED_CODE = "W_TEXT_INFERRED";
-const XML_ILLEGAL_CHAR_CODE = "E_XML_ILLEGAL_CHAR";
-const COLUMN_AS_PROPERTY_VALUE_CODE = "W_COLUMN_AS_PROPERTY_VALUE";
-const RELATION_ASSUMED_CODE = "W_RELATION_ASSUMED";
-const TYPEDEF_NODES_CODE = "W_TYPEDEF_NODES";
-const GRAPH_COLUMN_AS_METADATA_CODE = "W_GRAPH_COLUMN_AS_METADATA";
-const DIRECTION_DROPPED_CODE = "W_DIRECTION_DROPPED";
-const NONFINITE_AS_NULL_CODE = "W_NONFINITE_AS_NULL";
-const NODE_ORDER_CODE = "W_NODE_ORDER";
-const OPTIONS_GAINED_CODE = "W_OPTIONS_GAINED";
-const ELEMENT_ISSUE = Object.freeze({
-  /** A node id of a type the graph cannot hold (an empty id, a non-finite number, an object). The node is skipped. */
-  INVALID_ID: "E_INVALID_ID",
-  /** An edge names a node the file never declares, while `addMissingNodes` is false. The edge is skipped. */
-  UNKNOWN_NODE: "E_UNKNOWN_NODE",
-  /**
-   * An edge weight that is not a number (text such as "2,5" with a decimal comma, NaN, a boolean). The whole edge is
-   * skipped, not only its weight.
-   */
-  INVALID_WEIGHT: "E_INVALID_WEIGHT",
-  /** A second edge between the same two nodes, while `duplicateEdges` is "error". The edge is skipped. */
-  DUPLICATE_EDGE: DUPLICATE_EDGE_CODE,
-  /** An edge from a node to itself, while `selfLoops` is "error". The edge is skipped. */
-  SELF_LOOP: SELF_LOOP_CODE,
-  /** An edge id declared twice. The second edge is skipped. */
-  DUPLICATE_EDGE_ID: DUPLICATE_EDGE_ID_CODE
-});
-const INPUT_ISSUE = Object.freeze({
-  /** The input is empty or holds only whitespace. The import stops. */
-  EMPTY_INPUT: EMPTY_INPUT_CODE,
-  /** The input, or one of its lines, is longer than a JavaScript string can hold. The import stops. */
-  TOO_LARGE: TOO_LARGE_CODE,
-  /** A byte order mark, the encoding option and the declared encoding disagree. */
-  ENCODING_CONFLICT: ENCODING_CONFLICT_CODE,
-  /** A control character or a stray U+FEFF in the text, or an ignored trailing Ctrl-Z. */
-  CONTROL_CHARACTER: CONTROL_CHARACTER_CODE,
-  /** The input is an HTML page, a PDF, compressed or zip data, or an image. The import stops. */
-  FOREIGN_FORMAT: FOREIGN_FORMAT_CODE,
-  /** Warnings of one code beyond the number a report keeps, counted in one warning. */
-  ISSUES_SUPPRESSED: ISSUES_SUPPRESSED_CODE
-});
-function plural(n) {
-  return n === 1 ? "" : "s";
-}
-function agree(n, one, many) {
-  return n === 1 ? one : many;
-}
-function elementCount(nodes, edges) {
-  const parts = [];
-  if (nodes > 0 || edges === 0) {
-    parts.push(`${nodes} node${plural(nodes)}`);
-  }
-  if (edges > 0) {
-    parts.push(`${edges} edge${plural(edges)}`);
-  }
-  return parts.join(" and ");
-}
-function withArticle(word) {
-  return `${/^[aeiou]/i.test(word) ? "an" : "a"} ${word}`;
-}
+import { aR as withArticle, C as COLUMN_RENAMED_CODE, U as UNKNOWN_ATTR_TYPE_CODE, R as ROLE_TAKEN_CODE, B as BAD_DEFAULT_CODE, ae as BAD_OPTIONS_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, M as MIXED_DIRECTION_CODE, O as OPTION_IGNORED_CODE, au as CONTROL_CHARACTER_CODE, E as EMPTY_INPUT_CODE, a1 as TOO_LARGE_CODE, t as INVALID_ENCODING_CODE, r as UNKNOWN_ENCODING_CODE, q as ENCODING_CONFLICT_CODE, u as INVALID_UTF8_CODE, s as ENCODING_FALLBACK_CODE, az as FOREIGN_FORMAT_CODE, N as NO_GRAPH_CODE, a2 as AMBIGUOUS_GRAPH_NAME_CODE, a3 as GRAPH_NOT_FOUND_CODE, p as plural, S as SINK_OPTION_CODE, ad as formatInteger, $ as formatF32, a0 as formatF64, P as PRECISION_CODE, aM as WEIGHTS_DROPPED_CODE, aE as NONFINITE_AS_NULL_CODE, aF as OPTIONS_GAINED_CODE, ac as XML_ILLEGAL_CHAR_CODE, aL as TEXT_INFERRED_CODE, aB as INTEGRAL_F64_CODE, aI as STORAGE_CLASS_CODE, ax as EMPTY_COLUMN_DROPPED_CODE, at as COLUMN_RENAMED_LOSS_CODE, aa as ROLE_ASSUMED_CODE, aN as WEIGHT_KEY_CLASH_CODE, aA as ID_TEXT_COLLISION_CODE, z as ID_TEXT_TYPE_CODE, G as MUTUAL_AS_UNDIRECTED_CODE, aD as MUTUAL_EXPANDED_CODE, F as PARENTS_DROPPED_CODE, A as ROLE_DROPPED_CODE, aK as TEMPORAL_TEXT_DROPPED_CODE, aJ as TEMPORAL_DROPPED_CODE, as as COLUMN_DROPPED_CODE, V as agree } from "./format-GDmO6m6Q.js";
 const TIME_TEXT_ROLE = "timeText";
 const TIME_TEXT_SUFFIX = ".text";
 const DATE_TIME$1 = /^(-?\d{4,})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?)?(Z|z|[+-]\d{2}(?::?\d{2})?)?$/;
@@ -734,7 +596,7 @@ function declareAttribute(input) {
       issues.push({
         category: "validation-error",
         code: BAD_DEFAULT_CODE,
-        message: `default "${defaultText}" of attribute "${name}" does not parse as ${spec.declared}: ${messageOf$1(err)}`
+        message: `default "${defaultText}" of attribute "${name}" does not parse as ${spec.declared}: ${messageOf(err)}`
       });
     }
   }
@@ -768,7 +630,7 @@ function declareOptions(decl, spec, optionsText, listSyntax, issues) {
     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)}`
+      message: `options "${optionsText}" of attribute "${decl.name}" do not parse as ${spec.declared}: ${messageOf(err)}`
     });
   }
   return spec;
@@ -954,7 +816,7 @@ function resolveName(input) {
 function parseItem(text, spec) {
   return parseScalarText(text, spec.kind, spec.temporal);
 }
-function messageOf$1(err) {
+function messageOf(err) {
   return err instanceof Error ? err.message : String(err);
 }
 const DIRECTED_COLUMN = "graphty.directed";
@@ -2058,9 +1920,13 @@ function checkContinuation(bytes, i, sequence) {
 }
 function controlByte(bytes, final) {
   const last = bytes.byteLength - 1;
-  return bytes.findIndex(
-    (b, i) => b < 32 && b !== 9 && b !== 10 && b !== 12 && b !== 13 && !(b === 26 && final && i === last)
-  );
+  for (let i = 0; i <= last; i++) {
+    const b = bytes[i];
+    if (b < 32 && b !== 9 && b !== 10 && b !== 12 && b !== 13 && !(b === 26 && final && i === last)) {
+      return i;
+    }
+  }
+  return -1;
 }
 function decodeEntryName(bytes, cp437 = false) {
   try {
@@ -3060,403 +2926,6 @@ function describe(value) {
 function list(allowed) {
   return [...allowed].map((v) => JSON.stringify(v)).join(", ");
 }
-class ImportError extends GraphFormatError {
-  /**
-   * Create an ImportError.
-   * @param message - a plain-ASCII human-readable message
-   * @param report - the partial report
-   * @param details - optional machine-readable context; its `code` names the issue that stopped the import
-   */
-  constructor(message, report, details) {
-    super("E_IMPORT", message, details);
-    this.name = "ImportError";
-    Object.defineProperty(this, "report", { value: report, enumerable: false });
-    this.issue = stoppingIssue(report.issues, details?.code);
-  }
-}
-function stoppingIssue(issues, code) {
-  let lastError = null;
-  for (let i = issues.length - 1; i >= 0; i--) {
-    if (issues[i].code === code) {
-      return issues[i];
-    }
-    if (lastError === null && issues[i].severity === "error") {
-      lastError = issues[i];
-    }
-  }
-  return lastError;
-}
-const MAX_WARNINGS_PER_CODE = 1e3;
-const CATEGORY_BY_CODE = {
-  E_UNKNOWN_NODE: "missing-value",
-  E_UNKNOWN_COLUMN: "missing-value",
-  E_DIRECTED: "coercion",
-  E_TOO_LARGE: "unsupported",
-  E_UNSUPPORTED: "unsupported",
-  E_GPU_INELIGIBLE: "unsupported"
-};
-const PARSE_ERROR_CODE = "E_PARSE";
-function withLine(message, where) {
-  const line = where?.line;
-  return line === void 0 || line === null || message.includes(`line ${line}`) ? message : `line ${line}: ${message}`;
-}
-class ImportReportBuilder {
-  /**
-   * Create a builder for one import call.
-   * @param format - the importer's format name
-   * @param errorLimit - errors tolerated before the import aborts; Infinity for no limit
-   */
-  constructor(format, errorLimit) {
-    this.counts = { nodes: 0, edges: 0, skippedNodes: 0, skippedEdges: 0, expandedMixed: 0 };
-    this.issueList = [];
-    this.lossList = [];
-    this.onceCodes = /* @__PURE__ */ new Set();
-    this.warningsByCode = /* @__PURE__ */ new Map();
-    this.errors = 0;
-    this.warnings = 0;
-    this.truncatedFlag = false;
-    this.format = format;
-    this.errorLimit = errorLimit;
-    this.startedAt = now();
-  }
-  /**
-   * Issues recorded so far, in order.
-   * @returns the live list (not copied; finish() copies)
-   */
-  get issues() {
-    return this.issueList;
-  }
-  /**
-   * Issues with severity "error".
-   * @returns the count
-   */
-  get errorCount() {
-    return this.errors;
-  }
-  /**
-   * Issues with severity "warning".
-   * @returns the count
-   */
-  get warningCount() {
-    return this.warnings;
-  }
-  /**
-   * Whether the error limit was exceeded.
-   * @returns true once an error beyond the limit was recorded
-   */
-  get truncated() {
-    return this.truncatedFlag;
-  }
-  /**
-   * Loss notes recorded so far.
-   * @returns the live list
-   */
-  get lossy() {
-    return this.lossList;
-  }
-  /**
-   * Record an error. When the count goes beyond the error limit the report is marked truncated
-   * and an ImportError carrying it is thrown; the importer does not catch that.
-   * @param category - the issue category
-   * @param code - a stable code such as "E_UNKNOWN_NODE"
-   * @param message - a plain-ASCII message
-   * @param where - the line and element, when known
-   * @returns the recorded issue
-   */
-  error(category, code, message, where) {
-    const issue = makeIssue(category, "error", code, message, where);
-    this.issueList.push(issue);
-    this.errors++;
-    if (this.errors > this.errorLimit) {
-      this.truncatedFlag = true;
-      throw this.abort(`error limit of ${this.errorLimit} exceeded: ${withLine(message, where)}`, {
-        code,
-        limit: this.errorLimit
-      });
-    }
-    return issue;
-  }
-  /**
-   * Record a warning; warnings never count toward the limit. Beyond MAX_WARNINGS_PER_CODE
-   * warnings of one code the warning is counted, not kept: finish() adds one W_ISSUES_SUPPRESSED
-   * warning per such code with the number dropped.
-   * @param category - the issue category
-   * @param code - a stable code such as "W_WIDENED"
-   * @param message - a plain-ASCII message
-   * @param where - the line and element, when known
-   * @returns the recorded issue
-   */
-  warning(category, code, message, where) {
-    const issue = makeIssue(category, "warning", code, message, where);
-    const seen = (this.warningsByCode.get(code) ?? 0) + 1;
-    this.warningsByCode.set(code, seen);
-    if (seen <= MAX_WARNINGS_PER_CODE) {
-      this.issueList.push(issue);
-      this.warnings++;
-    }
-    return issue;
-  }
-  /**
-   * Record a warning the first time its key is seen and ignore later repeats, for conditions
-   * that would otherwise produce one warning per row.
-   * @param category - the issue category
-   * @param code - the stable code
-   * @param message - a plain-ASCII message
-   * @param where - the line and element, when known
-   * @param key - what repeats are deduplicated on; the code itself by default (pass `code:column`
-   * to warn once per column)
-   * @returns the recorded issue, or null when the key was already recorded
-   */
-  warnOnce(category, code, message, where, key = code) {
-    if (this.onceCodes.has(key)) {
-      return null;
-    }
-    this.onceCodes.add(key);
-    return this.warning(category, code, message, where);
-  }
-  /**
-   * Record something the importer could not represent.
-   * @param code - a stable code
-   * @param message - a plain-ASCII message
-   * @param column - the affected column, or null
-   * @param count - the affected count, or null
-   * @returns the recorded note
-   */
-  loss(code, message, column = null, count = null) {
-    const note = Object.freeze({ code, message, column, count });
-    this.lossList.push(note);
-    return note;
-  }
-  /**
-   * The per-element catch: record a thrown GraphFormatError as an error
-   * issue with its code and the category the code implies. Anything else is re-thrown unchanged:
-   * an ImportError (the import already aborted), an abort reason, and any other thrown value (a
-   * TypeError or RangeError is a programming error in the importer or the sink, never a defect of
-   * the input, so it must surface as an exception rather than as an issue blamed on the file).
-   * @param err - the thrown value
-   * @param where - the line and element, when known
-   * @returns the recorded issue
-   */
-  recordError(err, where) {
-    if (err instanceof GraphFormatError && !(err instanceof ImportError)) {
-      const category = CATEGORY_BY_CODE[err.code] ?? "validation-error";
-      if (err.code === "E_TOO_LARGE") {
-        return this.failWith(category, err.code, err.message, where);
-      }
-      return this.error(category, err.code, err.message, where);
-    }
-    throw err;
-  }
-  /**
-   * A builder that starts from everything this one recorded so far: issues, counts, loss notes,
-   * the warnOnce keys, the error and warning counts and the truncation flag. For an importer that
-   * reads its input once and emits several graphs, each with its own report.
-   * @returns the copy; later records to either builder do not reach the other
-   */
-  fork() {
-    const copy = new ImportReportBuilder(this.format, this.errorLimit);
-    Object.assign(copy.counts, this.counts);
-    copy.issueList.push(...this.issueList);
-    copy.lossList.push(...this.lossList);
-    for (const key of this.onceCodes) {
-      copy.onceCodes.add(key);
-    }
-    for (const [code, count] of this.warningsByCode) {
-      copy.warningsByCode.set(code, count);
-    }
-    copy.errors = this.errors;
-    copy.warnings = this.warnings;
-    copy.truncatedFlag = this.truncatedFlag;
-    return copy;
-  }
-  /**
-   * Build the ImportError that aborts the import, carrying the report so far. The caller throws
-   * it; this method only constructs it so it can be used in expression position.
-   * @param message - a plain-ASCII message
-   * @param details - optional machine-readable context
-   * @returns the error to throw
-   */
-  abort(message, details) {
-    return new ImportError(message, this.finish(), details);
-  }
-  /**
-   * Record a fatal parse error and abort: the issue is recorded (even beyond the error limit)
-   * and an ImportError carrying the report is thrown.
-   * @param code - a stable code such as "E_INVALID_UTF8"
-   * @param message - a plain-ASCII message
-   * @param where - the line and element, when known
-   * @param details - optional machine-readable context for the ImportError
-   */
-  fail(code, message, where, details) {
-    this.failWith("parse-error", code, message, where, details);
-  }
-  /**
-   * Record a fatal error of any category and abort, as fail() does for a parse error: a size
-   * limit (E_TOO_LARGE, category "unsupported") stops an import without being a defect of the
-   * syntax. A fatal error is not the error limit: `truncated` stays as it was.
-   * @param category - the issue category
-   * @param code - a stable code
-   * @param message - a plain-ASCII message
-   * @param where - the line and element, when known
-   * @param details - optional machine-readable context for the ImportError
-   */
-  failWith(category, code, message, where, details) {
-    this.issueList.push(makeIssue(category, "error", code, message, where));
-    this.errors++;
-    throw this.abort(withLine(message, where), { code, ...details });
-  }
-  /**
-   * Add a finished report to this one: its issues after the ones recorded so far, its counts, its
-   * loss notes and its truncated flag. Use it when an importer hands part of the work to another
-   * importer (for example, a wrapper around the CSV importer) and returns one report for both. The issues
-   * keep their codes; errors added this way do not count toward this report's error limit, since
-   * the other importer applied its own.
-   * @param report - the report the other importer returned
-   * @returns this builder
-   * @example
-   * ```ts
-   * const report = new ImportReportBuilder("netscope", opts.errorLimit);
-   * const text = await readText(input, report, opts);
-   * report.include(await csvImporter.import(text, sink, options));
-   * return report.finish();
-   * ```
-   */
-  include(report) {
-    for (const issue of report.issues) {
-      this.issueList.push(issue);
-      if (issue.severity === "error") {
-        this.errors++;
-      } else {
-        this.warnings++;
-      }
-    }
-    const { counts } = report;
-    this.counts.nodes += counts.nodes;
-    this.counts.edges += counts.edges;
-    this.counts.skippedNodes += counts.skippedNodes;
-    this.counts.skippedEdges += counts.skippedEdges;
-    this.counts.expandedMixed += counts.expandedMixed;
-    this.lossList.push(...report.lossy);
-    this.truncatedFlag ||= report.truncated;
-    return this;
-  }
-  /**
-   * The report as it stands: a frozen snapshot with the parse duration so far. Can be called more
-   * than once; each call reflects everything recorded up to that point.
-   * @returns the report
-   */
-  finish() {
-    const { nodes, edges, skippedNodes, skippedEdges, expandedMixed } = this.counts;
-    const suppressed = [];
-    for (const [code, seen] of this.warningsByCode) {
-      if (seen > MAX_WARNINGS_PER_CODE) {
-        const more = seen - MAX_WARNINGS_PER_CODE;
-        suppressed.push(
-          makeIssue(
-            "unsupported",
-            "warning",
-            ISSUES_SUPPRESSED_CODE,
-            `${more} more ${code} warning${plural(more)} ${agree(more, "was", "were")} not kept (the report keeps the first ${MAX_WARNINGS_PER_CODE})`,
-            { element: code }
-          )
-        );
-      }
-    }
-    return Object.freeze({
-      format: this.format,
-      counts: Object.freeze({ nodes, edges, skippedNodes, skippedEdges, expandedMixed }),
-      issues: Object.freeze([...this.issueList, ...suppressed]),
-      errorCount: this.errors,
-      warningCount: this.warnings + suppressed.length,
-      truncated: this.truncatedFlag,
-      lossy: Object.freeze([...this.lossList]),
-      durationMs: now() - this.startedAt
-    });
-  }
-}
-function makeIssue(category, severity, code, message, where) {
-  return Object.freeze({
-    category,
-    severity,
-    code,
-    message,
-    line: where?.line ?? null,
-    element: where?.element ?? null
-  });
-}
-function isAbortError(err) {
-  if (typeof err !== "object" || err === null) {
-    return false;
-  }
-  const { name } = err;
-  return name === "AbortError" || name === "TimeoutError";
-}
-function messageOf(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  if (typeof err === "string") {
-    return err;
-  }
-  return `non-error thrown (${typeof err})`;
-}
-function now() {
-  return typeof performance === "object" ? performance.now() : Date.now();
-}
-function formatF32(value) {
-  if (!Number.isFinite(value)) {
-    return String(value);
-  }
-  if (value === 0) {
-    return Object.is(value, -0) ? "-0" : "0";
-  }
-  for (let digits = 1; digits <= 9; digits++) {
-    const text = value.toPrecision(digits);
-    if (Math.fround(Number(text)) === value) {
-      return String(Number(text));
-    }
-  }
-  return String(value);
-}
-function formatF64(value) {
-  return Object.is(value, -0) ? "-0" : String(value);
-}
-function idText(id) {
-  return typeof id === "number" ? formatF64(id) : id;
-}
-function formatDecimal(value, dtype = "f64") {
-  if (!Number.isFinite(value)) {
-    return String(value);
-  }
-  if (Object.is(value, -0)) {
-    return "-0.0";
-  }
-  const text = formatNumber(value, dtype);
-  return text.includes(".") || text.includes("e") ? text : `${text}.0`;
-}
-function formatGmlReal(value, dtype = "f64") {
-  if (Number.isNaN(value)) {
-    return "NAN";
-  }
-  if (!Number.isFinite(value)) {
-    return value > 0 ? "+INF" : "-INF";
-  }
-  const text = formatDecimal(value, dtype);
-  if (text.includes(".")) {
-    return text;
-  }
-  const e = text.indexOf("e");
-  return `${text.slice(0, e)}.0${text.slice(e)}`;
-}
-function formatInteger(value) {
-  if (Number.isSafeInteger(value) || !Number.isFinite(value)) {
-    return String(value);
-  }
-  return BigInt(value).toString();
-}
-function formatNumber(value, dtype) {
-  return dtype === "f32" ? formatF32(value) : formatF64(value);
-}
 const DEFAULT_WEIGHT = 1;
 function isWeightField(name, weightFrom) {
   return weightFrom !== null && name === weightFrom;
@@ -3978,103 +3447,145 @@ const ROLE_WORDS = {
   position: "positions",
   originalId: "original ids"
 };
+function setCount(column) {
+  return column.length - column.nullCount;
+}
 function checkColumns(table, domain, caps, extras, note) {
+  const check = { domain, caps, extras, note };
   for (const column of table) {
-    const { name, role } = column.meta;
-    if (role !== null && STRUCTURAL_ROLES.has(role)) {
-      continue;
-    }
-    const label = `${domain} column "${name}"`;
-    noteRenamedRole(column, label, roleNamesOf(domain, extras), note);
-    if (domain === "edge" && role === "id") {
-      continue;
-    }
-    if (isDroppedColumn(column, domain, extras)) {
-      note(LOSS.COLUMN_DROPPED, `${label} is not written`, name, column.length - column.nullCount);
-      continue;
-    }
-    if (!checkSlotRole(column, label, caps, extras, note)) {
-      checkAttributeColumn(column, label, caps, extras, note);
-    }
+    checkColumn(column, check);
   }
 }
-function noteRenamedRole(column, label, roleNames, note) {
+function checkColumn(column, check) {
   const { name, role } = column.meta;
-  if (role === null || roleNames === void 0) {
+  if (role !== null && STRUCTURAL_ROLES.has(role)) {
     return;
   }
-  const fixed = roleNames[role];
-  if (fixed !== void 0 && fixed !== name) {
-    note(
+  const label = `${check.domain} column "${name}"`;
+  noteRoleRenamed(column, label, check);
+  if (check.domain === "edge" && role === "id") {
+    return;
+  }
+  if (isDropped(column, check)) {
+    check.note(LOSS.COLUMN_DROPPED, `${label} is not written`, name, setCount(column));
+    return;
+  }
+  const slot = role === null ? void 0 : ROLE_SLOT_CHECKS.find(([holds]) => holds(role));
+  if (slot !== void 0) {
+    slot[1](column, label, check);
+    return;
+  }
+  checkAttribute(column, label, check);
+}
+function noteRoleRenamed(column, label, check) {
+  const { name, role } = column.meta;
+  const fixed = role === null ? void 0 : roleNamesOf(check.domain, check.extras)?.[role];
+  if (role !== null && fixed !== void 0 && fixed !== name) {
+    check.note(
       LOSS.COLUMN_NAME_CHANGED,
       `${label} (the ${ROLE_WORDS[role] ?? role}) is written as the format's own ${role} and reads back as "${fixed}"`,
       name,
-      column.length - column.nullCount
+      setCount(column)
     );
   }
 }
-function isDroppedColumn(column, domain, extras) {
+function isDropped(column, check) {
   const { name, role } = column.meta;
+  const { domain, extras } = check;
   const named = extras.writtenColumns?.[domain]?.includes(name) ?? false;
-  return writesAttributes(domain, extras) === false && !named && !(role !== null && (extras.roles?.has(role) ?? false));
-}
-function slotRules() {
-  const rules = /* @__PURE__ */ new Map();
-  const add = (roles, rule) => {
-    for (const role of roles) {
-      rules.set(role, rule);
+  const kept = role !== null && (extras.roles?.has(role) ?? false);
+  return writesAttributes(domain, extras) === false && !named && !kept;
+}
+const ROLE_SLOT_CHECKS = [
+  [
+    (role) => role === "timeText",
+    (column, label, check) => {
+      if (check.extras.temporalText !== true) {
+        check.note(
+          LOSS.TEMPORAL_TEXT,
+          `${label} (the original text of a date or time column) cannot be written`,
+          column.meta.name,
+          setCount(column)
+        );
+      }
     }
-  };
-  add(["timeText"], {
-    code: LOSS.TEMPORAL_TEXT,
-    what: "the original text of a date or time column",
-    written: (_caps, extras) => extras.temporalText === true
-  });
-  add(VIZ_ROLES, { code: LOSS.VIZ, written: (caps) => caps.viz });
-  add(HIERARCHY_ROLES, { code: LOSS.HIERARCHY, written: (caps) => caps.hierarchy });
-  add(TEMPORAL_ROLES, { code: LOSS.TEMPORAL, written: (caps) => caps.temporal !== "none" });
-  add(["spells"], {
-    code: LOSS.SPELLS,
-    what: "spells",
-    written: (caps) => caps.temporal === "spells" || caps.temporal === "dynamic-values"
-  });
-  add(["open", "spellsOpen"], {
-    code: LOSS.OPEN_INTERVAL,
-    what: "open intervals",
-    written: (_caps, extras) => extras.openIntervals === true
-  });
-  return rules;
-}
-const SLOT_RULES = slotRules();
-function checkSlotRole(column, label, caps, extras, note) {
-  const { name, role } = column.meta;
-  if (role === "position") {
-    checkPositionColumn(column, label, caps, extras, note);
-    return true;
-  }
-  const rule = role === null ? void 0 : SLOT_RULES.get(role);
-  if (role === null || rule === void 0) {
-    return false;
-  }
-  if (!rule.written(caps, extras)) {
-    note(rule.code, `${label} (${rule.what ?? role}) cannot be written`, name, column.length - column.nullCount);
-  }
-  return true;
-}
-function checkPositionColumn(column, label, caps, extras, note) {
+  ],
+  [(role) => role === "position", checkPosition],
+  // Deprecated path (removed in the next major version): the role columns as the old way styles reached a
+  // file. With styles, the style writer is the only path and the caller leaves the role columns out.
+  [(role) => VIZ_ROLES.has(role), checkViz],
+  [
+    (role) => HIERARCHY_ROLES.has(role),
+    (column, label, check) => {
+      if (!check.caps.hierarchy) {
+        const { name, role } = column.meta;
+        check.note(LOSS.HIERARCHY, `${label} (${String(role)}) cannot be written`, name, setCount(column));
+      }
+    }
+  ],
+  [
+    (role) => TEMPORAL_ROLES.has(role),
+    (column, label, check) => {
+      if (check.caps.temporal === "none") {
+        const { name, role } = column.meta;
+        check.note(LOSS.TEMPORAL, `${label} (${String(role)}) cannot be written`, name, setCount(column));
+      }
+    }
+  ],
+  [
+    (role) => role === "spells",
+    (column, label, check) => {
+      if (check.caps.temporal !== "spells" && check.caps.temporal !== "dynamic-values") {
+        check.note(LOSS.SPELLS, `${label} (spells) cannot be written`, column.meta.name, setCount(column));
+      }
+    }
+  ],
+  [
+    // The open bits are written by the format's own temporal syntax when it has one; the
+    // column's u8 storage is never an attribute dtype, so no dtype note either way.
+    (role) => role === "open" || role === "spellsOpen",
+    (column, label, check) => {
+      if (check.extras.openIntervals !== true) {
+        check.note(
+          LOSS.OPEN_INTERVAL,
+          `${label} (open intervals) cannot be written`,
+          column.meta.name,
+          setCount(column)
+        );
+      }
+    }
+  ]
+];
+function checkPosition(column, label, check) {
+  const { caps, extras, note } = check;
   const { meta } = column;
   if (!caps.positions) {
-    note(LOSS.POSITIONS, `${label} (positions) cannot be written`, meta.name, column.length - column.nullCount);
+    note(LOSS.POSITIONS, `${label} (positions) cannot be written`, meta.name, setCount(column));
   } else if (extras.positionDtype !== void 0 && meta.dtype !== extras.positionDtype) {
     note(
       LOSS.DTYPE,
       `${label} (positions) is ${meta.dtype}; the format reads positions back as ${extras.positionDtype}`,
       meta.name,
-      column.length - column.nullCount
+      setCount(column)
     );
   }
 }
-function checkAttributeColumn(column, label, caps, extras, note) {
+function checkViz(column, label, check) {
+  const { caps, extras, note } = check;
+  if (caps.viz) {
+    return;
+  }
+  const { name } = column.meta;
+  const role = String(column.meta.role);
+  note(
+    LOSS.VIZ,
+    extras.vizAsAttributes === true ? `${label} (${role}) is written as a plain attribute; the format has no ${role} slot and the role is lost on re-import` : `${label} (${role}) cannot be written`,
+    name,
+    setCount(column)
+  );
+}
+function checkAttribute(column, label, check) {
+  const { caps, extras, note } = check;
   const { meta } = column;
   const { name, role } = meta;
   if (role !== null && !(extras.roles?.has(role) ?? false)) {
@@ -4082,7 +3593,7 @@ function checkAttributeColumn(column, label, caps, extras, note) {
       LOSS.ROLE,
       `${label} (${role}) is written as a plain attribute; the format has no ${role} slot and the role is lost`,
       name,
-      column.length - column.nullCount
+      setCount(column)
     );
   }
   if (meta.dynamic && caps.temporal !== "dynamic-values") {
@@ -4345,188 +3856,81 @@ function mangleNmtoken(text) {
   return out.length === 0 ? "_" : out;
 }
 export {
-  agree as $,
-  COLUMN_TYPE_CODE as A,
-  BAD_DEFAULT_CODE as B,
-  COLUMN_RENAMED_CODE as C,
-  DIRECTION_FORCED_CODE as D,
-  EMPTY_INPUT_CODE as E,
-  ELEMENT_ISSUE as F,
-  INPUT_ISSUE as G,
-  HYPEREDGE_CODE as H,
-  ID_MERGED_CODE as I,
-  ID_TEXT_TYPE_CODE as J,
-  ROLE_DROPPED_CODE as K,
+  PAIR_COLUMN as $,
+  losesPrecision as A,
+  parseTimeText as B,
+  splitListText as C,
+  DictHeuristic as D,
+  timeTextCompanion as E,
+  parseDecimalText as F,
+  sanitizeIds as G,
+  formatTimeValue as H,
+  IdCoercer as I,
+  mapDeclaredType as J,
+  joinListText as K,
   LOSS as L,
-  MIXED_DIRECTION_CODE as M,
-  NO_GRAPH_CODE as N,
-  OPTION_IGNORED_CODE as O,
-  PRECISION_CODE as P,
-  PARENTS_DROPPED_CODE as Q,
-  ROLE_TAKEN_CODE as R,
-  SINK_OPTION_CODE as S,
-  MUTUAL_AS_UNDIRECTED_CODE as T,
-  UNKNOWN_ATTR_TYPE_CODE as U,
-  BAD_ASPECT_BLOCK_CODE as V,
-  MULTI_ASPECT_FRAGMENT_CODE as W,
-  XML_SYNTAX_CODE as X,
-  ASPECT_ORDER_CODE as Y,
-  STATUS_FAILED_CODE as Z,
-  STATUS_WARNING_CODE as _,
+  MAX_TEXT_LENGTH as M,
+  formatTemporal as N,
+  isCanonicalIntegerText as O,
+  LineReader as P,
+  describe as Q,
+  RENAMED_CODE as R,
+  normalizeInput as S,
+  TIME_TEXT_ROLE as T,
+  foreignKind as U,
+  lockReader as V,
+  abortable as W,
+  DEFAULT_ERROR_LIMIT as X,
+  DIRECTED_COLUMN as Y,
+  MUTUAL_COLUMN as Z,
+  NO_CAPABILITIES as _,
   checkCapabilities as a,
-  COLUMN_RENAMED_LOSS_CODE as a$,
-  uniqueColumnName as a0,
-  declareResolved as a1,
-  JSON_NONSTANDARD_NUMBER_CODE as a2,
-  BAD_VALUE_CODE as a3,
-  textChunks as a4,
-  MAX_TEXT_LENGTH as a5,
-  tooLarge as a6,
-  chooseGraph as a7,
-  ImportReportBuilder as a8,
-  idText as a9,
-  NODE_ORDER_CODE as aA,
-  GRAPH_COLUMN_AS_METADATA_CODE as aB,
-  TYPEDEF_NODES_CODE as aC,
-  RELATION_ASSUMED_CODE as aD,
-  sanitizeIds as aE,
-  formatDecimal as aF,
-  formatInteger as aG,
-  canonicalId as aH,
-  coerceIdText as aI,
-  isWeightField as aJ,
-  parseWeightText as aK,
-  isAbortError as aL,
-  BAD_LINE_CODE as aM,
-  messageOf as aN,
-  describe as aO,
-  UNKNOWN_OPTION_CODE as aP,
-  normalizeInput as aQ,
-  foreignKind as aR,
-  ImportError as aS,
-  FETCH_CODE as aT,
-  EDGES_MERGED_CODE as aU,
-  SELF_LOOPS_DROPPED_CODE as aV,
-  WEIGHT_NOT_FOUND_CODE as aW,
-  lockReader as aX,
-  abortable as aY,
-  BAD_OPTIONS_CODE as aZ,
-  COLUMN_DROPPED_CODE as a_,
-  formatF32 as aa,
-  formatF64 as ab,
-  DictHeuristic as ac,
-  TOO_LARGE_CODE as ad,
-  AMBIGUOUS_GRAPH_NAME_CODE as ae,
-  GRAPH_NOT_FOUND_CODE as af,
-  SINGLE_OBJECT_ASPECT_CODE as ag,
-  STYLES_NOT_IMPORTED_CODE as ah,
-  PARENT_CYCLE_CODE as ai,
-  WIDENED_CODE as aj,
-  SYNTAX_CODE as ak,
-  resolveImportOptions as al,
-  throwIfAborted as am,
-  reportUnusedOptions as an,
-  reportSinkOptions as ao,
-  graphChosen as ap,
-  DirectionResolver as aq,
-  IdCoercer as ar,
-  weightFromValue as as,
-  COLUMN_AS_PROPERTY_VALUE_CODE as at,
-  ROLE_ASSUMED_CODE as au,
-  formatNumber as av,
-  isNameChar as aw,
-  XML_ILLEGAL_CHAR_CODE as ax,
-  RENAMED_CODE as ay,
-  LineReader as az,
-  plural as b,
-  readBytes as b$,
-  CONTROL_CHARACTER_CODE as b0,
-  DEFAULT_ERROR_LIMIT as b1,
-  DIRECTED_COLUMN as b2,
-  DIRECTION_DROPPED_CODE as b3,
-  DUPLICATE_EDGE_CODE as b4,
-  EMPTY_COLUMN_DROPPED_CODE as b5,
-  EQUATION_AS_TEXT_CODE as b6,
-  FOREIGN_FORMAT_CODE as b7,
-  ID_TEXT_COLLISION_CODE as b8,
-  INTEGRAL_F64_CODE as b9,
-  mangleNmtoken as bA,
-  readText as bB,
-  refusedSave as bC,
-  countMixedEdges as bD,
-  canonicalEncoding as bE,
-  TIME_TEXT_ROLE as bF,
-  TIME_TEXT_SUFFIX as bG,
-  declareAttribute as bH,
-  overflowsToInfinity as bI,
-  parseDeclaredTemporal as bJ,
-  parseDeclaredValue as bK,
-  losesPrecision as bL,
-  parseTimeText as bM,
-  splitListText as bN,
-  timeTextCompanion as bO,
-  parseDecimalText as bP,
-  formatTimeValue as bQ,
-  mapDeclaredType as bR,
-  joinListText as bS,
-  formatTemporal as bT,
-  DICT_SAMPLE_ROWS as bU,
-  reportWeightPrecision as bV,
-  takenIn as bW,
-  declareOn as bX,
-  parseTemporal as bY,
-  withArticle as bZ,
-  otherFormatDialect as b_,
-  ISSUES_SUPPRESSED_CODE as ba,
-  MUTUAL_COLUMN as bb,
-  MUTUAL_EXPANDED_CODE as bc,
-  NONFINITE_AS_NULL_CODE as bd,
-  NO_CAPABILITIES as be,
-  OPTIONS_GAINED_CODE as bf,
-  PAIR_COLUMN as bg,
-  PARSE_ERROR_CODE as bh,
-  SELF_LOOP_CODE as bi,
-  STORAGE_CLASS_CODE as bj,
-  TEMPORAL_DROPPED_CODE as bk,
-  TEMPORAL_TEXT_DROPPED_CODE as bl,
-  TEXT_INFERRED_CODE as bm,
-  UNKNOWN_TYPE_CODE as bn,
-  WEIGHTS_DROPPED_CODE as bo,
-  WEIGHT_KEY_CLASH_CODE as bp,
-  coerceId as bq,
-  declareCompanion as br,
-  decodeEntryName as bs,
-  edgeWeights as bt,
-  forDecodedText as bu,
-  formatGmlReal as bv,
-  inputLength as bw,
-  isCanonicalIntegerText as bx,
-  isImportInput as by,
-  isNmtoken as bz,
+  UNKNOWN_TYPE_CODE as a0,
+  canonicalId as a1,
+  coerceId as a2,
+  coerceIdText as a3,
+  decodeEntryName as a4,
+  edgeWeights as a5,
+  forDecodedText as a6,
+  inputLength as a7,
+  isImportInput as a8,
+  isNmtoken as a9,
+  mangleNmtoken as aa,
+  readText as ab,
+  refusedSave as ac,
+  declareOn as ad,
+  takenIn as ae,
+  parseTemporal as af,
+  DICT_SAMPLE_ROWS as ag,
+  otherFormatDialect as ah,
+  countMixedEdges as ai,
+  canonicalEncoding as aj,
+  readBytes as ak,
+  reportWeightPrecision as al,
+  tooLarge as b,
   capabilities as c,
-  elementCount as c0,
-  DIRECTION_REFUSED_CODE as d,
+  declareResolved as d,
   explicitWeights as e,
-  STRAY_TEXT_CODE as f,
-  UNKNOWN_ELEMENT_CODE as g,
-  UNKNOWN_XML_ATTRIBUTE_CODE as h,
-  DANGLING_REFERENCE_CODE as i,
-  COUNT_MISMATCH_CODE as j,
-  COUNT_HINT_CODE as k,
-  MULTIPLE_GRAPHS_CODE as l,
-  DUPLICATE_EDGE_ID_CODE as m,
-  DUPLICATE_NODE_CODE as n,
-  DUPLICATE_ATTRIBUTE_CODE as o,
+  chooseGraph as f,
+  resolveImportOptions as g,
+  throwIfAborted as h,
+  reportUnusedOptions as i,
+  reportSinkOptions as j,
+  graphChosen as k,
+  DirectionResolver as l,
+  TIME_TEXT_SUFFIX as m,
+  isNameChar as n,
+  isWeightField as o,
   pairFolding as p,
-  UNKNOWN_PARENT_CODE as q,
+  declareAttribute as q,
   resolveExportOptions as r,
-  MISSING_ENDPOINT_CODE as s,
-  MISSING_ID_CODE as t,
-  DUPLICATE_KEY_CODE as u,
-  ENCODING_CONFLICT_CODE as v,
-  UNKNOWN_ENCODING_CODE as w,
-  ENCODING_FALLBACK_CODE as x,
-  INVALID_ENCODING_CODE as y,
-  INVALID_UTF8_CODE as z
+  parseWeightText as s,
+  textChunks as t,
+  uniqueColumnName as u,
+  overflowsToInfinity as v,
+  weightFromValue as w,
+  parseDeclaredTemporal as x,
+  declareCompanion as y,
+  parseDeclaredValue as z
 };
-//# sourceMappingURL=export-rKLeGQMo.js.map
+//# sourceMappingURL=export-D7IGzTG4.js.map