@aicayzer/inkkit 0.0.18 → 0.1.0

package/dist/tables.js

@@ -1,344 +0,0 @@
-import { editorLabels } from './labels.js';
-import { commandsCtx, editorViewCtx } from '@milkdown/kit/core';
-import { tableBlock, tableBlockConfig, } from '@milkdown/kit/component/table-block';
-import { insertTableCommand, exitTable, moveRowCommand, moveColCommand, } from '@milkdown/kit/preset/gfm';
-import { addRowAfter, addRowBefore, addColumnAfter, addColumnBefore, deleteRow, deleteColumn, deleteTable, goToNextCell, selectedRect, TableMap, isInTable, CellSelection, } from '@milkdown/kit/prose/tables';
-import { Fragment } from '@milkdown/kit/prose/model';
-import { closeHistory } from '@milkdown/kit/prose/history';
-import { keymap } from '@milkdown/kit/prose/keymap';
-import { $prose } from '@milkdown/kit/utils';
-import { clipboardText } from './clipboard.js';
-export const tableCommands = [
-    'insert',
-    'addRowBefore',
-    'addRowAfter',
-    'addColumnBefore',
-    'addColumnAfter',
-    'deleteRow',
-    'deleteColumn',
-    'deleteTable',
-    'alignLeft',
-    'alignCenter',
-    'alignRight',
-    'moveRowUp',
-    'moveRowDown',
-    'moveColumnLeft',
-    'moveColumnRight',
-    'sortRows',
-    'exit',
-];
-export function tableContext(state) {
-    if (!isInTable(state))
-        return undefined;
-    const rect = selectedRect(state);
-    return {
-        row: rect.top,
-        column: rect.left,
-        rows: rect.map.height,
-        columns: rect.map.width,
-    };
-}
-/** Checks the same default operations without dispatching a transaction. */
-export function tableAvailability(ctx) {
-    const view = ctx.get(editorViewCtx);
-    const state = view.state;
-    const commands = ctx.get(commandsCtx);
-    const available = Object.fromEntries(tableCommands.map((name) => [name, false]));
-    available.insert = commands.get(insertTableCommand.key)({ row: 3, col: 2 })(state);
-    const actions = {
-        addRowBefore,
-        addRowAfter,
-        addColumnBefore,
-        addColumnAfter,
-        deleteRow,
-        deleteColumn,
-        deleteTable,
-    };
-    for (const [name, action] of Object.entries(actions))
-        available[name] = action(state);
-    available.exit = commands.get(exitTable.key)()(state);
-    if (!isInTable(state))
-        return available;
-    const rect = selectedRect(state);
-    available.alignLeft = available.alignCenter = available.alignRight = true;
-    if (!editableTable(rect.table))
-        return available;
-    available.moveRowUp = rect.top > 1;
-    available.moveRowDown = rect.top > 0 && rect.bottom < rect.map.height;
-    available.moveColumnLeft = rect.left > 0;
-    available.moveColumnRight = rect.right < rect.map.width;
-    const body = [];
-    rect.table.forEach((row, _offset, index) => {
-        if (index)
-            body.push({ key: clipboardText(row.child(rect.left).content), index });
-    });
-    const sorted = [...body].sort((a, b) => compareCells(a.key, b.key, 'text', 'ascending') || a.index - b.index);
-    available.sortRows = sorted.some((row, index) => row !== body[index]);
-    return available;
-}
-const tableLabels = {
-    add_row: 'tableAddRow',
-    add_col: 'tableAddColumn',
-    delete_row: 'tableDeleteRow',
-    delete_col: 'tableDeleteColumn',
-    align_col_left: 'tableAlignLeft',
-    align_col_center: 'tableAlignCenter',
-    align_col_right: 'tableAlignRight',
-    col_drag_handle: 'tableMoveColumn',
-    row_drag_handle: 'tableMoveRow',
-};
-function tableButton(label) {
-    const span = document.createElement('span');
-    span.setAttribute('role', 'img');
-    span.setAttribute('aria-label', label);
-    span.textContent = label;
-    return span.outerHTML;
-}
-export const tablePlugins = [
-    moveRowCommand,
-    moveColCommand,
-    tableBlockConfig,
-    (ctx) => () => {
-        ctx.update(tableBlockConfig.key, (config) => ({
-            ...config,
-            renderButton: (type) => tableButton(editorLabels(ctx)[tableLabels[type]]),
-        }));
-    },
-    tableBlock,
-    $prose(() => keymap({ Tab: goToNextCell(1), 'Shift-Tab': goToNextCell(-1) })),
-].flat();
-export function tableCommand(ctx, command, options) {
-    const view = ctx.get(editorViewCtx);
-    const commands = ctx.get(commandsCtx);
-    if (command === 'insert') {
-        const row = options?.rows ?? 3, col = options?.columns ?? 2;
-        if (!Number.isInteger(row) ||
-            !Number.isInteger(col) ||
-            row < 1 ||
-            row > 100 ||
-            col < 1 ||
-            col > 100)
-            throw new RangeError('Table dimensions must be integers from 1 to 100');
-        return commands.call(insertTableCommand.key, { row, col });
-    }
-    if (command === 'exit')
-        return commands.call(exitTable.key);
-    if (command.startsWith('move') || command === 'sortRows')
-        return refineTable(view, command, options);
-    if (command === 'alignLeft' ||
-        command === 'alignCenter' ||
-        command === 'alignRight') {
-        if (!isInTable(view.state))
-            return false;
-        const rect = selectedRect(view.state), map = TableMap.get(rect.table);
-        const alignment = command === 'alignLeft'
-            ? 'left'
-            : command === 'alignRight'
-                ? 'right'
-                : 'center';
-        const tr = view.state.tr;
-        // GFM stores alignment on the header; apply it to the entire column so
-        // editing a body cell does not disappear when Markdown is saved.
-        const positions = new Set();
-        for (let row = 0; row < map.height; row++)
-            for (let col = rect.left; col < rect.right; col++)
-                positions.add(map.map[row * map.width + col]);
-        for (const offset of positions) {
-            const pos = rect.tableStart + offset, cell = tr.doc.nodeAt(pos);
-            tr.setNodeMarkup(pos, undefined, { ...cell.attrs, alignment });
-        }
-        view.dispatch(tr);
-        return true;
-    }
-    if (command === 'addRowBefore' || command === 'addRowAfter') {
-        if (!isInTable(view.state))
-            return false;
-        const { tableStart } = selectedRect(view.state);
-        const add = command === 'addRowBefore' ? addRowBefore : addRowAfter;
-        return add(view.state, (tr) => {
-            // GFM keeps alignment once per column, so a new row's cells take the
-            // header's; otherwise they read back aligned and the edit is refused.
-            const table = tr.doc.nodeAt(tableStart - 1);
-            const map = TableMap.get(table);
-            for (let row = 1; row < map.height; row++)
-                for (let col = 0; col < map.width; col++) {
-                    const offset = map.map[row * map.width + col];
-                    const cell = table.nodeAt(offset);
-                    const { alignment } = table.nodeAt(map.map[col]).attrs;
-                    if (cell.attrs.alignment !== alignment)
-                        tr.setNodeMarkup(tableStart + offset, undefined, {
-                            ...cell.attrs,
-                            alignment,
-                        });
-                }
-            view.dispatch(tr);
-        });
-    }
-    const actions = {
-        addColumnBefore,
-        addColumnAfter,
-        deleteRow,
-        deleteColumn,
-        deleteTable,
-    };
-    return actions[command](view.state, view.dispatch);
-}
-export function dispatchTableOperation(view, tr) {
-    view.dispatch(closeHistory(tr).scrollIntoView());
-    view.dispatch(closeHistory(view.state.tr).setMeta('addToHistory', false));
-}
-export function configureTableMovement(ctx, canEdit) {
-    const commands = ctx.get(commandsCtx);
-    for (const [key, rowMovement] of [
-        [moveRowCommand.key, true],
-        [moveColCommand.key, false],
-    ]) {
-        commands.remove(key);
-        commands.create(key, (options = {}) => () => {
-            const view = ctx.get(editorViewCtx);
-            if (!canEdit() ||
-                !view.editable ||
-                view.composing ||
-                !isInTable(view.state))
-                return false;
-            const rect = selectedRect(view.state);
-            const from = options.from ?? 0, to = options.to ?? 0;
-            const length = rowMovement ? rect.map.height : rect.map.width;
-            if (!editableTable(rect.table) ||
-                (options.pos != null && options.pos !== rect.tableStart) ||
-                !Number.isInteger(from) ||
-                !Number.isInteger(to) ||
-                from < 0 ||
-                to < 0 ||
-                from >= length ||
-                to >= length ||
-                from === to ||
-                (rowMovement && (from === 0 || to === 0)))
-                return false;
-            const rows = [];
-            rect.table.forEach((row) => rows.push(row));
-            if (rowMovement) {
-                const moved = rows.splice(from, 1)[0];
-                rows.splice(to, 0, moved);
-            }
-            else {
-                for (let index = 0; index < rows.length; index++) {
-                    const row = rows[index], cells = [];
-                    row.forEach((cell) => cells.push(cell));
-                    cells.splice(to, 0, cells.splice(from, 1)[0]);
-                    rows[index] = row.copy(Fragment.fromArray(cells));
-                }
-            }
-            const table = rect.table.copy(Fragment.fromArray(rows));
-            const tr = view.state.tr.replaceWith(rect.tableStart - 1, rect.tableStart - 1 + rect.table.nodeSize, table);
-            selectTableRectangle(tr, rect.tableStart, table, rowMovement ? to : 0, rowMovement ? 0 : to, rowMovement ? to + 1 : rect.map.height, rowMovement ? rect.map.width : to + 1);
-            dispatchTableOperation(view, tr);
-            return true;
-        });
-    }
-}
-export function editableTable(table) {
-    const map = TableMap.get(table);
-    if (map.problems?.length || map.width > 100 || map.height > 100)
-        return false;
-    let valid = table.firstChild?.type.name === 'table_header_row';
-    table.forEach((row, _offset, index) => {
-        valid &&= row.type.name === (index ? 'table_row' : 'table_header_row');
-        valid &&= row.childCount === map.width;
-        row.forEach((cell) => {
-            valid &&= cell.attrs.colspan === 1 && cell.attrs.rowspan === 1;
-        });
-    });
-    return Boolean(valid);
-}
-function refineTable(view, command, options) {
-    if (!isInTable(view.state))
-        return false;
-    const rect = selectedRect(view.state);
-    if (!editableTable(rect.table))
-        return false;
-    const rows = [];
-    rect.table.forEach((row) => rows.push(row));
-    let top = rect.top, bottom = rect.bottom, left = rect.left, right = rect.right;
-    if (command === 'sortRows') {
-        const column = options?.column ?? rect.left;
-        if (!Number.isInteger(column) || column < 0 || column >= rect.map.width)
-            throw new RangeError('Sort column must identify an existing table column');
-        const order = options?.order ?? 'ascending';
-        const comparison = options?.comparison ?? 'text';
-        if (!['ascending', 'descending'].includes(order))
-            throw new RangeError('Sort order must be ascending or descending');
-        if (!['text', 'number'].includes(comparison))
-            throw new RangeError('Sort comparison must be text or number');
-        const body = rows.slice(1).map((row, index) => ({
-            row,
-            index,
-            key: clipboardText(row.child(column).content),
-        }));
-        if (comparison === 'number' &&
-            body.some(({ key }) => {
-                const value = key.trim();
-                return value !== '' && decimalNumber(value) === undefined;
-            }))
-            throw new RangeError('Numeric sorting requires finite decimal values or blank cells');
-        body.sort((a, b) => compareCells(a.key, b.key, comparison, order) || a.index - b.index);
-        if (body.every(({ row }, index) => row === rows[index + 1]))
-            return false;
-        const activeIndex = top - 1;
-        rows.splice(1, rows.length - 1, ...body.map(({ row }) => row));
-        top =
-            top === 0 ? 0 : body.findIndex(({ index }) => index === activeIndex) + 1;
-        bottom = top + 1;
-    }
-    else if (command === 'moveRowUp' || command === 'moveRowDown') {
-        const up = command === 'moveRowUp';
-        if (top === 0 || (up ? top === 1 : bottom === rows.length))
-            return false;
-        const moved = rows.splice(top, bottom - top);
-        const destination = top + (up ? -1 : 1);
-        rows.splice(destination, 0, ...moved);
-        top = destination;
-        bottom += up ? -1 : 1;
-    }
-    else {
-        const backward = command === 'moveColumnLeft';
-        if (backward ? left === 0 : right === rect.map.width)
-            return false;
-        for (let index = 0; index < rows.length; index++) {
-            const row = rows[index];
-            const cells = [];
-            row.forEach((cell) => cells.push(cell));
-            const moved = cells.splice(left, right - left);
-            cells.splice(left + (backward ? -1 : 1), 0, ...moved);
-            rows[index] = row.copy(Fragment.fromArray(cells));
-        }
-        left += backward ? -1 : 1;
-        right += backward ? -1 : 1;
-    }
-    const table = rect.table.copy(Fragment.fromArray(rows));
-    const tr = view.state.tr.replaceWith(rect.tableStart - 1, rect.tableStart - 1 + rect.table.nodeSize, table);
-    selectTableRectangle(tr, rect.tableStart, table, top, left, bottom, right);
-    dispatchTableOperation(view, tr);
-    return true;
-}
-export function selectTableRectangle(tr, tableStart, table, top, left, bottom, right) {
-    const map = TableMap.get(table);
-    tr.setSelection(CellSelection.create(tr.doc, tableStart + map.map[top * map.width + left], tableStart + map.map[(bottom - 1) * map.width + right - 1]));
-}
-function compareCells(a, b, comparison, order) {
-    const x = a.trim(), y = b.trim();
-    if (!x || !y)
-        return x === y ? 0 : x ? -1 : 1;
-    const direction = order === 'ascending' ? 1 : -1;
-    const text = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
-    if (comparison === 'text')
-        return direction * text(a, b);
-    const nx = decimalNumber(x), ny = decimalNumber(y);
-    return direction * (nx < ny ? -1 : nx > ny ? 1 : 0);
-}
-function decimalNumber(value) {
-    return /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value) &&
-        Number.isFinite(Number(value))
-        ? Number(value)
-        : undefined;
-}

package/dist/tasks.d.ts

@@ -1,3 +0,0 @@
-import type { Ctx } from '@milkdown/kit/ctx';
-export declare const taskListPlugin: import("@milkdown/kit/utils").$Prose;
-export declare function toggleTaskList(ctx: Ctx): void;

package/dist/tasks.js

@@ -1,51 +0,0 @@
-import { commandsCtx, editorViewCtx } from '@milkdown/kit/core';
-import { wrapInBulletListCommand } from '@milkdown/kit/preset/commonmark';
-import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
-import { $prose } from '@milkdown/kit/utils';
-// A click on the task marker lands on the <li> itself, since the marker is a
-// pseudo-element; clicks inside the item's text land on its children.
-export const taskListPlugin = $prose(() => new Plugin({
-    key: new PluginKey('taskToggle'),
-    props: {
-        handleClickOn(view, _pos, node, nodePos, event) {
-            if (!view.editable)
-                return false;
-            if (node.type.name !== 'list_item' || node.attrs.checked == null)
-                return false;
-            const target = event.target;
-            if (!target.matches('li[data-item-type="task"]'))
-                return false;
-            view.dispatch(view.state.tr.setNodeMarkup(nodePos, undefined, {
-                ...node.attrs,
-                checked: !node.attrs.checked,
-            }));
-            return true;
-        },
-    },
-}));
-function listItemsInSelection(view) {
-    const { from, to } = view.state.selection;
-    const items = [];
-    view.state.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.type.name === 'list_item')
-            items.push({ pos, node });
-    });
-    return items;
-}
-export function toggleTaskList(ctx) {
-    const view = ctx.get(editorViewCtx);
-    let items = listItemsInSelection(view);
-    if (items.length === 0) {
-        ctx.get(commandsCtx).call(wrapInBulletListCommand.key);
-        items = listItemsInSelection(view);
-    }
-    const allTasks = items.every(({ node }) => node.attrs.checked != null);
-    let tr = view.state.tr;
-    for (const { pos, node } of items) {
-        tr = tr.setNodeMarkup(pos, undefined, {
-            ...node.attrs,
-            checked: allTasks ? null : (node.attrs.checked ?? false),
-        });
-    }
-    view.dispatch(tr);
-}

package/dist/text-ranges.d.ts

@@ -1,29 +0,0 @@
-import type { Node as ProseNode } from '@milkdown/kit/prose/model';
-import type { EditorView } from '@milkdown/kit/prose/view';
-import { type TextRect } from './types.js';
-export interface TextSpan {
-    from: number;
-    to: number;
-    start: number;
-    end: number;
-    kind: 'text' | 'break' | 'embed' | 'separator';
-}
-export interface TextProjection {
-    text: string;
-    spans: TextSpan[];
-}
-export declare function readableProjection(doc: ProseNode): TextProjection;
-export declare function projectionPosition(projection: TextProjection, offset: number, side: -1 | 1): number;
-export declare function projectionOffset(projection: TextProjection, position: number): number;
-export declare function validateOffsets(text: string, from: number, to: number): void;
-export declare function textRect(rect: Pick<TextRect, 'left' | 'top' | 'right' | 'bottom'>): TextRect;
-export declare function formattedRects(view: EditorView, projection: TextProjection, from: number, to: number): TextRect[];
-export declare function literalRangesRects(plain: HTMLTextAreaElement, ranges: readonly {
-    from: number;
-    to: number;
-}[]): TextRect[][];
-export declare function intersectsViewport(rect: Pick<TextRect, 'top' | 'right' | 'bottom' | 'left'>, viewport: TextRect): boolean;
-export declare function literalVisibleRanges(plain: HTMLTextAreaElement, viewport: TextRect): {
-    from: number;
-    to: number;
-}[];

package/dist/text-ranges.js

@@ -1,256 +0,0 @@
-import { InkKitError } from './types.js';
-import { fileReference } from './linked-syntax.js';
-import { imageBlockName } from './image-blocks.js';
-export function readableProjection(doc) {
-    const result = { text: '', spans: [] };
-    let blocks = 0;
-    const append = (text, start, end, kind) => {
-        const from = result.text.length;
-        result.text += text;
-        result.spans.push({ from, to: result.text.length, start, end, kind });
-    };
-    const block = (start) => {
-        if (blocks++)
-            append('\n', result.spans.at(-1)?.end ?? start, start, 'separator');
-    };
-    doc.descendants((node, position) => {
-        const name = node.type.name;
-        if (name === 'comment_inline' ||
-            name === 'comment_block' ||
-            name === 'reference_definition')
-            return false;
-        if (name === 'inkkit_callout') {
-            block(position);
-            append(node.attrs.title ||
-                String(node.attrs.kind).replace(/^./, (value) => value.toUpperCase()), position, position + 1, 'embed');
-            return true;
-        }
-        if (name === imageBlockName) {
-            block(position);
-            append(fileReference(node).label || 'Image', position, position + node.nodeSize, 'embed');
-            return false;
-        }
-        if (node.isTextblock) {
-            block(position + 1);
-            if (!node.content.size)
-                append('', position + 1, position + 1, 'text');
-            return true;
-        }
-        if (node.isText) {
-            append(node.text ?? '', position, position + node.nodeSize, 'text');
-            return false;
-        }
-        if (name === 'hardbreak' || name === 'hard_break') {
-            append('\n', position, position + node.nodeSize, 'break');
-            return false;
-        }
-        if (name === 'image' ||
-            name === 'footnote_reference' ||
-            name === 'inkkit_wiki_link') {
-            append(name === 'image'
-                ? fileReference(node).label || 'Image'
-                : name === 'inkkit_wiki_link'
-                    ? String(node.attrs.label || node.attrs.target || 'Link')
-                    : `[${node.attrs.label}]`, position, position + node.nodeSize, 'embed');
-            return false;
-        }
-        return true;
-    });
-    return result;
-}
-export function projectionPosition(projection, offset, side) {
-    const spans = projection.spans;
-    const span = spans.find((span) => (offset > span.from && offset < span.to) ||
-        (side > 0 ? offset === span.from : offset === span.to)) ?? (side > 0 ? spans.at(-1) : spans[0]);
-    if (!span)
-        return 0;
-    if (span.kind === 'text')
-        return (span.start +
-            Math.max(0, Math.min(offset - span.from, span.to - span.from)));
-    return offset <= span.from ? span.start : span.end;
-}
-export function projectionOffset(projection, position) {
-    for (const span of projection.spans) {
-        if (position < span.start)
-            return span.from;
-        if (position <= span.end)
-            return span.kind === 'text'
-                ? span.from + Math.max(0, position - span.start)
-                : position === span.start
-                    ? span.from
-                    : span.to;
-    }
-    return projection.text.length;
-}
-export function validateOffsets(text, from, to) {
-    const split = (offset) => offset > 0 &&
-        offset < text.length &&
-        /[\uD800-\uDBFF]/.test(text[offset - 1]) &&
-        /[\uDC00-\uDFFF]/.test(text[offset]);
-    if (!Number.isInteger(from) ||
-        !Number.isInteger(to) ||
-        from < 0 ||
-        to < from ||
-        to > text.length ||
-        split(from) ||
-        split(to))
-        throw new InkKitError('invalid-range', 'Range must use valid UTF-16 boundaries in the text snapshot');
-}
-export function textRect(rect) {
-    return {
-        left: rect.left,
-        top: rect.top,
-        right: rect.right,
-        bottom: rect.bottom,
-        width: Math.max(0, rect.right - rect.left),
-        height: Math.max(0, rect.bottom - rect.top),
-    };
-}
-export function formattedRects(view, projection, from, to) {
-    if (from === to) {
-        const position = projectionPosition(projection, from, 1);
-        const dom = view.domAtPos(position);
-        const element = dom.node.nodeType === 1 ? dom.node : dom.node.parentElement;
-        if (!element?.getClientRects().length)
-            return [];
-        return [textRect(view.coordsAtPos(position))];
-    }
-    const rects = [];
-    let low = 0;
-    let high = projection.spans.length;
-    while (low < high) {
-        const middle = (low + high) >>> 1;
-        if (projection.spans[middle].to <= from)
-            low = middle + 1;
-        else
-            high = middle;
-    }
-    for (let index = low; index < projection.spans.length; index++) {
-        const span = projection.spans[index];
-        if (span.from >= to)
-            break;
-        if (span.kind === 'separator')
-            continue;
-        if (span.kind === 'embed' || span.kind === 'break') {
-            const node = view.nodeDOM(span.start);
-            if (node instanceof Element) {
-                // A standalone image's node is its full-width row; the card is what shows.
-                const label = node.matches('.inkkit-callout')
-                    ? (node.querySelector(':scope > .inkkit-callout-header > .inkkit-callout-title') ?? node)
-                    : node.matches('.inkkit-image-block')
-                        ? (node.firstElementChild ?? node)
-                        : node;
-                rects.push(...Array.from(label.getClientRects(), textRect));
-            }
-            continue;
-        }
-        const start = view.domAtPos(span.start + Math.max(0, from - span.from), 1);
-        const end = view.domAtPos(span.start + Math.min(span.to - span.from, to - span.from), -1);
-        const range = view.dom.ownerDocument.createRange();
-        range.setStart(start.node, start.offset);
-        range.setEnd(end.node, end.offset);
-        rects.push(...Array.from(range.getClientRects(), textRect));
-    }
-    return rects.filter((rect) => rect.height > 0 && rect.width >= 0);
-}
-function withLiteralLayout(plain, measure) {
-    if (!plain.clientWidth || !plain.clientHeight)
-        return undefined;
-    const document = plain.ownerDocument;
-    const style = document.defaultView.getComputedStyle(plain);
-    const mirror = document.createElement('div');
-    for (const property of [
-        'font',
-        'font-family',
-        'font-size',
-        'font-weight',
-        'font-style',
-        'font-stretch',
-        'font-variant',
-        'line-height',
-        'letter-spacing',
-        'word-spacing',
-        'tab-size',
-        'padding',
-        'text-indent',
-        'text-transform',
-        'direction',
-        'word-break',
-    ])
-        mirror.style.setProperty(property, style.getPropertyValue(property));
-    const origin = plain.getBoundingClientRect();
-    Object.assign(mirror.style, {
-        position: 'fixed',
-        visibility: 'hidden',
-        pointerEvents: 'none',
-        left: `${origin.left + plain.clientLeft - plain.scrollLeft}px`,
-        top: `${origin.top + plain.clientTop - plain.scrollTop}px`,
-        width: `${plain.clientWidth}px`,
-        boxSizing: 'border-box',
-        whiteSpace: plain.wrap === 'off' ? 'pre' : 'pre-wrap',
-        overflowWrap: plain.wrap === 'off' ? 'normal' : 'break-word',
-    });
-    mirror.setAttribute('aria-hidden', 'true');
-    const text = document.createTextNode(plain.value + '\u200b');
-    mirror.append(text);
-    document.body.append(mirror);
-    try {
-        return measure(text);
-    }
-    finally {
-        mirror.remove();
-    }
-}
-export function literalRangesRects(plain, ranges) {
-    return (withLiteralLayout(plain, (text) => {
-        const range = plain.ownerDocument.createRange();
-        return ranges.map(({ from, to }) => {
-            range.setStart(text, from);
-            range.setEnd(text, from === to ? Math.min(to + 1, text.length) : to);
-            return Array.from(range.getClientRects(), (rect) => textRect({
-                left: rect.left,
-                right: from === to ? rect.left : rect.right,
-                top: rect.top,
-                bottom: rect.bottom,
-            }));
-        });
-    }) ?? ranges.map(() => []));
-}
-export function intersectsViewport(rect, viewport) {
-    return (viewport.width > 0 &&
-        viewport.height > 0 &&
-        rect.bottom > viewport.top &&
-        rect.top < viewport.bottom &&
-        rect.right >= viewport.left &&
-        rect.left < viewport.right);
-}
-export function literalVisibleRanges(plain, viewport) {
-    return (withLiteralLayout(plain, (text) => {
-        const range = plain.ownerDocument.createRange();
-        const ranges = [];
-        const visible = (from, to) => {
-            range.setStart(text, from);
-            range.setEnd(text, to);
-            return Array.from(range.getClientRects()).some((rect) => intersectsViewport(rect, viewport));
-        };
-        for (let start = 0; start < plain.value.length;) {
-            const newline = plain.value.indexOf('\n', start);
-            const end = newline < 0 ? plain.value.length : newline + 1;
-            if (visible(start, end)) {
-                for (let from = start; from < end;) {
-                    const to = from + (plain.value.codePointAt(from) > 0xffff ? 2 : 1);
-                    if (visible(from, to)) {
-                        const previous = ranges.at(-1);
-                        if (previous?.to === from)
-                            previous.to = to;
-                        else
-                            ranges.push({ from, to });
-                    }
-                    from = to;
-                }
-            }
-            start = end;
-        }
-        return ranges;
-    }) ?? []);
-}