@jbrowse/mobx-state-tree 5.6.10 → 5.7.1

package/esm/types/utility-types/union.js

@@ -0,0 +1,240 @@
+import { BaseType } from "../../core/type/type.js";
+import { ModelType, TypeFlags, assertArg, assertIsType, devMode, fail, flattenTypeErrors, isPlainObject, isStateTreeNode, isType, isTypeCheckingEnabled, typeCheckFailure, typeCheckSuccess } from "../../internal.js";
+/**
+ * @internal
+ * @hidden
+ */
+export class Union extends BaseType {
+    _types;
+    _dispatcher;
+    _eager = true;
+    get flags() {
+        let result = TypeFlags.Union;
+        this._types.forEach(type => {
+            result |= type.flags;
+        });
+        return result;
+    }
+    constructor(name, _types, options) {
+        super(name);
+        this._types = _types;
+        options = {
+            eager: true,
+            dispatcher: undefined,
+            ...options
+        };
+        this._dispatcher = options.dispatcher;
+        if (!options.eager) {
+            this._eager = false;
+        }
+    }
+    isAssignableFrom(type) {
+        return this._types.some(subType => subType.isAssignableFrom(type));
+    }
+    describe() {
+        return ("(" + this._types.map(factory => factory.describe()).join(" | ") + ")");
+    }
+    instantiate(parent, subpath, environment, initialValue) {
+        const type = this.determineType(initialValue, undefined);
+        if (!type) {
+            throw fail(this.noMatchMessage(initialValue));
+        } // can happen in prod builds
+        return type.instantiate(parent, subpath, environment, initialValue);
+    }
+    reconcile(current, newValue, parent, subpath) {
+        const type = this.determineType(newValue, current.getReconciliationType());
+        if (!type) {
+            throw fail(this.noMatchMessage(newValue));
+        } // can happen in prod builds
+        return type.reconcile(current, newValue, parent, subpath);
+    }
+    noMatchMessage(value) {
+        const discriminator = isPlainObject(value) && typeof value.type === "string"
+            ? ` for snapshot with type "${value.type}"`
+            : "";
+        return `No matching type for union ${this.name}${discriminator}`;
+    }
+    determineType(value, reconcileCurrentType) {
+        // try the dispatcher, if defined
+        if (this._dispatcher) {
+            return this._dispatcher(value);
+        }
+        // fast path: when type checking is disabled, try quick structural matching first
+        if (!isTypeCheckingEnabled()) {
+            const quickMatch = this.tryQuickMatch(value, reconcileCurrentType);
+            if (quickMatch) {
+                return quickMatch;
+            }
+            // for plain object snapshots that didn't match via quick path, try all types
+            // with quick matching before falling back to full validation
+            // (state tree nodes must go through full validation for type identity checks)
+            if (isPlainObject(value) && !isStateTreeNode(value)) {
+                for (const type of this._types) {
+                    if (this.snapshotLooksLikeType(value, type)) {
+                        return type;
+                    }
+                }
+            }
+        }
+        // find the most accomodating type
+        // if we are using reconciliation try the current node type first (fix for #1045)
+        if (reconcileCurrentType) {
+            if (reconcileCurrentType.is(value)) {
+                return reconcileCurrentType;
+            }
+            return this._types
+                .filter(t => t !== reconcileCurrentType)
+                .find(type => type.is(value));
+        }
+        else {
+            return this._types.find(type => type.is(value));
+        }
+    }
+    tryQuickMatch(value, reconcileCurrentType) {
+        // state tree nodes need full type compatibility checking
+        // (e.g., A.is(B.create()) must return false even if snapshots are compatible)
+        if (isStateTreeNode(value)) {
+            return undefined;
+        }
+        // for non-object values, try primitive matching
+        if (!isPlainObject(value)) {
+            return this.tryMatchPrimitive(value);
+        }
+        // for objects, try structural matching against model types
+        const typesToCheck = reconcileCurrentType
+            ? [
+                reconcileCurrentType,
+                ...this._types.filter(t => t !== reconcileCurrentType)
+            ]
+            : this._types;
+        for (const type of typesToCheck) {
+            if (this.snapshotLooksLikeType(value, type)) {
+                return type;
+            }
+        }
+        return undefined;
+    }
+    tryMatchPrimitive(value) {
+        const valueType = typeof value;
+        for (const type of this._types) {
+            const flags = type.flags;
+            if ((valueType === "string" && flags & TypeFlags.String) ||
+                (valueType === "number" &&
+                    flags &
+                        (TypeFlags.Number |
+                            TypeFlags.Integer |
+                            TypeFlags.Float |
+                            TypeFlags.Finite)) ||
+                (valueType === "boolean" && flags & TypeFlags.Boolean) ||
+                (value === null && flags & TypeFlags.Null) ||
+                (value === undefined && flags & TypeFlags.Undefined)) {
+                return type;
+            }
+            // for literals, check exact value match
+            if (flags & TypeFlags.Literal) {
+                if (type.is(value)) {
+                    return type;
+                }
+            }
+        }
+        return undefined;
+    }
+    snapshotLooksLikeType(value, type) {
+        // for model types, check if snapshot has all the required property keys
+        // and that any literal-typed properties match exactly
+        if (type instanceof ModelType) {
+            const props = type.properties;
+            // use cached propertyNames from ModelType instead of Object.keys()
+            for (const key of type.propertyNames) {
+                const propType = props[key];
+                const isOptional = propType.flags & TypeFlags.Optional;
+                const propValue = value[key];
+                // check required properties exist and are not undefined
+                // (unless the type accepts undefined, which Optional types do)
+                if (!isOptional) {
+                    if (!(key in value) || propValue === undefined) {
+                        return false;
+                    }
+                }
+                // for literal types, verify the value matches exactly
+                // this is critical for discriminated unions
+                if (propType.flags & TypeFlags.Literal) {
+                    if (!propType.is(propValue)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    isValidSnapshot(value, context) {
+        if (this._dispatcher) {
+            return this._dispatcher(value).validate(value, context);
+        }
+        // for plain-object snapshots, prefer union members whose literal-typed
+        // discriminator properties match the value (e.g. {type: "MsaView"})
+        // so error output is scoped to the intended branch instead of every member
+        const candidates = isPlainObject(value) && !isStateTreeNode(value)
+            ? this._types.filter(t => this.snapshotLooksLikeType(value, t))
+            : [];
+        const typesToValidate = candidates.length > 0 ? candidates : this._types;
+        const allErrors = [];
+        let applicableTypes = 0;
+        for (const type of typesToValidate) {
+            const errors = type.validate(value, context);
+            if (errors.length === 0) {
+                if (this._eager) {
+                    return typeCheckSuccess();
+                }
+                else {
+                    applicableTypes++;
+                }
+            }
+            else {
+                allErrors.push(errors);
+            }
+        }
+        if (applicableTypes === 1) {
+            return typeCheckSuccess();
+        }
+        return typeCheckFailure(context, value, "No type is applicable for the union").concat(flattenTypeErrors(allErrors));
+    }
+    getSubTypes() {
+        return this._types;
+    }
+}
+/**
+ * `types.union` - Create a union of multiple types. If the correct type cannot be inferred unambiguously from a snapshot, provide a dispatcher function of the form `(snapshot) => Type`.
+ *
+ * @param optionsOrType
+ * @param otherTypes
+ * @returns
+ */
+export function union(optionsOrType, ...otherTypes) {
+    const options = isType(optionsOrType) ? undefined : optionsOrType;
+    const types = isType(optionsOrType)
+        ? [optionsOrType, ...otherTypes]
+        : otherTypes;
+    const name = "(" + types.map(type => type.name).join(" | ") + ")";
+    // check all options
+    if (devMode()) {
+        if (options) {
+            assertArg(options, o => isPlainObject(o), "object { eager?: boolean, dispatcher?: Function }", 1);
+        }
+        types.forEach((type, i) => {
+            assertIsType(type, options ? i + 2 : i + 1);
+        });
+    }
+    return new Union(name, types, options);
+}
+/**
+ * Returns if a given value represents a union type.
+ *
+ * @param type
+ * @returns
+ */
+export function isUnionType(type) {
+    return (type.flags & TypeFlags.Union) > 0;
+}
+//# sourceMappingURL=union.js.map

package/esm/types/utility-types/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../../src/types/utility-types/union.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseType } from \"../../core/type/type.ts\"\nimport {\n  type AnyObjectNode,\n  type IAnyType,\n  type IModelType,\n  type IType,\n  type IValidationContext,\n  type IValidationError,\n  type IValidationResult,\n  type ModelCreationType2,\n  type ModelInstanceType,\n  type ModelProperties,\n  type ModelSnapshotType2,\n  ModelType,\n  TypeFlags,\n  type _NotCustomized,\n  assertArg,\n  assertIsType,\n  devMode,\n  fail,\n  flattenTypeErrors,\n  isPlainObject,\n  isStateTreeNode,\n  isType,\n  isTypeCheckingEnabled,\n  typeCheckFailure,\n  typeCheckSuccess\n} from \"../../internal.ts\"\n\nexport type ITypeDispatcher = (snapshot: any) => IAnyType\n\nexport interface UnionOptions {\n  eager?: boolean\n  dispatcher?: ITypeDispatcher\n}\n\n/**\n * @internal\n * @hidden\n */\nexport class Union extends BaseType<any, any, any> {\n  private readonly _dispatcher?: ITypeDispatcher\n  private readonly _eager: boolean = true\n\n  get flags() {\n    let result: TypeFlags = TypeFlags.Union\n\n    this._types.forEach(type => {\n      result |= type.flags\n    })\n\n    return result\n  }\n\n  constructor(\n    name: string,\n    private readonly _types: IAnyType[],\n    options?: UnionOptions\n  ) {\n    super(name)\n    options = {\n      eager: true,\n      dispatcher: undefined,\n      ...options\n    }\n    this._dispatcher = options.dispatcher\n    if (!options.eager) {\n      this._eager = false\n    }\n  }\n\n  isAssignableFrom(type: IAnyType) {\n    return this._types.some(subType => subType.isAssignableFrom(type))\n  }\n\n  describe() {\n    return (\n      \"(\" + this._types.map(factory => factory.describe()).join(\" | \") + \")\"\n    )\n  }\n\n  instantiate(\n    parent: AnyObjectNode | null,\n    subpath: string,\n    environment: any,\n    initialValue: this[\"C\"] | this[\"T\"]\n  ): this[\"N\"] {\n    const type = this.determineType(initialValue, undefined)\n    if (!type) {\n      throw fail(this.noMatchMessage(initialValue))\n    } // can happen in prod builds\n    return type.instantiate(parent, subpath, environment, initialValue)\n  }\n\n  reconcile(\n    current: this[\"N\"],\n    newValue: this[\"C\"] | this[\"T\"],\n    parent: AnyObjectNode,\n    subpath: string\n  ): this[\"N\"] {\n    const type = this.determineType(newValue, current.getReconciliationType())\n    if (!type) {\n      throw fail(this.noMatchMessage(newValue))\n    } // can happen in prod builds\n    return type.reconcile(current, newValue, parent, subpath)\n  }\n\n  private noMatchMessage(value: unknown): string {\n    const discriminator =\n      isPlainObject(value) && typeof (value as any).type === \"string\"\n        ? ` for snapshot with type \"${(value as any).type}\"`\n        : \"\"\n    return `No matching type for union ${this.name}${discriminator}`\n  }\n\n  determineType(\n    value: this[\"C\"] | this[\"T\"],\n    reconcileCurrentType: IAnyType | undefined\n  ): IAnyType | undefined {\n    // try the dispatcher, if defined\n    if (this._dispatcher) {\n      return this._dispatcher(value)\n    }\n\n    // fast path: when type checking is disabled, try quick structural matching first\n    if (!isTypeCheckingEnabled()) {\n      const quickMatch = this.tryQuickMatch(value, reconcileCurrentType)\n      if (quickMatch) {\n        return quickMatch\n      }\n      // for plain object snapshots that didn't match via quick path, try all types\n      // with quick matching before falling back to full validation\n      // (state tree nodes must go through full validation for type identity checks)\n      if (isPlainObject(value) && !isStateTreeNode(value)) {\n        for (const type of this._types) {\n          if (this.snapshotLooksLikeType(value, type)) {\n            return type\n          }\n        }\n      }\n    }\n\n    // find the most accomodating type\n    // if we are using reconciliation try the current node type first (fix for #1045)\n    if (reconcileCurrentType) {\n      if (reconcileCurrentType.is(value)) {\n        return reconcileCurrentType\n      }\n      return this._types\n        .filter(t => t !== reconcileCurrentType)\n        .find(type => type.is(value))\n    } else {\n      return this._types.find(type => type.is(value))\n    }\n  }\n\n  private tryQuickMatch(\n    value: any,\n    reconcileCurrentType: IAnyType | undefined\n  ): IAnyType | undefined {\n    // state tree nodes need full type compatibility checking\n    // (e.g., A.is(B.create()) must return false even if snapshots are compatible)\n    if (isStateTreeNode(value)) {\n      return undefined\n    }\n\n    // for non-object values, try primitive matching\n    if (!isPlainObject(value)) {\n      return this.tryMatchPrimitive(value)\n    }\n\n    // for objects, try structural matching against model types\n    const typesToCheck = reconcileCurrentType\n      ? [\n          reconcileCurrentType,\n          ...this._types.filter(t => t !== reconcileCurrentType)\n        ]\n      : this._types\n\n    for (const type of typesToCheck) {\n      if (this.snapshotLooksLikeType(value, type)) {\n        return type\n      }\n    }\n    return undefined\n  }\n\n  private tryMatchPrimitive(value: any): IAnyType | undefined {\n    const valueType = typeof value\n    for (const type of this._types) {\n      const flags = type.flags\n      if (\n        (valueType === \"string\" && flags & TypeFlags.String) ||\n        (valueType === \"number\" &&\n          flags &\n            (TypeFlags.Number |\n              TypeFlags.Integer |\n              TypeFlags.Float |\n              TypeFlags.Finite)) ||\n        (valueType === \"boolean\" && flags & TypeFlags.Boolean) ||\n        (value === null && flags & TypeFlags.Null) ||\n        (value === undefined && flags & TypeFlags.Undefined)\n      ) {\n        return type\n      }\n      // for literals, check exact value match\n      if (flags & TypeFlags.Literal) {\n        if (type.is(value)) {\n          return type\n        }\n      }\n    }\n    return undefined\n  }\n\n  private snapshotLooksLikeType(value: any, type: IAnyType): boolean {\n    // for model types, check if snapshot has all the required property keys\n    // and that any literal-typed properties match exactly\n    if (type instanceof ModelType) {\n      const props = type.properties\n      // use cached propertyNames from ModelType instead of Object.keys()\n      for (const key of type.propertyNames) {\n        const propType = props[key]!\n        const isOptional = propType.flags & TypeFlags.Optional\n        const propValue = value[key]\n\n        // check required properties exist and are not undefined\n        // (unless the type accepts undefined, which Optional types do)\n        if (!isOptional) {\n          if (!(key in value) || propValue === undefined) {\n            return false\n          }\n        }\n\n        // for literal types, verify the value matches exactly\n        // this is critical for discriminated unions\n        if (propType.flags & TypeFlags.Literal) {\n          if (!propType.is(propValue)) {\n            return false\n          }\n        }\n      }\n      return true\n    }\n    return false\n  }\n\n  isValidSnapshot(\n    value: this[\"C\"],\n    context: IValidationContext\n  ): IValidationResult {\n    if (this._dispatcher) {\n      return this._dispatcher(value).validate(value, context)\n    }\n\n    // for plain-object snapshots, prefer union members whose literal-typed\n    // discriminator properties match the value (e.g. {type: \"MsaView\"})\n    // so error output is scoped to the intended branch instead of every member\n    const candidates =\n      isPlainObject(value) && !isStateTreeNode(value)\n        ? this._types.filter(t => this.snapshotLooksLikeType(value, t))\n        : []\n    const typesToValidate = candidates.length > 0 ? candidates : this._types\n\n    const allErrors: IValidationError[][] = []\n    let applicableTypes = 0\n    for (const type of typesToValidate) {\n      const errors = type.validate(value, context)\n      if (errors.length === 0) {\n        if (this._eager) {\n          return typeCheckSuccess()\n        } else {\n          applicableTypes++\n        }\n      } else {\n        allErrors.push(errors)\n      }\n    }\n\n    if (applicableTypes === 1) {\n      return typeCheckSuccess()\n    }\n    return typeCheckFailure(\n      context,\n      value,\n      \"No type is applicable for the union\"\n    ).concat(flattenTypeErrors(allErrors))\n  }\n\n  getSubTypes() {\n    return this._types\n  }\n}\n\n/**\n * Transform _NotCustomized | _NotCustomized... to _NotCustomized, _NotCustomized | A | B to A | B\n * @hidden\n */\nexport type _CustomCSProcessor<T> =\n  Exclude<T, _NotCustomized> extends never\n    ? _NotCustomized\n    : Exclude<T, _NotCustomized>\n\n/** @hidden */\nexport interface ITypeUnion<C, S, T> extends IType<\n  _CustomCSProcessor<C>,\n  _CustomCSProcessor<S>,\n  T\n> {}\n\n// generated with packages/mobx-state-tree/scripts/generate-union-types.js\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB,\n    OB, FCB, FSB>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G:\n        IModelType<PG, OG, FCG, FSG>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE,\n        FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH, PI extends ModelProperties, OI, FCI, FSI>(A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD, OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>, I: IModelType<PI, OI, FCI, FSI>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH> | ModelCreationType2<PI, FCI>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH> | ModelSnapshotType2<PI, FSI>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH> | ModelInstanceType<PI, OI>>\n// prettier-ignore\nexport function union<PA extends ModelProperties, OA, FCA, FSA, PB extends ModelProperties, OB, FCB, FSB, PC extends ModelProperties, OC, FCC, FSC, PD extends ModelProperties, OD,\n    FCD, FSD, PE extends ModelProperties, OE, FCE, FSE, PF extends ModelProperties, OF, FCF, FSF, PG extends ModelProperties, OG, FCG, FSG, PH extends ModelProperties, OH, FCH, FSH, PI extends ModelProperties, OI, FCI, FSI>(options: UnionOptions, A: IModelType<PA, OA, FCA, FSA>, B: IModelType<PB, OB, FCB, FSB>, C: IModelType<PC, OC, FCC, FSC>, D: IModelType<PD,\n        OD, FCD, FSD>, E: IModelType<PE, OE, FCE, FSE>, F: IModelType<PF, OF, FCF, FSF>, G: IModelType<PG, OG, FCG, FSG>, H: IModelType<PH, OH, FCH, FSH>, I: IModelType<PI, OI, FCI, FSI>): ITypeUnion<ModelCreationType2<PA, FCA> | ModelCreationType2<PB, FCB> | ModelCreationType2<PC, FCC> | ModelCreationType2<PD, FCD> | ModelCreationType2<PE, FCE> | ModelCreationType2<PF, FCF> | ModelCreationType2<PG, FCG> | ModelCreationType2<PH, FCH> | ModelCreationType2<PI, FCI>, ModelSnapshotType2<PA, FSA> | ModelSnapshotType2<PB, FSB> | ModelSnapshotType2<PC, FSC> | ModelSnapshotType2<PD, FSD> | ModelSnapshotType2<PE, FSE> | ModelSnapshotType2<PF, FSF> | ModelSnapshotType2<PG, FSG> | ModelSnapshotType2<PH, FSH> | ModelSnapshotType2<PI, FSI>, ModelInstanceType<PA, OA> | ModelInstanceType<PB, OB> | ModelInstanceType<PC, OC> | ModelInstanceType<PD, OD> | ModelInstanceType<PE, OE> | ModelInstanceType<PF, OF> | ModelInstanceType<PG, OG> | ModelInstanceType<PH, OH> | ModelInstanceType<PI, OI>>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>): ITypeUnion<CA | CB, SA | SB, TA | TB>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>): ITypeUnion<CA | CB, SA | SB, TA | TB>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>): ITypeUnion<CA | CB | CC, SA | SB | SC, TA | TB | TC>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>): ITypeUnion<CA | CB | CC, SA | SB | SC, TA | TB | TC>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>): ITypeUnion<CA | CB |\n    CC | CD, SA | SB | SC | SD, TA | TB | TC | TD>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>): ITypeUnion<CA | CB | CC | CD, SA | SB | SC | SD, TA | TB | TC | TD>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>): ITypeUnion<CA | CB | CC | CD | CE, SA | SB | SC | SD | SE, TA | TB | TC | TD | TE>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>): ITypeUnion<CA | CB | CC | CD | CE, SA | SB | SC | SD | SE, TA | TB | TC | TD | TE>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>): ITypeUnion<CA | CB | CC | CD | CE | CF, SA | SB | SC | SD | SE | SF, TA | TB | TC | TD | TE | TF>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>): ITypeUnion<CA | CB | CC | CD | CE | CF, SA | SB | SC | SD | SE | SF, TA | TB | TC | TD | TE | TF>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG, SA | SB | SC | SD | SE | SF | SG, TA | TB | TC | TD |\n    TE | TF | TG>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG, SA | SB | SC | SD | SE | SF | SG, TA | TB | TC | TD | TE | TF | TG>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG | CH, SA | SB | SC |\n    SD | SE | SF | SG | SH, TA | TB | TC | TD | TE | TF | TG | TH>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB,\n    TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG | CH, SA | SB | SC | SD | SE | SF | SG | SH, TA | TB | TC | TD | TE | TF | TG | TH>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH, CI, SI, TI>(A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>, I: IType<CI, SI, TI>): ITypeUnion<CA | CB | CC | CD |\n    CE | CF | CG | CH | CI, SA | SB | SC | SD | SE | SF | SG | SH | SI, TA | TB | TC | TD | TE | TF | TG | TH | TI>\n// prettier-ignore\nexport function union<CA, SA, TA, CB, SB, TB, CC, SC, TC, CD, SD, TD, CE, SE, TE, CF, SF, TF, CG, SG, TG, CH, SH, TH, CI, SI, TI>(options: UnionOptions, A: IType<CA, SA, TA>, B: IType<CB, SB, TB>, C: IType<CC, SC, TC>, D: IType<CD, SD, TD>, E: IType<CE, SE, TE>, F: IType<CF, SF, TF>, G: IType<CG, SG, TG>, H: IType<CH, SH, TH>, I: IType<CI, SI, TI>): ITypeUnion<CA | CB | CC | CD | CE | CF | CG | CH | CI, SA | SB | SC | SD | SE | SF | SG | SH | SI, TA | TB | TC | TD | TE | TF | TG | TH | TI>\n\n// manually written\nexport function union(...types: IAnyType[]): IAnyType\nexport function union(\n  dispatchOrType: UnionOptions | IAnyType,\n  ...otherTypes: IAnyType[]\n): IAnyType\n/**\n * `types.union` - Create a union of multiple types. If the correct type cannot be inferred unambiguously from a snapshot, provide a dispatcher function of the form `(snapshot) => Type`.\n *\n * @param optionsOrType\n * @param otherTypes\n * @returns\n */\nexport function union(\n  optionsOrType: UnionOptions | IAnyType,\n  ...otherTypes: IAnyType[]\n): IAnyType {\n  const options = isType(optionsOrType) ? undefined : optionsOrType\n  const types = isType(optionsOrType)\n    ? [optionsOrType, ...otherTypes]\n    : otherTypes\n  const name = \"(\" + types.map(type => type.name).join(\" | \") + \")\"\n\n  // check all options\n  if (devMode()) {\n    if (options) {\n      assertArg(\n        options,\n        o => isPlainObject(o),\n        \"object { eager?: boolean, dispatcher?: Function }\",\n        1\n      )\n    }\n    types.forEach((type, i) => {\n      assertIsType(type, options ? i + 2 : i + 1)\n    })\n  }\n  return new Union(name, types, options)\n}\n\n/**\n * Returns if a given value represents a union type.\n *\n * @param type\n * @returns\n */\nexport function isUnionType<IT extends IAnyType>(type: IT): type is IT {\n  return (type.flags & TypeFlags.Union) > 0\n}\n"]}

package/esm/utils.d.ts

@@ -0,0 +1,230 @@
+import type { Primitives } from "./core/type/type.ts";
+/**
+ * @internal
+ * @hidden
+ */
+export declare const EMPTY_ARRAY: ReadonlyArray<any>;
+/**
+ * @internal
+ * @hidden
+ */
+export declare const EMPTY_OBJECT: {};
+/**
+ * @internal
+ * @hidden
+ */
+export declare const mobxShallow: {
+    deep: boolean;
+    proxy?: undefined;
+} | {
+    deep: boolean;
+    proxy: boolean;
+};
+/**
+ * A generic disposer.
+ */
+export type IDisposer = () => void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function fail(message?: string): Error;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function identity(_: any): any;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function noop(): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare const isInteger: (number: unknown) => boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isFloat(val: any): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isFinite(val: any): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isArray(val: any): val is any[];
+/**
+ * @internal
+ * @hidden
+ */
+export declare function asArray<T>(val: undefined | null | T | T[] | ReadonlyArray<T>): T[];
+/**
+ * @internal
+ * @hidden
+ */
+export declare function extend<A, B>(a: A, b: B): A & B;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function extend<A, B, C>(a: A, b: B, c: C): A & B & C;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function extend<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function extend(a: any, ...b: any[]): any;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isPlainObject(value: any): value is {
+    [k: string]: any;
+};
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isMutable(value: any): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isPrimitive(value: any, includeDate?: boolean): value is Primitives;
+/**
+ * @internal
+ * @hidden
+ * Freeze a value and return it (if not in production)
+ */
+export declare function freeze<T>(value: T): T;
+/**
+ * @internal
+ * @hidden
+ * Recursively freeze a value (if not in production)
+ */
+export declare function deepFreeze<T>(value: T): T;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isSerializable(value: any): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function defineProperty(object: any, key: PropertyKey, descriptor: PropertyDescriptor): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function addHiddenFinalProp(object: any, propName: string, value: any): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function addHiddenWritableProp(object: any, propName: string, value: any): void;
+/**
+ * @internal
+ * @hidden
+ */
+export type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never;
+/**
+ * @internal
+ * @hidden
+ */
+export declare class EventHandlers<E extends {
+    [k: string]: Function;
+}> {
+    private eventHandlers?;
+    hasSubscribers(event: keyof E): boolean;
+    register<N extends keyof E>(event: N, fn: E[N], atTheBeginning?: boolean): IDisposer;
+    has<N extends keyof E>(event: N, fn: E[N]): boolean;
+    unregister<N extends keyof E>(event: N, fn: E[N]): void;
+    clear<N extends keyof E>(event: N): void;
+    clearAll(): void;
+    emit<N extends keyof E>(event: N, ...args: ArgumentTypes<E[N]>): void;
+}
+/**
+ * @internal
+ * @hidden
+ */
+export declare function hasOwnProperty(object: object, propName: string): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function argsToArray(args: IArguments): any[];
+/**
+ * @internal
+ * @hidden
+ */
+export declare function stringStartsWith(str: string, beginning: string): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export type DeprecatedFunction = Function & {
+    ids?: {
+        [id: string]: true;
+    };
+};
+/**
+ * @internal
+ * @hidden
+ */
+export declare const deprecated: DeprecatedFunction;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function warnError(msg: string): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function isTypeCheckingEnabled(): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function devMode(): boolean;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function setDevMode(value: boolean): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function assertArg<T>(value: T, fn: (value: T) => boolean, typeName: string, argNumber: number | number[]): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function assertIsFunction(value: Function, argNumber: number | number[]): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function assertIsNumber(value: number, argNumber: number | number[], min?: number, max?: number): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function assertIsString(value: string, argNumber: number | number[], canBeEmpty?: boolean): void;
+/**
+ * @internal
+ * @hidden
+ */
+export declare function setImmediateWithFallback(fn: (...args: any[]) => void): void;