@hanzogui/react-native-web-lite 2.0.0

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedDiffClamp.cjs

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AnimatedDiffClamp_exports = {};
+__export(AnimatedDiffClamp_exports, {
+  AnimatedDiffClamp: () => AnimatedDiffClamp,
+  default: () => AnimatedDiffClamp_default
+});
+module.exports = __toCommonJS(AnimatedDiffClamp_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+class AnimatedDiffClamp extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _a;
+  _min;
+  _max;
+  _value;
+  _lastValue;
+  constructor(a, min, max) {
+    super(), this._a = a, this._min = min, this._max = max, this._value = this._lastValue = this._a.__getValue();
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.AnimatedInterpolation(this, config);
+  }
+  __getValue() {
+    const value = this._a.__getValue(),
+      diff = value - this._lastValue;
+    return this._lastValue = value, this._value = Math.min(Math.max(this._value + diff, this._min), this._max), this._value;
+  }
+  __attach() {
+    this._a.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "diffclamp",
+      input: this._a.__getNativeTag(),
+      min: this._min,
+      max: this._max
+    };
+  }
+}
+var AnimatedDiffClamp_default = AnimatedDiffClamp;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedDivision.cjs

@@ -0,0 +1,64 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AnimatedDivision_exports = {};
+__export(AnimatedDivision_exports, {
+  AnimatedDivision: () => AnimatedDivision,
+  default: () => AnimatedDivision_default
+});
+module.exports = __toCommonJS(AnimatedDivision_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs"),
+  import_AnimatedNode = require("./AnimatedNode.cjs"),
+  import_AnimatedValue = require("./AnimatedValue.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+class AnimatedDivision extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _a;
+  _b;
+  _warnedAboutDivideByZero = !1;
+  constructor(a, b) {
+    super(), (b === 0 || b instanceof import_AnimatedNode.AnimatedNode && b.__getValue() === 0) && console.error("Detected potential division by zero in AnimatedDivision"), this._a = typeof a == "number" ? new import_AnimatedValue.AnimatedValue(a) : a, this._b = typeof b == "number" ? new import_AnimatedValue.AnimatedValue(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), this._b.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    const a = this._a.__getValue(),
+      b = this._b.__getValue();
+    return b === 0 ? (this._warnedAboutDivideByZero || (console.error("Detected division by zero in AnimatedDivision"), this._warnedAboutDivideByZero = !0), 0) : (this._warnedAboutDivideByZero = !1, a / b);
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.AnimatedInterpolation(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this), this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), this._b.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "division",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var AnimatedDivision_default = AnimatedDivision;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedInterpolation.cjs

@@ -0,0 +1,150 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AnimatedInterpolation_exports = {};
+__export(AnimatedInterpolation_exports, {
+  AnimatedInterpolation: () => AnimatedInterpolation,
+  default: () => AnimatedInterpolation_default
+});
+module.exports = __toCommonJS(AnimatedInterpolation_exports);
+var import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+const __DEV__ = process.env.NODE_ENV !== "production",
+  linear = t => t;
+function createInterpolation(config) {
+  if (config.outputRange && typeof config.outputRange[0] == "string") return createInterpolationFromStringOutputRange(config);
+  const outputRange = config.outputRange,
+    inputRange = config.inputRange;
+  __DEV__ && (checkInfiniteRange("outputRange", outputRange), checkInfiniteRange("inputRange", inputRange), checkValidInputRange(inputRange), (0, import_react_native_web_internals.invariant)(inputRange.length === outputRange.length, "inputRange (" + inputRange.length + ") and outputRange (" + outputRange.length + ") must have the same length"));
+  const easing = config.easing || linear;
+  let extrapolateLeft = "extend";
+  config.extrapolateLeft !== void 0 ? extrapolateLeft = config.extrapolateLeft : config.extrapolate !== void 0 && (extrapolateLeft = config.extrapolate);
+  let extrapolateRight = "extend";
+  return config.extrapolateRight !== void 0 ? extrapolateRight = config.extrapolateRight : config.extrapolate !== void 0 && (extrapolateRight = config.extrapolate), input => {
+    (0, import_react_native_web_internals.invariant)(typeof input == "number", "Cannot interpolation an input which is not a number");
+    const range = findRange(input, inputRange);
+    return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight);
+  };
+}
+function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight) {
+  let result = input;
+  if (result < inputMin) {
+    if (extrapolateLeft === "identity") return result;
+    extrapolateLeft === "clamp" && (result = inputMin);
+  }
+  if (result > inputMax) {
+    if (extrapolateRight === "identity") return result;
+    extrapolateRight === "clamp" && (result = inputMax);
+  }
+  return outputMin === outputMax ? outputMin : inputMin === inputMax ? input <= inputMin ? outputMin : outputMax : (inputMin === -1 / 0 ? result = -result : inputMax === 1 / 0 ? result = result - inputMin : result = (result - inputMin) / (inputMax - inputMin), result = easing(result), outputMin === -1 / 0 ? result = -result : outputMax === 1 / 0 ? result = result + outputMin : result = result * (outputMax - outputMin) + outputMin, result);
+}
+function colorToRgba(input) {
+  let normalizedColor = (0, import_react_native_web_internals.normalizeColor)(input);
+  if (normalizedColor === null || typeof normalizedColor != "number") return input;
+  normalizedColor = normalizedColor || 0;
+  const r = (normalizedColor & 4278190080) >>> 24,
+    g = (normalizedColor & 16711680) >>> 16,
+    b = (normalizedColor & 65280) >>> 8,
+    a = (normalizedColor & 255) / 255;
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+const stringShapeRegex = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
+function createInterpolationFromStringOutputRange(config) {
+  let outputRange = config.outputRange;
+  (0, import_react_native_web_internals.invariant)(outputRange.length >= 2, "Bad output range"), outputRange = outputRange.map(colorToRgba), checkPattern(outputRange);
+  const outputRanges = outputRange[0].match(stringShapeRegex).map(() => []);
+  outputRange.forEach(value => {
+    value.match(stringShapeRegex).forEach((number, i) => {
+      outputRanges[i].push(+number);
+    });
+  });
+  const interpolations = outputRange[0].match(stringShapeRegex).map((value, i) => createInterpolation({
+      ...config,
+      outputRange: outputRanges[i]
+    })),
+    shouldRound = isRgbOrRgba(outputRange[0]);
+  return input => {
+    let i = 0;
+    return outputRange[0].replace(stringShapeRegex, () => {
+      let val = +interpolations[i++](input);
+      return shouldRound && (val = i < 4 ? Math.round(val) : Math.round(val * 1e3) / 1e3), String(val);
+    });
+  };
+}
+function isRgbOrRgba(range) {
+  return typeof range == "string" && range.startsWith("rgb");
+}
+function checkPattern(arr) {
+  const pattern = arr[0].replace(stringShapeRegex, "");
+  for (let i = 1; i < arr.length; ++i) (0, import_react_native_web_internals.invariant)(pattern === arr[i].replace(stringShapeRegex, ""), "invalid pattern " + arr[0] + " and " + arr[i]);
+}
+function findRange(input, inputRange) {
+  let i;
+  for (i = 1; i < inputRange.length - 1 && !(inputRange[i] >= input); ++i);
+  return i - 1;
+}
+function checkValidInputRange(arr) {
+  (0, import_react_native_web_internals.invariant)(arr.length >= 2, "inputRange must have at least 2 elements");
+  const message = "inputRange must be monotonically non-decreasing " + String(arr);
+  for (let i = 1; i < arr.length; ++i) (0, import_react_native_web_internals.invariant)(arr[i] >= arr[i - 1], message);
+}
+function checkInfiniteRange(name, arr) {
+  (0, import_react_native_web_internals.invariant)(arr.length >= 2, name + " must have at least 2 elements"), (0, import_react_native_web_internals.invariant)(arr.length !== 2 || arr[0] !== -1 / 0 || arr[1] !== 1 / 0, name + "cannot be ]-infinity;+infinity[ " + arr);
+}
+class AnimatedInterpolation extends import_AnimatedWithChildren.AnimatedWithChildren {
+  // Export for testing.
+  static __createInterpolation = createInterpolation;
+  constructor(parent, config) {
+    super(), this._parent = parent, this._config = config, this._interpolation = createInterpolation(config);
+  }
+  __makeNative(platformConfig) {
+    this._parent.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    const parentValue = this._parent.__getValue();
+    return (0, import_react_native_web_internals.invariant)(typeof parentValue == "number", "Cannot interpolate an input which is not a number."), this._interpolation(parentValue);
+  }
+  interpolate(config) {
+    return new AnimatedInterpolation(this, config);
+  }
+  __attach() {
+    this._parent.__addChild(this);
+  }
+  __detach() {
+    this._parent.__removeChild(this), super.__detach();
+  }
+  __transformDataType(range) {
+    return range.map(import_NativeAnimatedHelper.NativeAnimatedHelper.transformDataType);
+  }
+  __getNativeConfig() {
+    return __DEV__ && import_NativeAnimatedHelper.NativeAnimatedHelper.validateInterpolation(this._config), {
+      inputRange: this._config.inputRange,
+      // Only the `outputRange` can contain strings so we don't need to transform `inputRange` here
+      outputRange: this.__transformDataType(this._config.outputRange),
+      extrapolateLeft: this._config.extrapolateLeft || this._config.extrapolate || "extend",
+      extrapolateRight: this._config.extrapolateRight || this._config.extrapolate || "extend",
+      type: "interpolation"
+    };
+  }
+}
+var AnimatedInterpolation_default = AnimatedInterpolation;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedModulo.cjs

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AnimatedModulo_exports = {};
+__export(AnimatedModulo_exports, {
+  AnimatedModulo: () => AnimatedModulo,
+  default: () => AnimatedModulo_default
+});
+module.exports = __toCommonJS(AnimatedModulo_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+class AnimatedModulo extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _a;
+  _modulus;
+  constructor(a, modulus) {
+    super(), this._a = a, this._modulus = modulus;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.AnimatedInterpolation(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "modulus",
+      input: this._a.__getNativeTag(),
+      modulus: this._modulus
+    };
+  }
+}
+var AnimatedModulo_default = AnimatedModulo;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedMultiplication.cjs

@@ -0,0 +1,60 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AnimatedMultiplication_exports = {};
+__export(AnimatedMultiplication_exports, {
+  AnimatedMultiplication: () => AnimatedMultiplication,
+  default: () => AnimatedMultiplication_default
+});
+module.exports = __toCommonJS(AnimatedMultiplication_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs"),
+  import_AnimatedValue = require("./AnimatedValue.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+class AnimatedMultiplication extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _a;
+  _b;
+  constructor(a, b) {
+    super(), this._a = typeof a == "number" ? new import_AnimatedValue.AnimatedValue(a) : a, this._b = typeof b == "number" ? new import_AnimatedValue.AnimatedValue(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), this._b.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return this._a.__getValue() * this._b.__getValue();
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.AnimatedInterpolation(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this), this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), this._b.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "multiplication",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var AnimatedMultiplication_default = AnimatedMultiplication;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedNode.cjs

@@ -0,0 +1,131 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AnimatedNode_exports = {};
+__export(AnimatedNode_exports, {
+  AnimatedNode: () => AnimatedNode,
+  default: () => AnimatedNode_default
+});
+module.exports = __toCommonJS(AnimatedNode_exports);
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+const NativeAnimatedAPI = import_NativeAnimatedHelper.NativeAnimatedHelper.API;
+let _uniqueId = 1;
+class AnimatedNode {
+  _listeners;
+  _platformConfig;
+  __nativeAnimatedValueListener;
+  __attach() {}
+  __detach() {
+    this.__isNative && this.__nativeTag != null && (import_NativeAnimatedHelper.NativeAnimatedHelper.API.dropAnimatedNode(this.__nativeTag), this.__nativeTag = void 0);
+  }
+  __getValue() {}
+  __getAnimatedValue() {
+    return this.__getValue();
+  }
+  __addChild(child) {}
+  __removeChild(child) {}
+  __getChildren() {
+    return [];
+  }
+  /* Methods and props used by native Animated impl */
+  __isNative;
+  __nativeTag;
+  __shouldUpdateListenersForNewNativeTag;
+  constructor() {
+    this._listeners = {};
+  }
+  __makeNative(platformConfig) {
+    if (!this.__isNative) throw new Error('This node cannot be made a "native" animated node');
+    this._platformConfig = platformConfig, this.hasListeners() && this._startListeningToNativeValueUpdates();
+  }
+  /**
+   * Adds an asynchronous listener to the value so you can observe updates from
+   * animations.  This is useful because there is no way to
+   * synchronously read the value because it might be driven natively.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#addlistener
+   */
+  addListener(callback) {
+    const id = String(_uniqueId++);
+    return this._listeners[id] = callback, this.__isNative && this._startListeningToNativeValueUpdates(), id;
+  }
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#removelistener
+   */
+  removeListener(id) {
+    delete this._listeners[id], this.__isNative && !this.hasListeners() && this._stopListeningForNativeValueUpdates();
+  }
+  /**
+   * Remove all registered listeners.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#removealllisteners
+   */
+  removeAllListeners() {
+    this._listeners = {}, this.__isNative && this._stopListeningForNativeValueUpdates();
+  }
+  hasListeners() {
+    return !!Object.keys(this._listeners).length;
+  }
+  _startListeningToNativeValueUpdates() {
+    this.__nativeAnimatedValueListener && !this.__shouldUpdateListenersForNewNativeTag || (this.__shouldUpdateListenersForNewNativeTag && (this.__shouldUpdateListenersForNewNativeTag = !1, this._stopListeningForNativeValueUpdates()), NativeAnimatedAPI.startListeningToAnimatedNodeValue(this.__getNativeTag()), this.__nativeAnimatedValueListener = import_NativeAnimatedHelper.NativeAnimatedHelper.nativeEventEmitter.addListener("onAnimatedValueUpdate", data => {
+      data.tag === this.__getNativeTag() && this.__onAnimatedValueUpdateReceived(data.value);
+    }));
+  }
+  __onAnimatedValueUpdateReceived(value) {
+    this.__callListeners(value);
+  }
+  __callListeners(value) {
+    for (const key in this._listeners) this._listeners[key]({
+      value
+    });
+  }
+  _stopListeningForNativeValueUpdates() {
+    this.__nativeAnimatedValueListener && (this.__nativeAnimatedValueListener.remove(), this.__nativeAnimatedValueListener = null, NativeAnimatedAPI.stopListeningToAnimatedNodeValue(this.__getNativeTag()));
+  }
+  __getNativeTag() {
+    import_NativeAnimatedHelper.NativeAnimatedHelper.assertNativeAnimatedModule(), (0, import_react_native_web_internals.invariant)(this.__isNative, 'Attempt to get native tag from node not marked as "native"');
+    const nativeTag = this.__nativeTag ?? import_NativeAnimatedHelper.NativeAnimatedHelper.generateNewNodeTag();
+    if (this.__nativeTag == null) {
+      this.__nativeTag = nativeTag;
+      const config = this.__getNativeConfig();
+      this._platformConfig && (config.platformConfig = this._platformConfig), import_NativeAnimatedHelper.NativeAnimatedHelper.API.createAnimatedNode(nativeTag, config), this.__shouldUpdateListenersForNewNativeTag = !0;
+    }
+    return nativeTag;
+  }
+  __getNativeConfig() {
+    throw new Error("This JS animated node type cannot be used as native animated node");
+  }
+  toJSON() {
+    return this.__getValue();
+  }
+  __getPlatformConfig() {
+    return this._platformConfig;
+  }
+  __setPlatformConfig(platformConfig) {
+    this._platformConfig = platformConfig;
+  }
+}
+var AnimatedNode_default = AnimatedNode;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedProps.cjs

@@ -0,0 +1,110 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var AnimatedProps_exports = {};
+__export(AnimatedProps_exports, {
+  AnimatedProps: () => AnimatedProps,
+  default: () => AnimatedProps_default
+});
+module.exports = __toCommonJS(AnimatedProps_exports);
+var import_AnimatedEvent = require("../AnimatedEvent.cjs"),
+  import_AnimatedNode = require("./AnimatedNode.cjs"),
+  import_AnimatedStyle = require("./AnimatedStyle.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+class AnimatedProps extends import_AnimatedNode.AnimatedNode {
+  constructor(props, callback) {
+    super(), props.style && (props = {
+      ...props,
+      style: new import_AnimatedStyle.AnimatedStyle(props.style)
+    }), this._props = props, this._callback = callback, this.__attach();
+  }
+  __getValue() {
+    const props = {};
+    for (const key in this._props) {
+      const value = this._props[key];
+      value instanceof import_AnimatedNode.AnimatedNode ? (!value.__isNative || value instanceof import_AnimatedStyle.AnimatedStyle) && (props[key] = value.__getValue()) : value instanceof import_AnimatedEvent.AnimatedEvent ? props[key] = value.__getHandler() : props[key] = value;
+    }
+    return props;
+  }
+  __getAnimatedValue() {
+    const props = {};
+    for (const key in this._props) {
+      const value = this._props[key];
+      value instanceof import_AnimatedNode.AnimatedNode && (props[key] = value.__getAnimatedValue());
+    }
+    return props;
+  }
+  __attach() {
+    for (const key in this._props) {
+      const value = this._props[key];
+      value instanceof import_AnimatedNode.AnimatedNode && value.__addChild(this);
+    }
+  }
+  __detach() {
+    this.__isNative && this._animatedView && this.__disconnectAnimatedView();
+    for (const key in this._props) {
+      const value = this._props[key];
+      value instanceof import_AnimatedNode.AnimatedNode && value.__removeChild(this);
+    }
+    super.__detach();
+  }
+  update() {
+    this._callback();
+  }
+  __makeNative() {
+    if (!this.__isNative) {
+      this.__isNative = !0;
+      for (const key in this._props) {
+        const value = this._props[key];
+        value instanceof import_AnimatedNode.AnimatedNode && value.__makeNative();
+      }
+      this._animatedView && this.__connectAnimatedView();
+    }
+  }
+  setNativeView(animatedView) {
+    this._animatedView !== animatedView && (this._animatedView = animatedView, this.__isNative && this.__connectAnimatedView());
+  }
+  __connectAnimatedView() {
+    (0, import_react_native_web_internals.invariant)(this.__isNative, 'Expected node to be marked as "native"');
+    const nativeViewTag = this._animatedView;
+    (0, import_react_native_web_internals.invariant)(nativeViewTag != null, "Unable to locate attached view in the native tree"), import_NativeAnimatedHelper.NativeAnimatedHelper.API.connectAnimatedNodeToView(this.__getNativeTag(), nativeViewTag);
+  }
+  __disconnectAnimatedView() {
+    (0, import_react_native_web_internals.invariant)(this.__isNative, 'Expected node to be marked as "native"');
+    const nativeViewTag = this._animatedView;
+    (0, import_react_native_web_internals.invariant)(nativeViewTag != null, "Unable to locate attached view in the native tree"), import_NativeAnimatedHelper.NativeAnimatedHelper.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), nativeViewTag);
+  }
+  __restoreDefaultValues() {
+    this.__isNative && import_NativeAnimatedHelper.NativeAnimatedHelper.API.restoreDefaultValues(this.__getNativeTag());
+  }
+  __getNativeConfig() {
+    const propsConfig = {};
+    for (const propKey in this._props) {
+      const value = this._props[propKey];
+      value instanceof import_AnimatedNode.AnimatedNode && (value.__makeNative(), propsConfig[propKey] = value.__getNativeTag());
+    }
+    return {
+      type: "props",
+      props: propsConfig
+    };
+  }
+}
+var AnimatedProps_default = AnimatedProps;