@nerd-bible/wordgard 0.3.3 → 0.3.5

package/dist/doc.d.ts

@@ -1536,6 +1536,15 @@ declare class Plot implements Node.Shared {
     node that overlaps the given range, outer nodes before inner
     nodes. When the function returns `false` for a node, descendents
     of that node are not iterated.
+    
+    When `from` is greater than `to`, iteration happens in inverted
+    order, yielding later siblings before earlier ones.
+    
+    Note that positions passed to the callback are relative to the
+    start of the node this method is called on. That will usually be
+    the document, in which case they are normal document positions,
+    but you can also call it on an arbitrary plot, in which case
+    they are local positions.
     */
     iterate(from: number, to: number, f: (node: Node, pos: number, parent: Plot | null, index: number) => boolean | void): void;
     iterate(f: (node: Node, pos: number, parent: Plot | null, index: number) => boolean | void): void;

package/dist/doc.js

@@ -1301,8 +1301,12 @@ class Plot {
     }
     iterate(a, b, c) {
         let [from, to, f] = typeof a == "number" ? [a, b, c] : [0, this.length, a];
-        if (this.isDoc || f(this, 0, null, 0) !== false)
-            this.iterInner(0, from, to, f);
+        if (this.isDoc || f(this, 0, null, 0) !== false) {
+            if (to < from)
+                this.iterBack(this.contentLength, to, from, f);
+            else
+                this.iterInner(0, from, to, f);
+        }
     }
     nodeAt(pos) {
         for (let node of this.content) {
@@ -1333,12 +1337,20 @@ class Plot {
                 break;
             let node = this.content[i], start = pos;
             pos += node.length;
-            if (pos <= from)
-                continue;
-            if (f(node, start, this, i) !== false && node.isPlot)
+            if (pos > from && f(node, start, this, i) !== false && node.isPlot)
                 node.iterInner(start + 1, from, to, f);
         }
     }
+    iterBack(contentEnd, from, to, f) {
+        for (let pos = contentEnd, i = this.content.length - 1; i >= 0; i--) {
+            if (pos <= from)
+                break;
+            let node = this.content[i], end = pos;
+            pos -= node.length;
+            if (pos < to && f(node, pos, this, i) !== false && node.isPlot)
+                node.iterBack(end - 1, from, to, f);
+        }
+    }
     toString() {
         return this.name + markString(this.tag.marks) + "(" + this.content.join() + ")";
     }
@@ -2945,15 +2957,17 @@ class SectionIter {
     }
     next() {
         let { sections } = this;
+        this.off = 0;
         if (this.i < sections.length) {
             this.len = sections[this.i++];
             this.ins = sections[this.i++];
+            if (this.len == 0 && this.ins < 0)
+                this.next();
         }
         else {
             this.len = 0;
             this.ins = -3;
         }
-        this.off = 0;
     }
     get keep() { return this.ins == -1 || this.ins == -2; }
     get done() { return this.ins == -3; }

package/dist/editor.d.ts

@@ -46,7 +46,7 @@ declare namespace Widget {
         /**
         How to render the widget as DOM content.
         */
-        render: (value: Param) => Element | Text;
+        render: (value: Param, wg: Wordgard) => Element | Text;
         /**
         Compare the widget value for equality. Will default to `===`.
         */
@@ -64,16 +64,22 @@ declare namespace Widget {
         */
         disconnect?: (value: Param, dom: Element | Text) => void;
         /**
-        Called before the editor handles a DOM event that comes from
-        inside the widget. May return true to indicate that no further
-        handling of the event should happen.
+        Used to determine whether events originating from the widget's
+        DOM should ignored by the editor. `false` or a function that
+        returns `false` for the event will prevent the editor's
+        regular event handling for the event.
         */
-        handleEvent?: (event: Event, wg: Wordgard) => boolean;
+        propagateEvent?: boolean | ((event: Event) => boolean);
         /**
         Set this to false for widgets that either aren't visible or
         are positioned outside of the regular document flow.
         */
         inFlow?: boolean;
+        /**
+        By default, widgets are set to be ineditable. Set this to
+        `true` to suppress that.
+        */
+        editable?: boolean;
     };
     /**
     Each widget has an associated type that describes how it
@@ -506,7 +512,7 @@ declare abstract class Tile {
     get boundary(): 0 | 1;
     get firstChild(): Tile | null;
     get lastChild(): Tile | null;
-    handleEvent(event: Event, wg: Wordgard): boolean;
+    ignoreEvent(event: Event): boolean;
     get ignoreMutations(): boolean;
     toString(): string;
     sync(): void;
@@ -606,6 +612,10 @@ declare class Wordgard {
     private editorAttrs;
     private contentAttrs;
     private styleModules;
+    /**
+    True when the editor is connected to a DOM document.
+    */
+    connected: boolean;
     private flushing;
     private willFlush;
     private flushFunc;

package/dist/editor.js

@@ -24,32 +24,40 @@ class Widget {
         return Widget.Type.new(spec).of(null);
     }
     type;
+    render(wg) {
+        return this.type.render(this.value, wg);
+    }
     get hasContent() { return false; }
 }
 ;Widget = /*@__PURE__*/(function (Widget) {
     class Type {
         render;
         eq;
-        handleEvent;
+        propagateEvent;
         connect;
         disconnect;
         inFlow;
+        editable;
         constructor(
         render, 
         eq, 
-        handleEvent, 
+        propagateEvent, 
         connect, 
         disconnect, 
-        inFlow) {
+        inFlow, 
+        editable) {
             this.render = render;
             this.eq = eq;
-            this.handleEvent = handleEvent;
+            this.propagateEvent = propagateEvent;
             this.connect = connect;
             this.disconnect = disconnect;
             this.inFlow = inFlow;
+            this.editable = editable;
         }
         static new(spec) {
-            return new Type(spec.render, spec.eq || ((a, b) => a === b), spec.handleEvent || (() => false), spec.connect ?? null, spec.disconnect ?? null, spec.inFlow !== false);
+            let prop = spec.propagateEvent;
+            let propEvent = typeof prop == "function" ? prop : prop == null ? () => true : () => prop;
+            return new Type(spec.render, spec.eq || ((a, b) => a === b), propEvent, spec.connect ?? null, spec.disconnect ?? null, spec.inFlow !== false, spec.editable === true);
         }
         of(value) { return Widget.new(this, value); }
     }
@@ -106,7 +114,7 @@ const Decoration = /*@__PURE__*/(function (Decoration) {
             return tagWidget.of({
                 type: Node.Type.get(type),
                 place: getPlace(place),
-                widget: typeof widget == "function" ? memo(widget) : (() => widget)
+                widget: typeof widget == "function" ? memo(widget) : widget
             });
         }
         Tag.widget = widget;
@@ -119,7 +127,7 @@ const Decoration = /*@__PURE__*/(function (Decoration) {
                     return {
                         type: tp,
                         place: p,
-                        widget: typeof w == "function" ? memo(w) : (() => w)
+                        widget: typeof w == "function" ? memo(w) : w
                     };
                 });
             }
@@ -262,7 +270,7 @@ class ShapeDecoration extends Decoration.Point {
         return this == other || other instanceof ShapeDecoration && other.shape.eq(this.shape);
     }
     get trackMode() { return "after"; }
-    get side() { return 1e9; }
+    get side() { return 1000000000; }
 }
 class WidgetDecoration extends Decoration.Point {
     widget;
@@ -273,7 +281,7 @@ class WidgetDecoration extends Decoration.Point {
         this.widget = widget;
         this.side = side;
         this.trackMode = trackMode;
-        if (side >= 1e9)
+        if (side >= 1000000000)
             throw new Error("Invalid widget side");
     }
     eq(other) {
@@ -297,7 +305,7 @@ class AttributeDecoration extends Decoration.Point {
             selectorEq(other.selector, this.selector);
     }
     get trackMode() { return "after"; }
-    get side() { return 1e9; }
+    get side() { return 1000000000; }
 }
 class WrapperDecoration extends Decoration.Point {
     elt;
@@ -312,7 +320,7 @@ class WrapperDecoration extends Decoration.Point {
             selectorEq(other.selector, this.selector);
     }
     get trackMode() { return "after"; }
-    get side() { return 1e9; }
+    get side() { return 1000000000; }
 }
 const nodeSelectionDeco = /*@__PURE__*/Decoration.Point.attributes({ class: "wg-selected-node" });
 function nodeSelection(state) {
@@ -494,9 +502,14 @@ class PointIterator {
     get side() {
         return this.done ? 1 : this.value.side;
     }
-    goto(pos) {
+    goto(pos, inclusive) {
         this.done = false;
-        this.fill(findAbove(this.set.positions, 0, pos - 1));
+        let i = findAbove(this.set.positions, 0, pos - 1);
+        if (!inclusive) {
+            while (i < this.set.values.length && this.set.values[i].side < 1000000000)
+                i++;
+        }
+        this.fill(i);
     }
 }
 function addDel(deleted, i) {
@@ -585,8 +598,8 @@ class RangeSet {
     compareRange(fromA, b, fromB, len, change) {
         let a = this, toB = fromB + len;
         if (a != b || fromA != fromB) {
-            let iA = findAbove(a.from, 0, fromA - 1), lA = a.from.length;
-            let iB = findAbove(b.from, 0, fromB - 1), lB = b.from.length;
+            let iA = findAbove(a.to, 0, fromA - 1), lA = a.from.length;
+            let iB = findAbove(b.to, 0, fromB - 1), lB = b.from.length;
             let off = fromB - fromA;
             let sameVals = a.values == b.values;
             for (;;) {
@@ -972,11 +985,14 @@ class DecoIterator {
     pos;
     rangeIter = [];
     pointIter = [];
+    endWidgets;
     constructor(state, decoSet) {
         this.state = state;
         this.decoSet = decoSet;
         this.tagShapes = state.facet(tagShape);
         this.globalWidgets = state.facet(tagWidget);
+        this.endWidgets = this.globalWidgets
+            .some(w => (w.place == 1 || w.place == 3) && typeof w.widget == "function");
         this.globalWrappers = state.facet(tagWrapper);
         this.globalAttrs = state.facet(tagAttribute);
         this.pos = state.doc.resolve(0);
@@ -995,17 +1011,22 @@ class DecoIterator {
     widgets(tag, place, walker) {
         for (let src of this.globalWidgets) {
             if (src.place == place && tag.type == src.type) {
-                let widget = src.widget(tag);
+                let widget = typeof src.widget == "function" ? src.widget(tag) : src.widget;
                 if (widget)
                     walker.widget(widget, place == 0 || place == 3 ? 1 : -1);
             }
         }
     }
+    hasEndWidget(type) {
+        return this.globalWidgets.some(tw => tw.type == type &&
+            (tw.place == 3 || tw.place == 1) &&
+            typeof tw.widget == "function");
+    }
     walk(from, inclusiveStart, to, walker) {
         for (let i of this.rangeIter)
             i.goto(from);
         for (let i of this.pointIter)
-            i.goto(inclusiveStart ? from : from + 1);
+            i.goto(from, inclusiveStart);
         let iter = new HeapIterator(this.rangeIter.filter(i => !i.done), this.pointIter.filter(i => !i.done), from, to);
         let pos = this.pos.advance(from - this.pos.pos), started = inclusiveStart;
         let atomParent;
@@ -1567,7 +1588,7 @@ class Tile {
         let last = this.children.length - 1;
         return last < 0 ? null : this.children[last];
     }
-    handleEvent(event, wg) { return false; }
+    ignoreEvent(event) { return false; }
     get ignoreMutations() { return false; }
     toString() { return this.dom.nodeName + (this.children.length ? `(${this.children})` : ""); }
     sync() { }
@@ -1754,18 +1775,18 @@ class DocTile extends CompositeTile {
         this.cursorWrapper = cursorWrapper;
         this.decoSet = decoSet;
     }
-    static create(state, dom) {
+    static create(state, dom, wg) {
         return new DocTile(state, dom, null, { points: new Map, ranges: new Map })
-            .updateRanges(state, getDecoSet(state), [0, state.doc.length], false);
+            .updateRanges(state, getDecoSet(state), [0, state.doc.length], wg);
     }
     get isDoc() { return true; }
     get node() { return this.state.doc; }
-    update(state, changes, connected = false, composition) {
+    update(state, changes, wg, composition) {
         let decoSet = getDecoSet(state);
         let changed = findChangedRanges(this.state, this.decoSet, state, decoSet, changes);
-        return this.updateRanges(state, decoSet, changed, connected, composition);
+        return this.updateRanges(state, decoSet, changed, wg, composition);
     }
-    updateRanges(state, decoSet, sections, connected, composition) {
+    updateRanges(state, decoSet, sections, wg, composition) {
         let wrapper = composition?.wrapCursor || null;
         if ((!sections.length || sections.length == 2 && sections[1] == -1) && eqArray(wrapper, this.cursorWrapper))
             return this;
@@ -1776,7 +1797,7 @@ class DocTile extends CompositeTile {
             else
                 sections = separated;
         }
-        let builder = new ContentUpdate(state, this, new DecoIterator(state, decoSet), wrapper);
+        let builder = new ContentUpdate(state, this, wg, new DecoIterator(state, decoSet), wrapper);
         for (let i = 0, posB = 0, startCovered = false; i < sections.length;) {
             let len = sections[i++], ins = sections[i++];
             if (composition && posB == composition.fromB && ins >= 0) {
@@ -1802,7 +1823,7 @@ class DocTile extends CompositeTile {
         }
         let result = builder.finish();
         result.sync();
-        if (connected) {
+        if (wg.connected) {
             for (let ch of this.children)
                 ch.disconnect(builder.reused);
             for (let tile of builder.toConnect)
@@ -2031,17 +2052,19 @@ class EltTile extends CompositeTile {
 class WidgetTile extends Tile {
     widget;
     _node;
-    constructor(widget, _node, flags, length = 0, dom) {
-        super(dom || widget.type.render(widget.value), flags);
+    constructor(widget, _node, flags, dom, length = 0) {
+        super(dom, flags);
         this.widget = widget;
         this._node = _node;
         this.length = length;
+        if (dom.nodeType == 1 && !widget.type.editable && dom.contentEditable == "inherit")
+            dom.contentEditable = "false";
     }
     get isNodeOuter() { return !!this._node; }
     get isAtom() { return true; }
     get node() { return this._node; }
     get children() { return noChildren; }
-    handleEvent(event, wg) { return this.widget.type.handleEvent(event, wg); }
+    ignoreEvent(event) { return !this.widget.type.propagateEvent(event); }
     connect() {
         this.widget.type.connect?.(this.widget.value, this.dom);
     }
@@ -2232,6 +2255,7 @@ class TilePointer {
 }
 class ContentUpdate {
     state;
+    wg;
     deco;
     old;
     new;
@@ -2240,8 +2264,9 @@ class ContentUpdate {
     keepWalker;
     toConnect = [];
     partialNode = null;
-    constructor(state, old, deco, cursorWrapper) {
+    constructor(state, old, wg, deco, cursorWrapper) {
         this.state = state;
+        this.wg = wg;
         this.deco = deco;
         this.old = new TilePointer(old, 0, null);
         this.new = new DocTile(state, old.dom, cursorWrapper, deco.decoSet);
@@ -2321,6 +2346,54 @@ class ContentUpdate {
         };
     }
     keep(len, includeStart, includeEnd) {
+        let cut = [], end = this.posB + len;
+        if (this.deco.endWidgets)
+            for (let nw = this.new, { tile, index, parent } = this.old, pos = this.posB; pos < end;) {
+                if (tile instanceof TextTile) {
+                    pos += tile.length - index;
+                    ({ tile, index, parent } = parent);
+                    index++;
+                }
+                else if (index < tile.children.length) {
+                    pos += tile.children[index].length;
+                    index++;
+                }
+                else {
+                    if (tile.node) {
+                        while (!nw.node && nw.parent)
+                            nw = nw.parent;
+                        if (!nw.parent)
+                            break;
+                        if (!nw.node.tag.eq(tile.node.tag) &&
+                            (this.deco.hasEndWidget(tile.node.type) || this.deco.hasEndWidget(nw.node.type)))
+                            cut.push(pos);
+                        nw = nw.parent;
+                        if (!nw)
+                            break;
+                        pos++;
+                    }
+                    if (!parent)
+                        break;
+                    ({ tile, index, parent } = parent);
+                    index++;
+                }
+            }
+        for (let i = cut.length; i;) {
+            let from = cut[--i], to = Math.min(from + 1, includeEnd ? end : end - 1);
+            while (i && cut[i - 1] == from - 1) {
+                from--;
+                i--;
+            }
+            if (from > this.posB)
+                this.keepInner(from - this.posB, includeStart, false);
+            this.update(to - from, true);
+            includeStart = false;
+            len = end - to;
+        }
+        if (len)
+            this.keepInner(len, includeStart, includeEnd);
+    }
+    keepInner(len, includeStart, includeEnd) {
         if (!includeStart) {
             this.old = this.old.walk(0, 1);
             this.openOldWrappers();
@@ -2343,7 +2416,7 @@ class ContentUpdate {
                 if (mark.type.element) {
                     this.openWrapper(renderMarkWrapper(mark), mark.spanning, false);
                 }
-            this.new.addChild(new WidgetTile(imgHack, null, 16 | 32));
+            this.new.addChild(new WidgetTile(imgHack, null, 16 | 32, imgHack.render(this.wg)));
             return;
         }
         let found = [];
@@ -2460,7 +2533,7 @@ class ContentUpdate {
                         : endOld && this.posB == end ? endOld.matchingWidget(widget, sideFlag, this.reused)
                             : null;
                 if (!tile) {
-                    tile = new WidgetTile(widget, null, 16 | sideFlag, 0);
+                    tile = new WidgetTile(widget, null, 16 | sideFlag, widget.render(this.wg));
                     if (widget.type.connect)
                         this.toConnect.push(tile);
                 }
@@ -2497,6 +2570,9 @@ class ContentUpdate {
     }
     buildNodeShape(node, shape, reuse, afterContent = 0) {
         if (shape instanceof Elt) {
+            if (node && !shape.hasContent && Attributes.get(shape.attrs, "contenteditable") == null &&
+                !/^(br|hr|img|input|wbr)$/i.test(shape.tagName))
+                shape = Elt.create(shape.tagName, Attributes.merge(shape.attrs, ["contenteditable", "false"]), shape.children);
             let reusable, dom, strict = true;
             if (reusable = this.findReusableTile(shape, reuse, strict) || this.findReusableTile(shape, reuse, strict = false)) {
                 this.reused.set(reusable, 2);
@@ -2528,7 +2604,7 @@ class ContentUpdate {
                 dom = reusable.dom;
             }
             let flags = (node ? 512 : 16 | 1) | afterContent;
-            let tile = new WidgetTile(shape, node, flags, node ? node.length : 0, dom);
+            let tile = new WidgetTile(shape, node, flags, dom || shape.render(this.wg), node ? node.length : 0);
             if (shape.type.connect)
                 this.toConnect.push(tile);
             return tile;
@@ -2576,7 +2652,7 @@ class ContentUpdate {
                 this.new.children.splice(hasHack, 1);
         }
         else if (needsHack) {
-            this.new.addChild(new WidgetTile(brHack, null, 16 | 64, 0));
+            this.new.addChild(new WidgetTile(brHack, null, 16 | 64, brHack.render(this.wg)));
         }
     }
     up() {
@@ -2704,10 +2780,12 @@ function updateAttributes(dom, a, b) {
     return changed;
 }
 const brHack = /*@__PURE__*/Widget.create({
-    render() { return document.createElement("br"); }
+    render() { return document.createElement("br"); },
+    editable: true
 });
 const imgHack = /*@__PURE__*/Widget.create({
-    render() { return document.createElement("img"); }
+    render() { return document.createElement("img"); },
+    editable: true
 });
 function separateComposition(sections, comp) {
     let result = [], { fromB, toB } = comp;
@@ -4185,13 +4263,17 @@ function isInPrimarySelection(wg, event) {
     }
     return false;
 }
+const focusEvents = /*@__PURE__*/(() => new Set(["input", "beforeinput", "keydown", "keyup", "keypress", "copy", "cut", "paste"]))();
 function eventBelongsToEditor(wg, event) {
-    if (!event.bubbles)
-        return true;
     if (event.defaultPrevented)
         return false;
+    if (!event.bubbles)
+        return true;
+    let active = wg.root.activeElement;
     for (let node = event.target, tile; node != wg.contentDOM; node = node.parentNode)
-        if (!node || node.nodeType == 11 || (tile = Tile.get(node)) && tile.handleEvent(event, wg))
+        if (!node || node.nodeType == 11 ||
+            (tile = Tile.get(node)) && tile.ignoreEvent(event) ||
+            node == active && focusEvents.has(event.type))
             return false;
     return true;
 }
@@ -4756,7 +4838,7 @@ class Wordgard {
         for (let plugin of this.plugins)
             plugin.update(this);
         this.inputState = new InputState(this);
-        this.docTile = DocTile.create(this.state, this.contentDOM);
+        this.docTile = DocTile.create(this.state, this.contentDOM, this);
         this.updateAttrs();
         this.observer = new DOMObserver(this);
         if (spec.parent)
@@ -4899,7 +4981,7 @@ class Wordgard {
                 this.mountStyles();
             this.updateAttrs();
         }
-        this.docTile = prevDocTile.update(update.state, changes, this.connected, composition);
+        this.docTile = prevDocTile.update(update.state, changes, this, composition);
         if ((composition?.wrapCursor || !composition && (prevDocTile != this.docTile || update.selectionSet)) && this.hasFocus)
             setDOMSelection(this);
         this.observer.clear();

package/dist/schema.js

@@ -4,7 +4,7 @@ import { Paragraph, Heading, Direction, Blockquote, HorizontalRule, Alignment, D
 import { phrases, imagePhrases, colorNames } from 'wordgard/phrases';
 import { Command, setTextblockType, Menu, setAlignment, setDirection, toggleBlock, listIsActive, toggleList, enter, toggleMark } from 'wordgard/command';
 import { history } from 'wordgard/history';
-import { KeyBinding, InputRule, Wordgard, Panel, Dialog, Decoration, PointSet, Tooltip } from 'wordgard/editor';
+import { KeyBinding, InputRule, Wordgard, Widget, Decoration, Panel, Dialog, PointSet, Tooltip } from 'wordgard/editor';
 import cr from 'crelt';
 
 function blockDoc() {
@@ -313,6 +313,97 @@ function codeBlock() {
         };
     }));
 ;return codeBlock})(codeBlock);
+function codeBlockLanguage(options = {}) {
+    return [
+        GardState.schemaElement.of(CodeBlockLanguage),
+        options.languages ? [
+            languageStyles,
+            languageOptions.of(options.languages),
+            languageSelect,
+            codeBlockLanguage.selectLanguageBinding
+        ] : []
+    ];
+}
+const languageStyles = /*@__PURE__*/Wordgard.styles({
+    pre: {
+        position: "relative",
+        "& select.wg-code-language": {
+            font: "var(--wg-dialog-font)",
+            fontSize: "70%",
+            position: "absolute",
+            top: "2px",
+            right: "4px",
+            border: "none",
+            borderRadius: "4px"
+        }
+    }
+});
+const languageOptions = /*@__PURE__*/GardState.Facet.define({
+    combine: input => input.reduce((a, b) => a.concat(b), [])
+});
+function option(text, selected, value) {
+    let node = document.createElement("option");
+    node.textContent = text;
+    node.value = value;
+    if (selected)
+        node.selected = true;
+    return node;
+}
+const languageWidget = /*@__PURE__*/Widget.define({
+    render({ options, value }, wg) {
+        let sel = document.createElement("select");
+        sel.className = "wg-code-language";
+        sel.tabIndex = -1;
+        sel.appendChild(option("Plain", value == null, ""));
+        let selected = value && options.find(o => o.toLowerCase() == value);
+        if (value && !selected)
+            sel.appendChild(option(value, true, value));
+        for (let opt of options)
+            sel.appendChild(option(opt, opt == selected, opt.toLowerCase()));
+        sel.onchange = () => {
+            let value = sel.value || undefined;
+            let pos = wg.posAtDOM(sel.parentNode);
+            let block = pos > 0 && wg.state.doc.nodeAt(pos - 1);
+            if (block && block.type == CodeBlock.type && block.mark(CodeBlockLanguage) != value) {
+                wg.dispatch({
+                    changes: value ? { from: pos - 1, add: CodeBlockLanguage.of(value) } :
+                        { from: pos - 1, remove: CodeBlockLanguage.isInSet(block.tag.marks) }
+                });
+                wg.focus();
+            }
+        };
+        return sel;
+    },
+    propagateEvent: false,
+    eq(a, b) {
+        return a.value == b.value && a.options.length == b.options.length &&
+            a.options.every((o, i) => o == b.options[i]);
+    },
+    inFlow: false
+});
+const languageSelect = /*@__PURE__*/Decoration.Tag.widget.dynamic(CodeBlock, "end", state => {
+    let options = state.facet(languageOptions);
+    return tag => {
+        return languageWidget.of({ options, value: tag.mark(CodeBlockLanguage) });
+    };
+});
+;codeBlockLanguage = /*@__PURE__*/(function (codeBlockLanguage) {
+    codeBlockLanguage.selectLanguage = wg => {
+        let blk = wg.state.sel.head.textblockParent;
+        if (!blk || blk.node.type != CodeBlock.type)
+            return false;
+        let sel = wg.nodeDOM(blk.before)?.querySelector("select.wg-code-language");
+        if (!sel)
+            return false;
+        sel.focus();
+        sel.showPicker();
+        return true;
+    };
+    codeBlockLanguage.selectLanguageBinding = KeyBinding.of({
+        key: "Shift-Mod-l",
+        run: codeBlockLanguage.selectLanguage
+    });
+;return codeBlockLanguage})(codeBlockLanguage);
 
 function strong() {
     return [GardState.schemaElement.of(Strong), strong.button, strong.keyBinding];
@@ -1188,7 +1279,7 @@ function toggleLink(wg) {
             let url = form && form.elements.namedItem("url")?.value;
             if (url)
                 wg.dispatch({
-                    changes: selection.ranges.map(r => ({ from: r.from, to: r.to, add: Link.of(url) })),
+                    changes: wg.state.selection.ranges.map(r => ({ from: r.from, to: r.to, add: Link.of(url) })),
                     userEvent: "mark.add"
                 });
         });

package/dist/state.js

@@ -1884,6 +1884,7 @@ function scanChanges(changes, doc, corrections) {
                             pos = off;
                             break;
                         }
+                        off = end;
                     }
                     if (queried.has(pos))
                         return;

package/dist/table.js

@@ -159,7 +159,7 @@ function sameCell(a, b) {
     return a != 0 && a == b;
 }
 function computeMap(table) {
-    if (table.tag != Table)
+    if (table.type != Table.type)
         throw new RangeError(`Not a table node: ${table.type.name}`);
     let width = table.content[0].content.reduce((w, c) => w + (c.mark(ColSpan) ?? 1), 0);
     let height = table.content.length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nerd-bible/wordgard",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Semantic rich text editor system",
   "type": "module",
   "main": "dist/index.js",
@@ -17,6 +17,14 @@
     "./collab": "./dist/collab.js",
     "./phrases": "./dist/phrases.js"
   },
+  "scripts": {
+    "test": "mocha test/test-*.ts",
+    "test-headless": "node bin/test-headless.ts",
+    "prepare": "node bin/build.ts",
+    "watch": "node bin/build.ts --watch",
+    "testserver": "node bin/run-testserver.ts",
+    "release": "node bin/release.ts"
+  },
   "files": [
     "/dist"
   ],
@@ -49,4 +57,4 @@
   "repository": {
     "url": "https://github.com/nerd-bible/wordgard"
   }
-}
+}