@jacobbubu/md-to-lark 1.0.0

package/dist/last/api.js

@@ -0,0 +1,1687 @@
+import { LAST_TEXTUAL_BLOCK_TYPE_SET } from './textual-block-types.js';
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isDocument(model) {
+    return !('mode' in model && model.mode === 'fragment');
+}
+function isTextualBlockNode(block) {
+    return LAST_TEXTUAL_BLOCK_TYPE_SET.has(block.type);
+}
+function getTopLevelBlockIds(model) {
+    if (!isDocument(model)) {
+        return [...model.topLevel];
+    }
+    const root = model.blocks[model.rootId];
+    return root ? [...root.children] : [];
+}
+function setTopLevelBlockIds(model, ids) {
+    if (!isDocument(model)) {
+        model.topLevel = [...ids];
+        return;
+    }
+    const root = model.blocks[model.rootId];
+    if (!root)
+        return;
+    root.children = [...ids];
+}
+function parseNumericSuffix(value, prefix) {
+    if (!value.startsWith(prefix))
+        return 0;
+    const n = Number(value.slice(prefix.length));
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}
+function seedNextCounters(model) {
+    let maxBlock = 0;
+    let maxInline = 0;
+    for (const block of Object.values(model.blocks)) {
+        maxBlock = Math.max(maxBlock, parseNumericSuffix(block.id, 'b_'));
+        if (!isTextualBlockNode(block))
+            continue;
+        for (const inline of block.payload.inlines) {
+            maxInline = Math.max(maxInline, parseNumericSuffix(inline.id, 'i_'));
+        }
+    }
+    return {
+        block: maxBlock + 1,
+        inline: maxInline + 1,
+    };
+}
+function nextBlockId(state) {
+    let candidate = `b_${state.nextBlockCounter}`;
+    while (state.model.blocks[candidate]) {
+        state.nextBlockCounter += 1;
+        candidate = `b_${state.nextBlockCounter}`;
+    }
+    state.nextBlockCounter += 1;
+    return candidate;
+}
+function nextInlineId(state) {
+    const id = `i_${state.nextInlineCounter}`;
+    state.nextInlineCounter += 1;
+    return id;
+}
+function toSearchText(inline) {
+    switch (inline.kind) {
+        case 'text_run':
+            return { text: inline.text ?? '', editable: true };
+        case 'mention_user':
+            return { text: inline.userId ?? '', editable: false };
+        case 'equation':
+            return { text: inline.latex ?? '', editable: false };
+        case 'mention_doc':
+            return { text: inline.title ?? '', editable: false };
+        case 'link_preview':
+            return { text: inline.title ?? inline.url ?? '', editable: false };
+        case 'reminder':
+        case 'inline_block':
+        case 'inline_file':
+            return { text: '', editable: false };
+        default:
+            return { text: '', editable: false };
+    }
+}
+function blockText(block) {
+    if (!isTextualBlockNode(block))
+        return '';
+    let out = '';
+    for (const inline of block.payload.inlines) {
+        out += toSearchText(inline).text;
+    }
+    return out;
+}
+function regexTest(text, pattern) {
+    const probe = new RegExp(pattern.source, pattern.flags);
+    return probe.test(text);
+}
+function buildScopeForTopLevelTextBlock(scopeId, block) {
+    let normalizedText = '';
+    const segments = [];
+    for (const inline of block.payload.inlines) {
+        const projection = toSearchText(inline);
+        if (projection.text.length === 0)
+            continue;
+        const from = normalizedText.length;
+        normalizedText += projection.text;
+        const to = normalizedText.length;
+        segments.push({
+            inlineId: inline.id,
+            inlineKind: inline.kind,
+            from,
+            to,
+            editable: projection.editable,
+        });
+    }
+    return {
+        id: scopeId,
+        blockId: block.id,
+        blockType: block.type,
+        normalizedText,
+        segments,
+    };
+}
+export function rebuildLASTIndexes(model) {
+    const byType = {};
+    for (const block of Object.values(model.blocks)) {
+        const ids = byType[block.type] ?? [];
+        ids.push(block.id);
+        byType[block.type] = ids;
+    }
+    const textScopes = {};
+    const textScopeByBlockId = {};
+    let scopeCounter = 1;
+    for (const blockId of getTopLevelBlockIds(model)) {
+        const block = model.blocks[blockId];
+        if (!block || !isTextualBlockNode(block) || block.type === 'page') {
+            continue;
+        }
+        const scopeId = `scope_${scopeCounter}`;
+        scopeCounter += 1;
+        const scope = buildScopeForTopLevelTextBlock(scopeId, block);
+        textScopes[scopeId] = scope;
+        textScopeByBlockId[block.id] = scopeId;
+    }
+    return {
+        byType,
+        textScopes,
+        textScopeByBlockId,
+    };
+}
+function ensureIndexes(state) {
+    state.model.indexes = rebuildLASTIndexes(state.model);
+}
+function ensureTxn(state) {
+    if (state.active)
+        return;
+    state.checkpoint = deepClone(state.model);
+    state.stagedOps = [];
+    state.warnings = [];
+    state.active = true;
+}
+function uniqueOrdered(ids) {
+    const seen = new Set();
+    const out = [];
+    for (const id of ids) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+function matcherFromSelector(input) {
+    if (input === undefined) {
+        return () => true;
+    }
+    if (typeof input === 'function') {
+        return (node, idx) => input(idx, node);
+    }
+    if (typeof input === 'string') {
+        const raw = input.trim();
+        if (!raw || raw === '*') {
+            return () => true;
+        }
+        const tokens = raw
+            .split(',')
+            .map((x) => x.trim())
+            .filter((x) => x.length > 0);
+        const predicates = tokens.map((token) => {
+            if (token === '*') {
+                return (_node) => true;
+            }
+            if (token.startsWith('#')) {
+                const id = token.slice(1);
+                return (node) => node.id === id;
+            }
+            const attrMatch = token.match(/^\[([^=\]]+)(?:=(.+))?\]$/);
+            if (attrMatch) {
+                const key = attrMatch[1]?.trim() ?? '';
+                const rawValue = attrMatch[2]?.trim();
+                const expected = rawValue ? stripQuotes(rawValue) : undefined;
+                return (node) => {
+                    const value = getPathValue(node, key);
+                    if (expected === undefined)
+                        return value !== undefined;
+                    return String(value) === expected;
+                };
+            }
+            return (node) => node.type === token;
+        });
+        return (node) => predicates.some((p) => p(node));
+    }
+    if (isSelectionLike(input)) {
+        const ids = new Set(input.ids());
+        return (node) => ids.has(node.id);
+    }
+    if (isBlockNode(input)) {
+        return (node) => node.id === input.id;
+    }
+    const descriptor = input;
+    return (node) => {
+        if (descriptor.ids && !descriptor.ids.includes(node.id))
+            return false;
+        if (descriptor.types && !descriptor.types.includes(node.type))
+            return false;
+        if (descriptor.bttIds && !descriptor.bttIds.includes(node.bttId ?? ''))
+            return false;
+        if (descriptor.attrs) {
+            for (const [k, v] of Object.entries(descriptor.attrs)) {
+                const current = getPathValue(node, k);
+                if (current !== v)
+                    return false;
+            }
+        }
+        if (descriptor.hasText !== undefined) {
+            const text = blockText(node);
+            if (typeof descriptor.hasText === 'string') {
+                if (!text.includes(descriptor.hasText))
+                    return false;
+            }
+            else if (!regexTest(text, descriptor.hasText)) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+function stripQuotes(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function isSelectionLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'ids' in value &&
+        typeof value.ids === 'function');
+}
+function isBlockNode(value) {
+    return typeof value === 'object' && value !== null && 'id' in value && 'type' in value && 'children' in value;
+}
+function getPathValue(target, path) {
+    if (!path)
+        return undefined;
+    const parts = path.split('.').filter((x) => x.length > 0);
+    let current = target;
+    for (const part of parts) {
+        if (typeof current !== 'object' || current === null) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function setPathValue(target, path, value) {
+    const parts = path.split('.').filter((x) => x.length > 0);
+    if (parts.length === 0 || typeof target !== 'object' || target === null)
+        return;
+    let cursor = target;
+    for (let i = 0; i < parts.length - 1; i += 1) {
+        const key = parts[i];
+        if (!key)
+            continue;
+        const current = cursor[key];
+        if (typeof current === 'object' && current !== null) {
+            cursor = current;
+            continue;
+        }
+        const next = {};
+        cursor[key] = next;
+        cursor = next;
+    }
+    const tail = parts[parts.length - 1];
+    if (!tail)
+        return;
+    cursor[tail] = value;
+}
+function deletePathValue(target, path) {
+    const parts = path.split('.').filter((x) => x.length > 0);
+    if (parts.length === 0 || typeof target !== 'object' || target === null)
+        return;
+    let cursor = target;
+    for (let i = 0; i < parts.length - 1; i += 1) {
+        const key = parts[i];
+        if (!key)
+            return;
+        const current = cursor[key];
+        if (typeof current !== 'object' || current === null) {
+            return;
+        }
+        cursor = current;
+    }
+    const tail = parts[parts.length - 1];
+    if (!tail)
+        return;
+    delete cursor[tail];
+}
+function getSiblingContext(model, block) {
+    if (block.parentId) {
+        const parent = model.blocks[block.parentId];
+        if (!parent)
+            return null;
+        const idx = parent.children.indexOf(block.id);
+        if (idx < 0)
+            return null;
+        return { list: parent.children, index: idx };
+    }
+    if (isDocument(model)) {
+        if (block.id === model.rootId) {
+            return null;
+        }
+        const root = model.blocks[model.rootId];
+        if (!root)
+            return null;
+        const idx = root.children.indexOf(block.id);
+        if (idx < 0)
+            return null;
+        return { list: root.children, index: idx };
+    }
+    const idx = model.topLevel.indexOf(block.id);
+    if (idx < 0)
+        return null;
+    return { list: model.topLevel, index: idx };
+}
+function gatherDescendantIds(model, id) {
+    const out = [];
+    const stack = [id];
+    while (stack.length > 0) {
+        const currentId = stack.pop();
+        if (!currentId)
+            continue;
+        const node = model.blocks[currentId];
+        if (!node)
+            continue;
+        for (let i = node.children.length - 1; i >= 0; i -= 1) {
+            const childId = node.children[i];
+            if (!childId)
+                continue;
+            out.push(childId);
+            stack.push(childId);
+        }
+    }
+    return out;
+}
+function removeSubtree(model, rootId) {
+    const removed = [rootId, ...gatherDescendantIds(model, rootId)];
+    const root = model.blocks[rootId];
+    if (!root)
+        return [];
+    const sibling = getSiblingContext(model, root);
+    if (sibling) {
+        sibling.list.splice(sibling.index, 1);
+    }
+    for (const id of removed) {
+        delete model.blocks[id];
+    }
+    return removed;
+}
+function asNodeList(input) {
+    return Array.isArray(input) ? input : [input];
+}
+function materializeInsertionNodes(state, nodes, parentId) {
+    const out = [];
+    for (const node of asNodeList(nodes)) {
+        const cloned = deepClone(node);
+        cloned.id = nextBlockId(state);
+        cloned.parentId = parentId;
+        cloned.children = [];
+        out.push(cloned);
+    }
+    return out;
+}
+function textualInlineFromText(state, text) {
+    return {
+        id: nextInlineId(state),
+        kind: 'text_run',
+        marks: {
+            bold: false,
+            italic: false,
+            strikethrough: false,
+            underline: false,
+            inlineCode: false,
+        },
+        text,
+    };
+}
+function advanceStringIndex(input, index, unicode) {
+    if (!unicode)
+        return index + 1;
+    if (index < 0 || index >= input.length)
+        return index + 1;
+    const first = input.charCodeAt(index);
+    if (first < 0xd800 || first > 0xdbff || index + 1 >= input.length) {
+        return index + 1;
+    }
+    const second = input.charCodeAt(index + 1);
+    if (second < 0xdc00 || second > 0xdfff) {
+        return index + 1;
+    }
+    return index + 2;
+}
+function collectRegexMatches(text, pattern, maxMatches = Number.POSITIVE_INFINITY) {
+    if (maxMatches <= 0) {
+        return [];
+    }
+    const matches = [];
+    const flags = pattern.global ? pattern.flags : pattern.flags.replace(/g/g, '');
+    const probe = new RegExp(pattern.source, flags);
+    if (!pattern.global) {
+        const found = probe.exec(text);
+        if (!found)
+            return [];
+        return [
+            {
+                match: found[0],
+                captures: found.slice(1).map((item) => (item === undefined ? undefined : String(item))),
+                ...(found.groups ? { namedGroups: { ...found.groups } } : {}),
+                start: found.index,
+                end: found.index + found[0].length,
+            },
+        ];
+    }
+    while (matches.length < maxMatches) {
+        const found = probe.exec(text);
+        if (!found)
+            break;
+        matches.push({
+            match: found[0],
+            captures: found.slice(1).map((item) => (item === undefined ? undefined : String(item))),
+            ...(found.groups ? { namedGroups: { ...found.groups } } : {}),
+            start: found.index,
+            end: found.index + found[0].length,
+        });
+        if (found[0].length === 0) {
+            probe.lastIndex = advanceStringIndex(text, probe.lastIndex, probe.unicode);
+        }
+    }
+    return matches;
+}
+function expandReplacementTemplate(template, found, input) {
+    let out = '';
+    for (let i = 0; i < template.length; i += 1) {
+        const ch = template[i];
+        if (ch !== '$' || i + 1 >= template.length) {
+            out += ch;
+            continue;
+        }
+        const next = template[i + 1] ?? '';
+        if (next === '$') {
+            out += '$';
+            i += 1;
+            continue;
+        }
+        if (next === '&') {
+            out += found.match;
+            i += 1;
+            continue;
+        }
+        if (next === '`') {
+            out += input.slice(0, found.start);
+            i += 1;
+            continue;
+        }
+        if (next === "'") {
+            out += input.slice(found.end);
+            i += 1;
+            continue;
+        }
+        if (next === '<') {
+            const close = template.indexOf('>', i + 2);
+            if (close < 0) {
+                out += '$<';
+                i += 1;
+                continue;
+            }
+            const name = template.slice(i + 2, close);
+            if (found.namedGroups) {
+                out += found.namedGroups[name] ?? '';
+            }
+            else {
+                out += `$<${name}>`;
+            }
+            i = close;
+            continue;
+        }
+        if (next >= '0' && next <= '9') {
+            let consumed = 1;
+            let captureText = null;
+            if (next !== '0') {
+                const one = Number(next);
+                const next2 = template[i + 2];
+                if (next2 && next2 >= '0' && next2 <= '9') {
+                    const two = Number(`${next}${next2}`);
+                    if (two > 0 && two <= found.captures.length) {
+                        captureText = found.captures[two - 1] ?? '';
+                        consumed = 2;
+                    }
+                }
+                if (captureText === null && one > 0 && one <= found.captures.length) {
+                    captureText = found.captures[one - 1] ?? '';
+                    consumed = 1;
+                }
+            }
+            if (captureText !== null) {
+                out += captureText;
+            }
+            else {
+                out += `$${next}`;
+            }
+            i += consumed;
+            continue;
+        }
+        out += `$${next}`;
+        i += 1;
+    }
+    return out;
+}
+function resolveReplacementText(source, found, replacement) {
+    if (typeof replacement === 'function') {
+        const callback = replacement;
+        const args = [found.match, ...found.captures, found.start, source];
+        if (found.namedGroups) {
+            args.push(found.namedGroups);
+        }
+        return String(callback(...args));
+    }
+    return expandReplacementTemplate(replacement, found, source);
+}
+function marksEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function marksAtIndex(slices, index) {
+    if (slices.length === 0) {
+        return {
+            bold: false,
+            italic: false,
+            strikethrough: false,
+            underline: false,
+            inlineCode: false,
+        };
+    }
+    for (const slice of slices) {
+        if (index >= slice.start && index < slice.end) {
+            return deepClone(slice.run.marks);
+        }
+    }
+    const first = slices[0];
+    if (!first) {
+        return {
+            bold: false,
+            italic: false,
+            strikethrough: false,
+            underline: false,
+            inlineCode: false,
+        };
+    }
+    if (index <= first.start) {
+        return deepClone(first.run.marks);
+    }
+    const last = slices[slices.length - 1];
+    if (!last) {
+        return deepClone(first.run.marks);
+    }
+    return deepClone(last.run.marks);
+}
+function appendSourceSegments(slices, from, to, out) {
+    if (to <= from)
+        return;
+    for (const slice of slices) {
+        const left = Math.max(from, slice.start);
+        const right = Math.min(to, slice.end);
+        if (left >= right)
+            continue;
+        const part = slice.text.slice(left - slice.start, right - slice.start);
+        if (part.length === 0)
+            continue;
+        out.push({
+            text: part,
+            marks: deepClone(slice.run.marks),
+        });
+    }
+}
+function mergeSegments(segments) {
+    const out = [];
+    for (const segment of segments) {
+        if (segment.text.length === 0)
+            continue;
+        const prev = out[out.length - 1];
+        if (prev && marksEqual(prev.marks, segment.marks)) {
+            prev.text += segment.text;
+            continue;
+        }
+        out.push({
+            text: segment.text,
+            marks: deepClone(segment.marks),
+        });
+    }
+    return out;
+}
+function replaceTextRunCluster(state, cluster, pattern, replacement, maxMatches) {
+    if (maxMatches <= 0) {
+        return {
+            changed: false,
+            matchCount: 0,
+            inlines: cluster.map((inline) => deepClone(inline)),
+        };
+    }
+    const slices = [];
+    let cursor = 0;
+    for (const run of cluster) {
+        const text = run.text ?? '';
+        slices.push({
+            run,
+            text,
+            start: cursor,
+            end: cursor + text.length,
+        });
+        cursor += text.length;
+    }
+    const source = slices.map((slice) => slice.text).join('');
+    if (source.length === 0) {
+        return {
+            changed: false,
+            matchCount: 0,
+            inlines: cluster.map((inline) => deepClone(inline)),
+        };
+    }
+    const matches = collectRegexMatches(source, pattern, maxMatches);
+    if (matches.length === 0) {
+        return {
+            changed: false,
+            matchCount: 0,
+            inlines: cluster.map((inline) => deepClone(inline)),
+        };
+    }
+    const segments = [];
+    let consumed = 0;
+    for (const found of matches) {
+        if (found.start < consumed) {
+            continue;
+        }
+        appendSourceSegments(slices, consumed, found.start, segments);
+        const nextText = resolveReplacementText(source, found, replacement);
+        if (nextText.length > 0) {
+            segments.push({
+                text: nextText,
+                marks: marksAtIndex(slices, found.start),
+            });
+        }
+        consumed = found.end;
+    }
+    appendSourceSegments(slices, consumed, source.length, segments);
+    const merged = mergeSegments(segments);
+    const nextText = merged.map((item) => item.text).join('');
+    if (nextText === source) {
+        return {
+            changed: false,
+            matchCount: 0,
+            inlines: cluster.map((inline) => deepClone(inline)),
+        };
+    }
+    const inlines = merged.map((segment) => ({
+        id: nextInlineId(state),
+        kind: 'text_run',
+        marks: deepClone(segment.marks),
+        text: segment.text,
+    }));
+    return {
+        changed: true,
+        matchCount: matches.length,
+        inlines,
+    };
+}
+function applyScopeReplaceToBlock(state, block, pattern, replacement) {
+    const sourceInlines = block.payload.inlines;
+    const nextInlines = [];
+    let changed = false;
+    let remaining = pattern.global ? Number.POSITIVE_INFINITY : 1;
+    let cluster = [];
+    const flushCluster = () => {
+        if (cluster.length === 0)
+            return;
+        if (remaining <= 0) {
+            nextInlines.push(...cluster.map((inline) => deepClone(inline)));
+            cluster = [];
+            return;
+        }
+        const result = replaceTextRunCluster(state, cluster, pattern, replacement, remaining);
+        nextInlines.push(...result.inlines);
+        if (result.changed) {
+            changed = true;
+        }
+        if (Number.isFinite(remaining)) {
+            remaining -= result.matchCount;
+        }
+        cluster = [];
+    };
+    for (const inline of sourceInlines) {
+        if (inline.kind === 'text_run') {
+            cluster.push(inline);
+            continue;
+        }
+        flushCluster();
+        nextInlines.push(deepClone(inline));
+    }
+    flushCluster();
+    if (!changed) {
+        return false;
+    }
+    block.payload.inlines = nextInlines;
+    return true;
+}
+class LASTJQSelectionImpl {
+    ctx;
+    selectedIds;
+    constructor(ctx, ids) {
+        this.ctx = ctx;
+        this.selectedIds = uniqueOrdered(ids);
+    }
+    create(ids) {
+        return new LASTJQSelectionImpl(this.ctx, ids);
+    }
+    nodesTyped() {
+        const out = [];
+        for (const id of this.selectedIds) {
+            const node = this.ctx.state.model.blocks[id];
+            if (!node)
+                continue;
+            out.push(node);
+        }
+        return out;
+    }
+    filteredIds(selector) {
+        const matcher = matcherFromSelector(selector);
+        const out = [];
+        this.nodesTyped().forEach((node, idx) => {
+            if (matcher(node, idx)) {
+                out.push(node.id);
+            }
+        });
+        return out;
+    }
+    get() {
+        return this.nodesTyped();
+    }
+    toArray() {
+        return this.get();
+    }
+    ids() {
+        return [...this.selectedIds];
+    }
+    length() {
+        return this.get().length;
+    }
+    isEmpty() {
+        return this.length() === 0;
+    }
+    each(fn) {
+        this.get().forEach((node, idx) => fn(idx, node));
+        return this;
+    }
+    map(fn) {
+        return this.get().map((node, idx) => fn(idx, node));
+    }
+    find(selector) {
+        const matcher = matcherFromSelector(selector);
+        const model = this.ctx.state.model;
+        const out = [];
+        for (const id of this.selectedIds) {
+            const descendants = gatherDescendantIds(model, id);
+            for (const descendantId of descendants) {
+                const node = model.blocks[descendantId];
+                if (!node)
+                    continue;
+                if (matcher(node, out.length)) {
+                    out.push(descendantId);
+                }
+            }
+        }
+        return this.create(out);
+    }
+    filter(selector) {
+        if (typeof selector === 'function') {
+            const ids = this.get()
+                .filter((node, idx) => selector(idx, node))
+                .map((node) => node.id);
+            return this.create(ids);
+        }
+        return this.create(this.filteredIds(selector));
+    }
+    not(selector) {
+        const matcher = matcherFromSelector(selector);
+        const ids = this.get()
+            .filter((node, idx) => !matcher(node, idx))
+            .map((node) => node.id);
+        return this.create(ids);
+    }
+    is(selector) {
+        const matcher = matcherFromSelector(selector);
+        return this.get().some((node, idx) => matcher(node, idx));
+    }
+    has(selector) {
+        const matcher = matcherFromSelector(selector);
+        const model = this.ctx.state.model;
+        const ids = [];
+        for (const id of this.selectedIds) {
+            const descendantIds = gatherDescendantIds(model, id);
+            let matched = false;
+            for (const descendantId of descendantIds) {
+                const node = model.blocks[descendantId];
+                if (!node)
+                    continue;
+                if (matcher(node, 0)) {
+                    matched = true;
+                    break;
+                }
+            }
+            if (matched) {
+                ids.push(id);
+            }
+        }
+        return this.create(ids);
+    }
+    byType(...types) {
+        const set = new Set(types);
+        const ids = this.get()
+            .filter((node) => set.has(node.type))
+            .map((node) => node.id);
+        return this.create(ids);
+    }
+    byId(...ids) {
+        const set = new Set(ids);
+        const out = this.selectedIds.filter((id) => set.has(id));
+        return this.create(out);
+    }
+    byBttId(...bttIds) {
+        const set = new Set(bttIds);
+        const out = this.get()
+            .filter((node) => set.has(node.bttId ?? ''))
+            .map((node) => node.id);
+        return this.create(out);
+    }
+    parent(selector) {
+        const parents = [];
+        for (const node of this.get()) {
+            if (node.parentId) {
+                parents.push(node.parentId);
+            }
+            else if (isDocument(this.ctx.state.model)) {
+                const doc = this.ctx.state.model;
+                if (node.id !== doc.rootId) {
+                    parents.push(doc.rootId);
+                }
+            }
+        }
+        return this.create(parents).filter(selector);
+    }
+    parents(selector) {
+        const model = this.ctx.state.model;
+        const out = [];
+        for (const node of this.get()) {
+            let cursor = node.parentId;
+            while (cursor) {
+                out.push(cursor);
+                const parent = model.blocks[cursor];
+                cursor = parent?.parentId ?? null;
+            }
+            if (!node.parentId && isDocument(model) && node.id !== model.rootId) {
+                out.push(model.rootId);
+            }
+        }
+        return this.create(out).filter(selector);
+    }
+    children(selector) {
+        const out = [];
+        for (const node of this.get()) {
+            out.push(...node.children);
+        }
+        return this.create(out).filter(selector);
+    }
+    descendants(selector) {
+        const model = this.ctx.state.model;
+        const out = [];
+        for (const id of this.selectedIds) {
+            out.push(...gatherDescendantIds(model, id));
+        }
+        return this.create(out).filter(selector);
+    }
+    siblings(selector) {
+        const model = this.ctx.state.model;
+        const out = [];
+        for (const node of this.get()) {
+            const ctx = getSiblingContext(model, node);
+            if (!ctx)
+                continue;
+            for (const siblingId of ctx.list) {
+                if (siblingId === node.id)
+                    continue;
+                out.push(siblingId);
+            }
+        }
+        return this.create(out).filter(selector);
+    }
+    next(selector) {
+        const model = this.ctx.state.model;
+        const out = [];
+        for (const node of this.get()) {
+            const sibling = getSiblingContext(model, node);
+            if (!sibling)
+                continue;
+            const candidate = sibling.list[sibling.index + 1];
+            if (candidate)
+                out.push(candidate);
+        }
+        return this.create(out).filter(selector);
+    }
+    prev(selector) {
+        const model = this.ctx.state.model;
+        const out = [];
+        for (const node of this.get()) {
+            const sibling = getSiblingContext(model, node);
+            if (!sibling)
+                continue;
+            const candidate = sibling.list[sibling.index - 1];
+            if (candidate)
+                out.push(candidate);
+        }
+        return this.create(out).filter(selector);
+    }
+    closest(selector) {
+        const matcher = matcherFromSelector(selector);
+        const model = this.ctx.state.model;
+        const out = [];
+        for (const node of this.get()) {
+            let cursor = node;
+            while (cursor) {
+                if (matcher(cursor, 0)) {
+                    out.push(cursor.id);
+                    break;
+                }
+                if (!cursor.parentId) {
+                    if (isDocument(model) && cursor.id !== model.rootId) {
+                        cursor = model.blocks[model.rootId];
+                        continue;
+                    }
+                    break;
+                }
+                cursor = model.blocks[cursor.parentId];
+            }
+        }
+        return this.create(out);
+    }
+    eq(index) {
+        const arr = this.get();
+        const normalized = index >= 0 ? index : arr.length + index;
+        if (normalized < 0 || normalized >= arr.length) {
+            return this.create([]);
+        }
+        const node = arr[normalized];
+        if (!node) {
+            return this.create([]);
+        }
+        return this.create([node.id]);
+    }
+    first() {
+        return this.eq(0);
+    }
+    last() {
+        return this.eq(-1);
+    }
+    slice(start, end) {
+        const ids = this.get()
+            .slice(start, end)
+            .map((node) => node.id);
+        return this.create(ids);
+    }
+    contains(text) {
+        const ids = this.get()
+            .filter((node) => blockText(node).includes(text))
+            .map((node) => node.id);
+        return this.create(ids);
+    }
+    matches(pattern) {
+        const ids = this.get()
+            .filter((node) => regexTest(blockText(node), pattern))
+            .map((node) => node.id);
+        return this.create(ids);
+    }
+    text(value) {
+        const nodes = this.get();
+        if (value === undefined) {
+            return nodes.map((node) => blockText(node)).join('');
+        }
+        ensureTxn(this.ctx.state);
+        nodes.forEach((node, idx) => {
+            if (!isTextualBlockNode(node))
+                return;
+            const old = blockText(node);
+            const next = typeof value === 'function' ? value(idx, old) : value;
+            node.payload.inlines = next.length === 0 ? [] : [textualInlineFromText(this.ctx.state, next)];
+        });
+        this.ctx.state.stagedOps.push({
+            kind: 'text_set',
+            targets: nodes.map((n) => n.id),
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    replaceText(pattern, replacement) {
+        const nodes = this.get();
+        ensureTxn(this.ctx.state);
+        for (const node of nodes) {
+            if (!isTextualBlockNode(node))
+                continue;
+            applyScopeReplaceToBlock(this.ctx.state, node, pattern, replacement);
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'text_replace',
+            targets: nodes.map((n) => n.id),
+            pattern: pattern.source,
+            flags: pattern.flags,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    inlines(value) {
+        const nodes = this.get();
+        if (value === undefined) {
+            const out = [];
+            for (const node of nodes) {
+                if (!isTextualBlockNode(node))
+                    continue;
+                out.push(...node.payload.inlines);
+            }
+            return out;
+        }
+        ensureTxn(this.ctx.state);
+        nodes.forEach((node, idx) => {
+            if (!isTextualBlockNode(node))
+                return;
+            const old = node.payload.inlines;
+            const nextRaw = typeof value === 'function' ? value(idx, old) : value;
+            node.payload.inlines = nextRaw.map((inline) => {
+                const cloned = deepClone(inline);
+                if (!cloned.id) {
+                    cloned.id = nextInlineId(this.ctx.state);
+                }
+                return cloned;
+            });
+        });
+        this.ctx.state.stagedOps.push({
+            kind: 'inlines_set',
+            targets: nodes.map((n) => n.id),
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    attr(name, value) {
+        const nodes = this.get();
+        const first = nodes[0];
+        if (value === undefined) {
+            return first ? getPathValue(first, `selector.attrs.${name}`) : undefined;
+        }
+        ensureTxn(this.ctx.state);
+        nodes.forEach((node, idx) => {
+            const oldValue = getPathValue(node, `selector.attrs.${name}`);
+            const nextValue = typeof value === 'function' ? value(idx, oldValue) : value;
+            if (!node.selector) {
+                node.selector = {};
+            }
+            if (!node.selector.attrs) {
+                node.selector.attrs = {};
+            }
+            node.selector.attrs[name] = nextValue;
+        });
+        this.ctx.state.stagedOps.push({
+            kind: 'attr_set',
+            targets: nodes.map((n) => n.id),
+            name,
+        });
+        return this;
+    }
+    removeAttr(name) {
+        const nodes = this.get();
+        ensureTxn(this.ctx.state);
+        nodes.forEach((node) => {
+            if (!node.selector?.attrs)
+                return;
+            delete node.selector.attrs[name];
+            if (Object.keys(node.selector.attrs).length === 0) {
+                delete node.selector.attrs;
+            }
+            if (Object.keys(node.selector).length === 0) {
+                delete node.selector;
+            }
+        });
+        this.ctx.state.stagedOps.push({
+            kind: 'attr_remove',
+            targets: nodes.map((n) => n.id),
+            name,
+        });
+        return this;
+    }
+    prop(name, value) {
+        const nodes = this.get();
+        const first = nodes[0];
+        if (value === undefined) {
+            return first ? getPathValue(first, name) : undefined;
+        }
+        ensureTxn(this.ctx.state);
+        nodes.forEach((node, idx) => {
+            const oldValue = getPathValue(node, name);
+            const nextValue = typeof value === 'function' ? value(idx, oldValue) : value;
+            setPathValue(node, name, nextValue);
+        });
+        this.ctx.state.stagedOps.push({
+            kind: 'prop_set',
+            targets: nodes.map((n) => n.id),
+            name,
+        });
+        return this;
+    }
+    css(nameOrPatch, value) {
+        const nodes = this.get();
+        const first = nodes[0];
+        if (typeof nameOrPatch === 'string' && value === undefined) {
+            if (!first || !isTextualBlockNode(first))
+                return undefined;
+            return getPathValue(first.payload.style, nameOrPatch);
+        }
+        ensureTxn(this.ctx.state);
+        if (typeof nameOrPatch === 'string') {
+            nodes.forEach((node, idx) => {
+                if (!isTextualBlockNode(node))
+                    return;
+                const oldValue = getPathValue(node.payload.style, nameOrPatch);
+                const nextValue = typeof value === 'function' ? value(idx, oldValue) : value;
+                setPathValue(node.payload.style, nameOrPatch, nextValue);
+            });
+            this.ctx.state.stagedOps.push({
+                kind: 'style_set',
+                targets: nodes.map((n) => n.id),
+                name: nameOrPatch,
+            });
+            ensureIndexes(this.ctx.state);
+            return this;
+        }
+        const patch = nameOrPatch;
+        nodes.forEach((node) => {
+            if (!isTextualBlockNode(node))
+                return;
+            for (const [k, v] of Object.entries(patch)) {
+                setPathValue(node.payload.style, k, v);
+            }
+        });
+        this.ctx.state.stagedOps.push({
+            kind: 'style_set',
+            targets: nodes.map((n) => n.id),
+            name: '[patch]',
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    append(node) {
+        const targets = this.get();
+        ensureTxn(this.ctx.state);
+        for (const target of targets) {
+            const inserted = materializeInsertionNodes(this.ctx.state, node, target.id);
+            for (const child of inserted) {
+                this.ctx.state.model.blocks[child.id] = child;
+                target.children.push(child.id);
+            }
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'insert',
+            mode: 'append',
+            targets: targets.map((x) => x.id),
+            count: asNodeList(node).length,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    prepend(node) {
+        const targets = this.get();
+        ensureTxn(this.ctx.state);
+        for (const target of targets) {
+            const inserted = materializeInsertionNodes(this.ctx.state, node, target.id);
+            for (const child of inserted) {
+                this.ctx.state.model.blocks[child.id] = child;
+            }
+            target.children = [...inserted.map((x) => x.id), ...target.children];
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'insert',
+            mode: 'prepend',
+            targets: targets.map((x) => x.id),
+            count: asNodeList(node).length,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    before(node) {
+        const targets = this.get();
+        ensureTxn(this.ctx.state);
+        for (const target of targets) {
+            const sibling = getSiblingContext(this.ctx.state.model, target);
+            if (!sibling)
+                continue;
+            const parentId = target.parentId;
+            const inserted = materializeInsertionNodes(this.ctx.state, node, parentId);
+            for (const n of inserted) {
+                this.ctx.state.model.blocks[n.id] = n;
+            }
+            sibling.list.splice(sibling.index, 0, ...inserted.map((x) => x.id));
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'insert',
+            mode: 'before',
+            targets: targets.map((x) => x.id),
+            count: asNodeList(node).length,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    after(node) {
+        const targets = this.get();
+        ensureTxn(this.ctx.state);
+        for (const target of targets) {
+            const sibling = getSiblingContext(this.ctx.state.model, target);
+            if (!sibling)
+                continue;
+            const parentId = target.parentId;
+            const inserted = materializeInsertionNodes(this.ctx.state, node, parentId);
+            for (const n of inserted) {
+                this.ctx.state.model.blocks[n.id] = n;
+            }
+            sibling.list.splice(sibling.index + 1, 0, ...inserted.map((x) => x.id));
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'insert',
+            mode: 'after',
+            targets: targets.map((x) => x.id),
+            count: asNodeList(node).length,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    replaceWith(node) {
+        const targets = this.get();
+        ensureTxn(this.ctx.state);
+        for (const target of targets) {
+            const sibling = getSiblingContext(this.ctx.state.model, target);
+            if (!sibling)
+                continue;
+            const parentId = target.parentId;
+            const inserted = materializeInsertionNodes(this.ctx.state, node, parentId);
+            for (const n of inserted) {
+                this.ctx.state.model.blocks[n.id] = n;
+            }
+            sibling.list.splice(sibling.index, 1, ...inserted.map((x) => x.id));
+            const removedIds = gatherDescendantIds(this.ctx.state.model, target.id);
+            for (const removedId of [target.id, ...removedIds]) {
+                delete this.ctx.state.model.blocks[removedId];
+            }
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'insert',
+            mode: 'replace',
+            targets: targets.map((x) => x.id),
+            count: asNodeList(node).length,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    remove() {
+        const ids = this.ids();
+        ensureTxn(this.ctx.state);
+        for (const id of ids) {
+            if (!this.ctx.state.model.blocks[id])
+                continue;
+            if (isDocument(this.ctx.state.model) && id === this.ctx.state.model.rootId) {
+                this.ctx.state.warnings.push('skip removing document root page');
+                continue;
+            }
+            removeSubtree(this.ctx.state.model, id);
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'remove',
+            targets: ids,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    empty() {
+        const nodes = this.get();
+        ensureTxn(this.ctx.state);
+        for (const node of nodes) {
+            if (isTextualBlockNode(node)) {
+                node.payload.inlines = [];
+            }
+            for (const childId of [...node.children]) {
+                removeSubtree(this.ctx.state.model, childId);
+            }
+            node.children = [];
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'empty',
+            targets: nodes.map((n) => n.id),
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+    clone(deep = true) {
+        const model = this.ctx.state.model;
+        const targets = this.get();
+        ensureTxn(this.ctx.state);
+        const clonedIds = [];
+        const cloneOne = (sourceId, parentId) => {
+            const source = model.blocks[sourceId];
+            if (!source)
+                return null;
+            const cloned = deepClone(source);
+            cloned.id = nextBlockId(this.ctx.state);
+            cloned.parentId = parentId;
+            cloned.children = [];
+            model.blocks[cloned.id] = cloned;
+            if (deep) {
+                for (const childId of source.children) {
+                    const childCloneId = cloneOne(childId, cloned.id);
+                    if (childCloneId)
+                        cloned.children.push(childCloneId);
+                }
+            }
+            return cloned.id;
+        };
+        for (const target of targets) {
+            const sibling = getSiblingContext(model, target);
+            if (!sibling)
+                continue;
+            const rootCloneId = cloneOne(target.id, target.parentId);
+            if (!rootCloneId)
+                continue;
+            sibling.list.splice(sibling.index + 1, 0, rootCloneId);
+            clonedIds.push(rootCloneId);
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'clone',
+            targets: targets.map((x) => x.id),
+            deep,
+        });
+        ensureIndexes(this.ctx.state);
+        return this.create(clonedIds);
+    }
+    detach() {
+        const ids = this.ids();
+        ensureTxn(this.ctx.state);
+        for (const id of ids) {
+            const block = this.ctx.state.model.blocks[id];
+            if (!block)
+                continue;
+            if (isDocument(this.ctx.state.model) && id === this.ctx.state.model.rootId) {
+                this.ctx.state.warnings.push('skip detaching document root page');
+                continue;
+            }
+            removeSubtree(this.ctx.state.model, id);
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'detach',
+            targets: ids,
+        });
+        ensureIndexes(this.ctx.state);
+        return this;
+    }
+}
+class LASTJQScopeSelectionImpl {
+    ctx;
+    scopeIds;
+    constructor(ctx, ids) {
+        this.ctx = ctx;
+        this.scopeIds = uniqueOrdered(ids);
+    }
+    create(ids) {
+        return new LASTJQScopeSelectionImpl(this.ctx, ids);
+    }
+    ids() {
+        return [...this.scopeIds];
+    }
+    byBlockId(blockId) {
+        const next = this.scopeIds.filter((scopeId) => {
+            const scope = this.ctx.state.model.indexes.textScopes[scopeId];
+            return scope?.blockId === blockId;
+        });
+        return this.create(next);
+    }
+    matches(pattern) {
+        const next = this.scopeIds.filter((scopeId) => {
+            const scope = this.ctx.state.model.indexes.textScopes[scopeId];
+            if (!scope)
+                return false;
+            return regexTest(scope.normalizedText, pattern);
+        });
+        return this.create(next);
+    }
+    replace(find, replacement) {
+        ensureTxn(this.ctx.state);
+        for (const scopeId of this.scopeIds) {
+            const scope = this.ctx.state.model.indexes.textScopes[scopeId];
+            if (!scope)
+                continue;
+            const block = this.ctx.state.model.blocks[scope.blockId];
+            if (!block || !isTextualBlockNode(block))
+                continue;
+            applyScopeReplaceToBlock(this.ctx.state, block, find, replacement);
+        }
+        this.ctx.state.stagedOps.push({
+            kind: 'scope_replace',
+            scopes: [...this.scopeIds],
+            pattern: find.source,
+            flags: find.flags,
+        });
+        ensureIndexes(this.ctx.state);
+        return createDollarProxy(this.ctx);
+    }
+}
+function buildAllIds(model) {
+    return Object.keys(model.blocks);
+}
+function selectIds(model, selector) {
+    const matcher = matcherFromSelector(selector);
+    const out = [];
+    const all = buildAllIds(model);
+    all.forEach((id, idx) => {
+        const node = model.blocks[id];
+        if (!node)
+            return;
+        if (matcher(node, idx)) {
+            out.push(id);
+        }
+    });
+    return out;
+}
+function operationToChange(op) {
+    switch (op.kind) {
+        case 'scope_replace':
+            return {
+                op: op.kind,
+                targets: [],
+                detail: {
+                    scopes: op.scopes,
+                    pattern: op.pattern,
+                    flags: op.flags,
+                },
+            };
+        case 'insert':
+            return {
+                op: op.kind,
+                targets: op.targets,
+                detail: {
+                    mode: op.mode,
+                    count: op.count,
+                },
+            };
+        case 'clone':
+            return {
+                op: op.kind,
+                targets: op.targets,
+                detail: {
+                    deep: op.deep,
+                },
+            };
+        case 'attr_set':
+        case 'attr_remove':
+        case 'prop_set':
+        case 'style_set':
+            return {
+                op: op.kind,
+                targets: op.targets,
+                detail: {
+                    name: op.name,
+                },
+            };
+        case 'text_replace':
+            return {
+                op: op.kind,
+                targets: op.targets,
+                detail: {
+                    pattern: op.pattern,
+                    flags: op.flags,
+                },
+            };
+        case 'plugin':
+            return {
+                op: op.kind,
+                targets: op.targets,
+                detail: {
+                    name: op.name,
+                    ...op.detail,
+                },
+            };
+        default:
+            return {
+                op: op.kind,
+                targets: 'targets' in op ? op.targets : [],
+            };
+    }
+}
+function makePlan(state) {
+    return {
+        schema: 'LASTMutationPlan',
+        version: '1.0.0',
+        docId: state.model.id,
+        createdAt: new Date().toISOString(),
+        ops: deepClone(state.stagedOps),
+    };
+}
+function createDollarProxy(ctx) {
+    const callable = ((selector) => {
+        const ids = selectIds(ctx.state.model, selector);
+        return new LASTJQSelectionImpl(ctx, ids);
+    });
+    Object.defineProperty(callable, 'model', {
+        enumerable: true,
+        configurable: false,
+        get: () => ctx.state.model,
+    });
+    const pluginRegistry = {
+        extend(methods) {
+            for (const [name, fn] of Object.entries(methods)) {
+                if (typeof fn !== 'function')
+                    continue;
+                Object.defineProperty(LASTJQSelectionImpl.prototype, name, {
+                    configurable: true,
+                    enumerable: false,
+                    writable: true,
+                    value: function pluginInvoker(...args) {
+                        const result = fn.apply(this, args);
+                        const selection = this;
+                        const selectionIds = selection.ids();
+                        const op = {
+                            kind: 'plugin',
+                            name,
+                            targets: selectionIds,
+                        };
+                        ensureTxn(ctx.state);
+                        ctx.state.stagedOps.push(op);
+                        return result;
+                    },
+                });
+            }
+        },
+    };
+    Object.defineProperty(callable, 'fn', {
+        enumerable: true,
+        configurable: false,
+        writable: false,
+        value: pluginRegistry,
+    });
+    callable.begin = () => {
+        ctx.state.checkpoint = deepClone(ctx.state.model);
+        ctx.state.stagedOps = [];
+        ctx.state.warnings = [];
+        ctx.state.active = true;
+        return callable;
+    };
+    callable.plan = () => makePlan(ctx.state);
+    callable.commit = (options) => {
+        const shouldRebuild = options?.rebuildIndexes ?? ctx.defaultRebuildIndexesOnCommit;
+        try {
+            const plan = makePlan(ctx.state);
+            ctx.state.hooks?.beforeCommit?.(plan);
+            if (shouldRebuild) {
+                ensureIndexes(ctx.state);
+            }
+            const result = {
+                ok: true,
+                next: deepClone(ctx.state.model),
+                indexes: deepClone(ctx.state.model.indexes),
+                changes: ctx.state.stagedOps.map(operationToChange),
+                warnings: [...ctx.state.warnings],
+            };
+            ctx.state.active = false;
+            ctx.state.checkpoint = null;
+            ctx.state.stagedOps = [];
+            ctx.state.warnings = [];
+            ctx.state.hooks?.afterCommit?.(result);
+            return result;
+        }
+        catch (error) {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            ctx.state.hooks?.onError?.(normalized);
+            if (ctx.state.checkpoint) {
+                ctx.state.model = deepClone(ctx.state.checkpoint);
+            }
+            ctx.state.active = false;
+            ctx.state.checkpoint = null;
+            ctx.state.stagedOps = [];
+            ctx.state.warnings = [];
+            throw normalized;
+        }
+    };
+    callable.rollback = () => {
+        if (ctx.state.checkpoint) {
+            ctx.state.model = deepClone(ctx.state.checkpoint);
+            ensureIndexes(ctx.state);
+        }
+        ctx.state.active = false;
+        ctx.state.checkpoint = null;
+        ctx.state.stagedOps = [];
+        ctx.state.warnings = [];
+        return callable;
+    };
+    callable.byScope = (selector) => {
+        const allIds = Object.keys(ctx.state.model.indexes.textScopes);
+        let filtered = allIds;
+        if (selector?.blockId) {
+            filtered = filtered.filter((scopeId) => {
+                const scope = ctx.state.model.indexes.textScopes[scopeId];
+                return scope?.blockId === selector.blockId;
+            });
+        }
+        if (selector?.pattern) {
+            filtered = filtered.filter((scopeId) => {
+                const scope = ctx.state.model.indexes.textScopes[scopeId];
+                if (!scope)
+                    return false;
+                return selector.pattern?.test(scope.normalizedText) ?? false;
+            });
+        }
+        return new LASTJQScopeSelectionImpl(ctx, filtered);
+    };
+    return callable;
+}
+export function createLASTDollar(model, options) {
+    const base = deepClone(model);
+    base.indexes = rebuildLASTIndexes(base);
+    const seeds = seedNextCounters(base);
+    const state = {
+        original: deepClone(base),
+        model: base,
+        checkpoint: null,
+        stagedOps: [],
+        warnings: [],
+        active: false,
+        nextBlockCounter: seeds.block,
+        nextInlineCounter: seeds.inline,
+    };
+    const ctx = {
+        state,
+        defaultRebuildIndexesOnCommit: options?.rebuildIndexesOnCommit ?? true,
+    };
+    return createDollarProxy(ctx);
+}
+export function createLASTApi(model, options) {
+    const $ = createLASTDollar(model, options);
+    return {
+        get model() {
+            return $.model;
+        },
+        $,
+        compile() {
+            return $.plan();
+        },
+        commit(commitOptions) {
+            return $.commit(commitOptions);
+        },
+    };
+}