@humanspeak/svelte-markdown 0.8.12 → 0.8.13

package/dist/utils/token-cache.js

@@ -0,0 +1,238 @@
+/**
+ * Token Cache
+ *
+ * Efficient caching layer for parsed markdown tokens.
+ * Built on top of the existing MemoryCache infrastructure with
+ * specialized features for markdown parsing optimization.
+ *
+ * Key features:
+ * - Fast FNV-1a hashing for cache keys
+ * - LRU eviction (inherited from MemoryCache)
+ * - TTL support (inherited from MemoryCache)
+ * - Handles large markdown documents efficiently
+ *
+ * @module token-cache
+ */
+import { MemoryCache } from './cache.js';
+/**
+ * Fast non-cryptographic hash function using FNV-1a algorithm.
+ * Optimized for speed over cryptographic security.
+ *
+ * FNV-1a (Fowler-Noll-Vo) provides:
+ * - Fast computation (single pass through string)
+ * - Good distribution (minimal collisions)
+ * - Small output size (base36 string)
+ *
+ * @param str - String to hash
+ * @returns Base36 hash string
+ *
+ * @example
+ * ```typescript
+ * const hash1 = hashString('# Hello World')
+ * const hash2 = hashString('# Hello World!')
+ * console.log(hash1 !== hash2) // true - different content = different hash
+ * ```
+ */
+function hashString(str) {
+    let hash = 2166136261; // FNV offset basis (32-bit)
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        // FNV prime multiply using bit shifts (faster than multiplication)
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    // Convert to unsigned 32-bit integer and base36 string
+    return (hash >>> 0).toString(36);
+}
+/**
+ * Generates a cache key from markdown source and parser options.
+ * Combines hashes of both source content and options to ensure
+ * different parsing configurations are cached separately.
+ *
+ * Handles non-serializable options (extensions, tokenizer, hooks, etc.) by:
+ * - Serializing functions by name/toString for stable keys
+ * - Detecting and handling circular references
+ * - Including ALL options that affect parsing
+ *
+ * @param source - Raw markdown string
+ * @param options - Svelte markdown parser options
+ * @returns Composite cache key
+ *
+ * @example
+ * ```typescript
+ * const key1 = getCacheKey('# Test', { gfm: true })
+ * const key2 = getCacheKey('# Test', { gfm: false })
+ * console.log(key1 !== key2) // true - different options = different key
+ * ```
+ */
+function getCacheKey(source, options) {
+    const sourceHash = hashString(source);
+    // Safely serialize all options including functions and objects
+    const seen = new WeakSet();
+    const optionsHash = hashString(JSON.stringify(options, (_, value) => {
+        // Serialize functions by their name or source code
+        if (typeof value === 'function') {
+            return value.name || value.toString();
+        }
+        // Handle circular references
+        if (value && typeof value === 'object') {
+            if (seen.has(value))
+                return '[Circular]';
+            seen.add(value);
+        }
+        return value;
+    }));
+    return `${sourceHash}:${optionsHash}`;
+}
+/**
+ * Specialized cache for markdown token storage.
+ * Extends MemoryCache with markdown-specific convenience methods.
+ *
+ * Inherits from MemoryCache:
+ * - Automatic LRU eviction when maxSize is reached
+ * - TTL-based expiration for time-sensitive content
+ * - Advanced deletion (deleteByPrefix, deleteByMagicString)
+ *
+ * Performance characteristics:
+ * - Cache hit: <1ms (vs 50-200ms parsing)
+ * - Memory: ~5MB for 50 cached documents (default maxSize)
+ * - Hash computation: ~0.05ms for 10KB, ~0.5ms for 100KB
+ *
+ * @class TokenCache
+ * @extends MemoryCache<Token[] | TokensList>
+ *
+ * @example
+ * ```typescript
+ * // Create cache with custom settings
+ * const cache = new TokenCache({
+ *     maxSize: 100,        // Cache up to 100 documents
+ *     ttl: 5 * 60 * 1000  // Expire after 5 minutes
+ * })
+ *
+ * // Check cache before parsing
+ * const cached = cache.getTokens(markdown, options)
+ * if (cached) {
+ *     return cached // Fast path - no parsing needed
+ * }
+ *
+ * // Parse and cache
+ * const tokens = lexer.lex(markdown)
+ * cache.setTokens(markdown, options, tokens)
+ * ```
+ */
+export class TokenCache extends MemoryCache {
+    /**
+     * Creates a new TokenCache instance.
+     *
+     * @param options - Cache configuration
+     * @param options.maxSize - Maximum number of documents to cache (default: 50)
+     * @param options.ttl - Time-to-live in milliseconds (default: 5 minutes)
+     */
+    constructor(options) {
+        super({ maxSize: 50, ttl: 5 * 60 * 1000, ...options });
+    }
+    /**
+     * Retrieves cached tokens for given markdown source and options.
+     * Returns undefined if not cached or expired.
+     *
+     * @param source - Raw markdown string
+     * @param options - Svelte markdown parser options
+     * @returns Cached tokens or undefined
+     *
+     * @example
+     * ```typescript
+     * const tokens = cache.getTokens('# Hello', { gfm: true })
+     * if (tokens) {
+     *     console.log('Cache hit!')
+     * }
+     * ```
+     */
+    getTokens(source, options) {
+        const key = getCacheKey(source, options);
+        return this.get(key);
+    }
+    /**
+     * Stores parsed tokens in cache for given markdown source and options.
+     * If cache is full, oldest entry is evicted (LRU).
+     *
+     * @param source - Raw markdown string
+     * @param options - Svelte markdown parser options
+     * @param tokens - Parsed token array or token list
+     *
+     * @example
+     * ```typescript
+     * const tokens = lexer.lex(markdown)
+     * cache.setTokens(markdown, options, tokens)
+     * ```
+     */
+    setTokens(source, options, tokens) {
+        const key = getCacheKey(source, options);
+        this.set(key, tokens);
+    }
+    /**
+     * Checks if tokens are cached without retrieving them.
+     * Useful for cache statistics or conditional logic.
+     *
+     * @param source - Raw markdown string
+     * @param options - Svelte markdown parser options
+     * @returns True if cached and not expired
+     *
+     * @example
+     * ```typescript
+     * if (cache.hasTokens(markdown, options)) {
+     *     console.log('Cache hit - no parsing needed')
+     * }
+     * ```
+     */
+    hasTokens(source, options) {
+        const key = getCacheKey(source, options);
+        return this.has(key);
+    }
+    /**
+     * Removes cached tokens for specific source and options.
+     *
+     * @param source - Raw markdown string
+     * @param options - Svelte markdown parser options
+     * @returns True if entry was removed, false if not found
+     *
+     * @example
+     * ```typescript
+     * cache.deleteTokens(markdown, options) // Remove specific cached entry
+     * ```
+     */
+    deleteTokens(source, options) {
+        const key = getCacheKey(source, options);
+        return this.delete(key);
+    }
+    /**
+     * Removes all cached tokens from the cache.
+     *
+     * @example
+     * ```typescript
+     * cache.clearAllTokens() // Clear entire cache
+     * ```
+     */
+    clearAllTokens() {
+        this.clear();
+    }
+}
+/**
+ * Global singleton instance for shared token caching.
+ * Use this instance across your application for maximum cache efficiency.
+ *
+ * @example
+ * ```typescript
+ * import { tokenCache } from './token-cache.js'
+ *
+ * const cached = tokenCache.getTokens(markdown, options)
+ * if (!cached) {
+ *     const tokens = lexer.lex(markdown)
+ *     tokenCache.setTokens(markdown, options, tokens)
+ * }
+ * ```
+ */
+export const tokenCache = new TokenCache();
+/**
+ * Export hash function for testing purposes.
+ * @internal
+ */
+export { hashString };

package/dist/utils/token-cleanup.js

@@ -273,7 +273,12 @@ export const containsMultipleTags = (html) => {
 export const shrinkHtmlTokens = (tokens) => {
     const result = [];
     for (const token of tokens) {
-        if (token.type === 'list') {
+        if ('tokens' in token && Array.isArray(token.tokens)) {
+            const t = token;
+            t.tokens = shrinkHtmlTokens(t.tokens);
+            result.push(token);
+        }
+        else if (token.type === 'list') {
             token.items = token.items.map((item, index) => ({
                 ...item,
                 listItemIndex: index,

package/package.json

@@ -1,21 +1,29 @@
 {
   "name": "@humanspeak/svelte-markdown",
-  "version": "0.8.12",
-  "description": "A powerful, customizable markdown renderer for Svelte with TypeScript support",
+  "version": "0.8.13",
+  "description": "Fast, customizable markdown renderer for Svelte with built-in caching, TypeScript support, and Svelte 5 runes",
   "keywords": [
     "svelte",
+    "svelte5",
+    "sveltekit",
     "markdown",
     "renderer",
     "parser",
+    "fast",
+    "performance",
+    "cache",
+    "caching",
     "marked",
     "component",
-    "sveltekit",
-    "svelte5",
+    "typescript",
+    "runes",
     "md",
     "documentation",
     "html",
     "converter",
-    "formatting"
+    "formatting",
+    "customizable",
+    "extensible"
   ],
   "homepage": "https://markdown.svelte.page",
   "bugs": {
@@ -57,25 +65,25 @@
   "dependencies": {
     "github-slugger": "^2.0.0",
     "htmlparser2": "^10.0.0",
-    "marked": "^16.3.0"
+    "marked": "^16.4.0"
   },
   "devDependencies": {
     "@eslint/compat": "^1.4.0",
-    "@eslint/js": "^9.36.0",
-    "@playwright/test": "^1.55.1",
-    "@sveltejs/adapter-auto": "^6.1.0",
-    "@sveltejs/kit": "^2.43.5",
+    "@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",
-    "@testing-library/jest-dom": "^6.8.0",
+    "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/svelte": "^5.2.8",
     "@testing-library/user-event": "^14.6.1",
-    "@types/node": "^24.5.2",
-    "@typescript-eslint/eslint-plugin": "^8.44.1",
-    "@typescript-eslint/parser": "^8.44.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",
     "concurrently": "^9.2.1",
-    "eslint": "^9.36.0",
+    "eslint": "^9.37.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-svelte": "^3.12.4",
@@ -87,12 +95,12 @@
     "prettier-plugin-organize-imports": "^4.3.0",
     "prettier-plugin-svelte": "^3.4.0",
     "prettier-plugin-tailwindcss": "^0.6.14",
-    "publint": "^0.3.13",
-    "svelte": "^5.39.6",
+    "publint": "^0.3.14",
+    "svelte": "^5.39.11",
     "svelte-check": "^4.3.2",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.44.1",
-    "vite": "^7.1.7",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.0",
+    "vite": "^7.1.9",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {