@atom-forge/brickee 0.0.0-stage → 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { default as Editor } from './Editor.svelte';
+export { default as Preview } from './Preview.svelte';
+export { default as Frame } from './kit/Frame.svelte';
+export { default as Empty } from './kit/Empty.svelte';
+export * from './kit/util';
+export * from './model';
+export { inline, fromStored, toStored, fromMarkdown, toMarkdown } from './markdown';
+export { provideMedia, useMedia, findMedia, type MediaItem } from './media';
+export { provideView, useView } from './view';
+export { scrollSync, scrollFraction, setScrollFraction, type ScrollSync } from './scroll';
+export { provideText, useText, translator, type Messages, type Translate } from './i18n';
+export { PALETTE_ITEMS, BUILT_IN_IDS, narrowPalette, type Icon, type PaletteItem } from './palette';
+export type { MarkdownContext, Block, BlockType, Content, PluginPreviewProps, PluginViewProps, PropField, Props, BlockPlugin } from './types';

package/dist/index.js

@@ -0,0 +1,16 @@
+// block-editor: a Svelte 5 block editor. The core is markdown (`md:p`, `md:h2`, `md:code`…) plus the kit to write plugins
+// with; every other block is a plugin with an editor view, a site preview and optionally a markdown form. The bundled
+// plugins (block-editor/plugins) are plugins like any other. The stored form is `StoredBlock[]` (see model.ts).
+export { default as Editor } from './Editor.svelte';
+export { default as Preview } from './Preview.svelte';
+// The kit: what plugins are written with (box frame, empty state, helpers).
+export { default as Frame } from './kit/Frame.svelte';
+export { default as Empty } from './kit/Empty.svelte';
+export * from './kit/util';
+export * from './model';
+export { inline, fromStored, toStored, fromMarkdown, toMarkdown } from './markdown';
+export { provideMedia, useMedia, findMedia } from './media';
+export { provideView, useView } from './view';
+export { scrollSync, scrollFraction, setScrollFraction } from './scroll';
+export { provideText, useText, translator } from './i18n';
+export { PALETTE_ITEMS, BUILT_IN_IDS, narrowPalette } from './palette';

package/dist/kit/Empty.svelte

@@ -0,0 +1,24 @@
+<!-- What a plugin without content shows until its props are set. -->
+<script lang="ts">
+	import { useText } from '../i18n';
+	import type { Icon } from '../palette';
+
+	let { icon: I, text }: { icon: Icon; text: string } = $props();
+	const tr = useText();
+</script>
+
+<div class="empty"><I size={18} /> {tr(text)}</div>
+
+<style>
+	.empty {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		gap: 8px;
+		min-height: 96px;
+		border: 1px dashed #d4d4da;
+		border-radius: 10px;
+		color: #a0a0a8;
+		font: 14px system-ui, sans-serif;
+	}
+</style>

package/dist/kit/Empty.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Icon } from '../palette';
+type $$ComponentProps = {
+    icon: Icon;
+    text: string;
+};
+declare const Empty: import("svelte").Component<$$ComponentProps, {}, "">;
+type Empty = ReturnType<typeof Empty>;
+export default Empty;

package/dist/kit/Frame.svelte

@@ -0,0 +1,76 @@
+<!-- The editor look of a plugin with nested blocks: a thin frame with the block's fields on its top (or, read-only, a
+     heading line), and the nested editor. -->
+<script lang="ts">
+	import { useText } from '../i18n';
+	import Editor from '../Editor.svelte';
+	import { claimFields } from '../PluginHost.svelte';
+	import type { BlockPlugin, StoredBlock } from '../types';
+
+	interface Props {
+		blocks: StoredBlock[];
+		readonly: boolean;
+		palette: string[];
+		plugins: BlockPlugin[];
+		/** Summary of the block's props (title…); `empty` is shown when there is none. */
+		heading?: string;
+		empty?: string;
+		image?: string;
+		placeholder?: string;
+	}
+	let {
+		blocks = $bindable(),
+		readonly,
+		palette,
+		plugins,
+		heading = '',
+		empty = '',
+		image,
+		placeholder
+	}: Props = $props();
+	const tr = useText();
+	const fields = claimFields();
+</script>
+
+<div class="frame">
+	{#if fields}
+		<div class="fields">{@render fields()}</div>
+	{:else if heading || empty || image}
+		<div class="head">
+			{#if image}<img src={image} alt="" draggable="false" />{/if}
+			<span class:muted={!heading}>{heading || empty}</span>
+		</div>
+	{/if}
+	<Editor bind:value={blocks} {readonly} {palette} {plugins} nested placeholder={placeholder ?? tr('Write inside…')} />
+</div>
+
+<style>
+	.frame {
+		position: relative;
+		border: 1px solid #e5e5ea;
+		border-radius: 10px;
+		/* left: room for the inner blocks' handle bar (22px left of the row, which reaches 8px out) */
+		padding: 0.8em 1.1em 0.4em calc(30px + 0.5em);
+	}
+	/* the fields reach to the frame's edges, the frame's padding taken back */
+	.fields {
+		margin: calc(-0.8em + 4px) calc(-1.1em + 4px) 0.5em calc(-30px - 0.5em + 4px);
+	}
+	.head {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		margin: 0 9em 0.3em 0;
+		font: 600 13px/1.4 system-ui, sans-serif;
+		color: #1d1d1f;
+	}
+	.head img {
+		height: 28px;
+		width: 44px;
+		object-fit: cover;
+		border-radius: 4px;
+	}
+	.muted {
+		font-weight: 400;
+		color: #a0a0a8;
+	}
+</style>

package/dist/kit/Frame.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { BlockPlugin, StoredBlock } from '../types';
+interface Props {
+    blocks: StoredBlock[];
+    readonly: boolean;
+    palette: string[];
+    plugins: BlockPlugin[];
+    /** Summary of the block's props (title…); `empty` is shown when there is none. */
+    heading?: string;
+    empty?: string;
+    image?: string;
+    placeholder?: string;
+}
+declare const Frame: import("svelte").Component<Props, {}, "blocks">;
+type Frame = ReturnType<typeof Frame>;
+export default Frame;

package/dist/kit/util.d.ts

@@ -0,0 +1,13 @@
+/** A #hex colour, or the fallback. */
+export declare const safeColor: (c: unknown, fallback: string) => string;
+export declare const lines: (s: string) => string[];
+/** The base value of a per-view prop (see PropField.views): the value itself, or the first view's. */
+export declare const baseValue: (v: unknown) => unknown;
+/** A per-view prop's value for each of these views (the first is the base); a view without its own takes the one before. */
+export declare function viewValues(v: unknown, keys: string[]): unknown[];
+/** Plain text made safe inside markdown (no inline marks, no block start). */
+export declare const mdText: (s: unknown) => string;
+/** Markdown lines quoted (`> `), for a box rendered as a blockquote. */
+export declare const mdQuote: (md: string) => string;
+/** Markdown parts joined as separate blocks, empty ones left out. */
+export declare const mdJoin: (...parts: (string | false | null | undefined)[]) => string;

package/dist/kit/util.js

@@ -0,0 +1,28 @@
+// Helpers for writing plugins: values come from the block fields, so the previews only use safe ones.
+/** A #hex colour, or the fallback. */
+export const safeColor = (c, fallback) => (/^#[0-9a-f]{3,8}$/i.test(String(c ?? '')) ? String(c) : fallback);
+export const lines = (s) => s
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+const byView = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/** The base value of a per-view prop (see PropField.views): the value itself, or the first view's. */
+export const baseValue = (v) => (byView(v) ? Object.values(v)[0] : v);
+/** A per-view prop's value for each of these views (the first is the base); a view without its own takes the one before. */
+export function viewValues(v, keys) {
+    const own = byView(v) ? v : { [keys[0]]: v };
+    let last;
+    return keys.map((k) => (last = own[k] ?? last));
+}
+/** Plain text made safe inside markdown (no inline marks, no block start). */
+export const mdText = (s) => String(s ?? '')
+    .replace(/[\\`*~[\]<_#]/g, '\\$&')
+    .replace(/\n+/g, ' ')
+    .trim();
+/** Markdown lines quoted (`> `), for a box rendered as a blockquote. */
+export const mdQuote = (md) => md
+    .split('\n')
+    .map((l) => (l ? `> ${l}` : '>'))
+    .join('\n');
+/** Markdown parts joined as separate blocks, empty ones left out. */
+export const mdJoin = (...parts) => parts.filter(Boolean).join('\n\n');

package/dist/locales/hu.d.ts

@@ -0,0 +1,2 @@
+import type { Messages } from '../i18n';
+export declare const hu: Messages;

package/dist/locales/hu.js

@@ -0,0 +1,147 @@
+export const hu = {
+    // szerkesztő
+    "Write something, or press '/' for blocks…": 'Írj valamit, vagy nyomj „/”-t a blokkokért…',
+    'Add a block below': 'Új blokk alá',
+    'Drag to move, click to select': 'Húzd az áthelyezéshez, kattints a kijelöléshez',
+    Done: 'Kész',
+    inherited: 'örökölt',
+    Settings: 'Beállítások',
+    'Hide settings': 'Beállítások elrejtése',
+    None: 'Nincs',
+    Images: 'Képek',
+    Choose: 'Választás',
+    'Choose…': 'Válassz…',
+    '{n} picked': '{n} kiválasztva',
+    language: 'nyelv',
+    'No images attached to this page yet.': 'Még nincs kép csatolva.',
+    'New block at the end': 'Új blokk a végére',
+    Formatting: 'Formázás',
+    'Turn into': 'Átalakítás',
+    'Block actions': 'Blokkműveletek',
+    'Block type': 'Blokktípus',
+    Delete: 'Törlés',
+    '{n} blocks': '{n} blokk',
+    'Remove this block': 'A blokk törlése',
+    Unwrap: 'Kicsomagolás',
+    'Move the inner blocks out': 'A belső blokkok kikerülnek',
+    'Put inside': 'Bele',
+    'Put {n} blocks inside': '{n} blokk bele',
+    'Loses formatting': 'A formázás elvész',
+    OK: 'OK',
+    Remove: 'Eltávolítás',
+    'Bold (Ctrl+B)': 'Félkövér (Ctrl+B)',
+    'Italic (Ctrl+I)': 'Dőlt (Ctrl+I)',
+    'Underline (Ctrl+U)': 'Aláhúzott (Ctrl+U)',
+    'Strikethrough (Ctrl+Shift+X)': 'Áthúzott (Ctrl+Shift+X)',
+    'Subscript (NO₂)': 'Alsó index (NO₂)',
+    'Superscript (m²)': 'Felső index (m²)',
+    'Code (Ctrl+E)': 'Kód (Ctrl+E)',
+    'Link (Ctrl+K)': 'Link (Ctrl+K)',
+    'Plain text: remove the formatting (Ctrl+\\)': 'Sima szöveg: a formázás törlése (Ctrl+\\)',
+    'List item': 'Listaelem',
+    Language: 'Nyelv',
+    'e.g. ts, py, css': 'pl. ts, py, css',
+    code: 'kód',
+    // beépített blokkok
+    Text: 'Szöveg',
+    'Plain paragraph': 'Sima bekezdés',
+    'text paragraph': 'szöveg bekezdés',
+    'Heading 1': 'Címsor 1',
+    'Heading 2': 'Címsor 2',
+    'Heading 3': 'Címsor 3',
+    'Heading 4': 'Címsor 4',
+    'Heading 5': 'Címsor 5',
+    'Heading 6': 'Címsor 6',
+    'Large heading': 'Nagy cím',
+    'Medium heading': 'Közepes cím',
+    'Small heading': 'Kis cím',
+    'Sub-heading': 'Alcím',
+    'Minor heading': 'Kisebb alcím',
+    'Smallest heading': 'Legkisebb alcím',
+    'heading h1 title': 'cím címsor',
+    'heading h2 title': 'cím címsor alcím',
+    'heading h3 title': 'cím címsor alcím',
+    'heading h4 title': 'alcím címsor',
+    'heading h5 title': 'alcím címsor',
+    'heading h6 title': 'alcím címsor',
+    'Bulleted list': 'Felsorolás',
+    'Simple bullets': 'Pontokba szedve',
+    'bullet list ul': 'lista felsorolás pont',
+    'Numbered list': 'Számozott lista',
+    'Ordered items': 'Sorszámozott elemek',
+    'numbered ordered list ol': 'számozott lista sorszám',
+    'To-do': 'Teendő',
+    'Checkable item': 'Kipipálható elem',
+    'todo task checkbox': 'teendő feladat pipa',
+    Quote: 'Idézet',
+    'Highlighted quote': 'Kiemelt idézet',
+    'quote blockquote': 'idézet',
+    Code: 'Kód',
+    'Monospaced block': 'Fix szélességű betűkkel',
+    'code snippet pre': 'kód forráskód',
+    Divider: 'Elválasztó',
+    'Horizontal line': 'Vízszintes vonal',
+    'divider hr line separator': 'elválasztó vonal',
+    // bővítmények: név, leírás, kulcsszavak
+    YouTube: 'YouTube',
+    'Video from a link': 'Videó linkből',
+    'youtube video embed': 'youtube videó beágyazás',
+    Table: 'Táblázat',
+    'Rows and columns': 'Sorok és oszlopok',
+    'table grid rows columns price list': 'táblázat sor oszlop árlista',
+    Map: 'Térkép',
+    Gap: 'Térköz',
+    'Empty space': 'Üres hely',
+    'gap space spacer whitespace': 'térköz hely üres távolság',
+    'Google Maps for a place': 'Google Térkép egy helyről',
+    'map google location address place': 'térkép hely cím',
+    // mezők
+    Title: 'Cím',
+    Height: 'Magasság',
+    '1 line': '1 sor',
+    '{n} lines': '{n} sor',
+    Original: 'Eredeti',
+    'Video link or id': 'A videó linkje vagy azonosítója',
+    'Place or address': 'Hely vagy cím',
+    'e.g. Pécs, Széchenyi tér': 'pl. Pécs, Széchenyi tér',
+    Zoom: 'Nagyítás',
+    // a blokkok címkéi (a blokk tetején, a mezők előtt)
+    left: 'bal',
+    right: 'jobb',
+    danger: 'vigyázat',
+    image: 'kép',
+    youtube: 'youtube',
+    table: 'táblázat',
+    map: 'térkép',
+    gap: 'térköz',
+    // a bővítmények nézetei
+    'Write inside…': 'Írj bele…',
+    'Paste a YouTube link above': 'Illeszd be fent a YouTube-linket',
+    'Set a place or an address above': 'Adj meg fent egy helyet vagy címet',
+    Row: 'Sor',
+    Column: 'Oszlop',
+    'Insert a row above': 'Új sor fölé',
+    'Insert a row below': 'Új sor alá',
+    'Delete this row': 'A sor törlése',
+    'Insert a column left': 'Új oszlop balra',
+    'Insert a column right': 'Új oszlop jobbra',
+    'Delete this column': 'Az oszlop törlése',
+    'Align column left': 'Az oszlop balra zárva',
+    'Center column': 'Az oszlop középre zárva',
+    'Align column right': 'Az oszlop jobbra zárva',
+    'Header row': 'Fejléc (első sor)',
+    'Footer row (e.g. sums)': 'Lábléc (utolsó sor, pl. összesítő)',
+    'Drag to move the row': 'Húzd a sor áthelyezéséhez',
+    'Drag to move the column': 'Húzd az oszlop áthelyezéséhez',
+    'Enter: next row · Shift+Enter: line break · paste from a spreadsheet': 'Enter: következő sor · Shift+Enter: sortörés · táblázatból be is illeszthető',
+    Heading: 'Fejléc',
+    'Row {r}, column {c}': '{r}. sor, {c}. oszlop',
+    'Add a column': 'Új oszlop',
+    'Add a row': 'Új sor',
+    // előnézet
+    'For supporters only': 'Csak támogatóknak',
+    'YouTube video': 'YouTube-videó',
+    video: 'videó',
+    'Play {title}': 'Lejátszás: {title}',
+    'Map: {place}': 'Térkép: {place}'
+};

package/dist/markdown.d.ts

@@ -0,0 +1,25 @@
+import type { MediaItem } from './media';
+import { type Block, type BlockPlugin, type StoredBlock } from './types';
+/** Inline markdown -> inline html (b, i, u, sub, sup, strike, code, a, br). Backslash escapes are honoured; links are
+ * http(s), mailto, tel or site-relative only. */
+export declare function inline(md: string): string;
+/** Inline html -> inline markdown (browser only). `code` keeps the text verbatim, as in a code block. */
+export declare function htmlToMarkdown(html: string, code?: boolean): string;
+/** One block -> its markdown snippet, without indentation. `n` is the ordinal of a numbered item. */
+export declare function blockToMd(b: Block, n?: number): string;
+/** One markdown snippet -> block fields. */
+export declare function mdToBlock(md: string): Pick<Block, 'type' | 'html' | 'checked' | 'props'>;
+/** Inline html -> the same letters without formatting (line breaks kept), as a code block holds them. */
+export declare function plainHtml(html: string): string;
+/** Editor block -> stored block: `md:<kind>` with inline markdown text, or the plugin's own type. */
+export declare function toStored(b: Block): StoredBlock;
+/** Stored block -> editor block with a fresh id. Unknown types (md: or plugin) are kept as they are. */
+export declare function fromStored(s: StoredBlock): Block;
+/** Markdown text -> blocks. Supports headings, lists, todos, quotes, fenced code, hr and basic inline marks. */
+export declare function fromMarkdown(src: string): Block[];
+/** Blocks -> markdown text (browser only: uses the DOM to read the inline html). A plugin block is written by its
+ * plugin's `markdown`; one without it is left out. */
+export declare function toMarkdown(blocks: Block[], opts?: {
+    plugins?: BlockPlugin[];
+    media?: MediaItem[];
+}): string;

package/dist/markdown.js

@@ -0,0 +1,219 @@
+import { MAX_INDENT, MD, newBlock, numbering } from './types';
+const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+/** Characters escaped in plain text so they never turn into inline markup. */
+const SPECIAL = /[\\`*~[\]<]/g;
+const MARK = '\u0000';
+/** Inline markdown -> inline html (b, i, u, sub, sup, strike, code, a, br). Backslash escapes are honoured; links are
+ * http(s), mailto, tel or site-relative only. */
+export function inline(md) {
+    const kept = [];
+    const guarded = md.replace(/\\([\\`*~[\]<>#+.!_-])/g, (_, c) => `${MARK}${kept.push(c) - 1}${MARK}`);
+    const restore = (s, raw) => s.replace(/\u0000(\d+)\u0000/g, (_, n) => (raw ? '\\' : '') + esc(kept[+n]));
+    return guarded
+        .split(/(`[^`]+`)/)
+        .map((seg, i) => {
+        if (i % 2)
+            return `<code>${restore(esc(seg.slice(1, -1)), true)}</code>`;
+        const html = esc(seg)
+            .replace(/\*\*(.+?)\*\*/g, '<b>$1</b>')
+            .replace(/(?<!\*)\*(?!\s)(.+?)(?<!\s)\*(?!\*)/g, '<i>$1</i>')
+            .replace(/~~(.+?)~~/g, '<strike>$1</strike>')
+            .replace(/&lt;(u|sub|sup)&gt;(.+?)&lt;\/\1&gt;/g, '<$1>$2</$1>')
+            .replace(/\[(.+?)\]\(((?:https?:|mailto:|tel:|\/(?!\/))[^)\s]+)\)/g, '<a href="$2">$1</a>')
+            .replace(/\n/g, '<br>');
+        return restore(html, false);
+    })
+        .join('');
+}
+function walk(n, code) {
+    if (n.nodeType === Node.TEXT_NODE) {
+        // Zero-width spaces only hold the caret outside a mark (see plainText()).
+        const t = (n.textContent ?? '').replace(/\u200B/g, '');
+        return code ? t : t.replace(SPECIAL, '\\$&');
+    }
+    if (!(n instanceof HTMLElement))
+        return '';
+    const inCode = code || n.tagName === 'CODE';
+    const inner = [...n.childNodes].map((c) => walk(c, inCode)).join('');
+    switch (n.tagName) {
+        case 'B':
+        case 'STRONG':
+            return inner ? `**${inner}**` : '';
+        case 'I':
+        case 'EM':
+            return inner ? `*${inner}*` : '';
+        case 'U':
+        case 'SUB':
+        case 'SUP': {
+            const tag = n.tagName.toLowerCase();
+            return inner ? `<${tag}>${inner}</${tag}>` : '';
+        }
+        case 'S':
+        case 'STRIKE':
+        case 'DEL':
+            return inner ? `~~${inner}~~` : '';
+        case 'CODE':
+            return inner && !code ? `\`${inner}\`` : inner;
+        case 'A':
+            return `[${inner}](${n.getAttribute('href') ?? ''})`;
+        case 'BR':
+            return '\n';
+        default:
+            return inner;
+    }
+}
+/** Inline html -> inline markdown (browser only). `code` keeps the text verbatim, as in a code block. */
+export function htmlToMarkdown(html, code = false) {
+    const d = document.createElement('div');
+    d.innerHTML = html;
+    return walk(d, code);
+}
+/** Line starts that markdown would read as a block; a paragraph starting like this gets a leading backslash. */
+const BLOCK_START = /^(?:#{1,6} |[-*+] |\d{1,3}[.)] |>|```|([-*_])\1{2,}\s*$)/;
+const RULE = /^([-*_])\1{2,}\s*$/;
+/** Opening code fence with an optional language: ```ts, ```c++, ```objective-c… */
+const FENCE = /^```([\w+#.-]*)[^\S\n]*/;
+const LINE = /^(?:(#{1,6}) |[-*+] \[([ xX])\] |([-*+]) |(\d{1,3})[.)] |(>) ?)?([\s\S]*)$/;
+/** One block -> its markdown snippet, without indentation. `n` is the ordinal of a numbered item. */
+export function blockToMd(b, n = 1) {
+    if (b.type === 'plugin')
+        return '';
+    if (b.type === 'hr')
+        return '---';
+    if (b.type === 'code')
+        return '```' + (b.props?.lang ?? '') + '\n' + htmlToMarkdown(b.html, true) + '\n```';
+    const t = htmlToMarkdown(b.html);
+    switch (b.type) {
+        case 'h1':
+        case 'h2':
+        case 'h3':
+        case 'h4':
+        case 'h5':
+        case 'h6':
+            return `${'#'.repeat(+b.type[1])} ${t}`;
+        case 'ul':
+            return `- ${t}`;
+        case 'ol':
+            return `${n}. ${t}`;
+        case 'todo':
+            return `- [${b.checked ? 'x' : ' '}] ${t}`;
+        case 'quote':
+            return `> ${t}`;
+        default:
+            return BLOCK_START.test(t) ? '\\' + t : t;
+    }
+}
+/** One markdown snippet -> block fields. */
+export function mdToBlock(md) {
+    const fence = FENCE.exec(md);
+    if (fence) {
+        const body = md.slice(fence[0].length).replace(/^\n/, '').replace(/\n?```\s*$/, '');
+        return { type: 'code', html: codeHtml(body), ...(fence[1] ? { props: { lang: fence[1] } } : {}) };
+    }
+    if (RULE.test(md))
+        return { type: 'hr', html: '' };
+    const m = LINE.exec(md);
+    const type = m[1]
+        ? `h${m[1].length}`
+        : m[2]
+            ? 'todo'
+            : m[3]
+                ? 'ul'
+                : m[4]
+                    ? 'ol'
+                    : m[5]
+                        ? 'quote'
+                        : 'p';
+    let text = m[6];
+    // Undo the backslash blockToMd put before a block-like start (text escapes such as `\*` stay).
+    if (type === 'p' && text[0] === '\\' && !/[\\`*~[\]<]/.test(text[1] ?? '\\') && BLOCK_START.test(text.slice(1)))
+        text = text.slice(1);
+    return { type, html: inline(text), ...(type === 'todo' ? { checked: m[2].toLowerCase() === 'x' } : {}) };
+}
+const BUILT_IN = ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ul', 'ol', 'todo', 'quote', 'code', 'hr'];
+const codeHtml = (text) => esc(text).replace(/\n/g, '<br>');
+/** Inline html -> the same letters without formatting (line breaks kept), as a code block holds them. */
+export function plainHtml(html) {
+    const d = document.createElement('div');
+    d.innerHTML = html.replace(/<br\s*\/?>/gi, '\n');
+    return codeHtml(d.textContent ?? '');
+}
+/** Editor block -> stored block: `md:<kind>` with inline markdown text, or the plugin's own type. */
+export function toStored(b) {
+    if (b.type === 'plugin')
+        return { type: b.plugin, indent: b.indent, props: b.props ?? {}, ...(b.blocks ? { blocks: b.blocks } : {}) };
+    const out = { type: MD + b.type, indent: b.indent };
+    if (b.type === 'code')
+        out.text = htmlToMarkdown(b.html, true);
+    else if (b.type !== 'hr')
+        out.text = htmlToMarkdown(b.html);
+    if (b.type === 'todo')
+        out.props = { checked: !!b.checked };
+    if (b.type === 'code' && b.props?.lang)
+        out.props = { lang: b.props.lang };
+    return out;
+}
+/** Stored block -> editor block with a fresh id. Unknown types (md: or plugin) are kept as they are. */
+export function fromStored(s) {
+    const kind = s.type.slice(MD.length);
+    if (!s.type.startsWith(MD) || !BUILT_IN.includes(kind))
+        return newBlock('plugin', '', { plugin: s.type, indent: s.indent, props: s.props ?? {}, blocks: s.blocks });
+    const text = s.text ?? '';
+    const html = kind === 'code' ? codeHtml(text) : kind === 'hr' ? '' : inline(text);
+    return newBlock(kind, html, {
+        indent: s.indent,
+        ...(kind === 'todo' ? { checked: !!s.props?.checked } : {}),
+        ...(kind === 'code' && s.props?.lang ? { props: { lang: s.props.lang } } : {})
+    });
+}
+/** Markdown text -> blocks. Supports headings, lists, todos, quotes, fenced code, hr and basic inline marks. */
+export function fromMarkdown(src) {
+    const out = [];
+    const lines = src.replace(/\r/g, '').split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fence = FENCE.exec(line.trimStart());
+        if (fence) {
+            const code = [];
+            i++;
+            while (i < lines.length && !/^\s*```/.test(lines[i]))
+                code.push(lines[i++]);
+            out.push(newBlock('code', codeHtml(code.join('\n')), fence[1] ? { props: { lang: fence[1] } } : {}));
+            continue;
+        }
+        if (!line.trim())
+            continue;
+        const lead = /^\s*/.exec(line)[0];
+        const indent = Math.min(MAX_INDENT, Math.floor(lead.replace(/\t/g, '  ').length / 2));
+        const { type, html, ...extra } = mdToBlock(line.slice(lead.length));
+        out.push(newBlock(type, html, { indent, ...extra }));
+    }
+    return out;
+}
+/** Blocks -> markdown text (browser only: uses the DOM to read the inline html). A plugin block is written by its
+ * plugin's `markdown`; one without it is left out. */
+export function toMarkdown(blocks, opts = {}) {
+    const nums = numbering(blocks);
+    const listy = (t) => t === 'ul' || t === 'ol' || t === 'todo';
+    const md = (b) => {
+        if (b.type !== 'plugin')
+            return ('  ').repeat(listy(b.type) || b.type === 'p' ? b.indent : 0) + blockToMd(b, nums[b.id]);
+        const plugin = opts.plugins?.find((p) => p.type === b.plugin);
+        if (!plugin?.markdown)
+            return '';
+        const inner = b.blocks?.length ? toMarkdown(b.blocks.map(fromStored), opts) : '';
+        return plugin.markdown(b.props ?? {}, { inner, media: opts.media ?? [] }).trim();
+    };
+    let out = '';
+    let prev;
+    for (const b of blocks) {
+        const text = md(b);
+        if (!text)
+            continue;
+        if (prev)
+            out += listy(b.type) && listy(prev.type) ? '\n' : '\n\n';
+        out += text;
+        prev = b;
+    }
+    return out;
+}

package/dist/media.d.ts

@@ -0,0 +1,17 @@
+export interface MediaItem {
+    /** Stored in the block's props. */
+    id: string;
+    /** File name or title, shown in the picker. */
+    name: string;
+    /** Address of the image (a thumbnail size is fine for the editor). */
+    url: string;
+    /** Where it comes from (e.g. the attachment category), shown as a heading in the picker. */
+    group?: string;
+}
+type Get = () => MediaItem[];
+/** Call in a component's init. Without its own list, a nested editor or preview keeps its parent's. */
+export declare function provideMedia(own: () => MediaItem[] | undefined): void;
+/** Call in a component's init; the returned function reads the current list. */
+export declare const useMedia: () => Get;
+export declare const findMedia: (list: MediaItem[], id: unknown) => MediaItem | undefined;
+export {};

package/dist/media.js

@@ -0,0 +1,12 @@
+// The images a document can use: the host's attachments (on a CMS page, the page's uploaded images). Blocks store
+// an attachment's id; the editor, the preview and the plugins look it up here.
+import { getContext, setContext } from 'svelte';
+const KEY = 'block-editor:media';
+/** Call in a component's init. Without its own list, a nested editor or preview keeps its parent's. */
+export function provideMedia(own) {
+    const parent = getContext(KEY);
+    setContext(KEY, () => own() ?? parent?.() ?? []);
+}
+/** Call in a component's init; the returned function reads the current list. */
+export const useMedia = () => getContext(KEY) ?? (() => []);
+export const findMedia = (list, id) => list.find((m) => m.id === id);

package/dist/model.d.ts

@@ -0,0 +1,21 @@
+export interface StoredBlock {
+    type: string;
+    indent: number;
+    text?: string;
+    props?: Record<string, unknown>;
+    blocks?: StoredBlock[];
+}
+export declare const MD = "md:";
+export declare const MAX_INDENT = 6;
+/** Plugins with nested blocks hold one level only, so a document is at most this deep. */
+export declare const MAX_DEPTH = 2;
+export declare const isMd: (b: StoredBlock) => boolean;
+/** Inline markdown -> plain text: marks, escapes and link targets dropped. */
+export declare function inlineToPlainText(md: string): string;
+/** Every text of a document, in order: for search, leads and meta descriptions. */
+export declare function blocksToPlainText(blocks: StoredBlock[]): string;
+/**
+ * Does a container's `accepts` list take this palette id? The list holds palette ids, and 'md:*' for every built-in
+ * block (text, headings, lists, quote, code, divider). No list: everything.
+ */
+export declare const acceptsId: (accepts: readonly string[] | undefined, id: string) => boolean;