yeet

node_modules/react-native-reanimated/lib/commonjs/derived/__mocks__/evaluateOnce.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluateOnce = evaluateOnce;
+
+var _base = require("../../base");
+
+function evaluateOnce(node, children = [], callback) {
+  if (!Array.isArray(children)) {
+    children = [children];
+  }
+
+  const alwaysNode = (0, _base.always)(node);
+
+  for (let i = 0; i < children.length; i++) {
+    alwaysNode.__addChild(children[i]);
+  }
+
+  for (let i = 0; i < children.length; i++) {
+    alwaysNode.__removeChild(children[i]);
+  }
+
+  callback && callback();
+}
+//# sourceMappingURL=evaluateOnce.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/__mocks__/evaluateOnce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["evaluateOnce.js"],"names":["evaluateOnce","node","children","callback","Array","isArray","alwaysNode","i","length","__addChild","__removeChild"],"mappings":";;;;;;;AAAA;;AACO,SAASA,YAAT,CAAsBC,IAAtB,EAA4BC,QAAQ,GAAG,EAAvC,EAA2CC,QAA3C,EAAqD;AAC1D,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcH,QAAd,CAAL,EAA8B;AAC5BA,IAAAA,QAAQ,GAAG,CAACA,QAAD,CAAX;AACD;;AACD,QAAMI,UAAU,GAAG,kBAAOL,IAAP,CAAnB;;AACA,OAAK,IAAIM,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGL,QAAQ,CAACM,MAA7B,EAAqCD,CAAC,EAAtC,EAA0C;AACxCD,IAAAA,UAAU,CAACG,UAAX,CAAsBP,QAAQ,CAACK,CAAD,CAA9B;AACD;;AACD,OAAK,IAAIA,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGL,QAAQ,CAACM,MAA7B,EAAqCD,CAAC,EAAtC,EAA0C;AACxCD,IAAAA,UAAU,CAACI,aAAX,CAAyBR,QAAQ,CAACK,CAAD,CAAjC;AACD;;AACDJ,EAAAA,QAAQ,IAAIA,QAAQ,EAApB;AACD","sourcesContent":["import { always } from '../../base';\nexport function evaluateOnce(node, children = [], callback) {\n  if (!Array.isArray(children)) {\n    children = [children];\n  }\n  const alwaysNode = always(node);\n  for (let i = 0; i < children.length; i++) {\n    alwaysNode.__addChild(children[i]);\n  }\n  for (let i = 0; i < children.length; i++) {\n    alwaysNode.__removeChild(children[i]);\n  }\n  callback && callback();\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/acc.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = acc;
+
+var _base = require("../base");
+
+var _InternalAnimatedValue = _interopRequireDefault(require("../core/InternalAnimatedValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const procAcc = (0, _base.proc)(function (v, acc) {
+  return (0, _base.set)(acc, (0, _base.add)(acc, v));
+});
+
+function acc(v) {
+  const acc = new _InternalAnimatedValue.default(0);
+  return procAcc(v, acc);
+}
+//# sourceMappingURL=acc.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/acc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["acc.js"],"names":["procAcc","v","acc","AnimatedValue"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEA,MAAMA,OAAO,GAAG,gBAAK,UAASC,CAAT,EAAYC,GAAZ,EAAiB;AACpC,SAAO,eAAIA,GAAJ,EAAS,eAAIA,GAAJ,EAASD,CAAT,CAAT,CAAP;AACD,CAFe,CAAhB;;AAIe,SAASC,GAAT,CAAaD,CAAb,EAAgB;AAC7B,QAAMC,GAAG,GAAG,IAAIC,8BAAJ,CAAkB,CAAlB,CAAZ;AACA,SAAOH,OAAO,CAACC,CAAD,EAAIC,GAAJ,CAAd;AACD","sourcesContent":["import { set, add, proc } from '../base';\nimport AnimatedValue from '../core/InternalAnimatedValue';\n\nconst procAcc = proc(function(v, acc) {\n  return set(acc, add(acc, v));\n});\n\nexport default function acc(v) {\n  const acc = new AnimatedValue(0);\n  return procAcc(v, acc);\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/color.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = color;
+
+var _reactNative = require("react-native");
+
+var _base = require("../base");
+
+var _AnimatedNode = _interopRequireDefault(require("../core/AnimatedNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const procColor = (0, _base.proc)(function (r, g, b, a) {
+  const color = (0, _base.add)((0, _base.multiply)(a, 1 << 24), (0, _base.multiply)((0, _base.round)(r), 1 << 16), (0, _base.multiply)((0, _base.round)(g), 1 << 8), (0, _base.round)(b));
+
+  if (_reactNative.Platform.OS === 'android') {
+    // on Android color is represented as signed 32 bit int
+    return (0, _base.cond)((0, _base.lessThan)(color, 1 << 31 >>> 0), color, (0, _base.sub)(color, Math.pow(2, 32)));
+  }
+
+  return color;
+});
+
+function color(r, g, b, a = 1) {
+  if (_reactNative.Platform.OS === 'web') {
+    // doesn't support bit shifting
+    return (0, _base.concat)('rgba(', r, ',', g, ',', b, ',', a, ')');
+  }
+
+  if (a instanceof _AnimatedNode.default) {
+    a = (0, _base.round)((0, _base.multiply)(a, 255));
+  } else {
+    a = Math.round(a * 255);
+  }
+
+  return procColor(r, g, b, a);
+}
+//# sourceMappingURL=color.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/color.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["color.js"],"names":["procColor","r","g","b","a","color","Platform","OS","Math","pow","AnimatedNode","round"],"mappings":";;;;;;;AAAA;;AAEA;;AACA;;;;AAEA,MAAMA,SAAS,GAAG,gBAAK,UAASC,CAAT,EAAYC,CAAZ,EAAeC,CAAf,EAAkBC,CAAlB,EAAqB;AAC1C,QAAMC,KAAK,GAAG,eACZ,oBAASD,CAAT,EAAY,KAAK,EAAjB,CADY,EAEZ,oBAAS,iBAAMH,CAAN,CAAT,EAAmB,KAAK,EAAxB,CAFY,EAGZ,oBAAS,iBAAMC,CAAN,CAAT,EAAmB,KAAK,CAAxB,CAHY,EAIZ,iBAAMC,CAAN,CAJY,CAAd;;AAOA,MAAIG,sBAASC,EAAT,KAAgB,SAApB,EAA+B;AAC7B;AACA,WAAO,gBACL,oBAASF,KAAT,EAAiB,KAAK,EAAN,KAAc,CAA9B,CADK,EAELA,KAFK,EAGL,eAAIA,KAAJ,EAAWG,IAAI,CAACC,GAAL,CAAS,CAAT,EAAY,EAAZ,CAAX,CAHK,CAAP;AAKD;;AACD,SAAOJ,KAAP;AACD,CAjBiB,CAAlB;;AAmBe,SAASA,KAAT,CAAeJ,CAAf,EAAkBC,CAAlB,EAAqBC,CAArB,EAAwBC,CAAC,GAAG,CAA5B,EAA+B;AAC5C,MAAIE,sBAASC,EAAT,KAAgB,KAApB,EAA2B;AACzB;AACA,WAAO,kBAAO,OAAP,EAAgBN,CAAhB,EAAmB,GAAnB,EAAwBC,CAAxB,EAA2B,GAA3B,EAAgCC,CAAhC,EAAmC,GAAnC,EAAwCC,CAAxC,EAA2C,GAA3C,CAAP;AACD;;AAED,MAAIA,CAAC,YAAYM,qBAAjB,EAA+B;AAC7BN,IAAAA,CAAC,GAAG,iBAAM,oBAASA,CAAT,EAAY,GAAZ,CAAN,CAAJ;AACD,GAFD,MAEO;AACLA,IAAAA,CAAC,GAAGI,IAAI,CAACG,KAAL,CAAWP,CAAC,GAAG,GAAf,CAAJ;AACD;;AAED,SAAOJ,SAAS,CAACC,CAAD,EAAIC,CAAJ,EAAOC,CAAP,EAAUC,CAAV,CAAhB;AACD","sourcesContent":["import { Platform } from 'react-native';\n\nimport { add, cond, concat, lessThan, multiply, round, sub, proc } from '../base';\nimport AnimatedNode from '../core/AnimatedNode';\n\nconst procColor = proc(function(r, g, b, a) {\n  const color = add(\n    multiply(a, 1 << 24),\n    multiply(round(r), 1 << 16),\n    multiply(round(g), 1 << 8),\n    round(b)\n  );\n  \n  if (Platform.OS === 'android') {\n    // on Android color is represented as signed 32 bit int\n    return cond(\n      lessThan(color, (1 << 31) >>> 0),\n      color,\n      sub(color, Math.pow(2, 32))\n    );\n  }\n  return color;\n});\n\nexport default function color(r, g, b, a = 1) {\n  if (Platform.OS === 'web') {\n    // doesn't support bit shifting\n    return concat('rgba(', r, ',', g, ',', b, ',', a, ')');\n  }\n\n  if (a instanceof AnimatedNode) {\n    a = round(multiply(a, 255));\n  } else {\n    a = Math.round(a * 255);\n  }\n\n  return procColor(r, g, b, a);\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/diff.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = diff;
+
+var _base = require("../base");
+
+var _InternalAnimatedValue = _interopRequireDefault(require("../core/InternalAnimatedValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const procDiff = (0, _base.proc)(function (v, stash, prev) {
+  return (0, _base.block)([(0, _base.set)(stash, (0, _base.cond)((0, _base.defined)(prev), (0, _base.sub)(v, prev), 0)), (0, _base.set)(prev, v), stash]);
+});
+
+function diff(v) {
+  const stash = new _InternalAnimatedValue.default(0);
+  const prev = new _InternalAnimatedValue.default();
+  return procDiff(v, stash, prev);
+}
+//# sourceMappingURL=diff.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["diff.js"],"names":["procDiff","v","stash","prev","diff","AnimatedValue"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEA,MAAMA,QAAQ,GAAG,gBAAK,UAASC,CAAT,EAAYC,KAAZ,EAAmBC,IAAnB,EAAyB;AAC7C,SAAO,iBAAM,CACX,eAAID,KAAJ,EAAW,gBAAK,mBAAQC,IAAR,CAAL,EAAoB,eAAIF,CAAJ,EAAOE,IAAP,CAApB,EAAkC,CAAlC,CAAX,CADW,EAEX,eAAIA,IAAJ,EAAUF,CAAV,CAFW,EAGXC,KAHW,CAAN,CAAP;AAKD,CANgB,CAAjB;;AAQe,SAASE,IAAT,CAAcH,CAAd,EAAiB;AAC9B,QAAMC,KAAK,GAAG,IAAIG,8BAAJ,CAAkB,CAAlB,CAAd;AACA,QAAMF,IAAI,GAAG,IAAIE,8BAAJ,EAAb;AACA,SAAOL,QAAQ,CAACC,CAAD,EAAIC,KAAJ,EAAWC,IAAX,CAAf;AACD","sourcesContent":["import { cond, block, defined, sub, set, proc } from '../base';\nimport AnimatedValue from '../core/InternalAnimatedValue';\n\nconst procDiff = proc(function(v, stash, prev) {\n  return block([\n    set(stash, cond(defined(prev), sub(v, prev), 0)),\n    set(prev, v),\n    stash,\n  ]);\n});\n\nexport default function diff(v) {\n  const stash = new AnimatedValue(0);\n  const prev = new AnimatedValue();\n  return procDiff(v, stash, prev);\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/diffClamp.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = diffClamp;
+
+var _base = require("../base");
+
+var _InternalAnimatedValue = _interopRequireDefault(require("../core/InternalAnimatedValue"));
+
+var _diff = _interopRequireDefault(require("./diff"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function diffClamp(a, minVal, maxVal) {
+  const value = new _InternalAnimatedValue.default();
+  return (0, _base.set)(value, (0, _base.min)((0, _base.max)((0, _base.add)((0, _base.cond)((0, _base.defined)(value), value, a), (0, _diff.default)(a)), minVal), maxVal));
+}
+//# sourceMappingURL=diffClamp.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/diffClamp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["diffClamp.js"],"names":["diffClamp","a","minVal","maxVal","value","AnimatedValue"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;;;AAEe,SAASA,SAAT,CAAmBC,CAAnB,EAAsBC,MAAtB,EAA8BC,MAA9B,EAAsC;AACnD,QAAMC,KAAK,GAAG,IAAIC,8BAAJ,EAAd;AACA,SAAO,eACLD,KADK,EAEL,eAAI,eAAI,eAAI,gBAAK,mBAAQA,KAAR,CAAL,EAAqBA,KAArB,EAA4BH,CAA5B,CAAJ,EAAoC,mBAAKA,CAAL,CAApC,CAAJ,EAAkDC,MAAlD,CAAJ,EAA+DC,MAA/D,CAFK,CAAP;AAID","sourcesContent":["import { cond, defined, set, add, min, max } from '../base';\nimport AnimatedValue from '../core/InternalAnimatedValue';\nimport diff from './diff';\n\nexport default function diffClamp(a, minVal, maxVal) {\n  const value = new AnimatedValue();\n  return set(\n    value,\n    min(max(add(cond(defined(value), value, a), diff(a)), minVal), maxVal)\n  );\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/evaluateOnce.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.evaluateOnce = evaluateOnce;
+
+var _InternalAnimatedValue = _interopRequireDefault(require("../core/InternalAnimatedValue"));
+
+var _AnimatedSet = require("../core/AnimatedSet");
+
+var _AnimatedCall = require("../core/AnimatedCall");
+
+var _AnimatedAlways = require("../core/AnimatedAlways");
+
+var _AnimatedCond = require("../core/AnimatedCond");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * evaluate given node and notify children
+ * @param node - node to be evaluated
+ * @param input - nodes (or one node) representing values which states input for node.
+ * @param callback - after callback
+ */
+function evaluateOnce(node, input = [], callback) {
+  if (!Array.isArray(input)) {
+    input = [input];
+  }
+
+  const done = new _InternalAnimatedValue.default(0);
+  const evalNode = (0, _AnimatedCond.createAnimatedCond)(done, 0, (0, _AnimatedCall.createAnimatedCall)([node, (0, _AnimatedSet.createAnimatedSet)(done, 1)], () => {
+    callback && callback();
+
+    for (let i = 0; i < input.length; i++) {
+      input[i].__removeChild(alwaysNode);
+
+      alwaysNode.__detach();
+    }
+  }));
+  const alwaysNode = (0, _AnimatedAlways.createAnimatedAlways)(evalNode);
+
+  for (let i = 0; i < input.length; i++) {
+    input[i].__addChild(alwaysNode);
+
+    alwaysNode.__attach();
+  }
+}
+//# sourceMappingURL=evaluateOnce.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/evaluateOnce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["evaluateOnce.js"],"names":["evaluateOnce","node","input","callback","Array","isArray","done","AnimatedValue","evalNode","i","length","__removeChild","alwaysNode","__detach","__addChild","__attach"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;;;AAEA;;;;;;AAOO,SAASA,YAAT,CAAsBC,IAAtB,EAA4BC,KAAK,GAAG,EAApC,EAAwCC,QAAxC,EAAkD;AACvD,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcH,KAAd,CAAL,EAA2B;AACzBA,IAAAA,KAAK,GAAG,CAACA,KAAD,CAAR;AACD;;AACD,QAAMI,IAAI,GAAG,IAAIC,8BAAJ,CAAkB,CAAlB,CAAb;AACA,QAAMC,QAAQ,GAAG,sCACfF,IADe,EAEf,CAFe,EAGf,sCAAK,CAACL,IAAD,EAAO,oCAAIK,IAAJ,EAAU,CAAV,CAAP,CAAL,EAA2B,MAAM;AAC/BH,IAAAA,QAAQ,IAAIA,QAAQ,EAApB;;AACA,SAAK,IAAIM,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGP,KAAK,CAACQ,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;AACrCP,MAAAA,KAAK,CAACO,CAAD,CAAL,CAASE,aAAT,CAAuBC,UAAvB;;AACAA,MAAAA,UAAU,CAACC,QAAX;AACD;AACF,GAND,CAHe,CAAjB;AAWA,QAAMD,UAAU,GAAG,0CAAOJ,QAAP,CAAnB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGP,KAAK,CAACQ,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;AACrCP,IAAAA,KAAK,CAACO,CAAD,CAAL,CAASK,UAAT,CAAoBF,UAApB;;AACAA,IAAAA,UAAU,CAACG,QAAX;AACD;AACF","sourcesContent":["import AnimatedValue from '../core/InternalAnimatedValue';\nimport { createAnimatedSet as set } from '../core/AnimatedSet';\nimport { createAnimatedCall as call } from '../core/AnimatedCall';\nimport { createAnimatedAlways as always } from '../core/AnimatedAlways';\nimport { createAnimatedCond as cond } from '../core/AnimatedCond';\n\n/**\n * evaluate given node and notify children\n * @param node - node to be evaluated\n * @param input - nodes (or one node) representing values which states input for node.\n * @param callback - after callback\n */\n\nexport function evaluateOnce(node, input = [], callback) {\n  if (!Array.isArray(input)) {\n    input = [input];\n  }\n  const done = new AnimatedValue(0);\n  const evalNode = cond(\n    done,\n    0,\n    call([node, set(done, 1)], () => {\n      callback && callback();\n      for (let i = 0; i < input.length; i++) {\n        input[i].__removeChild(alwaysNode);\n        alwaysNode.__detach();\n      }\n    })\n  );\n  const alwaysNode = always(evalNode);\n  for (let i = 0; i < input.length; i++) {\n    input[i].__addChild(alwaysNode);\n    alwaysNode.__attach();\n  }\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "acc", {
+  enumerable: true,
+  get: function get() {
+    return _acc.default;
+  }
+});
+Object.defineProperty(exports, "color", {
+  enumerable: true,
+  get: function get() {
+    return _color.default;
+  }
+});
+Object.defineProperty(exports, "diff", {
+  enumerable: true,
+  get: function get() {
+    return _diff.default;
+  }
+});
+Object.defineProperty(exports, "diffClamp", {
+  enumerable: true,
+  get: function get() {
+    return _diffClamp.default;
+  }
+});
+Object.defineProperty(exports, "interpolate", {
+  enumerable: true,
+  get: function get() {
+    return _interpolate.default;
+  }
+});
+Object.defineProperty(exports, "Extrapolate", {
+  enumerable: true,
+  get: function get() {
+    return _interpolate.Extrapolate;
+  }
+});
+Object.defineProperty(exports, "interpolateColors", {
+  enumerable: true,
+  get: function get() {
+    return _interpolateColors.default;
+  }
+});
+Object.defineProperty(exports, "onChange", {
+  enumerable: true,
+  get: function get() {
+    return _onChange.default;
+  }
+});
+Object.defineProperty(exports, "useCode", {
+  enumerable: true,
+  get: function get() {
+    return _useCode.default;
+  }
+});
+
+var _acc = _interopRequireDefault(require("./acc"));
+
+var _color = _interopRequireDefault(require("./color"));
+
+var _diff = _interopRequireDefault(require("./diff"));
+
+var _diffClamp = _interopRequireDefault(require("./diffClamp"));
+
+var _interpolate = _interopRequireWildcard(require("./interpolate"));
+
+var _interpolateColors = _interopRequireDefault(require("./interpolateColors"));
+
+var _onChange = _interopRequireDefault(require("./onChange"));
+
+var _useCode = _interopRequireDefault(require("./useCode"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+//# sourceMappingURL=index.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA","sourcesContent":["export { default as acc } from './acc';\nexport { default as color } from './color';\nexport { default as diff } from './diff';\nexport { default as diffClamp } from './diffClamp';\nexport { default as interpolate, Extrapolate } from './interpolate';\nexport { default as interpolateColors } from './interpolateColors';\nexport { default as onChange } from './onChange';\nexport { default as useCode } from './useCode';\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/interpolate.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = interpolate;
+exports.Extrapolate = void 0;
+
+var _operators = require("../operators");
+
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+
+var _AnimatedNode = _interopRequireDefault(require("../core/AnimatedNode"));
+
+var _AnimatedCond = require("../core/AnimatedCond");
+
+var _AnimatedFunction = require("../core/AnimatedFunction");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const interpolateInternalSingleProc = (0, _AnimatedFunction.createAnimatedFunction)(function (value, inS, inE, outS, outE) {
+  const progress = (0, _operators.divide)((0, _operators.sub)(value, inS), (0, _operators.sub)(inE, inS)); // logic below was made in order to provide a compatibility witn an Animated API
+
+  const resultForNonZeroRange = (0, _operators.add)(outS, (0, _operators.multiply)(progress, (0, _operators.sub)(outE, outS)));
+  const result = (0, _AnimatedCond.createAnimatedCond)((0, _operators.eq)(inS, inE), (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessOrEq)(value, inS), outS, outE), resultForNonZeroRange);
+  return result;
+});
+
+function interpolateInternalSingle(value, inputRange, outputRange, offset) {
+  const inS = inputRange[offset];
+  const inE = inputRange[offset + 1];
+  const outS = outputRange[offset];
+  const outE = outputRange[offset + 1];
+  return interpolateInternalSingleProc(value, inS, inE, outS, outE);
+}
+
+function interpolateInternal(value, inputRange, outputRange, offset = 0) {
+  if (inputRange.length - offset === 2) {
+    return interpolateInternalSingle(value, inputRange, outputRange, offset);
+  }
+
+  return (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessThan)(value, inputRange[offset + 1]), interpolateInternalSingle(value, inputRange, outputRange, offset), interpolateInternal(value, inputRange, outputRange, offset + 1));
+}
+
+const Extrapolate = {
+  EXTEND: 'extend',
+  CLAMP: 'clamp',
+  IDENTITY: 'identity'
+};
+exports.Extrapolate = Extrapolate;
+
+function checkNonDecreasing(name, arr) {
+  for (let i = 1; i < arr.length; ++i) {
+    // We can't validate animated nodes in JS.
+    if (arr[i] instanceof _AnimatedNode.default || arr[i - 1] instanceof _AnimatedNode.default) continue;
+    (0, _invariant.default)(arr[i] >= arr[i - 1], '%s must be monotonically non-decreasing. (%s)', name, arr);
+  }
+}
+
+function checkMinElements(name, arr) {
+  (0, _invariant.default)(arr.length >= 2, '%s must have at least 2 elements. (%s)', name, arr);
+}
+
+function checkValidNumbers(name, arr) {
+  for (let i = 0; i < arr.length; i++) {
+    // We can't validate animated nodes in JS.
+    if (arr[i] instanceof _AnimatedNode.default || typeof arr[i] !== 'number') continue;
+    (0, _invariant.default)(Number.isFinite(arr[i]), '%s cannot include %s. (%s)', name, arr[i], arr);
+  }
+}
+
+function convertToRadians(outputRange) {
+  for (const [i, value] of outputRange.entries()) {
+    if (typeof value === 'string' && value.endsWith('deg')) {
+      outputRange[i] = parseFloat(value) * (Math.PI / 180);
+    } else if (typeof value === 'string' && value.endsWith('rad')) {
+      outputRange[i] = parseFloat(value);
+    }
+  }
+}
+
+function interpolate(value, config) {
+  const {
+    inputRange,
+    outputRange,
+    extrapolate = Extrapolate.EXTEND,
+    extrapolateLeft,
+    extrapolateRight
+  } = config;
+  checkMinElements('inputRange', inputRange);
+  checkValidNumbers('inputRange', inputRange);
+  checkMinElements('outputRange', outputRange);
+  checkValidNumbers('outputRange', outputRange);
+  checkNonDecreasing('inputRange', inputRange);
+  (0, _invariant.default)(inputRange.length === outputRange.length, 'inputRange and outputRange must be the same length.');
+  convertToRadians(outputRange);
+  const left = extrapolateLeft || extrapolate;
+  const right = extrapolateRight || extrapolate;
+  let output = interpolateInternal(value, inputRange, outputRange);
+
+  if (left === Extrapolate.EXTEND) {} else if (left === Extrapolate.CLAMP) {
+    output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessThan)(value, inputRange[0]), outputRange[0], output);
+  } else if (left === Extrapolate.IDENTITY) {
+    output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessThan)(value, inputRange[0]), value, output);
+  }
+
+  if (right === Extrapolate.EXTEND) {} else if (right === Extrapolate.CLAMP) {
+    output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.greaterThan)(value, inputRange[inputRange.length - 1]), outputRange[outputRange.length - 1], output);
+  } else if (right === Extrapolate.IDENTITY) {
+    output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.greaterThan)(value, inputRange[inputRange.length - 1]), value, output);
+  }
+
+  return output;
+}
+//# sourceMappingURL=interpolate.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/interpolateColors.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = interpolateColors;
+
+var _reactNative = require("react-native");
+
+var _base = require("../base");
+
+var _color = _interopRequireDefault(require("./color"));
+
+var _interpolate = _interopRequireWildcard(require("./interpolate"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function red(c) {
+  return c >> 16 & 255;
+}
+
+function green(c) {
+  return c >> 8 & 255;
+}
+
+function blue(c) {
+  return c & 255;
+}
+
+function opacity(c) {
+  return (c >> 24 & 255) / 255;
+}
+/**
+ * Use this if you want to interpolate an `Animated.Value` into color values.
+ *
+ * #### Why is this needed?
+ *
+ * Unfortunately, if you'll pass color values directly into the `outputRange` option
+ * of `interpolate()` function, that won't really work (at least at the moment).
+ * See https://github.com/software-mansion/react-native-reanimated/issues/181 .
+ *
+ * So, for now you can just use this helper instead.
+ */
+
+
+function interpolateColors(animationValue, options) {
+  const {
+    inputRange,
+    outputColorRange
+  } = options;
+  const colors = outputColorRange.map(_reactNative.processColor);
+  const r = (0, _base.round)((0, _interpolate.default)(animationValue, {
+    inputRange,
+    outputRange: colors.map(red),
+    extrapolate: _interpolate.Extrapolate.CLAMP
+  }));
+  const g = (0, _base.round)((0, _interpolate.default)(animationValue, {
+    inputRange,
+    outputRange: colors.map(green),
+    extrapolate: _interpolate.Extrapolate.CLAMP
+  }));
+  const b = (0, _base.round)((0, _interpolate.default)(animationValue, {
+    inputRange,
+    outputRange: colors.map(blue),
+    extrapolate: _interpolate.Extrapolate.CLAMP
+  }));
+  const a = (0, _interpolate.default)(animationValue, {
+    inputRange,
+    outputRange: colors.map(opacity),
+    extrapolate: _interpolate.Extrapolate.CLAMP
+  });
+  return (0, _color.default)(r, g, b, a);
+}
+//# sourceMappingURL=interpolateColors.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/interpolateColors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["interpolateColors.js"],"names":["red","c","green","blue","opacity","interpolateColors","animationValue","options","inputRange","outputColorRange","colors","map","processColor","r","outputRange","extrapolate","Extrapolate","CLAMP","g","b","a"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AACA;;;;;;;;AAEA,SAASA,GAAT,CAAaC,CAAb,EAAgB;AACd,SAAQA,CAAC,IAAI,EAAN,GAAY,GAAnB;AACD;;AACD,SAASC,KAAT,CAAeD,CAAf,EAAkB;AAChB,SAAQA,CAAC,IAAI,CAAN,GAAW,GAAlB;AACD;;AACD,SAASE,IAAT,CAAcF,CAAd,EAAiB;AACf,SAAOA,CAAC,GAAG,GAAX;AACD;;AACD,SAASG,OAAT,CAAiBH,CAAjB,EAAoB;AAClB,SAAO,CAAEA,CAAC,IAAI,EAAN,GAAY,GAAb,IAAoB,GAA3B;AACD;AAED;;;;;;;;;;;;;AAWe,SAASI,iBAAT,CAA2BC,cAA3B,EAA2CC,OAA3C,EAAoD;AACjE,QAAM;AAAEC,IAAAA,UAAF;AAAcC,IAAAA;AAAd,MAAmCF,OAAzC;AACA,QAAMG,MAAM,GAAGD,gBAAgB,CAACE,GAAjB,CAAqBC,yBAArB,CAAf;AAEA,QAAMC,CAAC,GAAG,iBACR,0BAAYP,cAAZ,EAA4B;AAC1BE,IAAAA,UAD0B;AAE1BM,IAAAA,WAAW,EAAEJ,MAAM,CAACC,GAAP,CAAWX,GAAX,CAFa;AAG1Be,IAAAA,WAAW,EAAEC,yBAAYC;AAHC,GAA5B,CADQ,CAAV;AAOA,QAAMC,CAAC,GAAG,iBACR,0BAAYZ,cAAZ,EAA4B;AAC1BE,IAAAA,UAD0B;AAE1BM,IAAAA,WAAW,EAAEJ,MAAM,CAACC,GAAP,CAAWT,KAAX,CAFa;AAG1Ba,IAAAA,WAAW,EAAEC,yBAAYC;AAHC,GAA5B,CADQ,CAAV;AAOA,QAAME,CAAC,GAAG,iBACR,0BAAYb,cAAZ,EAA4B;AAC1BE,IAAAA,UAD0B;AAE1BM,IAAAA,WAAW,EAAEJ,MAAM,CAACC,GAAP,CAAWR,IAAX,CAFa;AAG1BY,IAAAA,WAAW,EAAEC,yBAAYC;AAHC,GAA5B,CADQ,CAAV;AAOA,QAAMG,CAAC,GAAG,0BAAYd,cAAZ,EAA4B;AACpCE,IAAAA,UADoC;AAEpCM,IAAAA,WAAW,EAAEJ,MAAM,CAACC,GAAP,CAAWP,OAAX,CAFuB;AAGpCW,IAAAA,WAAW,EAAEC,yBAAYC;AAHW,GAA5B,CAAV;AAMA,SAAO,oBAAMJ,CAAN,EAASK,CAAT,EAAYC,CAAZ,EAAeC,CAAf,CAAP;AACD","sourcesContent":["import { processColor } from 'react-native';\nimport { round } from '../base';\nimport color from './color';\nimport interpolate, { Extrapolate } from './interpolate';\n\nfunction red(c) {\n  return (c >> 16) & 255;\n}\nfunction green(c) {\n  return (c >> 8) & 255;\n}\nfunction blue(c) {\n  return c & 255;\n}\nfunction opacity(c) {\n  return ((c >> 24) & 255) / 255;\n}\n\n/**\n * Use this if you want to interpolate an `Animated.Value` into color values.\n *\n * #### Why is this needed?\n *\n * Unfortunately, if you'll pass color values directly into the `outputRange` option\n * of `interpolate()` function, that won't really work (at least at the moment).\n * See https://github.com/software-mansion/react-native-reanimated/issues/181 .\n *\n * So, for now you can just use this helper instead.\n */\nexport default function interpolateColors(animationValue, options) {\n  const { inputRange, outputColorRange } = options;\n  const colors = outputColorRange.map(processColor);\n\n  const r = round(\n    interpolate(animationValue, {\n      inputRange,\n      outputRange: colors.map(red),\n      extrapolate: Extrapolate.CLAMP,\n    })\n  );\n  const g = round(\n    interpolate(animationValue, {\n      inputRange,\n      outputRange: colors.map(green),\n      extrapolate: Extrapolate.CLAMP,\n    })\n  );\n  const b = round(\n    interpolate(animationValue, {\n      inputRange,\n      outputRange: colors.map(blue),\n      extrapolate: Extrapolate.CLAMP,\n    })\n  );\n  const a = interpolate(animationValue, {\n    inputRange,\n    outputRange: colors.map(opacity),\n    extrapolate: Extrapolate.CLAMP,\n  });\n\n  return color(r, g, b, a);\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/onChange.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = onChange;
+
+var _base = require("../base");
+
+var _InternalAnimatedValue = _interopRequireDefault(require("../core/InternalAnimatedValue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const procOnChange = (0, _base.proc)(function (value, action, prevValue) {
+  return (0, _base.block)([(0, _base.cond)((0, _base.not)((0, _base.defined)(prevValue)), (0, _base.set)(prevValue, value)), (0, _base.cond)((0, _base.neq)(value, prevValue), [(0, _base.set)(prevValue, value), action])]);
+});
+
+function onChange(value, action) {
+  const prevValue = new _InternalAnimatedValue.default();
+  return procOnChange(value, action, prevValue);
+}
+//# sourceMappingURL=onChange.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/onChange.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["onChange.js"],"names":["procOnChange","value","action","prevValue","onChange","AnimatedValue"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEA,MAAMA,YAAY,GAAG,gBAAK,UAASC,KAAT,EAAgBC,MAAhB,EAAwBC,SAAxB,EAAmC;AAC3D,SAAO,iBAAM,CACX,gBAAK,eAAI,mBAAQA,SAAR,CAAJ,CAAL,EAA8B,eAAIA,SAAJ,EAAeF,KAAf,CAA9B,CADW,EAEX,gBAAK,eAAIA,KAAJ,EAAWE,SAAX,CAAL,EAA4B,CAAC,eAAIA,SAAJ,EAAeF,KAAf,CAAD,EAAwBC,MAAxB,CAA5B,CAFW,CAAN,CAAP;AAID,CALoB,CAArB;;AAOe,SAASE,QAAT,CAAkBH,KAAlB,EAAyBC,MAAzB,EAAiC;AAC9C,QAAMC,SAAS,GAAG,IAAIE,8BAAJ,EAAlB;AACA,SAAOL,YAAY,CAACC,KAAD,EAAQC,MAAR,EAAgBC,SAAhB,CAAnB;AACD","sourcesContent":["import { block, cond, defined, neq, not, set, proc } from '../base';\nimport AnimatedValue from '../core/InternalAnimatedValue';\n\nconst procOnChange = proc(function(value, action, prevValue) {\n  return block([\n    cond(not(defined(prevValue)), set(prevValue, value)),\n    cond(neq(value, prevValue), [set(prevValue, value), action]),\n  ]);\n});\n\nexport default function onChange(value, action) {\n  const prevValue = new AnimatedValue();\n  return procOnChange(value, action, prevValue);\n}\n"]}

node_modules/react-native-reanimated/lib/commonjs/derived/useCode.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useCode;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _base = require("../base");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @callback NodeFactory
+ * Function to create a node or an array of nodes.
+ * @returns {(Node[] | Node | null | undefined | Boolean)}
+ */
+
+/**
+ * React hook to run a node.
+ * @param {NodeFactory} nodeFactory Function to build the node to run.
+ * @param dependencies Array of dependencies. Refresh the node on changes.
+ */
+function useCode(nodeFactory, dependencies) {
+  if (!(_react.default.useEffect instanceof Function)) return;
+
+  _react.default.useEffect(() => {
+    // check and correct 1st parameter
+    if (!(nodeFactory instanceof Function)) {
+      console.warn('useCode() first argument should be a function that returns an animation node.');
+      const node = nodeFactory;
+
+      nodeFactory = () => node;
+    }
+
+    let node = nodeFactory();
+
+    if (node) {
+      // allow factory to return array
+      if (node instanceof Array) node = (0, _base.block)(node);
+      const animatedAlways = (0, _base.always)(node);
+
+      animatedAlways.__attach(); // return undo function
+
+
+      return () => animatedAlways.__detach();
+    }
+  }, dependencies);
+}
+//# sourceMappingURL=useCode.js.map

node_modules/react-native-reanimated/lib/commonjs/derived/useCode.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useCode.js"],"names":["useCode","nodeFactory","dependencies","React","useEffect","Function","console","warn","node","Array","animatedAlways","__attach","__detach"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEA;;;;;;AAMA;;;;;AAKe,SAASA,OAAT,CAAiBC,WAAjB,EAA8BC,YAA9B,EAA4C;AACzD,MAAI,EAAEC,eAAMC,SAAN,YAA2BC,QAA7B,CAAJ,EAA4C;;AAE5CF,iBAAMC,SAAN,CAAgB,MAAM;AACpB;AACA,QAAI,EAAEH,WAAW,YAAYI,QAAzB,CAAJ,EAAwC;AACtCC,MAAAA,OAAO,CAACC,IAAR,CACE,+EADF;AAIA,YAAMC,IAAI,GAAGP,WAAb;;AACAA,MAAAA,WAAW,GAAG,MAAMO,IAApB;AACD;;AAED,QAAIA,IAAI,GAAGP,WAAW,EAAtB;;AACA,QAAIO,IAAJ,EAAU;AACR;AACA,UAAIA,IAAI,YAAYC,KAApB,EAA2BD,IAAI,GAAG,iBAAMA,IAAN,CAAP;AAE3B,YAAME,cAAc,GAAG,kBAAOF,IAAP,CAAvB;;AACAE,MAAAA,cAAc,CAACC,QAAf,GALQ,CAOR;;;AACA,aAAO,MAAMD,cAAc,CAACE,QAAf,EAAb;AACD;AACF,GAtBD,EAsBGV,YAtBH;AAuBD","sourcesContent":["import React from 'react';\nimport { always, block } from '../base';\n\n/**\n * @callback NodeFactory\n * Function to create a node or an array of nodes.\n * @returns {(Node[] | Node | null | undefined | Boolean)}\n */\n\n/**\n * React hook to run a node.\n * @param {NodeFactory} nodeFactory Function to build the node to run.\n * @param dependencies Array of dependencies. Refresh the node on changes.\n */\nexport default function useCode(nodeFactory, dependencies) {\n  if (!(React.useEffect instanceof Function)) return;\n\n  React.useEffect(() => {\n    // check and correct 1st parameter\n    if (!(nodeFactory instanceof Function)) {\n      console.warn(\n        'useCode() first argument should be a function that returns an animation node.'\n      );\n\n      const node = nodeFactory;\n      nodeFactory = () => node;\n    }\n\n    let node = nodeFactory();\n    if (node) {\n      // allow factory to return array\n      if (node instanceof Array) node = block(node);\n\n      const animatedAlways = always(node);\n      animatedAlways.__attach();\n\n      // return undo function\n      return () => animatedAlways.__detach();\n    }\n  }, dependencies);\n}\n"]}