@getodk/xforms-engine 0.9.0 → 0.11.0

package/dist/instance/SelectControl.d.ts

@@ -22,6 +22,7 @@ interface SelectControlStateSpec extends ValueNodeStateSpec<readonly string[]> {
     readonly label: Accessor<TextRange<'label'> | null>;
     readonly hint: Accessor<TextRange<'hint'> | null>;
     readonly valueOptions: Accessor<SelectValueOptions>;
+    readonly isSelectWithImages: Accessor<boolean>;
 }
 export declare class SelectControl extends ValueNode<'string', SelectDefinition<'string'>, readonly string[], readonly string[]> implements SelectNode, XFormsXPathElement, EvaluationContext, ValidationContext, ClientReactiveSerializableValueNode {
     static from(parent: GeneralParentNode, instanceNode: StaticLeafElement | null, definition: SelectDefinition): SelectControl;

package/dist/instance/text/TextRange.d.ts

@@ -1,10 +1,20 @@
+import { JRResourceURL } from '../../../../common/src/jr-resources/JRResourceURL.ts';
 import { TextRange as ClientTextRange, TextChunk, TextOrigin, TextRole } from '../../client/TextRange.ts';
+export interface MediaSources {
+    image?: JRResourceURL;
+    video?: JRResourceURL;
+    audio?: JRResourceURL;
+}
 export declare class TextRange<Role extends TextRole, Origin extends TextOrigin> implements ClientTextRange<Role, Origin> {
     readonly origin: Origin;
     readonly role: Role;
     protected readonly chunks: readonly TextChunk[];
+    protected readonly mediaSources?: MediaSources | undefined;
     [Symbol.iterator](): Generator<TextChunk, void, unknown>;
     get formatted(): Record<PropertyKey, unknown>;
     get asString(): string;
-    constructor(origin: Origin, role: Role, chunks: readonly TextChunk[]);
+    get imageSource(): JRResourceURL | undefined;
+    get audioSource(): JRResourceURL | undefined;
+    get videoSource(): JRResourceURL | undefined;
+    constructor(origin: Origin, role: Role, chunks: readonly TextChunk[], mediaSources?: MediaSources | undefined);
 }

package/dist/lib/reactivity/text/createTextRange.d.ts

@@ -5,8 +5,7 @@ import { TextRange } from '../../../instance/text/TextRange.ts';
 import { TextRangeDefinition } from '../../../parse/text/abstract/TextRangeDefinition.ts';
 type ComputedFormTextRange<Role extends TextRole> = Accessor<TextRange<Role, 'form'>>;
 /**
- * Creates a text range (e.g. label or hint) from the provided definition,
- * reactive to:
+ * Creates a text range (e.g. label or hint) from the provided definition, reactive to:
  *
  * - The form's current language (e.g. `<label ref="jr:itext('text-id')" />`)
  * - Direct `<output>` references within the label's children

package/dist/parse/expression/TextChunkExpression.d.ts

@@ -0,0 +1,16 @@
+import { TextChunkSource } from '../../client/TextRange.ts';
+import { AnyTextRangeDefinition } from '../text/abstract/TextRangeDefinition.ts';
+import { DependentExpression } from './abstract/DependentExpression.ts';
+interface TextChunkExpressionOptions {
+    readonly isTranslated?: true;
+}
+export declare class TextChunkExpression<T extends 'nodes' | 'string'> extends DependentExpression<T> {
+    readonly source: TextChunkSource;
+    readonly stringValue: string;
+    constructor(context: AnyTextRangeDefinition, resultType: T, expression: string, source: TextChunkSource, options?: TextChunkExpressionOptions, literalValue?: string);
+    static fromLiteral(context: AnyTextRangeDefinition, stringValue: string): TextChunkExpression<'string'>;
+    static fromReference(context: AnyTextRangeDefinition, ref: string): TextChunkExpression<'string'>;
+    static fromOutput(context: AnyTextRangeDefinition, element: Element): TextChunkExpression<'string'> | null;
+    static fromTranslation(context: AnyTextRangeDefinition, maybeExpression: string): TextChunkExpression<'nodes'> | null;
+}
+export {};

package/dist/parse/shared/parseInstanceXML.d.ts

@@ -15,7 +15,7 @@ import { ModelDefinition } from '../model/ModelDefinition.ts';
  * @todo Aside from this being a hack, it's not very robust because it makes
  * assumptions which are _likely but definitely not guaranteed_!
  *
- * - Instance XML (probably) doeesn't declare a default namespace
+ * - Instance XML (probably) doesn't declare a default namespace
  * - Instance XML **definitely** declares non-default namespaces
  */
 export declare const parseInstanceXML: (model: ModelDefinition, instanceXML: string) => StaticDocument;

package/dist/parse/text/ItemsetLabelDefinition.d.ts

@@ -1,12 +1,10 @@
 import { XFormDefinition } from '../../parse/XFormDefinition.ts';
-import { ItemDefinition } from '../body/control/ItemDefinition.ts';
 import { ItemsetDefinition } from '../body/control/ItemsetDefinition.ts';
-import { RefAttributeChunk } from './abstract/TextElementDefinition.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
-export type ItemLabelOwner = ItemDefinition | ItemsetDefinition;
 export declare class ItemsetLabelDefinition extends TextRangeDefinition<'item-label'> {
     static from(form: XFormDefinition, owner: ItemsetDefinition): ItemsetLabelDefinition | null;
     readonly role = "item-label";
-    readonly chunks: readonly [RefAttributeChunk];
+    readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     private constructor();
 }

package/dist/parse/text/MessageDefinition.d.ts

@@ -1,14 +1,10 @@
-import { TextLiteralExpression } from '../expression/TextLiteralExpression.ts';
-import { TextTranslationExpression } from '../expression/TextTranslationExpression.ts';
+import { TextChunkExpression } from '../expression/TextChunkExpression.ts';
 import { BindDefinition } from '../model/BindDefinition.ts';
-import { TextBindAttributeLocalName, TextSourceNode, TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
-export type MessageSourceNode = TextSourceNode<TextBindAttributeLocalName>;
-type MessageChunk = TextLiteralExpression | TextTranslationExpression;
+import { TextBindAttributeLocalName, TextRangeDefinition } from './abstract/TextRangeDefinition.ts';
 export declare class MessageDefinition<Type extends TextBindAttributeLocalName> extends TextRangeDefinition<Type> {
     readonly role: Type;
     static from<Type extends TextBindAttributeLocalName>(bind: BindDefinition, type: Type): MessageDefinition<Type> | null;
-    readonly chunks: readonly [MessageChunk];
+    readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     private constructor();
 }
 export type AnyMessageDefinition = MessageDefinition<TextBindAttributeLocalName>;
-export {};

package/dist/parse/text/abstract/TextElementDefinition.d.ts

@@ -1,21 +1,15 @@
 import { ElementTextRole } from '../../../client/TextRange.ts';
 import { XFormDefinition } from '../../../parse/XFormDefinition.ts';
 import { ItemDefinition } from '../../body/control/ItemDefinition.ts';
-import { TextLiteralExpression } from '../../expression/TextLiteralExpression.ts';
-import { TextOutputExpression } from '../../expression/TextOutputExpression.ts';
-import { TextReferenceExpression } from '../../expression/TextReferenceExpression.ts';
-import { TextTranslationExpression } from '../../expression/TextTranslationExpression.ts';
+import { TextChunkExpression } from '../../expression/TextChunkExpression.ts';
 import { HintDefinition } from '../HintDefinition.ts';
 import { ItemLabelDefinition } from '../ItemLabelDefinition.ts';
 import { ItemsetLabelDefinition } from '../ItemsetLabelDefinition.ts';
 import { LabelDefinition, LabelOwner } from '../LabelDefinition.ts';
 import { TextSourceNode, TextRangeDefinition } from './TextRangeDefinition.ts';
-export type RefAttributeChunk = TextReferenceExpression | TextTranslationExpression;
-type TextElementChildChunk = TextLiteralExpression | TextOutputExpression;
-type TextElementChunks = readonly [RefAttributeChunk] | readonly TextElementChildChunk[];
 type TextElementOwner = ItemDefinition | LabelOwner;
 export declare abstract class TextElementDefinition<Role extends ElementTextRole> extends TextRangeDefinition<Role> {
-    readonly chunks: TextElementChunks;
+    readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     constructor(form: XFormDefinition, owner: TextElementOwner, sourceNode: TextSourceNode<Role>);
 }
 export type AnyTextElementDefinition = HintDefinition | ItemLabelDefinition | ItemsetLabelDefinition | LabelDefinition;

package/dist/parse/text/abstract/TextRangeDefinition.d.ts

@@ -2,7 +2,7 @@ import { LocalNamedElement } from '../../../../../common/types/dom.ts';
 import { TextRole } from '../../../client/TextRange.ts';
 import { XFormDefinition } from '../../../parse/XFormDefinition.ts';
 import { DependencyContext } from '../../expression/abstract/DependencyContext.ts';
-import { AnyTextChunkExpression } from '../../expression/abstract/TextChunkExpression.ts';
+import { TextChunkExpression } from '../../expression/TextChunkExpression.ts';
 import { AnyMessageDefinition } from '../MessageDefinition.ts';
 import { AnyTextElementDefinition } from './TextElementDefinition.ts';
 export type TextBindAttributeLocalName = 'constraintMsg' | 'requiredMsg';
@@ -22,7 +22,7 @@ export declare abstract class TextRangeDefinition<Role extends TextRole> extends
     abstract readonly role: Role;
     readonly parentReference: string | null;
     readonly reference: string | null;
-    abstract readonly chunks: readonly AnyTextChunkExpression[];
+    abstract readonly chunks: ReadonlyArray<TextChunkExpression<'nodes' | 'string'>>;
     get isTranslated(): boolean;
     set isTranslated(value: true);
     protected constructor(form: XFormDefinition, ownerContext: DependencyContext, sourceNode: TextSourceNode<Role>);

package/dist/solid.js

@@ -67,37 +67,17 @@ const formResourceMetadata = (resource) => {
       rawData: null
     };
   }
-  return {
-    description: "Raw string data",
-    rawData: resource
-  };
+  return;
 };
 class LoadFormFailureError extends AggregateError {
   constructor(resource, errors) {
-    const { description, rawData } = formResourceMetadata(resource);
-    const messageLines = [
-      `Failed to load form resource: ${description}`,
-      "\n",
-      ...errors.map((error) => {
-        const aggregatedMessage = error.message;
-        if (aggregatedMessage == null) {
-          return "- Unknown error";
-        }
-        return `- ${aggregatedMessage}`;
-      })
-    ];
-    if (rawData != null) {
-      messageLines.push("\n- - -\n", "Raw resource data:", rawData);
-    }
-    const message = messageLines.join("\n");
+    const metadata = formResourceMetadata(resource);
+    const errorMessages = errors.map((error) => error.message || "Unknown error").join("\n");
+    const message = metadata?.description ? `Form source: ${metadata.description}
+${errorMessages}` : errorMessages;
     super(errors, message);
     const [head, ...tail] = errors;
-    if (head != null && tail.length === 0) {
-      const { stack } = head;
-      if (typeof stack === "string") {
-        this.stack = stack;
-      }
-    }
+    this.stack = typeof head?.stack === "string" && !tail.length ? head.stack : "No error trace available.";
   }
 }
 
@@ -9402,7 +9382,7 @@ const substring = new StringFunction(
     return string2.substring(start, end);
   }
 );
-const string$2 = new StringFunction(
+const string$1 = new StringFunction(
   "string",
   [{ arityType: "optional" }],
   (context, [expression]) => (expression?.evaluate(context) ?? context).toString()
@@ -9435,13 +9415,13 @@ const translate = new StringFunction(
   }
 );
 
-const string$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+const string$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   concat: concat$1,
   contains,
   normalizeSpace,
   startsWith,
-  string: string$2,
+  string: string$1,
   stringLength,
   substring,
   substringAfter,
@@ -9453,7 +9433,7 @@ const fn$2 = new FunctionLibrary(FN_NAMESPACE_URI, [
   ...Object.values(boolean$2),
   ...Object.values(nodeset$1),
   ...Object.values(number$3),
-  ...Object.values(string$3)
+  ...Object.values(string$2)
 ]);
 
 class BaseStep {
@@ -11233,21 +11213,21 @@ const enk = new FunctionLibrary(ENKETO_NAMESPACE_URI, [
   new FunctionAlias("format-date", formatDateTime)
 ]);
 
-const itext = new StringFunction(
+const itext = new NodeSetFunction(
   "itext",
   [{ arityType: "required", typeHint: "string" }],
   (context, [itextIDExpression]) => {
     const itextID = itextIDExpression.evaluate(context).toString();
-    return XFormsXPathEvaluator.getDefaultTranslationText(context, itextID);
+    return XFormsXPathEvaluator.getTranslationValues(context, itextID) ?? [];
   }
 );
 
-const string$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+const nodeSet = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   itext
 }, Symbol.toStringTag, { value: 'Module' }));
 
-const jr$2 = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [...Object.values(string$1)]);
+const jr$2 = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [...Object.values(nodeSet)]);
 
 const booleanFromString = new BooleanFunction(
   "boolean-from-string",
@@ -18950,46 +18930,39 @@ class XFormsItextTranslations {
     return textMap.get(itextID) ?? null;
   }
   /**
+   * Retrieves all translation value elements for a given Itext in the active language.
+   *
    * @package
    *
-   * Here, "default" is meant as more precise language than "regular" as
-   * {@link https://getodk.github.io/xforms-spec/#languages | specified by ODK XForms}. In other words, this is equivalent to the following hypothetical XPath pseudo-code (whitespace added to improve structural clarity):
+   * This method fetches the `text` element matching `itextID` and returns its child `value` elements,
+   * which may have an optional `@form` attribute.
+   *
+   * The operation is conceptually similar to the following XPath query:
    *
    * ```xpath
-   * string(
-   *   imaginary:itext-translation(
-   *     xpath3-fn:environment-variable('activeLanguage')
-   *   )
-   *     /text[@id = $itextID]
-   *       /value[not(@form)]
+   * imaginary:itext-translation(
+   *   xpath3-fn:environment-variable('activeLanguage')
    * )
+   *   /text[@id = $itextID]
+   *     /value
    * ```
    *
    * Or alternately:
    *
    * ```xpath
-   * string(
-   *   imaginary:itext-root()
-   *     /translation[@lang = xpath3-fn:environment-variable('activeLanguage')]
-   *       /text[@id = $itextID]
-   *         /value[not(@form)]
-   * )
+   * imaginary:itext-root()
+   *   /translation[@lang = xpath3-fn:environment-variable('activeLanguage')]
+   *     /text[@id = $itextID]
+   *       /value
    * ```
-   *
-   * @todo The above really feels like it adds some helpful clarity to how `jr:itext()` is designed to work, and the kinds of structures, state and input involved. Since there's already some discomfort around that API as specified, it's worth considering
+   * Returns an array of `XFormsItextTranslationValueElement<T>`
    */
-  getDefaultTranslationText(itextID) {
+  getTranslationValues(itextID) {
     const textElement = this.getTranslationTextElement(itextID);
     if (textElement == null) {
-      return "";
-    }
-    const { domProvider } = this;
-    for (const valueElement of domProvider.getChildrenByLocalName(textElement, "value")) {
-      if (!domProvider.hasLocalNamedAttribute(valueElement, "form")) {
-        return domProvider.getNodeValue(valueElement);
-      }
+      return [];
     }
-    return "";
+    return [...this.domProvider.getChildrenByLocalName(textElement, "value")];
   }
   getLanguages() {
     return this.languages;
@@ -19026,9 +18999,9 @@ class XFormsXPathEvaluator extends Evaluator {
     assertInternalXFormsXPathEvaluatorContext(context);
     return context.evaluator.secondaryInstancesById.get(id) ?? null;
   }
-  static getDefaultTranslationText(context, itextID) {
+  static getTranslationValues(context, itextID) {
     assertInternalXFormsXPathEvaluatorContext(context);
-    return context.evaluator.itextTranslations.getDefaultTranslationText(itextID);
+    return context.evaluator.itextTranslations.getTranslationValues(itextID);
   }
   rootNode;
   /**
@@ -19582,8 +19555,13 @@ const isTranslationFunctionCall = (syntaxNode) => {
   ]);
 };
 const isTranslationExpression = (expression) => {
-  const { rootNode } = expressionParser.parse(expression);
-  const functionCallNode = findTypedPrincipalExpressionNode(["function_call"], rootNode);
+  let result;
+  try {
+    result = expressionParser.parse(expression);
+  } catch {
+    return false;
+  }
+  const functionCallNode = findTypedPrincipalExpressionNode(["function_call"], result.rootNode);
   if (functionCallNode == null) {
     return false;
   }
@@ -19747,77 +19725,43 @@ class DependentExpression {
   }
 }
 
+const isOutputElement = (element) => {
+  return element.localName === "output" && element.hasAttribute("value");
+};
 class TextChunkExpression extends DependentExpression {
+  source;
+  // Set for the literal source, blank otherwise
   stringValue;
-  constructor(context, expression, options = {}) {
-    super(context, "string", expression, {
+  constructor(context, resultType, expression, source, options = {}, literalValue = "") {
+    super(context, resultType, expression, {
       semanticDependencies: {
         translations: options.isTranslated
       },
       ignoreContextReference: true
     });
+    this.source = source;
+    this.stringValue = literalValue;
   }
-}
-
-class TextLiteralExpression extends TextChunkExpression {
-  constructor(context, stringValue) {
-    super(context, "null");
-    this.stringValue = stringValue;
-  }
-  static from(context, stringValue) {
-    return new this(context, stringValue);
-  }
-  source = "literal";
-}
-
-const isOutputElement = (element) => {
-  return element.localName === "output" && element.hasAttribute("value");
-};
-class TextOutputExpression extends TextChunkExpression {
-  static from(context, element) {
-    if (isOutputElement(element)) {
-      return new this(context, element);
-    }
-    return null;
-  }
-  source = "output";
-  constructor(context, element) {
-    super(context, element.getAttribute("value"));
+  static fromLiteral(context, stringValue) {
+    return new TextChunkExpression(context, "string", "null", "literal", {}, stringValue);
   }
-}
-
-class TextReferenceExpression extends TextChunkExpression {
-  static from(context, refExpression) {
-    return new this(context, refExpression);
+  static fromReference(context, ref) {
+    return new TextChunkExpression(context, "string", ref, "reference");
   }
-  source = "reference";
-  constructor(context, refExpression) {
-    super(context, refExpression);
-  }
-}
-
-class TextTranslationExpression extends TextChunkExpression {
-  static fromMessage(context, maybeExpression) {
-    try {
-      expressionParser.parse(maybeExpression);
-    } catch {
+  static fromOutput(context, element) {
+    if (!isOutputElement(element)) {
       return null;
     }
-    if (isTranslationExpression(maybeExpression)) {
-      return new this(context, maybeExpression);
-    }
-    return null;
+    return new TextChunkExpression(context, "string", element.getAttribute("value"), "output");
   }
-  static from(context, maybeExpression) {
+  static fromTranslation(context, maybeExpression) {
     if (isTranslationExpression(maybeExpression)) {
-      return new this(context, maybeExpression);
+      return new TextChunkExpression(context, "nodes", maybeExpression, "translation", {
+        isTranslated: true
+      });
     }
     return null;
   }
-  source = "translation";
-  constructor(context, expression) {
-    super(context, expression, { isTranslated: true });
-  }
 }
 
 const absolutePathNodeList = (pathNode) => {
@@ -20066,16 +20010,20 @@ class TextElementDefinition extends TextRangeDefinition {
     if (refExpression == null) {
       this.chunks = Array.from(sourceNode.childNodes).flatMap((childNode) => {
         if (isElementNode(childNode)) {
-          return TextOutputExpression.from(context, childNode) ?? [];
+          return TextChunkExpression.fromOutput(context, childNode) ?? [];
         }
         if (isTextNode(childNode)) {
-          return TextLiteralExpression.from(context, childNode.data);
+          return TextChunkExpression.fromLiteral(context, childNode.data);
         }
         return [];
       });
     } else {
-      const refChunk = TextTranslationExpression.from(context, refExpression) ?? TextReferenceExpression.from(context, refExpression);
-      this.chunks = [refChunk];
+      const expression = TextChunkExpression.fromTranslation(context, refExpression);
+      if (expression != null) {
+        this.chunks = [expression];
+      } else {
+        this.chunks = [TextChunkExpression.fromReference(context, refExpression)];
+      }
     }
   }
 }
@@ -20327,8 +20275,12 @@ class ItemsetLabelDefinition extends TextRangeDefinition {
     if (refExpression == null) {
       throw new Error("<itemset><label> missing ref attribute");
     }
-    const refChunk = TextTranslationExpression.from(this, refExpression) ?? TextReferenceExpression.from(this, refExpression);
-    this.chunks = [refChunk];
+    const expression = TextChunkExpression.fromTranslation(this, refExpression);
+    if (expression != null) {
+      this.chunks = [expression];
+    } else {
+      this.chunks = [TextChunkExpression.fromReference(this, refExpression)];
+    }
   }
 }
 
@@ -21236,8 +21188,12 @@ class MessageDefinition extends TextRangeDefinition {
   constructor(bind, role, message) {
     super(bind.form, bind, null);
     this.role = role;
-    const chunk = TextTranslationExpression.fromMessage(this, message) ?? TextLiteralExpression.from(this, message);
-    this.chunks = [chunk];
+    const expression = TextChunkExpression.fromTranslation(this, message);
+    if (expression != null) {
+      this.chunks = [expression];
+    } else {
+      this.chunks = [TextChunkExpression.fromLiteral(this, message)];
+    }
   }
   static from(bind, type) {
     const message = bind.bindElement.getAttributeNS(JAVAROSA_NAMESPACE_URI$1, type);
@@ -27151,7 +27107,8 @@ const getWrappedInstanceRootElement = (xml) => {
   return root;
 };
 const parseInstanceXML = (model, instanceXML) => {
-  const wrappedXML = wrapInstanceXML(model, instanceXML);
+  const cleanedXML = instanceXML.replace(/<\?xml\s+[^?]*\?>\s*/, "");
+  const wrappedXML = wrapInstanceXML(model, cleanedXML);
   const root = getWrappedInstanceRootElement(wrappedXML);
   return parseStaticDocumentFromDOMSubtree(root);
 };
@@ -29122,10 +29079,11 @@ class TextChunk {
 }
 
 class TextRange {
-  constructor(origin, role, chunks) {
+  constructor(origin, role, chunks, mediaSources) {
     this.origin = origin;
     this.role = role;
     this.chunks = chunks;
+    this.mediaSources = mediaSources;
   }
   *[Symbol.iterator]() {
     yield* this.chunks;
@@ -29136,44 +29094,56 @@ class TextRange {
   get asString() {
     return this.chunks.map((chunk) => chunk.asString).join("");
   }
+  get imageSource() {
+    return this.mediaSources?.image;
+  }
+  get audioSource() {
+    return this.mediaSources?.audio;
+  }
+  get videoSource() {
+    return this.mediaSources?.video;
+  }
 }
 
-const createComputedTextChunk = (context, textSource) => {
-  const { source } = textSource;
-  if (source === "literal") {
-    const { stringValue } = textSource;
-    return {
-      source,
-      getText: () => stringValue
-    };
-  }
-  return context.scope.runTask(() => {
-    const getText = createComputedExpression(context, textSource, {
-      defaultValue: ""
-    });
-    return {
-      source,
-      getText
-    };
-  });
-};
-const createTextChunks = (context, textSources) => {
-  return context.scope.runTask(() => {
-    const chunkComputations = textSources.map((textSource) => {
-      return createComputedTextChunk(context, textSource);
-    });
-    return createMemo(() => {
-      return chunkComputations.map(({ source, getText }) => {
-        return new TextChunk(context, source, getText());
-      });
+const createTextChunks = (context, chunkExpressions) => {
+  return createMemo(() => {
+    const chunks = [];
+    const mediaSources = {};
+    chunkExpressions.forEach((chunkExpression) => {
+      if (chunkExpression.source === "literal") {
+        chunks.push(new TextChunk(context, chunkExpression.source, chunkExpression.stringValue));
+        return;
+      }
+      const computed = createComputedExpression(context, chunkExpression)();
+      if (typeof computed === "string") {
+        chunks.push(new TextChunk(context, chunkExpression.source, computed));
+        return;
+      } else {
+        computed.forEach((itextForm) => {
+          if (isEngineXPathElement(itextForm) && itextForm instanceof StaticElement) {
+            const formAttribute = itextForm.getAttributeValue("form");
+            if (!formAttribute) {
+              const defaultFormValue = itextForm.getXPathValue();
+              chunks.push(new TextChunk(context, chunkExpression.source, defaultFormValue));
+            } else if (["image", "video", "audio"].includes(formAttribute)) {
+              const formValue = itextForm.getXPathValue();
+              if (JRResourceURL.isJRResourceReference(formValue)) {
+                mediaSources[formAttribute] = JRResourceURL.from(formValue);
+              }
+            }
+          }
+        });
+      }
     });
+    return { chunks, mediaSources };
   });
 };
 const createTextRange = (context, role, definition) => {
   return context.scope.runTask(() => {
-    const getTextChunks = createTextChunks(context, definition.chunks);
+    const textChunks = createTextChunks(context, definition.chunks);
     return createMemo(() => {
-      return new TextRange("form", role, getTextChunks());
+      const chunks = textChunks();
+      return new TextRange("form", role, chunks.chunks, chunks.mediaSources);
     });
   });
 };
@@ -29340,8 +29310,7 @@ const createInstanceValueState = (context) => {
 const engineViolationMessage = (context, role) => {
   const messageText = VALIDATION_TEXT[role];
   const chunk = new TextChunk(context, "literal", messageText);
-  const message = new TextRange("engine", role, [chunk]);
-  return () => message;
+  return () => new TextRange("engine", role, [chunk]);
 };
 const createViolationMessage = (context, role, definition) => {
   if (definition == null) {
@@ -30518,6 +30487,9 @@ class SelectControl extends ValueNode {
     this.appearances = definition.bodyElement.appearances;
     this.selectType = definition.bodyElement.type;
     const valueOptions = createItemCollection(this);
+    const isSelectWithImages = this.scope.runTask(() => {
+      return createMemo(() => valueOptions().some((item) => !!item.label.imageSource));
+    });
     const mapOptionsByValue = this.scope.runTask(() => {
       return createMemo(() => {
         return new Map(valueOptions().map((item) => [item.value, item]));
@@ -30552,7 +30524,8 @@ class SelectControl extends ValueNode {
         children: null,
         valueOptions,
         value: valueState,
-        instanceValue: this.getInstanceValue
+        instanceValue: this.getInstanceValue,
+        isSelectWithImages
       },
       this.instanceConfig
     );