react-antd-xform 1.0.0

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/ObserverComponent.js

@@ -0,0 +1,5 @@
+import "mobx";
+import "react";
+import "./utils/observerFinalizationRegistry.js";
+import "../../../../use-sync-external-store@1.5.0_react@18.3.1/node_modules/use-sync-external-store/shim/index.js";
+if ("production" !== process.env.NODE_ENV) ;

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/index.js

@@ -0,0 +1,18 @@
+import "./utils/assertEnvironment.js";
+import { unstable_batchedUpdates } from "react-dom";
+import { observerBatching } from "./utils/observerBatching.js";
+import "mobx";
+import "react";
+import { observerFinalizationRegistry } from "./utils/observerFinalizationRegistry.js";
+import "../../../../use-sync-external-store@1.5.0_react@18.3.1/node_modules/use-sync-external-store/shim/index.js";
+import { observer } from "./observer.js";
+import "./ObserverComponent.js";
+var _a;
+observerBatching(unstable_batchedUpdates);
+(_a = observerFinalizationRegistry["finalizeAllImmediately"]) !== null && _a !== void 0 ? _a : function() {
+};
+export {
+  observerFinalizationRegistry as _observerFinalizationRegistry,
+  observer,
+  observerBatching
+};

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/observer.js

@@ -0,0 +1,84 @@
+import { forwardRef, memo } from "react";
+import { useObserver } from "./useObserver.js";
+var _a, _b;
+var warnObserverOptionsDeprecated = true;
+var warnLegacyContextTypes = true;
+var hasSymbol = typeof Symbol === "function" && Symbol.for;
+var isFunctionNameConfigurable = (_b = (_a = Object.getOwnPropertyDescriptor(function() {
+}, "name")) === null || _a === void 0 ? void 0 : _a.configurable) !== null && _b !== void 0 ? _b : false;
+var ReactForwardRefSymbol = hasSymbol ? Symbol.for("react.forward_ref") : typeof forwardRef === "function" && forwardRef(function(props) {
+  return null;
+})["$$typeof"];
+var ReactMemoSymbol = hasSymbol ? Symbol.for("react.memo") : typeof memo === "function" && memo(function(props) {
+  return null;
+})["$$typeof"];
+function observer(baseComponent, options) {
+  var _a2;
+  if (process.env.NODE_ENV !== "production" && warnObserverOptionsDeprecated && options) ;
+  if (ReactMemoSymbol && baseComponent["$$typeof"] === ReactMemoSymbol) {
+    throw new Error("[mobx-react-lite] You are trying to use `observer` on a function component wrapped in either another `observer` or `React.memo`. The observer already applies 'React.memo' for you.");
+  }
+  var useForwardRef = (_a2 = void 0) !== null && _a2 !== void 0 ? _a2 : false;
+  var render = baseComponent;
+  var baseComponentName = baseComponent.displayName || baseComponent.name;
+  if (ReactForwardRefSymbol && baseComponent["$$typeof"] === ReactForwardRefSymbol) {
+    useForwardRef = true;
+    render = baseComponent["render"];
+    if (typeof render !== "function") {
+      throw new Error("[mobx-react-lite] `render` property of ForwardRef was not a function");
+    }
+  }
+  var observerComponent = function(props, ref) {
+    return useObserver(function() {
+      return render(props, ref);
+    }, baseComponentName);
+  };
+  observerComponent.displayName = baseComponent.displayName;
+  if (isFunctionNameConfigurable) {
+    Object.defineProperty(observerComponent, "name", {
+      value: baseComponent.name,
+      writable: true,
+      configurable: true
+    });
+  }
+  if (baseComponent.contextTypes) {
+    observerComponent.contextTypes = baseComponent.contextTypes;
+    if (process.env.NODE_ENV !== "production" && warnLegacyContextTypes) {
+      warnLegacyContextTypes = false;
+      console.warn("[mobx-react-lite] Support for Legacy Context in function components will be removed in the next major release.");
+    }
+  }
+  if (useForwardRef) {
+    observerComponent = forwardRef(observerComponent);
+  }
+  observerComponent = memo(observerComponent);
+  copyStaticProperties(baseComponent, observerComponent);
+  if ("production" !== process.env.NODE_ENV) {
+    Object.defineProperty(observerComponent, "contextTypes", {
+      set: function() {
+        var _a3, _b2;
+        throw new Error("[mobx-react-lite] `".concat(this.displayName || ((_a3 = this.type) === null || _a3 === void 0 ? void 0 : _a3.displayName) || ((_b2 = this.type) === null || _b2 === void 0 ? void 0 : _b2.name) || "Component", ".contextTypes` must be set before applying `observer`."));
+      }
+    });
+  }
+  return observerComponent;
+}
+var hoistBlackList = {
+  $$typeof: true,
+  render: true,
+  compare: true,
+  type: true,
+  // Don't redefine `displayName`,
+  // it's defined as getter-setter pair on `memo` (see #3192).
+  displayName: true
+};
+function copyStaticProperties(base, target) {
+  Object.keys(base).forEach(function(key) {
+    if (!hoistBlackList[key]) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key));
+    }
+  });
+}
+export {
+  observer
+};

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/useObserver.js

@@ -0,0 +1,72 @@
+import { Reaction } from "mobx";
+import require$$0 from "react";
+import { printDebugValue } from "./utils/printDebugValue.js";
+import { observerFinalizationRegistry } from "./utils/observerFinalizationRegistry.js";
+import { s as shimExports } from "../../../../use-sync-external-store@1.5.0_react@18.3.1/node_modules/use-sync-external-store/shim/index.js";
+function createReaction(adm) {
+  adm.reaction = new Reaction("observer".concat(adm.name), function() {
+    var _a;
+    adm.stateVersion = Symbol();
+    (_a = adm.onStoreChange) === null || _a === void 0 ? void 0 : _a.call(adm);
+  });
+}
+function useObserver(render, baseComponentName) {
+  if (baseComponentName === void 0) {
+    baseComponentName = "observed";
+  }
+  var admRef = require$$0.useRef(null);
+  if (!admRef.current) {
+    var adm_1 = {
+      reaction: null,
+      onStoreChange: null,
+      stateVersion: Symbol(),
+      name: baseComponentName,
+      subscribe: function(onStoreChange) {
+        observerFinalizationRegistry.unregister(adm_1);
+        adm_1.onStoreChange = onStoreChange;
+        if (!adm_1.reaction) {
+          createReaction(adm_1);
+          adm_1.stateVersion = Symbol();
+        }
+        return function() {
+          var _a;
+          adm_1.onStoreChange = null;
+          (_a = adm_1.reaction) === null || _a === void 0 ? void 0 : _a.dispose();
+          adm_1.reaction = null;
+        };
+      },
+      getSnapshot: function() {
+        return adm_1.stateVersion;
+      }
+    };
+    admRef.current = adm_1;
+  }
+  var adm = admRef.current;
+  if (!adm.reaction) {
+    createReaction(adm);
+    observerFinalizationRegistry.register(admRef, adm, adm);
+  }
+  require$$0.useDebugValue(adm.reaction, printDebugValue);
+  shimExports.useSyncExternalStore(
+    // Both of these must be stable, otherwise it would keep resubscribing every render.
+    adm.subscribe,
+    adm.getSnapshot,
+    adm.getSnapshot
+  );
+  var renderResult;
+  var exception;
+  adm.reaction.track(function() {
+    try {
+      renderResult = render();
+    } catch (e) {
+      exception = e;
+    }
+  });
+  if (exception) {
+    throw exception;
+  }
+  return renderResult;
+}
+export {
+  useObserver
+};

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/utils/UniversalFinalizationRegistry.js

@@ -0,0 +1,96 @@
+var REGISTRY_FINALIZE_AFTER = 1e4;
+var REGISTRY_SWEEP_INTERVAL = 1e4;
+var TimerBasedFinalizationRegistry = (
+  /** @class */
+  function() {
+    function TimerBasedFinalizationRegistry2(finalize) {
+      var _this = this;
+      Object.defineProperty(this, "finalize", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: finalize
+      });
+      Object.defineProperty(this, "registrations", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: /* @__PURE__ */ new Map()
+      });
+      Object.defineProperty(this, "sweepTimeout", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, "sweep", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: function(maxAge) {
+          if (maxAge === void 0) {
+            maxAge = REGISTRY_FINALIZE_AFTER;
+          }
+          clearTimeout(_this.sweepTimeout);
+          _this.sweepTimeout = void 0;
+          var now = Date.now();
+          _this.registrations.forEach(function(registration, token) {
+            if (now - registration.registeredAt >= maxAge) {
+              _this.finalize(registration.value);
+              _this.registrations.delete(token);
+            }
+          });
+          if (_this.registrations.size > 0) {
+            _this.scheduleSweep();
+          }
+        }
+      });
+      Object.defineProperty(this, "finalizeAllImmediately", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: function() {
+          _this.sweep(0);
+        }
+      });
+    }
+    Object.defineProperty(TimerBasedFinalizationRegistry2.prototype, "register", {
+      enumerable: false,
+      configurable: true,
+      writable: true,
+      value: function(target, value, token) {
+        this.registrations.set(token, {
+          value,
+          registeredAt: Date.now()
+        });
+        this.scheduleSweep();
+      }
+    });
+    Object.defineProperty(TimerBasedFinalizationRegistry2.prototype, "unregister", {
+      enumerable: false,
+      configurable: true,
+      writable: true,
+      value: function(token) {
+        this.registrations.delete(token);
+      }
+    });
+    Object.defineProperty(TimerBasedFinalizationRegistry2.prototype, "scheduleSweep", {
+      enumerable: false,
+      configurable: true,
+      writable: true,
+      value: function() {
+        if (this.sweepTimeout === void 0) {
+          this.sweepTimeout = setTimeout(this.sweep, REGISTRY_SWEEP_INTERVAL);
+        }
+      }
+    });
+    return TimerBasedFinalizationRegistry2;
+  }()
+);
+var UniversalFinalizationRegistry = typeof FinalizationRegistry !== "undefined" ? FinalizationRegistry : TimerBasedFinalizationRegistry;
+export {
+  REGISTRY_FINALIZE_AFTER,
+  REGISTRY_SWEEP_INTERVAL,
+  TimerBasedFinalizationRegistry,
+  UniversalFinalizationRegistry
+};

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/utils/assertEnvironment.js

@@ -0,0 +1,8 @@
+import { makeObservable } from "mobx";
+import { useState } from "react";
+if (!useState) {
+  throw new Error("mobx-react-lite requires React with Hooks support");
+}
+if (!makeObservable) {
+  throw new Error("mobx-react-lite@3 requires mobx at least version 6 to be available");
+}

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/utils/observerBatching.js

@@ -0,0 +1,17 @@
+import { configure } from "mobx";
+function defaultNoopBatch(callback) {
+  callback();
+}
+function observerBatching(reactionScheduler) {
+  if (!reactionScheduler) {
+    reactionScheduler = defaultNoopBatch;
+    if ("production" !== process.env.NODE_ENV) {
+      console.warn("[MobX] Failed to get unstable_batched updates from react-dom / react-native");
+    }
+  }
+  configure({ reactionScheduler });
+}
+export {
+  defaultNoopBatch,
+  observerBatching
+};

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/utils/observerFinalizationRegistry.js

@@ -0,0 +1,9 @@
+import { UniversalFinalizationRegistry } from "./UniversalFinalizationRegistry.js";
+var observerFinalizationRegistry = new UniversalFinalizationRegistry(function(adm) {
+  var _a;
+  (_a = adm.reaction) === null || _a === void 0 ? void 0 : _a.dispose();
+  adm.reaction = null;
+});
+export {
+  observerFinalizationRegistry
+};

package/dist/node_modules/.pnpm/mobx-react-lite@4.1.0_mobx@6.13.7_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/mobx-react-lite/es/utils/printDebugValue.js

@@ -0,0 +1,7 @@
+import { getDependencyTree } from "mobx";
+function printDebugValue(v) {
+  return getDependencyTree(v);
+}
+export {
+  printDebugValue
+};