1334 lines
37 KiB
JavaScript
1334 lines
37 KiB
JavaScript
// Module ID: 4113
|
|
// Function ID: 4114
|
|
// Name: _extends
|
|
// Dependencies: [19, 4109, 1229, 1230, 4114, 4116, 4118, 1223]
|
|
// Exports: Prompt, Redirect, generatePath, matchPath, useHistory, useLocation, useParams, useRouteMatch, withRouter
|
|
|
|
// Module 4113 (_extends)
|
|
import noop from "noop";
|
|
import emptyFunction from "emptyFunction";
|
|
import warning from "warning";
|
|
import invariant from "invariant";
|
|
import parse from "parse";
|
|
import "num2";
|
|
import getStatics from "getStatics";
|
|
|
|
let Component6 = require;
|
|
let closure_1 = dependencyMap;
|
|
function _extends() {
|
|
let tmp = Object.assign || ((arg0) => {
|
|
for (let num = 1; num < arguments.length; num = num + 1) {
|
|
let tmp = arguments[num];
|
|
let tmp2 = tmp;
|
|
let tmp3 = num;
|
|
for (const key10012 in tmp) {
|
|
let tmp5 = key10012;
|
|
let _Object = Object;
|
|
let call = hasOwnProperty.call;
|
|
if (typeof call === "unknown") {
|
|
let hasOwnPropertyResult = hasOwnProperty(key10012);
|
|
} else {
|
|
hasOwnPropertyResult = call(tmp, key10012);
|
|
}
|
|
if (!hasOwnPropertyResult) {
|
|
continue;
|
|
} else {
|
|
arg0[key10012] = tmp[key10012];
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
return arg0;
|
|
});
|
|
const self = this;
|
|
const apply = tmp.apply;
|
|
if (typeof apply === "unknown") {
|
|
let applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
return applyArgumentsResult;
|
|
}
|
|
function _setPrototypeOf(arg0, Component) {
|
|
let fn = Object.setPrototypeOf;
|
|
if (!fn) {
|
|
fn = (arg0, Component) => {
|
|
arg0.__proto__ = Component;
|
|
return arg0;
|
|
};
|
|
}
|
|
return fn(arg0, Component);
|
|
}
|
|
function noop() {
|
|
|
|
}
|
|
if (noop) {
|
|
if (typeof noop === "object") {
|
|
if ("default" in noop) {
|
|
noop = noop.default;
|
|
}
|
|
}
|
|
}
|
|
if (emptyFunction) {
|
|
if (typeof emptyFunction === "object") {
|
|
if ("default" in emptyFunction) {
|
|
emptyFunction = emptyFunction.default;
|
|
}
|
|
}
|
|
}
|
|
if (invariant) {
|
|
if (typeof invariant === "object") {
|
|
if ("default" in invariant) {
|
|
invariant = invariant.default;
|
|
}
|
|
}
|
|
}
|
|
if (parse) {
|
|
if (typeof parse === "object") {
|
|
if ("default" in parse) {
|
|
parse = parse.default;
|
|
}
|
|
}
|
|
}
|
|
if (getStatics) {
|
|
if (typeof getStatics === "object") {
|
|
if ("default" in getStatics) {
|
|
getStatics = getStatics.default;
|
|
}
|
|
}
|
|
}
|
|
let c9 = 1073741823;
|
|
if (typeof globalThis !== "undefined") {
|
|
let _globalThis = globalThis;
|
|
} else {
|
|
const _window = window;
|
|
if (typeof window !== "undefined") {
|
|
_globalThis = window;
|
|
} else {
|
|
_globalThis = global;
|
|
if (undefined === global) {
|
|
_globalThis = {};
|
|
}
|
|
}
|
|
}
|
|
const tmp9 = noop.createContext || (function createReactContext(arg0, arg1) {
|
|
let Component2 = arg0;
|
|
let closure_1 = arg1;
|
|
let num = _globalThis.__global_unique_id__;
|
|
if (!num) {
|
|
num = 0;
|
|
}
|
|
const sum = num + 1;
|
|
_globalThis.__global_unique_id__ = sum;
|
|
const noop = `${"__create-react-context-" + tmp2}__`;
|
|
const Component = noop.Component;
|
|
Component2 = Component;
|
|
class t {
|
|
constructor() {
|
|
length = arguments.length;
|
|
array = new Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
array[num] = arguments[num];
|
|
}
|
|
call = Component.call;
|
|
items = [];
|
|
items[0] = this;
|
|
tmp2 = call.apply(Component, items.concat(array)) || this;
|
|
Component = tmp2.props.value;
|
|
closure_1 = [];
|
|
tmp2.emitter = {
|
|
on(arg0) {
|
|
|
|
},
|
|
off(arg0) {
|
|
let closure_0 = arg0;
|
|
},
|
|
get() {
|
|
return closure_0;
|
|
},
|
|
set(arg0, arg1) {
|
|
let closure_0 = arg1;
|
|
closure_0 = arg0;
|
|
const item = arr.forEach(() => { ... });
|
|
}
|
|
};
|
|
return tmp2;
|
|
}
|
|
}
|
|
t.prototype = Object.create(Component.prototype);
|
|
t.prototype.constructor = t;
|
|
_setPrototypeOf(t, Component);
|
|
const prototype = t.prototype;
|
|
prototype.getChildContext = function() {
|
|
return { [closure_2]: this.emitter };
|
|
};
|
|
prototype.componentWillReceiveProps = function(value) {
|
|
const self = this;
|
|
if (this.props.value !== value.value) {
|
|
value = self.props.value;
|
|
value = value.value;
|
|
if (value === value) {
|
|
let tmp2 = 0 !== value;
|
|
if (!tmp2) {
|
|
tmp2 = 1 / value === 1 / value;
|
|
}
|
|
let tmp = tmp2;
|
|
} else {
|
|
tmp = value != value && value != value;
|
|
}
|
|
if (!tmp) {
|
|
if (typeof closure_1 === "function") {
|
|
let tmp3Result = tmp3(value, value);
|
|
} else {
|
|
tmp3Result = outer1_9;
|
|
}
|
|
if (0 !== (tmp3Result | 0)) {
|
|
const emitter = self.emitter;
|
|
const result = emitter.set(value.value, tmp5);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
prototype.render = function() {
|
|
return this.props.children;
|
|
};
|
|
let obj = { [`${"__create-react-context-" + tmp2}__`]: emptyFunction.object.isRequired };
|
|
t.childContextTypes = obj;
|
|
Component2 = noop.Component;
|
|
class t {
|
|
constructor() {
|
|
length = arguments.length;
|
|
array = new Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
array[num] = arguments[num];
|
|
}
|
|
call = concat.call;
|
|
items = [];
|
|
items[0] = this;
|
|
obj = call.apply(concat, items.concat(array)) || this;
|
|
concat = obj;
|
|
obj.observedBits = undefined;
|
|
obj = { value: obj.getValue() };
|
|
obj.state = obj;
|
|
obj.onUpdate = (arg0, arg1) => {
|
|
if (obj.observedBits & arg1) {
|
|
obj = { value: null };
|
|
obj[0] = obj.getValue();
|
|
obj.setState(obj);
|
|
}
|
|
};
|
|
return obj;
|
|
}
|
|
}
|
|
t.prototype = Object.create(Component2.prototype);
|
|
t.prototype.constructor = t;
|
|
_setPrototypeOf(t, Component2);
|
|
const prototype2 = t.prototype;
|
|
prototype2.componentWillReceiveProps = function(observedBits) {
|
|
observedBits = observedBits.observedBits;
|
|
if (null == observedBits) {
|
|
observedBits = closure_9;
|
|
}
|
|
this.observedBits = observedBits;
|
|
};
|
|
prototype2.componentDidMount = function() {
|
|
const self = this;
|
|
if (this.context[closure_2]) {
|
|
self.context[tmp].on(self.onUpdate);
|
|
const obj = self.context[tmp];
|
|
}
|
|
let observedBits = self.props.observedBits;
|
|
if (null == observedBits) {
|
|
observedBits = outer1_9;
|
|
}
|
|
self.observedBits = observedBits;
|
|
};
|
|
prototype2.componentWillUnmount = function() {
|
|
const self = this;
|
|
if (this.context[closure_2]) {
|
|
self.context[tmp].off(self.onUpdate);
|
|
const obj = self.context[tmp];
|
|
}
|
|
};
|
|
prototype2.getValue = function() {
|
|
if (this.context[closure_2]) {
|
|
let value = this.context[tmp].get();
|
|
const obj = this.context[tmp];
|
|
} else {
|
|
value = Component2;
|
|
}
|
|
return value;
|
|
};
|
|
prototype2.render = function() {
|
|
const children = this.props.children;
|
|
let first = children;
|
|
if (Array.isArray(children)) {
|
|
first = children[0];
|
|
}
|
|
return first(this.state.value);
|
|
};
|
|
t.contextTypes = { [`${"__create-react-context-" + tmp2}__`]: emptyFunction.object };
|
|
obj = { Provider: t, Consumer: t };
|
|
return obj;
|
|
});
|
|
function generatePath(arg0, arg1) {
|
|
let str = arg0;
|
|
if (undefined === arg0) {
|
|
str = "/";
|
|
}
|
|
let obj = arg1;
|
|
if (undefined === arg1) {
|
|
obj = {};
|
|
}
|
|
if ("/" === str) {
|
|
return str;
|
|
} else {
|
|
obj = table;
|
|
if (table[str]) {
|
|
let tmp4 = obj[str];
|
|
} else {
|
|
const compileResult = parse.compile(str);
|
|
tmp4 = compileResult;
|
|
if (closure_16 < 10000) {
|
|
obj[str] = compileResult;
|
|
closure_16 = closure_16 + 1;
|
|
tmp4 = compileResult;
|
|
}
|
|
}
|
|
obj = { pretty: true };
|
|
tmp4(obj, obj);
|
|
}
|
|
}
|
|
function matchPath(pathname, arg1) {
|
|
let closure_0 = pathname;
|
|
let obj = arg1;
|
|
if (undefined === arg1) {
|
|
obj = {};
|
|
}
|
|
let tmp = typeof obj !== "string";
|
|
if (typeof obj !== "string") {
|
|
const _Array = Array;
|
|
tmp = !Array.isArray(obj);
|
|
}
|
|
let tmp2 = obj;
|
|
if (!tmp) {
|
|
obj = { path: null };
|
|
obj[0] = obj;
|
|
tmp2 = obj;
|
|
}
|
|
const exact = tmp2.exact;
|
|
let tmp3 = undefined !== exact;
|
|
if (tmp3) {
|
|
tmp3 = exact;
|
|
}
|
|
let closure_1 = tmp3;
|
|
const strict = tmp2.strict;
|
|
let closure_2 = undefined !== strict && strict;
|
|
const sensitive = tmp2.sensitive;
|
|
let closure_3 = undefined !== sensitive && sensitive;
|
|
const items = [];
|
|
const combined = items.concat(tmp2.path);
|
|
return combined.reduce((arg0, arg1) => {
|
|
let keys;
|
|
let regexp;
|
|
if (!arg1) {
|
|
if ("" !== arg1) {
|
|
return null;
|
|
}
|
|
}
|
|
if (arg0) {
|
|
return arg0;
|
|
} else {
|
|
let obj = { end: null, strict: null, sensitive: null };
|
|
obj[0] = closure_1;
|
|
obj[1] = match;
|
|
obj[2] = closure_3;
|
|
const sum = "" + obj.end + obj.strict + obj.sensitive;
|
|
let tmp7 = outer1_17[sum];
|
|
if (!tmp7) {
|
|
obj = {};
|
|
tmp6[sum] = obj;
|
|
tmp7 = obj;
|
|
}
|
|
if (tmp7[arg1]) {
|
|
let tmp10 = tmp7[arg1];
|
|
} else {
|
|
const items = [];
|
|
obj = { regexp: null, keys: null };
|
|
obj[0] = outer1_5(arg1, items, obj);
|
|
obj[1] = items;
|
|
tmp10 = obj;
|
|
if (outer1_18 < 10000) {
|
|
tmp7[arg1] = obj;
|
|
outer1_18 = outer1_18 + 1;
|
|
tmp10 = obj;
|
|
}
|
|
}
|
|
({ regexp, keys } = tmp10);
|
|
match = regexp.exec(closure_0);
|
|
if (match) {
|
|
const first = match[0];
|
|
closure_0 = match.slice(1);
|
|
if (!tmp2) {
|
|
const obj1 = { path: null, url: null, isExact: null, params: null };
|
|
obj1[0] = arg1;
|
|
let str2 = "/";
|
|
if ("/" !== arg1) {
|
|
str2 = first;
|
|
}
|
|
obj1[1] = str2;
|
|
obj1[2] = tmp15;
|
|
obj1[3] = keys.reduce((arg0, name) => {
|
|
arg0[name.name] = table[arg2];
|
|
return arg0;
|
|
}, {});
|
|
let tmp16 = obj1;
|
|
} else {
|
|
tmp16 = null;
|
|
}
|
|
return tmp16;
|
|
} else {
|
|
return null;
|
|
}
|
|
const tmp12 = closure_0;
|
|
tmp2 = closure_1;
|
|
}
|
|
}, null);
|
|
}
|
|
function useLocation() {
|
|
return useContext(closure_12).location;
|
|
}
|
|
let tmp9Result = tmp9();
|
|
tmp9Result.displayName = "Router-History";
|
|
const unpackModuleId = tmp9Result;
|
|
tmp9Result = tmp9();
|
|
tmp9Result.displayName = "Router";
|
|
let closure_12 = tmp9Result;
|
|
let Component = noop.Component;
|
|
Component6 = Component;
|
|
class t {
|
|
constructor(arg0) {
|
|
self = this;
|
|
tmp = call;
|
|
call = call.call;
|
|
tmp2 = (typeof call === "unknown" ? tmp(global) : call(self, global)) || self;
|
|
call = tmp2;
|
|
tmp2.state = { location: global.history.location };
|
|
tmp2._isMounted = false;
|
|
tmp2._pendingLocation = null;
|
|
if (!global.staticContext) {
|
|
history = global.history;
|
|
tmp2.unlisten = history.listen((_pendingLocation) => {
|
|
closure_0._pendingLocation = _pendingLocation;
|
|
});
|
|
}
|
|
return tmp2;
|
|
}
|
|
static computeRootMatch(arg0) {
|
|
obj = { path: "/", url: "/", params: {}, isExact: "/" === global };
|
|
return obj;
|
|
}
|
|
}
|
|
closure_1 = t;
|
|
t.prototype = Object.create(Component.prototype);
|
|
t.prototype.constructor = t;
|
|
_setPrototypeOf(t, Component);
|
|
let prototype = t.prototype;
|
|
prototype.componentDidMount = function() {
|
|
let self = this;
|
|
self = this;
|
|
this._isMounted = true;
|
|
if (this.unlisten) {
|
|
self.unlisten();
|
|
}
|
|
if (!self.props.staticContext) {
|
|
const history = self.props.history;
|
|
self.unlisten = history.listen((arg0) => {
|
|
let obj = self;
|
|
if (self._isMounted) {
|
|
obj = { location: null };
|
|
obj[0] = arg0;
|
|
obj.setState(obj);
|
|
}
|
|
});
|
|
}
|
|
if (self._pendingLocation) {
|
|
let obj = { location: null };
|
|
obj[0] = self._pendingLocation;
|
|
self.setState(obj);
|
|
}
|
|
};
|
|
prototype.componentWillUnmount = function() {
|
|
const self = this;
|
|
if (this.unlisten) {
|
|
self.unlisten();
|
|
self._isMounted = false;
|
|
self._pendingLocation = null;
|
|
}
|
|
};
|
|
prototype.render = function() {
|
|
let obj = { value: null };
|
|
obj = { history: this.props.history, location: this.state.location, match: closure_1.computeRootMatch(this.state.location.pathname), staticContext: this.props.staticContext };
|
|
obj[0] = obj;
|
|
let children = this.props.children;
|
|
if (!children) {
|
|
children = null;
|
|
}
|
|
obj = { children, value: this.props.history };
|
|
return <tmp9Result2.Provider children={children} value={this.props.history}><tmp9Result.Provider children={children} value={this.props.history} /></tmp9Result2.Provider>;
|
|
};
|
|
let closure_13 = t;
|
|
let Component2 = noop.Component;
|
|
Component6 = Component2;
|
|
class t {
|
|
constructor() {
|
|
length = arguments.length;
|
|
array = new Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
array[num] = arguments[num];
|
|
}
|
|
call = Component.call;
|
|
items = [];
|
|
items[0] = this;
|
|
tmp2 = call.apply(Component, items.concat(array)) || this;
|
|
obj = require("_extends");
|
|
tmp2.history = obj.createMemoryHistory(tmp2.props);
|
|
return tmp2;
|
|
}
|
|
render() {
|
|
obj = { history: this.history, children: this.props.children };
|
|
return closure_2.createElement(t, obj);
|
|
}
|
|
}
|
|
t.prototype = Object.create(Component2.prototype);
|
|
t.prototype.constructor = t;
|
|
_setPrototypeOf(t, Component2);
|
|
const Component3 = noop.Component;
|
|
Component6 = Component3;
|
|
class e {
|
|
constructor() {
|
|
self = this;
|
|
tmp = Component;
|
|
apply = Component.apply;
|
|
if (typeof apply === "unknown") {
|
|
tmp2 = tmp;
|
|
tmp3 = self;
|
|
applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
tmp5 = arguments;
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
if (!applyArgumentsResult) {
|
|
applyArgumentsResult = self;
|
|
}
|
|
return applyArgumentsResult;
|
|
}
|
|
}
|
|
e.prototype = Object.create(Component3.prototype);
|
|
e.prototype.constructor = e;
|
|
_setPrototypeOf(e, Component3);
|
|
let prototype2 = e.prototype;
|
|
prototype2.componentDidMount = function() {
|
|
const self = this;
|
|
if (this.props.onMount) {
|
|
const onMount = self.props.onMount;
|
|
const call = onMount.call;
|
|
if (typeof call === "unknown") {
|
|
onMount(self);
|
|
} else {
|
|
call(self, self);
|
|
}
|
|
}
|
|
};
|
|
prototype2.componentDidUpdate = function(arg0) {
|
|
const self = this;
|
|
if (this.props.onUpdate) {
|
|
const onUpdate = self.props.onUpdate;
|
|
const call = onUpdate.call;
|
|
if (typeof call === "unknown") {
|
|
onUpdate(self, arg0);
|
|
} else {
|
|
call(self, self, arg0);
|
|
}
|
|
}
|
|
};
|
|
prototype2.componentWillUnmount = function() {
|
|
const self = this;
|
|
if (this.props.onUnmount) {
|
|
const onUnmount = self.props.onUnmount;
|
|
const call = onUnmount.call;
|
|
if (typeof call === "unknown") {
|
|
onUnmount(self);
|
|
} else {
|
|
call(self, self);
|
|
}
|
|
}
|
|
};
|
|
prototype2.render = () => null;
|
|
let closure_14 = e;
|
|
let closure_15 = {};
|
|
let c16 = 0;
|
|
let closure_17 = {};
|
|
let c18 = 0;
|
|
const Component4 = noop.Component;
|
|
Component6 = Component4;
|
|
class e {
|
|
constructor() {
|
|
self = this;
|
|
tmp = Component;
|
|
apply = Component.apply;
|
|
if (typeof apply === "unknown") {
|
|
tmp2 = tmp;
|
|
tmp3 = self;
|
|
applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
tmp5 = arguments;
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
if (!applyArgumentsResult) {
|
|
applyArgumentsResult = self;
|
|
}
|
|
return applyArgumentsResult;
|
|
}
|
|
render() {
|
|
self = this;
|
|
return closure_2.createElement(createReactContext.Consumer, null, (location) => {
|
|
let children;
|
|
let component;
|
|
let render;
|
|
if (!location) {
|
|
outer1_4(false);
|
|
}
|
|
let obj = { location: tmp4, match: null };
|
|
let props = tmp3.props;
|
|
if (pathname.props.computedMatch) {
|
|
let match = props.computedMatch;
|
|
} else if (props.path) {
|
|
props = tmp3.props;
|
|
pathname = tmp4.pathname;
|
|
let c1;
|
|
let closure_2;
|
|
let closure_3;
|
|
if (undefined === props) {
|
|
props = {};
|
|
}
|
|
let tmp6 = typeof props !== "string";
|
|
if (typeof props !== "string") {
|
|
const _Array = Array;
|
|
tmp6 = !Array.isArray(props);
|
|
}
|
|
let tmp7 = props;
|
|
if (!tmp6) {
|
|
obj = { path: null };
|
|
obj[0] = props;
|
|
tmp7 = obj;
|
|
}
|
|
const exact = tmp7.exact;
|
|
let tmp8 = undefined !== exact;
|
|
if (tmp8) {
|
|
tmp8 = exact;
|
|
}
|
|
c1 = tmp8;
|
|
const strict = tmp7.strict;
|
|
closure_2 = undefined !== strict && strict;
|
|
const sensitive = tmp7.sensitive;
|
|
closure_3 = undefined !== sensitive && sensitive;
|
|
const items = [];
|
|
const combined = items.concat(tmp7.path);
|
|
match = combined.reduce((arg0, arg1) => {
|
|
let keys;
|
|
let regexp;
|
|
if (!arg1) {
|
|
if ("" !== arg1) {
|
|
return null;
|
|
}
|
|
}
|
|
if (arg0) {
|
|
return arg0;
|
|
} else {
|
|
let obj = { end: null, strict: null, sensitive: null };
|
|
obj[0] = closure_1;
|
|
obj[1] = match;
|
|
obj[2] = closure_3;
|
|
const sum = "" + obj.end + obj.strict + obj.sensitive;
|
|
let tmp7 = outer1_17[sum];
|
|
if (!tmp7) {
|
|
obj = {};
|
|
tmp6[sum] = obj;
|
|
tmp7 = obj;
|
|
}
|
|
if (tmp7[arg1]) {
|
|
let tmp10 = tmp7[arg1];
|
|
} else {
|
|
const items = [];
|
|
obj = { regexp: null, keys: null };
|
|
obj[0] = outer1_5(arg1, items, obj);
|
|
obj[1] = items;
|
|
tmp10 = obj;
|
|
if (outer1_18 < 10000) {
|
|
tmp7[arg1] = obj;
|
|
outer1_18 = outer1_18 + 1;
|
|
tmp10 = obj;
|
|
}
|
|
}
|
|
({ regexp, keys } = tmp10);
|
|
match = regexp.exec(closure_0);
|
|
if (match) {
|
|
const first = match[0];
|
|
closure_0 = match.slice(1);
|
|
if (!tmp2) {
|
|
const obj1 = { path: null, url: null, isExact: null, params: null };
|
|
obj1[0] = arg1;
|
|
let str2 = "/";
|
|
if ("/" !== arg1) {
|
|
str2 = first;
|
|
}
|
|
obj1[1] = str2;
|
|
obj1[2] = tmp15;
|
|
obj1[3] = keys.reduce((arg0, name) => {
|
|
arg0[name.name] = table[arg2];
|
|
return arg0;
|
|
}, {});
|
|
let tmp16 = obj1;
|
|
} else {
|
|
tmp16 = null;
|
|
}
|
|
return tmp16;
|
|
} else {
|
|
return null;
|
|
}
|
|
const tmp12 = closure_0;
|
|
tmp2 = closure_1;
|
|
}
|
|
}, null);
|
|
} else {
|
|
match = location.match;
|
|
}
|
|
obj[1] = match;
|
|
const tmp5Result = outer1_7({}, location, obj);
|
|
({ children, component, render } = pathname.props);
|
|
let isArray = Array.isArray(children);
|
|
if (isArray) {
|
|
const Children = outer1_2.Children;
|
|
isArray = 0 === Children.count(children);
|
|
}
|
|
let tmp12 = children;
|
|
if (isArray) {
|
|
tmp12 = null;
|
|
}
|
|
if (tmp5Result.match) {
|
|
if (tmp12) {
|
|
let tmp12Result = tmp12;
|
|
if (typeof tmp12 === "function") {
|
|
tmp12Result = tmp12(tmp5Result);
|
|
}
|
|
let element = tmp12Result;
|
|
} else if (component) {
|
|
element = <component {......tmp5Result} />;
|
|
} else {
|
|
element = null;
|
|
if (render) {
|
|
element = render(tmp5Result);
|
|
}
|
|
}
|
|
} else {
|
|
tmp12Result = null;
|
|
if (typeof tmp12 === "function") {
|
|
tmp12Result = tmp12(tmp5Result);
|
|
}
|
|
return tmp13(tmp14, { value: tmp5Result }, tmp12Result);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
e.prototype = Object.create(Component4.prototype);
|
|
e.prototype.constructor = e;
|
|
_setPrototypeOf(e, Component4);
|
|
const Component5 = noop.Component;
|
|
Component6 = Component5;
|
|
class t {
|
|
constructor() {
|
|
length = arguments.length;
|
|
array = new Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
array[num] = arguments[num];
|
|
}
|
|
call = concat.call;
|
|
items = [];
|
|
items[0] = this;
|
|
tmp2 = call.apply(concat, items.concat(array)) || this;
|
|
concat = tmp2;
|
|
tmp2.handlePush = (arg0) => tmp2.navigateTo(arg0, "PUSH");
|
|
tmp2.handleReplace = (arg0) => tmp2.navigateTo(arg0, "REPLACE");
|
|
tmp2.handleListen = () => closure_19;
|
|
tmp2.handleBlock = () => closure_19;
|
|
return tmp2;
|
|
}
|
|
}
|
|
t.prototype = Object.create(Component5.prototype);
|
|
t.prototype.constructor = t;
|
|
_setPrototypeOf(t, Component5);
|
|
const prototype3 = t.prototype;
|
|
prototype3.navigateTo = function(tmp4Result, action) {
|
|
const props = this.props;
|
|
const basename = props.basename;
|
|
let str = "";
|
|
if (undefined !== basename) {
|
|
str = basename;
|
|
}
|
|
let context = props.context;
|
|
if (undefined === context) {
|
|
context = {};
|
|
}
|
|
context.action = action;
|
|
let _location = Component6(closure_1[7]).createLocation(tmp4Result);
|
|
let tmp5Result = _location;
|
|
if (str) {
|
|
let text = str;
|
|
if ("/" !== str.charAt(0)) {
|
|
text = `/${str}`;
|
|
}
|
|
const obj = { pathname: null };
|
|
obj[0] = text + _location.pathname;
|
|
tmp5Result = _extends({}, _location, obj);
|
|
const tmp5 = _extends;
|
|
}
|
|
context.location = tmp5Result;
|
|
_location = context.location;
|
|
let path = _location;
|
|
if (typeof _location !== "string") {
|
|
path = Component6(closure_1[7]).createPath(_location);
|
|
const tmpResult = Component6(closure_1[7]);
|
|
}
|
|
context.url = path;
|
|
};
|
|
prototype3.render = function() {
|
|
const self = this;
|
|
const props = this.props;
|
|
const basename = props.basename;
|
|
let str = "";
|
|
if (undefined !== basename) {
|
|
str = basename;
|
|
}
|
|
let staticContext = props.context;
|
|
if (undefined === staticContext) {
|
|
staticContext = {};
|
|
}
|
|
let _location = props.location;
|
|
let str2 = "/";
|
|
if (undefined !== _location) {
|
|
str2 = _location;
|
|
}
|
|
const items = ["basename", "context", "location"];
|
|
if (null == props) {
|
|
let obj = {};
|
|
} else {
|
|
obj = {};
|
|
const _Object = Object;
|
|
const keys = Object.keys(props);
|
|
for (let num3 = 0; num3 < keys.length; num3 = num3 + 1) {
|
|
let tmp2 = keys[num3];
|
|
let tmp3 = num3;
|
|
if (0 > items.indexOf(tmp2)) {
|
|
obj[tmp2] = props[tmp2];
|
|
}
|
|
}
|
|
}
|
|
const obj1 = {
|
|
createHref(_location) {
|
|
let path = _location;
|
|
if (typeof _location !== "string") {
|
|
path = str(outer1_1[7]).createPath(_location);
|
|
const obj = str(outer1_1[7]);
|
|
}
|
|
let text = str;
|
|
if ("/" !== str + path.charAt(0)) {
|
|
text = `/${str}`;
|
|
}
|
|
return text;
|
|
},
|
|
action: "POP",
|
|
location: null,
|
|
push: null,
|
|
replace: null,
|
|
go: null,
|
|
goBack: null,
|
|
goForward: null,
|
|
listen: null,
|
|
block: null
|
|
};
|
|
_location = str(closure_1[7]).createLocation(str2);
|
|
let tmp5 = _location;
|
|
if (str) {
|
|
let text = str;
|
|
if ("/" !== str.charAt(0)) {
|
|
text = `/${str}`;
|
|
}
|
|
const pathname = _location.pathname;
|
|
let tmp7 = _location;
|
|
if (0 === pathname.indexOf(text)) {
|
|
const obj2 = { pathname: null };
|
|
obj2[0] = _location.pathname.substr(text.length);
|
|
tmp7 = _extends({}, _location, obj2);
|
|
const str3 = _location.pathname;
|
|
}
|
|
tmp5 = tmp7;
|
|
}
|
|
obj1[2] = tmp5;
|
|
({ handlePush: obj4[3], handleReplace: obj4[4] } = self);
|
|
obj1[5] = () => {
|
|
callback(false);
|
|
};
|
|
obj1[6] = () => {
|
|
callback(false);
|
|
};
|
|
obj1[7] = () => {
|
|
callback(false);
|
|
};
|
|
({ handleListen: obj4[8], handleBlock: obj4[9] } = self);
|
|
return <closure_13 {......_extends({}, obj, { history: obj1, staticContext })} />;
|
|
};
|
|
Component6 = noop.Component;
|
|
class e {
|
|
constructor() {
|
|
self = this;
|
|
tmp = Component;
|
|
apply = Component.apply;
|
|
if (typeof apply === "unknown") {
|
|
tmp2 = tmp;
|
|
tmp3 = self;
|
|
applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
tmp5 = arguments;
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
if (!applyArgumentsResult) {
|
|
applyArgumentsResult = self;
|
|
}
|
|
return applyArgumentsResult;
|
|
}
|
|
render() {
|
|
self = this;
|
|
return closure_2.createElement(createReactContext.Consumer, null, (location) => {
|
|
const _self = location;
|
|
if (!location) {
|
|
outer1_4(false);
|
|
}
|
|
let _location = _self.props.location;
|
|
if (!_location) {
|
|
_location = location.location;
|
|
}
|
|
let obj = outer1_2;
|
|
const Children = outer1_2.Children;
|
|
const item = Children.forEach(_self.props.children, (icon) => {
|
|
let exact;
|
|
let path;
|
|
if (null == match) {
|
|
path = icon;
|
|
if (outer1_2.isValidElement(icon)) {
|
|
let closure_1 = path;
|
|
let reduce = path.props.path || path.props.from;
|
|
if (reduce) {
|
|
let obj = { path: null };
|
|
obj[0] = reduce;
|
|
obj = outer1_7({}, path.props, obj);
|
|
pathname = pathname.pathname;
|
|
closure_1 = undefined;
|
|
match = undefined;
|
|
pathname = undefined;
|
|
if (undefined === obj) {
|
|
obj = {};
|
|
}
|
|
let tmp4 = typeof obj !== "string";
|
|
if (typeof obj !== "string") {
|
|
const _Array = Array;
|
|
tmp4 = !Array.isArray(obj);
|
|
}
|
|
let tmp5 = obj;
|
|
if (!tmp4) {
|
|
obj = { path: null };
|
|
obj[0] = obj;
|
|
tmp5 = obj;
|
|
}
|
|
({ path, exact } = tmp5);
|
|
closure_1 = undefined !== exact && exact;
|
|
const strict = tmp5.strict;
|
|
match = undefined !== strict && strict;
|
|
const sensitive = tmp5.sensitive;
|
|
pathname = undefined !== sensitive && sensitive;
|
|
let items = [];
|
|
const combined = items.concat(path);
|
|
reduce = combined.reduce;
|
|
match = reduce((arg0, arg1) => {
|
|
let keys;
|
|
let regexp;
|
|
if (!arg1) {
|
|
if ("" !== arg1) {
|
|
return null;
|
|
}
|
|
}
|
|
if (arg0) {
|
|
return arg0;
|
|
} else {
|
|
let obj = { end: null, strict: null, sensitive: null };
|
|
obj[0] = closure_1;
|
|
obj[1] = match;
|
|
obj[2] = closure_3;
|
|
const sum = "" + obj.end + obj.strict + obj.sensitive;
|
|
let tmp7 = outer1_17[sum];
|
|
if (!tmp7) {
|
|
obj = {};
|
|
tmp6[sum] = obj;
|
|
tmp7 = obj;
|
|
}
|
|
if (tmp7[arg1]) {
|
|
let tmp10 = tmp7[arg1];
|
|
} else {
|
|
const items = [];
|
|
obj = { regexp: null, keys: null };
|
|
obj[0] = outer1_5(arg1, items, obj);
|
|
obj[1] = items;
|
|
tmp10 = obj;
|
|
if (outer1_18 < 10000) {
|
|
tmp7[arg1] = obj;
|
|
outer1_18 = outer1_18 + 1;
|
|
tmp10 = obj;
|
|
}
|
|
}
|
|
({ regexp, keys } = tmp10);
|
|
match = regexp.exec(closure_0);
|
|
if (match) {
|
|
const first = match[0];
|
|
closure_0 = match.slice(1);
|
|
if (!tmp2) {
|
|
const obj1 = { path: null, url: null, isExact: null, params: null };
|
|
obj1[0] = arg1;
|
|
let str2 = "/";
|
|
if ("/" !== arg1) {
|
|
str2 = first;
|
|
}
|
|
obj1[1] = str2;
|
|
obj1[2] = tmp15;
|
|
obj1[3] = keys.reduce((arg0, name) => {
|
|
arg0[name.name] = table[arg2];
|
|
return arg0;
|
|
}, {});
|
|
let tmp16 = obj1;
|
|
} else {
|
|
tmp16 = null;
|
|
}
|
|
return tmp16;
|
|
} else {
|
|
return null;
|
|
}
|
|
const tmp12 = closure_0;
|
|
tmp2 = closure_1;
|
|
}
|
|
}, null);
|
|
} else {
|
|
match = pathname.match;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
let cloneElementResult = null;
|
|
if (closure_2) {
|
|
obj = { location: null, computedMatch: null };
|
|
obj[0] = _location;
|
|
obj[1] = closure_2;
|
|
cloneElementResult = obj.cloneElement(closure_1, obj);
|
|
}
|
|
return cloneElementResult;
|
|
});
|
|
}
|
|
}
|
|
e.prototype = Object.create(Component6.prototype);
|
|
e.prototype.constructor = e;
|
|
_setPrototypeOf(e, Component6);
|
|
const useContext = noop.useContext;
|
|
|
|
export const MemoryRouter = t;
|
|
export const Prompt = function Prompt(arg0) {
|
|
let Component6;
|
|
let when;
|
|
({ message: Component6, when } = arg0);
|
|
let closure_1 = undefined === when || when;
|
|
return <tmp9Result2.Consumer>{(staticContext) => {
|
|
if (!staticContext) {
|
|
outer1_4(false);
|
|
}
|
|
if (closure_1) {
|
|
if (!staticContext.staticContext) {
|
|
const block = staticContext.history.block;
|
|
const obj = { onMount: null, onUpdate: null, onUnmount: null, message: null };
|
|
obj[0] = function onMount(arg0) {
|
|
arg0.release = block(block);
|
|
};
|
|
obj[1] = function onUpdate(release, message) {
|
|
if (message.message !== block) {
|
|
release.release();
|
|
release.release = block(tmp);
|
|
}
|
|
};
|
|
obj[2] = function onUnmount(cellKey, arg1, arg2) {
|
|
cellKey.release();
|
|
};
|
|
obj[3] = block;
|
|
return <outer1_14 onMount={null} onUpdate={null} onUnmount={null} message={null} />;
|
|
}
|
|
}
|
|
return null;
|
|
}}</tmp9Result2.Consumer>;
|
|
};
|
|
export const Redirect = function Redirect(arg0) {
|
|
let Component6;
|
|
let closure_1;
|
|
let push;
|
|
({ computedMatch: Component6, to: closure_1, push } = arg0);
|
|
const noop = undefined !== push && push;
|
|
return <tmp9Result2.Consumer>{(history) => {
|
|
if (!history) {
|
|
outer1_4(false);
|
|
}
|
|
history = history.history;
|
|
const tmp3 = React ? history.push : history.replace;
|
|
let closure_0 = tmp3;
|
|
outer1_0(outer1_1[7]);
|
|
let tmp6 = closure_0;
|
|
if (closure_0) {
|
|
if (typeof tmp7 === "string") {
|
|
let params = tmp6.params;
|
|
let str3 = tmp7;
|
|
if (undefined === tmp7) {
|
|
str3 = "/";
|
|
}
|
|
if (undefined === params) {
|
|
params = {};
|
|
}
|
|
tmp6 = str3;
|
|
if ("/" === str3) {
|
|
let tmp30Result = tmp6;
|
|
} else {
|
|
let obj = outer1_15;
|
|
if (outer1_15[str3]) {
|
|
let tmp20 = obj[str3];
|
|
} else {
|
|
const compileResult = outer1_5.compile(str3);
|
|
tmp20 = compileResult;
|
|
if (outer1_16 < 10000) {
|
|
obj[str3] = compileResult;
|
|
outer1_16 = outer1_16 + 1;
|
|
tmp20 = compileResult;
|
|
}
|
|
}
|
|
obj = { pretty: true };
|
|
tmp20(params, obj);
|
|
}
|
|
} else {
|
|
let str = tmp7.pathname;
|
|
let params1 = tmp6.params;
|
|
if (undefined === str) {
|
|
str = "/";
|
|
}
|
|
if (undefined === params1) {
|
|
params1 = {};
|
|
}
|
|
if ("/" === str) {
|
|
obj = { pathname: null };
|
|
obj[0] = str;
|
|
tmp30Result = tmp30({}, tmp7, obj);
|
|
} else {
|
|
let obj1 = outer1_15;
|
|
if (outer1_15[str]) {
|
|
let tmp13 = obj1[str];
|
|
} else {
|
|
const compileResult1 = outer1_5.compile(str);
|
|
tmp13 = compileResult1;
|
|
if (outer1_16 < 10000) {
|
|
obj1[str] = compileResult1;
|
|
outer1_16 = outer1_16 + 1;
|
|
tmp13 = compileResult1;
|
|
}
|
|
}
|
|
obj1 = { pretty: true };
|
|
tmp13(params1, obj1);
|
|
}
|
|
tmp30 = outer1_7;
|
|
}
|
|
} else {
|
|
const tmp5Result = tmp5(tmp7);
|
|
let closure_1 = tmp5Result;
|
|
if (history.staticContext) {
|
|
tmp3(tmp5Result);
|
|
let element = null;
|
|
} else {
|
|
const obj2 = { onMount: null, onUpdate: null, to: null };
|
|
obj2[0] = function onMount() {
|
|
tmp3(closure_1);
|
|
};
|
|
obj2[1] = function onUpdate(arg0, to) {
|
|
let obj = tmp3(tmp5Result[7]);
|
|
const _location = obj.createLocation(to.to);
|
|
obj = { key: _location.key };
|
|
if (!obj2.locationsAreEqual(_location, outer1_7({}, tmp5Result, obj))) {
|
|
tmp3(tmp5Result);
|
|
}
|
|
};
|
|
obj2[2] = tmp7;
|
|
element = <outer1_14 onMount={null} onUpdate={null} to={null} />;
|
|
}
|
|
return element;
|
|
}
|
|
}}</tmp9Result2.Consumer>;
|
|
};
|
|
export const Route = e;
|
|
export const Router = t;
|
|
export const StaticRouter = t;
|
|
export const Switch = e;
|
|
export const __HistoryContext = tmp9Result;
|
|
export const __RouterContext = tmp9Result;
|
|
export { generatePath };
|
|
export { matchPath };
|
|
export const useHistory = function useHistory() {
|
|
return useContext(closure_11);
|
|
};
|
|
export { useLocation };
|
|
export const useParams = function useParams() {
|
|
const match = useContext(closure_12).match;
|
|
return match ? match.params : {};
|
|
};
|
|
export const useRouteMatch = function useRouteMatch(Routes) {
|
|
let obj = Routes;
|
|
let match = useContext(closure_12).match;
|
|
if (Routes) {
|
|
const pathname = useContext(closure_12).location.pathname;
|
|
let c1;
|
|
let closure_2;
|
|
let closure_3;
|
|
if (undefined === obj) {
|
|
obj = {};
|
|
}
|
|
let tmp = typeof obj !== "string";
|
|
if (typeof obj !== "string") {
|
|
const _Array = Array;
|
|
tmp = !Array.isArray(obj);
|
|
}
|
|
let tmp2 = obj;
|
|
if (!tmp) {
|
|
obj = { path: null };
|
|
obj[0] = obj;
|
|
tmp2 = obj;
|
|
}
|
|
const exact = tmp2.exact;
|
|
let tmp3 = undefined !== exact;
|
|
if (tmp3) {
|
|
tmp3 = exact;
|
|
}
|
|
c1 = tmp3;
|
|
const strict = tmp2.strict;
|
|
closure_2 = undefined !== strict && strict;
|
|
const sensitive = tmp2.sensitive;
|
|
closure_3 = undefined !== sensitive && sensitive;
|
|
const items = [];
|
|
const combined = items.concat(tmp2.path);
|
|
match = combined.reduce((arg0, arg1) => {
|
|
let keys;
|
|
let regexp;
|
|
if (!arg1) {
|
|
if ("" !== arg1) {
|
|
return null;
|
|
}
|
|
}
|
|
if (arg0) {
|
|
return arg0;
|
|
} else {
|
|
let obj = { end: null, strict: null, sensitive: null };
|
|
obj[0] = closure_1;
|
|
obj[1] = match;
|
|
obj[2] = closure_3;
|
|
const sum = "" + obj.end + obj.strict + obj.sensitive;
|
|
let tmp7 = outer1_17[sum];
|
|
if (!tmp7) {
|
|
obj = {};
|
|
tmp6[sum] = obj;
|
|
tmp7 = obj;
|
|
}
|
|
if (tmp7[arg1]) {
|
|
let tmp10 = tmp7[arg1];
|
|
} else {
|
|
const items = [];
|
|
obj = { regexp: null, keys: null };
|
|
obj[0] = outer1_5(arg1, items, obj);
|
|
obj[1] = items;
|
|
tmp10 = obj;
|
|
if (outer1_18 < 10000) {
|
|
tmp7[arg1] = obj;
|
|
outer1_18 = outer1_18 + 1;
|
|
tmp10 = obj;
|
|
}
|
|
}
|
|
({ regexp, keys } = tmp10);
|
|
match = regexp.exec(closure_0);
|
|
if (match) {
|
|
const first = match[0];
|
|
closure_0 = match.slice(1);
|
|
if (!tmp2) {
|
|
const obj1 = { path: null, url: null, isExact: null, params: null };
|
|
obj1[0] = arg1;
|
|
let str2 = "/";
|
|
if ("/" !== arg1) {
|
|
str2 = first;
|
|
}
|
|
obj1[1] = str2;
|
|
obj1[2] = tmp15;
|
|
obj1[3] = keys.reduce((arg0, name) => {
|
|
arg0[name.name] = table[arg2];
|
|
return arg0;
|
|
}, {});
|
|
let tmp16 = obj1;
|
|
} else {
|
|
tmp16 = null;
|
|
}
|
|
return tmp16;
|
|
} else {
|
|
return null;
|
|
}
|
|
const tmp12 = closure_0;
|
|
tmp2 = closure_1;
|
|
}
|
|
}, null);
|
|
}
|
|
return match;
|
|
};
|
|
export const withRouter = function withRouter(displayName) {
|
|
let closure_0 = displayName;
|
|
const fn = function t(wrappedComponentRef) {
|
|
wrappedComponentRef = wrappedComponentRef.wrappedComponentRef;
|
|
const items = ["wrappedComponentRef"];
|
|
if (null == wrappedComponentRef) {
|
|
let obj = {};
|
|
} else {
|
|
obj = {};
|
|
const _Object = Object;
|
|
const keys = Object.keys(wrappedComponentRef);
|
|
for (let num3 = 0; num3 < keys.length; num3 = num3 + 1) {
|
|
let tmp2 = keys[num3];
|
|
let tmp3 = num3;
|
|
if (0 > items.indexOf(tmp2)) {
|
|
obj[tmp2] = wrappedComponentRef[tmp2];
|
|
}
|
|
}
|
|
}
|
|
return <outer1_12.Consumer>{(arg0) => {
|
|
if (!arg0) {
|
|
outer2_4(false);
|
|
}
|
|
const obj = { ref: wrappedComponentRef };
|
|
return <wrappedComponentRef {......outer2_7({}, obj, arg0, obj)} />;
|
|
}}</outer1_12.Consumer>;
|
|
};
|
|
fn.displayName = `withRouter(${displayName.displayName || displayName.name})`;
|
|
fn.WrappedComponent = displayName;
|
|
return getStatics(fn, displayName);
|
|
};
|