funcity 1.3.0 → 1.4.0

package/dist/index.cjs

@@ -1,11 +1,11 @@
 /*!
  * name: funcity
- * version: 1.3.0
+ * version: 1.4.0
  * description: A functional language interpreter with text processing
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/funcity
- * git.commit.hash: 7acc4170f77cc7da97c545f902eff4a6a52c267e
+ * git.commit.hash: dc3a379ed9e44802528a8043aee8bb54b97c9bfc
  */
 
 "use strict";
@@ -629,6 +629,13 @@ const fromError = (error) => {
     return "unknown";
   }
 };
+const isPromiseLike = (value) => {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.then === "function";
+};
 const widerRange = (...args) => {
   const lastArg = args[args.length - 1];
   const logs = Array.isArray(lastArg) ? lastArg : void 0;
@@ -1745,13 +1752,13 @@ const runParser = (tokens, logs) => {
   const blockNodes = parseBlock(cursor, logs);
   return blockNodes;
 };
-const throwError = (info) => {
+const throwError$1 = (info) => {
   throw new FunCityReducerError({
     type: "error",
     ...info
   });
 };
-const deconstructConditionalCombine = (name) => {
+const deconstructConditionalCombine$1 = (name) => {
   if (name.length >= 1) {
     const last = name[name.length - 1];
     if (last === "?") {
@@ -1766,12 +1773,12 @@ const deconstructConditionalCombine = (name) => {
     canIgnore: false
   };
 };
-const resolveVariable = (context, name, signal) => {
-  const result = deconstructConditionalCombine(name.name);
+const resolveVariable$1 = (context, name, signal) => {
+  const result = deconstructConditionalCombine$1(name.name);
   const valueResult = context.getValue(result.name, signal);
   if (!valueResult.isFound) {
     if (!result.canIgnore) {
-      throwError({
+      throwError$1({
         description: `variable is not bound: ${result.name}`,
         range: name.range
       });
@@ -1786,11 +1793,11 @@ const resolveDotNode = async (context, node, signal) => {
   const firstSegmentOptional = (_b = (_a = node.segments[0]) == null ? void 0 : _a.optional) != null ? _b : false;
   let value;
   if (node.base.kind === "variable") {
-    const baseResult = deconstructConditionalCombine(node.base.name);
+    const baseResult = deconstructConditionalCombine$1(node.base.name);
     const valueResult = context.getValue(baseResult.name, signal);
     if (!valueResult.isFound) {
       if (!baseResult.canIgnore && !firstSegmentOptional) {
-        throwError({
+        throwError$1({
           description: `variable is not bound: ${baseResult.name}`,
           range: node.base.range
         });
@@ -1803,7 +1810,7 @@ const resolveDotNode = async (context, node, signal) => {
   }
   let parent;
   for (const segment of node.segments) {
-    const result = deconstructConditionalCombine(segment.name);
+    const result = deconstructConditionalCombine$1(segment.name);
     const isOptional = segment.optional || result.canIgnore;
     if (value !== null && (typeof value === "object" || typeof value === "function")) {
       const record = value;
@@ -1811,7 +1818,7 @@ const resolveDotNode = async (context, node, signal) => {
       value = record[result.name];
     } else {
       if (!isOptional) {
-        throwError({
+        throwError$1({
           description: `variable is not bound: ${result.name}`,
           range: segment.range
         });
@@ -1828,7 +1835,7 @@ const applyFunction = async (context, node, signal) => {
   signal == null ? void 0 : signal.throwIfAborted();
   const func = await reduceExpressionNode(context, node.func, signal);
   if (typeof func !== "function") {
-    throwError({
+    throwError$1({
       description: "could not apply it for function",
       range: node.range
     });
@@ -1881,7 +1888,7 @@ const reduceExpressionNode = async (context, node, signal) => {
       return resultList.map((result) => context.convertToString(result)).join("");
     }
     case "variable": {
-      return resolveVariable(context, node, signal);
+      return resolveVariable$1(context, node, signal);
     }
     case "dot": {
       return await resolveDotNode(context, node, signal);
@@ -1916,7 +1923,7 @@ const reduceNode = async (context, node, signal) => {
       const result = await reduceExpressionNode(context, node.iterable, signal);
       const iterable = asIterable(result);
       if (!iterable) {
-        throwError({
+        throwError$1({
           description: "could not apply it for function",
           range: node.range
         });
@@ -1976,39 +1983,143 @@ const reduceNode = async (context, node, signal) => {
     }
   }
 };
-const createScopedReducerContext = (parent, signal) => {
+const defaultReducerExecutor = {
+  reduceExpressionNodeImmediate: (context, node, signal) => reduceExpressionNode(context, node, signal),
+  reduceExpressionNode: (context, node, signal) => Promise.resolve(reduceExpressionNode(context, node, signal)),
+  reduceNodeImmediate: (context, node, signal) => reduceNode(context, node, signal),
+  reduceNode: (context, node, signal) => Promise.resolve(reduceNode(context, node, signal))
+};
+const reduceBlockImmediate = (context, nodeOrNodes, signal) => {
+  const nodes = Array.isArray(nodeOrNodes) ? nodeOrNodes : [nodeOrNodes];
+  const resultList = [];
+  for (let index = 0; index < nodes.length; index++) {
+    const results = context.reduceNodeImmediate(nodes[index], signal);
+    if (isPromiseLike(results)) {
+      return (async () => {
+        const firstResults = await results;
+        for (const result of firstResults) {
+          if (result !== void 0) {
+            resultList.push(result);
+          }
+        }
+        for (let continueIndex = index + 1; continueIndex < nodes.length; continueIndex++) {
+          const continueResults = await context.reduceNodeImmediate(
+            nodes[continueIndex],
+            signal
+          );
+          for (const result of continueResults) {
+            if (result !== void 0) {
+              resultList.push(result);
+            }
+          }
+        }
+        return resultList;
+      })();
+    }
+    for (const result of results) {
+      if (result !== void 0) {
+        resultList.push(result);
+      }
+    }
+  }
+  return resultList;
+};
+const createPreparedSlotState = (slotNames, slotValues, signal) => {
+  signal == null ? void 0 : signal.throwIfAborted();
+  let preparedSlotIds;
+  let preparedSlotValues;
+  let preparedSlotVersion = 0;
+  if (slotNames === void 0 || slotNames.length === 0) {
+    return {
+      preparedSlotIds,
+      preparedSlotValues,
+      preparedSlotVersion
+    };
+  }
+  for (let index = 0; index < slotNames.length; index++) {
+    const name = slotNames[index];
+    const existingSlot = preparedSlotIds == null ? void 0 : preparedSlotIds.get(name);
+    if (existingSlot !== void 0) {
+      preparedSlotValues[existingSlot] = slotValues == null ? void 0 : slotValues[index];
+      continue;
+    }
+    if (!preparedSlotIds) {
+      preparedSlotIds = /* @__PURE__ */ new Map();
+    }
+    if (!preparedSlotValues) {
+      preparedSlotValues = [];
+    }
+    const slot = preparedSlotValues.length;
+    preparedSlotIds.set(name, slot);
+    preparedSlotValues.push(slotValues == null ? void 0 : slotValues[index]);
+    preparedSlotVersion++;
+  }
+  return {
+    preparedSlotIds,
+    preparedSlotValues,
+    preparedSlotVersion
+  };
+};
+const createScopedReducerContext = (parent, signal, executor, initialSlotNames, initialSlotValues) => {
   signal == null ? void 0 : signal.throwIfAborted();
-  let thisVars;
+  const preparedSlotState = createPreparedSlotState(
+    initialSlotNames,
+    initialSlotValues,
+    signal
+  );
+  let thisSlotIds = preparedSlotState.preparedSlotIds;
+  let thisSlotValues = preparedSlotState.preparedSlotValues;
+  let thisSlotVersion = preparedSlotState.preparedSlotVersion;
   let thisContext;
+  const getSlotVersion = () => thisSlotVersion;
+  const resolveLocalSlot = (name, signal2) => {
+    signal2 == null ? void 0 : signal2.throwIfAborted();
+    return thisSlotIds == null ? void 0 : thisSlotIds.get(name);
+  };
+  const ensureLocalSlot = (name, signal2) => {
+    signal2 == null ? void 0 : signal2.throwIfAborted();
+    let slot = thisSlotIds == null ? void 0 : thisSlotIds.get(name);
+    if (slot !== void 0) {
+      return slot;
+    }
+    if (!thisSlotIds) {
+      thisSlotIds = /* @__PURE__ */ new Map();
+    }
+    if (!thisSlotValues) {
+      thisSlotValues = [];
+    }
+    slot = thisSlotValues.length;
+    thisSlotIds.set(name, slot);
+    thisSlotValues.push(void 0);
+    thisSlotVersion++;
+    return slot;
+  };
+  const getSlotValue = (slot, signal2) => {
+    signal2 == null ? void 0 : signal2.throwIfAborted();
+    return thisSlotValues == null ? void 0 : thisSlotValues[slot];
+  };
+  const setSlotValue = (slot, value, signal2) => {
+    signal2 == null ? void 0 : signal2.throwIfAborted();
+    if (!thisSlotValues) {
+      thisSlotValues = [];
+    }
+    thisSlotValues[slot] = value;
+  };
   const getValue = (name, signal2) => {
     signal2 == null ? void 0 : signal2.throwIfAborted();
-    if (thisVars == null ? void 0 : thisVars.has(name)) {
-      return { value: thisVars.get(name), isFound: true };
-    } else {
-      return parent.getValue(name, signal2);
+    const slot = resolveLocalSlot(name, signal2);
+    if (slot !== void 0) {
+      return { value: getSlotValue(slot, signal2), isFound: true };
     }
+    return parent.getValue(name, signal2);
   };
   const setValue = (name, value, signal2) => {
     signal2 == null ? void 0 : signal2.throwIfAborted();
-    if (!thisVars) {
-      thisVars = /* @__PURE__ */ new Map();
-    }
-    thisVars.set(name, value);
+    const slot = ensureLocalSlot(name, signal2);
+    setSlotValue(slot, value, signal2);
   };
   const createFunctionContext = (thisNode, signal2) => {
-    const reduceBlock = async (nodeOrNodes) => {
-      const nodes = Array.isArray(nodeOrNodes) ? nodeOrNodes : [nodeOrNodes];
-      const resultList = [];
-      for (const node of nodes) {
-        const results = await reduceNode(thisContext, node, signal2);
-        for (const result of results) {
-          if (result !== void 0) {
-            resultList.push(result);
-          }
-        }
-      }
-      return resultList;
-    };
+    const reduceBlock = (nodeOrNodes) => Promise.resolve(reduceBlockImmediate(thisContext, nodeOrNodes, signal2));
     return {
       thisNode,
       abortSignal: signal2,
@@ -2016,9 +2127,17 @@ const createScopedReducerContext = (parent, signal) => {
       setValue: (name, value) => setValue(name, value, signal2),
       appendWarning: parent.appendWarning,
       getBoundFunction: parent.getBoundFunction,
-      newScope: () => createScopedReducerContext(thisContext, signal2),
+      newScope: () => createScopedReducerContext(
+        thisContext,
+        signal2,
+        executor,
+        void 0,
+        void 0
+      ),
       convertToString: parent.convertToString,
-      reduce: (node) => reduceExpressionNode(thisContext, node, signal2),
+      reduceImmediate: (node) => thisContext.reduceExpressionNodeImmediate(node, signal2),
+      reduce: (node) => thisContext.reduceExpressionNode(node, signal2),
+      reduceBlockImmediate: (nodeOrNodes) => reduceBlockImmediate(thisContext, nodeOrNodes, signal2),
       reduceBlock
     };
   };
@@ -2027,15 +2146,39 @@ const createScopedReducerContext = (parent, signal) => {
     setValue,
     getBoundFunction: parent.getBoundFunction,
     appendWarning: parent.appendWarning,
-    newScope: (signal2) => createScopedReducerContext(thisContext, signal2),
+    newScope: (signal2) => createScopedReducerContext(
+      thisContext,
+      signal2,
+      executor,
+      void 0,
+      void 0
+    ),
+    newCallScope: (slotNames, slotValues, signal2) => createScopedReducerContext(
+      thisContext,
+      signal2,
+      executor,
+      slotNames,
+      slotValues
+    ),
+    getSlotVersion,
+    resolveLocalSlot,
+    ensureLocalSlot,
+    getSlotValue,
+    setSlotValue,
     convertToString: parent.convertToString,
+    reduceExpressionNode: (node, signal2) => executor.reduceExpressionNode(thisContext, node, signal2),
+    reduceExpressionNodeImmediate: (node, signal2) => executor.reduceExpressionNodeImmediate(thisContext, node, signal2),
+    reduceNode: (node, signal2) => executor.reduceNode(thisContext, node, signal2),
+    reduceNodeImmediate: (node, signal2) => executor.reduceNodeImmediate(thisContext, node, signal2),
     isConstructable: parent.isConstructable,
     createFunctionContext
   };
   return thisContext;
 };
-const createReducerContext = (variables, warningLogs) => {
-  let thisVars;
+const createReducerContext = (variables, warningLogs, executor = defaultReducerExecutor) => {
+  let thisSlotIds;
+  let thisSlotValues;
+  let thisSlotVersion = 0;
   let thisContext;
   const boundFunctionCache = /* @__PURE__ */ new WeakMap();
   const getBoundFunction = (owner, fn) => {
@@ -2053,22 +2196,55 @@ const createReducerContext = (variables, warningLogs) => {
     return bound;
   };
   const constructorCache = /* @__PURE__ */ new WeakMap();
+  const getSlotVersion = () => thisSlotVersion;
+  const resolveLocalSlot = (name, signal) => {
+    signal == null ? void 0 : signal.throwIfAborted();
+    return thisSlotIds == null ? void 0 : thisSlotIds.get(name);
+  };
+  const ensureLocalSlot = (name, signal) => {
+    signal == null ? void 0 : signal.throwIfAborted();
+    let slot = thisSlotIds == null ? void 0 : thisSlotIds.get(name);
+    if (slot !== void 0) {
+      return slot;
+    }
+    if (!thisSlotIds) {
+      thisSlotIds = /* @__PURE__ */ new Map();
+    }
+    if (!thisSlotValues) {
+      thisSlotValues = [];
+    }
+    slot = thisSlotValues.length;
+    thisSlotIds.set(name, slot);
+    thisSlotValues.push(void 0);
+    thisSlotVersion++;
+    return slot;
+  };
+  const getSlotValue = (slot, signal) => {
+    signal == null ? void 0 : signal.throwIfAborted();
+    return thisSlotValues == null ? void 0 : thisSlotValues[slot];
+  };
+  const setSlotValue = (slot, value, signal) => {
+    signal == null ? void 0 : signal.throwIfAborted();
+    if (!thisSlotValues) {
+      thisSlotValues = [];
+    }
+    thisSlotValues[slot] = value;
+  };
   const getValue = (name, signal) => {
     signal == null ? void 0 : signal.throwIfAborted();
-    if (thisVars == null ? void 0 : thisVars.has(name)) {
-      return { value: thisVars.get(name), isFound: true };
-    } else if (variables.has(name)) {
+    const slot = resolveLocalSlot(name, signal);
+    if (slot !== void 0) {
+      return { value: getSlotValue(slot, signal), isFound: true };
+    }
+    if (variables.has(name)) {
       return { value: variables.get(name), isFound: true };
-    } else {
-      return { value: void 0, isFound: false };
     }
+    return { value: void 0, isFound: false };
   };
   const setValue = (name, value, signal) => {
     signal == null ? void 0 : signal.throwIfAborted();
-    if (!thisVars) {
-      thisVars = /* @__PURE__ */ new Map();
-    }
-    thisVars.set(name, value);
+    const slot = ensureLocalSlot(name, signal);
+    setSlotValue(slot, value, signal);
   };
   const appendWarning = (warning) => {
     warningLogs.push(warning);
@@ -2092,19 +2268,7 @@ const createReducerContext = (variables, warningLogs) => {
     return internalConvertToString(v, getFuncId);
   };
   const createFunctionContext = (thisNode, signal) => {
-    const reduceBlock = async (nodeOrNodes) => {
-      const nodes = Array.isArray(nodeOrNodes) ? nodeOrNodes : [nodeOrNodes];
-      const resultList = [];
-      for (const node of nodes) {
-        const results = await reduceNode(thisContext, node, signal);
-        for (const result of results) {
-          if (result !== void 0) {
-            resultList.push(result);
-          }
-        }
-      }
-      return resultList;
-    };
+    const reduceBlock = (nodeOrNodes) => Promise.resolve(reduceBlockImmediate(thisContext, nodeOrNodes, signal));
     return {
       thisNode,
       abortSignal: signal,
@@ -2112,9 +2276,17 @@ const createReducerContext = (variables, warningLogs) => {
       setValue: (name, value) => setValue(name, value, signal),
       appendWarning,
       getBoundFunction,
-      newScope: () => createScopedReducerContext(thisContext, signal),
+      newScope: () => createScopedReducerContext(
+        thisContext,
+        signal,
+        executor,
+        void 0,
+        void 0
+      ),
       convertToString: convertToString2,
-      reduce: (node) => reduceExpressionNode(thisContext, node, signal),
+      reduceImmediate: (node) => thisContext.reduceExpressionNodeImmediate(node, signal),
+      reduce: (node) => thisContext.reduceExpressionNode(node, signal),
+      reduceBlockImmediate: (nodeOrNodes) => reduceBlockImmediate(thisContext, nodeOrNodes, signal),
       reduceBlock
     };
   };
@@ -2123,8 +2295,30 @@ const createReducerContext = (variables, warningLogs) => {
     setValue,
     getBoundFunction,
     appendWarning,
-    newScope: (signal) => createScopedReducerContext(thisContext, signal),
+    newScope: (signal) => createScopedReducerContext(
+      thisContext,
+      signal,
+      executor,
+      void 0,
+      void 0
+    ),
+    newCallScope: (slotNames, slotValues, signal) => createScopedReducerContext(
+      thisContext,
+      signal,
+      executor,
+      slotNames,
+      slotValues
+    ),
+    getSlotVersion,
+    resolveLocalSlot,
+    ensureLocalSlot,
+    getSlotValue,
+    setSlotValue,
     convertToString: convertToString2,
+    reduceExpressionNode: (node, signal) => executor.reduceExpressionNode(thisContext, node, signal),
+    reduceExpressionNodeImmediate: (node, signal) => executor.reduceExpressionNodeImmediate(thisContext, node, signal),
+    reduceNode: (node, signal) => executor.reduceNode(thisContext, node, signal),
+    reduceNodeImmediate: (node, signal) => executor.reduceNodeImmediate(thisContext, node, signal),
     isConstructable,
     createFunctionContext
   };
@@ -2143,7 +2337,13 @@ async function runReducer(nodes, variables, warningLogs, signal) {
   }
   return resultList;
 }
-const _cond = makeFunCityFunction(async function(arg0, arg1, arg2) {
+const resolveMaybePromise$1 = (value, onResolved) => {
+  if (isPromiseLike(value)) {
+    return value.then((resolved) => onResolved(resolved));
+  }
+  return onResolved(value);
+};
+const _cond = makeFunCityFunction(function(arg0, arg1, arg2) {
   if (!arg0 || !arg1 || !arg2) {
     throw new FunCityReducerError({
       type: "error",
@@ -2151,14 +2351,13 @@ const _cond = makeFunCityFunction(async function(arg0, arg1, arg2) {
       range: this.thisNode.range
     });
   }
-  const cond = await this.reduce(arg0);
-  if (isConditionalTrue(cond)) {
-    return await this.reduce(arg1);
-  } else {
-    return await this.reduce(arg2);
-  }
+  return resolveMaybePromise$1(
+    this.reduceImmediate(arg0),
+    (cond) => isConditionalTrue(cond) ? this.reduceImmediate(arg1) : this.reduceImmediate(arg2)
+    // Delayed execution when condition is false.
+  );
 });
-const _defaults = makeFunCityFunction(async function(arg0, arg1, ...rest) {
+const _defaults = makeFunCityFunction(function(arg0, arg1, ...rest) {
   if (!arg0 || !arg1 || rest.length !== 0) {
     throw new FunCityReducerError({
       type: "error",
@@ -2166,13 +2365,17 @@ const _defaults = makeFunCityFunction(async function(arg0, arg1, ...rest) {
       range: this.thisNode.range
     });
   }
-  const value = await this.reduce(arg0);
-  if (value !== void 0 && value !== null) {
-    return value;
-  }
-  return await this.reduce(arg1);
+  return resolveMaybePromise$1(
+    this.reduceImmediate(arg0),
+    (value) => {
+      if (value !== void 0 && value !== null) {
+        return value;
+      }
+      return this.reduceImmediate(arg1);
+    }
+  );
 });
-const _set = makeFunCityFunction(async function(arg0, arg1, ...rest) {
+const _set = makeFunCityFunction(function(arg0, arg1, ...rest) {
   if (!arg0 || !arg1 || rest.length !== 0) {
     throw new FunCityReducerError({
       type: "error",
@@ -2187,9 +2390,10 @@ const _set = makeFunCityFunction(async function(arg0, arg1, ...rest) {
       range: arg0.range
     });
   }
-  const value = await this.reduce(arg1);
-  this.setValue(arg0.name, value);
-  return void 0;
+  return resolveMaybePromise$1(this.reduceImmediate(arg1), (value) => {
+    this.setValue(arg0.name, value);
+    return void 0;
+  });
 });
 const extractParameterArguments = (namesNode, _context) => {
   switch (namesNode.kind) {
@@ -2221,7 +2425,7 @@ const extractParameterArguments = (namesNode, _context) => {
     }
   }
 };
-const _fun = makeFunCityFunction(async function(arg0, arg1, ...rest) {
+const _fun = makeFunCityFunction(function(arg0, arg1, ...rest) {
   if (!arg0 || !arg1 || rest.length !== 0) {
     throw new FunCityReducerError({
       type: "error",
@@ -2236,7 +2440,7 @@ const _fun = makeFunCityFunction(async function(arg0, arg1, ...rest) {
   const bodyNode = arg1;
   const lambdaRange = this.thisNode.range;
   const createScope = this.newScope;
-  return async (...args) => {
+  return (...args) => {
     if (args.length < nameNodes.length) {
       throw new FunCityReducerError({
         type: "error",
@@ -2258,15 +2462,10 @@ const _fun = makeFunCityFunction(async function(arg0, arg1, ...rest) {
         this.abortSignal
       );
     }
-    const result = await reduceExpressionNode(
-      newContext,
-      bodyNode,
-      this.abortSignal
-    );
-    return result;
+    return newContext.reduceExpressionNodeImmediate(bodyNode, this.abortSignal);
   };
 });
-const _typeof = async (arg0) => {
+const _typeof = (arg0) => {
   if (arg0 === null) {
     return "null";
   } else if (typeof arg0 === "string") {
@@ -2279,19 +2478,19 @@ const _typeof = async (arg0) => {
     return typeof arg0;
   }
 };
-const _toString = async (...args) => {
+const _toString = (...args) => {
   const results = args.map((arg0) => convertToString(arg0));
   return results.join(",");
 };
-const _toBoolean = async (arg0) => {
+const _toBoolean = (arg0) => {
   const r = isConditionalTrue(arg0);
   return r;
 };
-const _toNumber = async (arg0) => {
+const _toNumber = (arg0) => {
   const r = Number(arg0);
   return r;
 };
-const _toBigInt = async (arg0) => {
+const _toBigInt = (arg0) => {
   switch (typeof arg0) {
     case "number":
     case "bigint":
@@ -2301,59 +2500,59 @@ const _toBigInt = async (arg0) => {
       return r;
     }
     default: {
-      const r = BigInt(await _toString(arg0));
+      const r = BigInt(_toString(arg0));
       return r;
     }
   }
 };
-const _add = async (arg0, ...args) => {
+const _add = (arg0, ...args) => {
   const r = args.reduce((v0, v) => v0 + Number(v), Number(arg0));
   return r;
 };
-const _sub = async (arg0, ...args) => {
+const _sub = (arg0, ...args) => {
   const r = args.reduce((v0, v) => v0 - Number(v), Number(arg0));
   return r;
 };
-const _mul = async (arg0, ...args) => {
+const _mul = (arg0, ...args) => {
   const r = args.reduce((v0, v) => v0 * Number(v), Number(arg0));
   return r;
 };
-const _div = async (arg0, ...args) => {
+const _div = (arg0, ...args) => {
   const r = args.reduce((v0, v) => v0 / Number(v), Number(arg0));
   return r;
 };
-const _mod = async (arg0, ...args) => {
+const _mod = (arg0, ...args) => {
   const r = args.reduce((v0, v) => v0 % Number(v), Number(arg0));
   return r;
 };
-const _eq = async (arg0, arg1) => {
+const _eq = (arg0, arg1) => {
   const r = arg0 === arg1;
   return r;
 };
-const _ne = async (arg0, arg1) => {
+const _ne = (arg0, arg1) => {
   const r = arg0 !== arg1;
   return r;
 };
-const _lt = async (arg0, arg1) => {
+const _lt = (arg0, arg1) => {
   const r = arg0 < arg1;
   return r;
 };
-const _gt = async (arg0, arg1) => {
+const _gt = (arg0, arg1) => {
   const r = arg0 > arg1;
   return r;
 };
-const _le = async (arg0, arg1) => {
+const _le = (arg0, arg1) => {
   const r = arg0 <= arg1;
   return r;
 };
-const _ge = async (arg0, arg1) => {
+const _ge = (arg0, arg1) => {
   const r = arg0 >= arg1;
   return r;
 };
-const _now = async () => {
+const _now = () => {
   return /* @__PURE__ */ new Date();
 };
-const _random = makeFunCityFunction(async function(arg0, arg1, ...rest) {
+const _random = makeFunCityFunction(function(arg0, arg1, ...rest) {
   if (!arg0 || rest.length !== 0) {
     throw new FunCityReducerError({
       type: "error",
@@ -2361,14 +2560,19 @@ const _random = makeFunCityFunction(async function(arg0, arg1, ...rest) {
       range: this.thisNode.range
     });
   }
-  const baseValue = await this.reduce(arg0);
-  const spanValue = arg1 ? await this.reduce(arg1) : baseValue;
-  const base = arg1 ? Number(baseValue) : 0;
-  const span = Number(spanValue);
-  const r = base + Math.floor(Math.random() * span);
-  return r;
+  return resolveMaybePromise$1(
+    this.reduceImmediate(arg0),
+    (baseValue) => {
+      const spanValue = arg1 ? this.reduceImmediate(arg1) : baseValue;
+      return resolveMaybePromise$1(spanValue, (resolvedSpanValue) => {
+        const base = arg1 ? Number(baseValue) : 0;
+        const span = Number(resolvedSpanValue);
+        return base + Math.floor(Math.random() * span);
+      });
+    }
+  );
 });
-const _randomf = async (arg0, arg1) => {
+const _randomf = (arg0, arg1) => {
   if (arg0 === void 0) {
     return Math.random();
   }
@@ -2401,16 +2605,16 @@ const concatInner = (sep, args) => {
   }
   return v;
 };
-const _concat = async (...args) => {
+const _concat = (...args) => {
   const r = concatInner("", args);
   return r;
 };
-const _join = async (arg0, ...args) => {
+const _join = (arg0, ...args) => {
   const sep = convertToString(arg0);
   const r = concatInner(sep, args);
   return r;
 };
-const _trim = async (arg0) => {
+const _trim = (arg0) => {
   var _a;
   let v = arg0;
   if (v === void 0 || v === null) {
@@ -2420,7 +2624,7 @@ const _trim = async (arg0) => {
   }
   return v.trim();
 };
-const _toUpper = async (arg0) => {
+const _toUpper = (arg0) => {
   var _a;
   let v = arg0;
   if (typeof v !== "string") {
@@ -2428,7 +2632,7 @@ const _toUpper = async (arg0) => {
   }
   return v.toUpperCase();
 };
-const _toLower = async (arg0) => {
+const _toLower = (arg0) => {
   var _a;
   let v = arg0;
   if (typeof v !== "string") {
@@ -2436,7 +2640,7 @@ const _toLower = async (arg0) => {
   }
   return v.toLowerCase();
 };
-const _length = async (arg0) => {
+const _length = (arg0) => {
   if (arg0) {
     if (typeof arg0 === "string") {
       return arg0.length;
@@ -2455,7 +2659,7 @@ const _length = async (arg0) => {
   }
   return 0;
 };
-const _and = makeFunCityFunction(async function(...args) {
+const _and = makeFunCityFunction(function(...args) {
   if (args.length === 0) {
     throw new FunCityReducerError({
       type: "error",
@@ -2463,15 +2667,28 @@ const _and = makeFunCityFunction(async function(...args) {
       range: this.thisNode.range
     });
   }
-  for (const arg of args) {
-    const value = await this.reduce(arg);
+  for (let index = 0; index < args.length; index++) {
+    const value = this.reduceImmediate(args[index]);
+    if (isPromiseLike(value)) {
+      return (async () => {
+        if (!isConditionalTrue(await value)) {
+          return false;
+        }
+        for (let continueIndex = index + 1; continueIndex < args.length; continueIndex++) {
+          if (!isConditionalTrue(await this.reduceImmediate(args[continueIndex]))) {
+            return false;
+          }
+        }
+        return true;
+      })();
+    }
     if (!isConditionalTrue(value)) {
       return false;
     }
   }
   return true;
 });
-const _or = makeFunCityFunction(async function(...args) {
+const _or = makeFunCityFunction(function(...args) {
   if (args.length === 0) {
     throw new FunCityReducerError({
       type: "error",
@@ -2479,18 +2696,31 @@ const _or = makeFunCityFunction(async function(...args) {
       range: this.thisNode.range
     });
   }
-  for (const arg of args) {
-    const value = await this.reduce(arg);
+  for (let index = 0; index < args.length; index++) {
+    const value = this.reduceImmediate(args[index]);
+    if (isPromiseLike(value)) {
+      return (async () => {
+        if (isConditionalTrue(await value)) {
+          return true;
+        }
+        for (let continueIndex = index + 1; continueIndex < args.length; continueIndex++) {
+          if (isConditionalTrue(await this.reduceImmediate(args[continueIndex]))) {
+            return true;
+          }
+        }
+        return false;
+      })();
+    }
     if (isConditionalTrue(value)) {
       return true;
     }
   }
   return false;
 });
-const _not = async (arg0) => {
+const _not = (arg0) => {
   return !isConditionalTrue(arg0);
 };
-const _at = async (arg0, arg1) => {
+const _at = (arg0, arg1) => {
   const index = Number(arg0);
   if (arg1) {
     if (typeof arg1 === "string") {
@@ -2512,7 +2742,7 @@ const _at = async (arg0, arg1) => {
   }
   return void 0;
 };
-const _first = async (arg0) => {
+const _first = (arg0) => {
   if (arg0) {
     if (typeof arg0 === "string") {
       return arg0[0];
@@ -2529,7 +2759,7 @@ const _first = async (arg0) => {
   }
   return void 0;
 };
-const _last = async (arg0) => {
+const _last = (arg0) => {
   if (arg0) {
     if (typeof arg0 === "string") {
       return arg0[arg0.length - 1];
@@ -2548,7 +2778,7 @@ const _last = async (arg0) => {
   }
   return void 0;
 };
-const _range = async (arg0, arg1) => {
+const _range = (arg0, arg1) => {
   let value = Number(arg0);
   const count = Number(arg1);
   const resultList = [];
@@ -2564,7 +2794,7 @@ const sliceIterable = (iter, start, end) => {
   }
   return resultList.slice(start, end);
 };
-const _slice = async (arg0, arg1, arg2) => {
+const _slice = (arg0, arg1, arg2) => {
   const start = arg0 === void 0 ? void 0 : Number(arg0);
   if (arg2 === void 0) {
     if (typeof arg1 === "string") {
@@ -2578,7 +2808,7 @@ const _slice = async (arg0, arg1, arg2) => {
   }
   return sliceIterable(arg2, start, end);
 };
-const _reverse = async (arg0) => {
+const _reverse = (arg0) => {
   const iter = arg0;
   let resultList = [];
   for (const item of iter) {
@@ -2586,7 +2816,7 @@ const _reverse = async (arg0) => {
   }
   return resultList.reverse();
 };
-const _sort = async (arg0) => {
+const _sort = (arg0) => {
   const iter = arg0;
   let resultList = [];
   for (const item of iter) {
@@ -2614,7 +2844,7 @@ const _flatMap = async (arg0, arg1) => {
   }
   return resultList;
 };
-const _flatten = async (arg0) => {
+const _flatten = (arg0) => {
   const iter = arg0;
   const resultList = [];
   for (const item of iter) {
@@ -2638,7 +2868,7 @@ const _filter = async (arg0, arg1) => {
   }
   return resultList;
 };
-const _collect = async (arg0) => {
+const _collect = (arg0) => {
   const iter = arg0;
   const resultList = [];
   for (const item of iter) {
@@ -2648,7 +2878,7 @@ const _collect = async (arg0) => {
   }
   return resultList;
 };
-const _distinct = async (arg0) => {
+const _distinct = (arg0) => {
   const iter = arg0;
   const seen = /* @__PURE__ */ new Set();
   const resultList = [];
@@ -2674,7 +2904,7 @@ const _distinctBy = async (arg0, arg1) => {
   }
   return resultList;
 };
-const _union = async (arg0, arg1) => {
+const _union = (arg0, arg1) => {
   if (arg0 instanceof Set && arg1 instanceof Set) {
     const union = arg0.union;
     if (typeof union === "function") {
@@ -2719,7 +2949,7 @@ const _unionBy = async (arg0, arg1, arg2) => {
   }
   return resultList;
 };
-const _intersection = async (arg0, arg1) => {
+const _intersection = (arg0, arg1) => {
   if (arg0 instanceof Set && arg1 instanceof Set) {
     const intersection = arg0.intersection;
     if (typeof intersection === "function") {
@@ -2758,7 +2988,7 @@ const _intersectionBy = async (arg0, arg1, arg2) => {
   }
   return resultList;
 };
-const _difference = async (arg0, arg1) => {
+const _difference = (arg0, arg1) => {
   if (arg0 instanceof Set && arg1 instanceof Set) {
     const difference = arg0.difference;
     if (typeof difference === "function") {
@@ -2797,7 +3027,7 @@ const _differenceBy = async (arg0, arg1, arg2) => {
   }
   return resultList;
 };
-const _symmetricDifference = async (arg0, arg1) => {
+const _symmetricDifference = (arg0, arg1) => {
   if (arg0 instanceof Set && arg1 instanceof Set) {
     const symmetricDifference = arg0.symmetricDifference;
     if (typeof symmetricDifference === "function") {
@@ -2870,7 +3100,7 @@ const _symmetricDifferenceBy = async (arg0, arg1, arg2) => {
   }
   return resultList;
 };
-const _isSubsetOf = async (arg0, arg1) => {
+const _isSubsetOf = (arg0, arg1) => {
   if (arg0 instanceof Set && arg1 instanceof Set) {
     const isSubsetOf = arg0.isSubsetOf;
     if (typeof isSubsetOf === "function") {
@@ -2913,7 +3143,7 @@ const _isSubsetOfBy = async (arg0, arg1, arg2) => {
   }
   return true;
 };
-const _isSupersetOf = async (arg0, arg1) => {
+const _isSupersetOf = (arg0, arg1) => {
   if (arg0 instanceof Set && arg1 instanceof Set) {
     const isSupersetOf = arg0.isSupersetOf;
     if (typeof isSupersetOf === "function") {
@@ -2950,7 +3180,7 @@ const _isSupersetOfBy = async (arg0, arg1, arg2) => {
   }
   return true;
 };
-const _isDisjointFrom = async (arg0, arg1) => {
+const _isDisjointFrom = (arg0, arg1) => {
   if (arg0 instanceof Set && arg1 instanceof Set) {
     const isDisjointFrom = arg0.isDisjointFrom;
     if (typeof isDisjointFrom === "function") {
@@ -2991,18 +3221,18 @@ const _reduce = async (arg0, arg1, arg2) => {
   }
   return acc;
 };
-const _match = async (arg0, arg1) => {
+const _match = (arg0, arg1) => {
   const re = arg0 instanceof RegExp ? arg0 : new RegExp(convertToString(arg0), "g");
   const results = convertToString(arg1).match(re);
   return results;
 };
-const _replace = async (arg0, arg1, arg2) => {
+const _replace = (arg0, arg1, arg2) => {
   const re = arg0 instanceof RegExp ? arg0 : new RegExp(convertToString(arg0), "g");
   const replace = convertToString(arg1);
   const results = convertToString(arg2).replace(re, replace);
   return results;
 };
-const _regex = async (arg0, arg1) => {
+const _regex = (arg0, arg1) => {
   if (arg1) {
     const re = new RegExp(convertToString(arg0), convertToString(arg1));
     return re;
@@ -3011,11 +3241,11 @@ const _regex = async (arg0, arg1) => {
     return re;
   }
 };
-const _bind = async (arg0, ...args) => {
+const _bind = (arg0, ...args) => {
   const predicate = arg0;
   return predicate.bind(void 0, ...args);
 };
-const _url = async (arg0, arg1) => {
+const _url = (arg0, arg1) => {
   const url = new URL(
     convertToString(arg0),
     arg1 !== void 0 ? convertToString(arg1) : void 0
@@ -3095,11 +3325,7 @@ const createIncludeFunction = (options) => {
     const scopedContext = context.newScope();
     const resultList = [];
     for (const node of nodes) {
-      const results = await reduceNode(
-        scopedContext,
-        node,
-        context.abortSignal
-      );
+      const results = await scopedContext.reduceNode(node, context.abortSignal);
       for (const result of results) {
         if (result !== void 0) {
           resultList.push(result);
@@ -3238,55 +3464,2601 @@ const standardVariables = Object.freeze({
 const buildCandidateVariables = (...variablesList) => {
   return combineVariables(standardVariables, ...variablesList);
 };
-const runScriptOnce = async (script, props, signal) => {
-  const { variables = buildCandidateVariables(), logs = [], sourceId } = props;
-  const tokens = runTokenizer(script, logs, sourceId);
-  const nodes = runParser(tokens, logs);
-  if (logs.length >= 1) {
-    return [];
+const throwError = (info) => {
+  throw new FunCityReducerError({
+    type: "error",
+    ...info
+  });
+};
+const deconstructConditionalCombine = (name) => {
+  if (name.length >= 1) {
+    const last = name[name.length - 1];
+    if (last === "?") {
+      return {
+        name: name.substring(0, name.length - 1),
+        canIgnore: true
+      };
+    }
   }
-  const warningLogs = [];
-  const reducerContext = createReducerContext(variables, warningLogs);
-  const resultList = [];
-  try {
-    for (const node of nodes) {
-      const results = await reduceNode(reducerContext, node, signal);
-      for (const result of results) {
-        if (result !== void 0) {
-          resultList.push(result);
+  return {
+    name,
+    canIgnore: false
+  };
+};
+const extractLambdaParameterNames = (node) => {
+  switch (node.kind) {
+    case "variable": {
+      return [node.name];
+    }
+    case "list": {
+      const names = [];
+      for (const item of node.items) {
+        if (item.kind !== "variable") {
+          return void 0;
         }
+        names.push(item.name);
       }
+      return names;
     }
-  } catch (error) {
-    logs.push(...warningLogs);
-    if (error instanceof FunCityReducerError) {
-      logs.push(error.info);
-      return [];
+    default: {
+      return void 0;
     }
-    throw error;
   }
-  logs.push(...warningLogs);
-  return resultList;
 };
-const runScriptOnceToText = async (script, props, signal) => {
-  const { variables = buildCandidateVariables(), logs = [], sourceId } = props;
-  const tokens = runTokenizer(script, logs, sourceId);
-  const nodes = runParser(tokens, logs);
-  if (logs.length >= 1) {
+const resolveVariable = (context, result, range, signal) => {
+  const valueResult = context.getValue(result.name, signal);
+  if (!valueResult.isFound) {
+    if (!result.canIgnore) {
+      throwError({
+        description: `variable is not bound: ${result.name}`,
+        range
+      });
+    }
     return void 0;
   }
-  const warningLogs = [];
-  const reducerContext = createReducerContext(variables, warningLogs);
+  return valueResult.value;
+};
+const filterUndefined = (results) => results.filter((result) => result !== void 0);
+const resolveMaybePromise = (value, onResolved) => {
+  if (isPromiseLike(value)) {
+    return value.then((resolved) => onResolved(resolved));
+  }
+  return onResolved(value);
+};
+const specializableStandardCallTargets = Object.freeze({
+  toString: standardVariables.toString,
+  toBoolean: standardVariables.toBoolean,
+  toNumber: standardVariables.toNumber,
+  toBigInt: standardVariables.toBigInt,
+  typeof: standardVariables.typeof,
+  add: standardVariables.add,
+  sub: standardVariables.sub,
+  mul: standardVariables.mul,
+  div: standardVariables.div,
+  mod: standardVariables.mod,
+  eq: standardVariables.eq,
+  ne: standardVariables.ne,
+  lt: standardVariables.lt,
+  gt: standardVariables.gt,
+  le: standardVariables.le,
+  ge: standardVariables.ge,
+  now: standardVariables.now,
+  randomf: standardVariables.randomf,
+  concat: standardVariables.concat,
+  join: standardVariables.join,
+  trim: standardVariables.trim,
+  toUpper: standardVariables.toUpper,
+  toLower: standardVariables.toLower,
+  length: standardVariables.length,
+  not: standardVariables.not,
+  at: standardVariables.at,
+  first: standardVariables.first,
+  last: standardVariables.last,
+  range: standardVariables.range,
+  slice: standardVariables.slice,
+  sort: standardVariables.sort,
+  reverse: standardVariables.reverse,
+  map: standardVariables.map,
+  flatMap: standardVariables.flatMap,
+  flatten: standardVariables.flatten,
+  filter: standardVariables.filter,
+  collect: standardVariables.collect,
+  distinct: standardVariables.distinct,
+  distinctBy: standardVariables.distinctBy,
+  union: standardVariables.union,
+  unionBy: standardVariables.unionBy,
+  intersection: standardVariables.intersection,
+  intersectionBy: standardVariables.intersectionBy,
+  difference: standardVariables.difference,
+  differenceBy: standardVariables.differenceBy,
+  symmetricDifference: standardVariables.symmetricDifference,
+  symmetricDifferenceBy: standardVariables.symmetricDifferenceBy,
+  isSubsetOf: standardVariables.isSubsetOf,
+  isSubsetOfBy: standardVariables.isSubsetOfBy,
+  isSupersetOf: standardVariables.isSupersetOf,
+  isSupersetOfBy: standardVariables.isSupersetOfBy,
+  isDisjointFrom: standardVariables.isDisjointFrom,
+  isDisjointFromBy: standardVariables.isDisjointFromBy,
+  reduce: standardVariables.reduce,
+  match: standardVariables.match,
+  replace: standardVariables.replace,
+  regex: standardVariables.regex,
+  bind: standardVariables.bind,
+  url: standardVariables.url
+});
+const toSpecializableStandardCallTarget = (name) => {
+  return specializableStandardCallTargets[name];
+};
+const AsyncFunction = Object.getPrototypeOf(async () => {
+}).constructor;
+const createRawBlockRunnerImmediate = (generators) => {
+  return (context, signal) => {
+    const resultList = [];
+    for (let index = 0; index < generators.length; index++) {
+      const results = generators[index](context, signal);
+      if (isPromiseLike(results)) {
+        return (async () => {
+          resultList.push(...await results);
+          for (let continueIndex = index + 1; continueIndex < generators.length; continueIndex++) {
+            resultList.push(
+              ...await generators[continueIndex](context, signal)
+            );
+          }
+          return resultList;
+        })();
+      }
+      resultList.push(...results);
+    }
+    return resultList;
+  };
+};
+const createTextBlockRunnerImmediate = (generators) => {
+  return (context, signal) => {
+    let result = "";
+    for (let index = 0; index < generators.length; index++) {
+      const text = generators[index](context, signal);
+      if (isPromiseLike(text)) {
+        return (async () => {
+          result += await text;
+          for (let continueIndex = index + 1; continueIndex < generators.length; continueIndex++) {
+            result += await generators[continueIndex](context, signal);
+          }
+          return result;
+        })();
+      }
+      result += text;
+    }
+    return result;
+  };
+};
+const collectExpressionValues = (generators, context, signal) => {
   const resultList = [];
+  for (let index = 0; index < generators.length; index++) {
+    const result = generators[index](context, signal);
+    if (isPromiseLike(result)) {
+      return (async () => {
+        resultList.push(await result);
+        for (let continueIndex = index + 1; continueIndex < generators.length; continueIndex++) {
+          resultList.push(await generators[continueIndex](context, signal));
+        }
+        return resultList;
+      })();
+    }
+    resultList.push(result);
+  }
+  return resultList;
+};
+const handleApplyError = (node, error) => {
+  if (error instanceof FunCityReducerError) {
+    throw error;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    throw error;
+  }
+  throw new FunCityReducerError({
+    type: "error",
+    description: fromError(error),
+    range: node.range
+  });
+};
+const resolveSourceVariable = (context, name, canIgnore, range, signal) => {
+  const valueResult = context.getValue(name, signal);
+  if (!valueResult.isFound) {
+    if (!canIgnore) {
+      throwError({
+        description: `variable is not bound: ${name}`,
+        range
+      });
+    }
+    return void 0;
+  }
+  return valueResult.value;
+};
+const resolveSourceDotSegments = (context, baseValue, segments) => {
+  let value = baseValue;
+  let parent;
+  for (const segment of segments) {
+    if (value !== null && (typeof value === "object" || typeof value === "function")) {
+      const record = value;
+      parent = value;
+      value = record[segment.name];
+      continue;
+    }
+    if (!segment.canIgnore) {
+      throwError({
+        description: `variable is not bound: ${segment.name}`,
+        range: segment.range
+      });
+    }
+    return void 0;
+  }
+  if (parent && typeof value === "function" && !isFunCityFunction(value)) {
+    return context.getBoundFunction(parent, value);
+  }
+  return value;
+};
+const invokeSourceCallable = async (context, node, signal, callable, args, isSpecial) => {
+  const shouldConstruct = !isSpecial && context.isConstructable(callable);
   try {
-    for (const node of nodes) {
-      const results = await reduceNode(reducerContext, node, signal);
-      for (const result of results) {
-        if (result !== void 0) {
-          resultList.push(result);
+    if (shouldConstruct) {
+      return Reflect.construct(callable, args);
+    }
+    const thisProxy = context.createFunctionContext(node, signal);
+    return await callable.call(thisProxy, ...args);
+  } catch (error) {
+    return handleApplyError(node, error);
+  }
+};
+const invokeSourceBuiltin = async (node, builtin, args) => {
+  try {
+    return await builtin(...args);
+  } catch (error) {
+    return handleApplyError(node, error);
+  }
+};
+const createClosureDCodegen = () => {
+  const expressionImmediateCache = /* @__PURE__ */ new WeakMap();
+  const expressionCache = /* @__PURE__ */ new WeakMap();
+  const blockImmediateCache = /* @__PURE__ */ new WeakMap();
+  const blockCache = /* @__PURE__ */ new WeakMap();
+  const rawProgramImmediateCache = /* @__PURE__ */ new WeakMap();
+  const textBlockImmediateCache = /* @__PURE__ */ new WeakMap();
+  const textProgramImmediateCache = /* @__PURE__ */ new WeakMap();
+  const textProgramCache = /* @__PURE__ */ new WeakMap();
+  const programImmediateCache = /* @__PURE__ */ new WeakMap();
+  const programCache = /* @__PURE__ */ new WeakMap();
+  const generateRawProgramImmediate = (nodes) => {
+    const cached = rawProgramImmediateCache.get(nodes);
+    if (cached) {
+      return cached;
+    }
+    const generator = createRawBlockRunnerImmediate(
+      nodes.map(generateBlockImmediate)
+    );
+    rawProgramImmediateCache.set(nodes, generator);
+    return generator;
+  };
+  const generateTextProgramImmediate = (nodes) => {
+    const cached = textProgramImmediateCache.get(nodes);
+    if (cached) {
+      return cached;
+    }
+    const generator = createTextBlockRunnerImmediate(
+      nodes.map(generateTextBlockImmediate)
+    );
+    textProgramImmediateCache.set(nodes, generator);
+    return generator;
+  };
+  const resolveDotNode2 = (context, node, signal, compiledBase, baseResult) => {
+    var _a, _b;
+    signal == null ? void 0 : signal.throwIfAborted();
+    const firstSegmentOptional = (_b = (_a = node.segments[0]) == null ? void 0 : _a.optional) != null ? _b : false;
+    const resolveSegments = (baseValue) => {
+      let value = baseValue;
+      let parent;
+      for (const segment of node.segments) {
+        const result = deconstructConditionalCombine(segment.name);
+        const isOptional = segment.optional || result.canIgnore;
+        if (value !== null && (typeof value === "object" || typeof value === "function")) {
+          const record = value;
+          parent = value;
+          value = record[result.name];
+        } else {
+          if (!isOptional) {
+            throwError({
+              description: `variable is not bound: ${result.name}`,
+              range: segment.range
+            });
+          }
+          return void 0;
         }
       }
+      if (parent && typeof value === "function" && !isFunCityFunction(value)) {
+        return context.getBoundFunction(parent, value);
+      }
+      return value;
+    };
+    if (baseResult) {
+      const valueResult = context.getValue(baseResult.name, signal);
+      if (!valueResult.isFound) {
+        if (!baseResult.canIgnore && !firstSegmentOptional) {
+          throwError({
+            description: `variable is not bound: ${baseResult.name}`,
+            range: node.base.range
+          });
+        }
+        return void 0;
+      }
+      return resolveSegments(valueResult.value);
+    }
+    if (!compiledBase) {
+      return void 0;
+    }
+    return resolveMaybePromise(compiledBase(context, signal), resolveSegments);
+  };
+  const applyResolvedFunction = (context, node, signal, callable, compiledArgs) => {
+    const isSpecial = isFunCityFunction(callable);
+    const resolvedArgs = isSpecial ? node.args : collectExpressionValues(compiledArgs, context, signal);
+    const invokeCallable = (args) => {
+      const shouldConstruct = !isSpecial && context.isConstructable(callable);
+      try {
+        if (shouldConstruct) {
+          return Reflect.construct(callable, args);
+        }
+        const thisProxy = context.createFunctionContext(node, signal);
+        return callable.call(thisProxy, ...args);
+      } catch (error) {
+        handleApplyError(node, error);
+      }
+    };
+    const result = resolveMaybePromise(
+      resolvedArgs,
+      (args) => invokeCallable(args)
+    );
+    if (isPromiseLike(result)) {
+      return result.catch((error) => handleApplyError(node, error));
+    }
+    return result;
+  };
+  const applySpecializedStandardFunction = (context, node, signal, builtin, compiledArgs) => {
+    const invokeBuiltin = (args) => {
+      try {
+        return builtin(...args);
+      } catch (error) {
+        handleApplyError(node, error);
+      }
+    };
+    const result = resolveMaybePromise(
+      collectExpressionValues(compiledArgs, context, signal),
+      (args) => invokeBuiltin(args)
+    );
+    if (isPromiseLike(result)) {
+      return result.catch((error) => handleApplyError(node, error));
+    }
+    return result;
+  };
+  const applyFunction2 = (context, node, signal, compiledFunc, compiledArgs) => {
+    signal == null ? void 0 : signal.throwIfAborted();
+    return resolveMaybePromise(
+      compiledFunc(context, signal),
+      (func) => {
+        if (typeof func !== "function") {
+          throwError({
+            description: "could not apply it for function",
+            range: node.range
+          });
+        }
+        return applyResolvedFunction(
+          context,
+          node,
+          signal,
+          func,
+          compiledArgs
+        );
+      }
+    );
+  };
+  const generateExpressionImmediate = (node) => {
+    const cached = expressionImmediateCache.get(node);
+    if (cached) {
+      return cached;
+    }
+    let generator;
+    switch (node.kind) {
+      case "number":
+      case "string": {
+        generator = () => node.value;
+        break;
+      }
+      case "template": {
+        const generatedText = generateTextProgramImmediate(node.blocks);
+        generator = (context, signal) => generatedText(context, signal);
+        break;
+      }
+      case "variable": {
+        const variableResult = deconstructConditionalCombine(node.name);
+        generator = (context, signal) => resolveVariable(context, variableResult, node.range, signal);
+        break;
+      }
+      case "dot": {
+        const compiledBase = node.base.kind === "variable" ? void 0 : generateExpressionImmediate(node.base);
+        const baseResult = node.base.kind === "variable" ? deconstructConditionalCombine(node.base.name) : void 0;
+        generator = (context, signal) => resolveDotNode2(context, node, signal, compiledBase, baseResult);
+        break;
+      }
+      case "apply": {
+        const compiledFunc = generateExpressionImmediate(node.func);
+        const compiledArgs = node.args.map(generateExpressionImmediate);
+        const isIntrinsicCond = node.func.kind === "variable" && node.func.name === "cond" && node.args.length === 3;
+        const intrinsicFunParameters = node.func.kind === "variable" && node.func.name === "fun" && node.args.length === 2 ? extractLambdaParameterNames(node.args[0]) : void 0;
+        const intrinsicFunBody = intrinsicFunParameters !== void 0 ? node.args[1] : void 0;
+        const compiledIntrinsicFunBody = intrinsicFunBody !== void 0 ? generateExpressionImmediate(intrinsicFunBody) : void 0;
+        const specializedBuiltinName = node.func.kind === "variable" ? node.func.name : void 0;
+        const specializedBuiltin = specializedBuiltinName !== void 0 ? toSpecializableStandardCallTarget(specializedBuiltinName) : void 0;
+        if (isIntrinsicCond) {
+          generator = (context, signal) => {
+            const boundFunction = context.getValue("cond", signal);
+            if (boundFunction.isFound && boundFunction.value === standardVariables.cond) {
+              return resolveMaybePromise(
+                compiledArgs[0](context, signal),
+                (condition) => isConditionalTrue(condition) ? compiledArgs[1](context, signal) : compiledArgs[2](context, signal)
+              );
+            }
+            return applyFunction2(
+              context,
+              node,
+              signal,
+              compiledFunc,
+              compiledArgs
+            );
+          };
+          break;
+        }
+        if (compiledIntrinsicFunBody !== void 0 && intrinsicFunParameters !== void 0) {
+          generator = (context, signal) => {
+            const boundFunction = context.getValue("fun", signal);
+            if (boundFunction.isFound && boundFunction.value === standardVariables.fun) {
+              return (...args) => {
+                if (args.length < intrinsicFunParameters.length) {
+                  throwError({
+                    description: `Arguments are not filled: ${args.length} < ${intrinsicFunParameters.length}`,
+                    range: node.range
+                  });
+                }
+                if (args.length > intrinsicFunParameters.length) {
+                  context.appendWarning({
+                    type: "warning",
+                    description: `Too many arguments: ${args.length} > ${intrinsicFunParameters.length}`,
+                    range: node.range
+                  });
+                }
+                const newContext = context.newCallScope(
+                  intrinsicFunParameters,
+                  args,
+                  signal
+                );
+                return compiledIntrinsicFunBody(newContext, signal);
+              };
+            }
+            if (specializedBuiltin === void 0) {
+              return applyFunction2(
+                context,
+                node,
+                signal,
+                compiledFunc,
+                compiledArgs
+              );
+            }
+            const specializedFunction = context.getValue(
+              specializedBuiltinName,
+              signal
+            );
+            if (specializedFunction.isFound && specializedFunction.value === specializedBuiltin) {
+              return applySpecializedStandardFunction(
+                context,
+                node,
+                signal,
+                specializedBuiltin,
+                compiledArgs
+              );
+            }
+            return applyFunction2(
+              context,
+              node,
+              signal,
+              compiledFunc,
+              compiledArgs
+            );
+          };
+          break;
+        }
+        if (specializedBuiltin === void 0) {
+          generator = (context, signal) => applyFunction2(context, node, signal, compiledFunc, compiledArgs);
+          break;
+        }
+        generator = (context, signal) => {
+          const boundFunction = context.getValue(
+            specializedBuiltinName,
+            signal
+          );
+          if (boundFunction.isFound && boundFunction.value === specializedBuiltin) {
+            return applySpecializedStandardFunction(
+              context,
+              node,
+              signal,
+              specializedBuiltin,
+              compiledArgs
+            );
+          }
+          return applyFunction2(
+            context,
+            node,
+            signal,
+            compiledFunc,
+            compiledArgs
+          );
+        };
+        break;
+      }
+      case "list": {
+        const compiledItems = node.items.map(generateExpressionImmediate);
+        generator = (context, signal) => collectExpressionValues(compiledItems, context, signal);
+        break;
+      }
+      case "scope": {
+        const compiledNodes = node.nodes.map(generateExpressionImmediate);
+        generator = (context, signal) => {
+          if (compiledNodes.length === 0) {
+            return [];
+          }
+          let result = void 0;
+          for (let index = 0; index < compiledNodes.length; index++) {
+            const current = compiledNodes[index](context, signal);
+            if (isPromiseLike(current)) {
+              return (async () => {
+                result = await current;
+                for (let continueIndex = index + 1; continueIndex < compiledNodes.length; continueIndex++) {
+                  result = await compiledNodes[continueIndex](context, signal);
+                }
+                return result;
+              })();
+            }
+            result = current;
+          }
+          return result;
+        };
+        break;
+      }
+    }
+    expressionImmediateCache.set(node, generator);
+    return generator;
+  };
+  const generateExpression = (node) => {
+    const cached = expressionCache.get(node);
+    if (cached) {
+      return cached;
+    }
+    const immediate = generateExpressionImmediate(node);
+    const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+    expressionCache.set(node, generator);
+    return generator;
+  };
+  const generateBlockImmediate = (node) => {
+    const cached = blockImmediateCache.get(node);
+    if (cached) {
+      return cached;
+    }
+    let generator;
+    switch (node.kind) {
+      case "text": {
+        generator = () => [node.text];
+        break;
+      }
+      case "for": {
+        const iterableGenerator = generateExpressionImmediate(node.iterable);
+        const repeatGenerator = generateRawProgramImmediate(node.repeat);
+        generator = (context, signal) => resolveMaybePromise(
+          iterableGenerator(context, signal),
+          (result) => {
+            const iterable = asIterable(result);
+            if (!iterable) {
+              throwError({
+                description: "could not apply it for function",
+                range: node.range
+              });
+            }
+            const resolvedIterable = iterable;
+            const resultList = [];
+            const iterator = resolvedIterable[Symbol.iterator]();
+            for (let current = iterator.next(); !current.done; current = iterator.next()) {
+              context.setValue(node.bind.name, current.value, signal);
+              const repeated = repeatGenerator(context, signal);
+              if (isPromiseLike(repeated)) {
+                return (async () => {
+                  resultList.push(...await repeated);
+                  for (let next = iterator.next(); !next.done; next = iterator.next()) {
+                    context.setValue(node.bind.name, next.value, signal);
+                    resultList.push(
+                      ...await repeatGenerator(context, signal)
+                    );
+                  }
+                  return resultList;
+                })();
+              }
+              resultList.push(...repeated);
+            }
+            return resultList;
+          }
+        );
+        break;
+      }
+      case "while": {
+        const conditionGenerator = generateExpressionImmediate(node.condition);
+        const repeatGenerator = generateRawProgramImmediate(node.repeat);
+        generator = (context, signal) => {
+          const resultList = [];
+          while (true) {
+            const condition = conditionGenerator(context, signal);
+            if (isPromiseLike(condition)) {
+              return (async () => {
+                let currentCondition = await condition;
+                while (isConditionalTrue(currentCondition)) {
+                  resultList.push(...await repeatGenerator(context, signal));
+                  currentCondition = await conditionGenerator(context, signal);
+                }
+                return resultList;
+              })();
+            }
+            if (!isConditionalTrue(condition)) {
+              return resultList;
+            }
+            const repeated = repeatGenerator(context, signal);
+            if (isPromiseLike(repeated)) {
+              return (async () => {
+                resultList.push(...await repeated);
+                while (true) {
+                  const currentCondition = await conditionGenerator(
+                    context,
+                    signal
+                  );
+                  if (!isConditionalTrue(currentCondition)) {
+                    break;
+                  }
+                  resultList.push(...await repeatGenerator(context, signal));
+                }
+                return resultList;
+              })();
+            }
+            resultList.push(...repeated);
+          }
+        };
+        break;
+      }
+      case "if": {
+        const conditionGenerator = generateExpressionImmediate(node.condition);
+        const thenGenerator = generateRawProgramImmediate(node.then);
+        const elseGenerator = generateRawProgramImmediate(node.else);
+        generator = (context, signal) => resolveMaybePromise(
+          conditionGenerator(context, signal),
+          (condition) => isConditionalTrue(condition) ? thenGenerator(context, signal) : elseGenerator(context, signal)
+        );
+        break;
+      }
+      default: {
+        const expressionGenerator = generateExpressionImmediate(node);
+        generator = (context, signal) => resolveMaybePromise(
+          expressionGenerator(context, signal),
+          (result) => [result]
+        );
+        break;
+      }
+    }
+    blockImmediateCache.set(node, generator);
+    return generator;
+  };
+  const generateBlock = (node) => {
+    const cached = blockCache.get(node);
+    if (cached) {
+      return cached;
+    }
+    const immediate = generateBlockImmediate(node);
+    const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+    blockCache.set(node, generator);
+    return generator;
+  };
+  const generateTextBlockImmediate = (node) => {
+    const cached = textBlockImmediateCache.get(node);
+    if (cached) {
+      return cached;
+    }
+    let generator;
+    switch (node.kind) {
+      case "text": {
+        generator = () => node.text;
+        break;
+      }
+      case "for": {
+        const iterableGenerator = generateExpressionImmediate(node.iterable);
+        const repeatGenerator = generateTextProgramImmediate(node.repeat);
+        generator = (context, signal) => resolveMaybePromise(
+          iterableGenerator(context, signal),
+          (result) => {
+            const iterable = asIterable(result);
+            if (!iterable) {
+              throwError({
+                description: "could not apply it for function",
+                range: node.range
+              });
+            }
+            const resolvedIterable = iterable;
+            const iterator = resolvedIterable[Symbol.iterator]();
+            let text = "";
+            for (let current = iterator.next(); !current.done; current = iterator.next()) {
+              context.setValue(node.bind.name, current.value, signal);
+              const repeated = repeatGenerator(context, signal);
+              if (isPromiseLike(repeated)) {
+                return (async () => {
+                  text += await repeated;
+                  for (let next = iterator.next(); !next.done; next = iterator.next()) {
+                    context.setValue(node.bind.name, next.value, signal);
+                    text += await repeatGenerator(context, signal);
+                  }
+                  return text;
+                })();
+              }
+              text += repeated;
+            }
+            return text;
+          }
+        );
+        break;
+      }
+      case "while": {
+        const conditionGenerator = generateExpressionImmediate(node.condition);
+        const repeatGenerator = generateTextProgramImmediate(node.repeat);
+        generator = (context, signal) => {
+          let text = "";
+          while (true) {
+            const condition = conditionGenerator(context, signal);
+            if (isPromiseLike(condition)) {
+              return (async () => {
+                let currentCondition = await condition;
+                while (isConditionalTrue(currentCondition)) {
+                  text += await repeatGenerator(context, signal);
+                  currentCondition = await conditionGenerator(context, signal);
+                }
+                return text;
+              })();
+            }
+            if (!isConditionalTrue(condition)) {
+              return text;
+            }
+            const repeated = repeatGenerator(context, signal);
+            if (isPromiseLike(repeated)) {
+              return (async () => {
+                text += await repeated;
+                while (true) {
+                  const currentCondition = await conditionGenerator(
+                    context,
+                    signal
+                  );
+                  if (!isConditionalTrue(currentCondition)) {
+                    break;
+                  }
+                  text += await repeatGenerator(context, signal);
+                }
+                return text;
+              })();
+            }
+            text += repeated;
+          }
+        };
+        break;
+      }
+      case "if": {
+        const conditionGenerator = generateExpressionImmediate(node.condition);
+        const thenGenerator = generateTextProgramImmediate(node.then);
+        const elseGenerator = generateTextProgramImmediate(node.else);
+        generator = (context, signal) => resolveMaybePromise(
+          conditionGenerator(context, signal),
+          (condition) => isConditionalTrue(condition) ? thenGenerator(context, signal) : elseGenerator(context, signal)
+        );
+        break;
+      }
+      default: {
+        const expressionGenerator = generateExpressionImmediate(node);
+        generator = (context, signal) => resolveMaybePromise(
+          expressionGenerator(context, signal),
+          (result) => result === void 0 ? "" : context.convertToString(result)
+        );
+        break;
+      }
+    }
+    textBlockImmediateCache.set(node, generator);
+    return generator;
+  };
+  const generateProgramImmediate = (nodes) => {
+    const cached = programImmediateCache.get(nodes);
+    if (cached) {
+      return cached;
+    }
+    const generatedBlocks = generateRawProgramImmediate(nodes);
+    const generator = (context, signal) => resolveMaybePromise(
+      generatedBlocks(context, signal),
+      (results) => filterUndefined(results)
+    );
+    programImmediateCache.set(nodes, generator);
+    return generator;
+  };
+  const generateProgram = (nodes) => {
+    const cached = programCache.get(nodes);
+    if (cached) {
+      return cached;
+    }
+    const immediate = generateProgramImmediate(nodes);
+    const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+    programCache.set(nodes, generator);
+    return generator;
+  };
+  const generateTextProgram = (nodes) => {
+    const cached = textProgramCache.get(nodes);
+    if (cached) {
+      return cached;
+    }
+    const immediate = generateTextProgramImmediate(nodes);
+    const generator = (context, signal) => Promise.resolve(immediate(context, signal));
+    textProgramCache.set(nodes, generator);
+    return generator;
+  };
+  const createExecutor = () => {
+    const reduceExpressionNodeImmediate = (context, node, signal) => generateExpressionImmediate(node)(context, signal);
+    const reduceNodeImmediate = (context, node, signal) => generateBlockImmediate(node)(context, signal);
+    return {
+      reduceExpressionNode: (context, node, signal) => Promise.resolve(reduceExpressionNodeImmediate(context, node, signal)),
+      reduceExpressionNodeImmediate,
+      reduceNode: (context, node, signal) => Promise.resolve(reduceNodeImmediate(context, node, signal)),
+      reduceNodeImmediate
+    };
+  };
+  return {
+    generateExpression,
+    generateBlock,
+    generateProgram,
+    generateTextProgram,
+    createExecutor
+  };
+};
+const createSourceRunner = (body) => {
+  return new AsyncFunction(
+    "context",
+    "signal",
+    "runtime",
+    `'use strict';
+${body}`
+  );
+};
+const stripAbortChecksFromSource = (body) => {
+  return body.replace(/(^|\n)signal\?\.throwIfAborted\(\);\n?/g, "$1");
+};
+const createAdaptiveSourceRunner = (body) => {
+  const runnerWithSignal = createSourceRunner(body);
+  const runnerWithoutSignal = createSourceRunner(
+    stripAbortChecksFromSource(body)
+  );
+  return (context, signal, runtime) => signal === void 0 ? runnerWithoutSignal(context, void 0, runtime) : runnerWithSignal(context, signal, runtime);
+};
+const createSourceDCodegen = (options) => {
+  var _a;
+  const closureGenerator = createClosureDCodegen();
+  const closureExecutor = closureGenerator.createExecutor();
+  const aggressiveOptimize = (_a = options == null ? void 0 : options.aggressiveOptimize) != null ? _a : false;
+  const expressionCache = /* @__PURE__ */ new WeakMap();
+  const blockCache = /* @__PURE__ */ new WeakMap();
+  const programCache = /* @__PURE__ */ new WeakMap();
+  const textProgramCache = /* @__PURE__ */ new WeakMap();
+  const addConstant = (state, value) => {
+    const index = state.constants.length;
+    state.constants.push(value);
+    return index;
+  };
+  const allocateTemp = (state, prefix) => {
+    return `__${prefix}${state.nextTempId++}`;
+  };
+  const emptyCompileScope = {
+    localSlots: /* @__PURE__ */ new Map(),
+    directBindings: /* @__PURE__ */ new Map(),
+    selfBindings: /* @__PURE__ */ new Map()
+  };
+  const extendCompileScope = (scope, name, slotVar) => {
+    return {
+      localSlots: new Map(scope.localSlots).set(name, slotVar),
+      directBindings: scope.directBindings,
+      selfBindings: scope.selfBindings
+    };
+  };
+  const extendDirectBindingCompileScope = (scope, name, bindingRef) => {
+    return {
+      localSlots: scope.localSlots,
+      directBindings: new Map(scope.directBindings).set(name, bindingRef),
+      selfBindings: scope.selfBindings
+    };
+  };
+  const extendSelfBindingCompileScope = (scope, name, bindingRef) => {
+    return {
+      localSlots: scope.localSlots,
+      directBindings: scope.directBindings,
+      selfBindings: new Map(scope.selfBindings).set(name, bindingRef)
+    };
+  };
+  const resolveLocalSlotRef = (scope, name) => {
+    return scope.localSlots.get(name);
+  };
+  const resolveSelfBindingRef = (scope, name) => {
+    return scope.selfBindings.get(name);
+  };
+  const resolveDirectBindingRef = (scope, name) => {
+    return scope.directBindings.get(name);
+  };
+  const createLookupResultSource = (scope, name) => {
+    const localSlotRef = resolveLocalSlotRef(scope, name);
+    return localSlotRef !== void 0 ? `{ isFound: true, value: context.getSlotValue(${localSlotRef}, signal) }` : `context.getValue(${JSON.stringify(name)}, signal)`;
+  };
+  const resolveAggressiveVariableSource = (state, name) => {
+    if (!state.aggressiveOptimize) {
+      return void 0;
+    }
+    switch (name) {
+      case "undefined": {
+        return "undefined";
+      }
+      case "null": {
+        return "null";
+      }
+      case "true": {
+        return "true";
+      }
+      case "false": {
+        return "false";
+      }
+      case "cond": {
+        return "runtime.standardIntrinsics.cond";
+      }
+      case "fun": {
+        return "runtime.standardIntrinsics.fun";
+      }
+      case "set": {
+        return "runtime.standardIntrinsics.set";
+      }
+      case "add":
+      case "sub":
+      case "mul":
+      case "div":
+      case "mod":
+      case "eq":
+      case "ne":
+      case "lt":
+      case "gt":
+      case "le":
+      case "ge":
+      case "not": {
+        return `runtime.standardBuiltins.${name}`;
+      }
+      case "and":
+      case "or": {
+        return `runtime.constants[${addConstant(
+          state,
+          standardVariables[name]
+        )}]`;
+      }
+      case "range":
+      case "map":
+      case "filter":
+      case "reduce": {
+        return `runtime.standardBuiltins.${name}`;
+      }
+      default: {
+        return void 0;
+      }
+    }
+  };
+  const canExpressionSuspend = (node) => {
+    switch (node.kind) {
+      case "number":
+      case "string":
+      case "variable": {
+        return false;
+      }
+      case "template": {
+        return canBlockListSuspend(node.blocks);
+      }
+      case "dot": {
+        return canExpressionSuspend(node.base);
+      }
+      case "apply": {
+        return true;
+      }
+      case "list": {
+        return node.items.some((item) => canExpressionSuspend(item));
+      }
+      case "scope": {
+        return node.nodes.some((childNode) => canExpressionSuspend(childNode));
+      }
+    }
+  };
+  const canBlockSuspend = (node) => {
+    switch (node.kind) {
+      case "text": {
+        return false;
+      }
+      case "for": {
+        return canExpressionSuspend(node.iterable) || canBlockListSuspend(node.repeat);
+      }
+      case "while": {
+        return canExpressionSuspend(node.condition) || canBlockListSuspend(node.repeat);
+      }
+      case "if": {
+        return canExpressionSuspend(node.condition) || canBlockListSuspend(node.then) || canBlockListSuspend(node.else);
+      }
+      default: {
+        return canExpressionSuspend(node);
+      }
+    }
+  };
+  const canBlockListSuspend = (nodes) => {
+    return nodes.some((node) => canBlockSuspend(node));
+  };
+  const expressionContainsSetForName = (node, name) => {
+    var _a2;
+    switch (node.kind) {
+      case "number":
+      case "string":
+      case "variable": {
+        return false;
+      }
+      case "template": {
+        return blockListContainsSetForName(node.blocks, name);
+      }
+      case "dot": {
+        return expressionContainsSetForName(node.base, name);
+      }
+      case "apply": {
+        if (node.func.kind === "variable" && node.func.name === "set" && ((_a2 = node.args[0]) == null ? void 0 : _a2.kind) === "variable" && node.args[0].name === name) {
+          return true;
+        }
+        if (expressionContainsSetForName(node.func, name)) {
+          return true;
+        }
+        return node.args.some((arg) => expressionContainsSetForName(arg, name));
+      }
+      case "list": {
+        return node.items.some(
+          (item) => expressionContainsSetForName(item, name)
+        );
+      }
+      case "scope": {
+        return node.nodes.some(
+          (childNode) => blockContainsSetForName(childNode, name)
+        );
+      }
+    }
+  };
+  const blockContainsSetForName = (node, name) => {
+    switch (node.kind) {
+      case "text": {
+        return false;
+      }
+      case "for": {
+        return expressionContainsSetForName(node.iterable, name) || blockListContainsSetForName(node.repeat, name);
+      }
+      case "while": {
+        return expressionContainsSetForName(node.condition, name) || blockListContainsSetForName(node.repeat, name);
+      }
+      case "if": {
+        return expressionContainsSetForName(node.condition, name) || blockListContainsSetForName(node.then, name) || blockListContainsSetForName(node.else, name);
+      }
+      default: {
+        return expressionContainsSetForName(node, name);
+      }
+    }
+  };
+  const blockListContainsSetForName = (nodes, name) => {
+    return nodes.some((node) => blockContainsSetForName(node, name));
+  };
+  const wrapAwaitedSource = (source, canSuspend) => {
+    return canSuspend ? `await (${source})` : `(${source})`;
+  };
+  const wrapSourceClosure = (body, canSuspend) => {
+    return canSuspend ? `(async () => {
+${body}
+})()` : `(() => {
+${body}
+})()`;
+  };
+  const getBuiltinArgSource = (argVars, index) => {
+    var _a2;
+    return (_a2 = argVars[index]) != null ? _a2 : "undefined";
+  };
+  const compileNumericFoldSource = (argVars, operator) => {
+    const initial = `Number(${getBuiltinArgSource(argVars, 0)})`;
+    return argVars.slice(1).reduce(
+      (expression, argVar) => `(${expression} ${operator} Number(${argVar}))`,
+      initial
+    );
+  };
+  const compileInlineStandardBuiltinSource = (name, argVars) => {
+    switch (name) {
+      case "toString": {
+        return `[${argVars.map((argVar) => `context.convertToString(${argVar})`).join(", ")}].join(',')`;
+      }
+      case "toBoolean": {
+        return `runtime.isConditionalTrue(${getBuiltinArgSource(argVars, 0)})`;
+      }
+      case "toNumber": {
+        return `Number(${getBuiltinArgSource(argVars, 0)})`;
+      }
+      case "toBigInt": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+const __value = ${argSource};
+switch (typeof __value) {
+case 'number':
+case 'bigint':
+case 'string':
+case 'boolean':
+return BigInt(__value);
+default:
+return BigInt(context.convertToString(__value));
+}
+})()`;
+      }
+      case "typeof": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+const __value = ${argSource};
+if (__value === null) {
+return 'null';
+}
+if (typeof __value === 'string') {
+return 'string';
+}
+if (Array.isArray(__value)) {
+return 'array';
+}
+if (runtime.asIterable(__value)) {
+return 'iterable';
+}
+return typeof __value;
+})()`;
+      }
+      case "add": {
+        return compileNumericFoldSource(argVars, "+");
+      }
+      case "sub": {
+        return compileNumericFoldSource(argVars, "-");
+      }
+      case "mul": {
+        return compileNumericFoldSource(argVars, "*");
+      }
+      case "div": {
+        return compileNumericFoldSource(argVars, "/");
+      }
+      case "mod": {
+        return compileNumericFoldSource(argVars, "%");
+      }
+      case "eq": {
+        return `(${getBuiltinArgSource(argVars, 0)} === ${getBuiltinArgSource(argVars, 1)})`;
+      }
+      case "ne": {
+        return `(${getBuiltinArgSource(argVars, 0)} !== ${getBuiltinArgSource(argVars, 1)})`;
+      }
+      case "lt": {
+        return `(${getBuiltinArgSource(argVars, 0)} < ${getBuiltinArgSource(argVars, 1)})`;
+      }
+      case "gt": {
+        return `(${getBuiltinArgSource(argVars, 0)} > ${getBuiltinArgSource(argVars, 1)})`;
+      }
+      case "le": {
+        return `(${getBuiltinArgSource(argVars, 0)} <= ${getBuiltinArgSource(argVars, 1)})`;
+      }
+      case "ge": {
+        return `(${getBuiltinArgSource(argVars, 0)} >= ${getBuiltinArgSource(argVars, 1)})`;
+      }
+      case "not": {
+        return `(!runtime.isConditionalTrue(${getBuiltinArgSource(argVars, 0)}))`;
+      }
+      case "trim": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+let __value = ${argSource};
+if (__value === undefined || __value === null) {
+__value = '';
+} else if (typeof __value !== 'string') {
+__value = __value.toString() ?? '';
+}
+return __value.trim();
+})()`;
+      }
+      case "toUpper": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+let __value = ${argSource};
+if (typeof __value !== 'string') {
+__value = __value.toString() ?? '';
+}
+return __value.toUpperCase();
+})()`;
+      }
+      case "toLower": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+let __value = ${argSource};
+if (typeof __value !== 'string') {
+__value = __value.toString() ?? '';
+}
+return __value.toLowerCase();
+})()`;
+      }
+      case "length": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+const __value = ${argSource};
+if (!__value) {
+return 0;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value.length;
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return 0;
+}
+let __count = 0;
+for (const __item of __iterable) {
+__count++;
+}
+return __count;
+})()`;
+      }
+      case "at": {
+        const indexSource = getBuiltinArgSource(argVars, 0);
+        const valueSource = getBuiltinArgSource(argVars, 1);
+        return `(() => {
+const __index = Number(${indexSource});
+const __value = ${valueSource};
+if (!__value) {
+return undefined;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value[__index];
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return undefined;
+}
+let __current = 0;
+for (const __item of __iterable) {
+if (__current >= __index) {
+return __item;
+}
+__current++;
+}
+return undefined;
+})()`;
+      }
+      case "first": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+const __value = ${argSource};
+if (!__value) {
+return undefined;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value[0];
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return undefined;
+}
+for (const __item of __iterable) {
+return __item;
+}
+return undefined;
+})()`;
+      }
+      case "last": {
+        const argSource = getBuiltinArgSource(argVars, 0);
+        return `(() => {
+const __value = ${argSource};
+if (!__value) {
+return undefined;
+}
+if (typeof __value === 'string' || Array.isArray(__value)) {
+return __value[__value.length - 1];
+}
+const __iterable = runtime.asIterable(__value);
+if (!__iterable) {
+return undefined;
+}
+let __lastItem = undefined;
+for (const __item of __iterable) {
+__lastItem = __item;
+}
+return __lastItem;
+})()`;
+      }
+      case "slice": {
+        const startSource = getBuiltinArgSource(argVars, 0);
+        const middleSource = getBuiltinArgSource(argVars, 1);
+        const tailSource = getBuiltinArgSource(argVars, 2);
+        return `(() => {
+const __start = ${startSource} === undefined ? undefined : Number(${startSource});
+if (${tailSource} === undefined) {
+const __value = ${middleSource};
+if (typeof __value === 'string') {
+return __value.slice(__start);
+}
+return Array.from(__value).slice(__start, undefined);
+}
+const __end = ${middleSource} === undefined ? undefined : Number(${middleSource});
+const __value = ${tailSource};
+if (typeof __value === 'string') {
+return __value.slice(__start, __end);
+}
+return Array.from(__value).slice(__start, __end);
+})()`;
+      }
+      default: {
+        return void 0;
+      }
+    }
+  };
+  const compileDirectInlineBuiltinApplySource = (state, node, scope, name) => {
+    const builtinArgVars = node.args.map(() => allocateTemp(state, "arg"));
+    const inlineBuiltinSource = compileInlineStandardBuiltinSource(
+      name,
+      builtinArgVars
+    );
+    if (inlineBuiltinSource === void 0) {
+      return void 0;
+    }
+    const builtinArgStatements = node.args.map((arg, index) => {
+      const argSource = compileExpressionSource(state, arg, scope);
+      return `const ${builtinArgVars[index]} = ${wrapAwaitedSource(
+        argSource,
+        canExpressionSuspend(arg)
+      )};`;
+    }).join("\n");
+    return wrapSourceClosure(
+      `signal?.throwIfAborted();
+${builtinArgStatements}
+return ${inlineBuiltinSource};`,
+      node.args.some((arg) => canExpressionSuspend(arg))
+    );
+  };
+  const compileDirectLogicalApplySource = (state, node, scope, kind) => {
+    const rangeIndex = addConstant(state, node.range);
+    if (node.args.length === 0) {
+      return wrapSourceClosure(
+        `signal?.throwIfAborted();
+runtime.throwError({ description: 'empty arguments', range: runtime.constants[${rangeIndex}] });`,
+        false
+      );
+    }
+    const valueVars = node.args.map(() => allocateTemp(state, "value"));
+    const body = node.args.map((arg, index) => {
+      const valueVar = valueVars[index];
+      const argSource = compileExpressionSource(state, arg, scope);
+      const condition = kind === "and" ? `!runtime.isConditionalTrue(${valueVar})` : `runtime.isConditionalTrue(${valueVar})`;
+      const result = kind === "and" ? "false" : "true";
+      return `const ${valueVar} = ${wrapAwaitedSource(
+        argSource,
+        canExpressionSuspend(arg)
+      )};
+if (${condition}) {
+return ${result};
+}`;
+    }).join("\n");
+    return wrapSourceClosure(
+      `signal?.throwIfAborted();
+${body}
+return ${kind === "and" ? "true" : "false"};`,
+      node.args.some((arg) => canExpressionSuspend(arg))
+    );
+  };
+  const compileDirectRangeApplySource = (state, node, scope) => {
+    const startVar = allocateTemp(state, "start");
+    const countVar = allocateTemp(state, "count");
+    const resultVar = allocateTemp(state, "range");
+    const indexVar = allocateTemp(state, "index");
+    const startSource = node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(
+      compileExpressionSource(state, node.args[0], scope),
+      canExpressionSuspend(node.args[0])
+    );
+    const countSource = node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(
+      compileExpressionSource(state, node.args[1], scope),
+      canExpressionSuspend(node.args[1])
+    );
+    return wrapSourceClosure(
+      `signal?.throwIfAborted();
+let ${startVar} = Number(${startSource});
+const ${countVar} = Number(${countSource});
+const ${resultVar} = [];
+for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {
+${resultVar}.push(${startVar}++);
+}
+return ${resultVar};`,
+      node.args[0] !== void 0 && canExpressionSuspend(node.args[0]) || node.args[1] !== void 0 && canExpressionSuspend(node.args[1])
+    );
+  };
+  const compileDirectCollectionApplySource = (state, node, scope, name) => {
+    if (name === "map") {
+      const mapperVar = allocateTemp(state, "mapper");
+      const iterableVar2 = allocateTemp(state, "iterable");
+      const resultVar = allocateTemp(state, "mapped");
+      const itemVar2 = allocateTemp(state, "item");
+      const mapperSource = node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(
+        compileExpressionSource(state, node.args[0], scope),
+        canExpressionSuspend(node.args[0])
+      );
+      const iterableSource2 = node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(
+        compileExpressionSource(state, node.args[1], scope),
+        canExpressionSuspend(node.args[1])
+      );
+      return wrapSourceClosure(
+        `signal?.throwIfAborted();
+const ${mapperVar} = ${mapperSource};
+const ${iterableVar2} = ${iterableSource2};
+const ${resultVar} = [];
+for (const ${itemVar2} of ${iterableVar2}) {
+${resultVar}.push(await ${mapperVar}(${itemVar2}));
+}
+return ${resultVar};`,
+        true
+      );
     }
+    if (name === "filter") {
+      const predicateVar = allocateTemp(state, "predicate");
+      const iterableVar2 = allocateTemp(state, "iterable");
+      const resultVar = allocateTemp(state, "filtered");
+      const itemVar2 = allocateTemp(state, "item");
+      const predicateSource = node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(
+        compileExpressionSource(state, node.args[0], scope),
+        canExpressionSuspend(node.args[0])
+      );
+      const iterableSource2 = node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(
+        compileExpressionSource(state, node.args[1], scope),
+        canExpressionSuspend(node.args[1])
+      );
+      return wrapSourceClosure(
+        `signal?.throwIfAborted();
+const ${predicateVar} = ${predicateSource};
+const ${iterableVar2} = ${iterableSource2};
+const ${resultVar} = [];
+for (const ${itemVar2} of ${iterableVar2}) {
+if (runtime.isConditionalTrue(await ${predicateVar}(${itemVar2}))) {
+${resultVar}.push(${itemVar2});
+}
+}
+return ${resultVar};`,
+        true
+      );
+    }
+    const accVar = allocateTemp(state, "acc");
+    const reducerVar = allocateTemp(state, "reducer");
+    const iterableVar = allocateTemp(state, "iterable");
+    const itemVar = allocateTemp(state, "item");
+    const initialSource = node.args[0] === void 0 ? "undefined" : wrapAwaitedSource(
+      compileExpressionSource(state, node.args[0], scope),
+      canExpressionSuspend(node.args[0])
+    );
+    const reducerSource = node.args[1] === void 0 ? "undefined" : wrapAwaitedSource(
+      compileExpressionSource(state, node.args[1], scope),
+      canExpressionSuspend(node.args[1])
+    );
+    const iterableSource = node.args[2] === void 0 ? "undefined" : wrapAwaitedSource(
+      compileExpressionSource(state, node.args[2], scope),
+      canExpressionSuspend(node.args[2])
+    );
+    return wrapSourceClosure(
+      `signal?.throwIfAborted();
+let ${accVar} = ${initialSource};
+const ${reducerVar} = ${reducerSource};
+const ${iterableVar} = ${iterableSource};
+for (const ${itemVar} of ${iterableVar}) {
+${accVar} = await ${reducerVar}(${accVar}, ${itemVar});
+}
+return ${accVar};`,
+      true
+    );
+  };
+  const compileAggressiveApplySource = (state, node, scope) => {
+    if (!state.aggressiveOptimize || node.func.kind !== "variable") {
+      return void 0;
+    }
+    switch (node.func.name) {
+      case "add":
+      case "sub":
+      case "mul":
+      case "div":
+      case "mod":
+      case "eq":
+      case "ne":
+      case "lt":
+      case "gt":
+      case "le":
+      case "ge":
+      case "not": {
+        return compileDirectInlineBuiltinApplySource(
+          state,
+          node,
+          scope,
+          node.func.name
+        );
+      }
+      case "and":
+      case "or": {
+        return compileDirectLogicalApplySource(
+          state,
+          node,
+          scope,
+          node.func.name
+        );
+      }
+      case "range": {
+        return compileDirectRangeApplySource(state, node, scope);
+      }
+      case "map":
+      case "filter":
+      case "reduce": {
+        return compileDirectCollectionApplySource(
+          state,
+          node,
+          scope,
+          node.func.name
+        );
+      }
+      default: {
+        return void 0;
+      }
+    }
+  };
+  const deconstructAggressiveRangeLoop = (state, node) => {
+    if (!state.aggressiveOptimize || node.kind !== "apply") {
+      return void 0;
+    }
+    if (node.func.kind !== "variable" || node.func.name !== "range") {
+      return void 0;
+    }
+    return {
+      startNode: node.args[0],
+      countNode: node.args[1]
+    };
+  };
+  const toNumberLiteral = (state, value) => {
+    if (Object.is(value, -0)) {
+      return "-0";
+    }
+    if (Number.isFinite(value)) {
+      return String(value);
+    }
+    return `runtime.constants[${addConstant(state, value)}]`;
+  };
+  const createRuntime = (constants) => {
+    return {
+      constants,
+      standardBuiltins: specializableStandardCallTargets,
+      standardIntrinsics: {
+        cond: standardVariables.cond,
+        fun: standardVariables.fun,
+        set: standardVariables.set
+      },
+      asIterable,
+      isConditionalTrue,
+      isFunCityFunction,
+      throwError,
+      handleApplyError,
+      resolveVariable: resolveSourceVariable,
+      resolveDotSegments: resolveSourceDotSegments,
+      invokeCallable: invokeSourceCallable,
+      invokeBuiltin: invokeSourceBuiltin
+    };
+  };
+  const compileBlockStatements = (state, node, targetVar, filterUndefinedValues, scope) => {
+    switch (node.kind) {
+      case "text": {
+        return `${targetVar}.push(${JSON.stringify(node.text)});
+`;
+      }
+      case "for": {
+        const iterableVar = allocateTemp(state, "iterable");
+        const slotVar = allocateTemp(state, "slot");
+        const itemVar = allocateTemp(state, "item");
+        const rangeIndex = addConstant(state, node.range);
+        const iterableSource = compileExpressionSource(
+          state,
+          node.iterable,
+          scope
+        );
+        return `{
+const ${iterableVar} = runtime.asIterable(${wrapAwaitedSource(
+          iterableSource,
+          canExpressionSuspend(node.iterable)
+        )});
+if (!${iterableVar}) {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+const ${slotVar} = context.ensureLocalSlot(${JSON.stringify(
+          node.bind.name
+        )}, signal);
+for (const ${itemVar} of ${iterableVar}) {
+context.setSlotValue(${slotVar}, ${itemVar}, signal);
+${compileBlockListStatements(
+          state,
+          node.repeat,
+          targetVar,
+          filterUndefinedValues,
+          extendCompileScope(scope, node.bind.name, slotVar)
+        )}
+}
+}
+`;
+      }
+      case "while": {
+        const conditionSource = compileExpressionSource(
+          state,
+          node.condition,
+          scope
+        );
+        return `while (runtime.isConditionalTrue(${wrapAwaitedSource(
+          conditionSource,
+          canExpressionSuspend(node.condition)
+        )})) {
+${compileBlockListStatements(
+          state,
+          node.repeat,
+          targetVar,
+          filterUndefinedValues,
+          scope
+        )}
+}
+`;
+      }
+      case "if": {
+        const conditionSource = compileExpressionSource(
+          state,
+          node.condition,
+          scope
+        );
+        return `if (runtime.isConditionalTrue(${wrapAwaitedSource(
+          conditionSource,
+          canExpressionSuspend(node.condition)
+        )})) {
+${compileBlockListStatements(
+          state,
+          node.then,
+          targetVar,
+          filterUndefinedValues,
+          scope
+        )}
+} else {
+${compileBlockListStatements(
+          state,
+          node.else,
+          targetVar,
+          filterUndefinedValues,
+          scope
+        )}
+}
+`;
+      }
+      default: {
+        const valueVar = allocateTemp(state, "value");
+        const valueSource = compileExpressionSource(state, node, scope);
+        return `{
+const ${valueVar} = ${wrapAwaitedSource(
+          valueSource,
+          canExpressionSuspend(node)
+        )};
+${filterUndefinedValues ? `if (${valueVar} !== undefined) { ${targetVar}.push(${valueVar}); }` : `${targetVar}.push(${valueVar});`}
+}
+`;
+      }
+    }
+  };
+  const compileBlockListStatements = (state, nodes, targetVar, filterUndefinedValues, scope) => {
+    return nodes.map(
+      (node) => compileBlockStatements(
+        state,
+        node,
+        targetVar,
+        filterUndefinedValues,
+        scope
+      )
+    ).join("");
+  };
+  const compileTextBlockStatements = (state, node, targetVar, scope) => {
+    switch (node.kind) {
+      case "text": {
+        return `${targetVar} += ${JSON.stringify(node.text)};
+`;
+      }
+      case "for": {
+        const aggressiveRangeLoop = deconstructAggressiveRangeLoop(
+          state,
+          node.iterable
+        );
+        if (aggressiveRangeLoop !== void 0) {
+          const startVar = allocateTemp(state, "start");
+          const countVar = allocateTemp(state, "count");
+          const indexVar = allocateTemp(state, "index");
+          const itemVar2 = allocateTemp(state, "item");
+          const startSource = aggressiveRangeLoop.startNode === void 0 ? "undefined" : wrapAwaitedSource(
+            compileExpressionSource(
+              state,
+              aggressiveRangeLoop.startNode,
+              scope
+            ),
+            canExpressionSuspend(aggressiveRangeLoop.startNode)
+          );
+          const countSource = aggressiveRangeLoop.countNode === void 0 ? "undefined" : wrapAwaitedSource(
+            compileExpressionSource(
+              state,
+              aggressiveRangeLoop.countNode,
+              scope
+            ),
+            canExpressionSuspend(aggressiveRangeLoop.countNode)
+          );
+          const canUseDirectBinding = !blockListContainsSetForName(
+            node.repeat,
+            node.bind.name
+          );
+          if (canUseDirectBinding) {
+            return `{
+let ${startVar} = Number(${startSource});
+const ${countVar} = Number(${countSource});
+for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {
+const ${itemVar2} = ${startVar}++;
+${compileTextBlockListStatements(
+              state,
+              node.repeat,
+              targetVar,
+              extendDirectBindingCompileScope(scope, node.bind.name, itemVar2)
+            )}
+}
+}
+`;
+          }
+          const slotVar2 = allocateTemp(state, "slot");
+          return `{
+let ${startVar} = Number(${startSource});
+const ${countVar} = Number(${countSource});
+const ${slotVar2} = context.ensureLocalSlot(${JSON.stringify(
+            node.bind.name
+          )}, signal);
+for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {
+const ${itemVar2} = ${startVar}++;
+context.setSlotValue(${slotVar2}, ${itemVar2}, signal);
+${compileTextBlockListStatements(
+            state,
+            node.repeat,
+            targetVar,
+            extendCompileScope(scope, node.bind.name, slotVar2)
+          )}
+}
+}
+`;
+        }
+        const iterableVar = allocateTemp(state, "iterable");
+        const slotVar = allocateTemp(state, "slot");
+        const itemVar = allocateTemp(state, "item");
+        const rangeIndex = addConstant(state, node.range);
+        const iterableSource = compileExpressionSource(
+          state,
+          node.iterable,
+          scope
+        );
+        return `{
+const ${iterableVar} = runtime.asIterable(${wrapAwaitedSource(
+          iterableSource,
+          canExpressionSuspend(node.iterable)
+        )});
+if (!${iterableVar}) {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+const ${slotVar} = context.ensureLocalSlot(${JSON.stringify(
+          node.bind.name
+        )}, signal);
+for (const ${itemVar} of ${iterableVar}) {
+context.setSlotValue(${slotVar}, ${itemVar}, signal);
+${compileTextBlockListStatements(
+          state,
+          node.repeat,
+          targetVar,
+          extendCompileScope(scope, node.bind.name, slotVar)
+        )}
+}
+}
+`;
+      }
+      case "while": {
+        const conditionSource = compileExpressionSource(
+          state,
+          node.condition,
+          scope
+        );
+        return `while (runtime.isConditionalTrue(${wrapAwaitedSource(
+          conditionSource,
+          canExpressionSuspend(node.condition)
+        )})) {
+${compileTextBlockListStatements(state, node.repeat, targetVar, scope)}
+}
+`;
+      }
+      case "if": {
+        const conditionSource = compileExpressionSource(
+          state,
+          node.condition,
+          scope
+        );
+        return `if (runtime.isConditionalTrue(${wrapAwaitedSource(
+          conditionSource,
+          canExpressionSuspend(node.condition)
+        )})) {
+${compileTextBlockListStatements(state, node.then, targetVar, scope)}
+} else {
+${compileTextBlockListStatements(state, node.else, targetVar, scope)}
+}
+`;
+      }
+      default: {
+        const valueVar = allocateTemp(state, "value");
+        const valueSource = compileExpressionSource(state, node, scope);
+        if (state.aggressiveOptimize) {
+          return `{
+const ${valueVar} = ${wrapAwaitedSource(
+            valueSource,
+            canExpressionSuspend(node)
+          )};
+if (${valueVar} !== undefined) {
+if (${valueVar} === null) {
+${targetVar} += '(null)';
+} else {
+switch (typeof ${valueVar}) {
+case 'string':
+${targetVar} += ${valueVar};
+break;
+case 'boolean':
+case 'number':
+case 'bigint':
+case 'symbol':
+${targetVar} += ${valueVar}.toString();
+break;
+default:
+${targetVar} += context.convertToString(${valueVar});
+break;
+}
+}
+}
+}
+`;
+        }
+        return `{
+const ${valueVar} = ${wrapAwaitedSource(
+          valueSource,
+          canExpressionSuspend(node)
+        )};
+if (${valueVar} !== undefined) {
+${targetVar} += context.convertToString(${valueVar});
+}
+}
+`;
+      }
+    }
+  };
+  const compileTextBlockListStatements = (state, nodes, targetVar, scope) => {
+    return nodes.map((node) => compileTextBlockStatements(state, node, targetVar, scope)).join("");
+  };
+  const compileIntrinsicLambdaSource = (state, lambdaRange, parameterNames, bodyNode, scope, selfBinding) => {
+    const lambdaArgsVar = allocateTemp(state, "args");
+    const lambdaContextVar = allocateTemp(state, "context");
+    const rangeIndex = addConstant(state, lambdaRange);
+    const parameterNamesIndex = addConstant(state, [...parameterNames]);
+    const parameterSlotRefs = /* @__PURE__ */ new Map();
+    for (const parameterName of parameterNames) {
+      if (!parameterSlotRefs.has(parameterName)) {
+        parameterSlotRefs.set(parameterName, String(parameterSlotRefs.size));
+      }
+    }
+    const lambdaScope = Array.from(parameterSlotRefs.entries()).reduce(
+      (currentScope, [parameterName, slotRef]) => extendCompileScope(currentScope, parameterName, slotRef),
+      selfBinding === void 0 ? scope : extendSelfBindingCompileScope(
+        scope,
+        selfBinding.name,
+        selfBinding.bindingRef
+      )
+    );
+    const bodySource = compileExpressionSource(state, bodyNode, lambdaScope);
+    return `(...${lambdaArgsVar}) => {
+if (${lambdaArgsVar}.length < ${parameterNames.length}) {
+runtime.throwError({ description: 'Arguments are not filled: ' + ${lambdaArgsVar}.length + ' < ${parameterNames.length}', range: runtime.constants[${rangeIndex}] });
+}
+if (${lambdaArgsVar}.length > ${parameterNames.length}) {
+context.appendWarning({ type: 'warning', description: 'Too many arguments: ' + ${lambdaArgsVar}.length + ' > ${parameterNames.length}', range: runtime.constants[${rangeIndex}] });
+}
+const ${lambdaContextVar} = context.newCallScope(runtime.constants[${parameterNamesIndex}], ${lambdaArgsVar}, signal);
+return ((context) => {
+return ${bodySource};
+})(${lambdaContextVar});
+}`;
+  };
+  const compileGenericApplySource = (state, node, scope) => {
+    const applyNodeIndex = addConstant(state, node);
+    const rangeIndex = addConstant(state, node.range);
+    const argsNodeIndex = addConstant(state, node.args);
+    const argArraySource = `[${node.args.map(
+      (arg) => wrapAwaitedSource(
+        compileExpressionSource(state, arg, scope),
+        canExpressionSuspend(arg)
+      )
+    ).join(", ")}]`;
+    if (node.func.kind === "variable") {
+      const specializedBuiltin = toSpecializableStandardCallTarget(
+        node.func.name
+      );
+      if (specializedBuiltin !== void 0) {
+        const bindingVar = allocateTemp(state, "binding");
+        const funcVar2 = allocateTemp(state, "func");
+        const callArgsVar = allocateTemp(state, "args");
+        const builtinArgVars = node.args.map(() => allocateTemp(state, "arg"));
+        const inlineBuiltinSource = compileInlineStandardBuiltinSource(
+          node.func.name,
+          builtinArgVars
+        );
+        const builtinArgStatements = node.args.map((arg, index) => {
+          const argSource = compileExpressionSource(state, arg, scope);
+          return `const ${builtinArgVars[index]} = ${wrapAwaitedSource(
+            argSource,
+            canExpressionSuspend(arg)
+          )};`;
+        }).join("\n");
+        return `(async () => {
+signal?.throwIfAborted();
+const ${bindingVar} = ${createLookupResultSource(scope, node.func.name)};
+if (${bindingVar}.isFound && ${bindingVar}.value === runtime.standardBuiltins.${node.func.name}) {
+${builtinArgStatements}
+try {
+return ${inlineBuiltinSource != null ? inlineBuiltinSource : `await runtime.standardBuiltins.${node.func.name}(${builtinArgVars.join(", ")})`};
+} catch (error) {
+return runtime.handleApplyError(runtime.constants[${applyNodeIndex}], error);
+}
+}
+const ${funcVar2} = ${bindingVar}.isFound
+? ${bindingVar}.value
+: runtime.resolveVariable(context, ${JSON.stringify(
+          node.func.name
+        )}, false, runtime.constants[${addConstant(
+          state,
+          node.func.range
+        )}], signal);
+if (typeof ${funcVar2} !== 'function') {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+if (runtime.isFunCityFunction(${funcVar2})) {
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar2}, runtime.constants[${argsNodeIndex}], true);
+}
+const ${callArgsVar} = ${argArraySource};
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar2}, ${callArgsVar}, false);
+})()`;
+      }
+    }
+    const funcVar = allocateTemp(state, "func");
+    const argsVar = allocateTemp(state, "args");
+    const funcSource = compileExpressionSource(state, node.func, scope);
+    return `(async () => {
+signal?.throwIfAborted();
+const ${funcVar} = ${wrapAwaitedSource(
+      funcSource,
+      canExpressionSuspend(node.func)
+    )};
+if (typeof ${funcVar} !== 'function') {
+runtime.throwError({ description: 'could not apply it for function', range: runtime.constants[${rangeIndex}] });
+}
+if (runtime.isFunCityFunction(${funcVar})) {
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar}, runtime.constants[${argsNodeIndex}], true);
+}
+const ${argsVar} = ${argArraySource};
+return runtime.invokeCallable(context, runtime.constants[${applyNodeIndex}], signal, ${funcVar}, ${argsVar}, false);
+})()`;
+  };
+  const compileExpressionSource = (state, node, scope) => {
+    var _a2, _b;
+    switch (node.kind) {
+      case "number": {
+        return toNumberLiteral(state, node.value);
+      }
+      case "string": {
+        return JSON.stringify(node.value);
+      }
+      case "template": {
+        const textVar = allocateTemp(state, "text");
+        return wrapSourceClosure(
+          `let ${textVar} = '';
+${compileTextBlockListStatements(state, node.blocks, textVar, scope)}
+return ${textVar};`,
+          canBlockListSuspend(node.blocks)
+        );
+      }
+      case "variable": {
+        const variableResult = deconstructConditionalCombine(node.name);
+        const aggressiveSource = resolveAggressiveVariableSource(
+          state,
+          variableResult.name
+        );
+        if (aggressiveSource !== void 0) {
+          return aggressiveSource;
+        }
+        const localSlotRef = resolveLocalSlotRef(scope, variableResult.name);
+        if (localSlotRef !== void 0) {
+          return `context.getSlotValue(${localSlotRef}, signal)`;
+        }
+        const directBindingRef = resolveDirectBindingRef(
+          scope,
+          variableResult.name
+        );
+        if (directBindingRef !== void 0) {
+          return directBindingRef;
+        }
+        const selfBindingRef = resolveSelfBindingRef(
+          scope,
+          variableResult.name
+        );
+        if (selfBindingRef !== void 0) {
+          return selfBindingRef;
+        }
+        const rangeIndex = addConstant(state, node.range);
+        return `runtime.resolveVariable(context, ${JSON.stringify(
+          variableResult.name
+        )}, ${variableResult.canIgnore ? "true" : "false"}, runtime.constants[${rangeIndex}], signal)`;
+      }
+      case "dot": {
+        const segments = node.segments.map((segment) => {
+          const result = deconstructConditionalCombine(segment.name);
+          return {
+            name: result.name,
+            canIgnore: segment.optional || result.canIgnore,
+            range: segment.range
+          };
+        });
+        const segmentsIndex = addConstant(state, segments);
+        if (node.base.kind === "variable") {
+          const baseResult = deconstructConditionalCombine(node.base.name);
+          const localSlotRef = resolveLocalSlotRef(scope, baseResult.name);
+          const baseRangeIndex = addConstant(state, node.base.range);
+          const baseValueVar = allocateTemp(state, "base");
+          return wrapSourceClosure(
+            `signal?.throwIfAborted();
+const ${baseValueVar} = ${localSlotRef !== void 0 ? `{ isFound: true, value: context.getSlotValue(${localSlotRef}, signal) }` : createLookupResultSource(scope, baseResult.name)};
+if (!${baseValueVar}.isFound) {
+${baseResult.canIgnore || ((_b = (_a2 = node.segments[0]) == null ? void 0 : _a2.optional) != null ? _b : false) ? "return undefined;" : `runtime.throwError({ description: ${JSON.stringify(
+              `variable is not bound: ${baseResult.name}`
+            )}, range: runtime.constants[${baseRangeIndex}] });`}
+}
+return runtime.resolveDotSegments(context, ${baseValueVar}.value, runtime.constants[${segmentsIndex}]);`,
+            false
+          );
+        }
+        const baseSource = compileExpressionSource(state, node.base, scope);
+        return wrapSourceClosure(
+          `signal?.throwIfAborted();
+return runtime.resolveDotSegments(
+context,
+${wrapAwaitedSource(baseSource, canExpressionSuspend(node.base))},
+runtime.constants[${segmentsIndex}]
+);`,
+          canExpressionSuspend(node.base)
+        );
+      }
+      case "apply": {
+        if (node.func.kind === "variable" && resolveLocalSlotRef(scope, node.func.name) === void 0) {
+          const selfBindingRef = resolveSelfBindingRef(scope, node.func.name);
+          if (selfBindingRef !== void 0) {
+            const selfArgSources = node.args.map(
+              (arg) => wrapAwaitedSource(
+                compileExpressionSource(state, arg, scope),
+                canExpressionSuspend(arg)
+              )
+            );
+            return wrapSourceClosure(
+              `signal?.throwIfAborted();
+return ${selfBindingRef}(${selfArgSources.join(", ")});`,
+              node.args.some((arg) => canExpressionSuspend(arg))
+            );
+          }
+        }
+        if (node.func.kind === "variable" && node.func.name === "set" && node.args.length === 2 && node.args[0].kind === "variable" && node.args[1].kind === "apply" && node.args[1].func.kind === "variable" && node.args[1].func.name === "fun" && node.args[1].args.length === 2) {
+          const parameterNames = extractLambdaParameterNames(
+            node.args[1].args[0]
+          );
+          if (parameterNames !== void 0) {
+            const boundName = node.args[0].name;
+            const lambdaVar = allocateTemp(state, "lambda");
+            const lambdaSource = compileIntrinsicLambdaSource(
+              state,
+              node.args[1].range,
+              parameterNames,
+              node.args[1].args[1],
+              scope,
+              {
+                name: boundName,
+                bindingRef: lambdaVar
+              }
+            );
+            if (state.aggressiveOptimize) {
+              return wrapSourceClosure(
+                `signal?.throwIfAborted();
+const ${lambdaVar} = ${lambdaSource};
+context.setValue(${JSON.stringify(boundName)}, ${lambdaVar}, signal);
+return undefined;`,
+                true
+              );
+            }
+            const setBindingVar = allocateTemp(state, "binding");
+            const funBindingVar = allocateTemp(state, "binding");
+            return wrapSourceClosure(
+              `signal?.throwIfAborted();
+const ${setBindingVar} = ${createLookupResultSource(scope, "set")};
+const ${funBindingVar} = ${createLookupResultSource(scope, "fun")};
+if (${setBindingVar}.isFound && ${setBindingVar}.value === runtime.standardIntrinsics.set && ${funBindingVar}.isFound && ${funBindingVar}.value === runtime.standardIntrinsics.fun) {
+const ${lambdaVar} = ${lambdaSource};
+context.setValue(${JSON.stringify(boundName)}, ${lambdaVar}, signal);
+return undefined;
+}
+return ${compileGenericApplySource(state, node, scope)};`,
+              true
+            );
+          }
+        }
+        if (node.func.kind === "variable" && state.aggressiveOptimize && node.func.name === "set" && node.args.length === 2 && node.args[0].kind === "variable") {
+          const valueSource = compileExpressionSource(
+            state,
+            node.args[1],
+            scope
+          );
+          return wrapSourceClosure(
+            `signal?.throwIfAborted();
+context.setValue(${JSON.stringify(node.args[0].name)}, ${wrapAwaitedSource(
+              valueSource,
+              canExpressionSuspend(node.args[1])
+            )}, signal);
+return undefined;`,
+            canExpressionSuspend(node.args[1])
+          );
+        }
+        if (node.func.kind === "variable" && node.func.name === "cond" && node.args.length === 3) {
+          const conditionNode = node.args[0];
+          const thenNode = node.args[1];
+          const elseNode = node.args[2];
+          const bindingVar = allocateTemp(state, "binding");
+          const conditionVar = allocateTemp(state, "condition");
+          const conditionSource = compileExpressionSource(
+            state,
+            conditionNode,
+            scope
+          );
+          const thenSource = compileExpressionSource(state, thenNode, scope);
+          const elseSource = compileExpressionSource(state, elseNode, scope);
+          if (state.aggressiveOptimize) {
+            return wrapSourceClosure(
+              `signal?.throwIfAborted();
+const ${conditionVar} = ${wrapAwaitedSource(
+                conditionSource,
+                canExpressionSuspend(conditionNode)
+              )};
+if (runtime.isConditionalTrue(${conditionVar})) {
+return ${wrapAwaitedSource(thenSource, canExpressionSuspend(thenNode))};
+}
+return ${wrapAwaitedSource(elseSource, canExpressionSuspend(elseNode))};`,
+              true
+            );
+          }
+          return wrapSourceClosure(
+            `signal?.throwIfAborted();
+const ${bindingVar} = ${createLookupResultSource(scope, "cond")};
+if (${bindingVar}.isFound && ${bindingVar}.value === runtime.standardIntrinsics.cond) {
+const ${conditionVar} = ${wrapAwaitedSource(
+              conditionSource,
+              canExpressionSuspend(conditionNode)
+            )};
+if (runtime.isConditionalTrue(${conditionVar})) {
+return ${wrapAwaitedSource(thenSource, canExpressionSuspend(thenNode))};
+}
+return ${wrapAwaitedSource(elseSource, canExpressionSuspend(elseNode))};
+}
+return ${compileGenericApplySource(state, node, scope)};`,
+            true
+          );
+        }
+        if (node.func.kind === "variable" && node.func.name === "fun" && node.args.length === 2) {
+          const parameterNames = extractLambdaParameterNames(node.args[0]);
+          if (parameterNames !== void 0) {
+            const lambdaSource = compileIntrinsicLambdaSource(
+              state,
+              node.range,
+              parameterNames,
+              node.args[1],
+              scope,
+              void 0
+            );
+            if (state.aggressiveOptimize) {
+              return lambdaSource;
+            }
+            const bindingVar = allocateTemp(state, "binding");
+            return wrapSourceClosure(
+              `signal?.throwIfAborted();
+const ${bindingVar} = ${createLookupResultSource(scope, "fun")};
+if (${bindingVar}.isFound && ${bindingVar}.value === runtime.standardIntrinsics.fun) {
+return ${lambdaSource};
+}
+return ${compileGenericApplySource(state, node, scope)};`,
+              true
+            );
+          }
+        }
+        const aggressiveApplySource = compileAggressiveApplySource(
+          state,
+          node,
+          scope
+        );
+        if (aggressiveApplySource !== void 0) {
+          return aggressiveApplySource;
+        }
+        return compileGenericApplySource(state, node, scope);
+      }
+      case "list": {
+        return `[${node.items.map(
+          (item) => wrapAwaitedSource(
+            compileExpressionSource(state, item, scope),
+            canExpressionSuspend(item)
+          )
+        ).join(", ")}]`;
+      }
+      case "scope": {
+        if (node.nodes.length === 0) {
+          return "[]";
+        }
+        const resultVar = allocateTemp(state, "result");
+        return wrapSourceClosure(
+          `let ${resultVar} = undefined;
+${node.nodes.map((childNode) => {
+            const childSource = compileExpressionSource(state, childNode, scope);
+            return `${resultVar} = ${wrapAwaitedSource(
+              childSource,
+              canExpressionSuspend(childNode)
+            )};`;
+          }).join("\n")}
+return ${resultVar};`,
+          node.nodes.some((childNode) => canExpressionSuspend(childNode))
+        );
+      }
+    }
+  };
+  const createExpressionRunner = (node) => {
+    const cached = expressionCache.get(node);
+    if (cached) {
+      return cached;
+    }
+    const state = {
+      nextTempId: 0,
+      constants: [],
+      aggressiveOptimize
+    };
+    const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+return ${compileExpressionSource(state, node, emptyCompileScope)};`);
+    const runtime = createRuntime(state.constants);
+    const generated = (context, signal) => runner(context, signal, runtime);
+    expressionCache.set(node, generated);
+    return generated;
+  };
+  const createBlockRunner = (node) => {
+    const cached = blockCache.get(node);
+    if (cached) {
+      return cached;
+    }
+    const state = {
+      nextTempId: 0,
+      constants: [],
+      aggressiveOptimize
+    };
+    const resultVar = allocateTemp(state, "result");
+    const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+const ${resultVar} = [];
+${compileBlockStatements(state, node, resultVar, false, emptyCompileScope)}
+return ${resultVar};`);
+    const runtime = createRuntime(state.constants);
+    const generated = (context, signal) => runner(context, signal, runtime);
+    blockCache.set(node, generated);
+    return generated;
+  };
+  const createProgramRunner = (nodes) => {
+    const cached = programCache.get(nodes);
+    if (cached) {
+      return cached;
+    }
+    const state = {
+      nextTempId: 0,
+      constants: [],
+      aggressiveOptimize
+    };
+    const resultVar = allocateTemp(state, "result");
+    const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+const ${resultVar} = [];
+${compileBlockListStatements(state, nodes, resultVar, true, emptyCompileScope)}
+return ${resultVar};`);
+    const runtime = createRuntime(state.constants);
+    const generated = (context, signal) => runner(context, signal, runtime);
+    programCache.set(nodes, generated);
+    return generated;
+  };
+  const createTextProgramRunner = (nodes) => {
+    const cached = textProgramCache.get(nodes);
+    if (cached) {
+      return cached;
+    }
+    const state = {
+      nextTempId: 0,
+      constants: [],
+      aggressiveOptimize
+    };
+    const textVar = allocateTemp(state, "text");
+    const runner = createAdaptiveSourceRunner(`const {
+constants,
+standardBuiltins,
+asIterable,
+isConditionalTrue,
+isFunCityFunction,
+throwError,
+resolveVariable,
+resolveDotSegments,
+invokeCallable,
+invokeBuiltin
+} = runtime;
+let ${textVar} = '';
+${compileTextBlockListStatements(state, nodes, textVar, emptyCompileScope)}
+return ${textVar};`);
+    const runtime = createRuntime(state.constants);
+    const generated = (context, signal) => runner(context, signal, runtime);
+    textProgramCache.set(nodes, generated);
+    return generated;
+  };
+  const createExecutor = () => {
+    return {
+      reduceExpressionNode: (context, node, signal) => createExpressionRunner(node)(context, signal),
+      reduceExpressionNodeImmediate: closureExecutor.reduceExpressionNodeImmediate,
+      reduceNode: (context, node, signal) => createBlockRunner(node)(context, signal),
+      reduceNodeImmediate: closureExecutor.reduceNodeImmediate
+    };
+  };
+  return {
+    generateExpression: createExpressionRunner,
+    generateBlock: createBlockRunner,
+    generateProgram: createProgramRunner,
+    generateTextProgram: createTextProgramRunner,
+    createExecutor
+  };
+};
+const createDCodegen = (options) => {
+  switch (options == null ? void 0 : options.backend) {
+    case "source":
+      return createSourceDCodegen(options);
+    case "closure":
+    case void 0:
+      return createClosureDCodegen();
+  }
+};
+const runDCodegen = async (nodes, variables, warningLogs, signal) => {
+  const dcodegen = createDCodegen();
+  const context = createReducerContext(
+    variables,
+    warningLogs,
+    dcodegen.createExecutor()
+  );
+  const generator = dcodegen.generateProgram(nodes);
+  return await generator(context, signal);
+};
+const compilationCacheLimit = 64;
+const sharedSourceDCodegen = createDCodegen({ backend: "source" });
+const sharedAggressiveSourceDCodegen = createDCodegen({
+  backend: "source",
+  aggressiveOptimize: true
+});
+const sharedClosureDCodegen = createDCodegen({ backend: "closure" });
+const compiledScriptCache = /* @__PURE__ */ new Map();
+const defaultExecutionBackend = "source";
+const resolveExecutionBackend$1 = (backend) => backend != null ? backend : defaultExecutionBackend;
+const isDynamicCodegenBackend = (backend) => backend !== "reducer";
+const resolveAggressiveOptimize = (backend, aggressiveOptimize) => backend === "source" ? aggressiveOptimize != null ? aggressiveOptimize : false : false;
+const getSharedDCodegen = (backend, aggressiveOptimize) => {
+  if (backend === "closure") {
+    return sharedClosureDCodegen;
+  }
+  return resolveAggressiveOptimize(backend, aggressiveOptimize) ? sharedAggressiveSourceDCodegen : sharedSourceDCodegen;
+};
+const toCompilationCacheKey = (script, sourceId, mode, backend, aggressiveOptimize) => `${mode}\0${backend}\0${aggressiveOptimize ? "aggr1" : "aggr0"}\0${sourceId}\0${script}`;
+const setCompiledScriptCache = (key, compiled) => {
+  compiledScriptCache.set(key, compiled);
+  if (compiledScriptCache.size <= compilationCacheLimit) {
+    return;
+  }
+  const firstKey = compiledScriptCache.keys().next().value;
+  if (firstKey !== void 0) {
+    compiledScriptCache.delete(firstKey);
+  }
+};
+const createSharedDCodegenExecutor = (backend, aggressiveOptimize) => {
+  return getSharedDCodegen(
+    backend != null ? backend : defaultExecutionBackend,
+    aggressiveOptimize
+  ).createExecutor();
+};
+const createReducerBackedProgram = (nodes) => {
+  return async (context, signal) => {
+    const resultList = [];
+    for (const node of nodes) {
+      const results = await context.reduceNode(node, signal);
+      for (const result of results) {
+        if (result !== void 0) {
+          resultList.push(result);
+        }
+      }
+    }
+    return resultList;
+  };
+};
+const createReducerBackedTextProgram = (nodes) => {
+  const reducerProgram = createReducerBackedProgram(nodes);
+  return async (context, signal) => {
+    const resultList = await reducerProgram(context, signal);
+    return resultList.map((value) => context.convertToString(value)).join("");
+  };
+};
+const compileScriptCached = (script, sourceId, mode, backend, aggressiveOptimize) => {
+  var _a, _b;
+  const resolvedBackend = resolveExecutionBackend$1(backend);
+  const resolvedAggressiveOptimize = resolveAggressiveOptimize(
+    resolvedBackend,
+    aggressiveOptimize
+  );
+  const cacheKey = toCompilationCacheKey(
+    script,
+    sourceId,
+    mode,
+    resolvedBackend,
+    resolvedAggressiveOptimize
+  );
+  const cached = compiledScriptCache.get(cacheKey);
+  if (cached) {
+    compiledScriptCache.delete(cacheKey);
+    compiledScriptCache.set(cacheKey, cached);
+    return cached;
+  }
+  const logs = [];
+  const tokens = mode === "code" ? runCodeTokenizer(script, logs, sourceId) : runTokenizer(script, logs, sourceId);
+  const nodes = mode === "code" ? parseExpressions(tokens, logs) : runParser(tokens, logs);
+  const sharedDCodegen = isDynamicCodegenBackend(resolvedBackend) ? getSharedDCodegen(resolvedBackend, resolvedAggressiveOptimize) : void 0;
+  const compiled = {
+    sourceId,
+    mode,
+    nodes,
+    logs: logs.slice(),
+    program: (_a = sharedDCodegen == null ? void 0 : sharedDCodegen.generateProgram(nodes)) != null ? _a : createReducerBackedProgram(nodes),
+    textProgram: (_b = sharedDCodegen == null ? void 0 : sharedDCodegen.generateTextProgram(nodes)) != null ? _b : createReducerBackedTextProgram(nodes)
+  };
+  setCompiledScriptCache(cacheKey, compiled);
+  return compiled;
+};
+const resolveExecutionBackend = (backend) => backend != null ? backend : "source";
+const runScriptOnce = async (script, props, signal) => {
+  const {
+    variables = buildCandidateVariables(),
+    backend,
+    aggressiveOptimize,
+    logs = [],
+    sourceId
+  } = props;
+  const executionBackend = resolveExecutionBackend(backend);
+  const compiled = compileScriptCached(
+    script,
+    sourceId,
+    "template",
+    executionBackend,
+    aggressiveOptimize
+  );
+  logs.push(...compiled.logs);
+  if (compiled.logs.length >= 1) {
+    return [];
+  }
+  const warningLogs = [];
+  const reducerContext = createReducerContext(
+    variables,
+    warningLogs,
+    executionBackend === "reducer" ? void 0 : createSharedDCodegenExecutor(executionBackend, aggressiveOptimize)
+  );
+  try {
+    const resultList = await compiled.program(reducerContext, signal);
+    logs.push(...warningLogs);
+    return resultList;
+  } catch (error) {
+    logs.push(...warningLogs);
+    if (error instanceof FunCityReducerError) {
+      logs.push(error.info);
+      return [];
+    }
+    throw error;
+  }
+};
+const runScriptOnceToText = async (script, props, signal) => {
+  const {
+    variables = buildCandidateVariables(),
+    backend,
+    aggressiveOptimize,
+    logs = [],
+    sourceId
+  } = props;
+  const executionBackend = resolveExecutionBackend(backend);
+  const compiled = compileScriptCached(
+    script,
+    sourceId,
+    "template",
+    executionBackend,
+    aggressiveOptimize
+  );
+  logs.push(...compiled.logs);
+  if (compiled.logs.length >= 1) {
+    return void 0;
+  }
+  const warningLogs = [];
+  const reducerContext = createReducerContext(
+    variables,
+    warningLogs,
+    executionBackend === "reducer" ? void 0 : createSharedDCodegenExecutor(executionBackend, aggressiveOptimize)
+  );
+  try {
+    const text = await compiled.textProgram(reducerContext, signal);
+    logs.push(...warningLogs);
+    return text;
   } catch (error) {
     logs.push(...warningLogs);
     if (error instanceof FunCityReducerError) {
@@ -3295,9 +6067,6 @@ const runScriptOnceToText = async (script, props, signal) => {
     }
     throw error;
   }
-  logs.push(...warningLogs);
-  const text = resultList.map((result) => reducerContext.convertToString(result)).join("");
-  return text;
 };
 const objectVariables = Object.freeze({
   Object,
@@ -3371,10 +6140,13 @@ const fetchVariables = Object.freeze({
 exports.FunCityReducerError = FunCityReducerError;
 exports.buildCandidateVariables = buildCandidateVariables;
 exports.combineVariables = combineVariables;
+exports.compileScriptCached = compileScriptCached;
 exports.convertToString = convertToString;
+exports.createDCodegen = createDCodegen;
 exports.createIncludeFunction = createIncludeFunction;
 exports.createParserCursor = createParserCursor;
 exports.createReducerContext = createReducerContext;
+exports.createSharedDCodegenExecutor = createSharedDCodegenExecutor;
 exports.emptyLocation = emptyLocation;
 exports.emptyRange = emptyRange;
 exports.fetchVariables = fetchVariables;
@@ -3389,6 +6161,7 @@ exports.parseExpressions = parseExpressions;
 exports.reduceExpressionNode = reduceExpressionNode;
 exports.reduceNode = reduceNode;
 exports.runCodeTokenizer = runCodeTokenizer;
+exports.runDCodegen = runDCodegen;
 exports.runParser = runParser;
 exports.runReducer = runReducer;
 exports.runScriptOnce = runScriptOnce;