phormat 0.0.5

package/dist/editor/plugins/emphasis/parse-emphasis.js

@@ -0,0 +1,188 @@
+/** CM-style Unicode whitespace check; includes `\n` for simulated line-start boundary. */
+const reUnicodeWhitespaceChar = /^[\f\n\r\t\v\u0020\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/;
+/** CM punctuation prefix check on a single code unit or surrogate pair. */
+const rePunctuation = /^[\u2000-\u206F\u2E00-\u2E7F'!"#$%&()*+,\-./:;<=>?@[\]^_`{|}~]/;
+function isWhitespaceChar(c) {
+    return reUnicodeWhitespaceChar.test(c);
+}
+function isPunctuationChar(c) {
+    return rePunctuation.test(c);
+}
+function previousCharInLine(line, pos) {
+    if (pos === 0) {
+        return '\n';
+    }
+    const previousCc = line.charCodeAt(pos - 1);
+    if ((previousCc & 0xfc00) !== 0xdc00) {
+        return line.charAt(pos - 1);
+    }
+    const twoPreviousCc = line.charCodeAt(pos - 2);
+    if ((twoPreviousCc & 0xfc00) !== 0xd800) {
+        return line.charAt(pos - 1);
+    }
+    return line.slice(pos - 2, pos);
+}
+function scanDelims(line, startpos) {
+    let numdelims = 0;
+    let i = startpos;
+    while (i < line.length && line.charCodeAt(i) === 0x2a /* * */) {
+        numdelims++;
+        i++;
+    }
+    if (numdelims === 0) {
+        return null;
+    }
+    const charBefore = previousCharInLine(line, startpos);
+    const charAfter = i >= line.length ? '\n' : line.charAt(i);
+    const afterIsWhitespace = isWhitespaceChar(charAfter);
+    const afterIsPunctuation = isPunctuationChar(charAfter);
+    const beforeIsWhitespace = isWhitespaceChar(charBefore);
+    const beforeIsPunctuation = isPunctuationChar(charBefore);
+    const leftFlanking = !afterIsWhitespace && (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
+    const rightFlanking = !beforeIsWhitespace && (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
+    return { numdelims, canOpen: leftFlanking, canClose: rightFlanking };
+}
+function removeDelimiter(head, delim) {
+    if (delim.previous !== null) {
+        delim.previous.next = delim.next;
+    }
+    if (delim.next === null) {
+        head = delim.previous;
+    }
+    else {
+        delim.next.previous = delim.previous;
+    }
+    return head;
+}
+function removeDelimitersBetween(bottom, top) {
+    if (bottom.next !== top) {
+        bottom.next = top;
+        top.previous = bottom;
+    }
+}
+function processLineDelimiters(line, lineBase, lineIndex, headIn, spans) {
+    let head = headIn;
+    const stackBottom = null;
+    let closer = head;
+    while (closer !== null && closer.previous !== stackBottom) {
+        closer = closer.previous;
+    }
+    const openersBottom = Array.from({ length: 14 }, () => stackBottom);
+    while (closer !== null) {
+        if (!closer.canClose) {
+            closer = closer.next;
+            continue;
+        }
+        let opener = closer.previous;
+        let openerFound = false;
+        const openersBottomIndex = 8 + (closer.canOpen ? 3 : 0) + (closer.origdelims % 3);
+        while (opener !== null &&
+            opener !== stackBottom &&
+            opener !== openersBottom[openersBottomIndex]) {
+            const oddMatch = (closer.canOpen || opener.canClose) &&
+                closer.origdelims % 3 !== 0 &&
+                (opener.origdelims + closer.origdelims) % 3 === 0;
+            if (opener.cc === closer.cc && opener.canOpen && !oddMatch) {
+                openerFound = true;
+                break;
+            }
+            opener = opener.previous;
+        }
+        const oldCloser = closer;
+        if (!openerFound) {
+            closer = closer.next;
+            openersBottom[openersBottomIndex] = oldCloser.previous;
+            if (!oldCloser.canOpen) {
+                head = removeDelimiter(head, oldCloser);
+            }
+            continue;
+        }
+        const openerDelim = opener;
+        const useDelims = closer.numdelims >= 2 && openerDelim.numdelims >= 2 ? 2 : 1;
+        const kind = useDelims === 1 ? 'emphasis' : 'strong';
+        const openerRunEnd = openerDelim.start + openerDelim.numdelims;
+        const closerConsumedStart = closer.start + closer.numdelims - useDelims;
+        const innerText = line.slice(openerRunEnd, closerConsumedStart);
+        const openConsumedStart = openerRunEnd - useDelims;
+        spans.push({
+            lineIndex,
+            startOffset: lineBase + openConsumedStart,
+            endOffset: lineBase + closer.start + closer.numdelims,
+            kind,
+            text: innerText
+        });
+        openerDelim.numdelims -= useDelims;
+        closer.numdelims -= useDelims;
+        removeDelimitersBetween(openerDelim, closer);
+        if (openerDelim.numdelims === 0) {
+            head = removeDelimiter(head, openerDelim);
+        }
+        if (closer.numdelims === 0) {
+            const tempstack = closer.next;
+            head = removeDelimiter(head, closer);
+            closer = tempstack;
+        }
+        else {
+            closer = closer.next;
+        }
+    }
+    while (head !== null && head !== stackBottom) {
+        head = removeDelimiter(head, head);
+    }
+}
+export function parseEmphasis(source) {
+    const spans = [];
+    let lineStart = 0;
+    let lineIndex = 0;
+    while (lineStart <= source.length) {
+        const nl = source.indexOf('\n', lineStart);
+        const lineEnd = nl === -1 ? source.length : nl;
+        let line = source.slice(lineStart, lineEnd);
+        if (line.endsWith('\r')) {
+            line = line.slice(0, -1);
+        }
+        const lineBase = lineStart;
+        let head = null;
+        let i = 0;
+        while (i < line.length) {
+            const c = line.charCodeAt(i);
+            if (c === 0x5c /* \\ */ && i + 1 < line.length) {
+                i += 2;
+                continue;
+            }
+            if (c === 0x2a) {
+                const start = i;
+                const scanned = scanDelims(line, start);
+                if (!scanned) {
+                    i++;
+                    continue;
+                }
+                i = start + scanned.numdelims;
+                if (scanned.canOpen || scanned.canClose) {
+                    const delim = {
+                        cc: 0x2a,
+                        numdelims: scanned.numdelims,
+                        origdelims: scanned.numdelims,
+                        start,
+                        canOpen: scanned.canOpen,
+                        canClose: scanned.canClose,
+                        previous: head,
+                        next: null
+                    };
+                    if (head !== null) {
+                        head.next = delim;
+                    }
+                    head = delim;
+                }
+                continue;
+            }
+            i++;
+        }
+        processLineDelimiters(line, lineBase, lineIndex, head, spans);
+        if (nl === -1)
+            break;
+        lineStart = nl + 1;
+        lineIndex++;
+    }
+    return spans;
+}

package/dist/editor/plugins/emphasis/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Inline emphasis blocks come from a **per-line** CommonMark-style `*` delimiter
+ * pass (see `parse-emphasis.ts`). Emphasis cannot span newlines.
+ *
+ * Each block is one successful delimiter pair after stack processing:
+ * - `use_delims === 1` → `emphasis` (italic)
+ * - `use_delims === 2` → `strong` (bold)
+ *
+ * A single author span like `***text***` is typically split into nested pairs by
+ * the same rules as CommonMark, so it may yield **two** blocks (overlapping
+ * ranges) rather than one combined record.
+ */
+export type EmphasisKind = 'emphasis' | 'strong';
+export type EmphasisBlock = {
+    /** 0-based index of the line containing this span (no cross-line spans). */
+    lineIndex: number;
+    /** Inclusive start offset in the full document `source`. */
+    startOffset: number;
+    /** Exclusive end offset in the full document `source`. */
+    endOffset: number;
+    kind: EmphasisKind;
+    /** Inner text only; does not include the delimiter asterisks. */
+    text: string;
+};

package/dist/editor/plugins/emphasis/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/plugins/escaping/EscapingRenderer.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+	import type { EscapingBlock } from './types';
+
+	export { escapingRenderer };
+</script>
+
+{#snippet escapingRenderer(block: EscapingBlock)}
+	<article class="mb-4 border-l border-semantic-warning/50 pl-3 font-mono text-sm text-semantic-warning/95">
+		<p class="mb-1 text-[11px] font-medium tracking-wide text-semantic-warning/90 uppercase">
+			Escape · L{block.lineIndex + 1}:{block.column + 1}
+		</p>
+		<p class="tabular-nums">
+			<code class="text-option-yellow">{block.raw}</code>
+			<span class="mx-2 text-txt-tertiary">→</span>
+			<span class="text-txt-primary">{block.literal}</span>
+		</p>
+	</article>
+{/snippet}

package/dist/editor/plugins/escaping/EscapingRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { EscapingBlock } from './types';
+declare const escapingRenderer: (block: EscapingBlock) => ReturnType<import("svelte").Snippet>;
+export { escapingRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const EscapingRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type EscapingRenderer = InstanceType<typeof EscapingRenderer>;
+export default EscapingRenderer;

package/dist/editor/plugins/escaping/index.d.ts

@@ -0,0 +1,2 @@
+import type { BlockRenderAdapter } from '../types';
+export declare const escapingPlugin: BlockRenderAdapter;

package/dist/editor/plugins/escaping/index.js

@@ -0,0 +1,4 @@
+export const escapingPlugin = {
+    id: 'escaping',
+    name: 'Escaping'
+};

package/dist/editor/plugins/escaping/parse-escaping.d.ts

@@ -0,0 +1,6 @@
+import type { EscapingBlock } from './types';
+/**
+ * Escaping (md-spec): backslash prefixes a literal for special characters (e.g. `\*`, `\#`, `` \` ``).
+ * Records each `\x` pair in source order; trailing `\` with no following character is skipped.
+ */
+export declare function parseEscapes(source: string): EscapingBlock[];

package/dist/editor/plugins/escaping/parse-escaping.js

@@ -0,0 +1,26 @@
+/**
+ * Escaping (md-spec): backslash prefixes a literal for special characters (e.g. `\*`, `\#`, `` \` ``).
+ * Records each `\x` pair in source order; trailing `\` with no following character is skipped.
+ */
+export function parseEscapes(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        for (let i = 0; i < line.length; i++) {
+            if (line[i] !== '\\')
+                continue;
+            const next = line[i + 1];
+            if (next === undefined)
+                break;
+            out.push({
+                lineIndex,
+                column: i,
+                raw: `\\${next}`,
+                literal: next
+            });
+            i++;
+        }
+    }
+    return out;
+}

package/dist/editor/plugins/escaping/types.d.ts

@@ -0,0 +1,10 @@
+export type EscapingBlock = {
+    /** 0-based line in the source (split on `\r?\n`) */
+    lineIndex: number;
+    /** 0-based column where the backslash starts */
+    column: number;
+    /** The two-char source span: backslash + escaped code unit */
+    raw: string;
+    /** The character (code unit) produced after escaping */
+    literal: string;
+};

package/dist/editor/plugins/escaping/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/plugins/extended-task-list/ExtendedTaskListRenderer.svelte

@@ -0,0 +1,25 @@
+<script module lang="ts">
+	import type { ExtendedTaskListBlock } from './types';
+
+	const boxClass =
+		'inline-flex min-h-[1.25rem] min-w-[1.25rem] shrink-0 items-center justify-center border border-border-emphasis font-mono text-[10px] leading-none text-txt-secondary';
+
+	const rowClass = 'flex items-start gap-2 text-sm text-txt-primary';
+
+	export { extendedTaskListRenderer };
+</script>
+
+{#snippet extendedTaskListRenderer(block: ExtendedTaskListBlock)}
+	<div class={`${rowClass} mb-3`}>
+		{#if block.state === 'todo'}
+			<span class={boxClass} aria-hidden="true">&nbsp;</span>
+		{:else if block.state === 'done'}
+			<span class={boxClass} aria-hidden="true">✓</span>
+		{:else if block.state === 'in_progress'}
+			<span class={boxClass} aria-hidden="true">/</span>
+		{:else}
+			<span class={boxClass} aria-hidden="true">&gt;</span>
+		{/if}
+		<span class="min-w-0 pt-0.5">{block.label}</span>
+	</div>
+{/snippet}

package/dist/editor/plugins/extended-task-list/ExtendedTaskListRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { ExtendedTaskListBlock } from './types';
+declare const extendedTaskListRenderer: (block: ExtendedTaskListBlock) => ReturnType<import("svelte").Snippet>;
+export { extendedTaskListRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const ExtendedTaskListRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type ExtendedTaskListRenderer = InstanceType<typeof ExtendedTaskListRenderer>;
+export default ExtendedTaskListRenderer;

package/dist/editor/plugins/extended-task-list/index.d.ts

@@ -0,0 +1,2 @@
+import type { BlockRenderAdapter } from '../types';
+export declare const extendedTaskListPlugin: BlockRenderAdapter;

package/dist/editor/plugins/extended-task-list/index.js

@@ -0,0 +1,4 @@
+export const extendedTaskListPlugin = {
+    id: 'extended-task-list',
+    name: 'Extended task list'
+};

package/dist/editor/plugins/extended-task-list/parse-extended-task-list.d.ts

@@ -0,0 +1,2 @@
+import type { ExtendedTaskListBlock } from './types';
+export declare function parseExtendedTaskList(source: string): ExtendedTaskListBlock[];

package/dist/editor/plugins/extended-task-list/parse-extended-task-list.js

@@ -0,0 +1,35 @@
+/** `- [ ]`, `- [x]`, `- [/]`, `- [>]`: optional indent, hyphen bullet, bracket marker. */
+const EXTENDED_TASK_LINE = /^(\s*)-\s+\[([ xX/>])\]\s*(.*)$/;
+function markerToState(marker) {
+    switch (marker) {
+        case ' ':
+            return 'todo';
+        case 'x':
+        case 'X':
+            return 'done';
+        case '/':
+            return 'in_progress';
+        case '>':
+            return 'deferred';
+        default:
+            return null;
+    }
+}
+export function parseExtendedTaskList(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(EXTENDED_TASK_LINE);
+        if (!match)
+            continue;
+        const state = markerToState(match[2]);
+        if (!state)
+            continue;
+        out.push({
+            state,
+            label: match[3].trimEnd(),
+            lineIndex: i
+        });
+    }
+    return out;
+}

package/dist/editor/plugins/extended-task-list/types.d.ts

@@ -0,0 +1,6 @@
+export type ExtendedTaskCheckboxState = 'todo' | 'done' | 'in_progress' | 'deferred';
+export type ExtendedTaskListBlock = {
+    state: ExtendedTaskCheckboxState;
+    label: string;
+    lineIndex: number;
+};

package/dist/editor/plugins/extended-task-list/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/plugins/highlight/HighlightRenderer.svelte

@@ -0,0 +1,16 @@
+<script module lang="ts">
+	import type { HighlightBlock } from './types';
+
+	const defaultMarkClass = 'rounded px-0.5 decoration-clone bg-option-yellow/35 text-txt-primary';
+
+	export { highlightRenderer };
+</script>
+
+{#snippet highlightRenderer(block: HighlightBlock)}
+	<mark
+		class={block.color ? 'rounded px-0.5 text-txt-primary' : defaultMarkClass}
+		style={block.color ? `background-color: ${block.color}` : undefined}
+	>
+		{block.text}
+	</mark>
+{/snippet}

package/dist/editor/plugins/highlight/HighlightRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { HighlightBlock } from './types';
+declare const highlightRenderer: (block: HighlightBlock) => ReturnType<import("svelte").Snippet>;
+export { highlightRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const HighlightRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type HighlightRenderer = InstanceType<typeof HighlightRenderer>;
+export default HighlightRenderer;

package/dist/editor/plugins/highlight/index.d.ts

@@ -0,0 +1,2 @@
+import type { BlockRenderAdapter } from '../types';
+export declare const highlightPlugin: BlockRenderAdapter;

package/dist/editor/plugins/highlight/index.js

@@ -0,0 +1,4 @@
+export const highlightPlugin = {
+    id: 'highlight',
+    name: 'Highlights'
+};

package/dist/editor/plugins/highlight/parse-highlights.d.ts

@@ -0,0 +1,4 @@
+import type { HighlightBlock } from './types';
+/** Allows safe `background-color` values from user tokens (no `;`, quotes, or `url()`). */
+export declare function isSafeCssColorToken(token: string): boolean;
+export declare function parseHighlights(source: string): HighlightBlock[];

package/dist/editor/plugins/highlight/parse-highlights.js

@@ -0,0 +1,49 @@
+/** Allows safe `background-color` values from user tokens (no `;`, quotes, or `url()`). */
+export function isSafeCssColorToken(token) {
+    const t = token.trim();
+    if (!t)
+        return false;
+    if (/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(t))
+        return true;
+    if (/^[a-zA-Z][a-zA-Z0-9_-]{0,39}$/.test(t))
+        return true;
+    if (/^rgba?\(\s*[\d.%\s,]+\s*\)$/.test(t))
+        return true;
+    return false;
+}
+export function parseHighlights(source) {
+    const out = [];
+    let i = 0;
+    while (i < source.length) {
+        const open = source.indexOf('==', i);
+        if (open === -1)
+            break;
+        const close = source.indexOf('==', open + 2);
+        if (close === -1)
+            break;
+        const inner = source.slice(open + 2, close);
+        const colonIdx = inner.indexOf(':');
+        let color = null;
+        let text;
+        if (colonIdx !== -1) {
+            const rawColor = inner.slice(0, colonIdx).trim();
+            const afterColon = inner.slice(colonIdx + 1);
+            if (rawColor !== '' && isSafeCssColorToken(rawColor)) {
+                color = rawColor;
+                text = afterColon;
+            }
+            else if (rawColor === '') {
+                text = afterColon;
+            }
+            else {
+                text = inner;
+            }
+        }
+        else {
+            text = inner;
+        }
+        out.push({ color, text, startOffset: open });
+        i = close + 2;
+    }
+    return out;
+}

package/dist/editor/plugins/highlight/types.d.ts

@@ -0,0 +1,6 @@
+export type HighlightBlock = {
+    /** CSS color token when using `==color:text==`; null for plain `==text==`. */
+    color: string | null;
+    text: string;
+    startOffset: number;
+};

package/dist/editor/plugins/highlight/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/plugins/index.d.ts

@@ -0,0 +1 @@
+export type { AnyEditorRenderBlock, BlockRenderAdapter, EditorRenderBlock, MarkdownDocument } from './types';

package/dist/editor/plugins/index.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/plugins/links-images/LinksImagesRenderer.svelte

@@ -0,0 +1,53 @@
+<script module lang="ts">
+	import type { LinkImageBlock } from './types';
+	import { hrefForDisplay } from '../../context/assetBaseUrl.js';
+	import { imageLayoutCss, parseImageLabelLayout } from './parse-image-layout.js';
+
+	/* eslint-disable svelte/no-navigation-without-resolve -- MD link destinations are author-controlled, not Kit routes */
+
+	function isAbsoluteHttpHref(href: string): boolean {
+		return /^https?:\/\//iu.test(href.trim());
+	}
+
+	export { linksImagesRenderer };
+</script>
+
+{#snippet linksImagesRenderer(block: LinkImageBlock)}
+	{@const href = block.href ? hrefForDisplay(block.href) : null}
+	<div class="mb-4 text-sm">
+		{#if block.kind === 'image'}
+			{@const layout = parseImageLabelLayout(block.label)}
+			{@const css = imageLayoutCss(layout.displayWidth, layout.floatAlign)}
+			{#if href}
+				<span class="ph-image-layout {css.wrapperClass}">
+					<img
+						src={href}
+						alt={layout.malformedSuffix ? block.label : layout.alt}
+						title={block.title ?? undefined}
+						class={css.imgClass}
+						style={css.imgStyle}
+						loading="lazy"
+						decoding="async"
+						referrerpolicy="no-referrer"
+					/>
+				</span>
+			{:else}
+				<span class="text-txt-secondary italic">{block.label || 'Image'}</span>
+				<span class="text-txt-tertiary"> (blocked or invalid URL)</span>
+			{/if}
+		{:else if href}
+			<a
+				href={href}
+				title={block.title ?? undefined}
+				class="font-medium text-accent-primary underline decoration-accent-primary/50 underline-offset-2 hover:text-accent-secondary hover:decoration-accent-secondary"
+				target={isAbsoluteHttpHref(href) ? '_blank' : undefined}
+				rel={isAbsoluteHttpHref(href) ? 'noopener noreferrer' : undefined}
+			>
+				{block.label || block.href}
+			</a>
+		{:else}
+			<span class="text-txt-secondary">{block.label}</span>
+			<span class="text-txt-tertiary"> (blocked or invalid URL)</span>
+		{/if}
+	</div>
+{/snippet}

package/dist/editor/plugins/links-images/LinksImagesRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { LinkImageBlock } from './types';
+declare const linksImagesRenderer: (block: LinkImageBlock) => ReturnType<import("svelte").Snippet>;
+export { linksImagesRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const LinksImagesRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type LinksImagesRenderer = InstanceType<typeof LinksImagesRenderer>;
+export default LinksImagesRenderer;

package/dist/editor/plugins/links-images/index.d.ts

@@ -0,0 +1,2 @@
+import type { BlockRenderAdapter } from '../types';
+export declare const linksImagesPlugin: BlockRenderAdapter;

package/dist/editor/plugins/links-images/index.js

@@ -0,0 +1,4 @@
+export const linksImagesPlugin = {
+    id: 'links-images',
+    name: 'Links and images'
+};