/******/ 	return __webpack_require__(__webpack_require__.s = "ey5A");

/***/ "4eJC":

/***/ (function(module, exports, __webpack_require__) {

/**

 * Memize options object.

 *

 * @typedef MemizeOptions

 *

 * @property {number} [maxSize] Maximum size of the cache.

 */

/**

 * Internal cache entry.

 *

 * @typedef MemizeCacheNode

 *

 * @property {?MemizeCacheNode|undefined} [prev] Previous node.

 * @property {?MemizeCacheNode|undefined} [next] Next node.

 * @property {Array<*>}                   args   Function arguments for cache

 *                                               entry.

 * @property {*}                          val    Function result.

 */

/**

 * Properties of the enhanced function for controlling cache.

 *

 * @typedef MemizeMemoizedFunction

 *

 * @property {()=>void} clear Clear the cache.

 */

/**

 * Accepts a function to be memoized, and returns a new memoized function, with

 * optional options.

 *

 * @template {Function} F

 *

 * @param {F}             fn        Function to memoize.

 * @param {MemizeOptions} [options] Options object.

 *

 * @return {F & MemizeMemoizedFunction} Memoized function.

 */

function memize( fn, options ) {

	var size = 0;

	/** @type {?MemizeCacheNode|undefined} */

	var head;

	/** @type {?MemizeCacheNode|undefined} */

	var tail;

	options = options || {};

	function memoized( /* ...args */ ) {

		var node = head,

			len = arguments.length,

			args, i;

		searchCache: while ( node ) {

			// Perform a shallow equality test to confirm that whether the node

			// under test is a candidate for the arguments passed. Two arrays

			// are shallowly equal if their length matches and each entry is

			// strictly equal between the two sets. Avoid abstracting to a

			// function which could incur an arguments leaking deoptimization.

			// Check whether node arguments match arguments length

			if ( node.args.length !== arguments.length ) {

				node = node.next;

				continue;

			}

			// Check whether node arguments match arguments values

			for ( i = 0; i < len; i++ ) {

				if ( node.args[ i ] !== arguments[ i ] ) {

					node = node.next;

					continue searchCache;

				}

			}

			// At this point we can assume we've found a match

			// Surface matched node to head if not already

			if ( node !== head ) {

				// As tail, shift to previous. Must only shift if not also

				// head, since if both head and tail, there is no previous.

				if ( node === tail ) {

					tail = node.prev;

				}

				// Adjust siblings to point to each other. If node was tail,

				// this also handles new tail's empty `next` assignment.

				/** @type {MemizeCacheNode} */ ( node.prev ).next = node.next;

				if ( node.next ) {

					node.next.prev = node.prev;

				}

				node.next = head;

				node.prev = null;

				/** @type {MemizeCacheNode} */ ( head ).prev = node;

				head = node;

			}

			// Return immediately

			return node.val;

		}

		// No cached value found. Continue to insertion phase:

		// Create a copy of arguments (avoid leaking deoptimization)

		args = new Array( len );

		for ( i = 0; i < len; i++ ) {

			args[ i ] = arguments[ i ];

		}

		node = {

			args: args,

			// Generate the result from original function

			val: fn.apply( null, 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 ( head ) {

			head.prev = node;

			node.next = head;

		} else {

			// If no head, follows that there's no tail (at initial or reset)

			tail = node;

		}

		// Trim tail if we're reached max size and are pending cache insertion

		if ( size === /** @type {MemizeOptions} */ ( options ).maxSize ) {

			tail = /** @type {MemizeCacheNode} */ ( tail ).prev;

			/** @type {MemizeCacheNode} */ ( tail ).next = null;

		} else {

			size++;

		}

		head = node;

		return node.val;

	}

	memoized.clear = function() {

		head = null;

		tail = null;

		size = 0;

	};

	if ( false ) {}

	// Ignore reason: There's not a clear solution to create an intersection of

	// the function with additional properties, where the goal is to retain the

	// function signature of the incoming argument and add control properties

	// on the return value.

	// @ts-ignore

	return memoized;

module.exports = memize;

/***/ "GRId":

/***/ (function(module, exports) {

(function() { module.exports = window["wp"]["element"]; }());

/***/ }),

/***/ "K9lf":

/***/ (function(module, exports) {

(function() { module.exports = window["wp"]["compose"]; }());

/***/ }),

/***/ "Tqx9":

/***/ (function(module, exports) {

(function() { module.exports = window["wp"]["primitives"]; }());

/***/ }),

/***/ "YLtl":

/***/ (function(module, exports) {

(function() { module.exports = window["lodash"]; }());

/***/ }),

/***/ "ey5A":

__webpack_require__.d(__webpack_exports__, "withPluginContext", function() { return /* reexport */ withPluginContext; });

// EXTERNAL MODULE: external ["wp","element"]

var external_wp_element_ = __webpack_require__("GRId");

// EXTERNAL MODULE: external "lodash"

var external_lodash_ = __webpack_require__("YLtl");

// EXTERNAL MODULE: ./node_modules/memize/index.js

var memize = __webpack_require__("4eJC");

var memize_default = /*#__PURE__*/__webpack_require__.n(memize);

// EXTERNAL MODULE: external ["wp","hooks"]

var external_wp_hooks_ = __webpack_require__("g56x");

var esm_extends = __webpack_require__("wx14");

// EXTERNAL MODULE: external ["wp","compose"]

var external_wp_compose_ = __webpack_require__("K9lf");

const {

  Consumer,

  Provider

} = Object(external_wp_element_["createContext"])({

});

const withPluginContext = mapContextToProps => Object(external_wp_compose_["createHigherOrderComponent"])(OriginalComponent => {

  return props => Object(external_wp_element_["createElement"])(Consumer, null, context => Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, props, mapContextToProps(context, props))));

}, 'withPluginContext');

// EXTERNAL MODULE: external ["wp","primitives"]

var external_wp_primitives_ = __webpack_require__("Tqx9");

// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/plugins.js

/**

 * WordPress dependencies

 */

const plugins = Object(external_wp_element_["createElement"])(external_wp_primitives_["SVG"], {

  xmlns: "http://www.w3.org/2000/svg",

  viewBox: "0 0 24 24"

}, Object(external_wp_element_["createElement"])(external_wp_primitives_["Path"], {

  d: "M10.5 4v4h3V4H15v4h1.5a1 1 0 011 1v4l-3 4v2a1 1 0 01-1 1h-3a1 1 0 01-1-1v-2l-3-4V9a1 1 0 011-1H9V4h1.5zm.5 12.5v2h2v-2l3-4v-3H8v3l3 4z"

}));

/* harmony default export */ var library_plugins = (plugins);