PayPlug for WooCommerce (Official) / 3.1.0

PayPlug for WooCommerce (Official) v3.1.0

payplug / assets / js / blocks / wc-payplug-mybank-blocks.js

wc-payplug-mybank-blocks.js in PayPlug for WooCommerce (Official) 3.1.0, at assets/js/blocks/wc-payplug-mybank-blocks.js

1,561 lines 49.9 KB

Raw Download Zip

1	/******/ (() => { // webpackBootstrap
2	/******/ "use strict";
3	/******/ var __webpack_modules__ = ({
4
5	/***/ "./node_modules/react/cjs/react-jsx-runtime.development.js":
6	/!***************************************************************!\
7	!* ./node_modules/react/cjs/react-jsx-runtime.development.js *!
8	\*****************************************************************/
9	/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
10
11	/**
12	* @license React
13	* react-jsx-runtime.development.js
14	*
15	* Copyright (c) Facebook, Inc. and its affiliates.
16	*
17	* This source code is licensed under the MIT license found in the
18	* LICENSE file in the root directory of this source tree.
19	*/
20
21
22
23	if (true) {
24	(function() {
25	'use strict';
26
27	var React = __webpack_require__(/! react / "react");
28
29	// ATTENTION
30	// When adding new symbols to this file,
31	// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
32	// The Symbol used to tag the ReactElement-like types.
33	var REACT_ELEMENT_TYPE = Symbol.for('react.element');
34	var REACT_PORTAL_TYPE = Symbol.for('react.portal');
35	var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
36	var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
37	var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
38	var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
39	var REACT_CONTEXT_TYPE = Symbol.for('react.context');
40	var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
41	var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
42	var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
43	var REACT_MEMO_TYPE = Symbol.for('react.memo');
44	var REACT_LAZY_TYPE = Symbol.for('react.lazy');
45	var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
46	var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
47	var FAUX_ITERATOR_SYMBOL = '@@iterator';
48	function getIteratorFn(maybeIterable) {
49	if (maybeIterable === null \|\| typeof maybeIterable !== 'object') {
50	return null;
51	}
52
53	var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] \|\| maybeIterable[FAUX_ITERATOR_SYMBOL];
54
55	if (typeof maybeIterator === 'function') {
56	return maybeIterator;
57	}
58
59	return null;
60	}
61
62	var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
63
64	function error(format) {
65	{
66	{
67	for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
68	args[_key2 - 1] = arguments[_key2];
69	}
70
71	printWarning('error', format, args);
72	}
73	}
74	}
75
76	function printWarning(level, format, args) {
77	// When changing this logic, you might want to also
78	// update consoleWithStackDev.www.js as well.
79	{
80	var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
81	var stack = ReactDebugCurrentFrame.getStackAddendum();
82
83	if (stack !== '') {
84	format += '%s';
85	args = args.concat([stack]);
86	} // eslint-disable-next-line react-internal/safe-string-coercion
87
88
89	var argsWithFormat = args.map(function (item) {
90	return String(item);
91	}); // Careful: RN currently depends on this prefix
92
93	argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
94	// breaks IE9: https://github.com/facebook/react/issues/13610
95	// eslint-disable-next-line react-internal/no-production-logging
96
97	Function.prototype.apply.call(console[level], console, argsWithFormat);
98	}
99	}
100
101	// -----------------------------------------------------------------------------
102
103	var enableScopeAPI = false; // Experimental Create Event Handle API.
104	var enableCacheElement = false;
105	var enableTransitionTracing = false; // No known bugs, but needs performance testing
106
107	var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
108	// stuff. Intended to enable React core members to more easily debug scheduling
109	// issues in DEV builds.
110
111	var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
112
113	var REACT_MODULE_REFERENCE;
114
115	{
116	REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
117	}
118
119	function isValidElementType(type) {
120	if (typeof type === 'string' \|\| typeof type === 'function') {
121	return true;
122	} // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
123
124
125	if (type === REACT_FRAGMENT_TYPE \|\| type === REACT_PROFILER_TYPE \|\| enableDebugTracing \|\| type === REACT_STRICT_MODE_TYPE \|\| type === REACT_SUSPENSE_TYPE \|\| type === REACT_SUSPENSE_LIST_TYPE \|\| enableLegacyHidden \|\| type === REACT_OFFSCREEN_TYPE \|\| enableScopeAPI \|\| enableCacheElement \|\| enableTransitionTracing ) {
126	return true;
127	}
128
129	if (typeof type === 'object' && type !== null) {
130	if (type.$$typeof === REACT_LAZY_TYPE \|\| type.$$typeof === REACT_MEMO_TYPE \|\| type.$$typeof === REACT_PROVIDER_TYPE \|\| type.$$typeof === REACT_CONTEXT_TYPE \|\| type.$$typeof === REACT_FORWARD_REF_TYPE \|\| // This needs to include all possible module reference object
131	// types supported by any Flight configuration anywhere since
132	// we don't know which Flight build this will end up being used
133	// with.
134	type.$$typeof === REACT_MODULE_REFERENCE \|\| type.getModuleId !== undefined) {
135	return true;
136	}
137	}
138
139	return false;
140	}
141
142	function getWrappedName(outerType, innerType, wrapperName) {
143	var displayName = outerType.displayName;
144
145	if (displayName) {
146	return displayName;
147	}
148
149	var functionName = innerType.displayName \|\| innerType.name \|\| '';
150	return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
151	} // Keep in sync with react-reconciler/getComponentNameFromFiber
152
153
154	function getContextName(type) {
155	return type.displayName \|\| 'Context';
156	} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
157
158
159	function getComponentNameFromType(type) {
160	if (type == null) {
161	// Host root, text node or just invalid type.
162	return null;
163	}
164
165	{
166	if (typeof type.tag === 'number') {
167	error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
168	}
169	}
170
171	if (typeof type === 'function') {
172	return type.displayName \|\| type.name \|\| null;
173	}
174
175	if (typeof type === 'string') {
176	return type;
177	}
178
179	switch (type) {
180	case REACT_FRAGMENT_TYPE:
181	return 'Fragment';
182
183	case REACT_PORTAL_TYPE:
184	return 'Portal';
185
186	case REACT_PROFILER_TYPE:
187	return 'Profiler';
188
189	case REACT_STRICT_MODE_TYPE:
190	return 'StrictMode';
191
192	case REACT_SUSPENSE_TYPE:
193	return 'Suspense';
194
195	case REACT_SUSPENSE_LIST_TYPE:
196	return 'SuspenseList';
197
198	}
199
200	if (typeof type === 'object') {
201	switch (type.$$typeof) {
202	case REACT_CONTEXT_TYPE:
203	var context = type;
204	return getContextName(context) + '.Consumer';
205
206	case REACT_PROVIDER_TYPE:
207	var provider = type;
208	return getContextName(provider._context) + '.Provider';
209
210	case REACT_FORWARD_REF_TYPE:
211	return getWrappedName(type, type.render, 'ForwardRef');
212
213	case REACT_MEMO_TYPE:
214	var outerName = type.displayName \|\| null;
215
216	if (outerName !== null) {
217	return outerName;
218	}
219
220	return getComponentNameFromType(type.type) \|\| 'Memo';
221
222	case REACT_LAZY_TYPE:
223	{
224	var lazyComponent = type;
225	var payload = lazyComponent._payload;
226	var init = lazyComponent._init;
227
228	try {
229	return getComponentNameFromType(init(payload));
230	} catch (x) {
231	return null;
232	}
233	}
234
235	// eslint-disable-next-line no-fallthrough
236	}
237	}
238
239	return null;
240	}
241
242	var assign = Object.assign;
243
244	// Helpers to patch console.logs to avoid logging during side-effect free
245	// replaying on render function. This currently only patches the object
246	// lazily which won't cover if the log function was extracted eagerly.
247	// We could also eagerly patch the method.
248	var disabledDepth = 0;
249	var prevLog;
250	var prevInfo;
251	var prevWarn;
252	var prevError;
253	var prevGroup;
254	var prevGroupCollapsed;
255	var prevGroupEnd;
256
257	function disabledLog() {}
258
259	disabledLog.__reactDisabledLog = true;
260	function disableLogs() {
261	{
262	if (disabledDepth === 0) {
263	/* eslint-disable react-internal/no-production-logging */
264	prevLog = console.log;
265	prevInfo = console.info;
266	prevWarn = console.warn;
267	prevError = console.error;
268	prevGroup = console.group;
269	prevGroupCollapsed = console.groupCollapsed;
270	prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
271
272	var props = {
273	configurable: true,
274	enumerable: true,
275	value: disabledLog,
276	writable: true
277	}; // $FlowFixMe Flow thinks console is immutable.
278
279	Object.defineProperties(console, {
280	info: props,
281	log: props,
282	warn: props,
283	error: props,
284	group: props,
285	groupCollapsed: props,
286	groupEnd: props
287	});
288	/* eslint-enable react-internal/no-production-logging */
289	}
290
291	disabledDepth++;
292	}
293	}
294	function reenableLogs() {
295	{
296	disabledDepth--;
297
298	if (disabledDepth === 0) {
299	/* eslint-disable react-internal/no-production-logging */
300	var props = {
301	configurable: true,
302	enumerable: true,
303	writable: true
304	}; // $FlowFixMe Flow thinks console is immutable.
305
306	Object.defineProperties(console, {
307	log: assign({}, props, {
308	value: prevLog
309	}),
310	info: assign({}, props, {
311	value: prevInfo
312	}),
313	warn: assign({}, props, {
314	value: prevWarn
315	}),
316	error: assign({}, props, {
317	value: prevError
318	}),
319	group: assign({}, props, {
320	value: prevGroup
321	}),
322	groupCollapsed: assign({}, props, {
323	value: prevGroupCollapsed
324	}),
325	groupEnd: assign({}, props, {
326	value: prevGroupEnd
327	})
328	});
329	/* eslint-enable react-internal/no-production-logging */
330	}
331
332	if (disabledDepth < 0) {
333	error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
334	}
335	}
336	}
337
338	var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
339	var prefix;
340	function describeBuiltInComponentFrame(name, source, ownerFn) {
341	{
342	if (prefix === undefined) {
343	// Extract the VM specific prefix used by each line.
344	try {
345	throw Error();
346	} catch (x) {
347	var match = x.stack.trim().match(/\n( *(at )?)/);
348	prefix = match && match[1] \|\| '';
349	}
350	} // We use the prefix to ensure our stacks line up with native stack frames.
351
352
353	return '\n' + prefix + name;
354	}
355	}
356	var reentry = false;
357	var componentFrameCache;
358
359	{
360	var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
361	componentFrameCache = new PossiblyWeakMap();
362	}
363
364	function describeNativeComponentFrame(fn, construct) {
365	// If something asked for a stack inside a fake render, it should get ignored.
366	if ( !fn \|\| reentry) {
367	return '';
368	}
369
370	{
371	var frame = componentFrameCache.get(fn);
372
373	if (frame !== undefined) {
374	return frame;
375	}
376	}
377
378	var control;
379	reentry = true;
380	var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
381
382	Error.prepareStackTrace = undefined;
383	var previousDispatcher;
384
385	{
386	previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
387	// for warnings.
388
389	ReactCurrentDispatcher.current = null;
390	disableLogs();
391	}
392
393	try {
394	// This should throw.
395	if (construct) {
396	// Something should be setting the props in the constructor.
397	var Fake = function () {
398	throw Error();
399	}; // $FlowFixMe
400
401
402	Object.defineProperty(Fake.prototype, 'props', {
403	set: function () {
404	// We use a throwing setter instead of frozen or non-writable props
405	// because that won't throw in a non-strict mode function.
406	throw Error();
407	}
408	});
409
410	if (typeof Reflect === 'object' && Reflect.construct) {
411	// We construct a different control for this case to include any extra
412	// frames added by the construct call.
413	try {
414	Reflect.construct(Fake, []);
415	} catch (x) {
416	control = x;
417	}
418
419	Reflect.construct(fn, [], Fake);
420	} else {
421	try {
422	Fake.call();
423	} catch (x) {
424	control = x;
425	}
426
427	fn.call(Fake.prototype);
428	}
429	} else {
430	try {
431	throw Error();
432	} catch (x) {
433	control = x;
434	}
435
436	fn();
437	}
438	} catch (sample) {
439	// This is inlined manually because closure doesn't do it for us.
440	if (sample && control && typeof sample.stack === 'string') {
441	// This extracts the first frame from the sample that isn't also in the control.
442	// Skipping one frame that we assume is the frame that calls the two.
443	var sampleLines = sample.stack.split('\n');
444	var controlLines = control.stack.split('\n');
445	var s = sampleLines.length - 1;
446	var c = controlLines.length - 1;
447
448	while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
449	// We expect at least one stack frame to be shared.
450	// Typically this will be the root most one. However, stack frames may be
451	// cut off due to maximum stack limits. In this case, one maybe cut off
452	// earlier than the other. We assume that the sample is longer or the same
453	// and there for cut off earlier. So we should find the root most frame in
454	// the sample somewhere in the control.
455	c--;
456	}
457
458	for (; s >= 1 && c >= 0; s--, c--) {
459	// Next we find the first one that isn't the same which should be the
460	// frame that called our sample function and the control.
461	if (sampleLines[s] !== controlLines[c]) {
462	// In V8, the first line is describing the message but other VMs don't.
463	// If we're about to return the first line, and the control is also on the same
464	// line, that's a pretty good indicator that our sample threw at same line as
465	// the control. I.e. before we entered the sample frame. So we ignore this result.
466	// This can happen if you passed a class to function component, or non-function.
467	if (s !== 1 \|\| c !== 1) {
468	do {
469	s--;
470	c--; // We may still have similar intermediate frames from the construct call.
471	// The next one that isn't the same should be our match though.
472
473	if (c < 0 \|\| sampleLines[s] !== controlLines[c]) {
474	// V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
475	var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
476	// but we have a user-provided "displayName"
477	// splice it in to make the stack more readable.
478
479
480	if (fn.displayName && _frame.includes('<anonymous>')) {
481	_frame = _frame.replace('<anonymous>', fn.displayName);
482	}
483
484	{
485	if (typeof fn === 'function') {
486	componentFrameCache.set(fn, _frame);
487	}
488	} // Return the line we found.
489
490
491	return _frame;
492	}
493	} while (s >= 1 && c >= 0);
494	}
495
496	break;
497	}
498	}
499	}
500	} finally {
501	reentry = false;
502
503	{
504	ReactCurrentDispatcher.current = previousDispatcher;
505	reenableLogs();
506	}
507
508	Error.prepareStackTrace = previousPrepareStackTrace;
509	} // Fallback to just using the name if we couldn't make it throw.
510
511
512	var name = fn ? fn.displayName \|\| fn.name : '';
513	var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
514
515	{
516	if (typeof fn === 'function') {
517	componentFrameCache.set(fn, syntheticFrame);
518	}
519	}
520
521	return syntheticFrame;
522	}
523	function describeFunctionComponentFrame(fn, source, ownerFn) {
524	{
525	return describeNativeComponentFrame(fn, false);
526	}
527	}
528
529	function shouldConstruct(Component) {
530	var prototype = Component.prototype;
531	return !!(prototype && prototype.isReactComponent);
532	}
533
534	function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
535
536	if (type == null) {
537	return '';
538	}
539
540	if (typeof type === 'function') {
541	{
542	return describeNativeComponentFrame(type, shouldConstruct(type));
543	}
544	}
545
546	if (typeof type === 'string') {
547	return describeBuiltInComponentFrame(type);
548	}
549
550	switch (type) {
551	case REACT_SUSPENSE_TYPE:
552	return describeBuiltInComponentFrame('Suspense');
553
554	case REACT_SUSPENSE_LIST_TYPE:
555	return describeBuiltInComponentFrame('SuspenseList');
556	}
557
558	if (typeof type === 'object') {
559	switch (type.$$typeof) {
560	case REACT_FORWARD_REF_TYPE:
561	return describeFunctionComponentFrame(type.render);
562
563	case REACT_MEMO_TYPE:
564	// Memo may contain any component type so we recursively resolve it.
565	return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
566
567	case REACT_LAZY_TYPE:
568	{
569	var lazyComponent = type;
570	var payload = lazyComponent._payload;
571	var init = lazyComponent._init;
572
573	try {
574	// Lazy may contain any component type so we recursively resolve it.
575	return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
576	} catch (x) {}
577	}
578	}
579	}
580
581	return '';
582	}
583
584	var hasOwnProperty = Object.prototype.hasOwnProperty;
585
586	var loggedTypeFailures = {};
587	var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
588
589	function setCurrentlyValidatingElement(element) {
590	{
591	if (element) {
592	var owner = element._owner;
593	var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
594	ReactDebugCurrentFrame.setExtraStackFrame(stack);
595	} else {
596	ReactDebugCurrentFrame.setExtraStackFrame(null);
597	}
598	}
599	}
600
601	function checkPropTypes(typeSpecs, values, location, componentName, element) {
602	{
603	// $FlowFixMe This is okay but Flow doesn't know it.
604	var has = Function.call.bind(hasOwnProperty);
605
606	for (var typeSpecName in typeSpecs) {
607	if (has(typeSpecs, typeSpecName)) {
608	var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
609	// fail the render phase where it didn't fail before. So we log it.
610	// After these have been cleaned up, we'll let them throw.
611
612	try {
613	// This is intentionally an invariant that gets caught. It's the same
614	// behavior as without this statement except with a better message.
615	if (typeof typeSpecs[typeSpecName] !== 'function') {
616	// eslint-disable-next-line react-internal/prod-error-codes
617	var err = Error((componentName \|\| 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
618	err.name = 'Invariant Violation';
619	throw err;
620	}
621
622	error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
623	} catch (ex) {
624	error$1 = ex;
625	}
626
627	if (error$1 && !(error$1 instanceof Error)) {
628	setCurrentlyValidatingElement(element);
629
630	error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName \|\| 'React class', location, typeSpecName, typeof error$1);
631
632	setCurrentlyValidatingElement(null);
633	}
634
635	if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
636	// Only monitor this failure once because there tends to be a lot of the
637	// same error.
638	loggedTypeFailures[error$1.message] = true;
639	setCurrentlyValidatingElement(element);
640
641	error('Failed %s type: %s', location, error$1.message);
642
643	setCurrentlyValidatingElement(null);
644	}
645	}
646	}
647	}
648	}
649
650	var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
651
652	function isArray(a) {
653	return isArrayImpl(a);
654	}
655
656	/*
657	* The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
658	* and Temporal.* types. See https://github.com/facebook/react/pull/22064.
659	*
660	* The functions in this module will throw an easier-to-understand,
661	* easier-to-debug exception with a clear errors message message explaining the
662	* problem. (Instead of a confusing exception thrown inside the implementation
663	* of the `value` object).
664	*/
665	// $FlowFixMe only called in DEV, so void return is not possible.
666	function typeName(value) {
667	{
668	// toStringTag is needed for namespaced types like Temporal.Instant
669	var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
670	var type = hasToStringTag && value[Symbol.toStringTag] \|\| value.constructor.name \|\| 'Object';
671	return type;
672	}
673	} // $FlowFixMe only called in DEV, so void return is not possible.
674
675
676	function willCoercionThrow(value) {
677	{
678	try {
679	testStringCoercion(value);
680	return false;
681	} catch (e) {
682	return true;
683	}
684	}
685	}
686
687	function testStringCoercion(value) {
688	// If you ended up here by following an exception call stack, here's what's
689	// happened: you supplied an object or symbol value to React (as a prop, key,
690	// DOM attribute, CSS property, string ref, etc.) and when React tried to
691	// coerce it to a string using `'' + value`, an exception was thrown.
692	//
693	// The most common types that will cause this exception are `Symbol` instances
694	// and Temporal objects like `Temporal.Instant`. But any object that has a
695	// `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
696	// exception. (Library authors do this to prevent users from using built-in
697	// numeric operators like `+` or comparison operators like `>=` because custom
698	// methods are needed to perform accurate arithmetic or comparison.)
699	//
700	// To fix the problem, coerce this object or symbol value to a string before
701	// passing it to React. The most reliable way is usually `String(value)`.
702	//
703	// To find which value is throwing, check the browser or debugger console.
704	// Before this exception was thrown, there should be `console.error` output
705	// that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
706	// problem and how that type was used: key, atrribute, input value prop, etc.
707	// In most cases, this console output also shows the component and its
708	// ancestor components where the exception happened.
709	//
710	// eslint-disable-next-line react-internal/safe-string-coercion
711	return '' + value;
712	}
713	function checkKeyStringCoercion(value) {
714	{
715	if (willCoercionThrow(value)) {
716	error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
717
718	return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
719	}
720	}
721	}
722
723	var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
724	var RESERVED_PROPS = {
725	key: true,
726	ref: true,
727	__self: true,
728	__source: true
729	};
730	var specialPropKeyWarningShown;
731	var specialPropRefWarningShown;
732	var didWarnAboutStringRefs;
733
734	{
735	didWarnAboutStringRefs = {};
736	}
737
738	function hasValidRef(config) {
739	{
740	if (hasOwnProperty.call(config, 'ref')) {
741	var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
742
743	if (getter && getter.isReactWarning) {
744	return false;
745	}
746	}
747	}
748
749	return config.ref !== undefined;
750	}
751
752	function hasValidKey(config) {
753	{
754	if (hasOwnProperty.call(config, 'key')) {
755	var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
756
757	if (getter && getter.isReactWarning) {
758	return false;
759	}
760	}
761	}
762
763	return config.key !== undefined;
764	}
765
766	function warnIfStringRefCannotBeAutoConverted(config, self) {
767	{
768	if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
769	var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
770
771	if (!didWarnAboutStringRefs[componentName]) {
772	error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
773
774	didWarnAboutStringRefs[componentName] = true;
775	}
776	}
777	}
778	}
779
780	function defineKeyPropWarningGetter(props, displayName) {
781	{
782	var warnAboutAccessingKey = function () {
783	if (!specialPropKeyWarningShown) {
784	specialPropKeyWarningShown = true;
785
786	error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
787	}
788	};
789
790	warnAboutAccessingKey.isReactWarning = true;
791	Object.defineProperty(props, 'key', {
792	get: warnAboutAccessingKey,
793	configurable: true
794	});
795	}
796	}
797
798	function defineRefPropWarningGetter(props, displayName) {
799	{
800	var warnAboutAccessingRef = function () {
801	if (!specialPropRefWarningShown) {
802	specialPropRefWarningShown = true;
803
804	error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
805	}
806	};
807
808	warnAboutAccessingRef.isReactWarning = true;
809	Object.defineProperty(props, 'ref', {
810	get: warnAboutAccessingRef,
811	configurable: true
812	});
813	}
814	}
815	/**
816	* Factory method to create a new React element. This no longer adheres to
817	* the class pattern, so do not use new to call it. Also, instanceof check
818	* will not work. Instead test $$typeof field against Symbol.for('react.element') to check
819	* if something is a React Element.
820	*
821	* @param {*} type
822	* @param {*} props
823	* @param {*} key
824	* @param {string\|object} ref
825	* @param {*} owner
826	* @param {} self A temporary* helper to detect places where `this` is
827	* different from the `owner` when React.createElement is called, so that we
828	* can warn. We want to get rid of owner and replace string `ref`s with arrow
829	* functions, and as long as `this` and owner are the same, there will be no
830	* change in behavior.
831	* @param {*} source An annotation object (added by a transpiler or otherwise)
832	* indicating filename, line number, and/or other information.
833	* @internal
834	*/
835
836
837	var ReactElement = function (type, key, ref, self, source, owner, props) {
838	var element = {
839	// This tag allows us to uniquely identify this as a React Element
840	$$typeof: REACT_ELEMENT_TYPE,
841	// Built-in properties that belong on the element
842	type: type,
843	key: key,
844	ref: ref,
845	props: props,
846	// Record the component responsible for creating this element.
847	_owner: owner
848	};
849
850	{
851	// The validation flag is currently mutative. We put it on
852	// an external backing store so that we can freeze the whole object.
853	// This can be replaced with a WeakMap once they are implemented in
854	// commonly used development environments.
855	element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
856	// the validation flag non-enumerable (where possible, which should
857	// include every environment we run tests in), so the test framework
858	// ignores it.
859
860	Object.defineProperty(element._store, 'validated', {
861	configurable: false,
862	enumerable: false,
863	writable: true,
864	value: false
865	}); // self and source are DEV only properties.
866
867	Object.defineProperty(element, '_self', {
868	configurable: false,
869	enumerable: false,
870	writable: false,
871	value: self
872	}); // Two elements created in two different places should be considered
873	// equal for testing purposes and therefore we hide it from enumeration.
874
875	Object.defineProperty(element, '_source', {
876	configurable: false,
877	enumerable: false,
878	writable: false,
879	value: source
880	});
881
882	if (Object.freeze) {
883	Object.freeze(element.props);
884	Object.freeze(element);
885	}
886	}
887
888	return element;
889	};
890	/**
891	* https://github.com/reactjs/rfcs/pull/107
892	* @param {*} type
893	* @param {object} props
894	* @param {string} key
895	*/
896
897	function jsxDEV(type, config, maybeKey, source, self) {
898	{
899	var propName; // Reserved names are extracted
900
901	var props = {};
902	var key = null;
903	var ref = null; // Currently, key can be spread in as a prop. This causes a potential
904	// issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
905	// or <div key="Hi" {...props} /> ). We want to deprecate key spread,
906	// but as an intermediary step, we will use jsxDEV for everything except
907	// <div {...props} key="Hi" />, because we aren't currently able to tell if
908	// key is explicitly declared to be undefined or not.
909
910	if (maybeKey !== undefined) {
911	{
912	checkKeyStringCoercion(maybeKey);
913	}
914
915	key = '' + maybeKey;
916	}
917
918	if (hasValidKey(config)) {
919	{
920	checkKeyStringCoercion(config.key);
921	}
922
923	key = '' + config.key;
924	}
925
926	if (hasValidRef(config)) {
927	ref = config.ref;
928	warnIfStringRefCannotBeAutoConverted(config, self);
929	} // Remaining properties are added to a new props object
930
931
932	for (propName in config) {
933	if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
934	props[propName] = config[propName];
935	}
936	} // Resolve default props
937
938
939	if (type && type.defaultProps) {
940	var defaultProps = type.defaultProps;
941
942	for (propName in defaultProps) {
943	if (props[propName] === undefined) {
944	props[propName] = defaultProps[propName];
945	}
946	}
947	}
948
949	if (key \|\| ref) {
950	var displayName = typeof type === 'function' ? type.displayName \|\| type.name \|\| 'Unknown' : type;
951
952	if (key) {
953	defineKeyPropWarningGetter(props, displayName);
954	}
955
956	if (ref) {
957	defineRefPropWarningGetter(props, displayName);
958	}
959	}
960
961	return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
962	}
963	}
964
965	var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
966	var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
967
968	function setCurrentlyValidatingElement$1(element) {
969	{
970	if (element) {
971	var owner = element._owner;
972	var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
973	ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
974	} else {
975	ReactDebugCurrentFrame$1.setExtraStackFrame(null);
976	}
977	}
978	}
979
980	var propTypesMisspellWarningShown;
981
982	{
983	propTypesMisspellWarningShown = false;
984	}
985	/**
986	* Verifies the object is a ReactElement.
987	* See https://reactjs.org/docs/react-api.html#isvalidelement
988	* @param {?object} object
989	* @return {boolean} True if `object` is a ReactElement.
990	* @final
991	*/
992
993
994	function isValidElement(object) {
995	{
996	return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
997	}
998	}
999
1000	function getDeclarationErrorAddendum() {
1001	{
1002	if (ReactCurrentOwner$1.current) {
1003	var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
1004
1005	if (name) {
1006	return '\n\nCheck the render method of `' + name + '`.';
1007	}
1008	}
1009
1010	return '';
1011	}
1012	}
1013
1014	function getSourceInfoErrorAddendum(source) {
1015	{
1016	if (source !== undefined) {
1017	var fileName = source.fileName.replace(/^.*[\\\/]/, '');
1018	var lineNumber = source.lineNumber;
1019	return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
1020	}
1021
1022	return '';
1023	}
1024	}
1025	/**
1026	* Warn if there's no key explicitly set on dynamic arrays of children or
1027	* object keys are not valid. This allows us to keep track of children between
1028	* updates.
1029	*/
1030
1031
1032	var ownerHasKeyUseWarning = {};
1033
1034	function getCurrentComponentErrorInfo(parentType) {
1035	{
1036	var info = getDeclarationErrorAddendum();
1037
1038	if (!info) {
1039	var parentName = typeof parentType === 'string' ? parentType : parentType.displayName \|\| parentType.name;
1040
1041	if (parentName) {
1042	info = "\n\nCheck the top-level render call using <" + parentName + ">.";
1043	}
1044	}
1045
1046	return info;
1047	}
1048	}
1049	/**
1050	* Warn if the element doesn't have an explicit key assigned to it.
1051	* This element is in an array. The array could grow and shrink or be
1052	* reordered. All children that haven't already been validated are required to
1053	* have a "key" property assigned to it. Error statuses are cached so a warning
1054	* will only be shown once.
1055	*
1056	* @internal
1057	* @param {ReactElement} element Element that requires a key.
1058	* @param {*} parentType element's parent's type.
1059	*/
1060
1061
1062	function validateExplicitKey(element, parentType) {
1063	{
1064	if (!element._store \|\| element._store.validated \|\| element.key != null) {
1065	return;
1066	}
1067
1068	element._store.validated = true;
1069	var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
1070
1071	if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
1072	return;
1073	}
1074
1075	ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
1076	// property, it may be the creator of the child that's responsible for
1077	// assigning it a key.
1078
1079	var childOwner = '';
1080
1081	if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
1082	// Give the component that originally created this child.
1083	childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
1084	}
1085
1086	setCurrentlyValidatingElement$1(element);
1087
1088	error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
1089
1090	setCurrentlyValidatingElement$1(null);
1091	}
1092	}
1093	/**
1094	* Ensure that every element either is passed in a static location, in an
1095	* array with an explicit keys property defined, or in an object literal
1096	* with valid key property.
1097	*
1098	* @internal
1099	* @param {ReactNode} node Statically passed child of any type.
1100	* @param {*} parentType node's parent's type.
1101	*/
1102
1103
1104	function validateChildKeys(node, parentType) {
1105	{
1106	if (typeof node !== 'object') {
1107	return;
1108	}
1109
1110	if (isArray(node)) {
1111	for (var i = 0; i < node.length; i++) {
1112	var child = node[i];
1113
1114	if (isValidElement(child)) {
1115	validateExplicitKey(child, parentType);
1116	}
1117	}
1118	} else if (isValidElement(node)) {
1119	// This element was passed in a valid location.
1120	if (node._store) {
1121	node._store.validated = true;
1122	}
1123	} else if (node) {
1124	var iteratorFn = getIteratorFn(node);
1125
1126	if (typeof iteratorFn === 'function') {
1127	// Entry iterators used to provide implicit keys,
1128	// but now we print a separate warning for them later.
1129	if (iteratorFn !== node.entries) {
1130	var iterator = iteratorFn.call(node);
1131	var step;
1132
1133	while (!(step = iterator.next()).done) {
1134	if (isValidElement(step.value)) {
1135	validateExplicitKey(step.value, parentType);
1136	}
1137	}
1138	}
1139	}
1140	}
1141	}
1142	}
1143	/**
1144	* Given an element, validate that its props follow the propTypes definition,
1145	* provided by the type.
1146	*
1147	* @param {ReactElement} element
1148	*/
1149
1150
1151	function validatePropTypes(element) {
1152	{
1153	var type = element.type;
1154
1155	if (type === null \|\| type === undefined \|\| typeof type === 'string') {
1156	return;
1157	}
1158
1159	var propTypes;
1160
1161	if (typeof type === 'function') {
1162	propTypes = type.propTypes;
1163	} else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE \|\| // Note: Memo only checks outer props here.
1164	// Inner props are checked in the reconciler.
1165	type.$$typeof === REACT_MEMO_TYPE)) {
1166	propTypes = type.propTypes;
1167	} else {
1168	return;
1169	}
1170
1171	if (propTypes) {
1172	// Intentionally inside to avoid triggering lazy initializers:
1173	var name = getComponentNameFromType(type);
1174	checkPropTypes(propTypes, element.props, 'prop', name, element);
1175	} else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
1176	propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
1177
1178	var _name = getComponentNameFromType(type);
1179
1180	error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name \|\| 'Unknown');
1181	}
1182
1183	if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
1184	error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
1185	}
1186	}
1187	}
1188	/**
1189	* Given a fragment, validate that it can only be provided with fragment props
1190	* @param {ReactElement} fragment
1191	*/
1192
1193
1194	function validateFragmentProps(fragment) {
1195	{
1196	var keys = Object.keys(fragment.props);
1197
1198	for (var i = 0; i < keys.length; i++) {
1199	var key = keys[i];
1200
1201	if (key !== 'children' && key !== 'key') {
1202	setCurrentlyValidatingElement$1(fragment);
1203
1204	error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
1205
1206	setCurrentlyValidatingElement$1(null);
1207	break;
1208	}
1209	}
1210
1211	if (fragment.ref !== null) {
1212	setCurrentlyValidatingElement$1(fragment);
1213
1214	error('Invalid attribute `ref` supplied to `React.Fragment`.');
1215
1216	setCurrentlyValidatingElement$1(null);
1217	}
1218	}
1219	}
1220
1221	var didWarnAboutKeySpread = {};
1222	function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
1223	{
1224	var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
1225	// succeed and there will likely be errors in render.
1226
1227	if (!validType) {
1228	var info = '';
1229
1230	if (type === undefined \|\| typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
1231	info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
1232	}
1233
1234	var sourceInfo = getSourceInfoErrorAddendum(source);
1235
1236	if (sourceInfo) {
1237	info += sourceInfo;
1238	} else {
1239	info += getDeclarationErrorAddendum();
1240	}
1241
1242	var typeString;
1243
1244	if (type === null) {
1245	typeString = 'null';
1246	} else if (isArray(type)) {
1247	typeString = 'array';
1248	} else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
1249	typeString = "<" + (getComponentNameFromType(type.type) \|\| 'Unknown') + " />";
1250	info = ' Did you accidentally export a JSX literal instead of a component?';
1251	} else {
1252	typeString = typeof type;
1253	}
1254
1255	error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
1256	}
1257
1258	var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used.
1259	// TODO: Drop this when these are no longer allowed as the type argument.
1260
1261	if (element == null) {
1262	return element;
1263	} // Skip key warning if the type isn't valid since our key validation logic
1264	// doesn't expect a non-string/function type and can throw confusing errors.
1265	// We don't want exception behavior to differ between dev and prod.
1266	// (Rendering will throw with a helpful message and as soon as the type is
1267	// fixed, the key warnings will appear.)
1268
1269
1270	if (validType) {
1271	var children = props.children;
1272
1273	if (children !== undefined) {
1274	if (isStaticChildren) {
1275	if (isArray(children)) {
1276	for (var i = 0; i < children.length; i++) {
1277	validateChildKeys(children[i], type);
1278	}
1279
1280	if (Object.freeze) {
1281	Object.freeze(children);
1282	}
1283	} else {
1284	error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.');
1285	}
1286	} else {
1287	validateChildKeys(children, type);
1288	}
1289	}
1290	}
1291
1292	{
1293	if (hasOwnProperty.call(props, 'key')) {
1294	var componentName = getComponentNameFromType(type);
1295	var keys = Object.keys(props).filter(function (k) {
1296	return k !== 'key';
1297	});
1298	var beforeExample = keys.length > 0 ? '{key: someKey, ' + keys.join(': ..., ') + ': ...}' : '{key: someKey}';
1299
1300	if (!didWarnAboutKeySpread[componentName + beforeExample]) {
1301	var afterExample = keys.length > 0 ? '{' + keys.join(': ..., ') + ': ...}' : '{}';
1302
1303	error('A props object containing a "key" prop is being spread into JSX:\n' + ' let props = %s;\n' + ' <%s {...props} />\n' + 'React keys must be passed directly to JSX without using spread:\n' + ' let props = %s;\n' + ' <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);
1304
1305	didWarnAboutKeySpread[componentName + beforeExample] = true;
1306	}
1307	}
1308	}
1309
1310	if (type === REACT_FRAGMENT_TYPE) {
1311	validateFragmentProps(element);
1312	} else {
1313	validatePropTypes(element);
1314	}
1315
1316	return element;
1317	}
1318	} // These two functions exist to still get child warnings in dev
1319	// even with the prod transform. This means that jsxDEV is purely
1320	// opt-in behavior for better messages but that we won't stop
1321	// giving you warnings if you use production apis.
1322
1323	function jsxWithValidationStatic(type, props, key) {
1324	{
1325	return jsxWithValidation(type, props, key, true);
1326	}
1327	}
1328	function jsxWithValidationDynamic(type, props, key) {
1329	{
1330	return jsxWithValidation(type, props, key, false);
1331	}
1332	}
1333
1334	var jsx = jsxWithValidationDynamic ; // we may want to special case jsxs internally to take advantage of static children.
1335	// for now we can ship identical prod functions
1336
1337	var jsxs = jsxWithValidationStatic ;
1338
1339	exports.Fragment = REACT_FRAGMENT_TYPE;
1340	exports.jsx = jsx;
1341	exports.jsxs = jsxs;
1342	})();
1343	}
1344
1345
1346	/***/ }),
1347
1348	/***/ "./node_modules/react/jsx-runtime.js":
1349	/!*****************************************!\
1350	!* ./node_modules/react/jsx-runtime.js *!
1351	\*******************************************/
1352	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1353
1354
1355
1356	if (false) {} else {
1357	module.exports = __webpack_require__(/! ./cjs/react-jsx-runtime.development.js / "./node_modules/react/cjs/react-jsx-runtime.development.js");
1358	}
1359
1360
1361	/***/ }),
1362
1363	/***/ "react":
1364	/!**********************!\
1365	!* external "React" *!
1366	\************************/
1367	/***/ ((module) => {
1368
1369	module.exports = window["React"];
1370
1371	/***/ }),
1372
1373	/***/ "@woocommerce/blocks-registry":
1374	/!****************************************!\
1375	!* external ["wc","wcBlocksRegistry"] *!
1376	\******************************************/
1377	/***/ ((module) => {
1378
1379	module.exports = window["wc"]["wcBlocksRegistry"];
1380
1381	/***/ }),
1382
1383	/***/ "@woocommerce/settings":
1384	/!**********************************!\
1385	!* external ["wc","wcSettings"] *!
1386	\************************************/
1387	/***/ ((module) => {
1388
1389	module.exports = window["wc"]["wcSettings"];
1390
1391	/***/ }),
1392
1393	/***/ "@wordpress/html-entities":
1394	/!************************************!\
1395	!* external ["wp","htmlEntities"] *!
1396	\**************************************/
1397	/***/ ((module) => {
1398
1399	module.exports = window["wp"]["htmlEntities"];
1400
1401	/***/ }),
1402
1403	/***/ "@wordpress/i18n":
1404	/!****************************!\
1405	!* external ["wp","i18n"] *!
1406	\******************************/
1407	/***/ ((module) => {
1408
1409	module.exports = window["wp"]["i18n"];
1410
1411	/***/ })
1412
1413	/******/ });
1414	/************************************************************************/
1415	/******/ // The module cache
1416	/******/ var __webpack_module_cache__ = {};
1417	/******/
1418	/******/ // The require function
1419	/******/ function __webpack_require__(moduleId) {
1420	/******/ // Check if module is in cache
1421	/******/ var cachedModule = __webpack_module_cache__[moduleId];
1422	/******/ if (cachedModule !== undefined) {
1423	/******/ return cachedModule.exports;
1424	/******/ }
1425	/******/ // Create a new module (and put it into the cache)
1426	/******/ var module = __webpack_module_cache__[moduleId] = {
1427	/******/ // no module.id needed
1428	/******/ // no module.loaded needed
1429	/******/ exports: {}
1430	/******/ };
1431	/******/
1432	/******/ // Execute the module function
1433	/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
1434	/******/
1435	/******/ // Return the exports of the module
1436	/******/ return module.exports;
1437	/******/ }
1438	/******/
1439	/************************************************************************/
1440	/*****/ / webpack/runtime/compat get default export */
1441	/******/ (() => {
1442	/******/ // getDefaultExport function for compatibility with non-harmony modules
1443	/******/ __webpack_require__.n = (module) => {
1444	/******/ var getter = module && module.__esModule ?
1445	/******/ () => (module['default']) :
1446	/******/ () => (module);
1447	/******/ __webpack_require__.d(getter, { a: getter });
1448	/******/ return getter;
1449	/******/ };
1450	/******/ })();
1451	/******/
1452	/*****/ / webpack/runtime/define property getters */
1453	/******/ (() => {
1454	/******/ // define getter functions for harmony exports
1455	/******/ __webpack_require__.d = (exports, definition) => {
1456	/******/ for(var key in definition) {
1457	/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
1458	/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
1459	/******/ }
1460	/******/ }
1461	/******/ };
1462	/******/ })();
1463	/******/
1464	/*****/ / webpack/runtime/hasOwnProperty shorthand */
1465	/******/ (() => {
1466	/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
1467	/******/ })();
1468	/******/
1469	/*****/ / webpack/runtime/make namespace object */
1470	/******/ (() => {
1471	/******/ // define __esModule on exports
1472	/******/ __webpack_require__.r = (exports) => {
1473	/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
1474	/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
1475	/******/ }
1476	/******/ Object.defineProperty(exports, '__esModule', { value: true });
1477	/******/ };
1478	/******/ })();
1479	/******/
1480	/************************************************************************/
1481	var __webpack_exports__ = {};
1482	// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
1483	(() => {
1484	/!*********************************************************!\
1485	!* ./resources/js/frontend/wc-payplug-mybank-blocks.js *!
1486	\***********************************************************/
1487	__webpack_require__.r(__webpack_exports__);
1488	/* harmony import / var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/! @wordpress/i18n */ "@wordpress/i18n");
1489	/* harmony import / var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_0___default = /#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_0__);
1490	/* harmony import / var _woocommerce_blocks_registry__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/! @woocommerce/blocks-registry */ "@woocommerce/blocks-registry");
1491	/* harmony import / var _woocommerce_blocks_registry__WEBPACK_IMPORTED_MODULE_1___default = /#__PURE__*/__webpack_require__.n(_woocommerce_blocks_registry__WEBPACK_IMPORTED_MODULE_1__);
1492	/* harmony import / var _wordpress_html_entities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/! @wordpress/html-entities */ "@wordpress/html-entities");
1493	/* harmony import / var _wordpress_html_entities__WEBPACK_IMPORTED_MODULE_2___default = /#__PURE__*/__webpack_require__.n(_wordpress_html_entities__WEBPACK_IMPORTED_MODULE_2__);
1494	/* harmony import / var _woocommerce_settings__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/! @woocommerce/settings */ "@woocommerce/settings");
1495	/* harmony import / var _woocommerce_settings__WEBPACK_IMPORTED_MODULE_3___default = /#__PURE__*/__webpack_require__.n(_woocommerce_settings__WEBPACK_IMPORTED_MODULE_3__);
1496	/* harmony import / var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/! react/jsx-runtime */ "./node_modules/react/jsx-runtime.js");
1497
1498
1499
1500
1501
1502	const settings = (0,_woocommerce_settings__WEBPACK_IMPORTED_MODULE_3__.getSetting)('mybank_data', {});
1503	const defaultLabel = (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_0__.__)('Gateway method title', 'payplug');
1504	const label = (0,_wordpress_html_entities__WEBPACK_IMPORTED_MODULE_2__.decodeEntities)(settings?.title) \|\| defaultLabel;
1505	const allowed_country_codes = settings?.allowed_country_codes;
1506
1507	/**
1508	* Content component
1509	*/
1510	const Content = () => {
1511	return window.wp.htmlEntities.decodeEntities(settings?.description \|\| '');
1512	};
1513	/**
1514	* Label component
1515	*
1516	*/
1517	const Label = () => {
1518	return /#__PURE__/(0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsxs)("span", {
1519	style: {
1520	width: '100%'
1521	},
1522	children: [label, /#__PURE__/(0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(Icon, {})]
1523	});
1524	};
1525	const Icon = () => {
1526	return /#__PURE__/(0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)("img", {
1527	src: settings?.icon.src,
1528	alt: settings?.icon.icon_alt,
1529	className: "payplug-payment-icon",
1530	style: {
1531	float: 'right'
1532	}
1533	});
1534	};
1535
1536	/**
1537	* Payplug payment method config object.
1538	*/
1539	const Mybank = {
1540	name: "mybank",
1541	label: /#__PURE__/(0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(Label, {}),
1542	content: /#__PURE__/(0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(Content, {}),
1543	edit: /#__PURE__/(0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_4__.jsx)(Content, {}),
1544	canMakePayment: data => {
1545	if (allowed_country_codes.includes(data.billingData.country)) {
1546	return true;
1547	} else {
1548	return false;
1549	}
1550	},
1551	ariaLabel: label,
1552	supports: {
1553	features: settings.supports
1554	}
1555	};
1556	(0,_woocommerce_blocks_registry__WEBPACK_IMPORTED_MODULE_1__.registerPaymentMethod)(Mybank);
1557	})();
1558
1559	/******/ })()
1560	;
1561	//# sourceMappingURL=wc-payplug-mybank-blocks.js.map