@graphty/graph-io 0.3.48 → 0.3.49

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

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

package/dist/chunks/{generic-CP6YD34u.js → generic-ymWCETAJ.js}

@@ -1,6 +1,293 @@
-import { an as keptForStyles } from "./report-CgdsL9Hb.js";
-import { S as StyleBudget } from "./emit-CD8xnY8s.js";
-import { C as STYLE_PROPERTIES, I as interpolate, J as within, u as StyleNotes, t as toolDefaults, q as isStyleValue, K as describeFeature, a as STYLE_ISSUE, L as refSource, N as isShortPredicate, O as resolveRules, P as matches, Q as evalContinuous, R as numberOf, d as canonicalFor, s as styleFingerprint, v as parseStyleBlock, x as blockStyles, z as featuresOf, p as plainCell, S as STYLE_BLOCK_NAME, U as styleLengthUnit, g as canonColor, y as colorOpacity, l as canonEnum, o as canonText, m as canonBoolean, j as canonOpacity, h as canonNumber, H as DOT_POINTS_PER_INCH } from "./block-Cu22ewuS.js";
+import { an as keptForStyles } from "./report-CwMfYa9J.js";
+import { S as StyleBudget } from "./emit-BwHQkZle.js";
+import { w as STYLE_PROPERTIES, N as interpolate, O as within, h as StyleNotes, y as toolDefaults, l as isStyleValue, P as describeFeature, b as STYLE_ISSUE, Q as refSource, R as isShortPredicate, U as resolveRules, V as matches, W as evalContinuous, X as numberOf, C as canonicalFor, o as styleFingerprint, t as featuresOf, m as parseStyleBlock, q as blockStyles, Y as styleLengthUnit, p as plainCell, S as STYLE_BLOCK_NAME, d as canonColor, e as colorOpacity, a as canonEnum, f as canonText, k as canonBoolean, j as canonOpacity, g as canonSigned, c as canonNumber, H as DOT_POINTS_PER_INCH } from "./block-iptrlMBb.js";
+const CYTOSCAPE_ANNOTATIONS_COLUMN = "__Annotations";
+const TYPE_PREFIX = "org.cytoscape.view.presentation.annotations.";
+const SHAPES = /* @__PURE__ */ new Map([
+  ["rectangle", "rectangle"],
+  ["roundedrectangle", "round-rectangle"],
+  ["rounded_rectangle", "round-rectangle"],
+  ["ellipse", "ellipse"],
+  ["triangle", "triangle"],
+  ["diamond", "diamond"],
+  ["pentagon", "pentagon"],
+  ["hexagon", "hexagon"],
+  ["octagon", "octagon"],
+  ["parallelogram", "parallelogram"],
+  ["star5", "star"],
+  ["star6", "star"],
+  ["v", "vee"]
+]);
+const ARROW_ORDER = [
+  "circle",
+  "triangle",
+  "vee",
+  "diamond",
+  "triangle-open",
+  "none",
+  "other:x",
+  "triangle",
+  "tee"
+];
+const ARROW_LENGTHS = [10, 17, 17, 17, 17, 0, 10, 5, 0];
+const ARROW_WIDTH = 10;
+const ARROW_NAMES = /* @__PURE__ */ new Map([
+  ["circle", "circle"],
+  ["closed arrow", "triangle"],
+  ["concave arrow", "vee"],
+  ["diamond", "diamond"],
+  ["open arrow", "triangle-open"],
+  ["no arrow", "none"],
+  ["pipe", "tee"],
+  ["triangle", "triangle"],
+  ["t", "tee"],
+  ["t-shape", "tee"],
+  ["triangular head", "triangle"],
+  ["x", "other:x"],
+  ["x arrow", "other:x"]
+]);
+function readAnnotations(snapshot) {
+  const { graph } = snapshot;
+  const cell = graph.has(CYTOSCAPE_ANNOTATIONS_COLUMN) ? graph.value(CYTOSCAPE_ANNOTATIONS_COLUMN, 0) : null;
+  const entries = cellStrings(cell);
+  const fields = entries.map(parseEntry);
+  const byId = new Map(fields.map((f, i) => [f.get("uuid") ?? String(i), f]));
+  const annotations = [];
+  const skipped = /* @__PURE__ */ new Set();
+  fields.forEach((f, i) => {
+    const read = readOne(f, String(i), byId);
+    if (read === null) {
+      skipped.add((f.get("type") ?? "").replace(TYPE_PREFIX, ""));
+    } else {
+      annotations.push(...read);
+    }
+  });
+  return { annotations, skipped: [...skipped] };
+}
+function readImageAnnotations(snapshot) {
+  const { graph } = snapshot;
+  const cell = graph.has(CYTOSCAPE_ANNOTATIONS_COLUMN) ? graph.value(CYTOSCAPE_ANNOTATIONS_COLUMN, 0) : null;
+  return cellStrings(cell).flatMap((entry, i) => {
+    const f = parseEntry(entry);
+    const url = f.get("URL") ?? "";
+    if ((f.get("type") ?? "").replace(TYPE_PREFIX, "") !== "ImageAnnotation" || url === "") {
+      return [];
+    }
+    const zoom = positive(f.get("zoom")) ?? 1;
+    const x = num(f.get("x")) ?? 0;
+    const y = num(f.get("y")) ?? 0;
+    const width = (positive(f.get("width")) ?? 0) / zoom;
+    const height = (positive(f.get("height")) ?? 0) / zoom;
+    const border = javaColor(f.get("edgeColor")) ?? { color: "#000000", alpha: 1 };
+    const opacity = num(f.get("opacity"));
+    return [
+      {
+        id: f.get("uuid") ?? String(i),
+        layer: f.get("canvas") === "background" ? "background" : "foreground",
+        z: num(f.get("z")) ?? 0,
+        kind: "image",
+        rotation: num(f.get("rotation")) ?? 0,
+        center: { x: x + width / 2, y: -(y + height / 2) },
+        width,
+        height,
+        url,
+        opacity: opacity === null ? 1 : Math.min(1, Math.max(0, opacity)),
+        borderColor: border.color,
+        borderOpacity: border.alpha * percent(f.get("edgeOpacity")),
+        borderWidth: (num(f.get("edgeThickness")) ?? 0) / zoom
+      }
+    ];
+  });
+}
+function cellStrings(cell) {
+  if (typeof cell === "string") {
+    return cell.split(/[\r\n]+/).filter((s) => s !== "");
+  }
+  if (cell !== null && typeof cell === "object" && Symbol.iterator in cell) {
+    return Array.from(cell).filter((s) => typeof s === "string" && s !== "");
+  }
+  return [];
+}
+function parseEntry(entry) {
+  const out = /* @__PURE__ */ new Map();
+  for (const part of entry.split("|")) {
+    const eq = part.indexOf("=");
+    if (eq > 0) {
+      out.set(part.slice(0, eq), part.slice(eq + 1));
+    }
+  }
+  return out;
+}
+function readOne(f, index, byId) {
+  const type = (f.get("type") ?? "").replace(TYPE_PREFIX, "");
+  const zoom = positive(f.get("zoom")) ?? 1;
+  const base = {
+    id: f.get("uuid") ?? index,
+    layer: f.get("canvas") === "background" ? "background" : "foreground",
+    z: num(f.get("z")) ?? 0
+  };
+  switch (type) {
+    case "ShapeAnnotation":
+      return [shapeOf(f, base, zoom)];
+    case "TextAnnotation":
+      return [textOf(f, base, zoom, { x: num(f.get("x")) ?? 0, y: -(num(f.get("y")) ?? 0) }, "top-left")];
+    case "BoundedTextAnnotation": {
+      const shape = shapeOf(f, base, zoom);
+      return [shape, textOf(f, { ...base, id: `${base.id}:text` }, zoom, shape.center, "center")];
+    }
+    case "ArrowAnnotation":
+      return arrowOf(f, base, zoom, byId);
+    default:
+      return null;
+  }
+}
+function shapeOf(f, base, zoom) {
+  const x = num(f.get("x")) ?? 0;
+  const y = num(f.get("y")) ?? 0;
+  const width = (positive(f.get("width")) ?? 0) / zoom;
+  const height = (positive(f.get("height")) ?? 0) / zoom;
+  const fill = javaColor(f.get("fillColor"));
+  const border = javaColor(f.get("edgeColor")) ?? { color: "#000000", alpha: 1 };
+  return {
+    ...base,
+    kind: "shape",
+    rotation: num(f.get("rotation")) ?? 0,
+    center: { x: x + width / 2, y: -(y + height / 2) },
+    width,
+    height,
+    shape: SHAPES.get((f.get("shapeType") ?? "rectangle").toLowerCase()) ?? "rectangle",
+    fill: fill?.color ?? null,
+    fillOpacity: fill === null ? 0 : fill.alpha * percent(f.get("fillOpacity")),
+    borderColor: border.color,
+    borderOpacity: border.alpha * percent(f.get("edgeOpacity")),
+    borderWidth: (num(f.get("edgeThickness")) ?? 1) / zoom
+  };
+}
+function textOf(f, base, zoom, at, anchor) {
+  const style = num(f.get("fontStyle")) ?? 0;
+  const color = javaColor(f.get("color")) ?? { color: "#000000", alpha: 1 };
+  return {
+    ...base,
+    kind: "text",
+    rotation: num(f.get("rotation")) ?? 0,
+    text: f.get("text") ?? "",
+    at,
+    anchor,
+    fontSize: (positive(f.get("fontSize")) ?? 12) / zoom,
+    fontFamily: f.get("fontFamily") ?? "sans-serif",
+    bold: (style & 1) !== 0,
+    italic: (style & 2) !== 0,
+    color: color.color,
+    opacity: color.alpha
+  };
+}
+function arrowOf(f, base, zoom, byId) {
+  const sourceBox = boxOf(byId.get(f.get("sourceAnnotation") ?? ""), zoom);
+  const targetBox = boxOf(byId.get(f.get("targetAnnotation") ?? ""), zoom);
+  const toPoint = point(f.get("targetPoint")) ?? point(f.get("targetNode"));
+  const corner = { x: num(f.get("x")) ?? 0, y: num(f.get("y")) ?? 0 };
+  const sourceCenter = sourceBox === null ? corner : centerOfBox(sourceBox);
+  const aim = toPoint ?? (targetBox === null ? null : centerOfBox(targetBox));
+  if (aim === null) {
+    return null;
+  }
+  const from = sourceBox !== null && sourceBox.width > 0 && sourceBox.height > 0 ? facing(sourceBox, aim) : { x: aim.x > corner.x ? corner.x : sourceCenter.x, y: aim.y > corner.y ? corner.y : sourceCenter.y };
+  const to = toPoint ?? facing(targetBox ?? { x: aim.x, y: aim.y, width: 0, height: 0 }, sourceCenter);
+  const color = javaColor(f.get("lineColor")) ?? { color: "#000000", alpha: 1 };
+  const sourceColor = javaColor(f.get("sourceColor"))?.color ?? color.color;
+  const targetColor = javaColor(f.get("targetColor"))?.color ?? color.color;
+  return [
+    {
+      ...base,
+      kind: "arrow",
+      from: { x: from.x, y: -from.y },
+      to: { x: to.x, y: -to.y },
+      color: color.color,
+      opacity: color.alpha * percent(f.get("lineOpacity")),
+      width: Math.max(1, (positive(f.get("lineThickness")) ?? 1) / zoom / 2),
+      sourceArrow: arrowShape(f.get("sourceType")),
+      targetArrow: arrowShape(f.get("targetType")),
+      sourceSize: positive(f.get("sourceSize")) ?? 1,
+      targetSize: positive(f.get("targetSize")) ?? 1,
+      sourceColor,
+      targetColor,
+      ...heads("source", f.get("sourceType"), positive(f.get("sourceSize")) ?? 1),
+      ...heads("target", f.get("targetType"), positive(f.get("targetSize")) ?? 1)
+    }
+  ];
+}
+function heads(end, type, size) {
+  const shape = arrowShape(type);
+  if (shape === "none") {
+    return {};
+  }
+  const k = num(type) ?? ARROW_ORDER.indexOf(shape);
+  const length = ARROW_LENGTHS[k] ?? ARROW_LENGTHS[1];
+  return { [`${end}HeadLength`]: length * size, [`${end}HeadWidth`]: ARROW_WIDTH * size };
+}
+function boxOf(f, zoom) {
+  if (f === void 0) {
+    return null;
+  }
+  const x = num(f.get("x"));
+  const y = num(f.get("y"));
+  if (x === null || y === null) {
+    return null;
+  }
+  return { x, y, width: (positive(f.get("width")) ?? 0) / zoom, height: (positive(f.get("height")) ?? 0) / zoom };
+}
+function centerOfBox(b) {
+  return { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+}
+function facing(b, p) {
+  const c = centerOfBox(b);
+  const dx = p.x - c.x;
+  const dy = p.y - c.y;
+  if (Math.abs(dx) * b.height >= Math.abs(dy) * b.width) {
+    return { x: c.x + Math.sign(dx) * (b.width / 2), y: c.y };
+  }
+  return { x: c.x, y: c.y + Math.sign(dy) * (b.height / 2) };
+}
+function arrowShape(raw) {
+  if (raw === void 0) {
+    return "none";
+  }
+  const n = num(raw);
+  if (n !== null) {
+    return ARROW_ORDER[n] ?? "triangle";
+  }
+  return ARROW_NAMES.get(raw.trim().toLowerCase()) ?? "triangle";
+}
+function point(raw) {
+  const [x, y] = (raw ?? "").split(",").map((s) => num(s));
+  return x === null || x === void 0 || y === null || y === void 0 ? null : { x, y };
+}
+function javaColor(raw) {
+  const n = num(raw);
+  if (n === null || !Number.isInteger(n)) {
+    return null;
+  }
+  const argb = n >>> 0;
+  return {
+    color: `#${(argb & 16777215).toString(16).padStart(6, "0")}`,
+    alpha: (argb >>> 24) / 255
+  };
+}
+function percent(raw) {
+  const n = num(raw);
+  return n === null ? 1 : Math.min(1, Math.max(0, n / 100));
+}
+function num(raw) {
+  if (raw === void 0 || raw.trim() === "") {
+    return null;
+  }
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+function positive(raw) {
+  const n = num(raw);
+  return n !== null && n > 0 ? n : null;
+}
 function valueKey(v) {
   return v === null || v === void 0 ? "\0null" : `${typeof v}:${String(v)}`;
 }
@@ -355,7 +642,19 @@ function rampOf(fam, values, ys0, tolerant, spend) {
 }
 const MAX_STYLE_RULES = 16;
 const MAX_FEATURES = 64;
-const LENGTHS = /* @__PURE__ */ new Set(["width", "height", "borderWidth", "labelSize"]);
+const LENGTHS = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "borderWidth",
+  "labelSize",
+  "labelWrapWidth",
+  "labelPaddingX",
+  "labelPaddingY",
+  "labelOffsetX",
+  "labelOffsetY",
+  "fanSpacing",
+  "nodeGap"
+]);
 function planStyles(values, features, options = {}) {
   const notes = options.notes ?? new StyleNotes();
   const budget = options.budget ?? new StyleBudget();
@@ -386,7 +685,7 @@ function planStyles(values, features, options = {}) {
         out,
         allFeatures[target],
         new Set(options.rawColumns?.[target] ?? []),
-        toolSet,
+        { set: toolSet, derived: defaults?.derived ?? [] },
         options.signal
       )
     );
@@ -592,8 +891,9 @@ function passCandidate(plan, fam, truth, infos) {
   const raw = Array.from(cols.values()).some((f) => f.raw);
   return { type: "passdata", cols, raw, cost: raw ? 240 : 50 };
 }
-function planTarget(plan, out, features, rawNames, toolSet, signal) {
+function planTarget(plan, out, features, rawNames, tool, signal) {
   const { target, n } = plan;
+  const toolSet = tool.set;
   for (const [k, v] of out?.columns ?? []) {
     plan.columns.set(k, v);
   }
@@ -608,6 +908,7 @@ function planTarget(plan, out, features, rawNames, toolSet, signal) {
       set: toolSet
     }
   ];
+  toolRule.push(...derivedRules(plan, tool.derived, features, out?.rules ?? [], truth));
   const declared = prepareDeclared(plan, out?.rules ?? [], features);
   const declaredProps = new Set(declared.flatMap(writes));
   const { defaults, rest } = splitDefaults(n, truth, declaredProps);
@@ -694,6 +995,31 @@ function planTarget(plan, out, features, rawNames, toolSet, signal) {
   }
   return drafts.map(finish);
 }
+function derivedRules(plan, derived, features, given, truth) {
+  const stated = /* @__PURE__ */ new Set([...given.filter((r) => r.origin === "tool").flatMap(writes), ...truth.keys()]);
+  const out = [];
+  for (const d of derived) {
+    if (plan.target !== "node" || d.kind !== "labelFromColumn" || stated.has("label")) {
+      continue;
+    }
+    const { column } = d;
+    const feature = features.find((f) => "data" in f.ref && f.ref.data === column);
+    if (feature?.values.some((v) => v !== null && v !== "") !== true) {
+      continue;
+    }
+    stated.add("label");
+    out.push({
+      id: uniqueId(plan, "node.tool.label"),
+      target: "node",
+      role: "passthrough",
+      origin: "tool",
+      where: { has: { data: column } },
+      map: { label: { kind: "passthrough", by: { data: column } } },
+      facts: { reason: "NODE_NAME" }
+    });
+  }
+  return out;
+}
 function splitDefaults(n, truth, declaredProps) {
   const defaults = {};
   const rest = [];
@@ -903,10 +1229,11 @@ function enforceCap(plan, drafts, truth, src) {
     if (cands.length === 0) {
       break;
     }
+    const everyone = (r) => r.origin === "tool" && "all" in r.where ? 1 : 0;
     cands.sort((a, b) => {
       const pa = a.role === "passthrough" ? 1 : 0;
       const pb = b.role === "passthrough" ? 1 : 0;
-      return pa - pb || (FOLD_ORDER[a.origin] ?? 1) - (FOLD_ORDER[b.origin] ?? 1) || ruleSize(b) - ruleSize(a) || drafts.indexOf(b) - drafts.indexOf(a);
+      return pa - pb || (FOLD_ORDER[a.origin] ?? 1) - (FOLD_ORDER[b.origin] ?? 1) || everyone(a) - everyone(b) || ruleSize(b) - ruleSize(a) || drafts.indexOf(b) - drafts.indexOf(a);
     });
     const victim = cands[0];
     const before = drafts.map(finish);
@@ -980,34 +1307,32 @@ function replay(plan, drafts, truth, toolSet, tolerated, src) {
   };
 }
 const TARGETS = ["node", "edge"];
-const ENUM_KINDS = /* @__PURE__ */ new Set(["shape", "borderStyle", "lineStyle", "arrow", "weight", "position"]);
+const ENUM_KINDS = /* @__PURE__ */ new Set([
+  "shape",
+  "borderStyle",
+  "lineStyle",
+  "arrow",
+  "arrowSide",
+  "weight",
+  "position",
+  "labelFit",
+  "borderPosition"
+]);
 function extractStyles(importer, snapshot, report, options = {}) {
   const signal = options.signal ?? void 0;
   const notes = new StyleNotes();
   const budget = options.budget ?? new StyleBudget();
+  const pictures = readImageAnnotations(snapshot).length > 0;
+  for (const kind of readAnnotations(snapshot).skipped) {
+    if (!(pictures && kind === "ImageAnnotation")) {
+      notes.add(STYLE_ISSUE.ANNOTATION_SKIPPED, "graph", "annotations", { sample: kind });
+    }
+  }
   const canonical = readStyleValues(importer, snapshot, report, { notes, budget, signal });
   const fingerprint = styleFingerprint(snapshot);
-  const blockText = canonical?.block ?? graphValue(snapshot, STYLE_BLOCK_NAME);
-  if (blockText !== void 0) {
-    const parsed = parseStyleBlock(blockText, fingerprint);
-    if (parsed.ok) {
-      const truth = canonical === null ? {} : { node: canonical.node.values, edge: canonical.edge.values };
-      const fromBlock = blockStyles(
-        parsed.block,
-        snapshot,
-        importer.format,
-        truth,
-        canonical?.notes ?? [],
-        canonical?.tool ?? null,
-        canonical?.opacityInColor === true
-      );
-      if (fromBlock !== null) {
-        return fromBlock;
-      }
-      notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: "INVALID" });
-    } else {
-      notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: parsed.reason });
-    }
+  const fromBlock = stylesFromBlock(importer, snapshot, canonical, notes, fingerprint);
+  if (fromBlock !== null) {
+    return fromBlock;
   }
   if (canonical === null) {
     const list = notes.list();
@@ -1043,6 +1368,33 @@ function extractStyles(importer, snapshot, report, options = {}) {
   }
   return { ...planned, styles: { ...planned.styles, notes: [...canonical.notes, ...planned.styles.notes] } };
 }
+function stylesFromBlock(importer, snapshot, canonical, notes, fingerprint) {
+  const blockText = canonical?.block ?? graphValue(snapshot, STYLE_BLOCK_NAME);
+  if (blockText === void 0) {
+    return null;
+  }
+  const parsed = parseStyleBlock(blockText, fingerprint);
+  if (!parsed.ok) {
+    notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: parsed.reason });
+    return null;
+  }
+  const truth = canonical === null ? {} : { node: canonical.node.values, edge: canonical.edge.values };
+  const fromBlock = blockStyles(
+    parsed.block,
+    snapshot,
+    importer.format,
+    truth,
+    canonical?.notes ?? [],
+    canonical?.tool ?? null,
+    canonical?.opacityInColor === true
+  );
+  if (fromBlock === null) {
+    notes.add(STYLE_ISSUE.BLOCK_IGNORED, null, null, { sample: "INVALID" });
+    return null;
+  }
+  const skipped = notes.list();
+  return skipped.length === 0 ? fromBlock : { ...fromBlock, styles: { ...fromBlock.styles, notes: [...fromBlock.styles.notes, ...skipped] } };
+}
 function readStyleValues(importer, snapshot, report, context) {
   const { notes, budget, signal } = context;
   signal?.throwIfAborted();
@@ -1257,6 +1609,8 @@ function canonValue(kind, property, raw, dialect, site) {
         site,
         dialect === "graphviz" && (property === "width" || property === "height") ? DOT_POINTS_PER_INCH : 1
       );
+    case "signed":
+      return canonSigned(raw, site);
     case "opacity":
       return canonOpacity(raw, dialect, site);
     case "boolean":
@@ -1341,7 +1695,9 @@ function channelsColor(v, dtype) {
 }
 export {
   MAX_STYLE_RULES as M,
+  readImageAnnotations as a,
   extractStyles as e,
-  planStyles as p
+  planStyles as p,
+  readAnnotations as r
 };
-//# sourceMappingURL=generic-CP6YD34u.js.map
+//# sourceMappingURL=generic-ymWCETAJ.js.map