funcity 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -1,11 +1,11 @@
 /*!
  * name: funcity
- * version: 0.6.0
+ * version: 0.7.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: 0ead9e15b1d6951acb7bf50d4850def586a23c47
+ * git.commit.hash: fc92f38c817d11189397d8e458b1d25db727f766
  */
 
 "use strict";
@@ -139,11 +139,10 @@ const tokenizeNumber = (context) => {
   }
 };
 const firstVariableChars = "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-const variableChars = "_-.?0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const variableChars = "_-?0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 const tokenizeIdentity = (context) => {
   const start = context.cursor.location("start");
   let index = 1;
-  let lastCh = "";
   while (true) {
     if (context.cursor.eot()) {
       break;
@@ -152,11 +151,14 @@ const tokenizeIdentity = (context) => {
     if (variableChars.indexOf(ch) < 0) {
       break;
     }
-    if (lastCh === "?") {
-      index--;
+    if (ch === "?") {
+      const next = context.cursor.getChar(index + 1);
+      if (next === ".") {
+        break;
+      }
+      index++;
       break;
     }
-    lastCh = ch;
     index++;
   }
   return {
@@ -256,6 +258,24 @@ const tokenizeCodeTokens = (context, stopOnClose, finalizeUnknownOnEot) => {
         range: { start: location, end: location }
       });
       context.cursor.skip(1);
+    } else if (ch === "?" && context.cursor.getChar(1) === ".") {
+      finalizeUnknown();
+      const start = context.cursor.location("start");
+      context.cursor.skip(2);
+      tokens.push({
+        kind: "dot",
+        optional: true,
+        range: { start, end: context.cursor.location("end") }
+      });
+    } else if (ch === ".") {
+      finalizeUnknown();
+      const location = context.cursor.location("start");
+      tokens.push({
+        kind: "dot",
+        optional: false,
+        range: { start: location, end: location }
+      });
+      context.cursor.skip(1);
     } else if (firstVariableChars.indexOf(ch) >= 0) {
       finalizeUnknown();
       tokens.push(tokenizeIdentity(context));
@@ -686,6 +706,52 @@ const combineIntoScopeMultipleExpressions = (expressionList, ...outerRanges) =>
     }
   }
 };
+const parseDotChain = (cursor, logs, baseNode) => {
+  const segments = [];
+  const ranges = [baseNode.range];
+  while (true) {
+    const dotToken = cursor.peekToken();
+    if (!dotToken || dotToken.kind !== "dot") {
+      break;
+    }
+    const actualDotToken = cursor.takeToken();
+    ranges.push(actualDotToken.range);
+    const nextToken = cursor.peekToken();
+    if (!nextToken) {
+      logs.push({
+        type: "error",
+        description: "Could not find member identity after dot",
+        range: actualDotToken.range
+      });
+      break;
+    }
+    if (nextToken.kind !== "identity") {
+      logs.push({
+        type: "error",
+        description: "Required member identity after dot",
+        range: widerRange(actualDotToken.range, nextToken.range)
+      });
+      break;
+    }
+    const memberToken = cursor.takeToken();
+    segments.push({
+      name: memberToken.name,
+      optional: actualDotToken.optional,
+      range: memberToken.range,
+      operatorRange: actualDotToken.range
+    });
+    ranges.push(memberToken.range);
+  }
+  if (segments.length === 0) {
+    return baseNode;
+  }
+  return {
+    kind: "dot",
+    base: baseNode,
+    segments,
+    range: widerRange(...ranges)
+  };
+};
 const parsePartialExpression = (cursor, logs) => {
   const token = cursor.peekToken();
   if (!token) {
@@ -694,15 +760,24 @@ const parsePartialExpression = (cursor, logs) => {
   switch (token.kind) {
     case "number": {
       const node = parseNumber(cursor);
-      return node;
+      return parseDotChain(cursor, logs, node);
     }
     case "string": {
       const node = parseString(cursor);
-      return node;
+      return parseDotChain(cursor, logs, node);
     }
     case "identity": {
       const node = parseIdentity(cursor);
-      return node;
+      return parseDotChain(cursor, logs, node);
+    }
+    case "dot": {
+      const dotToken = cursor.takeToken();
+      logs.push({
+        type: "error",
+        description: "Invalid dot at this location",
+        range: dotToken.range
+      });
+      return void 0;
     }
     case "open": {
       cursor.skipToken();
@@ -747,7 +822,7 @@ const parsePartialExpression = (cursor, logs) => {
             };
           } else {
             const node = combineIntoScopeMultipleExpressions(innerNodes, range);
-            return node;
+            return node ? parseDotChain(cursor, logs, node) : node;
           }
         }
         // Bracket surrounding expression list `[ ... ]` (Iterable list)
@@ -758,7 +833,7 @@ const parsePartialExpression = (cursor, logs) => {
           if (!closeToken) {
             range = widerRange(
               token.range,
-              ...itemNodes.map((node) => node.range)
+              ...itemNodes.map((node2) => node2.range)
             );
             logs.push({
               type: "error",
@@ -769,7 +844,7 @@ const parsePartialExpression = (cursor, logs) => {
             cursor.skipToken();
             range = widerRange(
               token.range,
-              ...itemNodes.map((node) => node.range),
+              ...itemNodes.map((node2) => node2.range),
               closeToken.range
             );
             if (closeToken.kind !== "close" || closeToken.symbol !== "]") {
@@ -780,11 +855,12 @@ const parsePartialExpression = (cursor, logs) => {
               });
             }
           }
-          return {
+          const node = {
             kind: "list",
             items: itemNodes,
             range
           };
+          return parseDotChain(cursor, logs, node);
         }
         default: {
           logs.push({
@@ -1417,33 +1493,54 @@ const deconstructConditionalCombine = (name) => {
     canIgnore: false
   };
 };
-const traverseVariable = (context, name, signal) => {
-  const names = name.name.split(".");
-  const n0 = names[0];
-  const n0r = deconstructConditionalCombine(n0);
-  const result0 = context.getValue(n0r.name, signal);
-  if (!result0.isFound) {
-    if (!n0r.canIgnore) {
+const resolveVariable = (context, name, signal) => {
+  const result = deconstructConditionalCombine(name.name);
+  const valueResult = context.getValue(result.name, signal);
+  if (!valueResult.isFound) {
+    if (!result.canIgnore) {
       throwError({
-        description: `variable is not bound: ${names[0]}`,
+        description: `variable is not bound: ${result.name}`,
         range: name.range
       });
     }
     return void 0;
   }
-  let value = result0.value;
+  return valueResult.value;
+};
+const resolveDotNode = async (context, node, signal) => {
+  var _a, _b;
+  signal == null ? void 0 : signal.throwIfAborted();
+  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 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;
+    }
+    value = valueResult.value;
+  } else {
+    value = await reduceExpressionNode(context, node.base, signal);
+  }
   let parent;
-  for (const n of names.slice(1)) {
-    const nr = deconstructConditionalCombine(n);
-    if (value !== null && typeof value === "object") {
-      const r = value;
+  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 = r[nr.name];
+      value = record[result.name];
     } else {
-      if (!nr.canIgnore) {
+      if (!isOptional) {
         throwError({
-          description: `variable is not bound: ${n}`,
-          range: name.range
+          description: `variable is not bound: ${result.name}`,
+          range: segment.range
         });
       }
       return void 0;
@@ -1464,16 +1561,20 @@ const applyFunction = async (context, node, signal) => {
     });
     return void 0;
   }
-  const args = isFunCityFunction(func) ? node.args : await Promise.all(
+  const isSpecial = isFunCityFunction(func);
+  const args = isSpecial ? node.args : await Promise.all(
     node.args.map(async (argNode) => {
       const arg = await reduceExpressionNode(context, argNode, signal);
       return arg;
     })
   );
-  const thisProxy = context.createFunctionContext(node, signal);
+  const shouldConstruct = !isSpecial && context.isConstructable(func);
   try {
-    const value = await func.call(thisProxy, ...args);
-    return value;
+    if (shouldConstruct) {
+      return Reflect.construct(func, args);
+    }
+    const thisProxy = context.createFunctionContext(node, signal);
+    return await func.call(thisProxy, ...args);
   } catch (e) {
     if (e instanceof FunCityReducerError) {
       throw e;
@@ -1495,7 +1596,10 @@ const reduceExpressionNode = async (context, node, signal) => {
       return node.value;
     }
     case "variable": {
-      return traverseVariable(context, node, signal);
+      return resolveVariable(context, node, signal);
+    }
+    case "dot": {
+      return await resolveDotNode(context, node, signal);
     }
     case "apply": {
       return await applyFunction(context, node, signal);
@@ -1606,7 +1710,6 @@ const createScopedReducerContext = (parent, signal) => {
     }
     thisVars.set(name, value);
   };
-  const getBoundFunction = parent.getBoundFunction;
   const createFunctionContext = (thisNode, signal2) => {
     return {
       thisNode,
@@ -1614,6 +1717,7 @@ const createScopedReducerContext = (parent, signal) => {
       getValue: (name) => getValue(name, signal2),
       setValue: (name, value) => setValue(name, value, signal2),
       appendWarning: parent.appendWarning,
+      getBoundFunction: parent.getBoundFunction,
       newScope: () => createScopedReducerContext(thisContext, signal2),
       convertToString: parent.convertToString,
       reduce: (node) => reduceExpressionNode(thisContext, node, signal2)
@@ -1622,10 +1726,11 @@ const createScopedReducerContext = (parent, signal) => {
   thisContext = {
     getValue,
     setValue,
-    getBoundFunction,
+    getBoundFunction: parent.getBoundFunction,
     appendWarning: parent.appendWarning,
     newScope: (signal2) => createScopedReducerContext(thisContext, signal2),
     convertToString: parent.convertToString,
+    isConstructable: parent.isConstructable,
     createFunctionContext
   };
   return thisContext;
@@ -1633,24 +1738,22 @@ const createScopedReducerContext = (parent, signal) => {
 const createReducerContext = (variables, warningLogs) => {
   let thisVars;
   let thisContext;
-  const createBoundFunctionResolver = () => {
-    const cache = /* @__PURE__ */ new WeakMap();
-    return (owner, fn) => {
-      let ownerCache = cache.get(owner);
-      if (!ownerCache) {
-        ownerCache = /* @__PURE__ */ new WeakMap();
-        cache.set(owner, ownerCache);
-      }
-      const cached = ownerCache.get(fn);
-      if (cached) {
-        return cached;
-      }
-      const bound = fn.bind(owner);
-      ownerCache.set(fn, bound);
-      return bound;
-    };
+  const boundFunctionCache = /* @__PURE__ */ new WeakMap();
+  const getBoundFunction = (owner, fn) => {
+    let ownerCache = boundFunctionCache.get(owner);
+    if (!ownerCache) {
+      ownerCache = /* @__PURE__ */ new WeakMap();
+      boundFunctionCache.set(owner, ownerCache);
+    }
+    const cached = ownerCache.get(fn);
+    if (cached) {
+      return cached;
+    }
+    const bound = fn.bind(owner);
+    ownerCache.set(fn, bound);
+    return bound;
   };
-  const getBoundFunction = createBoundFunctionResolver();
+  const constructorCache = /* @__PURE__ */ new WeakMap();
   const getValue = (name, signal) => {
     signal == null ? void 0 : signal.throwIfAborted();
     if (thisVars == null ? void 0 : thisVars.has(name)) {
@@ -1671,6 +1774,20 @@ const createReducerContext = (variables, warningLogs) => {
   const appendWarning = (warning) => {
     warningLogs.push(warning);
   };
+  const isConstructable = (fn) => {
+    if (constructorCache.has(fn)) {
+      return constructorCache.get(fn);
+    }
+    let result = false;
+    try {
+      Reflect.construct(Object, [], fn);
+      result = true;
+    } catch (e) {
+      result = false;
+    }
+    constructorCache.set(fn, result);
+    return result;
+  };
   const getFuncId = internalCreateFunctionIdGenerator();
   const convertToString2 = (v) => {
     return internalConvertToString(v, getFuncId);
@@ -1682,6 +1799,7 @@ const createReducerContext = (variables, warningLogs) => {
       getValue: (name) => getValue(name, signal),
       setValue: (name, value) => setValue(name, value, signal),
       appendWarning,
+      getBoundFunction,
       newScope: () => createScopedReducerContext(thisContext, signal),
       convertToString: convertToString2,
       reduce: (node) => reduceExpressionNode(thisContext, node, signal)
@@ -1694,6 +1812,7 @@ const createReducerContext = (variables, warningLogs) => {
     appendWarning,
     newScope: (signal) => createScopedReducerContext(thisContext, signal),
     convertToString: convertToString2,
+    isConstructable,
     createFunctionContext
   };
   return thisContext;
@@ -1905,7 +2024,7 @@ const _ge = async (arg0, arg1) => {
   return r;
 };
 const _now = async () => {
-  return Date.now();
+  return /* @__PURE__ */ new Date();
 };
 const concatInner = (args) => {
   let v = "";
@@ -2268,8 +2387,7 @@ const standardVariables = Object.freeze({
   regex: _regex,
   bind: _bind,
   url: _url,
-  delay: _delay,
-  math: Math
+  delay: _delay
 });
 const buildCandidateVariables = (...variablesList) => {
   return combineVariables(standardVariables, ...variablesList);
@@ -2335,6 +2453,15 @@ const runScriptOnceToText = async (script, props, signal) => {
   const text = resultList.map((result) => reducerContext.convertToString(result)).join("");
   return text;
 };
+const objectVariables = Object.freeze({
+  Object,
+  Array,
+  String,
+  Number,
+  Function,
+  Math,
+  Date
+});
 const getFetch = () => {
   const fetchFn = globalThis.fetch;
   if (!fetchFn) {
@@ -2393,6 +2520,7 @@ exports.fetchVariables = fetchVariables;
 exports.isConditionalTrue = isConditionalTrue;
 exports.isFunCityFunction = isFunCityFunction;
 exports.makeFunCityFunction = makeFunCityFunction;
+exports.objectVariables = objectVariables;
 exports.outputErrors = outputErrors;
 exports.parseBlock = parseBlock;
 exports.parseExpression = parseExpression;