mnemonica 1.0.0 → 1.0.6

package/build/types/index.d.ts

@@ -64,10 +64,6 @@ export type constructorOptions = {
     submitStack?: boolean;
     awaitReturn?: boolean;
     asClass?: boolean;
-    exposeInstanceMethods?: boolean;
-};
-export type HideInstanceMethodsOptions = constructorOptions & {
-    exposeInstanceMethods: true;
 };
 export type SubtypesMap = Map<string, TypeClass>;
 export type TypeDef = {
@@ -130,21 +126,35 @@ export type ProtoFlat<P extends object, T extends object, L extends Exclude<keyo
 } & {
     [key in L]: P[key];
 };
+export type MnemonicaInstanceMethodKeys = 'extract' | 'pick' | 'parent' | 'clone' | 'fork' | 'exception' | 'sibling';
 export type Flatten<F> = {
     [key in keyof F]: F[key];
 };
+export type Extracted<T extends object> = {
+    [K in keyof T as K extends string ? (K extends MnemonicaInstanceMethodKeys ? never : K) : never]: T[K];
+} & {};
+export type Parsed<T extends object> = {
+    name: string;
+    props: Extracted<T>;
+    self: T;
+    proto: object;
+    joint: Record<string, unknown>;
+    parent: object | undefined;
+};
 export interface SiblingAccessor {
     (SiblingTypeName: string): TypeClass | undefined;
     [key: string]: TypeClass | undefined;
 }
-export interface MnemonicaInstance {
-    extract(): Record<string, unknown>;
+export interface MnemonicaInstance<T extends object = object> {
+    extract(): Extracted<T>;
+    pick<K extends keyof T>(...keys: (K | K[])[]): {
+        [P in K]: T[P];
+    } & {};
     pick(...keys: string[]): Record<string, unknown>;
-    pick(keys: string[]): Record<string, unknown>;
     parent(): object | undefined;
     parent(constructorLookupPath: string): object | undefined;
-    readonly clone: object;
-    fork(...forkArgs: unknown[]): object;
+    readonly clone: this;
+    fork(...forkArgs: unknown[]): this;
     exception(error: Error, ...args: unknown[]): Error;
     readonly sibling: SiblingAccessor;
 }
@@ -160,19 +170,18 @@ export type InstanceInternalProps = {
     __timestamp__: number;
 };
 export type Props = InstanceInternalProps & {
-    __self__: InstanceInternalProps & MnemonicaInstance;
+    __self__: InstanceInternalProps;
     [key: string]: unknown;
 };
-export type IsHidingMethods<Config extends constructorOptions> = Config extends {
-    exposeInstanceMethods: false;
-} ? true : false;
-export type InstanceResult<N extends object, Config extends constructorOptions> = IsHidingMethods<Config> extends true ? Flatten<N> : Flatten<N> & MnemonicaInstance;
-export interface IDefinitorInstance<N extends object, Config extends constructorOptions = constructorOptions, R extends InstanceResult<N, Config> = InstanceResult<N, Config>> {
+export type InstanceResult<N extends object> = {
+    [K in keyof N]: N[K];
+};
+export interface IDefinitorInstance<N extends object, R extends InstanceResult<N> = InstanceResult<N>> {
     TypeName: string;
     prototype: N;
     new (...args: unknown[]): R;
-    (...args: unknown[]): IDefinitorInstance<R, Config>;
-    define<T extends object, F extends Proto<N, T>>(TypeOrTypeName: string | CallableFunction, constructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction, configOrUndefined?: constructorOptions | CallableFunction | boolean): IDefinitorInstance<F, Config>;
+    (...args: unknown[]): IDefinitorInstance<R>;
+    define<T extends object, F extends Proto<N, T>>(TypeOrTypeName: string | CallableFunction, constructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction, configOrUndefined?: constructorOptions | CallableFunction | boolean): IDefinitorInstance<F>;
     lookup: TypeLookup;
     registerHook(hookType: hooksTypes, cb: hook): void;
     subtypes: SubtypesMap;
@@ -180,8 +189,7 @@ export interface IDefinitorInstance<N extends object, Config extends constructor
     collection?: CollectionDef;
 }
 export interface TypeAbsorber extends CallableFunction {
-    <T extends object>(this: unknown, TypeOrTypeName: string | CallableFunction, constructHandlerOrConfig: IDEF<T> | object | boolean | CallableFunction, configOrUndefined: HideInstanceMethodsOptions): IDefinitorInstance<T, HideInstanceMethodsOptions>;
-    <T extends object>(this: unknown, TypeOrTypeName: string | CallableFunction, constructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction, configOrUndefined?: constructorOptions | CallableFunction | boolean): IDefinitorInstance<T, constructorOptions>;
+    <T extends object>(this: unknown, TypeOrTypeName: string | CallableFunction, constructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction, configOrUndefined?: constructorOptions | CallableFunction | boolean): IDefinitorInstance<T>;
 }
 export interface TypesCollection extends Hookable {
     define: TypeAbsorber;
@@ -221,17 +229,32 @@ export type DecoratedClass<T extends Constructor<object>> = T & (<U extends Cons
     lookup: TypeLookup;
     TypeName: string;
 };
-export type ApplyFunction = <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, args?: unknown[]) => S;
-export type CallFunction = <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>, ...args: unknown[]) => S;
-export type BindFunction = <E extends object, T extends object, S extends Proto<E, T>>(entity: E, Constructor: IDEF<T>) => (...args: unknown[]) => S;
+export type Merge<E extends object, T extends object> = {
+    [K in keyof T | keyof E as K extends MnemonicaInstanceMethodKeys ? never : K]: K extends keyof T ? T[K] : E[K & keyof E];
+};
+export interface ApplyFunction extends CallableFunction {
+    <E extends object, T extends object>(entity: E, Constructor: IDEF<T>, args?: unknown[]): InstanceResult<Merge<E, T>>;
+}
+export interface CallFunction extends CallableFunction {
+    <E extends object, T extends object>(entity: E, Constructor: IDEF<T>, ...args: unknown[]): InstanceResult<Merge<E, T>>;
+}
+export interface BindFunction extends CallableFunction {
+    <E extends object, T extends object>(entity: E, Constructor: IDEF<T>): (...args: unknown[]) => InstanceResult<Merge<E, T>>;
+}
 export interface UtilsCollection {
-    extract: (instance: object) => Record<string, unknown>;
-    pick: (instance: object, ...args: (string | string[])[]) => Record<string, unknown>;
+    extract<T extends object>(instance: T): Extracted<T>;
+    pick<T extends object, K extends keyof T>(instance: T, ...args: (K | K[])[]): {
+        [P in K]: T[P];
+    } & {};
+    pick<T extends object>(instance: T, ...args: (string | string[])[]): Record<string, unknown>;
+    clone<T extends object>(instance: T): T;
+    fork<T extends object>(instance: T): (this: object, ...forkArgs: unknown[]) => T;
+    sibling(instance: object): SiblingAccessor;
     collectConstructors: (instance: object, flat?: boolean) => (CallableFunction | string)[];
-    merge: (...args: unknown[]) => unknown;
-    parse: (value: unknown) => object | undefined;
-    parent: (instance: object, strict?: boolean) => object | undefined;
-    toJSON: (instance: object) => string;
+    merge<A extends object, B extends object>(a: A, b: B, ...args: unknown[]): InstanceResult<Merge<B, A>>;
+    parse<T extends object>(self: T): Parsed<T>;
+    parent<T extends object>(instance: T, path?: string): object | undefined;
+    toJSON<T extends object>(instance: T): string;
     [key: string]: CallableFunction;
 }
 export interface MnemonicaModule {
@@ -240,7 +263,7 @@ export interface MnemonicaModule {
     apply: ApplyFunction;
     call: CallFunction;
     bind: BindFunction;
-    decorate: <U extends Constructor<object>>(target?: object, config?: object) => DecoratedClass<U>;
+    decorate: <T extends Constructor<object> | constructorOptions | undefined = undefined>(target?: T, config?: constructorOptions) => <U extends Constructor<object>>(cstr: U) => DecoratedClass<U>;
     registerHook: <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook) => void;
     defaultTypes: TypesCollection;
     BASE_MNEMONICA_ERROR: MnemonicaErrorConstructor;
@@ -258,12 +281,10 @@ export interface MnemonicaModule {
     WRONG_STACK_CLEANER: MnemonicaErrorConstructor;
     MNEMONICA: string;
     MNEMOSYNE: string;
-    URANUS: string;
     SymbolParentType: symbol;
     SymbolConstructorName: symbol;
     SymbolDefaultTypesCollection: symbol;
     SymbolConfig: symbol;
-    SymbolGaia: symbol;
     TYPE_TITLE_PREFIX: string;
     ErrorMessages: ErrorMessages;
     utils: UtilsCollection;

package/build/types/index.js

@@ -1,3 +1,3 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC","sourcesContent":["'use strict';\n/* eslint no-unused-vars: \"off\" */\n\n// Props type for getProps/setProps\nexport type PropsType = Record<string, unknown>;\n\n// Core type definitions for mnemonica\n\n// Base constructor function type - can be a class constructor or a function.\n// Args defaults to unknown[] so IDEF<T> is backwards compatible;\n// supply Args to get typed constructor params: IDEF<MyType, [string, number]>\nexport type IDEF<T, Args extends unknown[] = unknown[]> = { new(): T } | { (this: T, ...args: Args): void };\n\n// Error message types - all error messages are strings\nexport type ErrorMessageKey =\n\t| 'BASE_ERROR_MESSAGE'\n\t| 'HANDLER_MUST_BE_A_FUNCTION'\n\t| 'WRONG_TYPE_DEFINITION'\n\t| 'WRONG_INSTANCE_INVOCATION'\n\t| 'WRONG_MODIFICATION_PATTERN'\n\t| 'ALREADY_DECLARED'\n\t| 'WRONG_ARGUMENTS_USED'\n\t| 'WRONG_HOOK_TYPE'\n\t| 'MISSING_HOOK_CALLBACK'\n\t| 'MISSING_CALLBACK_ARGUMENT'\n\t| 'OPTIONS_ERROR'\n\t| 'WRONG_STACK_CLEANER';\n\t// | 'TYPENAME_MUST_BE_A_STRING'\n\t// | 'FLOW_CHECKER_REDEFINITION'\n\n// Error messages object type\nexport type ErrorMessages = Record<ErrorMessageKey, string>;\n\n// Hook callback — passed to registerHook and invoked by invokeHook\nexport interface hook extends CallableFunction {\n\t(opts: hooksOpts): unknown;\n}\n\n// Error constructor from constructError - constructable function with prototype\nexport interface MnemonicaErrorConstructor {\n\tnew(addition?: string, stack?: string | string[]): Error;\n\t(name: string): Error;\n\tprototype: {\n\t\tconstructor: MnemonicaErrorConstructor;\n\t};\n}\n\n// Errors types map - indexable record of error constructors\nexport type ErrorsTypesMap = Record<string, MnemonicaErrorConstructor>;\n\n// Mnemonica error interface for extended Error objects\nexport interface MnemonicaError extends Error {\n\texceptionReason?: Error;\n\treasons?: Error[];\n\tsurplus?: Error[];\n}\n\n/**\n * Internal Type Constructor.\n * \"Type\" here is used in the Computer Science sense — an interface/contract\n * describing what a constructor must satisfy (both `new`-able and callable).\n * TC = Type Constructor; \"Internal\" means this is the library's own constructor\n * shape, distinct from user-facing TypeConstructor below.\n */\nexport interface _Internal_TC_<ConstructorInstance extends object> {\n\tnew(...args: unknown[]): ConstructorInstance;\n\t(this: ConstructorInstance, ...args: unknown[]): ConstructorInstance;\n\treadonly prototype: ConstructorInstance & {\n\t\treadonly constructor: _Internal_TC_<ConstructorInstance>\n\t};\n}\n\n/**\n * Public alias for _Internal_TC_ — the shape of constructor functions returned by `define()`.\n * Augmented by tactica-generated TypeRegistry to become user-specific types.\n * Kept as a named alias (rather than inlining _Internal_TC_) so tactica can reference it\n * cleanly in generated declaration files.\n */\nexport type TypeConstructor<ConstructorInstance extends object> = _Internal_TC_<ConstructorInstance>;\n\n// Hook types\nexport type hooksTypes = 'preCreation' | 'postCreation' | 'creationError';\n\n// Hook options passed to hook callbacks\n// P = parent / existent instance (proto)\n// T = child / inherited instance (type being created)\nexport type hooksOpts<P = object, T = P> = {\n\tTypeName: string;\n\ttype: TypeDef;\n\targs: unknown[];\n\texistentInstance: P;\n\tinheritedInstance?: T;\n\tcreator?: { throwModificationError(error: Error): void };\n};\n\n// Callback passed into ModificationConstructor to attach internal props to the prototype\nexport interface AddPropsCallback extends CallableFunction {\n\t(proto: object): void;\n}\n\n// ModificationConstructor: wires prototype chain during instance creation\nexport interface ModificationConstructor extends CallableFunction {\n\t(\n\t\tthis: object,\n\t\tModificatorType: MnemonicaConstructor,\n\t\tModificatorTypePrototype: object,\n\t\t_addProps: AddPropsCallback\n\t): MnemonicaConstructor;\n}\n\n// Factory that returns a ModificationConstructor (used in constructorOptions)\nexport interface ModificationConstructorFactory extends CallableFunction {\n\t(): ModificationConstructor;\n}\n\n// Factory that returns a MnemonicaConstructor (stored in TypeDef.constructHandler)\nexport interface MnemonicaConstructorFactory extends CallableFunction {\n\t(): MnemonicaConstructor;\n}\n\n// Marks the top of a captured stack trace (passed to Error.captureStackTrace as constructorOpt)\nexport interface StackBoundary extends CallableFunction {}\n\n// A wrappable utility method — any callable that wrapThis() can proxy\nexport interface WrappableMethod extends CallableFunction {}\n\n// Constructor options for define - default (exposeInstanceMethods defaults to true behavior)\nexport type constructorOptions = {\n\t// explicit declaration we wish use\n\t// an old style based constructors\n\tModificationConstructor?: ModificationConstructorFactory,\n\t// shall or not we use strict checking\n\t// for creation sub-instances Only from current type\n\t// or we might use up-nested sub-instances from chain\n\tstrictChain?: boolean,\n\t// should we use forced errors checking\n\t// to make all inherited types errored\n\t// if there is an error somewhere in chain\n\tblockErrors?: boolean,\n\t// if it is necessary to collect stack\n\t// as a __stack__ prototype property\n\t// during the process of instance creation\n\tsubmitStack?: boolean,\n\t// await new Constructor()\n\t// must return value\n\tawaitReturn?: boolean,\n\t// Force class mode (auto-detected by default)\n\tasClass?: boolean,\n\t// Expose instance methods (extract, pick, parent, clone, fork, exception, sibling)\n\t// on the instance type. When false, these methods are still available on the prototype\n\t// but hidden from the type definition unless explicitly exposed.\n\texposeInstanceMethods?: boolean,\n};\n\n// Constructor options that explicitly hide instance methods\nexport type HideInstanceMethodsOptions = constructorOptions & {\n\texposeInstanceMethods: true;\n};\n\n// Subtypes map - represents the subtypes property\nexport type SubtypesMap = Map<string, TypeClass>;\n\n// Type definition object (internal properties)\nexport type TypeDef = {\n\tTypeName: string;\n\tproto: object;\n\tisSubType: boolean;\n\tsubtypes: SubtypesMap;\n\tcollection: CollectionDef;\n\tconfig: constructorOptions;\n\tparentType?: TypeDef;\n\tconstructHandler: MnemonicaConstructorFactory;\n\ttitle: string;\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook: (hookType: hooksTypes, opts: hooksOpts) => Set<unknown>;\n\tprototype: unknown;\n\tstack?: string;\n\t[Symbol.hasInstance]: (instance: object) => boolean;\n};\n\n// Collection definition\nexport type CollectionDef = Hookable & {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n};\n\n// Type lookup function type: may have augmentation by Tactica re-definition\nexport interface TypeLookup extends CallableFunction {\n\t(this: Map<string, unknown>, TypeNestedPath: string): TypeClass | undefined;\n}\n\n// Specification for chained subtype creation with .then()\nexport interface ThenSpec {\n\tsubtype: object;\n\targs: unknown[];\n\tname?: string;\n}\n\n// Context object passed through the InstanceCreator pipeline\nexport interface InstanceCreatorContext {\n\ttype: TypeDef;\n\tTypeName: string;\n\texistentInstance: object;\n\targs: unknown[];\n\tModificationConstructor: ModificationConstructor;\n\tModificatorType: MnemonicaConstructor;\n\tInstanceModificator: MnemonicaConstructor;\n\tinheritedInstance: object | Promise<object>;\n\tconfig: constructorOptions;\n\tproto: object;\n\t__proto_proto__?: object;\n\tstack?: string[];\n\n\tgetExistentAsyncStack(existentInstance: object): unknown;\n\tpostProcessing(continuationOf?: TypeDef): void;\n\tmakeAwaiter(type: TypeDef, then?: ThenSpec): Promise<object>;\n\taddThen(then: ThenSpec): void;\n\tinvokePreHooks(): void;\n\tinvokePostHooks(): { type: Set<unknown>; collection: Set<unknown> };\n\tthrowModificationError(error: MnemonicaError): void;\n}\n\n/**\n * Proto merge type - combines parent and child types without property conflicts.\n *\n * When a subtype is defined from a parent instance, we want the child properties\n * to take precedence. `Exclude<keyof P, keyof T>` removes overlapping keys from P,\n * so `Pick<P, ...>` only brings in parent properties that don't clash with child.\n *\n * Result: child T gets all its own props, plus parent's non-overlapping props.\n */\nexport type Proto<P extends object, T extends object> = T & Pick<P, Exclude<keyof P, keyof T>>;\n\n\n// export type ProtoFlat<\n// \tP extends object,\n// \tT extends object,\n// \tF extends Proto<P, T> = Proto<P, T>\n// > = { [key in keyof F]: F[key]} ;\n\nexport type ProtoFlat<\n\tP extends object,\n\tT extends object,\n\tL extends Exclude<keyof P, keyof T> = Exclude<keyof P, keyof T>,\n> = {\n    [key in keyof T]: T[key];\n} & {\n\t[key in L]: P[key];\n};\n\nexport type Flatten<F> = { [key in keyof F]: F[key] }\n\n// Sibling type accessor\nexport interface SiblingAccessor {\n\t(SiblingTypeName: string): TypeClass | undefined;\n\t[key: string]: TypeClass | undefined;\n}\n\n// Mnemonica instance methods interface\n// These methods are always available on the prototype chain\n// but can be hidden from type definitions via exposeInstanceMethods option\nexport interface MnemonicaInstance {\n\textract(): Record<string, unknown>;\n\tpick(...keys: string[]): Record<string, unknown>;\n\tpick(keys: string[]): Record<string, unknown>;\n\tparent(): object | undefined;\n\tparent(constructorLookupPath: string): object | undefined;\n\treadonly clone: object;\n\tfork(...forkArgs: unknown[]): object;\n\texception(error: Error, ...args: unknown[]): Error;\n\treadonly sibling: SiblingAccessor;\n}\n\n// Instance properties for __self__ reference\n// This merges internal props with the instance methods\n// Internal instance properties (non-enumerable)\n// These are always present on instances but accessed via getProps/setProps\nexport type InstanceInternalProps = {\n\t__proto_proto__: object;\n\t__args__: unknown[];\n\t__collection__: CollectionDef;\n\t__subtypes__: Map<string, object>;\n\t__type__: TypeDef;\n\t__parent__: object;\n\t__stack__?: string;\n\t__creator__: InstanceCreatorContext;\n\t__timestamp__: number;\n};\n\n// Combined Props type for internal use inside ./src\nexport type Props = InstanceInternalProps & {\n\t__self__: InstanceInternalProps & MnemonicaInstance;\n\t[key: string]: unknown;\n};\n\n// Helper type: true when exposeInstanceMethods is explicitly false\nexport type IsHidingMethods<Config extends constructorOptions> =\n  Config extends { exposeInstanceMethods: false } ? true : false;\n\n// Combined instance type based on config:\n//   hiding → Flatten<N> (user props only)\n//   showing → Flatten<N> & MnemonicaInstance (user props + extract/fork/etc.)\nexport type InstanceResult<\n  N extends object,\n  Config extends constructorOptions,\n> = IsHidingMethods<Config> extends true ? Flatten<N> : Flatten<N> & MnemonicaInstance;\n\n// Definitor instance - the constructor function returned by define\n// N = instance type (properties available on instances)\n// S = subtypes map\n// Config = constructor options controlling type visibility\nexport interface IDefinitorInstance<\n\tN extends object,\n\tConfig extends constructorOptions = constructorOptions,\n\tR extends InstanceResult<N, Config> = InstanceResult<N, Config>\n> {\n\n\tTypeName: string;\n\tprototype: N;\n\n\t\n\t// the line below declares a `new ...` invocation,\n\t// so makes interface constructible\n\t// new(...args: unknown[]): { [key in keyof R]: R[key] };\n\tnew(...args: unknown[]): R;\n\n\t\n\t// TODO: need check if line below works\n\t// also TS hinting check as well\n\t// the line below should make is a @decorate decorator working\n\t(...args: unknown[]): IDefinitorInstance<R, Config>;\n\n\n\t// Define method that combines parent N with new type T using Proto\n\tdefine<\n\t\tT extends object,\n\n\t\t// this will be instance type for sub-type !!!\n\t\t// F extends Flatten<Proto<N, T>>\n\t\tF extends Proto<N, T>\n\t>(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<F, Config>;\n\t\n\tlookup: TypeLookup;\n\t\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\n\t\n\tsubtypes: SubtypesMap;\n\t\n\t// Internal properties accessed by tests\n\t__type__?: TypeDef;\n\tcollection?: CollectionDef;\n\n\t/*\n\t// Allow dynamic property access for subtypes\n\t[key: string]: unknown;\n\t*/\n}\n\n// Type absorber function type - used for defining subtypes\n// Supports multiple calling conventions:\n// 1. Modern: define(TypeName, constructHandler, config?)\n// 2. Legacy: define(constructHandler, config?) - TypeName from constructor name\n// 3. Nested: parentType.define(TypeName, constructHandler, config?)\n// Using interface with overloads to properly handle exposeInstanceMethods option\nexport interface TypeAbsorber extends CallableFunction {\n\t// Overload: with exposeInstanceMethods: false - hide instance methods\n\t<T extends object>(\n\t\tthis: unknown,\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined: HideInstanceMethodsOptions\n\t): IDefinitorInstance<T, HideInstanceMethodsOptions>;\n\t\n\t// Overload: without config or with exposeInstanceMethods not false - show all\n\t<T extends object>(\n\t\tthis: unknown,\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<T, constructorOptions>;\n}\n\n// TypesCollection interface for createTypesCollection\n// This represents the actual return type of createTypesCollection\nexport interface TypesCollection extends Hookable {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n}\n\n// Shared interface for objects that support hooks (TypeDef and CollectionDef)\nexport interface Hookable {\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook(hookType: hooksTypes, opts: hooksOpts): Set<unknown>;\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\tregisterFlowChecker(cb: (opts: object) => unknown): void;\n}\n\n// createTypesCollection function type\nexport type CreateTypesCollectionFunction = (config?: constructorOptions) => TypesCollection;\n\n// Type class - base type constructor\nexport type TypeClass = IDefinitorInstance<object>;\n\n// Mnemonica constructor — the constructor function returned by constructHandler()\n// Has SymbolConstructorName attached and is both newable and callable\nexport interface MnemonicaConstructor extends NewableFunction {\n\tnew (...args: unknown[]): object;\n\t(this: object, ...args: unknown[]): unknown;\n\t[key: symbol]: unknown;\n}\n\n// Type descriptor instance — internal shape of TypeDescriptor objects\nexport interface TypeDescriptorDefine extends CallableFunction {\n\t(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: CallableFunction | object,\n\t\tconfig?: object\n\t): TypeClass;\n}\n\nexport interface TypeDescriptorLookup extends CallableFunction {\n\t(TypeNestedPath: string): TypeClass | undefined;\n}\n\nexport type TypeDescriptorInstance = {\n\tdefine: TypeDescriptorDefine;\n\tlookup: TypeDescriptorLookup;\n\tsubtypes: Map<string, object>;\n\tTypeName: string;\n};\n\n// Constructor type for decorate function\nexport type Constructor<T = object> = new (...args: unknown[]) => T;\n\n// Decorated class type - includes call signature for decorator pattern\nexport type DecoratedClass<T extends Constructor<object>> =\n\tT &\n\t(<U extends Constructor<object>>(target: U) => DecoratedClass<U>) & {\n\t\tdefine: TypeAbsorber;\n\t\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\tlookup: TypeLookup;\n\t\tTypeName: string;\n\t};\n\n// Apply/Call/Bind function types\nexport type ApplyFunction = <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\targs?: unknown[]\n) => S;\n\nexport type CallFunction = <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>,\n\t...args: unknown[]\n) => S;\n\nexport type BindFunction = <E extends object, T extends object, S extends Proto<E, T>>(\n\tentity: E,\n\tConstructor: IDEF<T>\n) => (...args: unknown[]) => S;\n\n// Utils object type\nexport interface UtilsCollection {\n\textract: (instance: object) => Record<string, unknown>;\n\tpick: (instance: object, ...args: (string | string[])[]) => Record<string, unknown>;\n\tcollectConstructors: (instance: object, flat?: boolean) => (CallableFunction | string)[];\n\tmerge: (...args: unknown[]) => unknown;\n\tparse: (value: unknown) => object | undefined;\n\tparent: (instance: object, strict?: boolean) => object | undefined;\n\ttoJSON: (instance: object) => string;\n\t[key: string]: CallableFunction;\n}\n\n// Main mnemonica module interface - represents the exported module object\nexport interface MnemonicaModule {\n\t// Core functions\n\tdefine: TypeAbsorber;\n\tlookup: (TypeNestedPath: string) => TypeClass | undefined;\n\tapply: ApplyFunction;\n\tcall: CallFunction;\n\tbind: BindFunction;\n\tdecorate: <U extends Constructor<object>>(target?: object, config?: object) => DecoratedClass<U>;\n\tregisterHook: <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook) => void;\n\n\t// Descriptors\n\tdefaultTypes: TypesCollection;\n\n\t// Errors\n\tBASE_MNEMONICA_ERROR: MnemonicaErrorConstructor;\n\tWRONG_TYPE_DEFINITION: MnemonicaErrorConstructor;\n\tWRONG_INSTANCE_INVOCATION: MnemonicaErrorConstructor;\n\tWRONG_MODIFICATION_PATTERN: MnemonicaErrorConstructor;\n\tALREADY_DECLARED: MnemonicaErrorConstructor;\n\tWRONG_ARGUMENTS_USED: MnemonicaErrorConstructor;\n\tWRONG_HOOK_TYPE: MnemonicaErrorConstructor;\n\tMISSING_CALLBACK_ARGUMENT: MnemonicaErrorConstructor;\n\t// FLOW_CHECKER_REDEFINITION: MnemonicaErrorConstructor;\n\tMISSING_HOOK_CALLBACK: MnemonicaErrorConstructor;\n\tTYPENAME_MUST_BE_A_STRING: MnemonicaErrorConstructor;\n\tHANDLER_MUST_BE_A_FUNCTION: MnemonicaErrorConstructor;\n\tOPTIONS_ERROR: MnemonicaErrorConstructor;\n\tWRONG_STACK_CLEANER: MnemonicaErrorConstructor;\n\n\t// Constants\n\tMNEMONICA: string;\n\tMNEMOSYNE: string;\n\tURANUS: string;\n\tSymbolParentType: symbol;\n\tSymbolConstructorName: symbol;\n\tSymbolDefaultTypesCollection: symbol;\n\tSymbolConfig: symbol;\n\tSymbolGaia: symbol;\n\tTYPE_TITLE_PREFIX: string;\n\tErrorMessages: ErrorMessages;\n\n\t// Utils\n\tutils: UtilsCollection;\n\tgetProps: (instance: object) => PropsType | undefined;\n\tsetProps: (instance: object, values: object) => string[] | false;\n\tfindSubTypeFromParent: (instance: object | undefined, subType: string) => object | null;\n\tisClass: (fn: CallableFunction) => boolean;\n\n\t// createTypesCollection\n\tcreateTypesCollection: CreateTypesCollectionFunction;\n\n\t// Allow additional properties\n\t[key: string]: unknown;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC","sourcesContent":["'use strict';\n/* eslint no-unused-vars: \"off\" */\n\n// Props type for getProps/setProps\nexport type PropsType = Record<string, unknown>;\n\n// Core type definitions for mnemonica\n\n// Base constructor function type - can be a class constructor or a function.\n// Args defaults to unknown[] so IDEF<T> is backwards compatible;\n// supply Args to get typed constructor params: IDEF<MyType, [string, number]>\nexport type IDEF<T, Args extends unknown[] = unknown[]> = { new(): T } | { (this: T, ...args: Args): void };\n\n// Error message types - all error messages are strings\nexport type ErrorMessageKey =\n\t| 'BASE_ERROR_MESSAGE'\n\t| 'HANDLER_MUST_BE_A_FUNCTION'\n\t| 'WRONG_TYPE_DEFINITION'\n\t| 'WRONG_INSTANCE_INVOCATION'\n\t| 'WRONG_MODIFICATION_PATTERN'\n\t| 'ALREADY_DECLARED'\n\t| 'WRONG_ARGUMENTS_USED'\n\t| 'WRONG_HOOK_TYPE'\n\t| 'MISSING_HOOK_CALLBACK'\n\t| 'MISSING_CALLBACK_ARGUMENT'\n\t| 'OPTIONS_ERROR'\n\t| 'WRONG_STACK_CLEANER';\n\t// | 'TYPENAME_MUST_BE_A_STRING'\n\t// | 'FLOW_CHECKER_REDEFINITION'\n\n// Error messages object type\nexport type ErrorMessages = Record<ErrorMessageKey, string>;\n\n// Hook callback — passed to registerHook and invoked by invokeHook\nexport interface hook extends CallableFunction {\n\t(opts: hooksOpts): unknown;\n}\n\n// Error constructor from constructError - constructable function with prototype\nexport interface MnemonicaErrorConstructor {\n\tnew(addition?: string, stack?: string | string[]): Error;\n\t(name: string): Error;\n\tprototype: {\n\t\tconstructor: MnemonicaErrorConstructor;\n\t};\n}\n\n// Errors types map - indexable record of error constructors\nexport type ErrorsTypesMap = Record<string, MnemonicaErrorConstructor>;\n\n// Mnemonica error interface for extended Error objects\nexport interface MnemonicaError extends Error {\n\texceptionReason?: Error;\n\treasons?: Error[];\n\tsurplus?: Error[];\n}\n\n/**\n * Internal Type Constructor.\n * \"Type\" here is used in the Computer Science sense — an interface/contract\n * describing what a constructor must satisfy (both `new`-able and callable).\n * TC = Type Constructor; \"Internal\" means this is the library's own constructor\n * shape, distinct from user-facing TypeConstructor below.\n */\nexport interface _Internal_TC_<ConstructorInstance extends object> {\n\tnew(...args: unknown[]): ConstructorInstance;\n\t(this: ConstructorInstance, ...args: unknown[]): ConstructorInstance;\n\treadonly prototype: ConstructorInstance & {\n\t\treadonly constructor: _Internal_TC_<ConstructorInstance>\n\t};\n}\n\n/**\n * Public alias for _Internal_TC_ — the shape of constructor functions returned by `define()`.\n * Augmented by tactica-generated TypeRegistry to become user-specific types.\n * Kept as a named alias (rather than inlining _Internal_TC_) so tactica can reference it\n * cleanly in generated declaration files.\n */\nexport type TypeConstructor<ConstructorInstance extends object> = _Internal_TC_<ConstructorInstance>;\n\n// Hook types\nexport type hooksTypes = 'preCreation' | 'postCreation' | 'creationError';\n\n// Hook options passed to hook callbacks\n// P = parent / existent instance (proto)\n// T = child / inherited instance (type being created)\nexport type hooksOpts<P = object, T = P> = {\n\tTypeName: string;\n\ttype: TypeDef;\n\targs: unknown[];\n\texistentInstance: P;\n\tinheritedInstance?: T;\n\tcreator?: { throwModificationError(error: Error): void };\n};\n\n// Callback passed into ModificationConstructor to attach internal props to the prototype\nexport interface AddPropsCallback extends CallableFunction {\n\t(proto: object): void;\n}\n\n// ModificationConstructor: wires prototype chain during instance creation\nexport interface ModificationConstructor extends CallableFunction {\n\t(\n\t\tthis: object,\n\t\tModificatorType: MnemonicaConstructor,\n\t\tModificatorTypePrototype: object,\n\t\t_addProps: AddPropsCallback\n\t): MnemonicaConstructor;\n}\n\n// Factory that returns a ModificationConstructor (used in constructorOptions)\nexport interface ModificationConstructorFactory extends CallableFunction {\n\t(): ModificationConstructor;\n}\n\n// Factory that returns a MnemonicaConstructor (stored in TypeDef.constructHandler)\nexport interface MnemonicaConstructorFactory extends CallableFunction {\n\t(): MnemonicaConstructor;\n}\n\n// Marks the top of a captured stack trace (passed to Error.captureStackTrace as constructorOpt)\nexport interface StackBoundary extends CallableFunction {}\n\n// A wrappable utility method — any callable that wrapThis() can proxy\nexport interface WrappableMethod extends CallableFunction {}\n\n// Constructor options for define\nexport type constructorOptions = {\n\t// explicit declaration we wish use\n\t// an old style based constructors\n\tModificationConstructor?: ModificationConstructorFactory,\n\t// shall or not we use strict checking\n\t// for creation sub-instances Only from current type\n\t// or we might use up-nested sub-instances from chain\n\tstrictChain?: boolean,\n\t// should we use forced errors checking\n\t// to make all inherited types errored\n\t// if there is an error somewhere in chain\n\tblockErrors?: boolean,\n\t// if it is necessary to collect stack\n\t// as a __stack__ prototype property\n\t// during the process of instance creation\n\tsubmitStack?: boolean,\n\t// await new Constructor()\n\t// must return value\n\tawaitReturn?: boolean,\n\t// Force class mode (auto-detected by default)\n\tasClass?: boolean,\n};\n\n// Subtypes map - represents the subtypes property\nexport type SubtypesMap = Map<string, TypeClass>;\n\n// Type definition object (internal properties)\nexport type TypeDef = {\n\tTypeName: string;\n\tproto: object;\n\tisSubType: boolean;\n\tsubtypes: SubtypesMap;\n\tcollection: CollectionDef;\n\tconfig: constructorOptions;\n\tparentType?: TypeDef;\n\tconstructHandler: MnemonicaConstructorFactory;\n\ttitle: string;\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook: (hookType: hooksTypes, opts: hooksOpts) => Set<unknown>;\n\tprototype: unknown;\n\tstack?: string;\n\t[Symbol.hasInstance]: (instance: object) => boolean;\n};\n\n// Collection definition\nexport type CollectionDef = Hookable & {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n};\n\n// Type lookup function type: may have augmentation by Tactica re-definition\nexport interface TypeLookup extends CallableFunction {\n\t(this: Map<string, unknown>, TypeNestedPath: string): TypeClass | undefined;\n}\n\n// Specification for chained subtype creation with .then()\nexport interface ThenSpec {\n\tsubtype: object;\n\targs: unknown[];\n\tname?: string;\n}\n\n// Context object passed through the InstanceCreator pipeline\nexport interface InstanceCreatorContext {\n\ttype: TypeDef;\n\tTypeName: string;\n\texistentInstance: object;\n\targs: unknown[];\n\tModificationConstructor: ModificationConstructor;\n\tModificatorType: MnemonicaConstructor;\n\tInstanceModificator: MnemonicaConstructor;\n\tinheritedInstance: object | Promise<object>;\n\tconfig: constructorOptions;\n\tproto: object;\n\t__proto_proto__?: object;\n\tstack?: string[];\n\n\tgetExistentAsyncStack(existentInstance: object): unknown;\n\tpostProcessing(continuationOf?: TypeDef): void;\n\tmakeAwaiter(type: TypeDef, then?: ThenSpec): Promise<object>;\n\taddThen(then: ThenSpec): void;\n\tinvokePreHooks(): void;\n\tinvokePostHooks(): { type: Set<unknown>; collection: Set<unknown> };\n\tthrowModificationError(error: MnemonicaError): void;\n}\n\n/**\n * Proto merge type - combines parent and child types without property conflicts.\n *\n * When a subtype is defined from a parent instance, we want the child properties\n * to take precedence. `Exclude<keyof P, keyof T>` removes overlapping keys from P,\n * so `Pick<P, ...>` only brings in parent properties that don't clash with child.\n *\n * Result: child T gets all its own props, plus parent's non-overlapping props.\n */\nexport type Proto<P extends object, T extends object> = T & Pick<P, Exclude<keyof P, keyof T>>;\n\n\n// export type ProtoFlat<\n// \tP extends object,\n// \tT extends object,\n// \tF extends Proto<P, T> = Proto<P, T>\n// > = { [key in keyof F]: F[key]} ;\n\nexport type ProtoFlat<\n\tP extends object,\n\tT extends object,\n\tL extends Exclude<keyof P, keyof T> = Exclude<keyof P, keyof T>,\n> = {\n    [key in keyof T]: T[key];\n} & {\n\t[key in L]: P[key];\n};\n\n// Mnemonica instance method keys. These are filtered out of extracted/merged\n// field-only views because they belong to the prototype, not to the user's\n// enumerable data properties.\nexport type MnemonicaInstanceMethodKeys =\n\t'extract' | 'pick' | 'parent' | 'clone' | 'fork' | 'exception' | 'sibling';\n\nexport type Flatten<F> = { [key in keyof F]: F[key] }\n\n// Extracted<T>: the shape returned by utils.extract(instance).\n// It contains the enumerable string-keyed user properties of the instance,\n// omitting MnemonicaInstance methods (extract, pick, parent, clone, fork,\n// exception, sibling). Optionality is preserved from the source type.\n// The `& {}` trick forces TypeScript to expand the alias in hover tooltips\n// so it renders as a plain object literal instead of \"Extracted<{...}>\".\nexport type Extracted<T extends object> = {\n\t[K in keyof T as K extends string ? (K extends MnemonicaInstanceMethodKeys ? never : K) : never]: T[K];\n} & {};\n\n// Parsed<T>: the shape returned by utils.parse(instance).\n// It is a one-level snapshot of the instance's prototype chain.\n// `props` contains the instance's enumerable user properties;\n// `joint` contains enumerable properties copied from the immediate prototype;\n// `parent` is the next link up the chain (currently not recursively parsed).\nexport type Parsed<T extends object> = {\n\tname: string;\n\tprops: Extracted<T>;\n\tself: T;\n\tproto: object;\n\tjoint: Record<string, unknown>;\n\tparent: object | undefined;\n};\n\n// Sibling type accessor\nexport interface SiblingAccessor {\n\t(SiblingTypeName: string): TypeClass | undefined;\n\t[key: string]: TypeClass | undefined;\n}\n\n// Mnemonica instance methods interface (opt-in).\n// These methods used to be auto-injected onto every instance. They are now\n// available only when a type explicitly adds them to its prototype.\n// Users can still use this interface to type their own root-level helpers.\nexport interface MnemonicaInstance<T extends object = object> {\n\textract(): Extracted<T>;\n\tpick<K extends keyof T>(...keys: (K | K[])[]): { [P in K]: T[P] } & {};\n\tpick(...keys: string[]): Record<string, unknown>;\n\tparent(): object | undefined;\n\tparent(constructorLookupPath: string): object | undefined;\n\treadonly clone: this;\n\tfork(...forkArgs: unknown[]): this;\n\texception(error: Error, ...args: unknown[]): Error;\n\treadonly sibling: SiblingAccessor;\n}\n\n// Instance properties for __self__ reference\n// This merges internal props with the instance methods\n// Internal instance properties (non-enumerable)\n// These are always present on instances but accessed via getProps/setProps\nexport type InstanceInternalProps = {\n\t__proto_proto__: object;\n\t__args__: unknown[];\n\t__collection__: CollectionDef;\n\t__subtypes__: Map<string, object>;\n\t__type__: TypeDef;\n\t__parent__: object;\n\t__stack__?: string;\n\t__creator__: InstanceCreatorContext;\n\t__timestamp__: number;\n};\n\n// Combined Props type for internal use inside ./src\nexport type Props = InstanceInternalProps & {\n\t__self__: InstanceInternalProps;\n\t[key: string]: unknown;\n};\n\n// Combined instance type: plain object with the user's fields only.\n// Instance methods (extract, pick, fork, etc.) are no longer auto-injected.\n// The inline mapped type is used instead of the Flatten alias so that hover\n// tooltips show the actual field object literal first, not \"Flatten<{...}>\".\nexport type InstanceResult<\n  N extends object,\n> = { [K in keyof N]: N[K] };\n\n// Definitor instance - the constructor function returned by define\n// N = instance type (properties available on instances)\n// S = subtypes map\nexport interface IDefinitorInstance<\n\tN extends object,\n\tR extends InstanceResult<N> = InstanceResult<N>\n> {\n\n\tTypeName: string;\n\tprototype: N;\n\n\t\n\t// the line below declares a `new ...` invocation,\n\t// so makes interface constructible\n\t// new(...args: unknown[]): { [key in keyof R]: R[key] };\n\tnew(...args: unknown[]): R;\n\n\t\n\t// TODO: need check if line below works\n\t// also TS hinting check as well\n\t// the line below should make is a @decorate decorator working\n\t(...args: unknown[]): IDefinitorInstance<R>;\n\n\n\t// Define method that combines parent N with new type T using Proto\n\tdefine<\n\t\tT extends object,\n\n\t\t// this will be instance type for sub-type !!!\n\t\t// F extends Flatten<Proto<N, T>>\n\t\tF extends Proto<N, T>\n\t>(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<F>;\n\t\n\tlookup: TypeLookup;\n\t\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\n\t\n\tsubtypes: SubtypesMap;\n\t\n\t// Internal properties accessed by tests\n\t__type__?: TypeDef;\n\tcollection?: CollectionDef;\n\n\t/*\n\t// Allow dynamic property access for subtypes\n\t[key: string]: unknown;\n\t*/\n}\n\n// Type absorber function type - used for defining subtypes\n// Supports multiple calling conventions:\n// 1. Modern: define(TypeName, constructHandler, config?)\n// 2. Legacy: define(constructHandler, config?) - TypeName from constructor name\n// 3. Nested: parentType.define(TypeName, constructHandler, config?)\nexport interface TypeAbsorber extends CallableFunction {\n\t<T extends object>(\n\t\tthis: unknown,\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: IDEF<T> | object | boolean | CallableFunction,\n\t\tconfigOrUndefined?: constructorOptions | CallableFunction | boolean\n\t): IDefinitorInstance<T>;\n}\n\n// TypesCollection interface for createTypesCollection\n// This represents the actual return type of createTypesCollection\nexport interface TypesCollection extends Hookable {\n\tdefine: TypeAbsorber;\n\tlookup: TypeLookup;\n\tsubtypes: SubtypesMap;\n\t[key: string]: unknown;\n}\n\n// Shared interface for objects that support hooks (TypeDef and CollectionDef)\nexport interface Hookable {\n\thooks: Record<string, Set<hook>>;\n\tinvokeHook(hookType: hooksTypes, opts: hooksOpts): Set<unknown>;\n\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\tregisterFlowChecker(cb: (opts: object) => unknown): void;\n}\n\n// createTypesCollection function type\nexport type CreateTypesCollectionFunction = (config?: constructorOptions) => TypesCollection;\n\n// Type class - base type constructor\nexport type TypeClass = IDefinitorInstance<object>;\n\n// Mnemonica constructor — the constructor function returned by constructHandler()\n// Has SymbolConstructorName attached and is both newable and callable\nexport interface MnemonicaConstructor extends NewableFunction {\n\tnew (...args: unknown[]): object;\n\t(this: object, ...args: unknown[]): unknown;\n\t[key: symbol]: unknown;\n}\n\n// Type descriptor instance — internal shape of TypeDescriptor objects\nexport interface TypeDescriptorDefine extends CallableFunction {\n\t(\n\t\tTypeOrTypeName: string | CallableFunction,\n\t\tconstructHandlerOrConfig?: CallableFunction | object,\n\t\tconfig?: object\n\t): TypeClass;\n}\n\nexport interface TypeDescriptorLookup extends CallableFunction {\n\t(TypeNestedPath: string): TypeClass | undefined;\n}\n\nexport type TypeDescriptorInstance = {\n\tdefine: TypeDescriptorDefine;\n\tlookup: TypeDescriptorLookup;\n\tsubtypes: Map<string, object>;\n\tTypeName: string;\n};\n\n// Constructor type for decorate function\nexport type Constructor<T = object> = new (...args: unknown[]) => T;\n\n// Decorated class type - includes call signature for decorator pattern\nexport type DecoratedClass<T extends Constructor<object>> =\n\tT &\n\t(<U extends Constructor<object>>(target: U) => DecoratedClass<U>) & {\n\t\tdefine: TypeAbsorber;\n\t\tregisterHook(hookType: hooksTypes, cb: hook): void;\n\t\tlookup: TypeLookup;\n\t\tTypeName: string;\n\t};\n\n// Helper: merge parent entity (E) and child constructor instance (T) into a\n// single flat object type, filtering out MnemonicaInstance method names.\n// Used by apply/call/bind.\nexport type Merge<E extends object, T extends object> = {\n\t[K in keyof T | keyof E as K extends MnemonicaInstanceMethodKeys ? never : K]:\n\t\tK extends keyof T ? T[K] : E[K & keyof E];\n};\n\n// Apply/Call/Bind function types\n// The return type merges the parent entity fields with the child constructor\n// fields (filtering out MnemonicaInstance method names), producing the same\n// `{ fields }` hover style as `new Type()`.\nexport interface ApplyFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>,\n\t\targs?: unknown[]\n\t): InstanceResult<Merge<E, T>>;\n}\n\nexport interface CallFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>,\n\t\t...args: unknown[]\n\t): InstanceResult<Merge<E, T>>;\n}\n\nexport interface BindFunction extends CallableFunction {\n\t<E extends object, T extends object>(\n\t\tentity: E,\n\t\tConstructor: IDEF<T>\n\t): (...args: unknown[]) => InstanceResult<Merge<E, T>>;\n}\n\n// Utils object type\nexport interface UtilsCollection {\n\textract<T extends object>(instance: T): Extracted<T>;\n\tpick<T extends object, K extends keyof T>(instance: T, ...args: (K | K[])[]): { [P in K]: T[P] } & {};\n\tpick<T extends object>(instance: T, ...args: (string | string[])[]): Record<string, unknown>;\n\tclone<T extends object>(instance: T): T;\n\tfork<T extends object>(instance: T): (this: object, ...forkArgs: unknown[]) => T;\n\tsibling(instance: object): SiblingAccessor;\n\tcollectConstructors: (instance: object, flat?: boolean) => (CallableFunction | string)[];\n\tmerge<A extends object, B extends object>(\n\t\ta: A,\n\t\tb: B,\n\t\t...args: unknown[]\n\t): InstanceResult<Merge<B, A>>;\n\tparse<T extends object>(self: T): Parsed<T>;\n\tparent<T extends object>(instance: T, path?: string): object | undefined;\n\ttoJSON<T extends object>(instance: T): string;\n\t[key: string]: CallableFunction;\n}\n\n// Main mnemonica module interface - represents the exported module object\nexport interface MnemonicaModule {\n\t// Core functions\n\tdefine: TypeAbsorber;\n\tlookup: (TypeNestedPath: string) => TypeClass | undefined;\n\tapply: ApplyFunction;\n\tcall: CallFunction;\n\tbind: BindFunction;\n\tdecorate: <T extends Constructor<object> | constructorOptions | undefined = undefined>(\n\t\ttarget?: T,\n\t\tconfig?: constructorOptions\n\t) => <U extends Constructor<object>>(cstr: U) => DecoratedClass<U>;\n\tregisterHook: <T extends object>(Constructor: IDEF<T>, hookType: hooksTypes, cb: hook) => void;\n\n\t// Descriptors\n\tdefaultTypes: TypesCollection;\n\n\t// Errors\n\tBASE_MNEMONICA_ERROR: MnemonicaErrorConstructor;\n\tWRONG_TYPE_DEFINITION: MnemonicaErrorConstructor;\n\tWRONG_INSTANCE_INVOCATION: MnemonicaErrorConstructor;\n\tWRONG_MODIFICATION_PATTERN: MnemonicaErrorConstructor;\n\tALREADY_DECLARED: MnemonicaErrorConstructor;\n\tWRONG_ARGUMENTS_USED: MnemonicaErrorConstructor;\n\tWRONG_HOOK_TYPE: MnemonicaErrorConstructor;\n\tMISSING_CALLBACK_ARGUMENT: MnemonicaErrorConstructor;\n\t// FLOW_CHECKER_REDEFINITION: MnemonicaErrorConstructor;\n\tMISSING_HOOK_CALLBACK: MnemonicaErrorConstructor;\n\tTYPENAME_MUST_BE_A_STRING: MnemonicaErrorConstructor;\n\tHANDLER_MUST_BE_A_FUNCTION: MnemonicaErrorConstructor;\n\tOPTIONS_ERROR: MnemonicaErrorConstructor;\n\tWRONG_STACK_CLEANER: MnemonicaErrorConstructor;\n\n\t// Constants\n\tMNEMONICA: string;\n\tMNEMOSYNE: string;\n\tSymbolParentType: symbol;\n\tSymbolConstructorName: symbol;\n\tSymbolDefaultTypesCollection: symbol;\n\tSymbolConfig: symbol;\n\tTYPE_TITLE_PREFIX: string;\n\tErrorMessages: ErrorMessages;\n\n\t// Utils\n\tutils: UtilsCollection;\n\tgetProps: (instance: object) => PropsType | undefined;\n\tsetProps: (instance: object, values: object) => string[] | false;\n\tfindSubTypeFromParent: (instance: object | undefined, subType: string) => object | null;\n\tisClass: (fn: CallableFunction) => boolean;\n\n\t// createTypesCollection\n\tcreateTypesCollection: CreateTypesCollectionFunction;\n\n\t// Allow additional properties\n\t[key: string]: unknown;\n}\n"]}

package/build/utils/clone.d.ts

@@ -0,0 +1 @@
+export declare const clone: <T extends object>(instance: T) => T;

package/build/utils/clone.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = void 0;
+const fork_1 = require("./fork");
+const clone = (instance) => {
+    const forkFn = (0, fork_1.fork)(instance);
+    const result = forkFn.call(instance);
+    return result;
+};
+exports.clone = clone;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvbmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvY2xvbmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWSxDQUFDOzs7QUFFYixpQ0FBOEI7QUFFdkIsTUFBTSxLQUFLLEdBQUcsQ0FBbUIsUUFBVyxFQUFLLEVBQUU7SUFFekQsTUFBTSxNQUFNLEdBQUcsSUFBQSxXQUFJLEVBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUIsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQU0sQ0FBQztJQUMxQyxPQUFPLE1BQU0sQ0FBQztBQUVmLENBQUMsQ0FBQztBQU5XLFFBQUEsS0FBSyxTQU1oQiIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuaW1wb3J0IHsgZm9yayB9IGZyb20gJy4vZm9yayc7XG5cbmV4cG9ydCBjb25zdCBjbG9uZSA9IDxUIGV4dGVuZHMgb2JqZWN0PihpbnN0YW5jZTogVCk6IFQgPT4ge1xuXG5cdGNvbnN0IGZvcmtGbiA9IGZvcmsoaW5zdGFuY2UpO1xuXHRjb25zdCByZXN1bHQgPSBmb3JrRm4uY2FsbChpbnN0YW5jZSkgYXMgVDtcblx0cmV0dXJuIHJlc3VsdDtcblxufTtcbiJdfQ==

package/build/utils/collectConstructors.js

@@ -4,15 +4,17 @@ exports.collectConstructors = void 0;
 const constants_1 = require("../constants");
 const { MNEMOSYNE, MNEMONICA, } = constants_1.constants;
 const getAdditor = (constructors) => {
-    return Array.isArray(constructors) ?
+    const result = Array.isArray(constructors) ?
         (name) => {
             constructors.push(name);
         } : (name) => {
         constructors[name] = true;
     };
+    return result;
 };
 const getAccumulator = (asSequence) => {
-    return asSequence ? [] : {};
+    const result = asSequence ? [] : {};
+    return result;
 };
 const collectConstructors = (self, asSequence = false) => {
     const constructors = getAccumulator(asSequence);
@@ -58,4 +60,4 @@ const collectConstructors = (self, asSequence = false) => {
     return constructors;
 };
 exports.collectConstructors = collectConstructors;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/exception.d.ts

@@ -0,0 +1 @@
+export declare const exception: (instance: object, error: Error, ...args: unknown[]) => any;

package/build/utils/exception.js

@@ -0,0 +1,14 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exception = void 0;
+const exceptionConstructor_1 = __importDefault(require("../api/errors/exceptionConstructor"));
+const exception = function (instance, error, ...args) {
+    const target = new.target;
+    const exceptionResult = exceptionConstructor_1.default.call(instance, target, error, ...args);
+    return exceptionResult;
+};
+exports.exception = exception;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhjZXB0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2V4Y2VwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZLENBQUM7Ozs7OztBQUViLDhGQUFzRTtBQUUvRCxNQUFNLFNBQVMsR0FBRyxVQUFVLFFBQWdCLEVBQUUsS0FBWSxFQUFFLEdBQUcsSUFBZTtJQUVwRixNQUFNLE1BQU0sR0FBRyxHQUFHLENBQUMsTUFBTSxDQUFDO0lBQzFCLE1BQU0sZUFBZSxHQUFHLDhCQUFvQixDQUFDLElBQUksQ0FDaEQsUUFBUSxFQUNSLE1BQU0sRUFDTixLQUFLLEVBQ0wsR0FBRyxJQUFJLENBQ1AsQ0FBQztJQUNGLE9BQU8sZUFBZSxDQUFDO0FBRXhCLENBQUMsQ0FBQztBQVhXLFFBQUEsU0FBUyxhQVdwQiIsInNvdXJjZXNDb250ZW50IjpbIid1c2Ugc3RyaWN0JztcblxuaW1wb3J0IGV4Y2VwdGlvbkNvbnN0cnVjdG9yIGZyb20gJy4uL2FwaS9lcnJvcnMvZXhjZXB0aW9uQ29uc3RydWN0b3InO1xuXG5leHBvcnQgY29uc3QgZXhjZXB0aW9uID0gZnVuY3Rpb24gKGluc3RhbmNlOiBvYmplY3QsIGVycm9yOiBFcnJvciwgLi4uYXJnczogdW5rbm93bltdKSB7XG5cblx0Y29uc3QgdGFyZ2V0ID0gbmV3LnRhcmdldDtcblx0Y29uc3QgZXhjZXB0aW9uUmVzdWx0ID0gZXhjZXB0aW9uQ29uc3RydWN0b3IuY2FsbChcblx0XHRpbnN0YW5jZSxcblx0XHR0YXJnZXQsXG5cdFx0ZXJyb3IsXG5cdFx0Li4uYXJnc1xuXHQpO1xuXHRyZXR1cm4gZXhjZXB0aW9uUmVzdWx0O1xuXG59O1xuIl19

package/build/utils/extract.d.ts

@@ -1,3 +1,2 @@
-export declare const extract: (instance: object) => {
-    [index: string]: unknown;
-};
+import type { Extracted } from '../types';
+export declare const extract: <T extends object>(instance: T) => Extracted<T>;

package/build/utils/extract.js

@@ -11,7 +11,8 @@ const extract = (instance) => {
     for (const name in instance) {
         extracted[name] = instance[name];
     }
-    return extracted;
+    const result = extracted;
+    return result;
 };
 exports.extract = extract;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0cmFjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9leHRyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsa0RBQW9EO0FBQ3BELE1BQU0sRUFBRSx5QkFBeUIsRUFBRSxHQUFHLG9CQUFXLENBQUM7QUFJM0MsTUFBTSxPQUFPLEdBQUcsQ0FBRSxRQUFnQixFQUFHLEVBQUU7SUFHN0MsSUFBSyxRQUFRLEtBQUssTUFBTSxDQUFFLFFBQVEsQ0FBRSxFQUFHLENBQUM7UUFDdkMsTUFBTSxJQUFJLHlCQUF5QixDQUFDO0lBQ3JDLENBQUM7SUFFRCxNQUFNLFNBQVMsR0FBbUMsRUFBRSxDQUFDO0lBRXJELEtBQU0sTUFBTSxJQUFJLElBQUksUUFBUSxFQUFHLENBQUM7UUFRL0IsU0FBUyxDQUFFLElBQUksQ0FBRSxHQUFLLFFBQXFDLENBQUUsSUFBSSxDQUFFLENBQUM7SUFDckUsQ0FBQztJQUVELE9BQU8sU0FBUyxDQUFDO0FBRWxCLENBQUMsQ0FBQztBQXRCVyxRQUFBLE9BQU8sV0FzQmxCIiwic291cmNlc0NvbnRlbnQiOlsiJ3VzZSBzdHJpY3QnO1xuXG5pbXBvcnQgeyBFcnJvcnNUeXBlcyB9IGZyb20gJy4uL2Rlc2NyaXB0b3JzL2Vycm9ycyc7XG5jb25zdCB7IFdST05HX0lOU1RBTkNFX0lOVk9DQVRJT04gfSA9IEVycm9yc1R5cGVzO1xuXG4vLyBpbXBvcnQgeyBob3AgfSBmcm9tICcuL2hvcCc7XG5cbmV4cG9ydCBjb25zdCBleHRyYWN0ID0gKCBpbnN0YW5jZTogb2JqZWN0ICkgPT4ge1xuXG5cdC8vIGF0IHRoaXMgc2l0dWF0aW9uIHRoaXMgY2hlY2sgaXMgZW5vdWdoXG5cdGlmICggaW5zdGFuY2UgIT09IE9iamVjdCggaW5zdGFuY2UgKSApIHtcblx0XHR0aHJvdyBuZXcgV1JPTkdfSU5TVEFOQ0VfSU5WT0NBVElPTjtcblx0fVxuXG5cdGNvbnN0IGV4dHJhY3RlZDogeyBbIGluZGV4OiBzdHJpbmcgXTogdW5rbm93biB9ID0ge307XG5cblx0Zm9yICggY29uc3QgbmFtZSBpbiBpbnN0YW5jZSApIHtcblx0XHQvLyBpZiAoIG5hbWUgPT09ICdjb25zdHJ1Y3RvcicgJiYgIWhvcCggaW5zdGFuY2UsIG5hbWUgKSApIHtcblx0XHQvLyBcdGNvbnRpbnVlO1xuXHRcdC8vIH1cblx0XHQvLyBpZiAobmFtZSA9PT0gJ3RpbWVzdGFtcCcpIHtcblx0XHQvLyBcdGNvbnRpbnVlO1xuXHRcdC8vIH1cblxuXHRcdGV4dHJhY3RlZFsgbmFtZSBdID0gKCBpbnN0YW5jZSBhcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiApWyBuYW1lIF07XG5cdH1cblxuXHRyZXR1cm4gZXh0cmFjdGVkO1xuXG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0cmFjdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9leHRyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7O0FBRWIsa0RBQW9EO0FBQ3BELE1BQU0sRUFBRSx5QkFBeUIsRUFBRSxHQUFHLG9CQUFXLENBQUM7QUFNM0MsTUFBTSxPQUFPLEdBQUcsQ0FBb0IsUUFBVyxFQUFpQixFQUFFO0lBR3hFLElBQUssUUFBUSxLQUFLLE1BQU0sQ0FBRSxRQUFRLENBQUUsRUFBRyxDQUFDO1FBQ3ZDLE1BQU0sSUFBSSx5QkFBeUIsQ0FBQztJQUNyQyxDQUFDO0lBRUQsTUFBTSxTQUFTLEdBQW1DLEVBQUUsQ0FBQztJQUVyRCxLQUFNLE1BQU0sSUFBSSxJQUFJLFFBQVEsRUFBRyxDQUFDO1FBUS9CLFNBQVMsQ0FBRSxJQUFJLENBQUUsR0FBSyxRQUFxQyxDQUFFLElBQUksQ0FBRSxDQUFDO0lBQ3JFLENBQUM7SUFFRCxNQUFNLE1BQU0sR0FBRyxTQUF5QixDQUFDO0lBQ3pDLE9BQU8sTUFBTSxDQUFDO0FBRWYsQ0FBQyxDQUFDO0FBdkJXLFFBQUEsT0FBTyxXQXVCbEIiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7IEVycm9yc1R5cGVzIH0gZnJvbSAnLi4vZGVzY3JpcHRvcnMvZXJyb3JzJztcbmNvbnN0IHsgV1JPTkdfSU5TVEFOQ0VfSU5WT0NBVElPTiB9ID0gRXJyb3JzVHlwZXM7XG5cbmltcG9ydCB0eXBlIHsgRXh0cmFjdGVkIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG4vLyBpbXBvcnQgeyBob3AgfSBmcm9tICcuL2hvcCc7XG5cbmV4cG9ydCBjb25zdCBleHRyYWN0ID0gPFQgZXh0ZW5kcyBvYmplY3Q+KCBpbnN0YW5jZTogVCApOiBFeHRyYWN0ZWQ8VD4gPT4ge1xuXG5cdC8vIGF0IHRoaXMgc2l0dWF0aW9uIHRoaXMgY2hlY2sgaXMgZW5vdWdoXG5cdGlmICggaW5zdGFuY2UgIT09IE9iamVjdCggaW5zdGFuY2UgKSApIHtcblx0XHR0aHJvdyBuZXcgV1JPTkdfSU5TVEFOQ0VfSU5WT0NBVElPTjtcblx0fVxuXG5cdGNvbnN0IGV4dHJhY3RlZDogeyBbIGluZGV4OiBzdHJpbmcgXTogdW5rbm93biB9ID0ge307XG5cblx0Zm9yICggY29uc3QgbmFtZSBpbiBpbnN0YW5jZSApIHtcblx0XHQvLyBpZiAoIG5hbWUgPT09ICdjb25zdHJ1Y3RvcicgJiYgIWhvcCggaW5zdGFuY2UsIG5hbWUgKSApIHtcblx0XHQvLyBcdGNvbnRpbnVlO1xuXHRcdC8vIH1cblx0XHQvLyBpZiAobmFtZSA9PT0gJ3RpbWVzdGFtcCcpIHtcblx0XHQvLyBcdGNvbnRpbnVlO1xuXHRcdC8vIH1cblxuXHRcdGV4dHJhY3RlZFsgbmFtZSBdID0gKCBpbnN0YW5jZSBhcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiApWyBuYW1lIF07XG5cdH1cblxuXHRjb25zdCByZXN1bHQgPSBleHRyYWN0ZWQgYXMgRXh0cmFjdGVkPFQ+O1xuXHRyZXR1cm4gcmVzdWx0O1xuXG59O1xuIl19

package/build/utils/fork.d.ts

@@ -0,0 +1 @@
+export declare const fork: <T extends object>(instance: T) => (this: object, ...forkArgs: unknown[]) => T;

package/build/utils/fork.js

@@ -0,0 +1,33 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fork = void 0;
+const Props_1 = require("../api/types/Props");
+const InstanceCreator_1 = require("../api/types/InstanceCreator");
+const index_1 = __importDefault(require("../api/utils/index"));
+const { reflectPrimitiveWrappers } = index_1.default;
+const fork = (instance) => {
+    const props = (0, Props_1.getProps)(instance);
+    const { __type__: type, __collection__: collection, __parent__: existentInstance, __args__, __self__, } = props;
+    const { isSubType, TypeName } = type;
+    const result = function (...forkArgs) {
+        let forked;
+        const Constructor = isSubType ?
+            existentInstance :
+            collection;
+        const args = forkArgs.length ? forkArgs : __args__;
+        if (this === __self__) {
+            forked = new (Constructor[TypeName])(...args);
+        }
+        else {
+            forked = new InstanceCreator_1.InstanceCreator(type, reflectPrimitiveWrappers(this), args);
+        }
+        const forkResult = forked;
+        return forkResult;
+    };
+    return result;
+};
+exports.fork = fork;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9mb3JrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVksQ0FBQzs7Ozs7O0FBRWIsOENBRTRCO0FBQzVCLGtFQUErRDtBQUMvRCwrREFBNEM7QUFFNUMsTUFBTSxFQUFFLHdCQUF3QixFQUFFLEdBQUcsZUFBVSxDQUFDO0FBRXpDLE1BQU0sSUFBSSxHQUFHLENBQW1CLFFBQVcsRUFBK0MsRUFBRTtJQUVsRyxNQUFNLEtBQUssR0FBRyxJQUFBLGdCQUFRLEVBQUMsUUFBUSxDQUFVLENBQUM7SUFFMUMsTUFBTSxFQUNMLFFBQVEsRUFBRSxJQUFJLEVBQ2QsY0FBYyxFQUFFLFVBQVUsRUFDMUIsVUFBVSxFQUFFLGdCQUFnQixFQUM1QixRQUFRLEVBQ1IsUUFBUSxHQUNSLEdBQUcsS0FBSyxDQUFDO0lBRVYsTUFBTSxFQUNMLFNBQVMsRUFDVCxRQUFRLEVBQ1IsR0FBRyxJQUFJLENBQUM7SUFFVCxNQUFNLE1BQU0sR0FBRyxVQUF3QixHQUFHLFFBQW1CO1FBRTVELElBQUksTUFBTSxDQUFDO1FBQ1gsTUFBTSxXQUFXLEdBQUcsU0FBUyxDQUFDLENBQUM7WUFDOUIsZ0JBQWdCLENBQUMsQ0FBQztZQUNsQixVQUFVLENBQUM7UUFFWixNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztRQUduRCxJQUFJLElBQUksS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUd2QixNQUFNLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBRSxRQUFRLENBQUUsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLENBQUM7UUFDakQsQ0FBQzthQUFNLENBQUM7WUFFUCxNQUFNLEdBQUcsSUFBSSxpQ0FBZSxDQUMzQixJQUFJLEVBQ0osd0JBQXdCLENBQUMsSUFBSSxDQUFDLEVBQzlCLElBQUksQ0FDSixDQUFDO1FBQ0gsQ0FBQztRQUVELE1BQU0sVUFBVSxHQUFHLE1BQVcsQ0FBQztRQUMvQixPQUFPLFVBQVUsQ0FBQztJQUVuQixDQUFDLENBQUM7SUFDRixPQUFPLE1BQU0sQ0FBQztBQUVmLENBQUMsQ0FBQztBQTlDVyxRQUFBLElBQUksUUE4Q2YiLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIHN0cmljdCc7XG5cbmltcG9ydCB7XG5cdGdldFByb3BzLCBQcm9wcyBcbn0gZnJvbSAnLi4vYXBpL3R5cGVzL1Byb3BzJztcbmltcG9ydCB7IEluc3RhbmNlQ3JlYXRvciB9IGZyb20gJy4uL2FwaS90eXBlcy9JbnN0YW5jZUNyZWF0b3InO1xuaW1wb3J0IFR5cGVzVXRpbHMgZnJvbSAnLi4vYXBpL3V0aWxzL2luZGV4JztcblxuY29uc3QgeyByZWZsZWN0UHJpbWl0aXZlV3JhcHBlcnMgfSA9IFR5cGVzVXRpbHM7XG5cbmV4cG9ydCBjb25zdCBmb3JrID0gPFQgZXh0ZW5kcyBvYmplY3Q+KGluc3RhbmNlOiBUKTogKHRoaXM6IG9iamVjdCwgLi4uZm9ya0FyZ3M6IHVua25vd25bXSkgPT4gVCA9PiB7XG5cblx0Y29uc3QgcHJvcHMgPSBnZXRQcm9wcyhpbnN0YW5jZSkgYXMgUHJvcHM7XG5cblx0Y29uc3Qge1xuXHRcdF9fdHlwZV9fOiB0eXBlLFxuXHRcdF9fY29sbGVjdGlvbl9fOiBjb2xsZWN0aW9uLFxuXHRcdF9fcGFyZW50X186IGV4aXN0ZW50SW5zdGFuY2UsXG5cdFx0X19hcmdzX18sXG5cdFx0X19zZWxmX18sXG5cdH0gPSBwcm9wcztcblxuXHRjb25zdCB7XG5cdFx0aXNTdWJUeXBlLFxuXHRcdFR5cGVOYW1lXG5cdH0gPSB0eXBlO1xuXG5cdGNvbnN0IHJlc3VsdCA9IGZ1bmN0aW9uICh0aGlzOiBvYmplY3QsIC4uLmZvcmtBcmdzOiB1bmtub3duW10pIHtcblxuXHRcdGxldCBmb3JrZWQ7XG5cdFx0Y29uc3QgQ29uc3RydWN0b3IgPSBpc1N1YlR5cGUgP1xuXHRcdFx0ZXhpc3RlbnRJbnN0YW5jZSA6XG5cdFx0XHRjb2xsZWN0aW9uO1xuXG5cdFx0Y29uc3QgYXJncyA9IGZvcmtBcmdzLmxlbmd0aCA/IGZvcmtBcmdzIDogX19hcmdzX187XG5cblxuXHRcdGlmICh0aGlzID09PSBfX3NlbGZfXykge1xuXG5cdFx0XHQvLyBAdHMtZXhwZWN0LWVycm9yICB0aGlzIGlzIGRlZmluaXRlbHkgYSBjb25zdHJ1Y3RvclxuXHRcdFx0Zm9ya2VkID0gbmV3IChDb25zdHJ1Y3RvclsgVHlwZU5hbWUgXSkoLi4uYXJncyk7XG5cdFx0fSBlbHNlIHtcblx0XHRcdC8vIGZvcmsuY2FsbCA/IGxldCdzIGRvIGl0ICFcblx0XHRcdGZvcmtlZCA9IG5ldyBJbnN0YW5jZUNyZWF0b3IoXG5cdFx0XHRcdHR5cGUsXG5cdFx0XHRcdHJlZmxlY3RQcmltaXRpdmVXcmFwcGVycyh0aGlzKSxcblx0XHRcdFx0YXJnc1xuXHRcdFx0KTtcblx0XHR9XG5cblx0XHRjb25zdCBmb3JrUmVzdWx0ID0gZm9ya2VkIGFzIFQ7XG5cdFx0cmV0dXJuIGZvcmtSZXN1bHQ7XG5cblx0fTtcblx0cmV0dXJuIHJlc3VsdDtcblxufTtcbiJdfQ==

package/build/utils/index.d.ts

@@ -1,4 +1,3 @@
-export declare const utils: {
-    [index: string]: CallableFunction;
-};
+import type { UtilsCollection } from '../types';
+export declare const utils: UtilsCollection;
 export { defineStackCleaner } from './defineStackCleaner';

package/build/utils/index.js

@@ -5,6 +5,10 @@ const collectConstructors_1 = require("./collectConstructors");
 const extract_1 = require("./extract");
 const parent_1 = require("./parent");
 const pick_1 = require("./pick");
+const sibling_1 = require("./sibling");
+const exception_1 = require("./exception");
+const fork_1 = require("./fork");
+const clone_1 = require("./clone");
 const toJSON_1 = require("./toJSON");
 const parse_1 = require("./parse");
 const merge_1 = require("./merge");
@@ -12,18 +16,28 @@ const utilsUnWrapped = {
     extract: extract_1.extract,
     pick: pick_1.pick,
     parent: parent_1.parent,
+    sibling: sibling_1.sibling,
+    exception: exception_1.exception,
+    fork: fork_1.fork,
+    clone: clone_1.clone,
     toJSON: toJSON_1.toJSON,
     parse: parse_1.parse,
     merge: merge_1.merge,
-    get collectConstructors() {
-        return collectConstructors_1.collectConstructors;
-    },
+    collectConstructors: collectConstructors_1.collectConstructors,
 };
 const wrapThis = (method) => {
-    return function (instance, ...args) {
-        const result = method(instance !== undefined ? instance : this, ...args);
-        return result;
+    const result = function (instance, ...args) {
+        const instanceContext = instance !== undefined ? instance : this;
+        let wrapResult;
+        if (new.target) {
+            wrapResult = new method(instanceContext, ...args);
+        }
+        else {
+            wrapResult = method(instanceContext, ...args);
+        }
+        return wrapResult;
     };
+    return result;
 };
 exports.utils = Object.assign({}, Object.entries(utilsUnWrapped)
     .reduce((methods, util) => {
@@ -33,4 +47,4 @@ exports.utils = Object.assign({}, Object.entries(utilsUnWrapped)
 }, {}));
 var defineStackCleaner_1 = require("./defineStackCleaner");
 Object.defineProperty(exports, "defineStackCleaner", { enumerable: true, get: function () { return defineStackCleaner_1.defineStackCleaner; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/merge.d.ts

@@ -1 +1,2 @@
-export declare const merge: (a: object, b: object, ...args: unknown[]) => object;
+import type { Merge, InstanceResult } from '../types';
+export declare const merge: <A extends object, B extends object>(a: A, b: B, ...args: unknown[]) => InstanceResult<Merge<B, A>>;

package/build/utils/merge.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.merge = void 0;
 const errors_1 = require("../descriptors/errors");
 const { WRONG_ARGUMENTS_USED } = errors_1.ErrorsTypes;
+const fork_1 = require("./fork");
+const Props_1 = require("../api/types/Props");
 const merge = (a, b, ...args) => {
     if (a !== Object(a)) {
         throw new WRONG_ARGUMENTS_USED('A should be an object');
@@ -10,12 +12,14 @@ const merge = (a, b, ...args) => {
     if (b !== Object(b)) {
         throw new WRONG_ARGUMENTS_USED('B should be an object');
     }
-    const { fork } = a;
-    if (typeof fork !== 'function') {
-        throw new WRONG_ARGUMENTS_USED('A should have A.fork()');
+    const props = (0, Props_1.getProps)(a);
+    if (props === undefined) {
+        throw new WRONG_ARGUMENTS_USED('A should be a mnemonica instance');
     }
-    const aa = fork.call(b, ...args);
-    return aa;
+    const forked = (0, fork_1.fork)(a);
+    const aa = forked.call(b, ...args);
+    const result = aa;
+    return result;
 };
 exports.merge = merge;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/parent.d.ts

@@ -1 +1 @@
-export declare const parent: (instance: object, path?: string) => unknown;
+export declare const parent: <T extends object>(instance: T, path?: string) => object | undefined;

package/build/utils/parent.js

@@ -17,8 +17,9 @@ const parent = (instance, path) => {
         return p;
     }
     const { constructor: { name } } = p;
-    return name === path ?
+    const result = name === path ?
         p : (0, exports.parent)(p, path);
+    return result;
 };
 exports.parent = parent;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/parse.d.ts

@@ -1,12 +1,2 @@
-export declare const parse: (self: object) => {
-    name: string;
-    props: {
-        [index: string]: unknown;
-    };
-    self: object;
-    proto: object;
-    joint: {
-        [index: string]: unknown;
-    };
-    parent: unknown;
-};
+import type { Parsed } from '../types';
+export declare const parse: <T extends object>(self: T) => Parsed<T>;