vendor: 6,853 bytes, lines 1-156
1/******/ (() => { // webpackBootstrap 2/******/ "use strict"; 3/******/ var __webpack_modules__ = ({ 4 5/***/ 4140: 6/***/ ((__unused_webpack_module, exports, __webpack_require__) => { 7 8 9 10var m = __webpack_require__(5795); 11if (true) { 12 exports.H = m.createRoot; 13 exports.c = m.hydrateRoot; 14} else { var i; } 15 16 17/***/ }), 18 19/***/ 5795: 20/***/ ((module) => { 21 22module.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/************************************************************************/ 82var __webpack_exports__ = {}; 83// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk. 84(() => { 85// ESM COMPAT FLAG 86__webpack_require__.r(__webpack_exports__); 87 88// EXPORTS 89__webpack_require__.d(__webpack_exports__, { 90 Children: () => (/* reexport */ external_React_namespaceObject.Children), 91 Component: () => (/* reexport */ external_React_namespaceObject.Component), 92 Fragment: () => (/* reexport */ external_React_namespaceObject.Fragment), 93 Platform: () => (/* reexport */ platform), 94 PureComponent: () => (/* reexport */ external_React_namespaceObject.PureComponent), 95 RawHTML: () => (/* reexport */ RawHTML), 96 StrictMode: () => (/* reexport */ external_React_namespaceObject.StrictMode), 97 Suspense: () => (/* reexport */ external_React_namespaceObject.Suspense), 98 cloneElement: () => (/* reexport */ external_React_namespaceObject.cloneElement), 99 concatChildren: () => (/* reexport */ concatChildren), 100 createContext: () => (/* reexport */ external_React_namespaceObject.createContext), 101 createElement: () => (/* reexport */ external_React_namespaceObject.createElement), 102 createInterpolateElement: () => (/* reexport */ create_interpolate_element), 103 createPortal: () => (/* reexport */ external_ReactDOM_.createPortal), 104 createRef: () => (/* reexport */ external_React_namespaceObject.createRef), 105 createRoot: () => (/* reexport */ client/* createRoot */.H), 106 findDOMNode: () => (/* reexport */ external_ReactDOM_.findDOMNode), 107 flushSync: () => (/* reexport */ external_ReactDOM_.flushSync), 108 forwardRef: () => (/* reexport */ external_React_namespaceObject.forwardRef), 109 hydrate: () => (/* reexport */ external_ReactDOM_.hydrate), 110 hydrateRoot: () => (/* reexport */ client/* hydrateRoot */.c), 111 isEmptyElement: () => (/* reexport */ isEmptyElement), 112 isValidElement: () => (/* reexport */ external_React_namespaceObject.isValidElement), 113 lazy: () => (/* reexport */ external_React_namespaceObject.lazy), 114 memo: () => (/* reexport */ external_React_namespaceObject.memo), 115 render: () => (/* reexport */ external_ReactDOM_.render), 116 renderToString: () => (/* reexport */ serialize), 117 startTransition: () => (/* reexport */ external_React_namespaceObject.startTransition), 118 switchChildrenNodeName: () => (/* reexport */ switchChildrenNodeName), 119 unmountComponentAtNode: () => (/* reexport */ external_ReactDOM_.unmountComponentAtNode), 120 useCallback: () => (/* reexport */ external_React_namespaceObject.useCallback), 121 useContext: () => (/* reexport */ external_React_namespaceObject.useContext), 122 useDebugValue: () => (/* reexport */ external_React_namespaceObject.useDebugValue), 123 useDeferredValue: () => (/* reexport */ external_React_namespaceObject.useDeferredValue), 124 useEffect: () => (/* reexport */ external_React_namespaceObject.useEffect), 125 useId: () => (/* reexport */ external_React_namespaceObject.useId), 126 useImperativeHandle: () => (/* reexport */ external_React_namespaceObject.useImperativeHandle), 127 useInsertionEffect: () => (/* reexport */ external_React_namespaceObject.useInsertionEffect), 128 useLayoutEffect: () => (/* reexport */ external_React_namespaceObject.useLayoutEffect), 129 useMemo: () => (/* reexport */ external_React_namespaceObject.useMemo), 130 useReducer: () => (/* reexport */ external_React_namespaceObject.useReducer), 131 useRef: () => (/* reexport */ external_React_namespaceObject.useRef), 132 useState: () => (/* reexport */ external_React_namespaceObject.useState), 133 useSyncExternalStore: () => (/* reexport */ external_React_namespaceObject.useSyncExternalStore), 134 useTransition: () => (/* reexport */ external_React_namespaceObject.useTransition) 135}); 136 137;// CONCATENATED MODULE: external "React" 138const external_React_namespaceObject = window["React"]; 139;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/create-interpolate-element.js 140/** 141 * Internal dependencies 142 */ 143 144 145/** 146 * Object containing a React element. 147 * 148 * @typedef {import('react').ReactElement} Element 149 */ 150 151let indoc, offset, output, stack; 152 153/** 154 * Matches tags in the localized string 155 * 156 * This is used for extracting the tag pattern groups for parsing the localized
157 * string and along with the map converting it to a react element. 158 * 159 * There are four references extracted using this tokenizer: 160 * 161 * match: Full match of the tag (i.e. <strong>, </strong>, <br/>) 162 * isClosing: The closing slash, if it exists. 163 * name: The name portion of the tag (strong, br) (if ) 164 * isSelfClosed: The slash on a self closing tag, if it exists. 165 * 166 * @type {RegExp} 167 */ 168const tokenizer = /<(\/)?(\w+)\s*(\/)?>/g; 169 170/** 171 * The stack frame tracking parse progress. 172 * 173 * @typedef Frame 174 * 175 * @property {Element} element A parent element which may still have 176 * @property {number} tokenStart Offset at which parent element first 177 * appears. 178 * @property {number} tokenLength Length of string marking start of parent 179 * element. 180 * @property {number} [prevOffset] Running offset at which parsing should 181 * continue. 182 * @property {number} [leadingTextStart] Offset at which last closing element 183 * finished, used for finding text between 184 * elements. 185 * @property {Element[]} children Children. 186 */ 187 188/** 189 * Tracks recursive-descent parse state. 190 * 191 * This is a Stack frame holding parent elements until all children have been 192 * parsed. 193 * 194 * @private 195 * @param {Element} element A parent element which may still have 196 * nested children not yet parsed. 197 * @param {number} tokenStart Offset at which parent element first 198 * appears. 199 * @param {number} tokenLength Length of string marking start of parent 200 * element. 201 * @param {number} [prevOffset] Running offset at which parsing should 202 * continue. 203 * @param {number} [leadingTextStart] Offset at which last closing element 204 * finished, used for finding text between 205 * elements. 206 * 207 * @return {Frame} The stack frame tracking parse progress. 208 */ 209function createFrame(element, tokenStart, tokenLength, prevOffset, leadingTextStart) { 210 return { 211 element, 212 tokenStart, 213 tokenLength, 214 prevOffset, 215 leadingTextStart, 216 children: [] 217 }; 218} 219 220/** 221 * This function creates an interpolated element from a passed in string with 222 * specific tags matching how the string should be converted to an element via 223 * the conversion map value. 224 * 225 * @example 226 * For example, for the given string: 227 * 228 * "This is a <span>string</span> with <a>a link</a> and a self-closing 229 * <CustomComponentB/> tag" 230 * 231 * You would have something like this as the conversionMap value: 232 * 233 * ```js 234 * { 235 * span: <span />, 236 * a: <a href={ 'https://github.com' } />, 237 * CustomComponentB: <CustomComponent />, 238 * } 239 * ``` 240 * 241 * @param {string} interpolatedString The interpolation string to be parsed. 242 * @param {Record<string, Element>} conversionMap The map used to convert the string to 243 * a react element. 244 * @throws {TypeError} 245 * @return {Element} A wp element. 246 */ 247const createInterpolateElement = (interpolatedString, conversionMap) => { 248 indoc = interpolatedString; 249 offset = 0; 250 output = []; 251 stack = []; 252 tokenizer.lastIndex = 0; 253 if (!isValidConversionMap(conversionMap)) { 254 throw new TypeError('The conversionMap provided is not valid. It must be an object with values that are React Elements'); 255 } 256 do { 257 // twiddle our thumbs 258 } while (proceed(conversionMap)); 259 return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, ...output); 260}; 261 262/** 263 * Validate conversion map. 264 * 265 * A map is considered valid if it's an object and every value in the object 266 * is a React Element 267 * 268 * @private 269 * 270 * @param {Object} conversionMap The map being validated. 271 * 272 * @return {boolean} True means the map is valid. 273 */ 274const isValidConversionMap = conversionMap => { 275 const isObject = typeof conversionMap === 'object';
276 const values = isObject && Object.values(conversionMap); 277 return isObject && values.length && values.every(element => (0,external_React_namespaceObject.isValidElement)(element)); 278}; 279 280/** 281 * This is the iterator over the matches in the string. 282 * 283 * @private 284 * 285 * @param {Object} conversionMap The conversion map for the string. 286 * 287 * @return {boolean} true for continuing to iterate, false for finished. 288 */ 289function proceed(conversionMap) { 290 const next = nextToken(); 291 const [tokenType, name, startOffset, tokenLength] = next; 292 const stackDepth = stack.length; 293 const leadingTextStart = startOffset > offset ? offset : null; 294 if (!conversionMap[name]) { 295 addText(); 296 return false; 297 } 298 switch (tokenType) { 299 case 'no-more-tokens': 300 if (stackDepth !== 0) { 301 const { 302 leadingTextStart: stackLeadingText, 303 tokenStart 304 } = stack.pop(); 305 output.push(indoc.substr(stackLeadingText, tokenStart)); 306 } 307 addText(); 308 return false; 309 case 'self-closed': 310 if (0 === stackDepth) { 311 if (null !== leadingTextStart) { 312 output.push(indoc.substr(leadingTextStart, startOffset - leadingTextStart)); 313 } 314 output.push(conversionMap[name]); 315 offset = startOffset + tokenLength; 316 return true; 317 } 318 319 // Otherwise we found an inner element. 320 addChild(createFrame(conversionMap[name], startOffset, tokenLength)); 321 offset = startOffset + tokenLength; 322 return true; 323 case 'opener': 324 stack.push(createFrame(conversionMap[name], startOffset, tokenLength, startOffset + tokenLength, leadingTextStart)); 325 offset = startOffset + tokenLength; 326 return true; 327 case 'closer': 328 // If we're not nesting then this is easy - close the block. 329 if (1 === stackDepth) { 330 closeOuterElement(startOffset); 331 offset = startOffset + tokenLength; 332 return true; 333 } 334 335 // Otherwise we're nested and we have to close out the current 336 // block and add it as a innerBlock to the parent. 337 const stackTop = stack.pop(); 338 const text = indoc.substr(stackTop.prevOffset, startOffset - stackTop.prevOffset); 339 stackTop.children.push(text); 340 stackTop.prevOffset = startOffset + tokenLength; 341 const frame = createFrame(stackTop.element, stackTop.tokenStart, stackTop.tokenLength, startOffset + tokenLength); 342 frame.children = stackTop.children; 343 addChild(frame); 344 offset = startOffset + tokenLength; 345 return true; 346 default: 347 addText(); 348 return false; 349 } 350} 351 352/** 353 * Grabs the next token match in the string and returns it's details. 354 * 355 * @private 356 * 357 * @return {Array} An array of details for the token matched. 358 */ 359function nextToken() { 360 const matches = tokenizer.exec(indoc); 361 // We have no more tokens. 362 if (null === matches) { 363 return ['no-more-tokens']; 364 } 365 const startedAt = matches.index; 366 const [match, isClosing, name, isSelfClosed] = matches; 367 const length = match.length; 368 if (isSelfClosed) { 369 return ['self-closed', name, startedAt, length]; 370 } 371 if (isClosing) { 372 return ['closer', name, startedAt, length]; 373 } 374 return ['opener', name, startedAt, length]; 375} 376 377/** 378 * Pushes text extracted from the indoc string to the output stack given the 379 * current rawLength value and offset (if rawLength is provided ) or the 380 * indoc.length and offset. 381 * 382 * @private 383 */ 384function addText() { 385 const length = indoc.length - offset; 386 if (0 === length) { 387 return; 388 } 389 output.push(indoc.substr(offset, length)); 390} 391 392/** 393 * Pushes a child element to the associated parent element's children for the 394 * parent currently active in the stack. 395 * 396 * @private 397 * 398 * @param {Frame} frame The Frame containing the child element and it's 399 * token information. 400 */ 401function addChild(frame) { 402 const { 403 element, 404 tokenStart, 405 tokenLength, 406 prevOffset, 407 children 408 } = frame; 409 const parent = stack[stack.length - 1]; 410 const text = indoc.substr(parent.prevOffset, tokenStart - parent.prevOffset); 411 if (text) { 412 parent.children.push(text); 413 } 414 parent.children.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children)); 415 parent.prevOffset = prevOffset ? prevOffset : tokenStart + tokenLength; 416} 417 418/** 419 * This is called for closing tags. It creates the element currently active in 420 * the stack. 421 * 422 * @private 423 * 424 * @param {number} endOffset Offset at which the closing tag for the element 425 * begins in the string. If this is greater than the 426 * prevOffset attached to the element, then this 427 * helps capture any remaining nested text nodes in 428 * the element. 429 */ 430function closeOuterElement(endOffset) { 431 const { 432 element, 433 leadingTextStart, 434 prevOffset, 435 tokenStart, 436 children 437 } = stack.pop(); 438 const text = endOffset ? indoc.substr(prevOffset, endOffset - prevOffset) : indoc.substr(prevOffset); 439 if (text) { 440 children.push(text); 441 } 442 if (null !== leadingTextStart) { 443 output.push(indoc.substr(leadingTextStart, tokenStart - leadingTextStart)); 444 } 445 output.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children)); 446} 447/* harmony default export */ const create_interpolate_element = (createInterpolateElement); 448 449;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/react.js 450/** 451 * External dependencies 452 */ 453// eslint-disable-next-line @typescript-eslint/no-restricted-imports 454 455 456/** 457 * Object containing a React element. 458 * 459 * @typedef {import('react').ReactElement} Element 460 */ 461 462/** 463 * Object containing a React component. 464 * 465 * @typedef {import('react').ComponentType} ComponentType 466 */ 467 468/** 469 * Object containing a React synthetic event. 470 * 471 * @typedef {import('react').SyntheticEvent} SyntheticEvent 472 */ 473 474/** 475 * Object containing a React synthetic event. 476 * 477 * @template T 478 * @typedef {import('react').RefObject<T>} RefObject<T> 479 */ 480 481/** 482 * Object that provides utilities for dealing with React children. 483 */ 484 485 486/** 487 * Creates a copy of an element with extended props. 488 * 489 * @param {Element} element Element 490 * @param {?Object} props Props to apply to cloned element 491 * 492 * @return {Element} Cloned element. 493 */ 494 495 496/** 497 * A base class to create WordPress Components (Refs, state and lifecycle hooks) 498 */ 499 500 501/**
502 * Creates a context object containing two components: a provider and consumer. 503 * 504 * @param {Object} defaultValue A default data stored in the context. 505 * 506 * @return {Object} Context object. 507 */ 508 509 510/** 511 * Returns a new element of given type. Type can be either a string tag name or 512 * another function which itself returns an element. 513 * 514 * @param {?(string|Function)} type Tag name or element creator 515 * @param {Object} props Element properties, either attribute 516 * set to apply to DOM node or values to 517 * pass through to element creator 518 * @param {...Element} children Descendant elements 519 * 520 * @return {Element} Element. 521 */ 522 523 524/** 525 * Returns an object tracking a reference to a rendered element via its 526 * `current` property as either a DOMElement or Element, dependent upon the 527 * type of element rendered with the ref attribute. 528 * 529 * @return {Object} Ref object. 530 */ 531 532 533/** 534 * Component enhancer used to enable passing a ref to its wrapped component. 535 * Pass a function argument which receives `props` and `ref` as its arguments, 536 * returning an element using the forwarded ref. The return value is a new 537 * component which forwards its ref. 538 * 539 * @param {Function} forwarder Function passed `props` and `ref`, expected to 540 * return an element. 541 * 542 * @return {Component} Enhanced component. 543 */ 544 545 546/** 547 * A component which renders its children without any wrapping element. 548 */ 549 550 551/** 552 * Checks if an object is a valid React Element. 553 * 554 * @param {Object} objectToCheck The object to be checked. 555 * 556 * @return {boolean} true if objectToTest is a valid React Element and false otherwise. 557 */ 558 559 560/** 561 * @see https://reactjs.org/docs/react-api.html#reactmemo 562 */ 563 564 565/** 566 * Component that activates additional checks and warnings for its desce
566ndants. 567 */ 568 569 570/** 571 * @see https://reactjs.org/docs/hooks-reference.html#usecallback 572 */ 573 574 575/** 576 * @see https://reactjs.org/docs/hooks-reference.html#usecontext 577 */ 578 579 580/** 581 * @see https://reactjs.org/docs/hooks-reference.html#usedebugvalue 582 */ 583 584 585/** 586 * @see https://reactjs.org/docs/hooks-reference.html#usedeferredvalue 587 */ 588 589 590/** 591 * @see https://reactjs.org/docs/hooks-reference.html#useeffect 592 */ 593 594 595/** 596 * @see https://reactjs.org/docs/hooks-reference.html#useid 597 */ 598 599 600/** 601 * @see https://reactjs.org/docs/hooks-reference.html#useimperativehandle 602 */ 603 604 605/** 606 * @see https://reactjs.org/docs/hooks-reference.html#useinsertioneffect 607 */ 608 609 610/** 611 * @see https://reactjs.org/docs/hooks-reference.html#uselayouteffect 612 */ 613 614 615/** 616 * @see https://reactjs.org/docs/hooks-reference.html#usememo 617 */ 618 619 620/** 621 * @see https://reactjs.org/docs/hooks-reference.html#usereducer 622 */ 623 624 625/** 626 * @see https://reactjs.org/docs/hooks-reference.html#useref 627 */ 628 629 630/** 631 * @see https://reactjs.org/docs/hooks-reference.html#usestate 632 */ 633 634 635/** 636 * @see https://reactjs.org/docs/hooks-reference.html#usesyncexternalstore 637 */ 638 639 640/** 641 * @see https://reactjs.org/docs/hooks-reference.html#usetransition 642 */ 643 644 645/** 646 * @see https://reactjs.org/docs/react-api.html#starttransition 647 */ 648 649 650/** 651 * @see https://reactjs.org/docs/react-api.html#reactlazy 652 */ 653 654 655/** 656 * @see https://reactjs.org/docs/react-api.html#reactsuspense 657 */ 658 659 660/** 661 * @see https://reactjs.org/docs/react-api.html#reactpurecomponent 662 */ 663 664 665/** 666 * Concatenate two or more React children objects. 667 * 668 * @param {...?Object} childrenArguments Array of children arguments (array of arrays/strings/objects) to concatenate. 669 * 670 * @return {Array} The concatenated value. 671 */ 672function concatChildren(...childrenArguments) { 673 return childrenArguments.reduce((accumulator, children, i) => { 674 external_React_namespaceObject.Children.forEach(children, (child, j) => { 675 if (child && 'string' !== typeof child) { 676 child = (0,external_React_namespaceObject.cloneElement)(child, { 677 key: [i, j].join() 678 }); 679 } 680 accumulator.push(child); 681 }); 682 return accumulator; 683 }, []); 684} 685 686/** 687 * Switches the nodeName of all the elements in the children object. 688 * 689 * @param {?Object} children Children object. 690 * @param {string} nodeName Node name. 691 * 692 * @return {?Object} The updated children object. 693 */ 694function switchChildrenNodeName(children, nodeName) { 695 return children && external_React_namespaceObject.Children.map(children, (elt, index) => { 696 if (typeof elt?.valueOf() === 'string') { 697 return (0,external_React_namespaceObject.createElement)(nodeName, { 698 key: index 699 }, elt); 700 } 701 const { 702 children: childrenProp, 703 ...props 704 } = elt.props; 705 return (0,external_React_namespaceObject.createElement)(nodeName, { 706 key: index, 707 ...props 708 }, childrenProp); 709 }); 710} 711 712// EXTERNAL MODULE: external "ReactDOM" 713var external_ReactDOM_ = __webpack_require__(5795); 714// EXTERNAL MODULE: ./node_modules/react-dom/client.js 715var client = __webpack_require__(4140); 716;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/react-platform.js 717/** 718 * External dependencies 719 */ 720 721 722 723/** 724 * Creates a portal into which a component can be rendered. 725 * 726 * @see https://github.com/facebook/react/issues/10309#issuecomment-318433235 727 * 728 * @param {import('react').ReactElement} child Any renderable child, such as an element, 729 * string, or fragment. 730 * @param {HTMLElement} container DOM node into which element should be rendered. 731 */ 732 733 734/** 735 * Finds the dom node of a React component. 736 * 737 * @param {import('react').ComponentType} component Component's instance. 738 */ 739 740 741/** 742 * Forces React to flush any updates inside the provided callback synchronously. 743 * 744 * @param {Function} callback Callback to run synchronously. 745 */ 746 747 748/** 749 * Renders a given element into the target DOM node. 750 * 751 * @deprecated since WordPress 6.2.0. Use `createRoot` instead. 752 * @see https://react.dev/reference/react-dom/render 753 */ 754 755 756/** 757 * Hydrates a given element into the target DOM node. 758 * 759 * @deprecated since WordPress 6.2.0. Use `hydrateRoot` instead. 760 * @see https://react.dev/reference/react-dom/hydrate 761 */ 762 763 764/** 765 * Creates a new React root for the target DOM node. 766 * 767 * @since 6.2.0 Introduced in WordPress core. 768 * @see https://react.dev/reference/react-dom/client/createRoot 769 */ 770 771 772/** 773 * Creates a new React root for the target DOM node and hydrates it with a pre-generated markup. 774 * 775 * @since 6.2.0 Introduced in WordPress core. 776 * @see https://react.dev/reference/react-dom/client/hydrateRoot 777 */ 778 779 780/** 781 * Removes any mounted element from the target DOM node. 782 * 783 * @deprecated since WordPress 6.2.0. Use `root.unmount()` instead. 784 * @see https://react.dev/reference/react-dom/unmountComponentAtNode 785 */ 786 787 788;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/utils.js 789/** 790 * Checks if the provided WP element is empty. 791 * 792 * @param {*} element WP element to check. 793 * @return {boolean} True when an element is considered empty. 794 */ 795const isEmptyElement = element => { 796 if (typeof element === 'number') { 797 return false;
798 } 799 if (typeof element?.valueOf() === 'string' || Array.isArray(element)) { 800 return !element.length; 801 } 802 return !element; 803}; 804 805;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/platform.js 806/** 807 * Parts of this source were derived and modified from react-native-web, 808 * released under the MIT license. 809 * 810 * Copyright (c) 2016-present, Nicolas Gallagher. 811 * Copyright (c) 2015-present, Facebook, Inc. 812 * 813 */ 814const Platform = { 815 OS: 'web', 816 select: spec => 'web' in spec ? spec.web : spec.default, 817 isWeb: true 818}; 819/** 820 * Component used to detect the current Platform being used. 821 * Use Platform.OS === 'web' to detect if running on web enviroment. 822 * 823 * This is the same concept as the React Native implementation. 824 * 825 * @see https://reactnative.dev/docs/platform-specific-code#platform-module 826 * 827 * Here is an example of how to use the select method: 828 * @example 829 * ```js 830 * import { Platform } from '@wordpress/element'; 831 * 832 * const placeholderLabel = Platform.select( { 833 * native: __( 'Add media' ), 834 * web: __( 'Drag images, upload new ones or select files from your library.' ), 835 * } ); 836 * ``` 837 */ 838/* harmony default export */ const platform = (Platform); 839 840;// CONCATENATED MODULE: ./node_modules/is-plain-object/dist/is-plain-object.mjs 841/*! 842 * is-plain-object <https://github.com/jonschlinkert/is-plain-object> 843 * 844 * Copyright (c) 2014-2017, Jon Schlinkert. 845 * Released under the MIT License. 846 */ 847 848function isObject(o) { 849 return Object.prototype.toString.call(o) === '[object Object]'; 850} 851 852function isPlainObject(o) { 853 var ctor,prot; 854 855 if (isObject(o) === false) return false; 856 857 // If has modified constructor 858 ctor = o.constructor; 859 if (ctor === undefined) return true; 860 861 // If has modified prototype 862 prot = ctor.prototype; 863 if (isObject(prot) === false) return false; 864 865 // If constructor does not have an Object-specific method 866 if (prot.hasOwnProperty('isPrototypeOf') === false) { 867 return false; 868 } 869 870 // Most likely a plain Object 871 return true; 872} 873 874 875 876;// CONCATENATED MODULE: .
vendor: 14,781 bytes, lines 876-1192
876/node_modules/tslib/tslib.es6.mjs 877/****************************************************************************** 878Copyright (c) Microsoft Corporation. 879 880Permission to use, copy, modify, and/or distribute this software for any 881purpose with or without fee is hereby granted. 882 883THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 884REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 885AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 886INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 887LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 888OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 889PERFORMANCE OF THIS SOFTWARE. 890***************************************************************************** */ 891/* global Reflect, Promise, SuppressedError, Symbol */ 892 893var extendStatics = function(d, b) { 894 extendStatics = Object.setPrototypeOf || 895 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 896 function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; 897 return extendStatics(d, b); 898}; 899 900function __extends(d, b) { 901 if (typeof b !== "function" && b !== null) 902 throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); 903 extendStatics(d, b); 904 function __() { this.constructor = d; } 905 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 906} 907 908var __assign = function() { 909 __assign = Object.assign || function __assign(t) { 910 for (var s, i = 1, n = arguments.length; i < n; i++) { 911 s = arguments[i]; 912 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; 913 } 914 return t; 915 } 916 return __assign.apply(this, arguments); 917} 918 919function __rest(s, e) { 920 var t = {}; 921 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) 922 t[p] = s[p]; 923 if (s != null && typeof Object.getOwnPropertySymbols === "function") 924 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { 925 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) 926 t[p[i]] = s[p[i]]; 927 } 928 return t; 929} 930 931function __decorate(decorators, target, key, desc) { 932 var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; 933 if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); 934 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; 935 return c > 3 && r && Object.defineProperty(target, key, r), r; 936} 937 938function __param(paramIndex, decorator) { 939 return function (target, key) { decorator(target, key, paramIndex); } 940} 941 942function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { 943 function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; } 944 var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; 945 var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; 946 var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); 947 var _, done = false; 948 for (var i = decorators.length - 1; i >= 0; i--) { 949 var context = {}; 950 for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; 951 for (var p in contextIn.access) context.access[p] = contextIn.access[p]; 952 context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); }; 953 var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); 954 if (kind === "accessor") { 955 if (result === void 0) continue; 956 if (result === null || typeof result !== "object") throw new TypeError("Object expected"); 957 if (_ = accept(result.get)) descriptor.get = _; 958 if (_ = accept(result.set)) descriptor.set = _; 959 if (_ = accept(result.init)) initializers.unshift(_); 960 } 961 else if (_ = accept(result)) { 962 if (kind === "field") initializers.unshift(_); 963 else descriptor[key] = _; 964 } 965 } 966 if (target) Object.defineProperty(target, contextIn.name, descriptor); 967 done = true; 968}; 969 970function __runInitializers(thisArg, initializers, value) { 971 var useValue = arguments.length > 2; 972 for (var i = 0; i < initializers.length; i++) { 973 value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); 974 } 975 return useValue ? value : void 0; 976}; 977 978function __propKey(x) { 979 return typeof x === "symbol" ? x : "".concat(x); 980}; 981 982function __setFunctionName(f, name, prefix) { 983 if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; 984 return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); 985}; 986 987function __metadata(metadataKey, metadataValue) { 988 if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); 989} 990 991function __awaiter(thisArg, _arguments, P, generator) { 992 function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } 993 return new (P || (P = Promise))(function (resolve, reject) { 994 function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } 995 function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } 996 function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } 997 step((generator = generator.apply(thisArg, _arguments || [])).next()); 998 }); 999} 1000 1001function __generator(thisArg, body) { 1002 var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; 1003 return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; 1004 function verb(n) { return function (v) { return step([n, v]); }; } 1005 function step(op) { 1006 if (f) throw new TypeError("Generator is already executing."); 1007 while (g && (g = 0, op[0] && (_ = 0)), _) try { 1008 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; 1009 if (y = 0, t) op = [op[0] & 2, t.value]; 1010 switch (op[0]) { 1011 case 0: case 1: t = op; break; 1012 case 4: _.label++; return { value: op[1], done: false }; 1013 case 5: _.label++; y = op[1]; op = [0]; continue; 1014 case 7: op = _.ops.pop(); _.trys.pop(); continue; 1015 default: 1016 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } 1017 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } 1018 if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } 1019 if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } 1020 if (t[2]) _.ops.pop(); 1021 _.trys.pop(); continue; 1022 } 1023 op = body.call(thisArg, _); 1024 } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } 1025 if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; 1026 } 1027} 1028 1029var __createBinding = Object.create ? (function(o, m, k, k2) { 1030 if (k2 === undefined) k2 = k; 1031 var desc = Object.getOwnPropertyDescriptor(m, k); 1032 if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { 1033 desc = { enumerable: true, get: function() { return m[k]; } }; 1034 } 1035 Object.defineProperty(o, k2, desc); 1036}) : (function(o, m, k, k2) { 1037 if (k2 === undefined) k2 = k; 1038 o[k2] = m[k]; 1039}); 1040 1041function __exportStar(m, o) { 1042 for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); 1043} 1044 1045function __values(o) { 1046 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; 1047 if (m) return m.call(o); 1048 if (o && typeof o.length === "number") return { 1049 next: function () { 1050 if (o && i >= o.length) o = void 0; 1051 return { value: o && o[i++], done: !o }; 1052 } 1053 }; 1054 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); 1055} 1056 1057function __read(o, n) { 1058 var m = typeof Symbol === "function" && o[Symbol.iterator]; 1059 if (!m) return o; 1060 var i = m.call(o), r, ar = [], e; 1061 try { 1062 while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); 1063 } 1064 catch (error) { e = { error: error }; } 1065 finally { 1066 try { 1067 if (r && !r.done && (m = i["return"])) m.call(i); 1068 } 1069 finally { if (e) throw e.error; } 1070 } 1071 return ar; 1072} 1073 1074/** @deprecated */ 1075function __spread() { 1076 for (var ar = [], i = 0; i < arguments.length; i++) 1077 ar = ar.concat(__read(arguments[i])); 1078 return ar; 1079} 1080 1081/** @deprecated */ 1082function __spreadArrays() { 1083 for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 1084 for (var r = Array(s), k = 0, i = 0; i < il; i++) 1085 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 1086 r[k] = a[j]; 1087 return r; 1088} 1089 1090function __spreadArray(to, from, pack) { 1091 if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { 1092 if (ar || !(i in from)) { 1093 if (!ar) ar = Array.prototype.slice.call(from, 0, i); 1094 ar[i] = from[i]; 1095 } 1096 } 1097 return to.concat(ar || Array.prototype.slice.call(from)); 1098} 1099 1100function __await(v) { 1101 return this instanceof __await ? (this.v = v, this) : new __await(v); 1102} 1103 1104function __asyncGenerator(thisArg, _arguments, generator) { 1105 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); 1106 var g = generator.apply(thisArg, _arguments || []), i, q = []; 1107 return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; 1108 function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } 1109 function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } 1110 function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } 1111 function fulfill(value) { resume("next", value); } 1112 function reject(value) { resume("throw", value); } 1113 function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } 1114} 1115 1116function __asyncDelegator(o) { 1117 var i, p; 1118 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; 1119 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; } 1120} 1121 1122function __asyncValues(o) { 1123 if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); 1124 var m = o[Symbol.asyncIterator], i; 1125 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); 1126 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); }); }; } 1127 function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } 1128} 1129 1130function __makeTemplateObject(cooked, raw) { 1131 if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } 1132 return cooked; 1133}; 1134 1135var __setModuleDefault = Object.create ? (function(o, v) { 1136 Object.defineProperty(o, "default", { enumerable: true, value: v }); 1137}) : function(o, v) { 1138 o["default"] = v; 1139}; 1140 1141function __importStar(mod) { 1142 if (mod && mod.__esModule) return mod; 1143 var result = {}; 1144 if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); 1145 __setModuleDefault(result, mod); 1146 return result; 1147} 1148 1149function __importDefault(mod) { 1150 return (mod && mod.__esModule) ? mod : { default: mod }; 1151} 1152 1153function __classPrivateFieldGet(receiver, state, kind, f) { 1154 if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); 1155 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"); 1156 return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); 1157} 1158 1159function __classPrivateFieldSet(receiver, state, value, kind, f) { 1160 if (kind === "m") throw new TypeError("Private method is not writable"); 1161 if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); 1162 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"); 1163 return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; 1164} 1165 1166function __classPrivateFieldIn(state, receiver) { 1167 if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object"); 1168 return typeof state === "function" ? receiver === state : state.has(receiver); 1169} 1170 1171function __addDisposableResource(env, value, async) { 1172 if (value !== null && value !== void 0) { 1173 if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); 1174 var dispose; 1175 if (async) { 1176 if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); 1177 dispose = value[Symbol.asyncDispose]; 1178 } 1179 if (dispose === void 0) { 1180 if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); 1181 dispose = value[Symbol.dispose]; 1182 } 1183 if (typeof dispose !== "function") throw new TypeError("Object not disposable."); 1184 env.stack.push({ value: value, dispose: dispose, async: async }); 1185 } 1186 else if (async) { 1187 env.stack.push({ async: true }); 1188 } 1189 return value; 1190} 1191 1192var _SuppressedError =
vendor: 1,130 bytes, lines 1192-1237
1192typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { 1193 var e = new Error(message); 1194 return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; 1195}; 1196 1197function __disposeResources(env) { 1198 function fail(e) { 1199 env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; 1200 env.hasError = true; 1201 } 1202 function next() { 1203 while (env.stack.length) { 1204 var rec = env.stack.pop(); 1205 try { 1206 var result = rec.dispose && rec.dispose.call(rec.value); 1207 if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); 1208 } 1209 catch (e) { 1210 fail(e); 1211 } 1212 } 1213 if (env.hasError) throw env.error; 1214 } 1215 return next(); 1216} 1217 1218/* harmony default export */ const tslib_es6 = ({ 1219 __extends, 1220 __assign, 1221 __rest, 1222 __decorate, 1223 __param, 1224 __metadata, 1225 __awaiter, 1226 __generator, 1227 __createBinding, 1228 __exportStar, 1229 __values, 1230 __read, 1231 __spread, 1232 __spreadArrays, 1233 __spreadArray, 1234 __await, 1235 __asyncGenerator, 1236 __asyncDelegator, 1237 __asyncValues,
1238 __makeTemplateObject, 1239 __importStar, 1240 __importDefault, 1241 __classPrivateFieldGet, 1242 __classPrivateFieldSet, 1243 __classPrivateFieldIn, 1244 __addDisposableResource, 1245 __disposeResources, 1246}); 1247 1248;// CONCATENATED MODULE: ./node_modules/lower-case/dist.es2015/index.js 1249/** 1250 * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt 1251 */ 1252var SUPPORTED_LOCALE = { 1253 tr: { 1254 regexp: /\u0130|\u0049|\u0049\u0307/g, 1255 map: { 1256 Ä°: "\u0069", 1257 I: "\u0131", 1258 IÌ: "\u0069", 1259 }, 1260 }, 1261 az: { 1262 regexp: /\u0130/g, 1263 map: { 1264 Ä°: "\u0069", 1265 I: "\u0131", 1266 IÌ: "\u0069", 1267 }, 1268 }, 1269 lt: { 1270 regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g, 1271 map: { 1272 I: "\u0069\u0307", 1273 J: "\u006A\u0307", 1274 Ä®: "\u012F\u0307", 1275 Ã: "\u0069\u0307\u0300", 1276 Ã: "\u0069\u0307\u0301", 1277 Ĩ: "\u0069\u0307\u0303", 1278 }, 1279 }, 1280}; 1281/** 1282 * Localized lower case. 1283 */ 1284function localeLowerCase(str, locale) {
1285 var lang = SUPPORTED_LOCALE[locale.toLowerCase()]; 1286 if (lang) 1287 return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; })); 1288 return lowerCase(str); 1289} 1290/** 1291 * Lower case as a function. 1292 */ 1293function lowerCase(str) { 1294 return str.toLowerCase(); 1295} 1296 1297;// CONCATENATED MODULE: ./node_modules/no-case/dist.es2015/index.js 1298 1299// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case"). 1300var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g]; 1301// Remove all non-word characters. 1302var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi; 1303/** 1304 * Normalize the string into something other libraries can manipulate easier. 1305 */ 1306function noCase(input, options) { 1307 if (options === void 0) { options = {}; } 1308 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; 1309 var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0"); 1310 var start = 0; 1311 var end = result.length; 1312 // Trim the delimiter from around the output string. 1313 while (result.charAt(start) === "\0") 1314 start++; 1315 while (result.charAt(end - 1) === "\0") 1316 end--; 1317 // Transform each token independently. 1318 return result.slice(start, end).split("\0").map(transform).join(delimiter); 1319} 1320/** 1321 * Replace `re` in the input string with the replacement value. 1322 */ 1323function replace(input, re, value) { 1324 if (re instanceof RegExp) 1325 return input.replace(re, value); 1326 return re.reduce(function (input, re) { return input.replace(re, value); }, input); 1327} 1328 1329;// CONCATENATED MODULE: ./node_modules/dot-case/dist.es2015/index.js 1330 1331 1332function dotCase(input, options) { 1333 if (options === void 0) { options = {}; } 1334 return noCase(input, __assign({ delimiter: "." }, options)); 1335} 1336 1337;// CONCATENATED MODULE: ./node_modules/param-case/dist.es2015/index.js 1338 1339 1340function paramCase(input, options) { 1341 if (options === void 0) { options = {}; } 1342 return dotCase(input, __assign({ delimiter: "-" }, options)); 1343} 1344 1345;// CONCATENATED MODULE: external ["wp","escapeHtml"] 1346const external_wp_escapeHtml_namespaceObject = window["wp"]["escapeHtml"]; 1347;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/raw-html.js 1348/** 1349 * Internal dependencies 1350 */ 1351 1352 1353/** @typedef {{children: string} & import('react').ComponentPropsWithoutRef<'div'>} RawHTMLProps */ 1354 1355/** 1356 * Component used as equivalent of Fragment with unescaped HTML, in cases where 1357 * it is desirable to render dangerous HTML without needing a wrapper element. 1358 * To preserve additional props, a `div` wrapper _will_ be created if any props 1359 * aside from `children` are passed. 1360 * 1361 * @param {RawHTMLProps} props Children should be a string of HTML or an array 1362 * of strings. Other props will be passed through 1363 * to the div wrapper. 1364 * 1365 * @return {JSX.Element} Dangerously-rendering component. 1366 */ 1367function RawHTML({ 1368 children, 1369 ...props 1370}) { 1371 let rawHtml = ''; 1372 1373 // Cast children as an array, and concatenate each element if it is a string. 1374 external_React_namespaceObject.Children.toArray(children).forEach(child => { 1375 if (typeof child === 'string' && child.trim() !== '') { 1376 rawHtml += child; 1377 } 1378 }); 1379 1380 // The `div` wrapper will be stripped by the `renderElement` serializer in 1381 // `./serialize.js` unless there are non-children props present. 1382 return (0,external_React_namespaceObject.createElement)('div', { 1383 dangerouslySetInnerHTML: { 1384 __html: rawHtml 1385 }, 1386 ...props 1387 }); 1388} 1389 1390;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/serialize.js 1391/** 1392 * Parts of this source were derived and modified from fast-react-render, 1393 * released under the MIT license. 1394 * 1395 * https://github.com/alt-j/fast-react-render 1396 * 1397 * Copyright (c) 2016 Andrey Morozov 1398 * 1399 * Permission is hereby granted, free of charge, to any person obtaining a copy 1400 * of this software and associated documentation files (the "Software"), to deal 1401 * in the Software without restriction, including without limitation the rights 1402 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 1403 * copies of the Software, and to permit persons to whom the Software is 1404 * furnished to do so, subject to the following conditions: 1405 * 1406 * The above copyright notice and this permission notice shall be included in 1407 * all copies or substantial portions of the Software. 1408 * 1409 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 1410 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 1411 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 1412 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 1413 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 1414 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 1415 * THE SOFTWARE. 1416 */ 1417 1418/** 1419 * External dependencies 1420 */ 1421 1422 1423 1424/** 1425 * WordPress dependencies 1426 */ 1427 1428 1429/** 1430 * Internal dependencies 1431 */ 1432 1433 1434 1435/** @typedef {import('react').ReactElement} ReactElement */ 1436 1437const { 1438 Provider, 1439 Consumer 1440} = (0,external_React_namespaceObject.createContext)(undefined); 1441const ForwardRef = (0,external_React_namespaceObject.forwardRef)(() => { 1442 return null; 1443}); 1444 1445/** 1446 * Valid attribute types. 1447 * 1448 * @type {Set<string>} 1449 */ 1450const ATTRIBUTES_TYPES = new Set(['string', 'boolean', 'number']); 1451 1452/** 1453 * Element tags which can be self-closing. 1454 * 1455 * @type {Set<string>} 1456 */ 1457const SELF_CLOSING_TAGS = new Set(['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr']); 1458 1459/** 1460 * Boolean attributes are attributes whose presence as being assigned is 1461 * meaningful, even if only empty. 1462 * 1463 * See: https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes 1464 * Extracted from: https://html.spec.whatwg.org/multipage/indices.html#attributes-3 1465 * 1466 * Object.keys( [ ...document.querySelectorAll( '#attributes-1 > tbody > tr' ) ] 1467 * .filter( ( tr ) => tr.lastChild.textContent.indexOf( 'Boolean attribute' ) !== -1 ) 1468 * .reduce( ( result, tr ) => Object.assign( result, { 1469 * [ tr.firstChild.textContent.trim() ]: true 1470 * } ), {} ) ).sort(); 1471 * 1472 * @type {Set<string>} 1473 */ 1474const BOOLEAN_ATTRIBUTES = new Set(['allowfullscreen', 'allowpaymentrequest', 'allowusermedia', 'async', 'autofocus', 'autoplay', 'checked', 'controls', 'default', 'defer', 'disabled', 'download', 'formnovalidate', 'hidden', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nomodule', 'novalidate', 'open', 'playsinline', 'readonly', 'required', 'reversed', 'selected', 'typemustmatch']); 1475 1476/** 1477 * Enumerated attributes are attributes which must be of a specific value form. 1478 * Like boolean attributes, these are meaningful if specified, even if not of a 1479 * valid enumerated value. 1480 * 1481 * See: https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#enumerated-attribute 1482 * Extracted from: https://html.spec.whatwg.org/multipage/indices.html#attributes-3 1483 * 1484 * Object.keys( [ ...document.querySelectorAll( '#attributes-1 > tbody > tr' ) ] 1485 * .filter( ( tr ) => /^("(.+?)";?\s*)+/.test( tr.lastChild.textContent.trim() ) ) 1486 * .reduce( ( result, tr ) => Object.assign( result, { 1487 * [ tr.firstChild.textContent.trim() ]: true 1488 * } ), {} ) ).sort(); 1489 * 1490 * Some notable omissions: 1491 * 1492 * - `alt`: https://blog.whatwg.org/omit-alt 1493 * 1494 * @type {Set<string>} 1495 */ 1496const ENUMERATED_ATTRIBUTES = new Set(['autocapitalize', 'autocomplete', 'charset', 'contenteditable', 'crossorigin', 'decoding', 'dir', 'draggable', 'enctype', 'formenctype', 'formmethod', 'http-equiv', 'inputmode', 'kind', 'method', 'preload', 'scope', 'shape', 'spellcheck', 'translate', 'type', 'wrap']); 1497 1498/** 1499 * Set of CSS style properties which support assignment of unitless numbers. 1500 * Used in rendering of style properties, where `px` unit is assumed unless 1501 * property is included in this set or value is zero. 1502 * 1503 * Generated via: 1504 * 1505 * Object.entries( document.createElement( 'div' ).style ) 1506 * .filter( ( [ key ] ) => ( 1507 * ! /^(webkit|ms|moz)/.test( key ) && 1508 * ( e.style[ key ] = 10 ) && 1509 * e.style[ key ] === '10' 1510 * ) ) 1511 * .map( ( [ key ] ) => key ) 1512 * .sort(); 1513 * 1514 * @type {Set<string>} 1515 */ 1516const CSS_PROPERTIES_SUPPORTS_UNITLESS = new Set(['animation', 'animationIterationCount', 'baselineShift', 'borderImageOutset', 'borderImageSlice', 'borderImageWidth', 'columnCount', 'cx', 'cy', 'fillOpacity', 'flexGrow', 'flexShrink', 'floodOpacity', 'fontWeight', 'gridColumnEnd', 'gridColumnStart', 'grid
1516RowEnd', 'gridRowStart', 'lineHeight', 'opacity', 'order', 'orphans', 'r', 'rx', 'ry', 'shapeImageThreshold', 'stopOpacity', 'strokeDasharray', 'strokeDashoffset', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'tabSize', 'widows', 'x', 'y', 'zIndex', 'zoom']); 1517 1518/** 1519 * Returns true if the specified string is prefixed by one of an array of 1520 * possible prefixes. 1521 * 1522 * @param {string} string String to check. 1523 * @param {string[]} prefixes Possible prefixes. 1524 * 1525 * @return {boolean} Whether string has prefix. 1526 */ 1527function hasPrefix(string, prefixes) { 1528 return prefixes.some(prefix => string.indexOf(prefix) === 0); 1529} 1530 1531/** 1532 * Returns true if the given prop name should be ignored in attributes 1533 * serialization, or false otherwise. 1534 * 1535 * @param {string} attribute Attribute to check. 1536 * 1537 * @return {boolean} Whether attribute should be ignored. 1538 */ 1539function isInternalAttribute(attribute) { 1540 return 'key' === attribute || 'children' === attribute; 1541} 1542 1543/** 1544 * Returns the normal form of the element's attribute value for HTML. 1545 * 1546 * @param {string} attribute Attribute name. 1547 * @param {*} value Non-normalized attribute value. 1548 * 1549 * @return {*} Normalized attribute value. 1550 */ 1551function getNormalAttributeValue(attribute, value) { 1552 switch (attribute) { 1553 case 'style': 1554 return renderStyle(value); 1555 } 1556 return value; 1557} 1558/** 1559 * This is a map of all SVG attributes that have dashes. Map(lower case prop => dashed lower case attribute). 1560 * We need this to render e.g strokeWidth as stroke-width. 1561 * 1562 * List from: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute. 1563 */ 1564const SVG_ATTRIBUTE_WITH_DASHES_LIST = ['accentHeight', 'alignmentBaseline', 'arabicForm', 'baselineShift', 'capHeight', 'clipPath', 'clipRule', 'colorInterpolation', 'colorInterpolationFilters', 'colorProfile', 'colorRendering', 'dominantBaseline', 'enableBackground', 'fillOpacity', 'fillRule', 'floodColor', 'floodOpacity', 'fontFamily', 'fontSize', 'fontSizeAdjust', 'fontStretch', 'fontStyle', 'fontVariant', 'fontWeight', 'glyphName', 'glyphOrientationHorizontal', 'glyphOrientationVertical', 'horizAdvX', 'horizOriginX', 'imageRendering', 'letterSpacing', 'lightingColor', 'markerEnd', 'markerMid', 'markerStart', 'overlinePosition', 'overlineThickness', 'paintOrder', 'panose1', 'pointerEvents', 'renderingIntent', 'shapeRendering', 'stopColor', 'stopOpacity', 'strikethroughPosition', 'strikethroughThickness', 'strokeDasharray', 'strokeDashoffset', 'strokeLinecap', 'strokeLinejoin', 'strokeMiterlimit', 'strokeOpacity', 'strokeWidth', 'textAnchor', 'textDecoration', 'textRendering', 'underlinePosition', 'underlineThickness', 'unicodeBidi', 'unicodeRange', 'unitsPerEm', 'vAlphabetic', 'vHanging', 'vIdeographic', 'vMathematical', 'vectorEffect', 'vertAdvY', 'vertOriginX', 'vertOriginY', 'wordSpacing', 'writingMode', 'xmlnsXlink', 'xHeight'].reduce((map, attribute) => { 1565 // The keys are lower-cased for more robust lookup. 1566 map[attribute.toLowerCase()] = attribute; 1567 return map; 1568}, {}); 1569 1570/** 1571 * This is a map of all case-sensitive SVG attributes. Map(lowercase key => proper case attribute). 1572 * The keys are lower-cased for more robust lookup. 1573 * Note that this list only contains attributes that contain at least one capital letter. 1574 * Lowercase attributes don't need mapping, since we lowercase all attributes by default. 1575 */ 1576const CASE_SENSITIVE_SVG_ATTRIBUTES = ['allowReorder', 'attributeName', 'attributeType', 'autoReverse', 'baseFrequency', 'baseProfile', 'calcMode', 'clipPathUnits', 'contentScriptType', 'contentStyleType', 'diffuseConstant', 'edgeMode', 'externalResourcesRequired', 'filterRes', 'filterUnits', 'glyphRef', 'gradientTransform', 'gradientUnits', 'kernelMatrix', 'kernelUnitLength', 'keyPoints', 'keySplines', 'keyTimes', 'lengthAdjust', 'limitingConeAngle', 'markerHeight', 'markerUnits', 'markerWidth', 'maskContentUnits', 'maskUnits', 'numOctaves', 'pathLength', 'patternContentUnits', 'patternTransform', 'patternUnits', 'pointsAtX', 'pointsAtY', 'pointsAtZ', 'preserveAlpha', 'preserveAspectRatio', 'primitiveUnits', 'refX', 'refY', 'repeatCount', 'repeatDur', 'requiredExtensions', 'requiredFeatures', 'specularConstant', 'specularExponent', 'spreadMethod', 'startOffset', 'stdDeviation', 'stitchTiles', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'surfaceScale', 'systemLanguage', 'tableValues', 'targetX', 'targetY', 'textLength', 'viewBox', 'viewTarget', 'xChannelSelector', 'yChannelSelector'].reduce((map, attribute) => { 1577 // The keys are lower-cased for more robust lookup. 1578 map[attribute.toLowerCase()] = attribute; 1579 return map; 1580}, {}); 1581 1582/** 1583 * This is a map of all SVG attributes that have colons. 1584 * Keys are lower-cased and stripped of their colons for more robust lookup. 1585 */ 1586const SVG_ATTRIBUTES_WITH_COLONS = ['xlink:actuate', 'xlink:arcrole', 'xlink:href', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type', 'xml:base', 'xml:lang', 'xml:space', 'xmlns:xlink'].reduce((map, attribute) => { 1587 map[attribute.replace(':', '').toLowerCase()] = attribute; 1588 return map; 1589}, {}); 1590 1591/** 1592 * Returns the normal form of the element's attribute name for HTML. 1593 * 1594 * @param {string} attribute Non-normalized attribute name. 1595 * 1596 * @return {string} Normalized attribute name. 1597 */ 1598function getNormalAttributeName(attribute) { 1599 switch (attribute) { 1600 case 'htmlFor': 1601 return 'for'; 1602 case 'className': 1603 return 'class'; 1604 } 1605 const attributeLowerCase = attribute.toLowerCase(); 1606 if (CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase]) { 1607 return CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase]; 1608 } else if (SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]) { 1609 return paramCase(SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]); 1610 } else if (SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase]) { 1611 return SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase]; 1612 } 1613 return attributeLowerCase; 1614} 1615 1616/** 1617 * Returns the normal form of the style property name for HTML. 1618 * 1619 * - Converts property names to kebab-case, e.g. 'backgroundColor' â 'background-color'
1620 * - Leaves custom attributes alone, e.g. '--myBackgroundColor' â '--myBackgroundColor' 1621 * - Converts vendor-prefixed property names to -kebab-case, e.g. 'MozTransform' â '-moz-transform' 1622 * 1623 * @param {string} property Property name. 1624 * 1625 * @return {string} Normalized property name. 1626 */ 1627function getNormalStylePropertyName(property) { 1628 if (property.startsWith('--')) { 1629 return property; 1630 } 1631 if (hasPrefix(property, ['ms', 'O', 'Moz', 'Webkit'])) { 1632 return '-' + paramCase(property); 1633 } 1634 return paramCase(property); 1635} 1636 1637/** 1638 * Returns the normal form of the style property value for HTML. Appends a 1639 * default pixel unit if numeric, not a unitless property, and not zero. 1640 * 1641 * @param {string} property Property name. 1642 * @param {*} value Non-normalized property value. 1643 * 1644 * @return {*} Normalized property value. 1645 */ 1646function getNormalStylePropertyValue(property, value) { 1647 if (typeof value === 'number' && 0 !== value && !CSS_PROPERTIES_SUPPORTS_UNITLESS.has(property)) { 1648 return value + 'px'; 1649 } 1650 return value; 1651} 1652 1653/** 1654 * Serializes a React element to string. 1655 * 1656 * @param {import('react').ReactNode} element Element to serialize. 1657 * @param {Object} [context] Context object. 1658 * @param {Object} [legacyContext] Legacy context object. 1659 * 1660 * @return {string} Serialized element. 1661 */ 1662function renderElement(element, context, legacyContext = {}) { 1663 if (null === element || undefined === element || false === element) { 1664 return ''; 1665 } 1666 if (Array.isArray(element)) { 1667 return renderChildren(element, context, legacyContext); 1668 } 1669 switch (typeof element) { 1670 case 'string': 1671 return (0,external_wp_escapeHtml_namespaceObject.escapeHTML)(element); 1672 case 'number': 1673 return element.toString(); 1674 } 1675 const { 1676 type, 1677 props 1678 } = /** @type {{type?: any, props?: any}} */ 1679 element; 1680 switch (type) { 1681 case external_React_namespaceObject.StrictMode: 1682 case external_React_namespaceObject.Fragment: 1683 return renderChildren(props.children, context, legacyContext); 1684 case RawHTML: 1685 const { 1686 children, 1687 ...wrapperProps 1688 } = props; 1689 return renderNativeComponent(!Object.keys(wrapperProps).length ? null : 'div', { 1690 ...wrapperProps, 1691 dangerouslySetInnerHTML: { 1692 __html: children 1693 } 1694 }, context, legacyContext); 1695 } 1696 switch (typeof type) { 1697 case 'string': 1698 return renderNativeComponent(type, props, context, legacyContext); 1699 case 'function': 1700 if (type.prototype && typeof type.prototype.render === 'function') { 1701 return renderComponent(type, props, context, legacyContext); 1702 } 1703 return renderElement(type(props, legacyContext), context, legacyContext); 1704 } 1705 switch (type && type.$$typeof) { 1706 case Provider.$$typeof: 1707 return renderChildren(props.children, props.value, legacyContext); 1708 case Consumer.$$typeof: 1709 return renderElement(props.children(context || type._currentValue), context, legacyContext); 1710 case ForwardRef.$$typeof: 1711 return renderElement(type.render(props), context, legacyContext); 1712 } 1713 return ''; 1714} 1715 1716/** 1717 * Serializes a native component type to string. 1718 * 1719 * @param {?string} type Native component type to serialize, or null if 1720 * rendering as fragment of children content. 1721 * @param {Object} props Props object. 1722 * @param {Object} [context] Context object. 1723 * @param {Object} [legacyContext] Legacy context object. 1724 * 1725 * @return {string} Serialized element. 1726 */ 1727function renderNativeComponent(type, props, context, legacyContext = {}) { 1728 let content = ''; 1729 if (type === 'textarea' && props.hasOwnProperty('value')) { 1730 // Textarea children can be assigned as value prop. If it is, render in 1731 // place of children. Ensure to omit so it is not assigned as attribute 1732 // as well. 1733 content = renderChildren(props.value, context, legacyContext); 1734 const { 1735 value, 1736 ...restProps 1737 } = props; 1738 props = restProps; 1739 } else if (props.dangerouslySetInnerHTML && typeof props.dangerouslySetInnerHTML.__html === 'string') { 1740 // Dangerous content is left unescaped. 1741 content = props.dangerouslySetInnerHTML.__html; 1742 } else if (typeof props.children !== 'undefined') { 1743 content = renderChildren(props.children, context, legacyContext); 1744 } 1745 if (!type) { 1746 return content; 1747 } 1748 const attributes = renderAttributes(props); 1749 if (SELF_CLOSING_TAGS.has(type)) { 1750 return '<' + type + attributes + '/>'; 1751 } 1752 return '<' + type + attributes + '>' + content + '</' + type + '>'; 1753} 1754 1755/** @typedef {import('react').ComponentType} ComponentType */ 1756 1757/** 1758 * Serializes a non-native component type to string. 1759 * 1760 * @param {ComponentType} Component Component type to serialize. 1761 * @param {Object} props Props object. 1762 * @param {Object} [context] Context object. 1763 * @param {Object} [legacyContext] Legacy context object. 1764 * 1765 * @return {string} Serialized element 1766 */ 1767function renderComponent(Component, props, context, legacyContext = {}) { 1768 const instance = new ( /** @type {import('react').ComponentClass} */ 1769 Component)(props, legacyContext); 1770 if (typeof 1771 // Ignore reason: Current prettier reformats parens and mangles type assertion 1772 // prettier-ignore 1773 /** @type {{getChildContext?: () => unknown}} */ 1774 instance.getChildContext === 'function') { 1775 Object.assign(legacyContext, /** @type {{getChildContext?: () => unknown}} */instance.getChildContext()); 1776 } 1777 const html = renderElement(instance.render(), context, legacyContext); 1778 return html; 1779} 1780 1781/** 1782 * Serializes an array of children to string. 1783 * 1784 * @param {import('react').ReactNodeArray} children Children to serialize. 1785 * @param {Object} [context] Context object. 1786 * @param {Object} [legacyContext] Legacy context object. 1787 * 1788 * @return {string} Serialized children. 1789 */ 1790function renderChildren(children, context, legacyContext = {}) { 1791 let result = ''; 1792 children = Array.isArray(children) ? children : [children]; 1793 for (let i = 0; i < children.length; i++) { 1794 const child = children[i];
1795 result += renderElement(child, context, legacyContext); 1796 } 1797 return result; 1798} 1799 1800/** 1801 * Renders a props object as a string of HTML attributes. 1802 * 1803 * @param {Object} props Props object. 1804 * 1805 * @return {string} Attributes string. 1806 */ 1807function renderAttributes(props) { 1808 let result = ''; 1809 for (const key in props) { 1810 const attribute = getNormalAttributeName(key); 1811 if (!(0,external_wp_escapeHtml_namespaceObject.isValidAttributeName)(attribute)) { 1812 continue; 1813 } 1814 let value = getNormalAttributeValue(key, props[key]); 1815 1816 // If value is not of serializable type, skip. 1817 if (!ATTRIBUTES_TYPES.has(typeof value)) { 1818 continue; 1819 } 1820 1821 // Don't render internal attribute names. 1822 if (isInternalAttribute(key)) { 1823 continue; 1824 } 1825 const isBooleanAttribute = BOOLEAN_ATTRIBUTES.has(attribute); 1826 1827 // Boolean attribute should be omitted outright if its value is false. 1828 if (isBooleanAttribute && value === false) { 1829 continue; 1830 } 1831 const isMeaningfulAttribute = isBooleanAttribute || hasPrefix(key, ['data-', 'aria-']) || ENUMERATED_ATTRIBUTES.has(attribute); 1832 1833 // Only write boolean value as attribute if meaningful. 1834 if (typeof value === 'boolean' && !isMeaningfulAttribute) { 1835 continue; 1836 } 1837 result += ' ' + attribute; 1838 1839 // Boolean attributes should write attribute name, but without value. 1840 // Mere presence of attribute name is effective truthiness. 1841 if (isBooleanAttribute) { 1842 continue; 1843 } 1844 if (typeof value === 'string') { 1845 value = (0,external_wp_escapeHtml_namespaceObject.escapeAttribute)(value); 1846 } 1847 result += '="' + value + '"'; 1848 } 1849 return result; 1850} 1851 1852/** 1853 * Renders a style object as a string attribute value. 1854 * 1855 * @param {Object} style Style object. 1856 * 1857 * @return {string} Style attribute value. 1858 */
1859function renderStyle(style) { 1860 // Only generate from object, e.g. tolerate string value. 1861 if (!isPlainObject(style)) { 1862 return style; 1863 } 1864 let result; 1865 for (const property in style) { 1866 const value = style[property]; 1867 if (null === value || undefined === value) { 1868 continue; 1869 } 1870 if (result) { 1871 result += ';'; 1872 } else { 1873 result = ''; 1874 } 1875 const normalName = getNormalStylePropertyName(property); 1876 const normalValue = getNormalStylePropertyValue(property, value); 1877 result += normalName + ':' + normalValue; 1878 } 1879 return result; 1880} 1881/* harmony default export */ const serialize = (renderElement); 1882 1883;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/index.js 1884 1885 1886 1887 1888 1889 1890 1891 1892})(); 1893 1894(window.wp = window.wp || {}).element = __webpack_exports__; 1895/******/ })() 1896;
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.