2022-04-11 14:04:30 +02:00
/******/ ( function ( ) { // webpackBootstrap
/******/ "use strict" ;
/******/ // The require scope
/******/ var _ _webpack _require _ _ = { } ;
/******/
/************************************************************************/
/******/ /* webpack/runtime/define property getters */
/******/ ! function ( ) {
/******/ // define getter functions for harmony exports
/******/ _ _webpack _require _ _ . d = function ( exports , definition ) {
/******/ for ( var key in definition ) {
/******/ if ( _ _webpack _require _ _ . o ( definition , key ) && ! _ _webpack _require _ _ . o ( exports , key ) ) {
/******/ Object . defineProperty ( exports , key , { enumerable : true , get : definition [ key ] } ) ;
/******/ }
/******/ }
/******/ } ;
/******/ } ( ) ;
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ ! function ( ) {
/******/ _ _webpack _require _ _ . o = function ( obj , prop ) { return Object . prototype . hasOwnProperty . call ( obj , prop ) ; }
/******/ } ( ) ;
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ ! function ( ) {
/******/ // define __esModule on exports
/******/ _ _webpack _require _ _ . r = function ( exports ) {
/******/ if ( typeof Symbol !== 'undefined' && Symbol . toStringTag ) {
/******/ Object . defineProperty ( exports , Symbol . toStringTag , { value : 'Module' } ) ;
/******/ }
/******/ Object . defineProperty ( exports , '__esModule' , { value : true } ) ;
2018-12-14 05:41:57 +01:00
/******/ } ;
2022-04-11 14:04:30 +02:00
/******/ } ( ) ;
/******/
2018-12-14 05:41:57 +01:00
/************************************************************************/
2022-04-11 14:04:30 +02:00
var _ _webpack _exports _ _ = { } ;
2020-06-29 13:50:29 +02:00
// ESM COMPAT FLAG
2018-12-14 05:41:57 +01:00
_ _webpack _require _ _ . r ( _ _webpack _exports _ _ ) ;
2020-06-29 13:50:29 +02:00
// EXPORTS
2022-04-11 14:04:30 +02:00
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , {
"Children" : function ( ) { return /* reexport */ external _React _namespaceObject . Children ; } ,
"Component" : function ( ) { return /* reexport */ external _React _namespaceObject . Component ; } ,
"Fragment" : function ( ) { return /* reexport */ external _React _namespaceObject . Fragment ; } ,
"Platform" : function ( ) { return /* reexport */ platform ; } ,
"RawHTML" : function ( ) { return /* reexport */ RawHTML ; } ,
"StrictMode" : function ( ) { return /* reexport */ external _React _namespaceObject . StrictMode ; } ,
"Suspense" : function ( ) { return /* reexport */ external _React _namespaceObject . Suspense ; } ,
"cloneElement" : function ( ) { return /* reexport */ external _React _namespaceObject . cloneElement ; } ,
"concatChildren" : function ( ) { return /* reexport */ concatChildren ; } ,
"createContext" : function ( ) { return /* reexport */ external _React _namespaceObject . createContext ; } ,
"createElement" : function ( ) { return /* reexport */ external _React _namespaceObject . createElement ; } ,
"createInterpolateElement" : function ( ) { return /* reexport */ create _interpolate _element ; } ,
"createPortal" : function ( ) { return /* reexport */ external _ReactDOM _namespaceObject . createPortal ; } ,
"createRef" : function ( ) { return /* reexport */ external _React _namespaceObject . createRef ; } ,
"findDOMNode" : function ( ) { return /* reexport */ external _ReactDOM _namespaceObject . findDOMNode ; } ,
"forwardRef" : function ( ) { return /* reexport */ external _React _namespaceObject . forwardRef ; } ,
"isEmptyElement" : function ( ) { return /* reexport */ isEmptyElement ; } ,
"isValidElement" : function ( ) { return /* reexport */ external _React _namespaceObject . isValidElement ; } ,
"lazy" : function ( ) { return /* reexport */ external _React _namespaceObject . lazy ; } ,
"memo" : function ( ) { return /* reexport */ external _React _namespaceObject . memo ; } ,
"render" : function ( ) { return /* reexport */ external _ReactDOM _namespaceObject . render ; } ,
"renderToString" : function ( ) { return /* reexport */ serialize ; } ,
"switchChildrenNodeName" : function ( ) { return /* reexport */ switchChildrenNodeName ; } ,
"unmountComponentAtNode" : function ( ) { return /* reexport */ external _ReactDOM _namespaceObject . unmountComponentAtNode ; } ,
"useCallback" : function ( ) { return /* reexport */ external _React _namespaceObject . useCallback ; } ,
"useContext" : function ( ) { return /* reexport */ external _React _namespaceObject . useContext ; } ,
"useDebugValue" : function ( ) { return /* reexport */ external _React _namespaceObject . useDebugValue ; } ,
"useEffect" : function ( ) { return /* reexport */ external _React _namespaceObject . useEffect ; } ,
"useImperativeHandle" : function ( ) { return /* reexport */ external _React _namespaceObject . useImperativeHandle ; } ,
"useLayoutEffect" : function ( ) { return /* reexport */ external _React _namespaceObject . useLayoutEffect ; } ,
"useMemo" : function ( ) { return /* reexport */ external _React _namespaceObject . useMemo ; } ,
"useReducer" : function ( ) { return /* reexport */ external _React _namespaceObject . useReducer ; } ,
"useRef" : function ( ) { return /* reexport */ external _React _namespaceObject . useRef ; } ,
"useState" : function ( ) { return /* reexport */ external _React _namespaceObject . useState ; }
} ) ;
; // CONCATENATED MODULE: external "React"
var external _React _namespaceObject = window [ "React" ] ;
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/create-interpolate-element.js
2020-01-08 12:57:23 +01:00
/ * *
2021-02-02 06:17:13 +01:00
* Internal dependencies
2020-01-08 12:57:23 +01:00
* /
2020-06-26 15:33:47 +02:00
/** @typedef {import('./react').WPElement} WPElement */
2021-05-19 17:09:27 +02:00
let indoc , offset , output , stack ;
2020-01-08 12:57:23 +01:00
/ * *
* Matches tags in the localized string
*
* This is used for extracting the tag pattern groups for parsing the localized
* string and along with the map converting it to a react element .
*
* There are four references extracted using this tokenizer :
*
* match : Full match of the tag ( i . e . < strong > , < /strong>, <br/ > )
* isClosing : The closing slash , it it exists .
* name : The name portion of the tag ( strong , br ) ( if )
* isSelfClosed : The slash on a self closing tag , if it exists .
*
* @ type { RegExp }
* /
2021-05-19 17:09:27 +02:00
const tokenizer = /<(\/)?(\w+)\s*(\/)?>/g ;
2020-06-26 15:33:47 +02:00
/ * *
* The stack frame tracking parse progress .
*
* @ typedef Frame
*
2021-11-08 15:29:21 +01:00
* @ property { WPElement } element A parent element which may still have
* @ property { number } tokenStart Offset at which parent element first
* appears .
* @ property { number } tokenLength Length of string marking start of parent
* element .
* @ property { number } [ prevOffset ] Running offset at which parsing should
* continue .
* @ property { number } [ leadingTextStart ] Offset at which last closing element
* finished , used for finding text between
* elements .
* @ property { WPElement [ ] } children Children .
2020-06-26 15:33:47 +02:00
* /
2020-01-08 12:57:23 +01:00
/ * *
* Tracks recursive - descent parse state .
*
* This is a Stack frame holding parent elements until all children have been
* parsed .
*
* @ private
2020-06-26 15:33:47 +02:00
* @ param { WPElement } element A parent element which may still have
* nested children not yet parsed .
* @ param { number } tokenStart Offset at which parent element first
* appears .
* @ param { number } tokenLength Length of string marking start of parent
* element .
* @ param { number } [ prevOffset ] Running offset at which parsing should
* continue .
* @ param { number } [ leadingTextStart ] Offset at which last closing element
* finished , used for finding text between
* elements .
2020-01-08 12:57:23 +01:00
*
* @ return { Frame } The stack frame tracking parse progress .
* /
2020-06-26 15:33:47 +02:00
function createFrame ( element , tokenStart , tokenLength , prevOffset , leadingTextStart ) {
2020-01-08 12:57:23 +01:00
return {
2021-05-19 17:09:27 +02:00
element ,
tokenStart ,
tokenLength ,
prevOffset ,
leadingTextStart ,
2020-01-08 12:57:23 +01:00
children : [ ]
} ;
}
/ * *
* This function creates an interpolated element from a passed in string with
* specific tags matching how the string should be converted to an element via
* the conversion map value .
*
* @ example
* For example , for the given string :
*
* " This is a < span > string < / s p a n > w i t h < a > a l i n k < / a > a n d a s e l f - c l o s i n g
* < CustomComponentB / > tag "
*
* You would have something like this as the conversionMap value :
*
* ` ` ` js
* {
* span : < span / > ,
* a : < a href = { 'https://github.com' } / > ,
* CustomComponentB : < CustomComponent / > ,
* }
* ` ` `
*
2021-11-08 15:29:21 +01:00
* @ param { string } interpolatedString The interpolation string to be parsed .
* @ param { Object } conversionMap The map used to convert the string to
* a react element .
2020-01-08 12:57:23 +01:00
* @ throws { TypeError }
* @ return { WPElement } A wp element .
* /
2021-05-19 17:09:27 +02:00
const createInterpolateElement = ( interpolatedString , conversionMap ) => {
2020-01-08 12:57:23 +01:00
indoc = interpolatedString ;
offset = 0 ;
output = [ ] ;
stack = [ ] ;
tokenizer . lastIndex = 0 ;
2021-05-19 17:09:27 +02:00
if ( ! isValidConversionMap ( conversionMap ) ) {
2020-01-08 12:57:23 +01:00
throw new TypeError ( 'The conversionMap provided is not valid. It must be an object with values that are WPElements' ) ;
}
do { // twiddle our thumbs
} while ( proceed ( conversionMap ) ) ;
2022-04-11 14:04:30 +02:00
return ( 0 , external _React _namespaceObject . createElement ) ( external _React _namespaceObject . Fragment , null , ... output ) ;
2020-01-08 12:57:23 +01:00
} ;
/ * *
* Validate conversion map .
*
* A map is considered valid if it ' s an object and every value in the object
* is a WPElement
*
* @ private
*
2021-11-08 15:29:21 +01:00
* @ param { Object } conversionMap The map being validated .
2020-01-08 12:57:23 +01:00
*
* @ return { boolean } True means the map is valid .
* /
2021-05-19 17:09:27 +02:00
const isValidConversionMap = conversionMap => {
const isObject = typeof conversionMap === 'object' ;
const values = isObject && Object . values ( conversionMap ) ;
2022-04-11 14:04:30 +02:00
return isObject && values . length && values . every ( element => ( 0 , external _React _namespaceObject . isValidElement ) ( element ) ) ;
2020-01-08 12:57:23 +01:00
} ;
/ * *
* This is the iterator over the matches in the string .
*
* @ private
*
* @ param { Object } conversionMap The conversion map for the string .
*
* @ return { boolean } true for continuing to iterate , false for finished .
* /
function proceed ( conversionMap ) {
2021-05-19 17:09:27 +02:00
const next = nextToken ( ) ;
const [ tokenType , name , startOffset , tokenLength ] = next ;
const stackDepth = stack . length ;
const leadingTextStart = startOffset > offset ? offset : null ;
2020-01-08 12:57:23 +01:00
if ( ! conversionMap [ name ] ) {
addText ( ) ;
return false ;
}
switch ( tokenType ) {
case 'no-more-tokens' :
if ( stackDepth !== 0 ) {
2021-05-19 17:09:27 +02:00
const {
leadingTextStart : stackLeadingText ,
tokenStart
} = stack . pop ( ) ;
2020-01-08 12:57:23 +01:00
output . push ( indoc . substr ( stackLeadingText , tokenStart ) ) ;
}
addText ( ) ;
return false ;
case 'self-closed' :
if ( 0 === stackDepth ) {
if ( null !== leadingTextStart ) {
output . push ( indoc . substr ( leadingTextStart , startOffset - leadingTextStart ) ) ;
}
output . push ( conversionMap [ name ] ) ;
offset = startOffset + tokenLength ;
return true ;
2022-04-12 17:12:47 +02:00
} // Otherwise we found an inner element.
2020-01-08 12:57:23 +01:00
2020-06-26 15:33:47 +02:00
addChild ( createFrame ( conversionMap [ name ] , startOffset , tokenLength ) ) ;
2020-01-08 12:57:23 +01:00
offset = startOffset + tokenLength ;
return true ;
case 'opener' :
2020-06-26 15:33:47 +02:00
stack . push ( createFrame ( conversionMap [ name ] , startOffset , tokenLength , startOffset + tokenLength , leadingTextStart ) ) ;
2020-01-08 12:57:23 +01:00
offset = startOffset + tokenLength ;
return true ;
case 'closer' :
2022-04-12 17:12:47 +02:00
// If we're not nesting then this is easy - close the block.
2020-01-08 12:57:23 +01:00
if ( 1 === stackDepth ) {
closeOuterElement ( startOffset ) ;
offset = startOffset + tokenLength ;
return true ;
2022-04-12 17:12:47 +02:00
} // Otherwise we're nested and we have to close out the current
// block and add it as a innerBlock to the parent.
2020-01-08 12:57:23 +01:00
2021-05-19 17:09:27 +02:00
const stackTop = stack . pop ( ) ;
const text = indoc . substr ( stackTop . prevOffset , startOffset - stackTop . prevOffset ) ;
2020-01-08 12:57:23 +01:00
stackTop . children . push ( text ) ;
stackTop . prevOffset = startOffset + tokenLength ;
2021-05-19 17:09:27 +02:00
const frame = createFrame ( stackTop . element , stackTop . tokenStart , stackTop . tokenLength , startOffset + tokenLength ) ;
2020-01-08 12:57:23 +01:00
frame . children = stackTop . children ;
addChild ( frame ) ;
offset = startOffset + tokenLength ;
return true ;
default :
addText ( ) ;
return false ;
}
}
/ * *
* Grabs the next token match in the string and returns it ' s details .
*
* @ private
*
* @ return { Array } An array of details for the token matched .
* /
function nextToken ( ) {
2022-04-12 17:12:47 +02:00
const matches = tokenizer . exec ( indoc ) ; // We have no more tokens.
2020-01-08 12:57:23 +01:00
if ( null === matches ) {
return [ 'no-more-tokens' ] ;
}
2021-05-19 17:09:27 +02:00
const startedAt = matches . index ;
const [ match , isClosing , name , isSelfClosed ] = matches ;
const length = match . length ;
2020-01-08 12:57:23 +01:00
if ( isSelfClosed ) {
return [ 'self-closed' , name , startedAt , length ] ;
}
if ( isClosing ) {
return [ 'closer' , name , startedAt , length ] ;
}
return [ 'opener' , name , startedAt , length ] ;
}
/ * *
* Pushes text extracted from the indoc string to the output stack given the
* current rawLength value and offset ( if rawLength is provided ) or the
* indoc . length and offset .
*
* @ private
* /
function addText ( ) {
2021-05-19 17:09:27 +02:00
const length = indoc . length - offset ;
2020-01-08 12:57:23 +01:00
if ( 0 === length ) {
return ;
}
output . push ( indoc . substr ( offset , length ) ) ;
}
/ * *
* Pushes a child element to the associated parent element ' s children for the
* parent currently active in the stack .
*
* @ private
*
2021-11-08 15:29:21 +01:00
* @ param { Frame } frame The Frame containing the child element and it ' s
* token information .
2020-01-08 12:57:23 +01:00
* /
function addChild ( frame ) {
2021-05-19 17:09:27 +02:00
const {
element ,
tokenStart ,
tokenLength ,
prevOffset ,
children
} = frame ;
const parent = stack [ stack . length - 1 ] ;
const text = indoc . substr ( parent . prevOffset , tokenStart - parent . prevOffset ) ;
2020-01-08 12:57:23 +01:00
if ( text ) {
parent . children . push ( text ) ;
}
2022-04-11 14:04:30 +02:00
parent . children . push ( ( 0 , external _React _namespaceObject . cloneElement ) ( element , null , ... children ) ) ;
2020-01-08 12:57:23 +01:00
parent . prevOffset = prevOffset ? prevOffset : tokenStart + tokenLength ;
}
/ * *
* This is called for closing tags . It creates the element currently active in
* the stack .
*
* @ private
*
* @ param { number } endOffset Offset at which the closing tag for the element
* begins in the string . If this is greater than the
* prevOffset attached to the element , then this
* helps capture any remaining nested text nodes in
* the element .
* /
function closeOuterElement ( endOffset ) {
2021-05-19 17:09:27 +02:00
const {
element ,
leadingTextStart ,
prevOffset ,
tokenStart ,
children
} = stack . pop ( ) ;
const text = endOffset ? indoc . substr ( prevOffset , endOffset - prevOffset ) : indoc . substr ( prevOffset ) ;
2020-01-08 12:57:23 +01:00
if ( text ) {
children . push ( text ) ;
}
if ( null !== leadingTextStart ) {
output . push ( indoc . substr ( leadingTextStart , tokenStart - leadingTextStart ) ) ;
}
2022-04-11 14:04:30 +02:00
output . push ( ( 0 , external _React _namespaceObject . cloneElement ) ( element , null , ... children ) ) ;
2020-01-08 12:57:23 +01:00
}
2021-05-19 17:09:27 +02:00
/* harmony default export */ var create _interpolate _element = ( createInterpolateElement ) ;
2018-12-14 05:41:57 +01:00
2022-04-11 14:04:30 +02:00
; // CONCATENATED MODULE: external "lodash"
var external _lodash _namespaceObject = window [ "lodash" ] ;
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/react.js
2018-12-14 05:41:57 +01:00
/ * *
* External dependencies
* /
2022-04-12 17:12:47 +02:00
// eslint-disable-next-line @typescript-eslint/no-restricted-imports
2018-12-14 05:41:57 +01:00
2020-01-08 12:57:23 +01:00
/ * *
* Object containing a React element .
*
* @ typedef { import ( 'react' ) . ReactElement } WPElement
* /
/ * *
* Object containing a React component .
*
2020-06-26 15:33:47 +02:00
* @ typedef { import ( 'react' ) . ComponentType } WPComponent
2020-01-08 12:57:23 +01:00
* /
/ * *
* Object containing a React synthetic event .
*
* @ typedef { import ( 'react' ) . SyntheticEvent } WPSyntheticEvent
* /
2019-03-21 13:48:00 +01:00
/ * *
* Object that provides utilities for dealing with React children .
* /
2018-12-14 05:41:57 +01:00
/ * *
* Creates a copy of an element with extended props .
*
* @ param { WPElement } element Element
* @ param { ? Object } props Props to apply to cloned element
*
* @ return { WPElement } Cloned element .
* /
/ * *
* A base class to create WordPress Components ( Refs , state and lifecycle hooks )
* /
/ * *
* Creates a context object containing two components : a provider and consumer .
*
* @ param { Object } defaultValue A default data stored in the context .
*
* @ return { Object } Context object .
* /
/ * *
* Returns a new element of given type . Type can be either a string tag name or
* another function which itself returns an element .
*
* @ param { ? ( string | Function ) } type Tag name or element creator
* @ param { Object } props Element properties , either attribute
2020-01-08 12:57:23 +01:00
* set to apply to DOM node or values to
* pass through to element creator
2018-12-14 05:41:57 +01:00
* @ param { ... WPElement } children Descendant elements
*
* @ return { WPElement } Element .
* /
/ * *
* Returns an object tracking a reference to a rendered element via its
* ` current ` property as either a DOMElement or Element , dependent upon the
* type of element rendered with the ref attribute .
*
* @ return { Object } Ref object .
* /
/ * *
* Component enhancer used to enable passing a ref to its wrapped component .
* Pass a function argument which receives ` props ` and ` ref ` as its arguments ,
* returning an element using the forwarded ref . The return value is a new
* component which forwards its ref .
*
* @ param { Function } forwarder Function passed ` props ` and ` ref ` , expected to
* return an element .
*
* @ return { WPComponent } Enhanced component .
* /
/ * *
* A component which renders its children without any wrapping element .
* /
/ * *
2020-01-08 12:57:23 +01:00
* Checks if an object is a valid WPElement .
2018-12-14 05:41:57 +01:00
*
* @ param { Object } objectToCheck The object to be checked .
*
* @ return { boolean } true if objectToTest is a valid WPElement and false otherwise .
* /
2019-09-19 17:19:18 +02:00
/ * *
* @ see https : //reactjs.org/docs/react-api.html#reactmemo
* /
2019-03-21 13:48:00 +01:00
/ * *
* Component that activates additional checks and warnings for its descendants .
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#usecallback
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#usecontext
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#usedebugvalue
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#useeffect
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#useimperativehandle
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#uselayouteffect
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#usememo
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#usereducer
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#useref
* /
/ * *
* @ see https : //reactjs.org/docs/hooks-reference.html#usestate
* /
2018-12-14 05:41:57 +01:00
2019-09-19 17:19:18 +02:00
/ * *
* @ see https : //reactjs.org/docs/react-api.html#reactlazy
* /
/ * *
* @ see https : //reactjs.org/docs/react-api.html#reactsuspense
* /
2018-12-14 05:41:57 +01:00
/ * *
* Concatenate two or more React children objects .
*
* @ param { ... ? Object } childrenArguments Array of children arguments ( array of arrays / strings / objects ) to concatenate .
*
* @ return { Array } The concatenated value .
* /
2021-11-15 13:50:17 +01:00
function concatChildren ( ) {
for ( var _len = arguments . length , childrenArguments = new Array ( _len ) , _key = 0 ; _key < _len ; _key ++ ) {
childrenArguments [ _key ] = arguments [ _key ] ;
}
2021-05-19 17:09:27 +02:00
return childrenArguments . reduce ( ( accumulator , children , i ) => {
2022-04-11 14:04:30 +02:00
external _React _namespaceObject . Children . forEach ( children , ( child , j ) => {
2018-12-14 05:41:57 +01:00
if ( child && 'string' !== typeof child ) {
2022-04-11 14:04:30 +02:00
child = ( 0 , external _React _namespaceObject . cloneElement ) ( child , {
2018-12-14 05:41:57 +01:00
key : [ i , j ] . join ( )
} ) ;
}
2020-01-08 12:57:23 +01:00
accumulator . push ( child ) ;
2018-12-14 05:41:57 +01:00
} ) ;
2020-01-08 12:57:23 +01:00
return accumulator ;
2018-12-14 05:41:57 +01:00
} , [ ] ) ;
}
/ * *
* Switches the nodeName of all the elements in the children object .
*
* @ param { ? Object } children Children object .
* @ param { string } nodeName Node name .
*
* @ return { ? Object } The updated children object .
* /
function switchChildrenNodeName ( children , nodeName ) {
2022-04-11 14:04:30 +02:00
return children && external _React _namespaceObject . Children . map ( children , ( elt , index ) => {
if ( ( 0 , external _lodash _namespaceObject . isString ) ( elt ) ) {
return ( 0 , external _React _namespaceObject . createElement ) ( nodeName , {
2018-12-14 05:41:57 +01:00
key : index
} , elt ) ;
}
2021-05-19 17:09:27 +02:00
const {
children : childrenProp ,
... props
} = elt . props ;
2022-04-11 14:04:30 +02:00
return ( 0 , external _React _namespaceObject . createElement ) ( nodeName , {
2021-05-19 17:09:27 +02:00
key : index ,
... props
} , childrenProp ) ;
2018-12-14 05:41:57 +01:00
} ) ;
}
2022-04-11 14:04:30 +02:00
; // CONCATENATED MODULE: external "ReactDOM"
var external _ReactDOM _namespaceObject = window [ "ReactDOM" ] ;
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/react-platform.js
2018-12-18 04:14:52 +01:00
/ * *
* External dependencies
* /
2018-12-14 05:41:57 +01:00
2018-12-18 04:14:52 +01:00
/ * *
* Creates a portal into which a component can be rendered .
*
* @ see https : //github.com/facebook/react/issues/10309#issuecomment-318433235
*
2021-11-08 15:29:21 +01:00
* @ param { import ( './react' ) . WPElement } child Any renderable child , such as an element ,
* string , or fragment .
* @ param { HTMLElement } container DOM node into which element should be rendered .
2018-12-18 04:14:52 +01:00
* /
2018-12-14 05:41:57 +01:00
2018-12-18 04:14:52 +01:00
/ * *
2020-01-08 12:57:23 +01:00
* Finds the dom node of a React component .
2018-12-18 04:14:52 +01:00
*
2020-06-26 15:33:47 +02:00
* @ param { import ( './react' ) . WPComponent } component Component ' s instance .
2018-12-18 04:14:52 +01:00
* /
/ * *
* Renders a given element into the target DOM node .
*
2021-11-08 15:29:21 +01:00
* @ param { import ( './react' ) . WPElement } element Element to render .
* @ param { HTMLElement } target DOM node into which element should be rendered .
2018-12-18 04:14:52 +01:00
* /
/ * *
* Removes any mounted element from the target DOM node .
*
* @ param { Element } target DOM node in which element is to be removed
* /
2022-04-11 14:04:30 +02:00
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/utils.js
2018-12-18 04:14:52 +01:00
/ * *
* External dependencies
* /
/ * *
* Checks if the provided WP element is empty .
*
* @ param { * } element WP element to check .
* @ return { boolean } True when an element is considered empty .
* /
2021-05-19 17:09:27 +02:00
const isEmptyElement = element => {
2022-04-11 14:04:30 +02:00
if ( ( 0 , external _lodash _namespaceObject . isNumber ) ( element ) ) {
2018-12-18 04:14:52 +01:00
return false ;
}
2022-04-11 14:04:30 +02:00
if ( ( 0 , external _lodash _namespaceObject . isString ) ( element ) || ( 0 , external _lodash _namespaceObject . isArray ) ( element ) ) {
2018-12-18 04:14:52 +01:00
return ! element . length ;
}
return ! element ;
} ;
2022-04-11 14:04:30 +02:00
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/platform.js
2020-01-08 12:57:23 +01:00
/ * *
* Parts of this source were derived and modified from react - native - web ,
* released under the MIT license .
*
* Copyright ( c ) 2016 - present , Nicolas Gallagher .
* Copyright ( c ) 2015 - present , Facebook , Inc .
*
* /
2021-05-19 17:09:27 +02:00
const Platform = {
2020-01-08 12:57:23 +01:00
OS : 'web' ,
2021-11-08 15:29:21 +01:00
select : spec => 'web' in spec ? spec . web : spec . default ,
isWeb : true
2020-01-08 12:57:23 +01:00
} ;
/ * *
* Component used to detect the current Platform being used .
* Use Platform . OS === 'web' to detect if running on web enviroment .
*
* This is the same concept as the React Native implementation .
*
* @ see https : //facebook.github.io/react-native/docs/platform-specific-code#platform-module
*
* Here is an example of how to use the select method :
* @ example
* ` ` ` js
* import { Platform } from '@wordpress/element' ;
*
* const placeholderLabel = Platform . select ( {
* native : _ _ ( 'Add media' ) ,
* web : _ _ ( 'Drag images, upload new ones or select files from your library.' ) ,
* } ) ;
* ` ` `
* /
/* harmony default export */ var platform = ( Platform ) ;
2018-12-18 04:14:52 +01:00
2022-04-11 14:04:30 +02:00
; // CONCATENATED MODULE: external ["wp","escapeHtml"]
var external _wp _escapeHtml _namespaceObject = window [ "wp" ] [ "escapeHtml" ] ;
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/raw-html.js
2018-12-18 04:14:52 +01:00
/ * *
2019-03-07 10:09:59 +01:00
* Internal dependencies
2018-12-18 04:14:52 +01:00
* /
2020-06-26 15:33:47 +02:00
// Disable reason: JSDoc linter doesn't seem to parse the union (`&`) correctly.
/** @typedef {{children: string} & import('react').ComponentPropsWithoutRef<'div'>} RawHTMLProps */
2018-12-18 04:14:52 +01:00
/ * *
* Component used as equivalent of Fragment with unescaped HTML , in cases where
* it is desirable to render dangerous HTML without needing a wrapper element .
* To preserve additional props , a ` div ` wrapper _will _ be created if any props
* aside from ` children ` are passed .
*
2021-11-08 15:29:21 +01:00
* @ param { RawHTMLProps } props Children should be a string of HTML or an array
* of strings . Other props will be passed through
* to the div wrapper .
2018-12-18 04:14:52 +01:00
*
2020-06-26 15:33:47 +02:00
* @ return { JSX . Element } Dangerously - rendering component .
2018-12-18 04:14:52 +01:00
* /
2021-11-15 13:50:17 +01:00
function RawHTML ( _ref ) {
let {
children ,
... props
} = _ref ;
2021-11-08 15:29:21 +01:00
let rawHtml = '' ; // Cast children as an array, and concatenate each element if it is a string.
2022-04-11 14:04:30 +02:00
external _React _namespaceObject . Children . toArray ( children ) . forEach ( child => {
2021-11-08 15:29:21 +01:00
if ( typeof child === 'string' && child . trim ( ) !== '' ) {
rawHtml += child ;
}
} ) ; // The `div` wrapper will be stripped by the `renderElement` serializer in
// `./serialize.js` unless there are non-children props present.
2022-04-11 14:04:30 +02:00
return ( 0 , external _React _namespaceObject . createElement ) ( 'div' , {
2018-12-18 04:14:52 +01:00
dangerouslySetInnerHTML : {
2021-11-08 15:29:21 +01:00
_ _html : rawHtml
2021-05-19 17:09:27 +02:00
} ,
... props
} ) ;
2018-12-18 04:14:52 +01:00
}
2022-04-11 14:04:30 +02:00
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/serialize.js
2018-12-14 05:41:57 +01:00
/ * *
* Parts of this source were derived and modified from fast - react - render ,
* released under the MIT license .
*
* https : //github.com/alt-j/fast-react-render
*
* Copyright ( c ) 2016 Andrey Morozov
*
* Permission is hereby granted , free of charge , to any person obtaining a copy
* of this software and associated documentation files ( the "Software" ) , to deal
* in the Software without restriction , including without limitation the rights
* to use , copy , modify , merge , publish , distribute , sublicense , and / or sell
* copies of the Software , and to permit persons to whom the Software is
* furnished to do so , subject to the following conditions :
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software .
*
* THE SOFTWARE IS PROVIDED "AS IS" , WITHOUT WARRANTY OF ANY KIND , EXPRESS OR
* IMPLIED , INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY ,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT . IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM , DAMAGES OR OTHER
* LIABILITY , WHETHER IN AN ACTION OF CONTRACT , TORT OR OTHERWISE , ARISING FROM ,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE .
* /
/ * *
* External dependencies
* /
/ * *
* WordPress dependencies
* /
/ * *
* Internal dependencies
* /
2020-06-26 15:33:47 +02:00
/** @typedef {import('./react').WPElement} WPElement */
2018-12-14 05:41:57 +01:00
2021-05-19 17:09:27 +02:00
const {
Provider ,
Consumer
2022-04-11 14:04:30 +02:00
} = ( 0 , external _React _namespaceObject . createContext ) ( undefined ) ;
const ForwardRef = ( 0 , external _React _namespaceObject . forwardRef ) ( ( ) => {
2019-09-19 17:19:18 +02:00
return null ;
} ) ;
2018-12-14 05:41:57 +01:00
/ * *
* Valid attribute types .
*
2020-06-26 15:33:47 +02:00
* @ type { Set < string > }
2018-12-14 05:41:57 +01:00
* /
2021-05-19 17:09:27 +02:00
const ATTRIBUTES _TYPES = new Set ( [ 'string' , 'boolean' , 'number' ] ) ;
2018-12-14 05:41:57 +01:00
/ * *
* Element tags which can be self - closing .
*
2020-06-26 15:33:47 +02:00
* @ type { Set < string > }
2018-12-14 05:41:57 +01:00
* /
2021-05-19 17:09:27 +02:00
const SELF _CLOSING _TAGS = new Set ( [ 'area' , 'base' , 'br' , 'col' , 'command' , 'embed' , 'hr' , 'img' , 'input' , 'keygen' , 'link' , 'meta' , 'param' , 'source' , 'track' , 'wbr' ] ) ;
2018-12-14 05:41:57 +01:00
/ * *
* Boolean attributes are attributes whose presence as being assigned is
* meaningful , even if only empty .
*
* See : https : //html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
* Extracted from : https : //html.spec.whatwg.org/multipage/indices.html#attributes-3
*
* Object . keys ( [ ... document . querySelectorAll ( '#attributes-1 > tbody > tr' ) ]
* . filter ( ( tr ) => tr . lastChild . textContent . indexOf ( 'Boolean attribute' ) !== - 1 )
* . reduce ( ( result , tr ) => Object . assign ( result , {
* [ tr . firstChild . textContent . trim ( ) ] : true
* } ) , { } ) ) . sort ( ) ;
*
2020-06-26 15:33:47 +02:00
* @ type { Set < string > }
2018-12-14 05:41:57 +01:00
* /
2021-05-19 17:09:27 +02:00
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' ] ) ;
2018-12-14 05:41:57 +01:00
/ * *
* Enumerated attributes are attributes which must be of a specific value form .
* Like boolean attributes , these are meaningful if specified , even if not of a
* valid enumerated value .
*
* See : https : //html.spec.whatwg.org/multipage/common-microsyntaxes.html#enumerated-attribute
* Extracted from : https : //html.spec.whatwg.org/multipage/indices.html#attributes-3
*
* Object . keys ( [ ... document . querySelectorAll ( '#attributes-1 > tbody > tr' ) ]
* . filter ( ( tr ) => / ^ ( "(.+?)" ; ? \ s * ) + / . t e s t ( t r . l a s t C h i l d . t e x t C o n t e n t . t r i m ( ) ) )
* . reduce ( ( result , tr ) => Object . assign ( result , {
* [ tr . firstChild . textContent . trim ( ) ] : true
* } ) , { } ) ) . sort ( ) ;
*
* Some notable omissions :
*
* - ` alt ` : https : //blog.whatwg.org/omit-alt
*
2020-06-26 15:33:47 +02:00
* @ type { Set < string > }
2018-12-14 05:41:57 +01:00
* /
2021-05-19 17:09:27 +02:00
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' ] ) ;
2018-12-14 05:41:57 +01:00
/ * *
* Set of CSS style properties which support assignment of unitless numbers .
* Used in rendering of style properties , where ` px ` unit is assumed unless
* property is included in this set or value is zero .
*
* Generated via :
*
* Object . entries ( document . createElement ( 'div' ) . style )
* . filter ( ( [ key ] ) => (
* ! /^(webkit|ms|moz)/ . test ( key ) &&
* ( e . style [ key ] = 10 ) &&
* e . style [ key ] === '10'
* ) )
* . map ( ( [ key ] ) => key )
* . sort ( ) ;
*
2020-06-26 15:33:47 +02:00
* @ type { Set < string > }
2018-12-14 05:41:57 +01:00
* /
2021-05-19 17:09:27 +02:00
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' ] ) ;
2018-12-14 05:41:57 +01:00
/ * *
* Returns true if the specified string is prefixed by one of an array of
* possible prefixes .
*
* @ param { string } string String to check .
* @ param { string [ ] } prefixes Possible prefixes .
*
* @ return { boolean } Whether string has prefix .
* /
function hasPrefix ( string , prefixes ) {
2021-05-19 17:09:27 +02:00
return prefixes . some ( prefix => string . indexOf ( prefix ) === 0 ) ;
2018-12-14 05:41:57 +01:00
}
/ * *
* Returns true if the given prop name should be ignored in attributes
* serialization , or false otherwise .
*
* @ param { string } attribute Attribute to check .
*
* @ return { boolean } Whether attribute should be ignored .
* /
function isInternalAttribute ( attribute ) {
return 'key' === attribute || 'children' === attribute ;
}
/ * *
* Returns the normal form of the element ' s attribute value for HTML .
*
* @ param { string } attribute Attribute name .
* @ param { * } value Non - normalized attribute value .
*
2020-06-26 15:33:47 +02:00
* @ return { * } Normalized attribute value .
2018-12-14 05:41:57 +01:00
* /
function getNormalAttributeValue ( attribute , value ) {
switch ( attribute ) {
case 'style' :
return renderStyle ( value ) ;
}
return value ;
}
2022-04-12 17:12:47 +02:00
/ * *
* This is a map of all SVG attributes that have dashes . Map ( lower case prop => dashed lower case attribute ) .
* We need this to render e . g strokeWidth as stroke - width .
*
* List from : https : //developer.mozilla.org/en-US/docs/Web/SVG/Attribute.
* /
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 ) => {
// The keys are lower-cased for more robust lookup.
map [ attribute . toLowerCase ( ) ] = attribute ;
return map ;
} , { } ) ;
/ * *
* This is a map of all case - sensitive SVG attributes . Map ( lowercase key => proper case attribute ) .
* The keys are lower - cased for more robust lookup .
* Note that this list only contains attributes that contain at least one capital letter .
* Lowercase attributes don ' t need mapping , since we lowercase all attributes by default .
* /
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 ) => {
// The keys are lower-cased for more robust lookup.
map [ attribute . toLowerCase ( ) ] = attribute ;
return map ;
} , { } ) ;
/ * *
* This is a map of all SVG attributes that have colons .
* Keys are lower - cased and stripped of their colons for more robust lookup .
* /
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 ) => {
map [ attribute . replace ( ':' , '' ) . toLowerCase ( ) ] = attribute ;
return map ;
} , { } ) ;
2018-12-14 05:41:57 +01:00
/ * *
* Returns the normal form of the element ' s attribute name for HTML .
*
* @ param { string } attribute Non - normalized attribute name .
*
* @ return { string } Normalized attribute name .
* /
function getNormalAttributeName ( attribute ) {
switch ( attribute ) {
case 'htmlFor' :
return 'for' ;
case 'className' :
return 'class' ;
}
2022-04-12 17:12:47 +02:00
const attributeLowerCase = attribute . toLowerCase ( ) ;
if ( CASE _SENSITIVE _SVG _ATTRIBUTES [ attributeLowerCase ] ) {
return CASE _SENSITIVE _SVG _ATTRIBUTES [ attributeLowerCase ] ;
} else if ( SVG _ATTRIBUTE _WITH _DASHES _LIST [ attributeLowerCase ] ) {
return ( 0 , external _lodash _namespaceObject . kebabCase ) ( SVG _ATTRIBUTE _WITH _DASHES _LIST [ attributeLowerCase ] ) ;
} else if ( SVG _ATTRIBUTES _WITH _COLONS [ attributeLowerCase ] ) {
return SVG _ATTRIBUTES _WITH _COLONS [ attributeLowerCase ] ;
}
return attributeLowerCase ;
2018-12-14 05:41:57 +01:00
}
/ * *
* Returns the normal form of the style property name for HTML .
*
* - Converts property names to kebab - case , e . g . 'backgroundColor' → 'background-color'
* - Leaves custom attributes alone , e . g . '--myBackgroundColor' → '--myBackgroundColor'
* - Converts vendor - prefixed property names to - kebab - case , e . g . 'MozTransform' → '-moz-transform'
*
* @ param { string } property Property name .
*
* @ return { string } Normalized property name .
* /
function getNormalStylePropertyName ( property ) {
2022-04-11 14:04:30 +02:00
if ( ( 0 , external _lodash _namespaceObject . startsWith ) ( property , '--' ) ) {
2018-12-14 05:41:57 +01:00
return property ;
}
if ( hasPrefix ( property , [ 'ms' , 'O' , 'Moz' , 'Webkit' ] ) ) {
2022-04-11 14:04:30 +02:00
return '-' + ( 0 , external _lodash _namespaceObject . kebabCase ) ( property ) ;
2018-12-14 05:41:57 +01:00
}
2022-04-11 14:04:30 +02:00
return ( 0 , external _lodash _namespaceObject . kebabCase ) ( property ) ;
2018-12-14 05:41:57 +01:00
}
/ * *
* Returns the normal form of the style property value for HTML . Appends a
* default pixel unit if numeric , not a unitless property , and not zero .
*
* @ param { string } property Property name .
* @ param { * } value Non - normalized property value .
*
* @ return { * } Normalized property value .
* /
function getNormalStylePropertyValue ( property , value ) {
if ( typeof value === 'number' && 0 !== value && ! CSS _PROPERTIES _SUPPORTS _UNITLESS . has ( property ) ) {
return value + 'px' ;
}
return value ;
}
/ * *
* Serializes a React element to string .
*
2020-06-26 15:33:47 +02:00
* @ param { import ( 'react' ) . ReactNode } element Element to serialize .
* @ param { Object } [ context ] Context object .
* @ param { Object } [ legacyContext ] Legacy context object .
2018-12-14 05:41:57 +01:00
*
* @ return { string } Serialized element .
* /
2021-11-15 13:50:17 +01:00
function renderElement ( element , context ) {
let legacyContext = arguments . length > 2 && arguments [ 2 ] !== undefined ? arguments [ 2 ] : { } ;
2018-12-14 05:41:57 +01:00
if ( null === element || undefined === element || false === element ) {
return '' ;
}
if ( Array . isArray ( element ) ) {
return renderChildren ( element , context , legacyContext ) ;
}
2021-05-19 17:09:27 +02:00
switch ( typeof element ) {
2018-12-14 05:41:57 +01:00
case 'string' :
2022-04-11 14:04:30 +02:00
return ( 0 , external _wp _escapeHtml _namespaceObject . escapeHTML ) ( element ) ;
2018-12-14 05:41:57 +01:00
case 'number' :
return element . toString ( ) ;
}
2021-05-19 17:09:27 +02:00
const {
type ,
props
} =
2020-06-26 15:33:47 +02:00
/** @type {{type?: any, props?: any}} */
2021-05-19 17:09:27 +02:00
element ;
2018-12-14 05:41:57 +01:00
switch ( type ) {
2022-04-11 14:04:30 +02:00
case external _React _namespaceObject . StrictMode :
case external _React _namespaceObject . Fragment :
2018-12-14 05:41:57 +01:00
return renderChildren ( props . children , context , legacyContext ) ;
2018-12-18 04:14:52 +01:00
case RawHTML :
2021-05-19 17:09:27 +02:00
const {
children ,
... wrapperProps
} = props ;
2022-04-11 14:04:30 +02:00
return renderNativeComponent ( ( 0 , external _lodash _namespaceObject . isEmpty ) ( wrapperProps ) ? null : 'div' , { ... wrapperProps ,
2018-12-14 05:41:57 +01:00
dangerouslySetInnerHTML : {
_ _html : children
}
2021-05-19 17:09:27 +02:00
} , context , legacyContext ) ;
2018-12-14 05:41:57 +01:00
}
2021-05-19 17:09:27 +02:00
switch ( typeof type ) {
2018-12-14 05:41:57 +01:00
case 'string' :
return renderNativeComponent ( type , props , context , legacyContext ) ;
case 'function' :
if ( type . prototype && typeof type . prototype . render === 'function' ) {
return renderComponent ( type , props , context , legacyContext ) ;
}
return renderElement ( type ( props , legacyContext ) , context , legacyContext ) ;
}
switch ( type && type . $$typeof ) {
case Provider . $$typeof :
return renderChildren ( props . children , props . value , legacyContext ) ;
case Consumer . $$typeof :
return renderElement ( props . children ( context || type . _currentValue ) , context , legacyContext ) ;
2019-09-19 17:19:18 +02:00
case ForwardRef . $$typeof :
return renderElement ( type . render ( props ) , context , legacyContext ) ;
2018-12-14 05:41:57 +01:00
}
return '' ;
}
/ * *
* Serializes a native component type to string .
*
2020-06-26 15:33:47 +02:00
* @ param { ? string } type Native component type to serialize , or null if
* rendering as fragment of children content .
* @ param { Object } props Props object .
* @ param { Object } [ context ] Context object .
* @ param { Object } [ legacyContext ] Legacy context object .
2018-12-14 05:41:57 +01:00
*
* @ return { string } Serialized element .
* /
2021-11-15 13:50:17 +01:00
function renderNativeComponent ( type , props , context ) {
let legacyContext = arguments . length > 3 && arguments [ 3 ] !== undefined ? arguments [ 3 ] : { } ;
2021-05-19 17:09:27 +02:00
let content = '' ;
2018-12-14 05:41:57 +01:00
if ( type === 'textarea' && props . hasOwnProperty ( 'value' ) ) {
// Textarea children can be assigned as value prop. If it is, render in
// place of children. Ensure to omit so it is not assigned as attribute
// as well.
content = renderChildren ( props . value , context , legacyContext ) ;
2022-04-11 14:04:30 +02:00
props = ( 0 , external _lodash _namespaceObject . omit ) ( props , 'value' ) ;
2018-12-14 05:41:57 +01:00
} else if ( props . dangerouslySetInnerHTML && typeof props . dangerouslySetInnerHTML . _ _html === 'string' ) {
// Dangerous content is left unescaped.
content = props . dangerouslySetInnerHTML . _ _html ;
} else if ( typeof props . children !== 'undefined' ) {
content = renderChildren ( props . children , context , legacyContext ) ;
}
if ( ! type ) {
return content ;
}
2021-05-19 17:09:27 +02:00
const attributes = renderAttributes ( props ) ;
2018-12-14 05:41:57 +01:00
if ( SELF _CLOSING _TAGS . has ( type ) ) {
return '<' + type + attributes + '/>' ;
}
return '<' + type + attributes + '>' + content + '</' + type + '>' ;
}
2020-06-26 15:33:47 +02:00
/** @typedef {import('./react').WPComponent} WPComponent */
2018-12-14 05:41:57 +01:00
/ * *
* Serializes a non - native component type to string .
*
2020-06-26 15:33:47 +02:00
* @ param { WPComponent } Component Component type to serialize .
* @ param { Object } props Props object .
* @ param { Object } [ context ] Context object .
* @ param { Object } [ legacyContext ] Legacy context object .
2018-12-14 05:41:57 +01:00
*
* @ return { string } Serialized element
* /
2021-11-15 13:50:17 +01:00
function renderComponent ( Component , props , context ) {
let legacyContext = arguments . length > 3 && arguments [ 3 ] !== undefined ? arguments [ 3 ] : { } ;
2021-05-19 17:09:27 +02:00
const instance = new
2020-06-26 15:33:47 +02:00
/** @type {import('react').ComponentClass} */
Component ( props , legacyContext ) ;
if ( typeof // Ignore reason: Current prettier reformats parens and mangles type assertion
// prettier-ignore
/** @type {{getChildContext?: () => unknown}} */
instance . getChildContext === 'function' ) {
Object . assign ( legacyContext ,
/** @type {{getChildContext?: () => unknown}} */
instance . getChildContext ( ) ) ;
2018-12-14 05:41:57 +01:00
}
2021-05-19 17:09:27 +02:00
const html = renderElement ( instance . render ( ) , context , legacyContext ) ;
2018-12-14 05:41:57 +01:00
return html ;
}
/ * *
* Serializes an array of children to string .
*
2020-06-26 15:33:47 +02:00
* @ param { import ( 'react' ) . ReactNodeArray } children Children to serialize .
* @ param { Object } [ context ] Context object .
* @ param { Object } [ legacyContext ] Legacy context object .
2018-12-14 05:41:57 +01:00
*
* @ return { string } Serialized children .
* /
2021-11-15 13:50:17 +01:00
function renderChildren ( children , context ) {
let legacyContext = arguments . length > 2 && arguments [ 2 ] !== undefined ? arguments [ 2 ] : { } ;
2021-05-19 17:09:27 +02:00
let result = '' ;
2022-04-11 14:04:30 +02:00
children = ( 0 , external _lodash _namespaceObject . castArray ) ( children ) ;
2018-12-14 05:41:57 +01:00
2021-05-19 17:09:27 +02:00
for ( let i = 0 ; i < children . length ; i ++ ) {
const child = children [ i ] ;
2018-12-14 05:41:57 +01:00
result += renderElement ( child , context , legacyContext ) ;
}
return result ;
}
/ * *
* Renders a props object as a string of HTML attributes .
*
* @ param { Object } props Props object .
*
* @ return { string } Attributes string .
* /
function renderAttributes ( props ) {
2021-05-19 17:09:27 +02:00
let result = '' ;
2018-12-14 05:41:57 +01:00
2021-05-19 17:09:27 +02:00
for ( const key in props ) {
const attribute = getNormalAttributeName ( key ) ;
2018-12-14 05:41:57 +01:00
2022-04-11 14:04:30 +02:00
if ( ! ( 0 , external _wp _escapeHtml _namespaceObject . isValidAttributeName ) ( attribute ) ) {
2018-12-14 05:41:57 +01:00
continue ;
}
2021-05-19 17:09:27 +02:00
let value = getNormalAttributeValue ( key , props [ key ] ) ; // If value is not of serializeable type, skip.
2018-12-14 05:41:57 +01:00
2021-05-19 17:09:27 +02:00
if ( ! ATTRIBUTES _TYPES . has ( typeof value ) ) {
2018-12-14 05:41:57 +01:00
continue ;
} // Don't render internal attribute names.
if ( isInternalAttribute ( key ) ) {
continue ;
}
2021-05-19 17:09:27 +02:00
const isBooleanAttribute = BOOLEAN _ATTRIBUTES . has ( attribute ) ; // Boolean attribute should be omitted outright if its value is false.
2018-12-14 05:41:57 +01:00
if ( isBooleanAttribute && value === false ) {
continue ;
}
2021-05-19 17:09:27 +02:00
const isMeaningfulAttribute = isBooleanAttribute || hasPrefix ( key , [ 'data-' , 'aria-' ] ) || ENUMERATED _ATTRIBUTES . has ( attribute ) ; // Only write boolean value as attribute if meaningful.
2018-12-14 05:41:57 +01:00
if ( typeof value === 'boolean' && ! isMeaningfulAttribute ) {
continue ;
}
result += ' ' + attribute ; // Boolean attributes should write attribute name, but without value.
// Mere presence of attribute name is effective truthiness.
if ( isBooleanAttribute ) {
continue ;
}
if ( typeof value === 'string' ) {
2022-04-11 14:04:30 +02:00
value = ( 0 , external _wp _escapeHtml _namespaceObject . escapeAttribute ) ( value ) ;
2018-12-14 05:41:57 +01:00
}
result += '="' + value + '"' ;
}
return result ;
}
/ * *
* Renders a style object as a string attribute value .
*
* @ param { Object } style Style object .
*
* @ return { string } Style attribute value .
* /
function renderStyle ( style ) {
// Only generate from object, e.g. tolerate string value.
2022-04-11 14:04:30 +02:00
if ( ! ( 0 , external _lodash _namespaceObject . isPlainObject ) ( style ) ) {
2018-12-14 05:41:57 +01:00
return style ;
}
2021-05-19 17:09:27 +02:00
let result ;
2018-12-14 05:41:57 +01:00
2021-05-19 17:09:27 +02:00
for ( const property in style ) {
const value = style [ property ] ;
2018-12-14 05:41:57 +01:00
if ( null === value || undefined === value ) {
continue ;
}
if ( result ) {
result += ';' ;
} else {
result = '' ;
}
2021-05-19 17:09:27 +02:00
const normalName = getNormalStylePropertyName ( property ) ;
const normalValue = getNormalStylePropertyValue ( property , value ) ;
2018-12-14 05:41:57 +01:00
result += normalName + ':' + normalValue ;
}
return result ;
}
2018-12-18 04:14:52 +01:00
/* harmony default export */ var serialize = ( renderElement ) ;
2018-12-14 05:41:57 +01:00
2022-04-11 14:04:30 +02:00
; // CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/index.js
2018-12-14 05:41:57 +01:00
2020-01-08 12:57:23 +01:00
2018-12-14 05:41:57 +01:00
2022-04-11 14:04:30 +02:00
( window . wp = window . wp || { } ) . element = _ _webpack _exports _ _ ;
/******/ } ) ( )
;