affinirum 1.0.0

package/dst/Keywords.d.ts

@@ -0,0 +1 @@
+export declare const Keywords: string[];

package/dst/Keywords.js

@@ -0,0 +1,17 @@
+export const 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/Node.d.ts

@@ -0,0 +1,13 @@
+import { ParserFrame } from './ParserFrame.js';
+import { Value } from './Value.js';
+import { Type } from './Type.js';
+export declare abstract class Node extends ParserFrame {
+    constructor(frame: ParserFrame);
+    abstract type: Type;
+    abstract compile(type: Type): Node;
+    abstract evaluate(): Value;
+    get constant(): boolean;
+    protected reduceType(type: Type): Type;
+    protected throwTypeError(type: Type): never;
+    toString(ident?: number): string;
+}

package/dst/Node.js

@@ -0,0 +1,22 @@
+import { ParserFrame } from './ParserFrame.js';
+export class Node extends 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}>`;
+    }
+}

package/dst/ParserFrame.d.ts

@@ -0,0 +1,13 @@
+export declare class ParserFrame {
+    protected readonly _expr: string;
+    protected _start: number;
+    protected _end: number;
+    constructor(_expr: string, _start?: number, _end?: number);
+    get expr(): string;
+    get start(): number;
+    get end(): number;
+    starts(frame?: ParserFrame): ParserFrame;
+    ends(frame?: ParserFrame): ParserFrame;
+    throwError(message: string): never;
+    toString(): string;
+}

package/dst/ParserFrame.js

@@ -0,0 +1,80 @@
+export 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}]`;
+    }
+}
+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/ParserState.d.ts

@@ -0,0 +1,54 @@
+import { Constant } from './Constant.js';
+import { Value } from './Value.js';
+import { Type } from './Type.js';
+import { ParserFrame } from './ParserFrame.js';
+declare class Literal {
+    readonly value: Value;
+    constructor(value: Value);
+}
+declare class Assignment {
+    readonly operator?: Constant | undefined;
+    constructor(operator?: Constant | undefined);
+}
+export declare class ParserState extends ParserFrame {
+    protected _fragment: Literal | Assignment | Constant | Type | symbol | string | undefined;
+    constructor(expr: string);
+    get literalValue(): Value;
+    get assignmentOperator(): Constant | undefined;
+    get operator(): Constant;
+    get type(): Type;
+    get token(): string;
+    get isOperator(): boolean;
+    get isLiteral(): boolean;
+    get isAssignment(): boolean;
+    get isType(): boolean;
+    get isToken(): boolean;
+    get isParenthesesOpen(): boolean;
+    get isParenthesesClose(): boolean;
+    get isBracketsOpen(): boolean;
+    get isBracketsClose(): boolean;
+    get isBracesOpen(): boolean;
+    get isBracesClose(): boolean;
+    get isSemicolonSeparator(): boolean;
+    get isColonSeparator(): boolean;
+    get isCommaSeparator(): boolean;
+    get isTildaMark(): boolean;
+    get isOptionalType(): boolean;
+    get isVariadicFunction(): boolean;
+    get isVariableDefinition(): boolean;
+    get isConstantDefinition(): boolean;
+    get isWhile(): boolean;
+    get isIf(): boolean;
+    get isElse(): boolean;
+    get isVoid(): boolean;
+    openParentheses(): this;
+    closeParentheses(): this;
+    openBrackets(): this;
+    closeBrackets(): this;
+    openBraces(): this;
+    closeBraces(): this;
+    separateByColon(): this;
+    clone(): ParserState;
+    next(): ParserState;
+}
+export {};