affinirum 1.0.0

package/dst/ParserState.js

@@ -0,0 +1,562 @@
+import { funcAt } from './constant/Iterable.js';
+import { funcOr, funcAnd, funcNot } from './constant/Boolean.js';
+import { parseBuffer } from './constant/Buffer.js';
+import { funcAdd } from './constant/Enumerable.js';
+import { isSign, isAlpha, isNumeric, isAlphanumeric, isHexadecimal, isQuotation, isDateSymbol, isTimeSymbol, isDateTimeSeparator } from './constant/String.js';
+import { Constant } from './Constant.js';
+import { funcGreaterThan, funcLessThan, funcGreaterOrEqual, funcLessOrEqual, funcSubtract, funcMultiply, funcDivide, funcRemainder, funcPower } from './constant/Number.js';
+import { funcCoalesce, funcEqual, funcNotEqual } from './constant/Unknown.js';
+import { Type } from './Type.js';
+import { ParserFrame } from './ParserFrame.js';
+class Literal {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+const valueTrue = new Literal(true);
+const valueFalse = new Literal(false);
+const valueNull = new Literal(undefined);
+class Assignment {
+    operator;
+    constructor(operator) {
+        this.operator = operator;
+    }
+}
+const funcAssignment = new Assignment();
+const funcOrAssignment = new Assignment(funcOr);
+const funcAndAssignment = new Assignment(funcAnd);
+const funcAddAssignment = new Assignment(funcAdd);
+const funcSubtractAssignment = new Assignment(funcSubtract);
+const funcMultiplyAssignment = new Assignment(funcMultiply);
+const funcDivideAssignment = new Assignment(funcDivide);
+const funcRemainderAssignment = new Assignment(funcRemainder);
+const symbolParenthesesOpen = Symbol();
+const symbolParenthesesClose = Symbol();
+const symbolBracketsOpen = Symbol();
+const symbolBracketsClose = Symbol();
+const symbolBracesOpen = Symbol();
+const symbolBracesClose = Symbol();
+const symbolSemicolonSeparator = Symbol();
+const symbolColonSeparator = Symbol();
+const symbolCommaSeparator = Symbol();
+const symbolTildaMark = Symbol();
+const symbolOptionalType = Symbol();
+const symbolVariadicFunction = Symbol();
+const symbolVariableDefinition = Symbol();
+const symbolConstantDefinition = Symbol();
+const symbolWhile = Symbol();
+const symbolIf = Symbol();
+const symbolElse = Symbol();
+export class ParserState extends ParserFrame {
+    _fragment;
+    constructor(expr) {
+        super(expr);
+    }
+    get literalValue() {
+        return this._fragment.value;
+    }
+    get assignmentOperator() {
+        return this._fragment.operator;
+    }
+    get operator() {
+        return this._fragment;
+    }
+    get type() {
+        return this._fragment;
+    }
+    get token() {
+        return this._fragment;
+    }
+    get isOperator() {
+        return this._fragment instanceof Constant;
+    }
+    get isLiteral() {
+        return this._fragment instanceof Literal;
+    }
+    get isAssignment() {
+        return this._fragment instanceof Assignment;
+    }
+    get isType() {
+        return this._fragment instanceof Type;
+    }
+    get isToken() {
+        return typeof this._fragment === 'string';
+    }
+    get isParenthesesOpen() {
+        return this._fragment === symbolParenthesesOpen;
+    }
+    get isParenthesesClose() {
+        return this._fragment === symbolParenthesesClose;
+    }
+    get isBracketsOpen() {
+        return this._fragment === symbolBracketsOpen;
+    }
+    get isBracketsClose() {
+        return this._fragment === symbolBracketsClose;
+    }
+    get isBracesOpen() {
+        return this._fragment === symbolBracesOpen;
+    }
+    get isBracesClose() {
+        return this._fragment === symbolBracesClose;
+    }
+    get isSemicolonSeparator() {
+        return this._fragment === symbolSemicolonSeparator;
+    }
+    get isColonSeparator() {
+        return this._fragment === symbolColonSeparator;
+    }
+    get isCommaSeparator() {
+        return this._fragment === symbolCommaSeparator;
+    }
+    get isTildaMark() {
+        return this._fragment === symbolTildaMark;
+    }
+    get isOptionalType() {
+        return this._fragment === symbolOptionalType;
+    }
+    get isVariadicFunction() {
+        return this._fragment === symbolVariadicFunction;
+    }
+    get isVariableDefinition() {
+        return this._fragment === symbolVariableDefinition;
+    }
+    get isConstantDefinition() {
+        return this._fragment === symbolConstantDefinition;
+    }
+    get isWhile() {
+        return this._fragment === symbolWhile;
+    }
+    get isIf() {
+        return this._fragment === symbolIf;
+    }
+    get isElse() {
+        return this._fragment === symbolElse;
+    }
+    get isVoid() {
+        return this._fragment == null;
+    }
+    openParentheses() {
+        if (!this.isParenthesesOpen) {
+            this.throwError('missing opening parentheses');
+        }
+        return this;
+    }
+    closeParentheses() {
+        if (!this.isParenthesesClose) {
+            this.throwError('missing closing parentheses');
+        }
+        return this;
+    }
+    openBrackets() {
+        if (!this.isBracketsOpen) {
+            this.throwError('missing opening brackets');
+        }
+        return this;
+    }
+    closeBrackets() {
+        if (!this.isBracketsClose) {
+            this.throwError('missing closing brackets');
+        }
+        return this;
+    }
+    openBraces() {
+        if (!this.isBracesOpen) {
+            this.throwError('missing opening braces');
+        }
+        return this;
+    }
+    closeBraces() {
+        if (!this.isBracesClose) {
+            this.throwError('missing closing braces');
+        }
+        return this;
+    }
+    separateByColon() {
+        if (!this.isColonSeparator) {
+            this.throwError('missing colon separator');
+        }
+        return this;
+    }
+    clone() {
+        const state = new ParserState(this._expr);
+        state._start = this._start;
+        state._end = this._end;
+        state._fragment = this._fragment;
+        return state;
+    }
+    next() {
+        this._fragment = undefined;
+        while (this._end < this._expr.length && this._fragment == null) {
+            this._start = this._end;
+            const c = this._expr.charAt(this._end);
+            ++this._end;
+            switch (c) {
+                case ' ':
+                case '\t':
+                case '\n':
+                case '\r': break;
+                case '(':
+                    this._fragment = symbolParenthesesOpen;
+                    break;
+                case ')':
+                    this._fragment = symbolParenthesesClose;
+                    break;
+                case '[':
+                    this._fragment = symbolBracketsOpen;
+                    break;
+                case ']':
+                    this._fragment = symbolBracketsClose;
+                    break;
+                case '{':
+                    this._fragment = symbolBracesOpen;
+                    break;
+                case '}':
+                    this._fragment = symbolBracesClose;
+                    break;
+                case ';':
+                    this._fragment = symbolSemicolonSeparator;
+                    break;
+                case ':':
+                    this._fragment = symbolColonSeparator;
+                    break;
+                case ',':
+                    this._fragment = symbolCommaSeparator;
+                    break;
+                case '~':
+                    this._fragment = symbolTildaMark;
+                    break;
+                case '?':
+                    switch (this._expr.charAt(this._end)) {
+                        case '?':
+                            ++this._end;
+                            this._fragment = Type.Unknown;
+                            break;
+                        case ':':
+                            ++this._end;
+                            this._fragment = funcCoalesce;
+                            break;
+                        default:
+                            this._fragment = symbolOptionalType;
+                            break;
+                    }
+                    break;
+                case '|':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcOrAssignment;
+                            break;
+                        default:
+                            this._fragment = funcOr;
+                            break;
+                    }
+                    break;
+                case '&':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcAndAssignment;
+                            break;
+                        default:
+                            this._fragment = funcAnd;
+                            break;
+                    }
+                    break;
+                case '>':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcGreaterOrEqual;
+                            break;
+                        default:
+                            this._fragment = funcGreaterThan;
+                            break;
+                    }
+                    break;
+                case '<':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcLessOrEqual;
+                            break;
+                        default:
+                            this._fragment = funcLessThan;
+                            break;
+                    }
+                    break;
+                case '!':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcNotEqual;
+                            break;
+                        default:
+                            this._fragment = funcNot;
+                            break;
+                    }
+                    break;
+                case '=':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcEqual;
+                            break;
+                        default:
+                            this._fragment = funcAssignment;
+                            break;
+                    }
+                    break;
+                case '+':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcAddAssignment;
+                            break;
+                        default:
+                            this._fragment = funcAdd;
+                            break;
+                    }
+                    break;
+                case '-':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcSubtractAssignment;
+                            break;
+                        default:
+                            this._fragment = funcSubtract;
+                            break;
+                    }
+                    break;
+                case '*':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcMultiplyAssignment;
+                            break;
+                        default:
+                            this._fragment = funcMultiply;
+                            break;
+                    }
+                    break;
+                case '/':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcDivideAssignment;
+                            break;
+                        default:
+                            this._fragment = funcDivide;
+                            break;
+                    }
+                    break;
+                case '%':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcRemainderAssignment;
+                            break;
+                        default:
+                            this._fragment = funcRemainder;
+                            break;
+                    }
+                    break;
+                case '$':
+                    switch (this._expr.charAt(this._end)) {
+                        case '$':
+                            while (this._expr.charAt(this._end) !== '' && this._expr.charAt(this._end) !== '\n') {
+                                ++this._end;
+                            }
+                            break;
+                        default:
+                            while (this._expr.charAt(this._end) !== '' && this._expr.charAt(this._end) !== c) {
+                                ++this._end;
+                            }
+                            if (this._end >= this._expr.length) {
+                                this._start = this._expr.length;
+                                throw new Error(`missing closing comment mark ${c}`);
+                            }
+                            ++this._end;
+                            break;
+                    }
+                    break;
+                case '^':
+                    this._fragment = funcPower;
+                    break;
+                case '.':
+                    switch (this._expr.charAt(this._end)) {
+                        case '.':
+                            if (this._expr.charAt(++this._end) === '.') {
+                                ++this._end;
+                                this._fragment = symbolVariadicFunction;
+                            }
+                            else {
+                                throw new Error('incomplete ellipsis ...');
+                            }
+                            break;
+                        default:
+                            this._fragment = funcAt;
+                            break;
+                    }
+                    break;
+                case '@':
+                    while (isDateSymbol(this._expr.charAt(this._end))) {
+                        ++this._end;
+                    }
+                    if (isDateTimeSeparator(this._expr.charAt(this._end))) {
+                        ++this._end;
+                        while (isTimeSymbol(this._expr.charAt(this._end))) {
+                            ++this._end;
+                        }
+                        if (this._expr.charAt(this._end) === '.') {
+                            ++this._end;
+                            while (isNumeric(this._expr.charAt(this._end))) {
+                                ++this._end;
+                            }
+                            if (this._expr.charAt(this._end) === 'Z') {
+                                ++this._end;
+                            }
+                        }
+                    }
+                    this._fragment = new Literal(new Date(this._expr.substring(this._start + 1, this._end)));
+                    break;
+                case '#':
+                    while (isHexadecimal(this._expr.charAt(this._end))) {
+                        ++this._end;
+                    }
+                    this._fragment = new Literal(parseBuffer(this._expr.substring(this._start + 1, this._end)));
+                    break;
+                default:
+                    if (isAlpha(c)) {
+                        while (isAlphanumeric(this._expr.charAt(this._end))) {
+                            ++this._end;
+                        }
+                        const token = this._expr.substring(this._start, this._end);
+                        switch (token) {
+                            case 'true':
+                                this._fragment = valueTrue;
+                                break;
+                            case 'false':
+                                this._fragment = valueFalse;
+                                break;
+                            case 'null':
+                                this._fragment = valueNull;
+                                break;
+                            case 'void':
+                                this._fragment = Type.Void;
+                                break;
+                            case 'bool':
+                            case 'boolean':
+                                this._fragment = Type.Boolean;
+                                break;
+                            case 'time':
+                            case 'timestamp':
+                                this._fragment = Type.Timestamp;
+                                break;
+                            case 'flo':
+                            case 'float':
+                                this._fragment = Type.Float;
+                                break;
+                            case 'int':
+                            case 'integer':
+                                this._fragment = Type.Integer;
+                                break;
+                            case 'buf':
+                            case 'buffer':
+                                this._fragment = Type.Buffer;
+                                break;
+                            case 'str':
+                            case 'string':
+                                this._fragment = Type.String;
+                                break;
+                            case 'arr':
+                            case 'array':
+                                this._fragment = Type.Array;
+                                break;
+                            case 'obj':
+                            case 'object':
+                                this._fragment = Type.Object;
+                                break;
+                            case 'func':
+                            case 'function':
+                                this._fragment = Type.Function;
+                                break;
+                            case 'var':
+                            case 'variable':
+                                this._fragment = symbolVariableDefinition;
+                                break;
+                            case 'const':
+                            case 'constant':
+                                this._fragment = symbolConstantDefinition;
+                                break;
+                            case 'while':
+                                this._fragment = symbolWhile;
+                                break;
+                            case 'if':
+                                this._fragment = symbolIf;
+                                break;
+                            case 'else':
+                                this._fragment = symbolElse;
+                                break;
+                            default:
+                                this._fragment = token;
+                                break;
+                        }
+                    }
+                    else if (isNumeric(c)) {
+                        let integer = true;
+                        while (isNumeric(this._expr.charAt(this._end))) {
+                            ++this._end;
+                        }
+                        if (this._expr.charAt(this._end) === '.') {
+                            ++this._end;
+                            if (isNumeric(this._expr.charAt(this._end))) {
+                                ++this._end;
+                                while (isNumeric(this._expr.charAt(this._end))) {
+                                    ++this._end;
+                                }
+                                integer = false;
+                            }
+                            else {
+                                --this._end;
+                            }
+                        }
+                        if (this._expr.charAt(this._end) === 'e') {
+                            ++this._end;
+                            if (isNumeric(this._expr.charAt(this._end)) || isSign(this._expr.charAt(this._end))) {
+                                ++this._end;
+                                while (isNumeric(this._expr.charAt(this._end))) {
+                                    ++this._end;
+                                }
+                            }
+                            integer = false;
+                        }
+                        this._fragment = integer
+                            ? new Literal(BigInt(this._expr.substring(this._start, this._end)))
+                            : new Literal(parseFloat(this._expr.substring(this._start, this._end)));
+                    }
+                    else if (isQuotation(c)) {
+                        while (this._expr.charAt(this._end) !== '' && this._expr.charAt(this._end) !== c) {
+                            ++this._end;
+                        }
+                        if (this._end >= this._expr.length) {
+                            this._start = this._expr.length;
+                            throw new Error(`missing closing quotation mark ${c}`);
+                        }
+                        this._fragment = new Literal(this._expr.substring(this._start + 1, this._end));
+                        ++this._end;
+                    }
+                    else {
+                        throw new Error(`unknown symbol ${c}`);
+                    }
+                    break;
+            }
+        }
+        if (this._end > this._expr.length) {
+            this._start = this._end = this._expr.length;
+        }
+        return this;
+    }
+}

package/dst/StaticScope.d.ts

@@ -0,0 +1,13 @@
+import { Variable } from './Variable.js';
+export declare class StaticScope {
+    protected _superscope?: StaticScope;
+    protected _subscopes: StaticScope[];
+    protected _variables: Map<string, Variable>;
+    protected _locals: Set<string>;
+    has(name: string): boolean;
+    get(name: string): Variable | undefined;
+    global(name: string, variable: Variable): StaticScope;
+    local(name: string, variable: Variable): StaticScope;
+    subscope(variables: Map<string, Variable>): StaticScope;
+    variables(): Record<string, Variable>;
+}

package/dst/StaticScope.js

@@ -0,0 +1,44 @@
+export class StaticScope {
+    _superscope;
+    _subscopes = [];
+    _variables = new Map();
+    _locals = new Set();
+    has(name) {
+        return this._variables.has(name) || Boolean(this._superscope?.has(name));
+    }
+    get(name) {
+        return this._variables.get(name) ?? this._superscope?.get(name);
+    }
+    global(name, variable) {
+        if (this._superscope) {
+            this._superscope.global(name, variable);
+        }
+        else {
+            this._variables.set(name, variable);
+        }
+        return this;
+    }
+    local(name, variable) {
+        this._variables.set(name, variable);
+        this._locals.add(name);
+        return this;
+    }
+    subscope(variables) {
+        const scope = new StaticScope();
+        scope._superscope = this;
+        this._subscopes.push(scope);
+        for (const [name, variable] of variables) {
+            scope.local(name, variable);
+        }
+        return scope;
+    }
+    variables() {
+        const variables = {};
+        for (const [name, variable] of this._variables) {
+            if (!this._locals.has(name)) {
+                variables[name] = variable;
+            }
+        }
+        return variables;
+    }
+}

package/dst/Type.d.ts

@@ -0,0 +1,72 @@
+import { Value } from './Value.js';
+import { PrimitiveAtom } from './atom/PrimitiveAtom.js';
+import { ArrayAtom } from './atom/ArrayAtom.js';
+import { ObjectAtom } from './atom/ObjectAtom.js';
+import { FunctionAtom } from './atom/FunctionAtom.js';
+export type Primitive = 'void' | 'boolean' | 'timestamp' | 'float' | 'integer' | 'buffer' | 'string';
+type Atom = PrimitiveAtom | ArrayAtom | ObjectAtom | FunctionAtom;
+export interface IType {
+    match(subtype: IType): boolean;
+    weight(): number;
+    toString(): string;
+}
+export declare class Type implements IType {
+    protected readonly _atoms: Atom[];
+    private constructor();
+    get isUnknown(): boolean;
+    get isAtom(): boolean;
+    get isOptional(): boolean;
+    get isVoid(): boolean;
+    get isBoolean(): boolean;
+    get isTimestamp(): boolean;
+    get isFloat(): boolean;
+    get isInteger(): boolean;
+    get isBuffer(): boolean;
+    get isString(): boolean;
+    get isArray(): boolean;
+    get isObject(): boolean;
+    get isFunction(): boolean;
+    get isNumeric(): boolean;
+    toOptional(): Type;
+    mergeFunctionAtomRetType(type: Type): Type;
+    mergeFunctionAtom(type: Type, argc: number): FunctionAtom | undefined;
+    reduce(mask: Type): Type | undefined;
+    match(type: IType): boolean;
+    weight(): number;
+    toString(): string;
+    static union(...types: Type[]): Type;
+    static of(value: Value): Type;
+    static isPrimitiveType(value: Value): value is string | number | bigint | boolean | void | Date | ArrayBuffer | null | undefined;
+    static arrayType(itemTypes?: Type[]): Type;
+    static objectType(propTypes?: Record<string, Type>): Type;
+    static functionType(retType?: Type, argTypes?: Type[], isVariadic?: boolean): Type;
+    static readonly Unknown: Type;
+    static readonly Void: Type;
+    static readonly Boolean: Type;
+    static readonly OptionalBoolean: Type;
+    static readonly Timestamp: Type;
+    static readonly OptionalTimestamp: Type;
+    static readonly Float: Type;
+    static readonly OptionalFloat: Type;
+    static readonly Integer: Type;
+    static readonly OptionalInteger: Type;
+    static readonly Buffer: Type;
+    static readonly OptionalBuffer: Type;
+    static readonly String: Type;
+    static readonly OptionalString: Type;
+    static readonly Array: Type;
+    static readonly OptionalArray: Type;
+    static readonly Object: Type;
+    static readonly OptionalObject: Type;
+    static readonly Function: Type;
+    static readonly OptionalFunction: Type;
+    static readonly Number: Type;
+    static readonly OptionalNumber: Type;
+    static readonly Enumerable: Type;
+    static readonly OptionalEnumerable: Type;
+    static readonly Iterable: Type;
+    static readonly OptionalIterable: Type;
+    private static _primitiveType;
+    private static _functionAtom;
+}
+export {};