@ruckc/truss-markdown 0.0.0-stage → 1.12.0

package/dist/Markdown.svelte

@@ -0,0 +1,60 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+	import { parseMarkdown } from './parse.js';
+	import MarkdownBlocks from './MarkdownBlocks.svelte';
+	import { provide } from './context.js';
+
+	let {
+		text,
+		headingOffset = 2,
+		code,
+		link,
+		class: klass = '',
+		...rest
+	}: Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'class'> & {
+		/** The Markdown source: paragraphs, headings, bold/italic/strikethrough, inline code, fenced code blocks, lists (with task items), quotes, tables, rules, and http/https/mailto links including bare URLs. Images show their alt text and a link. HTML in it is shown as text; nothing is injected as markup. */
+		text: string;
+		/** Added to the heading level, capped at 6: with `2`, `#` renders as `<h3>`, so rendered text never adds a page-level heading. */
+		headingOffset?: number;
+		/** Renders a fenced code block in place of the default `<pre><code>`, for syntax highlighting or a copy button. Receives the language (empty when none) and the code. */
+		code?: Snippet<[{ lang: string; text: string }]>;
+		/** Renders a link in place of the default `<a target="_blank" rel="noopener noreferrer">`, for client-side routing or a link preview. Only http, https and mailto links reach it; `children` is the link text. */
+		link?: Snippet<[{ href: string; children: Snippet }]>;
+		/** Other attributes (`data-testid`, `id`, ...) go to the root `<div>`. `class` is added to it. */
+		class?: string;
+	} = $props();
+
+	provide({ get headingOffset() { return headingOffset; }, get code() { return code; }, get link() { return link; } });
+	const nodes = $derived(parseMarkdown(text));
+</script>
+
+<div {...rest} class={['md', klass]}><MarkdownBlocks {nodes} /></div>
+
+<style>
+	.md { min-width: 0; overflow-wrap: anywhere; line-height: 1.5; }
+	.md > :global(:first-child) { margin-top: 0; }
+	.md > :global(:last-child) { margin-bottom: 0; }
+	.md :global(p), .md :global(ul), .md :global(ol), .md :global(blockquote) { margin: 0 0 0.6em; }
+	.md :global(h3), .md :global(h4), .md :global(h5), .md :global(h6) { margin: 0.8em 0 0.3em; font-size: 1em; line-height: 1.3; }
+	.md :global(h3) { font-size: 1.15em; }
+	.md :global(h4) { font-size: 1.05em; }
+	.md :global(h1), .md :global(h2) { margin: 0.8em 0 0.3em; line-height: 1.25; }
+	.md :global(ul), .md :global(ol) { padding-inline-start: 1.5em; }
+	.md :global(li > ul), .md :global(li > ol) { margin: 0.2em 0 0; }
+	.md :global(a) { color: var(--tr-primary-text, var(--tr-primary)); text-decoration: underline; text-underline-offset: 2px; }
+	.md :global(code) { padding: 0.1em 0.35em; border-radius: var(--tr-radius-sm); background: var(--tr-surface-container-high); color: var(--tr-on-surface); font-family: var(--tr-font-mono); font-size: 0.9em; }
+		.md :global(blockquote) { padding-inline-start: var(--tr-space-3); border-inline-start: 3px solid var(--tr-outline); color: var(--tr-on-surface-variant); }
+	.md :global(.table) { max-width: 100%; margin: 0 0 0.6em; overflow-x: auto; border: 1px solid var(--tr-outline-variant); border-radius: var(--tr-radius-md); background: var(--tr-surface); }
+	.md :global(.table:focus-visible) { outline: none; box-shadow: var(--tr-focus-ring); }
+	.md :global(table) { width: max-content; min-width: 100%; border-collapse: separate; border-spacing: 0; font-size: var(--tr-text-md); }
+	.md :global(th), .md :global(td) { padding: var(--tr-space-1) var(--tr-space-2); text-align: start; vertical-align: top; overflow-wrap: normal; border-bottom: 1px solid var(--tr-outline-variant); }
+	.md :global(th) { background: var(--tr-surface-container); font-size: var(--tr-text-sm); font-weight: 700; letter-spacing: 0.02em; color: var(--tr-on-surface-variant); }
+	.md :global(tbody tr:last-child td) { border-bottom: 0; }
+	.md :global([data-align='left']) { text-align: left; }
+	.md :global([data-align='center']) { text-align: center; }
+	.md :global([data-align='right']) { text-align: right; }
+	.md :global(li.task) { list-style: none; margin-inline-start: -1.25em; }
+	.md :global(li.task input) { margin: 0 0.3em 0 0; vertical-align: middle; }
+	.md :global(hr) { margin: 0.8em 0; border: 0; border-top: 1px solid var(--tr-outline-variant); }
+</style>

package/dist/Markdown.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'class'> & {
+    /** The Markdown source: paragraphs, headings, bold/italic/strikethrough, inline code, fenced code blocks, lists (with task items), quotes, tables, rules, and http/https/mailto links including bare URLs. Images show their alt text and a link. HTML in it is shown as text; nothing is injected as markup. */
+    text: string;
+    /** Added to the heading level, capped at 6: with `2`, `#` renders as `<h3>`, so rendered text never adds a page-level heading. */
+    headingOffset?: number;
+    /** Renders a fenced code block in place of the default `<pre><code>`, for syntax highlighting or a copy button. Receives the language (empty when none) and the code. */
+    code?: Snippet<[{
+        lang: string;
+        text: string;
+    }]>;
+    /** Renders a link in place of the default `<a target="_blank" rel="noopener noreferrer">`, for client-side routing or a link preview. Only http, https and mailto links reach it; `children` is the link text. */
+    link?: Snippet<[{
+        href: string;
+        children: Snippet;
+    }]>;
+    /** Other attributes (`data-testid`, `id`, ...) go to the root `<div>`. `class` is added to it. */
+    class?: string;
+};
+declare const Markdown: import("svelte").Component<$$ComponentProps, {}, "">;
+type Markdown = ReturnType<typeof Markdown>;
+export default Markdown;

package/dist/MarkdownBlocks.svelte

@@ -0,0 +1,54 @@
+<script lang="ts">
+	import type { BlockNode } from './parse.js';
+	import MarkdownBlocks from './MarkdownBlocks.svelte';
+	import MarkdownInlines from './MarkdownInlines.svelte';
+	import MarkdownCode from './MarkdownCode.svelte';
+	import { use } from './context.js';
+
+	/** Renders block nodes (paragraph, heading, list, code block, blockquote, rule) with plain elements. */
+	let { nodes }: { nodes: BlockNode[] } = $props();
+	const ctx = use();
+
+	/** A scrolling region must be reachable by keyboard so it can be scrolled with the arrow keys. */
+	const focusable = (node: HTMLElement) => void (node.tabIndex = 0);
+	const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? '' : 's'}`;
+</script>
+
+{#each nodes as n}
+	{#if n.type === 'paragraph'}
+		<p><MarkdownInlines nodes={n.children} /></p>
+	{:else if n.type === 'heading'}
+		<svelte:element this={`h${Math.min(6, n.level + ctx.headingOffset)}`}><MarkdownInlines nodes={n.children} /></svelte:element>
+	{:else if n.type === 'list'}
+		<svelte:element this={n.ordered ? 'ol' : 'ul'} start={n.ordered && n.start !== 1 ? n.start : undefined}>
+			{#each n.items as it}
+				{#if it.checked === undefined}
+					<li><MarkdownInlines nodes={it.children} /><MarkdownBlocks nodes={it.blocks} /></li>
+				{:else}
+					<li class="task"><label><input type="checkbox" disabled checked={it.checked} /> <MarkdownInlines nodes={it.children} /></label><MarkdownBlocks nodes={it.blocks} /></li>
+				{/if}
+			{/each}
+		</svelte:element>
+	{:else if n.type === 'code'}
+		<MarkdownCode lang={n.lang} text={n.text} />
+	{:else if n.type === 'table'}
+		<div class="table" role="region" {@attach focusable} aria-label={`Table, ${plural(n.head.length, 'column')}, ${plural(n.rows.length, 'row')}`}>
+			<table>
+				<thead>
+					<tr>{#each n.head as cell, k}<th scope="col" data-align={n.align[k] ?? undefined}><MarkdownInlines nodes={cell} /></th>{/each}</tr>
+				</thead>
+				{#if n.rows.length}
+					<tbody>
+						{#each n.rows as row}
+							<tr>{#each row as cell, k}<td data-align={n.align[k] ?? undefined}><MarkdownInlines nodes={cell} /></td>{/each}</tr>
+						{/each}
+					</tbody>
+				{/if}
+			</table>
+		</div>
+	{:else if n.type === 'blockquote'}
+		<blockquote><MarkdownBlocks nodes={n.children} /></blockquote>
+	{:else}
+		<hr />
+	{/if}
+{/each}

package/dist/MarkdownBlocks.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { BlockNode } from './parse.js';
+import MarkdownBlocks from './MarkdownBlocks.svelte';
+type $$ComponentProps = {
+    nodes: BlockNode[];
+};
+declare const MarkdownBlocks: import("svelte").Component<$$ComponentProps, {}, "">;
+type MarkdownBlocks = ReturnType<typeof MarkdownBlocks>;
+export default MarkdownBlocks;

package/dist/MarkdownCode.svelte

@@ -0,0 +1,69 @@
+<script lang="ts">
+	import { onDestroy } from 'svelte';
+	import { Button, Tooltip } from '@ruckc/truss-ui';
+	import { highlight, resolveLanguage, type Token } from './highlight.js';
+	import { use } from './context.js';
+
+	/** A fenced code block: highlighted tokens inside a scrollable `<pre>`, a language label and a Copy button, or the caller's `code` snippet. */
+	let { lang, text }: { lang: string; text: string } = $props();
+	const ctx = use();
+
+	/** One flat run of tokens, with a plain "\n" token between lines. */
+	const tokens = $derived(highlight(text, lang).flatMap((line, i): Token[] => (i ? [{ type: 'plain', text: '\n' }, ...line] : line)));
+	const label = $derived(lang || 'text');
+	let status = $state('');
+	let timer: ReturnType<typeof setTimeout>;
+	onDestroy(() => clearTimeout(timer));
+
+	/** A scrolling region must be reachable by keyboard so it can be scrolled with the arrow keys. */
+	const focusable = (node: HTMLElement) => void (node.tabIndex = 0);
+
+	async function copy() {
+		try {
+			await navigator.clipboard.writeText(text);
+			status = 'Copied';
+		} catch {
+			status = 'Copy failed';
+		}
+		clearTimeout(timer);
+		timer = setTimeout(() => (status = ''), 2000);
+	}
+</script>
+
+{#if ctx.code}
+	{@render ctx.code({ lang, text })}
+{:else}
+	<figure class="code" data-lang={resolveLanguage(lang) ?? 'plain'}>
+		<figcaption>
+			<span class="lang">{label}</span>
+			<Tooltip text="Copy code">
+				<Button variant="minimal" size="sm" icon={status === 'Copied' ? 'tick' : 'copy'} aria-label="Copy code" onclick={copy} />
+			</Tooltip>
+			<span class="tr-visually-hidden" role="status" aria-live="polite">{status}</span>
+		</figcaption>
+		<pre role="region" {@attach focusable} aria-label={`${label} code`}><code class={lang ? `language-${lang}` : undefined}
+				>{#each tokens as t}{#if t.type === 'plain'}{t.text}{:else}<span class="tok-{t.type}">{t.text}</span>{/if}{/each}</code></pre>
+	</figure>
+{/if}
+
+<style>
+	.code { margin: 0 0 0.6em; max-width: 100%; border: 1px solid var(--tr-outline-variant); border-radius: var(--tr-radius-md); background: var(--tr-surface-container); overflow: hidden; }
+	figcaption { display: flex; align-items: center; justify-content: space-between; gap: var(--tr-space-2); padding: 0 var(--tr-space-1) 0 var(--tr-space-3); border-bottom: 1px solid var(--tr-outline-variant); color: var(--tr-on-surface-variant); font-size: var(--tr-text-xs); }
+	.lang { font-family: var(--tr-font-mono); }
+	pre { margin: 0; max-width: 100%; overflow-x: auto; padding: var(--tr-space-3); border: 0; border-radius: 0; background: none; color: var(--tr-on-surface); font-family: var(--tr-font-mono); font-size: 0.875em; line-height: 1.5; tab-size: 2; }
+	pre:focus-visible { outline: none; box-shadow: inset var(--tr-focus-ring); }
+	code { padding: 0; background: none; font: inherit; white-space: pre; }
+	.tok-keyword { color: var(--tr-syntax-keyword); }
+	.tok-string { color: var(--tr-syntax-string); }
+	.tok-number { color: var(--tr-syntax-number); }
+	.tok-comment { color: var(--tr-syntax-comment); font-style: italic; }
+	.tok-function { color: var(--tr-syntax-function); }
+	.tok-type { color: var(--tr-syntax-type); }
+	.tok-variable { color: var(--tr-syntax-variable); }
+	.tok-constant { color: var(--tr-syntax-constant); }
+	.tok-operator { color: var(--tr-syntax-operator); }
+	.tok-punctuation { color: var(--tr-syntax-punctuation); }
+	.tok-tag { color: var(--tr-syntax-tag); }
+	.tok-attr { color: var(--tr-syntax-attr); }
+	.tok-regexp { color: var(--tr-syntax-regexp); }
+</style>

package/dist/MarkdownCode.svelte.d.ts

@@ -0,0 +1,7 @@
+type $$ComponentProps = {
+    lang: string;
+    text: string;
+};
+declare const MarkdownCode: import("svelte").Component<$$ComponentProps, {}, "">;
+type MarkdownCode = ReturnType<typeof MarkdownCode>;
+export default MarkdownCode;

package/dist/MarkdownInlines.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+	import type { InlineNode } from './parse.js';
+	import MarkdownInlines from './MarkdownInlines.svelte';
+	import MarkdownLink from './MarkdownLink.svelte';
+
+	/** Renders inline nodes (text, strong, em, del, code, link, line break). Every string is a plain Svelte text expression, which Svelte escapes. */
+	let { nodes }: { nodes: InlineNode[] } = $props();
+</script>
+
+{#each nodes as n}
+	{#if n.type === 'text'}{n.value}{:else if n.type === 'strong'}<strong><MarkdownInlines nodes={n.children} /></strong>{:else if n.type === 'em'}<em><MarkdownInlines nodes={n.children} /></em>{:else if n.type === 'del'}<del><MarkdownInlines nodes={n.children} /></del>{:else if n.type === 'code'}<code>{n.value}</code>{:else if n.type === 'br'}<br />{:else}<MarkdownLink href={n.href}><MarkdownInlines nodes={n.children} /></MarkdownLink>{/if}
+{/each}

package/dist/MarkdownInlines.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { InlineNode } from './parse.js';
+import MarkdownInlines from './MarkdownInlines.svelte';
+type $$ComponentProps = {
+    nodes: InlineNode[];
+};
+declare const MarkdownInlines: import("svelte").Component<$$ComponentProps, {}, "">;
+type MarkdownInlines = ReturnType<typeof MarkdownInlines>;
+export default MarkdownInlines;

package/dist/MarkdownLink.svelte

@@ -0,0 +1,10 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import { use } from './context.js';
+
+	/** A link node. `href` is already restricted to http, https and mailto by the parser. */
+	let { href, children }: { href: string; children: Snippet } = $props();
+	const ctx = use();
+</script>
+
+{#if ctx.link}{@render ctx.link({ href, children })}{:else}<a {href} target="_blank" rel="noopener noreferrer">{@render children()}</a>{/if}

package/dist/MarkdownLink.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    href: string;
+    children: Snippet;
+};
+declare const MarkdownLink: import("svelte").Component<$$ComponentProps, {}, "">;
+type MarkdownLink = ReturnType<typeof MarkdownLink>;
+export default MarkdownLink;

package/dist/context.d.ts

@@ -0,0 +1,15 @@
+import { type Snippet } from 'svelte';
+/** What a `Markdown` root hands to the nodes below it, read lazily so the overrides stay reactive. */
+export type MarkdownContext = {
+    readonly headingOffset: number;
+    readonly code: Snippet<[{
+        lang: string;
+        text: string;
+    }]> | undefined;
+    readonly link: Snippet<[{
+        href: string;
+        children: Snippet;
+    }]> | undefined;
+};
+export declare const provide: (c: MarkdownContext) => MarkdownContext;
+export declare const use: () => MarkdownContext;

package/dist/context.js

@@ -0,0 +1,4 @@
+import { getContext, setContext } from 'svelte';
+const KEY = Symbol('truss-markdown');
+export const provide = (c) => setContext(KEY, c);
+export const use = () => getContext(KEY);

package/dist/highlight.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A small, dependency-free syntax tokenizer for code blocks. Each language is a short list of sticky regular expressions
+ * tried in order at the current position, plus a word table for keywords, constants and types. The result is plain data,
+ * `{ type, text }[]` per line, that a component renders as text in `<span>`s: no HTML string is ever built.
+ *
+ * It highlights by shape, not by parsing, so it is forgiving: an unterminated string or comment runs to the end of its
+ * line (or the end of the code for block comments), and an unknown language is returned as plain text.
+ */
+export type TokenType = 'keyword' | 'string' | 'number' | 'comment' | 'function' | 'type' | 'variable' | 'constant' | 'operator' | 'punctuation' | 'tag' | 'attr' | 'regexp' | 'plain';
+export type Token = {
+    type: TokenType;
+    text: string;
+};
+/** The canonical language name for a fence label (`ts`, `TypeScript`, `yml`, ...), or `undefined` when it is not highlighted. */
+export declare function resolveLanguage(lang: string | undefined): string | undefined;
+/** The language names that are highlighted. */
+export declare const languages: string[];
+/**
+ * Tokenizes `code` for `lang` (any alias, see `resolveLanguage`), one array of tokens per line. Joining every token's text with
+ * the line breaks gives back the code exactly. An unknown or missing language yields `plain` tokens.
+ */
+export declare function highlight(code: string, lang?: string): Token[][];

package/dist/highlight.js

@@ -0,0 +1,230 @@
+/**
+ * A small, dependency-free syntax tokenizer for code blocks. Each language is a short list of sticky regular expressions
+ * tried in order at the current position, plus a word table for keywords, constants and types. The result is plain data,
+ * `{ type, text }[]` per line, that a component renders as text in `<span>`s: no HTML string is ever built.
+ *
+ * It highlights by shape, not by parsing, so it is forgiving: an unterminated string or comment runs to the end of its
+ * line (or the end of the code for block comments), and an unknown language is returned as plain text.
+ */
+const words = (type, list) => Object.fromEntries(list.split(' ').map((w) => [w, type]));
+const rule = (type, source, extra = {}) => ({ type, re: new RegExp(source, 'y'), ...extra });
+// shared pieces
+const BLOCK = '/\\*[\\s\\S]*?(?:\\*/|$)';
+const DQ = '"(?:[^"\\\\\\n]|\\\\.)*"?';
+const SQ = "'(?:[^'\\\\\\n]|\\\\.)*'?";
+const TPL = '`(?:[^`\\\\]|\\\\[\\s\\S])*`?';
+const NUM = '(?:0[xX][\\da-fA-F_]+|\\d[\\d_]*(?:\\.\\d[\\d_]*)?(?:[eE][+-]?\\d+)?)[A-Za-z]*';
+const OP = '[+\\-*/%=<>!&|^~?:@]+';
+const PUNCT = '[{}()[\\];,.]';
+const IDENT = '[A-Za-z_$][\\w$]*';
+const comment = (source) => rule('comment', source);
+const common = [rule('number', NUM), rule('operator', OP), rule('punctuation', PUNCT)];
+const ident = rule('plain', IDENT, { word: true });
+/** The character before the first non-blank one at or before `i`, to tell a regular expression from a division. */
+const prevSignificant = (src, i) => src.slice(0, i).trimEnd().slice(-1);
+const JS_WORDS = {
+    ...words('keyword', 'as async await break case catch class const continue debugger default delete do else enum export extends finally for from function get if implements import in instanceof interface let new of package private protected public readonly return set static super switch throw try typeof var void while with yield abstract declare namespace type keyof satisfies'),
+    ...words('constant', 'true false null undefined NaN Infinity this'),
+    ...words('type', 'string number boolean any unknown never object symbol bigint void Array Promise Record Map Set')
+};
+const js = {
+    rules: [
+        comment('//[^\\n]*'), comment(BLOCK), rule('string', DQ), rule('string', SQ), rule('string', TPL),
+        rule('regexp', '/(?![*/])(?:[^/\\\\\\n[]|\\\\.|\\[(?:[^\\]\\\\\\n]|\\\\.)*\\])+/[dgimsuvy]*', { when: (_s, i, src) => src[i] === '/' && !/[\w$)\]]/.test(prevSignificant(src, i)) }),
+        ident, ...common
+    ],
+    words: JS_WORDS,
+    caps: true
+};
+const jsx = {
+    ...js,
+    rules: [
+        ...js.rules.slice(0, 2),
+        rule('tag', '</?[A-Za-z][\\w.]*', { when: (_s, i, src) => src[i] === '<' && !/[\w$)\]]/.test(prevSignificant(src, i)) }),
+        rule('tag', '/>'),
+        ...js.rules.slice(2)
+    ]
+};
+const json = {
+    rules: [
+        comment('//[^\\n]*'), comment(BLOCK),
+        rule('attr', '"(?:[^"\\\\\\n]|\\\\.)*"(?=\\s*:)'), rule('string', DQ),
+        ident, rule('number', '-?' + NUM), rule('punctuation', '[{}[\\]:,]')
+    ],
+    words: words('constant', 'true false null')
+};
+const python = {
+    rules: [
+        comment('#[^\\n]*'),
+        rule('string', '(?:[rRbBfFuU]{1,2})?(?:"""[\\s\\S]*?(?:"""|$)|\'\'\'[\\s\\S]*?(?:\'\'\'|$)|' + DQ + '|' + SQ + ')'),
+        rule('function', '@[\\w.]+'), ident, ...common
+    ],
+    words: {
+        ...words('keyword', 'and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield match case'),
+        ...words('constant', 'True False None self cls'),
+        ...words('type', 'int str float bool list dict set tuple bytes object type')
+    },
+    caps: true
+};
+const SQL_KEYWORDS = 'select from where and or not in is null like between join inner left right full outer cross on as group by order having limit offset union all distinct insert into values update set delete create alter drop table index view database primary key foreign references default unique check constraint case when then else end exists with returning asc desc begin commit rollback';
+const sql = {
+    rules: [comment('--[^\\n]*'), comment(BLOCK), rule('string', SQ), rule('variable', '"(?:[^"\\\\\\n]|\\\\.)*"?|`[^`\\n]*`?'), ident, ...common],
+    words: { ...words('keyword', SQL_KEYWORDS), ...words('constant', 'true false null'), ...words('type', 'int integer bigint smallint serial text varchar char boolean bool date time timestamp numeric decimal float real json jsonb uuid') },
+    ci: true
+};
+const bash = {
+    rules: [
+        rule('comment', '#[^\\n]*', { when: (_s, i, src) => i === 0 || /\s|[;|&(]/.test(src[i - 1]) }),
+        rule('string', DQ), rule('string', "'[^']*'?"),
+        rule('variable', '\\$(?:\\{[^}\\n]*\\}?|[A-Za-z_]\\w*|[0-9@*#?$!-])'),
+        rule('attr', '--?[A-Za-z][\\w-]*(?:=)?', { when: (_s, i, src) => i === 0 || /\s/.test(src[i - 1]) }),
+        ident, rule('number', '\\d+'), rule('operator', '[|&<>=!;]+|\\$\\(|`'), rule('punctuation', '[{}()[\\],]')
+    ],
+    words: {
+        ...words('keyword', 'if then elif else fi for while until do done case esac in function select time return exit break continue local export readonly declare unset source alias'),
+        ...words('function', 'echo cd ls cat grep sed awk git npm npx node curl sudo mkdir rm cp mv chmod printf test read eval exec set trap')
+    }
+};
+const markup = (svelte) => ({
+    rules: [
+        comment('<!--[\\s\\S]*?(?:-->|$)'),
+        rule('tag', '</?[A-Za-z][\\w:.-]*', { on: (s) => { s.inTag = true; } }),
+        rule('tag', '/?>', { when: (s) => s.inTag, on: (s) => { s.inTag = false; } }),
+        rule('string', DQ, { when: (s) => s.inTag }), rule('string', SQ, { when: (s) => s.inTag }),
+        rule('attr', '[A-Za-z_:@][\\w:.@-]*', { when: (s) => s.inTag }),
+        rule('operator', '=', { when: (s) => s.inTag }),
+        rule('constant', '&#?\\w+;'),
+        ...(svelte ? [rule('keyword', '\\{[#:/@](?:if|else|each|await|then|catch|key|snippet|render|html|const|debug)\\b'), rule('punctuation', '[{}]')] : [])
+    ],
+    words: {}
+});
+const css = {
+    rules: [
+        comment(BLOCK), rule('string', DQ), rule('string', SQ),
+        rule('keyword', '@[\\w-]+'),
+        rule('number', '#[\\da-fA-F]{3,8}\\b', { when: (s) => s.depth > 0 }),
+        rule('variable', '--[\\w-]+'),
+        rule('attr', '[A-Za-z-]+(?=\\s*:)', { when: (s) => s.depth > 0 }),
+        rule('type', '[.#][\\w-]+(?=[^;{}]*\\{)'),
+        rule('number', NUM + '%?'),
+        rule('function', '[A-Za-z-]+(?=\\()'),
+        rule('punctuation', '[{]', { on: (s) => { s.depth++; } }),
+        rule('punctuation', '[}]', { on: (s) => { s.depth = Math.max(0, s.depth - 1); } }),
+        rule('punctuation', '[();,:[\\]]'), rule('operator', '[>+~*=!]+')
+    ],
+    words: {}
+};
+const yaml = {
+    rules: [
+        comment('#[^\\n]*'), rule('string', DQ), rule('string', SQ),
+        rule('attr', '[\\w.-]+(?=[ \\t]*:(?:\\s|$))'),
+        rule('variable', '[&*][\\w-]+'),
+        rule('punctuation', '---|\\.\\.\\.|[-:,[\\]{}|>?]'),
+        ident, rule('number', '-?\\d[\\d_]*(?:\\.\\d+)?')
+    ],
+    words: words('constant', 'true false null yes no on off True False Null')
+};
+const go = {
+    rules: [comment('//[^\\n]*'), comment(BLOCK), rule('string', DQ), rule('string', SQ), rule('string', '`[^`]*`?'), ident, ...common],
+    words: {
+        ...words('keyword', 'break case chan const continue default defer else fallthrough for func go goto if import interface map package range return select struct switch type var'),
+        ...words('constant', 'true false nil iota'),
+        ...words('type', 'int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex64 complex128 string bool byte rune error any')
+    },
+    caps: true
+};
+const rust = {
+    rules: [
+        comment('//[^\\n]*'), comment(BLOCK), rule('string', DQ), rule('string', "'(?:[^'\\\\\\n]|\\\\.)'"),
+        rule('variable', "'[A-Za-z_]\\w*"), rule('function', '[A-Za-z_]\\w*!(?=[(\\[{])'), ident, ...common
+    ],
+    words: {
+        ...words('keyword', 'as async await break const continue crate dyn else enum extern fn for if impl in let loop match mod move mut pub ref return static struct super trait type unsafe use where while'),
+        ...words('constant', 'true false None Some Ok Err self Self'),
+        ...words('type', 'i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize f32 f64 bool char str String Vec Option Result Box')
+    },
+    caps: true
+};
+const ALIASES = {
+    js: 'js', javascript: 'js', mjs: 'js', cjs: 'js', ts: 'js', typescript: 'js', mts: 'js', cts: 'js',
+    jsx: 'jsx', tsx: 'jsx',
+    json: 'json', jsonc: 'json', json5: 'json',
+    py: 'python', python: 'python', python3: 'python',
+    sql: 'sql', postgres: 'sql', postgresql: 'sql', mysql: 'sql', sqlite: 'sql',
+    bash: 'bash', sh: 'bash', shell: 'bash', zsh: 'bash', console: 'bash',
+    html: 'html', htm: 'html', xml: 'html', svg: 'html', svelte: 'svelte', vue: 'svelte',
+    css: 'css',
+    yaml: 'yaml', yml: 'yaml',
+    diff: 'diff', patch: 'diff',
+    go: 'go', golang: 'go',
+    rust: 'rust', rs: 'rust'
+};
+const GRAMMARS = { js, jsx, json, python, sql, bash, html: markup(false), svelte: markup(true), css, yaml, go, rust };
+/** The canonical language name for a fence label (`ts`, `TypeScript`, `yml`, ...), or `undefined` when it is not highlighted. */
+export function resolveLanguage(lang) {
+    return ALIASES[(lang ?? '').trim().toLowerCase()];
+}
+/** The language names that are highlighted. */
+export const languages = [...new Set(Object.values(ALIASES))];
+function classify(g, word, after) {
+    const known = g.words[g.ci ? word.toLowerCase() : word];
+    if (known)
+        return known;
+    if (after === '(')
+        return 'function';
+    return g.caps && /^[A-Z]/.test(word) ? 'type' : 'plain';
+}
+function scan(src, g) {
+    const out = [];
+    const s = { inTag: false, depth: 0 };
+    const add = (type, text) => {
+        const last = out[out.length - 1];
+        if (last?.type === type)
+            last.text += text;
+        else
+            out.push({ type, text });
+    };
+    let i = 0;
+    outer: while (i < src.length) {
+        for (const r of g.rules) {
+            if (r.when && !r.when(s, i, src))
+                continue;
+            r.re.lastIndex = i;
+            const m = r.re.exec(src);
+            if (!m)
+                continue;
+            r.on?.(s, m[0]);
+            add(r.word ? classify(g, m[0], src[i + m[0].length]) : r.type, m[0]);
+            i += m[0].length;
+            continue outer;
+        }
+        add('plain', src[i++]);
+    }
+    return out;
+}
+/** Diffs are highlighted per line: additions, removals, hunk headers and file headers. */
+function diff(src) {
+    return src.split('\n').map((line) => {
+        const type = /^(\+\+\+|---|diff |index )/.test(line) ? 'comment' : line.startsWith('+') ? 'string' : line.startsWith('-') ? 'tag' : line.startsWith('@@') ? 'function' : 'plain';
+        return line ? [{ type, text: line }] : [];
+    });
+}
+/**
+ * Tokenizes `code` for `lang` (any alias, see `resolveLanguage`), one array of tokens per line. Joining every token's text with
+ * the line breaks gives back the code exactly. An unknown or missing language yields `plain` tokens.
+ */
+export function highlight(code, lang) {
+    const name = resolveLanguage(lang);
+    if (name === 'diff')
+        return diff(code);
+    const tokens = name ? scan(code, GRAMMARS[name]) : [{ type: 'plain', text: code }];
+    const lines = [[]];
+    for (const t of tokens)
+        t.text.split('\n').forEach((part, k) => {
+            if (k)
+                lines.push([]);
+            if (part)
+                lines[lines.length - 1].push({ type: t.type, text: part });
+        });
+    return lines;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Markdown } from './Markdown.svelte';
+export { parseMarkdown, parseInline, isSafeUrl } from './parse.js';
+export type { BlockNode, InlineNode, ListItemNode, TableAlign } from './parse.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { default as Markdown } from './Markdown.svelte';
+export { parseMarkdown, parseInline, isSafeUrl } from './parse.js';

package/dist/parse.d.ts

@@ -0,0 +1,81 @@
+/**
+ * A small Markdown parser for chat messages. Pure and dependency-free: it turns text into a typed AST, which the
+ * `Markdown` component renders with plain Svelte elements. No HTML string is ever produced, so every piece of text
+ * reaches the DOM as a text node and raw HTML in the input is simply shown as text.
+ *
+ * Link targets must start with `http://`, `https://` or `mailto:`; any other link is kept as its plain label text.
+ *
+ * Supported: paragraphs, line breaks, headings, thematic breaks, `**bold**`, `*italic*`, `_italic_`, `~~strike~~`,
+ * `` `code` ``, fenced code blocks, ordered and unordered lists (nested by indentation, with `[ ]`/`[x]` task items),
+ * blockquotes, GFM tables, `[text](url)` links, bare `https://`, `http://` and `www.` autolinks, `<https://...>`
+ * autolinks, `![alt](url)` images (shown as the alt text and a link, never loaded) and backslash escapes.
+ * Anything else is plain text.
+ */
+export type InlineNode = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'strong';
+    children: InlineNode[];
+} | {
+    type: 'em';
+    children: InlineNode[];
+} | {
+    type: 'del';
+    children: InlineNode[];
+} | {
+    type: 'code';
+    value: string;
+} | {
+    type: 'link';
+    href: string;
+    children: InlineNode[];
+} | {
+    type: 'br';
+};
+export type ListItemNode = {
+    type: 'listItem';
+    /** The item's own text. */
+    children: InlineNode[];
+    /** Nested lists and continuation blocks. */
+    blocks: BlockNode[];
+    /** Set on task list items (`- [ ] a`, `- [x] b`): whether the box is checked. */
+    checked?: boolean;
+};
+/** Column alignment of a table: `:---` left, `:---:` center, `---:` right, `---` none. */
+export type TableAlign = 'left' | 'center' | 'right' | null;
+export type BlockNode = {
+    type: 'paragraph';
+    children: InlineNode[];
+} | {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineNode[];
+} | {
+    type: 'list';
+    ordered: boolean;
+    start: number;
+    items: ListItemNode[];
+} | {
+    type: 'code';
+    lang: string;
+    text: string;
+} | {
+    type: 'blockquote';
+    children: BlockNode[];
+}
+/** A GFM table. `align`, `head` and every row have one entry per column. */
+ | {
+    type: 'table';
+    align: TableAlign[];
+    head: InlineNode[][];
+    rows: InlineNode[][][];
+} | {
+    type: 'hr';
+};
+/** True when `url` may be used as a link `href`. */
+export declare const isSafeUrl: (url: string) => boolean;
+/** Parses inline markdown. */
+export declare function parseInline(src: string): InlineNode[];
+/** Parses markdown text into block nodes. */
+export declare function parseMarkdown(text: string): BlockNode[];

package/dist/parse.js

@@ -0,0 +1,297 @@
+/**
+ * A small Markdown parser for chat messages. Pure and dependency-free: it turns text into a typed AST, which the
+ * `Markdown` component renders with plain Svelte elements. No HTML string is ever produced, so every piece of text
+ * reaches the DOM as a text node and raw HTML in the input is simply shown as text.
+ *
+ * Link targets must start with `http://`, `https://` or `mailto:`; any other link is kept as its plain label text.
+ *
+ * Supported: paragraphs, line breaks, headings, thematic breaks, `**bold**`, `*italic*`, `_italic_`, `~~strike~~`,
+ * `` `code` ``, fenced code blocks, ordered and unordered lists (nested by indentation, with `[ ]`/`[x]` task items),
+ * blockquotes, GFM tables, `[text](url)` links, bare `https://`, `http://` and `www.` autolinks, `<https://...>`
+ * autolinks, `![alt](url)` images (shown as the alt text and a link, never loaded) and backslash escapes.
+ * Anything else is plain text.
+ */
+/** An allowed link target: http, https or mailto, with no whitespace or control characters. */
+const SAFE_URL = /^(?:https?:\/\/|mailto:)[^\s\u0000-\u001f\u007f]+$/i;
+/** True when `url` may be used as a link `href`. */
+export const isSafeUrl = (url) => SAFE_URL.test(url);
+const ESCAPE = /\\([\\`*_[\]()#>+.!~|<-])/y;
+const CODE = /(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/y;
+const LINK = /\[([^\]\n]*)\]\(\s*([^()\s]*)\s*\)/y;
+const IMAGE = /!\[([^\]\n]*)\]\(\s*([^()\s]*)\s*\)/y;
+const STRONG_EM = /\*\*\*(?=[^\s*])([^*]*?[^\s*])\*\*\*/y;
+const STRONG = /\*\*(?=\S)([\s\S]*?\S)\*\*/y;
+const EM = /\*(?=[^\s*])([^*]*?[^\s*])\*(?!\*)/y;
+const DEL = /~~(?=[^\s~])([\s\S]*?[^\s~])~~(?!~)/y;
+const STRONG_U = /__(?=\S)([\s\S]*?\S)__(?!\w)/y;
+const EM_U = /_(?=[^\s_])([^_]*?[^\s_])_(?!\w)/y;
+const ANGLE = /<((?:https?:\/\/|mailto:)[^\s<>]+)>/iy;
+const BARE = /(?:https?:\/\/|www\.)[^\s<]+/iy;
+const BARE_HOST = /^(?:https?:\/\/|www\.)[\p{L}\p{N}]/iu;
+const OPENER = { ')': '(', ']': '[', '}': '{' };
+/** Applies the GFM rules for where a bare URL ends: trailing punctuation, unbalanced closers and `&entity;` are not part of it. */
+function trimUrl(url) {
+    let prev;
+    do {
+        prev = url;
+        url = url.replace(/[?!.,:*_~'"]+$/, '');
+        const last = url[url.length - 1];
+        const open = OPENER[last];
+        if (open) {
+            if (url.split(last).length > url.split(open).length)
+                url = url.slice(0, -1);
+        }
+        else
+            url = url.replace(/&[a-z0-9]+;$/i, '');
+    } while (url !== prev);
+    return url;
+}
+/** Parses inline markdown. */
+export function parseInline(src) {
+    return inline(src, false);
+}
+/** `inLink` is set inside link text, where a nested link would be invalid. */
+function inline(src, inLink) {
+    const out = [];
+    let text = '';
+    let i = 0;
+    const flush = () => {
+        if (text)
+            out.push({ type: 'text', value: text });
+        text = '';
+    };
+    const at = (re) => {
+        re.lastIndex = i;
+        return re.exec(src);
+    };
+    while (i < src.length) {
+        const c = src[i];
+        let m = null;
+        if (c === '\\' && (m = at(ESCAPE))) {
+            text += m[1];
+            i += 2;
+            continue;
+        }
+        if (c === '`' && (m = at(CODE))) {
+            flush();
+            out.push({ type: 'code', value: m[2].trim() });
+        }
+        else if (c === '[' && (m = at(LINK))) {
+            flush();
+            const children = inline(m[1], true);
+            if (isSafeUrl(m[2]))
+                out.push({ type: 'link', href: m[2], children });
+            else
+                out.push(...children);
+        }
+        else if (c === '!' && src[i + 1] === '[' && (m = at(IMAGE))) {
+            // an image is never loaded: it becomes its alt text, linked when the address is safe
+            flush();
+            const label = [{ type: 'text', value: m[1] || 'image' }];
+            if (isSafeUrl(m[2]))
+                out.push({ type: 'link', href: m[2], children: label });
+            else
+                out.push(...label);
+        }
+        else if (c === '~' && (m = at(DEL))) {
+            flush();
+            out.push({ type: 'del', children: inline(m[1], inLink) });
+        }
+        else if (c === '<' && !inLink && (m = at(ANGLE))) {
+            flush();
+            out.push({ type: 'link', href: m[1], children: [{ type: 'text', value: m[1] }] });
+        }
+        else if (/[hHwW]/.test(c) && !inLink && (i === 0 || /[\s*_~(]/.test(src[i - 1])) && (m = at(BARE))) {
+            const url = trimUrl(m[0]);
+            if (BARE_HOST.test(url)) {
+                flush();
+                out.push({ type: 'link', href: /^www\./i.test(url) ? `https://${url}` : url, children: [{ type: 'text', value: url }] });
+                i += url.length;
+                continue;
+            }
+            m = null;
+        }
+        else if (c === '*' && (m = at(STRONG_EM))) {
+            flush();
+            out.push({ type: 'strong', children: [{ type: 'em', children: inline(m[1], inLink) }] });
+        }
+        else if (c === '*' && (m = at(STRONG))) {
+            flush();
+            out.push({ type: 'strong', children: inline(m[1], inLink) });
+        }
+        else if (c === '*' && (m = at(EM))) {
+            flush();
+            out.push({ type: 'em', children: inline(m[1], inLink) });
+        }
+        else if (c === '_' && (i === 0 || !/\w/.test(src[i - 1])) && (m = at(STRONG_U))) {
+            flush();
+            out.push({ type: 'strong', children: inline(m[1], inLink) });
+        }
+        else if (c === '_' && (i === 0 || !/\w/.test(src[i - 1])) && (m = at(EM_U))) {
+            flush();
+            out.push({ type: 'em', children: inline(m[1], inLink) });
+        }
+        else {
+            m = null;
+        }
+        if (m)
+            i += m[0].length;
+        else
+            text += src[i++];
+    }
+    flush();
+    return out;
+}
+const FENCE = /^ {0,3}(`{3,}|~{3,})\s*([^\s`]*)[^`]*$/;
+const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const QUOTE = /^ {0,3}>\s?(.*)$/;
+const HR = /^ {0,3}([-*_])(?: *\1){2,} *$/;
+const ITEM = /^( *)([-*+]|\d{1,9}[.)])\s+(.*)$/;
+const TASK = /^\[([ xX])\](?:\s+(.*))?$/;
+const DELIM_CELL = /^(:?)-+(:?)$/;
+const indentOf = (l) => l.length - l.trimStart().length;
+const startsBlock = (l) => FENCE.test(l) || HEADING.test(l) || QUOTE.test(l) || HR.test(l) || ITEM.test(l);
+/** Splits a table row into trimmed cells. The outer pipes are optional and `\|` is a literal pipe. */
+function splitRow(line) {
+    const row = line.trim();
+    const cells = [];
+    let cur = '';
+    for (let k = 0; k < row.length; k++) {
+        const c = row[k];
+        if (c === '\\' && k + 1 < row.length) {
+            cur += row[k + 1] === '|' ? '|' : c + row[k + 1];
+            k++;
+        }
+        else if (c === '|') {
+            cells.push(cur);
+            cur = '';
+        }
+        else
+            cur += c;
+    }
+    cells.push(cur);
+    // a leading pipe leaves an empty first cell; a trailing one leaves an empty last cell
+    if (row.startsWith('|'))
+        cells.shift();
+    if (row.endsWith('|') && !row.endsWith('\\|'))
+        cells.pop();
+    return cells.map((c) => c.trim());
+}
+/** The column alignments when `line` is a table delimiter row (`| :--- | :---: | ---: |`), otherwise null. */
+function delimiter(line) {
+    if (!line.includes('|') || !/^[\s|:-]+$/.test(line))
+        return null;
+    const align = [];
+    for (const cell of splitRow(line)) {
+        const m = DELIM_CELL.exec(cell);
+        if (!m)
+            return null;
+        align.push(m[1] && m[2] ? 'center' : m[2] ? 'right' : m[1] ? 'left' : null);
+    }
+    return align;
+}
+/** Parses markdown text into block nodes. */
+export function parseMarkdown(text) {
+    return blocks(text.replace(/\r\n?/g, '\n').split('\n'));
+}
+function blocks(lines) {
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (!line.trim()) {
+            i++;
+            continue;
+        }
+        const fence = FENCE.exec(line);
+        if (fence) {
+            const [, marker, info] = fence;
+            const body = [];
+            i++;
+            while (i < lines.length && !(lines[i].trim().startsWith(marker) && /^[`~]+$/.test(lines[i].trim())))
+                body.push(lines[i++]);
+            i++; // the closing fence (an unterminated block runs to the end)
+            out.push({ type: 'code', lang: info.replace(/[^\w+#.-]/g, ''), text: body.join('\n') });
+            continue;
+        }
+        const heading = HEADING.exec(line);
+        if (heading) {
+            out.push({ type: 'heading', level: heading[1].length, children: parseInline(heading[2]) });
+            i++;
+            continue;
+        }
+        if (HR.test(line)) {
+            out.push({ type: 'hr' });
+            i++;
+            continue;
+        }
+        if (QUOTE.test(line)) {
+            const inner = [];
+            while (i < lines.length && QUOTE.test(lines[i]))
+                inner.push(QUOTE.exec(lines[i++])[1]);
+            out.push({ type: 'blockquote', children: blocks(inner) });
+            continue;
+        }
+        const item = ITEM.exec(line);
+        if (item) {
+            const base = item[1].length;
+            const ordered = /\d/.test(item[2]);
+            const raw = [];
+            while (i < lines.length) {
+                const m = ITEM.exec(lines[i]);
+                if (m && m[1].length === base && /\d/.test(m[2]) === ordered) {
+                    raw.push({ first: m[3], rest: [] });
+                    i++;
+                }
+                else if (lines[i].trim() && indentOf(lines[i]) > base) {
+                    raw[raw.length - 1].rest.push(lines[i++]); // a nested list or continuation line
+                }
+                else
+                    break;
+            }
+            out.push({
+                type: 'list',
+                ordered,
+                start: ordered ? parseInt(item[2], 10) : 1,
+                items: raw.map((r) => {
+                    const task = TASK.exec(r.first);
+                    const node = { type: 'listItem', children: parseInline(task ? (task[2] ?? '') : r.first), blocks: r.rest.length ? blocks(dedent(r.rest)) : [] };
+                    if (task)
+                        node.checked = task[1] !== ' ';
+                    return node;
+                })
+            });
+            continue;
+        }
+        // a table is a header row and a delimiter row with as many cells, then rows until a blank line or another block
+        const align = line.includes('|') && i + 1 < lines.length ? delimiter(lines[i + 1]) : null;
+        const head = align ? splitRow(line) : [];
+        if (align && head.length === align.length) {
+            const rows = [];
+            i += 2;
+            while (i < lines.length && lines[i].trim() && !startsBlock(lines[i])) {
+                const cells = splitRow(lines[i++]);
+                rows.push(align.map((_, k) => parseInline(cells[k] ?? ''))); // pad short rows, drop extra cells
+            }
+            out.push({ type: 'table', align, head: head.map((c) => parseInline(c)), rows });
+            continue;
+        }
+        // a paragraph runs until a blank line or the start of another block; each line break is kept
+        const para = [line];
+        i++;
+        while (i < lines.length && lines[i].trim() && !startsBlock(lines[i]))
+            para.push(lines[i++]);
+        const children = [];
+        para.forEach((l, k) => {
+            if (k)
+                children.push({ type: 'br' });
+            children.push(...parseInline(l.trim()));
+        });
+        out.push({ type: 'paragraph', children });
+    }
+    return out;
+}
+function dedent(lines) {
+    const min = Math.min(...lines.map(indentOf));
+    return lines.map((l) => l.slice(min));
+}

package/package.json

@@ -1,6 +1,48 @@
 {
-  "name": "@ruckc/truss-markdown",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@ruckc/truss-markdown",
+	"version": "1.12.0",
+	"description": "A safe Markdown renderer for Truss UI: a typed AST rendered with Svelte components, never HTML strings",
+	"type": "module",
+	"license": "MIT",
+	"scripts": {
+		"package": "svelte-package -i src/lib -o dist"
+	},
+	"files": [
+		"dist"
+	],
+	"sideEffects": [
+		"**/*.css"
+	],
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.20.0",
+		"@ruckc/truss-ui": "^1.0.0"
+	},
+	"author": "Curtis Ruck",
+	"homepage": "https://truss.ruck.io",
+	"bugs": {
+		"url": "https://github.com/ruckc/truss-ui/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ruckc/truss-ui.git",
+		"directory": "packages/markdown"
+	},
+	"keywords": [
+		"svelte",
+		"sveltekit",
+		"truss",
+		"markdown",
+		"chat"
+	]
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.