@humanspeak/svelte-markdown 0.8.8 → 0.8.10

package/README.md

@@ -122,6 +122,166 @@ import type {
 } from '@humanspeak/svelte-markdown'
 ```
 
+## Exports for programmatic overrides
+
+You can import renderer maps and helper keys to selectively override behavior.
+
+```ts
+import SvelteMarkdown, {
+    // Maps
+    defaultRenderers, // markdown renderer map
+    Html, // HTML renderer map
+
+    // Keys
+    rendererKeys, // markdown renderer keys (excludes 'html')
+    htmlRendererKeys, // HTML renderer tag names
+
+    // Utility components
+    Unsupported, // markdown-level unsupported fallback
+    UnsupportedHTML // HTML-level unsupported fallback
+} from '@humanspeak/svelte-markdown'
+
+// Example: override a subset
+const customRenderers = {
+    ...defaultRenderers,
+    link: CustomLink,
+    html: {
+        ...Html,
+        span: CustomSpan
+    }
+}
+
+// Optional: iterate keys when building overrides dynamically
+for (const key of rendererKeys) {
+    // if (key === 'paragraph') customRenderers.paragraph = MyParagraph
+}
+for (const tag of htmlRendererKeys) {
+    // if (tag === 'div') customRenderers.html.div = MyDiv
+}
+```
+
+Notes
+
+- `rendererKeys` intentionally excludes `html`. Use `htmlRendererKeys` for HTML tag overrides.
+- `Unsupported` and `UnsupportedHTML` are available if you want a pass-through fallback strategy.
+
+## Helper utilities for allow/deny strategies
+
+These helpers make it easy to either allow only a subset or exclude only a subset of renderers without writing huge maps by hand.
+
+- **HTML helpers**
+    - `buildUnsupportedHTML()`: returns a map where every HTML tag uses `UnsupportedHTML`.
+    - `allowHtmlOnly(allowed)`: enable only the provided tags; others use `UnsupportedHTML`.
+        - Accepts tag names like `'strong'` or tuples like `['div', MyDiv]` to plug in custom components.
+    - `excludeHtmlOnly(excluded, overrides?)`: disable only the listed tags (mapped to `UnsupportedHTML`), with optional overrides for non-excluded tags using tuples.
+- **Markdown helpers (non-HTML)**
+    - `buildUnsupportedRenderers()`: returns a map where all markdown renderers (except `html`) use `Unsupported`.
+    - `allowRenderersOnly(allowed)`: enable only the provided markdown renderer keys; others use `Unsupported`.
+        - Accepts keys like `'paragraph'` or tuples like `['paragraph', MyParagraph]` to plug in custom components.
+    - `excludeRenderersOnly(excluded, overrides?)`: disable only the listed markdown renderer keys, with optional overrides for non-excluded keys using tuples.
+
+### HTML helpers in context
+
+The HTML helpers return an `HtmlRenderers` map to be used inside the `html` key of the overall `renderers` map. They do not replace the entire `renderers` object by themselves.
+
+Basic: keep markdown defaults, allow only a few HTML tags (others become `UnsupportedHTML`):
+
+```ts
+import SvelteMarkdown, { defaultRenderers, allowHtmlOnly } from '@humanspeak/svelte-markdown'
+
+const renderers = {
+    ...defaultRenderers, // keep markdown defaults
+    html: allowHtmlOnly(['strong', 'em', 'a']) // restrict HTML
+}
+```
+
+Allow a custom component for one tag while allowing others with defaults:
+
+```ts
+import SvelteMarkdown, { defaultRenderers, allowHtmlOnly } from '@humanspeak/svelte-markdown'
+
+const renderers = {
+    ...defaultRenderers,
+    html: allowHtmlOnly([['div', MyDiv], 'a'])
+}
+```
+
+Exclude just a few HTML tags; keep all other HTML tags as defaults:
+
+```ts
+import SvelteMarkdown, { defaultRenderers, excludeHtmlOnly } from '@humanspeak/svelte-markdown'
+
+const renderers = {
+    ...defaultRenderers,
+    html: excludeHtmlOnly(['span', 'iframe'])
+}
+
+// Or exclude 'span', but override 'a' to CustomA
+const renderersWithOverride = {
+    ...defaultRenderers,
+    html: excludeHtmlOnly(['span'], [['a', CustomA]])
+}
+```
+
+Disable all HTML quickly (markdown defaults unchanged):
+
+```ts
+import SvelteMarkdown, { defaultRenderers, buildUnsupportedHTML } from '@humanspeak/svelte-markdown'
+
+const renderers = {
+    ...defaultRenderers,
+    html: buildUnsupportedHTML()
+}
+```
+
+### Markdown-only (non-HTML) scenarios
+
+Allow only paragraph and link with defaults, disable others:
+
+```ts
+import { allowRenderersOnly } from '@humanspeak/svelte-markdown'
+
+const md = allowRenderersOnly(['paragraph', 'link'])
+```
+
+Exclude just link; keep others as defaults:
+
+```ts
+import { excludeRenderersOnly } from '@humanspeak/svelte-markdown'
+
+const md = excludeRenderersOnly(['link'])
+```
+
+Disable all markdown renderers (except `html`) quickly:
+
+```ts
+import { buildUnsupportedRenderers } from '@humanspeak/svelte-markdown'
+
+const md = buildUnsupportedRenderers()
+```
+
+### Combine HTML and Markdown helpers
+
+You can combine both maps in `renderers` for `SvelteMarkdown`.
+
+```svelte
+<script lang="ts">
+    import SvelteMarkdown, { allowRenderersOnly, allowHtmlOnly } from '@humanspeak/svelte-markdown'
+
+    const renderers = {
+        // Only allow a minimal markdown set
+        ...allowRenderersOnly(['paragraph', 'link']),
+
+        // Configure HTML separately (only strong/em/a)
+        html: allowHtmlOnly(['strong', 'em', 'a'])
+    }
+
+    const source = `# Title\n\nThis has <strong>HTML</strong> and [a link](https://example.com).`
+</script>
+
+<SvelteMarkdown {source} {renderers} />
+```
+
 ## Custom Renderer Example
 
 Here's a complete example of a custom renderer with TypeScript support:

package/dist/Parser.svelte

@@ -109,44 +109,13 @@
                                 {#each row ?? [] as cells, i (i)}
                                     {@const { align: _align, ...cellRest } = rest}
                                     <renderers.tablecell
+                                        {...cellRest}
                                         header={false}
                                         align={(rest.align as string[])[i]}
-                                        {...cellRest}
                                     >
-                                        {#if cells.tokens?.[0]?.type === 'html'}
-                                            {@const token = cells.tokens[0] as Token & {
-                                                tag: string
-                                                tokens?: Token[]
-                                            }}
-                                            {@const { tag, ...localRest } = token}
-                                            {@const htmlTag = tag as keyof typeof Html}
-                                            {#if renderers.html && htmlTag in renderers.html}
-                                                {@const HtmlComponent =
-                                                    renderers.html[
-                                                        htmlTag as keyof typeof renderers.html
-                                                    ]}
-                                                {#if HtmlComponent}
-                                                    <HtmlComponent {...token}>
-                                                        {#if token.tokens?.length}
-                                                            <Parser
-                                                                tokens={token.tokens}
-                                                                {renderers}
-                                                                {...Object.fromEntries(
-                                                                    Object.entries(
-                                                                        localRest
-                                                                    ).filter(
-                                                                        ([key]) =>
-                                                                            key !== 'attributes'
-                                                                    )
-                                                                )}
-                                                            />
-                                                        {/if}
-                                                    </HtmlComponent>
-                                                {/if}
-                                            {/if}
-                                        {:else}
-                                            <Parser tokens={cells.tokens} {renderers} />
-                                        {/if}
+                                        {#each cells.tokens ?? [] as cellToken, index (index)}
+                                            <Parser {...cellRest} {...cellToken} {renderers} />
+                                        {/each}
                                     </renderers.tablecell>
                                 {/each}
                             </renderers.tablerow>
@@ -158,7 +127,8 @@
     {:else if type === 'list' && renderers.list}
         {#if ordered}
             <renderers.list {ordered} {...rest}>
-                {@const { items, ...parserRest }: {items: Props[]} = rest}
+                {@const { items: _items, ...parserRest } = rest}
+                {@const items = (_items as Props[] | undefined) ?? []}
                 {#each items as item, index (index)}
                     {@const OrderedListComponent = renderers.orderedlistitem || renderers.listitem}
                     {#if OrderedListComponent}
@@ -170,7 +140,8 @@
             </renderers.list>
         {:else}
             <renderers.list {ordered} {...rest}>
-                {@const { items, ...parserRest }: {items: Props[]} = rest}
+                {@const { items: _items, ...parserRest } = rest}
+                {@const items = (_items as Props[] | undefined) ?? []}
                 {#each items as item, index (index)}
                     {@const UnorderedListComponent =
                         renderers.unorderedlistitem || renderers.listitem}

package/dist/index.d.ts

@@ -1,6 +1,12 @@
-import type { HtmlRenderers } from './renderers/html/index.js';
-import type { RendererComponent, Renderers, Token, TokensList } from './utils/markdown-parser.js';
+import { type HtmlRenderers } from './renderers/html/index.js';
 import SvelteMarkdown from './SvelteMarkdown.svelte';
 import type { SvelteMarkdownOptions, SvelteMarkdownProps } from './types.js';
+import { defaultRenderers, type RendererComponent, type Renderers, type Token, type TokensList } from './utils/markdown-parser.js';
 export default SvelteMarkdown;
+export { default as Html, UnsupportedHTML } from './renderers/html/index.js';
+export { Unsupported } from './renderers/index.js';
+export { allowHtmlOnly, buildUnsupportedHTML, excludeHtmlOnly } from './utils/unsupportedHtmlRenderers.js';
+export { allowRenderersOnly, buildUnsupportedRenderers, excludeRenderersOnly } from './utils/unsupportedRenderers.js';
+export { defaultRenderers };
+export { htmlRendererKeysInternal as htmlRendererKeys, rendererKeysInternal as rendererKeys } from './utils/rendererKeys.js';
 export type { HtmlRenderers, RendererComponent, Renderers, SvelteMarkdownOptions, SvelteMarkdownProps, Token, TokensList };

package/dist/index.js

@@ -1,2 +1,12 @@
+// Reexport your entry components here
+import {} from './renderers/html/index.js';
 import SvelteMarkdown from './SvelteMarkdown.svelte';
+import { defaultRenderers } from './utils/markdown-parser.js';
 export default SvelteMarkdown;
+export { default as Html, UnsupportedHTML } from './renderers/html/index.js';
+export { Unsupported } from './renderers/index.js';
+export { allowHtmlOnly, buildUnsupportedHTML, excludeHtmlOnly } from './utils/unsupportedHtmlRenderers.js';
+export { allowRenderersOnly, buildUnsupportedRenderers, excludeRenderersOnly } from './utils/unsupportedRenderers.js';
+export { defaultRenderers };
+// Canonical key lists (public API names)
+export { htmlRendererKeysInternal as htmlRendererKeys, rendererKeysInternal as rendererKeys } from './utils/rendererKeys.js';

package/dist/renderers/_Unsupported.svelte

@@ -0,0 +1,5 @@
+<script lang="ts">
+    const { raw } = $props()
+</script>
+
+{raw}

package/dist/renderers/_Unsupported.svelte.d.ts

@@ -0,0 +1,5 @@
+declare const Unsupported: import("svelte").Component<{
+    raw: any;
+}, {}, "">;
+type Unsupported = ReturnType<typeof Unsupported>;
+export default Unsupported;

package/dist/renderers/html/Br.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">
+    interface Props {
+        attributes?: Record<string, any> // eslint-disable-line @typescript-eslint/no-explicit-any
+    }
+
+    const { attributes = {} }: Props = $props()
+</script>
+
+<br {...attributes} />

package/dist/renderers/html/Br.svelte.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    attributes?: Record<string, any>;
+}
+declare const Br: import("svelte").Component<Props, {}, "">;
+type Br = ReturnType<typeof Br>;
+export default Br;

package/dist/renderers/html/_UnsupportedHTML.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+    import type { Snippet } from 'svelte'
+
+    const {
+        children,
+        tag,
+        attributes
+    }: { children?: Snippet; tag: string; attributes?: Record<string, string> } = $props()
+
+    const attributesString =
+        Object.entries(attributes || {})
+            .map(([key, value]) => `${key}="${value}"`)
+            .join(' ') || ''
+</script>
+
+&lt;{tag}{attributesString ? ` ${attributesString}` : ''}&gt;{@render children?.()}&lt;/{tag}&gt;

package/dist/renderers/html/_UnsupportedHTML.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    children?: Snippet;
+    tag: string;
+    attributes?: Record<string, string>;
+};
+declare const UnsupportedHtml: import("svelte").Component<$$ComponentProps, {}, "">;
+type UnsupportedHtml = ReturnType<typeof UnsupportedHtml>;
+export default UnsupportedHtml;

package/dist/renderers/html/index.d.ts

@@ -1,6 +1,8 @@
 import type { Component } from 'svelte';
+import UnsupportedHTML from './_UnsupportedHTML.svelte';
 export interface HtmlRenderers {
     [key: string]: Component<any, any, any> | null;
 }
 export declare const Html: HtmlRenderers;
 export default Html;
+export { UnsupportedHTML };

package/dist/renderers/html/index.js

@@ -8,6 +8,7 @@ import B from './B.svelte';
 import Bdi from './Bdi.svelte';
 import Bdo from './Bdo.svelte';
 import Blockquote from './Blockquote.svelte';
+import Br from './Br.svelte';
 import Button from './Button.svelte';
 import Canvas from './Canvas.svelte';
 import Cite from './Cite.svelte';
@@ -80,6 +81,7 @@ import Track from './Track.svelte';
 import U from './U.svelte';
 import Ul from './Ul.svelte';
 import Var from './Var.svelte';
+import UnsupportedHTML from './_UnsupportedHTML.svelte';
 export const Html = {
     a: A,
     abbr: Abbr,
@@ -91,6 +93,7 @@ export const Html = {
     bdi: Bdi,
     bdo: Bdo,
     blockquote: Blockquote,
+    br: Br,
     button: Button,
     canvas: Canvas,
     cite: Cite,
@@ -165,3 +168,4 @@ export const Html = {
     var: Var
 };
 export default Html;
+export { UnsupportedHTML };

package/dist/renderers/index.d.ts

@@ -1,3 +1,4 @@
+export { default as Unsupported } from './_Unsupported.svelte';
 export { default as Blockquote } from './Blockquote.svelte';
 export { default as Br } from './Br.svelte';
 export { default as Code } from './Code.svelte';

package/dist/renderers/index.js

@@ -1,3 +1,4 @@
+export { default as Unsupported } from './_Unsupported.svelte';
 export { default as Blockquote } from './Blockquote.svelte';
 export { default as Br } from './Br.svelte';
 export { default as Code } from './Code.svelte';

package/dist/utils/rendererKeys.d.ts

@@ -0,0 +1,6 @@
+import Html from '../renderers/html/index.js';
+import { type Renderers } from './markdown-parser.js';
+export type RendererKey = Exclude<keyof Renderers, 'html'>;
+export declare const rendererKeysInternal: RendererKey[];
+export type HtmlKey = keyof typeof Html;
+export declare const htmlRendererKeysInternal: HtmlKey[];

package/dist/utils/rendererKeys.js

@@ -0,0 +1,4 @@
+import Html from '../renderers/html/index.js';
+import { defaultRenderers } from './markdown-parser.js';
+export const rendererKeysInternal = Object.keys(defaultRenderers).filter((k) => k !== 'html');
+export const htmlRendererKeysInternal = Object.keys(Html);

package/dist/utils/token-cleanup.d.ts

@@ -94,6 +94,7 @@ export declare const containsMultipleTags: (html: string) => boolean;
  *
  * Key features:
  * - Breaks down complex HTML structures into atomic tokens
+ * - Formats self-closing tags with proper syntax (e.g., <br> -> <br/>)
  * - Maintains attribute information
  * - Preserves proper nesting relationships
  * - Handles malformed HTML gracefully

package/dist/utils/token-cleanup.js

@@ -12,6 +12,11 @@ import * as htmlparser2 from 'htmlparser2';
  */
 const HTML_TAG_PATTERN = /<\/?([a-zA-Z][a-zA-Z0-9-]{0,})(?:\s+[^>]*)?>/;
 const htmlTagRegex = new RegExp(HTML_TAG_PATTERN);
+/**
+ * Regex pattern for self-closing HTML tags.
+ * @const {RegExp}
+ */
+const SELF_CLOSING_TAGS = /^(br|hr|img|input|link|meta|area|base|col|embed|keygen|param|source|track|wbr)$/i;
 /**
  * Analyzes a string to determine if it contains an HTML tag and its characteristics.
  *
@@ -37,6 +42,33 @@ export const isHtmlOpenTag = (raw) => {
         return null;
     return { tag: match[1], isOpening: !raw.startsWith('</') };
 };
+/**
+ * Formats individual HTML tokens to ensure self-closing tags are properly formatted.
+ * This handles cases like <br> -> <br/> without affecting the token structure.
+ *
+ * @param {Token} token - HTML token to format
+ * @returns {Token} Formatted token with proper self-closing syntax
+ */
+const formatSelfClosingHtmlToken = (token) => {
+    // Extract tag name from raw HTML
+    const tagMatch = token.raw.match(/<\/?([a-zA-Z][a-zA-Z0-9-]*)/i);
+    if (!tagMatch)
+        return token;
+    const tagName = tagMatch[1];
+    if (!SELF_CLOSING_TAGS.test(tagName))
+        return token;
+    // If it's a self-closing tag and doesn't already end with />, format it properly
+    if (!token.raw.endsWith('/>')) {
+        const formattedRaw = token.raw.replace(/\s*>$/, '/>');
+        return {
+            ...token,
+            raw: formattedRaw,
+            tag: tagName,
+            attributes: extractAttributes(token.raw)
+        };
+    }
+    return token;
+};
 /**
  * Parses HTML attributes from a tag string into a structured object.
  * Handles both single and double quoted attributes.
@@ -117,7 +149,6 @@ export const extractAttributes = (raw) => {
 export const parseHtmlBlock = (html) => {
     const tokens = [];
     let currentText = '';
-    const selfClosingTags = /^(br|hr|img|input|link|meta|area|base|col|embed|keygen|param|source|track|wbr)$/i;
     const openTags = [];
     const parser = new htmlparser2.Parser({
         onopentag: (name, attributes) => {
@@ -129,8 +160,7 @@ export const parseHtmlBlock = (html) => {
                 });
                 currentText = '';
             }
-            openTags.push(name);
-            if (selfClosingTags.test(name)) {
+            if (SELF_CLOSING_TAGS.test(name)) {
                 tokens.push({
                     type: 'html',
                     raw: `<${name}${Object.entries(attributes)
@@ -141,6 +171,7 @@ export const parseHtmlBlock = (html) => {
                 });
             }
             else {
+                openTags.push(name);
                 tokens.push({
                     type: 'html',
                     raw: `<${name}${Object.entries(attributes)
@@ -165,7 +196,7 @@ export const parseHtmlBlock = (html) => {
             }
             // Only add closing tag if we found its opening tag
             // and it's not a self-closing tag
-            if (openTags.includes(name) && !selfClosingTags.test(name)) {
+            if (openTags.includes(name) && !SELF_CLOSING_TAGS.test(name)) {
                 if (html.includes(`</${name}>`)) {
                     tokens.push({
                         type: 'html',
@@ -219,6 +250,7 @@ export const containsMultipleTags = (html) => {
  *
  * Key features:
  * - Breaks down complex HTML structures into atomic tokens
+ * - Formats self-closing tags with proper syntax (e.g., <br> -> <br/>)
  * - Maintains attribute information
  * - Preserves proper nesting relationships
  * - Handles malformed HTML gracefully
@@ -251,6 +283,7 @@ export const shrinkHtmlTokens = (tokens) => {
         else if (token.type === 'table') {
             // Process header cells
             if (token.header) {
+                // @ts-expect-error: expected any
                 token.header = token.header.map((cell) => ({
                     ...cell,
                     tokens: cell.tokens ? shrinkHtmlTokens(cell.tokens) : []
@@ -258,7 +291,10 @@ export const shrinkHtmlTokens = (tokens) => {
             }
             // Process row cells
             if (token.rows) {
-                token.rows = token.rows.map((row) => row.map((cell) => ({
+                // @ts-expect-error: expected any
+                token.rows = token.rows.map((row) => 
+                // @ts-expect-error: expected any
+                row.map((cell) => ({
                     ...cell,
                     tokens: cell.tokens ? shrinkHtmlTokens(cell.tokens) : []
                 })));
@@ -269,6 +305,11 @@ export const shrinkHtmlTokens = (tokens) => {
             // Parse HTML with multiple tags into separate tokens
             result.push(...parseHtmlBlock(token.raw));
         }
+        else if (token.type === 'html') {
+            // Format self-closing tags properly (e.g., <br> -> <br/>)
+            const formattedToken = formatSelfClosingHtmlToken(token);
+            result.push(formattedToken);
+        }
         else {
             result.push(token);
         }

package/dist/utils/unsupportedHtmlRenderers.d.ts

@@ -0,0 +1,62 @@
+import { type HtmlRenderers } from '../renderers/html/index.js';
+import { type HtmlKey } from './rendererKeys.js';
+import type { Component } from 'svelte';
+/**
+ * Builds a map of HTML renderers where every known HTML tag is mapped to `UnsupportedHTML`.
+ * This is useful when you want to disable all built‑in HTML rendering and provide
+ * explicit allow-lists or a minimal subset afterwards.
+ *
+ * @function buildUnsupportedHTML
+ * @returns {HtmlRenderers} A map containing all tags set to `UnsupportedHTML`.
+ * @example
+ * import { buildUnsupportedHTML } from '@humanspeak/svelte-markdown'
+ * const renderers = {
+ *   html: buildUnsupportedHTML()
+ * }
+ */
+export declare const buildUnsupportedHTML: () => HtmlRenderers;
+/**
+ * Produces an HTML renderer map that allows only the specified tags.
+ * All non‑listed tags are set to `UnsupportedHTML`.
+ *
+ * Each entry can be either a tag name (to use the library’s default component for that tag),
+ * or a tuple `[tag, component]` to specify a custom component for that tag.
+ *
+ * @function allowHtmlOnly
+ * @param {Array<keyof HtmlRenderers | [keyof HtmlRenderers, Component | null]>} allowed
+ *        Tag names to allow, or tuples specifying a custom component per allowed tag.
+ *        Any tag not listed will be mapped to `UnsupportedHTML`.
+ * @returns {HtmlRenderers} A renderer map with only the provided tags enabled.
+ * @example
+ * // Only allow strong/em/a with default components; everything else UnsupportedHTML
+ * const html = allowHtmlOnly(['strong', 'em', 'a'])
+ *
+ * @example
+ * // Allow a custom component for div while allowing the default for a
+ * const html = allowHtmlOnly([['div', MyDiv], 'a'])
+ */
+export declare const allowHtmlOnly: (allowed: Array<HtmlKey | [HtmlKey, Component | null]>) => HtmlRenderers;
+/**
+ * Produces an HTML renderer map that excludes only the specified tags.
+ * Excluded tags are mapped to `UnsupportedHTML`, while all other tags use the
+ * library’s default components. Optionally, you can override specific non‑excluded
+ * tags with custom components using `[tag, component]` tuples.
+ *
+ * Exclusions take precedence over overrides. If a tag is listed in `excluded`, an
+ * override for the same tag will be ignored.
+ *
+ * @function excludeHtmlOnly
+ * @param {Array<keyof HtmlRenderers>} excluded
+ *        Tag names to exclude (set to `UnsupportedHTML`).
+ * @param {Array<[keyof HtmlRenderers, Component | null]>} [overrides]
+ *        Optional tuples mapping non‑excluded tags to custom components.
+ * @returns {HtmlRenderers} A renderer map with only the provided tags excluded.
+ * @example
+ * // Disable just span and div, keep others as defaults
+ * const html = excludeHtmlOnly(['span', 'div'])
+ *
+ * @example
+ * // Disable span; override 'a' to CustomA component
+ * const html = excludeHtmlOnly(['span'], [['a', CustomA]])
+ */
+export declare const excludeHtmlOnly: (excluded: HtmlKey[], overrides?: Array<[HtmlKey, Component | null]>) => HtmlRenderers;

package/dist/utils/unsupportedHtmlRenderers.js

@@ -0,0 +1,99 @@
+import Html, { UnsupportedHTML } from '../renderers/html/index.js';
+import { htmlRendererKeysInternal } from './rendererKeys.js';
+/**
+ * Builds a map of HTML renderers where every known HTML tag is mapped to `UnsupportedHTML`.
+ * This is useful when you want to disable all built‑in HTML rendering and provide
+ * explicit allow-lists or a minimal subset afterwards.
+ *
+ * @function buildUnsupportedHTML
+ * @returns {HtmlRenderers} A map containing all tags set to `UnsupportedHTML`.
+ * @example
+ * import { buildUnsupportedHTML } from '@humanspeak/svelte-markdown'
+ * const renderers = {
+ *   html: buildUnsupportedHTML()
+ * }
+ */
+export const buildUnsupportedHTML = () => {
+    const result = {};
+    for (const key of htmlRendererKeysInternal) {
+        result[key] = UnsupportedHTML;
+    }
+    return result;
+};
+/**
+ * Produces an HTML renderer map that allows only the specified tags.
+ * All non‑listed tags are set to `UnsupportedHTML`.
+ *
+ * Each entry can be either a tag name (to use the library’s default component for that tag),
+ * or a tuple `[tag, component]` to specify a custom component for that tag.
+ *
+ * @function allowHtmlOnly
+ * @param {Array<keyof HtmlRenderers | [keyof HtmlRenderers, Component | null]>} allowed
+ *        Tag names to allow, or tuples specifying a custom component per allowed tag.
+ *        Any tag not listed will be mapped to `UnsupportedHTML`.
+ * @returns {HtmlRenderers} A renderer map with only the provided tags enabled.
+ * @example
+ * // Only allow strong/em/a with default components; everything else UnsupportedHTML
+ * const html = allowHtmlOnly(['strong', 'em', 'a'])
+ *
+ * @example
+ * // Allow a custom component for div while allowing the default for a
+ * const html = allowHtmlOnly([['div', MyDiv], 'a'])
+ */
+export const allowHtmlOnly = (allowed) => {
+    const result = buildUnsupportedHTML();
+    for (const entry of allowed) {
+        if (Array.isArray(entry)) {
+            const [tag, component] = entry;
+            // Only set if the tag exists in our Html map
+            if (tag in Html)
+                result[tag] = component;
+        }
+        else {
+            const tag = entry;
+            if (tag in Html)
+                result[tag] = Html[tag];
+        }
+    }
+    return result;
+};
+/**
+ * Produces an HTML renderer map that excludes only the specified tags.
+ * Excluded tags are mapped to `UnsupportedHTML`, while all other tags use the
+ * library’s default components. Optionally, you can override specific non‑excluded
+ * tags with custom components using `[tag, component]` tuples.
+ *
+ * Exclusions take precedence over overrides. If a tag is listed in `excluded`, an
+ * override for the same tag will be ignored.
+ *
+ * @function excludeHtmlOnly
+ * @param {Array<keyof HtmlRenderers>} excluded
+ *        Tag names to exclude (set to `UnsupportedHTML`).
+ * @param {Array<[keyof HtmlRenderers, Component | null]>} [overrides]
+ *        Optional tuples mapping non‑excluded tags to custom components.
+ * @returns {HtmlRenderers} A renderer map with only the provided tags excluded.
+ * @example
+ * // Disable just span and div, keep others as defaults
+ * const html = excludeHtmlOnly(['span', 'div'])
+ *
+ * @example
+ * // Disable span; override 'a' to CustomA component
+ * const html = excludeHtmlOnly(['span'], [['a', CustomA]])
+ */
+export const excludeHtmlOnly = (excluded, overrides) => {
+    const result = { ...Html };
+    for (const tag of excluded) {
+        if (tag in Html)
+            result[tag] = UnsupportedHTML;
+    }
+    if (overrides) {
+        for (const [tag, component] of overrides) {
+            // Exclusions take precedence; do not override excluded tags
+            if (excluded.includes(tag))
+                continue;
+            if (tag in Html)
+                result[tag] = component;
+        }
+    }
+    return result;
+};

package/dist/utils/unsupportedRenderers.d.ts

@@ -0,0 +1,57 @@
+import { type RendererComponent, type Renderers } from './markdown-parser.js';
+import { type RendererKey } from './rendererKeys.js';
+/**
+ * Builds a map where every markdown renderer (excluding the special `html` map)
+ * is set to the `Unsupported` component.
+ *
+ * @function buildUnsupportedRenderers
+ * @returns {Partial<Renderers>} A map with all non‑HTML renderers set to `Unsupported`.
+ * @example
+ * import { buildUnsupportedRenderers } from '@humanspeak/svelte-markdown'
+ * const renderers = {
+ *   ...buildUnsupportedRenderers(),
+ *   html: {} // customize HTML separately
+ * }
+ */
+export declare const buildUnsupportedRenderers: () => Partial<Renderers>;
+/**
+ * Produces a renderer map that allows only the specified markdown renderers (excluding `html`).
+ * All non‑listed renderer keys are set to `Unsupported`.
+ * Each entry can be either a renderer key (to use the library’s default component),
+ * or a tuple `[key, component]` to specify a custom component for that key.
+ *
+ * @function allowRenderersOnly
+ * @param {Array<RendererKey | [RendererKey, RendererComponent]>} allowed
+ *        Renderer keys to allow, or tuples for custom component overrides.
+ * @returns {Partial<Renderers>} A renderer map with only the provided keys enabled.
+ * @example
+ * // Allow only paragraph and link with defaults
+ * const renderers = allowRenderersOnly(['paragraph', 'link'])
+ *
+ * @example
+ * // Allow paragraph with a custom component
+ * const renderers = allowRenderersOnly([['paragraph', MyParagraph]])
+ */
+export declare const allowRenderersOnly: (allowed: Array<RendererKey | [RendererKey, RendererComponent]>) => Partial<Renderers>;
+/**
+ * Produces a renderer map that excludes only the specified markdown renderer keys (excluding `html`).
+ * Excluded keys are mapped to `Unsupported`, while all other keys use the library’s default components.
+ * Optionally override specific non‑excluded keys with custom components via `[key, component]` tuples.
+ *
+ * Exclusions take precedence over overrides.
+ *
+ * @function excludeRenderersOnly
+ * @param {Array<RendererKey>} excluded
+ *        Renderer keys to exclude (set to `Unsupported`).
+ * @param {Array<[RendererKey, RendererComponent]>} [overrides]
+ *        Optional tuples mapping non‑excluded keys to custom components.
+ * @returns {Partial<Renderers>} A renderer map with only the provided keys excluded.
+ * @example
+ * // Disable just paragraph and link, keep others as defaults
+ * const renderers = excludeRenderersOnly(['paragraph', 'link'])
+ *
+ * @example
+ * // Disable link; override paragraph to a custom component
+ * const renderers = excludeRenderersOnly(['link'], [['paragraph', MyParagraph]])
+ */
+export declare const excludeRenderersOnly: (excluded: RendererKey[], overrides?: Array<[RendererKey, RendererComponent]>) => Partial<Renderers>;

package/dist/utils/unsupportedRenderers.js

@@ -0,0 +1,98 @@
+import { Unsupported } from '../renderers/index.js';
+import { defaultRenderers } from './markdown-parser.js';
+import { rendererKeysInternal } from './rendererKeys.js';
+const allRendererKeys = rendererKeysInternal;
+/**
+ * Builds a map where every markdown renderer (excluding the special `html` map)
+ * is set to the `Unsupported` component.
+ *
+ * @function buildUnsupportedRenderers
+ * @returns {Partial<Renderers>} A map with all non‑HTML renderers set to `Unsupported`.
+ * @example
+ * import { buildUnsupportedRenderers } from '@humanspeak/svelte-markdown'
+ * const renderers = {
+ *   ...buildUnsupportedRenderers(),
+ *   html: {} // customize HTML separately
+ * }
+ */
+export const buildUnsupportedRenderers = () => {
+    const result = {};
+    for (const key of allRendererKeys) {
+        result[key] = Unsupported;
+    }
+    return result;
+};
+/**
+ * Produces a renderer map that allows only the specified markdown renderers (excluding `html`).
+ * All non‑listed renderer keys are set to `Unsupported`.
+ * Each entry can be either a renderer key (to use the library’s default component),
+ * or a tuple `[key, component]` to specify a custom component for that key.
+ *
+ * @function allowRenderersOnly
+ * @param {Array<RendererKey | [RendererKey, RendererComponent]>} allowed
+ *        Renderer keys to allow, or tuples for custom component overrides.
+ * @returns {Partial<Renderers>} A renderer map with only the provided keys enabled.
+ * @example
+ * // Allow only paragraph and link with defaults
+ * const renderers = allowRenderersOnly(['paragraph', 'link'])
+ *
+ * @example
+ * // Allow paragraph with a custom component
+ * const renderers = allowRenderersOnly([['paragraph', MyParagraph]])
+ */
+export const allowRenderersOnly = (allowed) => {
+    const result = buildUnsupportedRenderers();
+    for (const entry of allowed) {
+        if (Array.isArray(entry)) {
+            const [key, component] = entry;
+            if (allRendererKeys.includes(key))
+                result[key] = component;
+        }
+        else {
+            const key = entry;
+            if (allRendererKeys.includes(key))
+                result[key] = defaultRenderers[key];
+        }
+    }
+    return result;
+};
+/**
+ * Produces a renderer map that excludes only the specified markdown renderer keys (excluding `html`).
+ * Excluded keys are mapped to `Unsupported`, while all other keys use the library’s default components.
+ * Optionally override specific non‑excluded keys with custom components via `[key, component]` tuples.
+ *
+ * Exclusions take precedence over overrides.
+ *
+ * @function excludeRenderersOnly
+ * @param {Array<RendererKey>} excluded
+ *        Renderer keys to exclude (set to `Unsupported`).
+ * @param {Array<[RendererKey, RendererComponent]>} [overrides]
+ *        Optional tuples mapping non‑excluded keys to custom components.
+ * @returns {Partial<Renderers>} A renderer map with only the provided keys excluded.
+ * @example
+ * // Disable just paragraph and link, keep others as defaults
+ * const renderers = excludeRenderersOnly(['paragraph', 'link'])
+ *
+ * @example
+ * // Disable link; override paragraph to a custom component
+ * const renderers = excludeRenderersOnly(['link'], [['paragraph', MyParagraph]])
+ */
+export const excludeRenderersOnly = (excluded, overrides) => {
+    const result = {};
+    for (const key of allRendererKeys) {
+        result[key] = defaultRenderers[key];
+    }
+    for (const key of excluded) {
+        if (allRendererKeys.includes(key))
+            result[key] = Unsupported;
+    }
+    if (overrides) {
+        for (const [key, component] of overrides) {
+            if (excluded.includes(key))
+                continue;
+            if (allRendererKeys.includes(key))
+                result[key] = component;
+        }
+    }
+    return result;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@humanspeak/svelte-markdown",
-    "version": "0.8.8",
+    "version": "0.8.10",
     "description": "A powerful, customizable markdown renderer for Svelte with TypeScript support",
     "keywords": [
         "svelte",
@@ -58,6 +58,7 @@
         "lint": "prettier --check . && eslint .",
         "lint:fix": "npm run format && eslint . --fix",
         "package": "svelte-kit sync && svelte-package && publint",
+        "prepare": "husky",
         "prepublishOnly": "npm run package",
         "preview": "vite preview",
         "test": "vitest run --coverage",
@@ -77,47 +78,48 @@
     "dependencies": {
         "github-slugger": "^2.0.0",
         "htmlparser2": "^10.0.0",
-        "marked": "^16.0.0"
+        "marked": "^16.1.2"
     },
     "devDependencies": {
-        "@eslint/compat": "^1.3.1",
-        "@eslint/js": "^9.31.0",
-        "@playwright/test": "^1.54.1",
-        "@sveltejs/adapter-auto": "^6.0.1",
-        "@sveltejs/kit": "^2.22.5",
-        "@sveltejs/package": "^2.3.12",
-        "@sveltejs/vite-plugin-svelte": "^6.0.0",
-        "@testing-library/jest-dom": "^6.6.3",
+        "@eslint/compat": "^1.3.2",
+        "@eslint/js": "^9.33.0",
+        "@playwright/test": "^1.54.2",
+        "@sveltejs/adapter-auto": "^6.0.2",
+        "@sveltejs/kit": "^2.27.3",
+        "@sveltejs/package": "^2.4.1",
+        "@sveltejs/vite-plugin-svelte": "^6.1.1",
+        "@testing-library/jest-dom": "^6.6.4",
         "@testing-library/svelte": "^5.2.8",
         "@testing-library/user-event": "^14.6.1",
-        "@types/node": "^24.0.13",
-        "@typescript-eslint/eslint-plugin": "^8.36.0",
-        "@typescript-eslint/parser": "^8.36.0",
+        "@types/node": "^24.2.1",
+        "@typescript-eslint/eslint-plugin": "^8.39.0",
+        "@typescript-eslint/parser": "^8.39.0",
         "@vitest/coverage-v8": "^3.2.4",
-        "eslint": "^9.31.0",
-        "eslint-config-prettier": "^10.1.5",
+        "eslint": "^9.33.0",
+        "eslint-config-prettier": "^10.1.8",
         "eslint-plugin-import": "^2.32.0",
-        "eslint-plugin-svelte": "^3.10.1",
+        "eslint-plugin-svelte": "^3.11.0",
         "eslint-plugin-unused-imports": "^4.1.4",
         "globals": "^16.3.0",
+        "husky": "^9.1.7",
         "jsdom": "^26.1.0",
         "prettier": "^3.6.2",
-        "prettier-plugin-organize-imports": "^4.1.0",
+        "prettier-plugin-organize-imports": "^4.2.0",
         "prettier-plugin-svelte": "^3.4.0",
         "prettier-plugin-tailwindcss": "^0.6.14",
         "publint": "^0.3.12",
-        "svelte": "^5.35.6",
-        "svelte-check": "^4.2.2",
-        "typescript": "^5.8.3",
-        "typescript-eslint": "^8.36.0",
-        "vite": "^7.0.4",
+        "svelte": "^5.38.0",
+        "svelte-check": "^4.3.1",
+        "typescript": "^5.9.2",
+        "typescript-eslint": "^8.39.0",
+        "vite": "^7.1.1",
         "vitest": "^3.2.4"
     },
     "peerDependencies": {
         "svelte": "^5.0.0"
     },
     "volta": {
-        "node": "22.17.0"
+        "node": "22.17.1"
     },
     "publishConfig": {
         "access": "public"