affinirum 1.0.0

package/dst/cjs/Keywords.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Keywords = void 0;
+exports.Keywords = [
+    'true', 'false',
+    'null', 'void',
+    'boolean', 'bool',
+    'timestamp', 'time',
+    'float', 'flo',
+    'integer', 'int',
+    'buffer', 'buf',
+    'string', 'str',
+    'array', 'arr',
+    'object', 'obj',
+    'function', 'func',
+    'variable', 'var',
+    'constant', 'const',
+    'while',
+    'if', 'else',
+];

package/dst/cjs/Node.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const ParserFrame_js_1 = require("./ParserFrame.js");
+class Node extends ParserFrame_js_1.ParserFrame {
+    constructor(frame) {
+        super(frame.expr, frame.start, frame.end);
+    }
+    get constant() {
+        return false;
+    }
+    reduceType(type) {
+        const compiledType = this.type.reduce(type);
+        if (compiledType) {
+            return compiledType;
+        }
+        this.throwTypeError(type);
+    }
+    throwTypeError(type) {
+        return this.throwError(`type ${this.type} mismatch with expected type ${type}`);
+    }
+    toString(ident = 0) {
+        return '  '.repeat(ident) + `[${this._start}:${this.end}] <${this.type}>`;
+    }
+}
+exports.Node = Node;

package/dst/cjs/ParserFrame.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserFrame = void 0;
+class ParserFrame {
+    _expr;
+    _start;
+    _end;
+    constructor(_expr, _start = 0, _end = 0) {
+        this._expr = _expr;
+        this._start = _start;
+        this._end = _end;
+    }
+    get expr() {
+        return this._expr;
+    }
+    get start() {
+        return this._start;
+    }
+    get end() {
+        return this._end;
+    }
+    starts(frame) {
+        if (frame) {
+            this._start = frame.start;
+            return this;
+        }
+        return new ParserFrame(this._expr, this._start, this._end);
+    }
+    ends(frame) {
+        if (frame) {
+            this._end = frame.end;
+            return this;
+        }
+        return new ParserFrame(this._expr, this._start, this._end);
+    }
+    throwError(message) {
+        const offset = this._start < 32 ? 0 : this._start - 32;
+        const length = this._end < this._start ? 0 : this._end - this._start - 1;
+        let expr = '';
+        for (let i = 0; i < this._expr.length; ++i) {
+            const c = this._expr[i];
+            expr += SPACE_SYMBOLS.includes(c) ? ' ' : c;
+        }
+        throw new Error(`error: ${message} at position ${this._start}:\n${expr.substring(offset, offset + 60)}\n` +
+            `${' '.repeat(expr.substring(offset, this._start).length)}^${'\''.repeat(length)}`);
+    }
+    toString() {
+        return `[${this._start}:${this._end}]`;
+    }
+}
+exports.ParserFrame = ParserFrame;
+const SPACE_SYMBOLS = [
+    // Whitespace and line-breaking characters
+    '\t', // tab
+    '\n', // newline
+    '\r', // carriage return
+    '\f', // form feed
+    '\v', // vertical tab
+    // Unicode spaces and separators
+    '\u00A0', // no-break space
+    '\u1680', // ogham space mark
+    '\u180E', // mongolian vowel separator
+    '\u2000', // en quad
+    '\u2001', // em quad
+    '\u2002', // en space
+    '\u2003', // em space
+    '\u2004', // three-per-em space
+    '\u2005', // four-per-em space
+    '\u2006', // six-per-em space
+    '\u2007', // figure space
+    '\u2008', // punctuation space
+    '\u2009', // thin space
+    '\u200A', // hair space
+    '\u2028', // line separator
+    '\u2029', // paragraph separator
+    '\u205F', // medium mathematical space
+    '\u3000', // ideographic space
+    // Zero-width & directional formatting characters
+    '\u200B', // zero-width space
+    '\u200C', // zero-width non-joiner
+    '\u200D', // zero-width joiner
+    '\u2060', // word joiner
+    '\uFEFF', // byte order mark
+];

package/dst/cjs/ParserState.js

@@ -0,0 +1,566 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserState = void 0;
+const Iterable_js_1 = require("./constant/Iterable.js");
+const Boolean_js_1 = require("./constant/Boolean.js");
+const Buffer_js_1 = require("./constant/Buffer.js");
+const Enumerable_js_1 = require("./constant/Enumerable.js");
+const String_js_1 = require("./constant/String.js");
+const Constant_js_1 = require("./Constant.js");
+const Number_js_1 = require("./constant/Number.js");
+const Unknown_js_1 = require("./constant/Unknown.js");
+const Type_js_1 = require("./Type.js");
+const ParserFrame_js_1 = require("./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(Boolean_js_1.funcOr);
+const funcAndAssignment = new Assignment(Boolean_js_1.funcAnd);
+const funcAddAssignment = new Assignment(Enumerable_js_1.funcAdd);
+const funcSubtractAssignment = new Assignment(Number_js_1.funcSubtract);
+const funcMultiplyAssignment = new Assignment(Number_js_1.funcMultiply);
+const funcDivideAssignment = new Assignment(Number_js_1.funcDivide);
+const funcRemainderAssignment = new Assignment(Number_js_1.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();
+class ParserState extends ParserFrame_js_1.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_js_1.Constant;
+    }
+    get isLiteral() {
+        return this._fragment instanceof Literal;
+    }
+    get isAssignment() {
+        return this._fragment instanceof Assignment;
+    }
+    get isType() {
+        return this._fragment instanceof Type_js_1.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_js_1.Type.Unknown;
+                            break;
+                        case ':':
+                            ++this._end;
+                            this._fragment = Unknown_js_1.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 = Boolean_js_1.funcOr;
+                            break;
+                    }
+                    break;
+                case '&':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcAndAssignment;
+                            break;
+                        default:
+                            this._fragment = Boolean_js_1.funcAnd;
+                            break;
+                    }
+                    break;
+                case '>':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = Number_js_1.funcGreaterOrEqual;
+                            break;
+                        default:
+                            this._fragment = Number_js_1.funcGreaterThan;
+                            break;
+                    }
+                    break;
+                case '<':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = Number_js_1.funcLessOrEqual;
+                            break;
+                        default:
+                            this._fragment = Number_js_1.funcLessThan;
+                            break;
+                    }
+                    break;
+                case '!':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = Unknown_js_1.funcNotEqual;
+                            break;
+                        default:
+                            this._fragment = Boolean_js_1.funcNot;
+                            break;
+                    }
+                    break;
+                case '=':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = Unknown_js_1.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 = Enumerable_js_1.funcAdd;
+                            break;
+                    }
+                    break;
+                case '-':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcSubtractAssignment;
+                            break;
+                        default:
+                            this._fragment = Number_js_1.funcSubtract;
+                            break;
+                    }
+                    break;
+                case '*':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcMultiplyAssignment;
+                            break;
+                        default:
+                            this._fragment = Number_js_1.funcMultiply;
+                            break;
+                    }
+                    break;
+                case '/':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcDivideAssignment;
+                            break;
+                        default:
+                            this._fragment = Number_js_1.funcDivide;
+                            break;
+                    }
+                    break;
+                case '%':
+                    switch (this._expr.charAt(this._end)) {
+                        case '=':
+                            ++this._end;
+                            this._fragment = funcRemainderAssignment;
+                            break;
+                        default:
+                            this._fragment = Number_js_1.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 = Number_js_1.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 = Iterable_js_1.funcAt;
+                            break;
+                    }
+                    break;
+                case '@':
+                    while ((0, String_js_1.isDateSymbol)(this._expr.charAt(this._end))) {
+                        ++this._end;
+                    }
+                    if ((0, String_js_1.isDateTimeSeparator)(this._expr.charAt(this._end))) {
+                        ++this._end;
+                        while ((0, String_js_1.isTimeSymbol)(this._expr.charAt(this._end))) {
+                            ++this._end;
+                        }
+                        if (this._expr.charAt(this._end) === '.') {
+                            ++this._end;
+                            while ((0, String_js_1.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 ((0, String_js_1.isHexadecimal)(this._expr.charAt(this._end))) {
+                        ++this._end;
+                    }
+                    this._fragment = new Literal((0, Buffer_js_1.parseBuffer)(this._expr.substring(this._start + 1, this._end)));
+                    break;
+                default:
+                    if ((0, String_js_1.isAlpha)(c)) {
+                        while ((0, String_js_1.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_js_1.Type.Void;
+                                break;
+                            case 'bool':
+                            case 'boolean':
+                                this._fragment = Type_js_1.Type.Boolean;
+                                break;
+                            case 'time':
+                            case 'timestamp':
+                                this._fragment = Type_js_1.Type.Timestamp;
+                                break;
+                            case 'flo':
+                            case 'float':
+                                this._fragment = Type_js_1.Type.Float;
+                                break;
+                            case 'int':
+                            case 'integer':
+                                this._fragment = Type_js_1.Type.Integer;
+                                break;
+                            case 'buf':
+                            case 'buffer':
+                                this._fragment = Type_js_1.Type.Buffer;
+                                break;
+                            case 'str':
+                            case 'string':
+                                this._fragment = Type_js_1.Type.String;
+                                break;
+                            case 'arr':
+                            case 'array':
+                                this._fragment = Type_js_1.Type.Array;
+                                break;
+                            case 'obj':
+                            case 'object':
+                                this._fragment = Type_js_1.Type.Object;
+                                break;
+                            case 'func':
+                            case 'function':
+                                this._fragment = Type_js_1.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 ((0, String_js_1.isNumeric)(c)) {
+                        let integer = true;
+                        while ((0, String_js_1.isNumeric)(this._expr.charAt(this._end))) {
+                            ++this._end;
+                        }
+                        if (this._expr.charAt(this._end) === '.') {
+                            ++this._end;
+                            if ((0, String_js_1.isNumeric)(this._expr.charAt(this._end))) {
+                                ++this._end;
+                                while ((0, String_js_1.isNumeric)(this._expr.charAt(this._end))) {
+                                    ++this._end;
+                                }
+                                integer = false;
+                            }
+                            else {
+                                --this._end;
+                            }
+                        }
+                        if (this._expr.charAt(this._end) === 'e') {
+                            ++this._end;
+                            if ((0, String_js_1.isNumeric)(this._expr.charAt(this._end)) || (0, String_js_1.isSign)(this._expr.charAt(this._end))) {
+                                ++this._end;
+                                while ((0, String_js_1.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 ((0, String_js_1.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;
+    }
+}
+exports.ParserState = ParserState;