sygnal 7.0.0 → 7.2.0-preview.0

package/dist/worker-page.cjs.js

@@ -0,0 +1,669 @@
+'use strict';
+
+var xs = require('xstream');
+
+const cache = new Map();
+const COMPOUND = /([a-zA-Z][\w-]*|\*)|#([\w-]+)|\.([\w-]+)|\[\s*([\w-]+)\s*(?:([~^$*]?=)\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]*))\s*)?\]|:(focus-visible|focus-within|focus|checked|disabled|enabled|open|modal|popover-open)|:not\(([^)]*)\)/y;
+function compound(s, sel) {
+    const out = { classes: [], attrs: [], pseudo: [], not: [] };
+    let i = 0;
+    while (i < s.length) {
+        COMPOUND.lastIndex = i;
+        const m = COMPOUND.exec(s);
+        if (!m)
+            throw new Error(`sygnal/host: unsupported selector "${sel}" (at "${s.slice(i)}")`);
+        // (before a :not() recursion reuses the sticky regex)
+        const next = COMPOUND.lastIndex;
+        if (m[1] && i == 0)
+            out.tag = m[1] == '*' ? undefined : m[1].toLowerCase();
+        else if (m[1])
+            throw new Error(`sygnal/host: unsupported selector "${sel}"`);
+        else if (m[2])
+            out.id = m[2];
+        else if (m[3])
+            out.classes.push(m[3]);
+        else if (m[4])
+            out.attrs.push([m[4], m[5] || '', m[6] ?? m[7] ?? m[8]]);
+        else if (m[9])
+            out.pseudo.push(m[9]);
+        else if (m[10] !== undefined)
+            out.not.push(compound(m[10].trim(), sel));
+        i = next;
+    }
+    return out;
+}
+function parse(sel) {
+    let r = cache.get(sel);
+    if (r)
+        return r;
+    r = sel.split(',').map(part => {
+        const steps = [];
+        let comb = ' ';
+        for (const t of part.trim().replace(/\s*>\s*/g, ' > ').split(/\s+/)) {
+            if (!t)
+                continue;
+            if (t == '>') {
+                comb = '>';
+                continue;
+            }
+            steps.push({ comb, simple: compound(t, sel) });
+            comb = ' ';
+        }
+        if (!steps.length)
+            throw new Error(`sygnal/host: empty selector "${sel}"`);
+        return steps;
+    });
+    if (cache.size < 1024)
+        cache.set(sel, r);
+    return r;
+}
+function attrOk(el, [name, op, v]) {
+    const has = el.getAttribute(name);
+    if (has === null)
+        return false;
+    if (v === undefined)
+        return true;
+    switch (op) {
+        case '=': return has === v;
+        case '^=': return !!v && has.startsWith(v);
+        case '$=': return !!v && has.endsWith(v);
+        case '*=': return !!v && has.includes(v);
+        default: return has.split(/\s+/).includes(v);
+    }
+}
+function simpleOk(el, s) {
+    if (s.tag && el.localName !== s.tag)
+        return false;
+    if (s.id && el.getAttribute('id') !== s.id)
+        return false;
+    for (const c of s.classes)
+        if (!el.classList.contains(c))
+            return false;
+    for (const a of s.attrs)
+        if (!attrOk(el, a))
+            return false;
+    for (const p of s.pseudo)
+        if (!pseudoOk(el, p))
+            return false;
+    for (const n of s.not)
+        if (simpleOk(el, n))
+            return false;
+    return true;
+}
+function pseudoOk(el, p) {
+    const a = el.ownerDocument.activeElement;
+    switch (p) {
+        case 'focus':
+        case 'focus-visible': return a === el;
+        case 'focus-within': return !!a && el.contains(a);
+        case 'checked': return el.localName == 'option' ? !!el.selected || el.parentNode?.value === (el.value || el.getAttribute('value') || el.textContent.trim()) : !!el.checked;
+        case 'disabled': return !!el.disabled;
+        case 'enabled': return !el.disabled;
+        case 'open': return el.localName == 'select' ? el.picker != null : !!el.open || !!el.popoverOpen;
+        case 'modal': return !!el.modal;
+        default: return !!el.popoverOpen;
+    }
+}
+/** right to left; `stop`: an ancestor the match may not reach (an isolation scope's boundary) */
+function stepsOk(el, steps, i, stop) {
+    if (!simpleOk(el, steps[i].simple))
+        return false;
+    if (i === 0)
+        return true;
+    const child = steps[i].comb === '>';
+    for (let p = el.parentNode; p && p !== stop; p = p.parentNode) {
+        if (stepsOk(p, steps, i - 1, stop))
+            return true;
+        if (child)
+            return false;
+    }
+    return false;
+}
+/** whether `el` matches `sel` without reaching `stop` or above for its ancestor parts */
+function matches(el, sel, stop = null) {
+    for (const steps of parse(sel))
+        if (stepsOk(el, steps, steps.length - 1, stop))
+            return true;
+    return false;
+}
+
+/** a scope's key: its scope names (src/cycle/dom/isolate's {type, scope} list) */
+/** a pattern's fields all equal the event's (nested objects compared the same way), as src/cycle/dom/fromEvent's */
+function matchPattern(pattern, obj) {
+    for (const k in pattern) {
+        const p = pattern[k], v = obj?.[k];
+        if (p && typeof p == 'object' && v && typeof v == 'object' ? !matchPattern(p, v) : p !== v)
+            return false;
+    }
+    return true;
+}
+
+/**
+ * sygnal/worker's wire format (research: dev-plans/research/web-worker §2), shared by the worker
+ * target (src/worker/target.ts) and the page bridge (src/worker/page.ts). Messages are plain,
+ * structured-cloneable objects; node ids are sygnal/host nodeId()s (the host body is the mount).
+ *
+ * worker → page
+ *   {root}                         the host body's id (the page maps it to its mount element)
+ *   {ops, ack, listen?, prevent?}  one per flush: flat op tuples; the last page event handled
+ *                                  before they were made; the event types intents listen for and
+ *                                  the intents' declared preventDefaults, each when it changed
+ *   {drv, sink}                    a value for the page driver `drv`'s sink
+ *   {sub, drv, method?, args} / {unsub}   open / close a page driver source subscription
+ * page → worker
+ *   {ev: [PageEvent]}              events, in dispatch order (a field value the page rebased
+ *                                  crosses as an input event, inputType 'insertReplacementText')
+ *   {ping: true}                   answer with a flush, even an empty one (a held submit waits for its ack)
+ *   {emit, v}                      a value from a page driver source subscription
+ */
+const OP = {
+    EL: 0, // [0, id, tag]
+    TEXT: 1, // [1, id, data]
+    KIDS: 2, // [2, parentId, childIds]
+    ATTR: 3, // [3, id, name, value | null]
+    PROP: 4, // [4, id, 'value' | 'checked' | 'selected', value]
+    DATA: 5, // [5, id, data]
+    STYLE: 6, // [6, id, key, value | null]
+    FOCUS: 7, // [7, id | 0]
+    FREE: 8, // [8, ids]
+    SCOPE: 9, // [9, id, scopeKey | null]: an isolation scope's root element (declared preventDefaults are scoped)
+};
+
+/**
+ * sygnal/worker/page: the page half (research: dev-plans/research/web-worker). Applies the worker's
+ * patch ops to the real DOM, forwards the events the app listens for (with the target's form
+ * state), makes the decisions that can't wait for the worker (preventDefault), and hosts the
+ * drivers that need the page (localStorage, the router, DOM-only browser APIs). No Sygnal core:
+ * xstream for the page drivers' sinks, and sygnal/host's selector matching for declared
+ * preventDefaults.
+ *
+ *   startBridge(new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' }), root, {
+ *     drivers: { STORE: localStorageDriver, ROUTER: routerDriver },
+ *   })
+ *
+ * Fields: while the user edits a field, the page owns its value. A value the page sent is never
+ * echoed back; a worker value about older text is rebased onto what the user typed since (and the
+ * caret kept); a submit waits until the worker has acknowledged the form's last edit.
+ */
+const INIT_KEYS = ['key', 'code', 'keyCode', 'which', 'charCode', 'location', 'shiftKey', 'ctrlKey', 'altKey', 'metaKey', 'repeat',
+    'button', 'buttons', 'clientX', 'clientY', 'pageX', 'pageY', 'offsetX', 'offsetY', 'screenX', 'screenY', 'movementX', 'movementY',
+    'deltaX', 'deltaY', 'deltaZ', 'deltaMode', 'detail', 'inputType', 'data', 'isComposing', 'pointerId', 'pointerType', 'pressure',
+    'width', 'height', 'isPrimary'];
+// always forwarded: the host tree's copy of field values and focus must follow the page even when
+// no intent listens (processForm reads the worker's form on submit)
+const ALWAYS = ['input', 'change', 'focus', 'blur'];
+const FIELD = /^(INPUT|TEXTAREA|SELECT)$/;
+// text fields whose caret the page can read and set (setSelectionRange throws on the others)
+const CARET = /^(text|search|url|tel|password)$/;
+function startBridge(worker, mount, options = {}) {
+    const nodes = new Map();
+    const idOf = new WeakMap();
+    const scopes = new WeakMap();
+    // per field: what the worker had, in order (see prop), and the seq of its last edit the page sent
+    const sent = new WeakMap();
+    const lastEdit = new WeakMap();
+    const composing = new WeakSet();
+    const pd = options.preventDefault || [['submit', '*']];
+    const coalesce = new Set(options.coalesce || ['pointermove', 'mousemove', 'scroll', 'wheel']);
+    const listening = new Set();
+    const declared = new Map();
+    const stats = { received: 0, sent: 0, ops: 0, held: 0 };
+    let seq = 0;
+    let ack = 0;
+    let applying = false;
+    let resolveReady;
+    const ready = new Promise((ok) => { resolveReady = ok; });
+    const post = (m) => { stats.sent++; worker.postMessage(m); };
+    // ---- ops → DOM ----------------------------------------------------------------------------
+    function apply(ops) {
+        applying = true;
+        let n = 0;
+        try {
+            for (let i = 0; i < ops.length; n++) {
+                switch (ops[i]) {
+                    case OP.EL: {
+                        const el = document.createElement(ops[i + 2]);
+                        nodes.set(ops[i + 1], el);
+                        idOf.set(el, ops[i + 1]);
+                        i += 3;
+                        break;
+                    }
+                    case OP.TEXT: {
+                        const t = document.createTextNode(ops[i + 2]);
+                        nodes.set(ops[i + 1], t);
+                        i += 3;
+                        break;
+                    }
+                    case OP.KIDS: {
+                        kids(nodes.get(ops[i + 1]), ops[i + 2]);
+                        i += 3;
+                        break;
+                    }
+                    case OP.ATTR: {
+                        const el = nodes.get(ops[i + 1]), v = ops[i + 3];
+                        v == null ? el.removeAttribute(ops[i + 2]) : el.setAttribute(ops[i + 2], v);
+                        i += 4;
+                        break;
+                    }
+                    case OP.PROP: {
+                        prop(nodes.get(ops[i + 1]), ops[i + 2], ops[i + 3]);
+                        i += 4;
+                        break;
+                    }
+                    case OP.DATA: {
+                        nodes.get(ops[i + 1]).data = ops[i + 2];
+                        i += 3;
+                        break;
+                    }
+                    case OP.STYLE: {
+                        const s = nodes.get(ops[i + 1]).style, k = ops[i + 2], v = ops[i + 3];
+                        if (k.startsWith('--') || k.includes('-'))
+                            v == null ? s.removeProperty(k) : s.setProperty(k, v);
+                        else
+                            s[k] = v == null ? '' : v;
+                        i += 4;
+                        break;
+                    }
+                    case OP.FOCUS: {
+                        const el = nodes.get(ops[i + 1]);
+                        el ? el.focus() : mount.contains(document.activeElement) && document.activeElement.blur();
+                        i += 2;
+                        break;
+                    }
+                    case OP.FREE: {
+                        for (const id of ops[i + 1])
+                            nodes.delete(id);
+                        i += 2;
+                        break;
+                    }
+                    case OP.SCOPE: {
+                        const el = nodes.get(ops[i + 1]);
+                        ops[i + 2] == null ? scopes.delete(el) : scopes.set(el, ops[i + 2]);
+                        i += 3;
+                        break;
+                    }
+                    default: throw new Error('sygnal/worker/page: unknown op ' + ops[i]);
+                }
+            }
+        }
+        finally {
+            applying = false;
+        }
+        return n;
+    }
+    /** a parent's children become exactly `ids`: removals first, then one pass of moves/inserts */
+    function kids(parent, ids) {
+        const want = ids.map((id) => nodes.get(id));
+        const keep = new Set(want);
+        for (let c = parent.firstChild; c;) {
+            const next = c.nextSibling;
+            if (!keep.has(c))
+                parent.removeChild(c);
+            c = next;
+        }
+        let cur = parent.firstChild;
+        for (const n of want) {
+            if (n === cur)
+                cur = cur.nextSibling;
+            else
+                parent.insertBefore(n, cur);
+        }
+    }
+    /**
+     * A field's value / checked from the worker. When the user has edited the field since the last
+     * event the worker had handled (`ack`), the worker's value is a decision about older text: it is
+     * rebased (the user's edits since then, applied to the worker's value) instead of dropped
+     * (React Native's event-count rule keeps the stale text: "Buy milk" + Enter + "W" would stay
+     * "Buy milkW" when the worker's clear arrives) or applied as is (the "W" would be lost).
+     * Deferred while an IME composes. The caret follows the text it was in.
+     *
+     * A field's log holds what the worker had, in order: [seq, value] for each value the page sent,
+     * [ack, value] for each value the worker wrote. The base of a rebase is the last entry at `ack`.
+     */
+    function prop(el, k, v) {
+        if (composing.has(el))
+            return;
+        if (k !== 'value') {
+            if (el[k] !== v)
+                el[k] = v;
+            return;
+        }
+        let log = sent.get(el);
+        if (!log)
+            sent.set(el, log = []);
+        let b = -1;
+        for (let i = 0; i < log.length; i++)
+            if (log[i][0] <= ack)
+                b = i;
+        const base = b >= 0 ? log[b][1] : '';
+        const later = log.slice(b + 1);
+        const heldEdits = held ? held.filter((ev) => fieldOf.get(ev) === el) : [];
+        log.length = 0;
+        log.push([ack, v], ...later);
+        if (!later.length && !heldEdits.length) {
+            if (el.value !== v)
+                setValue(el, v);
+            return;
+        }
+        // the events still held back, the screen, and what the worker was last sent follow too
+        for (const ev of heldEdits)
+            ev.state.value = rebase(base, ev.state.value, v);
+        const next = rebase(base, el.value, v);
+        if (next !== el.value)
+            setValue(el, next);
+        if (later.length) {
+            const known = later[later.length - 1][1], synced = rebase(base, known, v);
+            // the worker's copy and the app's state follow as an input event (its events carried the
+            // pre-rebase text), ahead of anything held
+            if (synced !== known)
+                post_({ seq: 0, type: 'input', id: idOf.get(el), init: { inputType: 'insertReplacementText' }, state: { value: synced } }, el);
+        }
+    }
+    /** a value write that keeps the caret where it was relative to the text around it (Q-WW-4) */
+    function setValue(el, next) {
+        const old = el.value;
+        const keep = el === document.activeElement && (el.tagName === 'TEXTAREA' || CARET.test(el.type));
+        const s = keep ? el.selectionStart : null, e = keep ? el.selectionEnd : null;
+        el.value = next;
+        if (keep && s != null)
+            try {
+                el.setSelectionRange(caret(old, next, s), caret(old, next, e ?? s));
+            }
+            catch { /* not a text field after all */ }
+    }
+    // ---- DOM events → worker ------------------------------------------------------------------
+    /** the element carrying `el`'s innermost isolation scope (null: the root component's) */
+    const scopeRoot = (el) => {
+        for (let e = el; e && e !== mount; e = e.parentNode)
+            if (scopes.has(e))
+                return e;
+        return null;
+    };
+    /** does an intent's declared preventDefault apply: as sygnal/host's delegation decides, on the page's elements */
+    function declaredPrevent(e) {
+        const list = declared.get(e.type);
+        if (!list)
+            return false;
+        let sr = scopeRoot(e.target);
+        for (let el = e.target; el && el !== mount.parentNode; el = el.parentNode) {
+            if (el.nodeType === 1) {
+                const key = sr ? scopes.get(sr) : '';
+                for (const [, sel, global, scope, pattern] of list) {
+                    let at = false;
+                    try {
+                        at = global ? !sel || matches(el, sel)
+                            : scope === key && (sel ? matches(el, sel, sr ? sr.parentNode : mount.parentNode) : el === (sr || mount));
+                    }
+                    catch { /* a selector sygnal/host doesn't support: the worker reported it */ }
+                    if (at && (pattern === true || matchPattern(pattern, e)))
+                        return true;
+                }
+            }
+            if (!e.bubbles || el === mount)
+                break;
+            if (el === sr)
+                sr = scopeRoot(el.parentNode);
+        }
+        return false;
+    }
+    // Q-WW-7: per frame, the latest event of a high-frequency type (pending, posted with the next frame or the next other event)
+    const pending = new Map();
+    let frame = 0;
+    function flushPending() {
+        if (frame) {
+            cancelAnimationFrame(frame);
+            frame = 0;
+        }
+        for (const ev of pending.values())
+            send(ev);
+        pending.clear();
+    }
+    // Q-WW-3: a submit waits until the worker has acknowledged the form's last edit, and what follows
+    // a submit waits until the worker has handled it (its reaction, a cleared field, rebases what the
+    // user typed meanwhile). Sequence numbers are given when an event is posted: the acks only grow
+    let held = null;
+    let holdUntil = 0;
+    let holdTimer = 0;
+    // a field event's field (its value is logged when it's posted), a submit's form
+    const fieldOf = new WeakMap();
+    const formOf = new WeakMap();
+    function hold(until) {
+        held = [];
+        holdUntil = until;
+        post({ ping: true });
+        // a worker that never answers mustn't swallow the events
+        holdTimer = setTimeout(release, 1000);
+    }
+    function send(ev) {
+        if (held) {
+            held.push(ev);
+            return;
+        }
+        const form = formOf.get(ev);
+        if (form) {
+            let until = 0;
+            for (const f of Array.from(form.elements || []))
+                until = Math.max(until, lastEdit.get(f) ?? 0);
+            if (until > ack) {
+                stats.held++;
+                hold(until);
+                held.push(ev);
+                return;
+            }
+            post_(ev);
+            hold(ev.seq);
+            return;
+        }
+        post_(ev, fieldOf.get(ev));
+    }
+    function post_(ev, field) {
+        ev.seq = ++seq;
+        if (field && ev.state && 'value' in ev.state) {
+            let log = sent.get(field);
+            if (!log)
+                sent.set(field, log = []);
+            log.push([ev.seq, ev.state.value]);
+            lastEdit.set(field, ev.seq);
+            // only the last entry the worker has acknowledged is still a possible base
+            if (log.length > 32) {
+                let b = 0;
+                for (let i = 0; i < log.length; i++)
+                    if (log[i][0] <= ack)
+                        b = i;
+                log.splice(0, b);
+            }
+        }
+        post({ ev: [ev] });
+    }
+    function release() {
+        clearTimeout(holdTimer);
+        const q = held;
+        held = null;
+        // one message each: the worker reacts to each before it takes the next; a submit holds again
+        for (const ev of q)
+            send(ev);
+    }
+    function onEvent(e) {
+        // focus moves the bridge itself made (autoFocus in the worker) aren't news to the worker
+        if (applying && (e.type === 'focus' || e.type === 'blur'))
+            return;
+        let el = e.target;
+        while (el && !idOf.has(el))
+            el = el.parentNode;
+        if (!el)
+            return;
+        const t = e.target;
+        if (!e.defaultPrevented) {
+            for (const [type, sel] of pd)
+                if (type === e.type && (sel === '*' || t.closest?.(sel))) {
+                    e.preventDefault();
+                    break;
+                }
+            if (!e.defaultPrevented && declaredPrevent(e))
+                e.preventDefault();
+        }
+        if (!listening.has(e.type) && !ALWAYS.includes(e.type))
+            return;
+        const init = {};
+        for (const k of INIT_KEYS) {
+            const v = e[k];
+            if (v !== undefined && typeof v != 'object' && typeof v != 'function')
+                init[k] = v;
+        }
+        const ev = { seq: 0, type: e.type, id: idOf.get(el), init };
+        if (FIELD.test(t.tagName) && 'value' in t) {
+            ev.state = t.type === 'checkbox' || t.type === 'radio' ? { value: t.value, checked: t.checked } : { value: t.value };
+            if (e.type === 'input' || e.type === 'change')
+                fieldOf.set(ev, t);
+        }
+        else if (e.type === 'scroll' && t.nodeType === 1)
+            ev.state = { scrollTop: t.scrollTop, scrollLeft: t.scrollLeft };
+        if (coalesce.has(e.type)) {
+            const prev = pending.get(e.type);
+            if (prev && prev.id !== ev.id) {
+                pending.delete(e.type);
+                send(prev);
+            }
+            else if (prev && e.type === 'wheel')
+                for (const k of ['deltaX', 'deltaY', 'deltaZ'])
+                    ev.init[k] = (ev.init[k] || 0) + (prev.init[k] || 0);
+            pending.set(e.type, ev);
+            if (!frame)
+                frame = requestAnimationFrame(() => { frame = 0; flushPending(); });
+            return;
+        }
+        flushPending();
+        if (e.type === 'submit')
+            formOf.set(ev, t);
+        send(ev);
+    }
+    // one capture listener per type: the always-forwarded ones, the bridge's own preventDefaults,
+    // then what the worker's intents listen for or declare
+    const attached = new Set();
+    const attach = (type) => {
+        if (attached.has(type))
+            return;
+        attached.add(type);
+        mount.addEventListener(type, onEvent, { capture: true, passive: false });
+    };
+    for (const t of ALWAYS)
+        attach(t);
+    for (const [t] of pd)
+        attach(t);
+    const compStart = (e) => composing.add(e.target);
+    const compEnd = (e) => composing.delete(e.target);
+    mount.addEventListener('compositionstart', compStart, true);
+    mount.addEventListener('compositionend', compEnd, true);
+    // ---- drivers on the page ------------------------------------------------------------------
+    const sinks = {};
+    const sources = {};
+    for (const [name, driver] of Object.entries(options.drivers || {})) {
+        sinks[name] = xs.create();
+        sources[name] = driver(sinks[name]);
+    }
+    const subs = new Map();
+    function onMessage(m) {
+        const d = m.data;
+        if (!d || typeof d != 'object')
+            return;
+        stats.received++;
+        if (d.ops) {
+            ack = d.ack;
+            if (d.listen)
+                for (const t of d.listen) {
+                    listening.add(t);
+                    attach(t);
+                }
+            if (d.prevent) {
+                declared.clear();
+                for (const p of d.prevent) {
+                    const l = declared.get(p[0]);
+                    l ? l.push(p) : declared.set(p[0], [p]);
+                    attach(p[0]);
+                }
+            }
+            const n = apply(d.ops);
+            stats.ops += n;
+            options.onApply?.(n);
+            if (held && ack >= holdUntil)
+                release();
+            resolveReady();
+        }
+        else if (d.root) {
+            nodes.set(d.root, mount);
+            idOf.set(mount, d.root);
+        }
+        else if (d.sink !== undefined)
+            sinks[d.drv]?.shamefullySendNext(d.sink);
+        else if (d.sub) {
+            const src = sources[d.drv];
+            if (!src)
+                return console.error(`sygnal/worker/page: no page driver named '${d.drv}' (startBridge's drivers)`);
+            const stream = d.method ? src[d.method](...d.args) : src;
+            const listener = { next: (v) => post({ emit: d.sub, v }), error: (e) => console.error(e), complete: () => { } };
+            subs.set(d.sub, { stream, listener });
+            stream.addListener(listener);
+        }
+        else if (d.unsub) {
+            const s = subs.get(d.unsub);
+            s?.stream.removeListener(s.listener);
+            subs.delete(d.unsub);
+        }
+    }
+    worker.addEventListener('message', onMessage);
+    worker.start?.();
+    return {
+        ready,
+        stats,
+        stop() {
+            worker.removeEventListener('message', onMessage);
+            for (const t of attached)
+                mount.removeEventListener(t, onEvent, true);
+            mount.removeEventListener('compositionstart', compStart, true);
+            mount.removeEventListener('compositionend', compEnd, true);
+            for (const s of subs.values())
+                s.stream.removeListener(s.listener);
+            subs.clear();
+            if (frame)
+                cancelAnimationFrame(frame);
+            clearTimeout(holdTimer);
+        },
+    };
+}
+/** the user's edit of `base` (now `mine`) applied to `theirs`: at the end when typed at the end */
+function rebase(base, mine, theirs) {
+    if (theirs === base)
+        return mine;
+    if (mine === base)
+        return theirs;
+    let p = 0, s = 0;
+    while (p < base.length && p < mine.length && base[p] === mine[p])
+        p++;
+    while (s < base.length - p && s < mine.length - p && base[base.length - 1 - s] === mine[mine.length - 1 - s])
+        s++;
+    const removed = base.length - p - s, inserted = mine.slice(p, mine.length - s);
+    if (s === 0)
+        return theirs.slice(0, Math.max(0, theirs.length - removed)) + inserted;
+    const at = Math.min(p, theirs.length);
+    return theirs.slice(0, at) + inserted + theirs.slice(at + removed);
+}
+/** a caret at `c` in `old`, in `next`: before the changed part it stays, after it keeps its distance from the end */
+function caret(old, next, c) {
+    if (old.length === next.length)
+        return c;
+    let p = 0, s = 0;
+    while (p < old.length && p < next.length && old[p] === next[p])
+        p++;
+    while (s < old.length - p && s < next.length - p && old[old.length - 1 - s] === next[next.length - 1 - s])
+        s++;
+    if (c <= p)
+        return c;
+    if (c >= old.length - s)
+        return next.length - (old.length - c);
+    return next.length - s;
+}
+
+exports.caret = caret;
+exports.rebase = rebase;
+exports.startBridge = startBridge;
+//# sourceMappingURL=worker-page.cjs.js.map