svelte-streamdown 2.3.0 → 2.3.2

package/dist/marked/marked-math.js

@@ -4,75 +4,121 @@ const blockRule = /^(\$\$)(?:\n((?:\\[\s\S]|[^\\])+?)\n\1(?:\n|$)|([^$\n]+?)\1(?
 // Inline math: handles both single ($) and double ($$) dollar delimiters
 // Avoids matching currency by checking context and requiring proper content
 const inlineRule = /^(\${1,2})(?!\$)((?:[^$\n]|\\\$)*?)\1(?!\d)/;
-export function markedMath() {
-    return {
-        extensions: [
-            {
-                name: 'math',
-                level: 'block',
-                tokenizer(src) {
-                    const match = src.match(blockRule);
-                    if (match) {
-                        // match[2] is multiline format, match[3] is single-line format
-                        const content = (match[2] || match[3]).trim();
-                        return {
-                            type: 'math',
-                            isInline: false,
-                            displayMode: true,
-                            raw: match[0],
-                            text: content
-                        };
-                    }
+// Enhanced currency detection patterns
+const currencyPatterns = {
+    // Simple price patterns: $123, $123.45, $1,234.56
+    simplePrice: /^\d{1,3}(?:,\d{3})*(?:\.\d{2})?$/,
+    // Multiple prices or numbers: "123, 456", "123.45, 678.90", "123 or 456"
+    multipleNumbers: /^\d+(?:[.,]\d+)*(?:\s*[,;]\s*\d+(?:[.,]\d+)*)+$/,
+    // Price ranges: "123-456", "123 - 456", "123 to 456"
+    priceRange: /^\d+(?:\.\d{2})?\s*(?:-|to|or)\s*\d+(?:\.\d{2})?$/i,
+    // Common currency words nearby (check surrounding context)
+    currencyContext: /(?:price|cost|dollar|euro|pound|yen|currency|pay|buy|sell|expensive|cheap)/i
+};
+export const markedMath = [
+    {
+        name: 'math',
+        level: 'block',
+        tokenizer(src) {
+            const match = src.match(blockRule);
+            if (match) {
+                // match[2] is multiline format, match[3] is single-line format
+                const content = (match[2] || match[3]).trim();
+                return {
+                    type: 'math',
+                    isInline: false,
+                    displayMode: true,
+                    raw: match[0],
+                    text: content
+                };
+            }
+        }
+    },
+    {
+        name: 'math',
+        level: 'inline',
+        start(src) {
+            let index = 0;
+            let searchSrc = src;
+            while (searchSrc) {
+                const dollarIndex = searchSrc.indexOf('$');
+                if (dollarIndex === -1) {
+                    return;
                 }
-            },
-            {
-                name: 'math',
-                level: 'inline',
-                start(src) {
-                    let index = 0;
-                    let searchSrc = src;
-                    while (searchSrc) {
-                        const dollarIndex = searchSrc.indexOf('$');
-                        if (dollarIndex === -1) {
-                            return;
-                        }
-                        const currentIndex = index + dollarIndex;
-                        const possibleMath = src.substring(currentIndex);
-                        // Check if this could be math (not currency)
-                        if (possibleMath.match(inlineRule)) {
-                            // Additional check: avoid currency patterns like $5.00
-                            const beforeChar = currentIndex > 0 ? src[currentIndex - 1] : '';
-                            const afterDollar = possibleMath.substring(1, 6); // Check first few chars after $
-                            // Skip if it looks like currency (digit immediately after $ or decimal pattern)
-                            if (!/^\d+(\.\d{2})?\s/.test(afterDollar)) {
-                                return currentIndex;
-                            }
-                        }
-                        index += dollarIndex + 1;
-                        searchSrc = src.substring(index);
-                    }
-                },
-                tokenizer(src) {
-                    const match = src.match(inlineRule);
+                const currentIndex = index + dollarIndex;
+                const possibleMath = src.substring(currentIndex);
+                // Check if this could be math (not currency)
+                if (possibleMath.match(inlineRule)) {
+                    const match = possibleMath.match(inlineRule);
                     if (match) {
-                        // Additional validation: avoid currency patterns
                         const content = match[2];
-                        if (/^\d+(\.\d{2})?$/.test(content.trim())) {
-                            // This looks like currency, skip it
-                            return;
+                        const dollarCount = match[1]; // '$' or '$$'
+                        // Only apply currency detection to single dollars
+                        // Double dollars ($$) indicate explicit math intent
+                        if (dollarCount === '$' && isCurrencyPattern(content, src, currentIndex)) {
+                            // This looks like currency with single dollars, skip it
+                            index += dollarIndex + 1;
+                            searchSrc = src.substring(index);
+                            continue;
                         }
-                        // Double dollars are display mode, single dollars are inline
-                        const isDisplayMode = match[1] === '$$';
-                        return {
-                            type: 'math',
-                            isInline: !isDisplayMode,
-                            displayMode: isDisplayMode,
-                            raw: match[0],
-                            text: content.trim()
-                        };
+                        return currentIndex;
                     }
                 }
+                index += dollarIndex + 1;
+                searchSrc = src.substring(index);
+            }
+        },
+        tokenizer(src) {
+            const match = src.match(inlineRule);
+            if (match) {
+                const content = match[2];
+                const dollarCount = match[1]; // '$' or '$$'
+                const isDisplayMode = dollarCount === '$$';
+                // Only apply currency detection to single dollars
+                // Double dollars ($$) indicate explicit math intent
+                if (dollarCount === '$' && isCurrencyPattern(content, src, 0)) {
+                    // This looks like currency with single dollars, skip it
+                    return;
+                }
+                return {
+                    type: 'math',
+                    isInline: true, // Inline tokenizer always produces inline math
+                    displayMode: isDisplayMode, // $$ = display mode styling, $ = inline styling
+                    raw: match[0],
+                    text: content.trim()
+                };
             }
-        ]
-    };
+        }
+    }
+];
+// Helper function to detect currency patterns
+function isCurrencyPattern(content, fullSrc, dollarIndex) {
+    const trimmedContent = content.trim();
+    // Check for simple price patterns
+    if (currencyPatterns.simplePrice.test(trimmedContent)) {
+        return true;
+    }
+    // Check for multiple numbers/prices pattern (like "199, 199")
+    if (currencyPatterns.multipleNumbers.test(trimmedContent)) {
+        return true;
+    }
+    // Check for price ranges
+    if (currencyPatterns.priceRange.test(trimmedContent)) {
+        return true;
+    }
+    // Check surrounding context for currency-related words
+    const contextStart = Math.max(0, dollarIndex - 50);
+    const contextEnd = Math.min(fullSrc.length, dollarIndex + content.length + 50);
+    const context = fullSrc.substring(contextStart, contextEnd);
+    if (currencyPatterns.currencyContext.test(context)) {
+        // If currency context is found and content is purely numeric, likely currency
+        if (/^\d+(?:[.,]\d+)*$/.test(trimmedContent)) {
+            return true;
+        }
+    }
+    // Additional check: if content is just numbers with common currency formatting
+    if (/^\d{1,3}(?:,\d{3})*(?:\.\d{1,2})?$/.test(trimmedContent)) {
+        return true;
+    }
+    return false;
 }

package/dist/marked/marked-subsup.d.ts

@@ -1,12 +1,6 @@
-import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
-export declare function markedSubSup(): {
-    extensions: {
-        name: string;
-        level: 'inline';
-        tokenizer: TokenizerExtensionFunction;
-        start?: TokenizerStartFunction;
-    }[];
-};
+import type { Extension } from './index.js';
+export declare const markedSub: Extension;
+export declare const markedSup: Extension;
 /**
  * Represents a subscript token.
  */

package/dist/marked/marked-subsup.js

@@ -1,45 +1,40 @@
 const subRule = /^~([^~\s](?:[^~]*[^~\s])?)~/; // ~text~
 const supRule = /^\^([^\^\s](?:[^\^]*[^\^\s])?)\^/; // ^text^
-export function markedSubSup() {
-    return {
-        extensions: [
-            {
-                name: 'sub',
-                level: 'inline',
-                start(src) {
-                    const i = src.indexOf('~');
-                    return i === -1 ? undefined : i;
-                },
-                tokenizer(src) {
-                    const match = src.match(subRule);
-                    if (match) {
-                        return {
-                            type: 'sub',
-                            raw: match[0],
-                            text: match[1],
-                            tokens: this.lexer.inlineTokens(match[1])
-                        };
-                    }
-                }
-            },
-            {
-                name: 'sup',
-                level: 'inline',
-                start(src) {
-                    return src.indexOf('^');
-                },
-                tokenizer(src) {
-                    const match = src.match(supRule);
-                    if (match) {
-                        return {
-                            type: 'sup',
-                            raw: match[0],
-                            text: match[1],
-                            tokens: this.lexer.inlineTokens(match[1])
-                        };
-                    }
-                }
-            }
-        ]
-    };
-}
+export const markedSub = {
+    name: 'sub',
+    level: 'inline',
+    start(src) {
+        const i = src.indexOf('~');
+        return i === -1 ? undefined : i;
+    },
+    tokenizer(src) {
+        const match = src.match(subRule);
+        if (match) {
+            return {
+                type: 'sub',
+                raw: match[0],
+                text: match[1],
+                tokens: this.lexer.inlineTokens(match[1])
+            };
+        }
+    }
+};
+export const markedSup = {
+    name: 'sup',
+    level: 'inline',
+    start(src) {
+        const i = src.indexOf('^');
+        return i === -1 ? undefined : i;
+    },
+    tokenizer(src) {
+        const match = src.match(supRule);
+        if (match) {
+            return {
+                type: 'sup',
+                raw: match[0],
+                text: match[1],
+                tokens: this.lexer.inlineTokens(match[1])
+            };
+        }
+    }
+};

package/dist/marked/marked-table.d.ts

@@ -1,4 +1,4 @@
-import type { TokenizerExtensionFunction, TokenizerStartFunction } from 'marked';
+import type { Extension } from './index.js';
 export interface SpanTableOptions {
     useTheadTbody?: boolean;
     useTfoot?: boolean;
@@ -56,12 +56,5 @@ type WorkingRow = WorkingCell[];
 export declare const DEFAULT_OPTIONS: Required<SpanTableOptions>;
 export declare const getTableCell: (text: string, cell: BaseCell, type: "th" | "td", align: string | null) => string;
 export declare const splitCells: (tableRow: string, count: number | null, prevRow?: WorkingRow | null, maxColspan?: number | null) => WorkingRow;
-export declare function markedTable(options?: SpanTableOptions): {
-    extensions: {
-        name: string;
-        level: 'block' | 'inline';
-        start: TokenizerStartFunction;
-        tokenizer: TokenizerExtensionFunction;
-    }[];
-};
+export declare const markedTable: Extension;
 export {};

package/dist/marked/marked-table.js

@@ -116,8 +116,7 @@ const processSpans = (cells, count, prevRow = [], maxColspan = null) => {
         let cellText = cell.text;
         // Handle Rowspan - cells ending with ^ (but not superscript ^text^)
         // Check if it's a rowspan indicator (single ^ at end) vs superscript (^text^)
-        const isRowspanIndicator = cellText.slice(-1) === '^' &&
-            !cellText.match(/\^[^^\n\r]+\^$/); // Not a superscript pattern ^text^
+        const isRowspanIndicator = cellText.slice(-1) === '^' && !cellText.match(/\^[^^\n\r]+\^$/); // Not a superscript pattern ^text^
         if (isRowspanIndicator && prevRow.length > 0) {
             // Clean the ^ indicator from the cell text
             cell.text = cellText.slice(0, -1).trim();
@@ -374,129 +373,121 @@ function processRows(headerRows, bodyRows, alignment, colCount, lexer, maxColspa
     }
     return tokens;
 }
+const { detectFooter, maxColspan } = DEFAULT_OPTIONS;
 // Adds support for extended tables in marked with row spanning, column spanning,
 // multi-row headers, and column alignment
-export function markedTable(options = {}) {
-    const config = { ...DEFAULT_OPTIONS, ...options };
-    const { detectFooter, maxColspan } = config;
-    return {
-        extensions: [
-            {
-                name: 'table',
-                level: 'block',
-                start(src) {
-                    // Check for table with potential header alignment
-                    let match = src.match(/^\n *([^\n ].*\|.*)\n/);
-                    if (match)
-                        return match.index;
-                    // Check for simple table without header alignment
-                    match = src.match(/^\n *(\|.*\|)\n/);
-                    if (match)
-                        return match.index;
+export const markedTable = {
+    name: 'table',
+    level: 'block',
+    start(src) {
+        // Check for table with potential header alignment
+        let match = src.match(/^\n *([^\n ].*\|.*)\n/);
+        if (match)
+            return match.index;
+        // Check for simple table without header alignment
+        match = src.match(/^\n *(\|.*\|)\n/);
+        if (match)
+            return match.index;
+        return undefined;
+    },
+    tokenizer(src) {
+        // Try to match table with header and alignment first
+        let regex = new RegExp('^' +
+            '([^\\n ].*\\|.*\\n(?: *[^\\s].*\\n)*?)' + // Header
+            ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' + // Header Align
+            '(?:\\n((?:(?! *\\n| {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})' + // Body Cells
+            '(?:\\n+|$)| {0,3}#{1,6} | {0,3}>| {4}[^\\n]| {0,3}(?:`{3,}' +
+            '(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n| {0,3}(?:[*+-]|1[.)]) |' +
+            '<\\/?(?:address|article|aside|base|basefont|blockquote|body|' +
+            'caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\\n|\\/?>)|<(?:script|pre|style|textarea|!--)).*(?:\\n|$))*)\\n*|$)');
+        let cap = regex.exec(src);
+        let hasHeaderAlignment = true;
+        // If no match with header alignment, try table without header alignment
+        if (!cap) {
+            // Simple regex for tables without header alignment
+            regex = /^(\|.*\|(?:\n\|.*\|)*)/;
+            cap = regex.exec(src);
+            hasHeaderAlignment = false;
+        }
+        if (!cap)
+            return undefined;
+        // Combine all captured groups to get complete table rows
+        let allTableContent = cap[1]; // Headers
+        if (cap[2])
+            allTableContent += '\n' + cap[2]; // Alignment row
+        if (cap[3])
+            allTableContent += '\n' + cap[3]; // Body rows
+        const allRows = allTableContent.replace(/\n$/, '').split('\n');
+        let headerRows = [];
+        let bodyRows = [];
+        let alignRow = [];
+        let alignment = [];
+        let colCount = 0;
+        if (hasHeaderAlignment) {
+            // Traditional table with header and alignment
+            // Parse all rows and identify which are headers vs body
+            let headerEndIndex = -1;
+            // Find the FIRST alignment row (contains dashes/underscores/asterisks)
+            for (let i = 0; i < allRows.length; i++) {
+                const row = allRows[i].trim();
+                const isAlignment = /^ *(\| *)?:?-+:? *(\| *:?-+:? *)*(\| *)?$/.test(row);
+                // Check if this row matches alignment pattern (contains only |, spaces, and alignment chars)
+                if (isAlignment) {
+                    headerEndIndex = i;
+                    alignRow = row.replace(/^ *\| *| *\| *$/g, '').split(/ *\| */);
+                    break; // Stop at the first alignment row
+                }
+            }
+            if (headerEndIndex === -1) {
+                // No alignment row found, treat as simple table
+                bodyRows = allRows;
+                colCount = bodyRows[0].split('|').filter((cell) => cell.trim() !== '').length;
+                alignment = new Array(colCount).fill(null);
+            }
+            else {
+                // Found alignment row, split headers and body
+                // Filter out empty rows and the alignment row itself from headers
+                headerRows = allRows.slice(0, headerEndIndex).filter((row) => row.trim() !== '');
+                bodyRows = headerEndIndex + 1 < allRows.length ? allRows.slice(headerEndIndex + 1) : [];
+                // Use alignment row length as the authoritative column count
+                colCount = alignRow.length;
+                // Validate that we have a reasonable table structure
+                if (colCount === 0)
                     return undefined;
-                },
-                tokenizer(src) {
-                    // Try to match table with header and alignment first
-                    let regex = new RegExp('^' +
-                        '([^\\n ].*\\|.*\\n(?: *[^\\s].*\\n)*?)' + // Header
-                        ' {0,3}(?:\\| *)?(:?-+:? *(?:\\| *:?-+:? *)*)(?:\\| *)?' + // Header Align
-                        '(?:\\n((?:(?! *\\n| {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})' + // Body Cells
-                        '(?:\\n+|$)| {0,3}#{1,6} | {0,3}>| {4}[^\\n]| {0,3}(?:`{3,}' +
-                        '(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n| {0,3}(?:[*+-]|1[.)]) |' +
-                        '<\\/?(?:address|article|aside|base|basefont|blockquote|body|' +
-                        'caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\\n|\\/?>)|<(?:script|pre|style|textarea|!--)).*(?:\\n|$))*)\\n*|$)');
-                    let cap = regex.exec(src);
-                    let hasHeaderAlignment = true;
-                    // If no match with header alignment, try table without header alignment
-                    if (!cap) {
-                        // Simple regex for tables without header alignment
-                        regex = /^(\|.*\|(?:\n\|.*\|)*)/;
-                        cap = regex.exec(src);
-                        hasHeaderAlignment = false;
-                    }
-                    if (!cap)
-                        return null;
-                    // Combine all captured groups to get complete table rows
-                    let allTableContent = cap[1]; // Headers
-                    if (cap[2])
-                        allTableContent += '\n' + cap[2]; // Alignment row
-                    if (cap[3])
-                        allTableContent += '\n' + cap[3]; // Body rows
-                    const allRows = allTableContent.replace(/\n$/, '').split('\n');
-                    let headerRows = [];
-                    let bodyRows = [];
-                    let alignRow = [];
-                    let alignment = [];
-                    let colCount = 0;
-                    if (hasHeaderAlignment) {
-                        // Traditional table with header and alignment
-                        // Parse all rows and identify which are headers vs body
-                        let headerEndIndex = -1;
-                        // Find the FIRST alignment row (contains dashes/underscores/asterisks)
-                        for (let i = 0; i < allRows.length; i++) {
-                            const row = allRows[i].trim();
-                            const isAlignment = /^ *(\| *)?:?-+:? *(\| *:?-+:? *)*(\| *)?$/.test(row);
-                            // Check if this row matches alignment pattern (contains only |, spaces, and alignment chars)
-                            if (isAlignment) {
-                                headerEndIndex = i;
-                                alignRow = row.replace(/^ *\| *| *\| *$/g, '').split(/ *\| */);
-                                break; // Stop at the first alignment row
-                            }
-                        }
-                        if (headerEndIndex === -1) {
-                            // No alignment row found, treat as simple table
-                            bodyRows = allRows;
-                            colCount = bodyRows[0].split('|').filter((cell) => cell.trim() !== '').length;
-                            alignment = new Array(colCount).fill(null);
-                        }
-                        else {
-                            // Found alignment row, split headers and body
-                            // Filter out empty rows and the alignment row itself from headers
-                            headerRows = allRows.slice(0, headerEndIndex).filter((row) => row.trim() !== '');
-                            bodyRows =
-                                headerEndIndex + 1 < allRows.length ? allRows.slice(headerEndIndex + 1) : [];
-                            // Use alignment row length as the authoritative column count
-                            colCount = alignRow.length;
-                            // Validate that we have a reasonable table structure
-                            if (colCount === 0)
-                                return null;
-                            // Process alignment
-                            alignment = processAlignment(alignRow);
-                        }
-                    }
-                    else {
-                        // Table without header alignment - treat all rows as body rows
-                        bodyRows = allRows;
-                        const firstRowCells = bodyRows[0].split('|').filter((cell) => cell.trim() !== '');
-                        colCount = firstRowCells.length;
-                        alignment = new Array(colCount).fill(null); // No alignment for tables without headers
-                    }
-                    // Detect footer alignment row pattern in body rows (only for tables with header alignment)
-                    let shouldDetectFooter = false;
-                    let processedBodyRows = bodyRows;
-                    if (detectFooter && hasHeaderAlignment && bodyRows.length > 0) {
-                        // Check if any row matches the alignment pattern (contains only dashes, pipes, colons, and spaces)
-                        for (let i = bodyRows.length - 1; i >= 0; i--) {
-                            const row = bodyRows[i];
-                            if (/^ *\| *:?-+:? *(\| *:?-+:? *)*\| *$/.test(row)) {
-                                // Found footer alignment row - remove it and enable footer detection
-                                shouldDetectFooter = true;
-                                processedBodyRows = bodyRows.slice(0, i).concat(bodyRows.slice(i + 1));
-                                break;
-                            }
-                        }
-                    }
-                    // Process all rows and create table sections
-                    const tokens = processRows(headerRows, processedBodyRows, alignment, colCount, this.lexer, maxColspan, shouldDetectFooter);
-                    const item = {
-                        type: 'table',
-                        tokens,
-                        raw: cap[0],
-                        align: alignment
-                    };
-                    return item;
+                // Process alignment
+                alignment = processAlignment(alignRow);
+            }
+        }
+        else {
+            // Table without header alignment - treat all rows as body rows
+            bodyRows = allRows;
+            const firstRowCells = bodyRows[0].split('|').filter((cell) => cell.trim() !== '');
+            colCount = firstRowCells.length;
+            alignment = new Array(colCount).fill(null); // No alignment for tables without headers
+        }
+        // Detect footer alignment row pattern in body rows (only for tables with header alignment)
+        let shouldDetectFooter = false;
+        let processedBodyRows = bodyRows;
+        if (detectFooter && hasHeaderAlignment && bodyRows.length > 0) {
+            // Check if any row matches the alignment pattern (contains only dashes, pipes, colons, and spaces)
+            for (let i = bodyRows.length - 1; i >= 0; i--) {
+                const row = bodyRows[i];
+                if (/^ *\| *:?-+:? *(\| *:?-+:? *)*\| *$/.test(row)) {
+                    // Found footer alignment row - remove it and enable footer detection
+                    shouldDetectFooter = true;
+                    processedBodyRows = bodyRows.slice(0, i).concat(bodyRows.slice(i + 1));
+                    break;
                 }
             }
-        ]
-    };
-}
+        }
+        // Process all rows and create table sections
+        const tokens = processRows(headerRows, processedBodyRows, alignment, colCount, this.lexer, maxColspan, shouldDetectFooter);
+        const item = {
+            type: 'table',
+            tokens,
+            raw: cap[0],
+            align: alignment
+        };
+        return item;
+    }
+};

package/dist/theme.js

@@ -121,7 +121,7 @@ export const theme = {
         base: 'italic'
     },
     del: {
-        base: 'line-through'
+        base: 'text-gray-600'
     },
     footnoteRef: {
         base: 'text-gray-600 px-1 py-0.5 rounded-md bg-gray-100/80'
@@ -250,7 +250,7 @@ export const shadcnTheme = {
         base: 'italic text-foreground'
     },
     del: {
-        base: 'line-through text-muted-foreground'
+        base: 'text-muted-foreground'
     },
     footnoteRef: {
         base: 'text-muted-foreground px-1 text-sm inline-block rounded-full bg-muted/80 aspect-square border border-border'

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-streamdown",
-	"version": "2.3.0",
+	"version": "2.3.2",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",
@@ -73,7 +73,6 @@
 	"dependencies": {
 		"@floating-ui/dom": "^1.7.4",
 		"clsx": "^2.1.1",
-		"html-url-attributes": "^3.0.1",
 		"katex": "^0.16.22",
 		"marked": "^16.2.1",
 		"mermaid": "^11.11.0",