@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/markdown/chunk.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Text chunking utilities for markdown-aware splitting.
+ *
+ * Provides functions to split text into chunks while respecting:
+ * - Fenced code blocks
+ * - Paragraph boundaries
+ * - Word boundaries
+ *
+ * @module markdown/chunk
+ */
+/**
+ * Split text into chunks of maximum length.
+ *
+ * Prefers breaking at:
+ * 1. Newlines (outside parentheses)
+ * 2. Whitespace (word boundaries)
+ * 3. Hard break at limit as fallback
+ *
+ * @param text - The text to chunk
+ * @param limit - Maximum chunk length
+ * @returns Array of text chunks
+ */
+export declare function chunkText(text: string, limit: number): string[];
+/**
+ * Split text into chunks on paragraph boundaries (blank lines).
+ *
+ * - Only breaks at paragraph separators ("\n\n" or more)
+ * - Packs multiple paragraphs into a single chunk up to `limit`
+ * - Falls back to length-based splitting when a paragraph exceeds `limit`
+ *
+ * @param text - The text to chunk
+ * @param limit - Maximum chunk length
+ * @param opts - Options for controlling splitting behavior
+ * @returns Array of text chunks
+ */
+export declare function chunkByParagraph(text: string, limit: number, opts?: {
+    splitLongParagraphs?: boolean;
+}): string[];
+/**
+ * Split markdown text with awareness of code fences.
+ *
+ * When a chunk must be split inside a code fence, properly closes
+ * the fence in the current chunk and reopens it in the next.
+ *
+ * @param text - The markdown text to chunk
+ * @param limit - Maximum chunk length
+ * @returns Array of text chunks
+ */
+export declare function chunkMarkdownText(text: string, limit: number): string[];
+//# sourceMappingURL=chunk.d.ts.map

package/packages/typescript/src/markdown/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/markdown/chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAiD/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC,MAAM,EAAE,CA0DV;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA2GvE"}

package/packages/typescript/src/markdown/chunk.js

@@ -0,0 +1,268 @@
+/**
+ * Text chunking utilities for markdown-aware splitting.
+ *
+ * Provides functions to split text into chunks while respecting:
+ * - Fenced code blocks
+ * - Paragraph boundaries
+ * - Word boundaries
+ *
+ * @module markdown/chunk
+ */
+import { findFenceSpanAt, isSafeFenceBreak, parseFenceSpans, } from "./fences.js";
+/**
+ * Split text into chunks of maximum length.
+ *
+ * Prefers breaking at:
+ * 1. Newlines (outside parentheses)
+ * 2. Whitespace (word boundaries)
+ * 3. Hard break at limit as fallback
+ *
+ * @param text - The text to chunk
+ * @param limit - Maximum chunk length
+ * @returns Array of text chunks
+ */
+export function chunkText(text, limit) {
+    if (!text) {
+        return [];
+    }
+    if (limit <= 0) {
+        return [text];
+    }
+    if (text.length <= limit) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        const window = remaining.slice(0, limit);
+        // 1) Prefer a newline break inside the window (outside parentheses).
+        const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(window);
+        // 2) Otherwise prefer the last whitespace (word boundary) inside the window.
+        let breakIdx = lastNewline > 0 ? lastNewline : lastWhitespace;
+        // 3) Fallback: hard break exactly at the limit.
+        if (breakIdx <= 0) {
+            breakIdx = limit;
+        }
+        const rawChunk = remaining.slice(0, breakIdx);
+        const chunk = rawChunk.trimEnd();
+        if (chunk.length > 0) {
+            chunks.push(chunk);
+        }
+        // If we broke on whitespace/newline, skip that separator; for hard breaks keep it.
+        const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+        const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+        remaining = remaining.slice(nextStart).trimStart();
+    }
+    if (remaining.length) {
+        chunks.push(remaining);
+    }
+    return chunks;
+}
+/**
+ * Split text into chunks on paragraph boundaries (blank lines).
+ *
+ * - Only breaks at paragraph separators ("\n\n" or more)
+ * - Packs multiple paragraphs into a single chunk up to `limit`
+ * - Falls back to length-based splitting when a paragraph exceeds `limit`
+ *
+ * @param text - The text to chunk
+ * @param limit - Maximum chunk length
+ * @param opts - Options for controlling splitting behavior
+ * @returns Array of text chunks
+ */
+export function chunkByParagraph(text, limit, opts) {
+    if (!text) {
+        return [];
+    }
+    if (limit <= 0) {
+        return [text];
+    }
+    const splitLongParagraphs = opts?.splitLongParagraphs !== false;
+    // Normalize to \n so blank line detection is consistent.
+    const normalized = text.replace(/\r\n?/g, "\n");
+    // Fast-path: if there are no blank-line paragraph separators, do not split.
+    const paragraphRe = /\n[\t ]*\n+/;
+    if (!paragraphRe.test(normalized)) {
+        if (normalized.length <= limit) {
+            return [normalized];
+        }
+        if (!splitLongParagraphs) {
+            return [normalized];
+        }
+        return chunkText(normalized, limit);
+    }
+    const spans = parseFenceSpans(normalized);
+    const parts = [];
+    const re = /\n[\t ]*\n+/g; // paragraph break: blank line(s), allowing whitespace
+    let lastIndex = 0;
+    for (const match of normalized.matchAll(re)) {
+        const idx = match.index ?? 0;
+        // Do not split on blank lines that occur inside fenced code blocks.
+        if (!isSafeFenceBreak(spans, idx)) {
+            continue;
+        }
+        parts.push(normalized.slice(lastIndex, idx));
+        lastIndex = idx + match[0].length;
+    }
+    parts.push(normalized.slice(lastIndex));
+    const chunks = [];
+    for (const part of parts) {
+        const paragraph = part.replace(/\s+$/g, "");
+        if (!paragraph.trim()) {
+            continue;
+        }
+        if (paragraph.length <= limit) {
+            chunks.push(paragraph);
+        }
+        else if (!splitLongParagraphs) {
+            chunks.push(paragraph);
+        }
+        else {
+            chunks.push(...chunkText(paragraph, limit));
+        }
+    }
+    return chunks;
+}
+/**
+ * Split markdown text with awareness of code fences.
+ *
+ * When a chunk must be split inside a code fence, properly closes
+ * the fence in the current chunk and reopens it in the next.
+ *
+ * @param text - The markdown text to chunk
+ * @param limit - Maximum chunk length
+ * @returns Array of text chunks
+ */
+export function chunkMarkdownText(text, limit) {
+    if (!text) {
+        return [];
+    }
+    if (limit <= 0) {
+        return [text];
+    }
+    if (text.length <= limit) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        const spans = parseFenceSpans(remaining);
+        const window = remaining.slice(0, limit);
+        const softBreak = pickSafeBreakIndex(window, spans);
+        let breakIdx = softBreak > 0 ? softBreak : limit;
+        const initialFence = isSafeFenceBreak(spans, breakIdx)
+            ? undefined
+            : findFenceSpanAt(spans, breakIdx);
+        let fenceToSplit = initialFence;
+        if (initialFence) {
+            const closeLine = `${initialFence.indent}${initialFence.marker}`;
+            const maxIdxIfNeedNewline = limit - (closeLine.length + 1);
+            if (maxIdxIfNeedNewline <= 0) {
+                fenceToSplit = undefined;
+                breakIdx = limit;
+            }
+            else {
+                const minProgressIdx = Math.min(remaining.length, initialFence.start + initialFence.openLine.length + 2);
+                const maxIdxIfAlreadyNewline = limit - closeLine.length;
+                let pickedNewline = false;
+                let lastNewline = remaining.lastIndexOf("\n", Math.max(0, maxIdxIfAlreadyNewline - 1));
+                while (lastNewline !== -1) {
+                    const candidateBreak = lastNewline + 1;
+                    if (candidateBreak < minProgressIdx) {
+                        break;
+                    }
+                    const candidateFence = findFenceSpanAt(spans, candidateBreak);
+                    if (candidateFence && candidateFence.start === initialFence.start) {
+                        breakIdx = Math.max(1, candidateBreak);
+                        pickedNewline = true;
+                        break;
+                    }
+                    lastNewline = remaining.lastIndexOf("\n", lastNewline - 1);
+                }
+                if (!pickedNewline) {
+                    if (minProgressIdx > maxIdxIfAlreadyNewline) {
+                        fenceToSplit = undefined;
+                        breakIdx = limit;
+                    }
+                    else {
+                        breakIdx = Math.max(minProgressIdx, maxIdxIfNeedNewline);
+                    }
+                }
+            }
+            const fenceAtBreak = findFenceSpanAt(spans, breakIdx);
+            fenceToSplit =
+                fenceAtBreak && fenceAtBreak.start === initialFence.start
+                    ? fenceAtBreak
+                    : undefined;
+        }
+        let rawChunk = remaining.slice(0, breakIdx);
+        if (!rawChunk) {
+            break;
+        }
+        const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+        const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+        let next = remaining.slice(nextStart);
+        if (fenceToSplit) {
+            const closeLine = `${fenceToSplit.indent}${fenceToSplit.marker}`;
+            rawChunk = rawChunk.endsWith("\n")
+                ? `${rawChunk}${closeLine}`
+                : `${rawChunk}\n${closeLine}`;
+            next = `${fenceToSplit.openLine}\n${next}`;
+        }
+        else {
+            next = stripLeadingNewlines(next);
+        }
+        chunks.push(rawChunk);
+        remaining = next;
+    }
+    if (remaining.length) {
+        chunks.push(remaining);
+    }
+    return chunks;
+}
+function stripLeadingNewlines(value) {
+    let i = 0;
+    while (i < value.length && value[i] === "\n") {
+        i++;
+    }
+    return i > 0 ? value.slice(i) : value;
+}
+function pickSafeBreakIndex(window, spans) {
+    const { lastNewline, lastWhitespace } = scanParenAwareBreakpoints(window, (index) => isSafeFenceBreak(spans, index));
+    if (lastNewline > 0) {
+        return lastNewline;
+    }
+    if (lastWhitespace > 0) {
+        return lastWhitespace;
+    }
+    return -1;
+}
+function scanParenAwareBreakpoints(window, isAllowed = () => true) {
+    let lastNewline = -1;
+    let lastWhitespace = -1;
+    let depth = 0;
+    for (let i = 0; i < window.length; i++) {
+        if (!isAllowed(i)) {
+            continue;
+        }
+        const char = window[i];
+        if (char === "(") {
+            depth += 1;
+            continue;
+        }
+        if (char === ")" && depth > 0) {
+            depth -= 1;
+            continue;
+        }
+        if (depth !== 0) {
+            continue;
+        }
+        if (char === "\n") {
+            lastNewline = i;
+        }
+        else if (/\s/.test(char)) {
+            lastWhitespace = i;
+        }
+    }
+    return { lastNewline, lastWhitespace };
+}

package/packages/typescript/src/markdown/code-spans.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Inline code span detection for markdown.
+ *
+ * Handles backtick-delimited inline code spans with proper
+ * tracking of state across streaming chunks.
+ *
+ * @module markdown/code-spans
+ */
+/**
+ * State for tracking open inline code spans across chunks.
+ */
+export type InlineCodeState = {
+    /** Whether we're currently inside an inline code span */
+    open: boolean;
+    /** Number of backticks in the opening sequence */
+    ticks: number;
+};
+/**
+ * Create initial inline code state.
+ */
+export declare function createInlineCodeState(): InlineCodeState;
+/**
+ * Index for checking if positions are inside code.
+ */
+export type CodeSpanIndex = {
+    /** Updated inline code state after processing */
+    inlineState: InlineCodeState;
+    /** Check if an index is inside any code (fence or inline) */
+    isInside: (index: number) => boolean;
+};
+/**
+ * Build an index for checking if positions are inside code spans.
+ *
+ * This handles both fenced code blocks and inline code spans.
+ * State can be passed in for streaming scenarios.
+ *
+ * @param text - The text to analyze
+ * @param inlineState - Optional state from previous chunk
+ * @returns Index object with isInside() method
+ */
+export declare function buildCodeSpanIndex(text: string, inlineState?: InlineCodeState): CodeSpanIndex;
+//# sourceMappingURL=code-spans.d.ts.map

package/packages/typescript/src/markdown/code-spans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-spans.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/markdown/code-spans.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC7B,yDAAyD;IACzD,IAAI,EAAE,OAAO,CAAC;IACd,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,eAAe,CAEvD;AAOD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC3B,iDAAiD;IACjD,WAAW,EAAE,eAAe,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACrC,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,eAAe,GAC3B,aAAa,CAiBf"}

package/packages/typescript/src/markdown/code-spans.js

@@ -0,0 +1,89 @@
+/**
+ * Inline code span detection for markdown.
+ *
+ * Handles backtick-delimited inline code spans with proper
+ * tracking of state across streaming chunks.
+ *
+ * @module markdown/code-spans
+ */
+import { parseFenceSpans } from "./fences.js";
+/**
+ * Create initial inline code state.
+ */
+export function createInlineCodeState() {
+    return { open: false, ticks: 0 };
+}
+/**
+ * Build an index for checking if positions are inside code spans.
+ *
+ * This handles both fenced code blocks and inline code spans.
+ * State can be passed in for streaming scenarios.
+ *
+ * @param text - The text to analyze
+ * @param inlineState - Optional state from previous chunk
+ * @returns Index object with isInside() method
+ */
+export function buildCodeSpanIndex(text, inlineState) {
+    const fenceSpans = parseFenceSpans(text);
+    const startState = inlineState
+        ? { open: inlineState.open, ticks: inlineState.ticks }
+        : createInlineCodeState();
+    const { spans: inlineSpans, state: nextInlineState } = parseInlineCodeSpans(text, fenceSpans, startState);
+    return {
+        inlineState: nextInlineState,
+        isInside: (index) => isInsideFenceSpan(index, fenceSpans) ||
+            isInsideInlineSpan(index, inlineSpans),
+    };
+}
+function parseInlineCodeSpans(text, fenceSpans, initialState) {
+    const spans = [];
+    let open = initialState.open;
+    let ticks = initialState.ticks;
+    let openStart = open ? 0 : -1;
+    let i = 0;
+    while (i < text.length) {
+        const fence = findFenceSpanAtInclusive(fenceSpans, i);
+        if (fence) {
+            i = fence.end;
+            continue;
+        }
+        if (text[i] !== "`") {
+            i += 1;
+            continue;
+        }
+        const runStart = i;
+        let runLength = 0;
+        while (i < text.length && text[i] === "`") {
+            runLength += 1;
+            i += 1;
+        }
+        if (!open) {
+            open = true;
+            ticks = runLength;
+            openStart = runStart;
+            continue;
+        }
+        if (runLength === ticks) {
+            spans.push([openStart, i]);
+            open = false;
+            ticks = 0;
+            openStart = -1;
+        }
+    }
+    if (open) {
+        spans.push([openStart, text.length]);
+    }
+    return {
+        spans,
+        state: { open, ticks },
+    };
+}
+function findFenceSpanAtInclusive(spans, index) {
+    return spans.find((span) => index >= span.start && index < span.end);
+}
+function isInsideFenceSpan(index, spans) {
+    return spans.some((span) => index >= span.start && index < span.end);
+}
+function isInsideInlineSpan(index, spans) {
+    return spans.some(([start, end]) => index >= start && index < end);
+}

package/packages/typescript/src/markdown/fences.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Code fence parsing utilities for markdown.
+ *
+ * Parses fenced code blocks (``` or ~~~) and provides utilities
+ * to check if a position is inside a fence or if a break is safe.
+ *
+ * @module markdown/fences
+ */
+/**
+ * Represents a fenced code block span in the text.
+ */
+export type FenceSpan = {
+    /** Start offset of the fence in the text */
+    start: number;
+    /** End offset of the fence in the text */
+    end: number;
+    /** The opening line of the fence (e.g., "```typescript") */
+    openLine: string;
+    /** The marker characters (e.g., "```" or "~~~") */
+    marker: string;
+    /** Leading whitespace/indent before the marker */
+    indent: string;
+};
+/**
+ * Parse all fenced code block spans from a string.
+ *
+ * Handles both backtick (```) and tilde (~~~) fences,
+ * with proper matching of closing markers.
+ *
+ * @param buffer - The text to parse
+ * @returns Array of fence spans found
+ */
+export declare function parseFenceSpans(buffer: string): FenceSpan[];
+/**
+ * Find the fence span that contains a given index.
+ *
+ * @param spans - Array of fence spans to search
+ * @param index - Position to check
+ * @returns The fence span containing the index, or undefined
+ */
+export declare function findFenceSpanAt(spans: FenceSpan[], index: number): FenceSpan | undefined;
+/**
+ * Check if it's safe to break text at a given index (not inside a fence).
+ *
+ * @param spans - Array of fence spans
+ * @param index - Position to check
+ * @returns True if safe to break (not inside a fence)
+ */
+export declare function isSafeFenceBreak(spans: FenceSpan[], index: number): boolean;
+//# sourceMappingURL=fences.d.ts.map

package/packages/typescript/src/markdown/fences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fences.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/markdown/fences.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACvB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CAmE3D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,MAAM,GACX,SAAS,GAAG,SAAS,CAEvB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE3E"}

package/packages/typescript/src/markdown/fences.js

@@ -0,0 +1,90 @@
+/**
+ * Code fence parsing utilities for markdown.
+ *
+ * Parses fenced code blocks (``` or ~~~) and provides utilities
+ * to check if a position is inside a fence or if a break is safe.
+ *
+ * @module markdown/fences
+ */
+/**
+ * Parse all fenced code block spans from a string.
+ *
+ * Handles both backtick (```) and tilde (~~~) fences,
+ * with proper matching of closing markers.
+ *
+ * @param buffer - The text to parse
+ * @returns Array of fence spans found
+ */
+export function parseFenceSpans(buffer) {
+    const spans = [];
+    let open;
+    let offset = 0;
+    while (offset <= buffer.length) {
+        const nextNewline = buffer.indexOf("\n", offset);
+        const lineEnd = nextNewline === -1 ? buffer.length : nextNewline;
+        const line = buffer.slice(offset, lineEnd);
+        const match = line.match(/^( {0,3})(`{3,}|~{3,})(.*)$/);
+        if (match) {
+            const indent = match[1];
+            const marker = match[2];
+            const markerChar = marker[0];
+            const markerLen = marker.length;
+            if (!open) {
+                open = {
+                    start: offset,
+                    markerChar,
+                    markerLen,
+                    openLine: line,
+                    marker,
+                    indent,
+                };
+            }
+            else if (open.markerChar === markerChar &&
+                markerLen >= open.markerLen) {
+                const end = lineEnd;
+                spans.push({
+                    start: open.start,
+                    end,
+                    openLine: open.openLine,
+                    marker: open.marker,
+                    indent: open.indent,
+                });
+                open = undefined;
+            }
+        }
+        if (nextNewline === -1) {
+            break;
+        }
+        offset = nextNewline + 1;
+    }
+    if (open) {
+        spans.push({
+            start: open.start,
+            end: buffer.length,
+            openLine: open.openLine,
+            marker: open.marker,
+            indent: open.indent,
+        });
+    }
+    return spans;
+}
+/**
+ * Find the fence span that contains a given index.
+ *
+ * @param spans - Array of fence spans to search
+ * @param index - Position to check
+ * @returns The fence span containing the index, or undefined
+ */
+export function findFenceSpanAt(spans, index) {
+    return spans.find((span) => index > span.start && index < span.end);
+}
+/**
+ * Check if it's safe to break text at a given index (not inside a fence).
+ *
+ * @param spans - Array of fence spans
+ * @param index - Position to check
+ * @returns True if safe to break (not inside a fence)
+ */
+export function isSafeFenceBreak(spans, index) {
+    return !findFenceSpanAt(spans, index);
+}

package/packages/typescript/src/markdown/frontmatter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * YAML frontmatter parsing for markdown files.
+ *
+ * Supports both YAML and simple line-based key: value formats.
+ *
+ * @module markdown/frontmatter
+ */
+/**
+ * Parsed frontmatter as key-value pairs.
+ * Values are always coerced to strings.
+ */
+export type ParsedFrontmatter = Record<string, string>;
+/**
+ * Parse frontmatter from markdown content.
+ *
+ * Extracts the YAML frontmatter block between --- delimiters.
+ * Falls back to line-based parsing if YAML parsing fails.
+ * Merges both results, preferring JSON-like values from line parsing.
+ *
+ * @param content - The markdown content
+ * @returns Parsed frontmatter as key-value pairs
+ */
+export declare function parseFrontmatterBlock(content: string): ParsedFrontmatter;
+//# sourceMappingURL=frontmatter.d.ts.map

package/packages/typescript/src/markdown/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/markdown/frontmatter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAoIvD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAwBxE"}