@hanzogui/react-native-web-lite 2.0.0

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

@@ -0,0 +1,104 @@
+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 AnimatedStyle_exports = {};
+__export(AnimatedStyle_exports, {
+  AnimatedStyle: () => AnimatedStyle,
+  default: () => AnimatedStyle_default
+});
+module.exports = __toCommonJS(AnimatedStyle_exports);
+var import_AnimatedNode = require("./AnimatedNode.cjs"),
+  import_AnimatedTransform = require("./AnimatedTransform.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+const flattenStyle = import_react_native_web_internals.StyleSheet.flatten;
+function createAnimatedStyle(inputStyle) {
+  const style = flattenStyle(inputStyle),
+    animatedStyles = {};
+  for (const key in style) {
+    const value = style[key];
+    key === "transform" && Array.isArray(value) ? animatedStyles[key] = new import_AnimatedTransform.AnimatedTransform(value) : value instanceof import_AnimatedNode.AnimatedNode ? animatedStyles[key] = value : value && !Array.isArray(value) && typeof value == "object" && (animatedStyles[key] = createAnimatedStyle(value));
+  }
+  return animatedStyles;
+}
+class AnimatedStyle extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _inputStyle;
+  _style;
+  constructor(style) {
+    super(), this._inputStyle = style, this._style = createAnimatedStyle(style);
+  }
+  // Recursively get values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetValues(style) {
+    const updatedStyle = {};
+    for (const key in style) {
+      const value = style[key];
+      value instanceof import_AnimatedNode.AnimatedNode ? value.__isNative || (updatedStyle[key] = value.__getValue()) : value && !Array.isArray(value) && typeof value == "object" ? updatedStyle[key] = this._walkStyleAndGetValues(value) : updatedStyle[key] = value;
+    }
+    return updatedStyle;
+  }
+  __getValue() {
+    return [this._inputStyle, this._walkStyleAndGetValues(this._style)];
+  }
+  // Recursively get animated values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetAnimatedValues(style) {
+    const updatedStyle = {};
+    for (const key in style) {
+      const value = style[key];
+      value instanceof import_AnimatedNode.AnimatedNode ? updatedStyle[key] = value.__getAnimatedValue() : value && !Array.isArray(value) && typeof value == "object" && (updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value));
+    }
+    return updatedStyle;
+  }
+  __getAnimatedValue() {
+    return this._walkStyleAndGetAnimatedValues(this._style);
+  }
+  __attach() {
+    for (const key in this._style) {
+      const value = this._style[key];
+      value instanceof import_AnimatedNode.AnimatedNode && value.__addChild(this);
+    }
+  }
+  __detach() {
+    for (const key in this._style) {
+      const value = this._style[key];
+      value instanceof import_AnimatedNode.AnimatedNode && value.__removeChild(this);
+    }
+    super.__detach();
+  }
+  __makeNative() {
+    for (const key in this._style) {
+      const value = this._style[key];
+      value instanceof import_AnimatedNode.AnimatedNode && value.__makeNative();
+    }
+    super.__makeNative();
+  }
+  __getNativeConfig() {
+    const styleConfig = {};
+    for (const styleKey in this._style) if (this._style[styleKey] instanceof import_AnimatedNode.AnimatedNode) {
+      const style = this._style[styleKey];
+      style.__makeNative(), styleConfig[styleKey] = style.__getNativeTag();
+    }
+    return import_NativeAnimatedHelper.NativeAnimatedHelper.validateStyles(styleConfig), {
+      type: "style",
+      style: styleConfig
+    };
+  }
+}
+var AnimatedStyle_default = AnimatedStyle;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedSubtraction.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 AnimatedSubtraction_exports = {};
+__export(AnimatedSubtraction_exports, {
+  AnimatedSubtraction: () => AnimatedSubtraction,
+  default: () => AnimatedSubtraction_default
+});
+module.exports = __toCommonJS(AnimatedSubtraction_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs"),
+  import_AnimatedValue = require("./AnimatedValue.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+class AnimatedSubtraction 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: "subtraction",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var AnimatedSubtraction_default = AnimatedSubtraction;

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

@@ -0,0 +1,73 @@
+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 AnimatedTracking_exports = {};
+__export(AnimatedTracking_exports, {
+  AnimatedTracking: () => AnimatedTracking,
+  default: () => AnimatedTracking_default
+});
+module.exports = __toCommonJS(AnimatedTracking_exports);
+var import_AnimatedValue = require("./AnimatedValue.cjs"),
+  import_AnimatedNode = require("./AnimatedNode.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class AnimatedTracking extends import_AnimatedNode.AnimatedNode {
+  _value;
+  _parent;
+  _callback;
+  _animationConfig;
+  _animationClass;
+  _useNativeDriver;
+  constructor(value, parent, animationClass, animationConfig, callback) {
+    super(), this._value = value, this._parent = parent, this._animationClass = animationClass, this._animationConfig = animationConfig, this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(animationConfig), this._callback = callback, this.__attach();
+  }
+  __makeNative() {
+    this.__isNative = !0, this._parent.__makeNative(), super.__makeNative(), this._value.__makeNative();
+  }
+  __getValue() {
+    return this._parent.__getValue();
+  }
+  __attach() {
+    this._parent.__addChild(this), this._useNativeDriver && this.__makeNative();
+  }
+  __detach() {
+    this._parent.__removeChild(this), super.__detach();
+  }
+  update() {
+    this._value.animate(new this._animationClass({
+      ...this._animationConfig,
+      toValue: this._animationConfig.toValue.__getValue()
+    }), this._callback);
+  }
+  __getNativeConfig() {
+    const animationConfig = new this._animationClass({
+      ...this._animationConfig,
+      // remove toValue from the config as it's a ref to Animated.Value
+      toValue: void 0
+    }).__getNativeAnimationConfig();
+    return {
+      type: "tracking",
+      animationId: (0, import_NativeAnimatedHelper.generateNewAnimationId)(),
+      animationConfig,
+      toValue: this._parent.__getNativeTag(),
+      value: this._value.__getNativeTag()
+    };
+  }
+}
+var AnimatedTracking_default = AnimatedTracking;

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

@@ -0,0 +1,102 @@
+"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 AnimatedTransform_exports = {};
+__export(AnimatedTransform_exports, {
+  AnimatedTransform: () => AnimatedTransform,
+  default: () => AnimatedTransform_default
+});
+module.exports = __toCommonJS(AnimatedTransform_exports);
+var import_AnimatedNode = require("./AnimatedNode.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class AnimatedTransform extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _transforms;
+  constructor(transforms) {
+    super(), this._transforms = transforms;
+  }
+  __makeNative() {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        value instanceof import_AnimatedNode.AnimatedNode && value.__makeNative();
+      }
+    }), super.__makeNative();
+  }
+  __getValue() {
+    return this._transforms.map(transform => {
+      const result = {};
+      for (const key in transform) {
+        const value = transform[key];
+        value instanceof import_AnimatedNode.AnimatedNode ? result[key] = value.__getValue() : result[key] = value;
+      }
+      return result;
+    });
+  }
+  __getAnimatedValue() {
+    return this._transforms.map(transform => {
+      const result = {};
+      for (const key in transform) {
+        const value = transform[key];
+        value instanceof import_AnimatedNode.AnimatedNode ? result[key] = value.__getAnimatedValue() : result[key] = value;
+      }
+      return result;
+    });
+  }
+  __attach() {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        value instanceof import_AnimatedNode.AnimatedNode && value.__addChild(this);
+      }
+    });
+  }
+  __detach() {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        value instanceof import_AnimatedNode.AnimatedNode && value.__removeChild(this);
+      }
+    }), super.__detach();
+  }
+  __getNativeConfig() {
+    const transConfigs = [];
+    return this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        value instanceof import_AnimatedNode.AnimatedNode ? transConfigs.push({
+          type: "animated",
+          property: key,
+          nodeTag: value.__getNativeTag()
+        }) : transConfigs.push({
+          type: "static",
+          property: key,
+          value: import_NativeAnimatedHelper.NativeAnimatedHelper.transformDataType(value)
+        });
+      }
+    }), import_NativeAnimatedHelper.NativeAnimatedHelper.validateTransform(transConfigs), {
+      type: "transform",
+      transforms: transConfigs
+    };
+  }
+}
+var AnimatedTransform_default = AnimatedTransform;

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

@@ -0,0 +1,170 @@
+"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 AnimatedValue_exports = {};
+__export(AnimatedValue_exports, {
+  AnimatedValue: () => AnimatedValue,
+  default: () => AnimatedValue_default
+});
+module.exports = __toCommonJS(AnimatedValue_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+const NativeAnimatedAPI = import_NativeAnimatedHelper.NativeAnimatedHelper.API;
+function _flush(rootNode) {
+  const animatedStyles = /* @__PURE__ */new Set();
+  function findAnimatedStyles(node) {
+    typeof node.update == "function" ? animatedStyles.add(node) : node.__getChildren().forEach(findAnimatedStyles);
+  }
+  findAnimatedStyles(rootNode), animatedStyles.forEach(animatedStyle => animatedStyle.update());
+}
+function _executeAsAnimatedBatch(id, operation) {
+  NativeAnimatedAPI.setWaitingForIdentifier(id), operation(), NativeAnimatedAPI.unsetWaitingForIdentifier(id);
+}
+class AnimatedValue extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _value;
+  _startingValue;
+  _offset;
+  _animation;
+  _tracking;
+  constructor(value, config) {
+    if (super(), typeof value != "number") throw new Error("AnimatedValue: Attempting to set value to undefined");
+    this._startingValue = this._value = value, this._offset = 0, this._animation = null, config && config.useNativeDriver && this.__makeNative();
+  }
+  __detach() {
+    this.__isNative && NativeAnimatedAPI.getValue(this.__getNativeTag(), value => {
+      this._value = value - this._offset;
+    }), this.stopAnimation(), super.__detach();
+  }
+  __getValue() {
+    return this._value + this._offset;
+  }
+  /**
+   * Directly set the value.  This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setvalue
+   */
+  setValue(value) {
+    this._animation && (this._animation.stop(), this._animation = null), this._updateValue(value, !this.__isNative
+    /* don't perform a flush for natively driven values */), this.__isNative && _executeAsAnimatedBatch(this.__getNativeTag().toString(), () => NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value));
+  }
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether via
+   * `setValue`, an animation, or `Animated.event`.  Useful for compensating
+   * things like the start of a pan gesture.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setoffset
+   */
+  setOffset(offset) {
+    this._offset = offset, this.__isNative && NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
+  }
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#flattenoffset
+   */
+  flattenOffset() {
+    this._value += this._offset, this._offset = 0, this.__isNative && NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
+  }
+  /**
+   * Sets the offset value to the base value, and resets the base value to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#extractoffset
+   */
+  extractOffset() {
+    this._offset += this._value, this._value = 0, this.__isNative && NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
+  }
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#stopanimation
+   */
+  stopAnimation(callback) {
+    this.stopTracking(), this._animation && this._animation.stop(), this._animation = null, callback && (this.__isNative ? NativeAnimatedAPI.getValue(this.__getNativeTag(), callback) : callback(this.__getValue()));
+  }
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#resetanimation
+   */
+  resetAnimation(callback) {
+    this.stopAnimation(callback), this._value = this._startingValue, this.__isNative && NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), this._startingValue);
+  }
+  __onAnimatedValueUpdateReceived(value) {
+    this._updateValue(value, !1
+    /*flush*/);
+  }
+  /**
+   * Interpolates the value before updating the property, e.g. mapping 0-1 to
+   * 0-10.
+   */
+  interpolate(config) {
+    return new import_AnimatedInterpolation.AnimatedInterpolation(this, config);
+  }
+  /**
+   * Typically only used internally, but could be used by a custom Animation
+   * class.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#animate
+   */
+  animate(animation, callback) {
+    let handle = null;
+    animation.__isInteraction && (handle = import_react_native_web_internals.InteractionManager.createInteractionHandle());
+    const previousAnimation = this._animation;
+    this._animation && this._animation.stop(), this._animation = animation, animation.start(this._value, value => {
+      this._updateValue(value, !0
+      /* flush */);
+    }, result => {
+      this._animation = null, handle !== null && import_react_native_web_internals.InteractionManager.clearInteractionHandle(handle), callback && callback(result);
+    }, previousAnimation, this);
+  }
+  /**
+   * Typically only used internally.
+   */
+  stopTracking() {
+    this._tracking && this._tracking.__detach(), this._tracking = null;
+  }
+  /**
+   * Typically only used internally.
+   */
+  track(tracking) {
+    this.stopTracking(), this._tracking = tracking, this._tracking && this._tracking.update();
+  }
+  _updateValue(value, flush) {
+    if (value === void 0) throw new Error("AnimatedValue: Attempting to set value to undefined");
+    this._value = value, flush && _flush(this), super.__callListeners(this.__getValue());
+  }
+  __getNativeConfig() {
+    return {
+      type: "value",
+      value: this._value,
+      offset: this._offset
+    };
+  }
+}
+var AnimatedValue_default = AnimatedValue;

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

@@ -0,0 +1,96 @@
+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 AnimatedValueXY_exports = {};
+__export(AnimatedValueXY_exports, {
+  AnimatedValueXY: () => AnimatedValueXY,
+  default: () => AnimatedValueXY_default
+});
+module.exports = __toCommonJS(AnimatedValueXY_exports);
+var import_AnimatedValue = require("./AnimatedValue.cjs"),
+  import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+let _uniqueId = 1;
+class AnimatedValueXY extends import_AnimatedWithChildren.AnimatedWithChildren {
+  constructor(valueIn) {
+    super();
+    const value = valueIn || {
+      x: 0,
+      y: 0
+    };
+    typeof value.x == "number" && typeof value.y == "number" ? (this.x = new import_AnimatedValue.AnimatedValue(value.x), this.y = new import_AnimatedValue.AnimatedValue(value.y)) : ((0, import_react_native_web_internals.invariant)(value.x instanceof import_AnimatedValue.AnimatedValue && value.y instanceof import_AnimatedValue.AnimatedValue, "AnimatedValueXY must be initialized with an object of numbers or AnimatedValues."), this.x = value.x, this.y = value.y), this._listeners = {};
+  }
+  setValue(value) {
+    this.x.setValue(value.x), this.y.setValue(value.y);
+  }
+  setOffset(offset) {
+    this.x.setOffset(offset.x), this.y.setOffset(offset.y);
+  }
+  flattenOffset() {
+    this.x.flattenOffset(), this.y.flattenOffset();
+  }
+  extractOffset() {
+    this.x.extractOffset(), this.y.extractOffset();
+  }
+  __getValue() {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue()
+    };
+  }
+  resetAnimation(callback) {
+    this.x.resetAnimation(), this.y.resetAnimation(), callback && callback(this.__getValue());
+  }
+  stopAnimation(callback) {
+    this.x.stopAnimation(), this.y.stopAnimation(), callback && callback(this.__getValue());
+  }
+  addListener(callback) {
+    const id = String(_uniqueId++),
+      jointCallback = ({
+        value
+      }) => {
+        callback(this.__getValue());
+      };
+    return this._listeners[id] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback)
+    }, id;
+  }
+  removeListener(id) {
+    this.x.removeListener(this._listeners[id].x), this.y.removeListener(this._listeners[id].y), delete this._listeners[id];
+  }
+  removeAllListeners() {
+    this.x.removeAllListeners(), this.y.removeAllListeners(), this._listeners = {};
+  }
+  getLayout() {
+    return {
+      left: this.x,
+      top: this.y
+    };
+  }
+  getTranslateTransform() {
+    return [{
+      translateX: this.x
+    }, {
+      translateY: this.y
+    }];
+  }
+}
+var AnimatedValueXY_default = AnimatedValueXY;

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

@@ -0,0 +1,61 @@
+"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 AnimatedWithChildren_exports = {};
+__export(AnimatedWithChildren_exports, {
+  AnimatedWithChildren: () => AnimatedWithChildren,
+  default: () => AnimatedWithChildren_default
+});
+module.exports = __toCommonJS(AnimatedWithChildren_exports);
+var import_AnimatedNode = require("./AnimatedNode.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class AnimatedWithChildren extends import_AnimatedNode.AnimatedNode {
+  _children;
+  constructor() {
+    super(), this._children = [];
+  }
+  __makeNative(platformConfig) {
+    if (!this.__isNative) {
+      this.__isNative = !0;
+      for (const child of this._children) child.__makeNative(platformConfig), import_NativeAnimatedHelper.NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+    }
+    super.__makeNative(platformConfig);
+  }
+  __addChild(child) {
+    this._children.length === 0 && this.__attach(), this._children.push(child), this.__isNative && (child.__makeNative(this.__getPlatformConfig()), import_NativeAnimatedHelper.NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag()));
+  }
+  __removeChild(child) {
+    const index = this._children.indexOf(child);
+    if (index === -1) {
+      console.warn("Trying to remove a child that doesn't exist");
+      return;
+    }
+    this.__isNative && child.__isNative && import_NativeAnimatedHelper.NativeAnimatedHelper.API.disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag()), this._children.splice(index, 1), this._children.length === 0 && this.__detach();
+  }
+  __getChildren() {
+    return this._children;
+  }
+  __callListeners(value) {
+    if (super.__callListeners(value), !this.__isNative) for (const child of this._children) child.__getValue && child.__callListeners(child.__getValue());
+  }
+}
+var AnimatedWithChildren_default = AnimatedWithChildren;