@astryxdesign/core 0.6.1 → 0.6.2

package/dist/Markdown/parser.js

@@ -3,7 +3,8 @@
 /**
  * @file parser.ts
  * @input Markdown string
- * @output Array of MarkdownNode AST nodes; heading slug helpers
+ * @output Array of MarkdownNode AST nodes, including opt-in math; heading slug
+ *   helpers
  *   (inlineText, slugify, uniqueSlug) shared by Markdown rendering and
  *   Outline's parseOutlineFromMarkdown
  * @position Core parser; consumed by Markdown.tsx and Outline
@@ -13,6 +14,18 @@
 // Types
 // ---------------------------------------------------------------------------
 
+/** Nodes returned by default and legacy parser calls. */
+
+/** The additional inline node returned only when parsing with `math: true`. */
+
+/** Nodes returned by an explicitly math-enabled inline parse. */
+
+/** Blocks returned by default and legacy parser calls. */
+
+/** The additional block returned only when parsing with `math: true`. */
+
+/** Blocks returned by an explicitly math-enabled block parse. */
+
 /**
  * Where a block sits in the source string handed to `parseMarkdown`:
  * `source.slice(start, end)` is the block, and `end` excludes the block's
@@ -35,6 +48,14 @@
  * `ReadonlySet<string>` shape as the second argument.
  */
 
+/** Options for default and legacy parser results. */
+
+/**
+ * Options that explicitly parse `$…$` and `$$…$$` into math-enabled result
+ * unions. Keeping this separate prevents a legacy `ParseOptions` annotation
+ * from silently widening an exhaustive node switch.
+ */
+
 const EMPTY_OPTS = {
   sourceIds: undefined,
   autolink: undefined
@@ -58,6 +79,7 @@ function resolveOptions(arg) {
   return {
     sourceIds: opts.sourceIds,
     autolink: opts.autolink,
+    math: opts.math === true ? true : undefined,
     sourceRanges: opts.sourceRanges
   };
 }
@@ -83,6 +105,106 @@ const LINK_TITLE_ONLY_RE = /^ {0,3}(?:"[^"\n]*"|'[^'\n]*'|\([^()\n]*\))[ \t]*$/;
 function normalizeLinkLabel(label) {
   return label.trim().replace(/\s+/g, ' ').toLowerCase();
 }
+function stripBlockquoteMarkers(line) {
+  let content = line.endsWith('\r') ? line.slice(0, -1) : line;
+  let quoteDepth = 0;
+  while (true) {
+    const marker = /^ {0,3}> ?/.exec(content);
+    if (marker == null) {
+      return {
+        content,
+        quoteDepth
+      };
+    }
+    content = content.slice(marker[0].length);
+    quoteDepth++;
+  }
+}
+function stripExactBlockquoteDepth(line, quoteDepth) {
+  let content = line;
+  for (let depth = 0; depth < quoteDepth; depth++) {
+    const marker = /^ {0,3}> ?/.exec(content);
+    if (marker == null) {
+      return null;
+    }
+    content = content.slice(marker[0].length);
+  }
+  return content;
+}
+
+/**
+ * Recognize a standalone display-math marker at the current container boundary.
+ * A list opener carries its base indent so an indented continuation marker can
+ * close it; blockquotes must keep the same quote depth.
+ */
+function displayMathContainer(line) {
+  const outer = stripBlockquoteMarkers(line);
+  const listMarker = /^( {0,9})(?:[-*+]|\d+[.)]) +(.*)$/.exec(outer.content);
+  if (listMarker != null) {
+    const taskMarker = /^\[[ xX]\] +(.*)$/.exec(listMarker[2]);
+    const inner = stripBlockquoteMarkers(taskMarker?.[1] ?? listMarker[2]);
+    return inner.content.trim() === '$$' ? {
+      outerQuoteDepth: outer.quoteDepth,
+      listBaseIndent: listMarker[1].length,
+      innerQuoteDepth: inner.quoteDepth
+    } : null;
+  }
+  return outer.content.trim() === '$$' ? {
+    outerQuoteDepth: outer.quoteDepth,
+    listBaseIndent: null,
+    innerQuoteDepth: 0
+  } : null;
+}
+function displayMathLineState(line, container) {
+  const outerContent = stripExactBlockquoteDepth(line, container.outerQuoteDepth);
+  if (outerContent == null) {
+    return 'outside';
+  }
+  if (container.listBaseIndent == null) {
+    // A deeper quote starts a different container. It cannot close or continue
+    // the math expression owned by the shallower quote.
+    if (/^ {0,3}> ?/.test(outerContent)) {
+      return 'outside';
+    }
+    return outerContent.trim() === '$$' ? 'close' : 'inside';
+  }
+  const continuationIndent = outerContent.length - outerContent.trimStart().length;
+  if (continuationIndent <= container.listBaseIndent) {
+    return 'outside';
+  }
+  const innerContent = stripExactBlockquoteDepth(outerContent.trimStart(), container.innerQuoteDepth);
+  if (innerContent == null || /^ {0,3}> ?/.test(innerContent)) {
+    return 'outside';
+  }
+  return innerContent.trim() === '$$' ? 'close' : 'inside';
+}
+
+/** Match a complete `$$…$$` display-math block without consuming partial input. */
+function matchDisplayMathBlock(lines, lineIndex) {
+  const trimmed = lines[lineIndex].trim();
+  if (trimmed.length > 4 && trimmed.startsWith('$$') && trimmed.endsWith('$$')) {
+    const value = trimmed.slice(2, -2);
+    return value.trim() === '' ? null : {
+      value,
+      nextIndex: lineIndex + 1,
+      endLine: lineIndex
+    };
+  }
+  if (trimmed !== '$$') {
+    return null;
+  }
+  for (let index = lineIndex + 1; index < lines.length; index++) {
+    if (lines[index].trim() === '$$') {
+      const value = lines.slice(lineIndex + 1, index).join('\n');
+      return value.trim() === '' ? null : {
+        value,
+        nextIndex: index + 1,
+        endLine: index
+      };
+    }
+  }
+  return null;
+}
 function matchLinkDefinition(line) {
   const match = LINK_DEFINITION_RE.exec(line);
   if (match == null) {
@@ -121,7 +243,7 @@ function matchLinkDefinition(line) {
  * where every definition is global. Separating a footer definition block with
  * a blank line — the usual form — always works.
  */
-function extractLinkDefinitions(input) {
+function extractLinkDefinitions(input, math = false) {
   const lines = input.split('\n');
   const defs = new Map();
   const keep = new Array(lines.length).fill(true);
@@ -141,6 +263,16 @@ function extractLinkDefinitions(input) {
       }
       continue;
     }
+    if (math) {
+      const displayMath = matchDisplayMathBlock(lines, index);
+      if (displayMath != null) {
+        // Math is opaque Markdown content: definition-shaped TeX must not leak
+        // into the document-wide link-definition map.
+        index = displayMath.endLine;
+        atBoundary = true;
+        continue;
+      }
+    }
     const fenceMatch = line.match(/^(`{3,}|~{3,})/);
     if (fenceMatch) {
       inFence = true;
@@ -324,6 +456,49 @@ function isWordChar(ch) {
   return /\w/.test(ch);
 }
 
+/** True when the character at `index` is preceded by an odd backslash run. */
+function isEscaped(text, index) {
+  let backslashes = 0;
+  for (let i = index - 1; i >= 0 && text[i] === '\\'; i--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 1;
+}
+
+/**
+ * Find the closing delimiter for `$…$` math on the same line.
+ *
+ * The whitespace and numeric-edge rules mirror common dollar-math parsers:
+ * whitespace cannot hug the delimiters, a digit cannot sit immediately before
+ * the opener or after the closer, and `$$` is reserved for display math. The
+ * numeric guard prevents ordinary prose such as "$20 and $30" from becoming a
+ * formula even in a math-enabled document.
+ */
+function isInlineMathStart(text, index) {
+  return text[index] === '$' && text[index - 1] !== '$' && text[index + 1] !== '$' && text[index + 1] != null && !/\s/.test(text[index + 1]) && !/\d/.test(text[index - 1] ?? '') && !isEscaped(text, index);
+}
+function findInlineMathEnd(text, start) {
+  if (!isInlineMathStart(text, start)) {
+    return -1;
+  }
+  for (let index = start + 1; index < text.length; index++) {
+    if (text[index] === '\n') {
+      return -1;
+    }
+    if (text[index] !== '$' || isEscaped(text, index)) {
+      continue;
+    }
+    // An unescaped dollar ends this candidate: it either forms a valid closer
+    // or makes the whole span literal. Never skip over one and pair with a
+    // later dollar, which would swallow currency or another expression.
+    if (text[index - 1] === '$' || text[index + 1] === '$' || /\s/.test(text[index - 1]) || /\d/.test(text[index + 1] ?? '')) {
+      return -1;
+    }
+    return index;
+  }
+  return -1;
+}
+
 // ---------------------------------------------------------------------------
 // URL scheme sanitization
 // ---------------------------------------------------------------------------
@@ -406,7 +581,7 @@ export function parseInline(text, arg) {
  * wrapper and call `parseInlineImpl` directly so the transform runs only on
  * the outermost block's inline tree — letting `transformAutolinks` decide
  * which subtrees to descend into (text, bold, italic, strikethrough) and
- * which to skip (link, code, image, citation, break).
+ * which to skip (link, code, math, image, citation, break).
  */
 function parseInlineEntry(text, opts) {
   const nodes = parseInlineImpl(text, opts);
@@ -441,6 +616,19 @@ function parseInlineImpl(text, opts) {
       }
     }
 
+    // --- Inline math (opt-in; code takes precedence) ---
+    if (opts.math && text[i] === '$') {
+      const closeIndex = findInlineMathEnd(text, i);
+      if (closeIndex !== -1) {
+        nodes.push({
+          type: 'math',
+          value: text.slice(i + 1, closeIndex)
+        });
+        i = closeIndex + 1;
+        continue;
+      }
+    }
+
     // --- Citation: fullwidth 【id】 ---
     {
       const citation = matchFullwidthCitation(text, i, opts);
@@ -613,7 +801,7 @@ function parseInlineImpl(text, opts) {
 
     // --- Plain text (with line-break detection) ---
     let end = i + 1;
-    while (end < text.length && !'*_~`[!\\\n\u3010'.includes(text[end])) {
+    while (end < text.length && !'*_~`[!\\\n\u3010'.includes(text[end]) && !(opts.math && text[end] === '$')) {
       end++;
     }
     const content = text.slice(i, end);
@@ -1195,7 +1383,7 @@ function parseMarkdownImpl(input, baseOpts) {
     defs,
     cleaned,
     lineMap
-  } = extractLinkDefinitions(input);
+  } = extractLinkDefinitions(input, baseOpts.math);
   const inherited = baseOpts.linkDefs;
   let linkDefs;
   if (defs.size === 0) {
@@ -1256,6 +1444,19 @@ function parseMarkdownImpl(input, baseOpts) {
       continue;
     }
 
+    // --- Display math (opt-in; fenced code takes precedence) ---
+    if (opts.math) {
+      const displayMath = matchDisplayMathBlock(lines, index);
+      if (displayMath != null) {
+        pushBlock({
+          type: 'math',
+          value: displayMath.value
+        }, displayMath.endLine);
+        index = displayMath.nextIndex;
+        continue;
+      }
+    }
+
     // --- Heading ---
     const headingMatch = line.match(/^(#{1,6}) +(.*)/);
     if (headingMatch) {
@@ -1332,7 +1533,7 @@ function parseMarkdownImpl(input, baseOpts) {
     // --- Paragraph ---
     const paraLines = [line];
     index++;
-    while (index < lines.length && !isBlockStart(lines[index]) && lines[index].trim() !== '') {
+    while (index < lines.length && !isBlockStart(lines[index]) && !(opts.math && matchDisplayMathBlock(lines, index) != null) && lines[index].trim() !== '') {
       paraLines.push(lines[index]);
       index++;
     }
@@ -1401,7 +1602,7 @@ const incrementalCaches = new WeakMap();
 function makeIncrementalCache(state) {
   const {
     defs
-  } = extractLinkDefinitions(state.settledText);
+  } = extractLinkDefinitions(state.settledText, state.math);
   const cache = {
     settledEnd: state.settledText.length,
     settledLinkDefs: new Map(defs),
@@ -1418,6 +1619,11 @@ function makeIncrementalCache(state) {
   incrementalCaches.set(state, cache);
   return cache;
 }
+
+/**
+ * Create an incremental parser cache. Use the `<true>` type argument with
+ * `MathParseOptions` so the cache and returned nodes share the math contract.
+ */
 export function createIncrementalState() {
   const state = {
     prevInput: '',
@@ -1456,33 +1662,70 @@ export function getIncrementalParseWork(state) {
  * the boundary to -1 even though the content before the fence opened cannot be
  * changed by anything typed inside it.
  */
-function findSettledBoundary(lines) {
+function findSettledBoundary(lines, math = false) {
   let inFence = false;
   let fenceMarker = '';
+  let mathContainer = null;
+  let suppressMathUntilBoundary = false;
   let lastBoundary = -1;
   let boundaryBeforeFence = -1;
+  let boundaryBeforeMath = -1;
   for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
     const line = lines[lineIndex];
-
-    // Fence open / close — match the specific marker character and length
-    const fenceMatch = line.match(/^(`{3,}|~{3,})/);
-    if (fenceMatch) {
-      if (!inFence) {
-        inFence = true;
-        fenceMarker = fenceMatch[1];
-        boundaryBeforeFence = lastBoundary;
-      } else if (fenceMatch[1].startsWith(fenceMarker[0]) && fenceMatch[1].length >= fenceMarker.length) {
+    if (inFence) {
+      const fenceMatch = line.match(/^(`{3,}|~{3,})/);
+      if (fenceMatch && fenceMatch[1].startsWith(fenceMarker[0]) && fenceMatch[1].length >= fenceMarker.length) {
         inFence = false;
         fenceMarker = '';
       }
+      continue;
     }
-    if (!inFence && line.trim() === '' && lineIndex > 0 && lineIndex < lines.length - 1) {
-      lastBoundary = lineIndex;
+    if (mathContainer != null) {
+      const state = displayMathLineState(line, mathContainer);
+      if (state === 'close') {
+        mathContainer = null;
+        continue;
+      }
+      if (state === 'inside') {
+        continue;
+      }
+      // The list item or blockquote ended before a closer arrived. The parser
+      // treats that unmatched opener literally, so resume ordinary boundary
+      // detection on this first line outside the container.
+      mathContainer = null;
+      suppressMathUntilBoundary = true;
+    }
+
+    // A complete same-line `$$…$$` expression never changes boundary state.
+    // A standalone marker may belong to the top level, a blockquote, or one
+    // list item; remember that container so its continuation marker closes the
+    // same expression instead of opening a new one.
+    if (math && !suppressMathUntilBoundary) {
+      const container = displayMathContainer(line);
+      if (container != null) {
+        mathContainer = container;
+        boundaryBeforeMath = lastBoundary;
+        continue;
+      }
+    }
+    const fenceMatch = line.match(/^(`{3,}|~{3,})/);
+    if (fenceMatch) {
+      inFence = true;
+      fenceMarker = fenceMatch[1];
+      boundaryBeforeFence = lastBoundary;
+      continue;
+    }
+    if (line.trim() === '') {
+      suppressMathUntilBoundary = false;
+      if (lineIndex > 0 && lineIndex < lines.length - 1) {
+        lastBoundary = lineIndex;
+      }
     }
   }
   return {
-    boundary: inFence ? boundaryBeforeFence : lastBoundary,
-    openFence: inFence
+    boundary: inFence ? boundaryBeforeFence : mathContainer != null ? boundaryBeforeMath : lastBoundary,
+    openFence: inFence,
+    openMath: mathContainer != null
   };
 }
 
@@ -1490,10 +1733,45 @@ function findSettledBoundary(lines) {
  * Strip trailing incomplete inline syntax that appears during streaming.
  * Only affects the tail of the last line — safe to apply to the full string.
  */
-export function trimStreamingArtifacts(input) {
-  const lastNL = input.lastIndexOf('\n');
-  const prefix = lastNL === -1 ? '' : input.slice(0, lastNL + 1);
-  let tail = lastNL === -1 ? input : input.slice(lastNL + 1);
+export function trimStreamingArtifacts(input, options) {
+  // First remove an incomplete display expression as one structural unit. This
+  // full-input scan distinguishes a terminal nested closer from a new opener;
+  // looking only at the final `$$` line cannot.
+  const displayTrimmed = options?.math ? trimOpenDisplayMath(input) : input;
+  const lastNL = displayTrimmed.lastIndexOf('\n');
+  const prefix = lastNL === -1 ? '' : displayTrimmed.slice(0, lastNL + 1);
+  let tail = lastNL === -1 ? displayTrimmed : displayTrimmed.slice(lastNL + 1);
+  if (options?.math) {
+    // Hold an unmatched inline opener so raw TeX syntax does not flash while
+    // streaming. If another unescaped dollar is already present but fails the
+    // closing-boundary rule, keep both literal (the currency case).
+    for (let index = 0; index < tail.length; index++) {
+      if (tail[index] === '$' && tail[index + 1] == null && tail[index - 1] !== '$' && !/\d/.test(tail[index - 1] ?? '') && !isEscaped(tail, index)) {
+        tail = tail.slice(0, index);
+        break;
+      }
+      if (!isInlineMathStart(tail, index)) {
+        continue;
+      }
+      const close = findInlineMathEnd(tail, index);
+      if (close !== -1) {
+        index = close;
+        continue;
+      }
+      let laterDollar = -1;
+      for (let next = index + 1; next < tail.length; next++) {
+        if (tail[next] === '$' && !isEscaped(tail, next)) {
+          laterDollar = next;
+          break;
+        }
+      }
+      if (laterDollar === -1) {
+        tail = tail.slice(0, index);
+        break;
+      }
+      index = laterDollar;
+    }
+  }
 
   // Scan backwards for unclosed syntax markers — no regex to avoid ReDoS
   // Find the last unclosed [ or ![ (link/image start)
@@ -1650,6 +1928,54 @@ export function trimStreamingArtifacts(input) {
  * Once a table is established (header + separator exist), new data rows
  * render immediately — no suppression.
  */
+function trimOpenDisplayMath(text) {
+  const lines = text.split('\n');
+  let inFence = false;
+  let fenceMarker = '';
+  let mathContainer = null;
+  let suppressMathUntilBoundary = false;
+  let mathStartLine = -1;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (inFence) {
+      const fence = line.match(/^(`{3,}|~{3,})/);
+      if (fence != null && fence[1].startsWith(fenceMarker[0]) && fence[1].length >= fenceMarker.length) {
+        inFence = false;
+        fenceMarker = '';
+      }
+      continue;
+    }
+    if (mathContainer != null) {
+      const state = displayMathLineState(line, mathContainer);
+      if (state === 'close') {
+        mathContainer = null;
+        mathStartLine = -1;
+        continue;
+      }
+      if (state === 'inside') {
+        continue;
+      }
+      mathContainer = null;
+      mathStartLine = -1;
+      suppressMathUntilBoundary = true;
+    }
+    if (line.trim() === '') {
+      suppressMathUntilBoundary = false;
+    }
+    const fence = line.match(/^(`{3,}|~{3,})/);
+    if (fence != null) {
+      inFence = true;
+      fenceMarker = fence[1];
+      continue;
+    }
+    const container = suppressMathUntilBoundary ? null : displayMathContainer(line);
+    if (container != null) {
+      mathContainer = container;
+      mathStartLine = index;
+    }
+  }
+  return mathContainer != null && mathStartLine >= 0 ? lines.slice(0, mathStartLine).join('\n').trimEnd() : text;
+}
 function trimUnsettledStructural(text) {
   const lines = text.split('\n');
 
@@ -1806,6 +2132,7 @@ function resetIncrementalCache(state, cache) {
   state.settledBlocks = [];
   state.settledUpTo = 0;
   state.linkDefsKey = undefined;
+  state.math = undefined;
   cache.settledEnd = 0;
   cache.settledLinkDefs.clear();
   cache.tailLinkDefs = new Map();
@@ -1836,12 +2163,13 @@ export function parseMarkdownIncremental(input, state, arg) {
   const cache = incrementalCaches.get(state) ?? makeIncrementalCache(state);
   let reparseSettled = false;
 
-  // Invalidate cache when the autolink or sourceRanges option flips — cached
+  // Invalidate cache when an option that changes parsed nodes flips — cached
   // settled blocks were parsed with the previous setting and would otherwise
   // be reused unchanged.
-  if (state.autolink !== opts.autolink || Boolean(state.sourceRanges) !== Boolean(opts.sourceRanges)) {
+  if (state.autolink !== opts.autolink || state.math !== opts.math || Boolean(state.sourceRanges) !== Boolean(opts.sourceRanges)) {
     reparseSettled = true;
     state.autolink = opts.autolink;
+    state.math = opts.math;
     state.sourceRanges = opts.sourceRanges;
   }
   if (input === '') {
@@ -1860,6 +2188,7 @@ export function parseMarkdownIncremental(input, state, arg) {
   if (state.settledText.length !== cache.settledEnd || !input.startsWith(state.settledText)) {
     resetIncrementalCache(state, cache);
     state.autolink = opts.autolink;
+    state.math = opts.math;
     state.sourceRanges = opts.sourceRanges;
   }
 
@@ -1871,8 +2200,9 @@ export function parseMarkdownIncremental(input, state, arg) {
   const tailLines = tailRaw.split('\n');
   const {
     boundary,
-    openFence
-  } = findSettledBoundary(tailLines);
+    openFence,
+    openMath
+  } = findSettledBoundary(tailLines, opts.math);
   const settledDelta = boundary >= 0 ? tailLines.slice(0, boundary).join('\n') : '';
   const nextSettledEnd = oldSettledEnd + settledDelta.length;
   const unsettledInput = input.slice(nextSettledEnd);
@@ -1885,7 +2215,7 @@ export function parseMarkdownIncremental(input, state, arg) {
   if (settledDelta !== '') {
     const {
       defs: deltaDefs
-    } = extractLinkDefinitions(settledDelta);
+    } = extractLinkDefinitions(settledDelta, opts.math);
     for (const [label, destination] of deltaDefs) {
       if (!cache.settledLinkDefs.has(label)) {
         cache.settledLinkDefs.set(label, destination);
@@ -1897,7 +2227,7 @@ export function parseMarkdownIncremental(input, state, arg) {
   }
   const {
     defs: tailLinkDefs
-  } = extractLinkDefinitions(unsettledInput);
+  } = extractLinkDefinitions(unsettledInput, opts.math);
   if (!sameUnsettledDefinitions(cache.tailLinkDefs, tailLinkDefs, cache.settledLinkDefs)) {
     definitionsChanged = true;
   }
@@ -1921,11 +2251,15 @@ export function parseMarkdownIncremental(input, state, arg) {
     }
     cache.settledEnd = nextSettledEnd;
   }
-  const unsettledRaw = unsettledInput.trim();
+  const trimmedUnsettledInput = unsettledInput.trim();
+  // String#trim removes the CR that belongs to the final content line of a
+  // CRLF snapshot along with trailing blank lines. Keep that one byte so
+  // source ranges and delimiter content remain identical to a full parse.
+  const unsettledRaw = trimmedUnsettledInput !== '' && /\r(?:\n[\s]*)?$/.test(unsettledInput) ? `${trimmedUnsettledInput}\r` : trimmedUnsettledInput;
   // Structural trimming holds back lines that look like an incomplete list or
   // table, which inside a fence is ordinary code: a TypeScript union or a `- `
   // would disappear from the code block as it streams.
-  const unsettledText = openFence ? unsettledRaw : trimUnsettledStructural(unsettledRaw);
+  const unsettledText = openFence ? unsettledRaw : openMath ? trimOpenDisplayMath(unsettledRaw) : trimUnsettledStructural(unsettledRaw);
   let parsedSettledBlocks = 0;
   if (reparseSettled) {
     state.settledBlocks = state.settledText ? parseMarkdownImpl(state.settledText, parseOpts) : [];
@@ -1973,7 +2307,8 @@ export function inlineText(nodes) {
     switch (node.type) {
       case 'text':
       case 'code':
-        return node.content;
+      case 'math':
+        return node.type === 'math' ? node.value : node.content;
       case 'bold':
       case 'italic':
       case 'strikethrough':

package/dist/Markdown/utils.d.ts

@@ -4,5 +4,5 @@
  * @position Subpath entry point: `@astryxdesign/core/Markdown/utils`
  */
 export { parseMarkdown, parseInline, parseMarkdownIncremental, createIncrementalState, trimStreamingArtifacts, } from './parser';
-export type { InlineNode, BlockNode, ListItemNode, TableCellNode, TableAlignment, IncrementalState, } from './parser';
+export type { InlineNode, InlineNodeWithMath, MathInlineNode, BlockNode, BlockNodeWithMath, MathBlockNode, ListItemNode, TableCellNode, TableAlignment, ParseOptions, MathParseOptions, IncrementalState, } from './parser';
 //# sourceMappingURL=utils.d.ts.map

package/dist/Markdown/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/Markdown/utils.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,EACL,aAAa,EACb,WAAW,EACX,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,UAAU,EACV,SAAS,EACT,YAAY,EACZ,aAAa,EACb,cAAc,EACd,gBAAgB,GACjB,MAAM,UAAU,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/Markdown/utils.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,EACL,aAAa,EACb,WAAW,EACX,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,cAAc,EACd,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,UAAU,CAAC"}

package/dist/Slider/Slider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Slider.d.ts","sourceRoot":"","sources":["../../src/Slider/Slider.tsx"],"names":[],"mappings":"AA0CA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAQhD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAQ9C,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAC3C,SAAS,CAAC,cAAc,CAAC,EACzB,UAAU,CACX;IACC,wCAAwC;IACxC,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAChC,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,8FAA8F;IAC9F,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oDAAoD;IACpD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,uCAAuC;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,WAAW,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;IACxC,uEAAuE;IACvE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACxC,6DAA6D;IAC7D,YAAY,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;IAC3C,8DAA8D;IAC9D,KAAK,CAAC,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,EAAE,CAAC;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,iEAAiE;IACjE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,8CAA8C;IAC9C,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IAC7C,iEAAiE;IACjE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IAChD,8CAA8C;IAC9C,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,MAAM,WAAW,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAoS/D;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,EAAC,GAAG,EAAE,GAAG,KAAK,EAAC,EAAE,WAAW,+BAsqBlD;yBAtqBe,MAAM"}
+{"version":3,"file":"Slider.d.ts","sourceRoot":"","sources":["../../src/Slider/Slider.tsx"],"names":[],"mappings":"AA0CA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAQhD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAQ9C,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAC3C,SAAS,CAAC,cAAc,CAAC,EACzB,UAAU,CACX;IACC,wCAAwC;IACxC,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAChC,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,8FAA8F;IAC9F,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oDAAoD;IACpD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,uCAAuC;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,WAAW,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;IACxC,uEAAuE;IACvE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACxC,6DAA6D;IAC7D,YAAY,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;IAC3C,8DAA8D;IAC9D,KAAK,CAAC,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,EAAE,CAAC;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,iEAAiE;IACjE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,8CAA8C;IAC9C,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IAC7C,iEAAiE;IACjE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IAChD,8CAA8C;IAC9C,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,MAAM,WAAW,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAoS/D;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,EAAC,GAAG,EAAE,GAAG,KAAK,EAAC,EAAE,WAAW,+BA4qBlD;yBA5qBe,MAAM"}

package/dist/Slider/Slider.js

@@ -660,7 +660,10 @@ export function Slider({
         onPointerMove: handlePointerMove,
         onPointerUp: handlePointerUp,
         onPointerCancel: handlePointerUp,
-        ...{
+        ...mergeProps(themeProps('slider-control', {
+          orientation,
+          disabled: isDisabled ? 'disabled' : null
+        }), {
           0: {
             className: "x1n2onr6 x78zum5 x6s0dn4 x1iyjqo2 x5ve5x3 x87ps6o xc8icb0 xw4jnvo x1ymw6g xkagaj0 xdt5ytf xl56j7k x1ypdohk x16khyan"
           },
@@ -673,7 +676,7 @@ export function Slider({
           3: {
             className: "x1n2onr6 x78zum5 x6s0dn4 x1iyjqo2 x5ve5x3 x87ps6o xc8icb0 x1qx5ct2 x80b3aj xh8yej3 xbyyjgo xt0e3qv"
           }
-        }[!!isHorizontal << 1 | !!isDisabled << 0],
+        }[!!isHorizontal << 1 | !!isDisabled << 0]),
         children: [/*#__PURE__*/_jsx("div", {
           "aria-hidden": "true",
           ...mergeProps(themeProps('slider-track', {

package/dist/Spinner/Spinner.d.ts

@@ -1,6 +1,6 @@
 /**
  * @file Spinner.tsx
- * @input Uses React, StyleX, SVG rendering
+ * @input Uses React, i18n (useTranslator), StyleX, SVG rendering
  * @output Exports Spinner component, SpinnerProps, SpinnerSize, SpinnerShade types
  * @position Core implementation of spinner loading indicator
  *

package/dist/Spinner/Spinner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Spinner.d.ts","sourceRoot":"","sources":["../../src/Spinner/Spinner.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAQ,KAAK,SAAS,EAAC,MAAM,OAAO,CAAC;AAG5C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAyB5C,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;CAKV,CAAC;AA+VF,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,KAAK,CAAC;AAE7C,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExE,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,eAAe,CAAC;IAC9D,wCAAwC;IACxC,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IACjC;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,EACtB,IAAW,EACX,KAAiB,EACjB,KAAK,EACL,MAAM,EACN,SAAS,EACT,KAAK,EACL,YAAY,EAAE,SAAS,EACvB,aAAa,EAAE,MAAM,EACrB,GAAG,EACH,GAAG,SAAS,EACb,EAAE,YAAY,+BAoHd;yBA/He,OAAO"}
+{"version":3,"file":"Spinner.d.ts","sourceRoot":"","sources":["../../src/Spinner/Spinner.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAQ,KAAK,SAAS,EAAC,MAAM,OAAO,CAAC;AAG5C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAuB5C,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;CAKV,CAAC;AA6WF,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,KAAK,CAAC;AAE7C,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAExE,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,eAAe,CAAC;IAC9D,wCAAwC;IACxC,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IACjC;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,EACtB,IAAW,EACX,KAAiB,EACjB,KAAK,EACL,MAAM,EACN,SAAS,EACT,KAAK,EACL,YAAY,EAAE,SAAS,EACvB,aAAa,EAAE,MAAM,EACrB,GAAG,EACH,GAAG,SAAS,EACb,EAAE,YAAY,+BAyHd;yBApIe,OAAO"}