@owomark/core 0.1.4 → 0.1.6

package/dist/{chunk-TRLKIMRD.js → chunk-6CBUAORJ.js}

@@ -11,185 +11,233 @@ import {
 } from "./chunk-MPIWZLI3.js";
 
 // src/parser/inline-tokens.ts
-function overlaps(segs, start, end) {
-  return segs.some((s) => start < s.end && end > s.start);
-}
+var HTML_TAG_RE = /<\/?[A-Za-z][\w:-]*(?:\s+[A-Za-z_:][\w:.-]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*\s*\/?>/y;
 function tok(type, text, start) {
   return { type, text, start, end: start + text.length };
 }
 function isEscaped(raw, index) {
   let backslashCount = 0;
-  for (let cursor = index - 1; cursor >= 0 && raw[cursor] === "\\"; cursor--) {
+  for (let cursor = index - 1; cursor >= 0 && raw[cursor] === "\\"; cursor -= 1) {
     backslashCount += 1;
   }
   return backslashCount % 2 === 1;
 }
-function findInlineMathRanges(raw) {
-  const ranges = [];
-  for (let start = 0; start < raw.length; start++) {
-    if (raw[start] !== "$" || isEscaped(raw, start)) continue;
-    if (raw[start + 1] === "$") {
-      start += 1;
-      continue;
-    }
-    for (let end = start + 1; end < raw.length; end++) {
-      if (raw[end] !== "$" || isEscaped(raw, end)) continue;
-      if (raw[end - 1] === "$" || raw[end + 1] === "$") continue;
-      ranges.push({ start, end: end + 1 });
-      start = end;
-      break;
-    }
+function isAsciiWordChar(value) {
+  return value != null && /[A-Za-z0-9]/.test(value);
+}
+function countRun(raw, start, char) {
+  let length = 0;
+  while (raw[start + length] === char) {
+    length += 1;
   }
-  return ranges;
+  return length;
 }
-function tokenizeInline(raw, baseOffset = 0) {
-  if (!raw) return [{ type: "text", text: "", start: baseOffset, end: baseOffset }];
-  const segs = [];
-  for (const m of raw.matchAll(/`([^`]+)`/g)) {
-    const s = m.index;
-    segs.push({
-      start: s,
-      end: s + m[0].length,
-      tokens: [
-        tok("code-marker", "`", baseOffset + s),
-        tok("code", m[1], baseOffset + s + 1),
-        tok("code-marker", "`", baseOffset + s + m[0].length - 1)
-      ]
-    });
+function findClosingDelimiter(raw, from, delimiter) {
+  for (let index = from; index <= raw.length - delimiter.length; index += 1) {
+    if (raw.slice(index, index + delimiter.length) !== delimiter) continue;
+    if (isEscaped(raw, index)) continue;
+    return index;
   }
-  for (const m of raw.matchAll(/!\[([^\]]*)\]\(([^)]*)\)/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      const tokens = [];
-      let pos2 = s;
-      tokens.push(tok("image-marker", "![", baseOffset + pos2));
-      pos2 += 2;
-      tokens.push(tok("image-alt", m[1], baseOffset + pos2));
-      pos2 += m[1].length;
-      tokens.push(tok("link-bracket", "](", baseOffset + pos2));
-      pos2 += 2;
-      tokens.push(tok("image-url", m[2], baseOffset + pos2));
-      pos2 += m[2].length;
-      tokens.push(tok("link-bracket", ")", baseOffset + pos2));
-      segs.push({ start: s, end: s + m[0].length, tokens });
-    }
-  }
-  for (const m of raw.matchAll(/\[([^\]]*)\]\(([^)]*)\)/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      const tokens = [];
-      let pos2 = s;
-      tokens.push(tok("link-bracket", "[", baseOffset + pos2));
-      pos2 += 1;
-      tokens.push(tok("link-text", m[1], baseOffset + pos2));
-      pos2 += m[1].length;
-      tokens.push(tok("link-bracket", "](", baseOffset + pos2));
-      pos2 += 2;
-      tokens.push(tok("link-url", m[2], baseOffset + pos2));
-      pos2 += m[2].length;
-      tokens.push(tok("link-bracket", ")", baseOffset + pos2));
-      segs.push({ start: s, end: s + m[0].length, tokens });
-    }
-  }
-  for (const m of raw.matchAll(/~~(.+?)~~/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("strikethrough-marker", "~~", baseOffset + s),
-          tok("strikethrough", m[1], baseOffset + s + 2),
-          tok("strikethrough-marker", "~~", baseOffset + s + m[0].length - 2)
-        ]
-      });
+  return -1;
+}
+function findClosingCodeDelimiter(raw, from, delimiterLength) {
+  for (let index = from; index < raw.length; index += 1) {
+    if (raw[index] !== "`" || isEscaped(raw, index)) continue;
+    const runLength = countRun(raw, index, "`");
+    if (runLength === delimiterLength) {
+      return index;
     }
+    index += runLength - 1;
   }
-  for (const range of findInlineMathRanges(raw)) {
-    if (!overlaps(segs, range.start, range.end)) {
-      const innerStart = range.start + 1;
-      const innerEnd = range.end - 1;
-      segs.push({
-        start: range.start,
-        end: range.end,
-        tokens: [
-          tok("math-marker", "$", baseOffset + range.start),
-          tok("math-text", raw.slice(innerStart, innerEnd), baseOffset + innerStart),
-          tok("math-marker", "$", baseOffset + innerEnd)
-        ]
-      });
-    }
+  return -1;
+}
+function matchCodeSpan(raw, index, baseOffset) {
+  if (raw[index] !== "`") return null;
+  const delimiterLength = countRun(raw, index, "`");
+  const delimiter = "`".repeat(delimiterLength);
+  const closeIndex = findClosingCodeDelimiter(raw, index + delimiterLength, delimiterLength);
+  if (closeIndex === -1 || closeIndex === index + delimiterLength) {
+    return null;
   }
-  for (const m of raw.matchAll(/\*\*(.+?)\*\*/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("strong-marker", "**", baseOffset + s),
-          tok("strong", m[1], baseOffset + s + 2),
-          tok("strong-marker", "**", baseOffset + s + m[0].length - 2)
-        ]
-      });
+  const innerStart = index + delimiterLength;
+  const innerText = raw.slice(innerStart, closeIndex);
+  return {
+    end: closeIndex + delimiterLength,
+    tokens: [
+      tok("code-marker", delimiter, baseOffset + index),
+      tok("code", innerText, baseOffset + innerStart),
+      tok("code-marker", delimiter, baseOffset + closeIndex)
+    ]
+  };
+}
+function findClosingBracket(raw, from) {
+  for (let index = from; index < raw.length; index += 1) {
+    if (raw[index] === "]" && !isEscaped(raw, index)) {
+      return index;
     }
   }
-  for (const m of raw.matchAll(/(?<![a-zA-Z0-9])__(.+?)__(?![a-zA-Z0-9])/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("strong-marker", "__", baseOffset + s),
-          tok("strong", m[1], baseOffset + s + 2),
-          tok("strong-marker", "__", baseOffset + s + m[0].length - 2)
-        ]
-      });
+  return -1;
+}
+function findClosingParen(raw, from) {
+  for (let index = from; index < raw.length; index += 1) {
+    if (raw[index] === ")" && !isEscaped(raw, index)) {
+      return index;
     }
   }
-  for (const m of raw.matchAll(/(?<!\*)\*([^*]+)\*(?!\*)/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("emphasis-marker", "*", baseOffset + s),
-          tok("emphasis", m[1], baseOffset + s + 1),
-          tok("emphasis-marker", "*", baseOffset + s + m[0].length - 1)
-        ]
-      });
+  return -1;
+}
+function matchLinkLike(raw, index, baseOffset, image2) {
+  const marker = image2 ? "![" : "[";
+  if (!raw.startsWith(marker, index)) return null;
+  const labelStart = index + marker.length;
+  const labelEnd = findClosingBracket(raw, labelStart);
+  if (labelEnd === -1 || raw[labelEnd + 1] !== "(") return null;
+  const urlStart = labelEnd + 2;
+  const urlEnd = findClosingParen(raw, urlStart);
+  if (urlEnd === -1) return null;
+  const label = raw.slice(labelStart, labelEnd);
+  const url = raw.slice(urlStart, urlEnd);
+  const tokens = [];
+  let cursor = index;
+  if (image2) {
+    tokens.push(tok("image-marker", "![", baseOffset + cursor));
+    cursor += 2;
+    tokens.push(tok("image-alt", label, baseOffset + cursor));
+    cursor += label.length;
+    tokens.push(tok("link-bracket", "](", baseOffset + cursor));
+    cursor += 2;
+    tokens.push(tok("image-url", url, baseOffset + cursor));
+    cursor += url.length;
+    tokens.push(tok("link-bracket", ")", baseOffset + cursor));
+  } else {
+    tokens.push(tok("link-bracket", "[", baseOffset + cursor));
+    cursor += 1;
+    tokens.push(tok("link-text", label, baseOffset + cursor));
+    cursor += label.length;
+    tokens.push(tok("link-bracket", "](", baseOffset + cursor));
+    cursor += 2;
+    tokens.push(tok("link-url", url, baseOffset + cursor));
+    cursor += url.length;
+    tokens.push(tok("link-bracket", ")", baseOffset + cursor));
+  }
+  return {
+    end: urlEnd + 1,
+    tokens
+  };
+}
+function matchDelimitedRange(raw, index, baseOffset, delimiter, markerType, contentType) {
+  if (!raw.startsWith(delimiter, index) || isEscaped(raw, index)) return null;
+  const contentStart = index + delimiter.length;
+  const closeIndex = findClosingDelimiter(raw, contentStart, delimiter);
+  if (closeIndex === -1 || closeIndex === contentStart) return null;
+  return {
+    end: closeIndex + delimiter.length,
+    tokens: [
+      tok(markerType, delimiter, baseOffset + index),
+      tok(contentType, raw.slice(contentStart, closeIndex), baseOffset + contentStart),
+      tok(markerType, delimiter, baseOffset + closeIndex)
+    ]
+  };
+}
+function matchInlineMath(raw, index, baseOffset) {
+  if (raw[index] !== "$" || isEscaped(raw, index)) return null;
+  if (raw[index + 1] === "$") return null;
+  for (let cursor = index + 1; cursor < raw.length; cursor += 1) {
+    if (raw[cursor] !== "$" || isEscaped(raw, cursor)) continue;
+    if (raw[cursor - 1] === "$" || raw[cursor + 1] === "$") continue;
+    if (cursor === index + 1) return null;
+    return {
+      end: cursor + 1,
+      tokens: [
+        tok("math-marker", "$", baseOffset + index),
+        tok("math-text", raw.slice(index + 1, cursor), baseOffset + index + 1),
+        tok("math-marker", "$", baseOffset + cursor)
+      ]
+    };
+  }
+  return null;
+}
+function matchHtml(raw, index, baseOffset) {
+  if (raw[index] !== "<") return null;
+  HTML_TAG_RE.lastIndex = index;
+  const match = HTML_TAG_RE.exec(raw);
+  if (!match || match.index !== index) return null;
+  return {
+    end: index + match[0].length,
+    tokens: [tok("html", match[0], baseOffset + index)]
+  };
+}
+function underscoreBoundaryAllows(raw, start, end) {
+  return !isAsciiWordChar(raw[start - 1]) && !isAsciiWordChar(raw[end]);
+}
+function matchStrong(raw, index, baseOffset) {
+  if (raw.startsWith("**", index)) {
+    return matchDelimitedRange(raw, index, baseOffset, "**", "strong-marker", "strong");
+  }
+  if (!raw.startsWith("__", index)) return null;
+  const match = matchDelimitedRange(raw, index, baseOffset, "__", "strong-marker", "strong");
+  if (!match) return null;
+  if (!underscoreBoundaryAllows(raw, index, match.end)) return null;
+  return match;
+}
+function matchEmphasis(raw, index, baseOffset) {
+  if (raw[index] === "*") {
+    if (raw[index - 1] === "*" || raw[index + 1] === "*") return null;
+    return matchDelimitedRange(raw, index, baseOffset, "*", "emphasis-marker", "emphasis");
+  }
+  if (raw[index] !== "_" || raw[index + 1] === "_") return null;
+  const match = matchDelimitedRange(raw, index, baseOffset, "_", "emphasis-marker", "emphasis");
+  if (!match) return null;
+  if (!underscoreBoundaryAllows(raw, index, match.end)) return null;
+  return match;
+}
+function tryMatch(raw, index, baseOffset, customMatchers) {
+  for (const matcher of customMatchers) {
+    const match = matcher(raw, index, baseOffset);
+    if (match) {
+      return match;
     }
   }
-  for (const m of raw.matchAll(/(?<![a-zA-Z0-9])_([^_]+)_(?![a-zA-Z0-9])/g)) {
-    const s = m.index;
-    if (!overlaps(segs, s, s + m[0].length)) {
-      segs.push({
-        start: s,
-        end: s + m[0].length,
-        tokens: [
-          tok("emphasis-marker", "_", baseOffset + s),
-          tok("emphasis", m[1], baseOffset + s + 1),
-          tok("emphasis-marker", "_", baseOffset + s + m[0].length - 1)
-        ]
-      });
+  return matchCodeSpan(raw, index, baseOffset) ?? matchLinkLike(raw, index, baseOffset, true) ?? matchLinkLike(raw, index, baseOffset, false) ?? matchDelimitedRange(raw, index, baseOffset, "~~", "strikethrough-marker", "strikethrough") ?? matchInlineMath(raw, index, baseOffset) ?? matchHtml(raw, index, baseOffset) ?? matchStrong(raw, index, baseOffset) ?? matchEmphasis(raw, index, baseOffset);
+}
+function createLiteralTokenMatcher(literal, tokenType) {
+  return (raw, index, baseOffset) => {
+    if (!raw.startsWith(literal, index) || isEscaped(raw, index)) {
+      return null;
     }
+    return {
+      end: index + literal.length,
+      tokens: [tok(tokenType, literal, baseOffset + index)]
+    };
+  };
+}
+function tokenizeInlineWithMatchers(raw, baseOffset = 0, customMatchers = []) {
+  if (!raw) {
+    return [{ type: "text", text: "", start: baseOffset, end: baseOffset }];
   }
-  segs.sort((a, b) => a.start - b.start);
-  const result = [];
-  let pos = 0;
-  for (const seg of segs) {
-    if (seg.start > pos) {
-      result.push(tok("text", raw.slice(pos, seg.start), baseOffset + pos));
+  const tokens = [];
+  let textStart = 0;
+  let index = 0;
+  while (index < raw.length) {
+    const match = tryMatch(raw, index, baseOffset, customMatchers);
+    if (!match) {
+      index += 1;
+      continue;
+    }
+    if (index > textStart) {
+      tokens.push(tok("text", raw.slice(textStart, index), baseOffset + textStart));
     }
-    result.push(...seg.tokens);
-    pos = seg.end;
+    tokens.push(...match.tokens);
+    index = match.end;
+    textStart = index;
   }
-  if (pos < raw.length) {
-    result.push(tok("text", raw.slice(pos), baseOffset + pos));
+  if (textStart < raw.length) {
+    tokens.push(tok("text", raw.slice(textStart), baseOffset + textStart));
   }
-  return result;
+  return tokens;
+}
+function tokenizeInline(raw, baseOffset = 0) {
+  return tokenizeInlineWithMatchers(raw, baseOffset);
 }
 
 // src/parser/blocks.ts
@@ -229,7 +277,7 @@ function tokenizeBlock(raw, blockType, baseOffset = 0) {
   }
   if (blockType === "table") {
     return tokenizeMultiLineBlock(raw, baseOffset, (line) => {
-      return tokenizeInline(line, -1);
+      return tokenizeTableLine(line, -1);
     });
   }
   if (blockType === "thematic-break") {
@@ -251,13 +299,55 @@ function tokenizeBlock(raw, blockType, baseOffset = 0) {
   }
   const listMatch = raw.match(/^(\s*(?:[-*+]|\d+\.)\s)(.*)/);
   if (listMatch && (blockType === "unordered-list" || blockType === "ordered-list")) {
-    return [
-      { type: "list-marker", text: listMatch[1], start: baseOffset, end: baseOffset + listMatch[1].length },
-      ...tokenizeInline(listMatch[2], baseOffset + listMatch[1].length)
-    ];
+    return tokenizeListItem(listMatch[1], listMatch[2], baseOffset);
   }
   return tokenizeInline(raw, baseOffset);
 }
+function tokenizeListItem(marker, content, baseOffset) {
+  const tokens = [
+    { type: "list-marker", text: marker, start: baseOffset, end: baseOffset + marker.length }
+  ];
+  const contentOffset = baseOffset + marker.length;
+  const leadingWhitespace = content.match(/^\s+/)?.[0] ?? "";
+  const taskCandidate = content.slice(leadingWhitespace.length);
+  const taskMatch = taskCandidate.match(/^(\[(?: |x|X)\])(\s*)(.*)$/);
+  let cursor = contentOffset;
+  if (leadingWhitespace) {
+    tokens.push({
+      type: "text",
+      text: leadingWhitespace,
+      start: cursor,
+      end: cursor + leadingWhitespace.length
+    });
+    cursor += leadingWhitespace.length;
+  }
+  if (!taskMatch) {
+    tokens.push(...tokenizeInline(taskCandidate, cursor));
+    return tokens;
+  }
+  const taskTokenType = /^[xX]$/.test(taskMatch[1][1]) ? "task-marker-checked" : "task-marker";
+  tokens.push({
+    type: taskTokenType,
+    text: taskMatch[1],
+    start: cursor,
+    end: cursor + taskMatch[1].length
+  });
+  cursor += taskMatch[1].length;
+  if (taskMatch[2]) {
+    tokens.push({
+      type: "text",
+      text: taskMatch[2],
+      start: cursor,
+      end: cursor + taskMatch[2].length
+    });
+    cursor += taskMatch[2].length;
+  }
+  tokens.push(...tokenizeInline(taskMatch[3], cursor));
+  return tokens;
+}
+function tokenizeTableLine(line, baseOffset) {
+  return tokenizeInlineWithMatchers(line, baseOffset, [TABLE_SEPARATOR_MATCHER]);
+}
 function tokenizeMultiLineBlock(raw, baseOffset, classifyLine) {
   const lines = raw.split("\n");
   const tokens = [];
@@ -269,13 +359,27 @@ function tokenizeMultiLineBlock(raw, baseOffset, classifyLine) {
       offset += 1;
     }
     const lineTokens = classifyLine(line, i, i === 0, i === lines.length - 1);
-    let pos = offset;
-    for (const t of lineTokens) {
-      if (t.start === -1) {
-        t.start = pos;
-        t.end = pos + t.text.length;
+    if (lineTokens.length > 0 && lineTokens[0].start < 0) {
+      let pos = offset;
+      for (const token of lineTokens) {
+        if (token.start === -1 && token.end === -1) {
+          token.start = pos;
+          token.end = pos + token.text.length;
+        } else {
+          token.start = offset + token.start + 1;
+          token.end = offset + token.end + 1;
+        }
+        pos = token.end;
+      }
+    } else {
+      let pos = offset;
+      for (const token of lineTokens) {
+        if (token.start === -1) {
+          token.start = pos;
+          token.end = pos + token.text.length;
+        }
+        pos = token.end;
       }
-      pos = t.end;
     }
     tokens.push(...lineTokens);
     offset += line.length;
@@ -311,6 +415,7 @@ function tokenizeCodeFence(raw, baseOffset) {
   }
   return tokens;
 }
+var TABLE_SEPARATOR_MATCHER = createLiteralTokenMatcher("|", "table-separator");
 
 // src/model/document.ts
 function createBlockIdGenerator() {
@@ -2996,6 +3101,7 @@ function buildBlockquoteBarsBoxShadow(depth) {
 }
 
 // src/render/block-render.ts
+var TOKEN_CLASS_EXEMPTIONS = /* @__PURE__ */ new Set(["text"]);
 function applyBlockquoteBarsStyle(el, depth) {
   const shadow = buildBlockquoteBarsBoxShadow(depth);
   if (!shadow) return;
@@ -3018,6 +3124,9 @@ var TOKEN_TO_CLASS = {
   "image-url": "owo-syntax-link-url",
   "heading-marker": "owo-syntax-heading-marker",
   "list-marker": "owo-syntax-list-marker",
+  "task-marker": "owo-syntax-task-marker",
+  "task-marker-checked": "owo-syntax-task-marker-checked",
+  "table-separator": "owo-syntax-table-separator",
   "blockquote-marker": "owo-syntax-blockquote-marker",
   "fence-marker": "owo-syntax-fence",
   "fence-lang": "owo-syntax-fence-lang",
@@ -3217,6 +3326,7 @@ export {
   expandWithContext,
   BQ_STEP,
   buildBlockquoteBarsBoxShadow,
+  TOKEN_CLASS_EXEMPTIONS,
   TOKEN_TO_CLASS,
   BLOCK_TYPE_TO_CLASS,
   createBlockElement,

package/dist/{dom-adapter-CTSJe5Uo.d.ts → dom-adapter-C8wuoffZ.d.ts}

@@ -68,7 +68,9 @@ type CompositionState = {
     active: boolean;
     range: VirtualSelection | null;
 };
-type InlineTokenType = 'text' | 'strong-marker' | 'strong' | 'emphasis-marker' | 'emphasis' | 'code-marker' | 'code' | 'link-bracket' | 'link-text' | 'link-url' | 'image-marker' | 'image-alt' | 'image-url' | 'heading-marker' | 'list-marker' | 'blockquote-marker' | 'fence-marker' | 'fence-lang' | 'code-block-text' | 'strikethrough-marker' | 'strikethrough' | 'math-marker' | 'math-text' | 'hr' | 'html';
+declare const INLINE_TOKEN_TYPES: readonly ["text", "strong-marker", "strong", "emphasis-marker", "emphasis", "code-marker", "code", "link-bracket", "link-text", "link-url", "image-marker", "image-alt", "image-url", "heading-marker", "list-marker", "task-marker", "task-marker-checked", "table-separator", "blockquote-marker", "fence-marker", "fence-lang", "code-block-text", "strikethrough-marker", "strikethrough", "math-marker", "math-text", "hr", "html"];
+type InlineTokenType = (typeof INLINE_TOKEN_TYPES)[number];
+declare const CLASSLESS_INLINE_TOKEN_TYPES: readonly ["text"];
 type InlineToken = {
     type: InlineTokenType;
     text: string;
@@ -466,4 +468,4 @@ type DomAdapterInstance = OwoMarkEditorInstance & {
 };
 declare function createDomAdapter(): DomAdapterInstance;
 
-export { isVirtualSelectionCollapsed as $, type JsonValue as A, type BlockNode as B, type CoreStateSnapshot as C, type DirtyRange as D, type OwoMarkCommands as E, type OwoMarkCore as F, type OwoMarkEditorInstance as G, type HeadingLevel as H, type InlineToken as I, type JsonPrimitive as J, type KeyDownIntent as K, type Leaf as L, type OwoMarkEditorLike as M, type OwoMarkSharedState as N, type OwoMarkSelection as O, type PreviewBlockKind as P, type OwoMarkSharedStateStore as Q, type PasteIntent as R, type SlashState as S, type PreviewDirtyReason as T, type SlashStateListener as U, type SlashTriggerInfo as V, type VirtualPosition as W, type VirtualSelection as X, applyMarkdownIndent as Y, createOwoMarkCore as Z, getBlockIndexForPosition as _, type BlockContextType as a, linearToVirtual as a0, linearToVirtualPosition as a1, resolveIndentSize as a2, virtualPositionToLinear as a3, virtualPositionsEqual as a4, virtualToLinear as a5, createDomAdapter as a6, type CommandRegistry as b, type OwoMarkDocument as c, type PreviewBlock as d, type BlockTransform as e, type OwoMarkSharedStateController as f, type InlineTokenType as g, type BeforeInputIntent as h, type BlockContext as i, type BlockContextListener as j, type BlockInsertType as k, type BlockType as l, type CommandContext as m, type CommandDefinition as n, type CompositionState as o, type CoreApplyAction as p, type CoreApplyResult as q, type CoreSelectionSnapshot as r, type CreateOwoMarkCoreOptions as s, type Decorator as t, type DecoratorType as u, type DocumentChangeCallback as v, type DomAdapterInstance as w, type HistoryEntry as x, type IndentMode as y, type IndentResult as z };
+export { createOwoMarkCore as $, type IndentMode as A, type BlockNode as B, type CoreStateSnapshot as C, type DirtyRange as D, type IndentResult as E, type JsonValue as F, type OwoMarkCommands as G, type HeadingLevel as H, type InlineToken as I, type JsonPrimitive as J, type KeyDownIntent as K, type Leaf as L, type OwoMarkCore as M, type OwoMarkEditorInstance as N, type OwoMarkSelection as O, type PreviewBlockKind as P, type OwoMarkEditorLike as Q, type OwoMarkSharedState as R, type SlashState as S, type OwoMarkSharedStateStore as T, type PasteIntent as U, type PreviewDirtyReason as V, type SlashStateListener as W, type SlashTriggerInfo as X, type VirtualPosition as Y, type VirtualSelection as Z, applyMarkdownIndent as _, type BlockContextType as a, getBlockIndexForPosition as a0, isVirtualSelectionCollapsed as a1, linearToVirtual as a2, linearToVirtualPosition as a3, resolveIndentSize as a4, virtualPositionToLinear as a5, virtualPositionsEqual as a6, virtualToLinear as a7, createDomAdapter as a8, type CommandRegistry as b, type OwoMarkDocument as c, type PreviewBlock as d, type BlockTransform as e, type OwoMarkSharedStateController as f, type InlineTokenType as g, type BeforeInputIntent as h, type BlockContext as i, type BlockContextListener as j, type BlockInsertType as k, type BlockType as l, CLASSLESS_INLINE_TOKEN_TYPES as m, type CommandContext as n, type CommandDefinition as o, type CompositionState as p, type CoreApplyAction as q, type CoreApplyResult as r, type CoreSelectionSnapshot as s, type CreateOwoMarkCoreOptions as t, type Decorator as u, type DecoratorType as v, type DocumentChangeCallback as w, type DomAdapterInstance as x, type HistoryEntry as y, INLINE_TOKEN_TYPES as z };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { B as BlockNode, a as BlockContextType, O as OwoMarkSelection, C as CoreStateSnapshot, S as SlashState, b as CommandRegistry, c as OwoMarkDocument, D as DirtyRange, P as PreviewBlockKind, d as PreviewBlock, e as BlockTransform, f as OwoMarkSharedStateController, I as InlineToken, g as InlineTokenType } from './dom-adapter-CTSJe5Uo.js';
-export { h as BeforeInputIntent, i as BlockContext, j as BlockContextListener, k as BlockInsertType, l as BlockType, m as CommandContext, n as CommandDefinition, o as CompositionState, p as CoreApplyAction, q as CoreApplyResult, r as CoreSelectionSnapshot, s as CreateOwoMarkCoreOptions, t as Decorator, u as DecoratorType, v as DocumentChangeCallback, w as DomAdapterInstance, H as HeadingLevel, x as HistoryEntry, y as IndentMode, z as IndentResult, J as JsonPrimitive, A as JsonValue, K as KeyDownIntent, L as Leaf, E as OwoMarkCommands, F as OwoMarkCore, G as OwoMarkEditorInstance, M as OwoMarkEditorLike, N as OwoMarkSharedState, Q as OwoMarkSharedStateStore, R as PasteIntent, T as PreviewDirtyReason, U as SlashStateListener, V as SlashTriggerInfo, W as VirtualPosition, X as VirtualSelection, Y as applyMarkdownIndent, Z as createOwoMarkCore, _ as getBlockIndexForPosition, $ as isVirtualSelectionCollapsed, a0 as linearToVirtual, a1 as linearToVirtualPosition, a2 as resolveIndentSize, a3 as virtualPositionToLinear, a4 as virtualPositionsEqual, a5 as virtualToLinear } from './dom-adapter-CTSJe5Uo.js';
+import { B as BlockNode, a as BlockContextType, O as OwoMarkSelection, C as CoreStateSnapshot, S as SlashState, b as CommandRegistry, c as OwoMarkDocument, D as DirtyRange, P as PreviewBlockKind, d as PreviewBlock, e as BlockTransform, f as OwoMarkSharedStateController, I as InlineToken, g as InlineTokenType } from './dom-adapter-C8wuoffZ.js';
+export { h as BeforeInputIntent, i as BlockContext, j as BlockContextListener, k as BlockInsertType, l as BlockType, m as CLASSLESS_INLINE_TOKEN_TYPES, n as CommandContext, o as CommandDefinition, p as CompositionState, q as CoreApplyAction, r as CoreApplyResult, s as CoreSelectionSnapshot, t as CreateOwoMarkCoreOptions, u as Decorator, v as DecoratorType, w as DocumentChangeCallback, x as DomAdapterInstance, H as HeadingLevel, y as HistoryEntry, z as INLINE_TOKEN_TYPES, A as IndentMode, E as IndentResult, J as JsonPrimitive, F as JsonValue, K as KeyDownIntent, L as Leaf, G as OwoMarkCommands, M as OwoMarkCore, N as OwoMarkEditorInstance, Q as OwoMarkEditorLike, R as OwoMarkSharedState, T as OwoMarkSharedStateStore, U as PasteIntent, V as PreviewDirtyReason, W as SlashStateListener, X as SlashTriggerInfo, Y as VirtualPosition, Z as VirtualSelection, _ as applyMarkdownIndent, $ as createOwoMarkCore, a0 as getBlockIndexForPosition, a1 as isVirtualSelectionCollapsed, a2 as linearToVirtual, a3 as linearToVirtualPosition, a4 as resolveIndentSize, a5 as virtualPositionToLinear, a6 as virtualPositionsEqual, a7 as virtualToLinear } from './dom-adapter-C8wuoffZ.js';
 export { WordBoundaryResult, deleteToLineEnd, deleteToLineStart, deleteWordBackward, deleteWordForward } from './internal/commands/word-boundary.js';
 export { normalizeMarkdownPaste } from './internal/clipboard/paste.js';
 export { enableMapSet, produce } from 'immer';
@@ -158,7 +158,7 @@ declare function createSharedStateStore(options?: CreateSharedStateOptions): Owo
 
 /**
  * Tokenize inline Markdown content into decoration tokens.
- * Pure function, no DOM dependency.
+ * Single-pass scanner with explicit priority and stable offsets.
  */
 declare function tokenizeInline(raw: string, baseOffset?: number): InlineToken[];
 
@@ -324,6 +324,7 @@ declare function detectAndRenderDirty(root: HTMLElement, oldDoc: OwoMarkDocument
  * Each block is a <div data-owo-block="index"> containing text/span nodes.
  */
 
+declare const TOKEN_CLASS_EXEMPTIONS: Set<"text" | "strong-marker" | "strong" | "emphasis-marker" | "emphasis" | "code-marker" | "code" | "link-bracket" | "link-text" | "link-url" | "image-marker" | "image-alt" | "image-url" | "heading-marker" | "list-marker" | "task-marker" | "task-marker-checked" | "table-separator" | "blockquote-marker" | "fence-marker" | "fence-lang" | "code-block-text" | "strikethrough-marker" | "strikethrough" | "math-marker" | "math-text" | "hr" | "html">;
 declare const TOKEN_TO_CLASS: Record<InlineTokenType, string>;
 declare const BLOCK_TYPE_TO_CLASS: Record<string, string>;
 declare function createBlockElement(doc: Document, tokens: InlineToken[], blockIndex: number, blockType: string, headingLevel?: number, depth?: number): HTMLDivElement;
@@ -362,4 +363,4 @@ declare function buildVirtualRows(blocks: readonly BlockNode[], heightCache: Map
 /** Compute the visible range given scroll state. */
 declare function computeVisibleRange(rows: VirtualRow[], scrollTop: number, viewportHeight: number, overscan?: number): VisibleRange;
 
-export { BLOCK_TYPE_TO_CLASS, BQ_STEP, BlockContextType, type BlockIdGenerator, BlockNode, BlockTransform, CommandRegistry, type CommandResult, type CoreEventHub, type CoreSlashStateListener, CoreStateSnapshot, type CreateSharedStateOptions, DirtyRange, type ImageSizeSyntax, InlineToken, InlineTokenType, NOT_HANDLED, OwoMarkDocument, OwoMarkSelection, OwoMarkSharedStateController, PreviewBlock, PreviewBlockKind, SlashState, TOKEN_TO_CLASS, type VirtualRow, type VisibleRange, buildBlockquoteBarsBoxShadow, buildVirtualRows, computePreviewDirtyRange, computeVisibleRange, createBlockElement, createBlockIdGenerator, createCommandRegistry, createImageSizeTransform, createSharedStateStore, deriveBlockId, deriveRenderKey, deriveSourceKey, detectAndRenderDirty, domRangeToOffset, estimateEditorBlockHeight, expandDirtyRange, expandWithContext, fullRender, getBlockAtOffset, getBlockById, getBlockIndexById, getBlockStartOffset, handleCharInput, handleMarkdownEnter, handleSmartBackspace, handleSmartDelete, insertCodeFence, insertImage, insertLink, insertMathBlock, insertSideAnnotation, insertTable, invalidateBlockCache, offsetToDomRange, parseMarkdownToDocument, patchDirtyBlocks, projectToPreviewBlocks, readSelection, reconcileBlocks, resetBlockIdCounter, resolveBlockContextType, restoreSelection, serializeDocument, toggleBold, toggleItalic, tokenizeBlock, tokenizeInline, updateBlockElement };
+export { BLOCK_TYPE_TO_CLASS, BQ_STEP, BlockContextType, type BlockIdGenerator, BlockNode, BlockTransform, CommandRegistry, type CommandResult, type CoreEventHub, type CoreSlashStateListener, CoreStateSnapshot, type CreateSharedStateOptions, DirtyRange, type ImageSizeSyntax, InlineToken, InlineTokenType, NOT_HANDLED, OwoMarkDocument, OwoMarkSelection, OwoMarkSharedStateController, PreviewBlock, PreviewBlockKind, SlashState, TOKEN_CLASS_EXEMPTIONS, TOKEN_TO_CLASS, type VirtualRow, type VisibleRange, buildBlockquoteBarsBoxShadow, buildVirtualRows, computePreviewDirtyRange, computeVisibleRange, createBlockElement, createBlockIdGenerator, createCommandRegistry, createImageSizeTransform, createSharedStateStore, deriveBlockId, deriveRenderKey, deriveSourceKey, detectAndRenderDirty, domRangeToOffset, estimateEditorBlockHeight, expandDirtyRange, expandWithContext, fullRender, getBlockAtOffset, getBlockById, getBlockIndexById, getBlockStartOffset, handleCharInput, handleMarkdownEnter, handleSmartBackspace, handleSmartDelete, insertCodeFence, insertImage, insertLink, insertMathBlock, insertSideAnnotation, insertTable, invalidateBlockCache, offsetToDomRange, parseMarkdownToDocument, patchDirtyBlocks, projectToPreviewBlocks, readSelection, reconcileBlocks, resetBlockIdCounter, resolveBlockContextType, restoreSelection, serializeDocument, toggleBold, toggleItalic, tokenizeBlock, tokenizeInline, updateBlockElement };

package/dist/index.js

@@ -4,6 +4,7 @@ import {
   NOT_HANDLED,
   SIDE_ANNOTATION_TAIL_RE,
   SIDE_CONTINUATION_TAIL_RE,
+  TOKEN_CLASS_EXEMPTIONS,
   TOKEN_TO_CLASS,
   applyMarkdownIndent,
   buildBlockquoteBarsBoxShadow,
@@ -53,7 +54,7 @@ import {
   virtualPositionToLinear,
   virtualPositionsEqual,
   virtualToLinear
-} from "./chunk-TRLKIMRD.js";
+} from "./chunk-6CBUAORJ.js";
 import {
   normalizeMarkdownPaste
 } from "./chunk-BGXCXQZP.js";
@@ -64,6 +65,39 @@ import {
   deleteWordForward
 } from "./chunk-MPIWZLI3.js";
 
+// src/types/public.ts
+var INLINE_TOKEN_TYPES = [
+  "text",
+  "strong-marker",
+  "strong",
+  "emphasis-marker",
+  "emphasis",
+  "code-marker",
+  "code",
+  "link-bracket",
+  "link-text",
+  "link-url",
+  "image-marker",
+  "image-alt",
+  "image-url",
+  "heading-marker",
+  "list-marker",
+  "task-marker",
+  "task-marker-checked",
+  "table-separator",
+  "blockquote-marker",
+  "fence-marker",
+  "fence-lang",
+  "code-block-text",
+  "strikethrough-marker",
+  "strikethrough",
+  "math-marker",
+  "math-text",
+  "hr",
+  "html"
+];
+var CLASSLESS_INLINE_TOKEN_TYPES = ["text"];
+
 // src/preview/block-id.ts
 function deriveBlockId(renderKey, occurrenceIndex) {
   return `${renderKey}#${occurrenceIndex}`;
@@ -590,7 +624,10 @@ function computeVisibleRange(rows, scrollTop, viewportHeight, overscan = 5) {
 export {
   BLOCK_TYPE_TO_CLASS,
   BQ_STEP,
+  CLASSLESS_INLINE_TOKEN_TYPES,
+  INLINE_TOKEN_TYPES,
   NOT_HANDLED,
+  TOKEN_CLASS_EXEMPTIONS,
   TOKEN_TO_CLASS,
   applyMarkdownIndent,
   buildBlockquoteBarsBoxShadow,

package/dist/internal/dom-adapter.d.ts

@@ -1 +1 @@
-export { v as DocumentChangeCallback, w as DomAdapterInstance, a6 as createDomAdapter } from '../dom-adapter-CTSJe5Uo.js';
+export { w as DocumentChangeCallback, x as DomAdapterInstance, a8 as createDomAdapter } from '../dom-adapter-C8wuoffZ.js';

package/dist/internal/dom-adapter.js

@@ -4,7 +4,7 @@ import {
   fullRender,
   readSelection,
   restoreSelection
-} from "../chunk-TRLKIMRD.js";
+} from "../chunk-6CBUAORJ.js";
 import "../chunk-BGXCXQZP.js";
 import "../chunk-MPIWZLI3.js";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owomark/core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Framework-agnostic core engine for the OwoMark editor.",
   "type": "module",
   "main": "./dist/index.js",