flexdesk 0.5.0 → 0.6.1

package/css/tokens.css

@@ -193,4 +193,76 @@
        to its OWN 0.4 values when a token is unset (normal: 6px 8px and an
        inherited line height; compact: 2px 6px and 1.35), and a default here
        would replace both densities' values with one. */
+
+    /* ── Flow editors (@flexdesk/flow) — TONES, not colours ───────────
+       A step-type category names a TONE (`violet`, `teal`, `amber`, `grey`,
+       `blue`, `indigo`) and these map the tone to its colours, so a consumer
+       restyles every editor's categories here and nowhere else. Each tone is:
+
+           -bg / -fg       a step's icon chip, a picker row's chip, a chip's fill
+           -line           a reference chip's border
+           -icon-bg        a lane card's icon zone
+           -text-bg        a lane card's text zone
+           -dot            a step tab's dot
+
+       New in the flow work and read by nothing older, so defining them
+       changes no existing screen. The values are the approved mocks'. */
+    --twm-flow-violet-bg:      rgba(167, 139, 250, 0.16);
+    --twm-flow-violet-fg:      #c6b4fb;
+    --twm-flow-violet-line:    rgba(167, 139, 250, 0.45);
+    --twm-flow-violet-icon-bg: #351a40;
+    --twm-flow-violet-text-bg: #261e30;
+    --twm-flow-violet-dot:     #a785e8;
+
+    --twm-flow-teal-bg:        rgba(45, 180, 165, 0.17);
+    --twm-flow-teal-fg:        #72d8c8;
+    --twm-flow-teal-line:      rgba(45, 180, 165, 0.45);
+    --twm-flow-teal-icon-bg:   #1a403a;
+    --twm-flow-teal-text-bg:   #1a2b2a;
+    --twm-flow-teal-dot:       #3fb8a6;
+
+    --twm-flow-amber-bg:       rgba(222, 150, 70, 0.17);
+    --twm-flow-amber-fg:       #ecb27a;
+    --twm-flow-amber-line:     rgba(215, 163, 74, 0.45);
+    --twm-flow-amber-icon-bg:  #3a3018;
+    --twm-flow-amber-text-bg:  #2b2518;
+    --twm-flow-amber-dot:      #d79a52;
+
+    --twm-flow-grey-bg:        rgba(255, 255, 255, 0.08);
+    --twm-flow-grey-fg:        #c4c4c4;
+    --twm-flow-grey-line:      rgba(255, 255, 255, 0.28);
+    --twm-flow-grey-icon-bg:   #333334;
+    --twm-flow-grey-text-bg:   #262627;
+    --twm-flow-grey-dot:       #9a9a9a;
+
+    --twm-flow-blue-bg:        rgba(22, 131, 196, 0.22);
+    --twm-flow-blue-fg:        #a8d4f2;
+    --twm-flow-blue-line:      rgba(80, 160, 220, 0.45);
+    --twm-flow-blue-icon-bg:   #173447;
+    --twm-flow-blue-text-bg:   #1a2630;
+    --twm-flow-blue-dot:       #4aa3dc;
+
+    --twm-flow-indigo-bg:      rgba(127, 140, 240, 0.17);
+    --twm-flow-indigo-fg:      #aab6fb;
+    --twm-flow-indigo-line:    rgba(127, 140, 240, 0.45);
+    --twm-flow-indigo-icon-bg: #252850;
+    --twm-flow-indigo-text-bg: #1e1f30;
+    --twm-flow-indigo-dot:     #7f8cf0;
+
+    /* The kit's own surfaces and signal colours (the mocks' values). The
+       focus ring is the canonical bright accent, so a consumer that restyles
+       the accent restyles it. */
+    --twm-flow-control-bg:     #2b2b2c;
+    --twm-flow-control-border: #454545;
+    --twm-flow-muted:          #a6a6a6;
+    --twm-flow-focus:          var(--accent-bright);
+    --twm-flow-error:          #f48771;
+    --twm-flow-error-bg:       rgba(244, 135, 113, 0.09);
+    --twm-flow-error-line:     rgba(244, 135, 113, 0.35);
+    --twm-flow-error-text:     #f2cfc6;
+    --twm-flow-warning:        #e2b366;
+    --twm-flow-warning-bg:     rgba(226, 179, 102, 0.09);
+    --twm-flow-warning-line:   rgba(226, 179, 102, 0.35);
+    --twm-flow-warning-text:   #f0dcb8;
+    --twm-flow-ok:             #89d185;
 }

package/dist/canvas.js

@@ -0,0 +1,390 @@
+import {
+  CanvasAdapter,
+  OBSTACLE_ROUTING_NODE_LIMIT,
+  arrange,
+  cardinality,
+  crowsFoot,
+  footAnchor,
+  returnEdge,
+  routeEdge,
+  selfLoop
+} from "./chunk-SN4LSOAR.js";
+import "./chunk-JYWURG5T.js";
+
+// src/canvas/graph/node_platform.js
+var NodePlatform = class {
+  /**
+   * @param {object} [options]
+   * @param {(node: object) => object[]} [options.collapsedPorts]  the ports a COLLAPSED node
+   *        still offers; by default none
+   */
+  constructor({ collapsedPorts = null } = {}) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.collapsedPorts = typeof collapsedPorts === "function" ? collapsedPorts : null;
+  }
+  on(event, handler) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(handler);
+    return () => this.listeners.get(event).delete(handler);
+  }
+  emit(event, payload) {
+    for (const handler of this.listeners.get(event) || []) handler(payload);
+  }
+  /**
+   * Replace the whole graph. Hydration, not an edit — see `HistoryService`.
+   *
+   * Each node is `{id, position?, size?, collapsed?, ports?, …}`: the position
+   * is copied (a missing one is (0, 0)), `size` is `{w, h}` or null, `ports`
+   * an array (none when absent), and every other key is kept as it is.
+   */
+  hydrate(nodes) {
+    this.nodes.clear();
+    for (const raw of Array.isArray(nodes) ? nodes : []) {
+      if (!raw || raw.id === void 0 || raw.id === null) continue;
+      const id = raw.id;
+      this.nodes.set(id, {
+        ...raw,
+        id,
+        // `size` and `collapsed` are in the snapshot, not derived: at
+        // hundreds of nodes a node showing forty ports is unreadable, and
+        // a collapsed node's ports fold away.
+        position: raw.position ? { x: raw.position.x, y: raw.position.y } : { x: 0, y: 0 },
+        size: raw.size ? { w: raw.size.w, h: raw.size.h } : null,
+        collapsed: Boolean(raw.collapsed),
+        ports: Array.isArray(raw.ports) ? raw.ports : []
+      });
+    }
+    this.emit("hydrated", { count: this.nodes.size });
+  }
+  get(id) {
+    return this.nodes.get(id);
+  }
+  all() {
+    return [...this.nodes.values()];
+  }
+  port(nodeId, portId) {
+    return this.nodes.get(nodeId)?.ports.find((p) => p.id === portId) || null;
+  }
+  setPosition(id, position, { silent = false } = {}) {
+    const node = this.nodes.get(id);
+    if (!node) return null;
+    const before = { ...node.position };
+    node.position = { ...position };
+    if (!silent) this.emit("moved", { id, before, after: { ...position } });
+    return before;
+  }
+  setCollapsed(id, collapsed, { silent = false } = {}) {
+    const node = this.nodes.get(id);
+    if (!node) return null;
+    const before = node.collapsed;
+    node.collapsed = Boolean(collapsed);
+    if (!silent) this.emit("collapsed", { id, before, after: node.collapsed });
+    return before;
+  }
+  /**
+   * Ports that are visible right now.
+   *
+   * A collapsed node offers only what `collapsedPorts` says it keeps (by
+   * default nothing). Answering from one place is what stops a renderer and
+   * the legality guard disagreeing about what can be dropped on.
+   */
+  visiblePorts(id) {
+    const node = this.nodes.get(id);
+    if (!node) return [];
+    if (node.collapsed) return this.collapsedPorts ? this.collapsedPorts(node) : [];
+    return node.ports;
+  }
+};
+
+// src/canvas/graph/connector_router.js
+var CONNECTOR_STRINGS = Object.freeze({
+  nodeGone: "That node is no longer on the canvas.",
+  portGone: "That port is no longer on the canvas.",
+  portDisabled: "That port cannot be connected.",
+  selfReference: "A node cannot connect to itself on this canvas.",
+  portFull: (max) => max === 1 ? "That port already carries its one connection." : `That port already carries its ${max} connections.`
+});
+var say = (strings, key, ...args) => {
+  const s = strings[key];
+  return typeof s === "function" ? s(...args) : String(s);
+};
+var defaultEndsOf = (edge) => ({ from: edge?.fromPort ?? null, to: edge?.toPort ?? null });
+function capacityOf(port) {
+  if (Number.isFinite(port?.maxConnections)) return port.maxConnections;
+  if (port?.allowMultiple === false) return 1;
+  return Infinity;
+}
+var ConnectorRouter = class {
+  /**
+   * @param {object} o
+   * @param {object} o.platform                        a `NodePlatform`
+   * @param {boolean} [o.selfReference]                may a node connect to itself
+   * @param {(ctx: object) => object|null|undefined} [o.policy]  the embedder's rules, asked last
+   * @param {(edge: object) => {from, to}} [o.endsOf]  the port ids an edge uses at each end
+   * @param {('source'|'target')[]} [o.disabledEnds]   which ends a disabled port refuses
+   * @param {object} [o.strings]                       the generic refusals' words
+   */
+  constructor({
+    platform,
+    selfReference = false,
+    policy = null,
+    endsOf = null,
+    disabledEnds = ["source", "target"],
+    strings = null
+  } = {}) {
+    this.platform = platform;
+    this.selfReference = selfReference;
+    this.policy = typeof policy === "function" ? policy : null;
+    this.endsOf = typeof endsOf === "function" ? endsOf : defaultEndsOf;
+    this.disabledEnds = new Set(disabledEnds);
+    this.strings = Object.freeze({ ...CONNECTOR_STRINGS, ...strings || {} });
+    this.edges = /* @__PURE__ */ new Map();
+  }
+  hydrate(edges) {
+    this.edges.clear();
+    for (const edge of edges) this.edges.set(edge.id, edge);
+  }
+  /** Every edge already touching this node, in either direction. */
+  edgesFor(nodeId) {
+    return [...this.edges.values()].filter((e) => e.from === nodeId || e.to === nodeId);
+  }
+  /** How many edges (applied and `pending`) already use this port at this node. */
+  connectionsAt(nodeId, portId, { pendingEdges = [] } = {}) {
+    let n = 0;
+    for (const edge of [...this.edges.values(), ...pendingEdges]) {
+      const ends = this.endsOf(edge) || {};
+      if (edge.from === nodeId && ends.from === portId) n += 1;
+      if (edge.to === nodeId && ends.to === portId) n += 1;
+    }
+    return n;
+  }
+  /**
+   * Can this drop become an edge?
+   *
+   * `source` and `target` are `{nodeId, portId}`. The answer is a verdict the
+   * caller can render directly — the reason strings ARE the notice text, so a
+   * policy should name the objects rather than describe the rule.
+   */
+  canConnect(source, target, { pendingEdges = [] } = {}) {
+    const S = this.strings;
+    const fromNode = this.platform.get(source.nodeId);
+    const toNode = this.platform.get(target.nodeId);
+    if (!fromNode || !toNode) return { ok: false, reason: say(S, "nodeGone") };
+    const fromPort = this.platform.port(source.nodeId, source.portId);
+    const toPort = this.platform.port(target.nodeId, target.portId);
+    if (!fromPort || !toPort) return { ok: false, reason: say(S, "portGone") };
+    if (fromPort.disabled && this.disabledEnds.has("source")) {
+      return { ok: false, reason: fromPort.disabledReason || say(S, "portDisabled") };
+    }
+    if (toPort.disabled && this.disabledEnds.has("target")) {
+      return { ok: false, reason: toPort.disabledReason || say(S, "portDisabled") };
+    }
+    const selfReference = fromNode.id === toNode.id;
+    if (selfReference && !this.selfReference) return { ok: false, reason: say(S, "selfReference") };
+    for (const [node, port] of [[fromNode, fromPort], [toNode, toPort]]) {
+      const max = capacityOf(port);
+      if (max !== Infinity && this.connectionsAt(node.id, port.id, { pendingEdges }) >= max) {
+        return { ok: false, reason: say(S, "portFull", max) };
+      }
+    }
+    if (this.policy) {
+      const verdict = this.policy({
+        source,
+        target,
+        fromNode,
+        toNode,
+        fromPort,
+        toPort,
+        pendingEdges,
+        selfReference,
+        edges: [...this.edges.values()],
+        router: this
+      });
+      if (verdict && typeof verdict === "object") return verdict;
+    }
+    return { ok: true, selfReference };
+  }
+  /**
+   * Record a STAGED edge. Nothing here talks to a server — the embedder turns
+   * a staged edge into whatever its own write is, and only that makes it real.
+   */
+  stage(edge) {
+    this.edges.set(edge.id, edge);
+    return edge;
+  }
+  unstage(id) {
+    const edge = this.edges.get(id);
+    this.edges.delete(id);
+    return edge || null;
+  }
+  /**
+   * Re-map edges when a node's port set is rebuilt.
+   *
+   * A node gains or loses a port constantly in a live diagram. Matches by port
+   * id, drops what cannot be mapped, and reports both — a silently dropped
+   * edge is a line that vanished from the drawing while what it stands for
+   * still exists. `endsOf` (else the router's own) names the ports an edge
+   * uses; an end that names none is not checked.
+   */
+  remapNodeConnections(nodeId, portIds, { endsOf = null } = {}) {
+    const ends = typeof endsOf === "function" ? endsOf : this.endsOf;
+    const available = new Set(portIds);
+    let remapped = 0;
+    const removed = [];
+    for (const [id, edge] of [...this.edges]) {
+      const at = ends(edge) || {};
+      const touches = [];
+      if (edge.from === nodeId && at.from !== null && at.from !== void 0) touches.push(at.from);
+      if (edge.to === nodeId && at.to !== null && at.to !== void 0) touches.push(at.to);
+      if (edge.from !== nodeId && edge.to !== nodeId) continue;
+      if (touches.every((portId) => available.has(portId))) {
+        remapped += 1;
+        continue;
+      }
+      this.edges.delete(id);
+      removed.push(edge);
+    }
+    return { remapped, removed };
+  }
+};
+
+// src/canvas/graph/history_service.js
+var DEFAULT_LIMIT = 200;
+var missing = (name) => new Error(
+  `HistoryService needs ${name}. Constructing it without the full dependency set is how an undo engine ends up silently doing nothing.`
+);
+var HistoryService = class {
+  /**
+   * @param {object} o
+   * @param {readonly string[]} o.actions  the only actions `record` accepts
+   * @param {(entry: object, direction: 'undo'|'redo') => void} o.apply  puts one entry back (or forward)
+   * @param {(state: {canUndo, canRedo, depth}) => void} [o.onState]
+   * @param {number} [o.limit]   entries kept; the oldest goes first
+   * @param {object} [o.requires]  `{name: value}` a subclass cannot work without; each is checked
+   * @param {(action: string) => string} [o.refusal]  the sentence a refused `record` throws
+   */
+  constructor({ actions, apply, onState, limit = DEFAULT_LIMIT, requires = null, refusal = null } = {}) {
+    for (const [name, value] of Object.entries(requires || {})) {
+      if (!value) throw missing(name);
+    }
+    if (!Array.isArray(actions) || !actions.length) throw missing("actions (its closed list)");
+    if (typeof apply !== "function") throw missing("apply(entry, direction)");
+    this.actions = Object.freeze([...actions]);
+    this._applyEntry = apply;
+    this.onState = onState;
+    this.limit = limit;
+    this.refusal = typeof refusal === "function" ? refusal : null;
+    this.undoStack = [];
+    this.redoStack = [];
+    this.recording = false;
+    this.batch = null;
+  }
+  /** The drawing has been loaded: the stacks start empty, and recording starts. */
+  hydrated() {
+    this.undoStack = [];
+    this.redoStack = [];
+    this.recording = true;
+    this._publish();
+  }
+  /** Group what is recorded until `endBatch` into one entry. */
+  startBatch(label) {
+    if (!this.recording) return;
+    this.batch = { action: "batch", label, entries: [] };
+  }
+  endBatch() {
+    if (!this.batch) return;
+    const batch = this.batch;
+    this.batch = null;
+    if (batch.entries.length) this._push(batch);
+  }
+  record(action, payload) {
+    if (!this.recording) return;
+    if (!this.actions.includes(action)) {
+      throw new Error(this.refusal ? this.refusal(action) : `${action} is not an undoable action here; the ones that are: ${this.actions.join(", ")}.`);
+    }
+    const entry = { action, ...payload };
+    if (this.batch) {
+      this.batch.entries.push(entry);
+      return;
+    }
+    this._push(entry);
+  }
+  undo() {
+    const entry = this.undoStack.pop();
+    if (!entry) return false;
+    this._apply(entry, "undo");
+    this.redoStack.push(entry);
+    this._publish();
+    return true;
+  }
+  redo() {
+    const entry = this.redoStack.pop();
+    if (!entry) return false;
+    this._apply(entry, "redo");
+    this.undoStack.push(entry);
+    this._publish();
+    return true;
+  }
+  reset() {
+    this.undoStack = [];
+    this.redoStack = [];
+    this._publish();
+  }
+  /**
+   * Take over the undo and redo stacks of a torn-down view whose state this
+   * one has just taken on, entry for entry and in the same order. Nothing new
+   * becomes undoable: every entry was recorded through a `record` whose action
+   * list is closed, so a stack can only carry what that list allows. Call it
+   * after `hydrated()`.
+   */
+  adopt({ undo = [], redo = [] } = {}) {
+    if (!this.recording) return;
+    this.undoStack = [...undo].slice(-this.limit);
+    this.redoStack = [...redo];
+    this._publish();
+  }
+  get canUndo() {
+    return this.undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.redoStack.length > 0;
+  }
+  _push(entry) {
+    this.undoStack.push(entry);
+    this.redoStack = [];
+    if (this.undoStack.length > this.limit) this.undoStack.shift();
+    this._publish();
+  }
+  _publish() {
+    this.onState?.({
+      canUndo: this.canUndo,
+      canRedo: this.canRedo,
+      depth: this.undoStack.length
+    });
+  }
+  _apply(entry, direction) {
+    if (entry.action === "batch") {
+      const entries = direction === "undo" ? [...entry.entries].reverse() : entry.entries;
+      for (const child of entries) this._apply(child, direction);
+      return;
+    }
+    this._applyEntry(entry, direction);
+  }
+};
+export {
+  CONNECTOR_STRINGS,
+  CanvasAdapter,
+  ConnectorRouter,
+  HistoryService,
+  NodePlatform,
+  OBSTACLE_ROUTING_NODE_LIMIT,
+  arrange,
+  cardinality,
+  crowsFoot,
+  footAnchor,
+  returnEdge,
+  routeEdge,
+  selfLoop
+};
+//# sourceMappingURL=canvas.js.map

package/dist/canvas.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/canvas/graph/node_platform.js", "../src/canvas/graph/connector_router.js", "../src/canvas/graph/history_service.js"],
+  "sourcesContent": ["/**\n * The canvas kernel \u2014 GRAPH LAYER: the node and port model (36 \u00A74.3).\n *\n * GENERIC. It holds nodes \u2014 each `{id, position, size, collapsed, ports}` plus\n * whatever else the embedder hangs on it \u2014 and answers which ports a node\n * offers. What a node IS (a table, a step, a form field) and which ports a\n * collapsed one keeps are the embedder's: a subclass builds the nodes and\n * calls `hydrate`, and the `collapsedPorts(node)` option decides what a folded\n * node shows.\n *\n * The genuinely reusable idea is the shape of a port descriptor \u2014 `{id, role,\n * direction, type, accepts, provides, allowMultiple, maxConnections, disabled,\n * disabledReason, meta}` \u2014 which is what lets one legality guard\n * (`ConnectorRouter`) serve a schema diagram, a flow graph and a form\n * designer. Nothing here requires any of those keys but `id`; the router reads\n * the ones it knows.\n *\n * DOM-free on purpose. It holds the graph; the embedder renders it. That split\n * is what makes the legality guard and the history service testable under\n * plain node.\n *\n * Events (`on(name, handler)` \u2192 an unsubscribe):\n *   `hydrated`   `{count}`                 after `hydrate`\n *   `moved`      `{id, before, after}`     after a `setPosition` that is not `silent`\n *   `collapsed`  `{id, before, after}`     after a `setCollapsed` that is not `silent`\n */\n\nexport class NodePlatform {\n    /**\n     * @param {object} [options]\n     * @param {(node: object) => object[]} [options.collapsedPorts]  the ports a COLLAPSED node\n     *        still offers; by default none\n     */\n    constructor({ collapsedPorts = null } = {}) {\n        /** @type {Map<string, object>} node id -> snapshot */\n        this.nodes = new Map();\n        this.listeners = new Map();\n        this.collapsedPorts = typeof collapsedPorts === 'function' ? collapsedPorts : null;\n    }\n\n    on(event, handler) {\n        if (!this.listeners.has(event)) this.listeners.set(event, new Set());\n        this.listeners.get(event).add(handler);\n        return () => this.listeners.get(event).delete(handler);\n    }\n\n    emit(event, payload) {\n        for (const handler of this.listeners.get(event) || []) handler(payload);\n    }\n\n    /**\n     * Replace the whole graph. Hydration, not an edit \u2014 see `HistoryService`.\n     *\n     * Each node is `{id, position?, size?, collapsed?, ports?, \u2026}`: the position\n     * is copied (a missing one is (0, 0)), `size` is `{w, h}` or null, `ports`\n     * an array (none when absent), and every other key is kept as it is.\n     */\n    hydrate(nodes) {\n        this.nodes.clear();\n        for (const raw of Array.isArray(nodes) ? nodes : []) {\n            if (!raw || raw.id === undefined || raw.id === null) continue;\n            const id = raw.id;\n            this.nodes.set(id, {\n                ...raw,\n                id,\n                // `size` and `collapsed` are in the snapshot, not derived: at\n                // hundreds of nodes a node showing forty ports is unreadable, and\n                // a collapsed node's ports fold away.\n                position: raw.position ? { x: raw.position.x, y: raw.position.y } : { x: 0, y: 0 },\n                size: raw.size ? { w: raw.size.w, h: raw.size.h } : null,\n                collapsed: Boolean(raw.collapsed),\n                ports: Array.isArray(raw.ports) ? raw.ports : [],\n            });\n        }\n        this.emit('hydrated', { count: this.nodes.size });\n    }\n\n    get(id) { return this.nodes.get(id); }\n    all() { return [...this.nodes.values()]; }\n\n    port(nodeId, portId) {\n        return this.nodes.get(nodeId)?.ports.find((p) => p.id === portId) || null;\n    }\n\n    setPosition(id, position, { silent = false } = {}) {\n        const node = this.nodes.get(id);\n        if (!node) return null;\n        const before = { ...node.position };\n        node.position = { ...position };\n        if (!silent) this.emit('moved', { id, before, after: { ...position } });\n        return before;\n    }\n\n    setCollapsed(id, collapsed, { silent = false } = {}) {\n        const node = this.nodes.get(id);\n        if (!node) return null;\n        const before = node.collapsed;\n        node.collapsed = Boolean(collapsed);\n        if (!silent) this.emit('collapsed', { id, before, after: node.collapsed });\n        return before;\n    }\n\n    /**\n     * Ports that are visible right now.\n     *\n     * A collapsed node offers only what `collapsedPorts` says it keeps (by\n     * default nothing). Answering from one place is what stops a renderer and\n     * the legality guard disagreeing about what can be dropped on.\n     */\n    visiblePorts(id) {\n        const node = this.nodes.get(id);\n        if (!node) return [];\n        if (node.collapsed) return this.collapsedPorts ? this.collapsedPorts(node) : [];\n        return node.ports;\n    }\n}\n", "/**\n * The canvas kernel \u2014 GRAPH LAYER: the edge model and its legality guard\n * (36 \u00A74.3).\n *\n * THE POINT OF THIS FILE IS THAT A DROP IS REFUSED \u2014 OR BETTER, NEGOTIATED \u2014\n * BEFORE ANY NETWORK CALL. A gesture that produces a round trip and then a\n * server error reads as a broken editor; the same gesture producing an\n * immediate reason reads as an editor that knows the rules.\n *\n * GENERIC. `canConnect` makes the refusals every graph shares, in this order:\n *\n *   1. an end is gone        \u2014 a node the platform no longer has\n *   2. a port is gone        \u2014 a port its node no longer has\n *   3. a disabled port       \u2014 `port.disabled`, refused with `port.disabledReason`\n *                              when it carries one (by default at either end;\n *                              `disabledEnds: ['source']` asks only of the source)\n *   4. a self-reference      \u2014 unless `selfReference: true`\n *   5. capacity              \u2014 a port with `maxConnections` (or `allowMultiple:\n *                              false`, which is one) that already carries that many\n *\n * and THEN asks the embedder's `policy(ctx)`, which is where a domain's own rules\n * live \u2014 and its sentences. A policy returns a verdict, or nothing for \"allowed\".\n *\n * SELF-REFERENCES ARE OPT-IN PER ROUTER rather than blanket-refused:\n * `employee.manager_id \u2192 employee` is the most common recursive relationship\n * in business schemas, and a diagram of them needs it on; a graph that must be\n * a DAG leaves it off. There is no cycle detection here at all \u2014 mutual\n * references are legal and common, and a graph that needs a DAG says so in\n * its policy.\n *\n * A verdict is `{ok: true, selfReference, \u2026}` or `{ok: false, reason}`. A policy\n * may answer `{ok: true, offer: {\u2026}}`: a drop that is legal once something\n * else changes too is an OFFER, not a failure.\n *\n * An edge is the embedder's object with at least `{id, from, to}`; which PORT\n * each end uses is read through `endsOf(edge) \u2192 {from, to}` (port ids, or null\n * for an end that names none), by default `edge.fromPort` and `edge.toPort`.\n */\n\nexport const CONNECTOR_STRINGS = Object.freeze({\n    nodeGone: 'That node is no longer on the canvas.',\n    portGone: 'That port is no longer on the canvas.',\n    portDisabled: 'That port cannot be connected.',\n    selfReference: 'A node cannot connect to itself on this canvas.',\n    portFull: (max) => (max === 1 ? 'That port already carries its one connection.'\n        : `That port already carries its ${max} connections.`),\n});\n\nconst say = (strings, key, ...args) => {\n    const s = strings[key];\n    return typeof s === 'function' ? s(...args) : String(s);\n};\n\nconst defaultEndsOf = (edge) => ({ from: edge?.fromPort ?? null, to: edge?.toPort ?? null });\n\n/** The most connections a port may carry: `maxConnections`, else one when it allows no more. */\nfunction capacityOf(port) {\n    if (Number.isFinite(port?.maxConnections)) return port.maxConnections;\n    if (port?.allowMultiple === false) return 1;\n    return Infinity;\n}\n\nexport class ConnectorRouter {\n    /**\n     * @param {object} o\n     * @param {object} o.platform                        a `NodePlatform`\n     * @param {boolean} [o.selfReference]                may a node connect to itself\n     * @param {(ctx: object) => object|null|undefined} [o.policy]  the embedder's rules, asked last\n     * @param {(edge: object) => {from, to}} [o.endsOf]  the port ids an edge uses at each end\n     * @param {('source'|'target')[]} [o.disabledEnds]   which ends a disabled port refuses\n     * @param {object} [o.strings]                       the generic refusals' words\n     */\n    constructor({ platform, selfReference = false, policy = null, endsOf = null,\n                  disabledEnds = ['source', 'target'], strings = null } = {}) {\n        this.platform = platform;\n        this.selfReference = selfReference;\n        this.policy = typeof policy === 'function' ? policy : null;\n        this.endsOf = typeof endsOf === 'function' ? endsOf : defaultEndsOf;\n        this.disabledEnds = new Set(disabledEnds);\n        this.strings = Object.freeze({ ...CONNECTOR_STRINGS, ...(strings || {}) });\n        /** @type {Map<string, object>} edge id -> edge */\n        this.edges = new Map();\n    }\n\n    hydrate(edges) {\n        this.edges.clear();\n        for (const edge of edges) this.edges.set(edge.id, edge);\n    }\n\n    /** Every edge already touching this node, in either direction. */\n    edgesFor(nodeId) {\n        return [...this.edges.values()].filter((e) => e.from === nodeId || e.to === nodeId);\n    }\n\n    /** How many edges (applied and `pending`) already use this port at this node. */\n    connectionsAt(nodeId, portId, { pendingEdges = [] } = {}) {\n        let n = 0;\n        for (const edge of [...this.edges.values(), ...pendingEdges]) {\n            const ends = this.endsOf(edge) || {};\n            if (edge.from === nodeId && ends.from === portId) n += 1;\n            if (edge.to === nodeId && ends.to === portId) n += 1;\n        }\n        return n;\n    }\n\n    /**\n     * Can this drop become an edge?\n     *\n     * `source` and `target` are `{nodeId, portId}`. The answer is a verdict the\n     * caller can render directly \u2014 the reason strings ARE the notice text, so a\n     * policy should name the objects rather than describe the rule.\n     */\n    canConnect(source, target, { pendingEdges = [] } = {}) {\n        const S = this.strings;\n        const fromNode = this.platform.get(source.nodeId);\n        const toNode = this.platform.get(target.nodeId);\n        if (!fromNode || !toNode) return { ok: false, reason: say(S, 'nodeGone') };\n        const fromPort = this.platform.port(source.nodeId, source.portId);\n        const toPort = this.platform.port(target.nodeId, target.portId);\n        if (!fromPort || !toPort) return { ok: false, reason: say(S, 'portGone') };\n        if (fromPort.disabled && this.disabledEnds.has('source')) {\n            return { ok: false, reason: fromPort.disabledReason || say(S, 'portDisabled') };\n        }\n        if (toPort.disabled && this.disabledEnds.has('target')) {\n            return { ok: false, reason: toPort.disabledReason || say(S, 'portDisabled') };\n        }\n        const selfReference = fromNode.id === toNode.id;\n        if (selfReference && !this.selfReference) return { ok: false, reason: say(S, 'selfReference') };\n        for (const [node, port] of [[fromNode, fromPort], [toNode, toPort]]) {\n            const max = capacityOf(port);\n            if (max !== Infinity && this.connectionsAt(node.id, port.id, { pendingEdges }) >= max) {\n                return { ok: false, reason: say(S, 'portFull', max) };\n            }\n        }\n        if (this.policy) {\n            const verdict = this.policy({\n                source, target, fromNode, toNode, fromPort, toPort, pendingEdges, selfReference,\n                edges: [...this.edges.values()], router: this,\n            });\n            if (verdict && typeof verdict === 'object') return verdict;\n        }\n        return { ok: true, selfReference };\n    }\n\n    /**\n     * Record a STAGED edge. Nothing here talks to a server \u2014 the embedder turns\n     * a staged edge into whatever its own write is, and only that makes it real.\n     */\n    stage(edge) {\n        this.edges.set(edge.id, edge);\n        return edge;\n    }\n\n    unstage(id) {\n        const edge = this.edges.get(id);\n        this.edges.delete(id);\n        return edge || null;\n    }\n\n    /**\n     * Re-map edges when a node's port set is rebuilt.\n     *\n     * A node gains or loses a port constantly in a live diagram. Matches by port\n     * id, drops what cannot be mapped, and reports both \u2014 a silently dropped\n     * edge is a line that vanished from the drawing while what it stands for\n     * still exists. `endsOf` (else the router's own) names the ports an edge\n     * uses; an end that names none is not checked.\n     */\n    remapNodeConnections(nodeId, portIds, { endsOf = null } = {}) {\n        const ends = typeof endsOf === 'function' ? endsOf : this.endsOf;\n        const available = new Set(portIds);\n        let remapped = 0;\n        const removed = [];\n        for (const [id, edge] of [...this.edges]) {\n            const at = ends(edge) || {};\n            const touches = [];\n            if (edge.from === nodeId && at.from !== null && at.from !== undefined) touches.push(at.from);\n            if (edge.to === nodeId && at.to !== null && at.to !== undefined) touches.push(at.to);\n            if (edge.from !== nodeId && edge.to !== nodeId) continue;\n            if (touches.every((portId) => available.has(portId))) {\n                remapped += 1;\n                continue;\n            }\n            this.edges.delete(id);\n            removed.push(edge);\n        }\n        return { remapped, removed };\n    }\n}\n", "/**\n * The canvas kernel \u2014 GRAPH LAYER: undo and redo over recorded edits, behind a\n * CLOSED action list (36 \u00A74.3).\n *\n * GENERIC. An entry is `{action, \u2026payload}` \u2014 typically `before` and `after` \u2014\n * and putting one back is the embedder's `apply(entry, direction)`: the\n * service knows the stack, the batch, the hydration gate and the closed list,\n * never what an entry means. (A whole-snapshot history, for a graph small\n * enough to copy, is `@flexdesk/flow`'s `FlowHistory`; this one records\n * DELTAS, for a diagram too large to snapshot on every move.)\n *\n * \u2550\u2550 THE CLOSED LIST \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n * The only actions that exist are the ones the embedder declares, and\n * `record()` REJECTS anything else \u2014 loudly, with `refusal(action)`'s\n * sentence. An embedder whose Ctrl+Z must never reach something (a change\n * already applied to a server, say) enforces that structurally: the action\n * that would touch it cannot be recorded by accident; it has to be added on\n * purpose, to a list the embedder's own comment says not to add it to.\n *\n * \u2550\u2550 TWO TRAPS THIS IS BUILT AGAINST \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n *\n *   1. A MISSING DEPENDENCY FAILS LOUDLY, AT CONSTRUCTION. An undo engine\n *      constructed with the wrong dependency set does nothing and reports\n *      nothing \u2014 every restore path quietly returns \u2014 and the symptom, \"undo\n *      does nothing\", says nothing about the cause. So `actions` and `apply`\n *      are required, and `requires` lets a subclass name its own\n *      (`{platform, router, plan}`): each must be present, or the constructor\n *      throws naming it.\n *   2. THE HYDRATION GATE. Loading a drawing must not itself be undoable \u2014\n *      otherwise the first Ctrl+Z after opening \"undoes\" the opening. Nothing is\n *      recorded until `hydrated()`.\n */\n\nconst DEFAULT_LIMIT = 200;\n\nconst missing = (name) => new Error(\n    `HistoryService needs ${name}. Constructing it without the full dependency set is how an undo `\n  + 'engine ends up silently doing nothing.');\n\nexport class HistoryService {\n    /**\n     * @param {object} o\n     * @param {readonly string[]} o.actions  the only actions `record` accepts\n     * @param {(entry: object, direction: 'undo'|'redo') => void} o.apply  puts one entry back (or forward)\n     * @param {(state: {canUndo, canRedo, depth}) => void} [o.onState]\n     * @param {number} [o.limit]   entries kept; the oldest goes first\n     * @param {object} [o.requires]  `{name: value}` a subclass cannot work without; each is checked\n     * @param {(action: string) => string} [o.refusal]  the sentence a refused `record` throws\n     */\n    constructor({ actions, apply, onState, limit = DEFAULT_LIMIT, requires = null, refusal = null } = {}) {\n        // Loudly, at construction \u2014 see the header.\n        for (const [name, value] of Object.entries(requires || {})) {\n            if (!value) throw missing(name);\n        }\n        if (!Array.isArray(actions) || !actions.length) throw missing('actions (its closed list)');\n        if (typeof apply !== 'function') throw missing('apply(entry, direction)');\n        this.actions = Object.freeze([...actions]);\n        this._applyEntry = apply;\n        this.onState = onState;\n        this.limit = limit;\n        this.refusal = typeof refusal === 'function' ? refusal : null;\n        this.undoStack = [];\n        this.redoStack = [];\n        // The hydration gate. Recording starts only once a drawing is loaded.\n        this.recording = false;\n        this.batch = null;\n    }\n\n    /** The drawing has been loaded: the stacks start empty, and recording starts. */\n    hydrated() {\n        this.undoStack = [];\n        this.redoStack = [];\n        this.recording = true;\n        this._publish();\n    }\n\n    /** Group what is recorded until `endBatch` into one entry. */\n    startBatch(label) {\n        if (!this.recording) return;\n        this.batch = { action: 'batch', label, entries: [] };\n    }\n\n    endBatch() {\n        if (!this.batch) return;\n        const batch = this.batch;\n        this.batch = null;\n        if (batch.entries.length) this._push(batch);\n    }\n\n    record(action, payload) {\n        if (!this.recording) return;\n        if (!this.actions.includes(action)) {\n            throw new Error(this.refusal\n                ? this.refusal(action)\n                : `${action} is not an undoable action here; the ones that are: ${this.actions.join(', ')}.`);\n        }\n        const entry = { action, ...payload };\n        if (this.batch) { this.batch.entries.push(entry); return; }\n        this._push(entry);\n    }\n\n    undo() {\n        const entry = this.undoStack.pop();\n        if (!entry) return false;\n        this._apply(entry, 'undo');\n        this.redoStack.push(entry);\n        this._publish();\n        return true;\n    }\n\n    redo() {\n        const entry = this.redoStack.pop();\n        if (!entry) return false;\n        this._apply(entry, 'redo');\n        this.undoStack.push(entry);\n        this._publish();\n        return true;\n    }\n\n    reset() {\n        this.undoStack = [];\n        this.redoStack = [];\n        this._publish();\n    }\n\n    /**\n     * Take over the undo and redo stacks of a torn-down view whose state this\n     * one has just taken on, entry for entry and in the same order. Nothing new\n     * becomes undoable: every entry was recorded through a `record` whose action\n     * list is closed, so a stack can only carry what that list allows. Call it\n     * after `hydrated()`.\n     */\n    adopt({ undo = [], redo = [] } = {}) {\n        if (!this.recording) return;\n        this.undoStack = [...undo].slice(-this.limit);\n        this.redoStack = [...redo];\n        this._publish();\n    }\n\n    get canUndo() { return this.undoStack.length > 0; }\n    get canRedo() { return this.redoStack.length > 0; }\n\n    _push(entry) {\n        this.undoStack.push(entry);\n        // A new action invalidates the redo branch. Keeping it would let a user\n        // redo their way into a state that never existed.\n        this.redoStack = [];\n        if (this.undoStack.length > this.limit) this.undoStack.shift();\n        this._publish();\n    }\n\n    _publish() {\n        this.onState?.({\n            canUndo: this.canUndo,\n            canRedo: this.canRedo,\n            depth: this.undoStack.length,\n        });\n    }\n\n    _apply(entry, direction) {\n        if (entry.action === 'batch') {\n            const entries = direction === 'undo'\n                ? [...entry.entries].reverse() : entry.entries;\n            for (const child of entries) this._apply(child, direction);\n            return;\n        }\n        this._applyEntry(entry, direction);\n    }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AA2BO,IAAM,eAAN,MAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMtB,YAAY,EAAE,iBAAiB,KAAK,IAAI,CAAC,GAAG;AAExC,SAAK,QAAQ,oBAAI,IAAI;AACrB,SAAK,YAAY,oBAAI,IAAI;AACzB,SAAK,iBAAiB,OAAO,mBAAmB,aAAa,iBAAiB;AAAA,EAClF;AAAA,EAEA,GAAG,OAAO,SAAS;AACf,QAAI,CAAC,KAAK,UAAU,IAAI,KAAK,EAAG,MAAK,UAAU,IAAI,OAAO,oBAAI,IAAI,CAAC;AACnE,SAAK,UAAU,IAAI,KAAK,EAAE,IAAI,OAAO;AACrC,WAAO,MAAM,KAAK,UAAU,IAAI,KAAK,EAAE,OAAO,OAAO;AAAA,EACzD;AAAA,EAEA,KAAK,OAAO,SAAS;AACjB,eAAW,WAAW,KAAK,UAAU,IAAI,KAAK,KAAK,CAAC,EAAG,SAAQ,OAAO;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,QAAQ,OAAO;AACX,SAAK,MAAM,MAAM;AACjB,eAAW,OAAO,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,GAAG;AACjD,UAAI,CAAC,OAAO,IAAI,OAAO,UAAa,IAAI,OAAO,KAAM;AACrD,YAAM,KAAK,IAAI;AACf,WAAK,MAAM,IAAI,IAAI;AAAA,QACf,GAAG;AAAA,QACH;AAAA;AAAA;AAAA;AAAA,QAIA,UAAU,IAAI,WAAW,EAAE,GAAG,IAAI,SAAS,GAAG,GAAG,IAAI,SAAS,EAAE,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE;AAAA,QACjF,MAAM,IAAI,OAAO,EAAE,GAAG,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,EAAE,IAAI;AAAA,QACpD,WAAW,QAAQ,IAAI,SAAS;AAAA,QAChC,OAAO,MAAM,QAAQ,IAAI,KAAK,IAAI,IAAI,QAAQ,CAAC;AAAA,MACnD,CAAC;AAAA,IACL;AACA,SAAK,KAAK,YAAY,EAAE,OAAO,KAAK,MAAM,KAAK,CAAC;AAAA,EACpD;AAAA,EAEA,IAAI,IAAI;AAAE,WAAO,KAAK,MAAM,IAAI,EAAE;AAAA,EAAG;AAAA,EACrC,MAAM;AAAE,WAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC;AAAA,EAAG;AAAA,EAEzC,KAAK,QAAQ,QAAQ;AACjB,WAAO,KAAK,MAAM,IAAI,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,MAAM,KAAK;AAAA,EACzE;AAAA,EAEA,YAAY,IAAI,UAAU,EAAE,SAAS,MAAM,IAAI,CAAC,GAAG;AAC/C,UAAM,OAAO,KAAK,MAAM,IAAI,EAAE;AAC9B,QAAI,CAAC,KAAM,QAAO;AAClB,UAAM,SAAS,EAAE,GAAG,KAAK,SAAS;AAClC,SAAK,WAAW,EAAE,GAAG,SAAS;AAC9B,QAAI,CAAC,OAAQ,MAAK,KAAK,SAAS,EAAE,IAAI,QAAQ,OAAO,EAAE,GAAG,SAAS,EAAE,CAAC;AACtE,WAAO;AAAA,EACX;AAAA,EAEA,aAAa,IAAI,WAAW,EAAE,SAAS,MAAM,IAAI,CAAC,GAAG;AACjD,UAAM,OAAO,KAAK,MAAM,IAAI,EAAE;AAC9B,QAAI,CAAC,KAAM,QAAO;AAClB,UAAM,SAAS,KAAK;AACpB,SAAK,YAAY,QAAQ,SAAS;AAClC,QAAI,CAAC,OAAQ,MAAK,KAAK,aAAa,EAAE,IAAI,QAAQ,OAAO,KAAK,UAAU,CAAC;AACzE,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,aAAa,IAAI;AACb,UAAM,OAAO,KAAK,MAAM,IAAI,EAAE;AAC9B,QAAI,CAAC,KAAM,QAAO,CAAC;AACnB,QAAI,KAAK,UAAW,QAAO,KAAK,iBAAiB,KAAK,eAAe,IAAI,IAAI,CAAC;AAC9E,WAAO,KAAK;AAAA,EAChB;AACJ;;;AC5EO,IAAM,oBAAoB,OAAO,OAAO;AAAA,EAC3C,UAAU;AAAA,EACV,UAAU;AAAA,EACV,cAAc;AAAA,EACd,eAAe;AAAA,EACf,UAAU,CAAC,QAAS,QAAQ,IAAI,kDAC1B,iCAAiC,GAAG;AAC9C,CAAC;AAED,IAAM,MAAM,CAAC,SAAS,QAAQ,SAAS;AACnC,QAAM,IAAI,QAAQ,GAAG;AACrB,SAAO,OAAO,MAAM,aAAa,EAAE,GAAG,IAAI,IAAI,OAAO,CAAC;AAC1D;AAEA,IAAM,gBAAgB,CAAC,UAAU,EAAE,MAAM,MAAM,YAAY,MAAM,IAAI,MAAM,UAAU,KAAK;AAG1F,SAAS,WAAW,MAAM;AACtB,MAAI,OAAO,SAAS,MAAM,cAAc,EAAG,QAAO,KAAK;AACvD,MAAI,MAAM,kBAAkB,MAAO,QAAO;AAC1C,SAAO;AACX;AAEO,IAAM,kBAAN,MAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUzB,YAAY;AAAA,IAAE;AAAA,IAAU,gBAAgB;AAAA,IAAO,SAAS;AAAA,IAAM,SAAS;AAAA,IACzD,eAAe,CAAC,UAAU,QAAQ;AAAA,IAAG,UAAU;AAAA,EAAK,IAAI,CAAC,GAAG;AACtE,SAAK,WAAW;AAChB,SAAK,gBAAgB;AACrB,SAAK,SAAS,OAAO,WAAW,aAAa,SAAS;AACtD,SAAK,SAAS,OAAO,WAAW,aAAa,SAAS;AACtD,SAAK,eAAe,IAAI,IAAI,YAAY;AACxC,SAAK,UAAU,OAAO,OAAO,EAAE,GAAG,mBAAmB,GAAI,WAAW,CAAC,EAAG,CAAC;AAEzE,SAAK,QAAQ,oBAAI,IAAI;AAAA,EACzB;AAAA,EAEA,QAAQ,OAAO;AACX,SAAK,MAAM,MAAM;AACjB,eAAW,QAAQ,MAAO,MAAK,MAAM,IAAI,KAAK,IAAI,IAAI;AAAA,EAC1D;AAAA;AAAA,EAGA,SAAS,QAAQ;AACb,WAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,OAAO,MAAM;AAAA,EACtF;AAAA;AAAA,EAGA,cAAc,QAAQ,QAAQ,EAAE,eAAe,CAAC,EAAE,IAAI,CAAC,GAAG;AACtD,QAAI,IAAI;AACR,eAAW,QAAQ,CAAC,GAAG,KAAK,MAAM,OAAO,GAAG,GAAG,YAAY,GAAG;AAC1D,YAAM,OAAO,KAAK,OAAO,IAAI,KAAK,CAAC;AACnC,UAAI,KAAK,SAAS,UAAU,KAAK,SAAS,OAAQ,MAAK;AACvD,UAAI,KAAK,OAAO,UAAU,KAAK,OAAO,OAAQ,MAAK;AAAA,IACvD;AACA,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,WAAW,QAAQ,QAAQ,EAAE,eAAe,CAAC,EAAE,IAAI,CAAC,GAAG;AACnD,UAAM,IAAI,KAAK;AACf,UAAM,WAAW,KAAK,SAAS,IAAI,OAAO,MAAM;AAChD,UAAM,SAAS,KAAK,SAAS,IAAI,OAAO,MAAM;AAC9C,QAAI,CAAC,YAAY,CAAC,OAAQ,QAAO,EAAE,IAAI,OAAO,QAAQ,IAAI,GAAG,UAAU,EAAE;AACzE,UAAM,WAAW,KAAK,SAAS,KAAK,OAAO,QAAQ,OAAO,MAAM;AAChE,UAAM,SAAS,KAAK,SAAS,KAAK,OAAO,QAAQ,OAAO,MAAM;AAC9D,QAAI,CAAC,YAAY,CAAC,OAAQ,QAAO,EAAE,IAAI,OAAO,QAAQ,IAAI,GAAG,UAAU,EAAE;AACzE,QAAI,SAAS,YAAY,KAAK,aAAa,IAAI,QAAQ,GAAG;AACtD,aAAO,EAAE,IAAI,OAAO,QAAQ,SAAS,kBAAkB,IAAI,GAAG,cAAc,EAAE;AAAA,IAClF;AACA,QAAI,OAAO,YAAY,KAAK,aAAa,IAAI,QAAQ,GAAG;AACpD,aAAO,EAAE,IAAI,OAAO,QAAQ,OAAO,kBAAkB,IAAI,GAAG,cAAc,EAAE;AAAA,IAChF;AACA,UAAM,gBAAgB,SAAS,OAAO,OAAO;AAC7C,QAAI,iBAAiB,CAAC,KAAK,cAAe,QAAO,EAAE,IAAI,OAAO,QAAQ,IAAI,GAAG,eAAe,EAAE;AAC9F,eAAW,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,UAAU,QAAQ,GAAG,CAAC,QAAQ,MAAM,CAAC,GAAG;AACjE,YAAM,MAAM,WAAW,IAAI;AAC3B,UAAI,QAAQ,YAAY,KAAK,cAAc,KAAK,IAAI,KAAK,IAAI,EAAE,aAAa,CAAC,KAAK,KAAK;AACnF,eAAO,EAAE,IAAI,OAAO,QAAQ,IAAI,GAAG,YAAY,GAAG,EAAE;AAAA,MACxD;AAAA,IACJ;AACA,QAAI,KAAK,QAAQ;AACb,YAAM,UAAU,KAAK,OAAO;AAAA,QACxB;AAAA,QAAQ;AAAA,QAAQ;AAAA,QAAU;AAAA,QAAQ;AAAA,QAAU;AAAA,QAAQ;AAAA,QAAc;AAAA,QAClE,OAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC;AAAA,QAAG,QAAQ;AAAA,MAC7C,CAAC;AACD,UAAI,WAAW,OAAO,YAAY,SAAU,QAAO;AAAA,IACvD;AACA,WAAO,EAAE,IAAI,MAAM,cAAc;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,MAAM;AACR,SAAK,MAAM,IAAI,KAAK,IAAI,IAAI;AAC5B,WAAO;AAAA,EACX;AAAA,EAEA,QAAQ,IAAI;AACR,UAAM,OAAO,KAAK,MAAM,IAAI,EAAE;AAC9B,SAAK,MAAM,OAAO,EAAE;AACpB,WAAO,QAAQ;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,qBAAqB,QAAQ,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC,GAAG;AAC1D,UAAM,OAAO,OAAO,WAAW,aAAa,SAAS,KAAK;AAC1D,UAAM,YAAY,IAAI,IAAI,OAAO;AACjC,QAAI,WAAW;AACf,UAAM,UAAU,CAAC;AACjB,eAAW,CAAC,IAAI,IAAI,KAAK,CAAC,GAAG,KAAK,KAAK,GAAG;AACtC,YAAM,KAAK,KAAK,IAAI,KAAK,CAAC;AAC1B,YAAM,UAAU,CAAC;AACjB,UAAI,KAAK,SAAS,UAAU,GAAG,SAAS,QAAQ,GAAG,SAAS,OAAW,SAAQ,KAAK,GAAG,IAAI;AAC3F,UAAI,KAAK,OAAO,UAAU,GAAG,OAAO,QAAQ,GAAG,OAAO,OAAW,SAAQ,KAAK,GAAG,EAAE;AACnF,UAAI,KAAK,SAAS,UAAU,KAAK,OAAO,OAAQ;AAChD,UAAI,QAAQ,MAAM,CAAC,WAAW,UAAU,IAAI,MAAM,CAAC,GAAG;AAClD,oBAAY;AACZ;AAAA,MACJ;AACA,WAAK,MAAM,OAAO,EAAE;AACpB,cAAQ,KAAK,IAAI;AAAA,IACrB;AACA,WAAO,EAAE,UAAU,QAAQ;AAAA,EAC/B;AACJ;;;AC1JA,IAAM,gBAAgB;AAEtB,IAAM,UAAU,CAAC,SAAS,IAAI;AAAA,EAC1B,wBAAwB,IAAI;AACY;AAErC,IAAM,iBAAN,MAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUxB,YAAY,EAAE,SAAS,OAAO,SAAS,QAAQ,eAAe,WAAW,MAAM,UAAU,KAAK,IAAI,CAAC,GAAG;AAElG,eAAW,CAAC,MAAM,KAAK,KAAK,OAAO,QAAQ,YAAY,CAAC,CAAC,GAAG;AACxD,UAAI,CAAC,MAAO,OAAM,QAAQ,IAAI;AAAA,IAClC;AACA,QAAI,CAAC,MAAM,QAAQ,OAAO,KAAK,CAAC,QAAQ,OAAQ,OAAM,QAAQ,2BAA2B;AACzF,QAAI,OAAO,UAAU,WAAY,OAAM,QAAQ,yBAAyB;AACxE,SAAK,UAAU,OAAO,OAAO,CAAC,GAAG,OAAO,CAAC;AACzC,SAAK,cAAc;AACnB,SAAK,UAAU;AACf,SAAK,QAAQ;AACb,SAAK,UAAU,OAAO,YAAY,aAAa,UAAU;AACzD,SAAK,YAAY,CAAC;AAClB,SAAK,YAAY,CAAC;AAElB,SAAK,YAAY;AACjB,SAAK,QAAQ;AAAA,EACjB;AAAA;AAAA,EAGA,WAAW;AACP,SAAK,YAAY,CAAC;AAClB,SAAK,YAAY,CAAC;AAClB,SAAK,YAAY;AACjB,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA,EAGA,WAAW,OAAO;AACd,QAAI,CAAC,KAAK,UAAW;AACrB,SAAK,QAAQ,EAAE,QAAQ,SAAS,OAAO,SAAS,CAAC,EAAE;AAAA,EACvD;AAAA,EAEA,WAAW;AACP,QAAI,CAAC,KAAK,MAAO;AACjB,UAAM,QAAQ,KAAK;AACnB,SAAK,QAAQ;AACb,QAAI,MAAM,QAAQ,OAAQ,MAAK,MAAM,KAAK;AAAA,EAC9C;AAAA,EAEA,OAAO,QAAQ,SAAS;AACpB,QAAI,CAAC,KAAK,UAAW;AACrB,QAAI,CAAC,KAAK,QAAQ,SAAS,MAAM,GAAG;AAChC,YAAM,IAAI,MAAM,KAAK,UACf,KAAK,QAAQ,MAAM,IACnB,GAAG,MAAM,uDAAuD,KAAK,QAAQ,KAAK,IAAI,CAAC,GAAG;AAAA,IACpG;AACA,UAAM,QAAQ,EAAE,QAAQ,GAAG,QAAQ;AACnC,QAAI,KAAK,OAAO;AAAE,WAAK,MAAM,QAAQ,KAAK,KAAK;AAAG;AAAA,IAAQ;AAC1D,SAAK,MAAM,KAAK;AAAA,EACpB;AAAA,EAEA,OAAO;AACH,UAAM,QAAQ,KAAK,UAAU,IAAI;AACjC,QAAI,CAAC,MAAO,QAAO;AACnB,SAAK,OAAO,OAAO,MAAM;AACzB,SAAK,UAAU,KAAK,KAAK;AACzB,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAEA,OAAO;AACH,UAAM,QAAQ,KAAK,UAAU,IAAI;AACjC,QAAI,CAAC,MAAO,QAAO;AACnB,SAAK,OAAO,OAAO,MAAM;AACzB,SAAK,UAAU,KAAK,KAAK;AACzB,SAAK,SAAS;AACd,WAAO;AAAA,EACX;AAAA,EAEA,QAAQ;AACJ,SAAK,YAAY,CAAC;AAClB,SAAK,YAAY,CAAC;AAClB,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,EAAE,IAAI,CAAC,GAAG;AACjC,QAAI,CAAC,KAAK,UAAW;AACrB,SAAK,YAAY,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,KAAK;AAC5C,SAAK,YAAY,CAAC,GAAG,IAAI;AACzB,SAAK,SAAS;AAAA,EAClB;AAAA,EAEA,IAAI,UAAU;AAAE,WAAO,KAAK,UAAU,SAAS;AAAA,EAAG;AAAA,EAClD,IAAI,UAAU;AAAE,WAAO,KAAK,UAAU,SAAS;AAAA,EAAG;AAAA,EAElD,MAAM,OAAO;AACT,SAAK,UAAU,KAAK,KAAK;AAGzB,SAAK,YAAY,CAAC;AAClB,QAAI,KAAK,UAAU,SAAS,KAAK,MAAO,MAAK,UAAU,MAAM;AAC7D,SAAK,SAAS;AAAA,EAClB;AAAA,EAEA,WAAW;AACP,SAAK,UAAU;AAAA,MACX,SAAS,KAAK;AAAA,MACd,SAAS,KAAK;AAAA,MACd,OAAO,KAAK,UAAU;AAAA,IAC1B,CAAC;AAAA,EACL;AAAA,EAEA,OAAO,OAAO,WAAW;AACrB,QAAI,MAAM,WAAW,SAAS;AAC1B,YAAM,UAAU,cAAc,SACxB,CAAC,GAAG,MAAM,OAAO,EAAE,QAAQ,IAAI,MAAM;AAC3C,iBAAW,SAAS,QAAS,MAAK,OAAO,OAAO,SAAS;AACzD;AAAA,IACJ;AACA,SAAK,YAAY,OAAO,SAAS;AAAA,EACrC;AACJ;",
+  "names": []
+}

package/dist/charts.js

@@ -39,10 +39,10 @@ import {
   setPlotlySource,
   uid,
   updateChart
-} from "./chunk-CNXP3SIN.js";
+} from "./chunk-ZMCRDOCF.js";
 import {
   createRafResizeObserver
-} from "./chunk-KH2GJTKR.js";
+} from "./chunk-IYV5JVYB.js";
 import {
   ManagedWindow
 } from "./chunk-6JSOVNID.js";