@humanspeak/svelte-markdown 0.8.9 → 0.8.11

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

@@ -127,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}
@@ -139,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/Escape.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">
+    interface Props {
+        text?: string
+    }
+    const { text }: Props = $props()
+</script>
+
+{text}

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

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

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/_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

@@ -81,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,
@@ -167,3 +168,4 @@ export const Html = {
     var: Var
 };
 export default Html;
+export { UnsupportedHTML };

package/dist/renderers/index.d.ts

@@ -1,9 +1,11 @@
+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';
 export { default as Codespan } from './Codespan.svelte';
 export { default as Del } from './Del.svelte';
 export { default as Em } from './Em.svelte';
+export { default as Escape } from './Escape.svelte';
 export { default as Heading } from './Heading.svelte';
 export { default as Hr } from './Hr.svelte';
 export { default as Html } from './html/index.js';

package/dist/renderers/index.js

@@ -1,9 +1,11 @@
+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';
 export { default as Codespan } from './Codespan.svelte';
 export { default as Del } from './Del.svelte';
 export { default as Em } from './Em.svelte';
+export { default as Escape } from './Escape.svelte';
 export { default as Heading } from './Heading.svelte';
 export { default as Hr } from './Hr.svelte';
 export { default as Html } from './html/index.js';

package/dist/utils/markdown-parser.d.ts

@@ -1,7 +1,7 @@
 export { default as Slugger } from 'github-slugger';
 export { Lexer, type MarkedOptions, type Token, type Tokens, type TokensList } from 'marked';
-import type { Component } from 'svelte';
 import { type HtmlRenderers } from '../renderers/html/index.js';
+import type { Component } from 'svelte';
 import type { SvelteMarkdownOptions } from '../types.js';
 /**
  * Represents a Svelte component that can be used as a renderer.
@@ -26,6 +26,7 @@ export type RendererComponent = Component<any, any, any> | undefined | null;
 export type Renderers = {
     html: HtmlRenderers;
     rawtext: RendererComponent;
+    escape: RendererComponent;
     heading: RendererComponent;
     paragraph: RendererComponent;
     blockquote: RendererComponent;

package/dist/utils/markdown-parser.js

@@ -1,7 +1,7 @@
 export { default as Slugger } from 'github-slugger';
 export { Lexer } from 'marked';
 import {} from '../renderers/html/index.js';
-import { Blockquote, Br, Code, Codespan, Del, Em, Heading, Hr, Html, Image, Link, List, ListItem, Paragraph, RawText, Strong, Table, TableBody, TableCell, TableHead, TableRow, Text } from '../renderers/index.js';
+import { Blockquote, Br, Code, Codespan, Del, Em, Escape, Heading, Hr, Html, Image, Link, List, ListItem, Paragraph, RawText, Strong, Table, TableBody, TableCell, TableHead, TableRow, Text } from '../renderers/index.js';
 /**
  * Default renderer configuration mapping markdown elements to Svelte components.
  * Provides out-of-the-box rendering capabilities while allowing for customization.
@@ -20,6 +20,7 @@ export const defaultRenderers = {
     image: Image,
     link: Link,
     em: Em,
+    escape: Escape,
     strong: Strong,
     codespan: Codespan,
     del: Del,

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/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,129 +1,129 @@
 {
-    "name": "@humanspeak/svelte-markdown",
-    "version": "0.8.9",
-    "description": "A powerful, customizable markdown renderer for Svelte with TypeScript support",
-    "keywords": [
-        "svelte",
-        "markdown",
-        "renderer",
-        "parser",
-        "marked",
-        "component",
-        "sveltekit",
-        "svelte5",
-        "md",
-        "documentation",
-        "html",
-        "converter",
-        "formatting"
-    ],
-    "homepage": "https://markdown.svelte.page",
-    "bugs": {
-        "url": "https://github.com/humanspeak/svelte-markdown/issues"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/humanspeak/svelte-markdown.git"
-    },
-    "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/humanspeak"
-    },
-    "license": "MIT",
-    "author": "Humanspeak, Inc.",
-    "sideEffects": [
-        "**/*.css"
-    ],
-    "type": "module",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "svelte": "./dist/index.js"
-        }
-    },
-    "svelte": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "files": [
-        "dist",
-        "!dist/**/*.test.*",
-        "!dist/**/*.spec.*",
-        "!dist/test/**/*"
-    ],
-    "scripts": {
-        "build": "vite build && npm run package",
-        "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-        "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-        "dev": "vite dev",
-        "format": "prettier --write .",
-        "lint": "prettier --check . && eslint .",
-        "lint:fix": "npm run format && eslint . --fix",
-        "package": "svelte-kit sync && svelte-package && publint",
-        "prepublishOnly": "npm run package",
-        "preview": "vite preview",
-        "test": "vitest run --coverage",
-        "test:all": "npm run test && npm run test:e2e",
-        "test:e2e": "playwright test",
-        "test:e2e:debug": "playwright test --debug",
-        "test:e2e:report": "playwright show-report",
-        "test:e2e:ui": "playwright test --ui",
-        "test:only": "vitest run",
-        "test:watch": "vitest"
-    },
-    "overrides": {
-        "@sveltejs/kit": {
-            "cookie": "^0.7.0"
-        }
-    },
-    "dependencies": {
-        "github-slugger": "^2.0.0",
-        "htmlparser2": "^10.0.0",
-        "marked": "^16.1.1"
-    },
-    "devDependencies": {
-        "@eslint/compat": "^1.3.1",
-        "@eslint/js": "^9.32.0",
-        "@playwright/test": "^1.54.1",
-        "@sveltejs/adapter-auto": "^6.0.1",
-        "@sveltejs/kit": "^2.26.1",
-        "@sveltejs/package": "^2.4.0",
-        "@sveltejs/vite-plugin-svelte": "^6.1.0",
-        "@testing-library/jest-dom": "^6.6.4",
-        "@testing-library/svelte": "^5.2.8",
-        "@testing-library/user-event": "^14.6.1",
-        "@types/node": "^24.1.0",
-        "@typescript-eslint/eslint-plugin": "^8.38.0",
-        "@typescript-eslint/parser": "^8.38.0",
-        "@vitest/coverage-v8": "^3.2.4",
-        "eslint": "^9.32.0",
-        "eslint-config-prettier": "^10.1.8",
-        "eslint-plugin-import": "^2.32.0",
-        "eslint-plugin-svelte": "^3.11.0",
-        "eslint-plugin-unused-imports": "^4.1.4",
-        "globals": "^16.3.0",
-        "jsdom": "^26.1.0",
-        "prettier": "^3.6.2",
-        "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.37.0",
-        "svelte-check": "^4.3.0",
-        "typescript": "^5.8.3",
-        "typescript-eslint": "^8.38.0",
-        "vite": "^7.0.6",
-        "vitest": "^3.2.4"
-    },
-    "peerDependencies": {
-        "svelte": "^5.0.0"
-    },
-    "volta": {
-        "node": "22.17.1"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "tags": [
-        "svelte",
-        "markdown"
-    ]
-}
+  "name": "@humanspeak/svelte-markdown",
+  "version": "0.8.11",
+  "description": "A powerful, customizable markdown renderer for Svelte with TypeScript support",
+  "keywords": [
+    "svelte",
+    "markdown",
+    "renderer",
+    "parser",
+    "marked",
+    "component",
+    "sveltekit",
+    "svelte5",
+    "md",
+    "documentation",
+    "html",
+    "converter",
+    "formatting"
+  ],
+  "homepage": "https://markdown.svelte.page",
+  "bugs": {
+    "url": "https://github.com/humanspeak/svelte-markdown/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/humanspeak/svelte-markdown.git"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/humanspeak"
+  },
+  "license": "MIT",
+  "author": "Humanspeak, Inc.",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    }
+  },
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*",
+    "!dist/test/**/*"
+  ],
+  "overrides": {
+    "@sveltejs/kit": {
+      "cookie": "^0.7.0"
+    }
+  },
+  "dependencies": {
+    "github-slugger": "^2.0.0",
+    "htmlparser2": "^10.0.0",
+    "marked": "^16.2.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.3.2",
+    "@eslint/js": "^9.33.0",
+    "@playwright/test": "^1.55.0",
+    "@sveltejs/adapter-auto": "^6.1.0",
+    "@sveltejs/kit": "^2.36.1",
+    "@sveltejs/package": "^2.5.0",
+    "@sveltejs/vite-plugin-svelte": "^6.1.3",
+    "@testing-library/jest-dom": "^6.8.0",
+    "@testing-library/svelte": "^5.2.8",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/node": "^24.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.40.0",
+    "@typescript-eslint/parser": "^8.40.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-svelte": "^3.11.0",
+    "eslint-plugin-unused-imports": "^4.2.0",
+    "globals": "^16.3.0",
+    "husky": "^9.1.7",
+    "jsdom": "^26.1.0",
+    "prettier": "^3.6.2",
+    "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.38.2",
+    "svelte-check": "^4.3.1",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.40.0",
+    "vite": "^7.1.3",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "volta": {
+    "node": "22.17.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "tags": [
+    "svelte",
+    "markdown"
+  ],
+  "scripts": {
+    "build": "vite build && npm run package",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "dev": "vite dev",
+    "format": "prettier --write .",
+    "lint": "prettier --check . && eslint .",
+    "lint:fix": "npm run format && eslint . --fix",
+    "package": "svelte-kit sync && svelte-package && publint",
+    "preview": "vite preview",
+    "test": "vitest run --coverage",
+    "test:all": "npm run test && npm run test:e2e",
+    "test:e2e": "playwright test",
+    "test:e2e:debug": "playwright test --debug",
+    "test:e2e:report": "playwright show-report",
+    "test:e2e:ui": "playwright test --ui",
+    "test:only": "vitest run",
+    "test:watch": "vitest"
+  }
+}