@bikky/replication 1.0.1

package/Expressions/Traverser.js

@@ -0,0 +1,348 @@
+import { describeObject } from "../Constants/SerialisationTypes.js";
+import { ExpressionAST } from "./Compiler/BuiltinGrammar.js";
+import { isToken } from "./Compiler/Tokenizer.js";
+import { EvaluationChain } from "./EvaluatorChain.js";
+import { ExpressionSyntaxError } from "../Constants/Errors.js";
+import { ChainType } from "./TypeRegistry/ChainTypes.js";
+import "./TypeRegistry/Primitive.js";
+import { ChainFunction, ChainProperty } from "./TypeRegistry/Accessors.js";
+import { ExpressionScopes, ValidExpressionTypes } from "./TypeRegistry/Registry.js";
+var GetTypeChain = ValidExpressionTypes.GetTypeChain;
+import { Pointer } from "../Transformers/Reference.js";
+export function OrderASTSequentially(ast) {
+    let order;
+    function RearrangeSubexpression(nodes) {
+        let params = [];
+        for (let arg of nodes) {
+            let oldOrder = order;
+            order = [];
+            RearrangeNodes(arg);
+            params.push(order);
+            order = oldOrder;
+        }
+        return params;
+    }
+    function RearrangeNodes(node) {
+        var _a;
+        if (isToken(node)) {
+            order.push({ type: "Token", node });
+            return;
+        }
+        //No support for loops yet.
+        if (ExpressionAST.IsLoopNode(node))
+            return;
+        if (ExpressionAST.IsControlFlowNode(node))
+            return;
+        if (ExpressionAST.IsCommentNode(node))
+            return;
+        if (ExpressionAST.IsPreprocessorCommandNode(node))
+            return;
+        if (ExpressionAST.IsStatementNode(node) || ExpressionAST.IsExpressionNode(node)) {
+            //Do we care? probably not.
+            // if (isToken(node.values.expression)) return;
+            RearrangeNodes(node.values.expression);
+            return;
+        }
+        if (ExpressionAST.IsArrayAccessSequenceNode(node)) {
+            RearrangeNodes(node.values.identifier);
+            for (let access of node.values.accessor) {
+                RearrangeNodes(access.values.index);
+            }
+            return;
+        }
+        //Ergh. Trying not to think about this one right now.
+        if (ExpressionAST.IsParenthetisedExpressionNode(node))
+            return;
+        if (ExpressionAST.IsBinaryExpressionNode(node)) {
+            RearrangeNodes(node.values.lhs);
+            order.push({
+                type: "Op",
+                node: node.values.operator,
+                params: RearrangeSubexpression([node.values.rhs])
+            });
+            return;
+        }
+        if (ExpressionAST.IsUnaryExpressionNode(node)) {
+            order.push({
+                type: "Op",
+                node: node.values.operator,
+                params: RearrangeSubexpression([node.values.value])
+            });
+            return;
+        }
+        if (ExpressionAST.IsAssignmentNode(node))
+            return;
+        if (ExpressionAST.IsStructNode(node))
+            return;
+        if (ExpressionAST.IsPropertySignatureNode(node))
+            return;
+        if (ExpressionAST.IsIdentifierDeclarationNode(node))
+            return;
+        if (ExpressionAST.IsFunctionDeclarationNode(node) || ExpressionAST.IsFunctionParameterNode(node))
+            return;
+        if (ExpressionAST.IsFunctionCallNode(node)) {
+            let temp = order;
+            order = [];
+            RearrangeNodes(node.values.name);
+            let function_name = order;
+            order = temp;
+            let last = function_name.pop();
+            if (!isToken(last.node)) {
+                throw new ExpressionSyntaxError(`Function call should always be preceeded by an identifier.`, last.node);
+            }
+            order.splice(order.length, 0, ...function_name, {
+                type: "Call",
+                node: last.node,
+                params: RearrangeSubexpression((_a = node.values.arguments) !== null && _a !== void 0 ? _a : [])
+            });
+            return;
+        }
+        if (ExpressionAST.IsCastNode(node) || ExpressionAST.IsForceCastNode(node)) {
+            RearrangeNodes(node.values.expression);
+            order.push({
+                type: ExpressionAST.IsForceCastNode(node) ? "ForceCast" : "Cast",
+                node: node.values.castType
+            });
+            return;
+        }
+        if (ExpressionAST.IsMemberAccessNode(node)) {
+            RearrangeNodes(node.values.context);
+            RearrangeNodes(node.values.memberName);
+        }
+    }
+    let orderedNodes = [];
+    for (let statement of ast.values.lines) {
+        order = [];
+        RearrangeNodes(statement);
+        orderedNodes.push(order);
+    }
+    return orderedNodes;
+}
+function ToChainType(type) {
+    if (type instanceof ChainType) {
+        return type;
+    }
+    return ValidExpressionTypes.GetTypeChain(type);
+}
+function TypesMatchRequirements(version, typesToCheck, requirements) {
+    let misMatches = [];
+    // Resolve aliases.
+    checkEachType: for (let checkType of typesToCheck) {
+        let checkChain = ToChainType(checkType);
+        if (!checkChain) {
+            throw new Error(`Error, unknown type ${describeObject(checkType)}. ${describeObject(checkType)} was used as a type to check against requirements.`);
+        }
+        let [types, style] = checkChain.getOutputTypes();
+        for (let requirement of requirements) {
+            if (checkChain == requirement) {
+                continue checkEachType;
+            }
+            if (types.some((e) => requirement.isAssignableCompile(version, e, style))) {
+                continue checkEachType;
+            }
+        }
+        misMatches.push(checkChain);
+    }
+    return misMatches;
+}
+function OrderNodesToTree(statement, config) {
+    let startType = config.startType;
+    let [globalChain, scopeChain] = ExpressionScopes.GetScopeChain(startType);
+    if (!scopeChain) {
+        throw new Error(`Error, tried to start expression from type `
+            + `${describeObject(config.startType)} but ${describeObject(config.startType)} doesn't exist in the parser's lexicon.`);
+    }
+    let lastContext = [scopeChain];
+    if (typeof lastContext[0] === "undefined") {
+        throw new Error(`Error, unknown enclosing type ${describeObject(startType)}.`
+            + ` ${describeObject(startType)} was used as the location from which to start `
+            + `resolving the expression, but ${describeObject(startType)} hasn't been added `
+            + `to the lexicon as an enclosing type.`);
+    }
+    let desiredOutputType = config.outputTypes.map((e) => {
+        let val = GetTypeChain(e);
+        if (!val) {
+            throw new Error(`Error, unknown type ${describeObject(e)}. ${describeObject(e)} was used as the`
+                + ` expected output type, but ${describeObject(e)} hasn't been added to the lexicon as a type.`);
+        }
+        if (config.outputDict) {
+            val = ValidExpressionTypes.GetDictType([val]);
+        }
+        if (config.outputMap) {
+            val = ValidExpressionTypes.GetMapType([val]);
+        }
+        if (config.outputArray == 1) {
+            val = ValidExpressionTypes.GetArrayType([val]);
+        }
+        if (config.outputArray == 2) {
+            val = ValidExpressionTypes.GetArrayType([ValidExpressionTypes.GetArrayType([val])]);
+        }
+        return val;
+    });
+    let isDataOnlyTime = config.duringLoad;
+    ///       O   O   O
+    ///     / | / | /  \
+    /// - O   X   X     O - O (output)
+    ///    \ | \ | \  /
+    ///      O  O   O
+    let finalTypes = new Set();
+    function FinishBranch(lastStep, types) {
+        //verify finished type.
+        let missMatches = TypesMatchRequirements(config.version, types, desiredOutputType);
+        if (missMatches.length !== 0) {
+            let outputName = types.length == 1 ? types[0].debugName : "(" + types.map((e) => e.debugName).join(" | ") + ")";
+            let missMatchesName = missMatches.length == 1 ? missMatches[0].debugName : "(" + missMatches.map((e) => e.debugName).join(" | ") + ")";
+            throw new Error(`Error, expression produced type ${outputName} but ${missMatchesName} isn't`
+                + ` assignable to desired types: ${desiredOutputType.map((e) => e.debugName).join(", ")}.`);
+        }
+        types.forEach((e) => finalTypes.add(e instanceof ChainType ? e : GetTypeChain(e)));
+        if (lastStep.expression instanceof ChainProperty) {
+            lastStep.set = lastStep.expression.settable;
+        }
+    }
+    function ParseRemainingAST(lastStep, type, statement, isBase = false) {
+        if (!(type instanceof ChainType)) {
+            type = GetTypeChain(type);
+            if (!type) {
+                throw new ExpressionSyntaxError(`Error, unknown type ${describeObject(type)}.`, statement[0].node);
+            }
+        }
+        let [prep, ...rest] = statement;
+        switch (prep.type) {
+            case "Token": {
+                //Step 1: Lookup the property on the current type.
+                let accessor;
+                if (config.duringLoad) {
+                    accessor = type.getData(config.version, prep.node.data, prep.node, isBase ? [scopeChain, globalChain] : []);
+                }
+                else {
+                    accessor = type.getLive(config.version, prep.node.data, prep.node, isBase ? [scopeChain, globalChain] : []);
+                }
+                if (accessor instanceof ChainFunction && accessor.parameters.length > 0) {
+                    throw new ExpressionSyntaxError(`Error, tried to access property ${prep.node.data}`
+                        + ` but ${prep.node.data} is a function on type ${type.debugName}.`, prep.node);
+                }
+                let step = {
+                    node: type,
+                    expression: accessor,
+                    eval: accessor.evaluate
+                };
+                lastStep.next.push(step);
+                if (rest.length > 0) {
+                    step.next = [];
+                    for (let rType of accessor.resultTypes) {
+                        ParseRemainingAST(step, rType, rest);
+                    }
+                }
+                else {
+                    FinishBranch(step, accessor.resultTypes);
+                }
+                break;
+            }
+            case "Call": {
+                if (config.duringLoad) {
+                    throw new ExpressionSyntaxError(`Error, cannot call functions during load time.`, prep.node);
+                }
+                else {
+                    //Get function.
+                    let accessor = type.getLive(config.version, prep.node.data, prep.node, isBase ? [scopeChain, globalChain] : []);
+                    if (!(accessor instanceof ChainFunction)) {
+                        throw new ExpressionSyntaxError(`Error, ${prep.node.data} is not a function.`, prep.node);
+                    }
+                    //Get parameters.
+                    let params = prep.params.map((e) => OrderNodesToTree(e, config));
+                    //Verify parameters.
+                    if (params.length < accessor.parameters.length) {
+                        throw new ExpressionSyntaxError(`Error, expected ${accessor.parameters.length} arguments,`
+                            + ` instead got ${params.length} arguments.`, prep.node);
+                    }
+                    for (let i = 0; i < accessor.parameters.length; i++) {
+                        if (!TypesMatchRequirements(config.version, params[i].outputTypes, accessor.parameters[i])) {
+                            throw new ExpressionSyntaxError(`Error, the ${i + 1}-nth parameter is of type ${params[i].outputTypes.map((e) => describeObject(e)).join(", ")}`
+                                + ` but should be ${accessor.parameters[i].map((e) => describeObject(e)).join(", ")}.`, prep.node);
+                        }
+                    }
+                    let step = {
+                        node: type,
+                        expression: accessor,
+                        eval: (scope) => {
+                            return accessor.evaluate(scope, ...params.map((e) => e.get(scope)));
+                        }
+                    };
+                    lastStep.next.push(step);
+                    if (rest.length > 0) {
+                        step.next = [];
+                        for (let rType of accessor.resultTypes) {
+                            ParseRemainingAST(step, rType, rest);
+                        }
+                    }
+                    else {
+                        FinishBranch(step, accessor.resultTypes);
+                    }
+                }
+                break;
+            }
+            case "Op": {
+                throw new ExpressionSyntaxError(`Error, cannot use operators during load time.`, prep.node);
+            }
+            case "Cast":
+            case "ForceCast": {
+                let newType = GetTypeChain(prep.node.data);
+                let possibleTypes = lastStep.expression.resultTypes;
+                let oneValidType = false;
+                //Cast requires a type matches at compile time. Force cast doesn't (that's what makes it 'force').
+                if (prep.type == "Cast") {
+                    // Cast needs only one matching type.
+                    for (let type of possibleTypes) {
+                        let chain = ToChainType(type);
+                        if (!chain) {
+                            throw new ExpressionSyntaxError(`Error, unknown type ${describeObject(type)}.`, statement[0].node);
+                        }
+                        if (newType.isCastableCompile(config.version, chain)) {
+                            oneValidType = true;
+                            break;
+                        }
+                    }
+                    if (!oneValidType) {
+                        throw new ExpressionSyntaxError(`Error, cannot cast from ${lastStep.node.debugName} to ${newType.debugName}.`, prep.node);
+                    }
+                }
+                let step = {
+                    node: newType,
+                    //a bit of a hack, but allows setting casted expression.
+                    expression: lastStep.expression,
+                    eval: (scope) => {
+                        let rawVal = scope.self instanceof Pointer ? scope.self.valOrNull : scope.self;
+                        if (!newType.isCastableLive(config.version, rawVal)) {
+                            throw new Error(`Error, cannot cast from ${describeObject(rawVal)} to ${newType.debugName}.`);
+                        }
+                        return scope.self;
+                    }
+                };
+                lastStep.next.push(step);
+                if (rest.length > 0) {
+                    step.next = [];
+                    ParseRemainingAST(step, newType, rest);
+                }
+                else {
+                    FinishBranch(step, [newType]);
+                }
+                break;
+            }
+        }
+    }
+    let fakeStep = {
+        node: scopeChain,
+        next: []
+    };
+    ParseRemainingAST(fakeStep, scopeChain, statement, true);
+    let resultTypes = Array.from(finalTypes);
+    return new EvaluationChain(fakeStep.next[0], resultTypes, isDataOnlyTime, config);
+}
+export function OrderedNodeSequencesToTrees(orderedNodes, config) {
+    let allExpressions = [];
+    for (let statement of orderedNodes) {
+        allExpressions.push(OrderNodesToTree(statement, config));
+    }
+    return allExpressions;
+}

package/Expressions/TypeRegistry/Accessors.d.ts

@@ -0,0 +1,26 @@
+import { TraversalScope } from "./Types.js";
+import { ChainType } from "./ChainTypes.js";
+export declare abstract class ChainAccessor {
+    propName: string;
+    evalScope: Exclude<keyof TraversalScope, "version" | "data">;
+    resultTypes: any[];
+    evaluate(scope: TraversalScope): any;
+    settable?(scope: TraversalScope, value: any): boolean;
+    constructor(propName: string, evalScope: ChainAccessor["evalScope"], resultTypes: any[]);
+}
+export declare class ChainFunction extends ChainAccessor {
+    parameters: any[][];
+    constructor(propName: string, evalScope: ChainFunction["evalScope"], resultTypes: ChainType[], parameters: ChainType[][]);
+    evaluate(scope: TraversalScope, ...args: any[]): any;
+}
+export declare class ChainProperty extends ChainAccessor {
+    settable(scope: TraversalScope, value: any): any;
+}
+export declare class ChainMap extends ChainAccessor {
+    evaluate(scope: TraversalScope): any;
+    settable(scope: TraversalScope, value: any): any;
+}
+export declare class ChainOverride extends ChainAccessor {
+    parameters: ChainType[][];
+    constructor(propName: string, evalScope: ChainFunction["evalScope"], resultTypes: any[], getter: (scope: TraversalScope) => any, setter?: (scope: TraversalScope, value: any) => any);
+}

package/Expressions/TypeRegistry/Accessors.js

@@ -0,0 +1,58 @@
+import { Pointer } from "../../Transformers/Reference.js";
+export class ChainAccessor {
+    evaluate(scope) {
+        if (scope[this.evalScope] instanceof Pointer) {
+            return scope[this.evalScope].val[this.propName];
+        }
+        return scope[this.evalScope][this.propName];
+    }
+    constructor(propName, evalScope, resultTypes) {
+        this.resultTypes = [];
+        this.propName = propName;
+        this.evalScope = evalScope;
+        this.resultTypes = resultTypes;
+        this.evaluate = this.evaluate.bind(this);
+        if (this.settable)
+            this.settable = this.settable.bind(this);
+    }
+}
+export class ChainFunction extends ChainAccessor {
+    constructor(propName, evalScope, resultTypes, parameters) {
+        super(propName, evalScope, resultTypes);
+        this.parameters = [];
+        this.parameters = parameters;
+    }
+    evaluate(scope, ...args) {
+        if (scope[this.evalScope] instanceof Pointer) {
+            return scope[this.evalScope].val[this.propName](...args);
+        }
+        return scope[this.evalScope][this.propName](...args);
+    }
+}
+export class ChainProperty extends ChainAccessor {
+    settable(scope, value) {
+        if (scope[this.evalScope] instanceof Pointer) {
+            return scope[this.evalScope].val[this.propName] = value;
+        }
+        return scope[this.evalScope][this.propName] = value;
+    }
+}
+export class ChainMap extends ChainAccessor {
+    evaluate(scope) {
+        return scope[this.evalScope].get(this.propName);
+    }
+    settable(scope, value) {
+        scope[this.evalScope].set(this.propName, value);
+        return value;
+    }
+}
+export class ChainOverride extends ChainAccessor {
+    constructor(propName, evalScope, resultTypes, getter, setter) {
+        super(propName, evalScope, resultTypes);
+        this.parameters = [];
+        this.evaluate = getter;
+        if (setter) {
+            this.settable = setter;
+        }
+    }
+}

package/Expressions/TypeRegistry/ChainCollections.d.ts

@@ -0,0 +1,51 @@
+import { Versions } from "../../Constants/Versions.js";
+import { ChainMap, ChainProperty } from "./Accessors.js";
+import { ChainType } from "./ChainTypes.js";
+import { ExpressionGrammar } from "../Compiler/ExpressionGrammar.js";
+import Node = ExpressionGrammar.Node;
+import { ErrorStack } from "../../Constants/Errors.js";
+export declare class DictType extends ChainType {
+    types: ChainType[];
+    constructor(name: string, types: ChainType[]);
+    static generateName(outputTypes: ChainType[]): string;
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    getOwnOutputTypes(): any[];
+    isAssignableCompile(type: any): boolean;
+    isAssignableLive(version: Versions, value: any): boolean;
+    isAssignableData(version: Versions, value: any): boolean;
+    isCastableCompile(type: any): boolean;
+    isCastableLive(version: Versions, value: any): boolean;
+    isCastableData(version: Versions, value: any): boolean;
+    getLive(version: Versions, prop: string, node: Node, parents?: ChainType[]): ChainProperty;
+    getData(version: Versions, prop: string, node: Node, parents?: ChainType[]): ChainProperty;
+}
+export declare class MapType extends ChainType {
+    types: ChainType[];
+    constructor(name: string, types: ChainType[]);
+    static generateName(outputTypes: ChainType[]): string;
+    getOwnOutputTypes(): any[];
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    isAssignableCompile(type: any): boolean;
+    isCastableCompile(type: any): boolean;
+    isAssignableLive(version: Versions, value: any): value is Map<any, any>;
+    isAssignableData(version: Versions, value: any): boolean;
+    isCastableLive(version: Versions, value: any): value is Map<any, any>;
+    isCastableData(version: Versions, value: any): boolean;
+    getLive(version: Versions, prop: string, node: Node, parent?: ChainType[]): ChainMap;
+    getData(version: Versions, prop: string, node: Node, parent?: ChainType[]): ChainMap;
+}
+export declare class ArrayType extends ChainType {
+    types: ChainType[];
+    constructor(name: string, types: ChainType[]);
+    static generateName(outputTypes: ChainType[]): string;
+    getOwnOutputTypes(): any[];
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    isAssignableCompile(type: any): boolean;
+    isAssignableLive(version: Versions, value: any): boolean;
+    isAssignableData(version: Versions, value: any, stack: ErrorStack): boolean;
+    isCastableCompile(type: any): boolean;
+    isCastableLive(version: Versions, value: any): boolean;
+    isCastableData(version: Versions, value: any): boolean;
+    getLive(version: Versions, prop: string, node: Node, parents?: ChainType[]): ChainProperty;
+    getData(version: Versions, prop: string, node: Node, parents?: ChainType[]): ChainProperty;
+}

package/Expressions/TypeRegistry/ChainCollections.js

@@ -0,0 +1,134 @@
+import { ChainMap, ChainProperty } from "./Accessors.js";
+import { ChainType } from "./ChainTypes.js";
+import { isPrimitiveType, primitiveTypeName } from "../../Constants/SerialisationTypes.js";
+export class DictType extends ChainType {
+    constructor(name, types) {
+        super(name);
+        this.types = [];
+        this.types = types;
+    }
+    static generateName(outputTypes) {
+        return "{[string]: " + outputTypes.map(x => x.debugName).join(" | ") + "}";
+    }
+    getOwnOutputStyle() {
+        return "Dict";
+    }
+    getOwnOutputTypes() {
+        return ChainType.ToRawTypes(this.types);
+    }
+    isAssignableCompile(type) {
+        return type === this.debugName;
+    }
+    isAssignableLive(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    isAssignableData(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    isCastableCompile(type) {
+        return type === this.debugName;
+    }
+    isCastableLive(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    isCastableData(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    getLive(version, prop, node, parents) {
+        return new ChainProperty(prop, "self", this.types);
+    }
+    getData(version, prop, node, parents) {
+        return new ChainProperty(prop, "self", this.types);
+    }
+}
+export class MapType extends ChainType {
+    constructor(name, types) {
+        super(name);
+        this.types = [];
+        this.types = types;
+    }
+    static generateName(outputTypes) {
+        return "Map<string," + outputTypes.map(x => x.debugName).join(" | ") + ">";
+    }
+    getOwnOutputTypes() {
+        return ChainType.ToRawTypes(this.types);
+    }
+    getOwnOutputStyle() {
+        return "Map";
+    }
+    isAssignableCompile(type) {
+        return type === this.debugName;
+    }
+    isCastableCompile(type) {
+        return type === this.debugName;
+    }
+    isAssignableLive(version, value) {
+        return value instanceof Map;
+    }
+    isAssignableData(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    isCastableLive(version, value) {
+        return value instanceof Map;
+    }
+    isCastableData(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    getLive(version, prop, node, parent) {
+        return new ChainMap(prop, "self", this.types);
+    }
+    getData(version, prop, node, parent) {
+        return new ChainMap(prop, "self", this.types);
+    }
+}
+export class ArrayType extends ChainType {
+    constructor(name, types) {
+        super(name);
+        this.types = [];
+        this.types = types;
+    }
+    static generateName(outputTypes) {
+        if (outputTypes.length == 1) {
+            if (isPrimitiveType(outputTypes[0])) {
+                return primitiveTypeName(outputTypes[0]) + "[]";
+            }
+            return outputTypes[0].debugName + "[]";
+        }
+        return "(" + outputTypes.map(x => {
+            if (isPrimitiveType(x)) {
+                return primitiveTypeName(x) + "[]";
+            }
+            return x.debugName;
+        }).join(" | ") + ")[]";
+    }
+    getOwnOutputTypes() {
+        return ChainType.ToRawTypes(this.types);
+    }
+    getOwnOutputStyle() {
+        return this.types[0] instanceof ArrayType ? "Array2" : "Array";
+    }
+    isAssignableCompile(type) {
+        return type === this.debugName;
+    }
+    isAssignableLive(version, value) {
+        return Array.isArray(value) && value.every(x => this.types.some(t => t.isAssignableLive(version, x)));
+    }
+    isAssignableData(version, value, stack) {
+        return Array.isArray(value) && value.every(x => this.types.some(t => t.isAssignableData(version, x, stack)));
+    }
+    isCastableCompile(type) {
+        return type === this.debugName;
+    }
+    isCastableLive(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    isCastableData(version, value) {
+        return value instanceof Object && value.__proto__ === Object.prototype;
+    }
+    getLive(version, prop, node, parents) {
+        return new ChainProperty(prop, "self", this.types);
+    }
+    getData(version, prop, node, parents) {
+        return new ChainProperty(prop, "self", this.types);
+    }
+}

package/Expressions/TypeRegistry/ChainTypes.d.ts

@@ -0,0 +1,23 @@
+import { ExpressionGrammar } from "../Compiler/ExpressionGrammar.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+import Node = ExpressionGrammar.Node;
+import { ChainAccessor } from "./Accessors.js";
+import { Versions } from "../../Constants/Versions.js";
+export declare abstract class ChainType {
+    debugName: string;
+    constructor(debugName: string);
+    abstract getOwnOutputTypes(): any[];
+    abstract getOwnOutputStyle(): "Single" | "Array" | "Array2" | "Map" | "Dict";
+    static ToRawTypes: (types: any[]) => any[];
+    getOutputTypes(): [any[], ReturnType<ChainType["getOwnOutputStyle"]>];
+    checkContextScopes(version: Versions, prop: string, node: ExpressionGrammar.Node, contexts?: ChainType[]): ChainAccessor | never;
+    checkContextsData(version: Versions, prop: string, node: ExpressionGrammar.Node, parents?: ChainType[]): ChainAccessor | never;
+    abstract isAssignableCompile(version: Versions, type: any, style: ReturnType<ChainType["getOwnOutputStyle"]>): boolean;
+    abstract isAssignableLive(version: Versions, value: any): boolean;
+    abstract isAssignableData(version: Versions, value: any, stack: ErrorStack): boolean;
+    abstract isCastableCompile(version: Versions, type: any): boolean;
+    abstract isCastableLive(version: Versions, value: any): boolean;
+    abstract isCastableData(version: Versions, value: any, stack: ErrorStack): boolean;
+    abstract getLive(version: Versions, prop: string, node: Node, parents?: ChainType[]): ChainAccessor;
+    abstract getData(version: Versions, prop: string, node: Node, parents?: ChainType[]): ChainAccessor;
+}