@mathscan/math-exercise-engine 1.0.4 → 1.0.5

package/dist/index.d.ts

@@ -19,6 +19,10 @@ export declare const AST_TYPES: {
     readonly SPACE: "Space";
     /** Text with optional character-range highlighting */
     readonly HIGHLIGHTED_TEXT: "HighlightedText";
+    /** Text with color and optional character-range coloring */
+    readonly COLOR_TEXT: "ColorText";
+    /** Bold text with optional character-range bolding */
+    readonly BOLD_TEXT: "BoldText";
     /** Inline input widget (string or numeric) */
     readonly INLINE_INPUT: "InlineInput";
     /** Question/instruction text block */
@@ -42,6 +46,108 @@ export declare const AST_TYPES: {
  */
 export declare type ASTType = typeof AST_TYPES[keyof typeof AST_TYPES];
 
+export declare type BoldText = z.infer<typeof BoldTextSchema>;
+
+export declare type BoldTextInline = z.infer<typeof BoldTextInlineSchema>;
+
+/**
+ * Bold text inline schema - text with optional range bolding
+ *
+ * highlight: [start, end] character positions for bold range
+ *
+ * @example
+ * {
+ *   type: "BoldText",
+ *   value: "123456",
+ *   highlight: [0, 3]  // Bolds "123"
+ * }
+ */
+export declare const BoldTextInlineSchema: z.ZodObject<{
+    type: z.ZodLiteral<"BoldText">;
+    value: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "BoldText";
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "BoldText";
+    highlight?: [number, number] | undefined;
+}>;
+
+export declare const BoldTextSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"bold-text">;
+    value: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "bold-text";
+    id: string;
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "bold-text";
+    id: string;
+    highlight?: [number, number] | undefined;
+}>;
+
+export declare type ColorText = z.infer<typeof ColorTextSchema>;
+
+export declare type ColorTextInline = z.infer<typeof ColorTextInlineSchema>;
+
+/**
+ * Color text inline schema - text with color and optional range coloring
+ *
+ * highlight: [start, end] character positions for colored range
+ * color: CSS color value (e.g., "red", "#ff0000")
+ *
+ * @example
+ * {
+ *   type: "ColorText",
+ *   value: "123456",
+ *   color: "red",
+ *   highlight: [0, 3]  // Colors "123" in red
+ * }
+ */
+export declare const ColorTextInlineSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ColorText">;
+    value: z.ZodString;
+    color: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "ColorText";
+    color: string;
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "ColorText";
+    color: string;
+    highlight?: [number, number] | undefined;
+}>;
+
+export declare const ColorTextSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"color-text">;
+    value: z.ZodString;
+    color: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "color-text";
+    color: string;
+    id: string;
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "color-text";
+    color: string;
+    id: string;
+    highlight?: [number, number] | undefined;
+}>;
+
 /**
  * Compile DSL text directly to JSON (convenience function)
  *
@@ -91,6 +197,15 @@ export declare function compileWithAST(dsl: string): {
                 value: string;
                 type: "HighlightedText";
                 highlight?: [number, number] | undefined;
+            } | {
+                value: string;
+                type: "ColorText";
+                color: string;
+                highlight?: [number, number] | undefined;
+            } | {
+                value: string;
+                type: "BoldText";
+                highlight?: [number, number] | undefined;
             } | {
                 length: number;
                 type: "InlineInput";
@@ -153,6 +268,16 @@ export declare function compileWithAST(dsl: string): {
     };
 };
 
+/**
+ * Create a bold text inline element
+ */
+export declare function createBoldText(value: string, highlight?: [number, number]): BoldTextInline;
+
+/**
+ * Create a color text inline element
+ */
+export declare function createColorText(value: string, color: string, highlight?: [number, number]): ColorTextInline;
+
 /**
  * Create a drag options tool
  */
@@ -347,6 +472,33 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             value: string;
             type: "HighlightedText";
             highlight?: [number, number] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"ColorText">;
+            value: z.ZodString;
+            color: z.ZodString;
+            highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            type: "ColorText";
+            color: string;
+            highlight?: [number, number] | undefined;
+        }, {
+            value: string;
+            type: "ColorText";
+            color: string;
+            highlight?: [number, number] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"BoldText">;
+            value: z.ZodString;
+            highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            type: "BoldText";
+            highlight?: [number, number] | undefined;
+        }, {
+            value: string;
+            type: "BoldText";
+            highlight?: [number, number] | undefined;
         }>, z.ZodDiscriminatedUnion<"inputType", [z.ZodObject<{
             type: z.ZodLiteral<"InlineInput">;
             name: z.ZodString;
@@ -395,6 +547,15 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             value: string;
             type: "HighlightedText";
             highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "ColorText";
+            color: string;
+            highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "BoldText";
+            highlight?: [number, number] | undefined;
         } | {
             length: number;
             type: "InlineInput";
@@ -419,6 +580,15 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             value: string;
             type: "HighlightedText";
             highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "ColorText";
+            color: string;
+            highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "BoldText";
+            highlight?: [number, number] | undefined;
         } | {
             length: number;
             type: "InlineInput";
@@ -490,6 +660,15 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             value: string;
             type: "HighlightedText";
             highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "ColorText";
+            color: string;
+            highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "BoldText";
+            highlight?: [number, number] | undefined;
         } | {
             length: number;
             type: "InlineInput";
@@ -535,6 +714,15 @@ export declare const ExerciseDocumentSchema: z.ZodObject<{
             value: string;
             type: "HighlightedText";
             highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "ColorText";
+            color: string;
+            highlight?: [number, number] | undefined;
+        } | {
+            value: string;
+            type: "BoldText";
+            highlight?: [number, number] | undefined;
         } | {
             length: number;
             type: "InlineInput";
@@ -1021,6 +1209,33 @@ export declare const InlineNodeSchema: z.ZodUnion<[z.ZodObject<{
     value: string;
     type: "HighlightedText";
     highlight?: [number, number] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"ColorText">;
+    value: z.ZodString;
+    color: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "ColorText";
+    color: string;
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "ColorText";
+    color: string;
+    highlight?: [number, number] | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"BoldText">;
+    value: z.ZodString;
+    highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "BoldText";
+    highlight?: [number, number] | undefined;
+}, {
+    value: string;
+    type: "BoldText";
+    highlight?: [number, number] | undefined;
 }>, z.ZodDiscriminatedUnion<"inputType", [z.ZodObject<{
     type: z.ZodLiteral<"InlineInput">;
     name: z.ZodString;
@@ -1059,6 +1274,20 @@ export declare const InlineNodeSchema: z.ZodUnion<[z.ZodObject<{
     answer?: string | number | undefined;
 }>]>]>;
 
+/**
+ * Type guard for BoldText
+ */
+export declare function isBoldText(item: LayoutItem): item is Extract<LayoutItem, {
+    type: 'bold-text';
+}>;
+
+/**
+ * Type guard for ColorText
+ */
+export declare function isColorText(item: LayoutItem): item is Extract<LayoutItem, {
+    type: 'color-text';
+}>;
+
 export declare function isDragOptions(value: unknown): value is DragOptionsTool;
 
 /**
@@ -1177,6 +1406,10 @@ export declare const JSON_TYPES: {
     readonly SPACE: "space";
     /** Text with optional highlighting */
     readonly HIGHLIGHTED_TEXT: "highlighted-text";
+    /** Text with color styling */
+    readonly COLOR_TEXT: "color-text";
+    /** Bold text */
+    readonly BOLD_TEXT: "bold-text";
     /** Reference to a widget */
     readonly WIDGET_REF: "widget-ref";
     /** Line break element */
@@ -1272,6 +1505,33 @@ export declare const LineBlockSchema: z.ZodObject<{
         value: string;
         type: "HighlightedText";
         highlight?: [number, number] | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"ColorText">;
+        value: z.ZodString;
+        color: z.ZodString;
+        highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "ColorText";
+        color: string;
+        highlight?: [number, number] | undefined;
+    }, {
+        value: string;
+        type: "ColorText";
+        color: string;
+        highlight?: [number, number] | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"BoldText">;
+        value: z.ZodString;
+        highlight: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "BoldText";
+        highlight?: [number, number] | undefined;
+    }, {
+        value: string;
+        type: "BoldText";
+        highlight?: [number, number] | undefined;
     }>, z.ZodDiscriminatedUnion<"inputType", [z.ZodObject<{
         type: z.ZodLiteral<"InlineInput">;
         name: z.ZodString;
@@ -1320,6 +1580,15 @@ export declare const LineBlockSchema: z.ZodObject<{
         value: string;
         type: "HighlightedText";
         highlight?: [number, number] | undefined;
+    } | {
+        value: string;
+        type: "ColorText";
+        color: string;
+        highlight?: [number, number] | undefined;
+    } | {
+        value: string;
+        type: "BoldText";
+        highlight?: [number, number] | undefined;
     } | {
         length: number;
         type: "InlineInput";
@@ -1344,6 +1613,15 @@ export declare const LineBlockSchema: z.ZodObject<{
         value: string;
         type: "HighlightedText";
         highlight?: [number, number] | undefined;
+    } | {
+        value: string;
+        type: "ColorText";
+        color: string;
+        highlight?: [number, number] | undefined;
+    } | {
+        value: string;
+        type: "BoldText";
+        highlight?: [number, number] | undefined;
     } | {
         length: number;
         type: "InlineInput";

package/dist/index.js

@@ -16,6 +16,10 @@ const AST_TYPES = {
   SPACE: "Space",
   /** Text with optional character-range highlighting */
   HIGHLIGHTED_TEXT: "HighlightedText",
+  /** Text with color and optional character-range coloring */
+  COLOR_TEXT: "ColorText",
+  /** Bold text with optional character-range bolding */
+  BOLD_TEXT: "BoldText",
   /** Inline input widget (string or numeric) */
   INLINE_INPUT: "InlineInput",
   // ═══════════════════════════════════════════════════════════════════════════
@@ -57,6 +61,10 @@ const JSON_TYPES = {
   SPACE: "space",
   /** Text with optional highlighting */
   HIGHLIGHTED_TEXT: "highlighted-text",
+  /** Text with color styling */
+  COLOR_TEXT: "color-text",
+  /** Bold text */
+  BOLD_TEXT: "bold-text",
   /** Reference to a widget */
   WIDGET_REF: "widget-ref",
   /** Line break element */
@@ -116,6 +124,14 @@ const TEXT_HIGHLIGHTER = chevrotain.createToken({
   name: "TEXT_HIGHLIGHTER",
   pattern: /TEXT_HIGHLIGHTER/
 });
+const COLOR_TEXT = chevrotain.createToken({
+  name: "COLOR_TEXT",
+  pattern: /COLOR_TEXT/
+});
+const BOLD_TEXT = chevrotain.createToken({
+  name: "BOLD_TEXT",
+  pattern: /BOLD_TEXT/
+});
 const HIGHLIGHT_TEXT = chevrotain.createToken({
   name: "HIGHLIGHT_TEXT",
   pattern: /HIGHLIGHT_TEXT/
@@ -231,6 +247,8 @@ const allTokens = [
   // Component keywords (before Identifier!)
   QUESTION_TEXT,
   TEXT_HIGHLIGHTER,
+  COLOR_TEXT,
+  BOLD_TEXT,
   HIGHLIGHT_TEXT,
   W_S_I,
   STRING_INPUT,
@@ -420,6 +438,10 @@ class MathExerciseParser extends chevrotain.CstParser {
         { ALT: () => this.CONSUME(RParen) },
         // TEXT_HIGHLIGHTER / HIGHLIGHT_TEXT (for highlighting)
         { ALT: () => this.SUBRULE(this.textHighlighter) },
+        // COLOR_TEXT (for colored text)
+        { ALT: () => this.SUBRULE(this.colorText) },
+        // BOLD_TEXT (for bold text)
+        { ALT: () => this.SUBRULE(this.boldText) },
         // W_S_I (inline input widget)
         { ALT: () => this.SUBRULE(this.inlineInput) }
       ]);
@@ -433,6 +455,18 @@ class MathExerciseParser extends chevrotain.CstParser {
       this.SUBRULE(this.parameterList);
       this.CONSUME(RBracket);
     });
+    this.colorText = this.RULE("colorText", () => {
+      this.CONSUME(COLOR_TEXT);
+      this.CONSUME(LBracket);
+      this.SUBRULE(this.parameterList);
+      this.CONSUME(RBracket);
+    });
+    this.boldText = this.RULE("boldText", () => {
+      this.CONSUME(BOLD_TEXT);
+      this.CONSUME(LBracket);
+      this.SUBRULE(this.parameterList);
+      this.CONSUME(RBracket);
+    });
     this.inlineInput = this.RULE("inlineInput", () => {
       this.OR([
         { ALT: () => this.CONSUME(W_S_I, { LABEL: "stringInput" }) },
@@ -575,6 +609,17 @@ const HighlightedTextInlineSchema = zod.z.object({
   value: zod.z.string(),
   highlight: zod.z.tuple([zod.z.number(), zod.z.number()]).optional()
 });
+const ColorTextInlineSchema = zod.z.object({
+  type: zod.z.literal(AST_TYPES.COLOR_TEXT),
+  value: zod.z.string(),
+  color: zod.z.string(),
+  highlight: zod.z.tuple([zod.z.number(), zod.z.number()]).optional()
+});
+const BoldTextInlineSchema = zod.z.object({
+  type: zod.z.literal(AST_TYPES.BOLD_TEXT),
+  value: zod.z.string(),
+  highlight: zod.z.tuple([zod.z.number(), zod.z.number()]).optional()
+});
 const InlineInputWidgetSchema = zod.z.discriminatedUnion("inputType", [
   zod.z.object({
     type: zod.z.literal(AST_TYPES.INLINE_INPUT),
@@ -595,6 +640,8 @@ const InlineNodeSchema = zod.z.union([
   FreeTextInlineSchema,
   SpaceInlineSchema,
   HighlightedTextInlineSchema,
+  ColorTextInlineSchema,
+  BoldTextInlineSchema,
   InlineInputWidgetSchema
 ]);
 function createFreeText(value) {
@@ -615,6 +662,21 @@ function createHighlightedText(value, highlight) {
     highlight
   });
 }
+function createColorText(value, color, highlight) {
+  return ColorTextInlineSchema.parse({
+    type: AST_TYPES.COLOR_TEXT,
+    value,
+    color,
+    highlight
+  });
+}
+function createBoldText(value, highlight) {
+  return BoldTextInlineSchema.parse({
+    type: AST_TYPES.BOLD_TEXT,
+    value,
+    highlight
+  });
+}
 function createStringInput(name, length, answer) {
   return InlineInputWidgetSchema.parse({
     type: AST_TYPES.INLINE_INPUT,
@@ -858,6 +920,12 @@ class NaturalDSLVisitor extends BaseCstVisitor {
     if (ctx.textHighlighter) {
       return this.visit(ctx.textHighlighter);
     }
+    if (ctx.colorText) {
+      return this.visit(ctx.colorText);
+    }
+    if (ctx.boldText) {
+      return this.visit(ctx.boldText);
+    }
     if (ctx.inlineInput) {
       return this.visit(ctx.inlineInput);
     }
@@ -872,6 +940,25 @@ class NaturalDSLVisitor extends BaseCstVisitor {
     }
     return createHighlightedText(value, highlight);
   }
+  colorText(ctx) {
+    const params = this.visit(ctx.parameterList);
+    const value = params.value;
+    const color = params.color;
+    let highlight = void 0;
+    if (params.start !== void 0 && params.end !== void 0) {
+      highlight = [params.start, params.end];
+    }
+    return createColorText(value, color, highlight);
+  }
+  boldText(ctx) {
+    const params = this.visit(ctx.parameterList);
+    const value = params.value;
+    let highlight = void 0;
+    if (params.start !== void 0 && params.end !== void 0) {
+      highlight = [params.start, params.end];
+    }
+    return createBoldText(value, highlight);
+  }
   inlineInput(ctx) {
     const params = this.visit(ctx.parameterList);
     const name = params.name;
@@ -1014,6 +1101,19 @@ const HighlightedTextSchema = zod.z.object({
   value: zod.z.string(),
   highlight: zod.z.tuple([zod.z.number(), zod.z.number()]).optional()
 });
+const ColorTextSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal(JSON_TYPES.COLOR_TEXT),
+  value: zod.z.string(),
+  color: zod.z.string(),
+  highlight: zod.z.tuple([zod.z.number(), zod.z.number()]).optional()
+});
+const BoldTextSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal(JSON_TYPES.BOLD_TEXT),
+  value: zod.z.string(),
+  highlight: zod.z.tuple([zod.z.number(), zod.z.number()]).optional()
+});
 const LinebreakSchema = zod.z.object({
   id: zod.z.string(),
   type: zod.z.literal(JSON_TYPES.LINEBREAK)
@@ -1030,6 +1130,8 @@ const LayoutItemSchema = zod.z.lazy(
     TextItemSchema,
     WidgetRefSchema,
     HighlightedTextSchema,
+    ColorTextSchema,
+    BoldTextSchema,
     LinebreakSchema,
     GroupItemSchema,
     OperatorItemSchema
@@ -1112,6 +1214,12 @@ function isWidgetRef(item) {
 function isHighlightedText(item) {
   return item.type === JSON_TYPES.HIGHLIGHTED_TEXT;
 }
+function isColorText(item) {
+  return item.type === JSON_TYPES.COLOR_TEXT;
+}
+function isBoldText(item) {
+  return item.type === JSON_TYPES.BOLD_TEXT;
+}
 function isLinebreak(item) {
   return item.type === JSON_TYPES.LINEBREAK;
 }
@@ -1244,6 +1352,21 @@ function transformInline(inline, idGenerator) {
         value: inline.value,
         highlight: inline.highlight
       };
+    case AST_TYPES.COLOR_TEXT:
+      return {
+        id: idGenerator.generate(JSON_TYPES.COLOR_TEXT),
+        type: JSON_TYPES.COLOR_TEXT,
+        value: inline.value,
+        color: inline.color,
+        highlight: inline.highlight
+      };
+    case AST_TYPES.BOLD_TEXT:
+      return {
+        id: idGenerator.generate(JSON_TYPES.BOLD_TEXT),
+        type: JSON_TYPES.BOLD_TEXT,
+        value: inline.value,
+        highlight: inline.highlight
+      };
     case AST_TYPES.INLINE_INPUT:
       return {
         id: idGenerator.generate(JSON_TYPES.WIDGET_REF),
@@ -5907,13 +6030,39 @@ const LayoutRenderer = ({
       const dirAttr = !hasArabic ? "ltr" : void 0;
       if (item.highlight) {
         const [start, end] = item.highlight;
-        return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "highlighted-text", dir: dirAttr, children: [
+        return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "highlighted-text text-item", dir: dirAttr, children: [
+          item.value.slice(0, start),
+          /* @__PURE__ */ jsxRuntime.jsx("mark", { className: "highlight text-item", children: item.value.slice(start, end) }),
+          item.value.slice(end)
+        ] });
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx("mark", { className: "highlighted-text text-item", dir: dirAttr, children: item.value });
+    }
+    case JSON_TYPES.COLOR_TEXT: {
+      const hasArabic = isArabic(item.value);
+      const dirAttr = !hasArabic ? "ltr" : void 0;
+      if (item.highlight) {
+        const [start, end] = item.highlight;
+        return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "color-text text-item", dir: dirAttr, children: [
+          item.value.slice(0, start),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "color-text-colored", style: { color: item.color }, children: item.value.slice(start, end) }),
+          item.value.slice(end)
+        ] });
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx("span", { className: "color-text text-item", style: { color: item.color }, dir: dirAttr, children: item.value });
+    }
+    case JSON_TYPES.BOLD_TEXT: {
+      const hasArabic = isArabic(item.value);
+      const dirAttr = !hasArabic ? "ltr" : void 0;
+      if (item.highlight) {
+        const [start, end] = item.highlight;
+        return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "bold-text text-item", dir: dirAttr, children: [
           item.value.slice(0, start),
-          /* @__PURE__ */ jsxRuntime.jsx("mark", { className: "highlight", children: item.value.slice(start, end) }),
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { className: "bold-text-strong text-item", children: item.value.slice(start, end) }),
           item.value.slice(end)
         ] });
       }
-      return /* @__PURE__ */ jsxRuntime.jsx("mark", { className: "highlighted-text", dir: dirAttr, children: item.value });
+      return /* @__PURE__ */ jsxRuntime.jsx("strong", { className: "bold-text text-item", dir: dirAttr, children: item.value });
     }
     case JSON_TYPES.WIDGET_REF: {
       const widget = widgets[item.widgetId];
@@ -38140,6 +38289,10 @@ function compileWithAST(dsl) {
   return { ast, json };
 }
 exports.AST_TYPES = AST_TYPES;
+exports.BoldTextInlineSchema = BoldTextInlineSchema;
+exports.BoldTextSchema = BoldTextSchema;
+exports.ColorTextInlineSchema = ColorTextInlineSchema;
+exports.ColorTextSchema = ColorTextSchema;
 exports.DragOptionsJSONSchema = DragOptionsJSONSchema;
 exports.DragOptionsToolSchema = DragOptionsToolSchema;
 exports.EngineError = EngineError;
@@ -38181,6 +38334,8 @@ exports.WidgetRefSchema = WidgetRefSchema;
 exports.WidgetRenderer = WidgetRenderer;
 exports.compile = compile;
 exports.compileWithAST = compileWithAST;
+exports.createBoldText = createBoldText;
+exports.createColorText = createColorText;
 exports.createDragOptions = createDragOptions;
 exports.createExerciseDocument = createExerciseDocument;
 exports.createExpressionValidation = createExpressionValidation;
@@ -38197,6 +38352,8 @@ exports.evaluate = evaluate;
 exports.extractExpressionVariables = extractVariables;
 exports.findValidCombination = findValidCombination;
 exports.getMissingInputs = getMissingInputs;
+exports.isBoldText = isBoldText;
+exports.isColorText = isColorText;
 exports.isDragOptions = isDragOptions;
 exports.isDragOptionsJSON = isDragOptionsJSON;
 exports.isExerciseDocument = isExerciseDocument;