@humanspeak/svelte-markdown 0.8.9 → 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

@@ -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/_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,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/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.9",
+    "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,40 +78,41 @@
     "dependencies": {
         "github-slugger": "^2.0.0",
         "htmlparser2": "^10.0.0",
-        "marked": "^16.1.1"
+        "marked": "^16.1.2"
     },
     "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",
+        "@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.1.0",
-        "@typescript-eslint/eslint-plugin": "^8.38.0",
-        "@typescript-eslint/parser": "^8.38.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.32.0",
+        "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.1.4",
         "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.37.0",
-        "svelte-check": "^4.3.0",
-        "typescript": "^5.8.3",
-        "typescript-eslint": "^8.38.0",
-        "vite": "^7.0.6",
+        "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": {