@nerd-bible/wordgard 0.5.3-beta5 → 0.5.3-beta6

package/dist/editor.d.ts

@@ -4,7 +4,7 @@ import { GardState, TextblockMap, Transaction, GardSelection } from 'wordgard/st
 import { PhraseSet } from 'wordgard/phrases';
 import { StyleModule, StyleSpec } from 'style-mod';
 import { Command, Menu } from 'wordgard/command';
-import { PointSet, RangeSet } from 'wordgard/set';
+import { PointSet, Set, RangeSet } from 'wordgard/set';
 
 type MakeSelectionStyle = (wg: Wordgard, event: MouseEvent) => Wordgard.MouseSelectionStyle | null;
 
@@ -124,7 +124,7 @@ declare namespace Decoration {
             /**
             This function allows you to define a {@link Decoration.Tag.shape
             custom node shape} that depends on the editor state. It will
-            automatically track what slots (see {@link
+            automatically track which state slots (see {@link
             GardState.Facet.compute}) you use, and make sure the nodes
             are redrawn when those change.
             
@@ -255,7 +255,7 @@ declare namespace Decoration {
         Create a {@link PointSet} from an array or source function of
         point decorations.
         */
-        static set(source: PointSet.Source<Point>): Point.Set;
+        static set(source: Set.Source<Point>): Point.Set;
         /**
         The empty set of point decorations.
         */
@@ -301,7 +301,7 @@ declare namespace Decoration {
         Create a {@link RangeSet} from an array or source function of
         range decorations.
         */
-        static set(source: RangeSet.Source<Range>): Range.Set;
+        static set(source: Set.Source<Range>): Range.Set;
         /**
         The empty set of range decorations.
         */
@@ -1326,6 +1326,35 @@ declare namespace KeyBinding {
     const defaultKeymap: readonly KeyBinding[];
 }
 
+type Config = {
+    /**
+    The type of plot to decorate.
+    */
+    type: Node$1.Query;
+    /**
+    A function that produces range decorations for a plot. `from`
+    and `to` should be relative to the start of the plot's content,
+    and be fall entirely within the plot.
+    */
+    ranges?: (node: Plot, range: (deco: Decoration.Range, from: number, to: number) => void) => void;
+    /**
+    A function that produces point decorations for a plot. `pos`
+    should be relative to the start of the plot's content.
+    */
+    points?: (node: Plot, point: (deco: Decoration.Point, pos: number) => void) => void;
+    /**
+    An optional function that causes the decorations to be recreated
+    on matching transaction, either for the entire document (`true`)
+    or for any plot where the returned predicate returns `true`.
+    */
+    refresh?: (tr: Transaction) => boolean | ((plot: Plot) => boolean);
+};
+/**
+Create an extension that adds decorations to plots matching the
+given type.
+*/
+declare function decoratePlots(config: Config): GardState.Extension;
+
 type PanelConfig = {
     /**
     By default, panels will be placed inside the editor's DOM
@@ -1832,4 +1861,4 @@ being dragged over the editor.
 */
 declare function dropCursor(): GardState.Extension;
 
-export { Decoration, Dialog, InputRule, KeyBinding, Panel, Tooltip, Widget, Wordgard, dropCursor, menuBar, placeholder };
+export { Decoration, Dialog, InputRule, KeyBinding, Panel, Tooltip, Widget, Wordgard, decoratePlots, dropCursor, menuBar, placeholder };

package/dist/editor.js

@@ -475,7 +475,7 @@ class WrapperDecoration extends Decoration.Point {
 const nodeSelectionDeco = /*@__PURE__*/Decoration.Point.attributes({ class: "wg-selected-node" });
 function nodeSelection(state) {
     if (state.selection instanceof GardSelection.Node)
-        return PointSet.create([[state.selection.from, nodeSelectionDeco]]);
+        return PointSet.create([[nodeSelectionDeco, state.selection.from]]);
     return PointSet.empty;
 }
 const none = [];
@@ -621,7 +621,7 @@ class SpanIterator {
                     nextActive = i;
                 }
             }
-            let { pos: pointPos, side: pointSide } = points.value ? points : { pos: 1e9, side: 1 };
+            let [pointPos, pointSide] = points.value ? [points.from, points.value.side] : [1e9, 1];
             let nextPos = Math.min(startPos, endPos, pointPos);
             if (this.to == this.end && nextPos > this.to) {
                 this.done = true;
@@ -635,7 +635,7 @@ class SpanIterator {
             else if (pointPos == nextPos && (startPos > pointPos || pointSide < 0) && (endPos > pointPos || pointSide < 0)) {
                 this.point = this.points.value;
                 this.pointSource = this.points.set;
-                this.from = this.to = this.points.pos;
+                this.from = this.to = this.points.from;
                 this.points.next();
                 break;
             }
@@ -5365,6 +5365,86 @@ class PluginInstance {
     }
 }
 
+function offset(add, offset) {
+    return (v, from, to) => add(v, from + offset, to == null ? undefined : to + offset);
+}
+function init(type, create, source, doc) {
+    return create(add => {
+        doc.iterate((node, pos) => {
+            if (node.isPlot && doc.schema.matchNode(node.type, type))
+                source(node, pos + 1, add);
+        });
+    });
+}
+function refreshByPred(type, source, doc, deco, pred) {
+    let recreate = [];
+    doc.iterate((node, pos) => {
+        if (doc.schema.matchNode(node.type, type) && pred(node))
+            recreate.push({
+                from: pos, to: pos + node.length,
+                add: add => source(node, pos + 1, add)
+            });
+    });
+    return recreate.length ? deco.modify({ replace: recreate }) : deco;
+}
+function update(config, create, source, deco, tr) {
+    let doc = tr.newDoc;
+    let refresh = config.refresh && config.refresh(tr);
+    if (refresh === true)
+        return init(config.type, create, source, doc);
+    if (refresh)
+        deco = refreshByPred(config.type, source, tr.startState.doc, deco, refresh);
+    if (!tr.docChanged && !refresh)
+        return deco;
+    let recreate = [];
+    let clear = [];
+    tr.changes.iterChangedRanges((fromA, toA, fromB, toB) => {
+        let covered = false;
+        doc.iterate(fromB, toB, (node, pos) => {
+            if (doc.schema.matchNode(node.type, config.type)) {
+                recreate.push({
+                    from: pos, to: pos + node.length,
+                    add: add => source(node, pos + 1, add)
+                });
+                if (pos < toB && pos + node.length > toB)
+                    covered = true;
+                return false;
+            }
+        });
+        if (!covered) {
+            let end = tr.startState.doc.resolve(toA);
+            let open = end.matchingParent(p => doc.schema.matchNode(p.type, config.type));
+            if (open && open.before >= fromA)
+                clear.push({ from: open.before, to: open.after });
+        }
+    });
+    if (clear.length)
+        deco = deco.modify({ replace: clear });
+    deco = deco.map(tr.changes, recreate);
+    return deco;
+}
+function decoratePlots(config) {
+    let result = [];
+    let { type, points, ranges } = config;
+    if (points) {
+        let source = (plot, start, add) => points(plot, offset(add, start));
+        let field = GardState.Field.define({
+            create(state) { return init(type, PointSet.create, source, state.doc); },
+            update(value, tr) { return update(config, PointSet.create, source, value, tr); }
+        });
+        result.push(field, Decoration.Point.source.of(s => s.field(field)));
+    }
+    if (ranges) {
+        let source = (plot, start, add) => ranges(plot, offset(add, start));
+        let field = GardState.Field.define({
+            create(state) { return init(type, RangeSet.create, source, state.doc); },
+            update(value, tr) { return update(config, RangeSet.create, source, value, tr); }
+        });
+        result.push(field, Decoration.Range.source.of(s => s.field(field)));
+    }
+    return result;
+}
+
 const panelConfig = /*@__PURE__*/GardState.Facet.define({
     combine(configs) {
         let topContainer, bottomContainer;
@@ -7020,7 +7100,7 @@ function showPlaceholder(state) {
     let shape = state.facet(placeholderShape);
     if (!shape.length)
         return Decoration.Point.none;
-    return Decoration.Point.set([[pos, Decoration.Point.widget(placeholderWidget.of(shape[0]), { side: 1 })]]);
+    return Decoration.Point.set([[Decoration.Point.widget(placeholderWidget.of(shape[0]), { side: 1 }), pos]]);
 }
 const placeholderField = /*@__PURE__*/GardState.Field.define({
     create(state) {
@@ -7124,4 +7204,4 @@ function dropCursor() {
     return [dropCursorPos, drawDropCursor];
 }
 
-export { Decoration, Dialog, InputRule, KeyBinding, Panel, Tooltip, Widget, Wordgard, dropCursor, menuBar, placeholder };
+export { Decoration, Dialog, InputRule, KeyBinding, Panel, Tooltip, Widget, Wordgard, decoratePlots, dropCursor, menuBar, placeholder };

package/dist/schema.js

@@ -834,9 +834,9 @@ const resizeState = /*@__PURE__*/GardState.Field.define({
                 let { target, resizing } = e.value;
                 if (target < 0)
                     return { target: -1, resizing: -1, deco: Decoration.Point.none };
-                let deco = [[target, resizeWrapper]];
+                let deco = [[resizeWrapper, target]];
                 if (resizing > -1)
-                    deco.push([target, Decoration.Point.attributes({ style: `width: ${resizing}px` }, { target: "img" })]);
+                    deco.push([Decoration.Point.attributes({ style: `width: ${resizing}px` }, { target: "img" }), target]);
                 return { target, resizing, deco: Decoration.Point.set(deco) };
             }
         }

package/dist/set.d.ts

@@ -1,62 +1,139 @@
 import { ChangeSet } from 'wordgard/doc';
 
 /**
-Data structure that stores sets of ranges, for use with {@link
-Decoration.Range range decorations} or other data types
-implementing {@link RangeSet.Value}.
+The interface shared between {@link RangeSet} and {@link
+PointSet}.
 */
-declare class RangeSet<T extends RangeSet.Value> {
-    private constructor();
+declare abstract class Set<T> {
     /**
-    Create a range set from an iterable of `[from, to, value]`
-    tuples, or a function that calls its argument for every range to
-    add.
+    The number of values in this set.
     */
-    static create<T extends RangeSet.Value>(source: RangeSet.Source<T>): RangeSet<T>;
+    abstract length: number;
     /**
-    The number of ranges stored in this set.
+    Returns `true` when this set is empty.
     */
-    get length(): number;
+    abstract empty: boolean;
     /**
-    Returns true when this set is empty.
+    Create a cursor over this point set, starting at the given
+    position and side.
     */
-    get empty(): boolean;
+    abstract cursor(from?: number): Set.Cursor<T>;
     /**
-    Create a cursor over this set, starting at the given position.
+    Adjust this set's positions for a set of document changes.
+    Returns a new set with the adjusted positions. Will delete
+    values when the content around them was deleted. Optionally
+    accepts an ordered sequence of replacements, whose positions
+    should refer to the post-change document.
     */
-    cursor(from?: number): RangeSet.Cursor<T>;
+    abstract map(map: ChangeSet, replace?: readonly Set.Replacement<T>[]): this;
     /**
-    Create a cursor over a collection of range sets.
+    Create an updated copy of this set.
     */
-    static cursor<T extends RangeSet.Value>(sets: readonly RangeSet<T>[], from?: number): RangeSet.Cursor<T>;
+    abstract modify(spec: {
+        /**
+        If given, replace all values in these ranges.
+        */
+        replace?: readonly Set.Replacement<T>[];
+        /**
+        Add values from this source.
+        */
+        add?: Set.Source<T>;
+        /**
+        Optionally filter out any value where this predicate returns
+        false.
+        */
+        filter?: (value: T, from: number, to: number) => boolean;
+    }): this;
+}
+declare namespace Set {
     /**
-    Adjust the positions of the ranges for the given change set.
-    Returns a set with the updated ranges. Optionally takes an array
-    of replacement ranges. Any ranges overlapping such a replacement
-    will be dropped, and new ranges provided by their `add`
-    properties will be added to the new set.
+    A cursor over a point or range set.
     */
-    map(map: ChangeSet, replace?: readonly RangeSet.Replacement<T>[]): RangeSet<T>;
-    private mapInner;
+    interface Cursor<T> {
+        /**
+        The value of the current range or point, or `null` when there
+        are no more values.
+        */
+        value: T | null;
+        /**
+        The start position of the current range or point.
+        */
+        from: number;
+        /**
+        The end position of the current range. Will be equal to `from`
+        for points.
+        */
+        to: number;
+        /**
+        Move the cursor to a given position.
+        */
+        goto(pos: number, side?: number): void;
+        /**
+        Continue to the next value, if any.
+        */
+        next(): void;
+        /**
+        The set object that the current value points at, if any.
+        */
+        set: any;
+    }
     /**
-    Modify this set.
+    A source, used to create or extend a set, is either
+    an array of `[value, pos, pos?]` tuples, or a function that calls its
+    argument to add a value.
+    
+    For ranges, `to` must be given, and ranges must be provided
+    ordered by start position. For points, `to` must be omitted or
+    be the same as `from`, and the points must be ordered by
+    position and {@link PointSet.Value.side side}.
     */
-    modify(spec: {
+    type Source<T> = Iterable<[T, number, number?]> | ((add: (value: T, pos: number, to?: number) => void) => void);
+    /**
+    Represents a replaced section in a set.
+    */
+    type Replacement<T> = {
         /**
-        Drop any ranges inside the given replacement ranges,
-        optionally add new ranges provided by their `add` property.
+        The start of the replacement.
         */
-        replace?: readonly RangeSet.Replacement<T>[];
+        from: number;
         /**
-        Add new ranges to the set.
+        The end of the replaced range.
         */
-        add?: RangeSet.Source<T>;
+        to: number;
         /**
-        Drop any range for which this predicate function returns
-        `false`.
+        An optional source of points to to this section.
         */
-        filter?: (from: number, to: number, value: T) => boolean;
-    }): RangeSet<T>;
+        add?: Source<T>;
+    };
+}
+
+/**
+Data structure that stores sets of ranges, for use with {@link
+Decoration.Range range decorations} or other data types
+implementing {@link RangeSet.Value}.
+*/
+declare class RangeSet<T extends RangeSet.Value> extends Set<T> {
+    private constructor();
+    /**
+    Create a range set from an iterable of `[from, to, value]`
+    tuples, or a function that calls its argument for every range to
+    add.
+    */
+    static create<T extends RangeSet.Value>(source: Set.Source<T>): RangeSet<T>;
+    get length(): number;
+    get empty(): boolean;
+    cursor(from?: number): Set.Cursor<T>;
+    /**
+    Create a cursor over a collection of range sets.
+    */
+    static cursor<T extends RangeSet.Value>(sets: readonly RangeSet<T>[], from?: number): Set.Cursor<T>;
+    map(map: ChangeSet, replace?: readonly Set.Replacement<T>[]): this;
+    private mapInner;
+    modify(spec: {
+        replace?: readonly Set.Replacement<T>[];
+        add?: Set.Source<T>;
+        filter?: (value: T, from: number, to: number) => boolean;
+    }): this;
     private modifyInner;
     /**
     Compare a section of this set with a section of the same length
@@ -88,57 +165,6 @@ declare namespace RangeSet {
         */
         eq(other: Value): boolean;
     }
-    /**
-    A range source, used to construct or extend a range set, must
-    either be an array of `[from, to, value]` tuples, or a function
-    that calls its argument for each range to add. Ranges must be
-    provided ordered by their `from` position.
-    */
-    type Source<T extends Value> = Iterable<[number, number, T]> | ((add: (from: number, to: number, value: T) => void) => void);
-    /**
-    Represents a replaced section in a range set.
-    */
-    type Replacement<T extends Value> = {
-        /**
-        The start of the section.
-        */
-        from: number;
-        /**
-        The end of the section.
-        */
-        to: number;
-        /**
-        An optional collection of ranges to replace the section with.
-        Must fall within `from` and `to`.
-        */
-        add?: Source<T>;
-    };
-    /**
-    A cursor over a range set.
-    */
-    interface Cursor<T extends Value> {
-        /**
-        The current range's value, or `null` if the end of the set has
-        been reached.
-        */
-        value: T | null;
-        /**
-        The start position of the current range.
-        */
-        from: number;
-        /**
-        The end position of the current range.
-        */
-        to: number;
-        /**
-        Move the cursor to a new position.
-        */
-        goto(pos: number): void;
-        /**
-        Move to the next range, if any.
-        */
-        next(): void;
-    }
 }
 
 /**
@@ -147,31 +173,25 @@ across document changes. Mostly used for {@link Decoration.Point
 point decorations}, but can also track your own types, if you make
 sure they implement the {@link PointSet.Value} interface.
 */
-declare class PointSet<T extends PointSet.Value> {
+declare class PointSet<T extends PointSet.Value> implements Set<T> {
     private constructor();
     /**
     Create a point set from an iterable of `[position, value]`
     tuples, or a function that calls its argument for every point to
     add.
     */
-    static create<T extends PointSet.Value>(source: PointSet.Source<T>): PointSet<T>;
-    /**
-    The number of points in this set.
-    */
+    static create<T extends PointSet.Value>(source: Set.Source<T>): PointSet<T>;
     get length(): number;
-    /**
-    Returns `true` when this set is empty.
-    */
     get empty(): boolean;
     /**
     Create a cursor over this point set, starting at the given
     position and side.
     */
-    cursor(from?: number, side?: number): PointSet.Cursor<T>;
+    cursor(from?: number, side?: number): Set.Cursor<T>;
     /**
     Create a cursor over a collection of point sets.
     */
-    static cursor<T extends PointSet.Value>(sets: readonly PointSet<T>[], from?: number, side?: number): PointSet.Cursor<T>;
+    static cursor<T extends PointSet.Value>(sets: readonly PointSet<T>[], from?: number, side?: number): Set.Cursor<T>;
     /**
     Get the value at the given position, if any. If there's multiple
     values at that position, the one with the lowest side is
@@ -184,26 +204,13 @@ declare class PointSet<T extends PointSet.Value> {
     around them was deleted. Optionally accepts an ordered sequence
     of replacements.
     */
-    map(map: ChangeSet, replace?: readonly PointSet.Replacement<T>[]): PointSet<T>;
+    map(map: ChangeSet, replace?: readonly Set.Replacement<T>[]): this;
     private mapInner;
-    /**
-    Create an updated copy of this set.
-    */
     modify(spec: {
-        /**
-        If given, replace all points in these ranges.
-        */
-        replace?: readonly PointSet.Replacement<T>[];
-        /**
-        Add the points from this source.
-        */
-        add?: PointSet.Source<T>;
-        /**
-        Optionally filter out any point where this predicate returns
-        false.
-        */
-        filter?: (pos: number, value: T) => boolean;
-    }): PointSet<T>;
+        replace?: readonly Set.Replacement<T>[];
+        add?: Set.Source<T>;
+        filter?: (value: T, from: number, to: number) => boolean;
+    }): this;
     private modifyInner;
     /**
     Compare a range in this set with a range in another set. Call
@@ -239,60 +246,6 @@ declare namespace PointSet {
         */
         eq(other: Value): boolean;
     }
-    /**
-    A point source, used to create or extend a point set, is either
-    an array of `[pos, value]` tuples, or a function that calls its
-    argument to add a point. Point sources must provide their points
-    ordered by position and {@link PointSet.Value.side side}.
-    */
-    type Source<T extends Value> = Iterable<[number, T]> | ((add: (pos: number, value: T) => void) => void);
-    /**
-    Represents a replaced section in a point set.
-    */
-    type Replacement<T extends Value> = {
-        /**
-        The start of the replacement.
-        */
-        from: number;
-        /**
-        The end of the replaced range.
-        */
-        to: number;
-        /**
-        An optional source of points to to this section.
-        */
-        add?: PointSet.Source<T>;
-    };
-    /**
-    A cursor over a point set.
-    */
-    interface Cursor<T extends Value> {
-        /**
-        The value of the current point, or `null` when there are no
-        more points.
-        */
-        value: T | null;
-        /**
-        The position of the current point.
-        */
-        pos: number;
-        /**
-        The side value of the current point.
-        */
-        side: number;
-        /**
-        Move the cursor to a given position and side.
-        */
-        goto(pos: number, side: number): void;
-        /**
-        Continue to the next point, if any.
-        */
-        next(): void;
-        /**
-        The set object that the current point belongs to.
-        */
-        set: PointSet<T>;
-    }
 }
 
 /**
@@ -302,4 +255,4 @@ such element exists) @hidden
 */
 declare function findAbove(array: readonly number[], start: number, n: number): number;
 
-export { PointSet, RangeSet, findAbove };
+export { PointSet, RangeSet, Set, findAbove };

package/dist/set.js

@@ -1,5 +1,8 @@
 import { ChangeSet } from 'wordgard/doc';
 
+class Set {
+}
+
 function findAbove(array, start, n) {
     let from = start, to = array.length;
     for (;;) {
@@ -12,6 +15,23 @@ function findAbove(array, start, n) {
             from = mid + 1;
     }
 }
+function addReplacements(changes, replace) {
+    let add = [], at = 0, len = changes.newLength;
+    for (let repl of replace) {
+        if (repl.from < at)
+            throw new Error("Replacing ranges must be ordered and non-overlapping");
+        if (repl.to > len)
+            throw new Error("Replacing range out of bounds");
+        if (repl.from > at)
+            add.push(repl.from - at, -1);
+        add.push(repl.to - repl.from, repl.to - repl.from);
+        at = repl.to;
+    }
+    if (len > at)
+        add.push(len - at, -1);
+    return ChangeSet.composeSections(changes.sections, add);
+}
+
 function heapBubble(heap, index, cmp) {
     for (let cur = heap[index];;) {
         let childIndex = (index << 1) + 1;
@@ -47,21 +67,50 @@ function heapPop(heap, cmp) {
         heapBubble(heap, 0, cmp);
     }
 }
-function addReplacements(changes, replace) {
-    let add = [], at = 0, len = changes.newLength;
-    for (let repl of replace) {
-        if (repl.from < at)
-            throw new Error("Replacing ranges must be ordered and non-overlapping");
-        if (repl.to > len)
-            throw new Error("Replacing range out of bounds");
-        if (repl.from > at)
-            add.push(repl.from - at, -1);
-        add.push(repl.to - repl.from, repl.to - repl.from);
-        at = repl.to;
+class HeapCursor {
+    cmp;
+    cursors;
+    heap = [];
+    constructor(cmp, cursors) {
+        this.cmp = cmp;
+        this.cursors = cursors;
+        for (let cur of cursors)
+            if (cur.value) {
+                this.heap.push(cur);
+                heapSink(this.heap, this.heap.length - 1, cmp);
+            }
+        this.fill();
     }
-    if (len > at)
-        add.push(len - at, -1);
-    return ChangeSet.composeSections(changes.sections, add);
+    fill() {
+        if (this.heap.length) {
+            ({ from: this.from, to: this.to, value: this.value } = this.heap[0]);
+        }
+        else {
+            this.from = this.to = 1e9;
+            this.value = null;
+        }
+    }
+    goto(pos, side) {
+        this.heap = [];
+        for (let cur of this.cursors) {
+            cur.goto(pos, side);
+            if (cur.value) {
+                this.heap.push(cur);
+                heapSink(this.heap, this.heap.length - 1, this.cmp);
+            }
+        }
+    }
+    next() {
+        if (this.heap.length) {
+            this.heap[0].next();
+            if (this.heap[0].value)
+                heapBubble(this.heap, 0, this.cmp);
+            else
+                heapPop(this.heap, this.cmp);
+            this.fill();
+        }
+    }
+    get set() { return this.heap.length ? this.heap[0].set : null; }
 }
 
 let Chunk$1 = class Chunk {
@@ -105,18 +154,18 @@ let SetBuilder$1 = class SetBuilder {
             source = add => { for (let [from, to, value] of array)
                 add(from, to, value); };
         }
-        source((from, to, value) => {
+        source((value, from, to = from) => {
             if (pre)
                 pre(from, to);
-            this.addRange(from, to, value);
+            this.addRange(value, from, to);
         });
     }
-    addRange(from, to, value) {
+    addRange(value, from, to) {
         if (from >= to)
             throw new Error("Ranges cannot be empty");
-        (this.lastTo <= from ? this : this.next).addInner(from, to, value);
+        (this.lastTo <= from ? this : this.next).addInner(value, from, to);
     }
-    addInner(from, to, value) {
+    addInner(value, from, to) {
         let chunk;
         if (this.chunks.length) {
             chunk = this.chunks[this.chunks.length - 1];
@@ -139,12 +188,13 @@ let SetBuilder$1 = class SetBuilder {
         return RangeSet.new(this.chunks, next);
     }
 };
-class RangeSet {
+class RangeSet extends Set {
     chunks;
     next;
     constructor(
     chunks, 
     next) {
+        super();
         this.chunks = chunks;
         this.next = next;
     }
@@ -167,20 +217,20 @@ class RangeSet {
     }
     cursor(from = 0) {
         if (!this.next)
-            return new LayerCursor(this.chunks, from);
+            return new LayerCursor(this, this.chunks, from);
         let cursors = [];
         for (let layer = this; layer; layer = layer.next)
-            cursors.push(new LayerCursor(layer.chunks, from));
-        return new HeapCursor$1(cursors);
+            cursors.push(new LayerCursor(this, layer.chunks, from));
+        return new HeapCursor(cmpCursor$1, cursors);
     }
     static cursor(sets, from = 0) {
         let cursors = [];
         for (let set of sets)
             if (!set.empty) {
                 for (let layer = set; layer; layer = layer.next)
-                    cursors.push(new LayerCursor(layer.chunks, from));
+                    cursors.push(new LayerCursor(set, layer.chunks, from));
             }
-        return cursors.length == 0 ? RangeSet.empty.cursor() : cursors.length == 1 ? cursors[0] : new HeapCursor$1(cursors);
+        return cursors.length == 0 ? RangeSet.empty.cursor() : cursors.length == 1 ? cursors[0] : new HeapCursor(cmpCursor$1, cursors);
     }
     map(map, replace = []) {
         let { sections } = map;
@@ -191,7 +241,7 @@ class RangeSet {
         return this.mapInner(sections, map, replace);
     }
     mapInner(sections, map, replace) {
-        let cursor = new LayerCursor(this.chunks, 0);
+        let cursor = new LayerCursor(this, this.chunks, 0);
         let replI = 0, posA = 0, posB = 0;
         let build = new SetBuilder$1();
         for (let i = 0; i < sections.length;) {
@@ -209,7 +259,7 @@ class RangeSet {
                         cursor.next(true);
                     }
                     else if (cursor.to < upto) {
-                        build.addRange(cursor.from + off, cursor.to + off, cursor.value);
+                        build.addRange(cursor.value, cursor.from + off, cursor.to + off);
                         cursor.next();
                     }
                     else {
@@ -245,7 +295,7 @@ class RangeSet {
     }
     modifyInner(add, filter) {
         let build = new SetBuilder$1();
-        let cursor = new LayerCursor(this.chunks, 0);
+        let cursor = new LayerCursor(this, this.chunks, 0);
         let advance = (pos) => {
             for (;;) {
                 let { cur } = cursor;
@@ -259,8 +309,8 @@ class RangeSet {
                     break;
                 }
                 else {
-                    if (!filter || filter(cursor.from, cursor.to, cursor.value))
-                        build.addRange(cursor.from, cursor.to, cursor.value);
+                    if (!filter || filter(cursor.value, cursor.from, cursor.to))
+                        build.addRange(cursor.value, cursor.from, cursor.to);
                     cursor.next();
                 }
             }
@@ -273,7 +323,7 @@ class RangeSet {
     compareRange(fromA, b, fromB, len, change) {
         if (this == b)
             return;
-        let curA = new LayerCursor(this.chunks, fromA), curB = new LayerCursor(b.chunks, fromB), off = fromB - fromA;
+        let curA = new LayerCursor(this, this.chunks, fromA), curB = new LayerCursor(b, b.chunks, fromB), off = fromB - fromA;
         let end = fromB + len, startA = -1, endA = -1, startB = -1, endB = -1;
         for (;;) {
             if (startA >= endA)
@@ -323,16 +373,18 @@ function copyMappedUpto$1(cursor, upto, map, build, replace, replI) {
                 filtered = true;
         }
         if (!filtered)
-            build.addRange(from, to, value);
+            build.addRange(value, from, to);
         cursor.next();
     }
 }
 class LayerCursor {
+    set;
     chunks;
     chunkI = 0;
     i = 0;
     from = 0;
-    constructor(chunks, start) {
+    constructor(set, chunks, start) {
+        this.set = set;
         this.chunks = chunks;
         this.goto(start);
     }
@@ -386,48 +438,6 @@ class LayerCursor {
 let cmpCursor$1 = (a, b) => {
     return (a.from - b.from) || (a.value.inclusiveStart ? (b.value.inclusiveStart ? 0 : 1) : -1) || (a.to - b.to);
 };
-let HeapCursor$1 = class HeapCursor {
-    cursors;
-    heap = [];
-    constructor(cursors) {
-        this.cursors = cursors;
-        for (let cur of cursors)
-            if (cur.value) {
-                this.heap.push(cur);
-                heapSink(this.heap, this.heap.length - 1, cmpCursor$1);
-            }
-        this.fill();
-    }
-    fill() {
-        if (this.heap.length) {
-            ({ from: this.from, to: this.to, value: this.value } = this.heap[0]);
-        }
-        else {
-            this.from = this.to = 1e9;
-            this.value = null;
-        }
-    }
-    goto(pos) {
-        this.heap = [];
-        for (let cur of this.cursors) {
-            cur.goto(pos);
-            if (cur.value) {
-                this.heap.push(cur);
-                heapSink(this.heap, this.heap.length - 1, cmpCursor$1);
-            }
-        }
-    }
-    next() {
-        if (this.heap.length) {
-            this.heap[0].next();
-            if (this.heap[0].value)
-                heapBubble(this.heap, 0, cmpCursor$1);
-            else
-                heapPop(this.heap, cmpCursor$1);
-            this.fill();
-        }
-    }
-};
 
 class Chunk {
     start;
@@ -463,16 +473,18 @@ class SetBuilder {
     add(source, pre) {
         if (typeof source != "function") {
             let array = source;
-            source = add => { for (let [pos, value] of array)
-                add(pos, value); };
+            source = add => { for (let [value, from, to] of array)
+                add(value, from, to); };
         }
-        source((pos, value) => {
+        source((value, from, to) => {
+            if (to != null && from != to)
+                throw new Error("Points cannot cover content");
             if (pre)
-                pre(pos, value);
-            this.addPoint(pos, value);
+                pre(value, from);
+            this.addPoint(value, from);
         });
     }
-    addPoint(pos, value) {
+    addPoint(value, pos) {
         let chunk;
         if (this.chunks.length) {
             chunk = this.chunks[this.chunks.length - 1];
@@ -521,7 +533,7 @@ class PointSet {
     static new(chunks) { return new PointSet(chunks); }
     static create(source) {
         let build = new SetBuilder();
-        build.add(source, (from, value) => {
+        build.add(source, (value, from) => {
             if ((from - build.lastPos || value.side - build.lastSide) < 0)
                 throw new Error("Points must be added in order");
         });
@@ -541,7 +553,7 @@ class PointSet {
         for (let set of sets)
             if (!set.empty)
                 cursors.push(set.cursor(from, side));
-        return cursors.length == 0 ? PointSet.empty.cursor() : cursors.length == 1 ? cursors[0] : new HeapCursor(cursors);
+        return cursors.length == 0 ? PointSet.empty.cursor() : cursors.length == 1 ? cursors[0] : new HeapCursor(cmpCursor, cursors);
     }
     at(pos) {
         for (let chunk of this.chunks) {
@@ -581,8 +593,8 @@ class PointSet {
                         build.addChunk(chunk.move(chunk.start + off));
                         cursor.next(true);
                     }
-                    else if (cursor.pos < upto) {
-                        build.addPoint(cursor.pos + off, cursor.value);
+                    else if (cursor.from < upto) {
+                        build.addPoint(cursor.value, cursor.from + off);
                         cursor.next();
                     }
                     else {
@@ -619,7 +631,7 @@ class PointSet {
     modifyInner(add, filter) {
         let build = new SetBuilder();
         let cursor = new PointCursor(this, 0, -1e9);
-        let advance = (pos) => {
+        let advance = (_, pos) => {
             for (;;) {
                 let { cur } = cursor;
                 if (!cur)
@@ -628,19 +640,19 @@ class PointSet {
                     build.addChunk(cur);
                     cursor.next(true);
                 }
-                else if (cursor.pos >= pos) {
+                else if (cursor.from >= pos) {
                     break;
                 }
                 else {
-                    if (!filter || filter(cursor.pos, cursor.value))
-                        build.addPoint(cursor.pos, cursor.value);
+                    if (!filter || filter(cursor.value, cursor.from, cursor.to))
+                        build.addPoint(cursor.value, cursor.from);
                     cursor.next();
                 }
             }
         };
         if (add)
             build.add(add, advance);
-        advance(1e9);
+        advance(null, 1e9);
         return build.finish();
     }
     compareRange(fromA, b, fromB, len, change) {
@@ -649,7 +661,7 @@ class PointSet {
         let curA = new PointCursor(this, fromA, -1e9), curB = new PointCursor(b, fromB, -1e9);
         let off = fromB - fromA, endB = fromB + len;
         for (;;) {
-            let nextA = curA.value ? curA.pos + off : 1e9, nextB = curB.value ? curB.pos : 1e9;
+            let nextA = curA.value ? curA.from + off : 1e9, nextB = curB.value ? curB.from : 1e9;
             if (Math.min(nextA, nextB) > endB)
                 break;
             let cmp = nextA - nextB || curA.side - curB.side;
@@ -673,9 +685,9 @@ class PointSet {
     static empty = /*@__PURE__*/(() => new PointSet([]))();
 }
 function copyMappedUpto(cursor, upto, map, build, replace, replI) {
-    while (cursor.value && cursor.pos <= upto) {
+    while (cursor.value && cursor.from <= upto) {
         let value = cursor.value;
-        let pos = map.mapPos(cursor.pos, value.side < 0 ? -1 : 1, value.trackMode);
+        let pos = map.mapPos(cursor.from, value.side < 0 ? -1 : 1, value.trackMode);
         if (pos != null) {
             let filtered = false;
             for (let i = replI; !filtered && i < replace.length && replace[i].from <= pos; i++) {
@@ -683,7 +695,7 @@ function copyMappedUpto(cursor, upto, map, build, replace, replI) {
                     filtered = true;
             }
             if (!filtered)
-                build.addPoint(pos, value);
+                build.addPoint(value, pos);
         }
         cursor.next();
     }
@@ -692,14 +704,15 @@ class PointCursor {
     set;
     chunkI = 0;
     i = 0;
-    pos = -1;
+    from = -1;
     constructor(set, start, side) {
         this.set = set;
         this.goto(start, side);
     }
+    get to() { return this.from; }
     get side() { return this.value ? this.value.side : 1e9; }
     goto(pos, side) {
-        let diff = pos - this.pos || side - this.side;
+        let diff = pos - this.from || side - this.side;
         if (diff < 0) {
             this.chunkI = this.i = 0;
         }
@@ -715,7 +728,7 @@ class PointCursor {
         }
         for (let first = true;;) {
             if (this.chunkI == this.set.chunks.length) {
-                this.pos = 1e9;
+                this.from = 1e9;
                 this.cur = this.value = null;
                 break;
             }
@@ -733,7 +746,7 @@ class PointCursor {
             }
             else {
                 this.cur = chunk;
-                this.pos = chunk.pos[this.i] + chunk.start;
+                this.from = chunk.pos[this.i] + chunk.start;
                 this.value = chunk.value[this.i];
                 break;
             }
@@ -757,58 +770,12 @@ class PointCursor {
                 cur = this.cur = this.set.chunks[this.chunkI];
             }
         }
-        this.pos = cur.pos[this.i] + cur.start;
+        this.from = cur.pos[this.i] + cur.start;
         this.value = cur.value[this.i];
     }
 }
 function cmpCursor(a, b) {
-    return a.pos - b.pos || a.value.side - b.value.side;
-}
-class HeapCursor {
-    cursors;
-    heap = [];
-    constructor(cursors) {
-        this.cursors = cursors;
-        for (let cur of cursors)
-            if (cur.value) {
-                this.heap.push(cur);
-                heapSink(this.heap, this.heap.length - 1, cmpCursor);
-            }
-        this.fill();
-    }
-    get side() {
-        return this.value ? this.value.side : 1e9;
-    }
-    fill() {
-        if (this.heap.length) {
-            ({ pos: this.pos, value: this.value } = this.heap[0]);
-        }
-        else {
-            this.pos = 1e9;
-            this.value = null;
-        }
-    }
-    goto(pos, side) {
-        this.heap = [];
-        for (let cur of this.cursors) {
-            cur.goto(pos, side);
-            if (cur.value) {
-                this.heap.push(cur);
-                heapSink(this.heap, this.heap.length - 1, cmpCursor);
-            }
-        }
-    }
-    next() {
-        if (this.heap.length) {
-            this.heap[0].next();
-            if (this.heap[0].value)
-                heapBubble(this.heap, 0, cmpCursor);
-            else
-                heapPop(this.heap, cmpCursor);
-            this.fill();
-        }
-    }
-    get set() { return this.heap.length ? this.heap[0].set : PointSet.empty; }
+    return a.from - b.from || a.value.side - b.value.side;
 }
 
-export { PointSet, RangeSet, findAbove };
+export { PointSet, RangeSet, Set, findAbove };

package/dist/table.js

@@ -237,7 +237,7 @@ const selectedCell = /*@__PURE__*/Decoration.Point.attributes({ class: "wg-selec
 function getCellDeco(state) {
     if (!(state.selection instanceof CellSelection))
         return Decoration.Point.none;
-    return Decoration.Point.set(state.selection.ranges.map(({ from }) => [from - 1, selectedCell]));
+    return Decoration.Point.set(state.selection.ranges.map(({ from }) => [selectedCell, from - 1]));
 }
 const tableSelectionFilter = /*@__PURE__*/(() => GardState.prec.low(Transaction.extender.of(tr => {
     let normalized = CellSelection.normalize(tr.newSelection, tr.newDoc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nerd-bible/wordgard",
-  "version": "0.5.3-beta5",
+  "version": "0.5.3-beta6",
   "description": "Semantic rich text editor system",
   "type": "module",
   "main": "dist/index.js",