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