@fuzdev/fuz_ui 0.185.2 → 0.187.0

package/dist/mdz_to_svelte.d.ts

@@ -7,7 +7,7 @@
  *
  * @module
  */
-import type { MdzNode } from './mdz.js';
+import { type MdzNode } from './mdz.js';
 /**
  * Result of converting `MdzNode` arrays to Svelte markup.
  */
@@ -33,6 +33,9 @@ export interface MdzToSvelteResult {
  *   If content references a component not in this map, `has_unconfigured_tags` is set.
  * @param elements Allowed HTML element names (e.g., `new Set(['aside', 'details'])`).
  *   If content references an element not in this set, `has_unconfigured_tags` is set.
+ * @param base Base path for resolving relative links (e.g., `'/docs/mdz/'`).
+ *   When provided, relative references (`./`, `../`) are resolved to absolute paths
+ *   and passed through `resolve()`. Trailing slash recommended.
  */
-export declare const mdz_to_svelte: (nodes: Array<MdzNode>, components: Record<string, string>, elements: ReadonlySet<string>) => MdzToSvelteResult;
+export declare const mdz_to_svelte: (nodes: Array<MdzNode>, components: Record<string, string>, elements: ReadonlySet<string>, base?: string) => MdzToSvelteResult;
 //# sourceMappingURL=mdz_to_svelte.d.ts.map

package/dist/mdz_to_svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mdz_to_svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_to_svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,UAAU,CAAC;AAEtC;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;KAAC,CAAC,CAAC;IAEhE,yEAAyE;IACzE,qBAAqB,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,OAAO,CAAC,EACrB,YAAY,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,UAAU,WAAW,CAAC,MAAM,CAAC,KAC3B,iBAgFF,CAAC"}
+{"version":3,"file":"mdz_to_svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_to_svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,EAAC,KAAK,OAAO,EAAwB,MAAM,UAAU,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;KAAC,CAAC,CAAC;IAEhE,yEAAyE;IACzE,qBAAqB,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GACzB,OAAO,KAAK,CAAC,OAAO,CAAC,EACrB,YAAY,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,UAAU,WAAW,CAAC,MAAM,CAAC,EAC7B,OAAO,MAAM,KACX,iBAyFF,CAAC"}

package/dist/mdz_to_svelte.js

@@ -10,6 +10,7 @@
 import { UnreachableError } from '@fuzdev/fuz_util/error.js';
 import { escape_svelte_text } from '@fuzdev/fuz_util/svelte_preprocess_helpers.js';
 import { escape_js_string } from '@fuzdev/fuz_util/string.js';
+import { resolve_relative_path } from './mdz.js';
 /**
  * Converts an array of `MdzNode` to a Svelte markup string.
  *
@@ -21,8 +22,11 @@ import { escape_js_string } from '@fuzdev/fuz_util/string.js';
  *   If content references a component not in this map, `has_unconfigured_tags` is set.
  * @param elements Allowed HTML element names (e.g., `new Set(['aside', 'details'])`).
  *   If content references an element not in this set, `has_unconfigured_tags` is set.
+ * @param base Base path for resolving relative links (e.g., `'/docs/mdz/'`).
+ *   When provided, relative references (`./`, `../`) are resolved to absolute paths
+ *   and passed through `resolve()`. Trailing slash recommended.
  */
-export const mdz_to_svelte = (nodes, components, elements) => {
+export const mdz_to_svelte = (nodes, components, elements, base) => {
     const imports = new Map();
     let has_unconfigured_tags = false;
     const render_nodes = (children) => {
@@ -49,7 +53,14 @@ export const mdz_to_svelte = (nodes, components, elements) => {
             case 'Link': {
                 const children_markup = render_nodes(node.children);
                 if (node.link_type === 'internal') {
-                    if (node.reference.startsWith('#') || node.reference.startsWith('?')) {
+                    if (node.reference.startsWith('.') && base) {
+                        const resolved = resolve_relative_path(node.reference, base);
+                        imports.set('resolve', { path: '$app/paths', kind: 'named' });
+                        return `<a href={resolve('${escape_js_string(resolved)}')}>${children_markup}</a>`;
+                    }
+                    if (node.reference.startsWith('#') ||
+                        node.reference.startsWith('?') ||
+                        node.reference.startsWith('.')) {
                         return `<a href={'${escape_js_string(node.reference)}'}>${children_markup}</a>`;
                     }
                     imports.set('resolve', { path: '$app/paths', kind: 'named' });

package/dist/mdz_token_parser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * mdz token parser — consumes a `MdzToken[]` stream to build the `MdzNode[]` AST.
+ *
+ * Phase 2 of the two-phase lexer+parser alternative to the single-pass parser
+ * in `mdz.ts`. Phase 1 (lexer) is in `mdz_lexer.ts`.
+ *
+ * @module
+ */
+import type { MdzNode } from './mdz.js';
+/**
+ * Parses text to an array of `MdzNode` using a two-phase lexer+parser approach.
+ */
+export declare const mdz_parse_lexer: (text: string) => Array<MdzNode>;
+//# sourceMappingURL=mdz_token_parser.d.ts.map

package/dist/mdz_token_parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdz_token_parser.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/mdz_token_parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,OAAO,EASP,MAAM,UAAU,CAAC;AAgBlB;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,KAAK,CAAC,OAAO,CAG3D,CAAC"}

package/dist/mdz_token_parser.js

@@ -0,0 +1,374 @@
+/**
+ * mdz token parser — consumes a `MdzToken[]` stream to build the `MdzNode[]` AST.
+ *
+ * Phase 2 of the two-phase lexer+parser alternative to the single-pass parser
+ * in `mdz.ts`. Phase 1 (lexer) is in `mdz_lexer.ts`.
+ *
+ * @module
+ */
+import { extract_single_tag } from './mdz_helpers.js';
+import { MdzLexer, } from './mdz_lexer.js';
+/**
+ * Parses text to an array of `MdzNode` using a two-phase lexer+parser approach.
+ */
+export const mdz_parse_lexer = (text) => {
+    const tokens = new MdzLexer(text).tokenize();
+    return new MdzTokenParser(tokens).parse();
+};
+class MdzTokenParser {
+    #tokens;
+    #index = 0;
+    constructor(tokens) {
+        this.#tokens = tokens;
+    }
+    parse() {
+        const root_nodes = [];
+        const paragraph_children = [];
+        while (this.#index < this.#tokens.length) {
+            const token = this.#tokens[this.#index];
+            // Block-level tokens
+            if (token.type === 'heading_start') {
+                const flushed = this.#flush_paragraph(paragraph_children, true);
+                if (flushed)
+                    root_nodes.push(flushed);
+                root_nodes.push(this.#parse_heading());
+                continue;
+            }
+            if (token.type === 'hr') {
+                const flushed = this.#flush_paragraph(paragraph_children, true);
+                if (flushed)
+                    root_nodes.push(flushed);
+                root_nodes.push({ type: 'Hr', start: token.start, end: token.end });
+                this.#index++;
+                continue;
+            }
+            if (token.type === 'codeblock') {
+                const flushed = this.#flush_paragraph(paragraph_children, true);
+                if (flushed)
+                    root_nodes.push(flushed);
+                root_nodes.push({
+                    type: 'Codeblock',
+                    lang: token.lang,
+                    content: token.content,
+                    start: token.start,
+                    end: token.end,
+                });
+                this.#index++;
+                continue;
+            }
+            if (token.type === 'paragraph_break') {
+                const flushed = this.#flush_paragraph(paragraph_children, true);
+                if (flushed)
+                    root_nodes.push(flushed);
+                this.#index++;
+                continue;
+            }
+            // Inline tokens → paragraph children
+            const node = this.#parse_inline();
+            if (node)
+                paragraph_children.push(node);
+        }
+        // Flush remaining content
+        const final_paragraph = this.#flush_paragraph(paragraph_children, true);
+        if (final_paragraph)
+            root_nodes.push(final_paragraph);
+        return root_nodes;
+    }
+    #parse_heading() {
+        const token = this.#tokens[this.#index];
+        const start = token.start;
+        const level = token.level;
+        this.#index++;
+        const children = [];
+        // Collect inline nodes until heading_end marker
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'heading_end') {
+                this.#index++; // consume the marker
+                break;
+            }
+            const node = this.#parse_inline();
+            if (node)
+                children.push(node);
+        }
+        const end = children.length > 0 ? children[children.length - 1].end : start + level + 1;
+        return { type: 'Heading', level, children, start, end };
+    }
+    #parse_inline() {
+        if (this.#index >= this.#tokens.length)
+            return null;
+        const token = this.#tokens[this.#index];
+        switch (token.type) {
+            case 'text':
+                this.#index++;
+                return { type: 'Text', content: token.content, start: token.start, end: token.end };
+            case 'code':
+                this.#index++;
+                return { type: 'Code', content: token.content, start: token.start, end: token.end };
+            case 'bold_open':
+                return this.#parse_bold();
+            case 'italic_open':
+                return this.#parse_italic();
+            case 'strikethrough_open':
+                return this.#parse_strikethrough();
+            case 'link_text_open':
+                return this.#parse_link();
+            case 'autolink':
+                return this.#parse_autolink();
+            case 'tag_open':
+                return this.#parse_tag_node();
+            case 'tag_self_close':
+                return this.#parse_self_close_tag();
+            // Orphaned close tokens - treat as text
+            case 'bold_close':
+                this.#index++;
+                return { type: 'Text', content: '**', start: token.start, end: token.end };
+            case 'italic_close':
+                this.#index++;
+                return { type: 'Text', content: '_', start: token.start, end: token.end };
+            case 'strikethrough_close':
+                this.#index++;
+                return { type: 'Text', content: '~', start: token.start, end: token.end };
+            case 'link_text_close':
+                this.#index++;
+                return { type: 'Text', content: ']', start: token.start, end: token.end };
+            case 'link_ref':
+                this.#index++;
+                return {
+                    type: 'Text',
+                    content: `(${token.reference})`,
+                    start: token.start,
+                    end: token.end,
+                };
+            case 'tag_close':
+                this.#index++;
+                return {
+                    type: 'Text',
+                    content: `</${token.name}>`,
+                    start: token.start,
+                    end: token.end,
+                };
+            default:
+                this.#index++;
+                return null;
+        }
+    }
+    #parse_bold() {
+        const token = this.#tokens[this.#index];
+        const start = token.start;
+        this.#index++;
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'bold_close') {
+                this.#index++;
+                return { type: 'Bold', children, start, end: t.end };
+            }
+            if (t.type === 'paragraph_break' ||
+                t.type === 'heading_start' ||
+                t.type === 'hr' ||
+                t.type === 'codeblock') {
+                break;
+            }
+            const node = this.#parse_inline();
+            if (node)
+                children.push(node);
+        }
+        // Unclosed - treat as text
+        return { type: 'Text', content: '**', start, end: start + 2 };
+    }
+    #parse_italic() {
+        const token = this.#tokens[this.#index];
+        const start = token.start;
+        this.#index++;
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'italic_close') {
+                this.#index++;
+                return { type: 'Italic', children, start, end: t.end };
+            }
+            if (t.type === 'paragraph_break' ||
+                t.type === 'heading_start' ||
+                t.type === 'hr' ||
+                t.type === 'codeblock') {
+                break;
+            }
+            const node = this.#parse_inline();
+            if (node)
+                children.push(node);
+        }
+        return { type: 'Text', content: '_', start, end: start + 1 };
+    }
+    #parse_strikethrough() {
+        const token = this.#tokens[this.#index];
+        const start = token.start;
+        this.#index++;
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'strikethrough_close') {
+                this.#index++;
+                return { type: 'Strikethrough', children, start, end: t.end };
+            }
+            if (t.type === 'paragraph_break' ||
+                t.type === 'heading_start' ||
+                t.type === 'hr' ||
+                t.type === 'codeblock') {
+                break;
+            }
+            const node = this.#parse_inline();
+            if (node)
+                children.push(node);
+        }
+        return { type: 'Text', content: '~', start, end: start + 1 };
+    }
+    #parse_link() {
+        const open_token = this.#tokens[this.#index];
+        const start = open_token.start;
+        this.#index++;
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'link_text_close') {
+                this.#index++;
+                // Expect link_ref next
+                if (this.#index < this.#tokens.length && this.#tokens[this.#index].type === 'link_ref') {
+                    const ref_token = this.#tokens[this.#index];
+                    this.#index++;
+                    return {
+                        type: 'Link',
+                        reference: ref_token.reference,
+                        children,
+                        link_type: ref_token.link_type,
+                        start,
+                        end: ref_token.end,
+                    };
+                }
+                // No link_ref - treat as text
+                return { type: 'Text', content: '[', start, end: start + 1 };
+            }
+            if (t.type === 'paragraph_break' ||
+                t.type === 'heading_start' ||
+                t.type === 'hr' ||
+                t.type === 'codeblock') {
+                break;
+            }
+            const node = this.#parse_inline();
+            if (node)
+                children.push(node);
+        }
+        return { type: 'Text', content: '[', start, end: start + 1 };
+    }
+    #parse_autolink() {
+        const token = this.#tokens[this.#index];
+        this.#index++;
+        return {
+            type: 'Link',
+            reference: token.reference,
+            children: [{ type: 'Text', content: token.reference, start: token.start, end: token.end }],
+            link_type: token.link_type,
+            start: token.start,
+            end: token.end,
+        };
+    }
+    #parse_tag_node() {
+        const open_token = this.#tokens[this.#index];
+        const start = open_token.start;
+        const tag_name = open_token.name;
+        const node_type = open_token.is_component ? 'Component' : 'Element';
+        this.#index++;
+        const children = [];
+        while (this.#index < this.#tokens.length) {
+            const t = this.#tokens[this.#index];
+            if (t.type === 'tag_close' && t.name === tag_name) {
+                this.#index++;
+                return { type: node_type, name: tag_name, children, start, end: t.end };
+            }
+            const node = this.#parse_inline();
+            if (node)
+                children.push(node);
+        }
+        // Unclosed tag
+        return { type: 'Text', content: '<', start, end: start + 1 };
+    }
+    #parse_self_close_tag() {
+        const token = this.#tokens[this.#index];
+        const node_type = token.is_component ? 'Component' : 'Element';
+        this.#index++;
+        return { type: node_type, name: token.name, children: [], start: token.start, end: token.end };
+    }
+    // -- Paragraph flushing --
+    #flush_paragraph(paragraph_children, trim_trailing = false) {
+        if (paragraph_children.length === 0)
+            return null;
+        if (trim_trailing) {
+            // Trim trailing newlines from last text node
+            const last = paragraph_children[paragraph_children.length - 1];
+            if (last.type === 'Text') {
+                const trimmed = last.content.replace(/\n+$/, '');
+                if (trimmed) {
+                    last.content = trimmed;
+                    last.end = last.start + trimmed.length;
+                }
+                else {
+                    paragraph_children.pop();
+                }
+            }
+            // Skip whitespace-only paragraphs
+            const has_content = paragraph_children.some((n) => n.type !== 'Text' || n.content.trim().length > 0);
+            if (!has_content) {
+                paragraph_children.length = 0;
+                return null;
+            }
+        }
+        // Single tag extraction (MDX convention)
+        const single_tag = extract_single_tag(paragraph_children);
+        if (single_tag) {
+            paragraph_children.length = 0;
+            return single_tag;
+        }
+        // Merge adjacent text nodes
+        const merged = this.#merge_adjacent_text(paragraph_children.slice());
+        paragraph_children.length = 0;
+        if (merged.length === 0)
+            return null;
+        return {
+            type: 'Paragraph',
+            children: merged,
+            start: merged[0].start,
+            end: merged[merged.length - 1].end,
+        };
+    }
+    #merge_adjacent_text(nodes) {
+        if (nodes.length <= 1)
+            return nodes;
+        const merged = [];
+        let pending_text = null;
+        for (const node of nodes) {
+            if (node.type === 'Text') {
+                if (pending_text) {
+                    pending_text = {
+                        type: 'Text',
+                        content: pending_text.content + node.content,
+                        start: pending_text.start,
+                        end: node.end,
+                    };
+                }
+                else {
+                    pending_text = { ...node };
+                }
+            }
+            else {
+                if (pending_text) {
+                    merged.push(pending_text);
+                    pending_text = null;
+                }
+                merged.push(node);
+            }
+        }
+        if (pending_text)
+            merged.push(pending_text);
+        return merged;
+    }
+}

package/dist/svelte_preprocess_mdz.js

@@ -161,6 +161,22 @@ const find_mdz_usages = (ast, mdz_names, context) => {
             const content_attr = find_attribute(node, 'content');
             if (!content_attr)
                 return;
+            // Extract optional static base prop for relative path resolution.
+            // If base is present but dynamic, skip precompilation entirely —
+            // MdzPrecompiled doesn't resolve relative paths at runtime,
+            // so precompiling with unresolved relative links would be wrong.
+            const base_attr = find_attribute(node, 'base');
+            let base;
+            if (base_attr) {
+                const base_value = extract_static_string(base_attr.value, context.bindings);
+                if (base_value === null)
+                    return; // dynamic base — fall back to runtime
+                base = base_value;
+            }
+            // Collect attributes to exclude from precompiled output
+            const exclude_attrs = new Set([content_attr]);
+            if (base_attr)
+                exclude_attrs.add(base_attr);
             // Extract static string value
             const content_value = extract_static_string(content_attr.value, context.bindings);
             if (content_value !== null) {
@@ -168,7 +184,7 @@ const find_mdz_usages = (ast, mdz_names, context) => {
                 let result;
                 try {
                     const nodes = mdz_parse(content_value);
-                    result = mdz_to_svelte(nodes, context.components, context.elements);
+                    result = mdz_to_svelte(nodes, context.components, context.elements, base);
                 }
                 catch (error) {
                     handle_preprocess_error(error, '[fuz-mdz]', context.filename, context.on_error);
@@ -178,7 +194,7 @@ const find_mdz_usages = (ast, mdz_names, context) => {
                 if (result.has_unconfigured_tags)
                     return;
                 const consumed = collect_consumed_bindings(content_attr.value, context.bindings);
-                const replacement = build_replacement(node, content_attr, result.markup, context.source);
+                const replacement = build_replacement(node, exclude_attrs, result.markup, context.source);
                 transformed_usages.set(node.name, (transformed_usages.get(node.name) ?? 0) + 1);
                 transformations.push({
                     start: node.start,
@@ -199,7 +215,7 @@ const find_mdz_usages = (ast, mdz_names, context) => {
             try {
                 for (const branch of chain) {
                     const nodes = mdz_parse(branch.value);
-                    const result = mdz_to_svelte(nodes, context.components, context.elements);
+                    const result = mdz_to_svelte(nodes, context.components, context.elements, base);
                     if (result.has_unconfigured_tags)
                         return;
                     branch_results.push({ markup: result.markup, imports: result.imports });
@@ -225,7 +241,7 @@ const find_mdz_usages = (ast, mdz_names, context) => {
                 }
             }
             children_markup += '{/if}';
-            const replacement = build_replacement(node, content_attr, children_markup, context.source);
+            const replacement = build_replacement(node, exclude_attrs, children_markup, context.source);
             // Merge imports from all branches
             const merged_imports = new Map();
             for (const result of branch_results) {
@@ -317,11 +333,11 @@ const remove_dead_const_bindings = (s, ast, transformations, source) => {
  * Reconstructs the opening tag as `<MdzPrecompiled` with all attributes except `content`,
  * using source text slicing to preserve exact formatting and dynamic expressions.
  */
-const build_replacement = (node, content_attr, children_markup, source) => {
-    // Collect source ranges of all attributes EXCEPT content
+const build_replacement = (node, exclude_attrs, children_markup, source) => {
+    // Collect source ranges of all attributes except excluded ones (content, base when resolved)
     const other_attr_ranges = [];
     for (const attr of node.attributes) {
-        if (attr === content_attr)
+        if (exclude_attrs.has(attr))
             continue;
         other_attr_ranges.push({ start: attr.start, end: attr.end });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_ui",
-  "version": "0.185.2",
+  "version": "0.187.0",
   "description": "Svelte UI library",
   "motto": "friendly user zystem",
   "glyph": "🧶",
@@ -27,7 +27,8 @@
     "test": "gro test",
     "fixtures:update": "gro src/test/fixtures/update",
     "preview": "vite preview",
-    "deploy": "gro deploy"
+    "deploy": "gro deploy",
+    "benchmark_mdz": "gro run src/benchmarks/mdz.benchmark.ts"
   },
   "type": "module",
   "engines": {
@@ -75,13 +76,13 @@
   "devDependencies": {
     "@changesets/changelog-git": "^0.2.1",
     "@fuzdev/fuz_code": "^0.45.1",
-    "@fuzdev/fuz_css": "^0.53.0",
-    "@fuzdev/fuz_util": "^0.52.0",
-    "@fuzdev/gro": "^0.195.0",
+    "@fuzdev/fuz_css": "^0.55.0",
+    "@fuzdev/fuz_util": "^0.53.4",
+    "@fuzdev/gro": "^0.197.0",
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@ryanatkn/eslint-config": "^0.9.0",
+    "@ryanatkn/eslint-config": "^0.10.1",
     "@sveltejs/adapter-static": "^3.0.10",
-    "@sveltejs/kit": "^2.50.1",
+    "@sveltejs/kit": "^2.53.4",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "@types/estree": "^1.0.8",
@@ -94,8 +95,8 @@
     "magic-string": "^0.30.21",
     "prettier": "^3.7.4",
     "prettier-plugin-svelte": "^3.4.1",
-    "svelte": "^5.49.1",
-    "svelte-check": "^4.3.6",
+    "svelte": "^5.53.7",
+    "svelte-check": "^4.4.5",
     "svelte2tsx": "^0.7.47",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",