@pilates/core 1.0.1 → 2.0.0

package/dist/algorithm/spineless/order-maintenance.js

@@ -0,0 +1,300 @@
+/**
+ * Order Maintenance (OM) data structure.
+ *
+ * Maintains a totally-ordered set of items under insertions, deletions,
+ * and `compare(a, b)` queries that return the relative order in O(1) (or
+ * O(1) amortized). Foundational primitive for Spineless Traversal
+ * (Kirisame, Wang, Panchekha — PLDI 2025): the priority queue that
+ * drives incremental layout invalidation is keyed on OM timestamps,
+ * so a fast OM comparator dominates per-operation cost.
+ *
+ * Reference: Bender, Cole, Demaine, Farach-Colton, Zito. "Two
+ * simplified algorithms for maintaining order in a list." ESA 2002.
+ *
+ * ## What this file ships
+ *
+ * **The interface** — `OMNode`, `OrderMaintenance` — is the surface the
+ * Spineless runtime will consume. We design it so the implementation
+ * can be swapped (naive ↔ Bender amortized O(1)) without ripple.
+ *
+ * **The naive implementation** — `NaiveOrderMaintenance` — uses a single
+ * doubly-linked list with sequential integer tags assigned on insert.
+ * Inserts trigger O(N) renumbering of trailing nodes. Compare is O(1).
+ *
+ * This is the **scaffolding implementation**: correct, simple, lets us
+ * write all the consumer code (priority queue, runtime, attribute grammar
+ * interpreter) without waiting for the optimized impl. The Bender et al.
+ * amortized-O(1) implementation lands as a drop-in replacement once the
+ * Spineless runtime is wired and we can benchmark end-to-end. The naive
+ * impl stays in tree forever as a reference oracle: every Bender op is
+ * differentially compared against naive in the property-based test.
+ *
+ * ## Why JS and not WASM
+ *
+ * The paper's reference (Megatron) emits C++ and uses inline `cmov` for
+ * branchless compare. We can't use inline assembly in JS, but we don't
+ * have to: V8 already lowers `a < b` on 32-bit-integer hidden classes
+ * to a branchless `cmp` + `setb` sequence on x86-64. The TS-side cost is
+ * predominantly in the `lookup` (Map.get) and the unboxed compare itself.
+ *
+ * @internal
+ */
+/**
+ * Naive O(N)-per-insert Order Maintenance. Correctness-only impl
+ * for scaffolding and as a fuzzer oracle for the future Bender impl.
+ *
+ * Invariants:
+ * - `_omTag` is strictly increasing along the `next` chain.
+ * - `_omTag` values are arbitrary integers but always orderable.
+ * - Insert renumbers all trailing nodes to maintain monotonicity.
+ *
+ * @internal
+ */
+export class NaiveOrderMaintenance {
+    firstNode = null;
+    nodeCount = 0;
+    get size() {
+        return this.nodeCount;
+    }
+    /**
+     * Returns the first node in the order, or `null` if empty. Exposed
+     * for tests and for the priority queue's extract-min operation.
+     *
+     * @internal
+     */
+    first() {
+        return this.firstNode;
+    }
+    init() {
+        const first = { _omTag: 0, prev: null, next: null };
+        this.firstNode = first;
+        this.nodeCount = 1;
+        return first;
+    }
+    insertAfter(after) {
+        const afterNode = after;
+        const newNode = {
+            _omTag: afterNode._omTag + 1,
+            prev: afterNode,
+            next: afterNode.next,
+        };
+        if (afterNode.next !== null) {
+            afterNode.next.prev = newNode;
+        }
+        afterNode.next = newNode;
+        // Renumber trailing nodes to maintain strict monotonicity.
+        // O(N) worst case; this is the scaffolding-only cost the Bender
+        // impl removes.
+        let cursor = newNode.next;
+        let nextTag = newNode._omTag + 1;
+        while (cursor !== null) {
+            cursor._omTag = nextTag;
+            nextTag++;
+            cursor = cursor.next;
+        }
+        this.nodeCount++;
+        return newNode;
+    }
+    delete(node) {
+        const n = node;
+        if (n.prev !== null) {
+            n.prev.next = n.next;
+        }
+        else {
+            this.firstNode = n.next;
+        }
+        if (n.next !== null) {
+            n.next.prev = n.prev;
+        }
+        // Renumbering is not strictly required after delete (gaps in tags
+        // are harmless), but consistency with insertAfter's invariant
+        // (consecutive tags) simplifies reasoning. Skipped for now to
+        // avoid an extra O(N) walk; tests should not rely on consecutive
+        // tags after deletes.
+        this.nodeCount--;
+    }
+    compare(a, b) {
+        const ta = a._omTag;
+        const tb = b._omTag;
+        return ta - tb;
+    }
+    predecessor(node) {
+        return node.prev;
+    }
+}
+// --- Bender et al. 2002 Algorithm 1 (list-labeling with windowed relabel) ---
+/**
+ * Label space. Labels live in `[0, LABEL_MAX)`. Using 2^30 keeps every
+ * arithmetic op (midpoint, double, mask) in V8's 31-bit SMI range, so
+ * the JIT lowers everything to native int instructions. At 2^30 we can
+ * host ~50M items before any global rebalance is forced — far above
+ * typical TUI scale.
+ *
+ * @internal
+ */
+const LABEL_MAX = 1 << 30;
+/**
+ * Bender, Cole, Demaine, Farach-Colton, Zito (2002): "Two simplified
+ * algorithms for maintaining order in a list." Algorithm 1 — list-
+ * labeling with exponentially-growing window relabel.
+ *
+ * Operations:
+ * - `compare`: O(1) integer subtract.
+ * - `insertAfter`: amortized O(log N) per operation (looser than the
+ *   paper's O(1) amortized when using density bound (3/2)^d at depth d;
+ *   we trade a log factor for simpler integer arithmetic and avoid
+ *   BigInt).
+ * - `delete`: O(1).
+ *
+ * Cross-validated against `NaiveOrderMaintenance` via property fuzzer.
+ *
+ * @internal
+ */
+export class BenderOrderMaintenance {
+    firstNode = null;
+    nodeCount = 0;
+    get size() {
+        return this.nodeCount;
+    }
+    first() {
+        return this.firstNode;
+    }
+    init() {
+        // Start label at the middle of the space so first inserts have room
+        // both before (via the global rebalance path) and after.
+        const first = { _omTag: LABEL_MAX >> 1, prev: null, next: null };
+        this.firstNode = first;
+        this.nodeCount = 1;
+        return first;
+    }
+    insertAfter(after) {
+        const pred = after;
+        const succ = pred.next;
+        const succLabel = succ === null ? LABEL_MAX : succ._omTag;
+        const predLabel = pred._omTag;
+        // Midpoint between predecessor and successor labels. Integer-only.
+        const newLabel = (predLabel + succLabel) >> 1;
+        const newNode = { _omTag: newLabel, prev: pred, next: succ };
+        pred.next = newNode;
+        if (succ !== null)
+            succ.prev = newNode;
+        this.nodeCount++;
+        if (newLabel === predLabel) {
+            // No room between pred and succ — trigger a windowed relabel.
+            // Relabel updates newNode._omTag (and others in the window) to
+            // spread out across available label space.
+            this.relabel(newNode);
+        }
+        return newNode;
+    }
+    delete(node) {
+        const n = node;
+        if (n.prev !== null) {
+            n.prev.next = n.next;
+        }
+        else {
+            this.firstNode = n.next;
+        }
+        if (n.next !== null) {
+            n.next.prev = n.prev;
+        }
+        this.nodeCount--;
+        // Delete only creates extra label room; no rebalance needed.
+    }
+    compare(a, b) {
+        return a._omTag - b._omTag;
+    }
+    predecessor(node) {
+        return node.prev;
+    }
+    /**
+     * Walk exponentially-growing windows around `pivot` until a window
+     * with low enough density to redistribute is found. Redistribute
+     * labels uniformly across that window.
+     *
+     * Density bound: `count * 2 ≤ span`. This guarantees:
+     *   - Every node gets a distinct integer label (count ≤ span).
+     *   - Each interval between consecutive labels has at least 2 units
+     *     of room, so subsequent midpoint inserts succeed without
+     *     triggering relabel again at the same depth.
+     *
+     * Window definition at depth d:
+     *   span    = 2^d
+     *   tagLow  = pivot._omTag aligned down to multiple of span
+     *   tagHigh = tagLow + span
+     *
+     * Amortized cost: O(log N) per insert. (Tighter than the paper's
+     * O(1) amortized with density bound (3/2)^d, but the bound here uses
+     * pure integer arithmetic for V8-friendly speed.)
+     *
+     * @internal
+     */
+    relabel(pivot) {
+        let depth = 1;
+        let span = 2;
+        while (true) {
+            // Find aligned window boundaries around the pivot's current label.
+            const mask = (LABEL_MAX - 1) ^ (span - 1);
+            const tagLow = pivot._omTag & mask;
+            const tagHigh = tagLow + span;
+            // Find leftmost node in the window by walking back from pivot.
+            let firstInWindow = pivot;
+            while (firstInWindow.prev !== null && firstInWindow.prev._omTag >= tagLow) {
+                firstInWindow = firstInWindow.prev;
+            }
+            // Count nodes in the window and collect them in-order.
+            const inWindow = [];
+            let cursor = firstInWindow;
+            while (cursor !== null && cursor._omTag < tagHigh) {
+                inWindow.push(cursor);
+                cursor = cursor.next;
+            }
+            const count = inWindow.length;
+            // Density bound: redistribute only when there's at least 2x
+            // headroom in the window. This guarantees distinct labels +
+            // future-insert room without immediate re-relabel.
+            if (count * 2 <= span) {
+                const step = Math.max(1, (span / count) | 0);
+                // Center the assigned range: leave equal padding at both ends.
+                const used = (count - 1) * step + 1;
+                const startPad = Math.max(0, (span - used) >> 1);
+                let label = tagLow + startPad;
+                for (const node of inWindow) {
+                    node._omTag = label;
+                    label += step;
+                }
+                return;
+            }
+            // Window overcrowded — expand. Doubling depth doubles span.
+            // If span exceeds the label space, fall back to a global relabel.
+            depth++;
+            span <<= 1;
+            if (span >= LABEL_MAX) {
+                this.globalRelabel();
+                return;
+            }
+        }
+    }
+    /**
+     * Fallback when the windowed relabel walks all the way up to the
+     * full label space without finding a sparse-enough window. Spreads
+     * every node uniformly across [0, LABEL_MAX).
+     *
+     * @internal
+     */
+    globalRelabel() {
+        const all = [];
+        let cursor = this.firstNode;
+        while (cursor !== null) {
+            all.push(cursor);
+            cursor = cursor.next;
+        }
+        const stride = Math.max(1, (LABEL_MAX / (all.length + 1)) | 0);
+        let label = stride;
+        for (const node of all) {
+            node._omTag = label;
+            label += stride;
+        }
+    }
+}
+//# sourceMappingURL=order-maintenance.js.map

package/dist/algorithm/spineless/order-maintenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-maintenance.js","sourceRoot":"","sources":["../../../src/algorithm/spineless/order-maintenance.ts"],"names":[],"mappings":"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"}

package/dist/algorithm/spineless/priority-queue.bench.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Microbenchmark for the OM-keyed priority queue.
+ *
+ * Targets (Phase 5 viability):
+ * - `push`: < 2µs/op at N=10k (called once per dirty field per layout)
+ * - `popMin`: < 2µs/op at N=10k (called once per recompute step)
+ *
+ * Each layout pass under Spineless may process up to ~5k field-recomputes
+ * on a 1k-node TUI tree. Total PQ overhead must stay well under the
+ * 50-100µs target for incremental layout to beat imperative.
+ *
+ * Run with: `tsx packages/core/src/algorithm/spineless/priority-queue.bench.ts`
+ *
+ * @internal
+ */
+export {};
+//# sourceMappingURL=priority-queue.bench.d.ts.map

package/dist/algorithm/spineless/priority-queue.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue.bench.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/priority-queue.bench.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/algorithm/spineless/priority-queue.bench.js

@@ -0,0 +1,57 @@
+/**
+ * Microbenchmark for the OM-keyed priority queue.
+ *
+ * Targets (Phase 5 viability):
+ * - `push`: < 2µs/op at N=10k (called once per dirty field per layout)
+ * - `popMin`: < 2µs/op at N=10k (called once per recompute step)
+ *
+ * Each layout pass under Spineless may process up to ~5k field-recomputes
+ * on a 1k-node TUI tree. Total PQ overhead must stay well under the
+ * 50-100µs target for incremental layout to beat imperative.
+ *
+ * Run with: `tsx packages/core/src/algorithm/spineless/priority-queue.bench.ts`
+ *
+ * @internal
+ */
+import { BenderOrderMaintenance } from './order-maintenance.js';
+import { OmPriorityQueue } from './priority-queue.js';
+function median(xs) {
+    const sorted = [...xs].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)];
+}
+function bench(label, sizes, opsPerTrial, trials) {
+    console.log(`\n## ${label}`);
+    for (const N of sizes) {
+        const trialMsPush = [];
+        const trialMsPop = [];
+        for (let t = 0; t < trials; t++) {
+            const om = new BenderOrderMaintenance();
+            const nodes = [om.init()];
+            for (let i = 1; i < N; i++)
+                nodes.push(om.insertAfter(nodes[i - 1]));
+            const pq = new OmPriorityQueue(om);
+            // Push phase
+            let s = performance.now();
+            for (let k = 0; k < opsPerTrial; k++) {
+                // Use a deterministic but spread-out order so the heap actually re-orders.
+                const i = (k * 2654435761) % N;
+                pq.push(k, nodes[i]);
+            }
+            let e = performance.now();
+            trialMsPush.push(e - s);
+            // Pop phase (extract everything)
+            s = performance.now();
+            while (!pq.isEmpty())
+                pq.popMin();
+            e = performance.now();
+            trialMsPop.push(e - s);
+        }
+        const usPush = (median(trialMsPush) * 1000) / opsPerTrial;
+        const usPop = (median(trialMsPop) * 1000) / opsPerTrial;
+        console.log(`  N=${N.toString().padStart(6)}  push=${usPush.toFixed(3).padStart(7)} µs  popMin=${usPop.toFixed(3).padStart(7)} µs`);
+    }
+}
+console.log('OmPriorityQueue microbench (Bender OM, single-threaded JS)');
+console.log('Targets: push < 2µs, popMin < 2µs at N=10k');
+bench('push + popMin', [100, 1000, 10000], 10_000, 5);
+//# sourceMappingURL=priority-queue.bench.js.map

package/dist/algorithm/spineless/priority-queue.bench.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue.bench.js","sourceRoot":"","sources":["../../../src/algorithm/spineless/priority-queue.bench.ts"],"names":[],"mappings":"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"}

package/dist/algorithm/spineless/priority-queue.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Order-Maintenance-keyed priority queue.
+ *
+ * The hot data structure of the Spineless Traversal runtime (Kirisame,
+ * Wang, Panchekha — PLDI 2025). Each item is keyed by an {@link OMNode}
+ * representing its position in the layout-field traversal order; the
+ * queue extracts items in OM-order, so the runtime always processes
+ * the earliest-dirty field next.
+ *
+ * Implementation: binary min-heap over `{ value, omNode }` records.
+ * Ordering uses `om.compare(a.omNode, b.omNode)`. Standard O(log N)
+ * push/popMin, O(1) peek/size.
+ *
+ * Membership tracking: an internal `Set` allows O(1) `has(value)`
+ * queries so the Spineless runtime can avoid enqueueing the same
+ * field twice. Important: this assumes `value` instances are stable
+ * (used as Map keys via reference equality), which fits the Spineless
+ * "one OMNode per (Node, field-name) pair, allocated once" model.
+ *
+ * ## Correctness under OM relabel
+ *
+ * The OM data structure may relabel internal tags on insert
+ * (`BenderOrderMaintenance`'s windowed redistribute). The heap
+ * invariant is "parent ≤ all descendants by OM compare". A relabel
+ * preserves the RELATIVE order of all live OM nodes, so
+ * `sign(compare(a, b))` is unchanged — the heap invariant holds.
+ *
+ * @internal
+ */
+import type { OMNode, OrderMaintenance } from './order-maintenance.js';
+/**
+ * @internal
+ */
+export declare class OmPriorityQueue<T> {
+    private readonly om;
+    private readonly heapValue;
+    private readonly heapOmNode;
+    private readonly members;
+    constructor(om: OrderMaintenance);
+    get size(): number;
+    isEmpty(): boolean;
+    has(value: T): boolean;
+    /**
+     * Push a value at the given OM position. Caller is responsible for
+     * checking `has(value)` first if dedup matters (some workflows
+     * intentionally re-enqueue after deletion).
+     *
+     * Returns `true` if added, `false` if `value` was already present
+     * (no-op — the queue is unchanged, original OM position retained).
+     */
+    push(value: T, omNode: OMNode): boolean;
+    /**
+     * Return (without removing) the value at OM-minimum. Returns
+     * `undefined` if the queue is empty.
+     */
+    peek(): T | undefined;
+    /**
+     * Remove and return the OM-minimum value. Returns `undefined` if
+     * the queue is empty.
+     */
+    popMin(): T | undefined;
+    /**
+     * Sift the element at index `start` up the heap until heap property
+     * is restored. O(log N).
+     */
+    private siftUp;
+    /**
+     * Sift the element at index `start` down the heap until heap property
+     * is restored. O(log N).
+     */
+    private siftDown;
+}
+//# sourceMappingURL=priority-queue.d.ts.map

package/dist/algorithm/spineless/priority-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/priority-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAEvE;;GAEG;AACH,qBAAa,eAAe,CAAC,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAmB;IAMtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAE3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,EAAE,EAAE,gBAAgB;IAIhC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,OAAO,IAAI,OAAO;IAIlB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAItB;;;;;;;OAOG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IASvC;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB;;;OAGG;IACH,MAAM,IAAI,CAAC,GAAG,SAAS;IAgBvB;;;OAGG;IACH,OAAO,CAAC,MAAM;IAgBd;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAsBjB"}

package/dist/algorithm/spineless/priority-queue.js

@@ -0,0 +1,149 @@
+/**
+ * Order-Maintenance-keyed priority queue.
+ *
+ * The hot data structure of the Spineless Traversal runtime (Kirisame,
+ * Wang, Panchekha — PLDI 2025). Each item is keyed by an {@link OMNode}
+ * representing its position in the layout-field traversal order; the
+ * queue extracts items in OM-order, so the runtime always processes
+ * the earliest-dirty field next.
+ *
+ * Implementation: binary min-heap over `{ value, omNode }` records.
+ * Ordering uses `om.compare(a.omNode, b.omNode)`. Standard O(log N)
+ * push/popMin, O(1) peek/size.
+ *
+ * Membership tracking: an internal `Set` allows O(1) `has(value)`
+ * queries so the Spineless runtime can avoid enqueueing the same
+ * field twice. Important: this assumes `value` instances are stable
+ * (used as Map keys via reference equality), which fits the Spineless
+ * "one OMNode per (Node, field-name) pair, allocated once" model.
+ *
+ * ## Correctness under OM relabel
+ *
+ * The OM data structure may relabel internal tags on insert
+ * (`BenderOrderMaintenance`'s windowed redistribute). The heap
+ * invariant is "parent ≤ all descendants by OM compare". A relabel
+ * preserves the RELATIVE order of all live OM nodes, so
+ * `sign(compare(a, b))` is unchanged — the heap invariant holds.
+ *
+ * @internal
+ */
+/**
+ * @internal
+ */
+export class OmPriorityQueue {
+    om;
+    // Parallel arrays for the heap. heapValue[i] is the user-supplied
+    // value; heapOmNode[i] is its OM position. Using parallel arrays
+    // rather than {value, omNode} pair objects avoids per-push
+    // allocation, which matters at Spineless-runtime scale (10k+
+    // pushes per layout pass at the largest TUI tree size).
+    heapValue = [];
+    heapOmNode = [];
+    // Membership set keyed by reference. Allows O(1) `has` checks.
+    members = new Set();
+    constructor(om) {
+        this.om = om;
+    }
+    get size() {
+        return this.heapValue.length;
+    }
+    isEmpty() {
+        return this.heapValue.length === 0;
+    }
+    has(value) {
+        return this.members.has(value);
+    }
+    /**
+     * Push a value at the given OM position. Caller is responsible for
+     * checking `has(value)` first if dedup matters (some workflows
+     * intentionally re-enqueue after deletion).
+     *
+     * Returns `true` if added, `false` if `value` was already present
+     * (no-op — the queue is unchanged, original OM position retained).
+     */
+    push(value, omNode) {
+        if (this.members.has(value))
+            return false;
+        this.heapValue.push(value);
+        this.heapOmNode.push(omNode);
+        this.members.add(value);
+        this.siftUp(this.heapValue.length - 1);
+        return true;
+    }
+    /**
+     * Return (without removing) the value at OM-minimum. Returns
+     * `undefined` if the queue is empty.
+     */
+    peek() {
+        return this.heapValue[0];
+    }
+    /**
+     * Remove and return the OM-minimum value. Returns `undefined` if
+     * the queue is empty.
+     */
+    popMin() {
+        const n = this.heapValue.length;
+        if (n === 0)
+            return undefined;
+        const top = this.heapValue[0];
+        const last = n - 1;
+        if (last > 0) {
+            this.heapValue[0] = this.heapValue[last];
+            this.heapOmNode[0] = this.heapOmNode[last];
+        }
+        this.heapValue.length = last;
+        this.heapOmNode.length = last;
+        this.members.delete(top);
+        if (last > 0)
+            this.siftDown(0);
+        return top;
+    }
+    /**
+     * Sift the element at index `start` up the heap until heap property
+     * is restored. O(log N).
+     */
+    siftUp(start) {
+        let i = start;
+        const value = this.heapValue[i];
+        const omNode = this.heapOmNode[i];
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            const parentOm = this.heapOmNode[parent];
+            if (this.om.compare(omNode, parentOm) >= 0)
+                break;
+            this.heapValue[i] = this.heapValue[parent];
+            this.heapOmNode[i] = parentOm;
+            i = parent;
+        }
+        this.heapValue[i] = value;
+        this.heapOmNode[i] = omNode;
+    }
+    /**
+     * Sift the element at index `start` down the heap until heap property
+     * is restored. O(log N).
+     */
+    siftDown(start) {
+        let i = start;
+        const n = this.heapValue.length;
+        const value = this.heapValue[i];
+        const omNode = this.heapOmNode[i];
+        const halfN = n >> 1;
+        while (i < halfN) {
+            let bestChild = (i << 1) | 1; // 2i + 1, left child
+            const right = bestChild + 1;
+            if (right < n) {
+                if (this.om.compare(this.heapOmNode[right], this.heapOmNode[bestChild]) < 0) {
+                    bestChild = right;
+                }
+            }
+            if (this.om.compare(this.heapOmNode[bestChild], omNode) >= 0)
+                break;
+            this.heapValue[i] = this.heapValue[bestChild];
+            this.heapOmNode[i] = this.heapOmNode[bestChild];
+            i = bestChild;
+        }
+        this.heapValue[i] = value;
+        this.heapOmNode[i] = omNode;
+    }
+}
+//# sourceMappingURL=priority-queue.js.map

package/dist/algorithm/spineless/priority-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue.js","sourceRoot":"","sources":["../../../src/algorithm/spineless/priority-queue.ts"],"names":[],"mappings":"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"}