@aicayzer/inkkit 0.0.2 → 0.0.4

package/README.md

@@ -33,10 +33,10 @@ editor.loadDocument({
 const snapshot = editor.snapshot(1)
 ```
 
-Markdown includes CommonMark, task lists, strikethrough, autolinks, GFM tables, editable footnotes and reference-style links. Unsupported constructs remain literal Markdown. TXT mode treats all text literally. Images require a host adapter. RTF files remain outside the package scope.
+Markdown includes CommonMark, task lists, strikethrough, autolinks, GFM tables, editable footnotes and reference-style links, bounded callouts, highlights and author comments. Unsupported constructs remain literal Markdown. TXT mode treats all text literally. Images require a host adapter. RTF files remain outside the package scope.
 
-See [the host API](docs/api.md), [preservation and clipboard behavior](docs/preservation.md), [development](docs/development.md), and [releases](docs/releasing.md).
+See [supported syntax](docs/supported-syntax.md), [the host API](docs/api.md), [preservation and clipboard behavior](docs/preservation.md), [development](docs/development.md), and [releases](docs/releasing.md).
 
-Planned work and release scope are tracked in the [InkKit Project](https://github.com/users/aicayzer/projects/3) and [milestones](https://github.com/aicayzer/inkkit/milestones). Releases 0.0.2 and 0.0.3 are authorised for sequential delivery; targets from 0.0.4 remain provisional.
+Planned work and release scope are tracked in the [InkKit Project](https://github.com/users/aicayzer/projects/3) and [milestones](https://github.com/aicayzer/inkkit/milestones). Release 0.0.2 is published and verified; 0.0.3 delivery is authorised. Targets from 0.0.4 remain provisional.
 
 MIT licensed. InkKit builds on the public PadPad and Memos editors; see [NOTICE](NOTICE).

package/dist/callouts.d.ts

@@ -0,0 +1,24 @@
+import type { Parent, RootContent } from 'mdast';
+interface Callout extends Parent {
+    type: 'inkkitCallout';
+    kind: string;
+    marker: string;
+    fold: string;
+    title: string;
+    titleSource: string;
+    listPlaceholder: boolean;
+    children: RootContent[];
+}
+declare module 'mdast' {
+    interface BlockContentMap {
+        inkkitCallout: Callout;
+    }
+    interface RootContentMap {
+        inkkitCallout: Callout;
+    }
+}
+export declare const remarkCalloutsPlugin: import("@milkdown/kit/utils").$Remark<"inkkitCallouts", unknown>;
+export declare const calloutSchema: import("@milkdown/kit/utils").$Node;
+export declare const calloutView: import("@milkdown/kit/utils").$Prose;
+export declare const callouts: (import("@milkdown/kit/utils").$Node | import("@milkdown/kit/utils").$Prose)[];
+export {};

package/dist/callouts.js

@@ -0,0 +1,296 @@
+import { $node, $prose, $remark } from '@milkdown/kit/utils';
+import { remarkCtx } from '@milkdown/kit/core';
+import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
+import { defaultHandlers } from 'mdast-util-to-markdown';
+const kinds = new Set(['NOTE', 'TIP', 'IMPORTANT', 'WARNING', 'CAUTION']);
+function plainHeader(processor, source) {
+    const node = processor.parse(source).children[0];
+    return node?.type === 'paragraph' &&
+        node.children.length === 1 &&
+        node.children[0]?.type === 'text'
+        ? node.children[0].value
+        : undefined;
+}
+const calloutHandler = (untyped, parent, state, info) => {
+    const node = untyped;
+    const body = defaultHandlers.blockquote({ type: 'blockquote', children: node.children }, parent, state, info);
+    const title = node.titleSource ?? node.title;
+    return `> ${node.marker}${node.fold}${title ? ` ${title}` : ''}\n${body}`;
+};
+function remarkCallouts() {
+    const processor = this;
+    const data = this.data();
+    (data.toMarkdownExtensions ??= []).push({
+        handlers: { inkkitCallout: calloutHandler },
+    });
+    return (tree, file) => {
+        const source = String(file.value).replace(/^\uFEFF/, '');
+        const visit = (node, parent, index) => {
+            if (node.type === 'blockquote') {
+                const start = node.position?.start.offset, end = node.position?.end.offset;
+                const raw = start == null || end == null ? '' : source.slice(start, end);
+                const header = /^>[ \t]*([\s\S]*?)(?:\r?\n|$)/.exec(raw)?.[1] ?? '';
+                if (header.startsWith('[!')) {
+                    const match = /^(\[!([A-Za-z]+)\])([+-]?)(?:[ \t]+([^\r\n]*))?$/.exec(header);
+                    const first = node.children[0];
+                    const decodedHeader = plainHeader(processor, header);
+                    // A bounded header occupies one unformatted line; other variants stay source.
+                    if (!match ||
+                        decodedHeader == null ||
+                        !kinds.has(match[2].toUpperCase()) ||
+                        /^[+-](?:[ \t]|[+-])/.test(match[4] ?? '') ||
+                        first?.type !== 'paragraph' ||
+                        first.children[0]?.type !== 'text')
+                        return {
+                            type: 'inkkitLiteral',
+                            value: raw,
+                            position: node.position,
+                        };
+                    const text = first.children[0];
+                    // Entities can decode to newlines without ending the authored header line.
+                    const ending = /^\r?\n/.exec(text.value.slice(decodedHeader.length));
+                    const lineEnd = ending ? decodedHeader.length : -1;
+                    if (lineEnd < 0 && first.children.length > 1)
+                        return {
+                            type: 'inkkitLiteral',
+                            value: raw,
+                            position: node.position,
+                        };
+                    const children = [...node.children];
+                    if (lineEnd >= 0) {
+                        const remaining = text.value.slice(lineEnd + ending[0].length);
+                        const firstStart = text.position?.start.offset;
+                        const token = firstStart == null
+                            ? ''
+                            : source.slice(firstStart, text.position?.end.offset);
+                        const boundary = /\r?\n[ \t]*>[ \t]?/.exec(token);
+                        const bodyStart = firstStart == null || !boundary
+                            ? undefined
+                            : firstStart + boundary.index + boundary[0].length;
+                        const point = bodyStart == null
+                            ? undefined
+                            : {
+                                line: source.slice(0, bodyStart).split('\n').length,
+                                column: bodyStart - source.lastIndexOf('\n', bodyStart - 1),
+                                offset: bodyStart,
+                            };
+                        children[0] = {
+                            ...first,
+                            children: [
+                                ...(remaining
+                                    ? [
+                                        {
+                                            ...text,
+                                            value: remaining,
+                                            position: point && text.position
+                                                ? { start: point, end: text.position.end }
+                                                : undefined,
+                                        },
+                                    ]
+                                    : []),
+                                ...first.children.slice(1),
+                            ],
+                        };
+                    }
+                    else
+                        children.shift();
+                    if (!children.length)
+                        children.push({ type: 'paragraph', children: [] });
+                    return {
+                        type: 'inkkitCallout',
+                        kind: match[2].toUpperCase(),
+                        marker: match[1],
+                        fold: match[3],
+                        title: decodedHeader
+                            .slice(header.length - (match[4]?.length ?? 0))
+                            .trimEnd(),
+                        titleSource: match[4]?.trimEnd() ?? '',
+                        listPlaceholder: parent?.type === 'listItem' && index === 0,
+                        children: children.map((child) => visit(child)),
+                        position: node.position,
+                    };
+                }
+            }
+            if ('children' in node)
+                node.children = node.children.map((child, index) => visit(child, node, index));
+            return node;
+        };
+        tree.children = tree.children.map((node) => visit(node));
+    };
+}
+export const remarkCalloutsPlugin = $remark('inkkitCallouts', () => remarkCallouts);
+export const calloutSchema = $node('inkkit_callout', (ctx) => ({
+    group: 'block',
+    content: 'block+',
+    defining: true,
+    attrs: {
+        kind: { default: 'NOTE' },
+        marker: { default: '[!NOTE]' },
+        fold: { default: '' },
+        title: { default: '' },
+        titleSource: { default: null },
+        listPlaceholder: { default: false },
+    },
+    parseDOM: [
+        {
+            tag: 'blockquote[data-inkkit-callout]',
+            priority: 100,
+            contentElement: '.inkkit-callout-body',
+            getAttrs: (dom) => {
+                const kind = (dom.getAttribute('data-inkkit-callout') ?? '').toUpperCase();
+                const marker = dom.getAttribute('data-inkkit-marker') ?? `[!${kind}]`;
+                const fold = dom.getAttribute('data-inkkit-fold') ?? '';
+                const titleSource = dom.getAttribute('data-inkkit-title');
+                const placeholder = dom.getAttribute('data-inkkit-list-placeholder');
+                const previous = dom.previousElementSibling;
+                const titleHeader = titleSource == null
+                    ? undefined
+                    : plainHeader(ctx.get(remarkCtx), `${marker} ${titleSource}`);
+                if (!kinds.has(kind) ||
+                    !/^\[![A-Za-z]+\]$/.test(marker) ||
+                    marker.slice(2, -1).toUpperCase() !== kind ||
+                    !['', '+', '-'].includes(fold) ||
+                    (titleSource != null &&
+                        (/[\r\n]/.test(titleSource) || titleHeader == null)))
+                    return false;
+                return {
+                    kind,
+                    marker,
+                    fold,
+                    title: titleHeader == null
+                        ? (dom.querySelector('.inkkit-callout-title')?.textContent ?? '')
+                        : titleHeader.slice(marker.length + 1).trimEnd(),
+                    titleSource,
+                    listPlaceholder: placeholder == null
+                        ? dom.parentElement?.tagName === 'LI' &&
+                            (!previous ||
+                                (previous.tagName === 'P' &&
+                                    !previous.textContent &&
+                                    !previous.childElementCount))
+                        : placeholder === 'true',
+                };
+            },
+        },
+    ],
+    toDOM: (node) => [
+        'blockquote',
+        {
+            class: 'inkkit-callout',
+            'data-inkkit-callout': node.attrs.kind,
+            'data-inkkit-marker': node.attrs.marker,
+            'data-inkkit-fold': node.attrs.fold,
+            'data-inkkit-title': node.attrs.titleSource ?? node.attrs.title,
+            'data-inkkit-list-placeholder': String(node.attrs.listPlaceholder),
+        },
+        [
+            'strong',
+            { class: 'inkkit-callout-title' },
+            node.attrs.title ||
+                String(node.attrs.kind)
+                    .toLowerCase()
+                    .replace(/^./, (letter) => letter.toUpperCase()),
+        ],
+        ['div', { class: 'inkkit-callout-body' }, 0],
+    ],
+    parseMarkdown: {
+        match: (node) => node.type === 'inkkitCallout',
+        runner(state, node, type) {
+            state.openNode(type, {
+                kind: node.kind,
+                marker: node.marker,
+                fold: node.fold,
+                title: node.title,
+                titleSource: node.titleSource,
+                listPlaceholder: node.listPlaceholder,
+            });
+            state.next(node.children);
+            state.closeNode();
+        },
+    },
+    toMarkdown: {
+        match: (node) => node.type.name === 'inkkit_callout',
+        runner(state, node) {
+            const parent = state.top();
+            const first = parent?.children?.[0];
+            // Lists require a leading paragraph even when their authored first block is a callout.
+            if (node.attrs.listPlaceholder &&
+                parent?.type === 'listItem' &&
+                parent.children?.length === 1 &&
+                first?.type === 'paragraph' &&
+                first.children?.length === 1 &&
+                first.children[0]?.type === 'html' &&
+                first.children[0].value === '<br />')
+                parent.children = [];
+            state.openNode('inkkitCallout', undefined, { ...node.attrs });
+            state.next(node.content);
+            state.closeNode();
+        },
+    },
+}));
+export const calloutView = $prose(() => new Plugin({
+    key: new PluginKey('inkkitCalloutView'),
+    props: {
+        nodeViews: {
+            inkkit_callout(node) {
+                const dom = document.createElement('blockquote');
+                dom.className = 'inkkit-callout';
+                dom.setAttribute('data-inkkit-callout', String(node.attrs.kind));
+                const header = document.createElement('div');
+                header.className = 'inkkit-callout-header';
+                header.contentEditable = 'false';
+                const title = document.createElement('strong');
+                title.className = 'inkkit-callout-title';
+                const contentDOM = document.createElement('div');
+                contentDOM.className = 'inkkit-callout-body';
+                let folded = node.attrs.fold === '-';
+                const button = document.createElement('button');
+                button.type = 'button';
+                button.setAttribute('data-inkkit-callout-toggle', '');
+                const render = () => {
+                    title.textContent =
+                        node.attrs.title ||
+                            String(node.attrs.kind)
+                                .toLowerCase()
+                                .replace(/^./, (letter) => letter.toUpperCase());
+                    dom.setAttribute('data-inkkit-folded', String(folded));
+                    button.hidden = !node.attrs.fold;
+                    button.setAttribute('aria-expanded', String(!folded));
+                    button.setAttribute('aria-label', `${folded ? 'Expand' : 'Collapse'} ${title.textContent}`);
+                    button.textContent = folded ? 'Expand' : 'Collapse';
+                };
+                const toggle = () => {
+                    folded = !folded;
+                    render();
+                };
+                button.addEventListener('click', toggle);
+                button.addEventListener('keydown', (event) => {
+                    if (event.key === 'Enter' || event.key === ' ') {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        toggle();
+                    }
+                });
+                header.append(title, button);
+                dom.append(header, contentDOM);
+                render();
+                return {
+                    dom,
+                    contentDOM,
+                    update(next) {
+                        if (next.type !== node.type)
+                            return false;
+                        if (next.attrs.fold !== node.attrs.fold)
+                            folded = next.attrs.fold === '-';
+                        node = next;
+                        render();
+                        return true;
+                    },
+                    stopEvent: (event) => header.contains(event.target),
+                    ignoreMutation: (mutation) => mutation.type !== 'selection' &&
+                        !contentDOM.contains(mutation.target),
+                };
+            },
+        },
+    },
+}));
+export const callouts = [calloutSchema, calloutView].flat();

package/dist/clipboard.d.ts

@@ -8,4 +8,4 @@ export declare function clipboardText(content: Fragment, missingImages?: Readonl
 export declare function clipboardContent(content: Fragment, schema: Schema): ClipboardContent;
 export declare const visibleClipboard: import("@milkdown/kit/utils").$Prose;
 /** Export a frozen document fragment; presentation URLs never enter the clipboard. */
-export declare function portableClipboard(content: Fragment, schema: Schema, markdown: string, adapter: ImageAdapter | undefined, context: DocumentContext): Promise<ClipboardOutput>;
+export declare function portableClipboard(content: Fragment, schema: Schema, markdown: string, adapter: ImageAdapter | undefined, context: DocumentContext, completeDiagrams?: ReadonlySet<string>): Promise<ClipboardOutput>;

package/dist/clipboard.js

@@ -1,9 +1,12 @@
 import { DOMSerializer, } from '@milkdown/kit/prose/model';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { $prose } from '@milkdown/kit/utils';
+import { shareableFragment } from './comments.js';
+import { diagramImage } from './mermaid.js';
 // Clipboard text is the visible document, not Markdown serialization: escaping
 // punctuation or trailing spaces here leaks source syntax into other apps.
 export function clipboardText(content, missingImages = new Set()) {
+    content = shareableFragment(content);
     const blocks = [];
     content.forEach((node) => {
         if (node.type.name !== 'reference_definition')
@@ -13,6 +16,11 @@ export function clipboardText(content, missingImages = new Set()) {
     return blocks.join(inline ? '' : '\n\n');
 }
 function nodeText(node, missingImages) {
+    if (node.type.name === 'inkkit_callout')
+        return `${node.attrs.title ||
+            String(node.attrs.kind)
+                .toLowerCase()
+                .replace(/^./, (letter) => letter.toUpperCase())}\n${clipboardText(node.content, missingImages)}`;
     if (node.type.name === 'reference_definition')
         return '';
     if (node.type.name === 'footnote_reference')
@@ -67,6 +75,7 @@ function nodeText(node, missingImages) {
     return clipboardText(node.content, missingImages);
 }
 export function clipboardContent(content, schema) {
+    content = shareableFragment(content);
     const container = document.createElement('div');
     const serializer = DOMSerializer.fromSchema(schema);
     // Construct image elements without a source so detached clipboard DOM never
@@ -102,7 +111,8 @@ export const visibleClipboard = $prose(() => new Plugin({
     },
 }));
 /** Export a frozen document fragment; presentation URLs never enter the clipboard. */
-export async function portableClipboard(content, schema, markdown, adapter, context) {
+export async function portableClipboard(content, schema, markdown, adapter, context, completeDiagrams) {
+    content = shareableFragment(content);
     const base = clipboardContent(content, schema);
     const container = document.createElement('div');
     container.innerHTML = base.html;
@@ -121,6 +131,7 @@ export async function portableClipboard(content, schema, markdown, adapter, cont
     });
     await Promise.all(captured.map(async ({ element, reference, alt }, index) => {
         element.setAttribute('data-inkkit-image-slot', String(index));
+        element.setAttribute('data-inkkit-authored-image-slot', String(index));
         try {
             if (!adapter)
                 throw new Error('The image is unavailable.');
@@ -143,6 +154,55 @@ export async function portableClipboard(content, schema, markdown, adapter, cont
             images[index] = { reference, alt, error: message };
         }
     }));
+    const diagrams = [];
+    for (const code of container.querySelectorAll('pre[data-language="mermaid"] > code')) {
+        const source = code.textContent ?? '';
+        if (completeDiagrams && !completeDiagrams.has(source))
+            continue;
+        const result = { source };
+        diagrams.push(result);
+        try {
+            const image = await diagramImage(source);
+            let binary = '';
+            for (const byte of image.bytes)
+                binary += String.fromCharCode(byte);
+            const figure = document.createElement('figure');
+            figure.setAttribute('data-inkkit-mermaid', source);
+            const fence = code.parentElement.getAttribute('data-inkkit-fence');
+            if (fence)
+                figure.setAttribute('data-inkkit-fence', fence);
+            const element = document.createElement('img');
+            element.src = `data:image/png;base64,${btoa(binary)}`;
+            element.alt = `Mermaid diagram: ${source}`;
+            figure.append(element);
+            code.parentElement.replaceWith(figure);
+            result.image = image;
+        }
+        catch (error) {
+            result.error =
+                error instanceof Error
+                    ? error.message
+                    : 'The diagram could not be exported.';
+            const warning = document.createElement('p');
+            warning.setAttribute('data-inkkit-diagram-error', '');
+            warning.textContent = `Diagram unavailable: ${result.error}`;
+            code.parentElement.before(warning);
+        }
+    }
+    // Native attachment slots follow DOM order, including generated diagrams.
+    const orderedImages = [];
+    for (const element of container.querySelectorAll('img')) {
+        const diagram = element.closest('[data-inkkit-mermaid]');
+        const item = diagram
+            ? {
+                reference: '',
+                alt: element.alt,
+                image: diagrams.find((entry) => entry.source === diagram.getAttribute('data-inkkit-mermaid')).image,
+            }
+            : images[Number(element.getAttribute('data-inkkit-image-slot'))];
+        element.setAttribute('data-inkkit-image-slot', String(orderedImages.length));
+        orderedImages.push(item);
+    }
     // Scriptable links and event attributes are not part of semantic rich text.
     for (const element of container.querySelectorAll('*')) {
         for (const attribute of [...element.attributes])
@@ -156,6 +216,7 @@ export async function portableClipboard(content, schema, markdown, adapter, cont
         text: clipboardText(content, missing),
         html: container.innerHTML,
         markdown,
-        images,
+        images: [...orderedImages, ...images.filter((image) => image.error)],
+        diagrams,
     };
 }

package/dist/code-fences.d.ts

@@ -0,0 +1,8 @@
+import { type Options } from 'mdast-util-to-markdown';
+import type { Ctx } from '@milkdown/kit/ctx';
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+export declare const remarkCodeFences: import("@milkdown/kit/utils").$Remark<"codeFences", unknown>;
+export declare const preservingCodeBlocks: import("@milkdown/kit/utils").$NodeSchema<"code_block">;
+export declare const fencedCodeHandler: NonNullable<Options['handlers']>['code'];
+export declare function restoreCodeEndings(ctx: Ctx, doc: ProseNode, markdown: string): string;
+export declare function finalCodeEnding(doc: ProseNode): string | undefined;

package/dist/code-fences.js

@@ -0,0 +1,166 @@
+import { codeBlockSchema } from '@milkdown/kit/preset/commonmark';
+import { $remark } from '@milkdown/kit/utils';
+import { defaultHandlers } from 'mdast-util-to-markdown';
+import { remarkCtx } from '@milkdown/kit/core';
+function readFence(value) {
+    if (typeof value !== 'object' || value == null)
+        return null;
+    const fence = value;
+    return typeof fence.marker === 'string' &&
+        /^(?:`{3,}|~{3,})$/.test(fence.marker) &&
+        fence.marker.length <= 30000 &&
+        typeof fence.info === 'string' &&
+        !/[\r\n]/.test(fence.info) &&
+        typeof fence.close === 'string' &&
+        (!fence.close ||
+            new RegExp(`^${fence.marker[0]}{${fence.marker.length},}$`).test(fence.close)) &&
+        typeof fence.trailing === 'string' &&
+        /^[ \t]*$/.test(fence.trailing) &&
+        ['\n', '\r\n'].includes(fence.ending)
+        ? fence
+        : null;
+}
+export const remarkCodeFences = $remark('codeFences', () => () => (tree, file) => {
+    const source = String(file.value).replace(/^\uFEFF/, '');
+    const visit = (node) => {
+        if (node.type === 'code') {
+            const raw = source.slice(node.position?.start.offset, node.position?.end.offset);
+            const opening = /^(`{3,}|~{3,})([^\r\n]*)(\r?\n)/.exec(raw);
+            if (opening) {
+                const close = /(?:^|\n)[ \t>]*(`{3,}|~{3,})([ \t]*)\r?$/.exec(raw);
+                const matching = close &&
+                    close[1][0] === opening[1][0] &&
+                    close[1].length >= opening[1].length;
+                node.data = {
+                    ...node.data,
+                    inkkitFence: {
+                        marker: opening[1],
+                        info: opening[2],
+                        close: matching ? close[1] : '',
+                        trailing: matching ? close[2] : '',
+                        ending: opening[3],
+                    },
+                };
+            }
+        }
+        if ('children' in node)
+            node.children.forEach(visit);
+    };
+    visit(tree);
+});
+export const preservingCodeBlocks = codeBlockSchema.extendSchema((base) => (ctx) => {
+    const schema = base(ctx);
+    return {
+        ...schema,
+        attrs: { ...schema.attrs, authoredFence: { default: null } },
+        parseDOM: [
+            {
+                tag: 'pre',
+                preserveWhitespace: 'full',
+                getAttrs: (dom) => {
+                    let authoredFence = null;
+                    try {
+                        authoredFence = readFence(JSON.parse(dom.getAttribute('data-inkkit-fence') ?? 'null'));
+                    }
+                    catch {
+                        /* Ordinary code stays usable without provenance. */
+                    }
+                    return { language: dom.dataset.language ?? '', authoredFence };
+                },
+            },
+        ],
+        toDOM: (node) => [
+            'pre',
+            {
+                'data-language': node.attrs.language,
+                ...(node.attrs.authoredFence
+                    ? { 'data-inkkit-fence': JSON.stringify(node.attrs.authoredFence) }
+                    : {}),
+            },
+            ['code', 0],
+        ],
+        parseMarkdown: {
+            match: (node) => node.type === 'code',
+            runner: (state, node, type) => {
+                state.openNode(type, {
+                    language: node.lang ?? '',
+                    authoredFence: readFence(node.data?.inkkitFence),
+                });
+                if (node.value)
+                    state.addText(String(node.value).replace(/\r\n?/g, '\n'));
+                state.closeNode();
+            },
+        },
+        toMarkdown: {
+            match: (node) => node.type.name === 'code_block',
+            runner: (state, node) => {
+                state.addNode('code', undefined, node.textContent, {
+                    lang: node.attrs.language,
+                    data: { inkkitFence: node.attrs.authoredFence },
+                });
+            },
+        },
+    };
+});
+export const fencedCodeHandler = (node, parent, state, info) => {
+    const fence = readFence(node.data?.inkkitFence);
+    if (!fence)
+        return defaultHandlers.code(node, parent, state, info);
+    const character = fence.marker[0];
+    let length = fence.marker.length;
+    const body = node.value.replace(/\r\n?/g, '\n');
+    for (const line of body.split('\n')) {
+        const run = new RegExp(`^ {0,3}(${character}+)[ \\t]*$`).exec(line);
+        if (run)
+            length = Math.max(length, run[1].length + 1);
+    }
+    const close = fence.close
+        ? character.repeat(Math.max(length, fence.close.length)) + fence.trailing
+        : '';
+    return (character.repeat(length) +
+        fence.info +
+        fence.ending +
+        body.replaceAll('\n', fence.ending) +
+        (close ? (body ? fence.ending : '') + close : ''));
+};
+export function restoreCodeEndings(ctx, doc, markdown) {
+    const endings = [];
+    doc.descendants((node) => {
+        if (node.type.name === 'code_block')
+            endings.push(readFence(node.attrs.authoredFence)?.ending ?? '\n');
+    });
+    const patches = [];
+    let index = 0;
+    const visit = (node) => {
+        if (node.type === 'code') {
+            const ending = endings[index++];
+            const from = node.position?.start.offset, to = node.position?.end.offset;
+            if (ending === '\r\n' && from != null && to != null)
+                patches.push({
+                    from,
+                    to,
+                    text: markdown
+                        .slice(from, to)
+                        .replace(/\r\n?/g, '\n')
+                        .replaceAll('\n', ending),
+                });
+        }
+        if ('children' in node)
+            node.children.forEach(visit);
+    };
+    const processor = ctx.get(remarkCtx);
+    visit(processor.runSync(processor.parse(markdown), { value: markdown }));
+    for (const patch of patches.reverse())
+        markdown =
+            markdown.slice(0, patch.from) + patch.text + markdown.slice(patch.to);
+    return markdown;
+}
+export function finalCodeEnding(doc) {
+    let last = doc.lastChild;
+    while (last) {
+        if (last.type.name === 'code_block')
+            return readFence(last.attrs.authoredFence)?.ending;
+        last = last.lastChild;
+    }
+    return undefined;
+}