diff -r c7c34916027a -r 177826044cd9 wp/wp-includes/js/dist/compose.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wp/wp-includes/js/dist/compose.js Mon Oct 14 18:28:13 2019 +0200 @@ -0,0 +1,894 @@ +this["wp"] = this["wp"] || {}; this["wp"]["compose"] = +/******/ (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 = 368); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 0: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["element"]; }()); + +/***/ }), + +/***/ 10: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; }); +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +/***/ }), + +/***/ 11: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; }); +/* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(32); +/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3); + + +function _possibleConstructorReturn(self, call) { + if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) { + return call; + } + + return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self); +} + +/***/ }), + +/***/ 12: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; }); +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +/***/ }), + +/***/ 13: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; }); + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +/***/ }), + +/***/ 19: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; }); +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +/***/ }), + +/***/ 2: +/***/ (function(module, exports) { + +(function() { module.exports = this["lodash"]; }()); + +/***/ }), + +/***/ 3: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; }); +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +/***/ }), + +/***/ 32: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; }); +function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); } + +function _typeof(obj) { + if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") { + _typeof = function _typeof(obj) { + return _typeof2(obj); + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj); + }; + } + + return _typeof(obj); +} + +/***/ }), + +/***/ 368: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); + +// EXTERNAL MODULE: external "lodash" +var external_lodash_ = __webpack_require__(2); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/create-higher-order-component/index.js +/** + * External dependencies + */ + +/** + * Given a function mapping a component to an enhanced component and modifier + * name, returns the enhanced component augmented with a generated displayName. + * + * @param {Function} mapComponentToEnhancedComponent Function mapping component + * to enhanced component. + * @param {string} modifierName Seed name from which to + * generated display name. + * + * @return {WPComponent} Component class with generated display name assigned. + */ + +function createHigherOrderComponent(mapComponentToEnhancedComponent, modifierName) { + return function (OriginalComponent) { + var EnhancedComponent = mapComponentToEnhancedComponent(OriginalComponent); + var _OriginalComponent$di = OriginalComponent.displayName, + displayName = _OriginalComponent$di === void 0 ? OriginalComponent.name || 'Component' : _OriginalComponent$di; + EnhancedComponent.displayName = "".concat(Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(modifierName)), "(").concat(displayName, ")"); + return EnhancedComponent; + }; +} + +/* harmony default export */ var create_higher_order_component = (createHigherOrderComponent); + +// EXTERNAL MODULE: external {"this":["wp","element"]} +var external_this_wp_element_ = __webpack_require__(0); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/if-condition/index.js + + +/** + * Internal dependencies + */ + +/** + * Higher-order component creator, creating a new component which renders if + * the given condition is satisfied or with the given optional prop name. + * + * @param {Function} predicate Function to test condition. + * + * @return {Function} Higher-order component. + */ + +var if_condition_ifCondition = function ifCondition(predicate) { + return create_higher_order_component(function (WrappedComponent) { + return function (props) { + if (!predicate(props)) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(WrappedComponent, props); + }; + }, 'ifCondition'); +}; + +/* harmony default export */ var if_condition = (if_condition_ifCondition); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js +var classCallCheck = __webpack_require__(10); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js +var createClass = __webpack_require__(9); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js +var possibleConstructorReturn = __webpack_require__(11); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js +var getPrototypeOf = __webpack_require__(12); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules +var inherits = __webpack_require__(13); + +// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]} +var external_this_wp_isShallowEqual_ = __webpack_require__(42); +var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/pure/index.js + + + + + + + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/** + * Given a component returns the enhanced component augmented with a component + * only rerendering when its props/state change + * + * @param {Function} mapComponentToEnhancedComponent Function mapping component + * to enhanced component. + * @param {string} modifierName Seed name from which to + * generated display name. + * + * @return {WPComponent} Component class with generated display name assigned. + */ + +var pure = create_higher_order_component(function (Wrapped) { + if (Wrapped.prototype instanceof external_this_wp_element_["Component"]) { + return ( + /*#__PURE__*/ + function (_Wrapped) { + Object(inherits["a" /* default */])(_class, _Wrapped); + + function _class() { + Object(classCallCheck["a" /* default */])(this, _class); + + return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); + } + + Object(createClass["a" /* default */])(_class, [{ + key: "shouldComponentUpdate", + value: function shouldComponentUpdate(nextProps, nextState) { + return !external_this_wp_isShallowEqual_default()(nextProps, this.props) || !external_this_wp_isShallowEqual_default()(nextState, this.state); + } + }]); + + return _class; + }(Wrapped) + ); + } + + return ( + /*#__PURE__*/ + function (_Component) { + Object(inherits["a" /* default */])(_class2, _Component); + + function _class2() { + Object(classCallCheck["a" /* default */])(this, _class2); + + return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class2).apply(this, arguments)); + } + + Object(createClass["a" /* default */])(_class2, [{ + key: "shouldComponentUpdate", + value: function shouldComponentUpdate(nextProps) { + return !external_this_wp_isShallowEqual_default()(nextProps, this.props); + } + }, { + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])(Wrapped, this.props); + } + }]); + + return _class2; + }(external_this_wp_element_["Component"]) + ); +}, 'pure'); +/* harmony default export */ var build_module_pure = (pure); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js +var esm_extends = __webpack_require__(19); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js +var assertThisInitialized = __webpack_require__(3); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-global-events/listener.js + + + +/** + * External dependencies + */ + +/** + * Class responsible for orchestrating event handling on the global window, + * binding a single event to be shared across all handling instances, and + * removing the handler when no instances are listening for the event. + */ + +var listener_Listener = +/*#__PURE__*/ +function () { + function Listener() { + Object(classCallCheck["a" /* default */])(this, Listener); + + this.listeners = {}; + this.handleEvent = this.handleEvent.bind(this); + } + + Object(createClass["a" /* default */])(Listener, [{ + key: "add", + value: function add(eventType, instance) { + if (!this.listeners[eventType]) { + // Adding first listener for this type, so bind event. + window.addEventListener(eventType, this.handleEvent); + this.listeners[eventType] = []; + } + + this.listeners[eventType].push(instance); + } + }, { + key: "remove", + value: function remove(eventType, instance) { + this.listeners[eventType] = Object(external_lodash_["without"])(this.listeners[eventType], instance); + + if (!this.listeners[eventType].length) { + // Removing last listener for this type, so unbind event. + window.removeEventListener(eventType, this.handleEvent); + delete this.listeners[eventType]; + } + } + }, { + key: "handleEvent", + value: function handleEvent(event) { + Object(external_lodash_["forEach"])(this.listeners[event.type], function (instance) { + instance.handleEvent(event); + }); + } + }]); + + return Listener; +}(); + +/* harmony default export */ var listener = (listener_Listener); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-global-events/index.js + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + +/** + * Listener instance responsible for managing document event handling. + * + * @type {Listener} + */ + +var with_global_events_listener = new listener(); + +function withGlobalEvents(eventTypesToHandlers) { + return create_higher_order_component(function (WrappedComponent) { + var Wrapper = + /*#__PURE__*/ + function (_Component) { + Object(inherits["a" /* default */])(Wrapper, _Component); + + function Wrapper() { + var _this; + + Object(classCallCheck["a" /* default */])(this, Wrapper); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Wrapper).apply(this, arguments)); + _this.handleEvent = _this.handleEvent.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.handleRef = _this.handleRef.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(Wrapper, [{ + key: "componentDidMount", + value: function componentDidMount() { + var _this2 = this; + + Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { + with_global_events_listener.add(eventType, _this2); + }); + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + var _this3 = this; + + Object(external_lodash_["forEach"])(eventTypesToHandlers, function (handler, eventType) { + with_global_events_listener.remove(eventType, _this3); + }); + } + }, { + key: "handleEvent", + value: function handleEvent(event) { + var handler = eventTypesToHandlers[event.type]; + + if (typeof this.wrappedRef[handler] === 'function') { + this.wrappedRef[handler](event); + } + } + }, { + key: "handleRef", + value: function handleRef(el) { + this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref` + // will cause `this.props.forwardedRef` to be `null`, so we need this + // check. + + if (this.props.forwardedRef) { + this.props.forwardedRef(el); + } + } + }, { + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, { + ref: this.handleRef + })); + } + }]); + + return Wrapper; + }(external_this_wp_element_["Component"]); + + return Object(external_this_wp_element_["forwardRef"])(function (props, ref) { + return Object(external_this_wp_element_["createElement"])(Wrapper, { + ownProps: props, + forwardedRef: ref + }); + }); + }, 'withGlobalEvents'); +} + +/* harmony default export */ var with_global_events = (withGlobalEvents); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-instance-id/index.js + + + + + + + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + +/** + * A Higher Order Component used to be provide a unique instance ID by + * component. + * + * @param {WPElement} WrappedComponent The wrapped component. + * + * @return {Component} Component with an instanceId prop. + */ + +/* harmony default export */ var with_instance_id = (create_higher_order_component(function (WrappedComponent) { + var instances = 0; + return ( + /*#__PURE__*/ + function (_Component) { + Object(inherits["a" /* default */])(_class, _Component); + + function _class() { + var _this; + + Object(classCallCheck["a" /* default */])(this, _class); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).apply(this, arguments)); + _this.instanceId = instances++; + return _this; + } + + Object(createClass["a" /* default */])(_class, [{ + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props, { + instanceId: this.instanceId + })); + } + }]); + + return _class; + }(external_this_wp_element_["Component"]) + ); +}, 'withInstanceId')); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-safe-timeout/index.js + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/** + * A higher-order component used to provide and manage delayed function calls + * that ought to be bound to a component's lifecycle. + * + * @param {Component} OriginalComponent Component requiring setTimeout + * + * @return {Component} Wrapped component. + */ + +var withSafeTimeout = create_higher_order_component(function (OriginalComponent) { + return ( + /*#__PURE__*/ + function (_Component) { + Object(inherits["a" /* default */])(WrappedComponent, _Component); + + function WrappedComponent() { + var _this; + + Object(classCallCheck["a" /* default */])(this, WrappedComponent); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments)); + _this.timeouts = []; + _this.setTimeout = _this.setTimeout.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.clearTimeout = _this.clearTimeout.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(WrappedComponent, [{ + key: "componentWillUnmount", + value: function componentWillUnmount() { + this.timeouts.forEach(clearTimeout); + } + }, { + key: "setTimeout", + value: function (_setTimeout) { + function setTimeout(_x, _x2) { + return _setTimeout.apply(this, arguments); + } + + setTimeout.toString = function () { + return _setTimeout.toString(); + }; + + return setTimeout; + }(function (fn, delay) { + var _this2 = this; + + var id = setTimeout(function () { + fn(); + + _this2.clearTimeout(id); + }, delay); + this.timeouts.push(id); + return id; + }) + }, { + key: "clearTimeout", + value: function (_clearTimeout) { + function clearTimeout(_x3) { + return _clearTimeout.apply(this, arguments); + } + + clearTimeout.toString = function () { + return _clearTimeout.toString(); + }; + + return clearTimeout; + }(function (id) { + clearTimeout(id); + this.timeouts = Object(external_lodash_["without"])(this.timeouts, id); + }) + }, { + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, { + setTimeout: this.setTimeout, + clearTimeout: this.clearTimeout + })); + } + }]); + + return WrappedComponent; + }(external_this_wp_element_["Component"]) + ); +}, 'withSafeTimeout'); +/* harmony default export */ var with_safe_timeout = (withSafeTimeout); + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/with-state/index.js + + + + + + + + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + +/** + * A Higher Order Component used to provide and manage internal component state + * via props. + * + * @param {?Object} initialState Optional initial state of the component. + * + * @return {Component} Wrapped component. + */ + +function withState() { + var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + return create_higher_order_component(function (OriginalComponent) { + return ( + /*#__PURE__*/ + function (_Component) { + Object(inherits["a" /* default */])(WrappedComponent, _Component); + + function WrappedComponent() { + var _this; + + Object(classCallCheck["a" /* default */])(this, WrappedComponent); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WrappedComponent).apply(this, arguments)); + _this.setState = _this.setState.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = initialState; + return _this; + } + + Object(createClass["a" /* default */])(WrappedComponent, [{ + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, this.props, this.state, { + setState: this.setState + })); + } + }]); + + return WrappedComponent; + }(external_this_wp_element_["Component"]) + ); + }, 'withState'); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/index.js +/* concated harmony reexport createHigherOrderComponent */__webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return create_higher_order_component; }); +/* concated harmony reexport ifCondition */__webpack_require__.d(__webpack_exports__, "ifCondition", function() { return if_condition; }); +/* concated harmony reexport pure */__webpack_require__.d(__webpack_exports__, "pure", function() { return build_module_pure; }); +/* concated harmony reexport withGlobalEvents */__webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return with_global_events; }); +/* concated harmony reexport withInstanceId */__webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return with_instance_id; }); +/* concated harmony reexport withSafeTimeout */__webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return with_safe_timeout; }); +/* concated harmony reexport withState */__webpack_require__.d(__webpack_exports__, "withState", function() { return withState; }); +/* concated harmony reexport compose */__webpack_require__.d(__webpack_exports__, "compose", function() { return external_lodash_["flowRight"]; }); +/** + * External dependencies + */ + + + + + + + + +/** + * Composes multiple higher-order components into a single higher-order component. Performs right-to-left function + * composition, where each successive invocation is supplied the return value of the previous. + * + * @param {...Function} hocs The HOC functions to invoke. + * + * @return {Function} Returns the new composite function. + */ + + + + +/***/ }), + +/***/ 42: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["isShallowEqual"]; }()); + +/***/ }), + +/***/ 9: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; }); +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +/***/ }) + +/******/ }); \ No newline at end of file