this["wp"] = this["wp"] || {}; this["wp"]["nux"] = /******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules[moduleId]) { /******/ return installedModules[moduleId].exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules[moduleId] = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (__webpack_modules__) /******/ __webpack_require__.m = modules; /******/ /******/ // expose the module cache /******/ __webpack_require__.c = installedModules; /******/ /******/ // define getter function for harmony exports /******/ __webpack_require__.d = function(exports, name, getter) { /******/ if(!__webpack_require__.o(exports, name)) { /******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); /******/ } /******/ }; /******/ /******/ // define __esModule on exports /******/ __webpack_require__.r = function(exports) { /******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /******/ } /******/ Object.defineProperty(exports, '__esModule', { value: true }); /******/ }; /******/ /******/ // create a fake namespace object /******/ // mode & 1: value is a module id, require it /******/ // mode & 2: merge all properties of value into the ns /******/ // mode & 4: return value when already ns object /******/ // mode & 8|1: behave like require /******/ __webpack_require__.t = function(value, mode) { /******/ if(mode & 1) value = __webpack_require__(value); /******/ if(mode & 8) return value; /******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; /******/ var ns = Object.create(null); /******/ __webpack_require__.r(ns); /******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); /******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); /******/ return ns; /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ __webpack_require__.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module['default']; } : /******/ function getModuleExports() { return module; }; /******/ __webpack_require__.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ /******/ /******/ // Load entry module and return exports /******/ return __webpack_require__(__webpack_require__.s = 361); /******/ }) /************************************************************************/ /******/ ({ /***/ 0: /***/ (function(module, exports) { (function() { module.exports = this["wp"]["element"]; }()); /***/ }), /***/ 1: /***/ (function(module, exports) { (function() { module.exports = this["wp"]["i18n"]; }()); /***/ }), /***/ 15: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /***/ }), /***/ 17: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js var iterableToArray = __webpack_require__(34); // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; }); function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread(); } /***/ }), /***/ 2: /***/ (function(module, exports) { (function() { module.exports = this["lodash"]; }()); /***/ }), /***/ 28: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js var arrayWithHoles = __webpack_require__(37); // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js var nonIterableRest = __webpack_require__(38); // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; }); function _slicedToArray(arr, i) { return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(nonIterableRest["a" /* default */])(); } /***/ }), /***/ 30: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; var LEAF_KEY, hasWeakMap; /** * Arbitrary value used as key for referencing cache object in WeakMap tree. * * @type {Object} */ LEAF_KEY = {}; /** * Whether environment supports WeakMap. * * @type {boolean} */ hasWeakMap = typeof WeakMap !== 'undefined'; /** * Returns the first argument as the sole entry in an array. * * @param {*} value Value to return. * * @return {Array} Value returned as entry in array. */ function arrayOf( value ) { return [ value ]; } /** * Returns true if the value passed is object-like, or false otherwise. A value * is object-like if it can support property assignment, e.g. object or array. * * @param {*} value Value to test. * * @return {boolean} Whether value is object-like. */ function isObjectLike( value ) { return !! value && 'object' === typeof value; } /** * Creates and returns a new cache object. * * @return {Object} Cache object. */ function createCache() { var cache = { clear: function() { cache.head = null; }, }; return cache; } /** * Returns true if entries within the two arrays are strictly equal by * reference from a starting index. * * @param {Array} a First array. * @param {Array} b Second array. * @param {number} fromIndex Index from which to start comparison. * * @return {boolean} Whether arrays are shallowly equal. */ function isShallowEqual( a, b, fromIndex ) { var i; if ( a.length !== b.length ) { return false; } for ( i = fromIndex; i < a.length; i++ ) { if ( a[ i ] !== b[ i ] ) { return false; } } return true; } /** * Returns a memoized selector function. The getDependants function argument is * called before the memoized selector and is expected to return an immutable * reference or array of references on which the selector depends for computing * its own return value. The memoize cache is preserved only as long as those * dependant references remain the same. If getDependants returns a different * reference(s), the cache is cleared and the selector value regenerated. * * @param {Function} selector Selector function. * @param {Function} getDependants Dependant getter returning an immutable * reference or array of reference used in * cache bust consideration. * * @return {Function} Memoized selector. */ /* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) { var rootCache, getCache; // Use object source as dependant if getter not provided if ( ! getDependants ) { getDependants = arrayOf; } /** * Returns the root cache. If WeakMap is supported, this is assigned to the * root WeakMap cache set, otherwise it is a shared instance of the default * cache object. * * @return {(WeakMap|Object)} Root cache object. */ function getRootCache() { return rootCache; } /** * Returns the cache for a given dependants array. When possible, a WeakMap * will be used to create a unique cache for each set of dependants. This * is feasible due to the nature of WeakMap in allowing garbage collection * to occur on entries where the key object is no longer referenced. Since * WeakMap requires the key to be an object, this is only possible when the * dependant is object-like. The root cache is created as a hierarchy where * each top-level key is the first entry in a dependants set, the value a * WeakMap where each key is the next dependant, and so on. This continues * so long as the dependants are object-like. If no dependants are object- * like, then the cache is shared across all invocations. * * @see isObjectLike * * @param {Array} dependants Selector dependants. * * @return {Object} Cache object. */ function getWeakMapCache( dependants ) { var caches = rootCache, isUniqueByDependants = true, i, dependant, map, cache; for ( i = 0; i < dependants.length; i++ ) { dependant = dependants[ i ]; // Can only compose WeakMap from object-like key. if ( ! isObjectLike( dependant ) ) { isUniqueByDependants = false; break; } // Does current segment of cache already have a WeakMap? if ( caches.has( dependant ) ) { // Traverse into nested WeakMap. caches = caches.get( dependant ); } else { // Create, set, and traverse into a new one. map = new WeakMap(); caches.set( dependant, map ); caches = map; } } // We use an arbitrary (but consistent) object as key for the last item // in the WeakMap to serve as our running cache. if ( ! caches.has( LEAF_KEY ) ) { cache = createCache(); cache.isUniqueByDependants = isUniqueByDependants; caches.set( LEAF_KEY, cache ); } return caches.get( LEAF_KEY ); } // Assign cache handler by availability of WeakMap getCache = hasWeakMap ? getWeakMapCache : getRootCache; /** * Resets root memoization cache. */ function clear() { rootCache = hasWeakMap ? new WeakMap() : createCache(); } // eslint-disable-next-line jsdoc/check-param-names /** * The augmented selector call, considering first whether dependants have * changed before passing it to underlying memoize function. * * @param {Object} source Source object for derivation. * @param {...*} extraArgs Additional arguments to pass to selector. * * @return {*} Selector result. */ function callSelector( /* source, ...extraArgs */ ) { var len = arguments.length, cache, node, i, args, dependants; // Create copy of arguments (avoid leaking deoptimization). args = new Array( len ); for ( i = 0; i < len; i++ ) { args[ i ] = arguments[ i ]; } dependants = getDependants.apply( null, args ); cache = getCache( dependants ); // If not guaranteed uniqueness by dependants (primitive type or lack // of WeakMap support), shallow compare against last dependants and, if // references have changed, destroy cache to recalculate result. if ( ! cache.isUniqueByDependants ) { if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) { cache.clear(); } cache.lastDependants = dependants; } node = cache.head; while ( node ) { // Check whether node arguments match arguments if ( ! isShallowEqual( node.args, args, 1 ) ) { node = node.next; continue; } // At this point we can assume we've found a match // Surface matched node to head if not already if ( node !== cache.head ) { // Adjust siblings to point to each other. node.prev.next = node.next; if ( node.next ) { node.next.prev = node.prev; } node.next = cache.head; node.prev = null; cache.head.prev = node; cache.head = node; } // Return immediately return node.val; } // No cached value found. Continue to insertion phase: node = { // Generate the result from original function val: selector.apply( null, args ), }; // Avoid including the source object in the cache. args[ 0 ] = null; node.args = args; // Don't need to check whether node is already head, since it would // have been returned above already if it was // Shift existing head down list if ( cache.head ) { cache.head.prev = node; node.next = cache.head; } cache.head = node; return node.val; } callSelector.getDependants = getDependants; callSelector.clear = clear; clear(); return callSelector; }); /***/ }), /***/ 34: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } /***/ }), /***/ 361: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); var actions_namespaceObject = {}; __webpack_require__.r(actions_namespaceObject); __webpack_require__.d(actions_namespaceObject, "triggerGuide", function() { return triggerGuide; }); __webpack_require__.d(actions_namespaceObject, "dismissTip", function() { return dismissTip; }); __webpack_require__.d(actions_namespaceObject, "disableTips", function() { return disableTips; }); __webpack_require__.d(actions_namespaceObject, "enableTips", function() { return enableTips; }); var selectors_namespaceObject = {}; __webpack_require__.r(selectors_namespaceObject); __webpack_require__.d(selectors_namespaceObject, "getAssociatedGuide", function() { return getAssociatedGuide; }); __webpack_require__.d(selectors_namespaceObject, "isTipVisible", function() { return isTipVisible; }); __webpack_require__.d(selectors_namespaceObject, "areTipsEnabled", function() { return selectors_areTipsEnabled; }); // EXTERNAL MODULE: external {"this":["wp","data"]} var external_this_wp_data_ = __webpack_require__(5); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js var defineProperty = __webpack_require__(15); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js var objectSpread = __webpack_require__(7); // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules var toConsumableArray = __webpack_require__(17); // CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/reducer.js /** * WordPress dependencies */ /** * Reducer that tracks which tips are in a guide. Each guide is represented by * an array which contains the tip identifiers contained within that guide. * * @param {Array} state Current state. * @param {Object} action Dispatched action. * * @return {Array} Updated state. */ function guides() { var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; var action = arguments.length > 1 ? arguments[1] : undefined; switch (action.type) { case 'TRIGGER_GUIDE': return [].concat(Object(toConsumableArray["a" /* default */])(state), [action.tipIds]); } return state; } /** * Reducer that tracks whether or not tips are globally enabled. * * @param {boolean} state Current state. * @param {Object} action Dispatched action. * * @return {boolean} Updated state. */ function areTipsEnabled() { var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; var action = arguments.length > 1 ? arguments[1] : undefined; switch (action.type) { case 'DISABLE_TIPS': return false; case 'ENABLE_TIPS': return true; } return state; } /** * Reducer that tracks which tips have been dismissed. If the state object * contains a tip identifier, then that tip is dismissed. * * @param {Object} state Current state. * @param {Object} action Dispatched action. * * @return {Object} Updated state. */ function dismissedTips() { var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; var action = arguments.length > 1 ? arguments[1] : undefined; switch (action.type) { case 'DISMISS_TIP': return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.id, true)); case 'ENABLE_TIPS': return {}; } return state; } var preferences = Object(external_this_wp_data_["combineReducers"])({ areTipsEnabled: areTipsEnabled, dismissedTips: dismissedTips }); /* harmony default export */ var reducer = (Object(external_this_wp_data_["combineReducers"])({ guides: guides, preferences: preferences })); // CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/actions.js /** * Returns an action object that, when dispatched, presents a guide that takes * the user through a series of tips step by step. * * @param {string[]} tipIds Which tips to show in the guide. * * @return {Object} Action object. */ function triggerGuide(tipIds) { return { type: 'TRIGGER_GUIDE', tipIds: tipIds }; } /** * Returns an action object that, when dispatched, dismisses the given tip. A * dismissed tip will not show again. * * @param {string} id The tip to dismiss. * * @return {Object} Action object. */ function dismissTip(id) { return { type: 'DISMISS_TIP', id: id }; } /** * Returns an action object that, when dispatched, prevents all tips from * showing again. * * @return {Object} Action object. */ function disableTips() { return { type: 'DISABLE_TIPS' }; } /** * Returns an action object that, when dispatched, makes all tips show again. * * @return {Object} Action object. */ function enableTips() { return { type: 'ENABLE_TIPS' }; } // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules var slicedToArray = __webpack_require__(28); // EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js var rememo = __webpack_require__(30); // EXTERNAL MODULE: external "lodash" var external_lodash_ = __webpack_require__(2); // CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/selectors.js /** * External dependencies */ /** * An object containing information about a guide. * * @typedef {Object} NUX.GuideInfo * @property {string[]} tipIds Which tips the guide contains. * @property {?string} currentTipId The guide's currently showing tip. * @property {?string} nextTipId The guide's next tip to show. */ /** * Returns an object describing the guide, if any, that the given tip is a part * of. * * @param {Object} state Global application state. * @param {string} tipId The tip to query. * * @return {?NUX.GuideInfo} Information about the associated guide. */ var getAssociatedGuide = Object(rememo["a" /* default */])(function (state, tipId) { var _iteratorNormalCompletion = true; var _didIteratorError = false; var _iteratorError = undefined; try { for (var _iterator = state.guides[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { var tipIds = _step.value; if (Object(external_lodash_["includes"])(tipIds, tipId)) { var nonDismissedTips = Object(external_lodash_["difference"])(tipIds, Object(external_lodash_["keys"])(state.preferences.dismissedTips)); var _nonDismissedTips = Object(slicedToArray["a" /* default */])(nonDismissedTips, 2), _nonDismissedTips$ = _nonDismissedTips[0], currentTipId = _nonDismissedTips$ === void 0 ? null : _nonDismissedTips$, _nonDismissedTips$2 = _nonDismissedTips[1], nextTipId = _nonDismissedTips$2 === void 0 ? null : _nonDismissedTips$2; return { tipIds: tipIds, currentTipId: currentTipId, nextTipId: nextTipId }; } } } catch (err) { _didIteratorError = true; _iteratorError = err; } finally { try { if (!_iteratorNormalCompletion && _iterator.return != null) { _iterator.return(); } } finally { if (_didIteratorError) { throw _iteratorError; } } } return null; }, function (state) { return [state.guides, state.preferences.dismissedTips]; }); /** * Determines whether or not the given tip is showing. Tips are hidden if they * are disabled, have been dismissed, or are not the current tip in any * guide that they have been added to. * * @param {Object} state Global application state. * @param {string} tipId The tip to query. * * @return {boolean} Whether or not the given tip is showing. */ function isTipVisible(state, tipId) { if (!state.preferences.areTipsEnabled) { return false; } if (state.preferences.dismissedTips[tipId]) { return false; } var associatedGuide = getAssociatedGuide(state, tipId); if (associatedGuide && associatedGuide.currentTipId !== tipId) { return false; } return true; } /** * Returns whether or not tips are globally enabled. * * @param {Object} state Global application state. * * @return {boolean} Whether tips are globally enabled. */ function selectors_areTipsEnabled(state) { return state.preferences.areTipsEnabled; } // CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/store/index.js /** * WordPress dependencies */ /** * Internal dependencies */ var store = Object(external_this_wp_data_["registerStore"])('core/nux', { reducer: reducer, actions: actions_namespaceObject, selectors: selectors_namespaceObject, persist: ['preferences'] }); /* harmony default export */ var build_module_store = (store); // EXTERNAL MODULE: external {"this":["wp","element"]} var external_this_wp_element_ = __webpack_require__(0); // EXTERNAL MODULE: external {"this":["wp","compose"]} var external_this_wp_compose_ = __webpack_require__(6); // EXTERNAL MODULE: external {"this":["wp","components"]} var external_this_wp_components_ = __webpack_require__(4); // EXTERNAL MODULE: external {"this":["wp","i18n"]} var external_this_wp_i18n_ = __webpack_require__(1); // CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/components/dot-tip/index.js /** * WordPress dependencies */ function getAnchorRect(anchor) { // The default getAnchorRect() excludes an element's top and bottom padding // from its calculation. We want tips to point to the outer margin of an // element, so we override getAnchorRect() to include all padding. return anchor.parentNode.getBoundingClientRect(); } function onClick(event) { // Tips are often nested within buttons. We stop propagation so that clicking // on a tip doesn't result in the button being clicked. event.stopPropagation(); } function DotTip(_ref) { var children = _ref.children, isVisible = _ref.isVisible, hasNextTip = _ref.hasNextTip, onDismiss = _ref.onDismiss, onDisable = _ref.onDisable; if (!isVisible) { return null; } return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Popover"], { className: "nux-dot-tip", position: "middle right", noArrow: true, focusOnMount: "container", getAnchorRect: getAnchorRect, role: "dialog", "aria-label": Object(external_this_wp_i18n_["__"])('Editor tips'), onClick: onClick }, Object(external_this_wp_element_["createElement"])("p", null, children), Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { isLink: true, onClick: onDismiss }, hasNextTip ? Object(external_this_wp_i18n_["__"])('See next tip') : Object(external_this_wp_i18n_["__"])('Got it'))), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { className: "nux-dot-tip__disable", icon: "no-alt", label: Object(external_this_wp_i18n_["__"])('Disable tips'), onClick: onDisable })); } /* harmony default export */ var dot_tip = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { var tipId = _ref2.tipId; var _select = select('core/nux'), isTipVisible = _select.isTipVisible, getAssociatedGuide = _select.getAssociatedGuide; var associatedGuide = getAssociatedGuide(tipId); return { isVisible: isTipVisible(tipId), hasNextTip: !!(associatedGuide && associatedGuide.nextTipId) }; }), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref3) { var tipId = _ref3.tipId; var _dispatch = dispatch('core/nux'), dismissTip = _dispatch.dismissTip, disableTips = _dispatch.disableTips; return { onDismiss: function onDismiss() { dismissTip(tipId); }, onDisable: function onDisable() { disableTips(); } }; }))(DotTip)); // CONCATENATED MODULE: ./node_modules/@wordpress/nux/build-module/index.js /* concated harmony reexport DotTip */__webpack_require__.d(__webpack_exports__, "DotTip", function() { return dot_tip; }); /** * Internal dependencies */ /***/ }), /***/ 37: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } /***/ }), /***/ 38: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } /***/ }), /***/ 4: /***/ (function(module, exports) { (function() { module.exports = this["wp"]["components"]; }()); /***/ }), /***/ 5: /***/ (function(module, exports) { (function() { module.exports = this["wp"]["data"]; }()); /***/ }), /***/ 6: /***/ (function(module, exports) { (function() { module.exports = this["wp"]["compose"]; }()); /***/ }), /***/ 7: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; }); /* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15); function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]); }); } return target; } /***/ }) /******/ });