@atom-forge/brickee 0.0.0-stage → 0.0.2

package/dist/dom.js

@@ -0,0 +1,224 @@
+/** Svelte action: sets innerHTML once and only re-syncs when the model differs from the DOM (keeps the caret). */
+export function rich(node, value) {
+    node.innerHTML = value;
+    return {
+        update(v) {
+            if (node.innerHTML !== v)
+                node.innerHTML = v;
+        }
+    };
+}
+export function serialize(frag) {
+    const d = document.createElement('div');
+    d.append(frag);
+    return d.innerHTML;
+}
+/** Returns '' for html that has no visible text (e.g. `<b></b>`, `<br>`). */
+export function clean(h) {
+    const d = document.createElement('div');
+    d.innerHTML = h;
+    return d.textContent ? h : '';
+}
+export function textLen(h) {
+    const d = document.createElement('div');
+    d.innerHTML = h;
+    return d.textContent?.length ?? 0;
+}
+function range() {
+    const sel = getSelection();
+    return sel && sel.rangeCount ? sel.getRangeAt(0) : null;
+}
+export function splitAtCaret(el) {
+    const r = range();
+    if (!r)
+        return null;
+    const pre = document.createRange();
+    pre.selectNodeContents(el);
+    pre.setEnd(r.startContainer, r.startOffset);
+    const post = document.createRange();
+    post.selectNodeContents(el);
+    post.setStart(r.endContainer, r.endOffset);
+    return [serialize(pre.cloneContents()), serialize(post.cloneContents())];
+}
+export function atStart(el) {
+    const r = range();
+    if (!r || !r.collapsed)
+        return false;
+    const pre = document.createRange();
+    pre.selectNodeContents(el);
+    pre.setEnd(r.startContainer, r.startOffset);
+    return pre.toString() === '';
+}
+export function atEnd(el) {
+    const r = range();
+    if (!r || !r.collapsed)
+        return false;
+    const post = document.createRange();
+    post.selectNodeContents(el);
+    post.setStart(r.endContainer, r.endOffset);
+    return post.toString() === '';
+}
+export function caretOffset(el) {
+    const r = range();
+    if (!r || !el.contains(r.startContainer))
+        return 0;
+    const pre = document.createRange();
+    pre.selectNodeContents(el);
+    pre.setEnd(r.startContainer, r.startOffset);
+    return pre.toString().length;
+}
+export function setCaret(el, where = 'end') {
+    el.focus({ preventScroll: true });
+    const sel = getSelection();
+    if (!sel)
+        return;
+    const r = document.createRange();
+    r.selectNodeContents(el);
+    if (where === 'start')
+        r.collapse(true);
+    else if (where === 'end')
+        r.collapse(false);
+    else {
+        r.collapse(false);
+        const w = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+        let left = where;
+        let n;
+        while ((n = w.nextNode())) {
+            const len = n.textContent?.length ?? 0;
+            if (left <= len) {
+                r.setStart(n, left);
+                r.collapse(true);
+                break;
+            }
+            left -= len;
+        }
+    }
+    sel.removeAllRanges();
+    sel.addRange(r);
+    el.scrollIntoView({ block: 'nearest' });
+}
+/** Viewport rect of the caret, or null when the browser can't tell (empty block). */
+export function caretRect() {
+    const r = range();
+    if (!r)
+        return null;
+    const c = r.cloneRange();
+    c.collapse(false);
+    const rects = c.getClientRects();
+    const rect = rects.length ? rects[rects.length - 1] : c.getBoundingClientRect();
+    return rect && (rect.width || rect.height) ? rect : null;
+}
+/** Places the caret in `el` at the viewport point (x, y). Keeps the horizontal position while moving between blocks. */
+export function caretAt(el, x, y) {
+    const d = document;
+    let r = null;
+    if (d.caretPositionFromPoint) {
+        const p = d.caretPositionFromPoint(x, y);
+        if (p) {
+            r = document.createRange();
+            r.setStart(p.offsetNode, p.offset);
+        }
+    }
+    else if (d.caretRangeFromPoint) {
+        r = d.caretRangeFromPoint(x, y);
+    }
+    if (!r || !el.contains(r.startContainer))
+        return false;
+    r.collapse(true);
+    el.focus({ preventScroll: true });
+    const sel = getSelection();
+    sel.removeAllRanges();
+    sel.addRange(r);
+    el.scrollIntoView({ block: 'nearest' });
+    return true;
+}
+/** Deletes `n` characters directly before the caret (inside the caret's text node). */
+export function removeBeforeCaret(n) {
+    const r = range();
+    if (!r || r.startContainer.nodeType !== Node.TEXT_NODE || r.startOffset < n)
+        return false;
+    const t = r.startContainer;
+    const off = r.startOffset;
+    t.deleteData(off - n, n);
+    const nr = document.createRange();
+    nr.setStart(t, off - n);
+    nr.collapse(true);
+    const sel = getSelection();
+    sel.removeAllRanges();
+    sel.addRange(nr);
+    return true;
+}
+/** Is the caret on the first (up) or last (down) visual line of the block? */
+export function onEdgeLine(el, up) {
+    const sel = getSelection();
+    if (!sel || !sel.isCollapsed)
+        return false;
+    const cr = caretRect();
+    if (!cr)
+        return true;
+    const er = el.getBoundingClientRect();
+    const lh = parseFloat(getComputedStyle(el).lineHeight) || 24;
+    return up ? cr.top - er.top < lh * 0.5 : er.bottom - cr.bottom < lh * 0.5;
+}
+const MARKS = new Set(['B', 'STRONG', 'I', 'EM', 'U', 'S', 'STRIKE', 'DEL', 'SUB', 'SUP', 'CODE', 'A']);
+/**
+ * Plain text: a selection loses every mark and link; a caret steps out of the marks around it, so what is typed next
+ * is plain (a zero-width space holds it there; the markdown conversion drops it).
+ */
+export function plainText(el) {
+    const sel = getSelection();
+    const r = range();
+    if (!sel || !r || !el.contains(r.commonAncestorContainer))
+        return;
+    if (!r.collapsed) {
+        document.execCommand('removeFormat');
+        document.execCommand('unlink');
+        return;
+    }
+    let outer = null;
+    for (let n = r.startContainer; n && n !== el; n = n.parentNode)
+        if (MARKS.has(n.nodeName))
+            outer = n;
+    if (!outer)
+        return;
+    const t = document.createTextNode('\u200B');
+    outer.after(t);
+    const nr = document.createRange();
+    nr.setStart(t, 1);
+    nr.collapse(true);
+    sel.removeAllRanges();
+    sel.addRange(nr);
+}
+export function toggleCode(el) {
+    const sel = getSelection();
+    const r = range();
+    if (!sel || !r || r.collapsed)
+        return;
+    const anc = r.commonAncestorContainer;
+    const host = (anc instanceof Element ? anc : anc.parentElement)?.closest('code');
+    if (host && el.contains(host)) {
+        const nodes = [...host.childNodes];
+        host.replaceWith(...nodes);
+        return;
+    }
+    const c = document.createElement('code');
+    c.append(r.extractContents());
+    r.insertNode(c);
+    const nr = document.createRange();
+    nr.selectNodeContents(c);
+    sel.removeAllRanges();
+    sel.addRange(nr);
+}
+/** Is the selection's moving end (focus) at the very start (up) or end (down) of the block's text? */
+export function focusAtEdge(el, up) {
+    const sel = getSelection();
+    if (!sel || !sel.focusNode || !el.contains(sel.focusNode))
+        return false;
+    const r = document.createRange();
+    r.selectNodeContents(el);
+    if (up)
+        r.setEnd(sel.focusNode, sel.focusOffset);
+    else
+        r.setStart(sel.focusNode, sel.focusOffset);
+    return r.toString() === '';
+}

package/dist/i18n.d.ts

@@ -0,0 +1,7 @@
+export type Messages = Record<string, string>;
+export type Translate = (text: string, vars?: Record<string, string | number>) => string;
+export declare const translator: (messages?: Messages) => Translate;
+/** Call in a component's init. Without its own messages, a nested editor or preview keeps its parent's. */
+export declare function provideText(own: () => Messages | undefined): void;
+/** Call in a component's init; the returned function translates with the current messages. */
+export declare function useText(): Translate;

package/dist/i18n.js

@@ -0,0 +1,18 @@
+// UI text. The editor and the plugins are written in English; a host passes `messages` (English text -> its own) to
+// the top editor or preview, and nested editors and plugin views inherit them. `{name}` placeholders are filled in.
+import { getContext, setContext } from 'svelte';
+const KEY = 'block-editor:text';
+export const translator = (messages) => (text, vars) => {
+    const out = messages?.[text] ?? text;
+    return vars ? out.replace(/\{(\w+)\}/g, (m, k) => (k in vars ? String(vars[k]) : m)) : out;
+};
+/** Call in a component's init. Without its own messages, a nested editor or preview keeps its parent's. */
+export function provideText(own) {
+    const parent = getContext(KEY);
+    setContext(KEY, () => own() ?? parent?.());
+}
+/** Call in a component's init; the returned function translates with the current messages. */
+export function useText() {
+    const get = getContext(KEY);
+    return (text, vars) => translator(get?.())(text, vars);
+}

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 { provideView, useView } from './view';
+export { provideCodeLanguages, useCodeLanguages, type CodeLanguage } from './code';
+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 { provideView, useView } from './view';
+export { provideCodeLanguages, useCodeLanguages } from './code';
+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 var(--color-frame, #d4d4da);
+		border-radius: 10px;
+		color: var(--color-muted-contrast, #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 var(--color-frame, #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: var(--color-surface-contrast, #1d1d1f);
+	}
+	.head img {
+		height: 28px;
+		width: 44px;
+		object-fit: cover;
+		border-radius: 4px;
+	}
+	.muted {
+		font-weight: 400;
+		color: var(--color-muted-contrast, #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,142 @@
+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',
+    '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ő)',
+    'Header and footer': 'Fejléc és lábléc',
+    'Click a cell to edit its row and column': 'Kattints egy cellába a sora és oszlopa szerkesztéséhez',
+    'Drag to move the row': 'Húzd a sor áthelyezéséhez',
+    'Drag to move the column': 'Húzd az oszlop áthelyezéséhez',
+    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,23 @@
+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[];
+}): string;