xmlui 0.9.0 → 0.9.1

package/dist/{apiInterceptorWorker-B1u6prJM.mjs → apiInterceptorWorker-230V_-Ds.mjs}

@@ -12,7 +12,7 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _executor, _DeferredPromise_instances, decorate_fn, _a2;
 import { delay as delay$1, HttpResponse, http } from "msw";
 import { isArray, isObject as isObject$1, mapValues } from "lodash-es";
-import { r as runEventHandlerCode, g as getDate, d as delay, m as miscellaneousUtils, a as dateFunctions, o as orderBy, T as ThrowStatementError } from "./index-CVvazA5D.mjs";
+import { r as runEventHandlerCode, g as getDate, d as delay, m as miscellaneousUtils, a as dateFunctions, o as orderBy, T as ThrowStatementError } from "./index-DUwwx3L4.mjs";
 import Dexie from "dexie";
 var POSITIONALS_EXP = /(%?)(%([sdijo]))/g;
 function serializePositional(positional, flag) {

package/dist/{index-CVvazA5D.mjs → index-DUwwx3L4.mjs}

@@ -30808,7 +30808,7 @@ function IconProvider({ children }) {
     /* @__PURE__ */ jsx("svg", { style: { display: "none" }, ref: spriteRootRef })
   ] });
 }
-const version = "0.9.0";
+const version = "0.9.1";
 const ApiInterceptorContext = createContext(null);
 function useApiInterceptorContext() {
   return useContext(ApiInterceptorContext);
@@ -31224,12 +31224,15 @@ async function evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thre
 }
 async function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
   await evaluator(thisStack, expr.obj, evalContext, thread);
+  await completeExprValue(expr.obj, thread);
   return evalMemberAccessCore(thisStack, expr, evalContext, thread);
 }
 async function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
   await evaluator(thisStack, expr.obj, evalContext, thread);
+  await completeExprValue(expr.obj, thread);
   await evaluator(thisStack, expr.member, evalContext, thread);
   thisStack.pop();
+  await completeExprValue(expr.member, thread);
   return evalCalculatedMemberAccessCore(thisStack, expr, evalContext, thread);
 }
 async function evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread) {
@@ -31305,14 +31308,13 @@ async function evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, t
 async function evalUnaryAsync(evaluator, thisStack, expr, evalContext, thread) {
   await evaluator(thisStack, expr.expr, evalContext, thread);
   thisStack.pop();
+  await completeExprValue(expr.expr, thread);
   return evalUnaryCore(expr, thisStack, evalContext, thread);
 }
 async function evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread) {
-  var _a, _b;
   await evaluator(thisStack, expr.left, evalContext, thread);
   thisStack.pop();
-  const l = await completePromise((_a = getExprValue(expr.left, thread)) == null ? void 0 : _a.value);
-  setExprValue(expr.left, { value: l }, thread);
+  const l = await completeExprValue(expr.left, thread);
   if (expr.op === "&&" && !l) {
     setExprValue(expr, { value: l }, thread);
     return l;
@@ -31323,13 +31325,13 @@ async function evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread)
   }
   await evaluator(thisStack, expr.right, evalContext, thread);
   thisStack.pop();
-  const r = await completePromise((_b = getExprValue(expr.right, thread)) == null ? void 0 : _b.value);
-  setExprValue(expr.right, { value: r }, thread);
+  await completeExprValue(expr.right, thread);
   return evalBinaryCore(expr, thisStack, evalContext, thread);
 }
 async function evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread) {
-  const condition = await evaluator(thisStack, expr.cond, evalContext, thread);
+  await evaluator(thisStack, expr.cond, evalContext, thread);
   thisStack.pop();
+  const condition = await completeExprValue(expr.cond, thread);
   const value = await evaluator(
     thisStack,
     condition ? expr.thenE : expr.elseE,
@@ -31348,8 +31350,10 @@ async function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thre
   }
   await evaluator(thisStack, leftValue, evalContext, thread);
   thisStack.pop();
+  await completeExprValue(leftValue, thread);
   await evaluator(thisStack, expr.expr, evalContext, thread);
   thisStack.pop();
+  await completeExprValue(expr.expr, thread);
   const value = evalAssignmentCore(thisStack, expr, evalContext, thread);
   if (updatesState && evalContext.onDidUpdate) {
     evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
@@ -31364,6 +31368,7 @@ async function evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, threa
   }
   await evaluator(thisStack, expr.expr, evalContext, thread);
   thisStack.pop();
+  await completeExprValue(expr.expr, thread);
   const value = evalPreOrPostCore(thisStack, expr, evalContext, thread);
   if (updatesState && evalContext.onDidUpdate) {
     evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
@@ -31377,12 +31382,14 @@ async function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalConte
   let hostObject;
   if (expr.obj.type === T_MEMBER_ACCESS_EXPRESSION) {
     hostObject = await evaluator(thisStack, expr.obj.obj, evalContext, thread);
+    await completeExprValue(expr.obj.obj, thread);
     functionObj = evalMemberAccessCore(thisStack, expr.obj, evalContext, thread);
     if (expr.obj.obj.type === T_IDENTIFIER && (hostObject == null ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT)) {
       implicitContextObject = hostObject;
     }
   } else {
-    functionObj = await evaluator(thisStack, expr.obj, evalContext, thread);
+    await evaluator(thisStack, expr.obj, evalContext, thread);
+    functionObj = await completeExprValue(expr.obj, thread);
   }
   thisStack.pop();
   const functionArgs = [];
@@ -31405,7 +31412,8 @@ async function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalConte
     for (let i = 0; i < expr.arguments.length; i++) {
       const arg = expr.arguments[i];
       if (arg.type === T_SPREAD_EXPRESSION) {
-        const funcArg = await evaluator([], arg.expr, evalContext, thread);
+        await evaluator([], arg.expr, evalContext, thread);
+        const funcArg = await completeExprValue(arg.expr, thread);
         if (!Array.isArray(funcArg)) {
           throw new Error("Spread operator within a function invocation expects an array operand.");
         }
@@ -31418,7 +31426,8 @@ async function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalConte
           };
           functionArgs.push(wrappedFunc);
         } else {
-          const funcArg = await evaluator([], arg, evalContext, thread);
+          await evaluator([], arg, evalContext, thread);
+          const funcArg = await completeExprValue(arg, thread);
           if (funcArg == null ? void 0 : funcArg._ARROW_EXPR_) {
             const wrappedFuncArg = await createArrowFunctionAsync(evaluator, funcArg);
             const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
@@ -31623,12 +31632,19 @@ async function completePromise(input2) {
 async function evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
   const segmentValues = new Array(expr.segments.length);
   for (let i = 0; i < expr.segments.length; ++i) {
-    const evaledValue = await evaluator(thisStack, expr.segments[i], evalContext, thread);
+    await evaluator(thisStack, expr.segments[i], evalContext, thread);
     thisStack.pop();
+    const evaledValue = await completeExprValue(expr.segments[i], thread);
     segmentValues[i] = evaledValue;
   }
   return evalTemplateLiteralCore(segmentValues);
 }
+async function completeExprValue(expr, thread) {
+  const exprValue = getExprValue(expr, thread);
+  const awaited = await completePromise(exprValue == null ? void 0 : exprValue.value);
+  setExprValue(expr, { ...exprValue, value: awaited }, thread);
+  return awaited;
+}
 async function processStatementQueueAsync(statements, evalContext, thread) {
   var _a, _b, _c;
   if (!thread) {
@@ -34776,7 +34792,7 @@ function ApiInterceptorProvider({
       let interceptorWorker;
       (async () => {
         if (process.env.VITE_MOCK_ENABLED) {
-          const { createApiInterceptorWorker } = await import("./apiInterceptorWorker-B1u6prJM.mjs");
+          const { createApiInterceptorWorker } = await import("./apiInterceptorWorker-230V_-Ds.mjs");
           if (interceptor) {
             interceptorWorker = await createApiInterceptorWorker(interceptor, apiWorker);
             if (!apiWorker) {

package/dist/scripts/src/components-core/script-runner/eval-tree-async.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evalBindingAsync = evalBindingAsync;
 exports.executeArrowExpression = executeArrowExpression;
+exports.completeExprValue = completeExprValue;
 const lodash_es_1 = require("lodash-es");
 const ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
 const process_statement_async_1 = require("./process-statement-async");
@@ -128,6 +129,7 @@ function evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread) {
 function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         yield evaluator(thisStack, expr.obj, evalContext, thread);
+        yield completeExprValue(expr.obj, thread);
         // --- At this point we definitely keep the parent object on `thisStack`, as it will be the context object
         // --- of a FunctionInvocationExpression, if that follows the MemberAccess. Other operations would call
         // --- `thisStack.pop()` to remove the result from the previous `evalBindingExpressionTree` call.
@@ -137,8 +139,10 @@ function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread)
 function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         yield evaluator(thisStack, expr.obj, evalContext, thread);
+        yield completeExprValue(expr.obj, thread);
         yield evaluator(thisStack, expr.member, evalContext, thread);
         thisStack.pop();
+        yield completeExprValue(expr.member, thread);
         return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(thisStack, expr, evalContext, thread);
     });
 }
@@ -230,16 +234,15 @@ function evalUnaryAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         yield evaluator(thisStack, expr.expr, evalContext, thread);
         thisStack.pop();
+        yield completeExprValue(expr.expr, thread);
         return (0, eval_tree_common_1.evalUnaryCore)(expr, thisStack, evalContext, thread);
     });
 }
 function evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
         yield evaluator(thisStack, expr.left, evalContext, thread);
         thisStack.pop();
-        const l = yield completePromise((_a = (0, eval_tree_common_1.getExprValue)(expr.left, thread)) === null || _a === void 0 ? void 0 : _a.value);
-        (0, eval_tree_common_1.setExprValue)(expr.left, { value: l }, thread);
+        const l = yield completeExprValue(expr.left, thread);
         if (expr.op === "&&" && !l) {
             (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
             return l;
@@ -250,15 +253,15 @@ function evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread) {
         }
         yield evaluator(thisStack, expr.right, evalContext, thread);
         thisStack.pop();
-        const r = yield completePromise((_b = (0, eval_tree_common_1.getExprValue)(expr.right, thread)) === null || _b === void 0 ? void 0 : _b.value);
-        (0, eval_tree_common_1.setExprValue)(expr.right, { value: r }, thread);
+        yield completeExprValue(expr.right, thread);
         return (0, eval_tree_common_1.evalBinaryCore)(expr, thisStack, evalContext, thread);
     });
 }
 function evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        const condition = yield evaluator(thisStack, expr.cond, evalContext, thread);
+        yield evaluator(thisStack, expr.cond, evalContext, thread);
         thisStack.pop();
+        const condition = yield completeExprValue(expr.cond, thread);
         const value = yield evaluator(thisStack, condition ? expr.thenE : expr.elseE, evalContext, thread);
         (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
         return value;
@@ -274,8 +277,10 @@ function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread) {
         }
         yield evaluator(thisStack, leftValue, evalContext, thread);
         thisStack.pop();
+        yield completeExprValue(leftValue, thread);
         yield evaluator(thisStack, expr.expr, evalContext, thread);
         thisStack.pop();
+        yield completeExprValue(expr.expr, thread);
         const value = (0, eval_tree_common_1.evalAssignmentCore)(thisStack, expr, evalContext, thread);
         if (updatesState && evalContext.onDidUpdate) {
             evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
@@ -292,6 +297,7 @@ function evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread) {
         }
         yield evaluator(thisStack, expr.expr, evalContext, thread);
         thisStack.pop();
+        yield completeExprValue(expr.expr, thread);
         const value = (0, eval_tree_common_1.evalPreOrPostCore)(thisStack, expr, evalContext, thread);
         if (updatesState && evalContext.onDidUpdate) {
             evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
@@ -308,6 +314,7 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
         // --- Check for contexted object
         if (expr.obj.type === ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION) {
             hostObject = yield evaluator(thisStack, expr.obj.obj, evalContext, thread);
+            yield completeExprValue(expr.obj.obj, thread);
             functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr.obj, evalContext, thread);
             if (expr.obj.obj.type === ScriptingSourceTreeExp_1.T_IDENTIFIER && (hostObject === null || hostObject === void 0 ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT)) {
                 implicitContextObject = hostObject;
@@ -315,7 +322,8 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
         }
         else {
             // --- Get the object on which to invoke the function
-            functionObj = yield evaluator(thisStack, expr.obj, evalContext, thread);
+            yield evaluator(thisStack, expr.obj, evalContext, thread);
+            functionObj = yield completeExprValue(expr.obj, thread);
         }
         thisStack.pop();
         // --- Keep function arguments here, we pass it to the function later
@@ -335,7 +343,8 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
             for (let i = 0; i < expr.arguments.length; i++) {
                 const arg = expr.arguments[i];
                 if (arg.type === ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION) {
-                    const funcArg = yield evaluator([], arg.expr, evalContext, thread);
+                    yield evaluator([], arg.expr, evalContext, thread);
+                    const funcArg = yield completeExprValue(arg.expr, thread);
                     if (!Array.isArray(funcArg)) {
                         throw new Error("Spread operator within a function invocation expects an array operand.");
                     }
@@ -350,7 +359,8 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
                         functionArgs.push(wrappedFunc);
                     }
                     else {
-                        const funcArg = yield evaluator([], arg, evalContext, thread);
+                        yield evaluator([], arg, evalContext, thread);
+                        const funcArg = yield completeExprValue(arg, thread);
                         if (funcArg === null || funcArg === void 0 ? void 0 : funcArg._ARROW_EXPR_) {
                             const wrappedFuncArg = yield createArrowFunctionAsync(evaluator, funcArg);
                             const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
@@ -586,10 +596,19 @@ function evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, threa
     return __awaiter(this, void 0, void 0, function* () {
         const segmentValues = new Array(expr.segments.length);
         for (let i = 0; i < expr.segments.length; ++i) {
-            const evaledValue = yield evaluator(thisStack, expr.segments[i], evalContext, thread);
+            yield evaluator(thisStack, expr.segments[i], evalContext, thread);
             thisStack.pop();
+            const evaledValue = yield completeExprValue(expr.segments[i], thread);
             segmentValues[i] = evaledValue;
         }
         return (0, eval_tree_common_1.evalTemplateLiteralCore)(segmentValues);
     });
 }
+function completeExprValue(expr, thread) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exprValue = (0, eval_tree_common_1.getExprValue)(expr, thread);
+        const awaited = yield completePromise(exprValue === null || exprValue === void 0 ? void 0 : exprValue.value);
+        (0, eval_tree_common_1.setExprValue)(expr, Object.assign(Object.assign({}, exprValue), { value: awaited }), thread);
+        return awaited;
+    });
+}

package/dist/xmlui-standalone.umd.js

@@ -15998,7 +15998,7 @@ li ._htmlOl_1snis_205 {
       });
     }
   }
-  var define_process_env_default$9 = { NODE_ENV: "production", VITE_MOCK_ENABLED: true, VITE_MOCK_WORKER_LOCATION: "mockApi.js", VITE_USED_COMPONENTS_Pdf: "false", VITE_USED_COMPONENTS_Chart: "false", VITE_USER_COMPONENTS_XmluiCodeHightlighter: "false", VITE_USED_COMPONENTS_Tree: "false", VITE_XMLUI_VERSION: "0.9.0 (built 4/1/2025)" };
+  var define_process_env_default$9 = { NODE_ENV: "production", VITE_MOCK_ENABLED: true, VITE_MOCK_WORKER_LOCATION: "mockApi.js", VITE_USED_COMPONENTS_Pdf: "false", VITE_USED_COMPONENTS_Chart: "false", VITE_USER_COMPONENTS_XmluiCodeHightlighter: "false", VITE_USED_COMPONENTS_Tree: "false", VITE_XMLUI_VERSION: "0.9.1 (built 4/1/2025)" };
   class Mutation extends Removable {
     constructor(config) {
       super();
@@ -131167,7 +131167,7 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
       /* @__PURE__ */ jsxRuntimeExports.jsx("svg", { style: { display: "none" }, ref: spriteRootRef })
     ] });
   }
-  const version = "0.9.0";
+  const version = "0.9.1";
   const ApiInterceptorContext = reactExports.createContext(null);
   function useApiInterceptorContext() {
     return reactExports.useContext(ApiInterceptorContext);
@@ -131583,12 +131583,15 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
   }
   async function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
     await evaluator(thisStack, expr.obj, evalContext, thread);
+    await completeExprValue(expr.obj, thread);
     return evalMemberAccessCore(thisStack, expr, evalContext, thread);
   }
   async function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
     await evaluator(thisStack, expr.obj, evalContext, thread);
+    await completeExprValue(expr.obj, thread);
     await evaluator(thisStack, expr.member, evalContext, thread);
     thisStack.pop();
+    await completeExprValue(expr.member, thread);
     return evalCalculatedMemberAccessCore(thisStack, expr, evalContext, thread);
   }
   async function evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread) {
@@ -131664,14 +131667,13 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
   async function evalUnaryAsync(evaluator, thisStack, expr, evalContext, thread) {
     await evaluator(thisStack, expr.expr, evalContext, thread);
     thisStack.pop();
+    await completeExprValue(expr.expr, thread);
     return evalUnaryCore(expr, thisStack, evalContext, thread);
   }
   async function evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread) {
-    var _a3, _b3;
     await evaluator(thisStack, expr.left, evalContext, thread);
     thisStack.pop();
-    const l2 = await completePromise((_a3 = getExprValue(expr.left, thread)) == null ? void 0 : _a3.value);
-    setExprValue(expr.left, { value: l2 }, thread);
+    const l2 = await completeExprValue(expr.left, thread);
     if (expr.op === "&&" && !l2) {
       setExprValue(expr, { value: l2 }, thread);
       return l2;
@@ -131682,13 +131684,13 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
     }
     await evaluator(thisStack, expr.right, evalContext, thread);
     thisStack.pop();
-    const r2 = await completePromise((_b3 = getExprValue(expr.right, thread)) == null ? void 0 : _b3.value);
-    setExprValue(expr.right, { value: r2 }, thread);
+    await completeExprValue(expr.right, thread);
     return evalBinaryCore(expr, thisStack, evalContext, thread);
   }
   async function evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread) {
-    const condition = await evaluator(thisStack, expr.cond, evalContext, thread);
+    await evaluator(thisStack, expr.cond, evalContext, thread);
     thisStack.pop();
+    const condition = await completeExprValue(expr.cond, thread);
     const value = await evaluator(
       thisStack,
       condition ? expr.thenE : expr.elseE,
@@ -131707,8 +131709,10 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
     }
     await evaluator(thisStack, leftValue, evalContext, thread);
     thisStack.pop();
+    await completeExprValue(leftValue, thread);
     await evaluator(thisStack, expr.expr, evalContext, thread);
     thisStack.pop();
+    await completeExprValue(expr.expr, thread);
     const value = evalAssignmentCore(thisStack, expr, evalContext, thread);
     if (updatesState && evalContext.onDidUpdate) {
       evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
@@ -131723,6 +131727,7 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
     }
     await evaluator(thisStack, expr.expr, evalContext, thread);
     thisStack.pop();
+    await completeExprValue(expr.expr, thread);
     const value = evalPreOrPostCore(thisStack, expr, evalContext, thread);
     if (updatesState && evalContext.onDidUpdate) {
       evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
@@ -131736,12 +131741,14 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
     let hostObject;
     if (expr.obj.type === T_MEMBER_ACCESS_EXPRESSION) {
       hostObject = await evaluator(thisStack, expr.obj.obj, evalContext, thread);
+      await completeExprValue(expr.obj.obj, thread);
       functionObj = evalMemberAccessCore(thisStack, expr.obj, evalContext, thread);
       if (expr.obj.obj.type === T_IDENTIFIER && (hostObject == null ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT)) {
         implicitContextObject = hostObject;
       }
     } else {
-      functionObj = await evaluator(thisStack, expr.obj, evalContext, thread);
+      await evaluator(thisStack, expr.obj, evalContext, thread);
+      functionObj = await completeExprValue(expr.obj, thread);
     }
     thisStack.pop();
     const functionArgs = [];
@@ -131764,7 +131771,8 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
       for (let i2 = 0; i2 < expr.arguments.length; i2++) {
         const arg = expr.arguments[i2];
         if (arg.type === T_SPREAD_EXPRESSION) {
-          const funcArg = await evaluator([], arg.expr, evalContext, thread);
+          await evaluator([], arg.expr, evalContext, thread);
+          const funcArg = await completeExprValue(arg.expr, thread);
           if (!Array.isArray(funcArg)) {
             throw new Error("Spread operator within a function invocation expects an array operand.");
           }
@@ -131777,7 +131785,8 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
             };
             functionArgs.push(wrappedFunc);
           } else {
-            const funcArg = await evaluator([], arg, evalContext, thread);
+            await evaluator([], arg, evalContext, thread);
+            const funcArg = await completeExprValue(arg, thread);
             if (funcArg == null ? void 0 : funcArg._ARROW_EXPR_) {
               const wrappedFuncArg = await createArrowFunctionAsync(evaluator, funcArg);
               const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
@@ -131982,12 +131991,19 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
   async function evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
     const segmentValues = new Array(expr.segments.length);
     for (let i2 = 0; i2 < expr.segments.length; ++i2) {
-      const evaledValue = await evaluator(thisStack, expr.segments[i2], evalContext, thread);
+      await evaluator(thisStack, expr.segments[i2], evalContext, thread);
       thisStack.pop();
+      const evaledValue = await completeExprValue(expr.segments[i2], thread);
       segmentValues[i2] = evaledValue;
     }
     return evalTemplateLiteralCore(segmentValues);
   }
+  async function completeExprValue(expr, thread) {
+    const exprValue = getExprValue(expr, thread);
+    const awaited = await completePromise(exprValue == null ? void 0 : exprValue.value);
+    setExprValue(expr, { ...exprValue, value: awaited }, thread);
+    return awaited;
+  }
   async function processStatementQueueAsync(statements, evalContext, thread) {
     var _a3, _b3, _c3;
     if (!thread) {
@@ -135906,7 +135922,7 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
     ToneChangerButton: ToneChangerButtonMd,
     Tree: TreeMd
   };
-  var define_process_env_default$2 = { VITE_XMLUI_VERSION: "0.9.0 (built 4/1/2025)" };
+  var define_process_env_default$2 = { VITE_XMLUI_VERSION: "0.9.1 (built 4/1/2025)" };
   const MAIN_FILE = "Main." + componentFileExtension;
   const MAIN_CODE_BEHIND_FILE = "Main." + codeBehindFileExtension;
   const CONFIG_FILE = "config.json";
@@ -148929,7 +148945,7 @@ For more information, see https://radix-ui.com/primitives/docs/components/${titl
   function isResponseWithoutBody(status) {
     return RESPONSE_STATUS_CODES_WITHOUT_BODY.has(status);
   }
-  var define_process_env_default$1 = { NODE_ENV: "production", VITE_MOCK_ENABLED: true, VITE_MOCK_WORKER_LOCATION: "mockApi.js", VITE_USED_COMPONENTS_Pdf: "false", VITE_USED_COMPONENTS_Chart: "false", VITE_USER_COMPONENTS_XmluiCodeHightlighter: "false", VITE_USED_COMPONENTS_Tree: "false", VITE_XMLUI_VERSION: "0.9.0 (built 4/1/2025)" };
+  var define_process_env_default$1 = { NODE_ENV: "production", VITE_MOCK_ENABLED: true, VITE_MOCK_WORKER_LOCATION: "mockApi.js", VITE_USED_COMPONENTS_Pdf: "false", VITE_USED_COMPONENTS_Chart: "false", VITE_USER_COMPONENTS_XmluiCodeHightlighter: "false", VITE_USED_COMPONENTS_Tree: "false", VITE_XMLUI_VERSION: "0.9.1 (built 4/1/2025)" };
   var __defProp$7 = Object.defineProperty;
   var __export = (target2, all2) => {
     for (var name2 in all2)

package/dist/xmlui.mjs

@@ -1,4 +1,4 @@
-import { A, B, E, I, i, h, S, b, c, e, f, j, p, s, t, k, u } from "./index-CVvazA5D.mjs";
+import { A, B, E, I, i, h, S, b, c, e, f, j, p, s, t, k, u } from "./index-DUwwx3L4.mjs";
 export {
   A as AppRoot,
   B as Button,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xmlui",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "sideEffects": false,
   "scripts": {
     "start-test-bed": "cd src/testing/infrastructure && xmlui start",