-
-
Save Nantris/7e56cdff8e88bfd1e7fbf4891874e448 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
this.wp = this.wp || {}, | |
this.wp.data = function(t) { | |
var e = {}; | |
function r(n) { | |
if (e[n]) | |
return e[n].exports; | |
var o = e[n] = { | |
i: n, | |
l: !1, | |
exports: {} | |
}; | |
return t[n].call(o.exports, o, o.exports, r), | |
o.l = !0, | |
o.exports | |
} | |
return r.m = t, | |
r.c = e, | |
r.d = function(t, e, n) { | |
r.o(t, e) || Object.defineProperty(t, e, { | |
enumerable: !0, | |
get: n | |
}) | |
} | |
, | |
r.r = function(t) { | |
"undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t, Symbol.toStringTag, { | |
value: "Module" | |
}), | |
Object.defineProperty(t, "__esModule", { | |
value: !0 | |
}) | |
} | |
, | |
r.t = function(t, e) { | |
if (1 & e && (t = r(t)), | |
8 & e) | |
return t; | |
if (4 & e && "object" == typeof t && t && t.__esModule) | |
return t; | |
var n = Object.create(null); | |
if (r.r(n), | |
Object.defineProperty(n, "default", { | |
enumerable: !0, | |
value: t | |
}), | |
2 & e && "string" != typeof t) | |
for (var o in t) | |
r.d(n, o, function(e) { | |
return t[e] | |
} | |
.bind(null, o)); | |
return n | |
} | |
, | |
r.n = function(t) { | |
var e = t && t.__esModule ? function() { | |
return t.default | |
} | |
: function() { | |
return t | |
} | |
; | |
return r.d(e, "a", e), | |
e | |
} | |
, | |
r.o = function(t, e) { | |
return Object.prototype.hasOwnProperty.call(t, e) | |
} | |
, | |
r.p = "", | |
r(r.s = 348) | |
}({ | |
0: function(t, e) { | |
!function() { | |
t.exports = this.wp.element | |
}() | |
}, | |
10: function(t, e, r) { | |
"use strict"; | |
function n(t, e, r) { | |
return e in t ? Object.defineProperty(t, e, { | |
value: r, | |
enumerable: !0, | |
configurable: !0, | |
writable: !0 | |
}) : t[e] = r, | |
t | |
} | |
r.d(e, "a", (function() { | |
return n | |
} | |
)) | |
}, | |
111: function(t, e) { | |
t.exports = function(t) { | |
var e, r = Object.keys(t); | |
return e = function() { | |
var t, e, n; | |
for (t = "return {", | |
e = 0; e < r.length; e++) | |
t += (n = JSON.stringify(r[e])) + ":r[" + n + "](s[" + n + "],a),"; | |
return t += "}", | |
new Function("r,s,a",t) | |
}(), | |
function(n, o) { | |
var i, u, c; | |
if (void 0 === n) | |
return e(t, {}, o); | |
for (i = e(t, n, o), | |
u = r.length; u--; ) | |
if (n[c = r[u]] !== i[c]) | |
return i; | |
return n | |
} | |
} | |
}, | |
145: function(t, e, r) { | |
"use strict"; | |
(function(t, n) { | |
var o, i = r(229); | |
o = "undefined" != typeof self ? self : "undefined" != typeof window ? window : void 0 !== t ? t : n; | |
var u = Object(i.a)(o); | |
e.a = u | |
} | |
).call(this, r(65), r(318)(t)) | |
}, | |
17: function(t, e, r) { | |
"use strict"; | |
var n = r(30); | |
function o(t) { | |
return function(t) { | |
if (Array.isArray(t)) { | |
for (var e = 0, r = new Array(t.length); e < t.length; e++) | |
r[e] = t[e]; | |
return r | |
} | |
}(t) || Object(n.a)(t) || function() { | |
throw new TypeError("Invalid attempt to spread non-iterable instance") | |
}() | |
} | |
r.d(e, "a", (function() { | |
return o | |
} | |
)) | |
}, | |
18: function(t, e, r) { | |
"use strict"; | |
function n() { | |
return (n = Object.assign || function(t) { | |
for (var e = 1; e < arguments.length; e++) { | |
var r = arguments[e]; | |
for (var n in r) | |
Object.prototype.hasOwnProperty.call(r, n) && (t[n] = r[n]) | |
} | |
return t | |
} | |
).apply(this, arguments) | |
} | |
r.d(e, "a", (function() { | |
return n | |
} | |
)) | |
}, | |
2: function(t, e) { | |
!function() { | |
t.exports = this.lodash | |
}() | |
}, | |
20: function(t, e, r) { | |
t.exports = r(47) | |
}, | |
228: function(t, e) { | |
!function() { | |
t.exports = this.wp.reduxRoutine | |
}() | |
}, | |
229: function(t, e, r) { | |
"use strict"; | |
function n(t) { | |
var e, r = t.Symbol; | |
return "function" == typeof r ? r.observable ? e = r.observable : (e = r("observable"), | |
r.observable = e) : e = "@@observable", | |
e | |
} | |
r.d(e, "a", (function() { | |
return n | |
} | |
)) | |
}, | |
23: function(t, e, r) { | |
"use strict"; | |
var n = r(38); | |
var o = r(39); | |
function i(t, e) { | |
return Object(n.a)(t) || function(t, e) { | |
var r = [] | |
, n = !0 | |
, o = !1 | |
, i = void 0; | |
try { | |
for (var u, c = t[Symbol.iterator](); !(n = (u = c.next()).done) && (r.push(u.value), | |
!e || r.length !== e); n = !0) | |
; | |
} catch (t) { | |
o = !0, | |
i = t | |
} finally { | |
try { | |
n || null == c.return || c.return() | |
} finally { | |
if (o) | |
throw i | |
} | |
} | |
return r | |
}(t, e) || Object(o.a)() | |
} | |
r.d(e, "a", (function() { | |
return i | |
} | |
)) | |
}, | |
230: function(t, e) { | |
!function() { | |
t.exports = this.wp.priorityQueue | |
}() | |
}, | |
30: function(t, e, r) { | |
"use strict"; | |
function n(t) { | |
if (Symbol.iterator in Object(t) || "[object Arguments]" === Object.prototype.toString.call(t)) | |
return Array.from(t) | |
} | |
r.d(e, "a", (function() { | |
return n | |
} | |
)) | |
}, | |
318: function(t, e) { | |
t.exports = function(t) { | |
if (!t.webpackPolyfill) { | |
var e = Object.create(t); | |
e.children || (e.children = []), | |
Object.defineProperty(e, "loaded", { | |
enumerable: !0, | |
get: function() { | |
return e.l | |
} | |
}), | |
Object.defineProperty(e, "id", { | |
enumerable: !0, | |
get: function() { | |
return e.i | |
} | |
}), | |
Object.defineProperty(e, "exports", { | |
enumerable: !0 | |
}), | |
e.webpackPolyfill = 1 | |
} | |
return e | |
} | |
}, | |
348: function(t, e, r) { | |
"use strict"; | |
r.r(e); | |
var n = {}; | |
r.r(n), | |
r.d(n, "getIsResolving", (function() { | |
return F | |
} | |
)), | |
r.d(n, "hasStartedResolution", (function() { | |
return M | |
} | |
)), | |
r.d(n, "hasFinishedResolution", (function() { | |
return U | |
} | |
)), | |
r.d(n, "isResolving", (function() { | |
return V | |
} | |
)), | |
r.d(n, "getCachedResolvers", (function() { | |
return G | |
} | |
)); | |
var o = {}; | |
r.r(o), | |
r.d(o, "startResolution", (function() { | |
return H | |
} | |
)), | |
r.d(o, "finishResolution", (function() { | |
return W | |
} | |
)), | |
r.d(o, "invalidateResolution", (function() { | |
return Y | |
} | |
)), | |
r.d(o, "invalidateResolutionForStore", (function() { | |
return X | |
} | |
)), | |
r.d(o, "invalidateResolutionForStoreSelector", (function() { | |
return J | |
} | |
)); | |
var i = {}; | |
r.r(i), | |
r.d(i, "controls", (function() { | |
return nt | |
} | |
)), | |
r.d(i, "persistence", (function() { | |
return lt | |
} | |
)); | |
var u = r(111) | |
, c = r.n(u) | |
, a = r(23) | |
, s = r(7) | |
, f = r(2) | |
, l = r(20) | |
, p = r.n(l) | |
, h = r(43) | |
, d = r(145) | |
, v = function() { | |
return Math.random().toString(36).substring(7).split("").join(".") | |
} | |
, y = { | |
INIT: "@@redux/INIT" + v(), | |
REPLACE: "@@redux/REPLACE" + v(), | |
PROBE_UNKNOWN_ACTION: function() { | |
return "@@redux/PROBE_UNKNOWN_ACTION" + v() | |
} | |
}; | |
function b(t) { | |
if ("object" != typeof t || null === t) | |
return !1; | |
for (var e = t; null !== Object.getPrototypeOf(e); ) | |
e = Object.getPrototypeOf(e); | |
return Object.getPrototypeOf(t) === e | |
} | |
function g(t, e, r) { | |
var n; | |
if ("function" == typeof e && "function" == typeof r || "function" == typeof r && "function" == typeof arguments[3]) | |
throw new Error("It looks like you are passing several store enhancers to createStore(). This is not supported. Instead, compose them together to a single function."); | |
if ("function" == typeof e && void 0 === r && (r = e, | |
e = void 0), | |
void 0 !== r) { | |
if ("function" != typeof r) | |
throw new Error("Expected the enhancer to be a function."); | |
return r(g)(t, e) | |
} | |
if ("function" != typeof t) | |
throw new Error("Expected the reducer to be a function."); | |
var o = t | |
, i = e | |
, u = [] | |
, c = u | |
, a = !1; | |
function s() { | |
c === u && (c = u.slice()) | |
} | |
function f() { | |
if (a) | |
throw new Error("You may not call store.getState() while the reducer is executing. The reducer has already received the state as an argument. Pass it down from the top reducer instead of reading it from the store."); | |
return i | |
} | |
function l(t) { | |
if ("function" != typeof t) | |
throw new Error("Expected the listener to be a function."); | |
if (a) | |
throw new Error("You may not call store.subscribe() while the reducer is executing. If you would like to be notified after the store has been updated, subscribe from a component and invoke store.getState() in the callback to access the latest state. See https://redux.js.org/api-reference/store#subscribe(listener) for more details."); | |
var e = !0; | |
return s(), | |
c.push(t), | |
function() { | |
if (e) { | |
if (a) | |
throw new Error("You may not unsubscribe from a store listener while the reducer is executing. See https://redux.js.org/api-reference/store#subscribe(listener) for more details."); | |
e = !1, | |
s(); | |
var r = c.indexOf(t); | |
c.splice(r, 1) | |
} | |
} | |
} | |
function p(t) { | |
if (!b(t)) | |
throw new Error("Actions must be plain objects. Use custom middleware for async actions."); | |
if (void 0 === t.type) | |
throw new Error('Actions may not have an undefined "type" property. Have you misspelled a constant?'); | |
if (a) | |
throw new Error("Reducers may not dispatch actions."); | |
try { | |
a = !0, | |
i = o(i, t) | |
} finally { | |
a = !1 | |
} | |
for (var e = u = c, r = 0; r < e.length; r++) { | |
(0, | |
e[r])() | |
} | |
return t | |
} | |
return p({ | |
type: y.INIT | |
}), | |
(n = { | |
dispatch: p, | |
subscribe: l, | |
getState: f, | |
replaceReducer: function(t) { | |
if ("function" != typeof t) | |
throw new Error("Expected the nextReducer to be a function."); | |
o = t, | |
p({ | |
type: y.REPLACE | |
}) | |
} | |
})[d.a] = function() { | |
var t, e = l; | |
return (t = { | |
subscribe: function(t) { | |
if ("object" != typeof t || null === t) | |
throw new TypeError("Expected the observer to be an object."); | |
function r() { | |
t.next && t.next(f()) | |
} | |
return r(), | |
{ | |
unsubscribe: e(r) | |
} | |
} | |
})[d.a] = function() { | |
return this | |
} | |
, | |
t | |
} | |
, | |
n | |
} | |
function O(t, e, r) { | |
return e in t ? Object.defineProperty(t, e, { | |
value: r, | |
enumerable: !0, | |
configurable: !0, | |
writable: !0 | |
}) : t[e] = r, | |
t | |
} | |
function w(t, e) { | |
var r = Object.keys(t); | |
return Object.getOwnPropertySymbols && r.push.apply(r, Object.getOwnPropertySymbols(t)), | |
e && (r = r.filter((function(e) { | |
return Object.getOwnPropertyDescriptor(t, e).enumerable | |
} | |
))), | |
r | |
} | |
function m(t) { | |
for (var e = 1; e < arguments.length; e++) { | |
var r = null != arguments[e] ? arguments[e] : {}; | |
e % 2 ? w(r, !0).forEach((function(e) { | |
O(t, e, r[e]) | |
} | |
)) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) : w(r).forEach((function(e) { | |
Object.defineProperty(t, e, Object.getOwnPropertyDescriptor(r, e)) | |
} | |
)) | |
} | |
return t | |
} | |
function j() { | |
for (var t = arguments.length, e = new Array(t), r = 0; r < t; r++) | |
e[r] = arguments[r]; | |
return 0 === e.length ? function(t) { | |
return t | |
} | |
: 1 === e.length ? e[0] : e.reduce((function(t, e) { | |
return function() { | |
return t(e.apply(void 0, arguments)) | |
} | |
} | |
)) | |
} | |
function S() { | |
for (var t = arguments.length, e = new Array(t), r = 0; r < t; r++) | |
e[r] = arguments[r]; | |
return function(t) { | |
return function() { | |
var r = t.apply(void 0, arguments) | |
, n = function() { | |
throw new Error("Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch.") | |
} | |
, o = { | |
getState: r.getState, | |
dispatch: function() { | |
return n.apply(void 0, arguments) | |
} | |
} | |
, i = e.map((function(t) { | |
return t(o) | |
} | |
)); | |
return m({}, r, { | |
dispatch: n = j.apply(void 0, i)(r.dispatch) | |
}) | |
} | |
} | |
} | |
var E, _ = r(228), R = r.n(_), x = r(98), T = r.n(x), I = function() { | |
return function(t) { | |
return function(e) { | |
return T()(e) ? e.then((function(e) { | |
if (e) | |
return t(e) | |
} | |
)) : t(e) | |
} | |
} | |
}, L = r(17), A = function(t, e) { | |
return function() { | |
return function(r) { | |
return function(n) { | |
var o = t.select("core/data").getCachedResolvers(e); | |
return Object.entries(o).forEach((function(r) { | |
var o = Object(a.a)(r, 2) | |
, i = o[0] | |
, u = o[1] | |
, c = Object(f.get)(t.stores, [e, "resolvers", i]); | |
c && c.shouldInvalidate && u.forEach((function(r, o) { | |
!1 === r && c.shouldInvalidate.apply(c, [n].concat(Object(L.a)(o))) && t.dispatch("core/data").invalidateResolution(e, i, o) | |
} | |
)) | |
} | |
)), | |
r(n) | |
} | |
} | |
} | |
}, N = r(74), P = r.n(N), k = r(10), C = Object(f.flowRight)([(E = "selectorName", | |
function(t) { | |
return function() { | |
var e = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {} | |
, r = arguments.length > 1 ? arguments[1] : void 0 | |
, n = r[E]; | |
if (void 0 === n) | |
return e; | |
var o = t(e[n], r); | |
return o === e[n] ? e : Object(s.a)({}, e, Object(k.a)({}, n, o)) | |
} | |
} | |
)])((function() { | |
var t = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : new P.a | |
, e = arguments.length > 1 ? arguments[1] : void 0; | |
switch (e.type) { | |
case "START_RESOLUTION": | |
case "FINISH_RESOLUTION": | |
var r = "START_RESOLUTION" === e.type | |
, n = new P.a(t); | |
return n.set(e.args, r), | |
n; | |
case "INVALIDATE_RESOLUTION": | |
var o = new P.a(t); | |
return o.delete(e.args), | |
o | |
} | |
return t | |
} | |
)), D = function() { | |
var t = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {} | |
, e = arguments.length > 1 ? arguments[1] : void 0; | |
switch (e.type) { | |
case "INVALIDATE_RESOLUTION_FOR_STORE": | |
return {}; | |
case "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR": | |
return Object(f.has)(t, [e.selectorName]) ? Object(f.omit)(t, [e.selectorName]) : t; | |
case "START_RESOLUTION": | |
case "FINISH_RESOLUTION": | |
case "INVALIDATE_RESOLUTION": | |
return C(t, e) | |
} | |
return t | |
}; | |
function F(t, e, r) { | |
var n = Object(f.get)(t, [e]); | |
if (n) | |
return n.get(r) | |
} | |
function M(t, e) { | |
return void 0 !== F(t, e, arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : []) | |
} | |
function U(t, e) { | |
return !1 === F(t, e, arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : []) | |
} | |
function V(t, e) { | |
return !0 === F(t, e, arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : []) | |
} | |
function G(t) { | |
return t | |
} | |
function H(t, e) { | |
return { | |
type: "START_RESOLUTION", | |
selectorName: t, | |
args: e | |
} | |
} | |
function W(t, e) { | |
return { | |
type: "FINISH_RESOLUTION", | |
selectorName: t, | |
args: e | |
} | |
} | |
function Y(t, e) { | |
return { | |
type: "INVALIDATE_RESOLUTION", | |
selectorName: t, | |
args: e | |
} | |
} | |
function X() { | |
return { | |
type: "INVALIDATE_RESOLUTION_FOR_STORE" | |
} | |
} | |
function J(t) { | |
return { | |
type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR", | |
selectorName: t | |
} | |
} | |
function K(t, e, r) { | |
var i, u = e.reducer, a = function(t, e, r) { | |
var n = [A(r, t), I]; | |
if (e.controls) { | |
var o = Object(f.mapValues)(e.controls, (function(t) { | |
return t.isRegistryControl ? t(r) : t | |
} | |
)); | |
n.push(R()(o)) | |
} | |
var i = [S.apply(void 0, n)]; | |
"undefined" != typeof window && window.__REDUX_DEVTOOLS_EXTENSION__ && i.push(window.__REDUX_DEVTOOLS_EXTENSION__({ | |
name: t, | |
instanceId: t | |
})); | |
var u = e.reducer | |
, a = e.initialState; | |
return g(c()({ | |
metadata: D, | |
root: u | |
}), { | |
root: a | |
}, Object(f.flowRight)(i)) | |
}(t, e, r), l = function(t, e) { | |
return Object(f.mapValues)(t, (function(t) { | |
return function() { | |
return Promise.resolve(e.dispatch(t.apply(void 0, arguments))) | |
} | |
} | |
)) | |
}(Object(s.a)({}, o, e.actions), a), d = function(t, e) { | |
return Object(f.mapValues)(t, (function(t) { | |
var r = function() { | |
var r = arguments.length | |
, n = new Array(r + 1); | |
n[0] = e.__unstableOriginalGetState(); | |
for (var o = 0; o < r; o++) | |
n[o + 1] = arguments[o]; | |
return t.apply(void 0, n) | |
}; | |
return r.hasResolver = !1, | |
r | |
} | |
)) | |
}(Object(s.a)({}, Object(f.mapValues)(n, (function(t) { | |
return function(e) { | |
for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), o = 1; o < r; o++) | |
n[o - 1] = arguments[o]; | |
return t.apply(void 0, [e.metadata].concat(n)) | |
} | |
} | |
)), Object(f.mapValues)(e.selectors, (function(t) { | |
return t.isRegistrySelector && (t.registry = r), | |
function(e) { | |
for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), o = 1; o < r; o++) | |
n[o - 1] = arguments[o]; | |
return t.apply(void 0, [e.root].concat(n)) | |
} | |
} | |
))), a); | |
if (e.resolvers) { | |
var v = function(t, e, r) { | |
var n = Object(f.mapValues)(t, (function(t) { | |
var e = t.fulfill | |
, r = void 0 === e ? t : e; | |
return Object(s.a)({}, t, { | |
fulfill: r | |
}) | |
} | |
)); | |
return { | |
resolvers: n, | |
selectors: Object(f.mapValues)(e, (function(e, o) { | |
var i = t[o]; | |
if (!i) | |
return e.hasResolver = !1, | |
e; | |
var u = function() { | |
for (var t = arguments.length, u = new Array(t), c = 0; c < t; c++) | |
u[c] = arguments[c]; | |
function a() { | |
return s.apply(this, arguments) | |
} | |
function s() { | |
return (s = Object(h.a)(p.a.mark((function t() { | |
var e, c; | |
return p.a.wrap((function(t) { | |
for (; ; ) | |
switch (t.prev = t.next) { | |
case 0: | |
if (e = r.getState(), | |
"function" != typeof i.isFulfilled || !i.isFulfilled.apply(i, [e].concat(u))) { | |
t.next = 3; | |
break | |
} | |
return t.abrupt("return"); | |
case 3: | |
if (c = r.__unstableOriginalGetState(), | |
!M(c.metadata, o, u)) { | |
t.next = 6; | |
break | |
} | |
return t.abrupt("return"); | |
case 6: | |
return r.dispatch(H(o, u)), | |
t.next = 9, | |
q.apply(void 0, [r, n, o].concat(u)); | |
case 9: | |
r.dispatch(W(o, u)); | |
case 10: | |
case "end": | |
return t.stop() | |
} | |
} | |
), t) | |
} | |
)))).apply(this, arguments) | |
} | |
return a.apply(void 0, u), | |
e.apply(void 0, u) | |
}; | |
return u.hasResolver = !0, | |
u | |
} | |
)) | |
} | |
}(e.resolvers, d, a); | |
i = v.resolvers, | |
d = v.selectors | |
} | |
a.__unstableOriginalGetState = a.getState, | |
a.getState = function() { | |
return a.__unstableOriginalGetState().root | |
} | |
; | |
var y = a && function(t) { | |
var e = a.__unstableOriginalGetState(); | |
a.subscribe((function() { | |
var r = a.__unstableOriginalGetState() | |
, n = r !== e; | |
e = r, | |
n && t() | |
} | |
)) | |
} | |
; | |
return { | |
reducer: u, | |
store: a, | |
actions: l, | |
selectors: d, | |
resolvers: i, | |
getSelectors: function() { | |
return d | |
}, | |
getActions: function() { | |
return l | |
}, | |
subscribe: y | |
} | |
} | |
function q(t, e, r) { | |
return z.apply(this, arguments) | |
} | |
function z() { | |
return (z = Object(h.a)(p.a.mark((function t(e, r, n) { | |
var o, i, u, c, a, s = arguments; | |
return p.a.wrap((function(t) { | |
for (; ; ) | |
switch (t.prev = t.next) { | |
case 0: | |
if (o = Object(f.get)(r, [n])) { | |
t.next = 3; | |
break | |
} | |
return t.abrupt("return"); | |
case 3: | |
for (i = s.length, | |
u = new Array(i > 3 ? i - 3 : 0), | |
c = 3; c < i; c++) | |
u[c - 3] = s[c]; | |
if (!(a = o.fulfill.apply(o, u))) { | |
t.next = 8; | |
break | |
} | |
return t.next = 8, | |
e.dispatch(a); | |
case 8: | |
case "end": | |
return t.stop() | |
} | |
} | |
), t) | |
} | |
)))).apply(this, arguments) | |
} | |
var B = function(t) { | |
return { | |
getSelectors: function() { | |
return ["getIsResolving", "hasStartedResolution", "hasFinishedResolution", "isResolving", "getCachedResolvers"].reduce((function(e, r) { | |
return Object(s.a)({}, e, Object(k.a)({}, r, function(e) { | |
return function(r) { | |
for (var n, o = arguments.length, i = new Array(o > 1 ? o - 1 : 0), u = 1; u < o; u++) | |
i[u - 1] = arguments[u]; | |
return (n = t.select(r))[e].apply(n, i) | |
} | |
}(r))) | |
} | |
), {}) | |
}, | |
getActions: function() { | |
return ["startResolution", "finishResolution", "invalidateResolution", "invalidateResolutionForStore", "invalidateResolutionForStoreSelector"].reduce((function(e, r) { | |
return Object(s.a)({}, e, Object(k.a)({}, r, function(e) { | |
return function(r) { | |
for (var n, o = arguments.length, i = new Array(o > 1 ? o - 1 : 0), u = 1; u < o; u++) | |
i[u - 1] = arguments[u]; | |
return (n = t.dispatch(r))[e].apply(n, i) | |
} | |
}(r))) | |
} | |
), {}) | |
}, | |
subscribe: function() { | |
return function() {} | |
} | |
} | |
}; | |
function Q() { | |
var t = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {} | |
, e = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : null | |
, r = {} | |
, n = []; | |
function o() { | |
n.forEach((function(t) { | |
return t() | |
} | |
)) | |
} | |
function i(t, e) { | |
if ("function" != typeof e.getSelectors) | |
throw new TypeError("config.getSelectors must be a function"); | |
if ("function" != typeof e.getActions) | |
throw new TypeError("config.getActions must be a function"); | |
if ("function" != typeof e.subscribe) | |
throw new TypeError("config.subscribe must be a function"); | |
r[t] = e, | |
e.subscribe(o) | |
} | |
var u, c = { | |
registerGenericStore: i, | |
stores: r, | |
namespaces: r, | |
subscribe: function(t) { | |
return n.push(t), | |
function() { | |
n = Object(f.without)(n, t) | |
} | |
}, | |
select: function(t) { | |
var n = r[t]; | |
return n ? n.getSelectors() : e && e.select(t) | |
}, | |
dispatch: function(t) { | |
var n = r[t]; | |
return n ? n.getActions() : e && e.dispatch(t) | |
}, | |
use: function(t, e) { | |
return c = Object(s.a)({}, c, t(c, e)) | |
} | |
}; | |
return c.registerStore = function(t, e) { | |
if (!e.reducer) | |
throw new TypeError("Must specify store reducer"); | |
var r = K(t, e, c); | |
return i(t, r), | |
r.store | |
} | |
, | |
i("core/data", B(c)), | |
Object.entries(t).forEach((function(t) { | |
var e = Object(a.a)(t, 2) | |
, r = e[0] | |
, n = e[1]; | |
return c.registerStore(r, n) | |
} | |
)), | |
e && e.subscribe(o), | |
u = c, | |
Object(f.mapValues)(u, (function(t, e) { | |
return "function" != typeof t ? t : function() { | |
return c[e].apply(null, arguments) | |
} | |
} | |
)) | |
} | |
var Z, $, tt = Q(), et = r(37), rt = r.n(et), nt = function(t) { | |
return rt()("wp.data.plugins.controls", { | |
hint: "The controls plugins is now baked-in." | |
}), | |
t | |
}, ot = { | |
getItem: function(t) { | |
return Z && Z[t] ? Z[t] : null | |
}, | |
setItem: function(t, e) { | |
Z || ot.clear(), | |
Z[t] = String(e) | |
}, | |
clear: function() { | |
Z = Object.create(null) | |
} | |
}, it = ot; | |
try { | |
($ = window.localStorage).setItem("__wpDataTestLocalStorage", ""), | |
$.removeItem("__wpDataTestLocalStorage") | |
} catch (t) { | |
$ = it | |
} | |
var ut = $ | |
, ct = "WP_DATA" | |
, at = function(t) { | |
return function(e, r) { | |
return r.nextState === e ? e : t(e, r) | |
} | |
}; | |
function st(t) { | |
var e, r = t.storage, n = void 0 === r ? ut : r, o = t.storageKey, i = void 0 === o ? ct : o; | |
return { | |
get: function() { | |
if (void 0 === e) { | |
var t = n.getItem(i); | |
if (null === t) | |
e = {}; | |
else | |
try { | |
e = JSON.parse(t) | |
} catch (t) { | |
e = {} | |
} | |
} | |
return e | |
}, | |
set: function(t, r) { | |
e = Object(s.a)({}, e, Object(k.a)({}, t, r)), | |
n.setItem(i, JSON.stringify(e)) | |
} | |
} | |
} | |
var ft = function(t, e) { | |
var r = st(e); | |
return { | |
registerStore: function(e, n) { | |
if (!n.persist) | |
return t.registerStore(e, n); | |
var o = r.get()[e]; | |
if (void 0 !== o) { | |
var i = n.reducer(void 0, { | |
type: "@@WP/PERSISTENCE_RESTORE" | |
}); | |
i = Object(f.isPlainObject)(i) && Object(f.isPlainObject)(o) ? Object(f.merge)({}, i, o) : o, | |
n = Object(s.a)({}, n, { | |
initialState: i | |
}) | |
} | |
var u = t.registerStore(e, n); | |
return u.subscribe(function(t, e, n) { | |
var o; | |
if (Array.isArray(n)) { | |
var i = n.reduce((function(t, e) { | |
return Object.assign(t, Object(k.a)({}, e, (function(t, r) { | |
return r.nextState[e] | |
} | |
))) | |
} | |
), {}); | |
o = at(c()(i)) | |
} else | |
o = function(t, e) { | |
return e.nextState | |
} | |
; | |
var u = o(void 0, { | |
nextState: t() | |
}); | |
return function() { | |
var n = o(u, { | |
nextState: t() | |
}); | |
n !== u && (r.set(e, n), | |
u = n) | |
} | |
}(u.getState, e, n.persist)), | |
u | |
} | |
} | |
}; | |
ft.__unstableMigrate = function(t) { | |
var e = st(t) | |
, r = Object(f.get)(e.get(), ["core/editor", "preferences", "insertUsage"]); | |
r && e.set("core/block-editor", { | |
preferences: { | |
insertUsage: r | |
} | |
}) | |
} | |
; | |
var lt = ft | |
, pt = r(18) | |
, ht = r(0) | |
, dt = r(8) | |
, vt = r(230) | |
, yt = r(41) | |
, bt = r.n(yt) | |
, gt = Object(ht.createContext)(tt) | |
, Ot = gt.Consumer | |
, wt = gt.Provider | |
, mt = Ot | |
, jt = wt; | |
function St() { | |
return Object(ht.useContext)(gt) | |
} | |
var Et = Object(ht.createContext)(!1) | |
, _t = (Et.Consumer, | |
Et.Provider); | |
var Rt = "undefined" != typeof window ? ht.useLayoutEffect : ht.useEffect | |
, xt = Object(vt.createQueue)(); | |
function Tt(t, e) { | |
var r, n = Object(ht.useCallback)(t, e), o = St(), i = Object(ht.useContext)(Et), u = Object(ht.useMemo)((function() { | |
return { | |
queue: !0 | |
} | |
} | |
), [o]), c = Object(ht.useReducer)((function(t) { | |
return t + 1 | |
} | |
), 0), s = Object(a.a)(c, 2)[1], f = Object(ht.useRef)(), l = Object(ht.useRef)(i), p = Object(ht.useRef)(), h = Object(ht.useRef)(), d = Object(ht.useRef)(); | |
try { | |
r = f.current !== n || h.current ? n(o.select, o) : p.current | |
} catch (t) { | |
var v = "An error occurred while running 'mapSelect': ".concat(t.message); | |
if (h.current) | |
throw v += "\nThe error may be correlated with this previous error:\n", | |
v += "".concat(h.current.stack, "\n\n"), | |
v += "Original stack trace:", | |
new Error(v) | |
} | |
return Rt((function() { | |
f.current = n, | |
l.current !== i && (l.current = i, | |
xt.flush(u)), | |
p.current = r, | |
h.current = void 0, | |
d.current = !0 | |
} | |
)), | |
Rt((function() { | |
var t = function() { | |
if (d.current) { | |
try { | |
var t = f.current(o.select, o); | |
if (bt()(p.current, t)) | |
return; | |
p.current = t | |
} catch (t) { | |
h.current = t | |
} | |
s({}) | |
} | |
}; | |
l.current ? xt.add(u, t) : t(); | |
var e = o.subscribe((function() { | |
l.current ? xt.add(u, t) : t() | |
} | |
)); | |
return function() { | |
d.current = !1, | |
e(), | |
xt.flush(u) | |
} | |
} | |
), [o]), | |
r | |
} | |
var It = function(t) { | |
return Object(dt.createHigherOrderComponent)((function(e) { | |
return Object(dt.pure)((function(r) { | |
var n = Tt((function(e, n) { | |
return t(e, r, n) | |
} | |
)); | |
return Object(ht.createElement)(e, Object(pt.a)({}, r, n)) | |
} | |
)) | |
} | |
), "withSelect") | |
} | |
, Lt = function(t) { | |
var e = St().dispatch; | |
return void 0 === t ? e : e(t) | |
} | |
, At = "undefined" != typeof window ? ht.useLayoutEffect : ht.useEffect | |
, Nt = function(t, e) { | |
var r = St() | |
, n = Object(ht.useRef)(t); | |
return At((function() { | |
n.current = t | |
} | |
)), | |
Object(ht.useMemo)((function() { | |
var t = n.current(r.dispatch, r); | |
return Object(f.mapValues)(t, (function(t, e) { | |
return "function" != typeof t && console.warn("Property ".concat(e, " returned from dispatchMap in useDispatchWithMap must be a function.")), | |
function() { | |
var t; | |
return (t = n.current(r.dispatch, r))[e].apply(t, arguments) | |
} | |
} | |
)) | |
} | |
), [r].concat(Object(L.a)(e))) | |
} | |
, Pt = function(t) { | |
return Object(dt.createHigherOrderComponent)((function(e) { | |
return function(r) { | |
var n = Nt((function(e, n) { | |
return t(e, r, n) | |
} | |
), []); | |
return Object(ht.createElement)(e, Object(pt.a)({}, r, n)) | |
} | |
} | |
), "withDispatch") | |
} | |
, kt = Object(dt.createHigherOrderComponent)((function(t) { | |
return function(e) { | |
return Object(ht.createElement)(mt, null, (function(r) { | |
return Object(ht.createElement)(t, Object(pt.a)({}, e, { | |
registry: r | |
})) | |
} | |
)) | |
} | |
} | |
), "withRegistry"); | |
function Ct(t) { | |
var e = function e() { | |
return t(e.registry.select).apply(void 0, arguments) | |
}; | |
return e.isRegistrySelector = !0, | |
e.registry = tt, | |
e | |
} | |
function Dt(t) { | |
return t.isRegistryControl = !0, | |
t | |
} | |
r.d(e, "select", (function() { | |
return Ft | |
} | |
)), | |
r.d(e, "dispatch", (function() { | |
return Mt | |
} | |
)), | |
r.d(e, "subscribe", (function() { | |
return Ut | |
} | |
)), | |
r.d(e, "registerGenericStore", (function() { | |
return Vt | |
} | |
)), | |
r.d(e, "registerStore", (function() { | |
return Gt | |
} | |
)), | |
r.d(e, "use", (function() { | |
return Ht | |
} | |
)), | |
r.d(e, "withSelect", (function() { | |
return It | |
} | |
)), | |
r.d(e, "withDispatch", (function() { | |
return Pt | |
} | |
)), | |
r.d(e, "withRegistry", (function() { | |
return kt | |
} | |
)), | |
r.d(e, "RegistryProvider", (function() { | |
return jt | |
} | |
)), | |
r.d(e, "RegistryConsumer", (function() { | |
return mt | |
} | |
)), | |
r.d(e, "useRegistry", (function() { | |
return St | |
} | |
)), | |
r.d(e, "useSelect", (function() { | |
return Tt | |
} | |
)), | |
r.d(e, "useDispatch", (function() { | |
return Lt | |
} | |
)), | |
r.d(e, "__experimentalAsyncModeProvider", (function() { | |
return _t | |
} | |
)), | |
r.d(e, "createRegistry", (function() { | |
return Q | |
} | |
)), | |
r.d(e, "createRegistrySelector", (function() { | |
return Ct | |
} | |
)), | |
r.d(e, "createRegistryControl", (function() { | |
return Dt | |
} | |
)), | |
r.d(e, "plugins", (function() { | |
return i | |
} | |
)), | |
r.d(e, "combineReducers", (function() { | |
return c.a | |
} | |
)); | |
var Ft = tt.select | |
, Mt = tt.dispatch | |
, Ut = tt.subscribe | |
, Vt = tt.registerGenericStore | |
, Gt = tt.registerStore | |
, Ht = tt.use | |
}, | |
37: function(t, e) { | |
!function() { | |
t.exports = this.wp.deprecated | |
}() | |
}, | |
38: function(t, e, r) { | |
"use strict"; | |
function n(t) { | |
if (Array.isArray(t)) | |
return t | |
} | |
r.d(e, "a", (function() { | |
return n | |
} | |
)) | |
}, | |
39: function(t, e, r) { | |
"use strict"; | |
function n() { | |
throw new TypeError("Invalid attempt to destructure non-iterable instance") | |
} | |
r.d(e, "a", (function() { | |
return n | |
} | |
)) | |
}, | |
41: function(t, e) { | |
!function() { | |
t.exports = this.wp.isShallowEqual | |
}() | |
}, | |
43: function(t, e, r) { | |
"use strict"; | |
function n(t, e, r, n, o, i, u) { | |
try { | |
var c = t[i](u) | |
, a = c.value | |
} catch (t) { | |
return void r(t) | |
} | |
c.done ? e(a) : Promise.resolve(a).then(n, o) | |
} | |
function o(t) { | |
return function() { | |
var e = this | |
, r = arguments; | |
return new Promise((function(o, i) { | |
var u = t.apply(e, r); | |
function c(t) { | |
n(u, o, i, c, a, "next", t) | |
} | |
function a(t) { | |
n(u, o, i, c, a, "throw", t) | |
} | |
c(void 0) | |
} | |
)) | |
} | |
} | |
r.d(e, "a", (function() { | |
return o | |
} | |
)) | |
}, | |
47: function(t, e, r) { | |
var n = function(t) { | |
"use strict"; | |
var e, r = Object.prototype, n = r.hasOwnProperty, o = "function" == typeof Symbol ? Symbol : {}, i = o.iterator || "@@iterator", u = o.asyncIterator || "@@asyncIterator", c = o.toStringTag || "@@toStringTag"; | |
function a(t, e, r, n) { | |
var o = e && e.prototype instanceof v ? e : v | |
, i = Object.create(o.prototype) | |
, u = new x(n || []); | |
return i._invoke = function(t, e, r) { | |
var n = f; | |
return function(o, i) { | |
if (n === p) | |
throw new Error("Generator is already running"); | |
if (n === h) { | |
if ("throw" === o) | |
throw i; | |
return I() | |
} | |
for (r.method = o, | |
r.arg = i; ; ) { | |
var u = r.delegate; | |
if (u) { | |
var c = E(u, r); | |
if (c) { | |
if (c === d) | |
continue; | |
return c | |
} | |
} | |
if ("next" === r.method) | |
r.sent = r._sent = r.arg; | |
else if ("throw" === r.method) { | |
if (n === f) | |
throw n = h, | |
r.arg; | |
r.dispatchException(r.arg) | |
} else | |
"return" === r.method && r.abrupt("return", r.arg); | |
n = p; | |
var a = s(t, e, r); | |
if ("normal" === a.type) { | |
if (n = r.done ? h : l, | |
a.arg === d) | |
continue; | |
return { | |
value: a.arg, | |
done: r.done | |
} | |
} | |
"throw" === a.type && (n = h, | |
r.method = "throw", | |
r.arg = a.arg) | |
} | |
} | |
}(t, r, u), | |
i | |
} | |
function s(t, e, r) { | |
try { | |
return { | |
type: "normal", | |
arg: t.call(e, r) | |
} | |
} catch (t) { | |
return { | |
type: "throw", | |
arg: t | |
} | |
} | |
} | |
t.wrap = a; | |
var f = "suspendedStart" | |
, l = "suspendedYield" | |
, p = "executing" | |
, h = "completed" | |
, d = {}; | |
function v() {} | |
function y() {} | |
function b() {} | |
var g = {}; | |
g[i] = function() { | |
return this | |
} | |
; | |
var O = Object.getPrototypeOf | |
, w = O && O(O(T([]))); | |
w && w !== r && n.call(w, i) && (g = w); | |
var m = b.prototype = v.prototype = Object.create(g); | |
function j(t) { | |
["next", "throw", "return"].forEach((function(e) { | |
t[e] = function(t) { | |
return this._invoke(e, t) | |
} | |
} | |
)) | |
} | |
function S(t) { | |
var e; | |
this._invoke = function(r, o) { | |
function i() { | |
return new Promise((function(e, i) { | |
!function e(r, o, i, u) { | |
var c = s(t[r], t, o); | |
if ("throw" !== c.type) { | |
var a = c.arg | |
, f = a.value; | |
return f && "object" == typeof f && n.call(f, "__await") ? Promise.resolve(f.__await).then((function(t) { | |
e("next", t, i, u) | |
} | |
), (function(t) { | |
e("throw", t, i, u) | |
} | |
)) : Promise.resolve(f).then((function(t) { | |
a.value = t, | |
i(a) | |
} | |
), (function(t) { | |
return e("throw", t, i, u) | |
} | |
)) | |
} | |
u(c.arg) | |
}(r, o, e, i) | |
} | |
)) | |
} | |
return e = e ? e.then(i, i) : i() | |
} | |
} | |
function E(t, r) { | |
var n = t.iterator[r.method]; | |
if (n === e) { | |
if (r.delegate = null, | |
"throw" === r.method) { | |
if (t.iterator.return && (r.method = "return", | |
r.arg = e, | |
E(t, r), | |
"throw" === r.method)) | |
return d; | |
r.method = "throw", | |
r.arg = new TypeError("The iterator does not provide a 'throw' method") | |
} | |
return d | |
} | |
var o = s(n, t.iterator, r.arg); | |
if ("throw" === o.type) | |
return r.method = "throw", | |
r.arg = o.arg, | |
r.delegate = null, | |
d; | |
var i = o.arg; | |
return i ? i.done ? (r[t.resultName] = i.value, | |
r.next = t.nextLoc, | |
"return" !== r.method && (r.method = "next", | |
r.arg = e), | |
r.delegate = null, | |
d) : i : (r.method = "throw", | |
r.arg = new TypeError("iterator result is not an object"), | |
r.delegate = null, | |
d) | |
} | |
function _(t) { | |
var e = { | |
tryLoc: t[0] | |
}; | |
1 in t && (e.catchLoc = t[1]), | |
2 in t && (e.finallyLoc = t[2], | |
e.afterLoc = t[3]), | |
this.tryEntries.push(e) | |
} | |
function R(t) { | |
var e = t.completion || {}; | |
e.type = "normal", | |
delete e.arg, | |
t.completion = e | |
} | |
function x(t) { | |
this.tryEntries = [{ | |
tryLoc: "root" | |
}], | |
t.forEach(_, this), | |
this.reset(!0) | |
} | |
function T(t) { | |
if (t) { | |
var r = t[i]; | |
if (r) | |
return r.call(t); | |
if ("function" == typeof t.next) | |
return t; | |
if (!isNaN(t.length)) { | |
var o = -1 | |
, u = function r() { | |
for (; ++o < t.length; ) | |
if (n.call(t, o)) | |
return r.value = t[o], | |
r.done = !1, | |
r; | |
return r.value = e, | |
r.done = !0, | |
r | |
}; | |
return u.next = u | |
} | |
} | |
return { | |
next: I | |
} | |
} | |
function I() { | |
return { | |
value: e, | |
done: !0 | |
} | |
} | |
return y.prototype = m.constructor = b, | |
b.constructor = y, | |
b[c] = y.displayName = "GeneratorFunction", | |
t.isGeneratorFunction = function(t) { | |
var e = "function" == typeof t && t.constructor; | |
return !!e && (e === y || "GeneratorFunction" === (e.displayName || e.name)) | |
} | |
, | |
t.mark = function(t) { | |
return Object.setPrototypeOf ? Object.setPrototypeOf(t, b) : (t.__proto__ = b, | |
c in t || (t[c] = "GeneratorFunction")), | |
t.prototype = Object.create(m), | |
t | |
} | |
, | |
t.awrap = function(t) { | |
return { | |
__await: t | |
} | |
} | |
, | |
j(S.prototype), | |
S.prototype[u] = function() { | |
return this | |
} | |
, | |
t.AsyncIterator = S, | |
t.async = function(e, r, n, o) { | |
var i = new S(a(e, r, n, o)); | |
return t.isGeneratorFunction(r) ? i : i.next().then((function(t) { | |
return t.done ? t.value : i.next() | |
} | |
)) | |
} | |
, | |
j(m), | |
m[c] = "Generator", | |
m[i] = function() { | |
return this | |
} | |
, | |
m.toString = function() { | |
return "[object Generator]" | |
} | |
, | |
t.keys = function(t) { | |
var e = []; | |
for (var r in t) | |
e.push(r); | |
return e.reverse(), | |
function r() { | |
for (; e.length; ) { | |
var n = e.pop(); | |
if (n in t) | |
return r.value = n, | |
r.done = !1, | |
r | |
} | |
return r.done = !0, | |
r | |
} | |
} | |
, | |
t.values = T, | |
x.prototype = { | |
constructor: x, | |
reset: function(t) { | |
if (this.prev = 0, | |
this.next = 0, | |
this.sent = this._sent = e, | |
this.done = !1, | |
this.delegate = null, | |
this.method = "next", | |
this.arg = e, | |
this.tryEntries.forEach(R), | |
!t) | |
for (var r in this) | |
"t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = e) | |
}, | |
stop: function() { | |
this.done = !0; | |
var t = this.tryEntries[0].completion; | |
if ("throw" === t.type) | |
throw t.arg; | |
return this.rval | |
}, | |
dispatchException: function(t) { | |
if (this.done) | |
throw t; | |
var r = this; | |
function o(n, o) { | |
return c.type = "throw", | |
c.arg = t, | |
r.next = n, | |
o && (r.method = "next", | |
r.arg = e), | |
!!o | |
} | |
for (var i = this.tryEntries.length - 1; i >= 0; --i) { | |
var u = this.tryEntries[i] | |
, c = u.completion; | |
if ("root" === u.tryLoc) | |
return o("end"); | |
if (u.tryLoc <= this.prev) { | |
var a = n.call(u, "catchLoc") | |
, s = n.call(u, "finallyLoc"); | |
if (a && s) { | |
if (this.prev < u.catchLoc) | |
return o(u.catchLoc, !0); | |
if (this.prev < u.finallyLoc) | |
return o(u.finallyLoc) | |
} else if (a) { | |
if (this.prev < u.catchLoc) | |
return o(u.catchLoc, !0) | |
} else { | |
if (!s) | |
throw new Error("try statement without catch or finally"); | |
if (this.prev < u.finallyLoc) | |
return o(u.finallyLoc) | |
} | |
} | |
} | |
}, | |
abrupt: function(t, e) { | |
for (var r = this.tryEntries.length - 1; r >= 0; --r) { | |
var o = this.tryEntries[r]; | |
if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { | |
var i = o; | |
break | |
} | |
} | |
i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); | |
var u = i ? i.completion : {}; | |
return u.type = t, | |
u.arg = e, | |
i ? (this.method = "next", | |
this.next = i.finallyLoc, | |
d) : this.complete(u) | |
}, | |
complete: function(t, e) { | |
if ("throw" === t.type) | |
throw t.arg; | |
return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, | |
this.method = "return", | |
this.next = "end") : "normal" === t.type && e && (this.next = e), | |
d | |
}, | |
finish: function(t) { | |
for (var e = this.tryEntries.length - 1; e >= 0; --e) { | |
var r = this.tryEntries[e]; | |
if (r.finallyLoc === t) | |
return this.complete(r.completion, r.afterLoc), | |
R(r), | |
d | |
} | |
}, | |
catch: function(t) { | |
for (var e = this.tryEntries.length - 1; e >= 0; --e) { | |
var r = this.tryEntries[e]; | |
if (r.tryLoc === t) { | |
var n = r.completion; | |
if ("throw" === n.type) { | |
var o = n.arg; | |
R(r) | |
} | |
return o | |
} | |
} | |
throw new Error("illegal catch attempt") | |
}, | |
delegateYield: function(t, r, n) { | |
return this.delegate = { | |
iterator: T(t), | |
resultName: r, | |
nextLoc: n | |
}, | |
"next" === this.method && (this.arg = e), | |
d | |
} | |
}, | |
t | |
}(t.exports); | |
try { | |
regeneratorRuntime = n | |
} catch (t) { | |
Function("r", "regeneratorRuntime = r")(n) | |
} | |
}, | |
65: function(t, e) { | |
var r; | |
r = function() { | |
return this | |
}(); | |
try { | |
r = r || new Function("return this")() | |
} catch (t) { | |
"object" == typeof window && (r = window) | |
} | |
t.exports = r | |
}, | |
7: function(t, e, r) { | |
"use strict"; | |
r.d(e, "a", (function() { | |
return o | |
} | |
)); | |
var n = r(10); | |
function o(t) { | |
for (var e = 1; e < arguments.length; e++) { | |
var r = null != arguments[e] ? arguments[e] : {} | |
, o = Object.keys(r); | |
"function" == typeof Object.getOwnPropertySymbols && (o = o.concat(Object.getOwnPropertySymbols(r).filter((function(t) { | |
return Object.getOwnPropertyDescriptor(r, t).enumerable | |
} | |
)))), | |
o.forEach((function(e) { | |
Object(n.a)(t, e, r[e]) | |
} | |
)) | |
} | |
return t | |
} | |
}, | |
74: function(t, e, r) { | |
"use strict"; | |
function n(t) { | |
return (n = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(t) { | |
return typeof t | |
} | |
: function(t) { | |
return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t | |
} | |
)(t) | |
} | |
function o(t, e) { | |
for (var r = 0; r < e.length; r++) { | |
var n = e[r]; | |
n.enumerable = n.enumerable || !1, | |
n.configurable = !0, | |
"value"in n && (n.writable = !0), | |
Object.defineProperty(t, n.key, n) | |
} | |
} | |
function i(t, e) { | |
var r = t._map | |
, n = t._arrayTreeMap | |
, o = t._objectTreeMap; | |
if (r.has(e)) | |
return r.get(e); | |
for (var i = Object.keys(e).sort(), u = Array.isArray(e) ? n : o, c = 0; c < i.length; c++) { | |
var a = i[c]; | |
if (void 0 === (u = u.get(a))) | |
return; | |
var s = e[a]; | |
if (void 0 === (u = u.get(s))) | |
return | |
} | |
var f = u.get("_ekm_value"); | |
return f ? (r.delete(f[0]), | |
f[0] = e, | |
u.set("_ekm_value", f), | |
r.set(e, f), | |
f) : void 0 | |
} | |
var u = function() { | |
function t(e) { | |
if (function(t, e) { | |
if (!(t instanceof e)) | |
throw new TypeError("Cannot call a class as a function") | |
}(this, t), | |
this.clear(), | |
e instanceof t) { | |
var r = []; | |
e.forEach((function(t, e) { | |
r.push([e, t]) | |
} | |
)), | |
e = r | |
} | |
if (null != e) | |
for (var n = 0; n < e.length; n++) | |
this.set(e[n][0], e[n][1]) | |
} | |
var e, r, u; | |
return e = t, | |
(r = [{ | |
key: "set", | |
value: function(e, r) { | |
if (null === e || "object" !== n(e)) | |
return this._map.set(e, r), | |
this; | |
for (var o = Object.keys(e).sort(), i = [e, r], u = Array.isArray(e) ? this._arrayTreeMap : this._objectTreeMap, c = 0; c < o.length; c++) { | |
var a = o[c]; | |
u.has(a) || u.set(a, new t), | |
u = u.get(a); | |
var s = e[a]; | |
u.has(s) || u.set(s, new t), | |
u = u.get(s) | |
} | |
var f = u.get("_ekm_value"); | |
return f && this._map.delete(f[0]), | |
u.set("_ekm_value", i), | |
this._map.set(e, i), | |
this | |
} | |
}, { | |
key: "get", | |
value: function(t) { | |
if (null === t || "object" !== n(t)) | |
return this._map.get(t); | |
var e = i(this, t); | |
return e ? e[1] : void 0 | |
} | |
}, { | |
key: "has", | |
value: function(t) { | |
return null === t || "object" !== n(t) ? this._map.has(t) : void 0 !== i(this, t) | |
} | |
}, { | |
key: "delete", | |
value: function(t) { | |
return !!this.has(t) && (this.set(t, void 0), | |
!0) | |
} | |
}, { | |
key: "forEach", | |
value: function(t) { | |
var e = this | |
, r = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : this; | |
this._map.forEach((function(o, i) { | |
null !== i && "object" === n(i) && (o = o[1]), | |
t.call(r, o, i, e) | |
} | |
)) | |
} | |
}, { | |
key: "clear", | |
value: function() { | |
this._map = new Map, | |
this._arrayTreeMap = new Map, | |
this._objectTreeMap = new Map | |
} | |
}, { | |
key: "size", | |
get: function() { | |
return this._map.size | |
} | |
}]) && o(e.prototype, r), | |
u && o(e, u), | |
t | |
}(); | |
t.exports = u | |
}, | |
8: function(t, e) { | |
!function() { | |
t.exports = this.wp.compose | |
}() | |
}, | |
98: function(t, e) { | |
t.exports = function(t) { | |
return !!t && ("object" == typeof t || "function" == typeof t) && "function" == typeof t.then | |
} | |
} | |
}); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment