comark 0.3.1 → 0.4.0

package/dist/internal/frontmatter.d.ts

@@ -7,6 +7,7 @@ import type { DumpOptions } from 'js-yaml';
 export declare function parseFrontmatter(content: string): {
     content: string;
     data: Record<string, any>;
+    frontmatterText: string;
 };
 /**
  * Render frontmatter to content

package/dist/internal/frontmatter.js

@@ -9,11 +9,12 @@ const CR = '\r';
  */
 export function parseFrontmatter(content) {
     let data = {};
+    let frontmatter = '';
     if (content.startsWith(FRONTMATTER_DELIMITER_DEFAULT)) {
         const idx = content.indexOf(LF + FRONTMATTER_DELIMITER_DEFAULT);
         if (idx !== -1) {
             const hasCarriageReturn = content[idx - 1] === CR;
-            const frontmatter = content.slice(4, idx - (hasCarriageReturn ? 1 : 0));
+            frontmatter = content.slice(4, idx - (hasCarriageReturn ? 1 : 0));
             if (frontmatter) {
                 data = parseYaml(frontmatter);
                 content = content.slice(idx + 4 + (hasCarriageReturn ? 1 : 0));
@@ -23,6 +24,7 @@ export function parseFrontmatter(content) {
     return {
         content,
         data,
+        frontmatterText: frontmatter,
     };
 }
 /**
@@ -33,7 +35,7 @@ export function parseFrontmatter(content) {
  */
 export function renderFrontmatter(data, content, yamlOptions) {
     if (!data || Object.keys(data).length === 0) {
-        return (content?.trim() || '');
+        return content?.trim() || '';
     }
     const fm = stringifyYaml(data, yamlOptions).trim();
     if (content) {

package/dist/internal/parse/auto-close/index.js

@@ -19,10 +19,33 @@ export function autoCloseMarkdown(markdown) {
     let inFrontmatter = false;
     let inBlockMath = false;
     let tableStart = -1;
+    // Tag name when inside a raw-text HTML element (`<style>`, `<script>`,
+    // `<pre>`, `<textarea>`). Their bodies must be passed through verbatim —
+    // any `::root`/`**` markers there are CSS/JS/text, not Comark/markdown.
+    let inRawTextElement = null;
+    const RAW_TEXT_OPEN_RE = /^<(script|pre|style|textarea)(\s|>|$)/i;
     const componentStack = [];
     for (let idx = 0; idx < n; idx++) {
         const line = lines[idx];
         const trimmed = line.trim();
+        // Raw-text HTML element: skip all line-level processing inside its body,
+        // and update the open/close state. Open and close can sit on the same
+        // line (e.g. `<style>body { ... }</style>` inline).
+        if (inRawTextElement) {
+            const closeRe = new RegExp(`</${inRawTextElement}\\s*>`, 'i');
+            if (closeRe.test(line))
+                inRawTextElement = null;
+            continue;
+        }
+        const rawTextMatch = trimmed.match(RAW_TEXT_OPEN_RE);
+        if (rawTextMatch) {
+            const tag = rawTextMatch[1].toLowerCase();
+            // Stay "inside" only if the close tag isn't already on this line.
+            const closeRe = new RegExp(`</${tag}\\s*>`, 'i');
+            if (!closeRe.test(line))
+                inRawTextElement = tag;
+            continue;
+        }
         // Frontmatter: only starts at document line 0
         if (idx === 0 && trimmed === '---') {
             inFrontmatter = true;
@@ -77,11 +100,22 @@ export function autoCloseMarkdown(markdown) {
                     let nameEnd = colonCount;
                     while (nameEnd < trimmed.length) {
                         const c = trimmed[nameEnd];
-                        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '$' || c === '.' || c === '-' || c === '_'))
+                        if (!((c >= 'a' && c <= 'z') ||
+                            (c >= 'A' && c <= 'Z') ||
+                            (c >= '0' && c <= '9') ||
+                            c === '$' ||
+                            c === '.' ||
+                            c === '-' ||
+                            c === '_'))
                             break;
                         nameEnd++;
                     }
-                    componentStack.push({ depth: colonCount, name: trimmed.slice(colonCount, nameEnd), indent, hasYamlProps: false });
+                    componentStack.push({
+                        depth: colonCount,
+                        name: trimmed.slice(colonCount, nameEnd),
+                        indent,
+                        hasYamlProps: false,
+                    });
                 }
                 else if (colonCount === trimmed.length && componentStack.length > 0) {
                     const top = componentStack[componentStack.length - 1];
@@ -136,14 +170,14 @@ export function autoCloseMarkdown(markdown) {
             for (let i = 0; i < propsContent.length; i++) {
                 if (propsContent[i] === '"')
                     dq++;
-                if (propsContent[i] === '\'')
+                if (propsContent[i] === "'")
                     sq++;
             }
             let braceClose = '';
             if (dq % 2 === 1)
                 braceClose += '"';
             if (sq % 2 === 1)
-                braceClose += '\'';
+                braceClose += "'";
             result += braceClose + '}';
         }
         if (componentStack.length > 0) {
@@ -179,7 +213,8 @@ function closeInlineMarkersLinear(line) {
     // Count markers by scanning
     let asteriskCount = 0;
     let underscoreCount = 0;
-    let tildeCount = 0; // Count individual tildes
+    let doubleTildeCount = 0; // Count ~~ occurrences (GFM strikethrough delimiter)
+    let singleTildeCount = 0; // Count standalone ~ (not part of ~~)
     let backtickCount = 0;
     let dollarCount = 0; // Count $ for math
     let dollarPairCount = 0; // Count $$ pairs for block math
@@ -269,7 +304,13 @@ function closeInlineMarkersLinear(line) {
             }
         }
         else if (ch === '~') {
-            tildeCount++;
+            if (i + 1 < len && line[i + 1] === '~') {
+                doubleTildeCount++;
+                i++; // Skip second tilde since we counted the pair
+            }
+            else {
+                singleTildeCount++;
+            }
         }
         else if (ch === '`') {
             backtickCount++;
@@ -299,8 +340,11 @@ function closeInlineMarkersLinear(line) {
             // Check if line starts with more than 3 asterisks (e.g., ****)
             if (!(line[3] === '*')) {
                 // Check if marker at end with no content
-                if (!(contentEnd >= 3 && line[contentEnd - 1] === '*' && line[contentEnd - 2] === '*'
-                    && line[contentEnd - 3] === '*' && (contentEnd === 3 || line[contentEnd - 4] === ' '))) {
+                if (!(contentEnd >= 3 &&
+                    line[contentEnd - 1] === '*' &&
+                    line[contentEnd - 2] === '*' &&
+                    line[contentEnd - 3] === '*' &&
+                    (contentEnd === 3 || line[contentEnd - 4] === ' '))) {
                     closingSuffix = '***';
                 }
             }
@@ -333,9 +377,9 @@ function closeInlineMarkersLinear(line) {
                         if (!allPaired) {
                             // Check if line ends with word (not just a closing marker)
                             const lastChar = line[contentEnd - 1];
-                            const endsWithWord = (lastChar >= 'a' && lastChar <= 'z')
-                                || (lastChar >= 'A' && lastChar <= 'Z')
-                                || (lastChar >= '0' && lastChar <= '9');
+                            const endsWithWord = (lastChar >= 'a' && lastChar <= 'z') ||
+                                (lastChar >= 'A' && lastChar <= 'Z') ||
+                                (lastChar >= '0' && lastChar <= '9');
                             if (!hasCompleteBoldPair || endsWithWord) {
                                 closingSuffix = '**';
                                 if (hasTrailingSpace && !endsWithMarker) {
@@ -375,8 +419,7 @@ function closeInlineMarkersLinear(line) {
                 // Check marker at end with no content
                 // Only skip if it's truly isolated (e.g., "input *")
                 // Don't skip if there are complete pairs before it (e.g., "input **bold** *")
-                const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '*'
-                    && (contentEnd === 1 || line[contentEnd - 2] === ' ');
+                const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '*' && (contentEnd === 1 || line[contentEnd - 2] === ' ');
                 if (!markerAtEnd || asteriskCount > 1) {
                     closingSuffix = '*';
                     const endsWithMarker = line[contentEnd - 1] === '*';
@@ -427,8 +470,7 @@ function closeInlineMarkersLinear(line) {
         }
         if (validItalic) {
             // Check marker at end with no content
-            const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '_'
-                && (contentEnd === 1 || line[contentEnd - 2] === ' ');
+            const markerAtEnd = contentEnd >= 1 && line[contentEnd - 1] === '_' && (contentEnd === 1 || line[contentEnd - 2] === ' ');
             if (!markerAtEnd) {
                 closingSuffix = '_';
                 const endsWithMarker = line[contentEnd - 1] === '_';
@@ -438,22 +480,18 @@ function closeInlineMarkersLinear(line) {
             }
         }
     }
-    // Check ~~ (strikethrough)
-    if (!closingSuffix && tildeCount >= 2) {
-        const remainder = tildeCount % 4;
-        if (remainder === 2) {
-            // Two tildes unclosed, close with ~~
-            closingSuffix = '~~';
-            if (hasTrailingSpace)
-                shouldTrim = true;
-        }
-        else if (remainder > 2 && remainder < 4) {
-            // Partial marker like ~~text~ (3 tildes), need 1 more
-            const needed = 4 - remainder;
-            closingSuffix = '~'.repeat(needed);
-            if (hasTrailingSpace)
-                shouldTrim = true;
-        }
+    // Check ~~ (strikethrough) and ~ (single-tilde) separately so that paired
+    // singles like ~Hello~ are left alone while ~~text and ~Hello both close.
+    if (!closingSuffix && doubleTildeCount % 2 === 1) {
+        // A trailing single ~ after an open ~~ is a partial closer (~~text~)
+        closingSuffix = singleTildeCount === 1 ? '~' : '~~';
+        if (hasTrailingSpace)
+            shouldTrim = true;
+    }
+    else if (!closingSuffix && singleTildeCount % 2 === 1) {
+        closingSuffix = '~';
+        if (hasTrailingSpace)
+            shouldTrim = true;
     }
     // Check ` (code)
     if (!closingSuffix && backtickCount % 2 === 1) {

package/dist/internal/parse/auto-close/table.js

@@ -87,12 +87,10 @@ export function closeTables(markdown) {
     const generateSeparator = () => '| ' + Array(columnCount).fill('---').join(' | ') + ' |';
     // Check if separator exists (including incomplete ones with just :)
     const secondLine = end - start >= 1 ? lines[start + 1].trim() : '';
-    const hasSeparator = secondLine.startsWith('|')
-        && (secondLine.includes('-') || secondLine.includes(':'));
+    const hasSeparator = secondLine.startsWith('|') && (secondLine.includes('-') || secondLine.includes(':'));
     // Handle last line
     const lastLine = lines[end].trim();
-    const isSeparator = lastLine.startsWith('|')
-        && (lastLine.includes('-') || lastLine.includes(':'));
+    const isSeparator = lastLine.startsWith('|') && (lastLine.includes('-') || lastLine.includes(':'));
     if (isSeparator) {
         // Parse and complete separator cells
         const sepCells = parseCells(lastLine);
@@ -147,11 +145,16 @@ export function closeTables(markdown) {
         const refWidths = parseCellWidths(refRow);
         const cells = parseCells(lastLine);
         // Rebuild with padding
-        lines[end] = '| ' + cells.map((cell, i) => {
-            const targetWidth = refWidths[i] || cell.length + 2;
-            const padding = ' '.repeat(Math.max(0, targetWidth - cell.length - 2));
-            return cell + padding;
-        }).join(' | ') + ' |';
+        lines[end] =
+            '| ' +
+                cells
+                    .map((cell, i) => {
+                    const targetWidth = refWidths[i] || cell.length + 2;
+                    const padding = ' '.repeat(Math.max(0, targetWidth - cell.length - 2));
+                    return cell + padding;
+                })
+                    .join(' | ') +
+                ' |';
     }
     // Add separator if missing
     if (!hasSeparator) {

package/dist/internal/parse/auto-unwrap.js

@@ -28,15 +28,11 @@ export function applyAutoUnwrap(node) {
     }
     // Check if we have exactly one paragraph child (and possibly empty text nodes)
     if (nonEmptyChildren.length > 1 || typeof nonEmptyChildren[0] === 'string' || nonEmptyChildren[0][0] !== 'p') {
-        return [
-            tag,
-            props,
-            ...children.map((child) => applyAutoUnwrap(child)),
-        ];
+        return [tag, props, ...children.map((child) => applyAutoUnwrap(child))];
     }
-    return [
-        tag,
-        props,
-        ...nonEmptyChildren[0].slice(2),
-    ];
+    // Lift the paragraph's attrs onto the parent so trailing `{attr}` survives the unwrap.
+    // Parent attrs take precedence so explicit component props aren't overridden.
+    const paragraphAttrs = nonEmptyChildren[0][1];
+    const mergedProps = paragraphAttrs && Object.keys(paragraphAttrs).length > 0 ? { ...paragraphAttrs, ...props } : props;
+    return [tag, mergedProps, ...nonEmptyChildren[0].slice(2)];
 }

package/dist/internal/parse/html/html_block_rule.js

@@ -1,11 +1,10 @@
-// BASED ON https://github.com/serkodev/markdown-exit/blob/fe1351070a5841426223ab4a0a5c7874ba2b1257/packages/markdown-exit/src/parser/block/rules/html_block.ts
+// Standard CommonMark html_block rule — see
+// https://spec.commonmark.org/0.30/#html-blocks
+//
+// 7 sequences in priority order, each: [opener regex, closer regex, can-terminate-paragraph]
 import block_names from "./html_blocks.js";
 import { HTML_OPEN_CLOSE_TAG_RE } from "./html_re.js";
-// An array of opening and corresponding closing sequences for html tags,
-// last argument defines whether it can terminate a paragraph or not
-//
 const HTML_SEQUENCES = [
-    [new RegExp(`${HTML_OPEN_CLOSE_TAG_RE.source}\\s*$`), /^<\/[^>]+>$/, true],
     [/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
     [/^<!--/, /-->/, true],
     [/^<\?/, /\?>/, true],
@@ -17,10 +16,9 @@ const HTML_SEQUENCES = [
 export default function html_block(state, startLine, endLine, silent) {
     let pos = state.bMarks[startLine] + state.tShift[startLine];
     let max = state.eMarks[startLine];
-    // if it's indented more than 3 spaces, it should be a code block
     if (state.sCount[startLine] - state.blkIndent >= 4)
         return false;
-    if (state.src.charCodeAt(pos) !== 0x3C /* < */)
+    if (state.src.charCodeAt(pos) !== 0x3c /* < */)
         return false;
     let lineText = state.src.slice(pos, max);
     let i = 0;
@@ -30,18 +28,14 @@ export default function html_block(state, startLine, endLine, silent) {
     }
     if (i === HTML_SEQUENCES.length)
         return false;
-    if (silent) {
-        // true if this sequence can be a terminator, false otherwise
+    if (silent)
         return HTML_SEQUENCES[i][2];
-    }
     let nextLine = startLine + 1;
-    // If we are here - we detected HTML block.
-    // Let's roll down till block end.
-    if (i !== 0 && !HTML_SEQUENCES[i][1].test(lineText)) {
+    // Walk forward until the closer regex matches or we hit a blank line.
+    if (!HTML_SEQUENCES[i][1].test(lineText)) {
         for (; nextLine < endLine; nextLine++) {
-            if (state.sCount[nextLine] < state.blkIndent) {
+            if (state.sCount[nextLine] < state.blkIndent)
                 break;
-            }
             pos = state.bMarks[nextLine] + state.tShift[nextLine];
             max = state.eMarks[nextLine];
             lineText = state.src.slice(pos, max);
@@ -53,7 +47,7 @@ export default function html_block(state, startLine, endLine, silent) {
         }
     }
     state.line = nextLine;
-    const token = lineText.startsWith('</') ? state.push('html_block_close', '', -1) : state.push('html_block', '', 1);
+    const token = state.push('html_block', '', 1);
     token.map = [startLine, nextLine];
     token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
     return true;

package/dist/internal/parse/html/html_inline_rule.js

@@ -9,22 +9,18 @@ function isLinkClose(str) {
 function isLetter(ch) {
     /* eslint no-bitwise:0 */
     const lc = ch | 0x20; // to lower case
-    return (lc >= 0x61 /* a */) && (lc <= 0x7A /* z */);
+    return lc >= 0x61 /* a */ && lc <= 0x7a; /* z */
 }
 export default function html_inline(state, silent) {
     // Check start
     const max = state.posMax;
     const pos = state.pos;
-    if (state.src.charCodeAt(pos) !== 0x3C
-        || /* < */ pos + 2 >= max) {
+    if (state.src.charCodeAt(pos) !== 0x3c || /* < */ pos + 2 >= max) {
         return false;
     }
     // Quick fail on second char
     const ch = state.src.charCodeAt(pos + 1);
-    if (ch !== 0x21
-        && /* ! */ ch !== 0x3F
-        && /* ? */ ch !== 0x2F
-        && /* / */ !isLetter(ch)) {
+    if (ch !== 0x21 && /* ! */ ch !== 0x3f && /* ? */ ch !== 0x2f && /* / */ !isLetter(ch)) {
         return false;
     }
     const match = state.src.slice(pos).match(HTML_TAG_RE);

package/dist/internal/parse/html/html_re.js

@@ -1,7 +1,7 @@
 // Regexps to match html elements
 const attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
 const unquoted = '[^"\'=<>`\\x00-\\x20]+';
-const single_quoted = '\'[^\']*\'';
+const single_quoted = "'[^']*'";
 const double_quoted = '"[^"]*"';
 const attr_value = `(?:${unquoted}|${single_quoted}|${double_quoted})`;
 const attribute = `(?:\\s+${attr_name}(?:\\s*=\\s*${attr_value})?)`;

package/dist/internal/parse/html/index.d.ts

@@ -1,4 +1,5 @@
 import type { ComarkNode } from 'comark';
+export declare const VOID_ELEMENTS: Set<string>;
 interface HtmlTagInfo {
     tag: string;
     attrs: Record<string, unknown>;

package/dist/internal/parse/html/index.js

@@ -1,7 +1,19 @@
 import { Parser } from 'htmlparser2';
-const VOID_ELEMENTS = new Set([
-    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-    'link', 'meta', 'param', 'source', 'track', 'wbr',
+export const VOID_ELEMENTS = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
 ]);
 function attribsToComarkAttrs(attribs, isInline = false) {
     const attrs = {

package/dist/internal/parse/syntax/block-params.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse `component-name [content] {.params}` from the trailing portion of a block fence line.
+ */
+export declare function parseBlockParams(str: string): {
+    name: string;
+    content?: string;
+    props?: [string, string][];
+    remaining?: string;
+};

package/dist/internal/parse/syntax/block-params.js

@@ -0,0 +1,48 @@
+import { kebabCase } from "../../../utils/index.js";
+import { parseBracketContent } from "./brackets.js";
+import { searchProps } from "./props.js";
+const RE_BLOCK_NAME = /^[a-z$][$\w.-]*/i;
+/**
+ * Parse `component-name [content] {.params}` from the trailing portion of a block fence line.
+ */
+export function parseBlockParams(str) {
+    str = str.trim();
+    if (!str)
+        return { name: '' };
+    const name = str.match(RE_BLOCK_NAME)?.[0];
+    if (!name)
+        throw new Error(`Invalid block params: ${str}`);
+    let remaining = str.slice(name.length).trim();
+    let content;
+    let props;
+    let unparsedRemaining;
+    if (remaining.startsWith('[')) {
+        const result = parseBracketContent(remaining, 0);
+        if (result) {
+            content = result.content;
+            remaining = remaining.slice(result.endIndex).trim();
+        }
+    }
+    if (remaining.startsWith('{')) {
+        const propsResult = searchProps(remaining, 0);
+        if (propsResult) {
+            props = propsResult.props;
+            const afterProps = remaining.slice(propsResult.index).trim();
+            if (afterProps)
+                unparsedRemaining = afterProps;
+        }
+    }
+    else if (remaining) {
+        unparsedRemaining = remaining;
+    }
+    const result = {
+        name: kebabCase(name),
+    };
+    if (content !== undefined)
+        result.content = content;
+    if (props !== undefined)
+        result.props = props;
+    if (unparsedRemaining)
+        result.remaining = unparsedRemaining;
+    return result;
+}

package/dist/internal/parse/syntax/brackets.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parse content within square brackets `[content]`.
+ * Returns the content (without the brackets) and the index just past the closing `]`.
+ */
+export declare function parseBracketContent(str: string, startIndex: number): {
+    content: string;
+    endIndex: number;
+} | null;

package/dist/internal/parse/syntax/brackets.js

@@ -0,0 +1,20 @@
+/**
+ * Parse content within square brackets `[content]`.
+ * Returns the content (without the brackets) and the index just past the closing `]`.
+ */
+export function parseBracketContent(str, startIndex) {
+    if (str[startIndex] !== '[')
+        return null;
+    let index = startIndex + 1;
+    while (index < str.length) {
+        if (str[index] === '\\' && index + 1 < str.length) {
+            index += 2;
+            continue;
+        }
+        if (str[index] === ']') {
+            return { content: str.slice(startIndex + 1, index), endIndex: index + 1 };
+        }
+        index += 1;
+    }
+    return null;
+}

package/dist/internal/parse/syntax/props.d.ts

@@ -0,0 +1,5 @@
+export declare function parseProps(content: string): [string, string][] | undefined;
+export declare function searchProps(content: string, index?: number): {
+    props: [string, string][];
+    index: number;
+} | undefined;

package/dist/internal/parse/syntax/props.js

@@ -0,0 +1,119 @@
+const bracketPairs = {
+    '[': ']',
+    '{': '}',
+    '(': ')',
+};
+const quotePairs = {
+    "'": "'",
+    '"': '"',
+    '`': '`',
+};
+export function parseProps(content) {
+    content = content.trim();
+    if (!content)
+        return undefined;
+    const props = searchProps(content);
+    if (!props)
+        throw new Error(`Invalid props: \`${content}\``);
+    if (props.index !== content.length)
+        throw new Error(`Invalid props: \`${content}\`, expected end \`}\` but got \`${content.slice(props.index)}\``);
+    return props.props;
+}
+export function searchProps(content, index = 0) {
+    if (content[index] !== '{')
+        throw new Error(`Invalid props, expected \`{\` but got '${content[index]}'`);
+    const props = [];
+    // Skip Vue mustache `{{ }}` syntax
+    if (content[index + 1] === '{')
+        return undefined;
+    index += 1;
+    while (index < content.length) {
+        if (content[index] === '\\') {
+            index += 2;
+        }
+        else if (content[index] === '}') {
+            index += 1;
+            break;
+        }
+        else if (content[index] === ' ') {
+            index += 1;
+        }
+        else if (content[index] === '.') {
+            index += 1;
+            props.push(['class', searchUntil(' #.}')]);
+        }
+        else if (content[index] === '#') {
+            index += 1;
+            props.push(['id', searchUntil(' #.}')]);
+        }
+        else {
+            const start = index;
+            while (index < content.length) {
+                index += 1;
+                if (' }='.includes(content[index]))
+                    break;
+            }
+            const char = content[index];
+            if (start !== index) {
+                const key = content.slice(start, index).trim();
+                if (char === '=') {
+                    index += 1;
+                    props.push([key, searchValue()]);
+                }
+                else {
+                    props.push([key, 'true']);
+                }
+            }
+        }
+    }
+    function searchUntil(str) {
+        const start = index;
+        while (index < content.length) {
+            index += 1;
+            if (content[index] === '\\')
+                index += 2;
+            if (str.includes(content[index]))
+                break;
+        }
+        return content.slice(start, index);
+    }
+    function searchValue() {
+        const start = index;
+        if (content[index] in bracketPairs) {
+            searchBracket(bracketPairs[content[index]]);
+            index += 1;
+            return content.slice(start, index);
+        }
+        else if (content[index] in quotePairs) {
+            searchString(quotePairs[content[index]]);
+            index += 1;
+            return content.slice(start, index);
+        }
+        else {
+            return searchUntil(' }');
+        }
+    }
+    function searchBracket(end) {
+        while (index < content.length) {
+            index++;
+            if (content[index] in quotePairs)
+                searchString(quotePairs[content[index]]);
+            else if (content[index] in bracketPairs)
+                searchBracket(bracketPairs[content[index]]);
+            else if (content[index] === end)
+                return;
+        }
+    }
+    function searchString(end) {
+        return searchUntil(end);
+    }
+    // Strip surrounding quotes from values
+    props.forEach((v) => {
+        if (/^(['"`]).*\1$/.test(v[1]))
+            v[1] = v[1].slice(1, -1);
+    });
+    return {
+        props,
+        index,
+    };
+}