@graphty/graph-io 0.3.38 → 0.3.40

package/dist/chunks/{text-Btw3sBe_.js.map → text-Bjfa1xYL.js.map}

@@ -1 +1 @@
-{"version":3,"file":"text-Btw3sBe_.js","sources":["../../src/common/text.ts"],"sourcesContent":["/**\n * The fixed lexical grammar of design section 5.1 for untyped text sources (CSV cells, GML\n * values, DOT strings, Pajek tokens), reproduced from the core's reference implementation so the\n * two agree (invariant I15). Text importers parse each cell with parseTextCell() and push the JS\n * value; the sink's per-column inference then widens `bool -> i32 -> f64 -> string` and never per\n * cell, so a column that saw `1` and then `\"01\"` becomes string for all rows.\n *\n * - `bool` is exactly `true` / `false` (case-sensitive);\n * - `i32` is `/^-?(0|[1-9][0-9]*)$/` within `[-2^31, 2^31)`; `0` / `1` are i32, never bool;\n * - `f64` is a decimal or exponent literal accepted by `Number()` that is not empty, not\n *   whitespace, not `Infinity` / `NaN`, not a hex / octal / binary form, has no leading zeros in\n *   its integer part, and whose value is finite (an integer literal outside i32 range is f64);\n * - everything else is `string`.\n */\n\nimport { type ColumnHandle, GraphFormatError, type GraphSink, INVALID_INDEX } from \"@graphty/graph-format\";\n\nimport { PRECISION_CODE } from \"./codes.js\";\nimport { type ImportReportBuilder } from \"./report.js\";\n\nconst I32_TEXT = /^-?(0|[1-9]\\d*)$/;\nconst F64_TEXT = /^[+-]?((0|[1-9]\\d*)(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?$/;\nconst I32_MIN = -2147483648;\nconst I32_MAX = 2147483647;\n\n/**\n * The dtype a text cell parses as under the fixed text grammar.\n * @public\n * @category Plugin helpers\n */\nexport type TextDtype = \"bool\" | \"i32\" | \"f64\" | \"string\";\n\n/**\n * A digit string without its trailing zeros (`\"1200\"` becomes `\"12\"`).\n * @param digits - the digits\n * @returns the digits up to the last one that is not 0\n */\nexport function trimTrailingZeros(digits: string): string {\n    let end = digits.length;\n    while (end > 0 && digits[end - 1] === \"0\") {\n        end--;\n    }\n    return digits.slice(0, end);\n}\n\n/**\n * Classify one text cell by the fixed grammar.\n * @param text - the cell text, exactly as read (no trimming)\n * @returns bool, i32, f64 or string\n * @category Plugin helpers\n */\nexport function inferTextDtype(text: string): TextDtype {\n    if (text === \"true\" || text === \"false\") {\n        return \"bool\";\n    }\n    if (I32_TEXT.test(text)) {\n        const n = Number(text);\n        if (n >= I32_MIN && n <= I32_MAX) {\n            return \"i32\";\n        }\n        return Number.isFinite(n) ? \"f64\" : \"string\";\n    }\n    if (F64_TEXT.test(text) && Number.isFinite(Number(text))) {\n        return \"f64\";\n    }\n    return \"string\";\n}\n\n/**\n * Parse one text cell into the JS value its grammar class implies: a boolean for bool, a number for\n * i32 / f64, the text itself for string. The sink infers the column dtype from the value.\n * @param text - the cell text, exactly as read\n * @returns the value\n * @category Plugin helpers\n */\nexport function parseTextCell(text: string): boolean | number | string {\n    switch (inferTextDtype(text)) {\n        case \"bool\":\n            return text === \"true\";\n        case \"i32\":\n        case \"f64\":\n            return Number(text);\n        case \"string\":\n            return text;\n        default:\n            return text;\n    }\n}\n\n/**\n * Whether a text cell is a number under the f64 grammar (an i32 or f64 literal).\n * @param text - the cell text\n * @returns true when parseTextCell(text) returns a number\n * @category Plugin helpers\n */\nexport function isNumericText(text: string): boolean {\n    const dtype = inferTextDtype(text);\n    return dtype === \"i32\" || dtype === \"f64\";\n}\n\n/**\n * Whether a numeric cell text is the canonical spelling of its value (`String(value) === text`),\n * so that the sink's own re-formatting of the value would reproduce it.\n * @param text - the cell text\n * @param value - the parsed value\n * @returns true when the lexical form survives a widening to string\n */\nfunction isCanonicalNumberText(text: string, value: number): boolean {\n    return String(value) === text;\n}\n\n/**\n * The widening rank of a text dtype in the design section 5.1 order.\n * @param dtype - the text dtype\n * @returns 0 for bool, 1 for i32, 2 for f64, 3 for string\n */\nfunction textDtypeRank(dtype: TextDtype): number {\n    switch (dtype) {\n        case \"bool\":\n            return 0;\n        case \"i32\":\n            return 1;\n        case \"f64\":\n            return 2;\n        case \"string\":\n            return 3;\n        default: {\n            const name: string = dtype;\n            throw new GraphFormatError(\"E_UNSUPPORTED\", `unknown text dtype ${name}`, { dtype: name });\n        }\n    }\n}\n\n/**\n * Writes the cells of one attribute of a text format whose values carry no type (CSV, DOT, Pajek):\n * you hand it each cell's text and it stores a number, a boolean or text, choosing one type for the\n * whole attribute. A column of `2.0`, `3.5` stays a number column with decimals even though `2.0`\n * alone looks like an integer, and once one cell turns out to be text, earlier cells such as `1e5`\n * are kept as written instead of as `100000`. Create one writer per attribute name and per kind\n * (\"node\" or \"edge\"), and call `write(index, text)` with the node or edge index the sink gave you:\n *\n * ```ts\n * const color = new TextCellWriter(\"color\", \"node\", sink, report);\n * color.write(sink.addNode(\"a\"), \"red\");\n * ```\n *\n * A sink that cannot change a column's type after the fact (one of your own without\n * `widenNodeColumn` / `widenEdgeColumn`) keeps the type the first values implied, with one W_WIDENING_UNSUPPORTED warning\n * per attribute.\n * @public\n * @category Writing a format\n */\nexport class TextCellWriter {\n    /** The column name in the sink. */\n    readonly name: string;\n\n    private readonly domain: \"node\" | \"edge\";\n\n    private readonly sink: GraphSink;\n\n    private readonly report: ImportReportBuilder;\n\n    private handle: ColumnHandle = INVALID_INDEX as ColumnHandle;\n\n    /** The widest text dtype seen (the column's dtype under the 5.1 grammar). */\n    private textDtype: TextDtype | null = null;\n\n    /** The widest dtype the pushed values imply (what the sink inferred on its own). */\n    private valueDtype: TextDtype | null = null;\n\n    private readonly keptRows: number[] = [];\n\n    private readonly keptTexts: string[] = [];\n\n    /**\n     * Create a writer. The attribute is added to the sink on the first write.\n     * @param name - the attribute name\n     * @param domain - \"node\" for a node attribute, \"edge\" for an edge attribute\n     * @param sink - the sink the importer fills\n     * @param report - the import report, for warnings about the values\n     */\n    constructor(name: string, domain: \"node\" | \"edge\", sink: GraphSink, report: ImportReportBuilder) {\n        this.name = name;\n        this.domain = domain;\n        this.sink = sink;\n        this.report = report;\n    }\n\n    /**\n     * The sink's handle of the attribute's column, for reading it back.\n     * @returns the handle, or INVALID_INDEX before the first write\n     */\n    get column(): ColumnHandle {\n        return this.handle;\n    }\n\n    /**\n     * Write one cell.\n     * @param row - the node or edge index, as the sink's addNode() or addEdge() returned it\n     * @param text - the cell text, exactly as read from the file\n     */\n    write(row: number, text: string): void {\n        const kind = inferTextDtype(text);\n        const value = parseTextCell(text);\n        if (\n            typeof value === \"number\" &&\n            !Number.isSafeInteger(value) &&\n            I32_TEXT.test(text) &&\n            BigInt(text) !== BigInt(value)\n        ) {\n            // an integer beyond 2^53 is stored as the nearest double; say so once per column\n            this.report.warnOnce(\n                \"precision\",\n                PRECISION_CODE,\n                `${this.domain} column \"${this.name}\": integers beyond 2^53 are stored as the nearest double (first: ${text})`,\n                { element: this.name },\n                `${PRECISION_CODE}:${this.domain}:${this.name}`,\n            );\n        }\n        const wasString = this.textDtype === \"string\";\n        const textDtype =\n            this.textDtype === null || textDtypeRank(kind) > textDtypeRank(this.textDtype) ? kind : this.textDtype;\n        // a string column keeps every cell's lexical form; a numeric text is never re-spelled. The\n        // sink may refuse the value (a declared column of another dtype): the state advances only\n        // once the cell is written, so a refused cell leaves the writer as it was.\n        this.set(row, textDtype === \"string\" ? text : value);\n        this.textDtype = textDtype;\n        const valueKind = kindOfValue(value);\n        if (this.valueDtype === null || textDtypeRank(valueKind) > textDtypeRank(this.valueDtype)) {\n            this.valueDtype = valueKind;\n        }\n        if (this.textDtype === \"string\") {\n            if (!wasString && this.keptRows.length > 0) {\n                // the sink just widened the column to string from the values; restore the texts\n                // whose lexical form the values did not carry\n                for (let i = 0; i < this.keptRows.length; i++) {\n                    this.set(this.keptRows[i], this.keptTexts[i]);\n                }\n                this.keptRows.length = 0;\n                this.keptTexts.length = 0;\n            }\n            return;\n        }\n        if (typeof value === \"number\" && !isCanonicalNumberText(text, value)) {\n            this.keptRows.push(row);\n            this.keptTexts.push(text);\n        }\n        if (this.textDtype === \"f64\" && this.valueDtype !== \"f64\") {\n            this.widen(\"f64\");\n        }\n    }\n\n    /**\n     * Write a value (the parsed scalar, or a text into a widened column).\n     * @param row - the row\n     * @param value - the value\n     */\n    private set(row: number, value: unknown): void {\n        if (this.handle === INVALID_INDEX) {\n            if (this.domain === \"node\") {\n                this.sink.setNodeValue(this.name, row, value);\n                this.handle = this.sink.nodeColumn(this.name);\n            } else {\n                this.sink.setEdgeValue(this.name, row, value);\n                this.handle = this.sink.edgeColumn(this.name);\n            }\n            return;\n        }\n        if (this.domain === \"node\") {\n            this.sink.setNodeValue(this.handle, row, value);\n        } else {\n            this.sink.setEdgeValue(this.handle, row, value);\n        }\n    }\n\n    /**\n     * Widen the column to the dtype the text grammar implies, through the sink's optional call.\n     * @param dtype - the dtype\n     */\n    private widen(dtype: \"f64\"): void {\n        const { sink } = this;\n        const supported =\n            this.domain === \"node\" ? sink.widenNodeColumn !== undefined : sink.widenEdgeColumn !== undefined;\n        if (!supported) {\n            this.report.warnOnce(\n                \"coercion\",\n                WIDENING_UNSUPPORTED_CODE,\n                `column \"${this.name}\" holds ${dtype} text but the sink cannot widen an inferred column; it keeps the value-inferred dtype`,\n                { element: this.name },\n            );\n            this.valueDtype = dtype;\n            return;\n        }\n        try {\n            if (this.domain === \"node\") {\n                sink.widenNodeColumn?.(this.handle, dtype);\n            } else {\n                sink.widenEdgeColumn?.(this.handle, dtype);\n            }\n            this.valueDtype = dtype;\n        } catch (err) {\n            if (!(err instanceof GraphFormatError) || err.code !== \"E_COLUMN_TYPE\") {\n                throw err;\n            }\n            // a caller's declared column of the name: its dtype stands\n            this.valueDtype = dtype;\n        }\n    }\n}\n\n/**\n * Your graph builder cannot change an attribute's type after its first value, so a text column keeps the type of its\n * first values.\n * @category Issue and loss codes\n */\nexport const WIDENING_UNSUPPORTED_CODE = \"W_WIDENING_UNSUPPORTED\";\n\n/**\n * The text dtype a parsed cell value implies on its own (what the sink's inference sees). It must\n * be graph-format's inference rule exactly: -0 is an integer there, so a column holding only\n * `-0.0` is inferred i32 and must be widened to f64, or the sign is lost.\n * @param value - the parsed value\n * @returns the dtype\n */\nfunction kindOfValue(value: boolean | number | string): TextDtype {\n    if (typeof value === \"boolean\") {\n        return \"bool\";\n    }\n    if (typeof value === \"string\") {\n        return \"string\";\n    }\n    return Number.isInteger(value) && value >= -2147483648 && value <= 2147483647 ? \"i32\" : \"f64\";\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"text-Bjfa1xYL.js","sources":["../../src/common/text.ts"],"sourcesContent":["/**\n * The fixed lexical grammar of design section 5.1 for untyped text sources (CSV cells, GML\n * values, DOT strings, Pajek tokens), reproduced from the core's reference implementation so the\n * two agree (invariant I15). Text importers parse each cell with parseTextCell() and push the JS\n * value; the sink's per-column inference then widens `bool -> i32 -> f64 -> string` and never per\n * cell, so a column that saw `1` and then `\"01\"` becomes string for all rows.\n *\n * - `bool` is exactly `true` / `false` (case-sensitive);\n * - `i32` is `/^-?(0|[1-9][0-9]*)$/` within `[-2^31, 2^31)`; `0` / `1` are i32, never bool;\n * - `f64` is a decimal or exponent literal accepted by `Number()` that is not empty, not\n *   whitespace, not `Infinity` / `NaN`, not a hex / octal / binary form, has no leading zeros in\n *   its integer part, and whose value is finite (an integer literal outside i32 range is f64);\n * - everything else is `string`.\n */\n\nimport { type ColumnHandle, GraphFormatError, type GraphSink, INVALID_INDEX } from \"@graphty/graph-format\";\n\nimport { PRECISION_CODE } from \"./codes.js\";\nimport { type ImportReportBuilder } from \"./report.js\";\n\nconst I32_TEXT = /^-?(0|[1-9]\\d*)$/;\nconst F64_TEXT = /^[+-]?((0|[1-9]\\d*)(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?$/;\nconst I32_MIN = -2147483648;\nconst I32_MAX = 2147483647;\n\n/**\n * The dtype a text cell parses as under the fixed text grammar.\n * @public\n * @category Plugin helpers\n */\nexport type TextDtype = \"bool\" | \"i32\" | \"f64\" | \"string\";\n\n/**\n * A digit string without its trailing zeros (`\"1200\"` becomes `\"12\"`).\n * @param digits - the digits\n * @returns the digits up to the last one that is not 0\n */\nexport function trimTrailingZeros(digits: string): string {\n    let end = digits.length;\n    while (end > 0 && digits[end - 1] === \"0\") {\n        end--;\n    }\n    return digits.slice(0, end);\n}\n\n/**\n * Classify one text cell by the fixed grammar.\n * @param text - the cell text, exactly as read (no trimming)\n * @returns bool, i32, f64 or string\n * @category Plugin helpers\n */\nexport function inferTextDtype(text: string): TextDtype {\n    if (text === \"true\" || text === \"false\") {\n        return \"bool\";\n    }\n    if (I32_TEXT.test(text)) {\n        const n = Number(text);\n        if (n >= I32_MIN && n <= I32_MAX) {\n            return \"i32\";\n        }\n        return Number.isFinite(n) ? \"f64\" : \"string\";\n    }\n    if (F64_TEXT.test(text) && Number.isFinite(Number(text))) {\n        return \"f64\";\n    }\n    return \"string\";\n}\n\n/**\n * Parse one text cell into the JS value its grammar class implies: a boolean for bool, a number for\n * i32 / f64, the text itself for string. The sink infers the column dtype from the value.\n * @param text - the cell text, exactly as read\n * @returns the value\n * @category Plugin helpers\n */\nexport function parseTextCell(text: string): boolean | number | string {\n    switch (inferTextDtype(text)) {\n        case \"bool\":\n            return text === \"true\";\n        case \"i32\":\n        case \"f64\":\n            return Number(text);\n        case \"string\":\n            return text;\n        default:\n            return text;\n    }\n}\n\n/**\n * Whether a text cell is a number under the f64 grammar (an i32 or f64 literal).\n * @param text - the cell text\n * @returns true when parseTextCell(text) returns a number\n * @category Plugin helpers\n */\nexport function isNumericText(text: string): boolean {\n    const dtype = inferTextDtype(text);\n    return dtype === \"i32\" || dtype === \"f64\";\n}\n\n/**\n * Whether a numeric cell text is the canonical spelling of its value (`String(value) === text`),\n * so that the sink's own re-formatting of the value would reproduce it.\n * @param text - the cell text\n * @param value - the parsed value\n * @returns true when the lexical form survives a widening to string\n */\nfunction isCanonicalNumberText(text: string, value: number): boolean {\n    return String(value) === text;\n}\n\n/**\n * The widening rank of a text dtype in the design section 5.1 order.\n * @param dtype - the text dtype\n * @returns 0 for bool, 1 for i32, 2 for f64, 3 for string\n */\nfunction textDtypeRank(dtype: TextDtype): number {\n    switch (dtype) {\n        case \"bool\":\n            return 0;\n        case \"i32\":\n            return 1;\n        case \"f64\":\n            return 2;\n        case \"string\":\n            return 3;\n        default: {\n            const name: string = dtype;\n            throw new GraphFormatError(\"E_UNSUPPORTED\", `unknown text dtype ${name}`, { dtype: name });\n        }\n    }\n}\n\n/**\n * Writes the cells of one attribute of a text format whose values carry no type (CSV, DOT, Pajek):\n * you hand it each cell's text and it stores a number, a boolean or text, choosing one type for the\n * whole attribute. A column of `2.0`, `3.5` stays a number column with decimals even though `2.0`\n * alone looks like an integer, and once one cell turns out to be text, earlier cells such as `1e5`\n * are kept as written instead of as `100000`. Create one writer per attribute name and per kind\n * (\"node\" or \"edge\"), and call `write(index, text)` with the node or edge index the sink gave you:\n *\n * ```ts\n * const color = new TextCellWriter(\"color\", \"node\", sink, report);\n * color.write(sink.addNode(\"a\"), \"red\");\n * ```\n *\n * A sink that cannot change a column's type after the fact (one of your own without\n * `widenNodeColumn` / `widenEdgeColumn`) keeps the type the first values implied, with one W_WIDENING_UNSUPPORTED warning\n * per attribute.\n * @public\n * @category Writing a format\n */\nexport class TextCellWriter {\n    /** The column name in the sink. */\n    readonly name: string;\n\n    private readonly domain: \"node\" | \"edge\";\n\n    private readonly sink: GraphSink;\n\n    private readonly report: ImportReportBuilder;\n\n    private handle: ColumnHandle = INVALID_INDEX as ColumnHandle;\n\n    /** The widest text dtype seen (the column's dtype under the 5.1 grammar). */\n    private textDtype: TextDtype | null = null;\n\n    /** The widest dtype the pushed values imply (what the sink inferred on its own). */\n    private valueDtype: TextDtype | null = null;\n\n    private readonly keptRows: number[] = [];\n\n    private readonly keptTexts: string[] = [];\n\n    /**\n     * Create a writer. The attribute is added to the sink on the first write.\n     * @param name - the attribute name\n     * @param domain - \"node\" for a node attribute, \"edge\" for an edge attribute\n     * @param sink - the sink the importer fills\n     * @param report - the import report, for warnings about the values\n     */\n    constructor(name: string, domain: \"node\" | \"edge\", sink: GraphSink, report: ImportReportBuilder) {\n        this.name = name;\n        this.domain = domain;\n        this.sink = sink;\n        this.report = report;\n    }\n\n    /**\n     * The sink's handle of the attribute's column, for reading it back.\n     * @returns the handle, or INVALID_INDEX before the first write\n     */\n    get column(): ColumnHandle {\n        return this.handle;\n    }\n\n    /**\n     * Write one cell.\n     * @param row - the node or edge index, as the sink's addNode() or addEdge() returned it\n     * @param text - the cell text, exactly as read from the file\n     */\n    write(row: number, text: string): void {\n        const kind = inferTextDtype(text);\n        const value = parseTextCell(text);\n        if (\n            typeof value === \"number\" &&\n            !Number.isSafeInteger(value) &&\n            I32_TEXT.test(text) &&\n            BigInt(text) !== BigInt(value)\n        ) {\n            // an integer beyond 2^53 is stored as the nearest double; say so once per column\n            this.report.warnOnce(\n                \"precision\",\n                PRECISION_CODE,\n                `${this.domain} column \"${this.name}\": integers beyond 2^53 are stored as the nearest double (first: ${text})`,\n                { element: this.name },\n                `${PRECISION_CODE}:${this.domain}:${this.name}`,\n            );\n        }\n        const wasString = this.textDtype === \"string\";\n        const textDtype =\n            this.textDtype === null || textDtypeRank(kind) > textDtypeRank(this.textDtype) ? kind : this.textDtype;\n        // a string column keeps every cell's lexical form; a numeric text is never re-spelled. The\n        // sink may refuse the value (a declared column of another dtype): the state advances only\n        // once the cell is written, so a refused cell leaves the writer as it was.\n        this.set(row, textDtype === \"string\" ? text : value);\n        this.textDtype = textDtype;\n        const valueKind = kindOfValue(value);\n        if (this.valueDtype === null || textDtypeRank(valueKind) > textDtypeRank(this.valueDtype)) {\n            this.valueDtype = valueKind;\n        }\n        if (this.textDtype === \"string\") {\n            if (!wasString && this.keptRows.length > 0) {\n                // the sink just widened the column to string from the values; restore the texts\n                // whose lexical form the values did not carry\n                for (let i = 0; i < this.keptRows.length; i++) {\n                    this.set(this.keptRows[i], this.keptTexts[i]);\n                }\n                this.keptRows.length = 0;\n                this.keptTexts.length = 0;\n            }\n            return;\n        }\n        if (typeof value === \"number\" && !isCanonicalNumberText(text, value)) {\n            this.keptRows.push(row);\n            this.keptTexts.push(text);\n        }\n        if (this.textDtype === \"f64\" && this.valueDtype !== \"f64\") {\n            this.widen(\"f64\");\n        }\n    }\n\n    /**\n     * Write a value (the parsed scalar, or a text into a widened column).\n     * @param row - the row\n     * @param value - the value\n     */\n    private set(row: number, value: unknown): void {\n        if (this.handle === INVALID_INDEX) {\n            if (this.domain === \"node\") {\n                this.sink.setNodeValue(this.name, row, value);\n                this.handle = this.sink.nodeColumn(this.name);\n            } else {\n                this.sink.setEdgeValue(this.name, row, value);\n                this.handle = this.sink.edgeColumn(this.name);\n            }\n            return;\n        }\n        if (this.domain === \"node\") {\n            this.sink.setNodeValue(this.handle, row, value);\n        } else {\n            this.sink.setEdgeValue(this.handle, row, value);\n        }\n    }\n\n    /**\n     * Widen the column to the dtype the text grammar implies, through the sink's optional call.\n     * @param dtype - the dtype\n     */\n    private widen(dtype: \"f64\"): void {\n        const { sink } = this;\n        const supported =\n            this.domain === \"node\" ? sink.widenNodeColumn !== undefined : sink.widenEdgeColumn !== undefined;\n        if (!supported) {\n            this.report.warnOnce(\n                \"coercion\",\n                WIDENING_UNSUPPORTED_CODE,\n                `column \"${this.name}\" holds ${dtype} text but the sink cannot widen an inferred column; it keeps the value-inferred dtype`,\n                { element: this.name },\n            );\n            this.valueDtype = dtype;\n            return;\n        }\n        try {\n            if (this.domain === \"node\") {\n                sink.widenNodeColumn?.(this.handle, dtype);\n            } else {\n                sink.widenEdgeColumn?.(this.handle, dtype);\n            }\n            this.valueDtype = dtype;\n        } catch (err) {\n            if (!(err instanceof GraphFormatError) || err.code !== \"E_COLUMN_TYPE\") {\n                throw err;\n            }\n            // a caller's declared column of the name: its dtype stands\n            this.valueDtype = dtype;\n        }\n    }\n}\n\n/**\n * Your graph builder cannot change an attribute's type after its first value, so a text column keeps the type of its\n * first values.\n * @category Issue and loss codes\n */\nexport const WIDENING_UNSUPPORTED_CODE = \"W_WIDENING_UNSUPPORTED\";\n\n/**\n * The text dtype a parsed cell value implies on its own (what the sink's inference sees). It must\n * be graph-format's inference rule exactly: -0 is an integer there, so a column holding only\n * `-0.0` is inferred i32 and must be widened to f64, or the sign is lost.\n * @param value - the parsed value\n * @returns the dtype\n */\nfunction kindOfValue(value: boolean | number | string): TextDtype {\n    if (typeof value === \"boolean\") {\n        return \"bool\";\n    }\n    if (typeof value === \"string\") {\n        return \"string\";\n    }\n    return Number.isInteger(value) && value >= -2147483648 && value <= 2147483647 ? \"i32\" : \"f64\";\n}\n"],"names":[],"mappings":"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"}

package/dist/csv.js

@@ -1,8 +1,8 @@
-import { b as plural, bU as DICT_SAMPLE_ROWS, ac as DictHeuristic, R as ROLE_TAKEN_CODE$1, I as ID_MERGED_CODE$1, m as DUPLICATE_EDGE_ID_CODE$1, n as DUPLICATE_NODE_CODE$1, t as MISSING_ID_CODE$1, s as MISSING_ENDPOINT_CODE$1, E as EMPTY_INPUT_CODE$1, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, aq as DirectionResolver, ar as IdCoercer, am as throwIfAborted, O as OPTION_IGNORED_CODE, aK as parseWeightText, a0 as uniqueColumnName, ay as RENAMED_CODE, a1 as declareResolved, c as capabilities, L as LOSS, a as checkCapabilities, r as resolveExportOptions, p as pairFolding, bD as countMixedEdges, $ as agree, e as explicitWeights, b_ as otherFormatDialect, bS as joinListText, aG as formatInteger, aF as formatDecimal, aH as canonicalId, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, C as COLUMN_RENAMED_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, P as PRECISION_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-CTUlibzr.js";
-import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-Btw3sBe_.js";
+import { b as plural, bU as DICT_SAMPLE_ROWS, ac as DictHeuristic, R as ROLE_TAKEN_CODE$1, I as ID_MERGED_CODE$1, m as DUPLICATE_EDGE_ID_CODE$1, n as DUPLICATE_NODE_CODE$1, t as MISSING_ID_CODE$1, s as MISSING_ENDPOINT_CODE$1, E as EMPTY_INPUT_CODE$1, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, aq as DirectionResolver, ar as IdCoercer, am as throwIfAborted, O as OPTION_IGNORED_CODE, aK as parseWeightText, a0 as uniqueColumnName, ay as RENAMED_CODE, a1 as declareResolved, c as capabilities, L as LOSS, a as checkCapabilities, r as resolveExportOptions, p as pairFolding, bD as countMixedEdges, $ as agree, e as explicitWeights, b_ as otherFormatDialect, bS as joinListText, aG as formatInteger, aF as formatDecimal, aH as canonicalId, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, C as COLUMN_RENAMED_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, P as PRECISION_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-B-aVCwyG.js";
+import { i as inferTextDtype, T as TextCellWriter, p as parseTextCell, W as WIDENING_UNSUPPORTED_CODE } from "./chunks/text-Bjfa1xYL.js";
 import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
-import { s as stripLeadingComments, a as sniffNewline, b as sniffDelimiter, D as DELIMITER_CANDIDATES, c as checkRecordSyntax, C as CsvRecordReader, d as splitRecords, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-ChmWZGuz.js";
-import { o as quoteCsvCell } from "./chunks/escape-BRcyzD77.js";
+import { s as stripLeadingComments, a as sniffNewline, b as sniffDelimiter, D as DELIMITER_CANDIDATES, c as checkRecordSyntax, C as CsvRecordReader, d as splitRecords, B as BAD_QUOTE_CODE, U as UNCLOSED_QUOTE_CODE } from "./chunks/records-r3SFHz11.js";
+import { o as quoteCsvCell } from "./chunks/escape-BJRLd3vJ.js";
 import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
 const SOURCE_NAMES = Object.freeze([
   "source",

package/dist/cx.js

@@ -1,4 +1,4 @@
-import { C, a, b, c, d } from "./chunks/importer-CNMQnHDd.js";
+import { C, a, b, c, d } from "./chunks/importer-D_srHyj6.js";
 export {
   C as CX_CAPABILITIES,
   a as CX_ISSUE,

package/dist/cx2.js

@@ -1,5 +1,5 @@
-import { C, a, c } from "./chunks/exporter-Bf5tZA0X.js";
-import { C as C2, c as c2 } from "./chunks/importer-BuzbaFFY.js";
+import { C, a, c } from "./chunks/exporter-6ocL_9x_.js";
+import { C as C2, c as c2 } from "./chunks/importer-BJlGAOht.js";
 export {
   C as CX2_CAPABILITIES,
   C2 as CX2_ISSUE,

package/dist/cys.js

@@ -1,4 +1,4 @@
-import { C, a, b, c, d } from "./chunks/importer-CEuUmyPe.js";
+import { C, a, b, c, d } from "./chunks/importer-CPqnIY8m.js";
 export {
   C as CYS_CAPABILITIES,
   a as CYS_ISSUE,

package/dist/dot.js

@@ -1,4 +1,4 @@
-import { D, a, d, b } from "./chunks/importer-oIUx9u_g.js";
+import { D, a, d, b } from "./chunks/importer-DcKB97kW.js";
 export {
   D as DOT_ISSUE,
   a as DOT_LOSS,

package/dist/gexf.js

@@ -1,6 +1,6 @@
-import { bF as TIME_TEXT_ROLE, bG as TIME_TEXT_SUFFIX, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, a4 as textChunks, E as EMPTY_INPUT_CODE, X as XML_SYNTAX_CODE, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, f as STRAY_TEXT_CODE, N as NO_GRAPH_CODE, h as UNKNOWN_XML_ATTRIBUTE_CODE, l as MULTIPLE_GRAPHS_CODE, j as COUNT_MISMATCH_CODE, k as COUNT_HINT_CODE, o as DUPLICATE_ATTRIBUTE_CODE, aJ as isWeightField, bH as declareAttribute, a1 as declareResolved, t as MISSING_ID_CODE, n as DUPLICATE_NODE_CODE, q as UNKNOWN_PARENT_CODE, ai as PARENT_CYCLE_CODE, s as MISSING_ENDPOINT_CODE, m as DUPLICATE_EDGE_ID_CODE, aK as parseWeightText, bI as overflowsToInfinity, P as PRECISION_CODE, bJ as parseDeclaredTemporal, br as declareCompanion, bK as parseDeclaredValue, bL as losesPrecision, bM as parseTimeText, a3 as BAD_VALUE_CODE, bN as splitListText, g as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, bO as timeTextCompanion, bP as parseDecimalText, c as capabilities, L as LOSS, aE as sanitizeIds, p as pairFolding, e as explicitWeights, r as resolveExportOptions, a as checkCapabilities, bQ as formatTimeValue, aa as formatF32, ab as formatF64, bR as mapDeclaredType, bS as joinListText, bT as formatTemporal, aG as formatInteger, b as plural, $ as agree, bx as isCanonicalIntegerText, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, aZ as BAD_OPTIONS_CODE, B as BAD_DEFAULT_CODE, U as UNKNOWN_ATTR_TYPE_CODE, v as ENCODING_CONFLICT_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, A as COLUMN_TYPE_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-CTUlibzr.js";
+import { bF as TIME_TEXT_ROLE, bG as TIME_TEXT_SUFFIX, al as resolveImportOptions, a8 as ImportReportBuilder, ao as reportSinkOptions, an as reportUnusedOptions, a4 as textChunks, E as EMPTY_INPUT_CODE, X as XML_SYNTAX_CODE, am as throwIfAborted, ar as IdCoercer, aq as DirectionResolver, f as STRAY_TEXT_CODE, N as NO_GRAPH_CODE, h as UNKNOWN_XML_ATTRIBUTE_CODE, l as MULTIPLE_GRAPHS_CODE, j as COUNT_MISMATCH_CODE, k as COUNT_HINT_CODE, o as DUPLICATE_ATTRIBUTE_CODE, aJ as isWeightField, bH as declareAttribute, a1 as declareResolved, t as MISSING_ID_CODE, n as DUPLICATE_NODE_CODE, q as UNKNOWN_PARENT_CODE, ai as PARENT_CYCLE_CODE, s as MISSING_ENDPOINT_CODE, m as DUPLICATE_EDGE_ID_CODE, aK as parseWeightText, bI as overflowsToInfinity, P as PRECISION_CODE, bJ as parseDeclaredTemporal, br as declareCompanion, bK as parseDeclaredValue, bL as losesPrecision, bM as parseTimeText, a3 as BAD_VALUE_CODE, bN as splitListText, g as UNKNOWN_ELEMENT_CODE, I as ID_MERGED_CODE, bO as timeTextCompanion, bP as parseDecimalText, c as capabilities, L as LOSS, aE as sanitizeIds, p as pairFolding, e as explicitWeights, r as resolveExportOptions, a as checkCapabilities, bQ as formatTimeValue, aa as formatF32, ab as formatF64, bR as mapDeclaredType, bS as joinListText, bT as formatTemporal, aG as formatInteger, b as plural, $ as agree, bx as isCanonicalIntegerText, M as MIXED_DIRECTION_CODE, D as DIRECTION_FORCED_CODE, d as DIRECTION_REFUSED_CODE, S as SINK_OPTION_CODE, O as OPTION_IGNORED_CODE, R as ROLE_TAKEN_CODE, C as COLUMN_RENAMED_CODE, aZ as BAD_OPTIONS_CODE, B as BAD_DEFAULT_CODE, U as UNKNOWN_ATTR_TYPE_CODE, v as ENCODING_CONFLICT_CODE, w as UNKNOWN_ENCODING_CODE, x as ENCODING_FALLBACK_CODE, y as INVALID_ENCODING_CODE, z as INVALID_UTF8_CODE, A as COLUMN_TYPE_CODE, F as ELEMENT_ISSUE, G as INPUT_ISSUE } from "./chunks/export-B-aVCwyG.js";
 import { GraphFormatError, INVALID_INDEX, MAX_COUNT } from "@graphty/graph-format";
-import { t as tokenizeXml, f as xmlDeclaredEncoding, g as XmlEmptyInputError, X as XmlSyntaxError, s as sniffXmlText, l as localName, j as isWhitespace, x as xmlIllegalTextNotes, a as escapeXmlText, e as escapeXmlAttribute } from "./chunks/escape-BRcyzD77.js";
+import { t as tokenizeXml, f as xmlDeclaredEncoding, g as XmlEmptyInputError, X as XmlSyntaxError, s as sniffXmlText, l as localName, j as isWhitespace, x as xmlIllegalTextNotes, a as escapeXmlText, e as escapeXmlAttribute } from "./chunks/escape-BJRLd3vJ.js";
 import { j as joinText, e as encodeChunks } from "./chunks/writer-DxjgHwSe.js";
 const GEXF_FORMAT = "gexf";
 const GEXF_NAMESPACES = {
@@ -3355,7 +3355,8 @@ function lifetimeAttrs(roles, row, plan) {
       return;
     }
     const text = timeText(column, roles.companions.get(column.meta.name) ?? null, row, timeFormat);
-    out += ` ${open ? `${name}open` : name}="${escapeXmlAttribute(text)}"`;
+    const attribute = open ? `${name}open` : name;
+    out += ` ${attribute}="${escapeXmlAttribute(text)}"`;
   };
   if (roles.timestamp?.isSet(row)) {
     if (version === "1.3" && plan.timeRepresentation === "timestamp") {
@@ -3370,7 +3371,8 @@ function lifetimeAttrs(roles, row, plan) {
   }
   if (version === "1.3" && roles.timestamps?.isSet(row)) {
     const items = listItems(roles.timestamps, row).map((t) => formatTimeValue(t, timeFormat));
-    out += ` timestamps="${escapeXmlAttribute(`<[${items.join(", ")}]>`)}"`;
+    const stamps = `<[${items.join(", ")}]>`;
+    out += ` timestamps="${escapeXmlAttribute(stamps)}"`;
   }
   return out;
 }