@graphty/graph-io 0.3.18 → 0.3.19

package/dist/chunks/weights-CwISIpCP.js

@@ -0,0 +1,176 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { aF as parseDecimalText } from "./report-BcWboivV.js";
+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 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;
+}
+function parseWeightText(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  let value;
+  try {
+    value = parseDecimalText(trimmed);
+  } catch (err) {
+    throw invalidWeight(text, err);
+  }
+  if (Number.isNaN(value)) {
+    throw invalidWeight(text, null);
+  }
+  return value;
+}
+function weightFromValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) {
+      throw invalidWeight(value, null);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    return parseWeightText(value);
+  }
+  throw invalidWeight(value, null);
+}
+function invalidWeight(value, cause) {
+  let shown;
+  switch (typeof value) {
+    case "string":
+      shown = JSON.stringify(value);
+      break;
+    case "number":
+      shown = String(value);
+      break;
+    default:
+      shown = typeof value;
+  }
+  return new GraphFormatError("E_INVALID_WEIGHT", `invalid edge weight ${shown}`, {
+    value: typeof value === "object" ? typeof value : value,
+    cause: cause instanceof Error ? cause.message : null
+  });
+}
+const NEGATIVE_ZERO_TEXT = "-0";
+const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
+function weightFormatter(dtype) {
+  switch (dtype) {
+    case "f32":
+      return formatF32;
+    case "f64":
+      return formatF64;
+    default:
+      return formatInteger;
+  }
+}
+function explicitWeights(snapshot) {
+  const shadowColumn = snapshot.edges.byRole("weight");
+  const shadow = shadowColumn !== null && NUMERIC_DTYPES.has(shadowColumn.dtype) ? shadowColumn : null;
+  if (shadow !== null) {
+    const dtype = shadow.dtype === "f32" ? "f32" : "f64";
+    const format = weightFormatter(shadow.dtype);
+    return {
+      weighted: true,
+      dtype,
+      isExplicit: (e) => shadow.isSet(e),
+      value: (e) => shadow.value(e),
+      text: (e, integral = false) => {
+        if (!shadow.isSet(e)) {
+          return null;
+        }
+        const value = shadow.value(e);
+        if (Object.is(value, -0)) {
+          return NEGATIVE_ZERO_TEXT;
+        }
+        return integral && Number.isInteger(value) ? formatInteger(value) : format(value);
+      }
+    };
+  }
+  const { weights } = snapshot.edgeList();
+  if (weights === null || !snapshot.flags.weighted) {
+    return {
+      weighted: false,
+      dtype: "f32",
+      isExplicit: () => false,
+      value: () => DEFAULT_WEIGHT,
+      text: () => null
+    };
+  }
+  return {
+    weighted: true,
+    dtype: "f32",
+    isExplicit: () => true,
+    value: (e) => weights[e],
+    text: (e, integral = false) => {
+      const value = weights[e];
+      if (Object.is(value, -0)) {
+        return NEGATIVE_ZERO_TEXT;
+      }
+      return integral && Number.isInteger(value) ? formatInteger(value) : formatF32(value);
+    }
+  };
+}
+export {
+  formatF32 as a,
+  formatF64 as b,
+  formatGmlReal as c,
+  formatInteger as d,
+  explicitWeights as e,
+  formatDecimal as f,
+  isWeightField as i,
+  parseWeightText as p,
+  weightFromValue as w
+};
+//# sourceMappingURL=weights-CwISIpCP.js.map

package/dist/chunks/weights-CwISIpCP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights-CwISIpCP.js","sources":["../../src/common/format.ts","../../src/common/weights.ts"],"sourcesContent":["/**\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\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 */\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 */\nexport function formatF64(value: number): string {\n    return Object.is(value, -0) ? \"-0\" : String(value);\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 (design section 8.5); 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 */\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 */\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 */\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 */\nexport function formatNumber(value: number, dtype: \"f32\" | \"f64\" | \"i32\" | \"u32\" | \"u8\"): string {\n    return dtype === \"f32\" ? formatF32(value) : formatF64(value);\n}\n","/**\n * Weight resolution shared by every importer (design sections 3.7 and 8.4): which source field is\n * THE weight (`weightFrom`, per-format default, null = unweighted), how its text or JSON value\n * becomes the number passed to `addEdge`, and the E_INVALID_WEIGHT boundary.\n *\n * An edge whose weight field is absent or blank is pushed WITHOUT a weight argument, never with an\n * explicit 1: the builder's weightSet bitmap then records that the weight was defaulted, and the\n * exporter re-emits no weight for it (decision D-WSET). NaN and non-numeric text are\n * E_INVALID_WEIGHT before the sink is touched, so the importer records the issue and skips the edge\n * with the sink unchanged; Infinity and negative values are legal weights (design section 3.7).\n */\n\nimport { type Column, GraphFormatError, type GraphSnapshot } from \"@graphty/graph-format\";\n\nimport { parseDecimalText } from \"./declared-types.js\";\nimport { formatF32, formatF64, formatInteger } from \"./format.js\";\n\n/** The weight of an edge added without one (design section 3.7). */\nexport const DEFAULT_WEIGHT = 1;\n\n/**\n * Whether a source field is the weight field under the resolved `weightFrom` option.\n * @param name - the field name (attribute title, CSV header, JSON key)\n * @param weightFrom - the resolved option; null means unweighted\n * @returns true when the field is THE weight\n */\nexport function isWeightField(name: string, weightFrom: string | null): boolean {\n    return weightFrom !== null && name === weightFrom;\n}\n\n/**\n * The weight argument of addEdge from a text cell: undefined for a blank cell (the weight is\n * omitted), the number otherwise.\n * @param text - the cell text\n * @returns the weight, or undefined when blank; E_INVALID_WEIGHT for NaN or non-numeric text\n */\nexport function parseWeightText(text: string): number | undefined {\n    const trimmed = text.trim();\n    if (trimmed.length === 0) {\n        return undefined;\n    }\n    let value: number;\n    try {\n        value = parseDecimalText(trimmed);\n    } catch (err) {\n        throw invalidWeight(text, err);\n    }\n    if (Number.isNaN(value)) {\n        throw invalidWeight(text, null);\n    }\n    return value;\n}\n\n/**\n * The weight argument of addEdge from a typed value (JSON, a record field): undefined for null /\n * undefined, the number for a finite or infinite number, the parsed number for numeric text.\n * @param value - the field value\n * @returns the weight, or undefined when absent; E_INVALID_WEIGHT for NaN, a boolean, an object or non-numeric text\n */\nexport function weightFromValue(value: unknown): number | undefined {\n    if (value === undefined || value === null) {\n        return undefined;\n    }\n    if (typeof value === \"number\") {\n        if (Number.isNaN(value)) {\n            throw invalidWeight(value, null);\n        }\n        return value;\n    }\n    if (typeof value === \"string\") {\n        return parseWeightText(value);\n    }\n    throw invalidWeight(value, null);\n}\n\n/**\n * The E_INVALID_WEIGHT error of a rejected value.\n * @param value - the rejected value\n * @param cause - the parse error, or null\n * @returns the error\n */\nfunction invalidWeight(value: unknown, cause: unknown): GraphFormatError {\n    let shown: string;\n    switch (typeof value) {\n        case \"string\":\n            shown = JSON.stringify(value);\n            break;\n        case \"number\":\n            shown = String(value);\n            break;\n        default:\n            shown = typeof value;\n    }\n    return new GraphFormatError(\"E_INVALID_WEIGHT\", `invalid edge weight ${shown}`, {\n        value: typeof value === \"object\" ? typeof value : value,\n        cause: cause instanceof Error ? cause.message : null,\n    });\n}\n\n// ============================================================ the exporter side\n\n/**\n * The explicit weights of a snapshot for exporters (design sections 3.7 and 8.5): the weight\n * role column when present (its validity says which edges had an explicit weight, its dtype how\n * the value is written), else `edgeList().weights` as f32 for every edge of a weighted snapshot;\n * nothing for an unweighted one. One implementation for every exporter.\n * Consumed by the per-format exporters under src/formats.\n * @public\n */\nexport interface ExplicitWeights {\n    /** Whether any edge can have an explicit weight (the snapshot is weighted). */\n    readonly weighted: boolean;\n    /** The dtype the values are read from: the shadow column's, or f32 for the arc array. */\n    readonly dtype: \"f32\" | \"f64\";\n    /**\n     * Whether an edge's weight was explicit in the source.\n     * @param e - the logical edge index\n     * @returns true when the exporter must write it\n     */\n    isExplicit(e: number): boolean;\n    /**\n     * The weight value of an edge (meaningful when explicit).\n     * @param e - the logical edge index\n     * @returns the value\n     */\n    value(e: number): number;\n    /**\n     * The weight text of an edge: the shortest round-tripping decimal for its dtype, or the\n     * integer digits when `integral` is requested and the value is an integer; null when the\n     * weight was defaulted.\n     * @param e - the logical edge index\n     * @param integral - write an integral value without a decimal part (formats declaring an int weight)\n     * @returns the text, or null\n     */\n    text(e: number, integral?: boolean): string | null;\n}\n\n/** A weight of -0 keeps its sign: every importer's weight grammar reads \"-0\" back as -0. */\nconst NEGATIVE_ZERO_TEXT = \"-0\";\n\n/** The dtypes a weight role column may have (an integer column declared by a caller included). */\nconst NUMERIC_DTYPES: ReadonlySet<string> = new Set([\"f32\", \"f64\", \"i32\", \"u32\", \"u8\"]);\n\n/**\n * The shortest round-tripping text of a weight by the shadow column's dtype.\n * @param dtype - the shadow column's dtype\n * @returns the formatter\n */\nfunction weightFormatter(dtype: string): (value: number) => string {\n    switch (dtype) {\n        case \"f32\":\n            return formatF32;\n        case \"f64\":\n            return formatF64;\n        default:\n            return formatInteger;\n    }\n}\n\n/**\n * Build the explicit-weight view of a snapshot.\n * @param snapshot - the snapshot\n * @returns the view\n */\nexport function explicitWeights(snapshot: GraphSnapshot): ExplicitWeights {\n    const shadowColumn = snapshot.edges.byRole(\"weight\");\n    const shadow: Column | null = shadowColumn !== null && NUMERIC_DTYPES.has(shadowColumn.dtype) ? shadowColumn : null;\n    if (shadow !== null) {\n        const dtype = shadow.dtype === \"f32\" ? \"f32\" : \"f64\";\n        const format = weightFormatter(shadow.dtype);\n        return {\n            weighted: true,\n            dtype,\n            isExplicit: (e: number): boolean => shadow.isSet(e),\n            value: (e: number): number => shadow.value(e) as number,\n            text: (e: number, integral = false): string | null => {\n                if (!shadow.isSet(e)) {\n                    return null;\n                }\n                const value = shadow.value(e) as number;\n                if (Object.is(value, -0)) {\n                    return NEGATIVE_ZERO_TEXT;\n                }\n                return integral && Number.isInteger(value) ? formatInteger(value) : format(value);\n            },\n        };\n    }\n    const { weights } = snapshot.edgeList();\n    if (weights === null || !snapshot.flags.weighted) {\n        return {\n            weighted: false,\n            dtype: \"f32\",\n            isExplicit: (): boolean => false,\n            value: (): number => DEFAULT_WEIGHT,\n            text: (): string | null => null,\n        };\n    }\n    return {\n        weighted: true,\n        dtype: \"f32\",\n        isExplicit: (): boolean => true,\n        value: (e: number): number => weights[e],\n        text: (e: number, integral = false): string => {\n            const value = weights[e];\n            if (Object.is(value, -0)) {\n                return NEGATIVE_ZERO_TEXT;\n            }\n            return integral && Number.isInteger(value) ? formatInteger(value) : formatF32(value);\n        },\n    };\n}\n"],"names":[],"mappings":";;AAaO,SAAS,UAAU,OAAuB;AAC7C,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AACzB,WAAO,OAAO,KAAK;AAAA,EACvB;AACA,MAAI,UAAU,GAAG;AACb,WAAO,OAAO,GAAG,OAAO,EAAE,IAAI,OAAO;AAAA,EACzC;AACA,WAAS,SAAS,GAAG,UAAU,GAAG,UAAU;AACxC,UAAM,OAAO,MAAM,YAAY,MAAM;AACrC,QAAI,KAAK,OAAO,OAAO,IAAI,CAAC,MAAM,OAAO;AACrC,aAAO,OAAO,OAAO,IAAI,CAAC;AAAA,IAC9B;AAAA,EACJ;AACA,SAAO,OAAO,KAAK;AACvB;AAQO,SAAS,UAAU,OAAuB;AAC7C,SAAO,OAAO,GAAG,OAAO,EAAE,IAAI,OAAO,OAAO,KAAK;AACrD;AAcO,SAAS,cAAc,OAAe,QAA8C,OAAe;AACtG,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AACzB,WAAO,OAAO,KAAK;AAAA,EACvB;AACA,MAAI,OAAO,GAAG,OAAO,EAAE,GAAG;AACtB,WAAO;AAAA,EACX;AACA,QAAM,OAAO,aAAa,OAAO,KAAK;AAEtC,SAAO,KAAK,SAAS,GAAG,KAAK,KAAK,SAAS,GAAG,IAAI,OAAO,GAAG,IAAI;AACpE;AAWO,SAAS,cAAc,OAAe,QAA8C,OAAe;AACtG,MAAI,OAAO,MAAM,KAAK,GAAG;AACrB,WAAO;AAAA,EACX;AACA,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AACzB,WAAO,QAAQ,IAAI,SAAS;AAAA,EAChC;AACA,QAAM,OAAO,cAAc,OAAO,KAAK;AACvC,MAAI,KAAK,SAAS,GAAG,GAAG;AACpB,WAAO;AAAA,EACX;AAEA,QAAM,IAAI,KAAK,QAAQ,GAAG;AAC1B,SAAO,GAAG,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,CAAC;AAChD;AAQO,SAAS,cAAc,OAAuB;AACjD,MAAI,OAAO,cAAc,KAAK,KAAK,CAAC,OAAO,SAAS,KAAK,GAAG;AACxD,WAAO,OAAO,KAAK;AAAA,EACvB;AACA,SAAO,OAAO,KAAK,EAAE,SAAA;AACzB;AASO,SAAS,aAAa,OAAe,OAAqD;AAC7F,SAAO,UAAU,QAAQ,UAAU,KAAK,IAAI,UAAU,KAAK;AAC/D;AC5FO,MAAM,iBAAiB;AAQvB,SAAS,cAAc,MAAc,YAAoC;AAC5E,SAAO,eAAe,QAAQ,SAAS;AAC3C;AAQO,SAAS,gBAAgB,MAAkC;AAC9D,QAAM,UAAU,KAAK,KAAA;AACrB,MAAI,QAAQ,WAAW,GAAG;AACtB,WAAO;AAAA,EACX;AACA,MAAI;AACJ,MAAI;AACA,YAAQ,iBAAiB,OAAO;AAAA,EACpC,SAAS,KAAK;AACV,UAAM,cAAc,MAAM,GAAG;AAAA,EACjC;AACA,MAAI,OAAO,MAAM,KAAK,GAAG;AACrB,UAAM,cAAc,MAAM,IAAI;AAAA,EAClC;AACA,SAAO;AACX;AAQO,SAAS,gBAAgB,OAAoC;AAChE,MAAI,UAAU,UAAa,UAAU,MAAM;AACvC,WAAO;AAAA,EACX;AACA,MAAI,OAAO,UAAU,UAAU;AAC3B,QAAI,OAAO,MAAM,KAAK,GAAG;AACrB,YAAM,cAAc,OAAO,IAAI;AAAA,IACnC;AACA,WAAO;AAAA,EACX;AACA,MAAI,OAAO,UAAU,UAAU;AAC3B,WAAO,gBAAgB,KAAK;AAAA,EAChC;AACA,QAAM,cAAc,OAAO,IAAI;AACnC;AAQA,SAAS,cAAc,OAAgB,OAAkC;AACrE,MAAI;AACJ,UAAQ,OAAO,OAAA;AAAA,IACX,KAAK;AACD,cAAQ,KAAK,UAAU,KAAK;AAC5B;AAAA,IACJ,KAAK;AACD,cAAQ,OAAO,KAAK;AACpB;AAAA,IACJ;AACI,cAAQ,OAAO;AAAA,EAAA;AAEvB,SAAO,IAAI,iBAAiB,oBAAoB,uBAAuB,KAAK,IAAI;AAAA,IAC5E,OAAO,OAAO,UAAU,WAAW,OAAO,QAAQ;AAAA,IAClD,OAAO,iBAAiB,QAAQ,MAAM,UAAU;AAAA,EAAA,CACnD;AACL;AAyCA,MAAM,qBAAqB;AAG3B,MAAM,qCAA0C,IAAI,CAAC,OAAO,OAAO,OAAO,OAAO,IAAI,CAAC;AAOtF,SAAS,gBAAgB,OAA0C;AAC/D,UAAQ,OAAA;AAAA,IACJ,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO;AAAA,IACX;AACI,aAAO;AAAA,EAAA;AAEnB;AAOO,SAAS,gBAAgB,UAA0C;AACtE,QAAM,eAAe,SAAS,MAAM,OAAO,QAAQ;AACnD,QAAM,SAAwB,iBAAiB,QAAQ,eAAe,IAAI,aAAa,KAAK,IAAI,eAAe;AAC/G,MAAI,WAAW,MAAM;AACjB,UAAM,QAAQ,OAAO,UAAU,QAAQ,QAAQ;AAC/C,UAAM,SAAS,gBAAgB,OAAO,KAAK;AAC3C,WAAO;AAAA,MACH,UAAU;AAAA,MACV;AAAA,MACA,YAAY,CAAC,MAAuB,OAAO,MAAM,CAAC;AAAA,MAClD,OAAO,CAAC,MAAsB,OAAO,MAAM,CAAC;AAAA,MAC5C,MAAM,CAAC,GAAW,WAAW,UAAyB;AAClD,YAAI,CAAC,OAAO,MAAM,CAAC,GAAG;AAClB,iBAAO;AAAA,QACX;AACA,cAAM,QAAQ,OAAO,MAAM,CAAC;AAC5B,YAAI,OAAO,GAAG,OAAO,EAAE,GAAG;AACtB,iBAAO;AAAA,QACX;AACA,eAAO,YAAY,OAAO,UAAU,KAAK,IAAI,cAAc,KAAK,IAAI,OAAO,KAAK;AAAA,MACpF;AAAA,IAAA;AAAA,EAER;AACA,QAAM,EAAE,QAAA,IAAY,SAAS,SAAA;AAC7B,MAAI,YAAY,QAAQ,CAAC,SAAS,MAAM,UAAU;AAC9C,WAAO;AAAA,MACH,UAAU;AAAA,MACV,OAAO;AAAA,MACP,YAAY,MAAe;AAAA,MAC3B,OAAO,MAAc;AAAA,MACrB,MAAM,MAAqB;AAAA,IAAA;AAAA,EAEnC;AACA,SAAO;AAAA,IACH,UAAU;AAAA,IACV,OAAO;AAAA,IACP,YAAY,MAAe;AAAA,IAC3B,OAAO,CAAC,MAAsB,QAAQ,CAAC;AAAA,IACvC,MAAM,CAAC,GAAW,WAAW,UAAkB;AAC3C,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,OAAO,GAAG,OAAO,EAAE,GAAG;AACtB,eAAO;AAAA,MACX;AACA,aAAO,YAAY,OAAO,UAAU,KAAK,IAAI,cAAc,KAAK,IAAI,UAAU,KAAK;AAAA,IACvF;AAAA,EAAA;AAER;"}

package/dist/chunks/{writer-GAdltGmC.js → writer-DQiKgQJc.js}

@@ -1,167 +1,5 @@
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { aO as parseDecimalText, U as OPTIONS_GAINED_CODE, al as XML_ILLEGAL_CHAR_CODE, ac as TEXT_INFERRED_CODE, y as INTEGRAL_F64_CODE, a6 as STORAGE_CLASS_CODE, E as EMPTY_COLUMN_DROPPED_CODE, f as COLUMN_RENAMED_LOSS_CODE, a0 as ROLE_ASSUMED_CODE, aj as WEIGHT_KEY_CLASH_CODE, w as ID_TEXT_COLLISION_CODE, x as ID_TEXT_TYPE_CODE, Q as MUTUAL_AS_UNDIRECTED_CODE, S as MUTUAL_EXPANDED_CODE, X as PARENTS_DROPPED_CODE, a1 as ROLE_DROPPED_CODE, ab as TEMPORAL_TEXT_DROPPED_CODE, aa as TEMPORAL_DROPPED_CODE, O as MIXED_DIRECTION_CODE } from "./report-BOk0p5y8.js";
-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 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;
-}
-function parseWeightText(text) {
-  const trimmed = text.trim();
-  if (trimmed.length === 0) {
-    return void 0;
-  }
-  let value;
-  try {
-    value = parseDecimalText(trimmed);
-  } catch (err) {
-    throw invalidWeight(text, err);
-  }
-  if (Number.isNaN(value)) {
-    throw invalidWeight(text, null);
-  }
-  return value;
-}
-function weightFromValue(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value === "number") {
-    if (Number.isNaN(value)) {
-      throw invalidWeight(value, null);
-    }
-    return value;
-  }
-  if (typeof value === "string") {
-    return parseWeightText(value);
-  }
-  throw invalidWeight(value, null);
-}
-function invalidWeight(value, cause) {
-  let shown;
-  switch (typeof value) {
-    case "string":
-      shown = JSON.stringify(value);
-      break;
-    case "number":
-      shown = String(value);
-      break;
-    default:
-      shown = typeof value;
-  }
-  return new GraphFormatError("E_INVALID_WEIGHT", `invalid edge weight ${shown}`, {
-    value: typeof value === "object" ? typeof value : value,
-    cause: cause instanceof Error ? cause.message : null
-  });
-}
-const NEGATIVE_ZERO_TEXT = "-0";
-const NUMERIC_DTYPES = /* @__PURE__ */ new Set(["f32", "f64", "i32", "u32", "u8"]);
-function weightFormatter(dtype) {
-  switch (dtype) {
-    case "f32":
-      return formatF32;
-    case "f64":
-      return formatF64;
-    default:
-      return formatInteger;
-  }
-}
-function explicitWeights(snapshot) {
-  const shadowColumn = snapshot.edges.byRole("weight");
-  const shadow = shadowColumn !== null && NUMERIC_DTYPES.has(shadowColumn.dtype) ? shadowColumn : null;
-  if (shadow !== null) {
-    const dtype = shadow.dtype === "f32" ? "f32" : "f64";
-    const format = weightFormatter(shadow.dtype);
-    return {
-      weighted: true,
-      dtype,
-      isExplicit: (e) => shadow.isSet(e),
-      value: (e) => shadow.value(e),
-      text: (e, integral = false) => {
-        if (!shadow.isSet(e)) {
-          return null;
-        }
-        const value = shadow.value(e);
-        if (Object.is(value, -0)) {
-          return NEGATIVE_ZERO_TEXT;
-        }
-        return integral && Number.isInteger(value) ? formatInteger(value) : format(value);
-      }
-    };
-  }
-  const { weights } = snapshot.edgeList();
-  if (weights === null || !snapshot.flags.weighted) {
-    return {
-      weighted: false,
-      dtype: "f32",
-      isExplicit: () => false,
-      value: () => DEFAULT_WEIGHT,
-      text: () => null
-    };
-  }
-  return {
-    weighted: true,
-    dtype: "f32",
-    isExplicit: () => true,
-    value: (e) => weights[e],
-    text: (e, integral = false) => {
-      const value = weights[e];
-      if (Object.is(value, -0)) {
-        return NEGATIVE_ZERO_TEXT;
-      }
-      return integral && Number.isInteger(value) ? formatInteger(value) : formatF32(value);
-    }
-  };
-}
+import { T as OPTIONS_GAINED_CODE, ak as XML_ILLEGAL_CHAR_CODE, ab as TEXT_INFERRED_CODE, x as INTEGRAL_F64_CODE, a5 as STORAGE_CLASS_CODE, E as EMPTY_COLUMN_DROPPED_CODE, e as COLUMN_RENAMED_LOSS_CODE, $ as ROLE_ASSUMED_CODE, ai as WEIGHT_KEY_CLASH_CODE, v as ID_TEXT_COLLISION_CODE, w as ID_TEXT_TYPE_CODE, P as MUTUAL_AS_UNDIRECTED_CODE, R as MUTUAL_EXPANDED_CODE, W as PARENTS_DROPPED_CODE, a0 as ROLE_DROPPED_CODE, aa as TEMPORAL_TEXT_DROPPED_CODE, a9 as TEMPORAL_DROPPED_CODE, N as MIXED_DIRECTION_CODE } from "./report-BcWboivV.js";
 const LOSS = Object.freeze({
   /** The format has no mixed direction; expanded pairs are written per onMixedDirection. */
   MIXED_DIRECTION: "W_MIXED_DIRECTION",
@@ -807,21 +645,12 @@ export {
   capabilities as c,
   decodeChunks as d,
   encodeChunks as e,
-  explicitWeights as f,
-  formatDecimal as g,
-  formatF32 as h,
-  formatF64 as i,
-  formatGmlReal as j,
-  formatInteger as k,
-  isNmtoken as l,
-  isWeightField as m,
-  joinText as n,
-  mangleNmtoken as o,
-  parseWeightText as p,
-  isNameChar as q,
-  countMixedEdges as r,
+  isNameChar as f,
+  countMixedEdges as g,
+  isNmtoken as i,
+  joinText as j,
+  mangleNmtoken as m,
   sanitizeIds as s,
-  toReadableStream as t,
-  weightFromValue as w
+  toReadableStream as t
 };
-//# sourceMappingURL=writer-GAdltGmC.js.map
+//# sourceMappingURL=writer-DQiKgQJc.js.map

package/dist/chunks/writer-DQiKgQJc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer-DQiKgQJc.js","sources":["../../src/common/export.ts","../../src/common/writer.ts"],"sourcesContent":["/**\n * The exporter-side machinery of design section 8.5: the ExportCapabilities table helper, the\n * generic check() that turns capability gaps into LossNotes with shared codes, and id sanitising\n * (`sanitizeIds: \"error\"` by default; an exporter never silently renames a node; \"mangle\" rewrites\n * the ids the format cannot hold and hands the exporter the originals to write into its\n * `graphty:originalId` attribute).\n *\n * Every exporter's check() calls checkCapabilities() first and appends its format-specific notes\n * (design section 8.5 names W_GML_RECORD_NUMBER_TYPE and W_OPEN_INTERVAL); export() calls\n * sanitizeIds() before writing anything.\n */\n\nimport {\n    type Column,\n    type Dtype,\n    GraphFormatError,\n    type GraphSnapshot,\n    INVALID_INDEX,\n    type NodeId,\n} from \"@graphty/graph-format\";\n\nimport { type ExportCapabilities, type LossNote } from \"../types.js\";\nimport {\n    COLUMN_RENAMED_LOSS_CODE,\n    EMPTY_COLUMN_DROPPED_CODE,\n    ID_TEXT_COLLISION_CODE,\n    ID_TEXT_TYPE_CODE,\n    INTEGRAL_F64_CODE,\n    MIXED_DIRECTION_CODE,\n    MUTUAL_AS_UNDIRECTED_CODE,\n    MUTUAL_EXPANDED_CODE,\n    OPTIONS_GAINED_CODE,\n    PARENTS_DROPPED_CODE,\n    ROLE_ASSUMED_CODE,\n    ROLE_DROPPED_CODE,\n    STORAGE_CLASS_CODE,\n    TEMPORAL_DROPPED_CODE,\n    TEMPORAL_TEXT_DROPPED_CODE,\n    TEXT_INFERRED_CODE,\n    WEIGHT_KEY_CLASH_CODE,\n    XML_ILLEGAL_CHAR_CODE,\n} from \"./codes.js\";\nimport { type ResolvedExportOptions } from \"./options.js\";\n\n/** The shared LossNote codes of checkCapabilities(). */\nexport const LOSS = Object.freeze({\n    /** The format has no mixed direction; expanded pairs are written per onMixedDirection. */\n    MIXED_DIRECTION: \"W_MIXED_DIRECTION\",\n    /** The format has no mixed direction and onMixedDirection is \"error\": export() will throw E_DIRECTED. */\n    MIXED_DIRECTION_ERROR: MIXED_DIRECTION_CODE,\n    /** Parallel edges in a format without them. */\n    MULTI_EDGES: \"W_MULTI_EDGES\",\n    /** Self-loops in a format without them. */\n    SELF_LOOPS: \"W_SELF_LOOPS\",\n    /** The format requires edge ids and the snapshot has none; canonical e0..e{E-1} are generated. */\n    EDGE_IDS_GENERATED: \"W_EDGE_IDS_GENERATED\",\n    /** The snapshot has an edge id column and the format cannot write one. */\n    EDGE_IDS_DROPPED: \"W_EDGE_IDS_DROPPED\",\n    /** Ids outside the format's charset are rewritten (sanitizeIds \"mangle\"). */\n    ID_MANGLED: \"W_ID_MANGLED\",\n    /** Ids outside the format's charset and sanitizeIds \"error\": export() will throw E_INVALID_ID. */\n    ID_CHARSET: \"E_ID_CHARSET\",\n    /** The format numbers nodes 1..N; ids that are not their 1-based index are kept as labels only. */\n    ID_RENUMBERED: \"W_ID_RENUMBERED\",\n    /** A column dtype the format does not keep as declared. */\n    DTYPE: \"W_DTYPE_UNSUPPORTED\",\n    /** A multi-component column in a format without strides. */\n    COMPONENTS: \"W_COMPONENTS_FLATTENED\",\n    /** A list column in a format without lists. */\n    LIST: \"W_LIST_UNSUPPORTED\",\n    /** A json column in a format without nested values. */\n    JSON: \"W_JSON_UNSUPPORTED\",\n    /** A declared default in a format without defaults. */\n    DEFAULT: \"W_DEFAULT_DROPPED\",\n    /** Declared options in a format without enumerations. */\n    OPTIONS: \"W_OPTIONS_DROPPED\",\n    /** A parent / parents column in a format without containment. */\n    HIERARCHY: \"W_HIERARCHY_DROPPED\",\n    /** A start / end / timestamp column in a format without temporal support. */\n    TEMPORAL: TEMPORAL_DROPPED_CODE,\n    /** A `<column>.text` companion (design section 5.1) the format cannot carry. */\n    TEMPORAL_TEXT: TEMPORAL_TEXT_DROPPED_CODE,\n    /** A role column the format has no slot for; written as a plain attribute, the role lost. */\n    ROLE: ROLE_DROPPED_CODE,\n    /** A parents (multi-parent) column in a format with single containment only. */\n    PARENTS: PARENTS_DROPPED_CODE,\n    /** A mutual pair written as two directed edges without the mutual mark. */\n    MUTUAL_EXPANDED: MUTUAL_EXPANDED_CODE,\n    /** A mutual pair written as one undirected edge; the mark is lost and the pair reads back undirected. */\n    MUTUAL_AS_UNDIRECTED: MUTUAL_AS_UNDIRECTED_CODE,\n    /** Node ids whose written text reads back as the other type under the importer's id rule. */\n    ID_TEXT_TYPE: ID_TEXT_TYPE_CODE,\n    /** Two node ids share one written text; export() throws E_INVALID_ID. */\n    ID_TEXT_COLLISION: ID_TEXT_COLLISION_CODE,\n    /** A plain column named like the importer's weight key reads back as THE weight. */\n    WEIGHT_KEY_CLASH: WEIGHT_KEY_CLASH_CODE,\n    /** A role-less column whose written name the importer maps to a role. */\n    ROLE_ASSUMED: ROLE_ASSUMED_CODE,\n    /** A role column written into the format's slot reads back under the importer's fixed name. */\n    COLUMN_NAME_CHANGED: COLUMN_RENAMED_LOSS_CODE,\n    /** A declared column whose every row is unset vanishes through a format without declarations. */\n    EMPTY_COLUMN: EMPTY_COLUMN_DROPPED_CODE,\n    /** A string / dict column that reads back as the other storage class (the dictionary heuristic). */\n    STORAGE_CLASS: STORAGE_CLASS_CODE,\n    /** An f64 column whose set values are all integral reads back as i32 through an untyped format. */\n    INTEGRAL_F64: INTEGRAL_F64_CODE,\n    /** Text cells that read back as numbers or booleans under the 5.1 grammar. */\n    TEXT_INFERRED: TEXT_INFERRED_CODE,\n    /** A string cell holding a character XML 1.0 forbids; export() throws E_COLUMN_TYPE. */\n    XML_ILLEGAL_CHAR: XML_ILLEGAL_CHAR_CODE,\n    /** A dict column without declared options gains one on re-import. */\n    OPTIONS_GAINED: OPTIONS_GAINED_CODE,\n    /** A spells column in a format without spells. */\n    SPELLS: \"W_SPELLS_DROPPED\",\n    /** Dynamic attribute values (extension tables) in a format without them. */\n    DYNAMIC_VALUES: \"W_DYNAMIC_VALUES_DROPPED\",\n    /** An open-interval column in a format without open intervals (design section 5.1). */\n    OPEN_INTERVAL: \"W_OPEN_INTERVAL\",\n    /** Graph-level attributes in a format without them. */\n    GRAPH_ATTRIBUTES: \"W_GRAPH_ATTRIBUTES_DROPPED\",\n    /** A position column in a format without positions. */\n    POSITIONS: \"W_POSITIONS_DROPPED\",\n    /** Visual columns in a format without them. */\n    VIZ: \"W_VIZ_DROPPED\",\n    /** An extension table the format cannot carry. */\n    EXTENSION_TABLE: \"W_EXTENSION_TABLE_DROPPED\",\n});\n\n/** The capabilities of a format that keeps nothing beyond plain topology; the base every exporter overrides. */\nexport const NO_CAPABILITIES: ExportCapabilities = Object.freeze({\n    mixedDirection: false,\n    multiEdges: false,\n    selfLoops: false,\n    edgeIds: \"none\",\n    idCharset: \"any\",\n    dtypes: Object.freeze([]),\n    components: false,\n    lists: false,\n    json: false,\n    defaults: false,\n    options: false,\n    hierarchy: false,\n    temporal: \"none\",\n    graphAttributes: false,\n    positions: false,\n    viz: false,\n});\n\n/**\n * Build a capabilities table from the fields a format supports; every field left out is the\n * conservative NO_CAPABILITIES value, so an exporter states what it keeps and nothing is assumed.\n * @param supported - the fields the format supports\n * @returns a frozen table\n */\nexport function capabilities(supported: Partial<ExportCapabilities>): ExportCapabilities {\n    return Object.freeze({ ...NO_CAPABILITIES, ...supported, dtypes: Object.freeze([...(supported.dtypes ?? [])]) });\n}\n\n/**\n * Format facts checkCapabilities() needs that the 12.4 table does not carry.\n * Consumed by the per-format importers and exporters under src/formats.\n * @public\n */\nexport interface CheckExtras {\n    /** Whether the format can write open intervals (GEXF 1.2 startopen / endopen); default false. */\n    readonly openIntervals?: boolean | undefined;\n    /**\n     * Whether the format carries the `<column>.text` companions of design section 5.1 (the lexical\n     * form of a temporal value); default false, and every companion is then reported as\n     * W_TEMPORAL_TEXT_DROPPED.\n     */\n    readonly temporalText?: boolean | undefined;\n    /**\n     * The dtype the format's importer gives a position column; an f32 / f64 position of the other\n     * dtype is reported as W_DTYPE_UNSUPPORTED because its values differ at the other precision.\n     * Undefined skips the check.\n     */\n    readonly positionDtype?: Dtype | undefined;\n    /**\n     * The roles beyond the structural, position, viz, hierarchy and temporal ones that the format\n     * has a slot for (`label`, `kind`, `labels`, `idSpace`, `sourcePort`, `targetPort`, ...); a\n     * column with any other role is written as a plain attribute and reported as W_ROLE_DROPPED.\n     * Defaults to none.\n     */\n    readonly roles?: ReadonlySet<string> | undefined;\n    /**\n     * Roles the format writes into a fixed slot whose importer reads them back under a fixed name;\n     * a role column named otherwise is reported as W_COLUMN_NAME_CHANGED (role -> the name the\n     * importer gives it). Defaults to none.\n     */\n    readonly roleNames?: Readonly<Record<string, string>> | undefined;\n}\n\n/** The roles checkCapabilities() treats structurally rather than as attribute columns. */\nconst STRUCTURAL_ROLES: ReadonlySet<string> = new Set([\"directed\", \"pair\", \"mutual\", \"weight\", \"originalId\"]);\nconst VIZ_ROLES: ReadonlySet<string> = new Set([\"color\", \"size\", \"shape\", \"thickness\"]);\nconst TEMPORAL_ROLES: ReadonlySet<string> = new Set([\"start\", \"end\", \"timestamp\", \"timestamps\"]);\nconst HIERARCHY_ROLES: ReadonlySet<string> = new Set([\"parent\", \"parents\"]);\n\n/**\n * The generic pre-flight of design section 8.5: compare a snapshot with a format's capabilities\n * and return one LossNote per gap, with the shared codes of LOSS. Format-specific notes are the\n * exporter's to append.\n * @param snapshot - the snapshot about to be exported\n * @param caps - the exporter's capabilities\n * @param options - the resolved common export options\n * @param extras - format facts the capabilities table does not carry\n * @returns the notes, empty when the export is exact\n */\nexport function checkCapabilities(\n    snapshot: GraphSnapshot,\n    caps: ExportCapabilities,\n    options: ResolvedExportOptions,\n    extras: CheckExtras = {},\n): LossNote[] {\n    const notes: LossNote[] = [];\n    const note = (code: string, message: string, column: string | null = null, count: number | null = null): void => {\n        notes.push(Object.freeze({ code, message, column, count }));\n    };\n\n    // mixed direction (design section 3.6): an expanded snapshot carries the pair / directed roles\n    const mixed = countMixedEdges(snapshot);\n    if (mixed > 0 && !caps.mixedDirection) {\n        if (options.onMixedDirection === \"error\") {\n            note(\n                LOSS.MIXED_DIRECTION_ERROR,\n                `${mixed} undirected edge(s) in a directed graph; the format has no mixed direction and onMixedDirection is \"error\"`,\n                null,\n                mixed,\n            );\n        } else {\n            note(\n                LOSS.MIXED_DIRECTION,\n                `${mixed} undirected edge(s) in a directed graph written as ${options.onMixedDirection}`,\n                null,\n                mixed,\n            );\n        }\n    }\n\n    if (snapshot.flags.multigraph && !caps.multiEdges) {\n        const parallel = countParallelArcs(snapshot);\n        note(LOSS.MULTI_EDGES, `${parallel} parallel edge(s); the format has no parallel edges`, null, parallel);\n    }\n    if (snapshot.selfLoopCount > 0 && !caps.selfLoops) {\n        note(\n            LOSS.SELF_LOOPS,\n            `${snapshot.selfLoopCount} self-loop(s); the format has no self-loops`,\n            null,\n            snapshot.selfLoopCount,\n        );\n    }\n\n    const edgeIds = snapshot.edges.byRole(\"id\");\n    if (caps.edgeIds === \"required\" && edgeIds === null && snapshot.edgeCount > 0) {\n        note(\n            LOSS.EDGE_IDS_GENERATED,\n            \"the format requires edge ids; canonical e0..e{E-1} are generated and not written back\",\n            null,\n            snapshot.edgeCount,\n        );\n    } else if (caps.edgeIds === \"none\" && edgeIds !== null) {\n        note(\n            LOSS.EDGE_IDS_DROPPED,\n            `edge id column \"${edgeIds.meta.name}\" cannot be written`,\n            edgeIds.meta.name,\n            snapshot.edgeCount,\n        );\n    }\n\n    const unrepresentable = countUnrepresentableIds(snapshot, caps.idCharset);\n    if (unrepresentable > 0) {\n        if (caps.idCharset === \"dense-1-based\") {\n            note(\n                LOSS.ID_RENUMBERED,\n                options.sanitizeIds === \"mangle\"\n                    ? `${unrepresentable} node id(s) are not their 1-based index; nodes are numbered 1..N, the originals kept in the exporter's originalId attribute (restored by restoreMangledIds) and as labels of the nodes without a label value`\n                    : `${unrepresentable} node id(s) are not their 1-based index; nodes are numbered 1..N and ids kept as labels of the nodes without a label value (a node with one loses its id)`,\n                null,\n                unrepresentable,\n            );\n        } else if (options.sanitizeIds === \"mangle\") {\n            note(\n                LOSS.ID_MANGLED,\n                `${unrepresentable} node id(s) outside the ${caps.idCharset} charset are rewritten; originals kept in the originalId attribute`,\n                null,\n                unrepresentable,\n            );\n        } else {\n            note(\n                LOSS.ID_CHARSET,\n                `${unrepresentable} node id(s) outside the ${caps.idCharset} charset; export() will throw unless sanitizeIds is \"mangle\"`,\n                null,\n                unrepresentable,\n            );\n        }\n    }\n\n    checkColumns(snapshot.nodes, \"node\", caps, extras, note);\n    checkColumns(snapshot.edges, \"edge\", caps, extras, note);\n    const graphColumns = snapshot.graph.names();\n    if (graphColumns.length > 0) {\n        if (caps.graphAttributes) {\n            checkColumns(snapshot.graph, \"graph\", caps, extras, note);\n        } else {\n            note(\n                LOSS.GRAPH_ATTRIBUTES,\n                `${graphColumns.length} graph attribute(s) cannot be written`,\n                null,\n                graphColumns.length,\n            );\n        }\n    }\n\n    for (const [name, table] of snapshot.extensions) {\n        if (name.startsWith(\"temporal:\")) {\n            if (caps.temporal !== \"dynamic-values\") {\n                note(\n                    LOSS.DYNAMIC_VALUES,\n                    `dynamic values of \"${name}\" (${table.rowCount} row(s)) cannot be written`,\n                    name,\n                    table.rowCount,\n                );\n            }\n        } else {\n            note(\n                LOSS.EXTENSION_TABLE,\n                `extension table \"${name}\" (${table.rowCount} row(s)) cannot be written`,\n                name,\n                table.rowCount,\n            );\n        }\n    }\n    return notes;\n}\n\n/** A note-recording callback. */\ntype NoteFn = (code: string, message: string, column?: string | null, count?: number | null) => void;\n\n/**\n * The per-column checks of checkCapabilities().\n * @param table - the table\n * @param domain - the domain, for messages\n * @param caps - the capabilities\n * @param extras - format extras\n * @param note - the recorder\n */\nfunction checkColumns(\n    table: Iterable<Column>,\n    domain: string,\n    caps: ExportCapabilities,\n    extras: CheckExtras,\n    note: NoteFn,\n): void {\n    for (const column of table) {\n        const { meta } = column;\n        const { name, role } = meta;\n        if (role !== null && STRUCTURAL_ROLES.has(role)) {\n            continue;\n        }\n        const label = `${domain} column \"${name}\"`;\n        if (role !== null && extras.roleNames !== undefined) {\n            const fixed = extras.roleNames[role];\n            if (fixed !== undefined && fixed !== name) {\n                note(\n                    LOSS.COLUMN_NAME_CHANGED,\n                    `${label} (${role}) is written into the format's ${role} slot and reads back as \"${fixed}\"`,\n                    name,\n                    column.length - column.nullCount,\n                );\n            }\n        }\n        if (domain === \"edge\" && role === \"id\") {\n            continue;\n        }\n        if (role === \"timeText\") {\n            if (extras.temporalText !== true) {\n                note(\n                    LOSS.TEMPORAL_TEXT,\n                    `${label} (the lexical form of a temporal column, design section 5.1) cannot be written`,\n                    name,\n                    column.length - column.nullCount,\n                );\n            }\n            continue;\n        }\n        if (role === \"position\") {\n            if (!caps.positions) {\n                note(LOSS.POSITIONS, `${label} (positions) cannot be written`, name, column.length - column.nullCount);\n            } else if (extras.positionDtype !== undefined && meta.dtype !== extras.positionDtype) {\n                note(\n                    LOSS.DTYPE,\n                    `${label} (positions) is ${meta.dtype}; the format reads positions back as ${extras.positionDtype}`,\n                    name,\n                    column.length - column.nullCount,\n                );\n            }\n            continue;\n        }\n        if (role !== null && VIZ_ROLES.has(role)) {\n            if (!caps.viz) {\n                note(LOSS.VIZ, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);\n            }\n            continue;\n        }\n        if (role !== null && HIERARCHY_ROLES.has(role)) {\n            if (!caps.hierarchy) {\n                note(LOSS.HIERARCHY, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);\n            }\n            continue;\n        }\n        if (role !== null && TEMPORAL_ROLES.has(role)) {\n            if (caps.temporal === \"none\") {\n                note(LOSS.TEMPORAL, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);\n            }\n            continue;\n        }\n        if (role === \"spells\") {\n            if (caps.temporal !== \"spells\" && caps.temporal !== \"dynamic-values\") {\n                note(LOSS.SPELLS, `${label} (spells) cannot be written`, name, column.length - column.nullCount);\n            }\n            continue;\n        }\n        if (role === \"open\" || role === \"spellsOpen\") {\n            // The open bits are written by the format's own temporal syntax when it has one; the\n            // column's u8 storage is never an attribute dtype, so no dtype note either way.\n            if (extras.openIntervals !== true) {\n                note(\n                    LOSS.OPEN_INTERVAL,\n                    `${label} (open intervals) cannot be written`,\n                    name,\n                    column.length - column.nullCount,\n                );\n            }\n            continue;\n        }\n        if (role !== null && !(extras.roles?.has(role) ?? false)) {\n            note(\n                LOSS.ROLE,\n                `${label} (${role}) is written as a plain attribute; the format has no ${role} slot and the role is lost`,\n                name,\n                column.length - column.nullCount,\n            );\n        }\n        if (meta.dynamic && caps.temporal !== \"dynamic-values\") {\n            note(LOSS.DYNAMIC_VALUES, `${label} is dynamic; only its static value can be written`, name, null);\n        }\n        checkDtype(column, label, caps, note);\n        if (meta.default !== undefined && !caps.defaults) {\n            note(LOSS.DEFAULT, `${label} declares a default; the format has no defaults`, name, null);\n        }\n        if (meta.options !== null && !caps.options) {\n            note(LOSS.OPTIONS, `${label} declares options; the format has no enumerations`, name, null);\n        }\n    }\n}\n\n/**\n * The dtype checks of one attribute column: lists, nested values, scalar dtypes and strides\n * against the capability table.\n * @param column - the column\n * @param label - the column's label for messages\n * @param caps - the capabilities\n * @param note - the recorder\n */\nfunction checkDtype(column: Column, label: string, caps: ExportCapabilities, note: NoteFn): void {\n    const { meta } = column;\n    const { name } = meta;\n    const set = column.length - column.nullCount;\n    switch (meta.dtype) {\n        case \"list\":\n            if (!caps.lists) {\n                note(LOSS.LIST, `${label} is a list; the format has no lists`, name, set);\n            } else if (meta.itemDtype !== null && !caps.dtypes.includes(meta.itemDtype)) {\n                note(\n                    LOSS.DTYPE,\n                    `${label} holds ${meta.itemDtype} items; the format cannot keep that dtype`,\n                    name,\n                    set,\n                );\n            } else if (meta.itemDtype === \"dict\") {\n                // no format declares an enumeration for list items: they read back as strings\n                note(LOSS.DTYPE, `${label} holds dict items; list items read back as string`, name, set);\n            }\n            break;\n        case \"json\":\n            if (!caps.json) {\n                note(LOSS.JSON, `${label} holds nested values; the format has no nested values`, name, set);\n            }\n            break;\n        default:\n            if (!caps.dtypes.includes(meta.dtype)) {\n                note(LOSS.DTYPE, `${label} is ${meta.dtype}; the format cannot keep that dtype`, name, set);\n            }\n            if (meta.components > 1 && !caps.components) {\n                note(\n                    LOSS.COMPONENTS,\n                    `${label} has ${meta.components} components; the format has no strides`,\n                    name,\n                    set,\n                );\n            }\n            break;\n    }\n}\n\n/**\n * The number of source edges that were undirected in a directed snapshot (the halves of an\n * expanded pair count once; an expanded self-loop has no mirror and counts once).\n * @param snapshot - the snapshot\n * @returns the count; 0 for an undirected snapshot or one without the directed role\n */\nexport function countMixedEdges(snapshot: GraphSnapshot): number {\n    if (!snapshot.directed) {\n        return 0;\n    }\n    const directed = snapshot.edges.byRole(\"directed\");\n    if (directed === null || directed.dtype !== \"bool\") {\n        return 0;\n    }\n    const pair = snapshot.edges.byRole(\"pair\");\n    let undirectedRows = 0;\n    let paired = 0;\n    for (let e = 0; e < snapshot.edgeCount; e++) {\n        if (directed.isSet(e) && directed.value(e) === false) {\n            undirectedRows++;\n            if (pair !== null && pair.dtype === \"u32\" && pair.isSet(e) && pair.data[e] !== INVALID_INDEX) {\n                paired++;\n            }\n        }\n    }\n    return paired / 2 + (undirectedRows - paired);\n}\n\n/**\n * The number of arcs that repeat the previous arc's target within a row (parallel edges), counted\n * over the forward CSR; an undirected parallel edge is counted in both rows.\n * @param snapshot - the snapshot\n * @returns the count\n */\nexport function countParallelArcs(snapshot: GraphSnapshot): number {\n    const { rowPtr, colIdx, nodeCount } = snapshot;\n    let count = 0;\n    for (let u = 0; u < nodeCount; u++) {\n        for (let a = rowPtr[u] + 1; a < rowPtr[u + 1]; a++) {\n            if (colIdx[a] === colIdx[a - 1]) {\n                count++;\n            }\n        }\n    }\n    return snapshot.directed ? count : Math.ceil(count / 2);\n}\n\n// ============================================================ id sanitising\n\n/**\n * The id charsets of ExportCapabilities.\n * Consumed by the per-format importers and exporters under src/formats.\n * @public\n */\nexport type IdCharset = ExportCapabilities[\"idCharset\"];\n\n/**\n * The ids to write for every node after sanitising (design section 8.5).\n * Consumed by the per-format importers and exporters under src/formats.\n * @public\n */\nexport interface SanitizedIds {\n    /** The charset applied. */\n    readonly charset: IdCharset;\n    /** How many ids differ from the snapshot's. */\n    readonly changed: number;\n    /**\n     * The id to write for a node.\n     * @param index - the node index\n     * @returns the id as the format will read it back\n     */\n    idAt(index: number): NodeId;\n    /**\n     * Whether a node's written id differs from its original.\n     * @param index - the node index\n     * @returns true when the exporter must record the original\n     */\n    isChanged(index: number): boolean;\n    /**\n     * The original id of a node.\n     * @param index - the node index\n     * @returns the snapshot's id\n     */\n    originalAt(index: number): NodeId;\n}\n\n/** XML NameChar ranges (XML 1.0 fifth edition), as inclusive code point pairs. */\nconst NAME_CHAR_RANGES: readonly (readonly [number, number])[] = [\n    [0x2d, 0x2e],\n    [0x30, 0x3a],\n    [0x41, 0x5a],\n    [0x5f, 0x5f],\n    [0x61, 0x7a],\n    [0xb7, 0xb7],\n    [0xc0, 0xd6],\n    [0xd8, 0xf6],\n    [0xf8, 0x37d],\n    [0x37f, 0x1fff],\n    [0x200c, 0x200d],\n    [0x203f, 0x2040],\n    [0x2070, 0x218f],\n    [0x2c00, 0x2fef],\n    [0x3001, 0xd7ff],\n    [0xf900, 0xfdcf],\n    [0xfdf0, 0xfffd],\n    [0x10000, 0xeffff],\n];\n\n/**\n * Whether a code point is an XML NameChar.\n * @param cp - the code point\n * @returns true when it may appear in an NMTOKEN\n */\nexport function isNameChar(cp: number): boolean {\n    for (const [lo, hi] of NAME_CHAR_RANGES) {\n        if (cp < lo) {\n            return false;\n        }\n        if (cp <= hi) {\n            return true;\n        }\n    }\n    return false;\n}\n\n/**\n * Whether a text is an XML NMTOKEN (one or more NameChars; GraphML node and edge ids).\n * @param text - the text\n * @returns true for a non-empty text of NameChars\n */\nexport function isNmtoken(text: string): boolean {\n    if (text.length === 0) {\n        return false;\n    }\n    for (const ch of text) {\n        const cp = ch.codePointAt(0);\n        if (cp === undefined || !isNameChar(cp)) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/**\n * Whether an id can be written unchanged under a charset.\n * @param id - the id\n * @param charset - the charset\n * @returns true when the id needs no rewriting (\"dense-1-based\" is never true: see sanitizeIds)\n */\nexport function isRepresentableId(id: NodeId, charset: IdCharset): boolean {\n    switch (charset) {\n        case \"any\":\n            return true;\n        case \"nmtoken\":\n            return isNmtoken(String(id));\n        case \"integer\":\n            return typeof id === \"number\" && Number.isSafeInteger(id);\n        case \"dense-1-based\":\n            return false;\n        default: {\n            const name: string = charset;\n            throw new GraphFormatError(\"E_UNSUPPORTED\", `unknown id charset ${name}`, { charset: name });\n        }\n    }\n}\n\n/**\n * How many node ids a charset cannot hold as they are (for check()); under \"dense-1-based\" the\n * ids that are not their own 1-based index.\n * @param snapshot - the snapshot\n * @param charset - the charset\n * @returns the count\n */\nexport function countUnrepresentableIds(snapshot: GraphSnapshot, charset: IdCharset): number {\n    const { ids } = snapshot;\n    if (charset === \"any\") {\n        return 0;\n    }\n    if (charset === \"dense-1-based\") {\n        if (ids.kind === \"identity\" && ids.offset === 1) {\n            return 0;\n        }\n        let changed = 0;\n        for (let i = 0; i < ids.size; i++) {\n            if (ids.idOf(i) !== i + 1) {\n                changed++;\n            }\n        }\n        return changed;\n    }\n    let count = 0;\n    for (let i = 0; i < ids.size; i++) {\n        if (!isRepresentableId(ids.idOf(i), charset)) {\n            count++;\n        }\n    }\n    return count;\n}\n\n/**\n * Sanitise the node ids for a charset (design section 8.5). Under \"error\" any id the charset\n * cannot hold is E_INVALID_ID (details.reason \"charset\") and nothing is written; under \"mangle\"\n * such ids are rewritten deterministically and uniquely: NMTOKEN by replacing every other\n * character with `_` (an empty result becomes `_`) and suffixing `_2`, `_3`... on collision;\n * integer by the smallest unused non-negative integers in index order. \"dense-1-based\" always\n * writes the 1-based index (Pajek numbers vertices; the exporter writes the original id as the\n * label), which is a renumbering rather than a mangling, so it never throws under \"error\"; under\n * \"mangle\" the exporter also writes the original id under its originalId attribute.\n * @param snapshot - the snapshot\n * @param charset - the charset\n * @param mode - the resolved sanitizeIds option\n * @returns the ids to write\n */\nexport function sanitizeIds(snapshot: GraphSnapshot, charset: IdCharset, mode: \"error\" | \"mangle\"): SanitizedIds {\n    const { ids } = snapshot;\n    const n = ids.size;\n    if (charset === \"dense-1-based\") {\n        const changed = countUnrepresentableIds(snapshot, charset);\n        return {\n            charset,\n            changed,\n            idAt: (i: number): NodeId => i + 1,\n            isChanged: (i: number): boolean => ids.idOf(i) !== i + 1,\n            originalAt: (i: number): NodeId => ids.idOf(i),\n        };\n    }\n    const unchanged: SanitizedIds = {\n        charset,\n        changed: 0,\n        idAt: (i: number): NodeId => ids.idOf(i),\n        isChanged: (): boolean => false,\n        originalAt: (i: number): NodeId => ids.idOf(i),\n    };\n    if (charset === \"any\") {\n        return unchanged;\n    }\n    const bad: number[] = [];\n    for (let i = 0; i < n; i++) {\n        if (!isRepresentableId(ids.idOf(i), charset)) {\n            bad.push(i);\n        }\n    }\n    if (bad.length === 0) {\n        return unchanged;\n    }\n    if (mode === \"error\") {\n        const first = ids.idOf(bad[0]);\n        throw new GraphFormatError(\n            \"E_INVALID_ID\",\n            `${bad.length} node id(s) cannot be written as ${charset} (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: \"mangle\" to rewrite them`,\n            { reason: \"charset\", charset, count: bad.length, id: first, index: bad[0] },\n        );\n    }\n    const written = new Map<number, NodeId>();\n    if (charset === \"nmtoken\") {\n        const used = new Set<string>();\n        for (let i = 0; i < n; i++) {\n            const id = ids.idOf(i);\n            if (isRepresentableId(id, charset)) {\n                used.add(String(id));\n            }\n        }\n        for (const i of bad) {\n            const base = mangleNmtoken(String(ids.idOf(i)));\n            let candidate = base;\n            for (let k = 2; used.has(candidate); k++) {\n                candidate = `${base}_${k}`;\n            }\n            used.add(candidate);\n            written.set(i, candidate);\n        }\n    } else {\n        const used = new Set<number>();\n        for (let i = 0; i < n; i++) {\n            const id = ids.idOf(i);\n            if (typeof id === \"number\" && Number.isSafeInteger(id)) {\n                used.add(id);\n            }\n        }\n        let next = 0;\n        for (const i of bad) {\n            while (used.has(next)) {\n                next++;\n            }\n            used.add(next);\n            written.set(i, next);\n            next++;\n        }\n    }\n    return {\n        charset,\n        changed: bad.length,\n        idAt: (i: number): NodeId => written.get(i) ?? ids.idOf(i),\n        isChanged: (i: number): boolean => written.has(i),\n        originalAt: (i: number): NodeId => ids.idOf(i),\n    };\n}\n\n/**\n * Rewrite a text as an NMTOKEN: every character that is not a NameChar becomes `_`.\n * @param text - the text\n * @returns a non-empty NMTOKEN\n */\nexport function mangleNmtoken(text: string): string {\n    let out = \"\";\n    for (const ch of text) {\n        const cp = ch.codePointAt(0);\n        out += cp !== undefined && isNameChar(cp) ? ch : \"_\";\n    }\n    return out.length === 0 ? \"_\" : out;\n}\n","/**\n * The output side of the exporter contract (design sections 8.5 and 12.4): an exporter produces\n * its document as a sequence of text parts (a sync or async generator of strings, one per line or\n * element); these helpers turn that sequence into `export()`'s `AsyncIterable<Uint8Array>` of\n * UTF-8 chunks of a bounded size, into `exportToString()`'s one string, or into a\n * `ReadableStream<Uint8Array>` for a caller that wants a stream.\n */\n\n/**\n * Text parts an exporter produces.\n * Consumed by the per-format importers and exporters under src/formats.\n * @public\n */\nexport type TextParts = Iterable<string> | AsyncIterable<string>;\n\n/** The target size of one encoded chunk; parts are coalesced up to it and never split. */\nexport const DEFAULT_CHUNK_BYTES = 64 * 1024;\n\n/**\n * Encode text parts as UTF-8 chunks of about `chunkBytes` each. Small parts are coalesced; a part\n * larger than the chunk size is emitted whole. The last chunk may be short; nothing is emitted for\n * an empty document.\n * @param parts - the text parts\n * @param chunkBytes - the target chunk size in bytes\n * @yields UTF-8 chunks\n * @returns nothing\n */\nexport async function* encodeChunks(\n    parts: TextParts,\n    chunkBytes: number = DEFAULT_CHUNK_BYTES,\n): AsyncGenerator<Uint8Array, void, undefined> {\n    const encoder = new TextEncoder();\n    let pending: string[] = [];\n    let pendingUnits = 0;\n    for await (const part of parts) {\n        if (part.length === 0) {\n            continue;\n        }\n        pending.push(part);\n        pendingUnits += part.length;\n        // UTF-16 code units are a lower bound on the UTF-8 byte count; flush when the lower bound reaches the target\n        if (pendingUnits >= chunkBytes) {\n            yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(\"\"));\n            pending = [];\n            pendingUnits = 0;\n        }\n    }\n    if (pending.length > 0) {\n        yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(\"\"));\n    }\n}\n\n/**\n * Join text parts into one string.\n * @param parts - the text parts\n * @returns the whole document\n */\nexport async function joinText(parts: TextParts): Promise<string> {\n    const collected: string[] = [];\n    for await (const part of parts) {\n        collected.push(part);\n    }\n    return collected.join(\"\");\n}\n\n/**\n * Decode UTF-8 chunks back into one string (for tests and for callers holding an export() result).\n * @param chunks - the chunks\n * @returns the decoded text\n */\nexport async function decodeChunks(chunks: AsyncIterable<Uint8Array>): Promise<string> {\n    const decoder = new TextDecoder(\"utf-8\", { fatal: true });\n    const parts: string[] = [];\n    for await (const chunk of chunks) {\n        parts.push(decoder.decode(chunk, { stream: true }));\n    }\n    parts.push(decoder.decode());\n    return parts.join(\"\");\n}\n\n/**\n * Collect UTF-8 chunks into one Uint8Array.\n * @param chunks - the chunks\n * @returns the concatenated bytes\n */\nexport async function collectBytes(chunks: AsyncIterable<Uint8Array>): Promise<Uint8Array> {\n    const parts: Uint8Array[] = [];\n    let total = 0;\n    for await (const chunk of chunks) {\n        parts.push(chunk);\n        total += chunk.byteLength;\n    }\n    const out = new Uint8Array(total);\n    let offset = 0;\n    for (const part of parts) {\n        out.set(part, offset);\n        offset += part.byteLength;\n    }\n    return out;\n}\n\n/**\n * Wrap an async iterable of chunks as a ReadableStream, pulling one chunk per read and cancelling\n * the iterable when the stream is cancelled.\n * @param chunks - the chunks\n * @returns a byte stream\n */\nexport function toReadableStream(chunks: AsyncIterable<Uint8Array>): ReadableStream<Uint8Array> {\n    const iterator = chunks[Symbol.asyncIterator]();\n    return new ReadableStream<Uint8Array>({\n        async pull(controller): Promise<void> {\n            const { done, value } = await iterator.next();\n            if (done) {\n                controller.close();\n                return;\n            }\n            controller.enqueue(value);\n        },\n        async cancel(): Promise<void> {\n            await iterator.return?.(undefined);\n        },\n    });\n}\n"],"names":[],"mappings":"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"}

package/dist/csv.js

@@ -1,9 +1,10 @@
-import { aU as DICT_SAMPLE_ROWS, aT as DictHeuristic, a2 as ROLE_TAKEN_CODE$1, v as ID_MERGED_CODE$1, n as DUPLICATE_EDGE_ID_CODE$1, p as DUPLICATE_NODE_CODE$1, N as MISSING_ID_CODE$1, M as MISSING_ENDPOINT_CODE$1, r as EMPTY_INPUT_CODE$1, aD as resolveImportOptions, I as ImportReportBuilder, aA as reportSinkOptions, aB as reportUnusedOptions, q as DirectionResolver, J as IdCoercer, a as throwIfAborted, aE as uniqueColumnName, $ as RENAMED_CODE, as as declareResolved, aC as resolveExportOptions, ay as pairFolding, aR as joinListText, an as canonicalId, O as MIXED_DIRECTION_CODE, k as DIRECTION_FORCED_CODE, l as DIRECTION_REFUSED_CODE, a3 as SINK_OPTION_CODE, V as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, ag as UNKNOWN_ENCODING_CODE, s as ENCODING_FALLBACK_CODE, z as INVALID_ENCODING_CODE, F as INVALID_UTF8_CODE } from "./chunks/report-BOk0p5y8.js";
+import { aU as DICT_SAMPLE_ROWS, aT as DictHeuristic, a1 as ROLE_TAKEN_CODE$1, u as ID_MERGED_CODE$1, m as DUPLICATE_EDGE_ID_CODE$1, o as DUPLICATE_NODE_CODE$1, K as MISSING_ID_CODE$1, M as MISSING_ENDPOINT_CODE$1, q as EMPTY_INPUT_CODE$1, aC as resolveImportOptions, I as ImportReportBuilder, az as reportSinkOptions, aA as reportUnusedOptions, p as DirectionResolver, F as IdCoercer, t as throwIfAborted, aE as uniqueColumnName, _ as RENAMED_CODE, ar as declareResolved, aB as resolveExportOptions, ax as pairFolding, aR as joinListText, am as canonicalId, N as MIXED_DIRECTION_CODE, j as DIRECTION_FORCED_CODE, k as DIRECTION_REFUSED_CODE, a2 as SINK_OPTION_CODE, U as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, af as UNKNOWN_ENCODING_CODE, r as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE } from "./chunks/report-BcWboivV.js";
 import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-Dr0Ifpag.js";
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { p as parseWeightText, c as capabilities, L as LOSS, n as joinText, e as encodeChunks, a as checkCapabilities, r as countMixedEdges, f as explicitWeights, k as formatInteger, g as formatDecimal } from "./chunks/writer-GAdltGmC.js";
-import { s as sniffNewline, a as sniffDelimiter, C as CsvRecordReader, D as DELIMITER_CANDIDATES, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-Bk9jgodz.js";
-import { m as quoteCsvCell } from "./chunks/escape-D-gZWO26.js";
+import { p as parseWeightText, e as explicitWeights, d as formatInteger, f as formatDecimal } from "./chunks/weights-CwISIpCP.js";
+import { s as sniffNewline, a as sniffDelimiter, C as CsvRecordReader, D as DELIMITER_CANDIDATES, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-BzNicMsf.js";
+import { m as quoteCsvCell } from "./chunks/escape-CWExcecC.js";
+import { c as capabilities, L as LOSS, j as joinText, e as encodeChunks, a as checkCapabilities, g as countMixedEdges } from "./chunks/writer-DQiKgQJc.js";
 const SOURCE_NAMES = Object.freeze([
   "source",
   "src",