2022-04-11 14:04:30 +02:00
/******/ ( function ( ) { // webpackBootstrap
/******/ var _ _webpack _modules _ _ = ( {
/***/ 9756 :
/***/ ( function ( module ) {
/ * *
* Memize options object .
*
* @ typedef MemizeOptions
*
* @ property { number } [ maxSize ] Maximum size of the cache .
* /
/ * *
* Internal cache entry .
*
* @ typedef MemizeCacheNode
*
* @ property { ? MemizeCacheNode | undefined } [ prev ] Previous node .
* @ property { ? MemizeCacheNode | undefined } [ next ] Next node .
* @ property { Array < * > } args Function arguments for cache
* entry .
* @ property { * } val Function result .
* /
/ * *
* Properties of the enhanced function for controlling cache .
*
* @ typedef MemizeMemoizedFunction
*
* @ property { ( ) => void } clear Clear the cache .
* /
/ * *
* Accepts a function to be memoized , and returns a new memoized function , with
* optional options .
*
* @ template { Function } F
*
* @ param { F } fn Function to memoize .
* @ param { MemizeOptions } [ options ] Options object .
*
* @ return { F & MemizeMemoizedFunction } Memoized function .
* /
function memize ( fn , options ) {
var size = 0 ;
/** @type {?MemizeCacheNode|undefined} */
var head ;
/** @type {?MemizeCacheNode|undefined} */
var tail ;
options = options || { } ;
function memoized ( /* ...args */ ) {
var node = head ,
len = arguments . length ,
args , i ;
searchCache : while ( node ) {
// Perform a shallow equality test to confirm that whether the node
// under test is a candidate for the arguments passed. Two arrays
// are shallowly equal if their length matches and each entry is
// strictly equal between the two sets. Avoid abstracting to a
// function which could incur an arguments leaking deoptimization.
// Check whether node arguments match arguments length
if ( node . args . length !== arguments . length ) {
node = node . next ;
continue ;
}
// Check whether node arguments match arguments values
for ( i = 0 ; i < len ; i ++ ) {
if ( node . args [ i ] !== arguments [ i ] ) {
node = node . next ;
continue searchCache ;
}
}
// At this point we can assume we've found a match
// Surface matched node to head if not already
if ( node !== head ) {
// As tail, shift to previous. Must only shift if not also
// head, since if both head and tail, there is no previous.
if ( node === tail ) {
tail = node . prev ;
}
// Adjust siblings to point to each other. If node was tail,
// this also handles new tail's empty `next` assignment.
/** @type {MemizeCacheNode} */ ( node . prev ) . next = node . next ;
if ( node . next ) {
node . next . prev = node . prev ;
}
node . next = head ;
node . prev = null ;
/** @type {MemizeCacheNode} */ ( head ) . prev = node ;
head = node ;
}
// Return immediately
return node . val ;
}
// No cached value found. Continue to insertion phase:
// Create a copy of arguments (avoid leaking deoptimization)
args = new Array ( len ) ;
for ( i = 0 ; i < len ; i ++ ) {
args [ i ] = arguments [ i ] ;
}
node = {
args : args ,
// Generate the result from original function
val : fn . apply ( null , args ) ,
} ;
// Don't need to check whether node is already head, since it would
// have been returned above already if it was
// Shift existing head down list
if ( head ) {
head . prev = node ;
node . next = head ;
} else {
// If no head, follows that there's no tail (at initial or reset)
tail = node ;
}
// Trim tail if we're reached max size and are pending cache insertion
if ( size === /** @type {MemizeOptions} */ ( options ) . maxSize ) {
tail = /** @type {MemizeCacheNode} */ ( tail ) . prev ;
/** @type {MemizeCacheNode} */ ( tail ) . next = null ;
} else {
size ++ ;
}
head = node ;
return node . val ;
}
memoized . clear = function ( ) {
head = null ;
tail = null ;
size = 0 ;
} ;
if ( false ) { }
// Ignore reason: There's not a clear solution to create an intersection of
// the function with additional properties, where the goal is to retain the
// function signature of the incoming argument and add control properties
// on the return value.
// @ts-ignore
return memoized ;
}
module . exports = memize ;
/***/ } )
/******/ } ) ;
/************************************************************************/
2018-12-14 05:41:57 +01:00
/******/ // The module cache
2022-04-11 14:04:30 +02:00
/******/ var _ _webpack _module _cache _ _ = { } ;
/******/
2018-12-14 05:41:57 +01:00
/******/ // The require function
/******/ function _ _webpack _require _ _ ( moduleId ) {
/******/ // Check if module is in cache
2022-04-11 14:04:30 +02:00
/******/ var cachedModule = _ _webpack _module _cache _ _ [ moduleId ] ;
/******/ if ( cachedModule !== undefined ) {
/******/ return cachedModule . exports ;
2018-12-14 05:41:57 +01:00
/******/ }
/******/ // Create a new module (and put it into the cache)
2022-04-11 14:04:30 +02:00
/******/ var module = _ _webpack _module _cache _ _ [ moduleId ] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
2018-12-14 05:41:57 +01:00
/******/ exports : { }
/******/ } ;
2022-04-11 14:04:30 +02:00
/******/
2018-12-14 05:41:57 +01:00
/******/ // Execute the module function
2022-04-11 14:04:30 +02:00
/******/ _ _webpack _modules _ _ [ moduleId ] ( module , module . exports , _ _webpack _require _ _ ) ;
/******/
2018-12-14 05:41:57 +01:00
/******/ // Return the exports of the module
/******/ return module . exports ;
/******/ }
2022-04-11 14:04:30 +02:00
/******/
2018-12-14 05:41:57 +01:00
/************************************************************************/
2022-04-11 14:04:30 +02:00
/******/ /* webpack/runtime/compat get default export */
/******/ ! function ( ) {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ _ _webpack _require _ _ . n = function ( module ) {
/******/ var getter = module && module . _ _esModule ?
/******/ function ( ) { return module [ 'default' ] ; } :
/******/ function ( ) { return module ; } ;
/******/ _ _webpack _require _ _ . d ( getter , { a : getter } ) ;
/******/ return getter ;
/******/ } ;
/******/ } ( ) ;
/******/
/******/ /* 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 ) ; }
/******/ } ( ) ;
/******/
/************************************************************************/
var _ _webpack _exports _ _ = { } ;
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
! function ( ) {
"use strict" ;
2022-09-20 17:43:29 +02:00
/* unused harmony exports next, replace, string, regexp, attrs, fromMatch */
/* harmony import */ var memize _ _WEBPACK _IMPORTED _MODULE _0 _ _ = _ _webpack _require _ _ ( 9756 ) ;
/* harmony import */ var memize _ _WEBPACK _IMPORTED _MODULE _0 _ _ _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( memize _ _WEBPACK _IMPORTED _MODULE _0 _ _ ) ;
2018-12-14 05:41:57 +01:00
/ * *
2019-03-07 10:09:59 +01:00
* External dependencies
2018-12-14 05:41:57 +01:00
* /
/ * *
* Shortcode attributes object .
*
* @ typedef { Object } WPShortcodeAttrs
*
* @ property { Object } named Object with named attributes .
* @ property { Array } numeric Array with numeric attributes .
* /
/ * *
* Shortcode object .
*
* @ typedef { Object } WPShortcode
*
* @ property { string } tag Shortcode tag .
* @ property { WPShortcodeAttrs } attrs Shortcode attributes .
* @ property { string } content Shortcode content .
* @ property { string } type Shortcode type : ` self-closing ` ,
* ` closed ` , or ` single ` .
* /
/ * *
* @ typedef { Object } WPShortcodeMatch
*
* @ property { number } index Index the shortcode is found at .
* @ property { string } content Matched content .
* @ property { WPShortcode } shortcode Shortcode instance of the match .
* /
/ * *
* Find the next matching shortcode .
*
* @ param { string } tag Shortcode tag .
* @ param { string } text Text to search .
* @ param { number } index Index to start search from .
*
2023-02-07 08:04:52 +01:00
* @ return { WPShortcodeMatch | undefined } Matched information .
2018-12-14 05:41:57 +01:00
* /
2021-11-15 13:50:17 +01:00
function next ( tag , text ) {
let index = arguments . length > 2 && arguments [ 2 ] !== undefined ? arguments [ 2 ] : 0 ;
2021-05-19 17:09:27 +02:00
const re = regexp ( tag ) ;
2018-12-14 05:41:57 +01:00
re . lastIndex = index ;
2021-05-19 17:09:27 +02:00
const match = re . exec ( text ) ;
2018-12-14 05:41:57 +01:00
if ( ! match ) {
return ;
} // If we matched an escaped shortcode, try again.
if ( '[' === match [ 1 ] && ']' === match [ 7 ] ) {
return next ( tag , text , re . lastIndex ) ;
}
2021-05-19 17:09:27 +02:00
const result = {
2018-12-14 05:41:57 +01:00
index : match . index ,
content : match [ 0 ] ,
shortcode : fromMatch ( match )
} ; // If we matched a leading `[`, strip it from the match and increment the
// index accordingly.
if ( match [ 1 ] ) {
result . content = result . content . slice ( 1 ) ;
result . index ++ ;
} // If we matched a trailing `]`, strip it from the match.
if ( match [ 7 ] ) {
result . content = result . content . slice ( 0 , - 1 ) ;
}
return result ;
}
/ * *
* Replace matching shortcodes in a block of text .
*
* @ param { string } tag Shortcode tag .
* @ param { string } text Text to search .
* @ param { Function } callback Function to process the match and return
* replacement string .
*
* @ return { string } Text with shortcodes replaced .
* /
function replace ( tag , text , callback ) {
return text . replace ( regexp ( tag ) , function ( match , left , $3 , attrs , slash , content , closing , right ) {
// If both extra brackets exist, the shortcode has been properly
// escaped.
if ( left === '[' && right === ']' ) {
return match ;
} // Create the match object and pass it through the callback.
2021-05-19 17:09:27 +02:00
const result = callback ( fromMatch ( arguments ) ) ; // Make sure to return any of the extra brackets if they weren't used to
2018-12-14 05:41:57 +01:00
// escape the shortcode.
2021-01-28 03:04:13 +01:00
return result || result === '' ? left + result + right : match ;
2018-12-14 05:41:57 +01:00
} ) ;
}
/ * *
* Generate a string from shortcode parameters .
*
* Creates a shortcode instance and returns a string .
*
* Accepts the same ` options ` as the ` shortcode() ` constructor , containing a
* ` tag ` string , a string or object of ` attrs ` , a boolean indicating whether to
* format the shortcode using a ` single ` tag , and a ` content ` string .
*
* @ param { Object } options
*
* @ return { string } String representation of the shortcode .
* /
function string ( options ) {
return new shortcode ( options ) . string ( ) ;
}
/ * *
* Generate a RegExp to identify a shortcode .
*
* The base regex is functionally equivalent to the one found in
* ` get_shortcode_regex() ` in ` wp-includes/shortcodes.php ` .
*
* Capture groups :
*
* 1. An extra ` [ ` to allow for escaping shortcodes with double ` [[]] `
* 2. The shortcode name
* 3. The shortcode argument list
* 4. The self closing ` / `
* 5. The content of a shortcode when it wraps some content .
* 6. The closing tag .
* 7. An extra ` ] ` to allow for escaping shortcodes with double ` [[]] `
*
* @ param { string } tag Shortcode tag .
*
* @ return { RegExp } Shortcode RegExp .
* /
function regexp ( tag ) {
return new RegExp ( '\\[(\\[?)(' + tag + ')(?![\\w-])([^\\]\\/]*(?:\\/(?!\\])[^\\]\\/]*)*?)(?:(\\/)\\]|\\](?:([^\\[]*(?:\\[(?!\\/\\2\\])[^\\[]*)*)(\\[\\/\\2\\]))?)(\\]?)' , 'g' ) ;
}
/ * *
* Parse shortcode attributes .
*
* Shortcodes accept many types of attributes . These can chiefly be divided into
* named and numeric attributes :
*
* Named attributes are assigned on a key / value basis , while numeric attributes
* are treated as an array .
*
* Named attributes can be formatted as either ` name="value" ` , ` name='value' ` ,
* or ` name=value ` . Numeric attributes can be formatted as ` "value" ` or just
* ` value ` .
*
* @ param { string } text Serialised shortcode attributes .
*
* @ return { WPShortcodeAttrs } Parsed shortcode attributes .
* /
2022-09-20 17:43:29 +02:00
const attrs = memize _ _WEBPACK _IMPORTED _MODULE _0 _ _ _default ( ) ( text => {
2021-05-19 17:09:27 +02:00
const named = { } ;
const numeric = [ ] ; // This regular expression is reused from `shortcode_parse_atts()` in
2018-12-14 05:41:57 +01:00
// `wp-includes/shortcodes.php`.
//
// Capture groups:
//
// 1. An attribute name, that corresponds to...
// 2. a value in double quotes.
// 3. An attribute name, that corresponds to...
// 4. a value in single quotes.
// 5. An attribute name, that corresponds to...
// 6. an unquoted value.
// 7. A numeric attribute in double quotes.
// 8. A numeric attribute in single quotes.
// 9. An unquoted numeric attribute.
2021-05-19 17:09:27 +02:00
const pattern = /([\w-]+)\s*=\s*"([^"]*)"(?:\s|$)|([\w-]+)\s*=\s*'([^']*)'(?:\s|$)|([\w-]+)\s*=\s*([^\s'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|'([^']*)'(?:\s|$)|(\S+)(?:\s|$)/g ; // Map zero-width spaces to actual spaces.
2018-12-14 05:41:57 +01:00
text = text . replace ( /[\u00a0\u200b]/g , ' ' ) ;
2021-05-19 17:09:27 +02:00
let match ; // Match and normalize attributes.
2018-12-14 05:41:57 +01:00
while ( match = pattern . exec ( text ) ) {
if ( match [ 1 ] ) {
named [ match [ 1 ] . toLowerCase ( ) ] = match [ 2 ] ;
} else if ( match [ 3 ] ) {
named [ match [ 3 ] . toLowerCase ( ) ] = match [ 4 ] ;
} else if ( match [ 5 ] ) {
named [ match [ 5 ] . toLowerCase ( ) ] = match [ 6 ] ;
} else if ( match [ 7 ] ) {
numeric . push ( match [ 7 ] ) ;
} else if ( match [ 8 ] ) {
numeric . push ( match [ 8 ] ) ;
} else if ( match [ 9 ] ) {
numeric . push ( match [ 9 ] ) ;
}
}
return {
2021-05-19 17:09:27 +02:00
named ,
numeric
2018-12-14 05:41:57 +01:00
} ;
} ) ;
/ * *
* Generate a Shortcode Object from a RegExp match .
*
* Accepts a ` match ` object from calling ` regexp.exec() ` on a ` RegExp ` generated
* by ` regexp() ` . ` match ` can also be set to the ` arguments ` from a callback
* passed to ` regexp.replace() ` .
*
* @ param { Array } match Match array .
*
* @ return { WPShortcode } Shortcode instance .
* /
function fromMatch ( match ) {
2021-05-19 17:09:27 +02:00
let type ;
2018-12-14 05:41:57 +01:00
if ( match [ 4 ] ) {
type = 'self-closing' ;
} else if ( match [ 6 ] ) {
type = 'closed' ;
} else {
type = 'single' ;
}
return new shortcode ( {
tag : match [ 2 ] ,
attrs : match [ 3 ] ,
2021-05-19 17:09:27 +02:00
type ,
2018-12-14 05:41:57 +01:00
content : match [ 5 ]
} ) ;
}
/ * *
* Creates a shortcode instance .
*
* To access a raw representation of a shortcode , pass an ` options ` object ,
* containing a ` tag ` string , a string or object of ` attrs ` , a string indicating
* the ` type ` of the shortcode ( 'single' , 'self-closing' , or 'closed' ) , and a
* ` content ` string .
*
* @ param { Object } options Options as described .
*
* @ return { WPShortcode } Shortcode instance .
* /
2022-09-20 17:43:29 +02:00
const shortcode = Object . assign ( function ( options ) {
const {
tag ,
attrs : attributes ,
type ,
content
} = options || { } ;
Object . assign ( this , {
tag ,
type ,
content
} ) ; // Ensure we have a correctly formatted `attrs` object.
2018-12-14 05:41:57 +01:00
this . attrs = {
named : { } ,
numeric : [ ]
} ;
if ( ! attributes ) {
return ;
2022-09-20 17:43:29 +02:00
}
2018-12-14 05:41:57 +01:00
2022-09-20 17:43:29 +02:00
const attributeTypes = [ 'named' , 'numeric' ] ; // Parse a string of attributes.
2018-12-14 05:41:57 +01:00
2022-09-20 17:43:29 +02:00
if ( typeof attributes === 'string' ) {
2018-12-14 05:41:57 +01:00
this . attrs = attrs ( attributes ) ; // Identify a correctly formatted `attrs` object.
2022-09-20 17:43:29 +02:00
} else if ( attributes . length === attributeTypes . length && attributeTypes . every ( ( t , key ) => t === attributes [ key ] ) ) {
2018-12-14 05:41:57 +01:00
this . attrs = attributes ; // Handle a flat object of attributes.
} else {
2022-09-20 17:43:29 +02:00
Object . entries ( attributes ) . forEach ( _ref => {
let [ key , value ] = _ref ;
2021-05-19 17:09:27 +02:00
this . set ( key , value ) ;
2018-12-14 05:41:57 +01:00
} ) ;
}
} , {
2021-05-19 17:09:27 +02:00
next ,
replace ,
string ,
regexp ,
attrs ,
fromMatch
2018-12-14 05:41:57 +01:00
} ) ;
2022-09-20 17:43:29 +02:00
Object . assign ( shortcode . prototype , {
2018-12-14 05:41:57 +01:00
/ * *
* Get a shortcode attribute .
*
* Automatically detects whether ` attr ` is named or numeric and routes it
* accordingly .
*
* @ param { ( number | string ) } attr Attribute key .
*
* @ return { string } Attribute value .
* /
2021-05-19 17:09:27 +02:00
get ( attr ) {
2022-09-20 17:43:29 +02:00
return this . attrs [ typeof attr === 'number' ? 'numeric' : 'named' ] [ attr ] ;
2018-12-14 05:41:57 +01:00
} ,
/ * *
* Set a shortcode attribute .
*
* Automatically detects whether ` attr ` is named or numeric and routes it
* accordingly .
*
* @ param { ( number | string ) } attr Attribute key .
* @ param { string } value Attribute value .
*
* @ return { WPShortcode } Shortcode instance .
* /
2021-05-19 17:09:27 +02:00
set ( attr , value ) {
2022-09-20 17:43:29 +02:00
this . attrs [ typeof attr === 'number' ? 'numeric' : 'named' ] [ attr ] = value ;
2018-12-14 05:41:57 +01:00
return this ;
} ,
/ * *
* Transform the shortcode into a string .
*
* @ return { string } String representation of the shortcode .
* /
2021-05-19 17:09:27 +02:00
string ( ) {
let text = '[' + this . tag ;
2022-09-20 17:43:29 +02:00
this . attrs . numeric . forEach ( value => {
2018-12-14 05:41:57 +01:00
if ( /\s/ . test ( value ) ) {
text += ' "' + value + '"' ;
} else {
text += ' ' + value ;
}
} ) ;
2022-09-20 17:43:29 +02:00
Object . entries ( this . attrs . named ) . forEach ( _ref2 => {
let [ name , value ] = _ref2 ;
2018-12-14 05:41:57 +01:00
text += ' ' + name + '="' + value + '"' ;
} ) ; // If the tag is marked as `single` or `self-closing`, close the tag and
// ignore any additional content.
if ( 'single' === this . type ) {
return text + ']' ;
} else if ( 'self-closing' === this . type ) {
return text + ' /]' ;
} // Complete the opening tag.
text += ']' ;
if ( this . content ) {
text += this . content ;
} // Add the closing tag.
return text + '[/' + this . tag + ']' ;
}
2021-05-19 17:09:27 +02:00
2018-12-14 05:41:57 +01:00
} ) ;
2022-09-20 17:43:29 +02:00
/* harmony default export */ _ _webpack _exports _ _ [ "default" ] = ( shortcode ) ;
2018-12-14 05:41:57 +01:00
2022-04-11 14:04:30 +02:00
} ( ) ;
( window . wp = window . wp || { } ) . shortcode = _ _webpack _exports _ _ [ "default" ] ;
/******/ } ) ( )
;