@graphty/graph-io 0.3.47 → 0.3.49

package/dist/chunks/format-BXiAb-1h.js

@@ -0,0 +1,408 @@
+import { INVALID_INDEX, GraphFormatError } from "@graphty/graph-format";
+import { D as DIRECTION_FORCED_CODE, b as DIRECTION_REFUSED_CODE, M as MIXED_DIRECTION_CODE } from "./report-CwMfYa9J.js";
+const DIRECTED_COLUMN = "graphty.directed";
+const PAIR_COLUMN = "graphty.pair";
+const MUTUAL_COLUMN = "graphty.mutual";
+const DIRECTED_DECL = { name: DIRECTED_COLUMN, dtype: "bool", role: "directed" };
+const PAIR_DECL = { name: PAIR_COLUMN, dtype: "u32", role: "pair", refersTo: "edge" };
+const MUTUAL_DECL = { name: MUTUAL_COLUMN, dtype: "bool", role: "mutual" };
+class DirectionResolver {
+  /**
+   * Create a resolver.
+   * @param sink - the sink edges are pushed into
+   * @param report - the report issues are recorded in
+   * @param policy - the resolved onMixedDirection option
+   */
+  constructor(sink, report, policy) {
+    this.directedHandle = INVALID_INDEX;
+    this.pairHandle = INVALID_INDEX;
+    this.mutualHandle = INVALID_INDEX;
+    this.firstEdge = -1;
+    this.nextEdge = -1;
+    this.forcedCount = 0;
+    this.headerSet = false;
+    this.mirrorOfLast = INVALID_INDEX;
+    this.sink = sink;
+    this.report = report;
+    this.policy = policy;
+  }
+  /**
+   * The sink's current direction.
+   * @returns true when directed
+   */
+  get directed() {
+    return this.sink.directed;
+  }
+  /**
+   * Whether the graph holds undirected edges stored as two edges.
+   * @returns true once the first such edge was added
+   */
+  get expanded() {
+    return this.pairHandle !== INVALID_INDEX;
+  }
+  /**
+   * Set the graph's direction before the first edge: the direction the file declares, or the
+   * `defaultDirected` option for a file that declares none. Under `onMixedDirection` "directed" or
+   * "undirected" that direction is used instead, with a warning when it differs. When the sink
+   * cannot change direction (a caller's builder that already holds edges or was locked), the
+   * sink's direction stands and a warning is recorded.
+   * @param headerDirected - the direction the file declares (or the default)
+   * @param where - the line of the header, when known
+   */
+  setHeader(headerDirected, where) {
+    this.headerSet = true;
+    let wanted = headerDirected;
+    if (this.policy === "directed" || this.policy === "undirected") {
+      wanted = this.policy === "directed";
+      if (wanted !== headerDirected) {
+        this.report.warnOnce(
+          "coercion",
+          DIRECTION_FORCED_CODE,
+          `the file declares ${direction(headerDirected)} edges; read as ${direction(wanted)} per onMixedDirection`,
+          { line: where?.line ?? null },
+          `${DIRECTION_FORCED_CODE}:${direction(headerDirected)}`
+        );
+      }
+    }
+    const { sink } = this;
+    if (sink.directed === wanted) {
+      this.adoptExisting();
+      return;
+    }
+    try {
+      if (wanted && sink.edgeCount > 0 && !sink.directedLocked) {
+        const before = sink.edgeCount;
+        sink.setDirected(true, { expand: true });
+        this.adoptExpansionColumns();
+        this.report.counts.expandedMixed += before;
+      } else {
+        sink.setDirected(wanted);
+      }
+    } catch (err) {
+      if (!(err instanceof GraphFormatError) || err.code !== "E_DIRECTED") {
+        throw err;
+      }
+      this.report.warning(
+        "coercion",
+        DIRECTION_REFUSED_CODE,
+        `the file is ${direction(wanted)} but the sink is ${direction(sink.directed)} (${reasonOf(err)}); read as ${direction(sink.directed)}`,
+        { line: where?.line ?? null }
+      );
+    }
+    this.adoptExisting();
+  }
+  /**
+   * Pick up reserved columns a caller's sink already holds (an earlier expansion), so every edge
+   * pushed from now on gets its graphty.directed value.
+   */
+  adoptExisting() {
+    if (this.pairHandle === INVALID_INDEX && this.sink.edgeColumn(PAIR_COLUMN) !== INVALID_INDEX) {
+      this.adoptExpansionColumns();
+    }
+  }
+  /**
+   * The second edge of the edge the last addEdge() call added, when that edge was stored as two;
+   * otherwise INVALID_INDEX (4294967295). An edge attribute or weight you set after addEdge()
+   * belongs on both: set it on the index addEdge() returned and, when this is not INVALID_INDEX,
+   * on this index too.
+   * @returns the second edge's index, or INVALID_INDEX
+   */
+  get lastMirror() {
+    return this.mirrorOfLast;
+  }
+  /**
+   * Add one edge. An edge with the graph's direction is added as it is; one with the other
+   * direction is stored as two edges, given the graph's direction, or refused, as
+   * `onMixedDirection` says. When it is stored as two, the return value is the first and
+   * `lastMirror` the second.
+   * @param source - the source id
+   * @param target - the target id
+   * @param kind - the edge's direction in the file
+   * @param weight - the weight, or undefined when the file gives none
+   * @param where - the line and element, for issues
+   * @returns the index of the edge added (the first one, when it was stored as two)
+   */
+  addEdge(source, target, kind, weight, where) {
+    if (!this.headerSet) {
+      throw new GraphFormatError("E_DIRECTED", "DirectionResolver.setHeader() must run before the first edge", {
+        reason: "header not set"
+      });
+    }
+    const { sink } = this;
+    this.mirrorOfLast = INVALID_INDEX;
+    const edgeDirected = kind !== "undirected";
+    if (edgeDirected === sink.directed && kind !== "mutual") {
+      const e = sink.addEdge(source, target, weight);
+      this.track(e);
+      if (this.directedHandle !== INVALID_INDEX) {
+        sink.setEdgeValue(this.directedHandle, e, edgeDirected);
+      }
+      return e;
+    }
+    switch (this.policy) {
+      case "directed":
+      case "undirected": {
+        this.forcedCount++;
+        this.report.warnOnce(
+          "coercion",
+          DIRECTION_FORCED_CODE,
+          `${kind} edges read as ${direction(sink.directed)} per onMixedDirection`,
+          where,
+          `${DIRECTION_FORCED_CODE}:${kind}`
+        );
+        const e = sink.addEdge(source, target, weight);
+        this.track(e);
+        if (this.directedHandle !== INVALID_INDEX) {
+          sink.setEdgeValue(this.directedHandle, e, sink.directed);
+        }
+        return e;
+      }
+      case "error":
+        this.report.error(
+          "validation-error",
+          MIXED_DIRECTION_CODE,
+          `${kind} edge in a ${direction(sink.directed)} graph (onMixedDirection: "error")`,
+          where
+        );
+        throw this.report.abort("mixed direction refused", { code: MIXED_DIRECTION_CODE });
+      case "expand":
+        return this.expand(source, target, kind, weight, where);
+      default: {
+        const name = this.policy;
+        throw new GraphFormatError("E_UNSUPPORTED", `unknown onMixedDirection ${name}`, {
+          option: "onMixedDirection",
+          found: name
+        });
+      }
+    }
+  }
+  /**
+   * How many edges were given a direction other than their own, under `onMixedDirection`
+   * "directed" or "undirected".
+   * @returns the count
+   */
+  get forced() {
+    return this.forcedCount;
+  }
+  /**
+   * Expand one edge that differs from the sink's direction.
+   * @param source - the source id
+   * @param target - the target id
+   * @param kind - the edge's direction in the file
+   * @param weight - the weight, or undefined
+   * @param where - the line and element, for issues
+   * @returns the primary edge index
+   */
+  expand(source, target, kind, weight, where) {
+    const { sink } = this;
+    if (!sink.directed) {
+      try {
+        const before = sink.edgeCount;
+        sink.setDirected(true, { expand: true });
+        this.adoptExpansionColumns();
+        this.report.counts.expandedMixed += before;
+      } catch (err) {
+        if (!(err instanceof GraphFormatError) || err.code !== "E_DIRECTED") {
+          throw err;
+        }
+        this.report.error(
+          "coercion",
+          DIRECTION_REFUSED_CODE,
+          `${direction(true)} edge in a locked ${direction(false)} sink cannot be expanded`,
+          where
+        );
+        throw this.report.abort("the sink refused the expansion to directed", {
+          code: DIRECTION_REFUSED_CODE,
+          reason: err.details.reason
+        });
+      }
+      if (kind === "directed") {
+        const e = sink.addEdge(source, target, weight);
+        this.track(e);
+        sink.setEdgeValue(this.directedHandle, e, true);
+        return e;
+      }
+    }
+    this.ensureExpansionColumns();
+    const first = sink.addEdge(source, target, weight);
+    this.track(first);
+    const mutual = kind === "mutual";
+    sink.setEdgeValue(this.directedHandle, first, mutual);
+    this.report.counts.expandedMixed++;
+    if (mutual) {
+      this.ensureMutualColumn();
+      sink.setEdgeValue(this.mutualHandle, first, true);
+    }
+    const u = sink.indexOf(source);
+    const v = sink.indexOf(target);
+    if (u === v) {
+      return first;
+    }
+    const mirror = sink.addEdge(target, source, weight);
+    this.track(mirror);
+    this.mirrorOfLast = mirror;
+    sink.setEdgeValue(this.directedHandle, mirror, mutual);
+    sink.setEdgeValue(this.pairHandle, first, mirror);
+    sink.setEdgeValue(this.pairHandle, mirror, first);
+    return first;
+  }
+  /**
+   * Note an edge index this resolver pushed, for the backfill of graphty.directed.
+   * @param e - the edge index
+   */
+  track(e) {
+    if (this.firstEdge < 0) {
+      this.firstEdge = e;
+    }
+    this.nextEdge = e + 1;
+  }
+  /**
+   * Pick up the reserved columns the builder wrote during its own expansion.
+   */
+  adoptExpansionColumns() {
+    this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);
+    this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);
+  }
+  /**
+   * Declare the reserved columns on first use in a directed sink and backfill graphty.directed
+   * = true for every edge this resolver pushed so far (they were directed in the source).
+   */
+  ensureExpansionColumns() {
+    if (this.pairHandle !== INVALID_INDEX) {
+      return;
+    }
+    this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);
+    this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);
+    if (this.firstEdge >= 0) {
+      for (let e = this.firstEdge; e < this.nextEdge; e++) {
+        this.sink.setEdgeValue(this.directedHandle, e, true);
+      }
+    }
+  }
+  /** Declare graphty.mutual on first use. */
+  ensureMutualColumn() {
+    if (this.mutualHandle === INVALID_INDEX) {
+      this.mutualHandle = this.sink.declareEdgeColumn(MUTUAL_DECL);
+    }
+  }
+}
+function reasonOf(err) {
+  const { reason } = err.details;
+  return typeof reason === "string" ? reason : "refused";
+}
+function direction(directed) {
+  return directed ? "directed" : "undirected";
+}
+function pairFolding(snapshot, options = {}) {
+  const foldMutual = options.foldMutual ?? false;
+  const directedColumn = roleColumn(snapshot.edges.byRole("directed"), "bool");
+  const pairColumn = roleColumn(snapshot.edges.byRole("pair"), "u32");
+  const mutualColumn = roleColumn(snapshot.edges.byRole("mutual"), "bool");
+  const { edgeCount } = snapshot;
+  const mateOf = (e) => {
+    if (!pairColumn?.isSet(e)) {
+      return INVALID_INDEX;
+    }
+    const mate = pairColumn.value(e);
+    return typeof mate === "number" && mate !== INVALID_INDEX ? mate : INVALID_INDEX;
+  };
+  const sourceDirected = (e) => directedColumn === null || !directedColumn.isSet(e) || directedColumn.value(e) === true;
+  const isMutual = (e) => {
+    if (mutualColumn === null) {
+      return false;
+    }
+    if (mutualColumn.isSet(e) && mutualColumn.value(e) === true) {
+      return true;
+    }
+    const mate = mateOf(e);
+    return mate !== INVALID_INDEX && mutualColumn.isSet(mate) && mutualColumn.value(mate) === true;
+  };
+  const folded = (e) => {
+    const mate = mateOf(e);
+    if (mate === INVALID_INDEX || mate >= e) {
+      return false;
+    }
+    return !sourceDirected(e) || foldMutual && isMutual(e);
+  };
+  let mutualCount = 0;
+  if (mutualColumn !== null) {
+    for (let e = 0; e < edgeCount; e++) {
+      if (mutualColumn.isSet(e) && mutualColumn.value(e) === true && mateOf(e) > e) {
+        mutualCount++;
+      }
+    }
+  }
+  return { expanded: pairColumn !== null, mutualCount, folded, mateOf, sourceDirected, isMutual };
+}
+function roleColumn(column, dtype) {
+  return column !== null && column.dtype === dtype ? column : null;
+}
+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);
+}
+export {
+  DirectionResolver as D,
+  MUTUAL_COLUMN as M,
+  PAIR_COLUMN as P,
+  formatF64 as a,
+  formatNumber as b,
+  formatInteger as c,
+  formatDecimal as d,
+  formatGmlReal as e,
+  formatF32 as f,
+  DIRECTED_COLUMN as g,
+  idText as i,
+  pairFolding as p
+};
+//# sourceMappingURL=format-BXiAb-1h.js.map

package/dist/chunks/format-BXiAb-1h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-BXiAb-1h.js","sources":["../../src/common/direction.ts","../../src/common/format.ts"],"sourcesContent":["/**\n * Direction resolution through the sink (design sections 3.6 and 8.4, decision D-DIR): the\n * importer reads the file's header direction, calls `sink.setDirected()` once before the first\n * edge, then pushes every edge as it is read. Mixed files are handled per `onMixedDirection`:\n *\n * - \"expand\" (default): an undirected edge into a directed sink becomes two logical edges linked\n *   by the `graphty.pair` column with `graphty.directed` = false on both halves; a directed edge\n *   into an undirected sink triggers ONE `setDirected(true, { expand: true })`, after which the\n *   builder has expanded everything pushed so far and the importer continues in directed mode.\n * - \"directed\" / \"undirected\": every edge is treated that way (the distinction is dropped and\n *   reported once, with the count).\n * - \"error\": the first edge whose direction differs from the sink's aborts the import.\n *\n * A locked or non-empty sink wins over the file (design section 8.4 precedence): a refused\n * `setDirected` is recorded as a coercion issue and the importer continues with `sink.directed`,\n * expanding every edge that differs. A GEXF `mutual` edge expands like an undirected one with the\n * additional `graphty.mutual` role column set on its primary half.\n *\n * The reserved columns are declared with exactly the builder's own declarations so that a sink the\n * builder already expanded hands back the existing handles.\n */\n\nimport {\n    type Column,\n    type ColumnDecl,\n    type ColumnHandle,\n    GraphFormatError,\n    type GraphSink,\n    type GraphSnapshot,\n    INVALID_INDEX,\n    type NodeId,\n} from \"@graphty/graph-format\";\n\nimport { DIRECTION_FORCED_CODE, DIRECTION_REFUSED_CODE, MIXED_DIRECTION_CODE } from \"./codes.js\";\nimport { type ImportReportBuilder } from \"./report.js\";\n\n/**\n * The direction of one source edge.\n * @public\n * @category Plugin helpers\n */\nexport type EdgeKind = \"directed\" | \"undirected\" | \"mutual\";\n\n/**\n * Where an edge or header was read, for issues.\n * @public\n * @category Plugin helpers\n */\nexport interface EdgeLocation {\n    /** The 1-based line, when known. */\n    readonly line?: number | null | undefined;\n    /** The edge id or another element name, when known. */\n    readonly element?: string | null | undefined;\n}\n\n/**\n * The name of the bool edge column that, in a graph with both directed and undirected edges, says\n * which edges were directed in the file (true) and which were undirected (false).\n * @category Plugin helpers\n */\nexport const DIRECTED_COLUMN = \"graphty.directed\";\n\n/**\n * The name of the edge column that links the two edges an undirected edge is stored as, in a graph\n * with both directed and undirected edges: each holds the index of the other.\n * @category Plugin helpers\n */\nexport const PAIR_COLUMN = \"graphty.pair\";\n\n/**\n * The name of the bool edge column that marks a GEXF `mutual` edge.\n * @category Plugin helpers\n */\nexport const MUTUAL_COLUMN = \"graphty.mutual\";\n\nexport { DIRECTION_FORCED_CODE, DIRECTION_REFUSED_CODE, MIXED_DIRECTION_CODE } from \"./codes.js\";\n\nconst DIRECTED_DECL: ColumnDecl = { name: DIRECTED_COLUMN, dtype: \"bool\", role: \"directed\" };\nconst PAIR_DECL: ColumnDecl = { name: PAIR_COLUMN, dtype: \"u32\", role: \"pair\", refersTo: \"edge\" };\nconst MUTUAL_DECL: ColumnDecl = { name: MUTUAL_COLUMN, dtype: \"bool\", role: \"mutual\" };\n\n/**\n * Adds edges to the sink and handles files whose edges have different directions, the way\n * `onMixedDirection` asks. Make one per import call, call `setHeader()` once with the direction the\n * file declares, then `addEdge()` for each edge. In a directed graph an undirected edge is stored as\n * two edges, one each way, linked so an exporter writes them back as one.\n * @category Writing a format\n */\nexport class DirectionResolver {\n    private readonly sink: GraphSink;\n\n    private readonly report: ImportReportBuilder;\n\n    private readonly policy: \"expand\" | \"directed\" | \"undirected\" | \"error\";\n\n    private directedHandle: ColumnHandle = INVALID_INDEX as ColumnHandle;\n\n    private pairHandle: ColumnHandle = INVALID_INDEX as ColumnHandle;\n\n    private mutualHandle: ColumnHandle = INVALID_INDEX as ColumnHandle;\n\n    /** The first edge index this resolver pushed, for the backfill of graphty.directed; -1 before the first. */\n    private firstEdge = -1;\n\n    /** The next edge index this resolver expects to receive (contiguity between compactions, I16). */\n    private nextEdge = -1;\n\n    private forcedCount = 0;\n\n    private headerSet = false;\n\n    private mirrorOfLast: number = INVALID_INDEX;\n\n    /**\n     * Create a resolver.\n     * @param sink - the sink edges are pushed into\n     * @param report - the report issues are recorded in\n     * @param policy - the resolved onMixedDirection option\n     */\n    constructor(sink: GraphSink, report: ImportReportBuilder, policy: \"expand\" | \"directed\" | \"undirected\" | \"error\") {\n        this.sink = sink;\n        this.report = report;\n        this.policy = policy;\n    }\n\n    /**\n     * The sink's current direction.\n     * @returns true when directed\n     */\n    get directed(): boolean {\n        return this.sink.directed;\n    }\n\n    /**\n     * Whether the graph holds undirected edges stored as two edges.\n     * @returns true once the first such edge was added\n     */\n    get expanded(): boolean {\n        return this.pairHandle !== INVALID_INDEX;\n    }\n\n    /**\n     * Set the graph's direction before the first edge: the direction the file declares, or the\n     * `defaultDirected` option for a file that declares none. Under `onMixedDirection` \"directed\" or\n     * \"undirected\" that direction is used instead, with a warning when it differs. When the sink\n     * cannot change direction (a caller's builder that already holds edges or was locked), the\n     * sink's direction stands and a warning is recorded.\n     * @param headerDirected - the direction the file declares (or the default)\n     * @param where - the line of the header, when known\n     */\n    setHeader(headerDirected: boolean, where?: EdgeLocation): void {\n        this.headerSet = true;\n        let wanted = headerDirected;\n        if (this.policy === \"directed\" || this.policy === \"undirected\") {\n            wanted = this.policy === \"directed\";\n            if (wanted !== headerDirected) {\n                // once: this says it for every edge, so no edge repeats it\n                this.report.warnOnce(\n                    \"coercion\",\n                    DIRECTION_FORCED_CODE,\n                    `the file declares ${direction(headerDirected)} edges; read as ${direction(wanted)} per onMixedDirection`,\n                    { line: where?.line ?? null },\n                    `${DIRECTION_FORCED_CODE}:${direction(headerDirected)}`,\n                );\n            }\n        }\n        const { sink } = this;\n        if (sink.directed === wanted) {\n            this.adoptExisting();\n            return;\n        }\n        try {\n            if (wanted && sink.edgeCount > 0 && !sink.directedLocked) {\n                const before = sink.edgeCount;\n                sink.setDirected(true, { expand: true });\n                this.adoptExpansionColumns();\n                this.report.counts.expandedMixed += before;\n            } else {\n                sink.setDirected(wanted);\n            }\n        } catch (err) {\n            if (!(err instanceof GraphFormatError) || err.code !== \"E_DIRECTED\") {\n                throw err;\n            }\n            this.report.warning(\n                \"coercion\",\n                DIRECTION_REFUSED_CODE,\n                `the file is ${direction(wanted)} but the sink is ${direction(sink.directed)} (${reasonOf(err)}); read as ${direction(sink.directed)}`,\n                { line: where?.line ?? null },\n            );\n        }\n        this.adoptExisting();\n    }\n\n    /**\n     * Pick up reserved columns a caller's sink already holds (an earlier expansion), so every edge\n     * pushed from now on gets its graphty.directed value.\n     */\n    private adoptExisting(): void {\n        if (this.pairHandle === INVALID_INDEX && this.sink.edgeColumn(PAIR_COLUMN) !== INVALID_INDEX) {\n            this.adoptExpansionColumns();\n        }\n    }\n\n    /**\n     * The second edge of the edge the last addEdge() call added, when that edge was stored as two;\n     * otherwise INVALID_INDEX (4294967295). An edge attribute or weight you set after addEdge()\n     * belongs on both: set it on the index addEdge() returned and, when this is not INVALID_INDEX,\n     * on this index too.\n     * @returns the second edge's index, or INVALID_INDEX\n     */\n    get lastMirror(): number {\n        return this.mirrorOfLast;\n    }\n\n    /**\n     * Add one edge. An edge with the graph's direction is added as it is; one with the other\n     * direction is stored as two edges, given the graph's direction, or refused, as\n     * `onMixedDirection` says. When it is stored as two, the return value is the first and\n     * `lastMirror` the second.\n     * @param source - the source id\n     * @param target - the target id\n     * @param kind - the edge's direction in the file\n     * @param weight - the weight, or undefined when the file gives none\n     * @param where - the line and element, for issues\n     * @returns the index of the edge added (the first one, when it was stored as two)\n     */\n    addEdge(source: NodeId, target: NodeId, kind: EdgeKind, weight?: number, where?: EdgeLocation): number {\n        if (!this.headerSet) {\n            throw new GraphFormatError(\"E_DIRECTED\", \"DirectionResolver.setHeader() must run before the first edge\", {\n                reason: \"header not set\",\n            });\n        }\n        const { sink } = this;\n        this.mirrorOfLast = INVALID_INDEX;\n        const edgeDirected = kind !== \"undirected\";\n        if (edgeDirected === sink.directed && kind !== \"mutual\") {\n            const e = sink.addEdge(source, target, weight);\n            this.track(e);\n            if (this.directedHandle !== INVALID_INDEX) {\n                sink.setEdgeValue(this.directedHandle, e, edgeDirected);\n            }\n            return e;\n        }\n        switch (this.policy) {\n            case \"directed\":\n            case \"undirected\": {\n                // the sink's direction is the policy's (or a locked sink's); the edge is pushed as the sink's kind\n                this.forcedCount++;\n                this.report.warnOnce(\n                    \"coercion\",\n                    DIRECTION_FORCED_CODE,\n                    `${kind} edges read as ${direction(sink.directed)} per onMixedDirection`,\n                    where,\n                    `${DIRECTION_FORCED_CODE}:${kind}`,\n                );\n                const e = sink.addEdge(source, target, weight);\n                this.track(e);\n                if (this.directedHandle !== INVALID_INDEX) {\n                    sink.setEdgeValue(this.directedHandle, e, sink.directed);\n                }\n                return e;\n            }\n            case \"error\":\n                this.report.error(\n                    \"validation-error\",\n                    MIXED_DIRECTION_CODE,\n                    `${kind} edge in a ${direction(sink.directed)} graph (onMixedDirection: \"error\")`,\n                    where,\n                );\n                throw this.report.abort(\"mixed direction refused\", { code: MIXED_DIRECTION_CODE });\n            case \"expand\":\n                return this.expand(source, target, kind, weight, where);\n            default: {\n                const name: string = this.policy;\n                throw new GraphFormatError(\"E_UNSUPPORTED\", `unknown onMixedDirection ${name}`, {\n                    option: \"onMixedDirection\",\n                    found: name,\n                });\n            }\n        }\n    }\n\n    /**\n     * How many edges were given a direction other than their own, under `onMixedDirection`\n     * \"directed\" or \"undirected\".\n     * @returns the count\n     */\n    get forced(): number {\n        return this.forcedCount;\n    }\n\n    /**\n     * Expand one edge that differs from the sink's direction.\n     * @param source - the source id\n     * @param target - the target id\n     * @param kind - the edge's direction in the file\n     * @param weight - the weight, or undefined\n     * @param where - the line and element, for issues\n     * @returns the primary edge index\n     */\n    private expand(\n        source: NodeId,\n        target: NodeId,\n        kind: EdgeKind,\n        weight: number | undefined,\n        where: EdgeLocation | undefined,\n    ): number {\n        const { sink } = this;\n        if (!sink.directed) {\n            // a directed (or mutual) edge into an undirected sink: expand the sink once\n            try {\n                const before = sink.edgeCount;\n                sink.setDirected(true, { expand: true });\n                this.adoptExpansionColumns();\n                this.report.counts.expandedMixed += before;\n            } catch (err) {\n                if (!(err instanceof GraphFormatError) || err.code !== \"E_DIRECTED\") {\n                    throw err;\n                }\n                this.report.error(\n                    \"coercion\",\n                    DIRECTION_REFUSED_CODE,\n                    `${direction(true)} edge in a locked ${direction(false)} sink cannot be expanded`,\n                    where,\n                );\n                throw this.report.abort(\"the sink refused the expansion to directed\", {\n                    code: DIRECTION_REFUSED_CODE,\n                    reason: err.details.reason,\n                });\n            }\n            if (kind === \"directed\") {\n                const e = sink.addEdge(source, target, weight);\n                this.track(e);\n                sink.setEdgeValue(this.directedHandle, e, true);\n                return e;\n            }\n        }\n        this.ensureExpansionColumns();\n        const first = sink.addEdge(source, target, weight);\n        this.track(first);\n        const mutual = kind === \"mutual\";\n        sink.setEdgeValue(this.directedHandle, first, mutual);\n        this.report.counts.expandedMixed++;\n        if (mutual) {\n            this.ensureMutualColumn();\n            sink.setEdgeValue(this.mutualHandle, first, true);\n        }\n        const u = sink.indexOf(source);\n        const v = sink.indexOf(target);\n        if (u === v) {\n            // an undirected self-loop is one arc (I7); the builder does not mirror it either\n            return first;\n        }\n        const mirror = sink.addEdge(target, source, weight); // NOSONAR(S2234): the mirror arc runs the other way on purpose\n        this.track(mirror);\n        this.mirrorOfLast = mirror;\n        sink.setEdgeValue(this.directedHandle, mirror, mutual);\n        sink.setEdgeValue(this.pairHandle, first, mirror);\n        sink.setEdgeValue(this.pairHandle, mirror, first);\n        return first;\n    }\n\n    /**\n     * Note an edge index this resolver pushed, for the backfill of graphty.directed.\n     * @param e - the edge index\n     */\n    private track(e: number): void {\n        if (this.firstEdge < 0) {\n            this.firstEdge = e;\n        }\n        this.nextEdge = e + 1;\n    }\n\n    /**\n     * Pick up the reserved columns the builder wrote during its own expansion.\n     */\n    private adoptExpansionColumns(): void {\n        this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);\n        this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);\n    }\n\n    /**\n     * Declare the reserved columns on first use in a directed sink and backfill graphty.directed\n     * = true for every edge this resolver pushed so far (they were directed in the source).\n     */\n    private ensureExpansionColumns(): void {\n        if (this.pairHandle !== INVALID_INDEX) {\n            return;\n        }\n        this.directedHandle = this.sink.declareEdgeColumn(DIRECTED_DECL);\n        this.pairHandle = this.sink.declareEdgeColumn(PAIR_DECL);\n        if (this.firstEdge >= 0) {\n            for (let e = this.firstEdge; e < this.nextEdge; e++) {\n                this.sink.setEdgeValue(this.directedHandle, e, true);\n            }\n        }\n    }\n\n    /** Declare graphty.mutual on first use. */\n    private ensureMutualColumn(): void {\n        if (this.mutualHandle === INVALID_INDEX) {\n            this.mutualHandle = this.sink.declareEdgeColumn(MUTUAL_DECL);\n        }\n    }\n}\n\n/**\n * The reason of a refused setDirected(), for messages.\n * @param err - the E_DIRECTED error\n * @returns details.reason when it is a string, \"refused\" otherwise\n */\nfunction reasonOf(err: GraphFormatError): string {\n    const { reason } = err.details;\n    return typeof reason === \"string\" ? reason : \"refused\";\n}\n\n/**\n * The word for a direction, for messages.\n * @param directed - the direction\n * @returns \"directed\" or \"undirected\"\n */\nfunction direction(directed: boolean): string {\n    return directed ? \"directed\" : \"undirected\";\n}\n\n// ============================================================ the exporter side\n\n/**\n * What an exporter needs to know about edge direction, from `pairFolding(snapshot)`. In a graph\n * with both directed and undirected edges, each undirected edge is stored as two edges, one each\n * way. `folded(e)` tells you which of the two to skip, so the edge is written once, and\n * `sourceDirected(e)` whether an edge was directed. A GEXF `mutual` edge is also stored as two\n * edges; it is written as two directed edges unless you pass `foldMutual: true`.\n * @public\n * @category Plugin helpers\n */\nexport interface PairFolding {\n    /** Whether the graph holds any edge stored as two edges. When false, every method answers as for a plain edge. */\n    readonly expanded: boolean;\n    /** How many GEXF mutual edges the graph holds, each counted once. */\n    readonly mutualCount: number;\n    /**\n     * Whether to skip an edge: true for the second of the two edges an undirected edge (or, with\n     * `foldMutual`, a mutual edge) is stored as. Write the first and skip this one.\n     * @param e - the edge index\n     * @returns true when the edge must be skipped\n     */\n    folded(e: number): boolean;\n    /**\n     * The other of the two edges an undirected or mutual edge is stored as.\n     * @param e - the edge index\n     * @returns the other edge's index, or INVALID_INDEX (4294967295) for an edge stored once\n     */\n    mateOf(e: number): number;\n    /**\n     * Whether an edge was directed in the file it was read from: false for an undirected edge of a\n     * graph with both kinds. It is true for every edge of a graph without mixed direction, an\n     * undirected graph included, so the direction to write for edge `e` is\n     * `snapshot.directed && sourceDirected(e)`.\n     * @param e - the edge index\n     * @returns whether the edge is directed\n     */\n    sourceDirected(e: number): boolean;\n    /**\n     * Whether an edge is either of the two edges a GEXF `mutual` edge is stored as.\n     * @param e - the edge index\n     * @returns true for a mutual edge\n     */\n    isMutual(e: number): boolean;\n}\n\n/**\n * The per-format choice of pairFolding().\n * @category Plugin helpers\n */\nexport interface PairFoldingOptions {\n    /**\n     * Write a GEXF mutual edge once, for a format that can say an edge goes both ways. When false\n     * (the default), `folded()` keeps both of its edges, so it is written as two directed edges.\n     */\n    readonly foldMutual?: boolean | undefined;\n}\n\n/**\n * Read how a snapshot stores edge direction, for an exporter: which edges to skip so each\n * undirected edge is written once, and which edges were directed.\n * @param snapshot - the graph to write\n * @param options - whether a GEXF mutual edge is written once\n * @returns the answers, per edge\n * @category Writing a format\n */\nexport function pairFolding(snapshot: GraphSnapshot, options: PairFoldingOptions = {}): PairFolding {\n    const foldMutual = options.foldMutual ?? false;\n    const directedColumn = roleColumn(snapshot.edges.byRole(\"directed\"), \"bool\");\n    const pairColumn = roleColumn(snapshot.edges.byRole(\"pair\"), \"u32\");\n    const mutualColumn = roleColumn(snapshot.edges.byRole(\"mutual\"), \"bool\");\n    const { edgeCount } = snapshot;\n    const mateOf = (e: number): number => {\n        if (!pairColumn?.isSet(e)) {\n            return INVALID_INDEX;\n        }\n        const mate = pairColumn.value(e);\n        return typeof mate === \"number\" && mate !== INVALID_INDEX ? mate : INVALID_INDEX;\n    };\n    const sourceDirected = (e: number): boolean =>\n        directedColumn === null || !directedColumn.isSet(e) || directedColumn.value(e) === true;\n    const isMutual = (e: number): boolean => {\n        if (mutualColumn === null) {\n            return false;\n        }\n        if (mutualColumn.isSet(e) && mutualColumn.value(e) === true) {\n            return true;\n        }\n        const mate = mateOf(e);\n        return mate !== INVALID_INDEX && mutualColumn.isSet(mate) && mutualColumn.value(mate) === true;\n    };\n    const folded = (e: number): boolean => {\n        const mate = mateOf(e);\n        if (mate === INVALID_INDEX || mate >= e) {\n            return false;\n        }\n        // an undirected pair always folds; a mutual pair (directed on both halves) folds on request\n        return !sourceDirected(e) || (foldMutual && isMutual(e));\n    };\n    let mutualCount = 0;\n    if (mutualColumn !== null) {\n        for (let e = 0; e < edgeCount; e++) {\n            if (mutualColumn.isSet(e) && mutualColumn.value(e) === true && mateOf(e) > e) {\n                mutualCount++;\n            }\n        }\n    }\n    return { expanded: pairColumn !== null, mutualCount, folded, mateOf, sourceDirected, isMutual };\n}\n\n/**\n * A role column when it has the dtype the role requires, else null.\n * @param column - the column, or null\n * @param dtype - the required dtype\n * @returns the column or null\n */\nfunction roleColumn(column: Column | null, dtype: \"bool\" | \"u32\"): Column | null {\n    return column !== null && column.dtype === dtype ? column : null;\n}\n","/**\n * Number formatting for exporters (design section 3.7): an f32 weight is written as the shortest\n * decimal that round-trips through Math.fround (never `String(x)`, which prints\n * 0.10000000149011612 for a stored 0.1); an f64 value as its shortest JS text; a GML real always\n * with a decimal point so the dtype survives (design section 8.5); non-finite values as the\n * spelling the target syntax accepts.\n */\n\nimport type { NodeId } from \"@graphty/graph-format\";\n\n/**\n * The shortest decimal text that reads back to the same f32 value through Math.fround.\n * @param value - an f32 value (a JS number holding one)\n * @returns the text; \"Infinity\" / \"-Infinity\" / \"NaN\" for the non-finite values, \"-0\" for negative zero\n * @category Plugin helpers\n */\nexport function formatF32(value: number): string {\n    if (!Number.isFinite(value)) {\n        return String(value);\n    }\n    if (value === 0) {\n        return Object.is(value, -0) ? \"-0\" : \"0\";\n    }\n    for (let digits = 1; digits <= 9; digits++) {\n        const text = value.toPrecision(digits);\n        if (Math.fround(Number(text)) === value) {\n            return String(Number(text));\n        }\n    }\n    return String(value);\n}\n\n/**\n * The shortest text of an f64 value: `String(x)`, which is already the shortest round-tripping\n * decimal in JS, except for negative zero, which `String()` writes as \"0\".\n * @param value - the value\n * @returns the text; \"Infinity\" / \"-Infinity\" / \"NaN\" for the non-finite values, \"-0\" for negative zero\n * @category Plugin helpers\n */\nexport function formatF64(value: number): string {\n    return Object.is(value, -0) ? \"-0\" : String(value);\n}\n\n/**\n * The text of a node id for the text formats that write ids bare (DOT, Pajek, XGMML): the string\n * itself, or the shortest decimal of a number (formatF64).\n * @param id - the id\n * @returns the text\n */\nexport function idText(id: NodeId): string {\n    return typeof id === \"number\" ? formatF64(id) : id;\n}\n\n/**\n * A decimal text with a decimal point or an exponent guaranteed for a finite value (`2.0`,\n * `1e+21`, `1.5e-7`), so an\n * untyped re-import keeps the column f64 rather than i32; negative zero is\n * written `-0.0` so it reads back as -0; non-finite values are the JS spellings (`Infinity`,\n * `-Infinity`, `NaN`), which the CSV / DOT / Pajek importers read back as text. The one\n * implementation of the \"decimal point guaranteed\" rule for every text format; GML has its own\n * spellings of the non-finite values in formatGmlReal().\n * @param value - the value\n * @param dtype - the column dtype the value comes from; f32 values use the shortest fround-round-trip text\n * @returns the text\n * @category Plugin helpers\n */\nexport function formatDecimal(value: number, dtype: \"f32\" | \"f64\" | \"i32\" | \"u32\" | \"u8\" = \"f64\"): string {\n    if (!Number.isFinite(value)) {\n        return String(value);\n    }\n    if (Object.is(value, -0)) {\n        return \"-0.0\";\n    }\n    const text = formatNumber(value, dtype);\n    // an exponent form (`1e+21`, `1.5e-7`) is already f64 text under the 5.1 grammar\n    return text.includes(\".\") || text.includes(\"e\") ? text : `${text}.0`;\n}\n\n/**\n * A GML real: the shortest text with a decimal point guaranteed (`2.0`, `1.0e-7`), so a re-import\n * keeps the column real rather than int. Non-finite values have no GML spelling and are written\n * as the texts NetworkX's writer emits and its reader accepts, `+INF`, `-INF` and `NAN` (the\n * lowercase `inf` / `nan` would lex as keys there).\n * @param value - the value\n * @param dtype - the column dtype the value comes from; f32 values use the shortest fround-round-trip text\n * @returns the text\n * @category Plugin helpers\n */\nexport function formatGmlReal(value: number, dtype: \"f32\" | \"f64\" | \"i32\" | \"u32\" | \"u8\" = \"f64\"): string {\n    if (Number.isNaN(value)) {\n        return \"NAN\";\n    }\n    if (!Number.isFinite(value)) {\n        return value > 0 ? \"+INF\" : \"-INF\";\n    }\n    const text = formatDecimal(value, dtype);\n    if (text.includes(\".\")) {\n        return text;\n    }\n    // NetworkX's real pattern requires a decimal point even in the exponent form (`1.0e-7`)\n    const e = text.indexOf(\"e\");\n    return `${text.slice(0, e)}.0${text.slice(e)}`;\n}\n\n/**\n * An integer text for a value known to be integral (an i32 / u32 / u8 cell, an f64 that holds an\n * integer), avoiding the exponent form `String()` uses above 1e21.\n * @param value - an integral value\n * @returns the digits\n * @category Plugin helpers\n */\nexport function formatInteger(value: number): string {\n    if (Number.isSafeInteger(value) || !Number.isFinite(value)) {\n        return String(value);\n    }\n    return BigInt(value).toString();\n}\n\n/**\n * The text of a numeric cell of any numeric dtype, dispatching on the dtype: f32 through\n * formatF32, everything else through formatF64.\n * @param value - the value\n * @param dtype - the column dtype the value came from\n * @returns the text\n * @category Plugin helpers\n */\nexport function formatNumber(value: number, dtype: \"f32\" | \"f64\" | \"i32\" | \"u32\" | \"u8\"): string {\n    return dtype === \"f32\" ? formatF32(value) : formatF64(value);\n}\n"],"names":[],"mappings":"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"}