335 lines
11 KiB
JavaScript
335 lines
11 KiB
JavaScript
// Module ID: 354
|
|
// Function ID: 5227
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: [6, 7, 15, 17, 102, 18, 355, 44, 39, 38, 348, 357]
|
|
|
|
// Module 354 (_isNativeReflectConstruct)
|
|
import closure_2 from "A";
|
|
import invariant from "invariant";
|
|
import _possibleConstructorReturn from "_possibleConstructorReturn";
|
|
import _getPrototypeOf from "_getPrototypeOf";
|
|
import _get from "_get";
|
|
import _inherits from "_inherits";
|
|
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function _superPropGet(arg0, arg1, arg2, arg3) {
|
|
let closure_0 = arg2;
|
|
let prototype = arg0;
|
|
if (1) {
|
|
prototype = arg0.prototype;
|
|
}
|
|
const tmpResult = _get(_getPrototypeOf(prototype), arg1, arg2);
|
|
const dependencyMap = tmpResult;
|
|
let fn = tmpResult;
|
|
if (2) {
|
|
fn = tmpResult;
|
|
if ("function" === typeof tmpResult) {
|
|
fn = (arg0) => tmpResult.apply(closure_0, arg0);
|
|
}
|
|
}
|
|
return fn;
|
|
}
|
|
function createNumericInterpolation(extrapolateLeft) {
|
|
let dependencyMap;
|
|
let easing;
|
|
let importDefault;
|
|
({ outputRange: importDefault, inputRange: dependencyMap, easing } = extrapolateLeft);
|
|
if (!easing) {
|
|
easing = importDefault(355).linear;
|
|
}
|
|
let extrapolate = "extend";
|
|
if (undefined !== extrapolateLeft.extrapolateLeft) {
|
|
extrapolate = extrapolateLeft.extrapolateLeft;
|
|
} else if (undefined !== extrapolateLeft.extrapolate) {
|
|
extrapolate = extrapolateLeft.extrapolate;
|
|
}
|
|
extrapolate = "extend";
|
|
if (undefined !== extrapolateLeft.extrapolateRight) {
|
|
extrapolate = extrapolateLeft.extrapolateRight;
|
|
} else if (undefined !== extrapolateLeft.extrapolate) {
|
|
extrapolate = extrapolateLeft.extrapolate;
|
|
}
|
|
return (arg0) => {
|
|
outer1_0(outer1_1[7])("number" === typeof arg0, "Cannot interpolation an input which is not a number");
|
|
let num = 1;
|
|
if (1 < length.length - 1) {
|
|
let num2 = 1;
|
|
num = 1;
|
|
if (arr[1] < arg0) {
|
|
const sum = num2 + 1;
|
|
num = sum;
|
|
while (sum < arr.length - 1) {
|
|
num2 = sum;
|
|
num = sum;
|
|
if (arr[sum] >= arg0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const diff = num - 1;
|
|
const sum1 = diff + 1;
|
|
let tmp8 = dependencyMap[sum1];
|
|
let tmp12 = arg0;
|
|
if (arg0 >= length[diff]) {
|
|
let tmp14 = tmp12;
|
|
if (tmp12 <= tmp6) {
|
|
let tmp13 = tmp7;
|
|
if (tmp7 !== tmp8) {
|
|
if (tmp4 === tmp6) {
|
|
if (arg0 <= tmp4) {
|
|
tmp8 = tmp7;
|
|
}
|
|
tmp13 = tmp8;
|
|
} else {
|
|
if (tmp4 === -Infinity) {
|
|
let diff1 = -tmp14;
|
|
} else if (tmp6 === Infinity) {
|
|
diff1 = tmp14 - tmp4;
|
|
} else {
|
|
diff1 = (tmp14 - tmp4) / (tmp6 - tmp4);
|
|
}
|
|
const tmp9Result = tmp9(diff1);
|
|
if (tmp7 === -Infinity) {
|
|
let sum2 = -tmp9Result;
|
|
} else if (tmp8 === Infinity) {
|
|
sum2 = tmp9Result + tmp7;
|
|
} else {
|
|
sum2 = tmp9Result * (tmp8 - tmp7) + tmp7;
|
|
}
|
|
tmp13 = sum2;
|
|
}
|
|
}
|
|
} else {
|
|
tmp13 = tmp12;
|
|
if ("identity" !== tmp11) {
|
|
tmp14 = tmp12;
|
|
if ("clamp" === tmp11) {
|
|
tmp14 = tmp6;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
tmp13 = arg0;
|
|
if ("identity" !== tmp10) {
|
|
tmp12 = arg0;
|
|
if ("clamp" === tmp10) {
|
|
tmp12 = tmp4;
|
|
}
|
|
}
|
|
}
|
|
return tmp13;
|
|
};
|
|
}
|
|
function mapStringToNumericComponents(str) {
|
|
const tmp = importDefault(39)(str);
|
|
let tmp3 = null == tmp;
|
|
if (!tmp3) {
|
|
tmp3 = "object" !== typeof tmp;
|
|
}
|
|
importDefault(44)(tmp3, "PlatformColors are not supported");
|
|
if ("number" === typeof tmp) {
|
|
let obj = { isColor: true };
|
|
let num3 = tmp;
|
|
if (!tmp) {
|
|
num3 = 0;
|
|
}
|
|
const items = [(4278190080 & num3) >>> 24, (16711680 & num3) >>> 16, (65280 & num3) >>> 8, (255 & num3) / 255];
|
|
obj.components = items;
|
|
return obj;
|
|
} else {
|
|
const items1 = [];
|
|
const match = regex.exec(str);
|
|
let match1 = match;
|
|
let num = 0;
|
|
let num2 = 0;
|
|
if (null != match) {
|
|
do {
|
|
if (match1.index > num) {
|
|
let arr = items1.push(str.substring(num, match1.index));
|
|
}
|
|
let _parseFloat = parseFloat;
|
|
arr = items1.push(parseFloat(match1[0]));
|
|
num = match1.index + match1[0].length;
|
|
let tmp7 = regex;
|
|
match1 = regex.exec(str);
|
|
num2 = num;
|
|
} while (null != match1);
|
|
}
|
|
importDefault(44)(items1.length > 0, "outputRange must contain color or value with numeric component");
|
|
if (num2 < str.length) {
|
|
items1.push(str.substring(num2, str.length));
|
|
}
|
|
obj = { isColor: false, components: items1 };
|
|
return obj;
|
|
}
|
|
const tmp2 = importDefault(44);
|
|
}
|
|
const re8 = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
|
|
|
|
export default ((arg0) => {
|
|
class AnimatedInterpolation {
|
|
constructor(arg0, arg1) {
|
|
self = this;
|
|
tmp = outer1_2(this, AnimatedInterpolation);
|
|
items = [];
|
|
items[0] = arg1;
|
|
obj = outer1_5(AnimatedInterpolation);
|
|
tmp2 = outer1_4;
|
|
if (outer1_9()) {
|
|
tmp4 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp5 = outer1_5;
|
|
constructResult = Reflect.construct(obj, items, outer1_5(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items);
|
|
}
|
|
tmp2Result = tmp2(self, constructResult);
|
|
tmp2Result._parent = arg0;
|
|
tmp2Result._config = arg1;
|
|
return tmp2Result;
|
|
}
|
|
}
|
|
callback2(AnimatedInterpolation, arg0);
|
|
let obj = {
|
|
key: "_getInterpolation",
|
|
value: function _getInterpolation() {
|
|
const self = this;
|
|
if (!this._interpolation) {
|
|
const _config = self._config;
|
|
if (_config.outputRange) {
|
|
if ("string" === typeof _config.outputRange[0]) {
|
|
self._interpolation = (function createStringInterpolation(_config) {
|
|
let closure_0 = _config;
|
|
AnimatedInterpolation(outer2_1[7])(_config.outputRange.length >= 2, "Bad output range");
|
|
const outputRange = _config.outputRange;
|
|
let mapped = outputRange.map(outer2_12);
|
|
const isColor = mapped[0].isColor;
|
|
const mapped1 = mapped.map((components) => {
|
|
components = components.components;
|
|
if (isColor) {
|
|
let found = components;
|
|
} else {
|
|
found = components.filter((arg0) => "number" === typeof arg0);
|
|
}
|
|
return found;
|
|
});
|
|
const first = mapped1[0];
|
|
let _possibleConstructorReturn = first.map((arg0, arg1) => {
|
|
let closure_0 = arg1;
|
|
return outer3_11(Object.assign({}, closure_0, { outputRange: mapped1.map((arg0) => arg0[closure_0]) }));
|
|
});
|
|
return isColor ? ((arg0) => {
|
|
let closure_0 = arg0;
|
|
const mapped = _possibleConstructorReturn.map((arg0, arg1) => {
|
|
const tmp = arg0(closure_0);
|
|
if (arg1 < 3) {
|
|
const _Math2 = Math;
|
|
let rounded = Math.round(tmp);
|
|
} else {
|
|
const _Math = Math;
|
|
rounded = Math.round(1000 * tmp) / 1000;
|
|
}
|
|
return rounded;
|
|
});
|
|
return "rgba(" + mapped[0] + ", " + mapped[1] + ", " + mapped[2] + ", " + mapped[3] + ")";
|
|
}) : ((arg0) => {
|
|
let closure_0 = arg0;
|
|
let mapped = _possibleConstructorReturn.map((arg0) => arg0(closure_0));
|
|
let c2 = 0;
|
|
const components = mapped[0].components;
|
|
mapped = components.map((arg0) => {
|
|
let tmp = arg0;
|
|
if ("number" === typeof arg0) {
|
|
let closure_2 = tmp4 + 1;
|
|
tmp = table[tmp4];
|
|
}
|
|
return tmp;
|
|
});
|
|
return mapped.join("");
|
|
});
|
|
})(_config);
|
|
}
|
|
}
|
|
self._interpolation = outer1_11(_config);
|
|
}
|
|
return self._interpolation;
|
|
}
|
|
};
|
|
let items = [obj, , , , , , ];
|
|
obj = {
|
|
key: "__makeNative",
|
|
value: function __makeNative(arg0) {
|
|
const _parent = this._parent;
|
|
_parent.__makeNative(arg0);
|
|
const items = [arg0];
|
|
outer1_10(AnimatedInterpolation, "__makeNative", this, 3)(items);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "__getValue",
|
|
value: function __getValue() {
|
|
const _parent = this._parent;
|
|
const __getValueResult = _parent.__getValue();
|
|
AnimatedInterpolation(outer1_1[7])("number" === typeof __getValueResult, "Cannot interpolate an input which is not a number.");
|
|
return this._getInterpolation()(__getValueResult);
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "interpolate",
|
|
value: function interpolate(_config) {
|
|
return new AnimatedInterpolation(this, _config);
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "__attach",
|
|
value: function __attach() {
|
|
const _parent = this._parent;
|
|
_parent.__addChild(this);
|
|
outer1_10(AnimatedInterpolation, "__attach", this, 3)([]);
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "__detach",
|
|
value: function __detach() {
|
|
const _parent = this._parent;
|
|
_parent.__removeChild(this);
|
|
outer1_10(AnimatedInterpolation, "__detach", this, 3)([]);
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "__getNativeConfig",
|
|
value: function __getNativeConfig() {
|
|
const self = this;
|
|
const outputRange = this._config.outputRange;
|
|
let c0 = null;
|
|
let mapped = outputRange;
|
|
if ("string" === typeof outputRange[0]) {
|
|
mapped = outputRange.map((arg0) => {
|
|
const tmp = AnimatedInterpolation(outer2_1[9])(arg0);
|
|
if ("number" === typeof tmp) {
|
|
const color = "color";
|
|
let transformDataTypeResult = tmp;
|
|
} else {
|
|
transformDataTypeResult = AnimatedInterpolation(outer2_1[10]).transformDataType(arg0);
|
|
const obj = AnimatedInterpolation(outer2_1[10]);
|
|
}
|
|
return transformDataTypeResult;
|
|
});
|
|
}
|
|
let obj = { inputRange: self._config.inputRange, outputRange: mapped, outputType: c0, extrapolateLeft: self._config.extrapolateLeft || self._config.extrapolate || "extend", extrapolateRight: self._config.extrapolateRight || self._config.extrapolate || "extend", type: "interpolation", debugID: self.__getDebugID() };
|
|
return obj;
|
|
}
|
|
};
|
|
return callback(AnimatedInterpolation, items);
|
|
})(require("_isNativeReflectConstruct"));
|