affinirum 1.0.0

package/dst/cjs/Affinirum.js

@@ -0,0 +1,540 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Affinirum = void 0;
+const Boolean_js_1 = require("./constant/Boolean.js");
+const Enumerable_js_1 = require("./constant/Enumerable.js");
+const Iterable_js_1 = require("./constant/Iterable.js");
+const Number_js_1 = require("./constant/Number.js");
+const Unknown_js_1 = require("./constant/Unknown.js");
+const Constant_js_1 = require("./Constant.js");
+const Variable_js_1 = require("./Variable.js");
+const Type_js_1 = require("./Type.js");
+const Keywords_js_1 = require("./Keywords.js");
+const Constants_js_1 = require("./Constants.js");
+const Functions_js_1 = require("./Functions.js");
+const ArrayNode_js_1 = require("./node/ArrayNode.js");
+const BlockNode_js_1 = require("./node/BlockNode.js");
+const ConstantNode_js_1 = require("./node/ConstantNode.js");
+const CallNode_js_1 = require("./node/CallNode.js");
+const LoopNode_js_1 = require("./node/LoopNode.js");
+const ObjectNode_js_1 = require("./node/ObjectNode.js");
+const SwitchNode_js_1 = require("./node/SwitchNode.js");
+const VariableNode_js_1 = require("./node/VariableNode.js");
+const ParserState_js_1 = require("./ParserState.js");
+const StaticScope_js_1 = require("./StaticScope.js");
+class Affinirum {
+    static keywords = [...Keywords_js_1.Keywords, ...Constants_js_1.Constants.map((c) => c[0])];
+    _script;
+    _strict;
+    _root;
+    _vframes = new Map();
+    _variables = new Map();
+    _constants = new Map(Constants_js_1.Constants);
+    _functions = new Map(Functions_js_1.Functions);
+    _scope = new StaticScope_js_1.StaticScope();
+    /**
+        Creates compiled expression. Any parsed token not recognized as a constant or a function will be compiled as a variable.
+        @param script Math expression to compile.
+        @param config Optional expected type, strict mode, variable types, constant values and functions to add for the compilation.
+            If expected type is provided then expression return type is matched against it.
+            If strict mode is set then undeclared variables will not be allowed in expression.
+    */
+    constructor(script, config) {
+        this._script = script;
+        this._strict = config?.strict ?? false;
+        if (config?.variables) {
+            for (const v in config.variables) {
+                this._variables.set(v, new Variable_js_1.Variable(config.variables[v]));
+            }
+        }
+        const state = new ParserState_js_1.ParserState(this._script);
+        this._root = this._block(state.next(), this._scope);
+        if (!state.isVoid) {
+            state.throwError('unexpected expression token or expression end');
+        }
+        this._root = this._root.compile(config?.type ?? Type_js_1.Type.Unknown);
+    }
+    /**
+        Returns original script text.
+    */
+    get script() {
+        return this._script;
+    }
+    /**
+        Returns compiled expression return value type.
+    */
+    get type() {
+        return this._root.type;
+    }
+    /**
+        Returns string representing parsed node tree structure.
+        @returns Parsed expression string.
+    */
+    toString() {
+        return this._root.toString();
+    }
+    /**
+        Returns record with compiled variable names and expected types.
+        @returns Record with variable names and types.
+    */
+    variables() {
+        const types = {};
+        const variables = this._scope.variables();
+        for (const name in variables) {
+            types[name] = variables[name].type;
+        }
+        return types;
+    }
+    /**
+        Evaluates compiled expression using provided variable values.
+        @param values Record with variable names and values.
+        @returns Calculated value.
+    */
+    evaluate(values) {
+        const variables = this._scope.variables();
+        for (const name in variables) {
+            if (!Object.prototype.hasOwnProperty.call(values, name)) {
+                this._vframes.get(name)?.throwError(`undefined variable ${name}:\n`);
+            }
+            const variable = variables[name];
+            const value = values?.[name] ?? undefined;
+            if (!variable.type.match(Type_js_1.Type.of(value))) {
+                this._vframes.get(name)?.throwError(`unexpected type ${Type_js_1.Type.of(value)} for variable ${name} of type ${variable.type}:\n`);
+            }
+            variable.value = value;
+        }
+        return this._root.evaluate();
+    }
+    _block(state, scope) {
+        const frame = state.starts();
+        const nodes = [this._unit(state, scope)];
+        while (state.isSemicolonSeparator) {
+            nodes.push(this._unit(state.next(), scope));
+        }
+        return new BlockNode_js_1.BlockNode(frame.ends(state), nodes);
+    }
+    _unit(state, scope) {
+        return this._disjunction(state, scope);
+    }
+    _disjunction(state, scope) {
+        let node = this._conjunction(state, scope);
+        while (state.operator === Boolean_js_1.funcOr) {
+            node = this._call(state.starts(), state.operator, [node, this._conjunction(state.next(), scope)]);
+        }
+        return node;
+    }
+    _conjunction(state, scope) {
+        let node = this._comparison(state, scope);
+        while (state.operator === Boolean_js_1.funcAnd) {
+            node = this._call(state.starts(), state.operator, [node, this._comparison(state.next(), scope)]);
+        }
+        return node;
+    }
+    _comparison(state, scope) {
+        const frame = state.starts();
+        let not = false;
+        while (state.operator === Boolean_js_1.funcNot) {
+            not = !not;
+            frame.starts(state);
+            state.next();
+        }
+        let node = this._aggregate(state, scope);
+        while (state.operator === Number_js_1.funcGreaterThan || state.operator === Number_js_1.funcLessThan
+            || state.operator === Number_js_1.funcGreaterOrEqual || state.operator === Number_js_1.funcLessOrEqual
+            || state.operator === Unknown_js_1.funcEqual || state.operator === Unknown_js_1.funcNotEqual) {
+            node = this._call(state.starts(), state.operator, [node, this._aggregate(state.next(), scope)]);
+        }
+        if (not) {
+            node = this._call(frame.ends(state), Boolean_js_1.funcNot, [node]);
+        }
+        return node;
+    }
+    _aggregate(state, scope) {
+        let node = this._product(state, scope);
+        while (state.operator === Enumerable_js_1.funcAdd || state.operator === Number_js_1.funcSubtract) {
+            node = this._call(state.starts(), state.operator, [node, this._product(state.next(), scope)]);
+        }
+        return node;
+    }
+    _product(state, scope) {
+        let node = this._factor(state, scope);
+        while (state.operator === Number_js_1.funcMultiply || state.operator === Number_js_1.funcDivide || state.operator === Number_js_1.funcRemainder) {
+            node = this._call(state.starts(), state.operator, [node, this._factor(state.next(), scope)]);
+        }
+        return node;
+    }
+    _factor(state, scope) {
+        const frame = state.starts();
+        let neg = false;
+        while (state.operator === Number_js_1.funcSubtract) {
+            neg = !neg;
+            frame.starts(state);
+            state.next();
+        }
+        let node = this._coalescence(state, scope);
+        while (state.operator === Number_js_1.funcPower) {
+            node = this._call(state.starts(), state.operator, [node, this._coalescence(state.next(), scope)]);
+        }
+        if (neg) {
+            node = this._call(frame.ends(state), Number_js_1.funcNegate, [node]);
+        }
+        return node;
+    }
+    _coalescence(state, scope) {
+        let node = this._accessor(state, scope);
+        while (state.operator === Unknown_js_1.funcCoalesce) {
+            node = this._call(state.starts(), state.operator, [node, this._accessor(state.next(), scope)]);
+        }
+        return node;
+    }
+    _accessor(state, scope) {
+        let node = this._term(state, scope);
+        while (state.operator === Iterable_js_1.funcAt || state.isParenthesesOpen || state.isBracketsOpen) {
+            const frame = state.starts();
+            if (state.operator === Iterable_js_1.funcAt) {
+                if (state.next().isLiteral && (typeof state.literalValue === 'string' || typeof state.literalValue === 'bigint')) {
+                    node = this._call(frame.ends(state), Iterable_js_1.funcAt, [node, new ConstantNode_js_1.ConstantNode(state, new Constant_js_1.Constant(state.literalValue))]);
+                    state.next();
+                }
+                else if (state.isToken) {
+                    frame.ends(state);
+                    const func = this._functions.get(state.token);
+                    if (func) {
+                        if (state.next().isParenthesesOpen) {
+                            const subnodes = [node];
+                            while (!state.next().isParenthesesClose) {
+                                subnodes.push(this._unit(state, scope));
+                                if (!state.isCommaSeparator) {
+                                    break;
+                                }
+                            }
+                            node = this._call(frame.ends(state), func, subnodes);
+                            state.closeParentheses().next();
+                        }
+                        else {
+                            node = this._call(frame, func, [node]);
+                        }
+                    }
+                    else {
+                        node = this._call(frame, Iterable_js_1.funcAt, [node, new ConstantNode_js_1.ConstantNode(state, new Constant_js_1.Constant(state.token))]);
+                        state.next();
+                    }
+                }
+                else {
+                    state.throwError('missing array or object index');
+                }
+            }
+            else if (state.isParenthesesOpen) {
+                const subnodes = [];
+                while (!state.next().isParenthesesClose) {
+                    subnodes.push(this._unit(state, scope));
+                    if (!state.isCommaSeparator) {
+                        break;
+                    }
+                }
+                node = new CallNode_js_1.CallNode(frame.ends(state), node, subnodes);
+                state.closeParentheses().next();
+            }
+            else if (state.isBracketsOpen) {
+                node = this._call(frame, Iterable_js_1.funcAt, [node, this._unit(state.next(), scope)]);
+                state.closeBrackets().next();
+            }
+        }
+        return node;
+    }
+    _term(state, scope) {
+        if (state.isLiteral) {
+            const frame = state.starts();
+            const constant = new Constant_js_1.Constant(state.literalValue);
+            state.next();
+            return new ConstantNode_js_1.ConstantNode(frame, constant);
+        }
+        else if (state.isToken) {
+            const frame = state.starts();
+            const constants = this._constants.get(state.token);
+            if (constants != null) {
+                if (state.next().operator !== Iterable_js_1.funcAt) {
+                    state.throwError('missing constant accessor operator');
+                }
+                if (!state.next().isToken) {
+                    state.throwError('missing constant name');
+                }
+                const constant = constants[state.token];
+                if (!constant) {
+                    state.throwError(`unknown constant ${state.token}`);
+                }
+                state.next();
+                return new ConstantNode_js_1.ConstantNode(frame, constant);
+            }
+            let variable = scope.get(state.token);
+            if (variable == null) {
+                variable = this._variables.get(state.token);
+                if (variable == null) {
+                    if (this._strict) {
+                        state.throwError(`undefined variable ${state.token} in strict mode`);
+                    }
+                    else {
+                        variable = new Variable_js_1.Variable();
+                    }
+                }
+                scope.global(state.token, variable);
+            }
+            if (!this._vframes.has(state.token)) {
+                this._vframes.set(state.token, state.starts());
+            }
+            if (state.next().isAssignment) {
+                if (variable.constant) {
+                    state.throwError('illegal constant assignment');
+                }
+                if (state.assignmentOperator) {
+                    const operator = state.assignmentOperator;
+                    const subnodes = [new VariableNode_js_1.VariableNode(frame, variable), this._unit(state.next(), scope)];
+                    return new VariableNode_js_1.VariableNode(frame, variable, this._call(frame, operator, subnodes));
+                }
+                else {
+                    return new VariableNode_js_1.VariableNode(frame, variable, this._unit(state.next(), scope));
+                }
+            }
+            return new VariableNode_js_1.VariableNode(frame, variable);
+        }
+        else if (state.isBracesOpen) {
+            const node = this._block(state.next(), scope);
+            state.closeBraces().next();
+            return node;
+        }
+        else if (state.isBracesClose) {
+            state.throwError('unexpected closing braces');
+        }
+        else if (state.isParenthesesOpen) {
+            const node = this._unit(state.next(), scope);
+            state.closeParentheses().next();
+            return node;
+        }
+        else if (state.isParenthesesClose) {
+            state.throwError('unexpected closing parentheses');
+        }
+        else if (state.isBracketsOpen) {
+            const frame = state.starts();
+            const subnodes = [];
+            let index = 0, colon = false;
+            while (!state.next().isBracketsClose) {
+                if (state.isColonSeparator) {
+                    colon = true;
+                    state.next();
+                    break;
+                }
+                const node = this._unit(state, scope);
+                if (state.isColonSeparator) {
+                    colon = true;
+                    subnodes.push([node, this._unit(state.next(), scope)]);
+                }
+                else {
+                    subnodes.push([index++, node]);
+                }
+                if (!state.isCommaSeparator) {
+                    break;
+                }
+            }
+            frame.ends(state);
+            state.closeBrackets().next();
+            if (colon) {
+                return new ObjectNode_js_1.ObjectNode(frame, subnodes.map(([k, v]) => [typeof k === 'number' ? new ConstantNode_js_1.ConstantNode(v, new Constant_js_1.Constant(String(k))) : k, v]));
+            }
+            return new ArrayNode_js_1.ArrayNode(frame, subnodes.map(([, v]) => v));
+        }
+        else if (state.isBracketsClose) {
+            state.throwError('unexpected closing brackets');
+        }
+        else if (state.isVariableDefinition || state.isConstantDefinition) {
+            const constant = state.isConstantDefinition;
+            if (!state.next().isToken) {
+                state.throwError(`missing ${constant ? 'constant' : 'variable'} name`);
+            }
+            const token = state.token;
+            if (scope.has(token)) {
+                state.throwError(`illegal redefinition of ${constant ? 'constant' : 'variable'} ${token}`);
+            }
+            const frame = state.starts();
+            let type;
+            if (state.next().isColonSeparator) {
+                type = this._type(state.next(), scope);
+            }
+            const variable = new Variable_js_1.Variable(type, constant);
+            scope.local(token, variable);
+            if (state.isAssignment) {
+                if (state.assignmentOperator) {
+                    state.throwError(`illegal assignment to ${constant ? 'constant' : 'variable'} ${token}`);
+                }
+                return new VariableNode_js_1.VariableNode(frame, variable, this._unit(state.next(), scope));
+            }
+            return new VariableNode_js_1.VariableNode(frame, variable);
+        }
+        else if (state.isTildaMark) {
+            return this._function(state, scope);
+        }
+        else if (state.isWhile) {
+            return this._loop(state, scope);
+        }
+        else if (state.isIf) {
+            return this._switch(state, scope);
+        }
+        else if (state.isVoid) {
+            state.throwError('unexpected end of expression');
+        }
+        state.throwError('unexpected expression token');
+    }
+    _function(state, scope) {
+        const frame = state.starts();
+        let retType = undefined;
+        if (!state.next().isParenthesesOpen) {
+            retType = this._type(state, scope);
+            state.openParentheses();
+        }
+        let variadic = false;
+        const variables = new Map();
+        while (!state.next().isParenthesesClose) {
+            if (!state.isToken) {
+                state.throwError('missing function argument name');
+            }
+            const token = state.token;
+            if (scope.get(token)) {
+                state.throwError('variable redefinition');
+            }
+            let argType = Type_js_1.Type.Unknown;
+            if (state.next().isColonSeparator) {
+                argType = this._type(state.next(), scope);
+            }
+            variables.set(token, new Variable_js_1.Variable(argType));
+            if (argType.isArray && state.isVariadicFunction) {
+                variadic = true;
+                state.next();
+                break;
+            }
+            if (!state.isCommaSeparator) {
+                break;
+            }
+        }
+        state.closeParentheses();
+        frame.ends(state);
+        state.next().openBraces().next();
+        const subnode = this._block(state, scope.subscope(variables));
+        state.closeBraces().next();
+        const args = Array.from(variables.values());
+        const value = (...values) => {
+            args.forEach((arg, ix) => arg.value = values[ix]);
+            return subnode.evaluate();
+        };
+        if (!retType && args.length) {
+            retType = Type_js_1.Type.Unknown;
+        }
+        const constant = new Constant_js_1.Constant(value, Type_js_1.Type.functionType(retType, args.map((v) => v.type), variadic));
+        return new ConstantNode_js_1.ConstantNode(frame, constant, subnode);
+    }
+    _loop(state, scope) {
+        const frame = state.starts();
+        const cnode = this._unit(state.next(), scope);
+        frame.ends(state);
+        state.openBraces().next();
+        const subnode = this._block(state, scope);
+        state.closeBraces().next();
+        return new LoopNode_js_1.LoopNode(frame, cnode, subnode);
+    }
+    _switch(state, scope) {
+        const frame = state.starts();
+        const cnode = this._unit(state.next(), scope);
+        frame.ends(state);
+        const subnodes = [];
+        state.openBraces().next();
+        subnodes.push(this._block(state, scope));
+        state.closeBraces().next();
+        if (state.isElse) {
+            state.next().openBraces().next();
+            subnodes.push(this._block(state, scope));
+            state.closeBraces().next();
+        }
+        else {
+            subnodes.push(new ConstantNode_js_1.ConstantNode(state.starts(), Constant_js_1.Constant.Null));
+        }
+        return new SwitchNode_js_1.SwitchNode(frame, cnode, subnodes);
+    }
+    _call(frame, func, subnodes) {
+        return new CallNode_js_1.CallNode(frame, new ConstantNode_js_1.ConstantNode(frame, func), subnodes);
+    }
+    _type(state, scope) {
+        if (state.isType) {
+            let type = state.type;
+            if (state.next().isOptionalType) {
+                type = type.toOptional();
+                state.next();
+            }
+            if (state.operator === Boolean_js_1.funcOr) { // type union
+                return Type_js_1.Type.union(type, this._type(state.next(), scope));
+            }
+            return type;
+        }
+        else if (state.isBracketsOpen) { // array or object type
+            const itemPropTypes = [];
+            let index = 0, colon = false;
+            while (!state.next().isBracketsClose) {
+                if (state.isColonSeparator) { // default object type
+                    colon = true;
+                    state.next();
+                    break;
+                }
+                if (state.isType) {
+                    itemPropTypes.push([index++, this._type(state, scope)]);
+                }
+                else if (state.isToken) {
+                    const token = state.token;
+                    state.next().separateByColon().next();
+                    itemPropTypes.push([token, this._type(state, scope)]);
+                }
+                else {
+                    state.throwError('missing type or property name');
+                }
+                if (!state.isCommaSeparator) {
+                    break;
+                }
+            }
+            state.closeBrackets().next();
+            return colon
+                ? Type_js_1.Type.objectType(Object.fromEntries(itemPropTypes.map(([prop, type]) => [prop, type])))
+                : Type_js_1.Type.arrayType(itemPropTypes.map(([, v]) => v));
+        }
+        else if (state.isTildaMark) { // function type
+            let retType = undefined;
+            if (!state.next().isParenthesesOpen) {
+                retType = this._type(state, scope);
+                state.openParentheses();
+            }
+            let variadic = false;
+            const argTypes = [];
+            while (!state.next().isParenthesesClose) {
+                const argType = this._type(state, scope);
+                argTypes.push(argType);
+                if (state.isVariadicFunction) {
+                    if (argType.isArray) {
+                        variadic = true;
+                        state.next();
+                        break;
+                    }
+                    else {
+                        state.throwError('variadic function argument must be an array type');
+                    }
+                }
+                if (!state.isCommaSeparator) {
+                    break;
+                }
+            }
+            state.closeParentheses().next();
+            if (!retType && argTypes.length) {
+                retType = Type_js_1.Type.Unknown;
+            }
+            return Type_js_1.Type.functionType(retType, argTypes, variadic);
+        }
+        else {
+            state.throwError('missing type name');
+        }
+    }
+}
+exports.Affinirum = Affinirum;

package/dst/cjs/Constant.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Constant = void 0;
+const Type_js_1 = require("./Type.js");
+class Constant {
+    _value;
+    _type;
+    _deterministic;
+    constructor(_value, _type = Type_js_1.Type.of(_value), _deterministic = true) {
+        this._value = _value;
+        this._type = _type;
+        this._deterministic = _deterministic;
+    }
+    get value() {
+        return this._value;
+    }
+    get type() {
+        return Type_js_1.Type.isPrimitiveType(this._value) ? Type_js_1.Type.of(this._value) : this._type;
+    }
+    set type(type) {
+        this._type = type;
+    }
+    get deterministic() {
+        return this._deterministic;
+    }
+    static Null = new Constant(undefined);
+    static EmptyArray = new Constant([]);
+    static EmptyObject = new Constant({});
+}
+exports.Constant = Constant;

package/dst/cjs/Constants.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Constants = void 0;
+const Array_js_1 = require("./constant/Array.js");
+const Boolean_js_1 = require("./constant/Boolean.js");
+const Buffer_js_1 = require("./constant/Buffer.js");
+const Integer_js_1 = require("./constant/Integer.js");
+const Float_js_1 = require("./constant/Float.js");
+const Object_js_1 = require("./constant/Object.js");
+const String_js_1 = require("./constant/String.js");
+const Timestamp_js_1 = require("./constant/Timestamp.js");
+const AN_js_1 = require("./constant/notation/AN.js");
+const JSON_js_1 = require("./constant/notation/JSON.js");
+exports.Constants = [
+    ['Array', Array_js_1.constArray],
+    ['Boolean', Boolean_js_1.constBoolean],
+    ['Buffer', Buffer_js_1.constBuffer],
+    ['Float', Float_js_1.constFloat],
+    ['Integer', Integer_js_1.constInteger],
+    ['Object', Object_js_1.constObject],
+    ['String', String_js_1.constString],
+    ['Timestamp', Timestamp_js_1.constTimestamp],
+    ['AN', AN_js_1.constAN],
+    ['JSON', JSON_js_1.constJSON],
+];

package/dst/cjs/Functions.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Functions = void 0;
+const Array_js_1 = require("./constant/Array.js");
+const Buffer_js_1 = require("./constant/Buffer.js");
+const Enumerable_js_1 = require("./constant/Enumerable.js");
+const Iterable_js_1 = require("./constant/Iterable.js");
+const Number_js_1 = require("./constant/Number.js");
+const Object_js_1 = require("./constant/Object.js");
+const String_js_1 = require("./constant/String.js");
+const Timestamp_js_1 = require("./constant/Timestamp.js");
+const Unknown_js_1 = require("./constant/Unknown.js");
+exports.Functions = [
+    // Array
+    ['First', Array_js_1.funcFirst],
+    ['Last', Array_js_1.funcLast],
+    ['FirstIndex', Array_js_1.funcFirstIndex],
+    ['LastIndex', Array_js_1.funcLastIndex],
+    ['Any', Array_js_1.funcAny],
+    ['Every', Array_js_1.funcEvery],
+    ['Flatten', Array_js_1.funcFlatten],
+    ['Reverse', Array_js_1.funcReverse],
+    ['Mutate', Array_js_1.funcMutate],
+    ['Filter', Array_js_1.funcFilter],
+    ['Reduce', Array_js_1.funcReduce],
+    ['Compose', Array_js_1.funcCompose],
+    ['Prepend', Array_js_1.funcPrepend],
+    ['Append', Array_js_1.funcAppend],
+    // Buffer
+    ['Byte', Buffer_js_1.funcByte],
+    // Enumerable
+    ['Add', Enumerable_js_1.funcAdd],
+    ['Slice', Enumerable_js_1.funcSlice],
+    ['Splice', Enumerable_js_1.funcSplice],
+    ['Inject', Enumerable_js_1.funcInject],
+    // Iterable
+    ['Length', Iterable_js_1.funcLength],
+    ['At', Iterable_js_1.funcAt],
+    // Number
+    ['GreaterThan', Number_js_1.funcGreaterThan],
+    ['LessThan', Number_js_1.funcLessThan],
+    ['GreaterOrEqual', Number_js_1.funcGreaterOrEqual],
+    ['LessOrEqual', Number_js_1.funcLessOrEqual],
+    ['Subtract', Number_js_1.funcSubtract],
+    ['Multiply', Number_js_1.funcMultiply],
+    ['Divide', Number_js_1.funcDivide],
+    ['Remainder', Number_js_1.funcRemainder],
+    ['Modulo', Number_js_1.funcModulo],
+    ['Power', Number_js_1.funcPower],
+    ['Root', Number_js_1.funcRoot],
+    ['Negate', Number_js_1.funcNegate],
+    ['Cast', Number_js_1.funcCast],
+    // Object
+    ['Entries', Object_js_1.funcEntries],
+    ['Keys', Object_js_1.funcKeys],
+    ['Values', Object_js_1.funcValues],
+    // String
+    ['Like', String_js_1.funcLike],
+    ['Unlike', String_js_1.funcUnlike],
+    ['Contains', String_js_1.funcContains],
+    ['StartsWith', String_js_1.funcStartsWith],
+    ['EndsWith', String_js_1.funcEndsWith],
+    ['Char', String_js_1.funcChar],
+    ['CharCode', String_js_1.funcCharCode],
+    ['Trim', String_js_1.funcTrim],
+    ['TrimStart', String_js_1.funcTrimStart],
+    ['TrimEnd', String_js_1.funcTrimEnd],
+    ['LowerCase', String_js_1.funcLowerCase],
+    ['UpperCase', String_js_1.funcUpperCase],
+    ['Split', String_js_1.funcSplit],
+    // Timestamp
+    ['Year', Timestamp_js_1.funcYear],
+    ['Month', Timestamp_js_1.funcMonth],
+    ['MonthIndex', Timestamp_js_1.funcMonthIndex],
+    ['WeekdayIndex', Timestamp_js_1.funcWeekdayIndex],
+    ['Day', Timestamp_js_1.funcDay],
+    ['Hour', Timestamp_js_1.funcHour],
+    ['Minute', Timestamp_js_1.funcMinute],
+    ['Second', Timestamp_js_1.funcSecond],
+    ['Millisecond', Timestamp_js_1.funcMillisecond],
+    ['EpochTime', Timestamp_js_1.funcEpochTime],
+    // Unknown
+    ['Coalesce', Unknown_js_1.funcCoalesce],
+    ['Equal', Unknown_js_1.funcEqual],
+    ['Unequal', Unknown_js_1.funcNotEqual],
+    ['Encode', Unknown_js_1.funcEncode],
+    ['Format', Unknown_js_1.funcFormat],
+];