[Summary view] [Print] [Text view]

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