mobx-keystone 0.67.4 → 0.68.1-alpha

package/dist/src/context/context.mjs

@@ -0,0 +1,141 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { observable, createAtom, action, computed } from "mobx";
+import { fastGetParent } from "../parent/path.mjs";
+import { assertTweakedObject, isTweakedObject } from "../tweaker/core.mjs";
+import { getOrCreate } from "../utils/mapUtils.mjs";
+function resolveContextValue(contextValue) {
+  if (contextValue.type === "value") {
+    return contextValue.value;
+  } else {
+    return contextValue.value.get();
+  }
+}
+class ContextClass {
+  constructor(defaultValue) {
+    __publicField(this, "defaultContextValue", observable.box(void 0, { deep: false }));
+    __publicField(this, "overrideContextValue", observable.box(void 0, {
+      deep: false
+    }));
+    __publicField(this, "nodeContextValue", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "nodeAtom", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "setDefault", action((value) => {
+      this.defaultContextValue.set({
+        type: "value",
+        value
+      });
+    }));
+    __publicField(this, "setDefaultComputed", action((valueFn) => {
+      this.defaultContextValue.set({
+        type: "computed",
+        value: computed(valueFn)
+      });
+    }));
+    __publicField(this, "set", action((node, value) => {
+      assertTweakedObject(node, "node");
+      this.nodeContextValue.set(node, {
+        type: "value",
+        value
+      });
+      this.getNodeAtom(node).reportChanged();
+    }));
+    __publicField(this, "setComputed", action((node, valueFn) => {
+      this._setComputed(node, computed(valueFn));
+    }));
+    __publicField(this, "unset", action((node) => {
+      assertTweakedObject(node, "node");
+      this.nodeContextValue.delete(node);
+      this.getNodeAtom(node).reportChanged();
+    }));
+    __publicField(this, "apply", action((fn, value) => {
+      const old = this.overrideContextValue.get();
+      this.overrideContextValue.set({
+        type: "value",
+        value
+      });
+      try {
+        const ret = fn();
+        if (isTweakedObject(ret, true)) {
+          this.set(ret, value);
+        }
+        return ret;
+      } finally {
+        this.overrideContextValue.set(old);
+      }
+    }));
+    __publicField(this, "applyComputed", action((fn, valueFn) => {
+      const computedValueFn = computed(valueFn);
+      const old = this.overrideContextValue.get();
+      this.overrideContextValue.set({
+        type: "computed",
+        value: computedValueFn
+      });
+      try {
+        const ret = fn();
+        if (isTweakedObject(ret, true)) {
+          this._setComputed(ret, computedValueFn);
+        }
+        return ret;
+      } finally {
+        this.overrideContextValue.set(old);
+      }
+    }));
+    this.setDefault(defaultValue);
+  }
+  getNodeAtom(node) {
+    return getOrCreate(this.nodeAtom, node, () => createAtom("contextValue"));
+  }
+  fastGet(node) {
+    this.getNodeAtom(node).reportObserved();
+    const obsForNode = this.nodeContextValue.get(node);
+    if (obsForNode) {
+      return resolveContextValue(obsForNode);
+    }
+    const parent = fastGetParent(node);
+    if (!parent) {
+      const overrideValue = this.overrideContextValue.get();
+      if (overrideValue) {
+        return resolveContextValue(overrideValue);
+      }
+      return this.getDefault();
+    }
+    return this.fastGet(parent);
+  }
+  get(node) {
+    assertTweakedObject(node, "node");
+    return this.fastGet(node);
+  }
+  fastGetProviderNode(node) {
+    this.getNodeAtom(node).reportObserved();
+    const obsForNode = this.nodeContextValue.get(node);
+    if (obsForNode) {
+      return node;
+    }
+    const parent = fastGetParent(node);
+    if (!parent) {
+      return void 0;
+    }
+    return this.fastGetProviderNode(parent);
+  }
+  getProviderNode(node) {
+    assertTweakedObject(node, "node");
+    return this.fastGetProviderNode(node);
+  }
+  getDefault() {
+    return resolveContextValue(this.defaultContextValue.get());
+  }
+  _setComputed(node, computedValueFn) {
+    assertTweakedObject(node, "node");
+    this.nodeContextValue.set(node, { type: "computed", value: computedValueFn });
+    this.getNodeAtom(node).reportChanged();
+  }
+}
+function createContext(defaultValue) {
+  return new ContextClass(defaultValue);
+}
+export { createContext };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"context.mjs","sources":["../../../src/context/context.ts"],"sourcesContent":["import { action, computed, createAtom, IAtom, IComputedValue, observable } from \"mobx\"\nimport { fastGetParent } from \"../parent/path\"\nimport { assertTweakedObject, isTweakedObject } from \"../tweaker/core\"\nimport { getOrCreate } from \"../utils/mapUtils\"\n\n/**\n * A context.\n */\nexport interface Context<T> {\n  /**\n   * Gets the context default value.\n   *\n   * @returns\n   */\n  getDefault(): T\n\n  /**\n   * Sets the context default value.\n   * @param value\n   */\n  setDefault(value: T): void\n\n  /**\n   * Sets the context default value resolver.\n   * @param valueFn\n   */\n  setDefaultComputed(valueFn: () => T): void\n\n  /**\n   * Gets the context value for a given node.\n   * @param node\n   */\n  get(node: object): T\n\n  /**\n   * Gets node that will provide the context value, or `undefined`\n   * if it comes from the default.\n   * @param node\n   */\n  getProviderNode(node: object): object | undefined\n\n  /**\n   * Sets the context value for a given node, effectively making it a provider.\n   * @param node\n   * @param value\n   */\n  set(node: object, value: T): void\n\n  /**\n   * Sets the context value resolver for a given node, effectively making it a provider.\n   * @param node\n   * @param valueFn\n   */\n  setComputed(node: object, valueFn: () => T): void\n\n  /**\n   * Unsets the context value for a given node, therefore it won't be a provider anymore.\n   * @param node\n   */\n  unset(node: object): void\n\n  /**\n   * Applies a value override while the given function is running and, if a node is returned,\n   * sets the node as a provider of the value.\n   *\n   * @typeparam R\n   * @param fn Function to run.\n   * @param value Value to apply.\n   * @returns The value returned from the function.\n   */\n  apply<R>(fn: () => R, value: T): R\n\n  /**\n   * Applies a computed value override while the given function is running and, if a node is returned,\n   * sets the node as a provider of the computed value.\n   *\n   * @typeparam R\n   * @param fn Function to run.\n   * @param value Value to apply.\n   * @returns The value returned from the function.\n   */\n  applyComputed<R>(fn: () => R, valueFn: () => T): R\n}\n\ntype ContextValue<T> =\n  | {\n      type: \"value\"\n      value: T\n    }\n  | {\n      type: \"computed\"\n      value: IComputedValue<T>\n    }\n\nfunction resolveContextValue<T>(contextValue: ContextValue<T>): T {\n  if (contextValue.type === \"value\") {\n    return contextValue.value\n  } else {\n    return contextValue.value.get()\n  }\n}\n\nclass ContextClass<T> implements Context<T> {\n  private defaultContextValue = observable.box<ContextValue<T>>(undefined, { deep: false })\n\n  private overrideContextValue = observable.box<ContextValue<T> | undefined>(undefined, {\n    deep: false,\n  })\n\n  private readonly nodeContextValue = new WeakMap<object, ContextValue<T>>()\n  private readonly nodeAtom = new WeakMap<object, IAtom>()\n\n  private getNodeAtom(node: object) {\n    return getOrCreate(this.nodeAtom, node, () => createAtom(\"contextValue\"))\n  }\n\n  private fastGet(node: object): T {\n    this.getNodeAtom(node).reportObserved()\n\n    const obsForNode = this.nodeContextValue.get(node)\n    if (obsForNode) {\n      return resolveContextValue(obsForNode)\n    }\n\n    const parent = fastGetParent(node)\n    if (!parent) {\n      const overrideValue = this.overrideContextValue.get()\n      if (overrideValue) {\n        return resolveContextValue(overrideValue)\n      }\n      return this.getDefault()\n    }\n\n    return this.fastGet(parent)\n  }\n\n  get(node: object) {\n    assertTweakedObject(node, \"node\")\n\n    return this.fastGet(node)\n  }\n\n  private fastGetProviderNode(node: object): object | undefined {\n    this.getNodeAtom(node).reportObserved()\n\n    const obsForNode = this.nodeContextValue.get(node)\n    if (obsForNode) {\n      return node\n    }\n\n    const parent = fastGetParent(node)\n    if (!parent) {\n      return undefined\n    }\n\n    return this.fastGetProviderNode(parent)\n  }\n\n  getProviderNode(node: object): object | undefined {\n    assertTweakedObject(node, \"node\")\n\n    return this.fastGetProviderNode(node)\n  }\n\n  getDefault(): T {\n    return resolveContextValue(this.defaultContextValue.get())\n  }\n\n  setDefault = action((value: T) => {\n    this.defaultContextValue.set({\n      type: \"value\",\n      value,\n    })\n  })\n\n  setDefaultComputed = action((valueFn: () => T) => {\n    this.defaultContextValue.set({\n      type: \"computed\",\n      value: computed(valueFn),\n    })\n  })\n\n  set = action((node: object, value: T) => {\n    assertTweakedObject(node, \"node\")\n\n    this.nodeContextValue.set(node, {\n      type: \"value\",\n      value,\n    })\n    this.getNodeAtom(node).reportChanged()\n  })\n\n  private _setComputed(node: object, computedValueFn: IComputedValue<T>) {\n    assertTweakedObject(node, \"node\")\n\n    this.nodeContextValue.set(node, { type: \"computed\", value: computedValueFn })\n    this.getNodeAtom(node).reportChanged()\n  }\n\n  setComputed = action((node: object, valueFn: () => T) => {\n    this._setComputed(node, computed(valueFn))\n  })\n\n  unset = action((node: object) => {\n    assertTweakedObject(node, \"node\")\n\n    this.nodeContextValue.delete(node)\n    this.getNodeAtom(node).reportChanged()\n  })\n\n  apply = action(<R>(fn: () => R, value: T): R => {\n    const old = this.overrideContextValue.get()\n    this.overrideContextValue.set({\n      type: \"value\",\n      value,\n    })\n\n    try {\n      const ret = fn()\n      if (isTweakedObject(ret, true)) {\n        this.set(ret, value)\n      }\n      return ret\n    } finally {\n      this.overrideContextValue.set(old)\n    }\n  })\n\n  applyComputed = action(<R>(fn: () => R, valueFn: () => T): R => {\n    const computedValueFn = computed(valueFn)\n\n    const old = this.overrideContextValue.get()\n    this.overrideContextValue.set({\n      type: \"computed\",\n      value: computedValueFn,\n    })\n\n    try {\n      const ret = fn()\n      if (isTweakedObject(ret, true)) {\n        this._setComputed(ret, computedValueFn)\n      }\n      return ret\n    } finally {\n      this.overrideContextValue.set(old)\n    }\n  })\n\n  constructor(defaultValue?: T) {\n    this.setDefault(defaultValue as T)\n  }\n}\n\n/**\n * Creates a new context with no default value, thus making its default value undefined.\n *\n * @typeparam T Context value type.\n * @returns\n */\nexport function createContext<T>(): Context<T | undefined>\n\n/**\n * Creates a new context with a default value.\n *\n * @typeparam T Context value type.\n * @param defaultValue\n * @returns\n */\nexport function createContext<T>(defaultValue: T): Context<T>\n\n// base\nexport function createContext<T>(defaultValue?: T): Context<T> {\n  return new ContextClass(defaultValue)\n}\n"],"names":[],"mappings":";;;;;;;;;;AA8FA,6BAAgC;MAC1B,aAAa,SAAS,SAAS;WAC1B,aAAa;AAAA,SACf;WACE,aAAa,MAAM;;AAE9B;AAEA,MAAM;EAkJJ,YAAY;AAjJJ,+CAAsB,WAAW,IAAqB,QAAW,EAAE,MAAM,OAAO;AAEhF,gDAAuB,WAAW,IAAiC,QAAW;AAAA,MACpF,MAAM;AAAA,KACP;AAEgB,gEAAuB;AACvB,wDAAe;AA0DhC,sCAAa,OAAO,CAAC;WACd,oBAAoB,IAAI;AAAA,QAC3B,MAAM;AAAA,QACN;AAAA,OACD;AAAA,KACF;AAED,8CAAqB,OAAO,CAAC;WACtB,oBAAoB,IAAI;AAAA,QAC3B,MAAM;AAAA,QACN,OAAO,SAAS,OAAO;AAAA,OACxB;AAAA,KACF;AAED,+BAAM,OAAO,CAAC,MAAc;0BACN,MAAM,MAAM;WAE3B,iBAAiB,IAAI,MAAM;AAAA,QAC9B,MAAM;AAAA,QACN;AAAA,OACD;WACI,YAAY,IAAI,EAAE;KACxB;AASD,uCAAc,OAAO,CAAC,MAAc;WAC7B,aAAa,MAAM,SAAS,OAAO,CAAC;AAAA,KAC1C;AAED,iCAAQ,OAAO,CAAC;0BACM,MAAM,MAAM;WAE3B,iBAAiB,OAAO,IAAI;WAC5B,YAAY,IAAI,EAAE;KACxB;AAED,iCAAQ,OAAO,CAAI,IAAa;YACxB,MAAM,KAAK,qBAAqB;WACjC,qBAAqB,IAAI;AAAA,QAC5B,MAAM;AAAA,QACN;AAAA,OACD;UAEG;cACI,MAAM;YACR,gBAAgB,KAAK,IAAI,GAAG;eACzB,IAAI,KAAK,KAAK;AAAA;eAEd;AAAA;aAEF,qBAAqB,IAAI,GAAG;AAAA;KAEpC;AAED,yCAAgB,OAAO,CAAI,IAAa;YAChC,kBAAkB,SAAS,OAAO;YAElC,MAAM,KAAK,qBAAqB;WACjC,qBAAqB,IAAI;AAAA,QAC5B,MAAM;AAAA,QACN,OAAO;AAAA,OACR;UAEG;cACI,MAAM;YACR,gBAAgB,KAAK,IAAI,GAAG;eACzB,aAAa,KAAK,eAAe;AAAA;eAEjC;AAAA;aAEF,qBAAqB,IAAI,GAAG;AAAA;KAEpC;SAGM,WAAW,YAAiB;AAAA;EAzI3B,YAAY;WACX,YAAY,KAAK,UAAU,MAAM,MAAM,WAAW,cAAc,CAAC;AAAA;EAGlE,QAAQ;SACT,YAAY,IAAI,EAAE;UAEjB,aAAa,KAAK,iBAAiB,IAAI,IAAI;QAC7C,YAAY;aACP,oBAAoB,UAAU;AAAA;UAGjC,SAAS,cAAc,IAAI;QAC7B,CAAC,QAAQ;YACL,gBAAgB,KAAK,qBAAqB;UAC5C,eAAe;eACV,oBAAoB,aAAa;AAAA;aAEnC,KAAK;;WAGP,KAAK,QAAQ,MAAM;AAAA;EAG5B,IAAI;wBACkB,MAAM,MAAM;WAEzB,KAAK,QAAQ,IAAI;AAAA;EAGlB,oBAAoB;SACrB,YAAY,IAAI,EAAE;UAEjB,aAAa,KAAK,iBAAiB,IAAI,IAAI;QAC7C,YAAY;aACP;AAAA;UAGH,SAAS,cAAc,IAAI;QAC7B,CAAC,QAAQ;aACJ;AAAA;WAGF,KAAK,oBAAoB,MAAM;AAAA;EAGxC,gBAAgB;wBACM,MAAM,MAAM;WAEzB,KAAK,oBAAoB,IAAI;AAAA;EAGtC;WACS,oBAAoB,KAAK,oBAAoB,KAAK;AAAA;EA2BnD,aAAa,MAAc;wBACb,MAAM,MAAM;SAE3B,iBAAiB,IAAI,MAAM,EAAE,MAAM,YAAY,OAAO,iBAAiB;SACvE,YAAY,IAAI,EAAE;;;uBA2EM;SACxB,IAAI,aAAa,YAAY;AACtC;;"}

package/dist/src/dataModel/BaseDataModel.mjs

@@ -0,0 +1,108 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var _a;
+import { propsTypeSymbol } from "../modelShared/BaseModelShared.mjs";
+import { modelInfoByClass } from "../modelShared/modelInfo.mjs";
+import { getInternalModelClassPropsInfo } from "../modelShared/modelPropsInfo.mjs";
+import { noDefaultValue } from "../modelShared/prop.mjs";
+import { getSnapshot } from "../snapshot/getSnapshot.mjs";
+import { isTreeNode } from "../tweaker/core.mjs";
+import { toTreeNode } from "../tweaker/tweak.mjs";
+import { typesDataModelData } from "../types/objectBased/dataModelData.mjs";
+import { typeCheck } from "../types/typeCheck.mjs";
+import { isObject, failure } from "../utils/index.mjs";
+import { getOrCreate } from "../utils/mapUtils.mjs";
+import { internalNewDataModel } from "./newDataModel.mjs";
+const dataModelInstanceCache = /* @__PURE__ */ new WeakMap();
+class BaseDataModel {
+  constructor(data) {
+    __publicField(this, _a);
+    __publicField(this, "$");
+    if (!isObject(data)) {
+      throw failure("data models can only work over data objects");
+    }
+    const { modelClass: _modelClass } = arguments[1];
+    const modelClass = _modelClass;
+    let tweakedData;
+    if (isTreeNode(data)) {
+      tweakedData = data;
+    } else {
+      const modelInfo = modelInfoByClass.get(modelClass);
+      if (!modelInfo) {
+        throw failure(`no model info for class ${modelClass.name} could be found - did you forget to add the @model decorator?`);
+      }
+      const modelProps = getInternalModelClassPropsInfo(modelClass);
+      const initialData = Object.assign({}, data);
+      const modelPropsKeys = Object.keys(modelProps);
+      for (let i = 0; i < modelPropsKeys.length; i++) {
+        const k = modelPropsKeys[i];
+        const propData = modelProps[k];
+        let newValue = initialData[k];
+        let changed = false;
+        if (propData._internal.transform) {
+          changed = true;
+          newValue = propData._internal.transform.untransform(newValue, this, k);
+        }
+        if (newValue == null) {
+          if (propData._internal.defaultFn !== noDefaultValue) {
+            changed = true;
+            newValue = propData._internal.defaultFn();
+          } else if (propData._internal.defaultValue !== noDefaultValue) {
+            changed = true;
+            newValue = propData._internal.defaultValue;
+          }
+        }
+        if (changed) {
+          initialData[k] = newValue;
+        }
+      }
+      tweakedData = toTreeNode(initialData);
+    }
+    const instancesForModelClass = getOrCreate(dataModelInstanceCache, modelClass, () => /* @__PURE__ */ new WeakMap());
+    const instance = instancesForModelClass.get(tweakedData);
+    if (instance) {
+      return instance;
+    }
+    instancesForModelClass.set(tweakedData, this);
+    Object.setPrototypeOf(this, modelClass.prototype);
+    const self = this;
+    delete self[propsTypeSymbol];
+    internalNewDataModel(this, tweakedData, {
+      modelClass
+    });
+  }
+  typeCheck() {
+    const type = typesDataModelData(this.constructor);
+    return typeCheck(type, this.$);
+  }
+  toString(options) {
+    const finalOptions = __spreadValues({
+      withData: true
+    }, options);
+    const modelInfo = modelInfoByClass.get(this.constructor);
+    const firstPart = `${this.constructor.name}#${modelInfo.name}`;
+    return finalOptions.withData ? `[${firstPart} ${JSON.stringify(getSnapshot(this))}]` : `[${firstPart}]`;
+  }
+}
+_a = propsTypeSymbol;
+const baseDataModelPropNames = /* @__PURE__ */ new Set(["onLazyInit", "$", "typeCheck"]);
+export { BaseDataModel, baseDataModelPropNames };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"BaseDataModel.mjs","sources":["../../../src/dataModel/BaseDataModel.ts"],"sourcesContent":["import { ModelClass, propsTypeSymbol } from \"../modelShared/BaseModelShared\"\nimport { modelInfoByClass } from \"../modelShared/modelInfo\"\nimport { getInternalModelClassPropsInfo } from \"../modelShared/modelPropsInfo\"\nimport {\n  ModelProps,\n  ModelPropsToCreationData,\n  ModelPropsToData,\n  ModelPropsToTransformedCreationData,\n  noDefaultValue,\n} from \"../modelShared/prop\"\nimport { getSnapshot } from \"../snapshot/getSnapshot\"\nimport { isTreeNode } from \"../tweaker/core\"\nimport { toTreeNode } from \"../tweaker/tweak\"\nimport { typesDataModelData } from \"../types/objectBased/dataModelData\"\nimport { typeCheck } from \"../types/typeCheck\"\nimport type { TypeCheckError } from \"../types/TypeCheckError\"\nimport { failure, isObject } from \"../utils\"\nimport { getOrCreate } from \"../utils/mapUtils\"\nimport type { DataModelConstructorOptions } from \"./DataModelConstructorOptions\"\nimport { internalNewDataModel } from \"./newDataModel\"\n\nconst dataModelInstanceCache = new WeakMap<ModelClass<AnyDataModel>, WeakMap<any, AnyDataModel>>()\n\n/**\n * Base abstract class for data models. Use `DataModel` instead when extending.\n *\n * Never override the constructor, use `onLazyInit` instead.\n *\n * @typeparam Data Props data type.\n */\nexport abstract class BaseDataModel<TProps extends ModelProps> {\n  // just to make typing work properly\n  [propsTypeSymbol]!: TProps\n\n  /**\n   * Called after the instance is created when there's the first call to `fn(M, data)`.\n   */\n  protected onLazyInit?(): void\n\n  /**\n   * Data part of the model, which is observable and will be serialized in snapshots.\n   * Use it if one of the data properties matches one of the model properties/functions.\n   * This also allows access to the backed values of transformed properties.\n   */\n  readonly $!: ModelPropsToData<TProps>\n\n  /**\n   * Performs a type check over the model instance.\n   * For this to work a data type has to be declared as part of the model properties.\n   *\n   * @returns A `TypeCheckError` or `null` if there is no error.\n   */\n  typeCheck(): TypeCheckError | null {\n    const type = typesDataModelData<this>(this.constructor as any)\n    return typeCheck(type, this.$ as any)\n  }\n\n  /**\n   * Creates an instance of a data model.\n   */\n  constructor(\n    data: ModelPropsToCreationData<TProps> | ModelPropsToTransformedCreationData<TProps>\n  ) {\n    if (!isObject(data)) {\n      throw failure(\"data models can only work over data objects\")\n    }\n\n    const { modelClass: _modelClass }: DataModelConstructorOptions = arguments[1] as any\n    const modelClass = _modelClass!\n\n    type Data = ModelPropsToData<TProps>\n    let tweakedData: Data\n    if (isTreeNode(data)) {\n      // in theory already initialized\n      tweakedData = data as any as Data\n    } else {\n      const modelInfo = modelInfoByClass.get(modelClass)\n      if (!modelInfo) {\n        throw failure(\n          `no model info for class ${modelClass.name} could be found - did you forget to add the @model decorator?`\n        )\n      }\n\n      const modelProps = getInternalModelClassPropsInfo(modelClass)\n\n      const initialData: Record<string, any> = Object.assign({}, data)\n\n      const modelPropsKeys = Object.keys(modelProps)\n      for (let i = 0; i < modelPropsKeys.length; i++) {\n        const k = modelPropsKeys[i]\n        const propData = modelProps[k]\n\n        let newValue = initialData![k]\n        let changed = false\n\n        // apply untransform (if any)\n        if (propData._internal.transform) {\n          changed = true\n          newValue = propData._internal.transform.untransform(newValue, this, k)\n        }\n\n        // apply default value (if needed)\n        if (newValue == null) {\n          if (propData._internal.defaultFn !== noDefaultValue) {\n            changed = true\n            newValue = propData._internal.defaultFn()\n          } else if (propData._internal.defaultValue !== noDefaultValue) {\n            changed = true\n            newValue = propData._internal.defaultValue\n          }\n        }\n\n        if (changed) {\n          initialData[k] = newValue\n        }\n      }\n\n      tweakedData = toTreeNode(initialData as Data)\n    }\n\n    const instancesForModelClass = getOrCreate(\n      dataModelInstanceCache,\n      modelClass,\n      () => new WeakMap()\n    )\n\n    const instance = instancesForModelClass.get(tweakedData)\n    if (instance) {\n      return instance\n    }\n\n    instancesForModelClass.set(tweakedData, this)\n\n    Object.setPrototypeOf(this, modelClass.prototype)\n\n    const self = this as any\n\n    // delete unnecessary props\n    delete self[propsTypeSymbol]\n\n    internalNewDataModel(this, tweakedData as any, {\n      modelClass,\n    })\n  }\n\n  toString(options?: { withData?: boolean }) {\n    const finalOptions = {\n      withData: true,\n      ...options,\n    }\n\n    const modelInfo = modelInfoByClass.get(this.constructor as any)\n\n    const firstPart = `${this.constructor.name}#${modelInfo!.name}`\n\n    return finalOptions.withData\n      ? `[${firstPart} ${JSON.stringify(getSnapshot(this))}]`\n      : `[${firstPart}]`\n  }\n}\n\n/**\n * @ignore\n */\nexport type BaseDataModelKeys = keyof AnyDataModel | \"onLazyInit\"\n\n// these props will never be hoisted to this\n/**\n * @internal\n */\nexport const baseDataModelPropNames = new Set<BaseDataModelKeys>([\"onLazyInit\", \"$\", \"typeCheck\"])\n\n/**\n * Any kind of data model instance.\n */\nexport interface AnyDataModel extends BaseDataModel<any> {}\n\n/**\n * A data model class declaration, made of a base model and the model interface.\n */\nexport type DataModelClassDeclaration<BaseModelClass, ModelInterface> = BaseModelClass & {\n  (...args: any[]): ModelInterface\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,6CAA6B;MASb;EA8BpB,YACE;AA7BD;AAYQ;QAmBH,CAAC,SAAS,IAAI,GAAG;YACb,QAAQ,6CAA6C;AAAA;UAGvD,EAAE,YAAY,gBAA6C,UAAU;UACrE,aAAa;QAGf;QACA,WAAW,IAAI,GAAG;oBAEN;AAAA,WACT;YACC,YAAY,iBAAiB,IAAI,UAAU;UAC7C,CAAC,WAAW;cACR,QACJ,2BAA2B,WAAW,mEAAmE;AAAA;YAIvG,aAAa,+BAA+B,UAAU;YAEtD,cAAmC,OAAO,OAAO,IAAI,IAAI;YAEzD,iBAAiB,OAAO,KAAK,UAAU;eACpC,IAAI,GAAG,IAAI,eAAe,QAAQ,KAAK;cACxC,IAAI,eAAe;cACnB,WAAW,WAAW;YAExB,WAAW,YAAa;YACxB,UAAU;YAGV,SAAS,UAAU,WAAW;oBACtB;qBACC,SAAS,UAAU,UAAU,YAAY,UAAU,MAAM,CAAC;AAAA;YAInE,YAAY,MAAM;cAChB,SAAS,UAAU,cAAc,gBAAgB;sBACzC;uBACC,SAAS,UAAU;qBACrB,SAAS,UAAU,iBAAiB,gBAAgB;sBACnD;uBACC,SAAS,UAAU;AAAA;;YAI9B,SAAS;sBACC,KAAK;AAAA;;oBAIP,WAAW,WAAmB;AAAA;UAGxC,yBAAyB,YAC7B,wBACA,YACA,0BAAU,SAAS;UAGf,WAAW,uBAAuB,IAAI,WAAW;QACnD,UAAU;aACL;AAAA;2BAGc,IAAI,aAAa,IAAI;WAErC,eAAe,MAAM,WAAW,SAAS;UAE1C,OAAO;WAGN,KAAK;yBAES,MAAM,aAAoB;AAAA,MAC7C;AAAA,KACD;AAAA;EA1FH;UACQ,OAAO,mBAAyB,KAAK,WAAkB;WACtD,UAAU,MAAM,KAAK,CAAQ;AAAA;EA2FtC,SAAS;UACD,eAAe;AAAA,MACnB,UAAU;AAAA,OACP;UAGC,YAAY,iBAAiB,IAAI,KAAK,WAAkB;UAExD,YAAY,GAAG,KAAK,YAAY,QAAQ,UAAW;WAElD,aAAa,WAChB,IAAI,aAAa,KAAK,UAAU,YAAY,IAAI,CAAC,OACjD,IAAI;AAAA;;AA7HT;MA0IU,6CAA6B,IAAuB,CAAC,cAAc,KAAK,WAAW,CAAC;;"}

package/dist/src/dataModel/DataModel.mjs

@@ -0,0 +1,32 @@
+import { sharedInternalModel } from "../modelShared/Model.mjs";
+import { isDataModelClass, assertIsDataModelClass } from "./utils.mjs";
+function ExtendedDataModel(...args) {
+  let baseModel;
+  let modelProps;
+  if (isDataModelClass(args[0])) {
+    baseModel = args[0];
+    modelProps = args[1];
+  } else {
+    const gen = args[0]();
+    baseModel = gen.baseModel;
+    modelProps = gen.props;
+  }
+  assertIsDataModelClass(baseModel, "baseModel");
+  return internalDataModel(modelProps, baseModel);
+}
+function DataModel(fnModelPropsOrModelProps) {
+  const modelProps = typeof fnModelPropsOrModelProps === "function" ? fnModelPropsOrModelProps() : fnModelPropsOrModelProps;
+  return internalDataModel(modelProps, void 0);
+}
+function internalDataModel(modelProps, baseModel) {
+  return sharedInternalModel({
+    modelProps,
+    baseModel,
+    type: "data",
+    valueType: false,
+    fromSnapshotProcessor: void 0,
+    toSnapshotProcessor: void 0
+  });
+}
+export { DataModel, ExtendedDataModel };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/dataModel/actions.mjs

@@ -0,0 +1,12 @@
+const dataModelActionRegistry = /* @__PURE__ */ new Map();
+function getDataModelAction(fullActionName) {
+  return dataModelActionRegistry.get(fullActionName);
+}
+function setDataModelAction(fullActionName, modelClass, fnName) {
+  dataModelActionRegistry.set(fullActionName, {
+    modelClass,
+    fnName
+  });
+}
+export { getDataModelAction, setDataModelAction };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9ucy5tanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9kYXRhTW9kZWwvYWN0aW9ucy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2RlbENsYXNzIH0gZnJvbSBcIi4uL21vZGVsU2hhcmVkL0Jhc2VNb2RlbFNoYXJlZFwiXG5pbXBvcnQgdHlwZSB7IEFueURhdGFNb2RlbCB9IGZyb20gXCIuL0Jhc2VEYXRhTW9kZWxcIlxuXG5jb25zdCBkYXRhTW9kZWxBY3Rpb25SZWdpc3RyeSA9IG5ldyBNYXA8XG4gIHN0cmluZyxcbiAge1xuICAgIG1vZGVsQ2xhc3M6IE1vZGVsQ2xhc3M8QW55RGF0YU1vZGVsPlxuICAgIGZuTmFtZTogc3RyaW5nXG4gIH1cbj4oKVxuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0RGF0YU1vZGVsQWN0aW9uKGZ1bGxBY3Rpb25OYW1lOiBzdHJpbmcpIHtcbiAgcmV0dXJuIGRhdGFNb2RlbEFjdGlvblJlZ2lzdHJ5LmdldChmdWxsQWN0aW9uTmFtZSlcbn1cblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldERhdGFNb2RlbEFjdGlvbihcbiAgZnVsbEFjdGlvbk5hbWU6IHN0cmluZyxcbiAgbW9kZWxDbGFzczogTW9kZWxDbGFzczxBbnlEYXRhTW9kZWw+LFxuICBmbk5hbWU6IHN0cmluZ1xuKSB7XG4gIGRhdGFNb2RlbEFjdGlvblJlZ2lzdHJ5LnNldChmdWxsQWN0aW9uTmFtZSwge1xuICAgIG1vZGVsQ2xhc3MsXG4gICAgZm5OYW1lLFxuICB9KVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sOENBQThCOzRCQVdEO1NBQzFCLHdCQUF3QixJQUFJLGNBQWM7QUFDbkQ7NEJBTUUsZ0JBQ0EsWUFDQTswQkFFd0IsSUFBSSxnQkFBZ0I7QUFBQSxJQUMxQztBQUFBLElBQ0E7QUFBQSxHQUNEO0FBQ0g7OyJ9

package/dist/src/dataModel/getDataModelMetadata.mjs

@@ -0,0 +1,14 @@
+import { modelMetadataSymbol } from "../modelShared/modelSymbols.mjs";
+import { failure } from "../utils/index.mjs";
+import { isDataModel, isDataModelClass } from "./utils.mjs";
+function getDataModelMetadata(modelClassOrInstance) {
+  if (isDataModel(modelClassOrInstance)) {
+    return modelClassOrInstance.constructor[modelMetadataSymbol];
+  } else if (isDataModelClass(modelClassOrInstance)) {
+    return modelClassOrInstance[modelMetadataSymbol];
+  } else {
+    throw failure(`modelClassOrInstance must be a model class or instance`);
+  }
+}
+export { getDataModelMetadata };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0RGF0YU1vZGVsTWV0YWRhdGEubWpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGF0YU1vZGVsL2dldERhdGFNb2RlbE1ldGFkYXRhLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTW9kZWxDbGFzcyB9IGZyb20gXCIuLi9tb2RlbFNoYXJlZC9CYXNlTW9kZWxTaGFyZWRcIlxuaW1wb3J0IHsgbW9kZWxNZXRhZGF0YVN5bWJvbCB9IGZyb20gXCIuLi9tb2RlbFNoYXJlZC9tb2RlbFN5bWJvbHNcIlxuaW1wb3J0IHR5cGUgeyBBbnlUeXBlIH0gZnJvbSBcIi4uL3R5cGVzL3NjaGVtYXNcIlxuaW1wb3J0IHsgZmFpbHVyZSB9IGZyb20gXCIuLi91dGlsc1wiXG5pbXBvcnQgdHlwZSB7IEFueURhdGFNb2RlbCB9IGZyb20gXCIuL0Jhc2VEYXRhTW9kZWxcIlxuaW1wb3J0IHsgaXNEYXRhTW9kZWwsIGlzRGF0YU1vZGVsQ2xhc3MgfSBmcm9tIFwiLi91dGlsc1wiXG5cbi8qKlxuICogQXNzb2NpYXRlZCBkYXRhIG1vZGVsIG1ldGFkYXRhLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIERhdGFNb2RlbE1ldGFkYXRhIHtcbiAgLyoqXG4gICAqIEFzc29jaWF0ZWQgZGF0YSB0eXBlIGZvciBydW50aW1lIGNoZWNraW5nIChpZiBhbnkpLlxuICAgKi9cbiAgZGF0YVR5cGU/OiBBbnlUeXBlXG59XG5cbi8qKlxuICogUmV0dXJucyB0aGUgYXNzb2NpYXRlZCBtZXRhZGF0YSBmb3IgYSBkYXRhIG1vZGVsIGluc3RhbmNlIG9yIGNsYXNzLlxuICpcbiAqIEBwYXJhbSBtb2RlbENsYXNzT3JJbnN0YW5jZSBEYXRhIG1vZGVsIGNsYXNzIG9yIGluc3RhbmNlLlxuICogQHJldHVybnMgVGhlIGFzc29jaWF0ZWQgbWV0YWRhdGEuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXREYXRhTW9kZWxNZXRhZGF0YShcbiAgbW9kZWxDbGFzc09ySW5zdGFuY2U6IEFueURhdGFNb2RlbCB8IE1vZGVsQ2xhc3M8QW55RGF0YU1vZGVsPlxuKTogRGF0YU1vZGVsTWV0YWRhdGEge1xuICBpZiAoaXNEYXRhTW9kZWwobW9kZWxDbGFzc09ySW5zdGFuY2UpKSB7XG4gICAgcmV0dXJuIChtb2RlbENsYXNzT3JJbnN0YW5jZSBhcyBhbnkpLmNvbnN0cnVjdG9yW21vZGVsTWV0YWRhdGFTeW1ib2xdXG4gIH0gZWxzZSBpZiAoaXNEYXRhTW9kZWxDbGFzcyhtb2RlbENsYXNzT3JJbnN0YW5jZSkpIHtcbiAgICByZXR1cm4gKG1vZGVsQ2xhc3NPckluc3RhbmNlIGFzIGFueSlbbW9kZWxNZXRhZGF0YVN5bWJvbF1cbiAgfSBlbHNlIHtcbiAgICB0aHJvdyBmYWlsdXJlKGBtb2RlbENsYXNzT3JJbnN0YW5jZSBtdXN0IGJlIGEgbW9kZWwgY2xhc3Mgb3IgaW5zdGFuY2VgKVxuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OzhCQXdCRTtNQUVJLFlBQVksb0JBQW9CLEdBQUc7V0FDN0IscUJBQTZCLFlBQVk7QUFBQSxhQUN4QyxpQkFBaUIsb0JBQW9CLEdBQUc7V0FDekMscUJBQTZCO0FBQUEsU0FDaEM7VUFDQyxRQUFRLHdEQUF3RDtBQUFBO0FBRTFFOzsifQ==

package/dist/src/dataModel/newDataModel.mjs

@@ -0,0 +1,31 @@
+import { action } from "mobx";
+import { isModelAutoTypeCheckingEnabled } from "../globalConfig/globalConfig.mjs";
+import { modelInfoByClass } from "../modelShared/modelInfo.mjs";
+import { applyModelInitializers } from "../modelShared/newModel.mjs";
+import { failure } from "../utils/index.mjs";
+import { getDataModelMetadata } from "./getDataModelMetadata.mjs";
+import "../types/primitiveBased/primitives.mjs";
+import "../types/TypeChecker.mjs";
+import "../model/newModel.mjs";
+import "../snapshot/internal.mjs";
+import "../tweaker/tweak.mjs";
+const internalNewDataModel = action("newModel", (origModelObj, tweakedData, options) => {
+  const { modelClass: _modelClass } = options;
+  const modelClass = _modelClass;
+  const modelObj = origModelObj;
+  const modelInfo = modelInfoByClass.get(modelClass);
+  if (!modelInfo) {
+    throw failure(`no model info for class ${modelClass.name} could be found - did you forget to add the @model decorator?`);
+  }
+  modelObj.$ = tweakedData;
+  if (isModelAutoTypeCheckingEnabled() && getDataModelMetadata(modelClass).dataType) {
+    const err = modelObj.typeCheck();
+    if (err) {
+      err.throw(modelObj);
+    }
+  }
+  applyModelInitializers(modelClass, modelObj);
+  return modelObj;
+});
+export { internalNewDataModel };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/dataModel/utils.mjs

@@ -0,0 +1,29 @@
+import { failure } from "../utils/index.mjs";
+import { BaseDataModel } from "./BaseDataModel.mjs";
+function isDataModel(model) {
+  return model instanceof BaseDataModel;
+}
+function assertIsDataModel(model, argName, customErrMsg = "must be a data model instance") {
+  if (!isDataModel(model)) {
+    throw failure(`${argName} ${customErrMsg}`);
+  }
+}
+function isDataModelClass(modelClass) {
+  if (typeof modelClass !== "function") {
+    return false;
+  }
+  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
+    return false;
+  }
+  return true;
+}
+function assertIsDataModelClass(modelClass, argName) {
+  if (typeof modelClass !== "function") {
+    throw failure(`${argName} must be a class`);
+  }
+  if (modelClass !== BaseDataModel && !(modelClass.prototype instanceof BaseDataModel)) {
+    throw failure(`${argName} must extend DataModel`);
+  }
+}
+export { assertIsDataModel, assertIsDataModelClass, isDataModel, isDataModelClass };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/frozen/Frozen.mjs

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { getGlobalConfig } from "../globalConfig/globalConfig.mjs";
+import { tweak } from "../tweaker/tweak.mjs";
+import { inDevMode, isPrimitive, failure, isPlainObject } from "../utils/index.mjs";
+var FrozenCheckMode;
+(function(FrozenCheckMode2) {
+  FrozenCheckMode2["DevModeOnly"] = "devModeOnly";
+  FrozenCheckMode2["On"] = "on";
+  FrozenCheckMode2["Off"] = "off";
+})(FrozenCheckMode || (FrozenCheckMode = {}));
+const frozenKey = "$frozen";
+class Frozen {
+  constructor(dataToFreeze, checkMode = FrozenCheckMode.DevModeOnly) {
+    __publicField(this, "data");
+    const check = checkMode === FrozenCheckMode.On || checkMode === FrozenCheckMode.DevModeOnly && inDevMode();
+    if (check) {
+      checkDataIsSerializableAndFreeze(dataToFreeze);
+    }
+    this.data = dataToFreeze;
+    if (check) {
+      Object.freeze(this.data);
+    }
+    tweak(this, void 0);
+  }
+}
+function frozen(data, checkMode = FrozenCheckMode.DevModeOnly) {
+  return new Frozen(data, checkMode);
+}
+function checkDataIsSerializableAndFreeze(data) {
+  if (isPrimitive(data)) {
+    return;
+  }
+  if (Array.isArray(data)) {
+    const arrLen = data.length;
+    for (let i = 0; i < arrLen; i++) {
+      const v = data[i];
+      if (v === void 0 && !getGlobalConfig().allowUndefinedArrayElements) {
+        throw failure("undefined is not supported inside arrays since it is not serializable in JSON, consider using null instead");
+      }
+      checkDataIsSerializableAndFreeze(v);
+    }
+    Object.freeze(data);
+    return;
+  }
+  if (isPlainObject(data)) {
+    const dataKeys = Object.keys(data);
+    const dataKeysLen = dataKeys.length;
+    for (let i = 0; i < dataKeysLen; i++) {
+      const k = dataKeys[i];
+      const v = data[k];
+      checkDataIsSerializableAndFreeze(k);
+      checkDataIsSerializableAndFreeze(v);
+    }
+    Object.freeze(data);
+    return;
+  }
+  throw failure(`frozen data must be plainly serializable to JSON, but ${data} is not`);
+}
+function isFrozenSnapshot(snapshot) {
+  return isPlainObject(snapshot) && frozenKey in snapshot;
+}
+export { Frozen, FrozenCheckMode, frozen, frozenKey, isFrozenSnapshot };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/src/globalConfig/globalConfig.mjs

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { nanoid } from "../../node_modules/nanoid/non-secure/index.mjs";
+import { failure, inDevMode } from "../utils/index.mjs";
+var ModelAutoTypeCheckingMode;
+(function(ModelAutoTypeCheckingMode2) {
+  ModelAutoTypeCheckingMode2["DevModeOnly"] = "devModeOnly";
+  ModelAutoTypeCheckingMode2["AlwaysOn"] = "alwaysOn";
+  ModelAutoTypeCheckingMode2["AlwaysOff"] = "alwaysOff";
+})(ModelAutoTypeCheckingMode || (ModelAutoTypeCheckingMode = {}));
+let localId = 0;
+const localBaseId = nanoid();
+function defaultModelIdGenerator() {
+  const id = localId.toString(36) + "-" + localBaseId;
+  localId++;
+  return id;
+}
+let globalConfig = {
+  modelAutoTypeChecking: ModelAutoTypeCheckingMode.DevModeOnly,
+  modelIdGenerator: defaultModelIdGenerator,
+  allowUndefinedArrayElements: false,
+  showDuplicateModelNameWarnings: true
+};
+function setGlobalConfig(config) {
+  globalConfig = Object.freeze(__spreadValues(__spreadValues({}, globalConfig), config));
+}
+function getGlobalConfig() {
+  return globalConfig;
+}
+function isModelAutoTypeCheckingEnabled() {
+  switch (getGlobalConfig().modelAutoTypeChecking) {
+    case ModelAutoTypeCheckingMode.DevModeOnly:
+      return inDevMode();
+    case ModelAutoTypeCheckingMode.AlwaysOff:
+      return false;
+    case ModelAutoTypeCheckingMode.AlwaysOn:
+      return true;
+    default:
+      throw failure(`invalid 'modelAutoTypeChecking' config value - ${globalConfig.modelAutoTypeChecking}`);
+  }
+}
+export { ModelAutoTypeCheckingMode, getGlobalConfig, isModelAutoTypeCheckingEnabled, setGlobalConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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