affinirum 1.0.0

package/dst/constant/Timestamp.d.ts

@@ -0,0 +1,20 @@
+import { Constant } from '../Constant.js';
+export declare const encodeTimestamp: (value: Date, encoding?: "int64" | "int64le") => ArrayBuffer;
+export declare const decodeTimestamp: (value: ArrayBuffer, encoding?: "int64" | "int64le", byteOffset?: bigint) => Date;
+export declare const formatTimestamp: (value: Date, radix?: number) => string;
+export declare const funcYear: Constant;
+export declare const funcMonth: Constant;
+export declare const funcMonthIndex: Constant;
+export declare const funcWeekdayIndex: Constant;
+export declare const funcDay: Constant;
+export declare const funcHour: Constant;
+export declare const funcMinute: Constant;
+export declare const funcSecond: Constant;
+export declare const funcMillisecond: Constant;
+export declare const funcEpochTime: Constant;
+export declare const constTimestamp: {
+    Now: Constant;
+    Epoch: Constant;
+    Decode: Constant;
+    Parse: Constant;
+};

package/dst/constant/Timestamp.js

@@ -0,0 +1,50 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+const typeTimestampPart = Type.functionType(Type.Integer, [Type.Timestamp, Type.OptionalBoolean]);
+export const encodeTimestamp = (value, encoding = 'int64') => {
+    const buf = new ArrayBuffer(8);
+    const dv = new DataView(buf);
+    dv.setBigInt64(0, BigInt(value.getTime()), encoding === 'int64le');
+    return buf;
+};
+export const decodeTimestamp = (value, encoding = 'int64', byteOffset) => new Date(Number(new DataView(value).getBigInt64(byteOffset == null ? 0 : Number(byteOffset), encoding === 'int64le')));
+export const formatTimestamp = (value, radix) => {
+    const str = value.toISOString();
+    switch (radix) {
+        case 1: return str.slice(0, 4);
+        case 2: return str.slice(5, 7);
+        case 3: return str.slice(8, 10);
+        case 4: return str.slice(11, 13);
+        case 5: return str.slice(14, 16);
+        case 6: return str.slice(17, 19);
+        case 7: return str.slice(20, 23);
+        default: return str;
+    }
+};
+const parseTimestamp = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    const date = new Date(value);
+    return isNaN(date.getTime()) ? undefined : date;
+};
+const funcNow = new Constant(() => new Date(), Type.functionType(Type.Timestamp, []), false);
+export const funcYear = new Constant((value, utc = false) => BigInt(utc ? value.getUTCFullYear() : value.getFullYear()), typeTimestampPart);
+export const funcMonth = new Constant((value, utc = false) => BigInt(1 + (utc ? value.getUTCMonth() : value.getMonth())), typeTimestampPart);
+export const funcMonthIndex = new Constant((value, utc = false) => BigInt(utc ? value.getUTCMonth() : value.getMonth()), typeTimestampPart);
+export const funcWeekdayIndex = new Constant((value, utc = false) => BigInt(utc ? value.getUTCDay() : value.getDay()), typeTimestampPart);
+export const funcDay = new Constant((value, utc = false) => BigInt(utc ? value.getUTCDate() : value.getDate()), typeTimestampPart);
+export const funcHour = new Constant((value, utc = false) => BigInt(utc ? value.getUTCHours() : value.getHours()), typeTimestampPart);
+export const funcMinute = new Constant((value, utc = false) => BigInt(utc ? value.getUTCMinutes() : value.getMinutes()), typeTimestampPart);
+export const funcSecond = new Constant((value, utc = false) => BigInt(utc ? value.getUTCSeconds() : value.getSeconds()), typeTimestampPart);
+export const funcMillisecond = new Constant((value, utc = false) => BigInt(utc ? value.getUTCMilliseconds() : value.getMilliseconds()), typeTimestampPart);
+export const funcEpochTime = new Constant((value, epoch = new Date(0)) => BigInt.asIntN(64, BigInt(value.getTime() - epoch.getTime())), Type.functionType(Type.Integer, [Type.Timestamp, Type.OptionalTimestamp]));
+const funcEpochTimestamp = new Constant((value, epoch = new Date(0)) => new Date(Number(value) + epoch.getTime()), Type.functionType(Type.Timestamp, [Type.Number, Type.OptionalTimestamp]));
+const funcDecodeTimestamp = new Constant((value, encoding = 'int64', byteOffset) => decodeTimestamp(value, encoding, byteOffset), Type.functionType(Type.OptionalTimestamp, [Type.Buffer, Type.OptionalString, Type.OptionalInteger]));
+const funcParseTimestamp = new Constant((value) => parseTimestamp(value), Type.functionType(Type.OptionalTimestamp, [Type.String]));
+export const constTimestamp = {
+    Now: funcNow,
+    Epoch: funcEpochTimestamp,
+    Decode: funcDecodeTimestamp,
+    Parse: funcParseTimestamp,
+};

package/dst/constant/Unknown.d.ts

@@ -0,0 +1,10 @@
+import { Constant } from '../Constant.js';
+import { Value } from '../Value.js';
+export declare const equate: (value1: Value, value2: Value) => boolean;
+export declare const encode: (value: Value, encoding?: "float32" | "float32le" | "float64" | "float64le" | "int8" | "int16" | "int16le" | "int32" | "int32le" | "int64" | "int64le" | "uint8" | "uint16" | "uint16le" | "uint32" | "uint32le" | "uint64" | "uint64le" | "utf8" | "ucs2" | "ucs2le") => ArrayBuffer;
+export declare const format: (value: Value, radix?: number, separator?: string) => string;
+export declare const funcCoalesce: Constant;
+export declare const funcEqual: Constant;
+export declare const funcNotEqual: Constant;
+export declare const funcEncode: Constant;
+export declare const funcFormat: Constant;

package/dst/constant/Unknown.js

@@ -0,0 +1,95 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+import { encodeFloat, formatFloat } from './Float.js';
+import { encodeInteger } from './Integer.js';
+import { concatBuffers, equateBuffers, formatBuffer } from './Buffer.js';
+import { encodeString } from './String.js';
+import { encodeTimestamp, formatTimestamp } from './Timestamp.js';
+export const equate = (value1, value2) => {
+    if (value1 == null || value2 == null) {
+        return value1 == value2;
+    }
+    if (typeof value1 !== typeof value2) {
+        if (typeof value1 === 'number' && typeof value2 === 'bigint') {
+            return value1 === Number(value2);
+        }
+        if (typeof value1 === 'bigint' && typeof value2 === 'number') {
+            return Number.isInteger(value2) && value1 === BigInt(value2);
+        }
+        return false;
+    }
+    if (typeof value1 === 'number') {
+        return isNaN(value1) && isNaN(value2) ? true : value1 === value2;
+    }
+    if (typeof value1 === 'boolean' || typeof value1 === 'bigint' || typeof value1 === 'string' || typeof value1 === 'function') {
+        return value1 === value2;
+    }
+    if (value1 instanceof Date && value2 instanceof Date) {
+        return value1.getTime() === value2.getTime();
+    }
+    if (value1 instanceof ArrayBuffer && value2 instanceof ArrayBuffer) {
+        return equateBuffers(value1, value2);
+    }
+    if (Array.isArray(value1) && Array.isArray(value2)) {
+        if (value1.length === value2.length) {
+            for (let i = 0; i < value1.length; ++i) {
+                if (!equate(value1[i], value2[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    const props = new Set([...Object.getOwnPropertyNames(value1), ...Object.getOwnPropertyNames(value2)]);
+    for (const prop of props) {
+        if (!equate(value1[prop], value2[prop])) {
+            return false;
+        }
+    }
+    return true;
+};
+export const encode = (value, encoding) => value == null
+    ? new Uint8Array(0).buffer
+    : typeof value === 'boolean'
+        ? new Uint8Array([value ? 255 : 0]).buffer
+        : value instanceof Date
+            ? encodeTimestamp(value, encoding ?? 'int64')
+            : typeof value === 'number'
+                ? encodeFloat(value, encoding ?? 'float64')
+                : typeof value === 'bigint'
+                    ? encodeInteger(value, encoding ?? 'int64')
+                    : value instanceof ArrayBuffer
+                        ? value
+                        : typeof value === 'string'
+                            ? encodeString(value, encoding ?? 'utf8')
+                            : Array.isArray(value)
+                                ? value.map((i) => encode(i, encoding)).reduce((acc, val) => concatBuffers(acc, val))
+                                : typeof value === 'object'
+                                    ? Object.entries(value).map(([k, v]) => concatBuffers(encode(k, encoding), encode(v, encoding))).reduce((acc, val) => concatBuffers(acc, val))
+                                    : new Uint8Array(0).buffer;
+export const format = (value, radix, separator = '') => value == null
+    ? 'null'
+    : typeof value === 'boolean'
+        ? value.toString()
+        : value instanceof Date
+            ? formatTimestamp(value, radix ? Number(radix) : undefined)
+            : typeof value === 'number'
+                ? formatFloat(value, radix ? Number(radix) : undefined)
+                : typeof value === 'bigint'
+                    ? value.toString(radix ? Number(radix) : undefined)
+                    : value instanceof ArrayBuffer
+                        ? formatBuffer(value)
+                        : typeof value === 'string'
+                            ? value
+                            : Array.isArray(value)
+                                ? value.map((i) => format(i, radix)).join(separator)
+                                : typeof value === 'object'
+                                    ? Object.entries(value).map(([k, v]) => `${format(k)}${radix}${format(v)}`).join(separator)
+                                    : 'function';
+const typeEquator = Type.functionType(Type.Boolean, [Type.Unknown, Type.Unknown]);
+export const funcCoalesce = new Constant((value, valueOtherwise) => value ?? valueOtherwise, Type.union(Type.functionType(Type.Unknown, [Type.Unknown, Type.Unknown]), Type.functionType(Type.OptionalFloat, [Type.OptionalFloat, Type.OptionalFloat]), Type.functionType(Type.OptionalBoolean, [Type.OptionalBoolean, Type.OptionalBoolean]), Type.functionType(Type.OptionalTimestamp, [Type.OptionalTimestamp, Type.OptionalTimestamp]), Type.functionType(Type.OptionalInteger, [Type.OptionalInteger, Type.OptionalInteger]), Type.functionType(Type.OptionalBuffer, [Type.OptionalBuffer, Type.OptionalBuffer]), Type.functionType(Type.OptionalString, [Type.OptionalString, Type.OptionalString]), Type.functionType(Type.OptionalArray, [Type.OptionalArray, Type.OptionalArray]), Type.functionType(Type.OptionalObject, [Type.OptionalObject, Type.OptionalObject]), Type.functionType(Type.OptionalFunction, [Type.OptionalFunction, Type.OptionalFunction])));
+export const funcEqual = new Constant((value1, value2) => equate(value1, value2), typeEquator);
+export const funcNotEqual = new Constant((value1, value2) => !equate(value1, value2), typeEquator);
+export const funcEncode = new Constant((value, encoding) => encode(value, encoding), Type.union(Type.functionType(Type.Buffer, [Type.Boolean]), Type.functionType(Type.Buffer, [Type.Timestamp, Type.OptionalString]), Type.functionType(Type.Buffer, [Type.Float, Type.OptionalString]), Type.functionType(Type.Buffer, [Type.Integer, Type.OptionalString]), Type.functionType(Type.Buffer, [Type.String, Type.OptionalString]), Type.functionType(Type.Buffer, [Type.Array, Type.OptionalString]), Type.functionType(Type.Buffer, [Type.Object, Type.OptionalString])));
+export const funcFormat = new Constant((value, radix, separator = '') => format(value, radix == null ? undefined : Number(radix), separator), Type.union(Type.functionType(Type.String, [Type.Boolean]), Type.functionType(Type.String, [Type.Timestamp, Type.OptionalInteger]), Type.functionType(Type.String, [Type.Float, Type.OptionalInteger]), Type.functionType(Type.String, [Type.Integer, Type.OptionalInteger]), Type.functionType(Type.String, [Type.Buffer]), Type.functionType(Type.String, [Type.Array, Type.OptionalInteger, Type.OptionalString]), Type.functionType(Type.String, [Type.Object, Type.OptionalInteger, Type.OptionalString])));

package/dst/constant/notation/AN.d.ts

@@ -0,0 +1,6 @@
+import { Constant } from '../../Constant.js';
+import { Value } from '../../Value.js';
+export declare const formatAN: (value: Value, whitespace?: string) => string;
+export declare const constAN: {
+    Format: Constant;
+};

package/dst/constant/notation/AN.js

@@ -0,0 +1,42 @@
+import { Constant } from '../../Constant.js';
+import { Type } from '../../Type.js';
+import { formatFloat } from '../Float.js';
+import { formatBuffer } from '../Buffer.js';
+export const formatAN = (value, whitespace) => {
+    if (value == null) {
+        return 'null';
+    }
+    if (typeof value === 'boolean') {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return `@${value.toISOString()}`;
+    }
+    if (typeof value === 'number') {
+        return formatFloat(value);
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (value instanceof ArrayBuffer) {
+        return `#${formatBuffer(value)}`;
+    }
+    if (typeof value === 'string') {
+        return `"${value}"`;
+    }
+    if (Array.isArray(value)) {
+        const [prefix, suffix] = whitespace ? ['\n' + whitespace, '\n'] : ['', ''];
+        const lines = value.map((i) => `${prefix}${formatAN(i, whitespace).split('\n').join(prefix)}`);
+        return `[${lines.join(',')}${suffix}]`;
+    }
+    if (typeof value === 'object') {
+        const [prefix, suffix] = whitespace ? ['\n' + whitespace, '\n'] : ['', ''];
+        const lines = Object.entries(value).map(([k, v]) => `${prefix}"${k}":${formatAN(v, whitespace).split('\n').join(prefix)}`);
+        return `[${lines.join(',')}${suffix}]`;
+    }
+    return 'function';
+};
+const funcFormatAN = new Constant((value, whitespace) => formatAN(value ?? null, whitespace), Type.functionType(Type.String, [Type.Unknown, Type.OptionalString]));
+export const constAN = {
+    Format: funcFormatAN,
+};

package/dst/constant/notation/JSON.d.ts

@@ -0,0 +1,7 @@
+import { Constant } from '../../Constant.js';
+import { Value } from 'src/Value.js';
+export declare const formatJSON: (value: Value, whitespace?: string) => string;
+export declare const constJSON: {
+    Format: Constant;
+    Parse: Constant;
+};

package/dst/constant/notation/JSON.js

@@ -0,0 +1,10 @@
+import { Constant } from '../../Constant.js';
+import { Type } from '../../Type.js';
+const typeJson = Type.union(Type.Void, Type.Boolean, Type.Timestamp, Type.Float, Type.Integer, Type.String, Type.Array, Type.Object);
+export const formatJSON = (value, whitespace) => JSON.stringify(value, (_key, value) => typeof value === 'bigint' ? value.toString() : value, whitespace);
+const funcFormatJSON = new Constant((value, whitespace) => formatJSON(value ?? null, whitespace), Type.functionType(Type.String, [typeJson, Type.OptionalString]));
+const funcParseJSON = new Constant((value) => JSON.parse(value), Type.functionType(typeJson, [Type.String]));
+export const constJSON = {
+    Format: funcFormatJSON,
+    Parse: funcParseJSON,
+};

package/dst/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Value.js';
+export * from './Type.js';
+export * from './Affinirum.js';

package/dst/index.js

@@ -0,0 +1,3 @@
+export * from './Value.js';
+export * from './Type.js';
+export * from './Affinirum.js';

package/dst/node/ArrayNode.d.ts

@@ -0,0 +1,12 @@
+import { Node } from '../Node.js';
+import { ParserFrame } from '../ParserFrame.js';
+import { Value } from '../Value.js';
+import { Type } from '../Type.js';
+export declare class ArrayNode extends Node {
+    protected _subnodes: Node[];
+    constructor(frame: ParserFrame, _subnodes: Node[]);
+    get type(): Type;
+    compile(type: Type): Node;
+    evaluate(): Value;
+    toString(ident?: number): string;
+}

package/dst/node/ArrayNode.js

@@ -0,0 +1,30 @@
+import { Node } from '../Node.js';
+import { Constant } from '../Constant.js';
+import { ConstantNode } from './ConstantNode.js';
+import { Type } from '../Type.js';
+export class ArrayNode extends Node {
+    _subnodes;
+    constructor(frame, _subnodes) {
+        super(frame);
+        this._subnodes = _subnodes;
+    }
+    get type() {
+        return Type.Array;
+    }
+    compile(type) {
+        this.reduceType(type);
+        let constant = true;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(Type.Unknown);
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant ? new ConstantNode(this, new Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        return this._subnodes.map((s) => s.evaluate());
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} array node subnodes:\n${subnodes}`;
+    }
+}

package/dst/node/BlockNode.d.ts

@@ -0,0 +1,12 @@
+import { Node } from '../Node.js';
+import { ParserFrame } from '../ParserFrame.js';
+import { Value } from '../Value.js';
+import { Type } from '../Type.js';
+export declare class BlockNode extends Node {
+    protected _subnodes: Node[];
+    constructor(frame: ParserFrame, _subnodes: Node[]);
+    get type(): Type;
+    compile(type: Type): Node;
+    evaluate(): Value;
+    toString(ident?: number): string;
+}

package/dst/node/BlockNode.js

@@ -0,0 +1,29 @@
+import { Node } from '../Node.js';
+import { Constant } from '../Constant.js';
+import { ConstantNode } from './ConstantNode.js';
+import { Type } from '../Type.js';
+export class BlockNode extends Node {
+    _subnodes;
+    constructor(frame, _subnodes) {
+        super(frame);
+        this._subnodes = _subnodes;
+    }
+    get type() {
+        return this._subnodes[this._subnodes.length - 1].type;
+    }
+    compile(type) {
+        let constant = true;
+        for (let i = 0, last = this._subnodes.length - 1; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(i < last ? Type.Unknown : type);
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant ? new ConstantNode(this, new Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        return this._subnodes.map((s) => s.evaluate())[this._subnodes.length - 1];
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} block node subnodes:\n${subnodes}`;
+    }
+}

package/dst/node/CallNode.d.ts

@@ -0,0 +1,14 @@
+import { Node } from '../Node.js';
+import { ParserFrame } from '../ParserFrame.js';
+import { Value } from '../Value.js';
+import { Type } from '../Type.js';
+export declare class CallNode extends Node {
+    protected _fnode: Node;
+    protected _subnodes: Node[];
+    protected _type: Type;
+    constructor(frame: ParserFrame, _fnode: Node, _subnodes: Node[]);
+    get type(): Type;
+    compile(type: Type): Node;
+    evaluate(): Value;
+    toString(ident?: number): string;
+}

package/dst/node/CallNode.js

@@ -0,0 +1,50 @@
+import { Node } from '../Node.js';
+import { Constant } from '../Constant.js';
+import { ConstantNode } from './ConstantNode.js';
+import { Type } from '../Type.js';
+export class CallNode extends Node {
+    _fnode;
+    _subnodes;
+    _type;
+    constructor(frame, _fnode, _subnodes) {
+        super(frame);
+        this._fnode = _fnode;
+        this._subnodes = _subnodes;
+        this._type = this._fnode.type.mergeFunctionAtom(Type.Unknown, _subnodes.length)?.retType ?? Type.Unknown;
+    }
+    get type() {
+        return this._type;
+    }
+    compile(type) {
+        this._fnode = this._fnode.compile(this._fnode.type);
+        const mergedFunctionAtom = this._fnode.type.mergeFunctionAtom(type, this._subnodes.length);
+        if (!mergedFunctionAtom) {
+            this.throwError(`function type ${this._fnode.type} mismatch with expected return type ${type} and ${this._subnodes.length} arguments`);
+        }
+        this._type = mergedFunctionAtom.retType;
+        if (this._subnodes.length < mergedFunctionAtom.minArity) {
+            this.throwError(`function requires ${mergedFunctionAtom.minArity} arguments not ${this._subnodes.length}`);
+        }
+        if (this._subnodes.length > mergedFunctionAtom.maxArity) {
+            this.throwError(`function requires ${mergedFunctionAtom.maxArity} arguments not ${this._subnodes.length}`);
+        }
+        let constant = this._fnode.constant;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(mergedFunctionAtom.argType(i));
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant ? new ConstantNode(this, new Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        const func = this._fnode.evaluate();
+        if (typeof func !== 'function') {
+            this.throwError(`function expected not ${Type.of(func)}`);
+        }
+        return func(...this._subnodes.map((node) => node.evaluate()));
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} invocation node fnode:\n${this._fnode.toString(ident + 1)}\n`
+            + `${super.toString(ident)} invocation node subnodes:\n${subnodes}`;
+    }
+}

package/dst/node/ConstantNode.d.ts

@@ -0,0 +1,15 @@
+import { Node } from '../Node.js';
+import { ParserFrame } from '../ParserFrame.js';
+import { Constant } from '../Constant.js';
+import { Value } from '../Value.js';
+import { Type } from '../Type.js';
+export declare class ConstantNode extends Node {
+    protected readonly _constant: Constant;
+    protected _subnode?: Node | undefined;
+    constructor(frame: ParserFrame, _constant: Constant, _subnode?: Node | undefined);
+    get type(): Type;
+    compile(type: Type): Node;
+    evaluate(): Value;
+    get constant(): boolean;
+    toString(ident?: number): string;
+}

package/dst/node/ConstantNode.js

@@ -0,0 +1,29 @@
+import { Node } from '../Node.js';
+export class ConstantNode extends Node {
+    _constant;
+    _subnode;
+    constructor(frame, _constant, _subnode) {
+        super(frame);
+        this._constant = _constant;
+        this._subnode = _subnode;
+    }
+    get type() {
+        return this._constant.type;
+    }
+    compile(type) {
+        this._constant.type = this.reduceType(type);
+        this._subnode = this._subnode?.compile(this._constant.type.mergeFunctionAtomRetType(type));
+        return this;
+    }
+    evaluate() {
+        return this._constant.value;
+    }
+    get constant() {
+        return !this._subnode && this._constant.deterministic;
+    }
+    toString(ident = 0) {
+        return this._subnode
+            ? `${super.toString(ident)} constant node subnode:\n${this._subnode.toString(ident + 1)}`
+            : `${super.toString(ident)} constant node`;
+    }
+}

package/dst/node/LoopNode.d.ts

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

package/dst/node/LoopNode.js

@@ -0,0 +1,30 @@
+import { Node } from '../Node.js';
+import { Type } from '../Type.js';
+export class LoopNode extends Node {
+    _cnode;
+    _subnode;
+    constructor(frame, _cnode, _subnode) {
+        super(frame);
+        this._cnode = _cnode;
+        this._subnode = _subnode;
+    }
+    get type() {
+        return this._subnode.type;
+    }
+    compile(type) {
+        this._cnode = this._cnode.compile(Type.Boolean);
+        this._subnode = this._subnode.compile(type);
+        return this;
+    }
+    evaluate() {
+        let value;
+        while (this._cnode.evaluate()) {
+            value = this._subnode.evaluate();
+        }
+        return value;
+    }
+    toString(ident = 0) {
+        return `${super.toString(ident)} loop node cnode:\n${this._cnode.toString(ident + 1)}\n`
+            + `${super.toString(ident)} subnode:\n${this._subnode.toString(ident + 1)}`;
+    }
+}

package/dst/node/ObjectNode.d.ts

@@ -0,0 +1,13 @@
+import { Node } from '../Node.js';
+import { ParserFrame } from '../ParserFrame.js';
+import { Value } from '../Value.js';
+import { Type } from '../Type.js';
+export declare class ObjectNode extends Node {
+    protected _subnodes: [Node, Node][];
+    protected _type: Type;
+    constructor(frame: ParserFrame, _subnodes: [Node, Node][]);
+    get type(): Type;
+    compile(type: Type): Node;
+    evaluate(): Value;
+    toString(ident?: number): string;
+}

package/dst/node/ObjectNode.js

@@ -0,0 +1,38 @@
+import { Node } from '../Node.js';
+import { Constant } from '../Constant.js';
+import { ConstantNode } from './ConstantNode.js';
+import { Type } from '../Type.js';
+export class ObjectNode extends Node {
+    _subnodes;
+    _type;
+    constructor(frame, _subnodes) {
+        super(frame);
+        this._subnodes = _subnodes;
+        this._type = Type.Object;
+    }
+    get type() {
+        return this._type;
+    }
+    compile(type) {
+        this._type = this.reduceType(type);
+        let constant = true;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i][0] = this._subnodes[i][0].compile(Type.String);
+            constant &&= this._subnodes[i][0].constant;
+            this._subnodes[i][1] = this._subnodes[i][1].compile(Type.Unknown);
+            constant &&= this._subnodes[i][1].constant;
+        }
+        return constant ? new ConstantNode(this, new Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        const obj = {};
+        for (const [key, value] of this._subnodes) {
+            obj[key.evaluate()] = value.evaluate();
+        }
+        return obj;
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map(([k, v]) => `${k.toString(ident + 1)}:\n${v.toString(ident + 1)}`).join('\n');
+        return `${super.toString(ident)} object node subnodes:\n${subnodes}`;
+    }
+}

package/dst/node/SwitchNode.d.ts

@@ -0,0 +1,14 @@
+import { Node } from '../Node.js';
+import { ParserFrame } from '../ParserFrame.js';
+import { Value } from '../Value.js';
+import { Type } from '../Type.js';
+export declare class SwitchNode extends Node {
+    protected _cnode: Node;
+    protected _subnodes: Node[];
+    protected _type: Type;
+    constructor(frame: ParserFrame, _cnode: Node, _subnodes: Node[]);
+    get type(): Type;
+    compile(type: Type): Node;
+    evaluate(): Value;
+    toString(ident?: number): string;
+}

package/dst/node/SwitchNode.js

@@ -0,0 +1,41 @@
+import { Node } from '../Node.js';
+import { Constant } from '../Constant.js';
+import { ConstantNode } from './ConstantNode.js';
+import { Type } from '../Type.js';
+export class SwitchNode extends Node {
+    _cnode;
+    _subnodes;
+    _type;
+    constructor(frame, _cnode, _subnodes) {
+        super(frame);
+        this._cnode = _cnode;
+        this._subnodes = _subnodes;
+        if (_subnodes.length !== 2) {
+            this.throwError(`switch requires 2 subnodes not ${_subnodes.length}`);
+        }
+        this._type = Type.union(...this._subnodes.map((i) => i.type));
+    }
+    get type() {
+        return Type.union(...this._subnodes.map((i) => i.type));
+    }
+    compile(type) {
+        this._cnode = this._cnode.compile(Type.Boolean);
+        this._type = type;
+        let constant = this._cnode.constant;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(type);
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant
+            ? new ConstantNode(this, new Constant(this.evaluate(), this.type))
+            : this;
+    }
+    evaluate() {
+        return this._cnode.evaluate() ? this._subnodes[0].evaluate() : this._subnodes[1].evaluate();
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} switch node cnode:\n${this._cnode.toString(ident + 1)}\n`
+            + `${super.toString(ident)} switch node subnodes:\n${subnodes}`;
+    }
+}

package/dst/node/VariableNode.d.ts

@@ -0,0 +1,14 @@
+import { Node } from '../Node.js';
+import { ParserFrame } from '../ParserFrame.js';
+import { Variable } from '../Variable.js';
+import { Value } from '../Value.js';
+import { Type } from '../Type.js';
+export declare class VariableNode extends Node {
+    protected readonly _variable: Variable;
+    protected _subnode?: Node | undefined;
+    constructor(frame: ParserFrame, _variable: Variable, _subnode?: Node | undefined);
+    get type(): Type;
+    compile(type: Type): Node;
+    evaluate(): Value;
+    toString(ident?: number): string;
+}