funcity 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2005 @@
+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 tokenizeString = (context) => {
+  const start = context.cursor.location("start");
+  context.cursor.skip(1);
+  let value = context.cursor.getUntil("'");
+  if (value !== void 0) {
+    context.cursor.skip(1);
+  } else {
+    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",
+    value,
+    range: { start, end: context.cursor.location("end") }
+  };
+};
+const firstNumericChars = "0123456789-+";
+const numericCharsWithDot = "0123456789.";
+const numericChars = "0123456789";
+const tokenizeNumber = (context) => {
+  const start = context.cursor.location("start");
+  let index = 1;
+  while (true) {
+    if (context.cursor.eot()) {
+      return {
+        kind: "number",
+        value: Number(context.cursor.getRangeAndSkip(index)),
+        range: { start, end: context.cursor.location("end") }
+      };
+    }
+    const ch = context.cursor.getChar(index);
+    if (numericCharsWithDot.indexOf(ch) < 0) {
+      if (ch === ".") {
+        break;
+      }
+      return {
+        kind: "number",
+        value: Number(context.cursor.getRangeAndSkip(index)),
+        range: { start, end: context.cursor.location("end") }
+      };
+    }
+    index++;
+  }
+  while (true) {
+    if (context.cursor.eot()) {
+      return {
+        kind: "number",
+        value: Number(context.cursor.getRangeAndSkip(index)),
+        range: { start, end: context.cursor.location("end") }
+      };
+    }
+    const ch = context.cursor.getChar(index);
+    if (numericChars.indexOf(ch) < 0) {
+      return {
+        kind: "number",
+        value: Number(context.cursor.getRangeAndSkip(index)),
+        range: { start, end: context.cursor.location("end") }
+      };
+    }
+    index++;
+  }
+};
+const firstVariableChars = "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const variableChars = "_-.?0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const tokenizeIdentity = (context) => {
+  const start = context.cursor.location("start");
+  let index = 1;
+  let lastCh = "";
+  while (true) {
+    if (context.cursor.eot()) {
+      break;
+    }
+    const ch = context.cursor.getChar(index);
+    if (variableChars.indexOf(ch) < 0) {
+      break;
+    }
+    if (lastCh === "?") {
+      index--;
+      break;
+    }
+    lastCh = ch;
+    index++;
+  }
+  return {
+    kind: "identity",
+    name: context.cursor.getRangeAndSkip(index),
+    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") }
+    }
+  ];
+  let unknownStartLocation;
+  const finalizeUnknown = () => {
+    if (unknownStartLocation) {
+      context.errors.push({
+        type: "warning",
+        description: "unknown words",
+        range: {
+          start: unknownStartLocation,
+          end: context.cursor.location("end")
+        }
+      });
+      unknownStartLocation = void 0;
+    }
+  };
+  while (!context.cursor.eot()) {
+    if (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;
+    }
+    const ch = context.cursor.getChar();
+    if (ch === "\\") {
+      const next = context.cursor.getChar(1);
+      if (next === "{" || next === "}") {
+        context.cursor.skip(2);
+        continue;
+      }
+    }
+    if (ch === "'") {
+      finalizeUnknown();
+      tokens.push(tokenizeString(context));
+    } else if (firstNumericChars.indexOf(ch) >= 0) {
+      finalizeUnknown();
+      tokens.push(tokenizeNumber(context));
+    } else if (ch === "(") {
+      finalizeUnknown();
+      const location = context.cursor.location("start");
+      tokens.push({
+        kind: "open",
+        symbol: "(",
+        range: { start: location, end: location }
+      });
+      context.cursor.skip(1);
+    } else if (ch === ")") {
+      finalizeUnknown();
+      const location = context.cursor.location("start");
+      tokens.push({
+        kind: "close",
+        symbol: ")",
+        range: { start: location, end: location }
+      });
+      context.cursor.skip(1);
+    } else if (ch === "[") {
+      finalizeUnknown();
+      const location = context.cursor.location("start");
+      tokens.push({
+        kind: "open",
+        symbol: "[",
+        range: { start: location, end: location }
+      });
+      context.cursor.skip(1);
+    } else if (ch === "]") {
+      finalizeUnknown();
+      const location = context.cursor.location("start");
+      tokens.push({
+        kind: "close",
+        symbol: "]",
+        range: { start: location, end: location }
+      });
+      context.cursor.skip(1);
+    } else if (firstVariableChars.indexOf(ch) >= 0) {
+      finalizeUnknown();
+      tokens.push(tokenizeIdentity(context));
+    } else if (ch === "\n") {
+      finalizeUnknown();
+      const location = context.cursor.location("start");
+      tokens.push({
+        kind: "eol",
+        range: { start: location, end: location }
+      });
+      context.cursor.skip(1);
+    } else if (ch === "\r") {
+      finalizeUnknown();
+      context.cursor.skip(1);
+    } else if (ch === " ") {
+      finalizeUnknown();
+      context.cursor.skip(1);
+    } else if (!unknownStartLocation) {
+      unknownStartLocation = context.cursor.location("start");
+      context.cursor.skip(1);
+    }
+    context.cursor.skipChars(" ");
+  }
+  const causeLocation = context.cursor.location("start");
+  context.errors.push({
+    type: "error",
+    description: "required code block closer: `}}`",
+    range: { start: causeLocation, end: causeLocation }
+  });
+  return tokens;
+};
+const createTokenizerCursor = (text) => {
+  let currentIndex = 0;
+  let rawLine = 0;
+  let rawColumn = 0;
+  let lastLine = 0;
+  let lastColumn = 0;
+  const eot = () => currentIndex >= text.length;
+  const getChar = (index) => text[(index != null ? index : 0) + currentIndex];
+  const skip = (length) => {
+    let lastch = "\0";
+    while (length > 0) {
+      lastColumn = rawColumn;
+      lastLine = rawLine;
+      const ch = text[currentIndex];
+      if (ch === "\r") {
+        rawColumn = 0;
+      } else if (ch === "\n" && lastch !== "\r") {
+        rawColumn = 0;
+        rawLine++;
+      } else {
+        rawColumn++;
+      }
+      currentIndex++;
+      length--;
+      lastch = ch;
+    }
+  };
+  const skipChars = (ch) => {
+    while (!eot()) {
+      if (getChar() !== ch) {
+        return true;
+      }
+      skip(1);
+    }
+    return false;
+  };
+  const skipUntil = (word) => {
+    while (!eot()) {
+      const index = text.indexOf(word, currentIndex);
+      if (index === currentIndex) {
+        skip(word.length);
+        return true;
+      }
+      skip(1);
+    }
+    return false;
+  };
+  const assert = (word) => {
+    if (text.length - currentIndex < word.length) {
+      return false;
+    }
+    if (text.substring(currentIndex, currentIndex + word.length) === word) {
+      return true;
+    }
+    return false;
+  };
+  const getRangeAndSkip = (length) => {
+    const result = text.substring(currentIndex, currentIndex + length);
+    skip(result.length);
+    return result;
+  };
+  const getUntil = (word) => {
+    if (currentIndex >= text.length) {
+      return void 0;
+    }
+    const index = text.indexOf(word, currentIndex);
+    if (index >= 0) {
+      const result = text.substring(currentIndex, index);
+      skip(index - currentIndex);
+      return result;
+    } else {
+      const result = text.substring(currentIndex, text.length);
+      skip(text.length - currentIndex);
+      return result;
+    }
+  };
+  const location = (type) => type === "end" ? {
+    line: lastLine + 1,
+    column: lastColumn + 1
+  } : {
+    line: rawLine + 1,
+    column: rawColumn + 1
+  };
+  return {
+    eot,
+    getChar,
+    skip,
+    skipChars,
+    skipUntil,
+    assert,
+    getRangeAndSkip,
+    getUntil,
+    location
+  };
+};
+const runTokenizer = (script, errors) => {
+  const context = {
+    cursor: createTokenizerCursor(script),
+    errors
+  };
+  const tokens = [];
+  const readTextBlock = () => {
+    if (context.cursor.eot()) {
+      return void 0;
+    }
+    let text = "";
+    while (!context.cursor.eot()) {
+      if (context.cursor.assert("{{")) {
+        return text;
+      }
+      const ch = context.cursor.getChar();
+      if (ch === "\\") {
+        const next = context.cursor.getChar(1);
+        if (next === "{" || next === "}") {
+          text += next;
+          context.cursor.skip(2);
+          continue;
+        }
+      }
+      text += ch;
+      context.cursor.skip(1);
+    }
+    return text;
+  };
+  while (!context.cursor.eot()) {
+    const start = context.cursor.location("start");
+    const text = readTextBlock();
+    if (text) {
+      tokens.push({
+        kind: "text",
+        text,
+        range: { start, end: context.cursor.location("end") }
+      });
+    } else {
+      tokens.push(...tokenizeCodeBlock(context));
+    }
+  }
+  return tokens;
+};
+const parseNumber = (cursor, _errors) => {
+  const token = cursor.takeToken();
+  return {
+    kind: "number",
+    value: token.value,
+    range: token.range
+  };
+};
+const parseString = (cursor, _errors) => {
+  const token = cursor.takeToken();
+  return {
+    kind: "string",
+    value: token.value,
+    range: token.range
+  };
+};
+const parseIdentity = (cursor, _errors) => {
+  const token = cursor.takeToken();
+  return {
+    kind: "variable",
+    name: token.name,
+    range: token.range
+  };
+};
+const unitKind = "'()'";
+const combineIntoScopeMultipleExpressions = (expressionList, ...outerRanges) => {
+  switch (expressionList.length) {
+    case 0: {
+      return void 0;
+    }
+    case 1: {
+      return expressionList[0];
+    }
+    default: {
+      return {
+        kind: "scope",
+        nodes: expressionList,
+        range: widerRange(
+          ...expressionList.map((node) => node.range),
+          ...outerRanges
+        )
+      };
+    }
+  }
+};
+const parseLambdaExpression = (cursor, errors) => {
+  const funToken = cursor.takeToken();
+  const namesPartial = parsePartialExpression(cursor, errors);
+  const bodyPartial = namesPartial ? parsePartialExpression(cursor, errors) : void 0;
+  if (!namesPartial || !bodyPartial) {
+    const ranges = [funToken.range];
+    if (namesPartial) {
+      ranges.push(namesPartial.range);
+    }
+    if (bodyPartial) {
+      ranges.push(bodyPartial.range);
+    }
+    errors.push({
+      type: "error",
+      description: "Required `fun` parameter identity and expression",
+      range: widerRange(...ranges)
+    });
+    return void 0;
+  }
+  const namesNode = normalizePartialUnitNode(namesPartial, errors);
+  if (namesNode.kind !== "variable" && namesNode.kind !== "list") {
+    errors.push({
+      type: "error",
+      description: "Required `fun` parameter identity",
+      range: namesNode.range
+    });
+    return void 0;
+  }
+  const nameNodes = extractParameterArguments(namesNode, errors);
+  if (!nameNodes) {
+    return void 0;
+  }
+  const bodyNode = normalizePartialUnitNode(bodyPartial, errors);
+  return {
+    kind: "lambda",
+    names: nameNodes,
+    body: bodyNode,
+    range: widerRange(funToken.range, namesNode.range, bodyNode.range)
+  };
+};
+const parsePartialExpression = (cursor, errors) => {
+  const token = cursor.peekToken();
+  switch (token.kind) {
+    case "number": {
+      const node = parseNumber(cursor);
+      return node;
+    }
+    case "string": {
+      const node = parseString(cursor);
+      return node;
+    }
+    case "identity": {
+      if (token.name === "fun") {
+        const node2 = parseLambdaExpression(cursor, errors);
+        return node2;
+      }
+      const node = parseIdentity(cursor);
+      return node;
+    }
+    case "open": {
+      cursor.takeToken();
+      switch (token.symbol) {
+        // Parenthesis surrounding expression list `( ... )` (Scope)
+        case "(": {
+          const innerNodes = parseMultipleApplicationExpressions(
+            cursor,
+            errors
+          );
+          const closeToken = cursor.peekToken();
+          let range;
+          if (!closeToken) {
+            range = widerRange(
+              token.range,
+              ...innerNodes.map((node) => node.range)
+            );
+            errors.push({
+              type: "error",
+              description: "Could not find close parenthesis",
+              range: widerRange(
+                token.range,
+                ...innerNodes.map((node) => node.range)
+              )
+            });
+          } else {
+            cursor.takeToken();
+            range = widerRange(
+              token.range,
+              ...innerNodes.map((node) => node.range),
+              closeToken.range
+            );
+            if (closeToken.kind !== "close" || closeToken.symbol !== ")") {
+              errors.push({
+                type: "error",
+                description: `Mismatched close parenthesis`,
+                range
+              });
+            }
+          }
+          if (innerNodes.length === 0) {
+            return {
+              kind: unitKind,
+              range
+            };
+          } else {
+            const node = combineIntoScopeMultipleExpressions(innerNodes, range);
+            return node;
+          }
+        }
+        // Bracket surrounding expression list `[ ... ]` (Iterable list)
+        case "[": {
+          const itemNodes = parseListExpression(cursor, errors);
+          const closeToken = cursor.peekToken();
+          let range;
+          if (!closeToken) {
+            range = widerRange(
+              token.range,
+              ...itemNodes.map((node) => node.range)
+            );
+            errors.push({
+              type: "error",
+              description: "Could not find close bracket",
+              range
+            });
+          } else {
+            cursor.takeToken();
+            range = widerRange(
+              token.range,
+              ...itemNodes.map((node) => node.range),
+              closeToken.range
+            );
+            if (closeToken.kind !== "close" || closeToken.symbol !== "]") {
+              errors.push({
+                type: "error",
+                description: `Mismatched close bracket`,
+                range
+              });
+            }
+          }
+          return {
+            kind: "list",
+            items: itemNodes,
+            range
+          };
+        }
+        default: {
+          errors.push({
+            type: "error",
+            description: `Invalid open parenthesis/bracket`,
+            range: token.range
+          });
+          return void 0;
+        }
+      }
+    }
+  }
+  return void 0;
+};
+const normalizePartialUnitNode = (node, errors) => {
+  if (node.kind === unitKind) {
+    errors.push({
+      type: "error",
+      description: `Invalid ${unitKind} at this location`,
+      range: node.range
+    });
+    return {
+      kind: "variable",
+      name: "undefined",
+      range: node.range
+    };
+  } else {
+    return node;
+  }
+};
+const finalizeApplicationException = (partialNodes, errors) => {
+  if (partialNodes.length === 0) {
+    return;
+  }
+  if (partialNodes.length === 1) {
+    return normalizePartialUnitNode(partialNodes[0], errors);
+  }
+  const func = partialNodes[0];
+  if (func.kind !== "variable" && func.kind !== "lambda") {
+    errors.push({
+      type: "error",
+      description: `Invalid ${func.kind} at this location`,
+      range: func.range
+    });
+    return void 0;
+  }
+  const arg0 = partialNodes[1];
+  if (arg0.kind === unitKind) {
+    return {
+      kind: "apply",
+      func,
+      args: [],
+      // Unit application: `foobar ()`
+      range: widerRange(func.range, arg0.range)
+    };
+  }
+  const args = partialNodes.slice(1).map((node) => normalizePartialUnitNode(node, errors));
+  return {
+    kind: "apply",
+    func,
+    args,
+    range: widerRange(func.range, ...args.map((node) => node.range))
+  };
+};
+const parseMultipleApplicationExpressions = (cursor, errors) => {
+  const expressionList = [];
+  const partialNodes = [];
+  while (true) {
+    const token = cursor.peekToken();
+    if (!token) {
+      break;
+    }
+    switch (token.kind) {
+      case "eol": {
+        cursor.takeToken();
+        const expr2 = finalizeApplicationException(partialNodes, errors);
+        if (expr2) {
+          expressionList.push(expr2);
+        }
+        partialNodes.length = 0;
+        continue;
+      }
+    }
+    const partialNode = parsePartialExpression(cursor, errors);
+    if (!partialNode) {
+      break;
+    }
+    partialNodes.push(partialNode);
+  }
+  const expr = finalizeApplicationException(partialNodes, errors);
+  if (expr) {
+    expressionList.push(expr);
+  }
+  return expressionList;
+};
+const parseListExpression = (cursor, errors) => {
+  const itemNodes = [];
+  while (true) {
+    const token = cursor.peekToken();
+    if (!token) {
+      break;
+    }
+    switch (token.kind) {
+      case "eol": {
+        continue;
+      }
+    }
+    const partialNode = parsePartialExpression(cursor, errors);
+    if (!partialNode) {
+      break;
+    }
+    itemNodes.push(normalizePartialUnitNode(partialNode, errors));
+  }
+  return itemNodes;
+};
+const drainEndOfLineAndPeek = (cursor) => {
+  let token = cursor.peekToken();
+  while (token) {
+    if (token.kind === "eol") {
+      cursor.takeToken();
+    } else {
+      break;
+    }
+    token = cursor.peekToken();
+  }
+  return token;
+};
+const parseExpression = (cursor, errors) => {
+  let token = drainEndOfLineAndPeek(cursor);
+  if (!token) {
+    return void 0;
+  }
+  const partialNodes = [];
+  while (true) {
+    const partialNode = parsePartialExpression(cursor, errors);
+    if (!partialNode) {
+      break;
+    }
+    partialNodes.push(partialNode);
+    token = cursor.peekToken();
+    if (!token) {
+      break;
+    }
+    if (token.kind === "eol") {
+      cursor.takeToken();
+      token = cursor.peekToken();
+      break;
+    }
+  }
+  drainEndOfLineAndPeek(cursor);
+  const expr = finalizeApplicationException(partialNodes, errors);
+  return expr;
+};
+const createBranchState = () => ({
+  blocks: [],
+  exprBuffer: []
+});
+const getBranchState = (statementState) => {
+  switch (statementState.kind) {
+    case "root": {
+      return statementState.branch;
+    }
+    case "if": {
+      return statementState.currentBlock === "then" ? statementState.then : statementState.else;
+    }
+    case "while":
+    case "for": {
+      return statementState.repeat;
+    }
+  }
+};
+const flushExpressions = (branch) => {
+  if (branch.exprBuffer.length === 0) {
+    return;
+  }
+  if (branch.exprBuffer.length === 1) {
+    branch.blocks.push(branch.exprBuffer[0]);
+  } else {
+    branch.blocks.push({
+      kind: "scope",
+      nodes: branch.exprBuffer,
+      range: widerRange(...branch.exprBuffer.map((node) => node.range))
+    });
+  }
+  branch.exprBuffer = [];
+};
+const flushCurrentBranch = (statementStates) => {
+  const statementState = statementStates[statementStates.length - 1];
+  flushExpressions(getBranchState(statementState));
+};
+const flushStatementState = (statementState) => {
+  switch (statementState.kind) {
+    case "root": {
+      flushExpressions(statementState.branch);
+      break;
+    }
+    case "if": {
+      flushExpressions(statementState.then);
+      flushExpressions(statementState.else);
+      break;
+    }
+    case "while":
+    case "for": {
+      flushExpressions(statementState.repeat);
+      break;
+    }
+  }
+};
+const pushExpressionNode = (statementStates, node) => {
+  const statementState = statementStates[statementStates.length - 1];
+  const branch = getBranchState(statementState);
+  branch.exprBuffer.push(node);
+};
+const pushBlockNode = (statementStates, node) => {
+  const statementState = statementStates[statementStates.length - 1];
+  const branch = getBranchState(statementState);
+  flushExpressions(branch);
+  branch.blocks.push(node);
+};
+const pushNode = (statementStates, node) => {
+  switch (node.kind) {
+    case "text":
+    case "if":
+    case "while":
+    case "for": {
+      pushBlockNode(statementStates, node);
+      break;
+    }
+    default: {
+      pushExpressionNode(statementStates, node);
+      break;
+    }
+  }
+};
+const parseStatementArguments = (cursor, errors) => {
+  const args = [];
+  while (true) {
+    const token = cursor.peekToken();
+    if (!token) {
+      break;
+    }
+    if (token.kind === "eol") {
+      cursor.takeToken();
+      break;
+    }
+    const partialNode = parsePartialExpression(cursor, errors);
+    if (!partialNode) {
+      break;
+    }
+    args.push(normalizePartialUnitNode(partialNode, errors));
+  }
+  return args;
+};
+const extractParameterArguments = (namesNode, errors) => {
+  switch (namesNode.kind) {
+    case "variable": {
+      return [namesNode];
+    }
+    case "list": {
+      const nameNodes = [];
+      for (const nameNode of namesNode.items) {
+        if (nameNode.kind !== "variable") {
+          errors.push({
+            type: "error",
+            description: "Required lambda parameter identity",
+            range: nameNode.range
+          });
+        } else {
+          nameNodes.push(nameNode);
+        }
+      }
+      return nameNodes;
+    }
+    default: {
+      errors.push({
+        type: "error",
+        description: "Required lambda parameter identity",
+        range: namesNode.range
+      });
+      return void 0;
+    }
+  }
+};
+const parseBlock = (cursor, errors) => {
+  const rootState = {
+    kind: "root",
+    startRange: emptyRange,
+    branch: createBranchState()
+  };
+  const statementStates = [rootState];
+  let isInExpressionBlock = false;
+  while (true) {
+    const token = drainEndOfLineAndPeek(cursor);
+    if (!token) {
+      break;
+    }
+    switch (token.kind) {
+      case "text": {
+        cursor.takeToken();
+        if (isInExpressionBlock) {
+          errors.push({
+            type: "error",
+            description: `Already opened expression block (tokenizer bug?)`,
+            range: token.range
+          });
+          break;
+        }
+        pushNode(statementStates, {
+          kind: "text",
+          text: token.text,
+          range: token.range
+        });
+        break;
+      }
+      case "open": {
+        if (token.symbol === "{{") {
+          cursor.takeToken();
+          if (isInExpressionBlock) {
+            errors.push({
+              type: "error",
+              description: `Already opened expression block`,
+              range: token.range
+            });
+          }
+          isInExpressionBlock = true;
+        } else {
+          const node = parseExpression(cursor, errors);
+          if (node) {
+            pushNode(statementStates, node);
+          }
+        }
+        break;
+      }
+      case "close": {
+        cursor.takeToken();
+        if (!isInExpressionBlock) {
+          errors.push({
+            type: "error",
+            description: `Mismatched close bracket`,
+            range: token.range
+          });
+          break;
+        }
+        flushCurrentBranch(statementStates);
+        isInExpressionBlock = false;
+        break;
+      }
+      case "identity": {
+        if (!isInExpressionBlock) {
+          errors.push({
+            type: "error",
+            description: `Invalid identity (tokenizer bug?)`,
+            range: token.range
+          });
+          break;
+        }
+        switch (token.name) {
+          case "if": {
+            cursor.takeToken();
+            const args = parseStatementArguments(cursor, errors);
+            if (args.length !== 1) {
+              errors.push({
+                type: "error",
+                description: "Required `if` condition",
+                range: widerRange(
+                  token.range,
+                  ...args.map((node) => node.range)
+                )
+              });
+              break;
+            }
+            const conditionNode = args[0];
+            statementStates.push({
+              kind: "if",
+              startRange: token.range,
+              condition: conditionNode,
+              then: createBranchState(),
+              else: createBranchState(),
+              currentBlock: "then"
+            });
+            break;
+          }
+          case "else": {
+            cursor.takeToken();
+            const args = parseStatementArguments(cursor, errors);
+            if (args.length !== 0) {
+              errors.push({
+                type: "error",
+                description: "Could not take any arguments in `else` statement",
+                range: widerRange(
+                  token.range,
+                  ...args.map((node) => node.range)
+                )
+              });
+            }
+            if (statementStates.length <= 1) {
+              errors.push({
+                type: "error",
+                description: "Cound not find pair of `if` statement",
+                range: token.range
+              });
+              break;
+            }
+            const lastState = statementStates[statementStates.length - 1];
+            if (lastState.kind !== "if") {
+              errors.push({
+                type: "error",
+                description: "Cound not find pair of `if` statement",
+                range: token.range
+              });
+              break;
+            }
+            if (lastState.currentBlock === "else") {
+              errors.push({
+                type: "error",
+                description: "Duplicated `else` statement",
+                range: token.range
+              });
+              break;
+            }
+            flushExpressions(lastState.then);
+            lastState.currentBlock = "else";
+            break;
+          }
+          case "while": {
+            cursor.takeToken();
+            const args = parseStatementArguments(cursor, errors);
+            if (args.length !== 1) {
+              errors.push({
+                type: "error",
+                description: "Required `while` condition",
+                range: widerRange(
+                  token.range,
+                  ...args.map((node) => node.range)
+                )
+              });
+              break;
+            }
+            const conditionNode = args[0];
+            statementStates.push({
+              kind: "while",
+              startRange: token.range,
+              condition: conditionNode,
+              repeat: createBranchState()
+            });
+            break;
+          }
+          case "for": {
+            cursor.takeToken();
+            const args = parseStatementArguments(cursor, errors);
+            if (args.length !== 2) {
+              errors.push({
+                type: "error",
+                description: "Required `for` bind identity and iterable 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 `for` bind identity",
+                range: bindNode.range
+              });
+              break;
+            }
+            const iterableNode = args[1];
+            statementStates.push({
+              kind: "for",
+              startRange: token.range,
+              bind: bindNode,
+              iterable: iterableNode,
+              repeat: createBranchState()
+            });
+            break;
+          }
+          case "end": {
+            cursor.takeToken();
+            const args = parseStatementArguments(cursor, errors);
+            if (args.length !== 0) {
+              errors.push({
+                type: "error",
+                description: "Could not take any arguments in `end` statement",
+                range: widerRange(
+                  token.range,
+                  ...args.map((node) => node.range)
+                )
+              });
+            }
+            if (statementStates.length <= 1) {
+              errors.push({
+                type: "error",
+                description: "Cound not find pair of `if`,`while` or `for` statement",
+                range: token.range
+              });
+              break;
+            }
+            const lastState = statementStates.pop();
+            flushStatementState(lastState);
+            switch (lastState.kind) {
+              case "if": {
+                pushNode(statementStates, {
+                  kind: "if",
+                  condition: lastState.condition,
+                  then: lastState.then.blocks,
+                  else: lastState.else.blocks,
+                  range: widerRange(
+                    lastState.startRange,
+                    lastState.condition.range,
+                    ...lastState.then.blocks.map((node) => node.range),
+                    ...lastState.else.blocks.map((node) => node.range),
+                    token.range
+                  )
+                });
+                break;
+              }
+              case "while": {
+                pushNode(statementStates, {
+                  kind: "while",
+                  condition: lastState.condition,
+                  repeat: lastState.repeat.blocks,
+                  range: widerRange(
+                    lastState.startRange,
+                    lastState.condition.range,
+                    ...lastState.repeat.blocks.map((node) => node.range),
+                    token.range
+                  )
+                });
+                break;
+              }
+              case "for": {
+                pushNode(statementStates, {
+                  kind: "for",
+                  bind: lastState.bind,
+                  iterable: lastState.iterable,
+                  repeat: lastState.repeat.blocks,
+                  range: widerRange(
+                    lastState.startRange,
+                    lastState.bind.range,
+                    ...lastState.repeat.blocks.map((node) => node.range),
+                    token.range
+                  )
+                });
+                break;
+              }
+            }
+            break;
+          }
+          case "set": {
+            cursor.takeToken();
+            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) {
+              pushNode(statementStates, node);
+            }
+            break;
+          }
+        }
+        break;
+      }
+      default: {
+        if (!isInExpressionBlock) {
+          errors.push({
+            type: "error",
+            description: `Invalid ${token.kind} (tokenizer bug?)`,
+            range: token.range
+          });
+          break;
+        }
+        const node = parseExpression(cursor, errors);
+        if (node) {
+          pushNode(statementStates, node);
+        }
+        break;
+      }
+    }
+  }
+  flushStatementState(rootState);
+  if (statementStates.length !== 1) {
+    errors.push({
+      type: "error",
+      description: `Could not find statement closing`,
+      range: widerRange(...statementStates.map((state) => state.startRange))
+    });
+  }
+  return rootState.branch.blocks;
+};
+const createParserCursor = (tokens) => {
+  let index = 0;
+  const peekToken = () => {
+    return tokens[index];
+  };
+  const takeToken = () => {
+    if (index >= tokens.length) {
+      return void 0;
+    }
+    const token = tokens[index];
+    index++;
+    return token;
+  };
+  return {
+    peekToken,
+    takeToken
+  };
+};
+const runParser = (tokens, errors) => {
+  const cursor = createParserCursor(tokens);
+  const blockNodes = parseBlock(cursor, errors);
+  return blockNodes;
+};
+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
+      };
+    }
+  }
+  return {
+    name,
+    canIgnore: false
+  };
+};
+const traverseVariable = (context, name) => {
+  const names = name.name.split(".");
+  const n0 = names[0];
+  const n0r = deconstructConditionalCombine(n0);
+  const result0 = context.getValue(n0r.name);
+  if (!result0.isFound) {
+    if (!n0r.canIgnore) {
+      context.appendError({
+        type: "error",
+        description: `variable is not bound: ${names[0]}`,
+        range: name.range
+      });
+    }
+    return void 0;
+  }
+  let value = result0.value;
+  for (const n of names.slice(1)) {
+    const nr = deconstructConditionalCombine(n);
+    if (typeof value === "object") {
+      const r = value;
+      const v = r[nr.name];
+      value = v;
+    } else {
+      if (!nr.canIgnore) {
+        context.appendError({
+          type: "error",
+          description: `variable is not bound: ${n}`,
+          range: name.range
+        });
+      }
+      return void 0;
+    }
+  }
+  return value;
+};
+const fromLambda = (context, lambda) => {
+  return async (...args) => {
+    if (args.length < lambda.names.length) {
+      context.appendError({
+        type: "error",
+        description: `Arguments are not filled: ${args.length} < ${lambda.names.length}`,
+        range: lambda.range
+      });
+      return void 0;
+    } else if (args.length > lambda.names.length) {
+      context.appendError({
+        type: "warning",
+        description: `Too many arguments: ${args.length} > ${lambda.names.length}`,
+        range: lambda.range
+      });
+    }
+    const newContext = context.newScope();
+    for (let index = 0; index < lambda.names.length; index++) {
+      newContext.setValue(lambda.names[index].name, args[index]);
+    }
+    const result = await reduceExpressionNode(newContext, lambda.body);
+    return result;
+  };
+};
+const reduceExpressionNode = async (context, node) => {
+  switch (node.kind) {
+    case "number":
+    case "string": {
+      return node.value;
+    }
+    case "variable": {
+      return traverseVariable(context, node);
+    }
+    case "apply": {
+      const func = await reduceExpressionNode(context, node.func);
+      if (typeof func !== "function") {
+        context.appendError({
+          type: "error",
+          description: "could not apply it for function",
+          range: node.range
+        });
+        return void 0;
+      }
+      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;
+            }
+          })
+        );
+        const value = await func.call(thisProxy, ...args);
+        return value;
+      }
+    }
+    case "lambda": {
+      return fromLambda(context, node);
+    }
+    case "list": {
+      const results = await Promise.all(
+        node.items.map((item) => reduceExpressionNode(context, item))
+      );
+      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 [];
+      }
+      let index = 0;
+      while (!context.isFailed()) {
+        const result = await reduceExpressionNode(context, node.nodes[index]);
+        index++;
+        if (index >= node.nodes.length) {
+          return result;
+        }
+      }
+      return void 0;
+    }
+  }
+};
+const reduceNode = async (context, node) => {
+  switch (node.kind) {
+    case "text": {
+      return [node.text];
+    }
+    case "for": {
+      const result = await reduceExpressionNode(context, node.iterable);
+      const iterable = asIterable(result);
+      if (!iterable) {
+        context.appendError({
+          type: "error",
+          description: "could not apply it for function",
+          range: node.range
+        });
+        return [];
+      }
+      const resultList = [];
+      for (const item of iterable) {
+        if (context.isFailed()) {
+          break;
+        }
+        context.setValue(node.bind.name, item);
+        for (const repeat of node.repeat) {
+          const results = await reduceNode(context, repeat);
+          resultList.push(...results);
+        }
+      }
+      return resultList;
+    }
+    case "while": {
+      const resultList = [];
+      while (!context.isFailed()) {
+        const condition = await reduceExpressionNode(context, node.condition);
+        if (!isConditionalTrue(condition)) {
+          break;
+        }
+        for (const repeat of node.repeat) {
+          const results = await reduceNode(context, repeat);
+          resultList.push(...results);
+        }
+      }
+      return resultList;
+    }
+    case "if": {
+      const resultList = [];
+      const condition = await reduceExpressionNode(context, node.condition);
+      if (isConditionalTrue(condition)) {
+        for (const then of node.then) {
+          const results = await reduceNode(context, then);
+          resultList.push(...results);
+        }
+      } else {
+        for (const els of node.else) {
+          const results = await reduceNode(context, els);
+          resultList.push(...results);
+        }
+      }
+      return resultList;
+    }
+    default: {
+      const result = await reduceExpressionNode(context, node);
+      return [result];
+    }
+  }
+};
+const createReducerContext = (variables, errors) => {
+  let vs = variables;
+  let mvs;
+  let variablesProxy;
+  const getValue = (name) => {
+    if (vs.has(name)) {
+      return { value: vs.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
+      });
+    }
+  };
+  const appendError = (error) => {
+    errors.push(error);
+  };
+  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();
+      },
+      thisNode,
+      appendError,
+      reduce: reduceByProxy
+    };
+  };
+  context = {
+    getValue,
+    setValue,
+    appendError,
+    isFailed,
+    newScope,
+    createFunctionContext
+  };
+  return context;
+};
+const unwrap = (results) => {
+  return results.flatMap((result) => {
+    if (result === void 0) {
+      return [];
+    } else {
+      return [result];
+    }
+  });
+};
+async function runReducer(nodes, variables, errors) {
+  const context = createReducerContext(variables, errors);
+  if (Array.isArray(nodes)) {
+    const resultList = [];
+    for (const node of nodes) {
+      const results = await reduceNode(context, node);
+      resultList.push(...results);
+    }
+    return unwrap(resultList);
+  } else {
+    const results = await reduceNode(context, nodes);
+    return unwrap(results);
+  }
+}
+const _cond = makeSpecialFunction(async function(arg0, arg1, arg2) {
+  const cond = await this.reduce(arg0);
+  if (isConditionalTrue(cond)) {
+    return await this.reduce(arg1);
+  } else {
+    return await this.reduce(arg2);
+  }
+});
+const _typeof = async (arg0) => {
+  if (arg0 === null) {
+    return "null";
+  } else if (typeof arg0 === "string") {
+    return "string";
+  } else if (Array.isArray(arg0)) {
+    return "array";
+  } else if (asIterable(arg0)) {
+    return "iterable";
+  } else {
+    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);
+            }
+        }
+    }
+  });
+  return results.join(",");
+};
+const _add = async (arg0, ...args) => {
+  const r = args.reduce((v0, v) => v0 + Number(v), Number(arg0));
+  return r;
+};
+const _sub = async (arg0, ...args) => {
+  const r = args.reduce((v0, v) => v0 - Number(v), Number(arg0));
+  return r;
+};
+const _mul = async (arg0, ...args) => {
+  const r = args.reduce((v0, v) => v0 * Number(v), Number(arg0));
+  return r;
+};
+const _div = async (arg0, ...args) => {
+  const r = args.reduce((v0, v) => v0 / Number(v), Number(arg0));
+  return r;
+};
+const _mod = async (arg0, ...args) => {
+  const r = args.reduce((v0, v) => v0 % Number(v), Number(arg0));
+  return r;
+};
+const _equal = async (arg0, arg1) => {
+  const r = arg0 === arg1;
+  return r;
+};
+const _now = async () => {
+  return Date.now();
+};
+const concatInner = (args) => {
+  let v = "";
+  for (const arg of args) {
+    if (typeof arg === "string") {
+      v = v + arg;
+    } else {
+      const iterable = asIterable(arg);
+      if (iterable) {
+        v = v + concatInner(iterable);
+      } else {
+        v = v + String(arg);
+      }
+    }
+  }
+  return v;
+};
+const _concat = async (...args) => {
+  const r = concatInner(args);
+  return r;
+};
+const _join = async (arg0, ...args) => {
+  const sep = String(arg0);
+  const r = args.map((v) => String(v)).join(sep);
+  return r;
+};
+const _trim = async (arg0) => {
+  var _a;
+  let v = arg0;
+  if (v === void 0 || v === null) {
+    v = "";
+  } else if (typeof v !== "string") {
+    v = (_a = v.toString()) != null ? _a : "";
+  }
+  return v.trim();
+};
+const _toUpper = async (arg0) => {
+  var _a;
+  let v = arg0;
+  if (typeof v !== "string") {
+    v = (_a = v.toString()) != null ? _a : "";
+  }
+  return v.toUpperCase();
+};
+const _toLower = async (arg0) => {
+  var _a;
+  let v = arg0;
+  if (typeof v !== "string") {
+    v = (_a = v.toString()) != null ? _a : "";
+  }
+  return v.toLowerCase();
+};
+const _length = async (arg0) => {
+  if (arg0) {
+    if (typeof arg0 === "string") {
+      return arg0.length;
+    } else if (Array.isArray(arg0)) {
+      return arg0.length;
+    } else {
+      const iterable = asIterable(arg0);
+      if (iterable) {
+        let count = 0;
+        for (const _item of arg0) {
+          count++;
+        }
+        return count;
+      }
+    }
+  }
+  return 0;
+};
+const _and = async (...args) => {
+  if (args.length === 0) {
+    throw new Error("empty arguments");
+  }
+  const r = args.reduce((v0, v) => v0 && isConditionalTrue(v), true);
+  return r;
+};
+const _or = async (...args) => {
+  if (args.length === 0) {
+    throw new Error("empty arguments");
+  }
+  const r = args.reduce((v0, v) => v0 || isConditionalTrue(v), false);
+  return r;
+};
+const _not = async (arg0) => {
+  return !isConditionalTrue(arg0);
+};
+const _at = async (arg0, arg1) => {
+  const index = Number(arg0);
+  if (arg1) {
+    if (typeof arg1 === "string") {
+      return arg1[index];
+    } else if (Array.isArray(arg1)) {
+      return arg1[index];
+    } else {
+      const iterable = asIterable(arg1);
+      if (iterable) {
+        let current = 0;
+        for (const item of iterable) {
+          if (current >= index) {
+            return item;
+          }
+          current++;
+        }
+      }
+    }
+  }
+  return void 0;
+};
+const _first = async (arg0) => {
+  if (arg0) {
+    if (typeof arg0 === "string") {
+      return arg0[0];
+    } else if (Array.isArray(arg0)) {
+      return arg0[0];
+    } else {
+      const iterable = asIterable(arg0);
+      if (iterable) {
+        for (const item of iterable) {
+          return item;
+        }
+      }
+    }
+  }
+  return void 0;
+};
+const _last = async (arg0) => {
+  if (arg0) {
+    if (typeof arg0 === "string") {
+      return arg0[arg0.length - 1];
+    } else if (Array.isArray(arg0)) {
+      return arg0[arg0.length - 1];
+    } else {
+      const iterable = asIterable(arg0);
+      if (iterable) {
+        let lastItem = void 0;
+        for (const item of iterable) {
+          lastItem = item;
+        }
+        return lastItem;
+      }
+    }
+  }
+  return void 0;
+};
+const _range = async (arg0, arg1) => {
+  let value = Number(arg0);
+  const count = Number(arg1);
+  const resultList = [];
+  for (let index = 0; index < count; index++) {
+    resultList.push(value++);
+  }
+  return resultList;
+};
+const _reverse = async (arg0) => {
+  const iter = arg0;
+  let resultList = [];
+  for (const item of iter) {
+    resultList.push(item);
+  }
+  return resultList.reverse();
+};
+const _sort = async (arg0) => {
+  const iter = arg0;
+  let resultList = [];
+  for (const item of iter) {
+    resultList.push(item);
+  }
+  return resultList.sort();
+};
+const _map = async (arg0, arg1) => {
+  const predicate = arg0;
+  const iter = arg1;
+  const resultList = [];
+  for (const item of iter) {
+    const result = await predicate(item);
+    resultList.push(result);
+  }
+  return resultList;
+};
+const _flatMap = async (arg0, arg1) => {
+  const predicate = arg0;
+  const iter = arg1;
+  const resultList = [];
+  for (const item of iter) {
+    const results = await predicate(item);
+    resultList.push(...results);
+  }
+  return resultList;
+};
+const _filter = async (arg0, arg1) => {
+  const predicate = arg0;
+  const iter = arg1;
+  const resultList = [];
+  for (const item of iter) {
+    const result = await predicate(item);
+    if (isConditionalTrue(result)) {
+      resultList.push(item);
+    }
+  }
+  return resultList;
+};
+const _collect = async (arg0) => {
+  const iter = arg0;
+  const resultList = [];
+  for (const item of iter) {
+    if (item !== void 0 && item !== null) {
+      resultList.push(item);
+    }
+  }
+  return resultList;
+};
+const _reduce = async (arg0, arg1, arg2) => {
+  let acc = arg0;
+  const predicate = arg1;
+  const iter = arg2;
+  for (const item of iter) {
+    acc = await predicate(acc, item);
+  }
+  return acc;
+};
+const _match = async (arg0, arg1) => {
+  const re = arg0 instanceof RegExp ? arg0 : new RegExp(String(arg0), "g");
+  const results = String(arg1).match(re);
+  return results;
+};
+const _replace = async (arg0, arg1, arg2) => {
+  const re = arg0 instanceof RegExp ? arg0 : new RegExp(String(arg0), "g");
+  const replace = String(arg1);
+  const results = String(arg2).replace(re, replace);
+  return results;
+};
+const _regex = async (arg0, arg1) => {
+  if (arg1) {
+    const re = new RegExp(String(arg0), String(arg1));
+    return re;
+  } else {
+    const re = new RegExp(String(arg0));
+    return re;
+  }
+};
+const _bind = async (arg0, ...args) => {
+  const predicate = arg0;
+  return predicate.bind(void 0, ...args);
+};
+const standardVariables = {
+  undefined: void 0,
+  null: null,
+  true: true,
+  false: false,
+  cond: _cond,
+  toString: _toString,
+  typeof: _typeof,
+  add: _add,
+  sub: _sub,
+  mul: _mul,
+  div: _div,
+  mod: _mod,
+  equal: _equal,
+  now: _now,
+  concat: _concat,
+  join: _join,
+  trim: _trim,
+  toUpper: _toUpper,
+  toLower: _toLower,
+  length: _length,
+  and: _and,
+  or: _or,
+  not: _not,
+  at: _at,
+  first: _first,
+  last: _last,
+  range: _range,
+  sort: _sort,
+  reverse: _reverse,
+  map: _map,
+  flatMap: _flatMap,
+  filter: _filter,
+  collect: _collect,
+  reduce: _reduce,
+  match: _match,
+  replace: _replace,
+  regex: _regex,
+  bind: _bind
+};
+const buildCandidateVariables = (...variablesList) => {
+  return combineVariables(standardVariables, ...variablesList);
+};
+export {
+  asIterable,
+  buildCandidateVariables,
+  combineVariables,
+  createReducerContext,
+  emptyLocation,
+  emptyRange,
+  fromError,
+  isConditionalTrue,
+  isSpecialFunction,
+  makeSpecialFunction,
+  outputErrors,
+  parseBlock,
+  parseExpression,
+  reduceExpressionNode,
+  reduceNode,
+  runParser,
+  runReducer,
+  runTokenizer,
+  standardVariables,
+  widerRange
+};
+//# sourceMappingURL=index.mjs.map