@aicayzer/inkkit 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { InkKitEditor } from './editor.js';
-export type { EditorEvents, CaretState, Mark, Block, FormatCommand, Keymap, } from './editor.js';
-export type { TableCommand } from './tables.js';
+export type { EditorEvents, EditingMode, CaretState, Mark, Block, FormatCommand, Keymap, } from './editor.js';
+export type { TableCommand, TableOptions } from './tables.js';
+export type { Heading } from './outline.js';
 export { InkKitError } from './types.js';
 export type { DocumentFormat, DocumentContext, DocumentInput, DocumentSnapshot, EditorErrorCode, ImageAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, } from './types.js';

package/dist/outline.d.ts

@@ -0,0 +1,22 @@
+import type { Ctx } from '@milkdown/kit/ctx';
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+import type { EditorView } from '@milkdown/kit/prose/view';
+export interface Heading {
+    readonly id: string;
+    readonly level: number;
+    readonly text: string;
+    readonly documentId: string;
+    readonly generation: number;
+    readonly revision: number;
+}
+export interface OutlineContext {
+    documentId: string;
+    generation: number;
+    revision: number;
+    epoch: number;
+    mode: 'source' | 'formatted';
+}
+export declare function collectFormattedHeadings(doc: ProseNode, context: OutlineContext): readonly Heading[];
+export declare function collectSourceHeadings(ctx: Ctx, source: string, context: OutlineContext): readonly Heading[];
+export declare function sourceHeadingPosition(ctx: Ctx, source: string, requested: Heading, context: OutlineContext): number;
+export declare function navigateFormattedHeading(view: EditorView, requested: Heading, context: OutlineContext): boolean;

package/dist/outline.js

@@ -0,0 +1,79 @@
+import { parserCtx, remarkCtx } from '@milkdown/kit/core';
+import { TextSelection } from '@milkdown/kit/prose/state';
+import { clipboardText } from './clipboard.js';
+import { revealCalloutAncestors } from './callouts.js';
+import { InkKitError } from './types.js';
+function formattedLocations(doc) {
+    const headings = [];
+    doc.descendants((node, position) => {
+        if (node.type.name === 'heading')
+            headings.push({ node, position });
+    });
+    return headings;
+}
+function sourceLocations(ctx, source) {
+    const processor = ctx.get(remarkCtx);
+    const tree = processor.runSync(processor.parse(source), {
+        value: source,
+    });
+    const positions = [];
+    const bom = source.startsWith('\uFEFF') ? 1 : 0;
+    const visit = (node) => {
+        if (node.type === 'heading' && node.position?.start.offset != null)
+            positions.push({
+                position: node.position.start.offset + bom,
+                level: node.depth,
+            });
+        node.children?.forEach(visit);
+    };
+    visit(tree);
+    const parsed = formattedLocations(ctx.get(parserCtx)(source));
+    if (positions.length !== parsed.length ||
+        positions.some((item, index) => item.level !== parsed[index].node.attrs.level))
+        throw new InkKitError('preservation', 'The current Markdown headings cannot be located safely');
+    return parsed.map((heading, index) => ({
+        ...heading,
+        position: positions[index].position,
+    }));
+}
+function entry(heading, context) {
+    return Object.freeze({
+        id: `heading:${context.epoch}:${context.mode}:${context.generation}:${context.revision}:${heading.position}`,
+        level: Number(heading.node.attrs.level),
+        text: clipboardText(heading.node.content),
+        documentId: context.documentId,
+        generation: context.generation,
+        revision: context.revision,
+    });
+}
+export function collectFormattedHeadings(doc, context) {
+    return Object.freeze(formattedLocations(doc).map((item) => entry(item, context)));
+}
+export function collectSourceHeadings(ctx, source, context) {
+    return Object.freeze(sourceLocations(ctx, source).map((item) => entry(item, context)));
+}
+function currentLocation(locations, requested, context) {
+    for (const location of locations) {
+        const current = entry(location, context);
+        if (current.id === requested.id &&
+            current.documentId === requested.documentId &&
+            current.generation === requested.generation &&
+            current.revision === requested.revision &&
+            current.level === requested.level &&
+            current.text === requested.text)
+            return location.position;
+    }
+    throw new InkKitError('stale-document', 'The heading is no longer current');
+}
+export function sourceHeadingPosition(ctx, source, requested, context) {
+    return currentLocation(sourceLocations(ctx, source), requested, context);
+}
+export function navigateFormattedHeading(view, requested, context) {
+    const position = currentLocation(formattedLocations(view.state.doc), requested, context);
+    revealCalloutAncestors(view, position + 1);
+    view.dispatch(view.state.tr
+        .setSelection(TextSelection.create(view.state.doc, position + 1))
+        .scrollIntoView());
+    view.focus();
+    return true;
+}

package/dist/paste.js

@@ -1,7 +1,8 @@
 import { editorViewCtx, parserCtx } from '@milkdown/kit/core';
-import { DOMParser as ProseParser, Fragment, Slice, } from '@milkdown/kit/prose/model';
+import { DOMParser as ProseParser, DOMSerializer, Fragment, Slice, } from '@milkdown/kit/prose/model';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { $prose } from '@milkdown/kit/utils';
+import { pasteSpreadsheet } from './spreadsheet.js';
 import { avoidReferenceCollisions, markdownFromHTML, } from './reference-clipboard.js';
 import { InkKitError, } from './types.js';
 export class PasteController {
@@ -114,6 +115,10 @@ export class PasteController {
             const plainText = input.plainText ||
                 this.options.literalText?.() ||
                 view.state.selection.$from.parent.type.spec.code;
+            if (!plainText &&
+                input.markdown == null &&
+                pasteSpreadsheet(ctx, { ...input, images }))
+                return;
             const markdown = plainText
                 ? undefined
                 : (input.markdown ??
@@ -136,6 +141,16 @@ export class PasteController {
                 const template = document.createElement('template');
                 template.innerHTML = input.html;
                 const container = template.content;
+                // Preserve whole unsupported tables before rewriting their descendants,
+                // so comments retain their source and ordinary-copy privacy.
+                for (const table of [...container.querySelectorAll('table')]) {
+                    if (table.parentElement?.closest('table'))
+                        continue;
+                    if (schema.nodes.table && !unsupportedClipboardTable(table))
+                        continue;
+                    const preserved = ctx.get(parserCtx)(table.outerHTML);
+                    table.replaceWith(DOMSerializer.fromSchema(schema).serializeFragment(preserved.content));
+                }
                 for (const warning of container.querySelectorAll('[data-inkkit-diagram-error]'))
                     warning.remove();
                 for (const diagram of container.querySelectorAll('figure[data-inkkit-mermaid]')) {
@@ -252,11 +267,7 @@ export class PasteController {
                     if (table.parentElement?.closest('table'))
                         continue;
                     const rows = [...table.querySelectorAll('tr')];
-                    const widths = rows.map((row) => row.querySelectorAll(':scope > th,:scope > td').length);
-                    const unsupported = !schema.nodes.table ||
-                        widths.length === 0 ||
-                        widths.some((width) => !width || width !== widths[0]) ||
-                        table.querySelector('table,[rowspan]:not([rowspan="1"]),[colspan]:not([colspan="1"]),td > p ~ p,th > p ~ p,td > div,th > div,td > ul,td > ol,td > pre,td > blockquote,th > ul,th > ol,th > pre,th > blockquote');
+                    const unsupported = !schema.nodes.table || unsupportedClipboardTable(table);
                     if (!unsupported && !table.querySelector('th')) {
                         for (const cell of rows[0]?.querySelectorAll(':scope > td') ?? []) {
                             const heading = document.createElement('th');
@@ -422,6 +433,45 @@ export class PasteController {
         }
     }
 }
+function unsupportedClipboardTable(table) {
+    const rows = [...table.querySelectorAll('tr')];
+    const widths = rows.map((row) => row.querySelectorAll(':scope > th,:scope > td').length);
+    const supported = new Set([
+        'THEAD',
+        'TBODY',
+        'TFOOT',
+        'TR',
+        'TH',
+        'TD',
+        'P',
+        'STRONG',
+        'B',
+        'EM',
+        'I',
+        'S',
+        'DEL',
+        'STRIKE',
+        'CODE',
+        'A',
+        'MARK',
+        'SPAN',
+        'SUP',
+        'FONT',
+        'IMG',
+    ]);
+    return (widths.length === 0 ||
+        widths.some((width) => !width || width !== widths[0]) ||
+        !!document.createTreeWalker(table, NodeFilter.SHOW_COMMENT).nextNode() ||
+        [...table.querySelectorAll('*')].some((element) => !supported.has(element.tagName)) ||
+        [...table.querySelectorAll('p')].some((paragraph) => {
+            const cell = paragraph.parentElement;
+            return (!cell ||
+                !['TH', 'TD'].includes(cell.tagName) ||
+                cell.children.length !== 1 ||
+                [...cell.childNodes].some((node) => node !== paragraph && !!node.textContent?.trim()));
+        }) ||
+        !!table.querySelector('[rowspan]:not([rowspan="1"]),[colspan]:not([colspan="1"])'));
+}
 function dataImage(source) {
     const match = /^data:(image\/(?:png|jpeg|gif|webp|avif|bmp|tiff));base64,([A-Za-z0-9+/=\s]+)$/.exec(source);
     if (!match)

package/dist/preserve.js

@@ -2,16 +2,14 @@ import { parserCtx, remarkCtx } from '@milkdown/kit/core';
 import { serialize } from './dialect.js';
 import { restoreCodeEndings, finalCodeEnding } from './code-fences.js';
 function signature(node) {
-    return JSON.stringify(node, (key, value) => ['position', 'data', 'url', 'title', 'marker'].includes(key)
-        ? undefined
-        : value);
+    return JSON.stringify(node, (key, value) => ['position', 'data', 'marker'].includes(key) ? undefined : value);
 }
 function ownShape(node) {
     return JSON.stringify(node, (key, value) => ['position', 'data', 'children', 'value', 'marker'].includes(key)
         ? undefined
         : value);
 }
-function retainText(raw, before, after, quoteIndent = false) {
+function retainText(raw, before, after, quoteIndent = false, inTable = false) {
     before = before.replace(/\r\n?/g, '\n');
     after = after.replace(/\r\n?/g, '\n');
     let prefix = 0;
@@ -64,7 +62,7 @@ function retainText(raw, before, after, quoteIndent = false) {
     }
     if (decoded !== before) {
         // Continuation indentation is excluded from a quoted paragraph's text.
-        return quoteIndent ? after : retainText(raw, before, after, true);
+        return quoteIndent ? after : retainText(raw, before, after, true, inTable);
     }
     const inserted = after
         .slice(prefix, after.length - suffix)
@@ -73,7 +71,9 @@ function retainText(raw, before, after, quoteIndent = false) {
         const at = prefix + index;
         const delimiter = (character === '%' || character === '=') &&
             (after[at - 1] === character || after[at + 1] === character);
-        return delimiter || /[\\`*_[\]<>]/.test(character)
+        return delimiter ||
+            /[\\`*_[\]<>]/.test(character) ||
+            (inTable && character === '|')
             ? `\\${character}`
             : character;
     })
@@ -108,7 +108,7 @@ function retainBoundaryWhitespace(raw, canonical) {
     return raw;
 }
 // Patch changed leaves so an adjacent edit retains authored delimiters and labels.
-function retainSource(before, after, source, canonical, lineEnding) {
+function retainSource(before, after, source, canonical, lineEnding, inTable = false) {
     const start = before.position?.start.offset;
     const end = before.position?.end.offset;
     const newStart = after.position?.start.offset;
@@ -163,7 +163,7 @@ function retainSource(before, after, source, canonical, lineEnding) {
                 destination[3]);
     }
     if (before.type === 'text' && after.type === 'text')
-        return retainBoundaryWhitespace(retainText(raw, before.value, after.value), canonical.slice(newStart, newEnd));
+        return retainBoundaryWhitespace(retainText(raw, before.value, after.value, false, inTable), canonical.slice(newStart, newEnd));
     if (signature(before) === signature(after) &&
         ownShape(before) === ownShape(after))
         return raw;
@@ -173,13 +173,40 @@ function retainSource(before, after, source, canonical, lineEnding) {
         after.children &&
         before.children.length === after.children.length) {
         let output = '', previous = start;
+        const retained = new Set();
         before.children.forEach((child, index) => {
+            const incoming = after.children[index];
+            const movedIndex = before.type === 'table' || before.type === 'tableRow'
+                ? before.children.findIndex((candidate, candidateIndex) => !retained.has(candidateIndex) &&
+                    signature(candidate) === signature(incoming) &&
+                    ownShape(candidate) === ownShape(incoming))
+                : -1;
+            const original = movedIndex < 0 ? child : before.children[movedIndex];
+            if (movedIndex >= 0)
+                retained.add(movedIndex);
             const childStart = child.position?.start.offset, childEnd = child.position?.end.offset;
             if (childStart == null || childEnd == null)
                 throw new PreservationError('A source token has no location');
-            output +=
-                source.slice(previous, childStart) +
-                    retainSource(child, after.children[index], source, canonical, lineEnding);
+            let retainedSource = retainSource(original, incoming, source, canonical, lineEnding, inTable || before.type === 'tableCell');
+            if (before.type === 'tableRow' && movedIndex >= 0) {
+                // Cell positions own different pipe boundaries at the row edges.
+                const originalFrom = original.children?.[0]?.position?.start.offset;
+                const originalTo = original.children?.at(-1)?.position?.end.offset;
+                const from = child.children?.[0]?.position?.start.offset;
+                const to = child.children?.at(-1)?.position?.end.offset;
+                retainedSource =
+                    originalFrom != null &&
+                        originalTo != null &&
+                        from != null &&
+                        to != null
+                        ? source.slice(childStart, from) +
+                            source.slice(originalFrom, originalTo) +
+                            source.slice(to, childEnd)
+                        : canonical
+                            .slice(incoming.position.start.offset, incoming.position.end.offset)
+                            .replaceAll('\n', lineEnding);
+            }
+            output += source.slice(previous, childStart) + retainedSource;
             previous = childEnd;
         });
         return output + source.slice(previous, end);

package/dist/search.d.ts

@@ -0,0 +1,14 @@
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+import type { EditorView } from '@milkdown/kit/prose/view';
+export interface TextMatch {
+    from: number;
+    to: number;
+}
+export interface LiteralReplacement extends TextMatch {
+    text: string;
+    count: number;
+}
+export declare function findLiteral(text: string, search: string, from?: number): TextMatch | undefined;
+export declare function replaceLiteral(text: string, search: string, replacement: string, selection: TextMatch, all?: boolean): LiteralReplacement;
+export declare function findFormatted(view: EditorView, text: string): void;
+export declare function replaceFormatted(view: EditorView, search: string, replacement: string, preflight: (doc: ProseNode) => void, all?: boolean): number;

package/dist/search.js

@@ -0,0 +1,171 @@
+import { Fragment, Slice } from '@milkdown/kit/prose/model';
+import { closeHistory } from '@milkdown/kit/prose/history';
+import { Selection, TextSelection } from '@milkdown/kit/prose/state';
+import { SearchQuery, setSearchState, getSearchState } from 'prosemirror-search';
+import { InkKitError } from './types.js';
+function escapedPattern(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function literalMatches(text, search) {
+    if (!search)
+        return [];
+    const pattern = new RegExp(escapedPattern(search), 'giu');
+    return [...text.matchAll(pattern)].map((match) => ({
+        from: match.index,
+        to: match.index + match[0].length,
+    }));
+}
+export function findLiteral(text, search, from = 0) {
+    const matches = literalMatches(text, search);
+    return matches.find((match) => match.from >= from) ?? matches[0];
+}
+export function replaceLiteral(text, search, replacement, selection, all = false) {
+    const matches = literalMatches(text, search);
+    const selected = matches.find((match) => match.from === selection.from && match.to === selection.to) ??
+        matches.find((match) => match.from >= selection.to) ??
+        matches[0];
+    const changed = (all ? matches : selected ? [selected] : []).filter((match) => text.slice(match.from, match.to) !== replacement);
+    if (!changed.length)
+        return { ...selection, text, count: 0 };
+    let output = text;
+    for (const match of [...changed].reverse())
+        output = output.slice(0, match.from) + replacement + output.slice(match.to);
+    if (!all)
+        return {
+            text: output,
+            count: 1,
+            from: changed[0].from,
+            to: changed[0].from + replacement.length,
+        };
+    const map = (position) => {
+        let difference = 0;
+        for (const match of changed) {
+            if (position < match.from)
+                break;
+            if (position <= match.to)
+                return (match.from +
+                    difference +
+                    (position === match.from ? 0 : replacement.length));
+            difference += replacement.length - (match.to - match.from);
+        }
+        return position + difference;
+    };
+    return {
+        text: output,
+        count: changed.length,
+        from: map(selection.from),
+        to: map(selection.to),
+    };
+}
+function formattedQuery(text) {
+    // Unicode regexp matching retains offsets when lowercasing would expand a character.
+    return new SearchQuery({
+        search: escapedPattern(text),
+        regexp: true,
+        literal: true,
+        filter: (state, match) => {
+            const from = state.doc.resolve(match.from);
+            const to = state.doc.resolve(match.to);
+            if (from.parent !== to.parent || !from.parent.inlineContent)
+                return false;
+            const content = state.doc.slice(match.from, match.to).content;
+            let textOnly = true;
+            content.forEach((node) => {
+                if (!node.isText)
+                    textOnly = false;
+            });
+            return textOnly;
+        },
+    });
+}
+export function findFormatted(view, text) {
+    const query = formattedQuery(text);
+    const previous = getSearchState(view.state)?.query.search;
+    let tr = setSearchState(view.state.tr, query);
+    if (text) {
+        const start = previous === query.search
+            ? view.state.selection.to
+            : view.state.selection.from;
+        const match = query.findNext(view.state, start) ?? query.findNext(view.state, 0);
+        if (match)
+            tr = tr
+                .setSelection(TextSelection.create(tr.doc, match.from, match.to))
+                .scrollIntoView();
+        else
+            tr = tr.setSelection(Selection.near(view.state.selection.$to));
+    }
+    else if (previous)
+        tr = tr.setSelection(Selection.near(view.state.selection.$to));
+    view.dispatch(tr);
+}
+export function replaceFormatted(view, search, replacement, preflight, all = false) {
+    if (!search)
+        return 0;
+    const state = view.state;
+    const query = formattedQuery(search);
+    if (!query.valid)
+        return 0;
+    const matches = [];
+    if (all) {
+        for (let position = 0;;) {
+            const match = query.findNext(state, position);
+            if (!match)
+                break;
+            matches.push(match);
+            position = match.to;
+        }
+    }
+    else {
+        const selection = state.selection;
+        const current = query.findNext(state, selection.from, selection.to);
+        const match = (current?.from === selection.from && current.to === selection.to
+            ? current
+            : undefined) ??
+            query.findNext(state, selection.to) ??
+            query.findNext(state, 0);
+        if (match)
+            matches.push(match);
+    }
+    const value = replacement.replace(/\r\n?/g, '\n');
+    const changed = matches.filter((match) => state.doc.textBetween(match.from, match.to) !== value);
+    if (!changed.length)
+        return 0;
+    let tr = setSearchState(state.tr, query);
+    for (const match of [...changed].reverse()) {
+        const from = state.doc.resolve(match.from);
+        const to = state.doc.resolve(match.to);
+        const marks = from.marksAcross(to) ?? from.marks();
+        let content = Fragment.empty;
+        if (from.parent.type.spec.code) {
+            if (value)
+                content = Fragment.from(state.schema.text(value, marks));
+        }
+        else {
+            const nodes = [];
+            const lines = value.split('\n');
+            lines.forEach((line, index) => {
+                if (index)
+                    nodes.push(state.schema.nodes.hardbreak.create({ isHTML: index === lines.length - 1 && line === '' }, null, marks));
+                if (line)
+                    nodes.push(state.schema.text(line, marks));
+            });
+            content = Fragment.fromArray(nodes);
+        }
+        tr.replace(match.from, match.to, new Slice(content, 0, 0));
+    }
+    if (!all) {
+        const match = changed[0];
+        tr = tr.setSelection(TextSelection.create(tr.doc, match.from, tr.mapping.map(match.to, 1)));
+    }
+    try {
+        preflight(tr.doc);
+    }
+    catch (error) {
+        if (error instanceof InkKitError)
+            throw error;
+        throw new InkKitError('preservation', error instanceof Error ? error.message : 'Cannot preserve replacement');
+    }
+    view.dispatch(closeHistory(tr).scrollIntoView());
+    view.dispatch(closeHistory(view.state.tr).setMeta('addToHistory', false));
+    return changed.length;
+}

package/dist/source.d.ts

@@ -0,0 +1,17 @@
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+export declare const sourceAttribute = "inkkitSource";
+export interface SourceProvenance {
+    readonly text: string;
+    readonly format: 'md' | 'txt';
+    readonly from: number;
+    readonly to: number;
+}
+export declare function cleanSourceDoc(doc: ProseNode): ProseNode;
+export declare function rawOffset(source: string, normalized: number): number;
+export declare function normalizedOffset(source: string, raw: number): number;
+export declare function editedPlainSource(previous: string, value: string): string;
+export declare function sourceSelection(source: string, start: number, end: number): {
+    markdown: string;
+    shareable: string;
+};
+export declare function revealSourceCaret(plain: HTMLTextAreaElement): void;

package/dist/source.js

@@ -0,0 +1,117 @@
+import { literalCommentSpans } from './comments.js';
+export const sourceAttribute = 'inkkitSource';
+export function cleanSourceDoc(doc) {
+    return doc.attrs[sourceAttribute] == null
+        ? doc
+        : doc.type.create({ ...doc.attrs, [sourceAttribute]: null }, doc.content);
+}
+export function rawOffset(source, normalized) {
+    let position = 0, count = 0;
+    while (position < source.length && count < normalized) {
+        if (source[position] === '\r' && source[position + 1] === '\n')
+            position++;
+        position++;
+        count++;
+    }
+    return position;
+}
+export function normalizedOffset(source, raw) {
+    return source.slice(0, raw).replace(/\r\n?/g, '\n').length;
+}
+export function editedPlainSource(previous, value) {
+    const normalized = previous.replace(/\r\n?/g, '\n');
+    if (normalized === value)
+        return previous;
+    let prefix = 0, suffix = 0;
+    while (prefix < normalized.length &&
+        prefix < value.length &&
+        normalized[prefix] === value[prefix])
+        prefix++;
+    while (suffix < normalized.length - prefix &&
+        suffix < value.length - prefix &&
+        normalized[normalized.length - suffix - 1] ===
+            value[value.length - suffix - 1])
+        suffix++;
+    const ending = /\r\n|\r|\n/.exec(previous)?.[0] ?? '\n';
+    return (previous.slice(0, rawOffset(previous, prefix)) +
+        value
+            .slice(prefix, value.length - suffix)
+            .replace(/\r\n?/g, '\n')
+            .replaceAll('\n', ending) +
+        previous.slice(rawOffset(previous, normalized.length - suffix)));
+}
+export function sourceSelection(source, start, end) {
+    const from = rawOffset(source, start), to = rawOffset(source, end);
+    let shareable = '', cursor = from;
+    const bom = source.startsWith('\uFEFF') ? 1 : 0;
+    for (const parsed of literalCommentSpans(source.slice(bom))) {
+        const span = { start: parsed.start + bom, end: parsed.end + bom };
+        if (span.end <= from || span.start >= to)
+            continue;
+        if (span.start > cursor)
+            shareable += source.slice(cursor, Math.min(span.start, to));
+        cursor = Math.max(cursor, Math.min(span.end, to));
+    }
+    shareable += source.slice(cursor, to);
+    return { markdown: source.slice(from, to), shareable };
+}
+export function revealSourceCaret(plain) {
+    if (!plain.clientWidth || !plain.clientHeight)
+        return;
+    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));
+    Object.assign(mirror.style, {
+        position: 'fixed',
+        visibility: 'hidden',
+        left: '-10000px',
+        top: '0',
+        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 caret = document.createElement('span');
+    caret.setAttribute('data-inkkit-source-caret', '');
+    caret.textContent = plain.value.slice(plain.selectionStart) || '\u200b';
+    mirror.append(document.createTextNode(plain.value.slice(0, plain.selectionStart)), caret);
+    document.body.append(mirror);
+    try {
+        // Textareas expose selection offsets but no caret geometry; matching their layout also accounts for wrapped lines.
+        const rect = caret.getClientRects()[0] ?? caret.getBoundingClientRect();
+        const top = rect.top - mirror.getBoundingClientRect().top;
+        const lineHeight = Math.max(rect.height, Number.parseFloat(style.lineHeight) || rect.height);
+        const insetTop = Number.parseFloat(style.paddingTop) || 0;
+        const insetBottom = Number.parseFloat(style.paddingBottom) || 0;
+        if (plain.selectionStart === 0)
+            plain.scrollTop = 0;
+        else if (top < plain.scrollTop + insetTop)
+            plain.scrollTop = Math.max(0, top - insetTop);
+        else if (top + lineHeight >
+            plain.scrollTop + plain.clientHeight - insetBottom)
+            plain.scrollTop = Math.max(0, top + lineHeight - plain.clientHeight + insetBottom);
+    }
+    finally {
+        mirror.remove();
+    }
+}

package/dist/spreadsheet.d.ts

@@ -0,0 +1,3 @@
+import type { Ctx } from '@milkdown/kit/ctx';
+import { type ClipboardInput } from './types.js';
+export declare function pasteSpreadsheet(ctx: Ctx, input: ClipboardInput): boolean;