mnemonica 0.9.93 → 0.9.98

package/build/descriptors/types/index.js

@@ -1,170 +1,170 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.types = void 0;
-const hop_1 = require('../../utils/hop');
-const constants_1 = require('../../constants');
+const hop_1 = require("../../utils/hop");
+const constants_1 = require("../../constants");
 const { odp, SymbolConstructorName, SymbolDefaultNamespace, SymbolDefaultTypesCollection, SymbolConfig, MNEMONICA, MNEMOSYNE, } = constants_1.constants;
-const errors_1 = require('../../descriptors/errors');
+const errors_1 = require("../../descriptors/errors");
 const { NAMESPACE_DOES_NOT_EXIST, ASSOCIATION_EXISTS, } = errors_1.ErrorsTypes;
-const namespaces_1 = require('../namespaces');
+const namespaces_1 = require("../namespaces");
 const { [SymbolDefaultNamespace]: defaultNamespace, defaultOptionsKeys } = namespaces_1.namespaces;
-const types_1 = require('../../api/types');
-const hooksAPI = require('../../api/hooks');
-const proto = Object.assign({ define : types_1.define,
-	lookup : types_1.lookup }, hooksAPI);
+const types_1 = require("../../api/types");
+const hooksAPI = require("../../api/hooks");
+const proto = Object.assign({ define: types_1.define,
+    lookup: types_1.lookup }, hooksAPI);
 const TypesCollection = function (namespace, config) {
-	const self = this;
-	const subtypes = new Map();
-	config = defaultOptionsKeys.reduce((o, key) => {
-		if (typeof config[key] === 'boolean') {
-			o[key] = config[key];
-		}
-		else {
-			o[key] = namespace[SymbolConfig][key];
-		}
-		return o;
-	}, {});
-	odp(this, SymbolConfig, {
-		get () {
-			return config;
-		}
-	});
-	odp(this, Symbol.hasInstance, {
-		get () {
-			return (instance) => {
-				return instance[SymbolConstructorName] === namespace.name;
-			};
-		}
-	});
-	odp(this, 'subtypes', {
-		get () {
-			return subtypes;
-		}
-	});
-	odp(subtypes, MNEMOSYNE, {
-		get () {
-			return namespace.typesCollections.get(self);
-		}
-	});
-	odp(this, MNEMOSYNE, {
-		get () {
-			return namespace.typesCollections.get(self);
-		}
-	});
-	odp(this, 'namespace', {
-		get () {
-			return namespace;
-		}
-	});
-	odp(subtypes, 'namespace', {
-		get () {
-			return namespace;
-		}
-	});
-	const hooks = Object.create(null);
-	odp(this, 'hooks', {
-		get () {
-			return hooks;
-		}
-	});
+    const self = this;
+    const subtypes = new Map();
+    config = defaultOptionsKeys.reduce((o, key) => {
+        if (typeof config[key] === 'boolean') {
+            o[key] = config[key];
+        }
+        else {
+            o[key] = namespace[SymbolConfig][key];
+        }
+        return o;
+    }, {});
+    odp(this, SymbolConfig, {
+        get() {
+            return config;
+        }
+    });
+    odp(this, Symbol.hasInstance, {
+        get() {
+            return (instance) => {
+                return instance[SymbolConstructorName] === namespace.name;
+            };
+        }
+    });
+    odp(this, 'subtypes', {
+        get() {
+            return subtypes;
+        }
+    });
+    odp(subtypes, MNEMOSYNE, {
+        get() {
+            return namespace.typesCollections.get(self);
+        }
+    });
+    odp(this, MNEMOSYNE, {
+        get() {
+            return namespace.typesCollections.get(self);
+        }
+    });
+    odp(this, 'namespace', {
+        get() {
+            return namespace;
+        }
+    });
+    odp(subtypes, 'namespace', {
+        get() {
+            return namespace;
+        }
+    });
+    const hooks = Object.create(null);
+    odp(this, 'hooks', {
+        get() {
+            return hooks;
+        }
+    });
 };
 odp(TypesCollection.prototype, MNEMONICA, {
-	get () {
-		return this.namespace.typesCollections.get(this);
-	}
+    get() {
+        return this.namespace.typesCollections.get(this);
+    }
 });
 odp(TypesCollection.prototype, 'define', {
-	get () {
-		const { subtypes } = this;
-		return function (...args) {
-			return proto.define.call(this, subtypes, ...args);
-		};
-	},
-	enumerable : true
+    get() {
+        const { subtypes } = this;
+        return function (...args) {
+            return proto.define.call(this, subtypes, ...args);
+        };
+    },
+    enumerable: true
 });
 odp(TypesCollection.prototype, 'lookup', {
-	get () {
-		return function (...args) {
-			return proto.lookup.call(this.subtypes, ...args);
-		}.bind(this);
-	},
-	enumerable : true
+    get() {
+        return function (...args) {
+            return proto.lookup.call(this.subtypes, ...args);
+        }.bind(this);
+    },
+    enumerable: true
 });
 odp(TypesCollection.prototype, 'registerHook', {
-	get () {
-		const proxy = this.namespace.typesCollections.get(this);
-		return function (hookName, hookCallback) {
-			return proto.registerHook.call(this, hookName, hookCallback);
-		}.bind(proxy);
-	},
-	enumerable : true
+    get() {
+        const proxy = this.namespace.typesCollections.get(this);
+        return function (hookName, hookCallback) {
+            return proto.registerHook.call(this, hookName, hookCallback);
+        }.bind(proxy);
+    },
+    enumerable: true
 });
 odp(TypesCollection.prototype, 'invokeHook', {
-	get () {
-		const proxy = this.namespace.typesCollections.get(this);
-		return function (hookName, hookCallback) {
-			return proto.invokeHook.call(this, hookName, hookCallback);
-		}.bind(proxy);
-	}
+    get() {
+        const proxy = this.namespace.typesCollections.get(this);
+        return function (hookName, hookCallback) {
+            return proto.invokeHook.call(this, hookName, hookCallback);
+        }.bind(proxy);
+    }
 });
 odp(TypesCollection.prototype, 'registerFlowChecker', {
-	get () {
-		const proxy = this.namespace.typesCollections.get(this);
-		return function (flowCheckerCallback) {
-			return proto.registerFlowChecker.call(this, flowCheckerCallback);
-		}.bind(proxy);
-	}
+    get() {
+        const proxy = this.namespace.typesCollections.get(this);
+        return function (flowCheckerCallback) {
+            return proto.registerFlowChecker.call(this, flowCheckerCallback);
+        }.bind(proxy);
+    }
 });
 const typesCollectionProxyHandler = {
-	get (target, prop) {
-		if (target.subtypes.has(prop)) {
-			return target.subtypes.get(prop);
-		}
-		return Reflect.get(target, prop);
-	},
-	set (target, TypeName, Constructor) {
-		return target.define(TypeName, Constructor);
-	},
-	getOwnPropertyDescriptor (target, prop) {
-		return target.subtypes.has(prop) ? {
-			configurable : true,
-			enumerable   : true,
-			writeable    : false,
-			value        : target.subtypes.get(prop)
-		} : undefined;
-	}
+    get(target, prop) {
+        if (target.subtypes.has(prop)) {
+            return target.subtypes.get(prop);
+        }
+        return Reflect.get(target, prop);
+    },
+    set(target, TypeName, Constructor) {
+        return target.define(TypeName, Constructor);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+        return target.subtypes.has(prop) ? {
+            configurable: true,
+            enumerable: true,
+            writable: false,
+            value: target.subtypes.get(prop)
+        } : undefined;
+    }
 };
 const createTypesCollection = (namespace = defaultNamespace, association, config = {}) => {
-	if (!(namespace instanceof Object) ||
-        !hop_1.hop(namespace, 'name') ||
+    if (!(namespace instanceof Object) ||
+        !(0, hop_1.hop)(namespace, 'name') ||
         !namespaces_1.namespaces.namespaces.has(namespace.name)) {
-		throw new NAMESPACE_DOES_NOT_EXIST;
-	}
-	if (namespace.typesCollections.has(association)) {
-		throw new ASSOCIATION_EXISTS;
-	}
-	const typesCollection = new TypesCollection(namespace, config);
-	const typesCollectionProxy = new Proxy(typesCollection, typesCollectionProxyHandler);
-	namespace.typesCollections.set(typesCollection, typesCollectionProxy);
-	namespace.typesCollections.set(typesCollectionProxy, typesCollection);
-	if (association) {
-		namespace.typesCollections.set(association, typesCollectionProxy);
-	}
-	return typesCollectionProxy;
+        throw new NAMESPACE_DOES_NOT_EXIST;
+    }
+    if (namespace.typesCollections.has(association)) {
+        throw new ASSOCIATION_EXISTS;
+    }
+    const typesCollection = new TypesCollection(namespace, config);
+    const typesCollectionProxy = new Proxy(typesCollection, typesCollectionProxyHandler);
+    namespace.typesCollections.set(typesCollection, typesCollectionProxy);
+    namespace.typesCollections.set(typesCollectionProxy, typesCollection);
+    if (association) {
+        namespace.typesCollections.set(association, typesCollectionProxy);
+    }
+    return typesCollectionProxy;
 };
 const DEFAULT_TYPES = createTypesCollection(defaultNamespace, SymbolDefaultTypesCollection);
 odp(DEFAULT_TYPES, SymbolDefaultTypesCollection, {
-	get () {
-		return true;
-	}
+    get() {
+        return true;
+    }
 });
 exports.types = {
-	get createTypesCollection () {
-		return function (namespace, association, config = {}) {
-			return createTypesCollection(namespace, association, config);
-		};
-	},
-	get defaultTypes () {
-		return DEFAULT_TYPES;
-	}
+    get createTypesCollection() {
+        return function (namespace, association, config = {}) {
+            return createTypesCollection(namespace, association, config);
+        };
+    },
+    get defaultTypes() {
+        return DEFAULT_TYPES;
+    }
 };

package/build/index.d.ts

@@ -1,13 +1,47 @@
-import { TypeAbsorber, ITypeClass, TypeLookup, IDEF } from './types';
+import { TypeLookup, IDEF } from './types';
 export type { IDEF } from './types';
 export declare const defaultTypes: any;
-export declare const define: TypeAbsorber;
-export declare const tsdefine: <T>(this: any, TypeName: string, constructHandler: IDEF<T>, proto?: object | undefined, config?: object | undefined) => ITypeClass<T>;
+type hooksTypes = 'preCreation' | 'postCreation' | 'creationError';
+type hooksOpts = {
+    TypeName: string;
+    args: unknown[];
+    existentInstance: object;
+    inheritedInstance: object;
+};
+type hook = {
+    (opts: hooksOpts): void;
+};
+type constructorOptions = {
+    useOldStyle?: boolean;
+    strictChain?: boolean;
+    blockErrors?: boolean;
+    submitStack?: boolean;
+    awaitReturn?: boolean;
+    bindedProto?: boolean;
+};
+type Proto<P, T> = Pick<P, Exclude<keyof P, keyof T>> & T;
+type SN = Record<string, new () => unknown>;
+interface IDefinitorInstance<N extends object, S> {
+    new (...arg: unknown[]): {
+        [key in keyof S]: S[key];
+    };
+    define: IDefinitor<N, string>;
+    registerHook: (hookType: hooksTypes, cb: hook) => void;
+}
+interface IDefinitor<P extends object, SubTypeName extends string> {
+    <PP extends object, T, M extends Proto<P, Proto<PP, T>>, S extends SN & M>(this: unknown, TypeName: SubTypeName, constructHandler: IDEF<T>, proto?: PP, config?: constructorOptions): IDefinitorInstance<M, S>;
+}
+export declare const define: <T, P extends object, N extends Proto<P, T>, S extends SN & N, R extends IDefinitorInstance<N, S>>(this: unknown, TypeName?: string, constructHandler?: IDEF<T> | undefined, proto?: P | undefined, config?: constructorOptions) => R;
 export declare const lookup: TypeLookup;
+export declare const apply: <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, args?: unknown[]) => { [key in keyof S]: S[key]; };
+export declare const call: <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, ...args: unknown[]) => { [key in keyof S]: S[key]; };
+export declare const bind: <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>) => (...args: unknown[]) => { [key in keyof S]: S[key]; };
+export declare const decorate: (parentClass?: unknown, proto?: object, config?: constructorOptions) => <T extends new () => unknown>(cstr: T, s: ClassDecoratorContext<T>) => T;
+export declare const registerHook: <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook) => void;
 export declare const mnemonica: {
-    [index: string]: any;
+    [index: string]: unknown;
 };
-export declare const SymbolSubtypeCollection: any, SymbolConstructorName: any, SymbolGaia: any, SymbolReplaceGaia: any, SymbolDefaultNamespace: any, SymbolDefaultTypesCollection: any, SymbolConfig: any, MNEMONICA: any, MNEMOSYNE: any, GAIA: any, URANUS: any, TYPE_TITLE_PREFIX: any, ErrorMessages: any, createNamespace: any, namespaces: any, defaultNamespace: any, createTypesCollection: any;
+export declare const SymbolSubtypeCollection: unknown, SymbolConstructorName: unknown, SymbolGaia: unknown, SymbolReplaceGaia: unknown, SymbolDefaultNamespace: unknown, SymbolDefaultTypesCollection: unknown, SymbolConfig: unknown, MNEMONICA: unknown, MNEMOSYNE: unknown, GAIA: unknown, URANUS: unknown, TYPE_TITLE_PREFIX: unknown, ErrorMessages: unknown, createNamespace: unknown, namespaces: unknown, defaultNamespace: unknown, createTypesCollection: unknown;
 export declare const defaultCollection: any;
 export declare const errors: any;
 export { utils } from './utils';

package/build/index.js

@@ -1,42 +1,74 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
-exports.defineStackCleaner = exports.utils = exports.errors = exports.defaultCollection = exports.createTypesCollection = exports.defaultNamespace = exports.namespaces = exports.createNamespace = exports.ErrorMessages = exports.TYPE_TITLE_PREFIX = exports.URANUS = exports.GAIA = exports.MNEMOSYNE = exports.MNEMONICA = exports.SymbolConfig = exports.SymbolDefaultTypesCollection = exports.SymbolDefaultNamespace = exports.SymbolReplaceGaia = exports.SymbolGaia = exports.SymbolConstructorName = exports.SymbolSubtypeCollection = exports.mnemonica = exports.lookup = exports.tsdefine = exports.define = exports.defaultTypes = void 0;
-const constants_1 = require('./constants');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineStackCleaner = exports.utils = exports.errors = exports.defaultCollection = exports.createTypesCollection = exports.defaultNamespace = exports.namespaces = exports.createNamespace = exports.ErrorMessages = exports.TYPE_TITLE_PREFIX = exports.URANUS = exports.GAIA = exports.MNEMOSYNE = exports.MNEMONICA = exports.SymbolConfig = exports.SymbolDefaultTypesCollection = exports.SymbolDefaultNamespace = exports.SymbolReplaceGaia = exports.SymbolGaia = exports.SymbolConstructorName = exports.SymbolSubtypeCollection = exports.mnemonica = exports.registerHook = exports.decorate = exports.bind = exports.call = exports.apply = exports.lookup = exports.define = exports.defaultTypes = void 0;
+const constants_1 = require("./constants");
 const { odp } = constants_1.constants;
-const errorsApi = require('./api/errors');
-const descriptors_1 = require('./descriptors');
+const errorsApi = require("./api/errors");
+const descriptors_1 = require("./descriptors");
 exports.defaultTypes = descriptors_1.descriptors.defaultTypes;
-function checkThis (pointer) {
-	return pointer === exports.mnemonica ||
-        pointer === exports;
+function checkThis(pointer) {
+    return pointer === exports.mnemonica || pointer === exports;
 }
-
-exports.define = function (TypeName, constructHandler, proto, config) {
-	const types = checkThis(this) ? exports.defaultTypes : this || exports.defaultTypes;
-	return types.define(TypeName, constructHandler, proto, config);
-};
-exports.tsdefine = function (TypeName, constructHandler, proto, config) {
-	return exports.defaultTypes.define(TypeName, constructHandler, proto, config);
+const define = function (TypeName, constructHandler, proto, config) {
+    const types = checkThis(this) ? exports.defaultTypes : this || exports.defaultTypes;
+    return types.define(TypeName, constructHandler, proto, config);
 };
+exports.define = define;
 exports.lookup = function (TypeNestedPath) {
-	const types = checkThis(this) ? exports.defaultTypes : this || exports.defaultTypes;
-	return types.lookup(TypeNestedPath);
+    const types = checkThis(this) ? exports.defaultTypes : this || exports.defaultTypes;
+    return types.lookup(TypeNestedPath);
+};
+const apply = function (entity, Constructor, args = []) {
+    const result = new entity[Constructor.TypeName](...args);
+    return result;
+};
+exports.apply = apply;
+const call = function (entity, Constructor, ...args) {
+    const result = new entity[Constructor.TypeName](...args);
+    return result;
+};
+exports.call = call;
+const bind = function (entity, Constructor) {
+    return (...args) => {
+        const result = new entity[Constructor.TypeName](...args);
+        return result;
+    };
+};
+exports.bind = bind;
+const decorate = function (parentClass = undefined, proto, config) {
+    const decorator = function (cstr, s) {
+        if (parentClass === undefined) {
+            return (0, exports.define)(s.name, cstr, proto, config);
+        }
+        return parentClass.define(s.name, cstr, proto, config);
+    };
+    return decorator;
+};
+exports.decorate = decorate;
+const registerHook = function (Constructor, hookType, cb) {
+    Constructor.registerHook(hookType, cb);
 };
-exports.mnemonica = Object.entries(Object.assign(Object.assign(Object.assign({ define : exports.define,
-	lookup : exports.lookup }, descriptors_1.descriptors), errorsApi), constants_1.constants)).reduce((acc, entry) => {
-	const [name, code] = entry;
-	odp(acc, name, {
-		get () {
-			return code;
-		},
-		enumerable : true
-	});
-	return acc;
+exports.registerHook = registerHook;
+exports.mnemonica = Object.entries(Object.assign(Object.assign(Object.assign({ define: exports.define,
+    lookup: exports.lookup,
+    apply: exports.apply,
+    call: exports.call,
+    bind: exports.bind,
+    decorate: exports.decorate,
+    registerHook: exports.registerHook }, descriptors_1.descriptors), errorsApi), constants_1.constants)).reduce((acc, entry) => {
+    const [name, code] = entry;
+    odp(acc, name, {
+        get() {
+            return code;
+        },
+        enumerable: true
+    });
+    return acc;
 }, {});
 exports.SymbolSubtypeCollection = exports.mnemonica.SymbolSubtypeCollection, exports.SymbolConstructorName = exports.mnemonica.SymbolConstructorName, exports.SymbolGaia = exports.mnemonica.SymbolGaia, exports.SymbolReplaceGaia = exports.mnemonica.SymbolReplaceGaia, exports.SymbolDefaultNamespace = exports.mnemonica.SymbolDefaultNamespace, exports.SymbolDefaultTypesCollection = exports.mnemonica.SymbolDefaultTypesCollection, exports.SymbolConfig = exports.mnemonica.SymbolConfig, exports.MNEMONICA = exports.mnemonica.MNEMONICA, exports.MNEMOSYNE = exports.mnemonica.MNEMOSYNE, exports.GAIA = exports.mnemonica.GAIA, exports.URANUS = exports.mnemonica.URANUS, exports.TYPE_TITLE_PREFIX = exports.mnemonica.TYPE_TITLE_PREFIX, exports.ErrorMessages = exports.mnemonica.ErrorMessages, exports.createNamespace = exports.mnemonica.createNamespace, exports.namespaces = exports.mnemonica.namespaces, exports.defaultNamespace = exports.mnemonica.defaultNamespace, exports.createTypesCollection = exports.mnemonica.createTypesCollection;
 exports.defaultCollection = exports.defaultTypes.subtypes;
 exports.errors = descriptors_1.descriptors.ErrorsTypes;
-var utils_1 = require('./utils');
-Object.defineProperty(exports, 'utils', { enumerable : true, get : function () { return utils_1.utils; } });
-var utils_2 = require('./utils');
-Object.defineProperty(exports, 'defineStackCleaner', { enumerable : true, get : function () { return utils_2.defineStackCleaner; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "utils", { enumerable: true, get: function () { return utils_1.utils; } });
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "defineStackCleaner", { enumerable: true, get: function () { return utils_2.defineStackCleaner; } });

package/build/types/index.d.ts

@@ -1,27 +1,26 @@
+export type IDEF<T> = {
+    new (): T;
+} | {
+    (this: T, ...args: any[]): void;
+};
 export interface ConstructorFunction<ConstructorInstance extends object> {
-    new (...args: any[]): ConstructorInstance;
-    (this: ConstructorInstance, ...args: any[]): ConstructorInstance;
+    new (...args: unknown[]): ConstructorInstance;
+    (this: ConstructorInstance, ...args: unknown[]): ConstructorInstance;
     prototype: ConstructorInstance;
 }
-export declare type TypeModificator<T extends object> = (...args: any[]) => ConstructorFunction<T>;
-export declare type TypeLookup = (this: Map<string, any>, TypeNestedPath: string) => TypeClass;
-export declare type TypeClass = {
-    new (...args: any[]): any;
+export type TypeLookup = (this: Map<string, unknown>, TypeNestedPath: string) => TypeClass;
+export type TypeClass = {
+    new (...args: unknown[]): unknown;
     define: TypeAbsorber;
     lookup: TypeLookup;
-    registerHook: (type: 'preCreation' | 'postCreation' | 'creationError', hook: CallableFunction) => any;
-};
-export declare type TypeAbsorber = (this: any, TypeName: string, constructHandler: CallableFunction, proto?: object, config?: object) => TypeClass;
-export declare type IDEF<T> = {
-    new (...args: any[]): T;
-    (this: T, ...args: any[]): T;
-    prototype?: ThisType<T>;
+    registerHook: (type: 'preCreation' | 'postCreation' | 'creationError', hook: CallableFunction) => unknown;
 };
-export declare type ITypeAbsorber<T> = (this: any, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
+export type TypeAbsorber = (this: unknown, TypeName: string, constructHandler: CallableFunction, proto?: object, config?: object) => TypeClass;
+export type ITypeAbsorber<T> = (this: unknown, TypeName: string, constructHandler: IDEF<T>, proto?: object, config?: object) => ITypeClass<T>;
 export interface ITypeClass<T> {
-    new (...args: any[]): T;
-    (this: T, ...args: any[]): T;
+    new (...args: unknown[]): T;
+    (this: T, ...args: unknown[]): T;
     define: ITypeAbsorber<T>;
     lookup: TypeLookup;
-    registerHook: (type: 'preCreation' | 'postCreation' | 'creationError', hook: CallableFunction) => any;
+    registerHook: (type: 'preCreation' | 'postCreation' | 'creationError', hook: CallableFunction) => unknown;
 }

package/build/types/index.js

@@ -1,2 +1,2 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/utils/collectConstructors.js

@@ -1,59 +1,60 @@
 'use strict';
-Object.defineProperty(exports, '__esModule', { value : true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectConstructors = void 0;
-const constants_1 = require('../constants');
+const constants_1 = require("../constants");
 const { MNEMOSYNE, MNEMONICA, GAIA, } = constants_1.constants;
 const getAdditor = (constructors) => {
-	return Array.isArray(constructors) ?
-		(name) => {
-			constructors.push(name);
-		} : (name) => {
-			constructors[name] = true;
-		};
+    return Array.isArray(constructors) ?
+        (name) => {
+            constructors.push(name);
+        } : (name) => {
+        constructors[name] = true;
+    };
 };
 const getAccumulator = (asSequence) => {
-	return asSequence ? [] : {};
+    return asSequence ? [] : {};
 };
-exports.collectConstructors = (self, asSequence = false) => {
-	const constructors = getAccumulator(asSequence);
-	const addToSequence = getAdditor(constructors);
-	if (typeof self === 'object') {
-		if (self === null) {
-			return constructors;
-		}
-	}
-	else {
-		return constructors;
-	}
-	let proto = Reflect.getPrototypeOf(self);
-	let mnemonicaReached = false;
-	while (proto) {
-		if (!proto.constructor) {
-			addToSequence(proto);
-			break;
-		}
-		const constructorName = proto.constructor.name;
-		if (constructorName === GAIA) {
-			self = proto;
-			proto = Reflect.getPrototypeOf(self);
-			continue;
-		}
-		if (constructorName === MNEMONICA) {
-			if (!mnemonicaReached) {
-				addToSequence(constructorName);
-				addToSequence(MNEMOSYNE);
-				mnemonicaReached = true;
-			}
-		}
-		else if (constructorName === 'Object') {
-			addToSequence(constructorName);
-			break;
-		}
-		else {
-			addToSequence(constructorName);
-		}
-		self = proto;
-		proto = Reflect.getPrototypeOf(self);
-	}
-	return constructors;
+const collectConstructors = (self, asSequence = false) => {
+    const constructors = getAccumulator(asSequence);
+    const addToSequence = getAdditor(constructors);
+    if (typeof self === 'object') {
+        if (self === null) {
+            return constructors;
+        }
+    }
+    else {
+        return constructors;
+    }
+    let proto = Reflect.getPrototypeOf(self);
+    let mnemonicaReached = false;
+    while (proto) {
+        if (!proto.constructor) {
+            addToSequence(proto);
+            break;
+        }
+        const constructorName = proto.constructor.name;
+        if (constructorName === GAIA) {
+            self = proto;
+            proto = Reflect.getPrototypeOf(self);
+            continue;
+        }
+        if (constructorName === MNEMONICA) {
+            if (!mnemonicaReached) {
+                addToSequence(constructorName);
+                addToSequence(MNEMOSYNE);
+                mnemonicaReached = true;
+            }
+        }
+        else if (constructorName === 'Object') {
+            addToSequence(constructorName);
+            break;
+        }
+        else {
+            addToSequence(constructorName);
+        }
+        self = proto;
+        proto = Reflect.getPrototypeOf(self);
+    }
+    return constructors;
 };
+exports.collectConstructors = collectConstructors;