@graphty/graph-io 0.3.18 → 0.3.20

package/dist/chunks/weights-Dzba96G3.js

@@ -0,0 +1,176 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { aH as parseDecimalText } from "./report-B1z4WT9e.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 {
+  formatF64 as a,
+  formatDecimal as b,
+  formatGmlReal as c,
+  formatInteger as d,
+  explicitWeights as e,
+  formatF32 as f,
+  isWeightField as i,
+  parseWeightText as p,
+  weightFromValue as w
+};
+//# sourceMappingURL=weights-Dzba96G3.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"weights-Dzba96G3.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-C7flM-Ih.js

@@ -0,0 +1,77 @@
+const DEFAULT_CHUNK_BYTES = 64 * 1024;
+async function* encodeChunks(parts, chunkBytes = DEFAULT_CHUNK_BYTES) {
+  const encoder = new TextEncoder();
+  let pending = [];
+  let pendingUnits = 0;
+  for await (const part of parts) {
+    if (part.length === 0) {
+      continue;
+    }
+    pending.push(part);
+    pendingUnits += part.length;
+    if (pendingUnits >= chunkBytes) {
+      yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+      pending = [];
+      pendingUnits = 0;
+    }
+  }
+  if (pending.length > 0) {
+    yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+  }
+}
+async function joinText(parts) {
+  const collected = [];
+  for await (const part of parts) {
+    collected.push(part);
+  }
+  return collected.join("");
+}
+async function decodeChunks(chunks) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const parts = [];
+  for await (const chunk of chunks) {
+    parts.push(decoder.decode(chunk, { stream: true }));
+  }
+  parts.push(decoder.decode());
+  return parts.join("");
+}
+async function collectBytes(chunks) {
+  const parts = [];
+  let total = 0;
+  for await (const chunk of chunks) {
+    parts.push(chunk);
+    total += chunk.byteLength;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.byteLength;
+  }
+  return out;
+}
+function toReadableStream(chunks) {
+  const iterator = chunks[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await iterator.next();
+      if (done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(value);
+    },
+    async cancel() {
+      await iterator.return?.(void 0);
+    }
+  });
+}
+export {
+  DEFAULT_CHUNK_BYTES as D,
+  collectBytes as c,
+  decodeChunks as d,
+  encodeChunks as e,
+  joinText as j,
+  toReadableStream as t
+};
+//# sourceMappingURL=writer-C7flM-Ih.js.map

package/dist/chunks/writer-C7flM-Ih.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer-C7flM-Ih.js","sources":["../../src/common/writer.ts"],"sourcesContent":["/**\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":"AAgBO,MAAM,sBAAsB,KAAK;AAWxC,gBAAuB,aACnB,OACA,aAAqB,qBACsB;AAC3C,QAAM,UAAU,IAAI,YAAA;AACpB,MAAI,UAAoB,CAAA;AACxB,MAAI,eAAe;AACnB,mBAAiB,QAAQ,OAAO;AAC5B,QAAI,KAAK,WAAW,GAAG;AACnB;AAAA,IACJ;AACA,YAAQ,KAAK,IAAI;AACjB,oBAAgB,KAAK;AAErB,QAAI,gBAAgB,YAAY;AAC5B,YAAM,QAAQ,OAAO,QAAQ,WAAW,IAAI,QAAQ,CAAC,IAAI,QAAQ,KAAK,EAAE,CAAC;AACzE,gBAAU,CAAA;AACV,qBAAe;AAAA,IACnB;AAAA,EACJ;AACA,MAAI,QAAQ,SAAS,GAAG;AACpB,UAAM,QAAQ,OAAO,QAAQ,WAAW,IAAI,QAAQ,CAAC,IAAI,QAAQ,KAAK,EAAE,CAAC;AAAA,EAC7E;AACJ;AAOA,eAAsB,SAAS,OAAmC;AAC9D,QAAM,YAAsB,CAAA;AAC5B,mBAAiB,QAAQ,OAAO;AAC5B,cAAU,KAAK,IAAI;AAAA,EACvB;AACA,SAAO,UAAU,KAAK,EAAE;AAC5B;AAOA,eAAsB,aAAa,QAAoD;AACnF,QAAM,UAAU,IAAI,YAAY,SAAS,EAAE,OAAO,MAAM;AACxD,QAAM,QAAkB,CAAA;AACxB,mBAAiB,SAAS,QAAQ;AAC9B,UAAM,KAAK,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAA,CAAM,CAAC;AAAA,EACtD;AACA,QAAM,KAAK,QAAQ,QAAQ;AAC3B,SAAO,MAAM,KAAK,EAAE;AACxB;AAOA,eAAsB,aAAa,QAAwD;AACvF,QAAM,QAAsB,CAAA;AAC5B,MAAI,QAAQ;AACZ,mBAAiB,SAAS,QAAQ;AAC9B,UAAM,KAAK,KAAK;AAChB,aAAS,MAAM;AAAA,EACnB;AACA,QAAM,MAAM,IAAI,WAAW,KAAK;AAChC,MAAI,SAAS;AACb,aAAW,QAAQ,OAAO;AACtB,QAAI,IAAI,MAAM,MAAM;AACpB,cAAU,KAAK;AAAA,EACnB;AACA,SAAO;AACX;AAQO,SAAS,iBAAiB,QAA+D;AAC5F,QAAM,WAAW,OAAO,OAAO,aAAa,EAAA;AAC5C,SAAO,IAAI,eAA2B;AAAA,IAClC,MAAM,KAAK,YAA2B;AAClC,YAAM,EAAE,MAAM,MAAA,IAAU,MAAM,SAAS,KAAA;AACvC,UAAI,MAAM;AACN,mBAAW,MAAA;AACX;AAAA,MACJ;AACA,iBAAW,QAAQ,KAAK;AAAA,IAC5B;AAAA,IACA,MAAM,SAAwB;AAC1B,YAAM,SAAS,SAAS,MAAS;AAAA,IACrC;AAAA,EAAA,CACH;AACL;"}

package/dist/csv.js

@@ -1,9 +1,11 @@
-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 { aV as DICT_SAMPLE_ROWS, _ as DictHeuristic, R as ROLE_TAKEN_CODE$1, I as ID_MERGED_CODE$1, c as DUPLICATE_EDGE_ID_CODE$1, d as DUPLICATE_NODE_CODE$1, f as MISSING_ID_CODE$1, e as MISSING_ENDPOINT_CODE$1, u as EMPTY_INPUT_CODE$1, v as resolveImportOptions, w as ImportReportBuilder, F as reportSinkOptions, z as reportUnusedOptions, J as DirectionResolver, K as IdCoercer, y as throwIfAborted, Q as uniqueColumnName, at as RENAMED_CODE, L as declareResolved, V as resolveExportOptions, X as pairFolding, aT as joinListText, ax as canonicalId, af as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, a as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, C as COLUMN_RENAMED_CODE, q as UNKNOWN_ENCODING_CODE, E as ENCODING_FALLBACK_CODE, r as INVALID_ENCODING_CODE, s as INVALID_UTF8_CODE } from "./chunks/report-B1z4WT9e.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, b as formatDecimal } from "./chunks/weights-Dzba96G3.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-dbRkxwaq.js";
+import { m as quoteCsvCell } from "./chunks/escape-B-tkk_Cl.js";
+import { c as capabilities, L as LOSS, a as checkCapabilities, d as countMixedEdges } from "./chunks/export-Bh60Dv-n.js";
+import { j as joinText, e as encodeChunks } from "./chunks/writer-C7flM-Ih.js";
 const SOURCE_NAMES = Object.freeze([
   "source",
   "src",