@esportsplus/ui 0.56.3 → 0.57.0

package/build/components/inline-edit/history.js

@@ -0,0 +1,40 @@
+const LIMIT = 200;
+const MERGE_WITHIN = 1000;
+function equal(a, b) {
+    return !!a && !!b
+        && a.anchor.block === b.anchor.block
+        && a.anchor.offset === b.anchor.offset
+        && a.focus.block === b.focus.block
+        && a.focus.offset === b.focus.offset;
+}
+export default () => {
+    let last = { after: null, at: 0, kind: 'other' }, redo = [], undo = [];
+    function step(from, to, current) {
+        let entry = from.pop();
+        if (entry) {
+            to.push(current);
+        }
+        last = { after: null, at: 0, kind: 'other' };
+        return entry ?? null;
+    }
+    return {
+        clear: () => {
+            last = { after: null, at: 0, kind: 'other' };
+            redo.length = 0;
+            undo.length = 0;
+        },
+        push: (before, after, kind) => {
+            let now = Date.now();
+            if (kind === 'other' || kind !== last.kind || now - last.at > MERGE_WITHIN || !equal(before.selection, last.after)) {
+                undo.push(before);
+                if (undo.length > LIMIT) {
+                    undo.shift();
+                }
+            }
+            last = { after, at: now, kind };
+            redo.length = 0;
+        },
+        redo: (current) => step(redo, undo, current),
+        undo: (current) => step(undo, redo, current)
+    };
+};

package/build/components/inline-edit/index.d.ts

@@ -1,17 +1,21 @@
+import * as template_u1 from '@esportsplus/template';
 import { type Attributes } from '@esportsplus/template';
 import input from '../input/index.js';
+import rich from './rich.js';
+import { INLINE_EDIT_STATUS, type Status } from './status.js';
 import './scss/index.scss';
 type A = Attributes & {
     [INLINE_EDIT_DISPLAY]?: Attributes;
     [INLINE_EDIT_FIELD]?: Field;
+    [INLINE_EDIT_STATUS]?: Attributes;
     label: string;
     multiline?: boolean;
-    onsave?: (value: string) => void;
+    onsave?: (value: string) => unknown;
     placeholder?: string;
     state?: State;
+    status?: boolean | Status;
     value?: string;
 };
-type D = Attributes & Pick<A, typeof INLINE_EDIT_DISPLAY | typeof INLINE_EDIT_FIELD>;
 type Field = Parameters<typeof input>[0];
 type State = {
     editing: boolean;
@@ -20,11 +24,13 @@ type State = {
 };
 declare const INLINE_EDIT_DISPLAY: unique symbol;
 declare const INLINE_EDIT_FIELD: unique symbol;
-declare function template(this: {
-    attributes?: D;
-} | void, { label, multiline, onsave, placeholder, value, state, ...attributes }: A): DocumentFragment | Text;
-declare const _default: typeof template & {
+declare const plain: template_u1.Factory<A, template_u1.Renderable<any>, template_u1.Renderable<any>, {
     readonly display: typeof INLINE_EDIT_DISPLAY;
     readonly field: typeof INLINE_EDIT_FIELD;
+    readonly status: typeof INLINE_EDIT_STATUS;
+}>;
+declare const inlineEdit: typeof plain & {
+    rich: typeof rich;
 };
-export default _default;
+export default inlineEdit;
+export type { Status };

package/build/components/inline-edit/index.js

@@ -1,9 +1,15 @@
 import * as template_u1 from '@esportsplus/template';
+import { component } from '@esportsplus/template';
 import * as reactivity_u0 from '@esportsplus/reactivity';
+import { flush } from '@esportsplus/reactivity';
 import input from '../input/index.js';
 import textarea from '../textarea/index.js';
+import rich from './rich.js';
+import status, { INLINE_EDIT_STATUS } from './status.js';
+import check from '@esportsplus/ui/svg/check.svg';
+import pencil from '@esportsplus/ui/svg/pencil.svg';
 import './scss/index.scss';
-const template_13ikqx12 = template_u1.template(`<div class='inline-edit'><button class='inline-edit-display' type='button'><span class='inline-edit-label'>Edit <!--$-->: </span></button><!--$--><span aria-hidden='true' class='inline-edit-icon'><svg class='inline-edit-icon-pencil' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' viewBox='0 0 16 16'><path d='M9.75 3.75 12.25 6.25M3.25 12.75l.6-2.6 6.9-6.9a1.25 1.25 0 0 1 1.77 0l.73.73a1.25 1.25 0 0 1 0 1.77l-6.9 6.9Z' /></svg><svg class='inline-edit-icon-check' fill='none' stroke='currentColor' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' viewBox='0 0 16 16'><path d='m3.5 8.5 3 3 6-7' />`);
+const template_13ikqx12 = template_u1.template(`<div class='inline-edit'><button class='inline-edit-display' type='button'><span class='inline-edit-label'>Edit <!--$-->: </span></button><!--$--><span aria-hidden='true' class='inline-edit-icon'><svg class='inline-edit-icon-pencil'><use /></svg><svg class='inline-edit-icon-check'><use />`);
 class ReactiveObject_13ikqx10 extends reactivity_u0.ReactiveObject {
     #draft = this[reactivity_u0.SIGNAL]('');
     constructor() {
@@ -16,11 +22,14 @@ class ReactiveObject_13ikqx10 extends reactivity_u0.ReactiveObject {
         reactivity_u0.write(this.#draft, _v0);
     }
 }
+const WHITESPACE = /\s+/g;
 const INLINE_EDIT_DISPLAY = Symbol.for('@esportsplus/ui/inline-edit.display');
 const INLINE_EDIT_FIELD = Symbol.for('@esportsplus/ui/inline-edit.field');
-const SAVED_FOR = 1600;
-function template({ label, multiline = false, onsave, placeholder = '', value = '', state = reactivity_u0.reactive({ editing: false, saved: false, value }), ...attributes }) {
-    let display, draft = '', local = new ReactiveObject_13ikqx10(), parts = { ...this?.attributes?.[INLINE_EDIT_FIELD], ...attributes[INLINE_EDIT_FIELD] }, timer;
+function template({ label, multiline = false, onsave, placeholder = '', status: shown = false, value = '', state = reactivity_u0.reactive({ editing: false, saved: false, value }), ...attributes }) {
+    let display, draft = '', local = new ReactiveObject_13ikqx10(), parts = { ...this?.attributes?.[INLINE_EDIT_FIELD], ...attributes[INLINE_EDIT_FIELD] }, saving = status.saver(state, shown, () => clean(local.draft) !== state.value, onsave);
+    function clean(value) {
+        return multiline ? value.trim() : value.replace(WHITESPACE, ' ').trim();
+    }
     function field() {
         let own = {
             'aria-label': label,
@@ -47,7 +56,7 @@ function template({ label, multiline = false, onsave, placeholder = '', value =
             value: draft
         };
         if (multiline) {
-            return textarea.bind({ attributes: parts })({ ...own, rows: 1 });
+            return textarea.call({ attributes: parts }, { ...own, rows: 1 });
         }
         return input.call({ attributes: parts }, own);
     }
@@ -57,33 +66,27 @@ function template({ label, multiline = false, onsave, placeholder = '', value =
         }
         state.editing = false;
         if (keyboard) {
-            requestAnimationFrame(() => requestAnimationFrame(() => display?.focus()));
+            flush();
+            display?.focus();
         }
-        let next = multiline ? local.draft.trim() : local.draft.replace(/\s+/g, ' ').trim();
-        if (!commit || next === state.value) {
-            return;
+        let next = clean(local.draft);
+        if (commit && next !== state.value) {
+            saving.save(next);
         }
-        state.value = next;
-        state.saved = true;
-        onsave?.(next);
-        clearTimeout(timer);
-        timer = setTimeout(() => {
-            state.saved = false;
-        }, SAVED_FOR);
     }
     return (() => {
-        let root_13ikqx11 = template_13ikqx12(), element_13ikqx13 = root_13ikqx11.firstChild, element_13ikqx14 = element_13ikqx13.firstElementChild, element_13ikqx15 = element_13ikqx14.firstElementChild.firstChild.nextSibling, element_13ikqx16 = element_13ikqx13.firstChild.nextSibling;
-        template_u1.setProperties(element_13ikqx13, this?.attributes);
-        template_u1.setProperties(element_13ikqx13, attributes);
-        template_u1.setList(element_13ikqx13, 'class', [
-            multiline && 'inline-edit--multiline',
-            () => state.editing && '--active',
-            () => state.saved && '--saved',
-            () => state.value.trim() === '' && '--empty'
-        ]);
-        template_u1.ondisconnect(element_13ikqx13, () => {
-            clearTimeout(timer);
-        });
+        let root_13ikqx11 = template_13ikqx12(), element_13ikqx13 = root_13ikqx11.firstChild, element_13ikqx14 = element_13ikqx13.firstElementChild, element_13ikqx15 = element_13ikqx14.firstElementChild.firstChild.nextSibling, element_13ikqx16 = element_13ikqx13.firstChild.nextSibling, element_13ikqx17 = element_13ikqx14.nextElementSibling.firstElementChild.firstElementChild, element_13ikqx18 = element_13ikqx14.nextElementSibling.firstElementChild.nextElementSibling.firstElementChild;
+        template_u1.slot(element_13ikqx15, label);
+        new template_u1.EffectSlot(element_13ikqx14, () => {
+            if (state.editing) {
+                return `${local.draft} `;
+            }
+            return state.value.trim() === '' ? placeholder : state.value;
+        }, 2);
+        new template_u1.EffectSlot(element_13ikqx16, () => state.editing && field());
+        template_u1.slot(element_13ikqx13, saving.status && status.render(saving.status, this?.attributes?.[INLINE_EDIT_STATUS], attributes[INLINE_EDIT_STATUS]), 2);
+        template_u1.setProperty(element_13ikqx18, 'href', template_u1.interpolate(["#", (check)]));
+        template_u1.setProperty(element_13ikqx17, 'href', template_u1.interpolate(["#", (pencil)]));
         template_u1.setProperties(element_13ikqx14, this?.attributes?.[INLINE_EDIT_DISPLAY]);
         template_u1.setProperties(element_13ikqx14, attributes[INLINE_EDIT_DISPLAY]);
         template_u1.delegate(element_13ikqx14, 'click', () => {
@@ -91,18 +94,21 @@ function template({ label, multiline = false, onsave, placeholder = '', value =
             local.draft = draft;
             state.editing = true;
         });
-        template_u1.onrender(element_13ikqx14, (element) => {
+        template_u1.onconnect(element_13ikqx14, (element) => {
             display = element;
         });
-        template_u1.slot(element_13ikqx15, label);
-        new template_u1.EffectSlot(element_13ikqx14, () => {
-            if (state.editing) {
-                return `${local.draft} `;
-            }
-            return state.value.trim() === '' ? placeholder : state.value;
-        }, 2);
-        new template_u1.EffectSlot(element_13ikqx16, () => state.editing ? field() : '');
+        template_u1.setProperties(element_13ikqx13, this?.attributes);
+        template_u1.setProperties(element_13ikqx13, attributes);
+        template_u1.setList(element_13ikqx13, 'class', [
+            multiline && 'inline-edit--multiline',
+            () => state.editing && '--active',
+            () => state.saved && 'inline-edit--saved',
+            () => state.value.trim() === '' && 'inline-edit--empty'
+        ]);
+        template_u1.ondisconnect(element_13ikqx13, saving.dispose);
         return root_13ikqx11;
     })();
 }
-export default Object.assign(template, { display: INLINE_EDIT_DISPLAY, field: INLINE_EDIT_FIELD });
+const plain = component(template, { display: INLINE_EDIT_DISPLAY, field: INLINE_EDIT_FIELD, status: INLINE_EDIT_STATUS });
+const inlineEdit = Object.assign(plain, { rich });
+export default inlineEdit;

package/build/components/inline-edit/markdown.d.ts

@@ -0,0 +1,7 @@
+import { type Doc, type Mark } from './model.js';
+type Feature = Group | Mark | 'clear' | 'copy';
+type Group = 'bullet' | 'codeblock' | 'heading' | 'ordered' | 'quote' | 'task';
+declare const parse: (markdown: string, features: Set<Feature>, multiline: boolean) => Doc;
+declare const serialize: (doc: Doc, features: Set<Feature>, multiline: boolean) => string;
+export { parse, serialize };
+export type { Feature, Group };

package/build/components/inline-edit/markdown.js

@@ -0,0 +1,314 @@
+import { block, list, nest, sort, text } from './model.js';
+import { INLINE_LINE_BREAKS, NON_BREAKING_SPACES, safe } from './utilities.js';
+const BACKSLASHES = /\\/g;
+const EMPHASIS_DELIMITERS = /[*_]/g;
+const NON_WHITESPACE = /\S/;
+const WORD_CHARACTER = /\w/;
+const BACKTICKS = /`/g;
+const BRACKETS = /[[\]]/g;
+const NEWLINES = /\n/g;
+const LINK_CHARACTERS = /[()\s]/g;
+const HEADING_PREFIX = /^#{1,6}\s/;
+const BULLET_PREFIX = /^[-*+]\s/;
+const ORDERED_PREFIX = /^\d+[.)]\s/;
+const ORDERED_NUMBER = /^(\d+)/;
+const SURROUNDING_NEWLINES = /^\n+|\n+$/g;
+const ESCAPED_PUNCTUATION = /\\([!-/:-@[-`{-~])/g;
+const TRAILING_NEWLINES = /\n+$/;
+const WHITESPACE = /\s+/g;
+const LINE_BREAKS = /\r\n?/g;
+const SUPPORTED_HEADING_PREFIX = /^#{1,3}\s/;
+const QUOTE_PREFIX = /^>/;
+const CODEBLOCK_PREFIX = /^```/;
+const HEADING = /^(#{1,3})\s+(.*)$/;
+const QUOTE_MARKER = /^>\s?/;
+const TASK_PREFIX = /^[-*+]\s+\[[ xX]\]\s/;
+const TASK_ITEM = /^[-*+]\s+\[([ xX])\]\s+(.*)$/;
+const BULLET_ITEM = /^[-*+]\s+()(.*)$/;
+const ORDERED_ITEM = /^\d+[.)]\s+()(.*)$/;
+const MARK_PAIRS = {
+    '=': /==/g,
+    '~': /~~/g
+};
+const PARAGRAPHS = new WeakMap();
+const PARKED = /[-]/g;
+const RULES = [
+    { mark: 'code', pattern: /`([^`\n]+)`/ },
+    { mark: 'link', pattern: /\[([^\]\n]+)\]\(((?:[^()\s]|\([^()\s]*\))+)\)/ },
+    { mark: 'bold', pattern: /\*\*(?=\S)([^\n]*?\S)\*\*/ },
+    { mark: 'strike', pattern: /~~(?=\S)([^\n]*?\S)~~/ },
+    { mark: 'highlight', pattern: /==(?=\S)([^\n]*?\S)==/ },
+    { mark: 'italic', pattern: /(?<![\w\\])_(?=\S)([^\n]*?\S)_(?!\w)|(?<!\*)\*(?=[^\s*])([^\n]*?[^\s*])\*(?!\*)/ }
+];
+function escape(text, features) {
+    text = text.replace(BACKSLASHES, '\\\\');
+    if (features.has('bold') || features.has('italic')) {
+        text = text.replace(EMPHASIS_DELIMITERS, (c, i, s) => {
+            let after = s[i + 1] ?? '', before = s[i - 1] ?? '';
+            let delimits = c === '*'
+                ? NON_WHITESPACE.test(before) || NON_WHITESPACE.test(after)
+                : (!WORD_CHARACTER.test(before) && NON_WHITESPACE.test(after)) || (NON_WHITESPACE.test(before) && !WORD_CHARACTER.test(after));
+            return delimits ? `\\${c}` : c;
+        });
+    }
+    if (features.has('code')) {
+        text = text.replace(BACKTICKS, '\\`');
+    }
+    if (features.has('highlight')) {
+        text = pairs(text, '=');
+    }
+    if (features.has('link')) {
+        text = text.replace(BRACKETS, '\\$&');
+    }
+    if (features.has('strike')) {
+        text = pairs(text, '~');
+    }
+    return text;
+}
+function first(tree) {
+    if (!tree) {
+        return '';
+    }
+    return 'text' in tree ? tree.text[0] ?? '' : first(tree.children[0]);
+}
+function inline(trees, features) {
+    let out = '';
+    for (let i = 0, n = trees.length; i < n; i++) {
+        let tree = trees[i];
+        if ('text' in tree) {
+            out += escape(tree.text.replace(NON_BREAKING_SPACES, ' '), features);
+            continue;
+        }
+        if (!features.has(tree.mark)) {
+            out += inline(tree.children, features);
+            continue;
+        }
+        if (tree.mark === 'code') {
+            let value = plain(tree).replace(NEWLINES, ' ');
+            out += value.includes('`') ? `\`\` ${value} \`\`` : `\`${value}\``;
+            continue;
+        }
+        let value = inline(tree.children, features), core = value.trim();
+        if (!core) {
+            out += value;
+            continue;
+        }
+        let lead = value.slice(0, value.indexOf(core)), trail = value.slice(value.indexOf(core) + core.length);
+        if (tree.mark === 'link') {
+            out += lead + (safe(tree.href) ? `[${core}](${tree.href.replace(LINK_CHARACTERS, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`)})` : core) + trail;
+        }
+        else {
+            out += lead + wrap(tree.mark, core, (out + lead).slice(-1), trail[0] ?? first(trees[i + 1])) + trail;
+        }
+    }
+    return out;
+}
+function marks(value, features, style, out) {
+    while (value) {
+        let found = null;
+        for (let i = 0, n = RULES.length; i < n; i++) {
+            let rule = RULES[i];
+            if (!features.has(rule.mark)) {
+                continue;
+            }
+            let match = rule.pattern.exec(value);
+            if (match && (!found || match.index < found.match.index)) {
+                found = { match, rule };
+            }
+        }
+        if (!found) {
+            out.push({ ...style, text: unpark(value) });
+            return;
+        }
+        let { match, rule } = found;
+        if (match.index > 0) {
+            out.push({ ...style, text: unpark(value.slice(0, match.index)) });
+        }
+        value = value.slice(match.index + match[0].length);
+        if (rule.mark === 'code') {
+            out.push({ href: style.href, marks: sort([...style.marks, 'code']), text: unpark(match[1], true) });
+        }
+        else if (rule.mark === 'link') {
+            let href = unpark(match[2]);
+            marks(match[1], features, safe(href) ? { ...style, href } : style, out);
+        }
+        else {
+            marks(match[1] ?? match[2], features, { ...style, marks: sort([...style.marks, rule.mark]) }, out);
+        }
+    }
+}
+function pairs(text, c) {
+    return text.replace(MARK_PAIRS[c], (pair, i, s) => NON_WHITESPACE.test(s[i - 1] ?? '') || NON_WHITESPACE.test(s[i + 2] ?? '') ? `\\${c}\\${c}` : pair);
+}
+function paragraph(runs, features) {
+    let memo = PARAGRAPHS.get(features);
+    if (!memo) {
+        PARAGRAPHS.set(features, memo = new WeakMap());
+    }
+    let out = memo.get(runs);
+    if (out === undefined) {
+        memo.set(runs, out = prose(runs, features));
+    }
+    return out;
+}
+function park(text) {
+    return text.replace(ESCAPED_PUNCTUATION, (_, c) => String.fromCharCode(0xE000 + c.charCodeAt(0)));
+}
+function plain(tree) {
+    return 'text' in tree ? tree.text : tree.children.map(plain).join('');
+}
+function prose(runs, features) {
+    return inline(nest(runs), features)
+        .split('\n')
+        .map((line) => {
+        line = line.trim();
+        if ((features.has('heading') && HEADING_PREFIX.test(line)) ||
+            (features.has('quote') && line[0] === '>') ||
+            ((features.has('bullet') || features.has('task')) && BULLET_PREFIX.test(line))) {
+            return `\\${line}`;
+        }
+        if (features.has('ordered') && ORDERED_PREFIX.test(line)) {
+            return line.replace(ORDERED_NUMBER, '$1\\');
+        }
+        if (features.has('codeblock') && line.startsWith('```')) {
+            return `\\${line}`;
+        }
+        return line;
+    })
+        .join('\n')
+        .replace(SURROUNDING_NEWLINES, '');
+}
+function runs(value, features) {
+    let out = [];
+    marks(park(value), features, { href: '', marks: [], text: '' }, out);
+    return out;
+}
+function unpark(text, code = false) {
+    return text.replace(PARKED, (c) => (code ? '\\' : '') + String.fromCharCode(c.charCodeAt(0) - 0xE000));
+}
+function wrap(mark, text, before, after) {
+    switch (mark) {
+        case 'bold':
+            return `**${text}**`;
+        case 'highlight':
+            return `==${text}==`;
+        case 'italic':
+            return WORD_CHARACTER.test(before) || WORD_CHARACTER.test(after) ? `*${text}*` : `_${text}_`;
+        default:
+            return `~~${text}~~`;
+    }
+}
+function write(group, features) {
+    let { kind, runs } = group[0];
+    if (list(kind)) {
+        let enabled = features.has(kind), lines = [];
+        for (let i = 0, n = group.length; i < n; i++) {
+            let value = paragraph(group[i].runs, features).replace(NEWLINES, ' ');
+            if (!enabled) {
+                lines.push(value);
+            }
+            else if (kind === 'ordered') {
+                lines.push(`${i + 1}. ${value}`);
+            }
+            else if (kind === 'task') {
+                lines.push(`- [${group[i].checked ? 'x' : ' '}] ${value}`);
+            }
+            else {
+                lines.push(`- ${value}`);
+            }
+        }
+        return lines.filter(Boolean).join(enabled ? '\n' : '\n\n');
+    }
+    if (kind === 'codeblock') {
+        let value = text(runs).replace(TRAILING_NEWLINES, '');
+        return features.has('codeblock') ? `\`\`\`\n${value}\n\`\`\`` : prose([{ href: '', marks: [], text: value }], features);
+    }
+    let value = paragraph(runs, features);
+    if (kind === 'quote') {
+        return features.has('quote') && value ? value.split('\n').map((line) => `> ${line}`).join('\n') : value;
+    }
+    if (kind[0] === 'h') {
+        return features.has('heading') && value ? `${'#'.repeat(Number(kind[1]))} ${value.replace(NEWLINES, ' ')}` : value;
+    }
+    return value;
+}
+const parse = (markdown, features, multiline) => {
+    if (!multiline) {
+        return [block('paragraph', runs(markdown.replace(WHITESPACE, ' ').trim(), features))];
+    }
+    let doc = [], lines = markdown.replace(LINE_BREAKS, '\n').split('\n'), n = lines.length;
+    let opens = (line) => (features.has('heading') && SUPPORTED_HEADING_PREFIX.test(line)) ||
+        (features.has('quote') && QUOTE_PREFIX.test(line)) ||
+        (features.has('codeblock') && CODEBLOCK_PREFIX.test(line)) ||
+        ((features.has('bullet') || features.has('task')) && BULLET_PREFIX.test(line)) ||
+        (features.has('ordered') && ORDERED_PREFIX.test(line));
+    for (let i = 0; i < n;) {
+        let line = lines[i], match;
+        if (!line.trim()) {
+            i++;
+            continue;
+        }
+        if (features.has('codeblock') && line.startsWith('```')) {
+            let body = [];
+            for (i++; i < n && !lines[i].startsWith('```'); i++) {
+                body.push(lines[i]);
+            }
+            doc.push(block('codeblock', body.length && body.join('\n') ? [{ href: '', marks: [], text: body.join('\n') }] : []));
+            i++;
+            continue;
+        }
+        if (features.has('heading') && (match = line.match(HEADING))) {
+            doc.push(block(`h${match[1].length}`, runs(match[2].trim(), features)));
+            i++;
+            continue;
+        }
+        if (features.has('quote') && line.startsWith('>')) {
+            let body = [];
+            for (; i < n && lines[i].startsWith('>'); i++) {
+                body.push(lines[i].replace(QUOTE_MARKER, ''));
+            }
+            doc.push(block('quote', runs(body.join('\n'), features)));
+            continue;
+        }
+        let kind = ((features.has('task') && TASK_PREFIX.test(line) && 'task') ||
+            (features.has('bullet') && BULLET_PREFIX.test(line) && 'bullet') ||
+            (features.has('ordered') && ORDERED_PREFIX.test(line) && 'ordered'));
+        if (kind) {
+            let pattern = kind === 'task' ? TASK_ITEM : kind === 'bullet' ? BULLET_ITEM : ORDERED_ITEM;
+            for (; i < n && (match = lines[i].match(pattern)); i++) {
+                doc.push(block(kind, runs(match[2].trim(), features), kind === 'task' && match[1] !== ' '));
+            }
+            continue;
+        }
+        let body = [];
+        for (; i < n && lines[i].trim() && (!body.length || !opens(lines[i])); i++) {
+            body.push(lines[i].trim());
+        }
+        doc.push(block('paragraph', runs(body.join('\n'), features)));
+    }
+    if (!doc.length) {
+        doc.push(block('paragraph', []));
+    }
+    return doc;
+};
+const serialize = (doc, features, multiline) => {
+    if (!multiline) {
+        return doc.map((b) => inline(nest(b.runs), features)).join(' ').replace(INLINE_LINE_BREAKS, ' ').trim();
+    }
+    let out = [];
+    for (let i = 0, n = doc.length; i < n;) {
+        let j = i + 1;
+        if (list(doc[i].kind)) {
+            while (j < n && doc[j].kind === doc[i].kind) {
+                j++;
+            }
+        }
+        let value = write(doc.slice(i, j), features);
+        if (value) {
+            out.push(value);
+        }
+        i = j;
+    }
+    return out.join('\n\n').trim();
+};
+export { parse, serialize };

package/build/components/inline-edit/model.d.ts

@@ -0,0 +1,61 @@
+type Block = {
+    checked: boolean;
+    key: symbol;
+    kind: Kind;
+    runs: Run[];
+};
+type Doc = Block[];
+type Edit = {
+    doc: Doc;
+    selection: Selection;
+};
+type Kind = 'bullet' | 'codeblock' | 'h1' | 'h2' | 'h3' | 'ordered' | 'paragraph' | 'quote' | 'task';
+type Mark = 'bold' | 'code' | 'highlight' | 'italic' | 'link' | 'strike';
+type Pos = {
+    block: number;
+    offset: number;
+};
+type Run = {
+    href: string;
+    marks: Mark[];
+    text: string;
+};
+type Selection = {
+    anchor: Pos;
+    focus: Pos;
+};
+type Span = {
+    end: Pos;
+    start: Pos;
+};
+type Tree = {
+    children: Tree[];
+    href: string;
+    mark: Mark;
+} | {
+    text: string;
+};
+declare const LAYERS: Mark[];
+declare const block: (kind: Kind, runs: Run[], checked?: boolean) => Block;
+declare const caret: (pos: Pos) => Selection;
+declare const cut: (runs: Run[], from: number, to?: number) => Run[];
+declare const empty: (doc: Doc) => boolean;
+declare const has: (run: Run, mark: Mark) => boolean;
+declare const insert: (doc: Doc, span: Span, runs: Run[]) => Edit;
+declare const join: (...lists: Run[][]) => Run[];
+declare const length: (runs: Run[]) => number;
+declare const list: (kind: Kind) => boolean;
+declare const nest: (runs: Run[], depth?: number) => Tree[];
+declare const order: ({ anchor, focus }: Selection) => Span;
+declare const paste: (doc: Doc, span: Span, blocks: Doc) => Edit;
+declare const plain: (runs: Run[]) => Run[];
+declare const remove: (doc: Doc, { end, start }: Span) => Edit;
+declare const restyle: (runs: Run[], from: number, to: number, fn: (run: Run) => Run) => Run[];
+declare const same: (a: Run, b: Run) => boolean;
+declare const slice: (doc: Doc, { end, start }: Span) => Doc;
+declare const sort: (marks: Mark[]) => Mark[];
+declare const split: (doc: Doc, span: Span) => Edit;
+declare const styleAt: (runs: Run[], offset: number) => Run;
+declare const text: (runs: Run[]) => string;
+export { block, caret, cut, empty, has, insert, join, LAYERS, length, list, nest, order, paste, plain, remove, restyle, same, slice, sort, split, styleAt, text };
+export type { Block, Doc, Edit, Kind, Mark, Pos, Run, Selection, Span, Tree };