@bikky/replication 1.0.1

package/Transformers/Progress.js

@@ -0,0 +1,429 @@
+import { ArrayMap, InstantOpenPromise, InstantPromise, SmartArray } from "@bikky/smart-collections";
+import { describeObject, isPrimitiveType } from "../Constants/SerialisationTypes.js";
+const DoneCallbackList = [];
+const ReplCallbackList = [];
+const PrimCallbackList = [];
+const AliasCallbackList = [];
+let finished = false;
+class PendingProperty {
+    constructor(params, config) {
+        this.types = [];
+        this.loaded = false;
+        this.parameters = config;
+        this.ready = new InstantOpenPromise();
+        //If it's entirely primitive types, we can just complete it immediately.
+        if (params.every((e) => isPrimitiveType(e))) {
+            this.loaded = true;
+            this.ready.complete(this.parameters);
+        }
+        else {
+            for (let param of params) {
+                if (isPrimitiveType(param)) {
+                    let promise = new InstantOpenPromise();
+                    promise.complete([param]);
+                    this.types.push(promise);
+                }
+                else {
+                    this.types.push(Progress.ReadyForParameters(param));
+                }
+            }
+            InstantPromise.all(this.types).then((types) => {
+                this.loaded = true;
+                this.ready.complete(types.flat());
+            });
+        }
+    }
+}
+/**
+ * Keeps information for a class that hasn't loaded yet.
+ */
+class PendingClass {
+    constructor(name) {
+        this.addedProperties = [];
+        this.removedProperties = [];
+        this.addedFunctions = [];
+        this.loadingComplete = false;
+        this.name = name;
+        this.replReadyToSetupProperties = new InstantOpenPromise();
+        this.replReadyToSetupProperties.then(this.setRepl.bind(this));
+        this.replComplete = new InstantOpenPromise();
+    }
+    addProperty(config) {
+        if (this.loadingComplete) {
+            console.warn(`Property ${config[0]} is being added after the class has already loaded.`
+                + ` If immediate this will be fine, but if this happens significantly delayed then some types`
+                + ` or expressions may have loaded with incorrect information.`);
+        }
+        if (typeof config[2] === "undefined") {
+            throw new Error(`Property ${config[0]} is missing a type.`);
+        }
+        let params = [...config[2].type.flatMap((e) => e.type)];
+        if (config[2].customDataType) {
+            params.push(...config[2].customDataType.flatMap((e) => e.type));
+        }
+        let property = new PendingProperty(params, config);
+        property.ready.then(async () => {
+            if (finished && this.repl) {
+                this.repl.addProperty(...property.parameters);
+            }
+            else {
+                this.addedProperties.push(property);
+            }
+        });
+    }
+    removeProperty(config) {
+        if (this.loadingComplete) {
+            console.warn(`Property ${config[0]} is being removed after the class has already loaded.`
+                + ` If immediate this will be fine, but if this happens significantly delayed then some types`
+                + ` or expressions may have loaded with incorrect information.`);
+        }
+        let params = [...config[2].type.map((e) => e.type)];
+        if (config[2].customDataType) {
+            params.push(...config[2].customDataType.map((e) => e.type));
+        }
+        let property = new PendingProperty(params, config);
+        property.ready.then(async () => {
+            if (this.repl) {
+                this.repl.removeProperty(...property.parameters);
+            }
+            else {
+                this.removedProperties.push(property);
+            }
+        });
+    }
+    addFunction(config) {
+        if (this.loadingComplete) {
+            console.warn(`Property ${config[0]} is being added after the class has already loaded.`
+                + ` If immediate this will be fine, but if this happens significantly delayed then some types`
+                + ` or expressions may have loaded with incorrect information.`);
+        }
+        let params = [...config[2].flatMap((e) => e.type), ...config[3].flatMap((c) => c.flatMap((e) => e.type))];
+        let func = new PendingProperty(params, config);
+        func.ready.then(async () => {
+            if (this.repl) {
+                this.repl.addFunction(...func.parameters);
+            }
+            else {
+                this.addedFunctions.push(func);
+            }
+        });
+    }
+    setRepl(repl) {
+        this.repl = repl;
+    }
+}
+export var Progress;
+(function (Progress) {
+    /**
+     * The classes that are currently being constructed.
+     */
+    const ConstructingClasses = new Map();
+    const FinishedClasses = new Map();
+    const PrimitiveTypes = new Map();
+    /**
+     * The classes that are currently being requested externally. May include aliases.
+     */
+    const PendingTypes = new Map();
+    /**
+     *	The types and their mapped values.
+     */
+    const ValueMappings = new ArrayMap();
+    function SetupPrimitives() {
+        PrimitiveTypes.set(Number, Number);
+        PrimitiveTypes.set("number", Number);
+        PrimitiveTypes.set("Number", Number);
+        PrimitiveTypes.set(String, String);
+        PrimitiveTypes.set("string", String);
+        PrimitiveTypes.set("String", String);
+        PrimitiveTypes.set(Boolean, Boolean);
+        PrimitiveTypes.set("boolean", Boolean);
+        PrimitiveTypes.set("Boolean", Boolean);
+        PrimitiveTypes.set(null, null);
+        PrimitiveTypes.set("null", null);
+        PrimitiveTypes.set("Null", null);
+        PrimitiveTypes.set(undefined, undefined);
+        PrimitiveTypes.set("undefined", undefined);
+        PrimitiveTypes.set("Undefined", undefined);
+    }
+    SetupPrimitives();
+    /**
+     *	The types being requested internally (by functions or properties) and the promises that are waiting for them.
+     */
+    const AwaitedMappings = new ArrayMap();
+    const Aliases = new Set();
+    const DelayedClasses = new Map();
+    const StandinClasses = new Map();
+    OnBikDelayCompleted(function MapProgressClasses(old, upd) {
+        DelayedClasses.set(old, upd);
+        StandinClasses.set(upd, old);
+    });
+    const ReplInitialisationFunctions = [];
+    function RegisterReplInitialisationFunction(callback) {
+        ReplInitialisationFunctions.push(callback);
+    }
+    Progress.RegisterReplInitialisationFunction = RegisterReplInitialisationFunction;
+    /**
+     * This function is designed to be called after every file in the game has finished loading.
+     * It completes the setup of each class, it's properties and functions, since often their types
+     * reference other classes.
+     * It's done in stages so circular references are treated fine.
+     */
+    function FinishedAllLoading() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        // First give all the available classes to ReplicableRegistry, as it'll need to be queried as everything
+        // instantiates itself.
+        for (let [alias, prim] of PrimitiveTypes.entries()) {
+            ValueMappings.push(alias, prim);
+            for (let callback of PrimCallbackList) {
+                callback(alias, prim);
+            }
+        }
+        for (let pending of ConstructingClasses.values()) {
+            if (!pending.repl) {
+                console.warn(`Class ${pending instanceof PendingClass ? pending.name : describeObject(pending)} was never completed.`);
+                continue;
+            }
+            let originalPending = StandinClasses.get(pending.repl.classConstructor);
+            for (let callback of ReplCallbackList) {
+                callback(pending.repl, originalPending);
+            }
+        }
+        // Second mark all aliases as completed along with giving them the classes that they alias to.
+        for (let alias of Aliases) {
+            alias = (_a = DelayedClasses.get(alias)) !== null && _a !== void 0 ? _a : alias;
+            let types = ValueMappings.get(alias);
+            if (!types) {
+                console.warn(`Alias ${describeObject(alias)} was never completed.`);
+                continue;
+            }
+            types = types.flatMap((e) => {
+                let delayed = DelayedClasses.get(e);
+                if (delayed) {
+                    e = delayed;
+                }
+                if (isPrimitiveType(e)) {
+                    return e;
+                }
+                //TODO: This check is probably unsafe, but it was done this way to avoid a circular import.
+                else if (typeof e == "object" && e.constructor.name == "ReplicableClass") {
+                    return e;
+                }
+                else {
+                    let repl = FinishedClasses.get(e);
+                    if (!repl) {
+                        console.error(`Unable to find class ${describeObject(e)} for alias ${describeObject(alias)}. Did you forget a @Struct or @Class decorator?`);
+                    }
+                    return repl;
+                }
+            });
+            ValueMappings.set(alias, types);
+            let originalAlias = (_b = StandinClasses.get(alias)) !== null && _b !== void 0 ? _b : alias;
+            (_c = AwaitedMappings.get(alias)) === null || _c === void 0 ? void 0 : _c.forEach((e) => e.complete(types));
+            (_d = AwaitedMappings.get(originalAlias)) === null || _d === void 0 ? void 0 : _d.forEach((e) => e.complete(types));
+            for (let callback of AliasCallbackList) {
+                callback(alias, [...types]);
+            }
+        }
+        // Third mark all classes that properties and functions are waiting for as "done" so the properties
+        // and functions instantiate correctly.
+        let values = new ArrayMap(ValueMappings);
+        for (let [id, value] of values.entries()) {
+            let updatedId = (_e = DelayedClasses.get(id)) !== null && _e !== void 0 ? _e : id;
+            let originalId = (_f = StandinClasses.get(id)) !== null && _f !== void 0 ? _f : id;
+            let updatedValue = new SmartArray(...value.flatMap((e) => { var _a; return (_a = DelayedClasses.get(e)) !== null && _a !== void 0 ? _a : e; }));
+            ValueMappings.set(updatedId, updatedValue);
+            ValueMappings.set(originalId, updatedValue);
+            if (!Aliases.has(updatedId)) {
+                for (let promise of (_g = AwaitedMappings.get(updatedId)) !== null && _g !== void 0 ? _g : []) {
+                    promise.complete(updatedValue);
+                }
+            }
+            if (!Aliases.has(originalId) && id != originalId) {
+                for (let promise of (_h = AwaitedMappings.get(originalId)) !== null && _h !== void 0 ? _h : []) {
+                    promise.complete(updatedValue);
+                }
+            }
+        }
+        // Fourth complete all properties and functions are waiting for as "done" so the properties
+        // and functions instantiate correctly.
+        // Properties depend on classes and aliases being done, so those are finished first.
+        for (let pending of ConstructingClasses.values()) {
+            if (!pending.repl) {
+                continue;
+            }
+            pending.repl.classConstructor = (_j = DelayedClasses.get(pending.repl.classConstructor)) !== null && _j !== void 0 ? _j : pending.repl.classConstructor;
+            for (let property of pending.addedProperties) {
+                if (!property.loaded) {
+                    console.warn(`Property ${pending.repl.opts.dataTypeName}.${property.parameters[0]}'s requirements never loaded.`);
+                }
+                pending.repl.addProperty(...property.parameters);
+            }
+            for (let removed of pending.removedProperties) {
+                if (!removed.loaded) {
+                    console.warn(`Property ${pending.repl.opts.dataTypeName}.${removed.parameters[0]}'s requirements never loaded.`);
+                }
+                pending.repl.removeProperty(...removed.parameters);
+            }
+            for (let func of pending.addedFunctions) {
+                if (!func.loaded) {
+                    console.warn(`Function ${pending.repl.opts.dataTypeName}.${func.parameters[0]}'s requirements never loaded.`);
+                }
+                pending.repl.addFunction(...func.parameters);
+            }
+            pending.addedProperties.length = 0;
+            pending.removedProperties.length = 0;
+            pending.addedFunctions.length = 0;
+            pending.loadingComplete = true;
+            for (let callback of ReplInitialisationFunctions) {
+                callback(pending.repl);
+            }
+            pending.replComplete.complete(pending.repl);
+        }
+        // Fifth instantiate all the aliases now that the types that they alias to have finished loading.
+        // for (let id of Aliases) {
+        // 	let value = ValueMappings.get(id) ?? [];
+        // 	for (let promise of AwaitedMappings.get(id) ?? []) {
+        // 		promise.complete(value);
+        // 	}
+        // }
+        // Finally let anything that was waiting on class creation know that the class is ready.
+        for (let [id, value] of PendingTypes.entries()) {
+            let val = (_k = ValueMappings.get(id)) !== null && _k !== void 0 ? _k : [];
+            if (val.length === 0 && DelayedClasses.has(id)) {
+                val = (_l = ValueMappings.get(DelayedClasses.get(id))) !== null && _l !== void 0 ? _l : [];
+            }
+            if (val.length === 0) {
+                console.warn(`Type ${describeObject(id)} was requested but never registered.`);
+            }
+            value.complete(val);
+        }
+        finished = true;
+        for (let callback of DoneCallbackList) {
+            callback();
+        }
+    }
+    Progress.FinishedAllLoading = FinishedAllLoading;
+    function ReadyForParameters(key) {
+        let promise = new InstantOpenPromise();
+        AwaitedMappings.push(key, promise);
+        return promise;
+    }
+    Progress.ReadyForParameters = ReadyForParameters;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    function AwaitReplicableFor(type) {
+        let promise = PendingTypes.get(type);
+        if (!promise) {
+            PendingTypes.set(type, promise = new InstantOpenPromise);
+        }
+        return new InstantPromise((res) => promise.then(res));
+    }
+    Progress.AwaitReplicableFor = AwaitReplicableFor;
+    function FinishReplicableType(type) {
+        let pending = ConstructingClasses.get(type.classConstructor);
+        if (!pending) {
+            ConstructingClasses.set(type.classConstructor, pending = new PendingClass(type.opts.typescriptTypeName));
+        }
+        pending.replReadyToSetupProperties.complete(type);
+        ValueMappings.push(type.opts.typescriptTypeName, type);
+        ValueMappings.push(type.opts.dataTypeName, type);
+        ValueMappings.push(type.classConstructor, type);
+        FinishedClasses.set(type.classConstructor, type);
+        FinishedClasses.set(type.opts.typescriptTypeName, type);
+        FinishedClasses.set(type.opts.dataTypeName, type);
+        let oldID = StandinClasses.get(type.classConstructor);
+        if (oldID) {
+            ValueMappings.push(oldID, type);
+            FinishedClasses.set(oldID, type);
+        }
+    }
+    Progress.FinishReplicableType = FinishReplicableType;
+    /**
+     * A type collection is an object or string whose value is only used to look up other values.
+     */
+    function RegisterAlias(type, value) {
+        if (finished) {
+            console.warn(`Alias ${describeObject(type)} is being added after the game`
+                + ` has already finished loading, this could cause significant issues.`);
+        }
+        Aliases.add(type);
+        if (typeof type === "object" && "name" in type) {
+            Aliases.add(type.name);
+        }
+        ValueMappings.push(type, value);
+        if (typeof type === "object" && "name" in type) {
+            ValueMappings.push(type.name, value);
+        }
+    }
+    Progress.RegisterAlias = RegisterAlias;
+    function RegisterPropertyLoad(classConstructor, property) {
+        if (finished) {
+            console.warn(`Property ${describeObject(classConstructor)}.${property[0]} is being added after the game`
+                + ` has already finished loading, this could cause significant issues.`);
+        }
+        let pending = ConstructingClasses.get(classConstructor);
+        if (!pending) {
+            ConstructingClasses.set(classConstructor, pending = new PendingClass(describeObject(classConstructor)));
+        }
+        pending.addProperty(property);
+    }
+    Progress.RegisterPropertyLoad = RegisterPropertyLoad;
+    function RegisterPropertyRemove(classConstructor, property) {
+        if (finished) {
+            console.warn(`Property ${describeObject(classConstructor)}.${property[0]} is being removed after the game`
+                + ` has already finished loading, this could cause significant issues.`);
+        }
+        let pending = ConstructingClasses.get(classConstructor);
+        if (!pending) {
+            ConstructingClasses.set(classConstructor, pending = new PendingClass(describeObject(classConstructor)));
+        }
+        pending.removeProperty(property);
+    }
+    Progress.RegisterPropertyRemove = RegisterPropertyRemove;
+    function RegisterFunctionAdd(classConstructor, property) {
+        if (finished) {
+            console.warn(`Function ${describeObject(classConstructor)}.${property[0]} is being added after the game`
+                + ` has already finished loading, this could cause significant issues.`);
+        }
+        let pending = ConstructingClasses.get(classConstructor);
+        if (!pending) {
+            ConstructingClasses.set(classConstructor, pending = new PendingClass(describeObject(classConstructor)));
+        }
+        pending.addFunction(property);
+    }
+    Progress.RegisterFunctionAdd = RegisterFunctionAdd;
+    function OnLoadFinished(callback) {
+        if (finished) {
+            callback();
+        }
+        DoneCallbackList.push(callback);
+    }
+    Progress.OnLoadFinished = OnLoadFinished;
+    function OnAnyReplicableReady(callback) {
+        ReplCallbackList.push(callback);
+    }
+    Progress.OnAnyReplicableReady = OnAnyReplicableReady;
+    function OnAnyPrimitiveReady(callback) {
+        PrimCallbackList.push(callback);
+    }
+    Progress.OnAnyPrimitiveReady = OnAnyPrimitiveReady;
+    function OnAnyAliasReady(callback) {
+        AliasCallbackList.push(callback);
+    }
+    Progress.OnAnyAliasReady = OnAnyAliasReady;
+    /**
+     * This function is only for testing!
+     */
+    function ClearCaches() {
+        if (typeof TestingMode === "boolean" && TestingMode) {
+            finished = false;
+            Aliases.clear();
+            ConstructingClasses.clear();
+            PendingTypes.clear();
+            ValueMappings.clear();
+            AwaitedMappings.clear();
+            FinishedClasses.clear();
+            SetupPrimitives();
+        }
+    }
+    Progress.ClearCaches = ClearCaches;
+})(Progress || (Progress = {}));

package/Transformers/Reference.d.ts

@@ -0,0 +1,37 @@
+import { Primitive } from "../Constants/SerialisationTypes.js";
+import type { Replicable } from "../Replicatable.js";
+import type { ReplicableClass } from "../Tracking/Class.js";
+declare const ptr: unique symbol;
+declare const registry: unique symbol;
+declare const alive: unique symbol;
+declare const ref: unique symbol;
+export declare class Pointer<T extends object> {
+    [ptr]: WeakRef<T> | undefined;
+    [alive]: boolean;
+    [registry]: FinalizationRegistry<T>;
+    [ref]: Replicable.Reference | null;
+    constructor(item?: T | null);
+    get val(): T;
+    get valOrNull(): T | null;
+    set val(value: T | null);
+    get ref(): Replicable.Reference | null;
+    set ref(refa: Replicable.Reference | null);
+}
+export declare namespace Referencer {
+    type Reference<R extends any[] = any[]> = [type: string, ...vals: R];
+    function SetDataNameLookupFunction(lookupFunc: (dataName: string) => ReplicableClass | undefined): void;
+    function SetAliasLookupFunction(lookupFunc: (dataName: string) => (ReplicableClass | Primitive)[] | undefined): void;
+    function UnregisterReference(type: ReplicableClass, pointer: Pointer<any>): void;
+    function RegisterReference(type: ReplicableClass, pointer: Pointer<any>): void;
+    /**
+     * Update all references of an object of this type to a new reference. This is good if the server and the client
+     * spawn entities with different IDs, this function helps to map the IDs sent from the client to the actual
+     * legitimate entity on the server.
+     */
+    function UpdateReferences(from: Replicable.Reference, to: Replicable.Reference): void;
+    function CanReference<T extends object>(item: T): boolean;
+    function IsReference(ref: any): ref is Referencer.Reference;
+    function Reference<T extends object>(data: T, type?: ReplicableClass): Referencer.Reference;
+    function Dereference<T extends object>(ref: Referencer.Reference, overrideType?: ReplicableClass): T;
+}
+export {};

package/Transformers/Reference.js

@@ -0,0 +1,212 @@
+var _a, _b;
+import { isPrimitiveType, isPrimitiveValue, TypeSymbol } from "../Constants/SerialisationTypes.js";
+import { WeakArray } from "@bikky/smart-collections";
+const ptr = Symbol("Pointer");
+const registry = Symbol("Registry");
+const alive = Symbol("Alive");
+const ref = Symbol("Reference");
+let getReplicableClassByName = null;
+let getReplicableClassByAlias = null;
+export class Pointer {
+    constructor(item) {
+        this[_a] = undefined;
+        this[_b] = false;
+        this[registry] = new FinalizationRegistry(() => {
+            this[alive] = false;
+        });
+        if (typeof item !== "undefined" && item !== null) {
+            //Use the setter so it sets the ref, value, and registry correctly.
+            this.val = item;
+        }
+        else {
+            this[ref] = null;
+        }
+    }
+    // isValid() {
+    //     return !!this.#ref;
+    // }
+    get val() {
+        if (!this[alive]) {
+            if (!this[ref])
+                throw new Error("Cannot get value before value is set!");
+            let val = Referencer.Dereference(this[ref]);
+            if (val) {
+                this.val = val;
+            }
+            else {
+                throw new Error(`Attempt to access invalid value.`);
+            }
+        }
+        return this[ptr].deref() || null;
+    }
+    get valOrNull() {
+        if (!this[alive]) {
+            if (!this[ref])
+                return null;
+            let val = Referencer.Dereference(this[ref]);
+            if (typeof val !== "undefined" && val !== null) {
+                this.val = val;
+            }
+            else {
+                return null;
+            }
+        }
+        return this[ptr].deref() || null;
+    }
+    set val(value) {
+        if (this[alive]) {
+            let existing = this[ptr].deref();
+            Referencer.UnregisterReference(existing[TypeSymbol], this);
+            this[registry].unregister(existing);
+        }
+        if (value === null) {
+            this[ptr] = undefined;
+            this[alive] = false;
+            this[ref] = null;
+            return;
+        }
+        this[ptr] = new WeakRef(value);
+        this[alive] = true;
+        this[registry].register(this[ptr], value);
+        this[ref] = Referencer.Reference(value);
+        Referencer.RegisterReference(value[TypeSymbol], this);
+    }
+    get ref() {
+        if (this[ref] === null)
+            return null;
+        if (!this[ref])
+            throw new Error("Cannot get reference before reference is set!");
+        return this[ref];
+    }
+    set ref(refa) {
+        if (this[alive]) {
+            let existing = this[ptr].deref();
+            Referencer.UnregisterReference(existing[TypeSymbol], this);
+            this[registry].unregister(existing);
+            this[alive] = false;
+        }
+        if (refa === null) {
+            this[ptr] = undefined;
+            this[alive] = false;
+            this[ref] = null;
+            return;
+        }
+        this[ref] = refa;
+        if (!getReplicableClassByName) {
+            throw new Error("Cannot set reference without a lookup function.");
+        }
+        Referencer.RegisterReference(getReplicableClassByName(refa[0]), this);
+    }
+}
+_a = ptr, _b = alive;
+export var Referencer;
+(function (Referencer) {
+    var refs = new Map();
+    function SetDataNameLookupFunction(lookupFunc) {
+        getReplicableClassByName = lookupFunc;
+    }
+    Referencer.SetDataNameLookupFunction = SetDataNameLookupFunction;
+    function SetAliasLookupFunction(lookupFunc) {
+        getReplicableClassByAlias = lookupFunc;
+    }
+    Referencer.SetAliasLookupFunction = SetAliasLookupFunction;
+    function UnregisterReference(type, pointer) {
+        let set = refs.get(type);
+        if (!set)
+            refs.set(type, set = new WeakArray());
+        set.removeAll(pointer);
+    }
+    Referencer.UnregisterReference = UnregisterReference;
+    function RegisterReference(type, pointer) {
+        let set = refs.get(type);
+        if (!set)
+            refs.set(type, set = new WeakArray());
+        if (!set.includes(pointer))
+            set.push(pointer);
+    }
+    Referencer.RegisterReference = RegisterReference;
+    /**
+     * Update all references of an object of this type to a new reference. This is good if the server and the client
+     * spawn entities with different IDs, this function helps to map the IDs sent from the client to the actual
+     * legitimate entity on the server.
+     */
+    function UpdateReferences(from, to) {
+        if (!getReplicableClassByName) {
+            throw new Error("Cannot update references without a lookup function.");
+        }
+        let type = getReplicableClassByName(from[0]);
+        if (!type)
+            throw new Error(`Cannot find type ${from[0]}.`);
+        let fromStr = JSON.stringify(from);
+        let allPtrs = refs.get(type);
+        if (!allPtrs)
+            throw new Error(`Cannot find pointers for type ${from[0]}.`);
+        for (let ptr of allPtrs) {
+            if (JSON.stringify(ptr.ref) == fromStr) {
+                ptr.ref = to;
+            }
+        }
+    }
+    Referencer.UpdateReferences = UpdateReferences;
+    function CanReference(item) {
+        if (isPrimitiveType(item))
+            return true;
+        let type = item[TypeSymbol];
+        if (!type)
+            return false;
+        return "Reference" in type.classConstructor && "Dereference" in type.classConstructor;
+    }
+    Referencer.CanReference = CanReference;
+    function IsReference(ref) {
+        if (!getReplicableClassByName) {
+            throw new Error("Cannot update references without a lookup function.");
+        }
+        if (!Array.isArray(ref))
+            return false;
+        let type = getReplicableClassByName(ref[0]);
+        if (!type)
+            return false;
+        return !!type && "Reference" in type.classConstructor && "Dereference" in type.classConstructor;
+    }
+    Referencer.IsReference = IsReference;
+    function Reference(data, type) {
+        if (type && "Reference" in type.classConstructor)
+            return [type.opts.typescriptTypeName, ...type.classConstructor.Reference(data)];
+        if (isPrimitiveValue(data))
+            return ["Primitive", data];
+        let typeDef = data[TypeSymbol];
+        if (!typeDef)
+            throw new Error(`Cannot find type for ${data}.`);
+        let classConstructor = typeDef.classConstructor;
+        if (!("Reference" in classConstructor)) {
+            throw new Error(`Tried to create a reference for a ${typeDef.opts.typescriptTypeName} which doesn't support references.`);
+        }
+        return [typeDef.opts.dataTypeName, ...classConstructor.Reference(data)];
+    }
+    Referencer.Reference = Reference;
+    function Dereference(ref, overrideType) {
+        if (!Array.isArray(ref)) {
+            return ref;
+        }
+        else {
+            if (!getReplicableClassByAlias) {
+                throw new Error("Cannot update references without a lookup function.");
+            }
+            if (ref[0] === "Primitive")
+                return ref[1];
+            if (ref[0] === "JSON")
+                return JSON.parse(ref[1]);
+            let types = overrideType ? [overrideType] : getReplicableClassByAlias(ref[0]);
+            let type = types === null || types === void 0 ? void 0 : types[0];
+            if (!type) {
+                throw new Error(`Tried to dereference ${ref[0]} which is an unregistered/non-replicable type.`);
+            }
+            let classConstructor = type.classConstructor;
+            if (!("Dereference" in classConstructor)) {
+                throw new Error(`Tried to dereference a ${type.opts.typescriptTypeName} which doesn't support dereferencing.`);
+            }
+            return classConstructor.Dereference(ref.slice(1));
+        }
+    }
+    Referencer.Dereference = Dereference;
+})(Referencer || (Referencer = {}));