Diff: STRATO-apps/wordpress_03/app/wp-includes/js/dist/element.js
Keine Baseline-Datei – Diff nur gegen leer.
1
-
1
+
/******/ (() => { // webpackBootstrap
2
+
/******/ "use strict";
3
+
/******/ var __webpack_modules__ = ({
4
+
5
+
/***/ 4140:
6
+
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
7
+
8
+
9
+
10
+
var m = __webpack_require__(5795);
11
+
if (true) {
12
+
exports.H = m.createRoot;
13
+
exports.c = m.hydrateRoot;
14
+
} else { var i; }
15
+
16
+
17
+
/***/ }),
18
+
19
+
/***/ 5795:
20
+
/***/ ((module) => {
21
+
22
+
module.exports = window["ReactDOM"];
23
+
24
+
/***/ })
25
+
26
+
/******/ });
27
+
/************************************************************************/
28
+
/******/ // The module cache
29
+
/******/ var __webpack_module_cache__ = {};
30
+
/******/
31
+
/******/ // The require function
32
+
/******/ function __webpack_require__(moduleId) {
33
+
/******/ // Check if module is in cache
34
+
/******/ var cachedModule = __webpack_module_cache__[moduleId];
35
+
/******/ if (cachedModule !== undefined) {
36
+
/******/ return cachedModule.exports;
37
+
/******/ }
38
+
/******/ // Create a new module (and put it into the cache)
39
+
/******/ var module = __webpack_module_cache__[moduleId] = {
40
+
/******/ // no module.id needed
41
+
/******/ // no module.loaded needed
42
+
/******/ exports: {}
43
+
/******/ };
44
+
/******/
45
+
/******/ // Execute the module function
46
+
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
47
+
/******/
48
+
/******/ // Return the exports of the module
49
+
/******/ return module.exports;
50
+
/******/ }
51
+
/******/
52
+
/************************************************************************/
53
+
/******/ /* webpack/runtime/define property getters */
54
+
/******/ (() => {
55
+
/******/ // define getter functions for harmony exports
56
+
/******/ __webpack_require__.d = (exports, definition) => {
57
+
/******/ for(var key in definition) {
58
+
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
59
+
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
60
+
/******/ }
61
+
/******/ }
62
+
/******/ };
63
+
/******/ })();
64
+
/******/
65
+
/******/ /* webpack/runtime/hasOwnProperty shorthand */
66
+
/******/ (() => {
67
+
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
68
+
/******/ })();
69
+
/******/
70
+
/******/ /* webpack/runtime/make namespace object */
71
+
/******/ (() => {
72
+
/******/ // define __esModule on exports
73
+
/******/ __webpack_require__.r = (exports) => {
74
+
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
75
+
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
76
+
/******/ }
77
+
/******/ Object.defineProperty(exports, '__esModule', { value: true });
78
+
/******/ };
79
+
/******/ })();
80
+
/******/
81
+
/************************************************************************/
82
+
var __webpack_exports__ = {};
83
+
// ESM COMPAT FLAG
84
+
__webpack_require__.r(__webpack_exports__);
85
+
86
+
// EXPORTS
87
+
__webpack_require__.d(__webpack_exports__, {
88
+
Children: () => (/* reexport */ external_React_namespaceObject.Children),
89
+
Component: () => (/* reexport */ external_React_namespaceObject.Component),
90
+
Fragment: () => (/* reexport */ external_React_namespaceObject.Fragment),
91
+
Platform: () => (/* reexport */ platform_default),
92
+
PureComponent: () => (/* reexport */ external_React_namespaceObject.PureComponent),
93
+
RawHTML: () => (/* reexport */ RawHTML),
94
+
StrictMode: () => (/* reexport */ external_React_namespaceObject.StrictMode),
95
+
Suspense: () => (/* reexport */ external_React_namespaceObject.Suspense),
96
+
cloneElement: () => (/* reexport */ external_React_namespaceObject.cloneElement),
97
+
concatChildren: () => (/* reexport */ concatChildren),
98
+
createContext: () => (/* reexport */ external_React_namespaceObject.createContext),
99
+
createElement: () => (/* reexport */ external_React_namespaceObject.createElement),
100
+
createInterpolateElement: () => (/* reexport */ create_interpolate_element_default),
101
+
createPortal: () => (/* reexport */ external_ReactDOM_.createPortal),
102
+
createRef: () => (/* reexport */ external_React_namespaceObject.createRef),
103
+
createRoot: () => (/* reexport */ client/* createRoot */.H),
104
+
findDOMNode: () => (/* reexport */ external_ReactDOM_.findDOMNode),
105
+
flushSync: () => (/* reexport */ external_ReactDOM_.flushSync),
106
+
forwardRef: () => (/* reexport */ external_React_namespaceObject.forwardRef),
107
+
hydrate: () => (/* reexport */ external_ReactDOM_.hydrate),
108
+
hydrateRoot: () => (/* reexport */ client/* hydrateRoot */.c),
109
+
isEmptyElement: () => (/* reexport */ isEmptyElement),
110
+
isValidElement: () => (/* reexport */ external_React_namespaceObject.isValidElement),
111
+
lazy: () => (/* reexport */ external_React_namespaceObject.lazy),
112
+
memo: () => (/* reexport */ external_React_namespaceObject.memo),
113
+
render: () => (/* reexport */ external_ReactDOM_.render),
114
+
renderToString: () => (/* reexport */ serialize_default),
115
+
startTransition: () => (/* reexport */ external_React_namespaceObject.startTransition),
116
+
switchChildrenNodeName: () => (/* reexport */ switchChildrenNodeName),
117
+
unmountComponentAtNode: () => (/* reexport */ external_ReactDOM_.unmountComponentAtNode),
118
+
useCallback: () => (/* reexport */ external_React_namespaceObject.useCallback),
119
+
useContext: () => (/* reexport */ external_React_namespaceObject.useContext),
120
+
useDebugValue: () => (/* reexport */ external_React_namespaceObject.useDebugValue),
121
+
useDeferredValue: () => (/* reexport */ external_React_namespaceObject.useDeferredValue),
122
+
useEffect: () => (/* reexport */ external_React_namespaceObject.useEffect),
123
+
useId: () => (/* reexport */ external_React_namespaceObject.useId),
124
+
useImperativeHandle: () => (/* reexport */ external_React_namespaceObject.useImperativeHandle),
125
+
useInsertionEffect: () => (/* reexport */ external_React_namespaceObject.useInsertionEffect),
126
+
useLayoutEffect: () => (/* reexport */ external_React_namespaceObject.useLayoutEffect),
127
+
useMemo: () => (/* reexport */ external_React_namespaceObject.useMemo),
128
+
useReducer: () => (/* reexport */ external_React_namespaceObject.useReducer),
129
+
useRef: () => (/* reexport */ external_React_namespaceObject.useRef),
130
+
useState: () => (/* reexport */ external_React_namespaceObject.useState),
131
+
useSyncExternalStore: () => (/* reexport */ external_React_namespaceObject.useSyncExternalStore),
132
+
useTransition: () => (/* reexport */ external_React_namespaceObject.useTransition)
133
+
});
134
+
135
+
;// external "React"
136
+
const external_React_namespaceObject = window["React"];
137
+
;// ./node_modules/@wordpress/element/build-module/create-interpolate-element.js
138
+
139
+
let indoc;
140
+
let offset;
141
+
let output;
142
+
let stack;
143
+
const tokenizer = /<(\/)?(\w+)\s*(\/)?>/g;
144
+
function createFrame(element, tokenStart, tokenLength, prevOffset, leadingTextStart) {
145
+
return {
146
+
element,
147
+
tokenStart,
148
+
tokenLength,
149
+
prevOffset,
150
+
leadingTextStart,
151
+
children: []
152
+
};
153
+
}
154
+
const createInterpolateElement = (interpolatedString, conversionMap) => {
155
+
indoc = interpolatedString;
156
+
offset = 0;
157
+
output = [];
158
+
stack = [];
159
+
tokenizer.lastIndex = 0;
160
+
if (!isValidConversionMap(conversionMap)) {
161
+
throw new TypeError(
162
+
"The conversionMap provided is not valid. It must be an object with values that are React Elements"
163
+
);
164
+
}
165
+
do {
166
+
} while (proceed(conversionMap));
167
+
return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, ...output);
168
+
};
169
+
const isValidConversionMap = (conversionMap) => {
170
+
const isObject = typeof conversionMap === "object" && conversionMap !== null;
171
+
const values = isObject && Object.values(conversionMap);
172
+
return isObject && values.length > 0 && values.every((element) => (0,external_React_namespaceObject.isValidElement)(element));
173
+
};
174
+
function proceed(conversionMap) {
175
+
const next = nextToken();
176
+
const [tokenType, name, startOffset, tokenLength] = next;
177
+
const stackDepth = stack.length;
178
+
const leadingTextStart = startOffset > offset ? offset : null;
179
+
if (name && !conversionMap[name]) {
180
+
addText();
181
+
return false;
182
+
}
183
+
switch (tokenType) {
184
+
case "no-more-tokens":
185
+
if (stackDepth !== 0) {
186
+
const { leadingTextStart: stackLeadingText, tokenStart } = stack.pop();
187
+
output.push(indoc.substr(stackLeadingText, tokenStart));
188
+
}
189
+
addText();
190
+
return false;
191
+
case "self-closed":
192
+
if (0 === stackDepth) {
193
+
if (null !== leadingTextStart) {
194
+
output.push(
195
+
indoc.substr(
196
+
leadingTextStart,
197
+
startOffset - leadingTextStart
198
+
)
199
+
);
200
+
}
201
+
output.push(conversionMap[name]);
202
+
offset = startOffset + tokenLength;
203
+
return true;
204
+
}
205
+
addChild(
206
+
createFrame(conversionMap[name], startOffset, tokenLength)
207
+
);
208
+
offset = startOffset + tokenLength;
209
+
return true;
210
+
case "opener":
211
+
stack.push(
212
+
createFrame(
213
+
conversionMap[name],
214
+
startOffset,
215
+
tokenLength,
216
+
startOffset + tokenLength,
217
+
leadingTextStart
218
+
)
219
+
);
220
+
offset = startOffset + tokenLength;
221
+
return true;
222
+
case "closer":
223
+
if (1 === stackDepth) {
224
+
closeOuterElement(startOffset);
225
+
offset = startOffset + tokenLength;
226
+
return true;
227
+
}
228
+
const stackTop = stack.pop();
229
+
const text = indoc.substr(
230
+
stackTop.prevOffset,
231
+
startOffset - stackTop.prevOffset
232
+
);
233
+
stackTop.children.push(text);
234
+
stackTop.prevOffset = startOffset + tokenLength;
235
+
const frame = createFrame(
236
+
stackTop.element,
237
+
stackTop.tokenStart,
238
+
stackTop.tokenLength,
239
+
startOffset + tokenLength
240
+
);
241
+
frame.children = stackTop.children;
242
+
addChild(frame);
243
+
offset = startOffset + tokenLength;
244
+
return true;
245
+
default:
246
+
addText();
247
+
return false;
248
+
}
249
+
}
250
+
function nextToken() {
251
+
const matches = tokenizer.exec(indoc);
252
+
if (null === matches) {
253
+
return ["no-more-tokens"];
254
+
}
255
+
const startedAt = matches.index;
256
+
const [match, isClosing, name, isSelfClosed] = matches;
257
+
const length = match.length;
258
+
if (isSelfClosed) {
259
+
return ["self-closed", name, startedAt, length];
260
+
}
261
+
if (isClosing) {
262
+
return ["closer", name, startedAt, length];
263
+
}
264
+
return ["opener", name, startedAt, length];
265
+
}
266
+
function addText() {
267
+
const length = indoc.length - offset;
268
+
if (0 === length) {
269
+
return;
270
+
}
271
+
output.push(indoc.substr(offset, length));
272
+
}
273
+
function addChild(frame) {
274
+
const { element, tokenStart, tokenLength, prevOffset, children } = frame;
275
+
const parent = stack[stack.length - 1];
276
+
const text = indoc.substr(
277
+
parent.prevOffset,
278
+
tokenStart - parent.prevOffset
279
+
);
280
+
if (text) {
281
+
parent.children.push(text);
282
+
}
283
+
parent.children.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children));
284
+
parent.prevOffset = prevOffset ? prevOffset : tokenStart + tokenLength;
285
+
}
286
+
function closeOuterElement(endOffset) {
287
+
const { element, leadingTextStart, prevOffset, tokenStart, children } = stack.pop();
288
+
const text = endOffset ? indoc.substr(prevOffset, endOffset - prevOffset) : indoc.substr(prevOffset);
289
+
if (text) {
290
+
children.push(text);
291
+
}
292
+
if (null !== leadingTextStart) {
293
+
output.push(
294
+
indoc.substr(leadingTextStart, tokenStart - leadingTextStart)
295
+
);
296
+
}
297
+
output.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children));
298
+
}
299
+
var create_interpolate_element_default = createInterpolateElement;
300
+
301
+
302
+
;// ./node_modules/@wordpress/element/build-module/react.js
303
+
304
+
function concatChildren(...childrenArguments) {
305
+
return childrenArguments.reduce(
306
+
(accumulator, children, i) => {
307
+
external_React_namespaceObject.Children.forEach(children, (child, j) => {
308
+
if ((0,external_React_namespaceObject.isValidElement)(child) && typeof child !== "string") {
309
+
child = (0,external_React_namespaceObject.cloneElement)(child, {
310
+
key: [i, j].join()
311
+
});
312
+
}
313
+
accumulator.push(child);
314
+
});
315
+
return accumulator;
316
+
},
317
+
[]
318
+
);
319
+
}
320
+
function switchChildrenNodeName(children, nodeName) {
321
+
return children && external_React_namespaceObject.Children.map(children, (elt, index) => {
322
+
if (typeof elt?.valueOf() === "string") {
323
+
return (0,external_React_namespaceObject.createElement)(nodeName, { key: index }, elt);
324
+
}
325
+
if (!(0,external_React_namespaceObject.isValidElement)(elt)) {
326
+
return elt;
327
+
}
328
+
const { children: childrenProp, ...props } = elt.props;
329
+
return (0,external_React_namespaceObject.createElement)(
330
+
nodeName,
331
+
{ key: index, ...props },
332
+
childrenProp
333
+
);
334
+
});
335
+
}
336
+
337
+
338
+
// EXTERNAL MODULE: external "ReactDOM"
339
+
var external_ReactDOM_ = __webpack_require__(5795);
340
+
// EXTERNAL MODULE: ./node_modules/react-dom/client.js
341
+
var client = __webpack_require__(4140);
342
+
;// ./node_modules/@wordpress/element/build-module/react-platform.js
343
+
344
+
345
+
346
+
347
+
;// ./node_modules/@wordpress/element/build-module/utils.js
348
+
const isEmptyElement = (element) => {
349
+
if (typeof element === "number") {
350
+
return false;
351
+
}
352
+
if (typeof element?.valueOf() === "string" || Array.isArray(element)) {
353
+
return !element.length;
354
+
}
355
+
return !element;
356
+
};
357
+
358
+
359
+
;// ./node_modules/@wordpress/element/build-module/platform.js
360
+
const Platform = {
361
+
/** Platform identifier. Will always be `'web'` in this module. */
362
+
OS: "web",
363
+
/**
364
+
* Select a value based on the platform.
365
+
*
366
+
* @template T
367
+
* @param spec - Object with optional platform-specific values.
368
+
* @return The selected value.
369
+
*/
370
+
select(spec) {
371
+
return "web" in spec ? spec.web : spec.default;
372
+
},
373
+
/** Whether the platform is web */
374
+
isWeb: true
375
+
};
376
+
var platform_default = Platform;
377
+
378
+
379
+
;// ./node_modules/is-plain-object/dist/is-plain-object.mjs
380
+
/*!
381
+
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
382
+
*
383
+
* Copyright (c) 2014-2017, Jon Schlinkert.
384
+
* Released under the MIT License.
385
+
*/
386
+
387
+
function isObject(o) {
388
+
return Object.prototype.toString.call(o) === '[object Object]';
389
+
}
390
+
391
+
function isPlainObject(o) {
392
+
var ctor,prot;
393
+
394
+
if (isObject(o) === false) return false;
395
+
396
+
// If has modified constructor
397
+
ctor = o.constructor;
398
+
if (ctor === undefined) return true;
399
+
400
+
// If has modified prototype
401
+
prot = ctor.prototype;
402
+
if (isObject(prot) === false) return false;
403
+
404
+
// If constructor does not have an Object-specific method
405
+
if (prot.hasOwnProperty('isPrototypeOf') === false) {
406
+
return false;
407
+
}
408
+
409
+
// Most likely a plain Object
410
+
return true;
411
+
}
412
+
413
+
414
+
415
+
;// ./node_modules/tslib/tslib.es6.mjs
416
+
/******************************************************************************
417
+
Copyright (c) Microsoft Corporation.
418
+
419
+
Permission to use, copy, modify, and/or distribute this software for any
420
+
purpose with or without fee is hereby granted.
421
+
422
+
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
423
+
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
424
+
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
425
+
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
426
+
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
427
+
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
428
+
PERFORMANCE OF THIS SOFTWARE.
429
+
***************************************************************************** */
430
+
/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
431
+
432
+
var extendStatics = function(d, b) {
433
+
extendStatics = Object.setPrototypeOf ||
434
+
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
435
+
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
436
+
return extendStatics(d, b);
437
+
};
438
+
439
+
function __extends(d, b) {
440
+
if (typeof b !== "function" && b !== null)
441
+
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
442
+
extendStatics(d, b);
443
+
function __() { this.constructor = d; }
444
+
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
445
+
}
446
+
447
+
var __assign = function() {
448
+
__assign = Object.assign || function __assign(t) {
449
+
for (var s, i = 1, n = arguments.length; i < n; i++) {
450
+
s = arguments[i];
451
+
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
452
+
}
453
+
return t;
454
+
}
455
+
return __assign.apply(this, arguments);
456
+
}
457
+
458
+
function __rest(s, e) {
459
+
var t = {};
460
+
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
461
+
t[p] = s[p];
462
+
if (s != null && typeof Object.getOwnPropertySymbols === "function")
463
+
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
464
+
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
465
+
t[p[i]] = s[p[i]];
466
+
}
467
+
return t;
468
+
}
469
+
470
+
function __decorate(decorators, target, key, desc) {
471
+
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
472
+
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
473
+
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
474
+
return c > 3 && r && Object.defineProperty(target, key, r), r;
475
+
}
476
+
477
+
function __param(paramIndex, decorator) {
478
+
return function (target, key) { decorator(target, key, paramIndex); }
479
+
}
480
+
481
+
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
482
+
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
483
+
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
484
+
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
485
+
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
486
+
var _, done = false;
487
+
for (var i = decorators.length - 1; i >= 0; i--) {
488
+
var context = {};
489
+
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
490
+
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
491
+
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
492
+
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
493
+
if (kind === "accessor") {
494
+
if (result === void 0) continue;
495
+
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
496
+
if (_ = accept(result.get)) descriptor.get = _;
497
+
if (_ = accept(result.set)) descriptor.set = _;
498
+
if (_ = accept(result.init)) initializers.unshift(_);
499
+
}
500
+
else if (_ = accept(result)) {
501
+
if (kind === "field") initializers.unshift(_);
502
+
else descriptor[key] = _;
503
+
}
504
+
}
505
+
if (target) Object.defineProperty(target, contextIn.name, descriptor);
506
+
done = true;
507
+
};
508
+
509
+
function __runInitializers(thisArg, initializers, value) {
510
+
var useValue = arguments.length > 2;
511
+
for (var i = 0; i < initializers.length; i++) {
512
+
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
513
+
}
514
+
return useValue ? value : void 0;
515
+
};
516
+
517
+
function __propKey(x) {
518
+
return typeof x === "symbol" ? x : "".concat(x);
519
+
};
520
+
521
+
function __setFunctionName(f, name, prefix) {
522
+
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
523
+
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
524
+
};
525
+
526
+
function __metadata(metadataKey, metadataValue) {
527
+
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
528
+
}
529
+
530
+
function __awaiter(thisArg, _arguments, P, generator) {
531
+
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
532
+
return new (P || (P = Promise))(function (resolve, reject) {
533
+
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
534
+
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
535
+
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
536
+
step((generator = generator.apply(thisArg, _arguments || [])).next());
537
+
});
538
+
}
539
+
540
+
function __generator(thisArg, body) {
541
+
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
542
+
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
543
+
function verb(n) { return function (v) { return step([n, v]); }; }
544
+
function step(op) {
545
+
if (f) throw new TypeError("Generator is already executing.");
546
+
while (g && (g = 0, op[0] && (_ = 0)), _) try {
547
+
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
548
+
if (y = 0, t) op = [op[0] & 2, t.value];
549
+
switch (op[0]) {
550
+
case 0: case 1: t = op; break;
551
+
case 4: _.label++; return { value: op[1], done: false };
552
+
case 5: _.label++; y = op[1]; op = [0]; continue;
553
+
case 7: op = _.ops.pop(); _.trys.pop(); continue;
554
+
default:
555
+
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
556
+
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
557
+
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
558
+
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
559
+
if (t[2]) _.ops.pop();
560
+
_.trys.pop(); continue;
561
+
}
562
+
op = body.call(thisArg, _);
563
+
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
564
+
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
565
+
}
566
+
}
567
+
568
+
var __createBinding = Object.create ? (function(o, m, k, k2) {
569
+
if (k2 === undefined) k2 = k;
570
+
var desc = Object.getOwnPropertyDescriptor(m, k);
571
+
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
572
+
desc = { enumerable: true, get: function() { return m[k]; } };
573
+
}
574
+
Object.defineProperty(o, k2, desc);
575
+
}) : (function(o, m, k, k2) {
576
+
if (k2 === undefined) k2 = k;
577
+
o[k2] = m[k];
578
+
});
579
+
580
+
function __exportStar(m, o) {
581
+
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
582
+
}
583
+
584
+
function __values(o) {
585
+
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
586
+
if (m) return m.call(o);
587
+
if (o && typeof o.length === "number") return {
588
+
next: function () {
589
+
if (o && i >= o.length) o = void 0;
590
+
return { value: o && o[i++], done: !o };
591
+
}
592
+
};
593
+
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
594
+
}
595
+
596
+
function __read(o, n) {
597
+
var m = typeof Symbol === "function" && o[Symbol.iterator];
598
+
if (!m) return o;
599
+
var i = m.call(o), r, ar = [], e;
600
+
try {
601
+
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
602
+
}
603
+
catch (error) { e = { error: error }; }
604
+
finally {
605
+
try {
606
+
if (r && !r.done && (m = i["return"])) m.call(i);
607
+
}
608
+
finally { if (e) throw e.error; }
609
+
}
610
+
return ar;
611
+
}
612
+
613
+
/** @deprecated */
614
+
function __spread() {
615
+
for (var ar = [], i = 0; i < arguments.length; i++)
616
+
ar = ar.concat(__read(arguments[i]));
617
+
return ar;
618
+
}
619
+
620
+
/** @deprecated */
621
+
function __spreadArrays() {
622
+
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
623
+
for (var r = Array(s), k = 0, i = 0; i < il; i++)
624
+
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
625
+
r[k] = a[j];
626
+
return r;
627
+
}
628
+
629
+
function __spreadArray(to, from, pack) {
630
+
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
631
+
if (ar || !(i in from)) {
632
+
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
633
+
ar[i] = from[i];
634
+
}
635
+
}
636
+
return to.concat(ar || Array.prototype.slice.call(from));
637
+
}
638
+
639
+
function __await(v) {
640
+
return this instanceof __await ? (this.v = v, this) : new __await(v);
641
+
}
642
+
643
+
function __asyncGenerator(thisArg, _arguments, generator) {
644
+
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
645
+
var g = generator.apply(thisArg, _arguments || []), i, q = [];
646
+
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
647
+
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
648
+
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
649
+
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
650
+
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
651
+
function fulfill(value) { resume("next", value); }
652
+
function reject(value) { resume("throw", value); }
653
+
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
654
+
}
655
+
656
+
function __asyncDelegator(o) {
657
+
var i, p;
658
+
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
659
+
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
660
+
}
661
+
662
+
function __asyncValues(o) {
663
+
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
664
+
var m = o[Symbol.asyncIterator], i;
665
+
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
666
+
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
667
+
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
668
+
}
669
+
670
+
function __makeTemplateObject(cooked, raw) {
671
+
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
672
+
return cooked;
673
+
};
674
+
675
+
var __setModuleDefault = Object.create ? (function(o, v) {
676
+
Object.defineProperty(o, "default", { enumerable: true, value: v });
677
+
}) : function(o, v) {
678
+
o["default"] = v;
679
+
};
680
+
681
+
var ownKeys = function(o) {
682
+
ownKeys = Object.getOwnPropertyNames || function (o) {
683
+
var ar = [];
684
+
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
685
+
return ar;
686
+
};
687
+
return ownKeys(o);
688
+
};
689
+
690
+
function __importStar(mod) {
691
+
if (mod && mod.__esModule) return mod;
692
+
var result = {};
693
+
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
694
+
__setModuleDefault(result, mod);
695
+
return result;
696
+
}
697
+
698
+
function __importDefault(mod) {
699
+
return (mod && mod.__esModule) ? mod : { default: mod };
700
+
}
701
+
702
+
function __classPrivateFieldGet(receiver, state, kind, f) {
703
+
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
704
+
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
705
+
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
706
+
}
707
+
708
+
function __classPrivateFieldSet(receiver, state, value, kind, f) {
709
+
if (kind === "m") throw new TypeError("Private method is not writable");
710
+
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
711
+
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
712
+
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
713
+
}
714
+
715
+
function __classPrivateFieldIn(state, receiver) {
716
+
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
717
+
return typeof state === "function" ? receiver === state : state.has(receiver);
718
+
}
719
+
720
+
function __addDisposableResource(env, value, async) {
721
+
if (value !== null && value !== void 0) {
722
+
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
723
+
var dispose, inner;
724
+
if (async) {
725
+
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
726
+
dispose = value[Symbol.asyncDispose];
727
+
}
728
+
if (dispose === void 0) {
729
+
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
730
+
dispose = value[Symbol.dispose];
731
+
if (async) inner = dispose;
732
+
}
733
+
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
734
+
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
735
+
env.stack.push({ value: value, dispose: dispose, async: async });
736
+
}
737
+
else if (async) {
738
+
env.stack.push({ async: true });
739
+
}
740
+
return value;
741
+
}
742
+
743
+
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
744
+
var e = new Error(message);
745
+
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
746
+
};
747
+
748
+
function __disposeResources(env) {
749
+
function fail(e) {
750
+
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
751
+
env.hasError = true;
752
+
}
753
+
var r, s = 0;
754
+
function next() {
755
+
while (r = env.stack.pop()) {
756
+
try {
757
+
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
758
+
if (r.dispose) {
759
+
var result = r.dispose.call(r.value);
760
+
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
761
+
}
762
+
else s |= 1;
763
+
}
764
+
catch (e) {
765
+
fail(e);
766
+
}
767
+
}
768
+
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
769
+
if (env.hasError) throw env.error;
770
+
}
771
+
return next();
772
+
}
773
+
774
+
function __rewriteRelativeImportExtension(path, preserveJsx) {
775
+
if (typeof path === "string" && /^\.\.?\//.test(path)) {
776
+
return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
777
+
return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
778
+
});
779
+
}
780
+
return path;
781
+
}
782
+
783
+
/* harmony default export */ const tslib_es6 = ({
784
+
__extends,
785
+
__assign,
786
+
__rest,
787
+
__decorate,
788
+
__param,
789
+
__esDecorate,
790
+
__runInitializers,
791
+
__propKey,
792
+
__setFunctionName,
793
+
__metadata,
794
+
__awaiter,
795
+
__generator,
796
+
__createBinding,
797
+
__exportStar,
798
+
__values,
799
+
__read,
800
+
__spread,
801
+
__spreadArrays,
802
+
__spreadArray,
803
+
__await,
804
+
__asyncGenerator,
805
+
__asyncDelegator,
806
+
__asyncValues,
807
+
__makeTemplateObject,
808
+
__importStar,
809
+
__importDefault,
810
+
__classPrivateFieldGet,
811
+
__classPrivateFieldSet,
812
+
__classPrivateFieldIn,
813
+
__addDisposableResource,
814
+
__disposeResources,
815
+
__rewriteRelativeImportExtension,
816
+
});
817
+
818
+
;// ./node_modules/lower-case/dist.es2015/index.js
819
+
/**
820
+
* Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
821
+
*/
822
+
var SUPPORTED_LOCALE = {
823
+
tr: {
824
+
regexp: /\u0130|\u0049|\u0049\u0307/g,
825
+
map: {
826
+
İ: "\u0069",
827
+
I: "\u0131",
828
+
İ: "\u0069",
829
+
},
830
+
},
831
+
az: {
832
+
regexp: /\u0130/g,
833
+
map: {
834
+
İ: "\u0069",
835
+
I: "\u0131",
836
+
İ: "\u0069",
837
+
},
838
+
},
839
+
lt: {
840
+
regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
841
+
map: {
842
+
I: "\u0069\u0307",
843
+
J: "\u006A\u0307",
844
+
Į: "\u012F\u0307",
845
+
Ì: "\u0069\u0307\u0300",
846
+
Í: "\u0069\u0307\u0301",
847
+
Ĩ: "\u0069\u0307\u0303",
848
+
},
849
+
},
850
+
};
851
+
/**
852
+
* Localized lower case.
853
+
*/
854
+
function localeLowerCase(str, locale) {
855
+
var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
856
+
if (lang)
857
+
return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
858
+
return lowerCase(str);
859
+
}
860
+
/**
861
+
* Lower case as a function.
862
+
*/
863
+
function lowerCase(str) {
864
+
return str.toLowerCase();
865
+
}
866
+
867
+
;// ./node_modules/no-case/dist.es2015/index.js
868
+
869
+
// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
870
+
var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
871
+
// Remove all non-word characters.
872
+
var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
873
+
/**
874
+
* Normalize the string into something other libraries can manipulate easier.
875
+
*/
876
+
function noCase(input, options) {
877
+
if (options === void 0) { options = {}; }
878
+
var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
879
+
var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
880
+
var start = 0;
881
+
var end = result.length;
882
+
// Trim the delimiter from around the output string.
883
+
while (result.charAt(start) === "\0")
884
+
start++;
885
+
while (result.charAt(end - 1) === "\0")
886
+
end--;
887
+
// Transform each token independently.
888
+
return result.slice(start, end).split("\0").map(transform).join(delimiter);
889
+
}
890
+
/**
891
+
* Replace `re` in the input string with the replacement value.
892
+
*/
893
+
function replace(input, re, value) {
894
+
if (re instanceof RegExp)
895
+
return input.replace(re, value);
896
+
return re.reduce(function (input, re) { return input.replace(re, value); }, input);
897
+
}
898
+
899
+
;// ./node_modules/dot-case/dist.es2015/index.js
900
+
901
+
902
+
function dotCase(input, options) {
903
+
if (options === void 0) { options = {}; }
904
+
return noCase(input, __assign({ delimiter: "." }, options));
905
+
}
906
+
907
+
;// ./node_modules/param-case/dist.es2015/index.js
908
+
909
+
910
+
function paramCase(input, options) {
911
+
if (options === void 0) { options = {}; }
912
+
return dotCase(input, __assign({ delimiter: "-" }, options));
913
+
}
914
+
915
+
;// external ["wp","escapeHtml"]
916
+
const external_wp_escapeHtml_namespaceObject = window["wp"]["escapeHtml"];
917
+
;// ./node_modules/@wordpress/element/build-module/raw-html.js
918
+
919
+
function RawHTML({
920
+
children,
921
+
...props
922
+
}) {
923
+
let rawHtml = "";
924
+
external_React_namespaceObject.Children.toArray(children).forEach((child) => {
925
+
if (typeof child === "string" && child.trim() !== "") {
926
+
rawHtml += child;
927
+
}
928
+
});
929
+
return (0,external_React_namespaceObject.createElement)("div", {
930
+
dangerouslySetInnerHTML: { __html: rawHtml },
931
+
...props
932
+
});
933
+
}
934
+
935
+
936
+
;// ./node_modules/@wordpress/element/build-module/serialize.js
937
+
938
+
939
+
940
+
941
+
942
+
const Context = (0,external_React_namespaceObject.createContext)(void 0);
943
+
Context.displayName = "ElementContext";
944
+
const { Provider, Consumer } = Context;
945
+
const ForwardRef = (0,external_React_namespaceObject.forwardRef)(() => {
946
+
return null;
947
+
});
948
+
const ATTRIBUTES_TYPES = /* @__PURE__ */ new Set(["string", "boolean", "number"]);
949
+
const SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
950
+
"area",
951
+
"base",
952
+
"br",
953
+
"col",
954
+
"command",
955
+
"embed",
956
+
"hr",
957
+
"img",
958
+
"input",
959
+
"keygen",
960
+
"link",
961
+
"meta",
962
+
"param",
963
+
"source",
964
+
"track",
965
+
"wbr"
966
+
]);
967
+
const BOOLEAN_ATTRIBUTES = /* @__PURE__ */ new Set([
968
+
"allowfullscreen",
969
+
"allowpaymentrequest",
970
+
"allowusermedia",
971
+
"async",
972
+
"autofocus",
973
+
"autoplay",
974
+
"checked",
975
+
"controls",
976
+
"default",
977
+
"defer",
978
+
"disabled",
979
+
"download",
980
+
"formnovalidate",
981
+
"hidden",
982
+
"ismap",
983
+
"itemscope",
984
+
"loop",
985
+
"multiple",
986
+
"muted",
987
+
"nomodule",
988
+
"novalidate",
989
+
"open",
990
+
"playsinline",
991
+
"readonly",
992
+
"required",
993
+
"reversed",
994
+
"selected",
995
+
"typemustmatch"
996
+
]);
997
+
const ENUMERATED_ATTRIBUTES = /* @__PURE__ */ new Set([
998
+
"autocapitalize",
999
+
"autocomplete",
1000
+
"charset",
1001
+
"contenteditable",
1002
+
"crossorigin",
1003
+
"decoding",
1004
+
"dir",
1005
+
"draggable",
1006
+
"enctype",
1007
+
"formenctype",
1008
+
"formmethod",
1009
+
"http-equiv",
1010
+
"inputmode",
1011
+
"kind",
1012
+
"method",
1013
+
"preload",
1014
+
"scope",
1015
+
"shape",
1016
+
"spellcheck",
1017
+
"translate",
1018
+
"type",
1019
+
"wrap"
1020
+
]);
1021
+
const CSS_PROPERTIES_SUPPORTS_UNITLESS = /* @__PURE__ */ new Set([
1022
+
"animation",
1023
+
"animationIterationCount",
1024
+
"baselineShift",
1025
+
"borderImageOutset",
1026
+
"borderImageSlice",
1027
+
"borderImageWidth",
1028
+
"columnCount",
1029
+
"cx",
1030
+
"cy",
1031
+
"fillOpacity",
1032
+
"flexGrow",
1033
+
"flexShrink",
1034
+
"floodOpacity",
1035
+
"fontWeight",
1036
+
"gridColumnEnd",
1037
+
"gridColumnStart",
1038
+
"gridRowEnd",
1039
+
"gridRowStart",
1040
+
"lineHeight",
1041
+
"opacity",
1042
+
"order",
1043
+
"orphans",
1044
+
"r",
1045
+
"rx",
1046
+
"ry",
1047
+
"shapeImageThreshold",
1048
+
"stopOpacity",
1049
+
"strokeDasharray",
1050
+
"strokeDashoffset",
1051
+
"strokeMiterlimit",
1052
+
"strokeOpacity",
1053
+
"strokeWidth",
1054
+
"tabSize",
1055
+
"widows",
1056
+
"x",
1057
+
"y",
1058
+
"zIndex",
1059
+
"zoom"
1060
+
]);
1061
+
function hasPrefix(string, prefixes) {
1062
+
return prefixes.some((prefix) => string.indexOf(prefix) === 0);
1063
+
}
1064
+
function isInternalAttribute(attribute) {
1065
+
return "key" === attribute || "children" === attribute;
1066
+
}
1067
+
function getNormalAttributeValue(attribute, value) {
1068
+
switch (attribute) {
1069
+
case "style":
1070
+
return renderStyle(value);
1071
+
}
1072
+
return value;
1073
+
}
1074
+
const SVG_ATTRIBUTE_WITH_DASHES_LIST = [
1075
+
"accentHeight",
1076
+
"alignmentBaseline",
1077
+
"arabicForm",
1078
+
"baselineShift",
1079
+
"capHeight",
1080
+
"clipPath",
1081
+
"clipRule",
1082
+
"colorInterpolation",
1083
+
"colorInterpolationFilters",
1084
+
"colorProfile",
1085
+
"colorRendering",
1086
+
"dominantBaseline",
1087
+
"enableBackground",
1088
+
"fillOpacity",
1089
+
"fillRule",
1090
+
"floodColor",
1091
+
"floodOpacity",
1092
+
"fontFamily",
1093
+
"fontSize",
1094
+
"fontSizeAdjust",
1095
+
"fontStretch",
1096
+
"fontStyle",
1097
+
"fontVariant",
1098
+
"fontWeight",
1099
+
"glyphName",
1100
+
"glyphOrientationHorizontal",
1101
+
"glyphOrientationVertical",
1102
+
"horizAdvX",
1103
+
"horizOriginX",
1104
+
"imageRendering",
1105
+
"letterSpacing",
1106
+
"lightingColor",
1107
+
"markerEnd",
1108
+
"markerMid",
1109
+
"markerStart",
1110
+
"overlinePosition",
1111
+
"overlineThickness",
1112
+
"paintOrder",
1113
+
"panose1",
1114
+
"pointerEvents",
1115
+
"renderingIntent",
1116
+
"shapeRendering",
1117
+
"stopColor",
1118
+
"stopOpacity",
1119
+
"strikethroughPosition",
1120
+
"strikethroughThickness",
1121
+
"strokeDasharray",
1122
+
"strokeDashoffset",
1123
+
"strokeLinecap",
1124
+
"strokeLinejoin",
1125
+
"strokeMiterlimit",
1126
+
"strokeOpacity",
1127
+
"strokeWidth",
1128
+
"textAnchor",
1129
+
"textDecoration",
1130
+
"textRendering",
1131
+
"underlinePosition",
1132
+
"underlineThickness",
1133
+
"unicodeBidi",
1134
+
"unicodeRange",
1135
+
"unitsPerEm",
1136
+
"vAlphabetic",
1137
+
"vHanging",
1138
+
"vIdeographic",
1139
+
"vMathematical",
1140
+
"vectorEffect",
1141
+
"vertAdvY",
1142
+
"vertOriginX",
1143
+
"vertOriginY",
1144
+
"wordSpacing",
1145
+
"writingMode",
1146
+
"xmlnsXlink",
1147
+
"xHeight"
1148
+
].reduce(
1149
+
(map, attribute) => {
1150
+
map[attribute.toLowerCase()] = attribute;
1151
+
return map;
1152
+
},
1153
+
{}
1154
+
);
1155
+
const CASE_SENSITIVE_SVG_ATTRIBUTES = [
1156
+
"allowReorder",
1157
+
"attributeName",
1158
+
"attributeType",
1159
+
"autoReverse",
1160
+
"baseFrequency",
1161
+
"baseProfile",
1162
+
"calcMode",
1163
+
"clipPathUnits",
1164
+
"contentScriptType",
1165
+
"contentStyleType",
1166
+
"diffuseConstant",
1167
+
"edgeMode",
1168
+
"externalResourcesRequired",
1169
+
"filterRes",
1170
+
"filterUnits",
1171
+
"glyphRef",
1172
+
"gradientTransform",
1173
+
"gradientUnits",
1174
+
"kernelMatrix",
1175
+
"kernelUnitLength",
1176
+
"keyPoints",
1177
+
"keySplines",
1178
+
"keyTimes",
1179
+
"lengthAdjust",
1180
+
"limitingConeAngle",
1181
+
"markerHeight",
1182
+
"markerUnits",
1183
+
"markerWidth",
1184
+
"maskContentUnits",
1185
+
"maskUnits",
1186
+
"numOctaves",
1187
+
"pathLength",
1188
+
"patternContentUnits",
1189
+
"patternTransform",
1190
+
"patternUnits",
1191
+
"pointsAtX",
1192
+
"pointsAtY",
1193
+
"pointsAtZ",
1194
+
"preserveAlpha",
1195
+
"preserveAspectRatio",
1196
+
"primitiveUnits",
1197
+
"refX",
1198
+
"refY",
1199
+
"repeatCount",
1200
+
"repeatDur",
1201
+
"requiredExtensions",
1202
+
"requiredFeatures",
1203
+
"specularConstant",
1204
+
"specularExponent",
1205
+
"spreadMethod",
1206
+
"startOffset",
1207
+
"stdDeviation",
1208
+
"stitchTiles",
1209
+
"suppressContentEditableWarning",
1210
+
"suppressHydrationWarning",
1211
+
"surfaceScale",
1212
+
"systemLanguage",
1213
+
"tableValues",
1214
+
"targetX",
1215
+
"targetY",
1216
+
"textLength",
1217
+
"viewBox",
1218
+
"viewTarget",
1219
+
"xChannelSelector",
1220
+
"yChannelSelector"
1221
+
].reduce(
1222
+
(map, attribute) => {
1223
+
map[attribute.toLowerCase()] = attribute;
1224
+
return map;
1225
+
},
1226
+
{}
1227
+
);
1228
+
const SVG_ATTRIBUTES_WITH_COLONS = [
1229
+
"xlink:actuate",
1230
+
"xlink:arcrole",
1231
+
"xlink:href",
1232
+
"xlink:role",
1233
+
"xlink:show",
1234
+
"xlink:title",
1235
+
"xlink:type",
1236
+
"xml:base",
1237
+
"xml:lang",
1238
+
"xml:space",
1239
+
"xmlns:xlink"
1240
+
].reduce(
1241
+
(map, attribute) => {
1242
+
map[attribute.replace(":", "").toLowerCase()] = attribute;
1243
+
return map;
1244
+
},
1245
+
{}
1246
+
);
1247
+
function getNormalAttributeName(attribute) {
1248
+
switch (attribute) {
1249
+
case "htmlFor":
1250
+
return "for";
1251
+
case "className":
1252
+
return "class";
1253
+
}
1254
+
const attributeLowerCase = attribute.toLowerCase();
1255
+
if (CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase]) {
1256
+
return CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase];
1257
+
} else if (SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]) {
1258
+
return paramCase(
1259
+
SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]
1260
+
);
1261
+
} else if (SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase]) {
1262
+
return SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase];
1263
+
}
1264
+
return attributeLowerCase;
1265
+
}
1266
+
function getNormalStylePropertyName(property) {
1267
+
if (property.startsWith("--")) {
1268
+
return property;
1269
+
}
1270
+
if (hasPrefix(property, ["ms", "O", "Moz", "Webkit"])) {
1271
+
return "-" + paramCase(property);
1272
+
}
1273
+
return paramCase(property);
1274
+
}
1275
+
function getNormalStylePropertyValue(property, value) {
1276
+
if (typeof value === "number" && 0 !== value && !hasPrefix(property, ["--"]) && !CSS_PROPERTIES_SUPPORTS_UNITLESS.has(property)) {
1277
+
return value + "px";
1278
+
}
1279
+
return value;
1280
+
}
1281
+
function renderElement(element, context, legacyContext = {}) {
1282
+
if (null === element || void 0 === element || false === element) {
1283
+
return "";
1284
+
}
1285
+
if (Array.isArray(element)) {
1286
+
return renderChildren(element, context, legacyContext);
1287
+
}
1288
+
switch (typeof element) {
1289
+
case "string":
1290
+
return (0,external_wp_escapeHtml_namespaceObject.escapeHTML)(element);
1291
+
case "number":
1292
+
return element.toString();
1293
+
}
1294
+
const { type, props } = element;
1295
+
switch (type) {
1296
+
case external_React_namespaceObject.StrictMode:
1297
+
case external_React_namespaceObject.Fragment:
1298
+
return renderChildren(props.children, context, legacyContext);
1299
+
case RawHTML:
1300
+
const { children, ...wrapperProps } = props;
1301
+
return renderNativeComponent(
1302
+
!Object.keys(wrapperProps).length ? null : "div",
1303
+
{
1304
+
...wrapperProps,
1305
+
dangerouslySetInnerHTML: { __html: children }
1306
+
},
1307
+
context,
1308
+
legacyContext
1309
+
);
1310
+
}
1311
+
switch (typeof type) {
1312
+
case "string":
1313
+
return renderNativeComponent(type, props, context, legacyContext);
1314
+
case "function":
1315
+
if (type.prototype && typeof type.prototype.render === "function") {
1316
+
return renderComponent(type, props, context, legacyContext);
1317
+
}
1318
+
return renderElement(
1319
+
type(props, legacyContext),
1320
+
context,
1321
+
legacyContext
1322
+
);
1323
+
}
1324
+
switch (type && type.$$typeof) {
1325
+
case Provider.$$typeof:
1326
+
return renderChildren(props.children, props.value, legacyContext);
1327
+
case Consumer.$$typeof:
1328
+
return renderElement(
1329
+
props.children(context || type._currentValue),
1330
+
context,
1331
+
legacyContext
1332
+
);
1333
+
case ForwardRef.$$typeof:
1334
+
return renderElement(
1335
+
type.render(props),
1336
+
context,
1337
+
legacyContext
1338
+
);
1339
+
}
1340
+
return "";
1341
+
}
1342
+
function renderNativeComponent(type, props, context, legacyContext = {}) {
1343
+
let content = "";
1344
+
if (type === "textarea" && props.hasOwnProperty("value")) {
1345
+
content = renderChildren(props.value, context, legacyContext);
1346
+
const { value, ...restProps } = props;
1347
+
props = restProps;
1348
+
} else if (props.dangerouslySetInnerHTML && typeof props.dangerouslySetInnerHTML.__html === "string") {
1349
+
content = props.dangerouslySetInnerHTML.__html;
1350
+
} else if (typeof props.children !== "undefined") {
1351
+
content = renderChildren(props.children, context, legacyContext);
1352
+
}
1353
+
if (!type) {
1354
+
return content;
1355
+
}
1356
+
const attributes = renderAttributes(props);
1357
+
if (SELF_CLOSING_TAGS.has(type)) {
1358
+
return "<" + type + attributes + "/>";
1359
+
}
1360
+
return "<" + type + attributes + ">" + content + "</" + type + ">";
1361
+
}
1362
+
function renderComponent(Component, props, context, legacyContext = {}) {
1363
+
const instance = new Component(props, legacyContext);
1364
+
if (typeof instance.getChildContext === "function") {
1365
+
Object.assign(legacyContext, instance.getChildContext());
1366
+
}
1367
+
const html = renderElement(instance.render(), context, legacyContext);
1368
+
return html;
1369
+
}
1370
+
function renderChildren(children, context, legacyContext = {}) {
1371
+
let result = "";
1372
+
const childrenArray = Array.isArray(children) ? children : [children];
1373
+
for (let i = 0; i < childrenArray.length; i++) {
1374
+
const child = childrenArray[i];
1375
+
result += renderElement(child, context, legacyContext);
1376
+
}
1377
+
return result;
1378
+
}
1379
+
function renderAttributes(props) {
1380
+
let result = "";
1381
+
for (const key in props) {
1382
+
const attribute = getNormalAttributeName(key);
1383
+
if (!(0,external_wp_escapeHtml_namespaceObject.isValidAttributeName)(attribute)) {
1384
+
continue;
1385
+
}
1386
+
let value = getNormalAttributeValue(key, props[key]);
1387
+
if (!ATTRIBUTES_TYPES.has(typeof value)) {
1388
+
continue;
1389
+
}
1390
+
if (isInternalAttribute(key)) {
1391
+
continue;
1392
+
}
1393
+
const isBooleanAttribute = BOOLEAN_ATTRIBUTES.has(attribute);
1394
+
if (isBooleanAttribute && value === false) {
1395
+
continue;
1396
+
}
1397
+
const isMeaningfulAttribute = isBooleanAttribute || hasPrefix(key, ["data-", "aria-"]) || ENUMERATED_ATTRIBUTES.has(attribute);
1398
+
if (typeof value === "boolean" && !isMeaningfulAttribute) {
1399
+
continue;
1400
+
}
1401
+
result += " " + attribute;
1402
+
if (isBooleanAttribute) {
1403
+
continue;
1404
+
}
1405
+
if (typeof value === "string") {
1406
+
value = (0,external_wp_escapeHtml_namespaceObject.escapeAttribute)(value);
1407
+
}
1408
+
result += '="' + value + '"';
1409
+
}
1410
+
return result;
1411
+
}
1412
+
function renderStyle(style) {
1413
+
if (!isPlainObject(style)) {
1414
+
return style;
1415
+
}
1416
+
let result;
1417
+
const styleObj = style;
1418
+
for (const property in styleObj) {
1419
+
const value = styleObj[property];
1420
+
if (null === value || void 0 === value) {
1421
+
continue;
1422
+
}
1423
+
if (result) {
1424
+
result += ";";
1425
+
} else {
1426
+
result = "";
1427
+
}
1428
+
const normalName = getNormalStylePropertyName(property);
1429
+
const normalValue = getNormalStylePropertyValue(property, value);
1430
+
result += normalName + ":" + normalValue;
1431
+
}
1432
+
return result;
1433
+
}
1434
+
var serialize_default = renderElement;
1435
+
1436
+
1437
+
;// ./node_modules/@wordpress/element/build-module/index.js
1438
+
1439
+
1440
+
1441
+
1442
+
1443
+
1444
+
1445
+
1446
+
1447
+
(window.wp = window.wp || {}).element = __webpack_exports__;
1448
+
/******/ })()
1449
+
;