npm - yarn-spinner-runner-ts - Versions diffs - 0.1.2 → 0.1.3 - Mend

yarn-spinner-runner-ts 0.1.2 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (70) hide show

package/README.md +97 -88
package/dist/compile/compiler.js +4 -4
package/dist/compile/compiler.js.map +1 -1
package/dist/compile/ir.d.ts +3 -0
package/dist/index.d.ts +3 -0
package/dist/index.js +3 -0
package/dist/index.js.map +1 -1
package/dist/markup/parser.d.ts +3 -0
package/dist/markup/parser.js +332 -0
package/dist/markup/parser.js.map +1 -0
package/dist/markup/types.d.ts +17 -0
package/dist/markup/types.js +2 -0
package/dist/markup/types.js.map +1 -0
package/dist/model/ast.d.ts +3 -0
package/dist/parse/parser.js +57 -8
package/dist/parse/parser.js.map +1 -1
package/dist/react/DialogueExample.js +6 -4
package/dist/react/DialogueExample.js.map +1 -1
package/dist/react/DialogueScene.d.ts +2 -1
package/dist/react/DialogueScene.js +95 -26
package/dist/react/DialogueScene.js.map +1 -1
package/dist/react/DialogueView.d.ts +10 -1
package/dist/react/DialogueView.js +68 -5
package/dist/react/DialogueView.js.map +1 -1
package/dist/react/MarkupRenderer.d.ts +8 -0
package/dist/react/MarkupRenderer.js +64 -0
package/dist/react/MarkupRenderer.js.map +1 -0
package/dist/react/TypingText.d.ts +14 -0
package/dist/react/TypingText.js +78 -0
package/dist/react/TypingText.js.map +1 -0
package/dist/runtime/results.d.ts +3 -0
package/dist/runtime/runner.d.ts +1 -0
package/dist/runtime/runner.js +151 -14
package/dist/runtime/runner.js.map +1 -1
package/dist/tests/markup.test.d.ts +1 -0
package/dist/tests/markup.test.js +46 -0
package/dist/tests/markup.test.js.map +1 -0
package/dist/tests/nodes_lines.test.js +25 -1
package/dist/tests/nodes_lines.test.js.map +1 -1
package/dist/tests/options.test.js +30 -1
package/dist/tests/options.test.js.map +1 -1
package/dist/tests/typing-text.test.d.ts +1 -0
package/dist/tests/typing-text.test.js +12 -0
package/dist/tests/typing-text.test.js.map +1 -0
package/docs/actor-transition.md +34 -0
package/docs/markup.md +34 -19
package/docs/scenes-actors-setup.md +1 -0
package/docs/typing-animation.md +44 -0
package/eslint.config.cjs +3 -0
package/examples/browser/index.html +1 -1
package/examples/browser/main.tsx +0 -2
package/package.json +1 -1
package/src/compile/compiler.ts +4 -4
package/src/compile/ir.ts +3 -2
package/src/index.ts +3 -0
package/src/markup/parser.ts +372 -0
package/src/markup/types.ts +22 -0
package/src/model/ast.ts +17 -13
package/src/parse/parser.ts +60 -8
package/src/react/DialogueExample.tsx +18 -42
package/src/react/DialogueScene.tsx +143 -44
package/src/react/DialogueView.tsx +122 -8
package/src/react/MarkupRenderer.tsx +110 -0
package/src/react/TypingText.tsx +127 -0
package/src/react/dialogue.css +26 -13
package/src/runtime/results.ts +3 -1
package/src/runtime/runner.ts +158 -14
package/src/tests/markup.test.ts +62 -0
package/src/tests/nodes_lines.test.ts +35 -1
package/src/tests/options.test.ts +39 -1

package/eslint.config.cjs CHANGED Viewed

@@ -18,6 +18,9 @@ module.exports = [
         window: "readonly",
         setTimeout: "readonly",
         clearTimeout: "readonly",
+        setInterval: "readonly",
+        clearInterval: "readonly",
+        requestAnimationFrame: "readonly",
       },
     },
     plugins: {

package/examples/browser/index.html CHANGED Viewed

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>NarraLeaf-React Dialogue Demo</title>
+  <title>yarn-spinner-ts Dialogue Demo</title>
   <style>
     * {
       margin: 0;

package/examples/browser/main.tsx CHANGED Viewed

@@ -11,8 +11,6 @@ if (!rootEl) {
 const root = createRoot(rootEl);
 root.render(
-  <React.StrictMode>
     <DialogueExample />
-  </React.StrictMode>
 );

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "yarn-spinner-runner-ts",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "private": false,
   "description": "TypeScript parser, compiler, and runtime for Yarn Spinner 3.x with React adapter [NPM package](https://www.npmjs.com/package/yarn-spinner-runner-ts)",
   "license": "MIT",

package/src/compile/compiler.ts CHANGED Viewed

@@ -44,7 +44,7 @@ export function compile(doc: YarnDocument, opts: CompileOptions = {}): IRProgram
           case "Line":
             {
               const line = s as Line;
-              block.push({ op: "line", speaker: line.speaker, text: line.text, tags: ensureLineId(line.tags) });
+              block.push({ op: "line", speaker: line.speaker, text: line.text, tags: ensureLineId(line.tags), markup: line.markup });
             }
             break;
           case "Command":
@@ -72,7 +72,7 @@ export function compile(doc: YarnDocument, opts: CompileOptions = {}): IRProgram
             }
             block.push({
               op: "options",
-              options: s.options.map((o: Option) => ({ text: o.text, tags: ensureLineId(o.tags), css: (o as any).css, block: emitBlock(o.body) })),
+              options: s.options.map((o: Option) => ({ text: o.text, tags: ensureLineId(o.tags), css: (o as any).css, markup: o.markup, block: emitBlock(o.body) })),
             });
             break;
           }
@@ -114,7 +114,7 @@ export function compile(doc: YarnDocument, opts: CompileOptions = {}): IRProgram
               case "Line":
                 {
                   const line = s as Line;
-                  block.push({ op: "line", speaker: line.speaker, text: line.text, tags: ensureLineId(line.tags) });
+                  block.push({ op: "line", speaker: line.speaker, text: line.text, tags: ensureLineId(line.tags), markup: line.markup });
                 }
                 break;
               case "Command":
@@ -141,7 +141,7 @@ export function compile(doc: YarnDocument, opts: CompileOptions = {}): IRProgram
                 }
                 block.push({
                   op: "options",
-                  options: s.options.map((o: Option) => ({ text: o.text, tags: ensureLineId(o.tags), css: (o as any).css, block: emitBlock(o.body) })),
+                  options: s.options.map((o: Option) => ({ text: o.text, tags: ensureLineId(o.tags), css: (o as any).css, markup: o.markup, block: emitBlock(o.body) })),
                 });
                 break;
               }

package/src/compile/ir.ts CHANGED Viewed

@@ -1,3 +1,4 @@
+import type { MarkupParseResult } from "../markup/types.js";
 export type IRProgram = {
   enums: Record<string, string[]>; // enum name -> cases
   nodes: Record<string, IRNode | IRNodeGroup>; // can be single node or group
@@ -17,11 +18,11 @@ export type IRNodeGroup = {
 };
 export type IRInstruction =
-  | { op: "line"; speaker?: string; text: string; tags?: string[] }
+  | { op: "line"; speaker?: string; text: string; tags?: string[]; markup?: MarkupParseResult }
   | { op: "command"; content: string }
   | { op: "jump"; target: string }
   | { op: "detour"; target: string }
-  | { op: "options"; options: Array<{ text: string; tags?: string[]; css?: string; block: IRInstruction[] }> }
+  | { op: "options"; options: Array<{ text: string; tags?: string[]; css?: string; markup?: MarkupParseResult; block: IRInstruction[] }> }
   | { op: "if"; branches: Array<{ condition: string | null; block: IRInstruction[] }> }
   | { op: "once"; id: string; block: IRInstruction[] };

package/src/index.ts CHANGED Viewed

@@ -3,6 +3,8 @@ export * from "./parse/lexer.js";
 export * from "./parse/parser.js";
 export * from "./compile/ir.js";
 export * from "./compile/compiler.js";
+export * from "./markup/types.js";
+export * from "./markup/parser.js";
 export * from "./runtime/results.js";
 export * from "./runtime/evaluator.js";
 export * from "./runtime/commands.js";
@@ -14,4 +16,5 @@ export * from "./react/useYarnRunner.js";
 export * from "./react/DialogueView.js";
 export * from "./react/DialogueExample.js";
 export * from "./react/DialogueScene.js";
+export * from "./react/MarkupRenderer.js";

package/src/markup/parser.ts ADDED Viewed

@@ -0,0 +1,372 @@
+import type { MarkupParseResult, MarkupSegment, MarkupValue, MarkupWrapper } from "./types.js";
+const DEFAULT_HTML_TAGS = new Set(["b", "em", "small", "strong", "sub", "sup", "ins", "del", "mark"]);
+interface StackEntry {
+  name: string;
+  type: MarkupWrapper["type"];
+  properties: Record<string, MarkupValue>;
+  originalText: string;
+}
+interface ParsedTag {
+  kind: "open" | "close" | "self";
+  name: string;
+  properties: Record<string, MarkupValue>;
+}
+const SELF_CLOSING_SPACE_REGEX = /\s+\/$/;
+const ATTRIBUTE_REGEX =
+  /^([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"']+)))?/;
+export function parseMarkup(input: string): MarkupParseResult {
+  const segments: MarkupSegment[] = [];
+  const stack: StackEntry[] = [];
+  const chars: string[] = [];
+  let currentSegment: MarkupSegment | null = null;
+  let nomarkupDepth = 0;
+  const pushSegment = (segment: MarkupSegment) => {
+    if (segment.selfClosing || segment.end > segment.start) {
+      segments.push(segment);
+    }
+  };
+  const wrappersEqual = (a: MarkupWrapper[], b: MarkupWrapper[]) => {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      const wa = a[i];
+      const wb = b[i];
+      if (wa.name !== wb.name || wa.type !== wb.type) return false;
+      const keysA = Object.keys(wa.properties);
+      const keysB = Object.keys(wb.properties);
+      if (keysA.length !== keysB.length) return false;
+      for (const key of keysA) {
+        if (wa.properties[key] !== wb.properties[key]) return false;
+      }
+    }
+    return true;
+  };
+  const flushCurrentSegment = () => {
+    if (currentSegment) {
+      segments.push(currentSegment);
+      currentSegment = null;
+    }
+  };
+  const cloneWrappers = (): MarkupWrapper[] =>
+    stack.map((entry) => ({
+      name: entry.name,
+      type: entry.type,
+      properties: { ...entry.properties },
+    }));
+  const appendChar = (char: string) => {
+    const index = chars.length;
+    chars.push(char);
+    const wrappers = cloneWrappers();
+    if (currentSegment && wrappersEqual(currentSegment.wrappers, wrappers)) {
+      currentSegment.end = index + 1;
+    } else {
+      flushCurrentSegment();
+      currentSegment = {
+        start: index,
+        end: index + 1,
+        wrappers,
+      };
+    }
+  };
+  const appendLiteral = (literal: string) => {
+    for (const ch of literal) {
+      appendChar(ch);
+    }
+  };
+  const parseTag = (contentRaw: string): ParsedTag | null => {
+    let content = contentRaw.trim();
+    if (!content) return null;
+    if (content.startsWith("/")) {
+      const name = content.slice(1).trim().toLowerCase();
+      if (!name) return null;
+      return { kind: "close", name, properties: {} };
+    }
+    let kind: ParsedTag["kind"] = "open";
+    if (content.endsWith("/")) {
+      content = content.replace(SELF_CLOSING_SPACE_REGEX, "").trim();
+      if (content.endsWith("/")) {
+        content = content.slice(0, -1).trim();
+      }
+      kind = "self";
+    }
+    const nameMatch = content.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
+    if (!nameMatch) return null;
+    const name = nameMatch[1].toLowerCase();
+    let rest = content.slice(nameMatch[0].length).trim();
+    const properties: Record<string, MarkupValue> = {};
+    while (rest.length > 0) {
+      const attrMatch = rest.match(ATTRIBUTE_REGEX);
+      if (!attrMatch) {
+        break;
+      }
+      const [, keyRaw, doubleQuoted, singleQuoted, bare] = attrMatch;
+      const key = keyRaw.toLowerCase();
+      let value: MarkupValue = true;
+      const rawValue = doubleQuoted ?? singleQuoted ?? bare;
+      if (rawValue !== undefined) {
+        value = parseAttributeValue(rawValue);
+      }
+      properties[key] = value;
+      rest = rest.slice(attrMatch[0].length).trim();
+    }
+    return { kind, name, properties };
+  };
+  const parseAttributeValue = (raw: string): MarkupValue => {
+    const trimmed = raw.trim();
+    if (/^(true|false)$/i.test(trimmed)) {
+      return /^true$/i.test(trimmed);
+    }
+    if (/^[+-]?\d+(\.\d+)?$/.test(trimmed)) {
+      const num = Number(trimmed);
+      if (!Number.isNaN(num)) {
+        return num;
+      }
+    }
+    return trimmed;
+  };
+  const handleSelfClosing = (tag: ParsedTag) => {
+    const wrapper: MarkupWrapper = {
+      name: tag.name,
+      type: DEFAULT_HTML_TAGS.has(tag.name) ? "default" : "custom",
+      properties: tag.properties,
+    };
+    const position = chars.length;
+    pushSegment({
+      start: position,
+      end: position,
+      wrappers: [wrapper],
+      selfClosing: true,
+    });
+  };
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (char === "\\" && i + 1 < input.length) {
+      const next = input[i + 1];
+      if (next === "[" || next === "]" || next === "\\") {
+        appendChar(next);
+        i += 2;
+        continue;
+      }
+    }
+    if (char === "[") {
+      const closeIndex = findClosingBracket(input, i + 1);
+      if (closeIndex === -1) {
+        appendChar(char);
+        i += 1;
+        continue;
+      }
+      const content = input.slice(i + 1, closeIndex);
+      const originalText = input.slice(i, closeIndex + 1);
+      const parsed = parseTag(content);
+      if (!parsed) {
+        appendLiteral(originalText);
+        i = closeIndex + 1;
+        continue;
+      }
+      if (parsed.name === "nomarkup") {
+        if (parsed.kind === "open") {
+          nomarkupDepth += 1;
+        } else if (parsed.kind === "close" && nomarkupDepth > 0) {
+          nomarkupDepth -= 1;
+        }
+        i = closeIndex + 1;
+        continue;
+      }
+      if (nomarkupDepth > 0) {
+        appendLiteral(originalText);
+        i = closeIndex + 1;
+        continue;
+      }
+      if (parsed.kind === "open") {
+        const entry: StackEntry = {
+          name: parsed.name,
+          type: DEFAULT_HTML_TAGS.has(parsed.name) ? "default" : "custom",
+          properties: parsed.properties,
+          originalText,
+        };
+        stack.push(entry);
+        flushCurrentSegment();
+        i = closeIndex + 1;
+        continue;
+      }
+      if (parsed.kind === "self") {
+        handleSelfClosing(parsed);
+        i = closeIndex + 1;
+        continue;
+      }
+      // closing tag
+      if (stack.length === 0) {
+        appendLiteral(originalText);
+        i = closeIndex + 1;
+        continue;
+      }
+      const top = stack[stack.length - 1];
+      if (top.name === parsed.name) {
+        flushCurrentSegment();
+        stack.pop();
+        i = closeIndex + 1;
+        continue;
+      }
+      // mismatched closing; treat as literal
+      appendLiteral(originalText);
+      i = closeIndex + 1;
+      continue;
+    }
+    appendChar(char);
+    i += 1;
+  }
+  flushCurrentSegment();
+  // If any tags remain open, treat them as literal text appended at end
+  while (stack.length > 0) {
+    const entry = stack.pop()!;
+    appendLiteral(entry.originalText);
+  }
+  flushCurrentSegment();
+  const text = chars.join("");
+  return {
+    text,
+    segments: mergeSegments(segments, text.length),
+  };
+}
+function mergeSegments(segments: MarkupSegment[], textLength: number): MarkupSegment[] {
+  const sorted = [...segments].sort((a, b) => a.start - b.start || a.end - b.end);
+  const merged: MarkupSegment[] = [];
+  let last: MarkupSegment | null = null;
+  for (const seg of sorted) {
+    if (seg.start === seg.end && !seg.selfClosing) {
+      continue;
+    }
+    if (last && !seg.selfClosing && last.end === seg.start && wrappersMatch(last.wrappers, seg.wrappers)) {
+      last.end = seg.end;
+    } else {
+      last = {
+        start: seg.start,
+        end: seg.end,
+        wrappers: seg.wrappers,
+        selfClosing: seg.selfClosing,
+      };
+      merged.push(last);
+    }
+  }
+  if (merged.length === 0 && textLength > 0) {
+    merged.push({
+      start: 0,
+      end: textLength,
+      wrappers: [],
+    });
+  }
+  return merged;
+}
+function wrappersMatch(a: MarkupWrapper[], b: MarkupWrapper[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].name !== b[i].name || a[i].type !== b[i].type) return false;
+    const keysA = Object.keys(a[i].properties);
+    const keysB = Object.keys(b[i].properties);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (a[i].properties[key] !== b[i].properties[key]) return false;
+    }
+  }
+  return true;
+}
+function findClosingBracket(text: string, start: number): number {
+  for (let i = start; i < text.length; i++) {
+    if (text[i] === "]") {
+      let backslashCount = 0;
+      let j = i - 1;
+      while (j >= 0 && text[j] === "\\") {
+        backslashCount++;
+        j--;
+      }
+      if (backslashCount % 2 === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+export function sliceMarkup(result: MarkupParseResult, start: number, end?: number): MarkupParseResult {
+  const textLength = result.text.length;
+  const sliceStart = Math.max(0, Math.min(start, textLength));
+  const sliceEnd = end === undefined ? textLength : Math.max(sliceStart, Math.min(end, textLength));
+  const slicedSegments: MarkupSegment[] = [];
+  for (const seg of result.segments) {
+    const segStart = Math.max(seg.start, sliceStart);
+    const segEnd = Math.min(seg.end, sliceEnd);
+    if (seg.selfClosing) {
+      if (segStart >= sliceStart && segStart <= sliceEnd) {
+        slicedSegments.push({
+          start: segStart - sliceStart,
+          end: segStart - sliceStart,
+          wrappers: seg.wrappers,
+          selfClosing: true,
+        });
+      }
+      continue;
+    }
+    if (segEnd <= segStart) continue;
+    slicedSegments.push({
+      start: segStart - sliceStart,
+      end: segEnd - sliceStart,
+      wrappers: seg.wrappers.map((wrapper) => ({
+        name: wrapper.name,
+        type: wrapper.type,
+        properties: { ...wrapper.properties },
+      })),
+    });
+  }
+  if (slicedSegments.length === 0 && sliceEnd - sliceStart > 0) {
+    slicedSegments.push({
+      start: 0,
+      end: sliceEnd - sliceStart,
+      wrappers: [],
+    });
+  }
+  return {
+    text: result.text.slice(sliceStart, sliceEnd),
+    segments: mergeSegments(slicedSegments, sliceEnd - sliceStart),
+  };
+}

package/src/markup/types.ts ADDED Viewed

@@ -0,0 +1,22 @@
+export type MarkupValue = string | number | boolean;
+export type MarkupWrapperType = "default" | "custom";
+export interface MarkupWrapper {
+  name: string;
+  type: MarkupWrapperType;
+  properties: Record<string, MarkupValue>;
+}
+export interface MarkupSegment {
+  start: number;
+  end: number;
+  wrappers: MarkupWrapper[];
+  selfClosing?: boolean;
+}
+export interface MarkupParseResult {
+  text: string;
+  segments: MarkupSegment[];
+}

package/src/model/ast.ts CHANGED Viewed

@@ -36,12 +36,15 @@ export type Statement =
   | Detour
   | EnumBlock;
-export interface Line {
-  type: "Line";
-  speaker?: string;
-  text: string;
-  tags?: string[];
-}
+import type { MarkupParseResult } from "../markup/types.js";
+export interface Line {
+  type: "Line";
+  speaker?: string;
+  text: string;
+  tags?: string[];
+  markup?: MarkupParseResult;
+}
 export interface Command {
   type: "Command";
@@ -63,13 +66,14 @@ export interface OptionGroup {
   options: Option[];
 }
-export interface Option {
-  type: "Option";
-  text: string;
-  body: Statement[]; // executed if chosen
-  tags?: string[];
-  css?: string; // Custom CSS style for option
-}
+export interface Option {
+  type: "Option";
+  text: string;
+  body: Statement[]; // executed if chosen
+  tags?: string[];
+  css?: string; // Custom CSS style for option
+  markup?: MarkupParseResult;
+}
 export interface IfBlock {
   type: "If";

package/src/parse/parser.ts CHANGED Viewed

@@ -1,4 +1,6 @@
 import { lex, Token } from "./lexer.js";
+import { parseMarkup, sliceMarkup } from "../markup/parser.js";
+import type { MarkupParseResult } from "../markup/types.js";
 import type {
   YarnDocument,
   YarnNode,
@@ -177,17 +179,33 @@ class Parser {
     }
     if (t.type === "TEXT") {
       const raw = this.take("TEXT").text;
-      const { cleanText: text, tags } = this.extractTags(raw);
-      const speakerMatch = text.match(/^([^:\s][^:]*)\s*:\s*(.*)$/);
+      const { cleanText: textWithoutTags, tags } = this.extractTags(raw);
+      const markup = parseMarkup(textWithoutTags);
+      const speakerMatch = markup.text.match(/^([^:\s][^:]*)\s*:\s*(.*)$/);
       if (speakerMatch) {
-        return { type: "Line", speaker: speakerMatch[1].trim(), text: speakerMatch[2], tags } as Line;
+        const messageText = speakerMatch[2];
+        const messageOffset = markup.text.length - messageText.length;
+        const slicedMarkup = sliceMarkup(markup, messageOffset);
+        const normalizedMarkup = this.normalizeMarkup(slicedMarkup);
+        return {
+          type: "Line",
+          speaker: speakerMatch[1].trim(),
+          text: messageText,
+          tags,
+          markup: normalizedMarkup,
+        } as Line;
       }
       // If/Else blocks use inline markup {if ...}
-      const trimmed = text.trim();
+      const trimmed = markup.text.trim();
       if (trimmed.startsWith("{if ") || trimmed === "{else}" || trimmed.startsWith("{else if ") || trimmed === "{endif}") {
-        return this.parseIfFromText(text);
+        return this.parseIfFromText(markup.text);
       }
-      return { type: "Line", text, tags } as Line;
+      return {
+        type: "Line",
+        text: markup.text,
+        tags,
+        markup: this.normalizeMarkup(markup),
+      } as Line;
     }
     throw new ParseError(`Unexpected token ${t.type}`);
   }
@@ -198,7 +216,8 @@ class Parser {
     while (this.at("OPTION")) {
       const raw = this.take("OPTION").text;
       const { cleanText: textWithAttrs, tags } = this.extractTags(raw);
-      const { text, css } = this.extractCss(textWithAttrs);
+      const { text: textWithoutCss, css } = this.extractCss(textWithAttrs);
+      const markup = parseMarkup(textWithoutCss);
       let body: Statement[] = [];
       if (this.at("INDENT")) {
         this.take("INDENT");
@@ -206,13 +225,46 @@ class Parser {
         this.take("DEDENT");
         while (this.at("EMPTY")) this.i++;
       }
-      options.push({ type: "Option", text, body, tags, css });
+      options.push({
+        type: "Option",
+        text: markup.text,
+        body,
+        tags,
+        css,
+        markup: this.normalizeMarkup(markup),
+      });
       // Consecutive options belong to the same group; break on non-OPTION
       while (this.at("EMPTY")) this.i++;
     }
     return { type: "OptionGroup", options };
   }
+  private normalizeMarkup(result: MarkupParseResult): MarkupParseResult | undefined {
+    if (!result) return undefined;
+    if (result.segments.length === 0) {
+      return undefined;
+    }
+    const hasFormatting = result.segments.some(
+      (segment) => segment.wrappers.length > 0 || segment.selfClosing
+    );
+    if (!hasFormatting) {
+      return undefined;
+    }
+    return {
+      text: result.text,
+      segments: result.segments.map((segment) => ({
+        start: segment.start,
+        end: segment.end,
+        wrappers: segment.wrappers.map((wrapper) => ({
+          name: wrapper.name,
+          type: wrapper.type,
+          properties: { ...wrapper.properties },
+        })),
+        selfClosing: segment.selfClosing,
+      })),
+    };
+  }
   private extractTags(input: string): { cleanText: string; tags?: string[] } {
     const tags: string[] = [];
     // Match tags that are space-separated and not part of hex colors or CSS