@humanspeak/svelte-markdown 0.8.13 → 0.8.14

package/dist/utils/cache.d.ts

@@ -1,168 +1,5 @@
 /**
- * Configuration options for cache initialization.
- *
- * @interface CacheOptions
- * @property {number} [maxSize] - Maximum number of entries the cache can hold before evicting oldest entries
- * @property {number} [ttl] - Time-to-live in milliseconds for cache entries before they expire
+ * Re-export MemoryCache from @humanspeak/memory-cache package.
+ * This provides a generic in-memory cache implementation with TTL and size-based eviction.
  */
-type CacheOptions = {
-    maxSize?: number;
-    ttl?: number;
-};
-/**
- * Generic in-memory cache implementation with TTL and size-based eviction.
- * Provides efficient caching for any type of data with automatic cleanup
- * of expired or excess entries.
- *
- * @class MemoryCache
- * @template T - The type of values being cached
- *
- * @example
- * ```typescript
- * // Create a cache for string values
- * const cache = new MemoryCache<string>({
- *     maxSize: 100,
- *     ttl: 5 * 60 * 1000 // 5 minutes
- * });
- *
- * // Store and retrieve values
- * cache.set('key', 'value');
- * const value = cache.get('key');
- * ```
- */
-export declare class MemoryCache<T> {
-    private cache;
-    private maxSize;
-    private ttl;
-    /**
-     * Creates a new MemoryCache instance.
-     *
-     * @param {CacheOptions} options - Configuration options for the cache
-     * @param {number} [options.maxSize=100] - Maximum number of entries (default: 100)
-     * @param {number} [options.ttl=300000] - Time-to-live in milliseconds (default: 5 minutes)
-     */
-    constructor(options?: CacheOptions);
-    /**
-     * Retrieves a value from the cache if it exists and hasn't expired.
-     *
-     * @param {string} key - The key to look up
-     * @returns {T | undefined} The cached value if found and valid, undefined otherwise
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<number>();
-     * cache.set('counter', 42);
-     * const value = cache.get('counter'); // Returns 42
-     * const missing = cache.get('nonexistent'); // Returns undefined
-     * ```
-     */
-    get(key: string): T | undefined;
-    /**
-     * Checks if a key exists in the cache (regardless of its value).
-     * This is useful for distinguishing between cache misses and cached undefined values.
-     *
-     * @param {string} key - The key to check
-     * @returns {boolean} True if the key exists in cache and hasn't expired, false otherwise
-     */
-    has(key: string): boolean;
-    /**
-     * Stores a value in the cache. If the cache is full, the oldest entry is removed.
-     *
-     * @param {string} key - The key under which to store the value
-     * @param {T} value - The value to cache
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('greeting', 'Hello, World!');
-     * ```
-     */
-    set(key: string, value: T): void;
-    /**
-     * Removes a specific entry from the cache.
-     *
-     * @param {string} key - The key of the entry to remove
-     * @returns {boolean} True if an element was removed, false if the key wasn't found
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('key', 'value');
-     * cache.delete('key'); // Returns true
-     * cache.delete('nonexistent'); // Returns false
-     * ```
-     */
-    delete(key: string): boolean;
-    deleteAsync(key: string): Promise<boolean>;
-    /**
-     * Removes all entries from the cache.
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('key1', 'value1');
-     * cache.set('key2', 'value2');
-     * cache.clear(); // Removes all entries
-     * ```
-     */
-    clear(): void;
-    /**
-     * Removes all entries from the cache whose keys start with the given prefix.
-     *
-     * @param {string} prefix - The prefix to match against cache keys
-     * @returns {number} Number of entries removed
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('user:123:name', 'John');
-     * cache.set('user:123:email', 'john@example.com');
-     * cache.set('post:456', 'Hello World');
-     *
-     * const removed = cache.deleteByPrefix('user:123:'); // Returns 2
-     * ```
-     */
-    deleteByPrefix(prefix: string): number;
-    /**
-     * Removes all entries from the cache whose keys match the given wildcard pattern.
-     * Supports asterisk (*) wildcards for flexible pattern matching.
-     *
-     * @param {string} magicString - The wildcard pattern to match against cache keys (use * for wildcards)
-     * @returns {number} Number of entries removed
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('user:123:name', 'John');
-     * cache.set('user:123:email', 'john@example.com');
-     * cache.set('user:456:name', 'Jane');
-     * cache.set('post:789', 'Hello World');
-     *
-     * const removed1 = cache.deleteByMagicString('user:123:*'); // Returns 2 (matches name and email)
-     * const removed2 = cache.deleteByMagicString('user:*:name'); // Returns 1 (matches Jane's name)
-     * const removed3 = cache.deleteByMagicString('post:*'); // Returns 1 (matches the post)
-     * ```
-     */
-    deleteByMagicString(magicString: string): number;
-}
-/**
- * Cache decorator factory for method-level caching.
- * Provides a way to cache method results based on their arguments.
- *
- * @template T - The return type of the decorated method
- * @param {CacheOptions} options - Configuration options for the cache
- * @returns A method decorator that caches the results
- *
- * @example
- * ```typescript
- * class UserService {
- *     @cached<User>({ ttl: 60000 })
- *     async getUser(id: string): Promise<User> {
- *         // Expensive operation
- *         return await fetchUser(id);
- *     }
- * }
- * ```
- */
-export declare function cached<T>(options?: CacheOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-export {};
+export { MemoryCache } from '@humanspeak/memory-cache';

package/dist/utils/cache.js

@@ -1,263 +1,5 @@
 /**
- * Special sentinel values to represent cached undefined/null values.
- * This allows us to distinguish between "not cached" and "cached undefined/null".
+ * Re-export MemoryCache from @humanspeak/memory-cache package.
+ * This provides a generic in-memory cache implementation with TTL and size-based eviction.
  */
-const CACHED_UNDEFINED = Symbol('CACHED_UNDEFINED');
-const CACHED_NULL = Symbol('CACHED_NULL');
-/**
- * Generic in-memory cache implementation with TTL and size-based eviction.
- * Provides efficient caching for any type of data with automatic cleanup
- * of expired or excess entries.
- *
- * @class MemoryCache
- * @template T - The type of values being cached
- *
- * @example
- * ```typescript
- * // Create a cache for string values
- * const cache = new MemoryCache<string>({
- *     maxSize: 100,
- *     ttl: 5 * 60 * 1000 // 5 minutes
- * });
- *
- * // Store and retrieve values
- * cache.set('key', 'value');
- * const value = cache.get('key');
- * ```
- */
-export class MemoryCache {
-    cache = new Map();
-    maxSize;
-    ttl;
-    /**
-     * Creates a new MemoryCache instance.
-     *
-     * @param {CacheOptions} options - Configuration options for the cache
-     * @param {number} [options.maxSize=100] - Maximum number of entries (default: 100)
-     * @param {number} [options.ttl=300000] - Time-to-live in milliseconds (default: 5 minutes)
-     */
-    constructor(options = {}) {
-        this.maxSize = options.maxSize ?? 100;
-        this.ttl = options.ttl ?? 5 * 60 * 1000; // 5 minutes default
-    }
-    /**
-     * Retrieves a value from the cache if it exists and hasn't expired.
-     *
-     * @param {string} key - The key to look up
-     * @returns {T | undefined} The cached value if found and valid, undefined otherwise
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<number>();
-     * cache.set('counter', 42);
-     * const value = cache.get('counter'); // Returns 42
-     * const missing = cache.get('nonexistent'); // Returns undefined
-     * ```
-     */
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return undefined;
-        // Check if entry has expired (skip check if TTL is 0 or negative)
-        if (this.ttl > 0 && Date.now() - entry.timestamp > this.ttl) {
-            this.cache.delete(key);
-            return undefined;
-        }
-        // Handle the special sentinel values for cached undefined/null
-        if (entry.value === CACHED_UNDEFINED) {
-            return undefined;
-        }
-        if (entry.value === CACHED_NULL) {
-            return null;
-        }
-        return entry.value;
-    }
-    /**
-     * Checks if a key exists in the cache (regardless of its value).
-     * This is useful for distinguishing between cache misses and cached undefined values.
-     *
-     * @param {string} key - The key to check
-     * @returns {boolean} True if the key exists in cache and hasn't expired, false otherwise
-     */
-    has(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return false;
-        // Check if entry has expired (skip check if TTL is 0 or negative)
-        if (this.ttl > 0 && Date.now() - entry.timestamp > this.ttl) {
-            this.cache.delete(key);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Stores a value in the cache. If the cache is full, the oldest entry is removed.
-     *
-     * @param {string} key - The key under which to store the value
-     * @param {T} value - The value to cache
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('greeting', 'Hello, World!');
-     * ```
-     */
-    set(key, value) {
-        // Remove oldest entry if cache is full (skip if maxSize is 0 or negative)
-        if (this.maxSize > 0 && this.cache.size >= this.maxSize) {
-            const oldestKey = this.cache.keys().next().value;
-            if (oldestKey) {
-                this.cache.delete(oldestKey);
-            }
-        }
-        // Store undefined/null values as sentinels to distinguish from cache misses
-        let valueToStore;
-        if (value === undefined) {
-            valueToStore = CACHED_UNDEFINED;
-        }
-        else if (value === null) {
-            valueToStore = CACHED_NULL;
-        }
-        else {
-            valueToStore = value;
-        }
-        this.cache.set(key, {
-            value: valueToStore,
-            timestamp: Date.now()
-        });
-    }
-    /**
-     * Removes a specific entry from the cache.
-     *
-     * @param {string} key - The key of the entry to remove
-     * @returns {boolean} True if an element was removed, false if the key wasn't found
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('key', 'value');
-     * cache.delete('key'); // Returns true
-     * cache.delete('nonexistent'); // Returns false
-     * ```
-     */
-    delete(key) {
-        return this.cache.delete(key);
-    }
-    async deleteAsync(key) {
-        return Promise.resolve(this.cache.delete(key));
-    }
-    /**
-     * Removes all entries from the cache.
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('key1', 'value1');
-     * cache.set('key2', 'value2');
-     * cache.clear(); // Removes all entries
-     * ```
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Removes all entries from the cache whose keys start with the given prefix.
-     *
-     * @param {string} prefix - The prefix to match against cache keys
-     * @returns {number} Number of entries removed
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('user:123:name', 'John');
-     * cache.set('user:123:email', 'john@example.com');
-     * cache.set('post:456', 'Hello World');
-     *
-     * const removed = cache.deleteByPrefix('user:123:'); // Returns 2
-     * ```
-     */
-    deleteByPrefix(prefix) {
-        let count = 0;
-        for (const key of this.cache.keys()) {
-            if (key.startsWith(prefix)) {
-                this.cache.delete(key);
-                count++;
-            }
-        }
-        return count;
-    }
-    /**
-     * Removes all entries from the cache whose keys match the given wildcard pattern.
-     * Supports asterisk (*) wildcards for flexible pattern matching.
-     *
-     * @param {string} magicString - The wildcard pattern to match against cache keys (use * for wildcards)
-     * @returns {number} Number of entries removed
-     *
-     * @example
-     * ```typescript
-     * const cache = new MemoryCache<string>();
-     * cache.set('user:123:name', 'John');
-     * cache.set('user:123:email', 'john@example.com');
-     * cache.set('user:456:name', 'Jane');
-     * cache.set('post:789', 'Hello World');
-     *
-     * const removed1 = cache.deleteByMagicString('user:123:*'); // Returns 2 (matches name and email)
-     * const removed2 = cache.deleteByMagicString('user:*:name'); // Returns 1 (matches Jane's name)
-     * const removed3 = cache.deleteByMagicString('post:*'); // Returns 1 (matches the post)
-     * ```
-     */
-    deleteByMagicString(magicString) {
-        let count = 0;
-        // Convert wildcard pattern to regex
-        const escapedPattern = magicString
-            .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except *
-            .replace(/\*/g, '.*'); // Convert * to .*
-        const regex = new RegExp(`^${escapedPattern}$`);
-        for (const key of this.cache.keys()) {
-            if (regex.test(key)) {
-                this.cache.delete(key);
-                count++;
-            }
-        }
-        return count;
-    }
-}
-/**
- * Cache decorator factory for method-level caching.
- * Provides a way to cache method results based on their arguments.
- *
- * @template T - The return type of the decorated method
- * @param {CacheOptions} options - Configuration options for the cache
- * @returns A method decorator that caches the results
- *
- * @example
- * ```typescript
- * class UserService {
- *     @cached<User>({ ttl: 60000 })
- *     async getUser(id: string): Promise<User> {
- *         // Expensive operation
- *         return await fetchUser(id);
- *     }
- * }
- * ```
- */
-export function cached(options = {}) {
-    const cache = new MemoryCache(options);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        descriptor.value = function (...args) {
-            const key = `${propertyKey}:${JSON.stringify(args)}`;
-            // Use has() to check if key exists, then get() to retrieve value
-            // This allows us to distinguish between cache miss and cached undefined
-            if (cache.has(key)) {
-                return cache.get(key);
-            }
-            const result = originalMethod.apply(this, args);
-            cache.set(key, result);
-            return result;
-        };
-        return descriptor;
-    };
-}
+export { MemoryCache } from '@humanspeak/memory-cache';

package/dist/utils/createFilterUtilities.d.ts

@@ -0,0 +1,52 @@
+import type { Component } from 'svelte';
+/**
+ * Generic component type for filter utilities.
+ * Allows Component, undefined, or null values.
+ */
+type FilterComponent = Component<any, any, any> | undefined | null;
+/**
+ * Creates a set of filter utility functions for renderer maps.
+ * This factory generates three functions: buildUnsupported, allowOnly, and excludeOnly.
+ *
+ * Used to eliminate code duplication between unsupportedRenderers.ts and unsupportedHtmlRenderers.ts.
+ *
+ * @template TKey - The string literal type for valid keys
+ * @template TResult - The result map type (e.g., Partial<Renderers> or HtmlRenderers)
+ *
+ * @param keys - Array of valid keys for this renderer type
+ * @param unsupportedComponent - The component to use for unsupported/disabled renderers
+ * @param defaultsMap - Map of keys to their default component implementations
+ *
+ * @returns Object containing buildUnsupported, allowOnly, and excludeOnly functions
+ *
+ * @example
+ * ```typescript
+ * import { createFilterUtilities } from './createFilterUtilities'
+ *
+ * type MyKey = 'foo' | 'bar' | 'baz'
+ * const keys: readonly MyKey[] = ['foo', 'bar', 'baz'] as const
+ * const UnsupportedComponent = () => null
+ * const defaults = { foo: FooComponent, bar: BarComponent, baz: BazComponent }
+ *
+ * const { buildUnsupported, allowOnly, excludeOnly } = createFilterUtilities<MyKey, Record<MyKey, Component>>(
+ *     keys,
+ *     UnsupportedComponent,
+ *     defaults
+ * )
+ *
+ * // Block all renderers
+ * const allUnsupported = buildUnsupported()
+ *
+ * // Allow only 'foo' and 'bar', block 'baz'
+ * const allowList = allowOnly(['foo', 'bar'])
+ *
+ * // Block only 'baz', allow others with defaults
+ * const denyList = excludeOnly(['baz'])
+ * ```
+ */
+export declare const createFilterUtilities: <TKey extends string, TResult extends Record<string, FilterComponent>>(keys: readonly TKey[], unsupportedComponent: FilterComponent, defaultsMap: Record<TKey, FilterComponent>) => {
+    buildUnsupported: () => TResult;
+    allowOnly: (_allowed: Array<TKey | [TKey, FilterComponent]>) => TResult;
+    excludeOnly: (_excluded: TKey[], _overrides?: Array<[TKey, FilterComponent]>) => TResult;
+};
+export {};

package/dist/utils/createFilterUtilities.js

@@ -0,0 +1,126 @@
+/**
+ * Creates a set of filter utility functions for renderer maps.
+ * This factory generates three functions: buildUnsupported, allowOnly, and excludeOnly.
+ *
+ * Used to eliminate code duplication between unsupportedRenderers.ts and unsupportedHtmlRenderers.ts.
+ *
+ * @template TKey - The string literal type for valid keys
+ * @template TResult - The result map type (e.g., Partial<Renderers> or HtmlRenderers)
+ *
+ * @param keys - Array of valid keys for this renderer type
+ * @param unsupportedComponent - The component to use for unsupported/disabled renderers
+ * @param defaultsMap - Map of keys to their default component implementations
+ *
+ * @returns Object containing buildUnsupported, allowOnly, and excludeOnly functions
+ *
+ * @example
+ * ```typescript
+ * import { createFilterUtilities } from './createFilterUtilities'
+ *
+ * type MyKey = 'foo' | 'bar' | 'baz'
+ * const keys: readonly MyKey[] = ['foo', 'bar', 'baz'] as const
+ * const UnsupportedComponent = () => null
+ * const defaults = { foo: FooComponent, bar: BarComponent, baz: BazComponent }
+ *
+ * const { buildUnsupported, allowOnly, excludeOnly } = createFilterUtilities<MyKey, Record<MyKey, Component>>(
+ *     keys,
+ *     UnsupportedComponent,
+ *     defaults
+ * )
+ *
+ * // Block all renderers
+ * const allUnsupported = buildUnsupported()
+ *
+ * // Allow only 'foo' and 'bar', block 'baz'
+ * const allowList = allowOnly(['foo', 'bar'])
+ *
+ * // Block only 'baz', allow others with defaults
+ * const denyList = excludeOnly(['baz'])
+ * ```
+ */
+export const createFilterUtilities = (keys, unsupportedComponent, defaultsMap) => {
+    /**
+     * Checks if a key is valid for this renderer type.
+     */
+    const hasKey = (key) => keys.includes(key);
+    /**
+     * Builds a map where every key is set to the unsupported component.
+     * Useful for starting with a "deny all" approach.
+     */
+    const buildUnsupported = () => {
+        const result = {};
+        for (const key of keys) {
+            ;
+            result[key] = unsupportedComponent;
+        }
+        return result;
+    };
+    /**
+     * Produces a renderer map that allows only the specified keys.
+     * All non-listed keys are set to the unsupported component.
+     *
+     * Each entry can be either:
+     * - A key string (to use the default component for that key)
+     * - A tuple [key, component] to specify a custom component
+     */
+    const allowOnly = (allowed) => {
+        const result = buildUnsupported();
+        for (const entry of allowed) {
+            if (Array.isArray(entry)) {
+                const [key, component] = entry;
+                if (hasKey(key)) {
+                    ;
+                    result[key] = component;
+                }
+            }
+            else {
+                const key = entry;
+                if (hasKey(key)) {
+                    ;
+                    result[key] = defaultsMap[key];
+                }
+            }
+        }
+        return result;
+    };
+    /**
+     * Produces a renderer map that excludes only the specified keys.
+     * Excluded keys are set to the unsupported component.
+     * All other keys use the default components.
+     *
+     * Optionally, specific non-excluded keys can be overridden with custom components.
+     * Exclusions take precedence over overrides.
+     */
+    const excludeOnly = (excluded, overrides) => {
+        const result = {};
+        // Start with all defaults
+        for (const key of keys) {
+            ;
+            result[key] = defaultsMap[key];
+        }
+        // Mark excluded keys as unsupported
+        for (const key of excluded) {
+            if (hasKey(key)) {
+                ;
+                result[key] = unsupportedComponent;
+            }
+        }
+        // Apply overrides (exclusions take precedence)
+        if (overrides) {
+            for (const [key, component] of overrides) {
+                if (excluded.includes(key))
+                    continue;
+                if (hasKey(key)) {
+                    ;
+                    result[key] = component;
+                }
+            }
+        }
+        return result;
+    };
+    return {
+        buildUnsupported,
+        allowOnly,
+        excludeOnly
+    };
+};

package/dist/utils/parse-and-cache.js

@@ -39,6 +39,9 @@ export function parseAndCacheTokens(source, options, isInline) {
     const lexer = new Lexer(options);
     const parsedTokens = isInline ? lexer.inlineTokens(source) : lexer.lex(source);
     const cleanedTokens = shrinkHtmlTokens(parsedTokens);
+    if (typeof options.walkTokens === 'function') {
+        cleanedTokens.forEach(options.walkTokens);
+    }
     // Cache the cleaned tokens for next time
     tokenCache.setTokens(source, options, cleanedTokens);
     return cleanedTokens;

package/dist/utils/rendererKeys.d.ts

@@ -2,5 +2,5 @@ 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 type HtmlKey = keyof typeof Html & string;
 export declare const htmlRendererKeysInternal: HtmlKey[];

package/dist/utils/unsupportedHtmlRenderers.d.ts

@@ -19,7 +19,7 @@ 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),
+ * 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
@@ -35,11 +35,11 @@ export declare const buildUnsupportedHTML: () => HtmlRenderers;
  * // 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;
+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
+ * 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
@@ -59,4 +59,4 @@ export declare const allowHtmlOnly: (allowed: Array<HtmlKey | [HtmlKey, Componen
  * // 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;
+export declare const excludeHtmlOnly: (_excluded: HtmlKey[], _overrides?: Array<[HtmlKey, Component | null]>) => HtmlRenderers;

package/dist/utils/unsupportedHtmlRenderers.js

@@ -1,5 +1,8 @@
 import Html, { UnsupportedHTML } from '../renderers/html/index.js';
 import { htmlRendererKeysInternal } from './rendererKeys.js';
+import { createFilterUtilities } from './createFilterUtilities.js';
+// Create filter utilities using the generic factory
+const filterUtils = createFilterUtilities(htmlRendererKeysInternal, UnsupportedHTML, Html);
 /**
  * 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
@@ -13,18 +16,12 @@ import { htmlRendererKeysInternal } from './rendererKeys.js';
  *   html: buildUnsupportedHTML()
  * }
  */
-export const buildUnsupportedHTML = () => {
-    const result = {};
-    for (const key of htmlRendererKeysInternal) {
-        result[key] = UnsupportedHTML;
-    }
-    return result;
-};
+export const buildUnsupportedHTML = filterUtils.buildUnsupported;
 /**
  * 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),
+ * 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
@@ -40,27 +37,11 @@ export const buildUnsupportedHTML = () => {
  * // 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;
-};
+export const allowHtmlOnly = filterUtils.allowOnly;
 /**
  * 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
+ * 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
@@ -80,20 +61,4 @@ export const allowHtmlOnly = (allowed) => {
  * // 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;
-};
+export const excludeHtmlOnly = filterUtils.excludeOnly;

package/dist/utils/unsupportedRenderers.d.ts

@@ -5,7 +5,7 @@ import { type RendererKey } from './rendererKeys.js';
  * is set to the `Unsupported` component.
  *
  * @function buildUnsupportedRenderers
- * @returns {Partial<Renderers>} A map with all non‑HTML renderers set to `Unsupported`.
+ * @returns {Omit<Renderers, 'html'>} A map with all non‑HTML renderers set to `Unsupported`.
  * @example
  * import { buildUnsupportedRenderers } from '@humanspeak/svelte-markdown'
  * const renderers = {
@@ -13,17 +13,17 @@ import { type RendererKey } from './rendererKeys.js';
  *   html: {} // customize HTML separately
  * }
  */
-export declare const buildUnsupportedRenderers: () => Partial<Renderers>;
+export declare const buildUnsupportedRenderers: () => Omit<Renderers, "html">;
 /**
  * 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),
+ * 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.
+ * @returns {Omit<Renderers, 'html'>} A renderer map with only the provided keys enabled.
  * @example
  * // Allow only paragraph and link with defaults
  * const renderers = allowRenderersOnly(['paragraph', 'link'])
@@ -32,10 +32,10 @@ export declare const buildUnsupportedRenderers: () => Partial<Renderers>;
  * // Allow paragraph with a custom component
  * const renderers = allowRenderersOnly([['paragraph', MyParagraph]])
  */
-export declare const allowRenderersOnly: (allowed: Array<RendererKey | [RendererKey, RendererComponent]>) => Partial<Renderers>;
+export declare const allowRenderersOnly: (_allowed: Array<RendererKey | [RendererKey, RendererComponent]>) => Omit<Renderers, "html">;
 /**
  * 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.
+ * 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.
@@ -45,7 +45,7 @@ export declare const allowRenderersOnly: (allowed: Array<RendererKey | [Renderer
  *        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.
+ * @returns {Omit<Renderers, 'html'>} A renderer map with only the provided keys excluded.
  * @example
  * // Disable just paragraph and link, keep others as defaults
  * const renderers = excludeRenderersOnly(['paragraph', 'link'])
@@ -54,4 +54,4 @@ export declare const allowRenderersOnly: (allowed: Array<RendererKey | [Renderer
  * // 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>;
+export declare const excludeRenderersOnly: (_excluded: RendererKey[], _overrides?: Array<[RendererKey, RendererComponent]>) => Omit<Renderers, "html">;

package/dist/utils/unsupportedRenderers.js

@@ -1,13 +1,15 @@
 import { Unsupported } from '../renderers/index.js';
 import { defaultRenderers } from './markdown-parser.js';
 import { rendererKeysInternal } from './rendererKeys.js';
-const allRendererKeys = rendererKeysInternal;
+import { createFilterUtilities } from './createFilterUtilities.js';
+// Create filter utilities using the generic factory
+const filterUtils = createFilterUtilities(rendererKeysInternal, Unsupported, defaultRenderers);
 /**
  * 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`.
+ * @returns {Omit<Renderers, 'html'>} A map with all non‑HTML renderers set to `Unsupported`.
  * @example
  * import { buildUnsupportedRenderers } from '@humanspeak/svelte-markdown'
  * const renderers = {
@@ -15,23 +17,17 @@ const allRendererKeys = rendererKeysInternal;
  *   html: {} // customize HTML separately
  * }
  */
-export const buildUnsupportedRenderers = () => {
-    const result = {};
-    for (const key of allRendererKeys) {
-        result[key] = Unsupported;
-    }
-    return result;
-};
+export const buildUnsupportedRenderers = filterUtils.buildUnsupported;
 /**
  * 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),
+ * 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.
+ * @returns {Omit<Renderers, 'html'>} A renderer map with only the provided keys enabled.
  * @example
  * // Allow only paragraph and link with defaults
  * const renderers = allowRenderersOnly(['paragraph', 'link'])
@@ -40,25 +36,10 @@ export const buildUnsupportedRenderers = () => {
  * // 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;
-};
+export const allowRenderersOnly = filterUtils.allowOnly;
 /**
  * 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.
+ * 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.
@@ -68,7 +49,7 @@ export const allowRenderersOnly = (allowed) => {
  *        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.
+ * @returns {Omit<Renderers, 'html'>} A renderer map with only the provided keys excluded.
  * @example
  * // Disable just paragraph and link, keep others as defaults
  * const renderers = excludeRenderersOnly(['paragraph', 'link'])
@@ -77,22 +58,4 @@ export const allowRenderersOnly = (allowed) => {
  * // 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;
-};
+export const excludeRenderersOnly = filterUtils.excludeOnly;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanspeak/svelte-markdown",
-  "version": "0.8.13",
+  "version": "0.8.14",
   "description": "Fast, customizable markdown renderer for Svelte with built-in caching, TypeScript support, and Svelte 5 runes",
   "keywords": [
     "svelte",
@@ -63,51 +63,52 @@
     }
   },
   "dependencies": {
+    "@humanspeak/memory-cache": "^1.0.2",
     "github-slugger": "^2.0.0",
     "htmlparser2": "^10.0.0",
-    "marked": "^16.4.0"
+    "marked": "^17.0.1"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.4.0",
-    "@eslint/js": "^9.37.0",
-    "@playwright/test": "^1.56.0",
-    "@sveltejs/adapter-auto": "^6.1.1",
-    "@sveltejs/kit": "^2.46.3",
-    "@sveltejs/package": "^2.5.4",
-    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@eslint/compat": "^2.0.0",
+    "@eslint/js": "^9.39.2",
+    "@playwright/test": "^1.57.0",
+    "@sveltejs/adapter-auto": "^7.0.0",
+    "@sveltejs/kit": "^2.49.3",
+    "@sveltejs/package": "^2.5.7",
+    "@sveltejs/vite-plugin-svelte": "^6.2.2",
     "@testing-library/jest-dom": "^6.9.1",
-    "@testing-library/svelte": "^5.2.8",
+    "@testing-library/svelte": "^5.3.1",
     "@testing-library/user-event": "^14.6.1",
-    "@types/node": "^24.7.0",
-    "@typescript-eslint/eslint-plugin": "^8.46.0",
-    "@typescript-eslint/parser": "^8.46.0",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.52.0",
+    "@typescript-eslint/parser": "^8.52.0",
+    "@vitest/coverage-v8": "^4.0.16",
     "concurrently": "^9.2.1",
-    "eslint": "^9.37.0",
+    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-svelte": "^3.12.4",
-    "eslint-plugin-unused-imports": "^4.2.0",
-    "globals": "^16.4.0",
+    "eslint-plugin-svelte": "^3.13.1",
+    "eslint-plugin-unused-imports": "^4.3.0",
+    "globals": "^17.0.0",
     "husky": "^9.1.7",
-    "jsdom": "^27.0.0",
-    "prettier": "^3.6.2",
+    "jsdom": "^27.4.0",
+    "prettier": "^3.7.4",
     "prettier-plugin-organize-imports": "^4.3.0",
-    "prettier-plugin-svelte": "^3.4.0",
-    "prettier-plugin-tailwindcss": "^0.6.14",
-    "publint": "^0.3.14",
-    "svelte": "^5.39.11",
-    "svelte-check": "^4.3.2",
+    "prettier-plugin-svelte": "^3.4.1",
+    "prettier-plugin-tailwindcss": "^0.7.2",
+    "publint": "^0.3.16",
+    "svelte": "^5.46.1",
+    "svelte-check": "^4.3.5",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.0",
-    "vite": "^7.1.9",
-    "vitest": "^3.2.4"
+    "typescript-eslint": "^8.52.0",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.16"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"
   },
   "volta": {
-    "node": "22.17.1"
+    "node": "24.12.0"
   },
   "publishConfig": {
     "access": "public"