funcity 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -1,19 +1,227 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const emptyLocation = {
+  line: 0,
+  column: 0
+};
+const emptyRange = {
+  start: emptyLocation,
+  end: emptyLocation
+};
+const specialFunctionMarker = /* @__PURE__ */ Symbol("$$special$$");
+const makeFunCityFunction = (f) => {
+  f[specialFunctionMarker] = true;
+  return f;
+};
+const isFunCityFunction = (f) => {
+  var _a;
+  return (_a = f[specialFunctionMarker]) != null ? _a : false;
+};
+const isConditionalTrue = (v) => {
+  if (v === void 0 || v === null) {
+    return false;
+  }
+  switch (typeof v) {
+    case "boolean":
+      return v;
+    case "number":
+    case "bigint":
+      return v !== 0;
+    default:
+      return true;
+  }
+};
+const asIterable = (v) => {
+  if (typeof v[Symbol.iterator] === "function") {
+    return v;
+  } else {
+    return void 0;
+  }
+};
+const combineVariables = (...variablesList) => {
+  const variables = /* @__PURE__ */ new Map();
+  const appendVariables = (vs) => vs.forEach((v, k) => variables.set(k, v));
+  const appendRecord = (vs) => Object.keys(vs).forEach((k) => variables.set(k, vs[k]));
+  variablesList.forEach((vs) => {
+    if (vs["forEach"] !== void 0) {
+      appendVariables(vs);
+    } else {
+      appendRecord(vs);
+    }
+  });
+  return variables;
+};
+const fromError = (error) => {
+  var _a;
+  if (error.message) {
+    return error.message;
+  } else if (typeof error.toString === "function") {
+    return (_a = error.toString()) != null ? _a : "unknown";
+  } else {
+    return "unknown";
+  }
+};
+const widerRange = (...ranges) => {
+  let start = emptyRange.start;
+  let end = emptyRange.end;
+  for (const range of ranges) {
+    if (range.start.line >= 1 && range.start.column >= 1) {
+      if (start.line === 0 || start.column === 0) {
+        start = range.start;
+      } else if (range.start.line < start.line) {
+        start = range.start;
+      } else if (range.start.line === start.line && range.start.column < start.column) {
+        start = range.start;
+      }
+      if (end.line === 0 || end.column === 0) {
+        end = range.end;
+      } else if (range.end.line > end.line) {
+        end = range.end;
+      } else if (range.end.line === end.line && range.end.column > end.column) {
+        end = range.end;
+      }
+    }
+  }
+  return { start, end };
+};
+const locationEquals = (lhs, rhs) => lhs.line === rhs.line && lhs.column === rhs.column;
+const getLocationString = (range) => locationEquals(range.start, range.end) ? `${range.start.line}:${range.start.column}` : `${range.start.line}:${range.start.column}:${range.end.line}:${range.end.column}`;
+const printErrorString = (path, error) => {
+  switch (error.type) {
+    case "warning":
+      console.warn(
+        `${path}:${getLocationString(error.range)}: warning: ${error.description}`
+      );
+      break;
+    case "error":
+      console.error(
+        `${path}:${getLocationString(error.range)}: error: ${error.description}`
+      );
+      return true;
+  }
+  return false;
+};
+const outputErrors = (path, errors) => {
+  let isError = false;
+  for (const error of errors) {
+    const result = printErrorString(path, error);
+    isError || (isError = result);
+  }
+  return isError;
+};
+const funcIds = /* @__PURE__ */ new WeakMap();
+let nextId = 1;
+const getFuncId = (fn) => {
+  const cached = funcIds.get(fn);
+  if (cached) {
+    return cached;
+  }
+  const id = nextId++;
+  funcIds.set(fn, id);
+  return id;
+};
+const convertToString = (v) => {
+  switch (v) {
+    case void 0:
+      return "(undefined)";
+    case null:
+      return "(null)";
+    default:
+      switch (typeof v) {
+        case "string":
+          return v;
+        case "boolean":
+          return v ? "true" : "false";
+        case "number":
+        case "bigint":
+        case "symbol":
+          return v.toString();
+        case "function":
+          if (v.name) {
+            return `fun<${v.name}:#${getFuncId(v)}>`;
+          } else {
+            return `fun<#${getFuncId(v)}>`;
+          }
+        default:
+          if (Array.isArray(v)) {
+            return JSON.stringify(v);
+          }
+          const iterable = asIterable(v);
+          if (iterable) {
+            const arr = Array.from(iterable);
+            return JSON.stringify(arr);
+          } else if (v instanceof Date) {
+            return v.toISOString();
+          } else if (v instanceof Error) {
+            return `${v.name}: ${v.message}`;
+          } else if (v instanceof URL) {
+            return v.origin;
+          } else {
+            return JSON.stringify(v);
+          }
+      }
+  }
+};
+const stringEscapeMap = {
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	",
+  v: "\v",
+  "0": "\0",
+  "'": "'",
+  "\\": "\\"
+};
 const tokenizeString = (context) => {
   const start = context.cursor.location("start");
   context.cursor.skip(1);
-  let value = context.cursor.getUntil("'");
-  if (value !== void 0) {
+  let value = "";
+  let closed = false;
+  while (!context.cursor.eot()) {
+    const ch = context.cursor.getChar();
+    if (ch === "'") {
+      context.cursor.skip(1);
+      closed = true;
+      break;
+    }
+    if (ch === "\\") {
+      const escapeStart = context.cursor.location("start");
+      context.cursor.skip(1);
+      if (context.cursor.eot()) {
+        context.errors.push({
+          type: "error",
+          description: "invalid escape sequence: \\\\",
+          range: { start: escapeStart, end: context.cursor.location("end") }
+        });
+        value += "\\";
+        break;
+      }
+      const escape = context.cursor.getChar();
+      const mapped = stringEscapeMap[escape];
+      if (mapped !== void 0) {
+        value += mapped;
+        context.cursor.skip(1);
+        continue;
+      }
+      context.cursor.skip(1);
+      context.errors.push({
+        type: "error",
+        description: `invalid escape sequence: \\${escape}`,
+        range: { start: escapeStart, end: context.cursor.location("end") }
+      });
+      value += `\\${escape}`;
+      continue;
+    }
+    value += ch;
     context.cursor.skip(1);
-  } else {
+  }
+  if (!closed) {
     const location = context.cursor.location("start");
     context.errors.push({
       type: "error",
       description: "string close quote is not found",
       range: { start: location, end: location }
     });
-    value = "";
   }
   return {
     kind: "string",
@@ -94,16 +302,8 @@ const tokenizeIdentity = (context) => {
     range: { start, end: context.cursor.location("end") }
   };
 };
-const tokenizeCodeBlock = (context) => {
-  const openStart = context.cursor.location("start");
-  context.cursor.skip(2);
-  const tokens = [
-    {
-      kind: "open",
-      symbol: "{{",
-      range: { start: openStart, end: context.cursor.location("end") }
-    }
-  ];
+const tokenizeCodeTokens = (context, stopOnClose, finalizeUnknownOnEot) => {
+  const tokens = [];
   let unknownStartLocation;
   const finalizeUnknown = () => {
     if (unknownStartLocation) {
@@ -119,20 +319,21 @@ const tokenizeCodeBlock = (context) => {
     }
   };
   while (!context.cursor.eot()) {
-    if (context.cursor.assert("}}")) {
+    if (stopOnClose && context.cursor.assert("}}")) {
       finalizeUnknown();
-      const location = context.cursor.location("start");
-      context.cursor.skip(2);
-      tokens.push({
-        kind: "close",
-        symbol: "}}",
-        range: { start: location, end: context.cursor.location("end") }
-      });
-      return tokens;
+      return { tokens, closed: true };
     }
     const ch = context.cursor.getChar();
     if (ch === "\\") {
       const next = context.cursor.getChar(1);
+      if (next === "\n") {
+        context.cursor.skip(2);
+        continue;
+      }
+      if (next === "\r" && context.cursor.getChar(2) === "\n") {
+        context.cursor.skip(3);
+        continue;
+      }
       if (next === "{" || next === "}") {
         context.cursor.skip(2);
         continue;
@@ -197,12 +398,41 @@ const tokenizeCodeBlock = (context) => {
     } else if (ch === " ") {
       finalizeUnknown();
       context.cursor.skip(1);
-    } else if (!unknownStartLocation) {
-      unknownStartLocation = context.cursor.location("start");
+    } else {
+      if (!unknownStartLocation) {
+        unknownStartLocation = context.cursor.location("start");
+      }
       context.cursor.skip(1);
     }
     context.cursor.skipChars(" ");
   }
+  if (finalizeUnknownOnEot) {
+    finalizeUnknown();
+  }
+  return { tokens, closed: false };
+};
+const tokenizeCodeBlock = (context) => {
+  const openStart = context.cursor.location("start");
+  context.cursor.skip(2);
+  const tokens = [
+    {
+      kind: "open",
+      symbol: "{{",
+      range: { start: openStart, end: context.cursor.location("end") }
+    }
+  ];
+  const result = tokenizeCodeTokens(context, true, false);
+  tokens.push(...result.tokens);
+  if (result.closed) {
+    const location = context.cursor.location("start");
+    context.cursor.skip(2);
+    tokens.push({
+      kind: "close",
+      symbol: "}}",
+      range: { start: location, end: context.cursor.location("end") }
+    });
+    return tokens;
+  }
   const causeLocation = context.cursor.location("start");
   context.errors.push({
     type: "error",
@@ -227,9 +457,12 @@ const createTokenizerCursor = (script) => {
       const ch = script[currentIndex];
       if (ch === "\r") {
         rawColumn = 0;
-      } else if (ch === "\n" && lastch !== "\r") {
-        rawColumn = 0;
         rawLine++;
+      } else if (ch === "\n") {
+        rawColumn = 0;
+        if (lastch !== "\r") {
+          rawLine++;
+        }
       } else {
         rawColumn++;
       }
@@ -306,6 +539,14 @@ const createTokenizerCursor = (script) => {
     location
   };
 };
+const runCodeTokenizer = (script, errors) => {
+  const context = {
+    cursor: createTokenizerCursor(script),
+    errors
+  };
+  const result = tokenizeCodeTokens(context, false, true);
+  return result.tokens;
+};
 const runTokenizer = (script, errors) => {
   const context = {
     cursor: createTokenizerCursor(script),
@@ -350,115 +591,6 @@ const runTokenizer = (script, errors) => {
   }
   return tokens;
 };
-const emptyLocation = {
-  line: 0,
-  column: 0
-};
-const emptyRange = {
-  start: emptyLocation,
-  end: emptyLocation
-};
-const specialFunctionMarker = /* @__PURE__ */ Symbol("$$special$$");
-const makeSpecialFunction = (f) => {
-  f[specialFunctionMarker] = true;
-  return f;
-};
-const isSpecialFunction = (f) => {
-  var _a;
-  return (_a = f[specialFunctionMarker]) != null ? _a : false;
-};
-const isConditionalTrue = (v) => {
-  if (v === void 0 || v === null) {
-    return false;
-  }
-  switch (typeof v) {
-    case "boolean":
-      return v;
-    case "number":
-    case "bigint":
-      return v !== 0;
-    default:
-      return true;
-  }
-};
-const asIterable = (v) => {
-  if (typeof v[Symbol.iterator] === "function") {
-    return v;
-  } else {
-    return void 0;
-  }
-};
-const combineVariables = (...variablesList) => {
-  const variables = /* @__PURE__ */ new Map();
-  const appendVariables = (vs) => vs.forEach((v, k) => variables.set(k, v));
-  const appendRecord = (vs) => Object.keys(vs).forEach((k) => variables.set(k, vs[k]));
-  variablesList.forEach((vs) => {
-    if (vs["forEach"] !== void 0) {
-      appendVariables(vs);
-    } else {
-      appendRecord(vs);
-    }
-  });
-  return variables;
-};
-const fromError = (error) => {
-  var _a;
-  if (error.message) {
-    return error.message;
-  } else if (typeof error.toString === "function") {
-    return (_a = error.toString()) != null ? _a : "unknown";
-  } else {
-    return "unknown";
-  }
-};
-const widerRange = (...ranges) => {
-  let start = emptyRange.start;
-  let end = emptyRange.end;
-  for (const range of ranges) {
-    if (range.start.line >= 1 && range.start.column >= 1) {
-      if (start.line === 0 || start.column === 0) {
-        start = range.start;
-      } else if (range.start.line < start.line) {
-        start = range.start;
-      } else if (range.start.line === start.line && range.start.column < start.column) {
-        start = range.start;
-      }
-      if (end.line === 0 || end.column === 0) {
-        end = range.end;
-      } else if (range.end.line > end.line) {
-        end = range.end;
-      } else if (range.end.line === end.line && range.end.column > end.column) {
-        end = range.end;
-      }
-    }
-  }
-  return { start, end };
-};
-const locationEquals = (lhs, rhs) => lhs.line === rhs.line && lhs.column === rhs.column;
-const getLocationString = (range) => locationEquals(range.start, range.end) ? `${range.start.line}:${range.start.column}` : `${range.start.line}:${range.start.column}:${range.end.line}:${range.end.column}`;
-const printErrorString = (path, error) => {
-  switch (error.type) {
-    case "warning":
-      console.warn(
-        `${path}:${getLocationString(error.range)}: warning: ${error.description}`
-      );
-      break;
-    case "error":
-      console.error(
-        `${path}:${getLocationString(error.range)}: error: ${error.description}`
-      );
-      return true;
-  }
-  return false;
-};
-const outputErrors = (path, errors) => {
-  let isError = false;
-  for (const error of errors) {
-    const result = printErrorString(path, error);
-    isError || (isError = result);
-  }
-  return isError;
-};
 const parseNumber = (cursor, _errors) => {
   const token = cursor.takeToken();
   return {
@@ -546,6 +678,9 @@ const parseLambdaExpression = (cursor, errors) => {
 };
 const parsePartialExpression = (cursor, errors) => {
   const token = cursor.peekToken();
+  if (!token) {
+    return void 0;
+  }
   switch (token.kind) {
     case "number": {
       const node = parseNumber(cursor);
@@ -930,14 +1065,15 @@ const extractParameterArguments = (namesNode, errors) => {
     }
   }
 };
-const parseBlock = (cursor, errors) => {
+const parseBlockCore = (cursor, errors, mode) => {
   const rootState = {
     kind: "root",
     startRange: emptyRange,
     branch: createBranchState()
   };
   const statementStates = [rootState];
-  let isInExpressionBlock = false;
+  const isCodeMode = mode === "code";
+  let isInExpressionBlock = isCodeMode;
   while (true) {
     const token = drainEndOfLineAndPeek(cursor);
     if (!token) {
@@ -964,14 +1100,16 @@ const parseBlock = (cursor, errors) => {
       case "open": {
         if (token.symbol === "{{") {
           cursor.skipToken();
-          if (isInExpressionBlock) {
-            errors.push({
-              type: "error",
-              description: `Already opened expression block`,
-              range: token.range
-            });
+          if (!isCodeMode) {
+            if (isInExpressionBlock) {
+              errors.push({
+                type: "error",
+                description: `Already opened expression block`,
+                range: token.range
+              });
+            }
+            isInExpressionBlock = true;
           }
-          isInExpressionBlock = true;
         } else {
           const node = parseExpression(cursor, errors);
           if (node) {
@@ -982,6 +1120,10 @@ const parseBlock = (cursor, errors) => {
       }
       case "close": {
         cursor.skipToken();
+        if (token.symbol === "}}" && isCodeMode) {
+          flushCurrentBranch(statementStates);
+          break;
+        }
         if (!isInExpressionBlock) {
           errors.push({
             type: "error",
@@ -990,6 +1132,14 @@ const parseBlock = (cursor, errors) => {
           });
           break;
         }
+        if (isCodeMode) {
+          errors.push({
+            type: "error",
+            description: `Mismatched close bracket`,
+            range: token.range
+          });
+          break;
+        }
         flushCurrentBranch(statementStates);
         isInExpressionBlock = false;
         break;
@@ -1199,38 +1349,6 @@ const parseBlock = (cursor, errors) => {
             }
             break;
           }
-          case "set": {
-            cursor.skipToken();
-            const args = parseStatementArguments(cursor, errors);
-            if (args.length !== 2) {
-              errors.push({
-                type: "error",
-                description: "Required `set` bind identity and expression",
-                range: widerRange(
-                  token.range,
-                  ...args.map((node) => node.range)
-                )
-              });
-              break;
-            }
-            const bindNode = args[0];
-            if (bindNode.kind !== "variable") {
-              errors.push({
-                type: "error",
-                description: "Required `set` bind identity",
-                range: bindNode.range
-              });
-              break;
-            }
-            const exprNode = args[1];
-            pushNode(statementStates, {
-              kind: "set",
-              name: bindNode,
-              expr: exprNode,
-              range: widerRange(token.range, bindNode.range, exprNode.range)
-            });
-            break;
-          }
           default: {
             const node = parseExpression(cursor, errors);
             if (node) {
@@ -1268,6 +1386,9 @@ const parseBlock = (cursor, errors) => {
   }
   return rootState.branch.blocks;
 };
+const parseBlock = (cursor, errors) => {
+  return parseBlockCore(cursor, errors, "script");
+};
 const createParserCursor = (tokens) => {
   let index = 0;
   const peekToken = () => {
@@ -1293,6 +1414,10 @@ const createParserCursor = (tokens) => {
     skipToken
   };
 };
+const parseExpressions = (tokens, errors) => {
+  const cursor = createParserCursor(tokens);
+  return parseBlockCore(cursor, errors, "code");
+};
 const runParser = (tokens, errors) => {
   const cursor = createParserCursor(tokens);
   const blockNodes = parseBlock(cursor, errors);
@@ -1373,6 +1498,7 @@ const fromLambda = (context, lambda) => {
   };
 };
 const reduceExpressionNode = async (context, node) => {
+  var _a;
   switch (node.kind) {
     case "number":
     case "string": {
@@ -1382,6 +1508,7 @@ const reduceExpressionNode = async (context, node) => {
       return traverseVariable(context, node);
     }
     case "apply": {
+      (_a = context.abortSignal) == null ? void 0 : _a.throwIfAborted();
       const func = await reduceExpressionNode(context, node.func);
       if (typeof func !== "function") {
         context.appendError({
@@ -1391,28 +1518,26 @@ const reduceExpressionNode = async (context, node) => {
         });
         return void 0;
       }
+      const args = isFunCityFunction(func) ? node.args : await Promise.all(
+        node.args.map(async (argNode) => {
+          const arg = await reduceExpressionNode(context, argNode);
+          return arg;
+        })
+      );
       const thisProxy = context.createFunctionContext(node);
-      if (isSpecialFunction(func)) {
-        const value = await func.call(thisProxy, ...node.args);
-        return value;
-      } else {
-        const args = await Promise.all(
-          node.args.map(async (argNode) => {
-            try {
-              const arg = await reduceExpressionNode(context, argNode);
-              return arg;
-            } catch (e) {
-              context.appendError({
-                type: "error",
-                description: fromError(e),
-                range: argNode.range
-              });
-              return void 0;
-            }
-          })
-        );
+      try {
         const value = await func.call(thisProxy, ...args);
         return value;
+      } catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
+          throw e;
+        }
+        context.appendError({
+          type: "error",
+          description: fromError(e),
+          range: node.range
+        });
+        return void 0;
       }
     }
     case "lambda": {
@@ -1424,11 +1549,6 @@ const reduceExpressionNode = async (context, node) => {
       );
       return results;
     }
-    case "set": {
-      const expr = await reduceExpressionNode(context, node.expr);
-      context.setValue(node.name.name, expr);
-      return void 0;
-    }
     case "scope": {
       if (node.nodes.length === 0) {
         return [];
@@ -1510,32 +1630,76 @@ const reduceNode = async (context, node) => {
     }
   }
 };
-const createReducerContext = (variables, errors) => {
-  let vs = variables;
-  let mvs;
-  let variablesProxy;
+const createScopedReducerContext = (parent) => {
+  let thisVars;
+  let thisContext;
+  const getValue = (name) => {
+    var _a;
+    (_a = parent.abortSignal) == null ? void 0 : _a.throwIfAborted();
+    if (thisVars == null ? void 0 : thisVars.has(name)) {
+      return { value: thisVars.get(name), isFound: true };
+    } else {
+      return parent.getValue(name);
+    }
+  };
+  const setValue = (name, value) => {
+    var _a;
+    (_a = parent.abortSignal) == null ? void 0 : _a.throwIfAborted();
+    if (!thisVars) {
+      thisVars = /* @__PURE__ */ new Map();
+    }
+    thisVars.set(name, value);
+  };
+  const createFunctionContext = (thisNode) => {
+    const newContext = {
+      thisNode,
+      abortSignal: parent.abortSignal,
+      getValue,
+      setValue,
+      isFailed: parent.isFailed,
+      appendError: parent.appendError,
+      reduce: (node) => {
+        var _a;
+        (_a = parent.abortSignal) == null ? void 0 : _a.throwIfAborted();
+        return reduceExpressionNode(thisContext, node);
+      }
+    };
+    return newContext;
+  };
+  thisContext = {
+    abortSignal: parent.abortSignal,
+    getValue,
+    setValue,
+    isFailed: parent.isFailed,
+    appendError: parent.appendError,
+    newScope: () => {
+      var _a;
+      (_a = parent.abortSignal) == null ? void 0 : _a.throwIfAborted();
+      return createScopedReducerContext(thisContext);
+    },
+    createFunctionContext
+  };
+  return thisContext;
+};
+const createReducerContext = (variables, errors, signal) => {
+  let thisVars;
+  let thisContext;
   const getValue = (name) => {
-    if (vs.has(name)) {
-      return { value: vs.get(name), isFound: true };
+    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)) {
+      return { value: variables.get(name), isFound: true };
     } else {
       return { value: void 0, isFound: false };
     }
   };
   const setValue = (name, value) => {
-    if (!mvs) {
-      mvs = new Map(vs);
-      vs = mvs;
-    }
-    mvs.set(name, value);
-    if (variablesProxy !== void 0) {
-      Object.defineProperty(variablesProxy, name, {
-        get() {
-          return vs.get(name);
-        },
-        configurable: true,
-        enumerable: true
-      });
+    signal == null ? void 0 : signal.throwIfAborted();
+    if (!thisVars) {
+      thisVars = /* @__PURE__ */ new Map();
     }
+    thisVars.set(name, value);
   };
   const appendError = (error) => {
     errors.push(error);
@@ -1543,47 +1707,37 @@ const createReducerContext = (variables, errors) => {
   const isFailed = () => {
     return errors.some((error) => error.type === "error");
   };
-  const newScope = () => {
-    const newContext = createReducerContext(vs, errors);
-    return newContext;
-  };
-  let context;
-  const reduceByProxy = (node) => reduceExpressionNode(context, node);
-  const getVariablesFromProxy = () => {
-    if (variablesProxy === void 0) {
-      variablesProxy = {};
-      for (const key of vs.keys()) {
-        Object.defineProperty(variablesProxy, key, {
-          get: () => vs.get(key),
-          configurable: true,
-          enumerable: true
-        });
-      }
-    }
-    return variablesProxy;
-  };
   const createFunctionContext = (thisNode) => {
-    return {
-      get variables() {
-        return getVariablesFromProxy();
-      },
+    const newContext = {
       thisNode,
+      abortSignal: signal,
+      getValue,
+      setValue,
+      isFailed,
       appendError,
-      reduce: reduceByProxy
+      reduce: (node) => {
+        signal == null ? void 0 : signal.throwIfAborted();
+        return reduceExpressionNode(thisContext, node);
+      }
     };
+    return newContext;
   };
-  context = {
+  thisContext = {
+    abortSignal: signal,
     getValue,
     setValue,
     appendError,
     isFailed,
-    newScope,
+    newScope: () => {
+      signal == null ? void 0 : signal.throwIfAborted();
+      return createScopedReducerContext(thisContext);
+    },
     createFunctionContext
   };
-  return context;
+  return thisContext;
 };
-async function runReducer(nodes, variables, errors) {
-  const context = createReducerContext(variables, errors);
+async function runReducer(nodes, variables, errors, signal) {
+  const context = createReducerContext(variables, errors, signal);
   const resultList = [];
   for (const node of nodes) {
     const results = await reduceNode(context, node);
@@ -1595,7 +1749,15 @@ async function runReducer(nodes, variables, errors) {
   }
   return resultList;
 }
-const _cond = makeSpecialFunction(async function(arg0, arg1, arg2) {
+const _cond = makeFunCityFunction(async function(arg0, arg1, arg2) {
+  if (!arg0 || !arg1 || !arg2) {
+    this.appendError({
+      type: "error",
+      description: "Required `cond` condition, true and false expressions",
+      range: this.thisNode.range
+    });
+    return void 0;
+  }
   const cond = await this.reduce(arg0);
   if (isConditionalTrue(cond)) {
     return await this.reduce(arg1);
@@ -1603,6 +1765,27 @@ const _cond = makeSpecialFunction(async function(arg0, arg1, arg2) {
     return await this.reduce(arg2);
   }
 });
+const _set = makeFunCityFunction(async function(arg0, arg1, ...rest) {
+  if (!arg0 || !arg1 || rest.length !== 0) {
+    this.appendError({
+      type: "error",
+      description: "Required `set` bind identity and expression",
+      range: this.thisNode.range
+    });
+    return void 0;
+  }
+  if (arg0.kind !== "variable") {
+    this.appendError({
+      type: "error",
+      description: "Required `set` bind identity",
+      range: arg0.range
+    });
+    return void 0;
+  }
+  const value = await this.reduce(arg1);
+  this.setValue(arg0.name, value);
+  return void 0;
+});
 const _typeof = async (arg0) => {
   if (arg0 === null) {
     return "null";
@@ -1616,54 +1799,33 @@ const _typeof = async (arg0) => {
     return typeof arg0;
   }
 };
-const funcIds = /* @__PURE__ */ new WeakMap();
-let nextId = 1;
-const getFuncId = (fn) => {
-  const cached = funcIds.get(fn);
-  if (cached) return cached;
-  const id = nextId++;
-  funcIds.set(fn, id);
-  return id;
-};
 const _toString = async (...args) => {
-  const results = args.map((arg0) => {
-    switch (arg0) {
-      case void 0:
-        return "(undefined)";
-      case null:
-        return "(null)";
-      default:
-        switch (typeof arg0) {
-          case "string":
-            return arg0;
-          case "boolean":
-            return arg0 ? "true" : "false";
-          case "number":
-          case "bigint":
-          case "symbol":
-            return arg0.toString();
-          case "function":
-            if (arg0.name) {
-              return `fun<${arg0.name}:#${getFuncId(arg0)}>`;
-            } else {
-              return `fun<#${getFuncId(arg0)}>`;
-            }
-          default:
-            if (Array.isArray(arg0)) {
-              return JSON.stringify(arg0);
-            }
-            const iterable = asIterable(arg0);
-            if (iterable) {
-              const arr = Array.from(iterable);
-              return JSON.stringify(arr);
-            } else {
-              return JSON.stringify(arg0);
-            }
-        }
-    }
-  });
+  const results = args.map((arg0) => convertToString(arg0));
   return results.join(",");
 };
+const _toBoolean = async (arg0) => {
+  const r = isConditionalTrue(arg0);
+  return r;
+};
+const _toNumber = async (arg0) => {
+  const r = Number(arg0);
+  return r;
+};
+const _toBigInt = async (arg0) => {
+  switch (typeof arg0) {
+    case "number":
+    case "bigint":
+    case "string":
+    case "boolean": {
+      const r = BigInt(arg0);
+      return r;
+    }
+    default: {
+      const r = BigInt(await _toString(arg0));
+      return r;
+    }
+  }
+};
 const _add = async (arg0, ...args) => {
   const r = args.reduce((v0, v) => v0 + Number(v), Number(arg0));
   return r;
@@ -1761,20 +1923,40 @@ const _length = async (arg0) => {
   }
   return 0;
 };
-const _and = async (...args) => {
+const _and = makeFunCityFunction(async function(...args) {
   if (args.length === 0) {
-    throw new Error("empty arguments");
+    this.appendError({
+      type: "error",
+      description: "empty arguments",
+      range: this.thisNode.range
+    });
+    return void 0;
   }
-  const r = args.reduce((v0, v) => v0 && isConditionalTrue(v), true);
-  return r;
-};
-const _or = async (...args) => {
+  for (const arg of args) {
+    const value = await this.reduce(arg);
+    if (!isConditionalTrue(value)) {
+      return false;
+    }
+  }
+  return true;
+});
+const _or = makeFunCityFunction(async function(...args) {
   if (args.length === 0) {
-    throw new Error("empty arguments");
+    this.appendError({
+      type: "error",
+      description: "empty arguments",
+      range: this.thisNode.range
+    });
+    return void 0;
   }
-  const r = args.reduce((v0, v) => v0 || isConditionalTrue(v), false);
-  return r;
-};
+  for (const arg of args) {
+    const value = await this.reduce(arg);
+    if (isConditionalTrue(value)) {
+      return true;
+    }
+  }
+  return false;
+});
 const _not = async (arg0) => {
   return !isConditionalTrue(arg0);
 };
@@ -1936,13 +2118,24 @@ const _bind = async (arg0, ...args) => {
   const predicate = arg0;
   return predicate.bind(void 0, ...args);
 };
+const _url = async (arg0, arg1) => {
+  const url = new URL(
+    convertToString(arg0),
+    arg1 !== void 0 ? convertToString(arg1) : void 0
+  );
+  return url;
+};
 const standardVariables = Object.freeze({
   undefined: void 0,
   null: null,
   true: true,
   false: false,
   cond: _cond,
+  set: _set,
   toString: _toString,
+  toBoolean: _toBoolean,
+  toNumber: _toNumber,
+  toBigInt: _toBigInt,
   typeof: _typeof,
   add: _add,
   sub: _sub,
@@ -1974,34 +2167,38 @@ const standardVariables = Object.freeze({
   match: _match,
   replace: _replace,
   regex: _regex,
-  bind: _bind
+  bind: _bind,
+  url: _url
 });
 const buildCandidateVariables = (...variablesList) => {
   return combineVariables(standardVariables, ...variablesList);
 };
-const runScriptOnce = async (script, variables, errors = []) => {
+const runScriptOnce = async (script, variables, errors = [], signal) => {
   const blocks = runTokenizer(script, errors);
   const nodes = runParser(blocks, errors);
-  const results = await runReducer(nodes, variables, errors);
-  const text = results.join("");
+  const results = await runReducer(nodes, variables, errors, signal);
+  const text = results.map((result) => convertToString(result)).join("");
   return text;
 };
 exports.asIterable = asIterable;
 exports.buildCandidateVariables = buildCandidateVariables;
 exports.combineVariables = combineVariables;
+exports.convertToString = convertToString;
 exports.createParserCursor = createParserCursor;
 exports.createReducerContext = createReducerContext;
 exports.emptyLocation = emptyLocation;
 exports.emptyRange = emptyRange;
 exports.fromError = fromError;
 exports.isConditionalTrue = isConditionalTrue;
-exports.isSpecialFunction = isSpecialFunction;
-exports.makeSpecialFunction = makeSpecialFunction;
+exports.isFunCityFunction = isFunCityFunction;
+exports.makeFunCityFunction = makeFunCityFunction;
 exports.outputErrors = outputErrors;
 exports.parseBlock = parseBlock;
 exports.parseExpression = parseExpression;
+exports.parseExpressions = parseExpressions;
 exports.reduceExpressionNode = reduceExpressionNode;
 exports.reduceNode = reduceNode;
+exports.runCodeTokenizer = runCodeTokenizer;
 exports.runParser = runParser;
 exports.runReducer = runReducer;
 exports.runScriptOnce = runScriptOnce;