2019-11-02 10:38:58 +01:00
this [ "wp" ] = this [ "wp" ] || { } ; this [ "wp" ] [ "i18n" ] =
/******/ ( function ( modules ) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = { } ;
/******/
/******/ // The require function
/******/ function _ _webpack _require _ _ ( moduleId ) {
/******/
/******/ // Check if module is in cache
/******/ if ( installedModules [ moduleId ] ) {
/******/ return installedModules [ moduleId ] . exports ;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules [ moduleId ] = {
/******/ i : moduleId ,
/******/ l : false ,
/******/ exports : { }
/******/ } ;
/******/
/******/ // Execute the module function
/******/ modules [ moduleId ] . call ( module . exports , module , module . exports , _ _webpack _require _ _ ) ;
/******/
/******/ // Flag the module as loaded
/******/ module . l = true ;
/******/
/******/ // Return the exports of the module
/******/ return module . exports ;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ _ _webpack _require _ _ . m = modules ;
/******/
/******/ // expose the module cache
/******/ _ _webpack _require _ _ . c = installedModules ;
/******/
/******/ // define getter function for harmony exports
/******/ _ _webpack _require _ _ . d = function ( exports , name , getter ) {
/******/ if ( ! _ _webpack _require _ _ . o ( exports , name ) ) {
/******/ Object . defineProperty ( exports , name , { enumerable : true , get : getter } ) ;
/******/ }
/******/ } ;
/******/
/******/ // 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 } ) ;
/******/ } ;
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ _ _webpack _require _ _ . t = function ( value , mode ) {
/******/ if ( mode & 1 ) value = _ _webpack _require _ _ ( value ) ;
/******/ if ( mode & 8 ) return value ;
/******/ if ( ( mode & 4 ) && typeof value === 'object' && value && value . _ _esModule ) return value ;
/******/ var ns = Object . create ( null ) ;
/******/ _ _webpack _require _ _ . r ( ns ) ;
/******/ Object . defineProperty ( ns , 'default' , { enumerable : true , value : value } ) ;
/******/ if ( mode & 2 && typeof value != 'string' ) for ( var key in value ) _ _webpack _require _ _ . d ( ns , key , function ( key ) { return value [ key ] ; } . bind ( null , key ) ) ;
/******/ return ns ;
/******/ } ;
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ _ _webpack _require _ _ . n = function ( module ) {
/******/ var getter = module && module . _ _esModule ?
/******/ function getDefault ( ) { return module [ 'default' ] ; } :
/******/ function getModuleExports ( ) { return module ; } ;
/******/ _ _webpack _require _ _ . d ( getter , 'a' , getter ) ;
/******/ return getter ;
/******/ } ;
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ _ _webpack _require _ _ . o = function ( object , property ) { return Object . prototype . hasOwnProperty . call ( object , property ) ; } ;
/******/
/******/ // __webpack_public_path__
/******/ _ _webpack _require _ _ . p = "" ;
/******/
/******/
/******/ // Load entry module and return exports
2020-12-10 14:06:04 +01:00
/******/ return _ _webpack _require _ _ ( _ _webpack _require _ _ . s = 485 ) ;
2019-11-02 10:38:58 +01:00
/******/ } )
/************************************************************************/
/******/ ( {
2020-12-10 14:06:04 +01:00
/***/ 202 :
2019-11-02 10:38:58 +01:00
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
var _ _WEBPACK _AMD _DEFINE _RESULT _ _ ; /* global window, exports, define */
! function ( ) {
'use strict'
var re = {
not _string : /[^s]/ ,
not _bool : /[^t]/ ,
not _type : /[^T]/ ,
not _primitive : /[^v]/ ,
number : /[diefg]/ ,
numeric _arg : /[bcdiefguxX]/ ,
json : /[j]/ ,
not _json : /[^j]/ ,
text : /^[^\x25]+/ ,
modulo : /^\x25{2}/ ,
placeholder : /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/ ,
key : /^([a-z_][a-z_\d]*)/i ,
key _access : /^\.([a-z_][a-z_\d]*)/i ,
index _access : /^\[(\d+)\]/ ,
sign : /^[+-]/
}
function sprintf ( key ) {
// `arguments` is not an array, but should be fine for this call
return sprintf _format ( sprintf _parse ( key ) , arguments )
}
function vsprintf ( fmt , argv ) {
return sprintf . apply ( null , [ fmt ] . concat ( argv || [ ] ) )
}
function sprintf _format ( parse _tree , argv ) {
var cursor = 1 , tree _length = parse _tree . length , arg , output = '' , i , k , ph , pad , pad _character , pad _length , is _positive , sign
for ( i = 0 ; i < tree _length ; i ++ ) {
if ( typeof parse _tree [ i ] === 'string' ) {
output += parse _tree [ i ]
}
else if ( typeof parse _tree [ i ] === 'object' ) {
ph = parse _tree [ i ] // convenience purposes only
if ( ph . keys ) { // keyword argument
arg = argv [ cursor ]
for ( k = 0 ; k < ph . keys . length ; k ++ ) {
if ( arg == undefined ) {
throw new Error ( sprintf ( '[sprintf] Cannot access property "%s" of undefined value "%s"' , ph . keys [ k ] , ph . keys [ k - 1 ] ) )
}
arg = arg [ ph . keys [ k ] ]
}
}
else if ( ph . param _no ) { // positional argument (explicit)
arg = argv [ ph . param _no ]
}
else { // positional argument (implicit)
arg = argv [ cursor ++ ]
}
if ( re . not _type . test ( ph . type ) && re . not _primitive . test ( ph . type ) && arg instanceof Function ) {
arg = arg ( )
}
if ( re . numeric _arg . test ( ph . type ) && ( typeof arg !== 'number' && isNaN ( arg ) ) ) {
throw new TypeError ( sprintf ( '[sprintf] expecting number but found %T' , arg ) )
}
if ( re . number . test ( ph . type ) ) {
is _positive = arg >= 0
}
switch ( ph . type ) {
case 'b' :
arg = parseInt ( arg , 10 ) . toString ( 2 )
break
case 'c' :
arg = String . fromCharCode ( parseInt ( arg , 10 ) )
break
case 'd' :
case 'i' :
arg = parseInt ( arg , 10 )
break
case 'j' :
arg = JSON . stringify ( arg , null , ph . width ? parseInt ( ph . width ) : 0 )
break
case 'e' :
arg = ph . precision ? parseFloat ( arg ) . toExponential ( ph . precision ) : parseFloat ( arg ) . toExponential ( )
break
case 'f' :
arg = ph . precision ? parseFloat ( arg ) . toFixed ( ph . precision ) : parseFloat ( arg )
break
case 'g' :
arg = ph . precision ? String ( Number ( arg . toPrecision ( ph . precision ) ) ) : parseFloat ( arg )
break
case 'o' :
arg = ( parseInt ( arg , 10 ) >>> 0 ) . toString ( 8 )
break
case 's' :
arg = String ( arg )
arg = ( ph . precision ? arg . substring ( 0 , ph . precision ) : arg )
break
case 't' :
arg = String ( ! ! arg )
arg = ( ph . precision ? arg . substring ( 0 , ph . precision ) : arg )
break
case 'T' :
arg = Object . prototype . toString . call ( arg ) . slice ( 8 , - 1 ) . toLowerCase ( )
arg = ( ph . precision ? arg . substring ( 0 , ph . precision ) : arg )
break
case 'u' :
arg = parseInt ( arg , 10 ) >>> 0
break
case 'v' :
arg = arg . valueOf ( )
arg = ( ph . precision ? arg . substring ( 0 , ph . precision ) : arg )
break
case 'x' :
arg = ( parseInt ( arg , 10 ) >>> 0 ) . toString ( 16 )
break
case 'X' :
arg = ( parseInt ( arg , 10 ) >>> 0 ) . toString ( 16 ) . toUpperCase ( )
break
}
if ( re . json . test ( ph . type ) ) {
output += arg
}
else {
if ( re . number . test ( ph . type ) && ( ! is _positive || ph . sign ) ) {
sign = is _positive ? '+' : '-'
arg = arg . toString ( ) . replace ( re . sign , '' )
}
else {
sign = ''
}
pad _character = ph . pad _char ? ph . pad _char === '0' ? '0' : ph . pad _char . charAt ( 1 ) : ' '
pad _length = ph . width - ( sign + arg ) . length
pad = ph . width ? ( pad _length > 0 ? pad _character . repeat ( pad _length ) : '' ) : ''
output += ph . align ? sign + arg + pad : ( pad _character === '0' ? sign + pad + arg : pad + sign + arg )
}
}
}
return output
}
var sprintf _cache = Object . create ( null )
function sprintf _parse ( fmt ) {
if ( sprintf _cache [ fmt ] ) {
return sprintf _cache [ fmt ]
}
var _fmt = fmt , match , parse _tree = [ ] , arg _names = 0
while ( _fmt ) {
if ( ( match = re . text . exec ( _fmt ) ) !== null ) {
parse _tree . push ( match [ 0 ] )
}
else if ( ( match = re . modulo . exec ( _fmt ) ) !== null ) {
parse _tree . push ( '%' )
}
else if ( ( match = re . placeholder . exec ( _fmt ) ) !== null ) {
if ( match [ 2 ] ) {
arg _names |= 1
var field _list = [ ] , replacement _field = match [ 2 ] , field _match = [ ]
if ( ( field _match = re . key . exec ( replacement _field ) ) !== null ) {
field _list . push ( field _match [ 1 ] )
while ( ( replacement _field = replacement _field . substring ( field _match [ 0 ] . length ) ) !== '' ) {
if ( ( field _match = re . key _access . exec ( replacement _field ) ) !== null ) {
field _list . push ( field _match [ 1 ] )
}
else if ( ( field _match = re . index _access . exec ( replacement _field ) ) !== null ) {
field _list . push ( field _match [ 1 ] )
}
else {
throw new SyntaxError ( '[sprintf] failed to parse named argument key' )
}
}
}
else {
throw new SyntaxError ( '[sprintf] failed to parse named argument key' )
}
match [ 2 ] = field _list
}
else {
arg _names |= 2
}
if ( arg _names === 3 ) {
throw new Error ( '[sprintf] mixing positional and named placeholders is not (yet) supported' )
}
parse _tree . push (
{
placeholder : match [ 0 ] ,
param _no : match [ 1 ] ,
keys : match [ 2 ] ,
sign : match [ 3 ] ,
pad _char : match [ 4 ] ,
align : match [ 5 ] ,
width : match [ 6 ] ,
precision : match [ 7 ] ,
type : match [ 8 ]
}
)
}
else {
throw new SyntaxError ( '[sprintf] unexpected placeholder' )
}
_fmt = _fmt . substring ( match [ 0 ] . length )
}
return sprintf _cache [ fmt ] = parse _tree
}
/ * *
* export to either browser or node . js
* /
/* eslint-disable quote-props */
if ( true ) {
exports [ 'sprintf' ] = sprintf
exports [ 'vsprintf' ] = vsprintf
}
if ( typeof window !== 'undefined' ) {
window [ 'sprintf' ] = sprintf
window [ 'vsprintf' ] = vsprintf
if ( true ) {
! ( _ _WEBPACK _AMD _DEFINE _RESULT _ _ = ( function ( ) {
return {
'sprintf' : sprintf ,
'vsprintf' : vsprintf
}
} ) . call ( exports , _ _webpack _require _ _ , exports , module ) ,
_ _WEBPACK _AMD _DEFINE _RESULT _ _ !== undefined && ( module . exports = _ _WEBPACK _AMD _DEFINE _RESULT _ _ ) )
}
}
/* eslint-enable quote-props */
} ( ) ; // eslint-disable-line
/***/ } ) ,
2020-12-10 14:06:04 +01:00
/***/ 485 :
2019-11-02 10:38:58 +01:00
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
2020-09-15 14:29:22 +02:00
// ESM COMPAT FLAG
2019-11-02 10:38:58 +01:00
_ _webpack _require _ _ . r ( _ _webpack _exports _ _ ) ;
2020-09-15 14:29:22 +02:00
// EXPORTS
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "sprintf" , function ( ) { return /* reexport */ sprintf _sprintf ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "createI18n" , function ( ) { return /* reexport */ create _i18n _createI18n ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "setLocaleData" , function ( ) { return /* reexport */ default _i18n _setLocaleData ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "__" , function ( ) { return /* reexport */ default _i18n _ ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "_x" , function ( ) { return /* reexport */ default _i18n _x ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "_n" , function ( ) { return /* reexport */ default _i18n _n ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "_nx" , function ( ) { return /* reexport */ default _i18n _nx ; } ) ;
_ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "isRTL" , function ( ) { return /* reexport */ default _i18n _isRTL ; } ) ;
// EXTERNAL MODULE: ./node_modules/memize/index.js
var memize = _ _webpack _require _ _ ( 60 ) ;
var memize _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( memize ) ;
// EXTERNAL MODULE: ./node_modules/sprintf-js/src/sprintf.js
2020-12-10 14:06:04 +01:00
var sprintf = _ _webpack _require _ _ ( 202 ) ;
2020-09-15 14:29:22 +02:00
var sprintf _default = /*#__PURE__*/ _ _webpack _require _ _ . n ( sprintf ) ;
// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/sprintf.js
/ * *
* External dependencies
* /
/ * *
* Log to console , once per message ; or more precisely , per referentially equal
* argument set . Because Jed throws errors , we log these to the console instead
* to avoid crashing the application .
*
* @ param { ... * } args Arguments to pass to ` console.error `
* /
var logErrorOnce = memize _default ( ) ( console . error ) ; // eslint-disable-line no-console
/ * *
* Returns a formatted string . If an error occurs in applying the format , the
* original format string is returned .
*
* @ param { string } format The format of the string to generate .
* @ param { ... * } args Arguments to apply to the format .
*
* @ see http : //www.diveintojavascript.com/projects/javascript-sprintf
*
* @ return { string } The formatted string .
* /
function sprintf _sprintf ( format ) {
try {
for ( var _len = arguments . length , args = new Array ( _len > 1 ? _len - 1 : 0 ) , _key = 1 ; _key < _len ; _key ++ ) {
args [ _key - 1 ] = arguments [ _key ] ;
}
return sprintf _default . a . sprintf . apply ( sprintf _default . a , [ format ] . concat ( args ) ) ;
} catch ( error ) {
logErrorOnce ( 'sprintf error: \n\n' + error . toString ( ) ) ;
return format ;
}
}
2020-05-06 17:23:38 +02:00
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
var defineProperty = _ _webpack _require _ _ ( 5 ) ;
2019-11-02 10:38:58 +01:00
// CONCATENATED MODULE: ./node_modules/@tannin/postfix/index.js
var PRECEDENCE , OPENERS , TERMINATORS , PATTERN ;
/ * *
* Operator precedence mapping .
*
* @ type { Object }
* /
PRECEDENCE = {
'(' : 9 ,
'!' : 8 ,
'*' : 7 ,
'/' : 7 ,
'%' : 7 ,
'+' : 6 ,
'-' : 6 ,
'<' : 5 ,
'<=' : 5 ,
'>' : 5 ,
'>=' : 5 ,
'==' : 4 ,
'!=' : 4 ,
'&&' : 3 ,
'||' : 2 ,
'?' : 1 ,
'?:' : 1 ,
} ;
/ * *
* Characters which signal pair opening , to be terminated by terminators .
*
* @ type { string [ ] }
* /
OPENERS = [ '(' , '?' ] ;
/ * *
* Characters which signal pair termination , the value an array with the
* opener as its first member . The second member is an optional operator
* replacement to push to the stack .
*
* @ type { string [ ] }
* /
TERMINATORS = {
')' : [ '(' ] ,
':' : [ '?' , '?:' ] ,
} ;
/ * *
* Pattern matching operators and openers .
*
* @ type { RegExp }
* /
PATTERN = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/ ;
/ * *
* Given a C expression , returns the equivalent postfix ( Reverse Polish )
* notation terms as an array .
*
* If a postfix string is desired , simply ` .join( ' ' ) ` the result .
*
* @ example
*
* ` ` ` js
* import postfix from '@tannin/postfix' ;
*
* postfix ( 'n > 1' ) ;
* // ⇒ [ 'n', '1', '>' ]
* ` ` `
*
* @ param { string } expression C expression .
*
* @ return { string [ ] } Postfix terms .
* /
function postfix ( expression ) {
var terms = [ ] ,
stack = [ ] ,
match , operator , term , element ;
while ( ( match = expression . match ( PATTERN ) ) ) {
operator = match [ 0 ] ;
// Term is the string preceding the operator match. It may contain
// whitespace, and may be empty (if operator is at beginning).
term = expression . substr ( 0 , match . index ) . trim ( ) ;
if ( term ) {
terms . push ( term ) ;
}
while ( ( element = stack . pop ( ) ) ) {
if ( TERMINATORS [ operator ] ) {
if ( TERMINATORS [ operator ] [ 0 ] === element ) {
// Substitution works here under assumption that because
// the assigned operator will no longer be a terminator, it
// will be pushed to the stack during the condition below.
operator = TERMINATORS [ operator ] [ 1 ] || operator ;
break ;
}
} else if ( OPENERS . indexOf ( element ) >= 0 || PRECEDENCE [ element ] < PRECEDENCE [ operator ] ) {
// Push to stack if either an opener or when pop reveals an
// element of lower precedence.
stack . push ( element ) ;
break ;
}
// For each popped from stack, push to terms.
terms . push ( element ) ;
}
if ( ! TERMINATORS [ operator ] ) {
stack . push ( operator ) ;
}
// Slice matched fragment from expression to continue match.
expression = expression . substr ( match . index + operator . length ) ;
}
// Push remainder of operand, if exists, to terms.
expression = expression . trim ( ) ;
if ( expression ) {
terms . push ( expression ) ;
}
// Pop remaining items from stack into terms.
return terms . concat ( stack . reverse ( ) ) ;
}
// CONCATENATED MODULE: ./node_modules/@tannin/evaluate/index.js
/ * *
* Operator callback functions .
*
* @ type { Object }
* /
var OPERATORS = {
'!' : function ( a ) {
return ! a ;
} ,
'*' : function ( a , b ) {
return a * b ;
} ,
'/' : function ( a , b ) {
return a / b ;
} ,
'%' : function ( a , b ) {
return a % b ;
} ,
'+' : function ( a , b ) {
return a + b ;
} ,
'-' : function ( a , b ) {
return a - b ;
} ,
'<' : function ( a , b ) {
return a < b ;
} ,
'<=' : function ( a , b ) {
return a <= b ;
} ,
'>' : function ( a , b ) {
return a > b ;
} ,
'>=' : function ( a , b ) {
return a >= b ;
} ,
'==' : function ( a , b ) {
return a === b ;
} ,
'!=' : function ( a , b ) {
return a !== b ;
} ,
'&&' : function ( a , b ) {
return a && b ;
} ,
'||' : function ( a , b ) {
return a || b ;
} ,
'?:' : function ( a , b , c ) {
if ( a ) {
throw b ;
}
return c ;
} ,
} ;
/ * *
* Given an array of postfix terms and operand variables , returns the result of
* the postfix evaluation .
*
* @ example
*
* ` ` ` js
* import evaluate from '@tannin/evaluate' ;
*
* // 3 + 4 * 5 / 6 ⇒ '3 4 5 * 6 / +'
* const terms = [ '3' , '4' , '5' , '*' , '6' , '/' , '+' ] ;
*
* evaluate ( terms , { } ) ;
* // ⇒ 6.333333333333334
* ` ` `
*
* @ param { string [ ] } postfix Postfix terms .
* @ param { Object } variables Operand variables .
*
* @ return { * } Result of evaluation .
* /
function evaluate _evaluate ( postfix , variables ) {
var stack = [ ] ,
i , j , args , getOperatorResult , term , value ;
for ( i = 0 ; i < postfix . length ; i ++ ) {
term = postfix [ i ] ;
getOperatorResult = OPERATORS [ term ] ;
if ( getOperatorResult ) {
// Pop from stack by number of function arguments.
j = getOperatorResult . length ;
args = Array ( j ) ;
while ( j -- ) {
args [ j ] = stack . pop ( ) ;
}
try {
value = getOperatorResult . apply ( null , args ) ;
} catch ( earlyReturn ) {
return earlyReturn ;
}
} else if ( variables . hasOwnProperty ( term ) ) {
value = variables [ term ] ;
} else {
value = + term ;
}
stack . push ( value ) ;
}
return stack [ 0 ] ;
}
// CONCATENATED MODULE: ./node_modules/@tannin/compile/index.js
/ * *
* Given a C expression , returns a function which can be called to evaluate its
* result .
*
* @ example
*
* ` ` ` js
* import compile from '@tannin/compile' ;
*
* const evaluate = compile ( 'n > 1' ) ;
*
* evaluate ( { n : 2 } ) ;
* // ⇒ true
* ` ` `
*
* @ param { string } expression C expression .
*
2020-05-06 17:23:38 +02:00
* @ return { ( variables ? : { [ variable : string ] : * } ) => * } Compiled evaluator .
2019-11-02 10:38:58 +01:00
* /
function compile ( expression ) {
var terms = postfix ( expression ) ;
return function ( variables ) {
return evaluate _evaluate ( terms , variables ) ;
} ;
}
// CONCATENATED MODULE: ./node_modules/@tannin/plural-forms/index.js
/ * *
* Given a C expression , returns a function which , when called with a value ,
* evaluates the result with the value assumed to be the "n" variable of the
* expression . The result will be coerced to its numeric equivalent .
*
* @ param { string } expression C expression .
*
* @ return { Function } Evaluator function .
* /
function pluralForms ( expression ) {
var evaluate = compile ( expression ) ;
return function ( n ) {
return + evaluate ( { n : n } ) ;
} ;
}
// CONCATENATED MODULE: ./node_modules/tannin/index.js
/ * *
* Tannin constructor options .
*
2020-05-06 17:23:38 +02:00
* @ typedef { Object } TanninOptions
2019-11-02 10:38:58 +01:00
*
2020-05-06 17:23:38 +02:00
* @ property { string } [ contextDelimiter ] Joiner in string lookup with context .
* @ property { Function } [ onMissingKey ] Callback to invoke when key missing .
* /
/ * *
* Domain metadata .
*
* @ typedef { Object } TanninDomainMetadata
*
* @ property { string } [ domain ] Domain name .
* @ property { string } [ lang ] Language code .
* @ property { ( string | Function ) } [ plural _forms ] Plural forms expression or
* function evaluator .
* /
/ * *
* Domain translation pair respectively representing the singular and plural
* translation .
2019-11-02 10:38:58 +01:00
*
2020-05-06 17:23:38 +02:00
* @ typedef { [ string , string ] } TanninTranslation
* /
/ * *
* Locale data domain . The key is used as reference for lookup , the value an
* array of two string entries respectively representing the singular and plural
* translation .
*
* @ typedef { { [ key : string ] : TanninDomainMetadata | TanninTranslation , '' : TanninDomainMetadata | TanninTranslation } } TanninLocaleDomain
* /
/ * *
* Jed - formatted locale data .
*
* @ see http : //messageformat.github.io/Jed/
*
* @ typedef { { [ domain : string ] : TanninLocaleDomain } } TanninLocaleData
2019-11-02 10:38:58 +01:00
* /
/ * *
* Default Tannin constructor options .
*
* @ type { TanninOptions }
* /
var DEFAULT _OPTIONS = {
contextDelimiter : '\u0004' ,
onMissingKey : null ,
} ;
/ * *
* Given a specific locale data ' s config ` plural_forms ` value , returns the
* expression .
*
* @ example
*
* ` ` `
* getPluralExpression ( 'nplurals=2; plural=(n != 1);' ) === '(n != 1)'
* ` ` `
*
* @ param { string } pf Locale data plural forms .
*
* @ return { string } Plural forms expression .
* /
function getPluralExpression ( pf ) {
var parts , i , part ;
parts = pf . split ( ';' ) ;
for ( i = 0 ; i < parts . length ; i ++ ) {
part = parts [ i ] . trim ( ) ;
if ( part . indexOf ( 'plural=' ) === 0 ) {
return part . substr ( 7 ) ;
}
}
}
/ * *
* Tannin constructor .
*
2020-05-06 17:23:38 +02:00
* @ class
*
* @ param { TanninLocaleData } data Jed - formatted locale data .
* @ param { TanninOptions } [ options ] Tannin options .
2019-11-02 10:38:58 +01:00
* /
function Tannin ( data , options ) {
var key ;
2020-05-06 17:23:38 +02:00
/ * *
* Jed - formatted locale data .
*
* @ name Tannin # data
* @ type { TanninLocaleData }
* /
2019-11-02 10:38:58 +01:00
this . data = data ;
2020-05-06 17:23:38 +02:00
/ * *
* Plural forms function cache , keyed by plural forms string .
*
* @ name Tannin # pluralForms
* @ type { Object < string , Function > }
* /
2019-11-02 10:38:58 +01:00
this . pluralForms = { } ;
2020-05-06 17:23:38 +02:00
/ * *
* Effective options for instance , including defaults .
*
* @ name Tannin # options
* @ type { TanninOptions }
* /
2019-11-02 10:38:58 +01:00
this . options = { } ;
2020-05-06 17:23:38 +02:00
2019-11-02 10:38:58 +01:00
for ( key in DEFAULT _OPTIONS ) {
2020-05-06 17:23:38 +02:00
this . options [ key ] = options !== undefined && key in options
? options [ key ]
: DEFAULT _OPTIONS [ key ] ;
2019-11-02 10:38:58 +01:00
}
}
/ * *
* Returns the plural form index for the given domain and value .
*
* @ param { string } domain Domain on which to calculate plural form .
* @ param { number } n Value for which plural form is to be calculated .
*
* @ return { number } Plural form index .
* /
Tannin . prototype . getPluralForm = function ( domain , n ) {
var getPluralForm = this . pluralForms [ domain ] ,
config , plural , pf ;
if ( ! getPluralForm ) {
config = this . data [ domain ] [ '' ] ;
pf = (
config [ 'Plural-Forms' ] ||
config [ 'plural-forms' ] ||
2020-05-06 17:23:38 +02:00
// Ignore reason: As known, there's no way to document the empty
// string property on a key to guarantee this as metadata.
// @ts-ignore
2019-11-02 10:38:58 +01:00
config . plural _forms
) ;
if ( typeof pf !== 'function' ) {
plural = getPluralExpression (
config [ 'Plural-Forms' ] ||
config [ 'plural-forms' ] ||
2020-05-06 17:23:38 +02:00
// Ignore reason: As known, there's no way to document the empty
// string property on a key to guarantee this as metadata.
// @ts-ignore
2019-11-02 10:38:58 +01:00
config . plural _forms
) ;
pf = pluralForms ( plural ) ;
}
getPluralForm = this . pluralForms [ domain ] = pf ;
}
return getPluralForm ( n ) ;
} ;
/ * *
* Translate a string .
*
2020-05-06 17:23:38 +02:00
* @ param { string } domain Translation domain .
* @ param { string | void } context Context distinguishing terms of the same name .
* @ param { string } singular Primary key for translation lookup .
* @ param { string = } plural Fallback value used for non - zero plural
* form index .
* @ param { number = } n Value to use in calculating plural form .
2019-11-02 10:38:58 +01:00
*
* @ return { string } Translated string .
* /
Tannin . prototype . dcnpgettext = function ( domain , context , singular , plural , n ) {
var index , key , entry ;
if ( n === undefined ) {
// Default to singular.
index = 0 ;
} else {
// Find index by evaluating plural form for value.
index = this . getPluralForm ( domain , n ) ;
}
key = singular ;
// If provided, context is prepended to key with delimiter.
if ( context ) {
key = context + this . options . contextDelimiter + singular ;
}
entry = this . data [ domain ] [ key ] ;
// Verify not only that entry exists, but that the intended index is within
// range and non-empty.
if ( entry && entry [ index ] ) {
return entry [ index ] ;
}
if ( this . options . onMissingKey ) {
this . options . onMissingKey ( singular , domain ) ;
}
// If entry not found, fall back to singular vs. plural with zero index
// representing the singular value.
return index === 0 ? singular : plural ;
} ;
2020-09-15 14:29:22 +02:00
// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/create-i18n.js
2019-11-02 10:38:58 +01:00
2020-05-06 17:23:38 +02:00
function ownKeys ( object , enumerableOnly ) { var keys = Object . keys ( object ) ; if ( Object . getOwnPropertySymbols ) { var symbols = Object . getOwnPropertySymbols ( object ) ; if ( enumerableOnly ) symbols = symbols . filter ( function ( sym ) { return Object . getOwnPropertyDescriptor ( object , sym ) . enumerable ; } ) ; keys . push . apply ( keys , symbols ) ; } return keys ; }
function _objectSpread ( target ) { for ( var i = 1 ; i < arguments . length ; i ++ ) { var source = arguments [ i ] != null ? arguments [ i ] : { } ; if ( i % 2 ) { ownKeys ( Object ( source ) , true ) . forEach ( function ( key ) { Object ( defineProperty [ "a" /* default */ ] ) ( target , key , source [ key ] ) ; } ) ; } else if ( Object . getOwnPropertyDescriptors ) { Object . defineProperties ( target , Object . getOwnPropertyDescriptors ( source ) ) ; } else { ownKeys ( Object ( source ) ) . forEach ( function ( key ) { Object . defineProperty ( target , key , Object . getOwnPropertyDescriptor ( source , key ) ) ; } ) ; } } return target ; }
2019-11-02 10:38:58 +01:00
/ * *
* External dependencies
* /
2020-05-06 17:23:38 +02:00
/ * *
2020-09-15 14:29:22 +02:00
* @ typedef { Record < string , any > } LocaleData
2020-05-06 17:23:38 +02:00
* /
2019-11-02 10:38:58 +01:00
/ * *
* Default locale data to use for Tannin domain when not otherwise provided .
* Assumes an English plural forms expression .
*
2020-05-06 17:23:38 +02:00
* @ type { LocaleData }
2019-11-02 10:38:58 +01:00
* /
var DEFAULT _LOCALE _DATA = {
'' : {
2020-09-15 14:29:22 +02:00
/** @param {number} n */
2019-11-15 22:59:44 +01:00
plural _forms : function plural _forms ( n ) {
return n === 1 ? 0 : 1 ;
}
2019-11-02 10:38:58 +01:00
}
} ;
/ * *
2020-09-15 14:29:22 +02:00
* An i18n instance
*
* @ typedef { Object } I18n
* @ property { Function } setLocaleData Merges locale data into the Tannin instance by domain . Accepts data in a
* Jed - formatted JSON object shape .
* @ property { Function } _ _ Retrieve the translation of text .
* @ property { Function } _x Retrieve translated string with gettext context .
* @ property { Function } _n Translates and retrieves the singular or plural form based on the supplied
* number .
* @ property { Function } _nx Translates and retrieves the singular or plural form based on the supplied
* number , with gettext context .
* @ property { Function } isRTL Check if current locale is RTL .
* /
/ * *
* Create an i18n instance
2019-11-02 10:38:58 +01:00
*
2020-09-15 14:29:22 +02:00
* @ param { LocaleData } [ initialData ] Locale data configuration .
* @ param { string } [ initialDomain ] Domain for which configuration applies .
* @ return { I18n } I18n instance
2019-11-02 10:38:58 +01:00
* /
2020-09-15 14:29:22 +02:00
var create _i18n _createI18n = function createI18n ( initialData , initialDomain ) {
/ * *
* The underlying instance of Tannin to which exported functions interface .
*
* @ type { Tannin }
* /
var tannin = new Tannin ( { } ) ;
/ * *
* Merges locale data into the Tannin instance by domain . Accepts data in a
* Jed - formatted JSON object shape .
*
* @ see http : //messageformat.github.io/Jed/
*
* @ param { LocaleData } [ data ] Locale data configuration .
* @ param { string } [ domain ] Domain for which configuration applies .
* /
var setLocaleData = function setLocaleData ( data ) {
var domain = arguments . length > 1 && arguments [ 1 ] !== undefined ? arguments [ 1 ] : 'default' ;
2020-12-10 14:06:04 +01:00
tannin . data [ domain ] = _objectSpread ( _objectSpread ( _objectSpread ( { } , DEFAULT _LOCALE _DATA ) , tannin . data [ domain ] ) , data ) ; // Populate default domain configuration (supported locale date which omits
2020-09-15 14:29:22 +02:00
// a plural forms expression).
2020-12-10 14:06:04 +01:00
tannin . data [ domain ] [ '' ] = _objectSpread ( _objectSpread ( { } , DEFAULT _LOCALE _DATA [ '' ] ) , tannin . data [ domain ] [ '' ] ) ;
2020-09-15 14:29:22 +02:00
} ;
/ * *
* Wrapper for Tannin ' s ` dcnpgettext ` . Populates default locale data if not
* otherwise previously assigned .
*
* @ param { string | undefined } domain Domain to retrieve the translated text .
* @ param { string | undefined } context Context information for the translators .
* @ param { string } single Text to translate if non - plural . Used as
* fallback return value on a caught error .
* @ param { string } [ plural ] The text to be used if the number is
* plural .
* @ param { number } [ number ] The number to compare against to use
* either the singular or plural form .
*
* @ return { string } The translated string .
* /
var dcnpgettext = function dcnpgettext ( ) {
var domain = arguments . length > 0 && arguments [ 0 ] !== undefined ? arguments [ 0 ] : 'default' ;
var context = arguments . length > 1 ? arguments [ 1 ] : undefined ;
var single = arguments . length > 2 ? arguments [ 2 ] : undefined ;
var plural = arguments . length > 3 ? arguments [ 3 ] : undefined ;
var number = arguments . length > 4 ? arguments [ 4 ] : undefined ;
if ( ! tannin . data [ domain ] ) {
setLocaleData ( undefined , domain ) ;
}
return tannin . dcnpgettext ( domain , context , single , plural , number ) ;
} ;
/ * *
* Retrieve the translation of text .
*
* @ see https : //developer.wordpress.org/reference/functions/__/
*
* @ param { string } text Text to translate .
* @ param { string } [ domain ] Domain to retrieve the translated text .
*
* @ return { string } Translated text .
* /
var _ _ = function _ _ ( text , domain ) {
return dcnpgettext ( domain , undefined , text ) ;
} ;
/ * *
* Retrieve translated string with gettext context .
*
* @ see https : //developer.wordpress.org/reference/functions/_x/
*
* @ param { string } text Text to translate .
* @ param { string } context Context information for the translators .
* @ param { string } [ domain ] Domain to retrieve the translated text .
*
* @ return { string } Translated context string without pipe .
* /
var _x = function _x ( text , context , domain ) {
return dcnpgettext ( domain , context , text ) ;
} ;
/ * *
* Translates and retrieves the singular or plural form based on the supplied
* number .
*
* @ see https : //developer.wordpress.org/reference/functions/_n/
*
* @ param { string } single The text to be used if the number is singular .
* @ param { string } plural The text to be used if the number is plural .
* @ param { number } number The number to compare against to use either the
* singular or plural form .
* @ param { string } [ domain ] Domain to retrieve the translated text .
*
* @ return { string } The translated singular or plural form .
* /
var _n = function _n ( single , plural , number , domain ) {
return dcnpgettext ( domain , undefined , single , plural , number ) ;
} ;
/ * *
* Translates and retrieves the singular or plural form based on the supplied
* number , with gettext context .
*
* @ see https : //developer.wordpress.org/reference/functions/_nx/
*
* @ param { string } single The text to be used if the number is singular .
* @ param { string } plural The text to be used if the number is plural .
* @ param { number } number The number to compare against to use either the
* singular or plural form .
* @ param { string } context Context information for the translators .
* @ param { string } [ domain ] Domain to retrieve the translated text .
*
* @ return { string } The translated singular or plural form .
* /
var _nx = function _nx ( single , plural , number , context , domain ) {
return dcnpgettext ( domain , context , single , plural , number ) ;
} ;
/ * *
* Check if current locale is RTL .
*
* * * RTL ( Right To Left ) * * is a locale property indicating that text is written from right to left .
* For example , the ` he ` locale ( for Hebrew ) specifies right - to - left . Arabic ( ar ) is another common
* language written RTL . The opposite of RTL , LTR ( Left To Right ) is used in other languages ,
* including English ( ` en ` , ` en-US ` , ` en-GB ` , etc . ) , Spanish ( ` es ` ) , and French ( ` fr ` ) .
*
* @ return { boolean } Whether locale is RTL .
* /
var isRTL = function isRTL ( ) {
return 'rtl' === _x ( 'ltr' , 'text direction' ) ;
} ;
if ( initialData ) {
setLocaleData ( initialData , initialDomain ) ;
}
return {
setLocaleData : setLocaleData ,
_ _ : _ _ ,
_x : _x ,
_n : _n ,
_nx : _nx ,
isRTL : isRTL
} ;
} ;
2019-11-02 10:38:58 +01:00
2020-09-15 14:29:22 +02:00
// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/default-i18n.js
2019-11-02 10:38:58 +01:00
/ * *
2020-09-15 14:29:22 +02:00
* Internal dependencies
* /
var i18n = create _i18n _createI18n ( ) ;
/ *
* Comments in this file are duplicated from . / i18n due to
* https : //github.com/WordPress/gutenberg/pull/20318#issuecomment-590837722
* /
/ * *
* @ typedef { import ( './create-i18n' ) . LocaleData } LocaleData
2019-11-02 10:38:58 +01:00
* /
/ * *
* Merges locale data into the Tannin instance by domain . Accepts data in a
* Jed - formatted JSON object shape .
*
* @ see http : //messageformat.github.io/Jed/
*
2020-05-06 17:23:38 +02:00
* @ param { LocaleData } [ data ] Locale data configuration .
* @ param { string } [ domain ] Domain for which configuration applies .
2019-11-02 10:38:58 +01:00
* /
2020-09-15 14:29:22 +02:00
var default _i18n _setLocaleData = i18n . setLocaleData . bind ( i18n ) ;
2019-11-02 10:38:58 +01:00
/ * *
* Retrieve the translation of text .
*
* @ see https : //developer.wordpress.org/reference/functions/__/
*
2020-05-06 17:23:38 +02:00
* @ param { string } text Text to translate .
* @ param { string } [ domain ] Domain to retrieve the translated text .
2019-11-02 10:38:58 +01:00
*
* @ return { string } Translated text .
* /
2020-09-15 14:29:22 +02:00
var default _i18n _ = i18n . _ _ . bind ( i18n ) ;
2019-11-02 10:38:58 +01:00
/ * *
* Retrieve translated string with gettext context .
*
* @ see https : //developer.wordpress.org/reference/functions/_x/
*
2020-05-06 17:23:38 +02:00
* @ param { string } text Text to translate .
* @ param { string } context Context information for the translators .
* @ param { string } [ domain ] Domain to retrieve the translated text .
2019-11-02 10:38:58 +01:00
*
* @ return { string } Translated context string without pipe .
* /
2020-09-15 14:29:22 +02:00
var default _i18n _x = i18n . _x . bind ( i18n ) ;
2019-11-02 10:38:58 +01:00
/ * *
* Translates and retrieves the singular or plural form based on the supplied
* number .
*
* @ see https : //developer.wordpress.org/reference/functions/_n/
*
2020-05-06 17:23:38 +02:00
* @ param { string } single The text to be used if the number is singular .
* @ param { string } plural The text to be used if the number is plural .
* @ param { number } number The number to compare against to use either the
* singular or plural form .
* @ param { string } [ domain ] Domain to retrieve the translated text .
2019-11-02 10:38:58 +01:00
*
* @ return { string } The translated singular or plural form .
* /
2020-09-15 14:29:22 +02:00
var default _i18n _n = i18n . _n . bind ( i18n ) ;
2019-11-02 10:38:58 +01:00
/ * *
* Translates and retrieves the singular or plural form based on the supplied
* number , with gettext context .
*
* @ see https : //developer.wordpress.org/reference/functions/_nx/
*
2020-05-06 17:23:38 +02:00
* @ param { string } single The text to be used if the number is singular .
* @ param { string } plural The text to be used if the number is plural .
* @ param { number } number The number to compare against to use either the
2019-11-02 10:38:58 +01:00
* singular or plural form .
2020-05-06 17:23:38 +02:00
* @ param { string } context Context information for the translators .
* @ param { string } [ domain ] Domain to retrieve the translated text .
2019-11-02 10:38:58 +01:00
*
* @ return { string } The translated singular or plural form .
* /
2020-09-15 14:29:22 +02:00
var default _i18n _nx = i18n . _nx . bind ( i18n ) ;
2019-11-02 10:38:58 +01:00
/ * *
2020-09-15 14:29:22 +02:00
* Check if current locale is RTL .
2019-11-02 10:38:58 +01:00
*
2020-09-15 14:29:22 +02:00
* * * RTL ( Right To Left ) * * is a locale property indicating that text is written from right to left .
* For example , the ` he ` locale ( for Hebrew ) specifies right - to - left . Arabic ( ar ) is another common
* language written RTL . The opposite of RTL , LTR ( Left To Right ) is used in other languages ,
* including English ( ` en ` , ` en-US ` , ` en-GB ` , etc . ) , Spanish ( ` es ` ) , and French ( ` fr ` ) .
2019-11-02 10:38:58 +01:00
*
2020-09-15 14:29:22 +02:00
* @ return { boolean } Whether locale is RTL .
2019-11-02 10:38:58 +01:00
* /
2020-09-15 14:29:22 +02:00
var default _i18n _isRTL = i18n . isRTL . bind ( i18n ) ;
2019-11-02 10:38:58 +01:00
2020-09-15 14:29:22 +02:00
// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/index.js
/***/ } ) ,
/***/ 5 :
/***/ ( function ( module , _ _webpack _exports _ _ , _ _webpack _require _ _ ) {
"use strict" ;
/* harmony export (binding) */ _ _webpack _require _ _ . d ( _ _webpack _exports _ _ , "a" , function ( ) { return _defineProperty ; } ) ;
function _defineProperty ( obj , key , value ) {
if ( key in obj ) {
Object . defineProperty ( obj , key , {
value : value ,
enumerable : true ,
configurable : true ,
writable : true
} ) ;
} else {
obj [ key ] = value ;
2019-11-02 10:38:58 +01:00
}
2020-09-15 14:29:22 +02:00
return obj ;
}
2019-11-02 10:38:58 +01:00
/***/ } ) ,
2020-09-15 14:29:22 +02:00
/***/ 60 :
2019-11-02 10:38:58 +01:00
/***/ ( function ( module , exports , _ _webpack _require _ _ ) {
2020-05-06 17:23:38 +02:00
/ * *
* Memize options object .
*
* @ typedef MemizeOptions
*
* @ property { number } [ maxSize ] Maximum size of the cache .
* /
2019-11-02 10:38:58 +01:00
2020-05-06 17:23:38 +02:00
/ * *
* 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 || { } ;
2019-11-02 10:38:58 +01:00
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.
2020-05-06 17:23:38 +02:00
/** @type {MemizeCacheNode} */ ( node . prev ) . next = node . next ;
2019-11-02 10:38:58 +01:00
if ( node . next ) {
node . next . prev = node . prev ;
}
node . next = head ;
node . prev = null ;
2020-05-06 17:23:38 +02:00
/** @type {MemizeCacheNode} */ ( head ) . prev = node ;
2019-11-02 10:38:58 +01:00
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
2020-05-06 17:23:38 +02:00
val : fn . apply ( null , args ) ,
2019-11-02 10:38:58 +01:00
} ;
// 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
2020-05-06 17:23:38 +02:00
if ( size === /** @type {MemizeOptions} */ ( options ) . maxSize ) {
tail = /** @type {MemizeCacheNode} */ ( tail ) . prev ;
/** @type {MemizeCacheNode} */ ( tail ) . next = null ;
2019-11-02 10:38:58 +01:00
} else {
size ++ ;
}
head = node ;
return node . val ;
}
memoized . clear = function ( ) {
head = null ;
tail = null ;
size = 0 ;
} ;
if ( false ) { }
2020-05-06 17:23:38 +02:00
// 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
2019-11-02 10:38:58 +01:00
return memoized ;
2020-05-06 17:23:38 +02:00
}
module . exports = memize ;
2019-11-02 10:38:58 +01:00
/***/ } )
/******/ } ) ;
