| @@ -1 +1,600 @@ | ||
| 1 | -this.wp=this.wp||{},this.wp.shortcode=function(t){var e={};function n(r){if(e[r])return e[r].exports;var i=e[r]={i:r,l:!1,exports:{}};return t[r].call(i.exports,i,i.exports,n),i.l=!0,i.exports}return n.m=t,n.c=e,n.d=function(t,e,r){n.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:r})},n.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n.t=function(t,e){if(1&e&&(t=n(t)),8&e)return t;if(4&e&&"object"==typeof t&&t&&t.__esModule)return t;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var i in t)n.d(r,i,function(e){return t[e]}.bind(null,i));return r},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=344)}({2:function(t,e){!function(){t.exports=this.lodash}()},344:function(t,e,n){"use strict";n.r(e),n.d(e,"next",(function(){return u})),n.d(e,"replace",(function(){return o})),n.d(e,"string",(function(){return c})),n.d(e,"regexp",(function(){return s})),n.d(e,"attrs",(function(){return a})),n.d(e,"fromMatch",(function(){return f}));var r=n(2),i=n(45);function u(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:0,r=s(t);r.lastIndex=n;var i=r.exec(e);if(i){if("["===i[1]&&"]"===i[7])return u(t,e,r.lastIndex);var o={index:i.index,content:i[0],shortcode:f(i)};return i[1]&&(o.content=o.content.slice(1),o.index++),i[7]&&(o.content=o.content.slice(0,-1)),o}}function o(t,e,n){return e.replace(s(t),(function(t,e,r,i,u,o,c,s){if("["===e&&"]"===s)return t;var a=n(f(arguments));return a?e+a+s:t}))}function c(t){return new l(t).string()}function s(t){return new RegExp("\\[(\\[?)("+t+")(?![\\w-])([^\\]\\/]*(?:\\/(?!\\])[^\\]\\/]*)*?)(?:(\\/)\\]|\\](?:([^\\[]*(?:\\[(?!\\/\\2\\])[^\\[]*)*)(\\[\\/\\2\\]))?)(\\]?)","g")}var a=n.n(i)()((function(t){var e,n={},r=[],i=/([\w-]+)\s*=\s*"([^"]*)"(?:\s|$)|([\w-]+)\s*=\s*'([^']*)'(?:\s|$)|([\w-]+)\s*=\s*([^\s'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|'([^']*)'(?:\s|$)|(\S+)(?:\s|$)/g;for(t=t.replace(/[\u00a0\u200b]/g," ");e=i.exec(t);)e[1]?n[e[1].toLowerCase()]=e[2]:e[3]?n[e[3].toLowerCase()]=e[4]:e[5]?n[e[5].toLowerCase()]=e[6]:e[7]?r.push(e[7]):e[8]?r.push(e[8]):e[9]&&r.push(e[9]);return{named:n,numeric:r}}));function f(t){var e;return e=t[4]?"self-closing":t[6]?"closed":"single",new l({tag:t[2],attrs:t[3],type:e,content:t[5]})}var l=Object(r.extend)((function(t){var e=this;Object(r.extend)(this,Object(r.pick)(t||{},"tag","attrs","type","content"));var n=this.attrs;this.attrs={named:{},numeric:[]},n&&(Object(r.isString)(n)?this.attrs=a(n):Object(r.isEqual)(Object.keys(n),["named","numeric"])?this.attrs=n:Object(r.forEach)(n,(function(t,n){e.set(n,t)})))}),{next:u,replace:o,string:c,regexp:s,attrs:a,fromMatch:f});Object(r.extend)(l.prototype,{get:function(t){return this.attrs[Object(r.isNumber)(t)?"numeric":"named"][t]},set:function(t,e){return this.attrs[Object(r.isNumber)(t)?"numeric":"named"][t]=e,this},string:function(){var t="["+this.tag;return Object(r.forEach)(this.attrs.numeric,(function(e){/\s/.test(e)?t+=' "'+e+'"':t+=" "+e})),Object(r.forEach)(this.attrs.named,(function(e,n){t+=" "+n+'="'+e+'"'})),"single"===this.type?t+"]":"self-closing"===this.type?t+" /]":(t+="]",this.content&&(t+=this.content),t+"[/"+this.tag+"]")}}),e.default=l},45:function(t,e,n){t.exports=function(t,e){var n,r,i,u=0;function o(){var e,o,c=r,s=arguments.length;t:for(;c;){if(c.args.length===arguments.length){for(o=0;o<s;o++)if(c.args[o]!==arguments[o]){c=c.next;continue t}return c!==r&&(c===i&&(i=c.prev),c.prev.next=c.next,c.next&&(c.next.prev=c.prev),c.next=r,c.prev=null,r.prev=c,r=c),c.val}c=c.next}for(e=new Array(s),o=0;o<s;o++)e[o]=arguments[o];return c={args:e,val:t.apply(null,e)},r?(r.prev=c,c.next=r):i=c,u===n?(i=i.prev).next=null:u++,r=c,c.val}return e&&e.maxSize&&(n=e.maxSize),o.clear=function(){r=null,i=null,u=0},o}}}).default; | |
| 1 | +/******/ (function() { // webpackBootstrap | |
| 2 | +/******/ var __webpack_modules__ = ({ | |
| 3 | + | |
| 4 | +/***/ 9588: | |
| 5 | +/***/ (function(module) { | |
| 6 | + | |
| 7 | +/** | |
| 8 | + * Memize options object. | |
| 9 | + * | |
| 10 | + * @typedef MemizeOptions | |
| 11 | + * | |
| 12 | + * @property {number} [maxSize] Maximum size of the cache. | |
| 13 | + */ | |
| 14 | + | |
| 15 | +/** | |
| 16 | + * Internal cache entry. | |
| 17 | + * | |
| 18 | + * @typedef MemizeCacheNode | |
| 19 | + * | |
| 20 | + * @property {?MemizeCacheNode|undefined} [prev] Previous node. | |
| 21 | + * @property {?MemizeCacheNode|undefined} [next] Next node. | |
| 22 | + * @property {Array<*>} args Function arguments for cache | |
| 23 | + * entry. | |
| 24 | + * @property {*} val Function result. | |
| 25 | + */ | |
| 26 | + | |
| 27 | +/** | |
| 28 | + * Properties of the enhanced function for controlling cache. | |
| 29 | + * | |
| 30 | + * @typedef MemizeMemoizedFunction | |
| 31 | + * | |
| 32 | + * @property {()=>void} clear Clear the cache. | |
| 33 | + */ | |
| 34 | + | |
| 35 | +/** | |
| 36 | + * Accepts a function to be memoized, and returns a new memoized function, with | |
| 37 | + * optional options. | |
| 38 | + * | |
| 39 | + * @template {Function} F | |
| 40 | + * | |
| 41 | + * @param {F} fn Function to memoize. | |
| 42 | + * @param {MemizeOptions} [options] Options object. | |
| 43 | + * | |
| 44 | + * @return {F & MemizeMemoizedFunction} Memoized function. | |
| 45 | + */ | |
| 46 | +function memize( fn, options ) { | |
| 47 | + var size = 0; | |
| 48 | + | |
| 49 | + /** @type {?MemizeCacheNode|undefined} */ | |
| 50 | + var head; | |
| 51 | + | |
| 52 | + /** @type {?MemizeCacheNode|undefined} */ | |
| 53 | + var tail; | |
| 54 | + | |
| 55 | + options = options || {}; | |
| 56 | + | |
| 57 | + function memoized( /* ...args */ ) { | |
| 58 | + var node = head, | |
| 59 | + len = arguments.length, | |
| 60 | + args, i; | |
| 61 | + | |
| 62 | + searchCache: while ( node ) { | |
| 63 | + // Perform a shallow equality test to confirm that whether the node | |
| 64 | + // under test is a candidate for the arguments passed. Two arrays | |
| 65 | + // are shallowly equal if their length matches and each entry is | |
| 66 | + // strictly equal between the two sets. Avoid abstracting to a | |
| 67 | + // function which could incur an arguments leaking deoptimization. | |
| 68 | + | |
| 69 | + // Check whether node arguments match arguments length | |
| 70 | + if ( node.args.length !== arguments.length ) { | |
| 71 | + node = node.next; | |
| 72 | + continue; | |
| 73 | + } | |
| 74 | + | |
| 75 | + // Check whether node arguments match arguments values | |
| 76 | + for ( i = 0; i < len; i++ ) { | |
| 77 | + if ( node.args[ i ] !== arguments[ i ] ) { | |
| 78 | + node = node.next; | |
| 79 | + continue searchCache; | |
| 80 | + } | |
| 81 | + } | |
| 82 | + | |
| 83 | + // At this point we can assume we've found a match | |
| 84 | + | |
| 85 | + // Surface matched node to head if not already | |
| 86 | + if ( node !== head ) { | |
| 87 | + // As tail, shift to previous. Must only shift if not also | |
| 88 | + // head, since if both head and tail, there is no previous. | |
| 89 | + if ( node === tail ) { | |
| 90 | + tail = node.prev; | |
| 91 | + } | |
| 92 | + | |
| 93 | + // Adjust siblings to point to each other. If node was tail, | |
| 94 | + // this also handles new tail's empty `next` assignment. | |
| 95 | + /** @type {MemizeCacheNode} */ ( node.prev ).next = node.next; | |
| 96 | + if ( node.next ) { | |
| 97 | + node.next.prev = node.prev; | |
| 98 | + } | |
| 99 | + | |
| 100 | + node.next = head; | |
| 101 | + node.prev = null; | |
| 102 | + /** @type {MemizeCacheNode} */ ( head ).prev = node; | |
| 103 | + head = node; | |
| 104 | + } | |
| 105 | + | |
| 106 | + // Return immediately | |
| 107 | + return node.val; | |
| 108 | + } | |
| 109 | + | |
| 110 | + // No cached value found. Continue to insertion phase: | |
| 111 | + | |
| 112 | + // Create a copy of arguments (avoid leaking deoptimization) | |
| 113 | + args = new Array( len ); | |
| 114 | + for ( i = 0; i < len; i++ ) { | |
| 115 | + args[ i ] = arguments[ i ]; | |
| 116 | + } | |
| 117 | + | |
| 118 | + node = { | |
| 119 | + args: args, | |
| 120 | + | |
| 121 | + // Generate the result from original function | |
| 122 | + val: fn.apply( null, args ), | |
| 123 | + }; | |
| 124 | + | |
| 125 | + // Don't need to check whether node is already head, since it would | |
| 126 | + // have been returned above already if it was | |
| 127 | + | |
| 128 | + // Shift existing head down list | |
| 129 | + if ( head ) { | |
| 130 | + head.prev = node; | |
| 131 | + node.next = head; | |
| 132 | + } else { | |
| 133 | + // If no head, follows that there's no tail (at initial or reset) | |
| 134 | + tail = node; | |
| 135 | + } | |
| 136 | + | |
| 137 | + // Trim tail if we're reached max size and are pending cache insertion | |
| 138 | + if ( size === /** @type {MemizeOptions} */ ( options ).maxSize ) { | |
| 139 | + tail = /** @type {MemizeCacheNode} */ ( tail ).prev; | |
| 140 | + /** @type {MemizeCacheNode} */ ( tail ).next = null; | |
| 141 | + } else { | |
| 142 | + size++; | |
| 143 | + } | |
| 144 | + | |
| 145 | + head = node; | |
| 146 | + | |
| 147 | + return node.val; | |
| 148 | + } | |
| 149 | + | |
| 150 | + memoized.clear = function() { | |
| 151 | + head = null; | |
| 152 | + tail = null; | |
| 153 | + size = 0; | |
| 154 | + }; | |
| 155 | + | |
| 156 | + if ( false ) {} | |
| 157 | + | |
| 158 | + // Ignore reason: There's not a clear solution to create an intersection of | |
| 159 | + // the function with additional properties, where the goal is to retain the | |
| 160 | + // function signature of the incoming argument and add control properties | |
| 161 | + // on the return value. | |
| 162 | + | |
| 163 | + // @ts-ignore | |
| 164 | + return memoized; | |
| 165 | +} | |
| 166 | + | |
| 167 | +module.exports = memize; | |
| 168 | + | |
| 169 | + | |
| 170 | +/***/ }) | |
| 171 | + | |
| 172 | +/******/ }); | |
| 173 | +/************************************************************************/ | |
| 174 | +/******/ // The module cache | |
| 175 | +/******/ var __webpack_module_cache__ = {}; | |
| 176 | +/******/ | |
| 177 | +/******/ // The require function | |
| 178 | +/******/ function __webpack_require__(moduleId) { | |
| 179 | +/******/ // Check if module is in cache | |
| 180 | +/******/ var cachedModule = __webpack_module_cache__[moduleId]; | |
| 181 | +/******/ if (cachedModule !== undefined) { | |
| 182 | +/******/ return cachedModule.exports; | |
| 183 | +/******/ } | |
| 184 | +/******/ // Create a new module (and put it into the cache) | |
| 185 | +/******/ var module = __webpack_module_cache__[moduleId] = { | |
| 186 | +/******/ // no module.id needed | |
| 187 | +/******/ // no module.loaded needed | |
| 188 | +/******/ exports: {} | |
| 189 | +/******/ }; | |
| 190 | +/******/ | |
| 191 | +/******/ // Execute the module function | |
| 192 | +/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); | |
| 193 | +/******/ | |
| 194 | +/******/ // Return the exports of the module | |
| 195 | +/******/ return module.exports; | |
| 196 | +/******/ } | |
| 197 | +/******/ | |
| 198 | +/************************************************************************/ | |
| 199 | +/******/ /* webpack/runtime/compat get default export */ | |
| 200 | +/******/ !function() { | |
| 201 | +/******/ // getDefaultExport function for compatibility with non-harmony modules | |
| 202 | +/******/ __webpack_require__.n = function(module) { | |
| 203 | +/******/ var getter = module && module.__esModule ? | |
| 204 | +/******/ function() { return module['default']; } : | |
| 205 | +/******/ function() { return module; }; | |
| 206 | +/******/ __webpack_require__.d(getter, { a: getter }); | |
| 207 | +/******/ return getter; | |
| 208 | +/******/ }; | |
| 209 | +/******/ }(); | |
| 210 | +/******/ | |
| 211 | +/******/ /* webpack/runtime/define property getters */ | |
| 212 | +/******/ !function() { | |
| 213 | +/******/ // define getter functions for harmony exports | |
| 214 | +/******/ __webpack_require__.d = function(exports, definition) { | |
| 215 | +/******/ for(var key in definition) { | |
| 216 | +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { | |
| 217 | +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); | |
| 218 | +/******/ } | |
| 219 | +/******/ } | |
| 220 | +/******/ }; | |
| 221 | +/******/ }(); | |
| 222 | +/******/ | |
| 223 | +/******/ /* webpack/runtime/hasOwnProperty shorthand */ | |
| 224 | +/******/ !function() { | |
| 225 | +/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } | |
| 226 | +/******/ }(); | |
| 227 | +/******/ | |
| 228 | +/************************************************************************/ | |
| 229 | +var __webpack_exports__ = {}; | |
| 230 | +// This entry need to be wrapped in an IIFE because it need to be in strict mode. | |
| 231 | +!function() { | |
| 232 | +"use strict"; | |
| 233 | + | |
| 234 | +// EXPORTS | |
| 235 | +__webpack_require__.d(__webpack_exports__, { | |
| 236 | + "default": function() { return /* binding */ build_module; } | |
| 237 | +}); | |
| 238 | + | |
| 239 | +// UNUSED EXPORTS: attrs, fromMatch, next, regexp, replace, string | |
| 240 | + | |
| 241 | +;// CONCATENATED MODULE: external "lodash" | |
| 242 | +var external_lodash_namespaceObject = window["lodash"]; | |
| 243 | +// EXTERNAL MODULE: ./node_modules/memize/index.js | |
| 244 | +var memize = __webpack_require__(9588); | |
| 245 | +var memize_default = /*#__PURE__*/__webpack_require__.n(memize); | |
| 246 | +;// CONCATENATED MODULE: ./packages/shortcode/build-module/index.js | |
| 247 | +/** | |
| 248 | + * External dependencies | |
| 249 | + */ | |
| 250 | + | |
| 251 | + | |
| 252 | +/** | |
| 253 | + * Shortcode attributes object. | |
| 254 | + * | |
| 255 | + * @typedef {Object} WPShortcodeAttrs | |
| 256 | + * | |
| 257 | + * @property {Object} named Object with named attributes. | |
| 258 | + * @property {Array} numeric Array with numeric attributes. | |
| 259 | + */ | |
| 260 | + | |
| 261 | +/** | |
| 262 | + * Shortcode object. | |
| 263 | + * | |
| 264 | + * @typedef {Object} WPShortcode | |
| 265 | + * | |
| 266 | + * @property {string} tag Shortcode tag. | |
| 267 | + * @property {WPShortcodeAttrs} attrs Shortcode attributes. | |
| 268 | + * @property {string} content Shortcode content. | |
| 269 | + * @property {string} type Shortcode type: `self-closing`, | |
| 270 | + * `closed`, or `single`. | |
| 271 | + */ | |
| 272 | + | |
| 273 | +/** | |
| 274 | + * @typedef {Object} WPShortcodeMatch | |
| 275 | + * | |
| 276 | + * @property {number} index Index the shortcode is found at. | |
| 277 | + * @property {string} content Matched content. | |
| 278 | + * @property {WPShortcode} shortcode Shortcode instance of the match. | |
| 279 | + */ | |
| 280 | + | |
| 281 | +/** | |
| 282 | + * Find the next matching shortcode. | |
| 283 | + * | |
| 284 | + * @param {string} tag Shortcode tag. | |
| 285 | + * @param {string} text Text to search. | |
| 286 | + * @param {number} index Index to start search from. | |
| 287 | + * | |
| 288 | + * @return {?WPShortcodeMatch} Matched information. | |
| 289 | + */ | |
| 290 | + | |
| 291 | +function next(tag, text) { | |
| 292 | + let index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; | |
| 293 | + const re = regexp(tag); | |
| 294 | + re.lastIndex = index; | |
| 295 | + const match = re.exec(text); | |
| 296 | + | |
| 297 | + if (!match) { | |
| 298 | + return; | |
| 299 | + } // If we matched an escaped shortcode, try again. | |
| 300 | + | |
| 301 | + | |
| 302 | + if ('[' === match[1] && ']' === match[7]) { | |
| 303 | + return next(tag, text, re.lastIndex); | |
| 304 | + } | |
| 305 | + | |
| 306 | + const result = { | |
| 307 | + index: match.index, | |
| 308 | + content: match[0], | |
| 309 | + shortcode: fromMatch(match) | |
| 310 | + }; // If we matched a leading `[`, strip it from the match and increment the | |
| 311 | + // index accordingly. | |
| 312 | + | |
| 313 | + if (match[1]) { | |
| 314 | + result.content = result.content.slice(1); | |
| 315 | + result.index++; | |
| 316 | + } // If we matched a trailing `]`, strip it from the match. | |
| 317 | + | |
| 318 | + | |
| 319 | + if (match[7]) { | |
| 320 | + result.content = result.content.slice(0, -1); | |
| 321 | + } | |
| 322 | + | |
| 323 | + return result; | |
| 324 | +} | |
| 325 | +/** | |
| 326 | + * Replace matching shortcodes in a block of text. | |
| 327 | + * | |
| 328 | + * @param {string} tag Shortcode tag. | |
| 329 | + * @param {string} text Text to search. | |
| 330 | + * @param {Function} callback Function to process the match and return | |
| 331 | + * replacement string. | |
| 332 | + * | |
| 333 | + * @return {string} Text with shortcodes replaced. | |
| 334 | + */ | |
| 335 | + | |
| 336 | +function replace(tag, text, callback) { | |
| 337 | + return text.replace(regexp(tag), function (match, left, $3, attrs, slash, content, closing, right) { | |
| 338 | + // If both extra brackets exist, the shortcode has been properly | |
| 339 | + // escaped. | |
| 340 | + if (left === '[' && right === ']') { | |
| 341 | + return match; | |
| 342 | + } // Create the match object and pass it through the callback. | |
| 343 | + | |
| 344 | + | |
| 345 | + const result = callback(fromMatch(arguments)); // Make sure to return any of the extra brackets if they weren't used to | |
| 346 | + // escape the shortcode. | |
| 347 | + | |
| 348 | + return result || result === '' ? left + result + right : match; | |
| 349 | + }); | |
| 350 | +} | |
| 351 | +/** | |
| 352 | + * Generate a string from shortcode parameters. | |
| 353 | + * | |
| 354 | + * Creates a shortcode instance and returns a string. | |
| 355 | + * | |
| 356 | + * Accepts the same `options` as the `shortcode()` constructor, containing a | |
| 357 | + * `tag` string, a string or object of `attrs`, a boolean indicating whether to | |
| 358 | + * format the shortcode using a `single` tag, and a `content` string. | |
| 359 | + * | |
| 360 | + * @param {Object} options | |
| 361 | + * | |
| 362 | + * @return {string} String representation of the shortcode. | |
| 363 | + */ | |
| 364 | + | |
| 365 | +function string(options) { | |
| 366 | + return new shortcode(options).string(); | |
| 367 | +} | |
| 368 | +/** | |
| 369 | + * Generate a RegExp to identify a shortcode. | |
| 370 | + * | |
| 371 | + * The base regex is functionally equivalent to the one found in | |
| 372 | + * `get_shortcode_regex()` in `wp-includes/shortcodes.php`. | |
| 373 | + * | |
| 374 | + * Capture groups: | |
| 375 | + * | |
| 376 | + * 1. An extra `[` to allow for escaping shortcodes with double `[[]]` | |
| 377 | + * 2. The shortcode name | |
| 378 | + * 3. The shortcode argument list | |
| 379 | + * 4. The self closing `/` | |
| 380 | + * 5. The content of a shortcode when it wraps some content. | |
| 381 | + * 6. The closing tag. | |
| 382 | + * 7. An extra `]` to allow for escaping shortcodes with double `[[]]` | |
| 383 | + * | |
| 384 | + * @param {string} tag Shortcode tag. | |
| 385 | + * | |
| 386 | + * @return {RegExp} Shortcode RegExp. | |
| 387 | + */ | |
| 388 | + | |
| 389 | +function regexp(tag) { | |
| 390 | + return new RegExp('\\[(\\[?)(' + tag + ')(?![\\w-])([^\\]\\/]*(?:\\/(?!\\])[^\\]\\/]*)*?)(?:(\\/)\\]|\\](?:([^\\[]*(?:\\[(?!\\/\\2\\])[^\\[]*)*)(\\[\\/\\2\\]))?)(\\]?)', 'g'); | |
| 391 | +} | |
| 392 | +/** | |
| 393 | + * Parse shortcode attributes. | |
| 394 | + * | |
| 395 | + * Shortcodes accept many types of attributes. These can chiefly be divided into | |
| 396 | + * named and numeric attributes: | |
| 397 | + * | |
| 398 | + * Named attributes are assigned on a key/value basis, while numeric attributes | |
| 399 | + * are treated as an array. | |
| 400 | + * | |
| 401 | + * Named attributes can be formatted as either `name="value"`, `name='value'`, | |
| 402 | + * or `name=value`. Numeric attributes can be formatted as `"value"` or just | |
| 403 | + * `value`. | |
| 404 | + * | |
| 405 | + * @param {string} text Serialised shortcode attributes. | |
| 406 | + * | |
| 407 | + * @return {WPShortcodeAttrs} Parsed shortcode attributes. | |
| 408 | + */ | |
| 409 | + | |
| 410 | +const attrs = memize_default()(text => { | |
| 411 | + const named = {}; | |
| 412 | + const numeric = []; // This regular expression is reused from `shortcode_parse_atts()` in | |
| 413 | + // `wp-includes/shortcodes.php`. | |
| 414 | + // | |
| 415 | + // Capture groups: | |
| 416 | + // | |
| 417 | + // 1. An attribute name, that corresponds to... | |
| 418 | + // 2. a value in double quotes. | |
| 419 | + // 3. An attribute name, that corresponds to... | |
| 420 | + // 4. a value in single quotes. | |
| 421 | + // 5. An attribute name, that corresponds to... | |
| 422 | + // 6. an unquoted value. | |
| 423 | + // 7. A numeric attribute in double quotes. | |
| 424 | + // 8. A numeric attribute in single quotes. | |
| 425 | + // 9. An unquoted numeric attribute. | |
| 426 | + | |
| 427 | + 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. | |
| 428 | + | |
| 429 | + text = text.replace(/[\u00a0\u200b]/g, ' '); | |
| 430 | + let match; // Match and normalize attributes. | |
| 431 | + | |
| 432 | + while (match = pattern.exec(text)) { | |
| 433 | + if (match[1]) { | |
| 434 | + named[match[1].toLowerCase()] = match[2]; | |
| 435 | + } else if (match[3]) { | |
| 436 | + named[match[3].toLowerCase()] = match[4]; | |
| 437 | + } else if (match[5]) { | |
| 438 | + named[match[5].toLowerCase()] = match[6]; | |
| 439 | + } else if (match[7]) { | |
| 440 | + numeric.push(match[7]); | |
| 441 | + } else if (match[8]) { | |
| 442 | + numeric.push(match[8]); | |
| 443 | + } else if (match[9]) { | |
| 444 | + numeric.push(match[9]); | |
| 445 | + } | |
| 446 | + } | |
| 447 | + | |
| 448 | + return { | |
| 449 | + named, | |
| 450 | + numeric | |
| 451 | + }; | |
| 452 | +}); | |
| 453 | +/** | |
| 454 | + * Generate a Shortcode Object from a RegExp match. | |
| 455 | + * | |
| 456 | + * Accepts a `match` object from calling `regexp.exec()` on a `RegExp` generated | |
| 457 | + * by `regexp()`. `match` can also be set to the `arguments` from a callback | |
| 458 | + * passed to `regexp.replace()`. | |
| 459 | + * | |
| 460 | + * @param {Array} match Match array. | |
| 461 | + * | |
| 462 | + * @return {WPShortcode} Shortcode instance. | |
| 463 | + */ | |
| 464 | + | |
| 465 | +function fromMatch(match) { | |
| 466 | + let type; | |
| 467 | + | |
| 468 | + if (match[4]) { | |
| 469 | + type = 'self-closing'; | |
| 470 | + } else if (match[6]) { | |
| 471 | + type = 'closed'; | |
| 472 | + } else { | |
| 473 | + type = 'single'; | |
| 474 | + } | |
| 475 | + | |
| 476 | + return new shortcode({ | |
| 477 | + tag: match[2], | |
| 478 | + attrs: match[3], | |
| 479 | + type, | |
| 480 | + content: match[5] | |
| 481 | + }); | |
| 482 | +} | |
| 483 | +/** | |
| 484 | + * Creates a shortcode instance. | |
| 485 | + * | |
| 486 | + * To access a raw representation of a shortcode, pass an `options` object, | |
| 487 | + * containing a `tag` string, a string or object of `attrs`, a string indicating | |
| 488 | + * the `type` of the shortcode ('single', 'self-closing', or 'closed'), and a | |
| 489 | + * `content` string. | |
| 490 | + * | |
| 491 | + * @param {Object} options Options as described. | |
| 492 | + * | |
| 493 | + * @return {WPShortcode} Shortcode instance. | |
| 494 | + */ | |
| 495 | + | |
| 496 | +const shortcode = (0,external_lodash_namespaceObject.extend)(function (options) { | |
| 497 | + (0,external_lodash_namespaceObject.extend)(this, (0,external_lodash_namespaceObject.pick)(options || {}, 'tag', 'attrs', 'type', 'content')); | |
| 498 | + const attributes = this.attrs; // Ensure we have a correctly formatted `attrs` object. | |
| 499 | + | |
| 500 | + this.attrs = { | |
| 501 | + named: {}, | |
| 502 | + numeric: [] | |
| 503 | + }; | |
| 504 | + | |
| 505 | + if (!attributes) { | |
| 506 | + return; | |
| 507 | + } // Parse a string of attributes. | |
| 508 | + | |
| 509 | + | |
| 510 | + if ((0,external_lodash_namespaceObject.isString)(attributes)) { | |
| 511 | + this.attrs = attrs(attributes); // Identify a correctly formatted `attrs` object. | |
| 512 | + } else if ((0,external_lodash_namespaceObject.isEqual)(Object.keys(attributes), ['named', 'numeric'])) { | |
| 513 | + this.attrs = attributes; // Handle a flat object of attributes. | |
| 514 | + } else { | |
| 515 | + (0,external_lodash_namespaceObject.forEach)(attributes, (value, key) => { | |
| 516 | + this.set(key, value); | |
| 517 | + }); | |
| 518 | + } | |
| 519 | +}, { | |
| 520 | + next, | |
| 521 | + replace, | |
| 522 | + string, | |
| 523 | + regexp, | |
| 524 | + attrs, | |
| 525 | + fromMatch | |
| 526 | +}); | |
| 527 | +(0,external_lodash_namespaceObject.extend)(shortcode.prototype, { | |
| 528 | + /** | |
| 529 | + * Get a shortcode attribute. | |
| 530 | + * | |
| 531 | + * Automatically detects whether `attr` is named or numeric and routes it | |
| 532 | + * accordingly. | |
| 533 | + * | |
| 534 | + * @param {(number|string)} attr Attribute key. | |
| 535 | + * | |
| 536 | + * @return {string} Attribute value. | |
| 537 | + */ | |
| 538 | + get(attr) { | |
| 539 | + return this.attrs[(0,external_lodash_namespaceObject.isNumber)(attr) ? 'numeric' : 'named'][attr]; | |
| 540 | + }, | |
| 541 | + | |
| 542 | + /** | |
| 543 | + * Set a shortcode attribute. | |
| 544 | + * | |
| 545 | + * Automatically detects whether `attr` is named or numeric and routes it | |
| 546 | + * accordingly. | |
| 547 | + * | |
| 548 | + * @param {(number|string)} attr Attribute key. | |
| 549 | + * @param {string} value Attribute value. | |
| 550 | + * | |
| 551 | + * @return {WPShortcode} Shortcode instance. | |
| 552 | + */ | |
| 553 | + set(attr, value) { | |
| 554 | + this.attrs[(0,external_lodash_namespaceObject.isNumber)(attr) ? 'numeric' : 'named'][attr] = value; | |
| 555 | + return this; | |
| 556 | + }, | |
| 557 | + | |
| 558 | + /** | |
| 559 | + * Transform the shortcode into a string. | |
| 560 | + * | |
| 561 | + * @return {string} String representation of the shortcode. | |
| 562 | + */ | |
| 563 | + string() { | |
| 564 | + let text = '[' + this.tag; | |
| 565 | + (0,external_lodash_namespaceObject.forEach)(this.attrs.numeric, value => { | |
| 566 | + if (/\s/.test(value)) { | |
| 567 | + text += ' "' + value + '"'; | |
| 568 | + } else { | |
| 569 | + text += ' ' + value; | |
| 570 | + } | |
| 571 | + }); | |
| 572 | + (0,external_lodash_namespaceObject.forEach)(this.attrs.named, (value, name) => { | |
| 573 | + text += ' ' + name + '="' + value + '"'; | |
| 574 | + }); // If the tag is marked as `single` or `self-closing`, close the tag and | |
| 575 | + // ignore any additional content. | |
| 576 | + | |
| 577 | + if ('single' === this.type) { | |
| 578 | + return text + ']'; | |
| 579 | + } else if ('self-closing' === this.type) { | |
| 580 | + return text + ' /]'; | |
| 581 | + } // Complete the opening tag. | |
| 582 | + | |
| 583 | + | |
| 584 | + text += ']'; | |
| 585 | + | |
| 586 | + if (this.content) { | |
| 587 | + text += this.content; | |
| 588 | + } // Add the closing tag. | |
| 589 | + | |
| 590 | + | |
| 591 | + return text + '[/' + this.tag + ']'; | |
| 592 | + } | |
| 593 | + | |
| 594 | +}); | |
| 595 | +/* harmony default export */ var build_module = (shortcode); | |
| 596 | +//# sourceMappingURL=index.js.map | |
| 597 | +}(); | |
| 598 | +(window.wp = window.wp || {}).shortcode = __webpack_exports__.default; | |
| 599 | +/******/ })() | |
| 600 | +; | |
