[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> blocks.js (source)

   1  /******/ (function() { // webpackBootstrap
   2  /******/     var __webpack_modules__ = ({
   3  
   4  /***/ 9756:
   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  /***/ 7308:
 173  /***/ (function(module, exports, __webpack_require__) {
 174  
 175  var __WEBPACK_AMD_DEFINE_RESULT__;;/*! showdown v 1.9.1 - 02-11-2019 */
 176  (function(){
 177  /**
 178   * Created by Tivie on 13-07-2015.
 179   */
 180  
 181  function getDefaultOpts (simple) {
 182    'use strict';
 183  
 184    var defaultOptions = {
 185      omitExtraWLInCodeBlocks: {
 186        defaultValue: false,
 187        describe: 'Omit the default extra whiteline added to code blocks',
 188        type: 'boolean'
 189      },
 190      noHeaderId: {
 191        defaultValue: false,
 192        describe: 'Turn on/off generated header id',
 193        type: 'boolean'
 194      },
 195      prefixHeaderId: {
 196        defaultValue: false,
 197        describe: 'Add a prefix to the generated header ids. Passing a string will prefix that string to the header id. Setting to true will add a generic \'section-\' prefix',
 198        type: 'string'
 199      },
 200      rawPrefixHeaderId: {
 201        defaultValue: false,
 202        describe: 'Setting this option to true will prevent showdown from modifying the prefix. This might result in malformed IDs (if, for instance, the " char is used in the prefix)',
 203        type: 'boolean'
 204      },
 205      ghCompatibleHeaderId: {
 206        defaultValue: false,
 207        describe: 'Generate header ids compatible with github style (spaces are replaced with dashes, a bunch of non alphanumeric chars are removed)',
 208        type: 'boolean'
 209      },
 210      rawHeaderId: {
 211        defaultValue: false,
 212        describe: 'Remove only spaces, \' and " from generated header ids (including prefixes), replacing them with dashes (-). WARNING: This might result in malformed ids',
 213        type: 'boolean'
 214      },
 215      headerLevelStart: {
 216        defaultValue: false,
 217        describe: 'The header blocks level start',
 218        type: 'integer'
 219      },
 220      parseImgDimensions: {
 221        defaultValue: false,
 222        describe: 'Turn on/off image dimension parsing',
 223        type: 'boolean'
 224      },
 225      simplifiedAutoLink: {
 226        defaultValue: false,
 227        describe: 'Turn on/off GFM autolink style',
 228        type: 'boolean'
 229      },
 230      excludeTrailingPunctuationFromURLs: {
 231        defaultValue: false,
 232        describe: 'Excludes trailing punctuation from links generated with autoLinking',
 233        type: 'boolean'
 234      },
 235      literalMidWordUnderscores: {
 236        defaultValue: false,
 237        describe: 'Parse midword underscores as literal underscores',
 238        type: 'boolean'
 239      },
 240      literalMidWordAsterisks: {
 241        defaultValue: false,
 242        describe: 'Parse midword asterisks as literal asterisks',
 243        type: 'boolean'
 244      },
 245      strikethrough: {
 246        defaultValue: false,
 247        describe: 'Turn on/off strikethrough support',
 248        type: 'boolean'
 249      },
 250      tables: {
 251        defaultValue: false,
 252        describe: 'Turn on/off tables support',
 253        type: 'boolean'
 254      },
 255      tablesHeaderId: {
 256        defaultValue: false,
 257        describe: 'Add an id to table headers',
 258        type: 'boolean'
 259      },
 260      ghCodeBlocks: {
 261        defaultValue: true,
 262        describe: 'Turn on/off GFM fenced code blocks support',
 263        type: 'boolean'
 264      },
 265      tasklists: {
 266        defaultValue: false,
 267        describe: 'Turn on/off GFM tasklist support',
 268        type: 'boolean'
 269      },
 270      smoothLivePreview: {
 271        defaultValue: false,
 272        describe: 'Prevents weird effects in live previews due to incomplete input',
 273        type: 'boolean'
 274      },
 275      smartIndentationFix: {
 276        defaultValue: false,
 277        description: 'Tries to smartly fix indentation in es6 strings',
 278        type: 'boolean'
 279      },
 280      disableForced4SpacesIndentedSublists: {
 281        defaultValue: false,
 282        description: 'Disables the requirement of indenting nested sublists by 4 spaces',
 283        type: 'boolean'
 284      },
 285      simpleLineBreaks: {
 286        defaultValue: false,
 287        description: 'Parses simple line breaks as <br> (GFM Style)',
 288        type: 'boolean'
 289      },
 290      requireSpaceBeforeHeadingText: {
 291        defaultValue: false,
 292        description: 'Makes adding a space between `#` and the header text mandatory (GFM Style)',
 293        type: 'boolean'
 294      },
 295      ghMentions: {
 296        defaultValue: false,
 297        description: 'Enables github @mentions',
 298        type: 'boolean'
 299      },
 300      ghMentionsLink: {
 301        defaultValue: 'https://github.com/{u}',
 302        description: 'Changes the link generated by @mentions. Only applies if ghMentions option is enabled.',
 303        type: 'string'
 304      },
 305      encodeEmails: {
 306        defaultValue: true,
 307        description: 'Encode e-mail addresses through the use of Character Entities, transforming ASCII e-mail addresses into its equivalent decimal entities',
 308        type: 'boolean'
 309      },
 310      openLinksInNewWindow: {
 311        defaultValue: false,
 312        description: 'Open all links in new windows',
 313        type: 'boolean'
 314      },
 315      backslashEscapesHTMLTags: {
 316        defaultValue: false,
 317        description: 'Support for HTML Tag escaping. ex: \<div>foo\</div>',
 318        type: 'boolean'
 319      },
 320      emoji: {
 321        defaultValue: false,
 322        description: 'Enable emoji support. Ex: `this is a :smile: emoji`',
 323        type: 'boolean'
 324      },
 325      underline: {
 326        defaultValue: false,
 327        description: 'Enable support for underline. Syntax is double or triple underscores: `__underline word__`. With this option enabled, underscores no longer parses into `<em>` and `<strong>`',
 328        type: 'boolean'
 329      },
 330      completeHTMLDocument: {
 331        defaultValue: false,
 332        description: 'Outputs a complete html document, including `<html>`, `<head>` and `<body>` tags',
 333        type: 'boolean'
 334      },
 335      metadata: {
 336        defaultValue: false,
 337        description: 'Enable support for document metadata (defined at the top of the document between `«««` and `»»»` or between `---` and `---`).',
 338        type: 'boolean'
 339      },
 340      splitAdjacentBlockquotes: {
 341        defaultValue: false,
 342        description: 'Split adjacent blockquote blocks',
 343        type: 'boolean'
 344      }
 345    };
 346    if (simple === false) {
 347      return JSON.parse(JSON.stringify(defaultOptions));
 348    }
 349    var ret = {};
 350    for (var opt in defaultOptions) {
 351      if (defaultOptions.hasOwnProperty(opt)) {
 352        ret[opt] = defaultOptions[opt].defaultValue;
 353      }
 354    }
 355    return ret;
 356  }
 357  
 358  function allOptionsOn () {
 359    'use strict';
 360    var options = getDefaultOpts(true),
 361        ret = {};
 362    for (var opt in options) {
 363      if (options.hasOwnProperty(opt)) {
 364        ret[opt] = true;
 365      }
 366    }
 367    return ret;
 368  }
 369  
 370  /**
 371   * Created by Tivie on 06-01-2015.
 372   */
 373  
 374  // Private properties
 375  var showdown = {},
 376      parsers = {},
 377      extensions = {},
 378      globalOptions = getDefaultOpts(true),
 379      setFlavor = 'vanilla',
 380      flavor = {
 381        github: {
 382          omitExtraWLInCodeBlocks:              true,
 383          simplifiedAutoLink:                   true,
 384          excludeTrailingPunctuationFromURLs:   true,
 385          literalMidWordUnderscores:            true,
 386          strikethrough:                        true,
 387          tables:                               true,
 388          tablesHeaderId:                       true,
 389          ghCodeBlocks:                         true,
 390          tasklists:                            true,
 391          disableForced4SpacesIndentedSublists: true,
 392          simpleLineBreaks:                     true,
 393          requireSpaceBeforeHeadingText:        true,
 394          ghCompatibleHeaderId:                 true,
 395          ghMentions:                           true,
 396          backslashEscapesHTMLTags:             true,
 397          emoji:                                true,
 398          splitAdjacentBlockquotes:             true
 399        },
 400        original: {
 401          noHeaderId:                           true,
 402          ghCodeBlocks:                         false
 403        },
 404        ghost: {
 405          omitExtraWLInCodeBlocks:              true,
 406          parseImgDimensions:                   true,
 407          simplifiedAutoLink:                   true,
 408          excludeTrailingPunctuationFromURLs:   true,
 409          literalMidWordUnderscores:            true,
 410          strikethrough:                        true,
 411          tables:                               true,
 412          tablesHeaderId:                       true,
 413          ghCodeBlocks:                         true,
 414          tasklists:                            true,
 415          smoothLivePreview:                    true,
 416          simpleLineBreaks:                     true,
 417          requireSpaceBeforeHeadingText:        true,
 418          ghMentions:                           false,
 419          encodeEmails:                         true
 420        },
 421        vanilla: getDefaultOpts(true),
 422        allOn: allOptionsOn()
 423      };
 424  
 425  /**
 426   * helper namespace
 427   * @type {{}}
 428   */
 429  showdown.helper = {};
 430  
 431  /**
 432   * TODO LEGACY SUPPORT CODE
 433   * @type {{}}
 434   */
 435  showdown.extensions = {};
 436  
 437  /**
 438   * Set a global option
 439   * @static
 440   * @param {string} key
 441   * @param {*} value
 442   * @returns {showdown}
 443   */
 444  showdown.setOption = function (key, value) {
 445    'use strict';
 446    globalOptions[key] = value;
 447    return this;
 448  };
 449  
 450  /**
 451   * Get a global option
 452   * @static
 453   * @param {string} key
 454   * @returns {*}
 455   */
 456  showdown.getOption = function (key) {
 457    'use strict';
 458    return globalOptions[key];
 459  };
 460  
 461  /**
 462   * Get the global options
 463   * @static
 464   * @returns {{}}
 465   */
 466  showdown.getOptions = function () {
 467    'use strict';
 468    return globalOptions;
 469  };
 470  
 471  /**
 472   * Reset global options to the default values
 473   * @static
 474   */
 475  showdown.resetOptions = function () {
 476    'use strict';
 477    globalOptions = getDefaultOpts(true);
 478  };
 479  
 480  /**
 481   * Set the flavor showdown should use as default
 482   * @param {string} name
 483   */
 484  showdown.setFlavor = function (name) {
 485    'use strict';
 486    if (!flavor.hasOwnProperty(name)) {
 487      throw Error(name + ' flavor was not found');
 488    }
 489    showdown.resetOptions();
 490    var preset = flavor[name];
 491    setFlavor = name;
 492    for (var option in preset) {
 493      if (preset.hasOwnProperty(option)) {
 494        globalOptions[option] = preset[option];
 495      }
 496    }
 497  };
 498  
 499  /**
 500   * Get the currently set flavor
 501   * @returns {string}
 502   */
 503  showdown.getFlavor = function () {
 504    'use strict';
 505    return setFlavor;
 506  };
 507  
 508  /**
 509   * Get the options of a specified flavor. Returns undefined if the flavor was not found
 510   * @param {string} name Name of the flavor
 511   * @returns {{}|undefined}
 512   */
 513  showdown.getFlavorOptions = function (name) {
 514    'use strict';
 515    if (flavor.hasOwnProperty(name)) {
 516      return flavor[name];
 517    }
 518  };
 519  
 520  /**
 521   * Get the default options
 522   * @static
 523   * @param {boolean} [simple=true]
 524   * @returns {{}}
 525   */
 526  showdown.getDefaultOptions = function (simple) {
 527    'use strict';
 528    return getDefaultOpts(simple);
 529  };
 530  
 531  /**
 532   * Get or set a subParser
 533   *
 534   * subParser(name)       - Get a registered subParser
 535   * subParser(name, func) - Register a subParser
 536   * @static
 537   * @param {string} name
 538   * @param {function} [func]
 539   * @returns {*}
 540   */
 541  showdown.subParser = function (name, func) {
 542    'use strict';
 543    if (showdown.helper.isString(name)) {
 544      if (typeof func !== 'undefined') {
 545        parsers[name] = func;
 546      } else {
 547        if (parsers.hasOwnProperty(name)) {
 548          return parsers[name];
 549        } else {
 550          throw Error('SubParser named ' + name + ' not registered!');
 551        }
 552      }
 553    }
 554  };
 555  
 556  /**
 557   * Gets or registers an extension
 558   * @static
 559   * @param {string} name
 560   * @param {object|function=} ext
 561   * @returns {*}
 562   */
 563  showdown.extension = function (name, ext) {
 564    'use strict';
 565  
 566    if (!showdown.helper.isString(name)) {
 567      throw Error('Extension \'name\' must be a string');
 568    }
 569  
 570    name = showdown.helper.stdExtName(name);
 571  
 572    // Getter
 573    if (showdown.helper.isUndefined(ext)) {
 574      if (!extensions.hasOwnProperty(name)) {
 575        throw Error('Extension named ' + name + ' is not registered!');
 576      }
 577      return extensions[name];
 578  
 579      // Setter
 580    } else {
 581      // Expand extension if it's wrapped in a function
 582      if (typeof ext === 'function') {
 583        ext = ext();
 584      }
 585  
 586      // Ensure extension is an array
 587      if (!showdown.helper.isArray(ext)) {
 588        ext = [ext];
 589      }
 590  
 591      var validExtension = validate(ext, name);
 592  
 593      if (validExtension.valid) {
 594        extensions[name] = ext;
 595      } else {
 596        throw Error(validExtension.error);
 597      }
 598    }
 599  };
 600  
 601  /**
 602   * Gets all extensions registered
 603   * @returns {{}}
 604   */
 605  showdown.getAllExtensions = function () {
 606    'use strict';
 607    return extensions;
 608  };
 609  
 610  /**
 611   * Remove an extension
 612   * @param {string} name
 613   */
 614  showdown.removeExtension = function (name) {
 615    'use strict';
 616    delete extensions[name];
 617  };
 618  
 619  /**
 620   * Removes all extensions
 621   */
 622  showdown.resetExtensions = function () {
 623    'use strict';
 624    extensions = {};
 625  };
 626  
 627  /**
 628   * Validate extension
 629   * @param {array} extension
 630   * @param {string} name
 631   * @returns {{valid: boolean, error: string}}
 632   */
 633  function validate (extension, name) {
 634    'use strict';
 635  
 636    var errMsg = (name) ? 'Error in ' + name + ' extension->' : 'Error in unnamed extension',
 637        ret = {
 638          valid: true,
 639          error: ''
 640        };
 641  
 642    if (!showdown.helper.isArray(extension)) {
 643      extension = [extension];
 644    }
 645  
 646    for (var i = 0; i < extension.length; ++i) {
 647      var baseMsg = errMsg + ' sub-extension ' + i + ': ',
 648          ext = extension[i];
 649      if (typeof ext !== 'object') {
 650        ret.valid = false;
 651        ret.error = baseMsg + 'must be an object, but ' + typeof ext + ' given';
 652        return ret;
 653      }
 654  
 655      if (!showdown.helper.isString(ext.type)) {
 656        ret.valid = false;
 657        ret.error = baseMsg + 'property "type" must be a string, but ' + typeof ext.type + ' given';
 658        return ret;
 659      }
 660  
 661      var type = ext.type = ext.type.toLowerCase();
 662  
 663      // normalize extension type
 664      if (type === 'language') {
 665        type = ext.type = 'lang';
 666      }
 667  
 668      if (type === 'html') {
 669        type = ext.type = 'output';
 670      }
 671  
 672      if (type !== 'lang' && type !== 'output' && type !== 'listener') {
 673        ret.valid = false;
 674        ret.error = baseMsg + 'type ' + type + ' is not recognized. Valid values: "lang/language", "output/html" or "listener"';
 675        return ret;
 676      }
 677  
 678      if (type === 'listener') {
 679        if (showdown.helper.isUndefined(ext.listeners)) {
 680          ret.valid = false;
 681          ret.error = baseMsg + '. Extensions of type "listener" must have a property called "listeners"';
 682          return ret;
 683        }
 684      } else {
 685        if (showdown.helper.isUndefined(ext.filter) && showdown.helper.isUndefined(ext.regex)) {
 686          ret.valid = false;
 687          ret.error = baseMsg + type + ' extensions must define either a "regex" property or a "filter" method';
 688          return ret;
 689        }
 690      }
 691  
 692      if (ext.listeners) {
 693        if (typeof ext.listeners !== 'object') {
 694          ret.valid = false;
 695          ret.error = baseMsg + '"listeners" property must be an object but ' + typeof ext.listeners + ' given';
 696          return ret;
 697        }
 698        for (var ln in ext.listeners) {
 699          if (ext.listeners.hasOwnProperty(ln)) {
 700            if (typeof ext.listeners[ln] !== 'function') {
 701              ret.valid = false;
 702              ret.error = baseMsg + '"listeners" property must be an hash of [event name]: [callback]. listeners.' + ln +
 703                ' must be a function but ' + typeof ext.listeners[ln] + ' given';
 704              return ret;
 705            }
 706          }
 707        }
 708      }
 709  
 710      if (ext.filter) {
 711        if (typeof ext.filter !== 'function') {
 712          ret.valid = false;
 713          ret.error = baseMsg + '"filter" must be a function, but ' + typeof ext.filter + ' given';
 714          return ret;
 715        }
 716      } else if (ext.regex) {
 717        if (showdown.helper.isString(ext.regex)) {
 718          ext.regex = new RegExp(ext.regex, 'g');
 719        }
 720        if (!(ext.regex instanceof RegExp)) {
 721          ret.valid = false;
 722          ret.error = baseMsg + '"regex" property must either be a string or a RegExp object, but ' + typeof ext.regex + ' given';
 723          return ret;
 724        }
 725        if (showdown.helper.isUndefined(ext.replace)) {
 726          ret.valid = false;
 727          ret.error = baseMsg + '"regex" extensions must implement a replace string or function';
 728          return ret;
 729        }
 730      }
 731    }
 732    return ret;
 733  }
 734  
 735  /**
 736   * Validate extension
 737   * @param {object} ext
 738   * @returns {boolean}
 739   */
 740  showdown.validateExtension = function (ext) {
 741    'use strict';
 742  
 743    var validateExtension = validate(ext, null);
 744    if (!validateExtension.valid) {
 745      console.warn(validateExtension.error);
 746      return false;
 747    }
 748    return true;
 749  };
 750  
 751  /**
 752   * showdownjs helper functions
 753   */
 754  
 755  if (!showdown.hasOwnProperty('helper')) {
 756    showdown.helper = {};
 757  }
 758  
 759  /**
 760   * Check if var is string
 761   * @static
 762   * @param {string} a
 763   * @returns {boolean}
 764   */
 765  showdown.helper.isString = function (a) {
 766    'use strict';
 767    return (typeof a === 'string' || a instanceof String);
 768  };
 769  
 770  /**
 771   * Check if var is a function
 772   * @static
 773   * @param {*} a
 774   * @returns {boolean}
 775   */
 776  showdown.helper.isFunction = function (a) {
 777    'use strict';
 778    var getType = {};
 779    return a && getType.toString.call(a) === '[object Function]';
 780  };
 781  
 782  /**
 783   * isArray helper function
 784   * @static
 785   * @param {*} a
 786   * @returns {boolean}
 787   */
 788  showdown.helper.isArray = function (a) {
 789    'use strict';
 790    return Array.isArray(a);
 791  };
 792  
 793  /**
 794   * Check if value is undefined
 795   * @static
 796   * @param {*} value The value to check.
 797   * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
 798   */
 799  showdown.helper.isUndefined = function (value) {
 800    'use strict';
 801    return typeof value === 'undefined';
 802  };
 803  
 804  /**
 805   * ForEach helper function
 806   * Iterates over Arrays and Objects (own properties only)
 807   * @static
 808   * @param {*} obj
 809   * @param {function} callback Accepts 3 params: 1. value, 2. key, 3. the original array/object
 810   */
 811  showdown.helper.forEach = function (obj, callback) {
 812    'use strict';
 813    // check if obj is defined
 814    if (showdown.helper.isUndefined(obj)) {
 815      throw new Error('obj param is required');
 816    }
 817  
 818    if (showdown.helper.isUndefined(callback)) {
 819      throw new Error('callback param is required');
 820    }
 821  
 822    if (!showdown.helper.isFunction(callback)) {
 823      throw new Error('callback param must be a function/closure');
 824    }
 825  
 826    if (typeof obj.forEach === 'function') {
 827      obj.forEach(callback);
 828    } else if (showdown.helper.isArray(obj)) {
 829      for (var i = 0; i < obj.length; i++) {
 830        callback(obj[i], i, obj);
 831      }
 832    } else if (typeof (obj) === 'object') {
 833      for (var prop in obj) {
 834        if (obj.hasOwnProperty(prop)) {
 835          callback(obj[prop], prop, obj);
 836        }
 837      }
 838    } else {
 839      throw new Error('obj does not seem to be an array or an iterable object');
 840    }
 841  };
 842  
 843  /**
 844   * Standardidize extension name
 845   * @static
 846   * @param {string} s extension name
 847   * @returns {string}
 848   */
 849  showdown.helper.stdExtName = function (s) {
 850    'use strict';
 851    return s.replace(/[_?*+\/\\.^-]/g, '').replace(/\s/g, '').toLowerCase();
 852  };
 853  
 854  function escapeCharactersCallback (wholeMatch, m1) {
 855    'use strict';
 856    var charCodeToEscape = m1.charCodeAt(0);
 857    return '¨E' + charCodeToEscape + 'E';
 858  }
 859  
 860  /**
 861   * Callback used to escape characters when passing through String.replace
 862   * @static
 863   * @param {string} wholeMatch
 864   * @param {string} m1
 865   * @returns {string}
 866   */
 867  showdown.helper.escapeCharactersCallback = escapeCharactersCallback;
 868  
 869  /**
 870   * Escape characters in a string
 871   * @static
 872   * @param {string} text
 873   * @param {string} charsToEscape
 874   * @param {boolean} afterBackslash
 875   * @returns {XML|string|void|*}
 876   */
 877  showdown.helper.escapeCharacters = function (text, charsToEscape, afterBackslash) {
 878    'use strict';
 879    // First we have to escape the escape characters so that
 880    // we can build a character class out of them
 881    var regexString = '([' + charsToEscape.replace(/([\[\]\\])/g, '\\$1') + '])';
 882  
 883    if (afterBackslash) {
 884      regexString = '\\\\' + regexString;
 885    }
 886  
 887    var regex = new RegExp(regexString, 'g');
 888    text = text.replace(regex, escapeCharactersCallback);
 889  
 890    return text;
 891  };
 892  
 893  /**
 894   * Unescape HTML entities
 895   * @param txt
 896   * @returns {string}
 897   */
 898  showdown.helper.unescapeHTMLEntities = function (txt) {
 899    'use strict';
 900  
 901    return txt
 902      .replace(/&quot;/g, '"')
 903      .replace(/&lt;/g, '<')
 904      .replace(/&gt;/g, '>')
 905      .replace(/&amp;/g, '&');
 906  };
 907  
 908  var rgxFindMatchPos = function (str, left, right, flags) {
 909    'use strict';
 910    var f = flags || '',
 911        g = f.indexOf('g') > -1,
 912        x = new RegExp(left + '|' + right, 'g' + f.replace(/g/g, '')),
 913        l = new RegExp(left, f.replace(/g/g, '')),
 914        pos = [],
 915        t, s, m, start, end;
 916  
 917    do {
 918      t = 0;
 919      while ((m = x.exec(str))) {
 920        if (l.test(m[0])) {
 921          if (!(t++)) {
 922            s = x.lastIndex;
 923            start = s - m[0].length;
 924          }
 925        } else if (t) {
 926          if (!--t) {
 927            end = m.index + m[0].length;
 928            var obj = {
 929              left: {start: start, end: s},
 930              match: {start: s, end: m.index},
 931              right: {start: m.index, end: end},
 932              wholeMatch: {start: start, end: end}
 933            };
 934            pos.push(obj);
 935            if (!g) {
 936              return pos;
 937            }
 938          }
 939        }
 940      }
 941    } while (t && (x.lastIndex = s));
 942  
 943    return pos;
 944  };
 945  
 946  /**
 947   * matchRecursiveRegExp
 948   *
 949   * (c) 2007 Steven Levithan <stevenlevithan.com>
 950   * MIT License
 951   *
 952   * Accepts a string to search, a left and right format delimiter
 953   * as regex patterns, and optional regex flags. Returns an array
 954   * of matches, allowing nested instances of left/right delimiters.
 955   * Use the "g" flag to return all matches, otherwise only the
 956   * first is returned. Be careful to ensure that the left and
 957   * right format delimiters produce mutually exclusive matches.
 958   * Backreferences are not supported within the right delimiter
 959   * due to how it is internally combined with the left delimiter.
 960   * When matching strings whose format delimiters are unbalanced
 961   * to the left or right, the output is intentionally as a
 962   * conventional regex library with recursion support would
 963   * produce, e.g. "<<x>" and "<x>>" both produce ["x"] when using
 964   * "<" and ">" as the delimiters (both strings contain a single,
 965   * balanced instance of "<x>").
 966   *
 967   * examples:
 968   * matchRecursiveRegExp("test", "\\(", "\\)")
 969   * returns: []
 970   * matchRecursiveRegExp("<t<<e>><s>>t<>", "<", ">", "g")
 971   * returns: ["t<<e>><s>", ""]
 972   * matchRecursiveRegExp("<div id=\"x\">test</div>", "<div\\b[^>]*>", "</div>", "gi")
 973   * returns: ["test"]
 974   */
 975  showdown.helper.matchRecursiveRegExp = function (str, left, right, flags) {
 976    'use strict';
 977  
 978    var matchPos = rgxFindMatchPos (str, left, right, flags),
 979        results = [];
 980  
 981    for (var i = 0; i < matchPos.length; ++i) {
 982      results.push([
 983        str.slice(matchPos[i].wholeMatch.start, matchPos[i].wholeMatch.end),
 984        str.slice(matchPos[i].match.start, matchPos[i].match.end),
 985        str.slice(matchPos[i].left.start, matchPos[i].left.end),
 986        str.slice(matchPos[i].right.start, matchPos[i].right.end)
 987      ]);
 988    }
 989    return results;
 990  };
 991  
 992  /**
 993   *
 994   * @param {string} str
 995   * @param {string|function} replacement
 996   * @param {string} left
 997   * @param {string} right
 998   * @param {string} flags
 999   * @returns {string}
1000   */
1001  showdown.helper.replaceRecursiveRegExp = function (str, replacement, left, right, flags) {
1002    'use strict';
1003  
1004    if (!showdown.helper.isFunction(replacement)) {
1005      var repStr = replacement;
1006      replacement = function () {
1007        return repStr;
1008      };
1009    }
1010  
1011    var matchPos = rgxFindMatchPos(str, left, right, flags),
1012        finalStr = str,
1013        lng = matchPos.length;
1014  
1015    if (lng > 0) {
1016      var bits = [];
1017      if (matchPos[0].wholeMatch.start !== 0) {
1018        bits.push(str.slice(0, matchPos[0].wholeMatch.start));
1019      }
1020      for (var i = 0; i < lng; ++i) {
1021        bits.push(
1022          replacement(
1023            str.slice(matchPos[i].wholeMatch.start, matchPos[i].wholeMatch.end),
1024            str.slice(matchPos[i].match.start, matchPos[i].match.end),
1025            str.slice(matchPos[i].left.start, matchPos[i].left.end),
1026            str.slice(matchPos[i].right.start, matchPos[i].right.end)
1027          )
1028        );
1029        if (i < lng - 1) {
1030          bits.push(str.slice(matchPos[i].wholeMatch.end, matchPos[i + 1].wholeMatch.start));
1031        }
1032      }
1033      if (matchPos[lng - 1].wholeMatch.end < str.length) {
1034        bits.push(str.slice(matchPos[lng - 1].wholeMatch.end));
1035      }
1036      finalStr = bits.join('');
1037    }
1038    return finalStr;
1039  };
1040  
1041  /**
1042   * Returns the index within the passed String object of the first occurrence of the specified regex,
1043   * starting the search at fromIndex. Returns -1 if the value is not found.
1044   *
1045   * @param {string} str string to search
1046   * @param {RegExp} regex Regular expression to search
1047   * @param {int} [fromIndex = 0] Index to start the search
1048   * @returns {Number}
1049   * @throws InvalidArgumentError
1050   */
1051  showdown.helper.regexIndexOf = function (str, regex, fromIndex) {
1052    'use strict';
1053    if (!showdown.helper.isString(str)) {
1054      throw 'InvalidArgumentError: first parameter of showdown.helper.regexIndexOf function must be a string';
1055    }
1056    if (regex instanceof RegExp === false) {
1057      throw 'InvalidArgumentError: second parameter of showdown.helper.regexIndexOf function must be an instance of RegExp';
1058    }
1059    var indexOf = str.substring(fromIndex || 0).search(regex);
1060    return (indexOf >= 0) ? (indexOf + (fromIndex || 0)) : indexOf;
1061  };
1062  
1063  /**
1064   * Splits the passed string object at the defined index, and returns an array composed of the two substrings
1065   * @param {string} str string to split
1066   * @param {int} index index to split string at
1067   * @returns {[string,string]}
1068   * @throws InvalidArgumentError
1069   */
1070  showdown.helper.splitAtIndex = function (str, index) {
1071    'use strict';
1072    if (!showdown.helper.isString(str)) {
1073      throw 'InvalidArgumentError: first parameter of showdown.helper.regexIndexOf function must be a string';
1074    }
1075    return [str.substring(0, index), str.substring(index)];
1076  };
1077  
1078  /**
1079   * Obfuscate an e-mail address through the use of Character Entities,
1080   * transforming ASCII characters into their equivalent decimal or hex entities.
1081   *
1082   * Since it has a random component, subsequent calls to this function produce different results
1083   *
1084   * @param {string} mail
1085   * @returns {string}
1086   */
1087  showdown.helper.encodeEmailAddress = function (mail) {
1088    'use strict';
1089    var encode = [
1090      function (ch) {
1091        return '&#' + ch.charCodeAt(0) + ';';
1092      },
1093      function (ch) {
1094        return '&#x' + ch.charCodeAt(0).toString(16) + ';';
1095      },
1096      function (ch) {
1097        return ch;
1098      }
1099    ];
1100  
1101    mail = mail.replace(/./g, function (ch) {
1102      if (ch === '@') {
1103        // this *must* be encoded. I insist.
1104        ch = encode[Math.floor(Math.random() * 2)](ch);
1105      } else {
1106        var r = Math.random();
1107        // roughly 10% raw, 45% hex, 45% dec
1108        ch = (
1109          r > 0.9 ? encode[2](ch) : r > 0.45 ? encode[1](ch) : encode[0](ch)
1110        );
1111      }
1112      return ch;
1113    });
1114  
1115    return mail;
1116  };
1117  
1118  /**
1119   *
1120   * @param str
1121   * @param targetLength
1122   * @param padString
1123   * @returns {string}
1124   */
1125  showdown.helper.padEnd = function padEnd (str, targetLength, padString) {
1126    'use strict';
1127    /*jshint bitwise: false*/
1128    // eslint-disable-next-line space-infix-ops
1129    targetLength = targetLength>>0; //floor if number or convert non-number to 0;
1130    /*jshint bitwise: true*/
1131    padString = String(padString || ' ');
1132    if (str.length > targetLength) {
1133      return String(str);
1134    } else {
1135      targetLength = targetLength - str.length;
1136      if (targetLength > padString.length) {
1137        padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
1138      }
1139      return String(str) + padString.slice(0,targetLength);
1140    }
1141  };
1142  
1143  /**
1144   * POLYFILLS
1145   */
1146  // use this instead of builtin is undefined for IE8 compatibility
1147  if (typeof console === 'undefined') {
1148    console = {
1149      warn: function (msg) {
1150        'use strict';
1151        alert(msg);
1152      },
1153      log: function (msg) {
1154        'use strict';
1155        alert(msg);
1156      },
1157      error: function (msg) {
1158        'use strict';
1159        throw msg;
1160      }
1161    };
1162  }
1163  
1164  /**
1165   * Common regexes.
1166   * We declare some common regexes to improve performance
1167   */
1168  showdown.helper.regexes = {
1169    asteriskDashAndColon: /([*_:~])/g
1170  };
1171  
1172  /**
1173   * EMOJIS LIST
1174   */
1175  showdown.helper.emojis = {
1176    '+1':'\ud83d\udc4d',
1177    '-1':'\ud83d\udc4e',
1178    '100':'\ud83d\udcaf',
1179    '1234':'\ud83d\udd22',
1180    '1st_place_medal':'\ud83e\udd47',
1181    '2nd_place_medal':'\ud83e\udd48',
1182    '3rd_place_medal':'\ud83e\udd49',
1183    '8ball':'\ud83c\udfb1',
1184    'a':'\ud83c\udd70\ufe0f',
1185    'ab':'\ud83c\udd8e',
1186    'abc':'\ud83d\udd24',
1187    'abcd':'\ud83d\udd21',
1188    'accept':'\ud83c\ude51',
1189    'aerial_tramway':'\ud83d\udea1',
1190    'airplane':'\u2708\ufe0f',
1191    'alarm_clock':'\u23f0',
1192    'alembic':'\u2697\ufe0f',
1193    'alien':'\ud83d\udc7d',
1194    'ambulance':'\ud83d\ude91',
1195    'amphora':'\ud83c\udffa',
1196    'anchor':'\u2693\ufe0f',
1197    'angel':'\ud83d\udc7c',
1198    'anger':'\ud83d\udca2',
1199    'angry':'\ud83d\ude20',
1200    'anguished':'\ud83d\ude27',
1201    'ant':'\ud83d\udc1c',
1202    'apple':'\ud83c\udf4e',
1203    'aquarius':'\u2652\ufe0f',
1204    'aries':'\u2648\ufe0f',
1205    'arrow_backward':'\u25c0\ufe0f',
1206    'arrow_double_down':'\u23ec',
1207    'arrow_double_up':'\u23eb',
1208    'arrow_down':'\u2b07\ufe0f',
1209    'arrow_down_small':'\ud83d\udd3d',
1210    'arrow_forward':'\u25b6\ufe0f',
1211    'arrow_heading_down':'\u2935\ufe0f',
1212    'arrow_heading_up':'\u2934\ufe0f',
1213    'arrow_left':'\u2b05\ufe0f',
1214    'arrow_lower_left':'\u2199\ufe0f',
1215    'arrow_lower_right':'\u2198\ufe0f',
1216    'arrow_right':'\u27a1\ufe0f',
1217    'arrow_right_hook':'\u21aa\ufe0f',
1218    'arrow_up':'\u2b06\ufe0f',
1219    'arrow_up_down':'\u2195\ufe0f',
1220    'arrow_up_small':'\ud83d\udd3c',
1221    'arrow_upper_left':'\u2196\ufe0f',
1222    'arrow_upper_right':'\u2197\ufe0f',
1223    'arrows_clockwise':'\ud83d\udd03',
1224    'arrows_counterclockwise':'\ud83d\udd04',
1225    'art':'\ud83c\udfa8',
1226    'articulated_lorry':'\ud83d\ude9b',
1227    'artificial_satellite':'\ud83d\udef0',
1228    'astonished':'\ud83d\ude32',
1229    'athletic_shoe':'\ud83d\udc5f',
1230    'atm':'\ud83c\udfe7',
1231    'atom_symbol':'\u269b\ufe0f',
1232    'avocado':'\ud83e\udd51',
1233    'b':'\ud83c\udd71\ufe0f',
1234    'baby':'\ud83d\udc76',
1235    'baby_bottle':'\ud83c\udf7c',
1236    'baby_chick':'\ud83d\udc24',
1237    'baby_symbol':'\ud83d\udebc',
1238    'back':'\ud83d\udd19',
1239    'bacon':'\ud83e\udd53',
1240    'badminton':'\ud83c\udff8',
1241    'baggage_claim':'\ud83d\udec4',
1242    'baguette_bread':'\ud83e\udd56',
1243    'balance_scale':'\u2696\ufe0f',
1244    'balloon':'\ud83c\udf88',
1245    'ballot_box':'\ud83d\uddf3',
1246    'ballot_box_with_check':'\u2611\ufe0f',
1247    'bamboo':'\ud83c\udf8d',
1248    'banana':'\ud83c\udf4c',
1249    'bangbang':'\u203c\ufe0f',
1250    'bank':'\ud83c\udfe6',
1251    'bar_chart':'\ud83d\udcca',
1252    'barber':'\ud83d\udc88',
1253    'baseball':'\u26be\ufe0f',
1254    'basketball':'\ud83c\udfc0',
1255    'basketball_man':'\u26f9\ufe0f',
1256    'basketball_woman':'\u26f9\ufe0f&zwj;\u2640\ufe0f',
1257    'bat':'\ud83e\udd87',
1258    'bath':'\ud83d\udec0',
1259    'bathtub':'\ud83d\udec1',
1260    'battery':'\ud83d\udd0b',
1261    'beach_umbrella':'\ud83c\udfd6',
1262    'bear':'\ud83d\udc3b',
1263    'bed':'\ud83d\udecf',
1264    'bee':'\ud83d\udc1d',
1265    'beer':'\ud83c\udf7a',
1266    'beers':'\ud83c\udf7b',
1267    'beetle':'\ud83d\udc1e',
1268    'beginner':'\ud83d\udd30',
1269    'bell':'\ud83d\udd14',
1270    'bellhop_bell':'\ud83d\udece',
1271    'bento':'\ud83c\udf71',
1272    'biking_man':'\ud83d\udeb4',
1273    'bike':'\ud83d\udeb2',
1274    'biking_woman':'\ud83d\udeb4&zwj;\u2640\ufe0f',
1275    'bikini':'\ud83d\udc59',
1276    'biohazard':'\u2623\ufe0f',
1277    'bird':'\ud83d\udc26',
1278    'birthday':'\ud83c\udf82',
1279    'black_circle':'\u26ab\ufe0f',
1280    'black_flag':'\ud83c\udff4',
1281    'black_heart':'\ud83d\udda4',
1282    'black_joker':'\ud83c\udccf',
1283    'black_large_square':'\u2b1b\ufe0f',
1284    'black_medium_small_square':'\u25fe\ufe0f',
1285    'black_medium_square':'\u25fc\ufe0f',
1286    'black_nib':'\u2712\ufe0f',
1287    'black_small_square':'\u25aa\ufe0f',
1288    'black_square_button':'\ud83d\udd32',
1289    'blonde_man':'\ud83d\udc71',
1290    'blonde_woman':'\ud83d\udc71&zwj;\u2640\ufe0f',
1291    'blossom':'\ud83c\udf3c',
1292    'blowfish':'\ud83d\udc21',
1293    'blue_book':'\ud83d\udcd8',
1294    'blue_car':'\ud83d\ude99',
1295    'blue_heart':'\ud83d\udc99',
1296    'blush':'\ud83d\ude0a',
1297    'boar':'\ud83d\udc17',
1298    'boat':'\u26f5\ufe0f',
1299    'bomb':'\ud83d\udca3',
1300    'book':'\ud83d\udcd6',
1301    'bookmark':'\ud83d\udd16',
1302    'bookmark_tabs':'\ud83d\udcd1',
1303    'books':'\ud83d\udcda',
1304    'boom':'\ud83d\udca5',
1305    'boot':'\ud83d\udc62',
1306    'bouquet':'\ud83d\udc90',
1307    'bowing_man':'\ud83d\ude47',
1308    'bow_and_arrow':'\ud83c\udff9',
1309    'bowing_woman':'\ud83d\ude47&zwj;\u2640\ufe0f',
1310    'bowling':'\ud83c\udfb3',
1311    'boxing_glove':'\ud83e\udd4a',
1312    'boy':'\ud83d\udc66',
1313    'bread':'\ud83c\udf5e',
1314    'bride_with_veil':'\ud83d\udc70',
1315    'bridge_at_night':'\ud83c\udf09',
1316    'briefcase':'\ud83d\udcbc',
1317    'broken_heart':'\ud83d\udc94',
1318    'bug':'\ud83d\udc1b',
1319    'building_construction':'\ud83c\udfd7',
1320    'bulb':'\ud83d\udca1',
1321    'bullettrain_front':'\ud83d\ude85',
1322    'bullettrain_side':'\ud83d\ude84',
1323    'burrito':'\ud83c\udf2f',
1324    'bus':'\ud83d\ude8c',
1325    'business_suit_levitating':'\ud83d\udd74',
1326    'busstop':'\ud83d\ude8f',
1327    'bust_in_silhouette':'\ud83d\udc64',
1328    'busts_in_silhouette':'\ud83d\udc65',
1329    'butterfly':'\ud83e\udd8b',
1330    'cactus':'\ud83c\udf35',
1331    'cake':'\ud83c\udf70',
1332    'calendar':'\ud83d\udcc6',
1333    'call_me_hand':'\ud83e\udd19',
1334    'calling':'\ud83d\udcf2',
1335    'camel':'\ud83d\udc2b',
1336    'camera':'\ud83d\udcf7',
1337    'camera_flash':'\ud83d\udcf8',
1338    'camping':'\ud83c\udfd5',
1339    'cancer':'\u264b\ufe0f',
1340    'candle':'\ud83d\udd6f',
1341    'candy':'\ud83c\udf6c',
1342    'canoe':'\ud83d\udef6',
1343    'capital_abcd':'\ud83d\udd20',
1344    'capricorn':'\u2651\ufe0f',
1345    'car':'\ud83d\ude97',
1346    'card_file_box':'\ud83d\uddc3',
1347    'card_index':'\ud83d\udcc7',
1348    'card_index_dividers':'\ud83d\uddc2',
1349    'carousel_horse':'\ud83c\udfa0',
1350    'carrot':'\ud83e\udd55',
1351    'cat':'\ud83d\udc31',
1352    'cat2':'\ud83d\udc08',
1353    'cd':'\ud83d\udcbf',
1354    'chains':'\u26d3',
1355    'champagne':'\ud83c\udf7e',
1356    'chart':'\ud83d\udcb9',
1357    'chart_with_downwards_trend':'\ud83d\udcc9',
1358    'chart_with_upwards_trend':'\ud83d\udcc8',
1359    'checkered_flag':'\ud83c\udfc1',
1360    'cheese':'\ud83e\uddc0',
1361    'cherries':'\ud83c\udf52',
1362    'cherry_blossom':'\ud83c\udf38',
1363    'chestnut':'\ud83c\udf30',
1364    'chicken':'\ud83d\udc14',
1365    'children_crossing':'\ud83d\udeb8',
1366    'chipmunk':'\ud83d\udc3f',
1367    'chocolate_bar':'\ud83c\udf6b',
1368    'christmas_tree':'\ud83c\udf84',
1369    'church':'\u26ea\ufe0f',
1370    'cinema':'\ud83c\udfa6',
1371    'circus_tent':'\ud83c\udfaa',
1372    'city_sunrise':'\ud83c\udf07',
1373    'city_sunset':'\ud83c\udf06',
1374    'cityscape':'\ud83c\udfd9',
1375    'cl':'\ud83c\udd91',
1376    'clamp':'\ud83d\udddc',
1377    'clap':'\ud83d\udc4f',
1378    'clapper':'\ud83c\udfac',
1379    'classical_building':'\ud83c\udfdb',
1380    'clinking_glasses':'\ud83e\udd42',
1381    'clipboard':'\ud83d\udccb',
1382    'clock1':'\ud83d\udd50',
1383    'clock10':'\ud83d\udd59',
1384    'clock1030':'\ud83d\udd65',
1385    'clock11':'\ud83d\udd5a',
1386    'clock1130':'\ud83d\udd66',
1387    'clock12':'\ud83d\udd5b',
1388    'clock1230':'\ud83d\udd67',
1389    'clock130':'\ud83d\udd5c',
1390    'clock2':'\ud83d\udd51',
1391    'clock230':'\ud83d\udd5d',
1392    'clock3':'\ud83d\udd52',
1393    'clock330':'\ud83d\udd5e',
1394    'clock4':'\ud83d\udd53',
1395    'clock430':'\ud83d\udd5f',
1396    'clock5':'\ud83d\udd54',
1397    'clock530':'\ud83d\udd60',
1398    'clock6':'\ud83d\udd55',
1399    'clock630':'\ud83d\udd61',
1400    'clock7':'\ud83d\udd56',
1401    'clock730':'\ud83d\udd62',
1402    'clock8':'\ud83d\udd57',
1403    'clock830':'\ud83d\udd63',
1404    'clock9':'\ud83d\udd58',
1405    'clock930':'\ud83d\udd64',
1406    'closed_book':'\ud83d\udcd5',
1407    'closed_lock_with_key':'\ud83d\udd10',
1408    'closed_umbrella':'\ud83c\udf02',
1409    'cloud':'\u2601\ufe0f',
1410    'cloud_with_lightning':'\ud83c\udf29',
1411    'cloud_with_lightning_and_rain':'\u26c8',
1412    'cloud_with_rain':'\ud83c\udf27',
1413    'cloud_with_snow':'\ud83c\udf28',
1414    'clown_face':'\ud83e\udd21',
1415    'clubs':'\u2663\ufe0f',
1416    'cocktail':'\ud83c\udf78',
1417    'coffee':'\u2615\ufe0f',
1418    'coffin':'\u26b0\ufe0f',
1419    'cold_sweat':'\ud83d\ude30',
1420    'comet':'\u2604\ufe0f',
1421    'computer':'\ud83d\udcbb',
1422    'computer_mouse':'\ud83d\uddb1',
1423    'confetti_ball':'\ud83c\udf8a',
1424    'confounded':'\ud83d\ude16',
1425    'confused':'\ud83d\ude15',
1426    'congratulations':'\u3297\ufe0f',
1427    'construction':'\ud83d\udea7',
1428    'construction_worker_man':'\ud83d\udc77',
1429    'construction_worker_woman':'\ud83d\udc77&zwj;\u2640\ufe0f',
1430    'control_knobs':'\ud83c\udf9b',
1431    'convenience_store':'\ud83c\udfea',
1432    'cookie':'\ud83c\udf6a',
1433    'cool':'\ud83c\udd92',
1434    'policeman':'\ud83d\udc6e',
1435    'copyright':'\u00a9\ufe0f',
1436    'corn':'\ud83c\udf3d',
1437    'couch_and_lamp':'\ud83d\udecb',
1438    'couple':'\ud83d\udc6b',
1439    'couple_with_heart_woman_man':'\ud83d\udc91',
1440    'couple_with_heart_man_man':'\ud83d\udc68&zwj;\u2764\ufe0f&zwj;\ud83d\udc68',
1441    'couple_with_heart_woman_woman':'\ud83d\udc69&zwj;\u2764\ufe0f&zwj;\ud83d\udc69',
1442    'couplekiss_man_man':'\ud83d\udc68&zwj;\u2764\ufe0f&zwj;\ud83d\udc8b&zwj;\ud83d\udc68',
1443    'couplekiss_man_woman':'\ud83d\udc8f',
1444    'couplekiss_woman_woman':'\ud83d\udc69&zwj;\u2764\ufe0f&zwj;\ud83d\udc8b&zwj;\ud83d\udc69',
1445    'cow':'\ud83d\udc2e',
1446    'cow2':'\ud83d\udc04',
1447    'cowboy_hat_face':'\ud83e\udd20',
1448    'crab':'\ud83e\udd80',
1449    'crayon':'\ud83d\udd8d',
1450    'credit_card':'\ud83d\udcb3',
1451    'crescent_moon':'\ud83c\udf19',
1452    'cricket':'\ud83c\udfcf',
1453    'crocodile':'\ud83d\udc0a',
1454    'croissant':'\ud83e\udd50',
1455    'crossed_fingers':'\ud83e\udd1e',
1456    'crossed_flags':'\ud83c\udf8c',
1457    'crossed_swords':'\u2694\ufe0f',
1458    'crown':'\ud83d\udc51',
1459    'cry':'\ud83d\ude22',
1460    'crying_cat_face':'\ud83d\ude3f',
1461    'crystal_ball':'\ud83d\udd2e',
1462    'cucumber':'\ud83e\udd52',
1463    'cupid':'\ud83d\udc98',
1464    'curly_loop':'\u27b0',
1465    'currency_exchange':'\ud83d\udcb1',
1466    'curry':'\ud83c\udf5b',
1467    'custard':'\ud83c\udf6e',
1468    'customs':'\ud83d\udec3',
1469    'cyclone':'\ud83c\udf00',
1470    'dagger':'\ud83d\udde1',
1471    'dancer':'\ud83d\udc83',
1472    'dancing_women':'\ud83d\udc6f',
1473    'dancing_men':'\ud83d\udc6f&zwj;\u2642\ufe0f',
1474    'dango':'\ud83c\udf61',
1475    'dark_sunglasses':'\ud83d\udd76',
1476    'dart':'\ud83c\udfaf',
1477    'dash':'\ud83d\udca8',
1478    'date':'\ud83d\udcc5',
1479    'deciduous_tree':'\ud83c\udf33',
1480    'deer':'\ud83e\udd8c',
1481    'department_store':'\ud83c\udfec',
1482    'derelict_house':'\ud83c\udfda',
1483    'desert':'\ud83c\udfdc',
1484    'desert_island':'\ud83c\udfdd',
1485    'desktop_computer':'\ud83d\udda5',
1486    'male_detective':'\ud83d\udd75\ufe0f',
1487    'diamond_shape_with_a_dot_inside':'\ud83d\udca0',
1488    'diamonds':'\u2666\ufe0f',
1489    'disappointed':'\ud83d\ude1e',
1490    'disappointed_relieved':'\ud83d\ude25',
1491    'dizzy':'\ud83d\udcab',
1492    'dizzy_face':'\ud83d\ude35',
1493    'do_not_litter':'\ud83d\udeaf',
1494    'dog':'\ud83d\udc36',
1495    'dog2':'\ud83d\udc15',
1496    'dollar':'\ud83d\udcb5',
1497    'dolls':'\ud83c\udf8e',
1498    'dolphin':'\ud83d\udc2c',
1499    'door':'\ud83d\udeaa',
1500    'doughnut':'\ud83c\udf69',
1501    'dove':'\ud83d\udd4a',
1502    'dragon':'\ud83d\udc09',
1503    'dragon_face':'\ud83d\udc32',
1504    'dress':'\ud83d\udc57',
1505    'dromedary_camel':'\ud83d\udc2a',
1506    'drooling_face':'\ud83e\udd24',
1507    'droplet':'\ud83d\udca7',
1508    'drum':'\ud83e\udd41',
1509    'duck':'\ud83e\udd86',
1510    'dvd':'\ud83d\udcc0',
1511    'e-mail':'\ud83d\udce7',
1512    'eagle':'\ud83e\udd85',
1513    'ear':'\ud83d\udc42',
1514    'ear_of_rice':'\ud83c\udf3e',
1515    'earth_africa':'\ud83c\udf0d',
1516    'earth_americas':'\ud83c\udf0e',
1517    'earth_asia':'\ud83c\udf0f',
1518    'egg':'\ud83e\udd5a',
1519    'eggplant':'\ud83c\udf46',
1520    'eight_pointed_black_star':'\u2734\ufe0f',
1521    'eight_spoked_asterisk':'\u2733\ufe0f',
1522    'electric_plug':'\ud83d\udd0c',
1523    'elephant':'\ud83d\udc18',
1524    'email':'\u2709\ufe0f',
1525    'end':'\ud83d\udd1a',
1526    'envelope_with_arrow':'\ud83d\udce9',
1527    'euro':'\ud83d\udcb6',
1528    'european_castle':'\ud83c\udff0',
1529    'european_post_office':'\ud83c\udfe4',
1530    'evergreen_tree':'\ud83c\udf32',
1531    'exclamation':'\u2757\ufe0f',
1532    'expressionless':'\ud83d\ude11',
1533    'eye':'\ud83d\udc41',
1534    'eye_speech_bubble':'\ud83d\udc41&zwj;\ud83d\udde8',
1535    'eyeglasses':'\ud83d\udc53',
1536    'eyes':'\ud83d\udc40',
1537    'face_with_head_bandage':'\ud83e\udd15',
1538    'face_with_thermometer':'\ud83e\udd12',
1539    'fist_oncoming':'\ud83d\udc4a',
1540    'factory':'\ud83c\udfed',
1541    'fallen_leaf':'\ud83c\udf42',
1542    'family_man_woman_boy':'\ud83d\udc6a',
1543    'family_man_boy':'\ud83d\udc68&zwj;\ud83d\udc66',
1544    'family_man_boy_boy':'\ud83d\udc68&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1545    'family_man_girl':'\ud83d\udc68&zwj;\ud83d\udc67',
1546    'family_man_girl_boy':'\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1547    'family_man_girl_girl':'\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1548    'family_man_man_boy':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc66',
1549    'family_man_man_boy_boy':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1550    'family_man_man_girl':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc67',
1551    'family_man_man_girl_boy':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1552    'family_man_man_girl_girl':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1553    'family_man_woman_boy_boy':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1554    'family_man_woman_girl':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc67',
1555    'family_man_woman_girl_boy':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1556    'family_man_woman_girl_girl':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1557    'family_woman_boy':'\ud83d\udc69&zwj;\ud83d\udc66',
1558    'family_woman_boy_boy':'\ud83d\udc69&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1559    'family_woman_girl':'\ud83d\udc69&zwj;\ud83d\udc67',
1560    'family_woman_girl_boy':'\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1561    'family_woman_girl_girl':'\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1562    'family_woman_woman_boy':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc66',
1563    'family_woman_woman_boy_boy':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1564    'family_woman_woman_girl':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc67',
1565    'family_woman_woman_girl_boy':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1566    'family_woman_woman_girl_girl':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1567    'fast_forward':'\u23e9',
1568    'fax':'\ud83d\udce0',
1569    'fearful':'\ud83d\ude28',
1570    'feet':'\ud83d\udc3e',
1571    'female_detective':'\ud83d\udd75\ufe0f&zwj;\u2640\ufe0f',
1572    'ferris_wheel':'\ud83c\udfa1',
1573    'ferry':'\u26f4',
1574    'field_hockey':'\ud83c\udfd1',
1575    'file_cabinet':'\ud83d\uddc4',
1576    'file_folder':'\ud83d\udcc1',
1577    'film_projector':'\ud83d\udcfd',
1578    'film_strip':'\ud83c\udf9e',
1579    'fire':'\ud83d\udd25',
1580    'fire_engine':'\ud83d\ude92',
1581    'fireworks':'\ud83c\udf86',
1582    'first_quarter_moon':'\ud83c\udf13',
1583    'first_quarter_moon_with_face':'\ud83c\udf1b',
1584    'fish':'\ud83d\udc1f',
1585    'fish_cake':'\ud83c\udf65',
1586    'fishing_pole_and_fish':'\ud83c\udfa3',
1587    'fist_raised':'\u270a',
1588    'fist_left':'\ud83e\udd1b',
1589    'fist_right':'\ud83e\udd1c',
1590    'flags':'\ud83c\udf8f',
1591    'flashlight':'\ud83d\udd26',
1592    'fleur_de_lis':'\u269c\ufe0f',
1593    'flight_arrival':'\ud83d\udeec',
1594    'flight_departure':'\ud83d\udeeb',
1595    'floppy_disk':'\ud83d\udcbe',
1596    'flower_playing_cards':'\ud83c\udfb4',
1597    'flushed':'\ud83d\ude33',
1598    'fog':'\ud83c\udf2b',
1599    'foggy':'\ud83c\udf01',
1600    'football':'\ud83c\udfc8',
1601    'footprints':'\ud83d\udc63',
1602    'fork_and_knife':'\ud83c\udf74',
1603    'fountain':'\u26f2\ufe0f',
1604    'fountain_pen':'\ud83d\udd8b',
1605    'four_leaf_clover':'\ud83c\udf40',
1606    'fox_face':'\ud83e\udd8a',
1607    'framed_picture':'\ud83d\uddbc',
1608    'free':'\ud83c\udd93',
1609    'fried_egg':'\ud83c\udf73',
1610    'fried_shrimp':'\ud83c\udf64',
1611    'fries':'\ud83c\udf5f',
1612    'frog':'\ud83d\udc38',
1613    'frowning':'\ud83d\ude26',
1614    'frowning_face':'\u2639\ufe0f',
1615    'frowning_man':'\ud83d\ude4d&zwj;\u2642\ufe0f',
1616    'frowning_woman':'\ud83d\ude4d',
1617    'middle_finger':'\ud83d\udd95',
1618    'fuelpump':'\u26fd\ufe0f',
1619    'full_moon':'\ud83c\udf15',
1620    'full_moon_with_face':'\ud83c\udf1d',
1621    'funeral_urn':'\u26b1\ufe0f',
1622    'game_die':'\ud83c\udfb2',
1623    'gear':'\u2699\ufe0f',
1624    'gem':'\ud83d\udc8e',
1625    'gemini':'\u264a\ufe0f',
1626    'ghost':'\ud83d\udc7b',
1627    'gift':'\ud83c\udf81',
1628    'gift_heart':'\ud83d\udc9d',
1629    'girl':'\ud83d\udc67',
1630    'globe_with_meridians':'\ud83c\udf10',
1631    'goal_net':'\ud83e\udd45',
1632    'goat':'\ud83d\udc10',
1633    'golf':'\u26f3\ufe0f',
1634    'golfing_man':'\ud83c\udfcc\ufe0f',
1635    'golfing_woman':'\ud83c\udfcc\ufe0f&zwj;\u2640\ufe0f',
1636    'gorilla':'\ud83e\udd8d',
1637    'grapes':'\ud83c\udf47',
1638    'green_apple':'\ud83c\udf4f',
1639    'green_book':'\ud83d\udcd7',
1640    'green_heart':'\ud83d\udc9a',
1641    'green_salad':'\ud83e\udd57',
1642    'grey_exclamation':'\u2755',
1643    'grey_question':'\u2754',
1644    'grimacing':'\ud83d\ude2c',
1645    'grin':'\ud83d\ude01',
1646    'grinning':'\ud83d\ude00',
1647    'guardsman':'\ud83d\udc82',
1648    'guardswoman':'\ud83d\udc82&zwj;\u2640\ufe0f',
1649    'guitar':'\ud83c\udfb8',
1650    'gun':'\ud83d\udd2b',
1651    'haircut_woman':'\ud83d\udc87',
1652    'haircut_man':'\ud83d\udc87&zwj;\u2642\ufe0f',
1653    'hamburger':'\ud83c\udf54',
1654    'hammer':'\ud83d\udd28',
1655    'hammer_and_pick':'\u2692',
1656    'hammer_and_wrench':'\ud83d\udee0',
1657    'hamster':'\ud83d\udc39',
1658    'hand':'\u270b',
1659    'handbag':'\ud83d\udc5c',
1660    'handshake':'\ud83e\udd1d',
1661    'hankey':'\ud83d\udca9',
1662    'hatched_chick':'\ud83d\udc25',
1663    'hatching_chick':'\ud83d\udc23',
1664    'headphones':'\ud83c\udfa7',
1665    'hear_no_evil':'\ud83d\ude49',
1666    'heart':'\u2764\ufe0f',
1667    'heart_decoration':'\ud83d\udc9f',
1668    'heart_eyes':'\ud83d\ude0d',
1669    'heart_eyes_cat':'\ud83d\ude3b',
1670    'heartbeat':'\ud83d\udc93',
1671    'heartpulse':'\ud83d\udc97',
1672    'hearts':'\u2665\ufe0f',
1673    'heavy_check_mark':'\u2714\ufe0f',
1674    'heavy_division_sign':'\u2797',
1675    'heavy_dollar_sign':'\ud83d\udcb2',
1676    'heavy_heart_exclamation':'\u2763\ufe0f',
1677    'heavy_minus_sign':'\u2796',
1678    'heavy_multiplication_x':'\u2716\ufe0f',
1679    'heavy_plus_sign':'\u2795',
1680    'helicopter':'\ud83d\ude81',
1681    'herb':'\ud83c\udf3f',
1682    'hibiscus':'\ud83c\udf3a',
1683    'high_brightness':'\ud83d\udd06',
1684    'high_heel':'\ud83d\udc60',
1685    'hocho':'\ud83d\udd2a',
1686    'hole':'\ud83d\udd73',
1687    'honey_pot':'\ud83c\udf6f',
1688    'horse':'\ud83d\udc34',
1689    'horse_racing':'\ud83c\udfc7',
1690    'hospital':'\ud83c\udfe5',
1691    'hot_pepper':'\ud83c\udf36',
1692    'hotdog':'\ud83c\udf2d',
1693    'hotel':'\ud83c\udfe8',
1694    'hotsprings':'\u2668\ufe0f',
1695    'hourglass':'\u231b\ufe0f',
1696    'hourglass_flowing_sand':'\u23f3',
1697    'house':'\ud83c\udfe0',
1698    'house_with_garden':'\ud83c\udfe1',
1699    'houses':'\ud83c\udfd8',
1700    'hugs':'\ud83e\udd17',
1701    'hushed':'\ud83d\ude2f',
1702    'ice_cream':'\ud83c\udf68',
1703    'ice_hockey':'\ud83c\udfd2',
1704    'ice_skate':'\u26f8',
1705    'icecream':'\ud83c\udf66',
1706    'id':'\ud83c\udd94',
1707    'ideograph_advantage':'\ud83c\ude50',
1708    'imp':'\ud83d\udc7f',
1709    'inbox_tray':'\ud83d\udce5',
1710    'incoming_envelope':'\ud83d\udce8',
1711    'tipping_hand_woman':'\ud83d\udc81',
1712    'information_source':'\u2139\ufe0f',
1713    'innocent':'\ud83d\ude07',
1714    'interrobang':'\u2049\ufe0f',
1715    'iphone':'\ud83d\udcf1',
1716    'izakaya_lantern':'\ud83c\udfee',
1717    'jack_o_lantern':'\ud83c\udf83',
1718    'japan':'\ud83d\uddfe',
1719    'japanese_castle':'\ud83c\udfef',
1720    'japanese_goblin':'\ud83d\udc7a',
1721    'japanese_ogre':'\ud83d\udc79',
1722    'jeans':'\ud83d\udc56',
1723    'joy':'\ud83d\ude02',
1724    'joy_cat':'\ud83d\ude39',
1725    'joystick':'\ud83d\udd79',
1726    'kaaba':'\ud83d\udd4b',
1727    'key':'\ud83d\udd11',
1728    'keyboard':'\u2328\ufe0f',
1729    'keycap_ten':'\ud83d\udd1f',
1730    'kick_scooter':'\ud83d\udef4',
1731    'kimono':'\ud83d\udc58',
1732    'kiss':'\ud83d\udc8b',
1733    'kissing':'\ud83d\ude17',
1734    'kissing_cat':'\ud83d\ude3d',
1735    'kissing_closed_eyes':'\ud83d\ude1a',
1736    'kissing_heart':'\ud83d\ude18',
1737    'kissing_smiling_eyes':'\ud83d\ude19',
1738    'kiwi_fruit':'\ud83e\udd5d',
1739    'koala':'\ud83d\udc28',
1740    'koko':'\ud83c\ude01',
1741    'label':'\ud83c\udff7',
1742    'large_blue_circle':'\ud83d\udd35',
1743    'large_blue_diamond':'\ud83d\udd37',
1744    'large_orange_diamond':'\ud83d\udd36',
1745    'last_quarter_moon':'\ud83c\udf17',
1746    'last_quarter_moon_with_face':'\ud83c\udf1c',
1747    'latin_cross':'\u271d\ufe0f',
1748    'laughing':'\ud83d\ude06',
1749    'leaves':'\ud83c\udf43',
1750    'ledger':'\ud83d\udcd2',
1751    'left_luggage':'\ud83d\udec5',
1752    'left_right_arrow':'\u2194\ufe0f',
1753    'leftwards_arrow_with_hook':'\u21a9\ufe0f',
1754    'lemon':'\ud83c\udf4b',
1755    'leo':'\u264c\ufe0f',
1756    'leopard':'\ud83d\udc06',
1757    'level_slider':'\ud83c\udf9a',
1758    'libra':'\u264e\ufe0f',
1759    'light_rail':'\ud83d\ude88',
1760    'link':'\ud83d\udd17',
1761    'lion':'\ud83e\udd81',
1762    'lips':'\ud83d\udc44',
1763    'lipstick':'\ud83d\udc84',
1764    'lizard':'\ud83e\udd8e',
1765    'lock':'\ud83d\udd12',
1766    'lock_with_ink_pen':'\ud83d\udd0f',
1767    'lollipop':'\ud83c\udf6d',
1768    'loop':'\u27bf',
1769    'loud_sound':'\ud83d\udd0a',
1770    'loudspeaker':'\ud83d\udce2',
1771    'love_hotel':'\ud83c\udfe9',
1772    'love_letter':'\ud83d\udc8c',
1773    'low_brightness':'\ud83d\udd05',
1774    'lying_face':'\ud83e\udd25',
1775    'm':'\u24c2\ufe0f',
1776    'mag':'\ud83d\udd0d',
1777    'mag_right':'\ud83d\udd0e',
1778    'mahjong':'\ud83c\udc04\ufe0f',
1779    'mailbox':'\ud83d\udceb',
1780    'mailbox_closed':'\ud83d\udcea',
1781    'mailbox_with_mail':'\ud83d\udcec',
1782    'mailbox_with_no_mail':'\ud83d\udced',
1783    'man':'\ud83d\udc68',
1784    'man_artist':'\ud83d\udc68&zwj;\ud83c\udfa8',
1785    'man_astronaut':'\ud83d\udc68&zwj;\ud83d\ude80',
1786    'man_cartwheeling':'\ud83e\udd38&zwj;\u2642\ufe0f',
1787    'man_cook':'\ud83d\udc68&zwj;\ud83c\udf73',
1788    'man_dancing':'\ud83d\udd7a',
1789    'man_facepalming':'\ud83e\udd26&zwj;\u2642\ufe0f',
1790    'man_factory_worker':'\ud83d\udc68&zwj;\ud83c\udfed',
1791    'man_farmer':'\ud83d\udc68&zwj;\ud83c\udf3e',
1792    'man_firefighter':'\ud83d\udc68&zwj;\ud83d\ude92',
1793    'man_health_worker':'\ud83d\udc68&zwj;\u2695\ufe0f',
1794    'man_in_tuxedo':'\ud83e\udd35',
1795    'man_judge':'\ud83d\udc68&zwj;\u2696\ufe0f',
1796    'man_juggling':'\ud83e\udd39&zwj;\u2642\ufe0f',
1797    'man_mechanic':'\ud83d\udc68&zwj;\ud83d\udd27',
1798    'man_office_worker':'\ud83d\udc68&zwj;\ud83d\udcbc',
1799    'man_pilot':'\ud83d\udc68&zwj;\u2708\ufe0f',
1800    'man_playing_handball':'\ud83e\udd3e&zwj;\u2642\ufe0f',
1801    'man_playing_water_polo':'\ud83e\udd3d&zwj;\u2642\ufe0f',
1802    'man_scientist':'\ud83d\udc68&zwj;\ud83d\udd2c',
1803    'man_shrugging':'\ud83e\udd37&zwj;\u2642\ufe0f',
1804    'man_singer':'\ud83d\udc68&zwj;\ud83c\udfa4',
1805    'man_student':'\ud83d\udc68&zwj;\ud83c\udf93',
1806    'man_teacher':'\ud83d\udc68&zwj;\ud83c\udfeb',
1807    'man_technologist':'\ud83d\udc68&zwj;\ud83d\udcbb',
1808    'man_with_gua_pi_mao':'\ud83d\udc72',
1809    'man_with_turban':'\ud83d\udc73',
1810    'tangerine':'\ud83c\udf4a',
1811    'mans_shoe':'\ud83d\udc5e',
1812    'mantelpiece_clock':'\ud83d\udd70',
1813    'maple_leaf':'\ud83c\udf41',
1814    'martial_arts_uniform':'\ud83e\udd4b',
1815    'mask':'\ud83d\ude37',
1816    'massage_woman':'\ud83d\udc86',
1817    'massage_man':'\ud83d\udc86&zwj;\u2642\ufe0f',
1818    'meat_on_bone':'\ud83c\udf56',
1819    'medal_military':'\ud83c\udf96',
1820    'medal_sports':'\ud83c\udfc5',
1821    'mega':'\ud83d\udce3',
1822    'melon':'\ud83c\udf48',
1823    'memo':'\ud83d\udcdd',
1824    'men_wrestling':'\ud83e\udd3c&zwj;\u2642\ufe0f',
1825    'menorah':'\ud83d\udd4e',
1826    'mens':'\ud83d\udeb9',
1827    'metal':'\ud83e\udd18',
1828    'metro':'\ud83d\ude87',
1829    'microphone':'\ud83c\udfa4',
1830    'microscope':'\ud83d\udd2c',
1831    'milk_glass':'\ud83e\udd5b',
1832    'milky_way':'\ud83c\udf0c',
1833    'minibus':'\ud83d\ude90',
1834    'minidisc':'\ud83d\udcbd',
1835    'mobile_phone_off':'\ud83d\udcf4',
1836    'money_mouth_face':'\ud83e\udd11',
1837    'money_with_wings':'\ud83d\udcb8',
1838    'moneybag':'\ud83d\udcb0',
1839    'monkey':'\ud83d\udc12',
1840    'monkey_face':'\ud83d\udc35',
1841    'monorail':'\ud83d\ude9d',
1842    'moon':'\ud83c\udf14',
1843    'mortar_board':'\ud83c\udf93',
1844    'mosque':'\ud83d\udd4c',
1845    'motor_boat':'\ud83d\udee5',
1846    'motor_scooter':'\ud83d\udef5',
1847    'motorcycle':'\ud83c\udfcd',
1848    'motorway':'\ud83d\udee3',
1849    'mount_fuji':'\ud83d\uddfb',
1850    'mountain':'\u26f0',
1851    'mountain_biking_man':'\ud83d\udeb5',
1852    'mountain_biking_woman':'\ud83d\udeb5&zwj;\u2640\ufe0f',
1853    'mountain_cableway':'\ud83d\udea0',
1854    'mountain_railway':'\ud83d\ude9e',
1855    'mountain_snow':'\ud83c\udfd4',
1856    'mouse':'\ud83d\udc2d',
1857    'mouse2':'\ud83d\udc01',
1858    'movie_camera':'\ud83c\udfa5',
1859    'moyai':'\ud83d\uddff',
1860    'mrs_claus':'\ud83e\udd36',
1861    'muscle':'\ud83d\udcaa',
1862    'mushroom':'\ud83c\udf44',
1863    'musical_keyboard':'\ud83c\udfb9',
1864    'musical_note':'\ud83c\udfb5',
1865    'musical_score':'\ud83c\udfbc',
1866    'mute':'\ud83d\udd07',
1867    'nail_care':'\ud83d\udc85',
1868    'name_badge':'\ud83d\udcdb',
1869    'national_park':'\ud83c\udfde',
1870    'nauseated_face':'\ud83e\udd22',
1871    'necktie':'\ud83d\udc54',
1872    'negative_squared_cross_mark':'\u274e',
1873    'nerd_face':'\ud83e\udd13',
1874    'neutral_face':'\ud83d\ude10',
1875    'new':'\ud83c\udd95',
1876    'new_moon':'\ud83c\udf11',
1877    'new_moon_with_face':'\ud83c\udf1a',
1878    'newspaper':'\ud83d\udcf0',
1879    'newspaper_roll':'\ud83d\uddde',
1880    'next_track_button':'\u23ed',
1881    'ng':'\ud83c\udd96',
1882    'no_good_man':'\ud83d\ude45&zwj;\u2642\ufe0f',
1883    'no_good_woman':'\ud83d\ude45',
1884    'night_with_stars':'\ud83c\udf03',
1885    'no_bell':'\ud83d\udd15',
1886    'no_bicycles':'\ud83d\udeb3',
1887    'no_entry':'\u26d4\ufe0f',
1888    'no_entry_sign':'\ud83d\udeab',
1889    'no_mobile_phones':'\ud83d\udcf5',
1890    'no_mouth':'\ud83d\ude36',
1891    'no_pedestrians':'\ud83d\udeb7',
1892    'no_smoking':'\ud83d\udead',
1893    'non-potable_water':'\ud83d\udeb1',
1894    'nose':'\ud83d\udc43',
1895    'notebook':'\ud83d\udcd3',
1896    'notebook_with_decorative_cover':'\ud83d\udcd4',
1897    'notes':'\ud83c\udfb6',
1898    'nut_and_bolt':'\ud83d\udd29',
1899    'o':'\u2b55\ufe0f',
1900    'o2':'\ud83c\udd7e\ufe0f',
1901    'ocean':'\ud83c\udf0a',
1902    'octopus':'\ud83d\udc19',
1903    'oden':'\ud83c\udf62',
1904    'office':'\ud83c\udfe2',
1905    'oil_drum':'\ud83d\udee2',
1906    'ok':'\ud83c\udd97',
1907    'ok_hand':'\ud83d\udc4c',
1908    'ok_man':'\ud83d\ude46&zwj;\u2642\ufe0f',
1909    'ok_woman':'\ud83d\ude46',
1910    'old_key':'\ud83d\udddd',
1911    'older_man':'\ud83d\udc74',
1912    'older_woman':'\ud83d\udc75',
1913    'om':'\ud83d\udd49',
1914    'on':'\ud83d\udd1b',
1915    'oncoming_automobile':'\ud83d\ude98',
1916    'oncoming_bus':'\ud83d\ude8d',
1917    'oncoming_police_car':'\ud83d\ude94',
1918    'oncoming_taxi':'\ud83d\ude96',
1919    'open_file_folder':'\ud83d\udcc2',
1920    'open_hands':'\ud83d\udc50',
1921    'open_mouth':'\ud83d\ude2e',
1922    'open_umbrella':'\u2602\ufe0f',
1923    'ophiuchus':'\u26ce',
1924    'orange_book':'\ud83d\udcd9',
1925    'orthodox_cross':'\u2626\ufe0f',
1926    'outbox_tray':'\ud83d\udce4',
1927    'owl':'\ud83e\udd89',
1928    'ox':'\ud83d\udc02',
1929    'package':'\ud83d\udce6',
1930    'page_facing_up':'\ud83d\udcc4',
1931    'page_with_curl':'\ud83d\udcc3',
1932    'pager':'\ud83d\udcdf',
1933    'paintbrush':'\ud83d\udd8c',
1934    'palm_tree':'\ud83c\udf34',
1935    'pancakes':'\ud83e\udd5e',
1936    'panda_face':'\ud83d\udc3c',
1937    'paperclip':'\ud83d\udcce',
1938    'paperclips':'\ud83d\udd87',
1939    'parasol_on_ground':'\u26f1',
1940    'parking':'\ud83c\udd7f\ufe0f',
1941    'part_alternation_mark':'\u303d\ufe0f',
1942    'partly_sunny':'\u26c5\ufe0f',
1943    'passenger_ship':'\ud83d\udef3',
1944    'passport_control':'\ud83d\udec2',
1945    'pause_button':'\u23f8',
1946    'peace_symbol':'\u262e\ufe0f',
1947    'peach':'\ud83c\udf51',
1948    'peanuts':'\ud83e\udd5c',
1949    'pear':'\ud83c\udf50',
1950    'pen':'\ud83d\udd8a',
1951    'pencil2':'\u270f\ufe0f',
1952    'penguin':'\ud83d\udc27',
1953    'pensive':'\ud83d\ude14',
1954    'performing_arts':'\ud83c\udfad',
1955    'persevere':'\ud83d\ude23',
1956    'person_fencing':'\ud83e\udd3a',
1957    'pouting_woman':'\ud83d\ude4e',
1958    'phone':'\u260e\ufe0f',
1959    'pick':'\u26cf',
1960    'pig':'\ud83d\udc37',
1961    'pig2':'\ud83d\udc16',
1962    'pig_nose':'\ud83d\udc3d',
1963    'pill':'\ud83d\udc8a',
1964    'pineapple':'\ud83c\udf4d',
1965    'ping_pong':'\ud83c\udfd3',
1966    'pisces':'\u2653\ufe0f',
1967    'pizza':'\ud83c\udf55',
1968    'place_of_worship':'\ud83d\uded0',
1969    'plate_with_cutlery':'\ud83c\udf7d',
1970    'play_or_pause_button':'\u23ef',
1971    'point_down':'\ud83d\udc47',
1972    'point_left':'\ud83d\udc48',
1973    'point_right':'\ud83d\udc49',
1974    'point_up':'\u261d\ufe0f',
1975    'point_up_2':'\ud83d\udc46',
1976    'police_car':'\ud83d\ude93',
1977    'policewoman':'\ud83d\udc6e&zwj;\u2640\ufe0f',
1978    'poodle':'\ud83d\udc29',
1979    'popcorn':'\ud83c\udf7f',
1980    'post_office':'\ud83c\udfe3',
1981    'postal_horn':'\ud83d\udcef',
1982    'postbox':'\ud83d\udcee',
1983    'potable_water':'\ud83d\udeb0',
1984    'potato':'\ud83e\udd54',
1985    'pouch':'\ud83d\udc5d',
1986    'poultry_leg':'\ud83c\udf57',
1987    'pound':'\ud83d\udcb7',
1988    'rage':'\ud83d\ude21',
1989    'pouting_cat':'\ud83d\ude3e',
1990    'pouting_man':'\ud83d\ude4e&zwj;\u2642\ufe0f',
1991    'pray':'\ud83d\ude4f',
1992    'prayer_beads':'\ud83d\udcff',
1993    'pregnant_woman':'\ud83e\udd30',
1994    'previous_track_button':'\u23ee',
1995    'prince':'\ud83e\udd34',
1996    'princess':'\ud83d\udc78',
1997    'printer':'\ud83d\udda8',
1998    'purple_heart':'\ud83d\udc9c',
1999    'purse':'\ud83d\udc5b',
2000    'pushpin':'\ud83d\udccc',
2001    'put_litter_in_its_place':'\ud83d\udeae',
2002    'question':'\u2753',
2003    'rabbit':'\ud83d\udc30',
2004    'rabbit2':'\ud83d\udc07',
2005    'racehorse':'\ud83d\udc0e',
2006    'racing_car':'\ud83c\udfce',
2007    'radio':'\ud83d\udcfb',
2008    'radio_button':'\ud83d\udd18',
2009    'radioactive':'\u2622\ufe0f',
2010    'railway_car':'\ud83d\ude83',
2011    'railway_track':'\ud83d\udee4',
2012    'rainbow':'\ud83c\udf08',
2013    'rainbow_flag':'\ud83c\udff3\ufe0f&zwj;\ud83c\udf08',
2014    'raised_back_of_hand':'\ud83e\udd1a',
2015    'raised_hand_with_fingers_splayed':'\ud83d\udd90',
2016    'raised_hands':'\ud83d\ude4c',
2017    'raising_hand_woman':'\ud83d\ude4b',
2018    'raising_hand_man':'\ud83d\ude4b&zwj;\u2642\ufe0f',
2019    'ram':'\ud83d\udc0f',
2020    'ramen':'\ud83c\udf5c',
2021    'rat':'\ud83d\udc00',
2022    'record_button':'\u23fa',
2023    'recycle':'\u267b\ufe0f',
2024    'red_circle':'\ud83d\udd34',
2025    'registered':'\u00ae\ufe0f',
2026    'relaxed':'\u263a\ufe0f',
2027    'relieved':'\ud83d\ude0c',
2028    'reminder_ribbon':'\ud83c\udf97',
2029    'repeat':'\ud83d\udd01',
2030    'repeat_one':'\ud83d\udd02',
2031    'rescue_worker_helmet':'\u26d1',
2032    'restroom':'\ud83d\udebb',
2033    'revolving_hearts':'\ud83d\udc9e',
2034    'rewind':'\u23ea',
2035    'rhinoceros':'\ud83e\udd8f',
2036    'ribbon':'\ud83c\udf80',
2037    'rice':'\ud83c\udf5a',
2038    'rice_ball':'\ud83c\udf59',
2039    'rice_cracker':'\ud83c\udf58',
2040    'rice_scene':'\ud83c\udf91',
2041    'right_anger_bubble':'\ud83d\uddef',
2042    'ring':'\ud83d\udc8d',
2043    'robot':'\ud83e\udd16',
2044    'rocket':'\ud83d\ude80',
2045    'rofl':'\ud83e\udd23',
2046    'roll_eyes':'\ud83d\ude44',
2047    'roller_coaster':'\ud83c\udfa2',
2048    'rooster':'\ud83d\udc13',
2049    'rose':'\ud83c\udf39',
2050    'rosette':'\ud83c\udff5',
2051    'rotating_light':'\ud83d\udea8',
2052    'round_pushpin':'\ud83d\udccd',
2053    'rowing_man':'\ud83d\udea3',
2054    'rowing_woman':'\ud83d\udea3&zwj;\u2640\ufe0f',
2055    'rugby_football':'\ud83c\udfc9',
2056    'running_man':'\ud83c\udfc3',
2057    'running_shirt_with_sash':'\ud83c\udfbd',
2058    'running_woman':'\ud83c\udfc3&zwj;\u2640\ufe0f',
2059    'sa':'\ud83c\ude02\ufe0f',
2060    'sagittarius':'\u2650\ufe0f',
2061    'sake':'\ud83c\udf76',
2062    'sandal':'\ud83d\udc61',
2063    'santa':'\ud83c\udf85',
2064    'satellite':'\ud83d\udce1',
2065    'saxophone':'\ud83c\udfb7',
2066    'school':'\ud83c\udfeb',
2067    'school_satchel':'\ud83c\udf92',
2068    'scissors':'\u2702\ufe0f',
2069    'scorpion':'\ud83e\udd82',
2070    'scorpius':'\u264f\ufe0f',
2071    'scream':'\ud83d\ude31',
2072    'scream_cat':'\ud83d\ude40',
2073    'scroll':'\ud83d\udcdc',
2074    'seat':'\ud83d\udcba',
2075    'secret':'\u3299\ufe0f',
2076    'see_no_evil':'\ud83d\ude48',
2077    'seedling':'\ud83c\udf31',
2078    'selfie':'\ud83e\udd33',
2079    'shallow_pan_of_food':'\ud83e\udd58',
2080    'shamrock':'\u2618\ufe0f',
2081    'shark':'\ud83e\udd88',
2082    'shaved_ice':'\ud83c\udf67',
2083    'sheep':'\ud83d\udc11',
2084    'shell':'\ud83d\udc1a',
2085    'shield':'\ud83d\udee1',
2086    'shinto_shrine':'\u26e9',
2087    'ship':'\ud83d\udea2',
2088    'shirt':'\ud83d\udc55',
2089    'shopping':'\ud83d\udecd',
2090    'shopping_cart':'\ud83d\uded2',
2091    'shower':'\ud83d\udebf',
2092    'shrimp':'\ud83e\udd90',
2093    'signal_strength':'\ud83d\udcf6',
2094    'six_pointed_star':'\ud83d\udd2f',
2095    'ski':'\ud83c\udfbf',
2096    'skier':'\u26f7',
2097    'skull':'\ud83d\udc80',
2098    'skull_and_crossbones':'\u2620\ufe0f',
2099    'sleeping':'\ud83d\ude34',
2100    'sleeping_bed':'\ud83d\udecc',
2101    'sleepy':'\ud83d\ude2a',
2102    'slightly_frowning_face':'\ud83d\ude41',
2103    'slightly_smiling_face':'\ud83d\ude42',
2104    'slot_machine':'\ud83c\udfb0',
2105    'small_airplane':'\ud83d\udee9',
2106    'small_blue_diamond':'\ud83d\udd39',
2107    'small_orange_diamond':'\ud83d\udd38',
2108    'small_red_triangle':'\ud83d\udd3a',
2109    'small_red_triangle_down':'\ud83d\udd3b',
2110    'smile':'\ud83d\ude04',
2111    'smile_cat':'\ud83d\ude38',
2112    'smiley':'\ud83d\ude03',
2113    'smiley_cat':'\ud83d\ude3a',
2114    'smiling_imp':'\ud83d\ude08',
2115    'smirk':'\ud83d\ude0f',
2116    'smirk_cat':'\ud83d\ude3c',
2117    'smoking':'\ud83d\udeac',
2118    'snail':'\ud83d\udc0c',
2119    'snake':'\ud83d\udc0d',
2120    'sneezing_face':'\ud83e\udd27',
2121    'snowboarder':'\ud83c\udfc2',
2122    'snowflake':'\u2744\ufe0f',
2123    'snowman':'\u26c4\ufe0f',
2124    'snowman_with_snow':'\u2603\ufe0f',
2125    'sob':'\ud83d\ude2d',
2126    'soccer':'\u26bd\ufe0f',
2127    'soon':'\ud83d\udd1c',
2128    'sos':'\ud83c\udd98',
2129    'sound':'\ud83d\udd09',
2130    'space_invader':'\ud83d\udc7e',
2131    'spades':'\u2660\ufe0f',
2132    'spaghetti':'\ud83c\udf5d',
2133    'sparkle':'\u2747\ufe0f',
2134    'sparkler':'\ud83c\udf87',
2135    'sparkles':'\u2728',
2136    'sparkling_heart':'\ud83d\udc96',
2137    'speak_no_evil':'\ud83d\ude4a',
2138    'speaker':'\ud83d\udd08',
2139    'speaking_head':'\ud83d\udde3',
2140    'speech_balloon':'\ud83d\udcac',
2141    'speedboat':'\ud83d\udea4',
2142    'spider':'\ud83d\udd77',
2143    'spider_web':'\ud83d\udd78',
2144    'spiral_calendar':'\ud83d\uddd3',
2145    'spiral_notepad':'\ud83d\uddd2',
2146    'spoon':'\ud83e\udd44',
2147    'squid':'\ud83e\udd91',
2148    'stadium':'\ud83c\udfdf',
2149    'star':'\u2b50\ufe0f',
2150    'star2':'\ud83c\udf1f',
2151    'star_and_crescent':'\u262a\ufe0f',
2152    'star_of_david':'\u2721\ufe0f',
2153    'stars':'\ud83c\udf20',
2154    'station':'\ud83d\ude89',
2155    'statue_of_liberty':'\ud83d\uddfd',
2156    'steam_locomotive':'\ud83d\ude82',
2157    'stew':'\ud83c\udf72',
2158    'stop_button':'\u23f9',
2159    'stop_sign':'\ud83d\uded1',
2160    'stopwatch':'\u23f1',
2161    'straight_ruler':'\ud83d\udccf',
2162    'strawberry':'\ud83c\udf53',
2163    'stuck_out_tongue':'\ud83d\ude1b',
2164    'stuck_out_tongue_closed_eyes':'\ud83d\ude1d',
2165    'stuck_out_tongue_winking_eye':'\ud83d\ude1c',
2166    'studio_microphone':'\ud83c\udf99',
2167    'stuffed_flatbread':'\ud83e\udd59',
2168    'sun_behind_large_cloud':'\ud83c\udf25',
2169    'sun_behind_rain_cloud':'\ud83c\udf26',
2170    'sun_behind_small_cloud':'\ud83c\udf24',
2171    'sun_with_face':'\ud83c\udf1e',
2172    'sunflower':'\ud83c\udf3b',
2173    'sunglasses':'\ud83d\ude0e',
2174    'sunny':'\u2600\ufe0f',
2175    'sunrise':'\ud83c\udf05',
2176    'sunrise_over_mountains':'\ud83c\udf04',
2177    'surfing_man':'\ud83c\udfc4',
2178    'surfing_woman':'\ud83c\udfc4&zwj;\u2640\ufe0f',
2179    'sushi':'\ud83c\udf63',
2180    'suspension_railway':'\ud83d\ude9f',
2181    'sweat':'\ud83d\ude13',
2182    'sweat_drops':'\ud83d\udca6',
2183    'sweat_smile':'\ud83d\ude05',
2184    'sweet_potato':'\ud83c\udf60',
2185    'swimming_man':'\ud83c\udfca',
2186    'swimming_woman':'\ud83c\udfca&zwj;\u2640\ufe0f',
2187    'symbols':'\ud83d\udd23',
2188    'synagogue':'\ud83d\udd4d',
2189    'syringe':'\ud83d\udc89',
2190    'taco':'\ud83c\udf2e',
2191    'tada':'\ud83c\udf89',
2192    'tanabata_tree':'\ud83c\udf8b',
2193    'taurus':'\u2649\ufe0f',
2194    'taxi':'\ud83d\ude95',
2195    'tea':'\ud83c\udf75',
2196    'telephone_receiver':'\ud83d\udcde',
2197    'telescope':'\ud83d\udd2d',
2198    'tennis':'\ud83c\udfbe',
2199    'tent':'\u26fa\ufe0f',
2200    'thermometer':'\ud83c\udf21',
2201    'thinking':'\ud83e\udd14',
2202    'thought_balloon':'\ud83d\udcad',
2203    'ticket':'\ud83c\udfab',
2204    'tickets':'\ud83c\udf9f',
2205    'tiger':'\ud83d\udc2f',
2206    'tiger2':'\ud83d\udc05',
2207    'timer_clock':'\u23f2',
2208    'tipping_hand_man':'\ud83d\udc81&zwj;\u2642\ufe0f',
2209    'tired_face':'\ud83d\ude2b',
2210    'tm':'\u2122\ufe0f',
2211    'toilet':'\ud83d\udebd',
2212    'tokyo_tower':'\ud83d\uddfc',
2213    'tomato':'\ud83c\udf45',
2214    'tongue':'\ud83d\udc45',
2215    'top':'\ud83d\udd1d',
2216    'tophat':'\ud83c\udfa9',
2217    'tornado':'\ud83c\udf2a',
2218    'trackball':'\ud83d\uddb2',
2219    'tractor':'\ud83d\ude9c',
2220    'traffic_light':'\ud83d\udea5',
2221    'train':'\ud83d\ude8b',
2222    'train2':'\ud83d\ude86',
2223    'tram':'\ud83d\ude8a',
2224    'triangular_flag_on_post':'\ud83d\udea9',
2225    'triangular_ruler':'\ud83d\udcd0',
2226    'trident':'\ud83d\udd31',
2227    'triumph':'\ud83d\ude24',
2228    'trolleybus':'\ud83d\ude8e',
2229    'trophy':'\ud83c\udfc6',
2230    'tropical_drink':'\ud83c\udf79',
2231    'tropical_fish':'\ud83d\udc20',
2232    'truck':'\ud83d\ude9a',
2233    'trumpet':'\ud83c\udfba',
2234    'tulip':'\ud83c\udf37',
2235    'tumbler_glass':'\ud83e\udd43',
2236    'turkey':'\ud83e\udd83',
2237    'turtle':'\ud83d\udc22',
2238    'tv':'\ud83d\udcfa',
2239    'twisted_rightwards_arrows':'\ud83d\udd00',
2240    'two_hearts':'\ud83d\udc95',
2241    'two_men_holding_hands':'\ud83d\udc6c',
2242    'two_women_holding_hands':'\ud83d\udc6d',
2243    'u5272':'\ud83c\ude39',
2244    'u5408':'\ud83c\ude34',
2245    'u55b6':'\ud83c\ude3a',
2246    'u6307':'\ud83c\ude2f\ufe0f',
2247    'u6708':'\ud83c\ude37\ufe0f',
2248    'u6709':'\ud83c\ude36',
2249    'u6e80':'\ud83c\ude35',
2250    'u7121':'\ud83c\ude1a\ufe0f',
2251    'u7533':'\ud83c\ude38',
2252    'u7981':'\ud83c\ude32',
2253    'u7a7a':'\ud83c\ude33',
2254    'umbrella':'\u2614\ufe0f',
2255    'unamused':'\ud83d\ude12',
2256    'underage':'\ud83d\udd1e',
2257    'unicorn':'\ud83e\udd84',
2258    'unlock':'\ud83d\udd13',
2259    'up':'\ud83c\udd99',
2260    'upside_down_face':'\ud83d\ude43',
2261    'v':'\u270c\ufe0f',
2262    'vertical_traffic_light':'\ud83d\udea6',
2263    'vhs':'\ud83d\udcfc',
2264    'vibration_mode':'\ud83d\udcf3',
2265    'video_camera':'\ud83d\udcf9',
2266    'video_game':'\ud83c\udfae',
2267    'violin':'\ud83c\udfbb',
2268    'virgo':'\u264d\ufe0f',
2269    'volcano':'\ud83c\udf0b',
2270    'volleyball':'\ud83c\udfd0',
2271    'vs':'\ud83c\udd9a',
2272    'vulcan_salute':'\ud83d\udd96',
2273    'walking_man':'\ud83d\udeb6',
2274    'walking_woman':'\ud83d\udeb6&zwj;\u2640\ufe0f',
2275    'waning_crescent_moon':'\ud83c\udf18',
2276    'waning_gibbous_moon':'\ud83c\udf16',
2277    'warning':'\u26a0\ufe0f',
2278    'wastebasket':'\ud83d\uddd1',
2279    'watch':'\u231a\ufe0f',
2280    'water_buffalo':'\ud83d\udc03',
2281    'watermelon':'\ud83c\udf49',
2282    'wave':'\ud83d\udc4b',
2283    'wavy_dash':'\u3030\ufe0f',
2284    'waxing_crescent_moon':'\ud83c\udf12',
2285    'wc':'\ud83d\udebe',
2286    'weary':'\ud83d\ude29',
2287    'wedding':'\ud83d\udc92',
2288    'weight_lifting_man':'\ud83c\udfcb\ufe0f',
2289    'weight_lifting_woman':'\ud83c\udfcb\ufe0f&zwj;\u2640\ufe0f',
2290    'whale':'\ud83d\udc33',
2291    'whale2':'\ud83d\udc0b',
2292    'wheel_of_dharma':'\u2638\ufe0f',
2293    'wheelchair':'\u267f\ufe0f',
2294    'white_check_mark':'\u2705',
2295    'white_circle':'\u26aa\ufe0f',
2296    'white_flag':'\ud83c\udff3\ufe0f',
2297    'white_flower':'\ud83d\udcae',
2298    'white_large_square':'\u2b1c\ufe0f',
2299    'white_medium_small_square':'\u25fd\ufe0f',
2300    'white_medium_square':'\u25fb\ufe0f',
2301    'white_small_square':'\u25ab\ufe0f',
2302    'white_square_button':'\ud83d\udd33',
2303    'wilted_flower':'\ud83e\udd40',
2304    'wind_chime':'\ud83c\udf90',
2305    'wind_face':'\ud83c\udf2c',
2306    'wine_glass':'\ud83c\udf77',
2307    'wink':'\ud83d\ude09',
2308    'wolf':'\ud83d\udc3a',
2309    'woman':'\ud83d\udc69',
2310    'woman_artist':'\ud83d\udc69&zwj;\ud83c\udfa8',
2311    'woman_astronaut':'\ud83d\udc69&zwj;\ud83d\ude80',
2312    'woman_cartwheeling':'\ud83e\udd38&zwj;\u2640\ufe0f',
2313    'woman_cook':'\ud83d\udc69&zwj;\ud83c\udf73',
2314    'woman_facepalming':'\ud83e\udd26&zwj;\u2640\ufe0f',
2315    'woman_factory_worker':'\ud83d\udc69&zwj;\ud83c\udfed',
2316    'woman_farmer':'\ud83d\udc69&zwj;\ud83c\udf3e',
2317    'woman_firefighter':'\ud83d\udc69&zwj;\ud83d\ude92',
2318    'woman_health_worker':'\ud83d\udc69&zwj;\u2695\ufe0f',
2319    'woman_judge':'\ud83d\udc69&zwj;\u2696\ufe0f',
2320    'woman_juggling':'\ud83e\udd39&zwj;\u2640\ufe0f',
2321    'woman_mechanic':'\ud83d\udc69&zwj;\ud83d\udd27',
2322    'woman_office_worker':'\ud83d\udc69&zwj;\ud83d\udcbc',
2323    'woman_pilot':'\ud83d\udc69&zwj;\u2708\ufe0f',
2324    'woman_playing_handball':'\ud83e\udd3e&zwj;\u2640\ufe0f',
2325    'woman_playing_water_polo':'\ud83e\udd3d&zwj;\u2640\ufe0f',
2326    'woman_scientist':'\ud83d\udc69&zwj;\ud83d\udd2c',
2327    'woman_shrugging':'\ud83e\udd37&zwj;\u2640\ufe0f',
2328    'woman_singer':'\ud83d\udc69&zwj;\ud83c\udfa4',
2329    'woman_student':'\ud83d\udc69&zwj;\ud83c\udf93',
2330    'woman_teacher':'\ud83d\udc69&zwj;\ud83c\udfeb',
2331    'woman_technologist':'\ud83d\udc69&zwj;\ud83d\udcbb',
2332    'woman_with_turban':'\ud83d\udc73&zwj;\u2640\ufe0f',
2333    'womans_clothes':'\ud83d\udc5a',
2334    'womans_hat':'\ud83d\udc52',
2335    'women_wrestling':'\ud83e\udd3c&zwj;\u2640\ufe0f',
2336    'womens':'\ud83d\udeba',
2337    'world_map':'\ud83d\uddfa',
2338    'worried':'\ud83d\ude1f',
2339    'wrench':'\ud83d\udd27',
2340    'writing_hand':'\u270d\ufe0f',
2341    'x':'\u274c',
2342    'yellow_heart':'\ud83d\udc9b',
2343    'yen':'\ud83d\udcb4',
2344    'yin_yang':'\u262f\ufe0f',
2345    'yum':'\ud83d\ude0b',
2346    'zap':'\u26a1\ufe0f',
2347    'zipper_mouth_face':'\ud83e\udd10',
2348    'zzz':'\ud83d\udca4',
2349  
2350    /* special emojis :P */
2351    'octocat':  '<img alt=":octocat:" height="20" width="20" align="absmiddle" src="https://assets-cdn.github.com/images/icons/emoji/octocat.png">',
2352    'showdown': '<span style="font-family: \'Anonymous Pro\', monospace; text-decoration: underline; text-decoration-style: dashed; text-decoration-color: #3e8b8a;text-underline-position: under;">S</span>'
2353  };
2354  
2355  /**
2356   * Created by Estevao on 31-05-2015.
2357   */
2358  
2359  /**
2360   * Showdown Converter class
2361   * @class
2362   * @param {object} [converterOptions]
2363   * @returns {Converter}
2364   */
2365  showdown.Converter = function (converterOptions) {
2366    'use strict';
2367  
2368    var
2369        /**
2370         * Options used by this converter
2371         * @private
2372         * @type {{}}
2373         */
2374        options = {},
2375  
2376        /**
2377         * Language extensions used by this converter
2378         * @private
2379         * @type {Array}
2380         */
2381        langExtensions = [],
2382  
2383        /**
2384         * Output modifiers extensions used by this converter
2385         * @private
2386         * @type {Array}
2387         */
2388        outputModifiers = [],
2389  
2390        /**
2391         * Event listeners
2392         * @private
2393         * @type {{}}
2394         */
2395        listeners = {},
2396  
2397        /**
2398         * The flavor set in this converter
2399         */
2400        setConvFlavor = setFlavor,
2401  
2402        /**
2403         * Metadata of the document
2404         * @type {{parsed: {}, raw: string, format: string}}
2405         */
2406        metadata = {
2407          parsed: {},
2408          raw: '',
2409          format: ''
2410        };
2411  
2412    _constructor();
2413  
2414    /**
2415     * Converter constructor
2416     * @private
2417     */
2418    function _constructor () {
2419      converterOptions = converterOptions || {};
2420  
2421      for (var gOpt in globalOptions) {
2422        if (globalOptions.hasOwnProperty(gOpt)) {
2423          options[gOpt] = globalOptions[gOpt];
2424        }
2425      }
2426  
2427      // Merge options
2428      if (typeof converterOptions === 'object') {
2429        for (var opt in converterOptions) {
2430          if (converterOptions.hasOwnProperty(opt)) {
2431            options[opt] = converterOptions[opt];
2432          }
2433        }
2434      } else {
2435        throw Error('Converter expects the passed parameter to be an object, but ' + typeof converterOptions +
2436        ' was passed instead.');
2437      }
2438  
2439      if (options.extensions) {
2440        showdown.helper.forEach(options.extensions, _parseExtension);
2441      }
2442    }
2443  
2444    /**
2445     * Parse extension
2446     * @param {*} ext
2447     * @param {string} [name='']
2448     * @private
2449     */
2450    function _parseExtension (ext, name) {
2451  
2452      name = name || null;
2453      // If it's a string, the extension was previously loaded
2454      if (showdown.helper.isString(ext)) {
2455        ext = showdown.helper.stdExtName(ext);
2456        name = ext;
2457  
2458        // LEGACY_SUPPORT CODE
2459        if (showdown.extensions[ext]) {
2460          console.warn('DEPRECATION WARNING: ' + ext + ' is an old extension that uses a deprecated loading method.' +
2461            'Please inform the developer that the extension should be updated!');
2462          legacyExtensionLoading(showdown.extensions[ext], ext);
2463          return;
2464          // END LEGACY SUPPORT CODE
2465  
2466        } else if (!showdown.helper.isUndefined(extensions[ext])) {
2467          ext = extensions[ext];
2468  
2469        } else {
2470          throw Error('Extension "' + ext + '" could not be loaded. It was either not found or is not a valid extension.');
2471        }
2472      }
2473  
2474      if (typeof ext === 'function') {
2475        ext = ext();
2476      }
2477  
2478      if (!showdown.helper.isArray(ext)) {
2479        ext = [ext];
2480      }
2481  
2482      var validExt = validate(ext, name);
2483      if (!validExt.valid) {
2484        throw Error(validExt.error);
2485      }
2486  
2487      for (var i = 0; i < ext.length; ++i) {
2488        switch (ext[i].type) {
2489  
2490          case 'lang':
2491            langExtensions.push(ext[i]);
2492            break;
2493  
2494          case 'output':
2495            outputModifiers.push(ext[i]);
2496            break;
2497        }
2498        if (ext[i].hasOwnProperty('listeners')) {
2499          for (var ln in ext[i].listeners) {
2500            if (ext[i].listeners.hasOwnProperty(ln)) {
2501              listen(ln, ext[i].listeners[ln]);
2502            }
2503          }
2504        }
2505      }
2506  
2507    }
2508  
2509    /**
2510     * LEGACY_SUPPORT
2511     * @param {*} ext
2512     * @param {string} name
2513     */
2514    function legacyExtensionLoading (ext, name) {
2515      if (typeof ext === 'function') {
2516        ext = ext(new showdown.Converter());
2517      }
2518      if (!showdown.helper.isArray(ext)) {
2519        ext = [ext];
2520      }
2521      var valid = validate(ext, name);
2522  
2523      if (!valid.valid) {
2524        throw Error(valid.error);
2525      }
2526  
2527      for (var i = 0; i < ext.length; ++i) {
2528        switch (ext[i].type) {
2529          case 'lang':
2530            langExtensions.push(ext[i]);
2531            break;
2532          case 'output':
2533            outputModifiers.push(ext[i]);
2534            break;
2535          default:// should never reach here
2536            throw Error('Extension loader error: Type unrecognized!!!');
2537        }
2538      }
2539    }
2540  
2541    /**
2542     * Listen to an event
2543     * @param {string} name
2544     * @param {function} callback
2545     */
2546    function listen (name, callback) {
2547      if (!showdown.helper.isString(name)) {
2548        throw Error('Invalid argument in converter.listen() method: name must be a string, but ' + typeof name + ' given');
2549      }
2550  
2551      if (typeof callback !== 'function') {
2552        throw Error('Invalid argument in converter.listen() method: callback must be a function, but ' + typeof callback + ' given');
2553      }
2554  
2555      if (!listeners.hasOwnProperty(name)) {
2556        listeners[name] = [];
2557      }
2558      listeners[name].push(callback);
2559    }
2560  
2561    function rTrimInputText (text) {
2562      var rsp = text.match(/^\s*/)[0].length,
2563          rgx = new RegExp('^\\s{0,' + rsp + '}', 'gm');
2564      return text.replace(rgx, '');
2565    }
2566  
2567    /**
2568     * Dispatch an event
2569     * @private
2570     * @param {string} evtName Event name
2571     * @param {string} text Text
2572     * @param {{}} options Converter Options
2573     * @param {{}} globals
2574     * @returns {string}
2575     */
2576    this._dispatch = function dispatch (evtName, text, options, globals) {
2577      if (listeners.hasOwnProperty(evtName)) {
2578        for (var ei = 0; ei < listeners[evtName].length; ++ei) {
2579          var nText = listeners[evtName][ei](evtName, text, this, options, globals);
2580          if (nText && typeof nText !== 'undefined') {
2581            text = nText;
2582          }
2583        }
2584      }
2585      return text;
2586    };
2587  
2588    /**
2589     * Listen to an event
2590     * @param {string} name
2591     * @param {function} callback
2592     * @returns {showdown.Converter}
2593     */
2594    this.listen = function (name, callback) {
2595      listen(name, callback);
2596      return this;
2597    };
2598  
2599    /**
2600     * Converts a markdown string into HTML
2601     * @param {string} text
2602     * @returns {*}
2603     */
2604    this.makeHtml = function (text) {
2605      //check if text is not falsy
2606      if (!text) {
2607        return text;
2608      }
2609  
2610      var globals = {
2611        gHtmlBlocks:     [],
2612        gHtmlMdBlocks:   [],
2613        gHtmlSpans:      [],
2614        gUrls:           {},
2615        gTitles:         {},
2616        gDimensions:     {},
2617        gListLevel:      0,
2618        hashLinkCounts:  {},
2619        langExtensions:  langExtensions,
2620        outputModifiers: outputModifiers,
2621        converter:       this,
2622        ghCodeBlocks:    [],
2623        metadata: {
2624          parsed: {},
2625          raw: '',
2626          format: ''
2627        }
2628      };
2629  
2630      // This lets us use ¨ trema as an escape char to avoid md5 hashes
2631      // The choice of character is arbitrary; anything that isn't
2632      // magic in Markdown will work.
2633      text = text.replace(/¨/g, '¨T');
2634  
2635      // Replace $ with ¨D
2636      // RegExp interprets $ as a special character
2637      // when it's in a replacement string
2638      text = text.replace(/\$/g, '¨D');
2639  
2640      // Standardize line endings
2641      text = text.replace(/\r\n/g, '\n'); // DOS to Unix
2642      text = text.replace(/\r/g, '\n'); // Mac to Unix
2643  
2644      // Stardardize line spaces
2645      text = text.replace(/\u00A0/g, '&nbsp;');
2646  
2647      if (options.smartIndentationFix) {
2648        text = rTrimInputText(text);
2649      }
2650  
2651      // Make sure text begins and ends with a couple of newlines:
2652      text = '\n\n' + text + '\n\n';
2653  
2654      // detab
2655      text = showdown.subParser('detab')(text, options, globals);
2656  
2657      /**
2658       * Strip any lines consisting only of spaces and tabs.
2659       * This makes subsequent regexs easier to write, because we can
2660       * match consecutive blank lines with /\n+/ instead of something
2661       * contorted like /[ \t]*\n+/
2662       */
2663      text = text.replace(/^[ \t]+$/mg, '');
2664  
2665      //run languageExtensions
2666      showdown.helper.forEach(langExtensions, function (ext) {
2667        text = showdown.subParser('runExtension')(ext, text, options, globals);
2668      });
2669  
2670      // run the sub parsers
2671      text = showdown.subParser('metadata')(text, options, globals);
2672      text = showdown.subParser('hashPreCodeTags')(text, options, globals);
2673      text = showdown.subParser('githubCodeBlocks')(text, options, globals);
2674      text = showdown.subParser('hashHTMLBlocks')(text, options, globals);
2675      text = showdown.subParser('hashCodeTags')(text, options, globals);
2676      text = showdown.subParser('stripLinkDefinitions')(text, options, globals);
2677      text = showdown.subParser('blockGamut')(text, options, globals);
2678      text = showdown.subParser('unhashHTMLSpans')(text, options, globals);
2679      text = showdown.subParser('unescapeSpecialChars')(text, options, globals);
2680  
2681      // attacklab: Restore dollar signs
2682      text = text.replace(/¨D/g, '$$');
2683  
2684      // attacklab: Restore tremas
2685      text = text.replace(/¨T/g, '¨');
2686  
2687      // render a complete html document instead of a partial if the option is enabled
2688      text = showdown.subParser('completeHTMLDocument')(text, options, globals);
2689  
2690      // Run output modifiers
2691      showdown.helper.forEach(outputModifiers, function (ext) {
2692        text = showdown.subParser('runExtension')(ext, text, options, globals);
2693      });
2694  
2695      // update metadata
2696      metadata = globals.metadata;
2697      return text;
2698    };
2699  
2700    /**
2701     * Converts an HTML string into a markdown string
2702     * @param src
2703     * @param [HTMLParser] A WHATWG DOM and HTML parser, such as JSDOM. If none is supplied, window.document will be used.
2704     * @returns {string}
2705     */
2706    this.makeMarkdown = this.makeMd = function (src, HTMLParser) {
2707  
2708      // replace \r\n with \n
2709      src = src.replace(/\r\n/g, '\n');
2710      src = src.replace(/\r/g, '\n'); // old macs
2711  
2712      // due to an edge case, we need to find this: > <
2713      // to prevent removing of non silent white spaces
2714      // ex: <em>this is</em> <strong>sparta</strong>
2715      src = src.replace(/>[ \t]+</, '>¨NBSP;<');
2716  
2717      if (!HTMLParser) {
2718        if (window && window.document) {
2719          HTMLParser = window.document;
2720        } else {
2721          throw new Error('HTMLParser is undefined. If in a webworker or nodejs environment, you need to provide a WHATWG DOM and HTML such as JSDOM');
2722        }
2723      }
2724  
2725      var doc = HTMLParser.createElement('div');
2726      doc.innerHTML = src;
2727  
2728      var globals = {
2729        preList: substitutePreCodeTags(doc)
2730      };
2731  
2732      // remove all newlines and collapse spaces
2733      clean(doc);
2734  
2735      // some stuff, like accidental reference links must now be escaped
2736      // TODO
2737      // doc.innerHTML = doc.innerHTML.replace(/\[[\S\t ]]/);
2738  
2739      var nodes = doc.childNodes,
2740          mdDoc = '';
2741  
2742      for (var i = 0; i < nodes.length; i++) {
2743        mdDoc += showdown.subParser('makeMarkdown.node')(nodes[i], globals);
2744      }
2745  
2746      function clean (node) {
2747        for (var n = 0; n < node.childNodes.length; ++n) {
2748          var child = node.childNodes[n];
2749          if (child.nodeType === 3) {
2750            if (!/\S/.test(child.nodeValue)) {
2751              node.removeChild(child);
2752              --n;
2753            } else {
2754              child.nodeValue = child.nodeValue.split('\n').join(' ');
2755              child.nodeValue = child.nodeValue.replace(/(\s)+/g, '$1');
2756            }
2757          } else if (child.nodeType === 1) {
2758            clean(child);
2759          }
2760        }
2761      }
2762  
2763      // find all pre tags and replace contents with placeholder
2764      // we need this so that we can remove all indentation from html
2765      // to ease up parsing
2766      function substitutePreCodeTags (doc) {
2767  
2768        var pres = doc.querySelectorAll('pre'),
2769            presPH = [];
2770  
2771        for (var i = 0; i < pres.length; ++i) {
2772  
2773          if (pres[i].childElementCount === 1 && pres[i].firstChild.tagName.toLowerCase() === 'code') {
2774            var content = pres[i].firstChild.innerHTML.trim(),
2775                language = pres[i].firstChild.getAttribute('data-language') || '';
2776  
2777            // if data-language attribute is not defined, then we look for class language-*
2778            if (language === '') {
2779              var classes = pres[i].firstChild.className.split(' ');
2780              for (var c = 0; c < classes.length; ++c) {
2781                var matches = classes[c].match(/^language-(.+)$/);
2782                if (matches !== null) {
2783                  language = matches[1];
2784                  break;
2785                }
2786              }
2787            }
2788  
2789            // unescape html entities in content
2790            content = showdown.helper.unescapeHTMLEntities(content);
2791  
2792            presPH.push(content);
2793            pres[i].outerHTML = '<precode language="' + language + '" precodenum="' + i.toString() + '"></precode>';
2794          } else {
2795            presPH.push(pres[i].innerHTML);
2796            pres[i].innerHTML = '';
2797            pres[i].setAttribute('prenum', i.toString());
2798          }
2799        }
2800        return presPH;
2801      }
2802  
2803      return mdDoc;
2804    };
2805  
2806    /**
2807     * Set an option of this Converter instance
2808     * @param {string} key
2809     * @param {*} value
2810     */
2811    this.setOption = function (key, value) {
2812      options[key] = value;
2813    };
2814  
2815    /**
2816     * Get the option of this Converter instance
2817     * @param {string} key
2818     * @returns {*}
2819     */
2820    this.getOption = function (key) {
2821      return options[key];
2822    };
2823  
2824    /**
2825     * Get the options of this Converter instance
2826     * @returns {{}}
2827     */
2828    this.getOptions = function () {
2829      return options;
2830    };
2831  
2832    /**
2833     * Add extension to THIS converter
2834     * @param {{}} extension
2835     * @param {string} [name=null]
2836     */
2837    this.addExtension = function (extension, name) {
2838      name = name || null;
2839      _parseExtension(extension, name);
2840    };
2841  
2842    /**
2843     * Use a global registered extension with THIS converter
2844     * @param {string} extensionName Name of the previously registered extension
2845     */
2846    this.useExtension = function (extensionName) {
2847      _parseExtension(extensionName);
2848    };
2849  
2850    /**
2851     * Set the flavor THIS converter should use
2852     * @param {string} name
2853     */
2854    this.setFlavor = function (name) {
2855      if (!flavor.hasOwnProperty(name)) {
2856        throw Error(name + ' flavor was not found');
2857      }
2858      var preset = flavor[name];
2859      setConvFlavor = name;
2860      for (var option in preset) {
2861        if (preset.hasOwnProperty(option)) {
2862          options[option] = preset[option];
2863        }
2864      }
2865    };
2866  
2867    /**
2868     * Get the currently set flavor of this converter
2869     * @returns {string}
2870     */
2871    this.getFlavor = function () {
2872      return setConvFlavor;
2873    };
2874  
2875    /**
2876     * Remove an extension from THIS converter.
2877     * Note: This is a costly operation. It's better to initialize a new converter
2878     * and specify the extensions you wish to use
2879     * @param {Array} extension
2880     */
2881    this.removeExtension = function (extension) {
2882      if (!showdown.helper.isArray(extension)) {
2883        extension = [extension];
2884      }
2885      for (var a = 0; a < extension.length; ++a) {
2886        var ext = extension[a];
2887        for (var i = 0; i < langExtensions.length; ++i) {
2888          if (langExtensions[i] === ext) {
2889            langExtensions[i].splice(i, 1);
2890          }
2891        }
2892        for (var ii = 0; ii < outputModifiers.length; ++i) {
2893          if (outputModifiers[ii] === ext) {
2894            outputModifiers[ii].splice(i, 1);
2895          }
2896        }
2897      }
2898    };
2899  
2900    /**
2901     * Get all extension of THIS converter
2902     * @returns {{language: Array, output: Array}}
2903     */
2904    this.getAllExtensions = function () {
2905      return {
2906        language: langExtensions,
2907        output: outputModifiers
2908      };
2909    };
2910  
2911    /**
2912     * Get the metadata of the previously parsed document
2913     * @param raw
2914     * @returns {string|{}}
2915     */
2916    this.getMetadata = function (raw) {
2917      if (raw) {
2918        return metadata.raw;
2919      } else {
2920        return metadata.parsed;
2921      }
2922    };
2923  
2924    /**
2925     * Get the metadata format of the previously parsed document
2926     * @returns {string}
2927     */
2928    this.getMetadataFormat = function () {
2929      return metadata.format;
2930    };
2931  
2932    /**
2933     * Private: set a single key, value metadata pair
2934     * @param {string} key
2935     * @param {string} value
2936     */
2937    this._setMetadataPair = function (key, value) {
2938      metadata.parsed[key] = value;
2939    };
2940  
2941    /**
2942     * Private: set metadata format
2943     * @param {string} format
2944     */
2945    this._setMetadataFormat = function (format) {
2946      metadata.format = format;
2947    };
2948  
2949    /**
2950     * Private: set metadata raw text
2951     * @param {string} raw
2952     */
2953    this._setMetadataRaw = function (raw) {
2954      metadata.raw = raw;
2955    };
2956  };
2957  
2958  /**
2959   * Turn Markdown link shortcuts into XHTML <a> tags.
2960   */
2961  showdown.subParser('anchors', function (text, options, globals) {
2962    'use strict';
2963  
2964    text = globals.converter._dispatch('anchors.before', text, options, globals);
2965  
2966    var writeAnchorTag = function (wholeMatch, linkText, linkId, url, m5, m6, title) {
2967      if (showdown.helper.isUndefined(title)) {
2968        title = '';
2969      }
2970      linkId = linkId.toLowerCase();
2971  
2972      // Special case for explicit empty url
2973      if (wholeMatch.search(/\(<?\s*>? ?(['"].*['"])?\)$/m) > -1) {
2974        url = '';
2975      } else if (!url) {
2976        if (!linkId) {
2977          // lower-case and turn embedded newlines into spaces
2978          linkId = linkText.toLowerCase().replace(/ ?\n/g, ' ');
2979        }
2980        url = '#' + linkId;
2981  
2982        if (!showdown.helper.isUndefined(globals.gUrls[linkId])) {
2983          url = globals.gUrls[linkId];
2984          if (!showdown.helper.isUndefined(globals.gTitles[linkId])) {
2985            title = globals.gTitles[linkId];
2986          }
2987        } else {
2988          return wholeMatch;
2989        }
2990      }
2991  
2992      //url = showdown.helper.escapeCharacters(url, '*_', false); // replaced line to improve performance
2993      url = url.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
2994  
2995      var result = '<a href="' + url + '"';
2996  
2997      if (title !== '' && title !== null) {
2998        title = title.replace(/"/g, '&quot;');
2999        //title = showdown.helper.escapeCharacters(title, '*_', false); // replaced line to improve performance
3000        title = title.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
3001        result += ' title="' + title + '"';
3002      }
3003  
3004      // optionLinksInNewWindow only applies
3005      // to external links. Hash links (#) open in same page
3006      if (options.openLinksInNewWindow && !/^#/.test(url)) {
3007        // escaped _
3008        result += ' rel="noopener noreferrer" target="¨E95Eblank"';
3009      }
3010  
3011      result += '>' + linkText + '</a>';
3012  
3013      return result;
3014    };
3015  
3016    // First, handle reference-style links: [link text] [id]
3017    text = text.replace(/\[((?:\[[^\]]*]|[^\[\]])*)] ?(?:\n *)?\[(.*?)]()()()()/g, writeAnchorTag);
3018  
3019    // Next, inline-style links: [link text](url "optional title")
3020    // cases with crazy urls like ./image/cat1).png
3021    text = text.replace(/\[((?:\[[^\]]*]|[^\[\]])*)]()[ \t]*\([ \t]?<([^>]*)>(?:[ \t]*((["'])([^"]*?)\5))?[ \t]?\)/g,
3022      writeAnchorTag);
3023  
3024    // normal cases
3025    text = text.replace(/\[((?:\[[^\]]*]|[^\[\]])*)]()[ \t]*\([ \t]?<?([\S]+?(?:\([\S]*?\)[\S]*?)?)>?(?:[ \t]*((["'])([^"]*?)\5))?[ \t]?\)/g,
3026      writeAnchorTag);
3027  
3028    // handle reference-style shortcuts: [link text]
3029    // These must come last in case you've also got [link test][1]
3030    // or [link test](/foo)
3031    text = text.replace(/\[([^\[\]]+)]()()()()()/g, writeAnchorTag);
3032  
3033    // Lastly handle GithubMentions if option is enabled
3034    if (options.ghMentions) {
3035      text = text.replace(/(^|\s)(\\)?(@([a-z\d]+(?:[a-z\d.-]+?[a-z\d]+)*))/gmi, function (wm, st, escape, mentions, username) {
3036        if (escape === '\\') {
3037          return st + mentions;
3038        }
3039  
3040        //check if options.ghMentionsLink is a string
3041        if (!showdown.helper.isString(options.ghMentionsLink)) {
3042          throw new Error('ghMentionsLink option must be a string');
3043        }
3044        var lnk = options.ghMentionsLink.replace(/\{u}/g, username),
3045            target = '';
3046        if (options.openLinksInNewWindow) {
3047          target = ' rel="noopener noreferrer" target="¨E95Eblank"';
3048        }
3049        return st + '<a href="' + lnk + '"' + target + '>' + mentions + '</a>';
3050      });
3051    }
3052  
3053    text = globals.converter._dispatch('anchors.after', text, options, globals);
3054    return text;
3055  });
3056  
3057  // url allowed chars [a-z\d_.~:/?#[]@!$&'()*+,;=-]
3058  
3059  var simpleURLRegex  = /([*~_]+|\b)(((https?|ftp|dict):\/\/|www\.)[^'">\s]+?\.[^'">\s]+?)()(\1)?(?=\s|$)(?!["<>])/gi,
3060      simpleURLRegex2 = /([*~_]+|\b)(((https?|ftp|dict):\/\/|www\.)[^'">\s]+\.[^'">\s]+?)([.!?,()\[\]])?(\1)?(?=\s|$)(?!["<>])/gi,
3061      delimUrlRegex   = /()<(((https?|ftp|dict):\/\/|www\.)[^'">\s]+)()>()/gi,
3062      simpleMailRegex = /(^|\s)(?:mailto:)?([A-Za-z0-9!#$%&'*+-/=?^_`{|}~.]+@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)(?=$|\s)/gmi,
3063      delimMailRegex  = /<()(?:mailto:)?([-.\w]+@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)>/gi,
3064  
3065      replaceLink = function (options) {
3066        'use strict';
3067        return function (wm, leadingMagicChars, link, m2, m3, trailingPunctuation, trailingMagicChars) {
3068          link = link.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
3069          var lnkTxt = link,
3070              append = '',
3071              target = '',
3072              lmc    = leadingMagicChars || '',
3073              tmc    = trailingMagicChars || '';
3074          if (/^www\./i.test(link)) {
3075            link = link.replace(/^www\./i, 'http://www.');
3076          }
3077          if (options.excludeTrailingPunctuationFromURLs && trailingPunctuation) {
3078            append = trailingPunctuation;
3079          }
3080          if (options.openLinksInNewWindow) {
3081            target = ' rel="noopener noreferrer" target="¨E95Eblank"';
3082          }
3083          return lmc + '<a href="' + link + '"' + target + '>' + lnkTxt + '</a>' + append + tmc;
3084        };
3085      },
3086  
3087      replaceMail = function (options, globals) {
3088        'use strict';
3089        return function (wholeMatch, b, mail) {
3090          var href = 'mailto:';
3091          b = b || '';
3092          mail = showdown.subParser('unescapeSpecialChars')(mail, options, globals);
3093          if (options.encodeEmails) {
3094            href = showdown.helper.encodeEmailAddress(href + mail);
3095            mail = showdown.helper.encodeEmailAddress(mail);
3096          } else {
3097            href = href + mail;
3098          }
3099          return b + '<a href="' + href + '">' + mail + '</a>';
3100        };
3101      };
3102  
3103  showdown.subParser('autoLinks', function (text, options, globals) {
3104    'use strict';
3105  
3106    text = globals.converter._dispatch('autoLinks.before', text, options, globals);
3107  
3108    text = text.replace(delimUrlRegex, replaceLink(options));
3109    text = text.replace(delimMailRegex, replaceMail(options, globals));
3110  
3111    text = globals.converter._dispatch('autoLinks.after', text, options, globals);
3112  
3113    return text;
3114  });
3115  
3116  showdown.subParser('simplifiedAutoLinks', function (text, options, globals) {
3117    'use strict';
3118  
3119    if (!options.simplifiedAutoLink) {
3120      return text;
3121    }
3122  
3123    text = globals.converter._dispatch('simplifiedAutoLinks.before', text, options, globals);
3124  
3125    if (options.excludeTrailingPunctuationFromURLs) {
3126      text = text.replace(simpleURLRegex2, replaceLink(options));
3127    } else {
3128      text = text.replace(simpleURLRegex, replaceLink(options));
3129    }
3130    text = text.replace(simpleMailRegex, replaceMail(options, globals));
3131  
3132    text = globals.converter._dispatch('simplifiedAutoLinks.after', text, options, globals);
3133  
3134    return text;
3135  });
3136  
3137  /**
3138   * These are all the transformations that form block-level
3139   * tags like paragraphs, headers, and list items.
3140   */
3141  showdown.subParser('blockGamut', function (text, options, globals) {
3142    'use strict';
3143  
3144    text = globals.converter._dispatch('blockGamut.before', text, options, globals);
3145  
3146    // we parse blockquotes first so that we can have headings and hrs
3147    // inside blockquotes
3148    text = showdown.subParser('blockQuotes')(text, options, globals);
3149    text = showdown.subParser('headers')(text, options, globals);
3150  
3151    // Do Horizontal Rules:
3152    text = showdown.subParser('horizontalRule')(text, options, globals);
3153  
3154    text = showdown.subParser('lists')(text, options, globals);
3155    text = showdown.subParser('codeBlocks')(text, options, globals);
3156    text = showdown.subParser('tables')(text, options, globals);
3157  
3158    // We already ran _HashHTMLBlocks() before, in Markdown(), but that
3159    // was to escape raw HTML in the original Markdown source. This time,
3160    // we're escaping the markup we've just created, so that we don't wrap
3161    // <p> tags around block-level tags.
3162    text = showdown.subParser('hashHTMLBlocks')(text, options, globals);
3163    text = showdown.subParser('paragraphs')(text, options, globals);
3164  
3165    text = globals.converter._dispatch('blockGamut.after', text, options, globals);
3166  
3167    return text;
3168  });
3169  
3170  showdown.subParser('blockQuotes', function (text, options, globals) {
3171    'use strict';
3172  
3173    text = globals.converter._dispatch('blockQuotes.before', text, options, globals);
3174  
3175    // add a couple extra lines after the text and endtext mark
3176    text = text + '\n\n';
3177  
3178    var rgx = /(^ {0,3}>[ \t]?.+\n(.+\n)*\n*)+/gm;
3179  
3180    if (options.splitAdjacentBlockquotes) {
3181      rgx = /^ {0,3}>[\s\S]*?(?:\n\n)/gm;
3182    }
3183  
3184    text = text.replace(rgx, function (bq) {
3185      // attacklab: hack around Konqueror 3.5.4 bug:
3186      // "----------bug".replace(/^-/g,"") == "bug"
3187      bq = bq.replace(/^[ \t]*>[ \t]?/gm, ''); // trim one level of quoting
3188  
3189      // attacklab: clean up hack
3190      bq = bq.replace(/¨0/g, '');
3191  
3192      bq = bq.replace(/^[ \t]+$/gm, ''); // trim whitespace-only lines
3193      bq = showdown.subParser('githubCodeBlocks')(bq, options, globals);
3194      bq = showdown.subParser('blockGamut')(bq, options, globals); // recurse
3195  
3196      bq = bq.replace(/(^|\n)/g, '$1  ');
3197      // These leading spaces screw with <pre> content, so we need to fix that:
3198      bq = bq.replace(/(\s*<pre>[^\r]+?<\/pre>)/gm, function (wholeMatch, m1) {
3199        var pre = m1;
3200        // attacklab: hack around Konqueror 3.5.4 bug:
3201        pre = pre.replace(/^  /mg, '¨0');
3202        pre = pre.replace(/¨0/g, '');
3203        return pre;
3204      });
3205  
3206      return showdown.subParser('hashBlock')('<blockquote>\n' + bq + '\n</blockquote>', options, globals);
3207    });
3208  
3209    text = globals.converter._dispatch('blockQuotes.after', text, options, globals);
3210    return text;
3211  });
3212  
3213  /**
3214   * Process Markdown `<pre><code>` blocks.
3215   */
3216  showdown.subParser('codeBlocks', function (text, options, globals) {
3217    'use strict';
3218  
3219    text = globals.converter._dispatch('codeBlocks.before', text, options, globals);
3220  
3221    // sentinel workarounds for lack of \A and \Z, safari\khtml bug
3222    text += '¨0';
3223  
3224    var pattern = /(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=¨0))/g;
3225    text = text.replace(pattern, function (wholeMatch, m1, m2) {
3226      var codeblock = m1,
3227          nextChar = m2,
3228          end = '\n';
3229  
3230      codeblock = showdown.subParser('outdent')(codeblock, options, globals);
3231      codeblock = showdown.subParser('encodeCode')(codeblock, options, globals);
3232      codeblock = showdown.subParser('detab')(codeblock, options, globals);
3233      codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
3234      codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing newlines
3235  
3236      if (options.omitExtraWLInCodeBlocks) {
3237        end = '';
3238      }
3239  
3240      codeblock = '<pre><code>' + codeblock + end + '</code></pre>';
3241  
3242      return showdown.subParser('hashBlock')(codeblock, options, globals) + nextChar;
3243    });
3244  
3245    // strip sentinel
3246    text = text.replace(/¨0/, '');
3247  
3248    text = globals.converter._dispatch('codeBlocks.after', text, options, globals);
3249    return text;
3250  });
3251  
3252  /**
3253   *
3254   *   *  Backtick quotes are used for <code></code> spans.
3255   *
3256   *   *  You can use multiple backticks as the delimiters if you want to
3257   *     include literal backticks in the code span. So, this input:
3258   *
3259   *         Just type ``foo `bar` baz`` at the prompt.
3260   *
3261   *       Will translate to:
3262   *
3263   *         <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
3264   *
3265   *    There's no arbitrary limit to the number of backticks you
3266   *    can use as delimters. If you need three consecutive backticks
3267   *    in your code, use four for delimiters, etc.
3268   *
3269   *  *  You can use spaces to get literal backticks at the edges:
3270   *
3271   *         ... type `` `bar` `` ...
3272   *
3273   *       Turns to:
3274   *
3275   *         ... type <code>`bar`</code> ...
3276   */
3277  showdown.subParser('codeSpans', function (text, options, globals) {
3278    'use strict';
3279  
3280    text = globals.converter._dispatch('codeSpans.before', text, options, globals);
3281  
3282    if (typeof text === 'undefined') {
3283      text = '';
3284    }
3285    text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
3286      function (wholeMatch, m1, m2, m3) {
3287        var c = m3;
3288        c = c.replace(/^([ \t]*)/g, '');    // leading whitespace
3289        c = c.replace(/[ \t]*$/g, '');    // trailing whitespace
3290        c = showdown.subParser('encodeCode')(c, options, globals);
3291        c = m1 + '<code>' + c + '</code>';
3292        c = showdown.subParser('hashHTMLSpans')(c, options, globals);
3293        return c;
3294      }
3295    );
3296  
3297    text = globals.converter._dispatch('codeSpans.after', text, options, globals);
3298    return text;
3299  });
3300  
3301  /**
3302   * Create a full HTML document from the processed markdown
3303   */
3304  showdown.subParser('completeHTMLDocument', function (text, options, globals) {
3305    'use strict';
3306  
3307    if (!options.completeHTMLDocument) {
3308      return text;
3309    }
3310  
3311    text = globals.converter._dispatch('completeHTMLDocument.before', text, options, globals);
3312  
3313    var doctype = 'html',
3314        doctypeParsed = '<!DOCTYPE HTML>\n',
3315        title = '',
3316        charset = '<meta charset="utf-8">\n',
3317        lang = '',
3318        metadata = '';
3319  
3320    if (typeof globals.metadata.parsed.doctype !== 'undefined') {
3321      doctypeParsed = '<!DOCTYPE ' +  globals.metadata.parsed.doctype + '>\n';
3322      doctype = globals.metadata.parsed.doctype.toString().toLowerCase();
3323      if (doctype === 'html' || doctype === 'html5') {
3324        charset = '<meta charset="utf-8">';
3325      }
3326    }
3327  
3328    for (var meta in globals.metadata.parsed) {
3329      if (globals.metadata.parsed.hasOwnProperty(meta)) {
3330        switch (meta.toLowerCase()) {
3331          case 'doctype':
3332            break;
3333  
3334          case 'title':
3335            title = '<title>' +  globals.metadata.parsed.title + '</title>\n';
3336            break;
3337  
3338          case 'charset':
3339            if (doctype === 'html' || doctype === 'html5') {
3340              charset = '<meta charset="' + globals.metadata.parsed.charset + '">\n';
3341            } else {
3342              charset = '<meta name="charset" content="' + globals.metadata.parsed.charset + '">\n';
3343            }
3344            break;
3345  
3346          case 'language':
3347          case 'lang':
3348            lang = ' lang="' + globals.metadata.parsed[meta] + '"';
3349            metadata += '<meta name="' + meta + '" content="' + globals.metadata.parsed[meta] + '">\n';
3350            break;
3351  
3352          default:
3353            metadata += '<meta name="' + meta + '" content="' + globals.metadata.parsed[meta] + '">\n';
3354        }
3355      }
3356    }
3357  
3358    text = doctypeParsed + '<html' + lang + '>\n<head>\n' + title + charset + metadata + '</head>\n<body>\n' + text.trim() + '\n</body>\n</html>';
3359  
3360    text = globals.converter._dispatch('completeHTMLDocument.after', text, options, globals);
3361    return text;
3362  });
3363  
3364  /**
3365   * Convert all tabs to spaces
3366   */
3367  showdown.subParser('detab', function (text, options, globals) {
3368    'use strict';
3369    text = globals.converter._dispatch('detab.before', text, options, globals);
3370  
3371    // expand first n-1 tabs
3372    text = text.replace(/\t(?=\t)/g, '    '); // g_tab_width
3373  
3374    // replace the nth with two sentinels
3375    text = text.replace(/\t/g, '¨A¨B');
3376  
3377    // use the sentinel to anchor our regex so it doesn't explode
3378    text = text.replace(/¨B(.+?)¨A/g, function (wholeMatch, m1) {
3379      var leadingText = m1,
3380          numSpaces = 4 - leadingText.length % 4;  // g_tab_width
3381  
3382      // there *must* be a better way to do this:
3383      for (var i = 0; i < numSpaces; i++) {
3384        leadingText += ' ';
3385      }
3386  
3387      return leadingText;
3388    });
3389  
3390    // clean up sentinels
3391    text = text.replace(/¨A/g, '    ');  // g_tab_width
3392    text = text.replace(/¨B/g, '');
3393  
3394    text = globals.converter._dispatch('detab.after', text, options, globals);
3395    return text;
3396  });
3397  
3398  showdown.subParser('ellipsis', function (text, options, globals) {
3399    'use strict';
3400  
3401    text = globals.converter._dispatch('ellipsis.before', text, options, globals);
3402  
3403    text = text.replace(/\.\.\./g, '…');
3404  
3405    text = globals.converter._dispatch('ellipsis.after', text, options, globals);
3406  
3407    return text;
3408  });
3409  
3410  /**
3411   * Turn emoji codes into emojis
3412   *
3413   * List of supported emojis: https://github.com/showdownjs/showdown/wiki/Emojis
3414   */
3415  showdown.subParser('emoji', function (text, options, globals) {
3416    'use strict';
3417  
3418    if (!options.emoji) {
3419      return text;
3420    }
3421  
3422    text = globals.converter._dispatch('emoji.before', text, options, globals);
3423  
3424    var emojiRgx = /:([\S]+?):/g;
3425  
3426    text = text.replace(emojiRgx, function (wm, emojiCode) {
3427      if (showdown.helper.emojis.hasOwnProperty(emojiCode)) {
3428        return showdown.helper.emojis[emojiCode];
3429      }
3430      return wm;
3431    });
3432  
3433    text = globals.converter._dispatch('emoji.after', text, options, globals);
3434  
3435    return text;
3436  });
3437  
3438  /**
3439   * Smart processing for ampersands and angle brackets that need to be encoded.
3440   */
3441  showdown.subParser('encodeAmpsAndAngles', function (text, options, globals) {
3442    'use strict';
3443    text = globals.converter._dispatch('encodeAmpsAndAngles.before', text, options, globals);
3444  
3445    // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
3446    // http://bumppo.net/projects/amputator/
3447    text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g, '&amp;');
3448  
3449    // Encode naked <'s
3450    text = text.replace(/<(?![a-z\/?$!])/gi, '&lt;');
3451  
3452    // Encode <
3453    text = text.replace(/</g, '&lt;');
3454  
3455    // Encode >
3456    text = text.replace(/>/g, '&gt;');
3457  
3458    text = globals.converter._dispatch('encodeAmpsAndAngles.after', text, options, globals);
3459    return text;
3460  });
3461  
3462  /**
3463   * Returns the string, with after processing the following backslash escape sequences.
3464   *
3465   * attacklab: The polite way to do this is with the new escapeCharacters() function:
3466   *
3467   *    text = escapeCharacters(text,"\\",true);
3468   *    text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
3469   *
3470   * ...but we're sidestepping its use of the (slow) RegExp constructor
3471   * as an optimization for Firefox.  This function gets called a LOT.
3472   */
3473  showdown.subParser('encodeBackslashEscapes', function (text, options, globals) {
3474    'use strict';
3475    text = globals.converter._dispatch('encodeBackslashEscapes.before', text, options, globals);
3476  
3477    text = text.replace(/\\(\\)/g, showdown.helper.escapeCharactersCallback);
3478    text = text.replace(/\\([`*_{}\[\]()>#+.!~=|-])/g, showdown.helper.escapeCharactersCallback);
3479  
3480    text = globals.converter._dispatch('encodeBackslashEscapes.after', text, options, globals);
3481    return text;
3482  });
3483  
3484  /**
3485   * Encode/escape certain characters inside Markdown code runs.
3486   * The point is that in code, these characters are literals,
3487   * and lose their special Markdown meanings.
3488   */
3489  showdown.subParser('encodeCode', function (text, options, globals) {
3490    'use strict';
3491  
3492    text = globals.converter._dispatch('encodeCode.before', text, options, globals);
3493  
3494    // Encode all ampersands; HTML entities are not
3495    // entities within a Markdown code span.
3496    text = text
3497      .replace(/&/g, '&amp;')
3498    // Do the angle bracket song and dance:
3499      .replace(/</g, '&lt;')
3500      .replace(/>/g, '&gt;')
3501    // Now, escape characters that are magic in Markdown:
3502      .replace(/([*_{}\[\]\\=~-])/g, showdown.helper.escapeCharactersCallback);
3503  
3504    text = globals.converter._dispatch('encodeCode.after', text, options, globals);
3505    return text;
3506  });
3507  
3508  /**
3509   * Within tags -- meaning between < and > -- encode [\ ` * _ ~ =] so they
3510   * don't conflict with their use in Markdown for code, italics and strong.
3511   */
3512  showdown.subParser('escapeSpecialCharsWithinTagAttributes', function (text, options, globals) {
3513    'use strict';
3514    text = globals.converter._dispatch('escapeSpecialCharsWithinTagAttributes.before', text, options, globals);
3515  
3516    // Build a regex to find HTML tags.
3517    var tags     = /<\/?[a-z\d_:-]+(?:[\s]+[\s\S]+?)?>/gi,
3518        comments = /<!(--(?:(?:[^>-]|-[^>])(?:[^-]|-[^-])*)--)>/gi;
3519  
3520    text = text.replace(tags, function (wholeMatch) {
3521      return wholeMatch
3522        .replace(/(.)<\/?code>(?=.)/g, '$1`')
3523        .replace(/([\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);
3524    });
3525  
3526    text = text.replace(comments, function (wholeMatch) {
3527      return wholeMatch
3528        .replace(/([\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);
3529    });
3530  
3531    text = globals.converter._dispatch('escapeSpecialCharsWithinTagAttributes.after', text, options, globals);
3532    return text;
3533  });
3534  
3535  /**
3536   * Handle github codeblocks prior to running HashHTML so that
3537   * HTML contained within the codeblock gets escaped properly
3538   * Example:
3539   * ```ruby
3540   *     def hello_world(x)
3541   *       puts "Hello, #{x}"
3542   *     end
3543   * ```
3544   */
3545  showdown.subParser('githubCodeBlocks', function (text, options, globals) {
3546    'use strict';
3547  
3548    // early exit if option is not enabled
3549    if (!options.ghCodeBlocks) {
3550      return text;
3551    }
3552  
3553    text = globals.converter._dispatch('githubCodeBlocks.before', text, options, globals);
3554  
3555    text += '¨0';
3556  
3557    text = text.replace(/(?:^|\n)(?: {0,3})(```+|~~~+)(?: *)([^\s`~]*)\n([\s\S]*?)\n(?: {0,3})\1/g, function (wholeMatch, delim, language, codeblock) {
3558      var end = (options.omitExtraWLInCodeBlocks) ? '' : '\n';
3559  
3560      // First parse the github code block
3561      codeblock = showdown.subParser('encodeCode')(codeblock, options, globals);
3562      codeblock = showdown.subParser('detab')(codeblock, options, globals);
3563      codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
3564      codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing whitespace
3565  
3566      codeblock = '<pre><code' + (language ? ' class="' + language + ' language-' + language + '"' : '') + '>' + codeblock + end + '</code></pre>';
3567  
3568      codeblock = showdown.subParser('hashBlock')(codeblock, options, globals);
3569  
3570      // Since GHCodeblocks can be false positives, we need to
3571      // store the primitive text and the parsed text in a global var,
3572      // and then return a token
3573      return '\n\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
3574    });
3575  
3576    // attacklab: strip sentinel
3577    text = text.replace(/¨0/, '');
3578  
3579    return globals.converter._dispatch('githubCodeBlocks.after', text, options, globals);
3580  });
3581  
3582  showdown.subParser('hashBlock', function (text, options, globals) {
3583    'use strict';
3584    text = globals.converter._dispatch('hashBlock.before', text, options, globals);
3585    text = text.replace(/(^\n+|\n+$)/g, '');
3586    text = '\n\n¨K' + (globals.gHtmlBlocks.push(text) - 1) + 'K\n\n';
3587    text = globals.converter._dispatch('hashBlock.after', text, options, globals);
3588    return text;
3589  });
3590  
3591  /**
3592   * Hash and escape <code> elements that should not be parsed as markdown
3593   */
3594  showdown.subParser('hashCodeTags', function (text, options, globals) {
3595    'use strict';
3596    text = globals.converter._dispatch('hashCodeTags.before', text, options, globals);
3597  
3598    var repFunc = function (wholeMatch, match, left, right) {
3599      var codeblock = left + showdown.subParser('encodeCode')(match, options, globals) + right;
3600      return '¨C' + (globals.gHtmlSpans.push(codeblock) - 1) + 'C';
3601    };
3602  
3603    // Hash naked <code>
3604    text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '<code\\b[^>]*>', '</code>', 'gim');
3605  
3606    text = globals.converter._dispatch('hashCodeTags.after', text, options, globals);
3607    return text;
3608  });
3609  
3610  showdown.subParser('hashElement', function (text, options, globals) {
3611    'use strict';
3612  
3613    return function (wholeMatch, m1) {
3614      var blockText = m1;
3615  
3616      // Undo double lines
3617      blockText = blockText.replace(/\n\n/g, '\n');
3618      blockText = blockText.replace(/^\n/, '');
3619  
3620      // strip trailing blank lines
3621      blockText = blockText.replace(/\n+$/g, '');
3622  
3623      // Replace the element text with a marker ("¨KxK" where x is its key)
3624      blockText = '\n\n¨K' + (globals.gHtmlBlocks.push(blockText) - 1) + 'K\n\n';
3625  
3626      return blockText;
3627    };
3628  });
3629  
3630  showdown.subParser('hashHTMLBlocks', function (text, options, globals) {
3631    'use strict';
3632    text = globals.converter._dispatch('hashHTMLBlocks.before', text, options, globals);
3633  
3634    var blockTags = [
3635          'pre',
3636          'div',
3637          'h1',
3638          'h2',
3639          'h3',
3640          'h4',
3641          'h5',
3642          'h6',
3643          'blockquote',
3644          'table',
3645          'dl',
3646          'ol',
3647          'ul',
3648          'script',
3649          'noscript',
3650          'form',
3651          'fieldset',
3652          'iframe',
3653          'math',
3654          'style',
3655          'section',
3656          'header',
3657          'footer',
3658          'nav',
3659          'article',
3660          'aside',
3661          'address',
3662          'audio',
3663          'canvas',
3664          'figure',
3665          'hgroup',
3666          'output',
3667          'video',
3668          'p'
3669        ],
3670        repFunc = function (wholeMatch, match, left, right) {
3671          var txt = wholeMatch;
3672          // check if this html element is marked as markdown
3673          // if so, it's contents should be parsed as markdown
3674          if (left.search(/\bmarkdown\b/) !== -1) {
3675            txt = left + globals.converter.makeHtml(match) + right;
3676          }
3677          return '\n\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
3678        };
3679  
3680    if (options.backslashEscapesHTMLTags) {
3681      // encode backslash escaped HTML tags
3682      text = text.replace(/\\<(\/?[^>]+?)>/g, function (wm, inside) {
3683        return '&lt;' + inside + '&gt;';
3684      });
3685    }
3686  
3687    // hash HTML Blocks
3688    for (var i = 0; i < blockTags.length; ++i) {
3689  
3690      var opTagPos,
3691          rgx1     = new RegExp('^ {0,3}(<' + blockTags[i] + '\\b[^>]*>)', 'im'),
3692          patLeft  = '<' + blockTags[i] + '\\b[^>]*>',
3693          patRight = '</' + blockTags[i] + '>';
3694      // 1. Look for the first position of the first opening HTML tag in the text
3695      while ((opTagPos = showdown.helper.regexIndexOf(text, rgx1)) !== -1) {
3696  
3697        // if the HTML tag is \ escaped, we need to escape it and break
3698  
3699  
3700        //2. Split the text in that position
3701        var subTexts = showdown.helper.splitAtIndex(text, opTagPos),
3702            //3. Match recursively
3703            newSubText1 = showdown.helper.replaceRecursiveRegExp(subTexts[1], repFunc, patLeft, patRight, 'im');
3704  
3705        // prevent an infinite loop
3706        if (newSubText1 === subTexts[1]) {
3707          break;
3708        }
3709        text = subTexts[0].concat(newSubText1);
3710      }
3711    }
3712    // HR SPECIAL CASE
3713    text = text.replace(/(\n {0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,
3714      showdown.subParser('hashElement')(text, options, globals));
3715  
3716    // Special case for standalone HTML comments
3717    text = showdown.helper.replaceRecursiveRegExp(text, function (txt) {
3718      return '\n\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
3719    }, '^ {0,3}<!--', '-->', 'gm');
3720  
3721    // PHP and ASP-style processor instructions (<?...?> and <%...%>)
3722    text = text.replace(/(?:\n\n)( {0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,
3723      showdown.subParser('hashElement')(text, options, globals));
3724  
3725    text = globals.converter._dispatch('hashHTMLBlocks.after', text, options, globals);
3726    return text;
3727  });
3728  
3729  /**
3730   * Hash span elements that should not be parsed as markdown
3731   */
3732  showdown.subParser('hashHTMLSpans', function (text, options, globals) {
3733    'use strict';
3734    text = globals.converter._dispatch('hashHTMLSpans.before', text, options, globals);
3735  
3736    function hashHTMLSpan (html) {
3737      return '¨C' + (globals.gHtmlSpans.push(html) - 1) + 'C';
3738    }
3739  
3740    // Hash Self Closing tags
3741    text = text.replace(/<[^>]+?\/>/gi, function (wm) {
3742      return hashHTMLSpan(wm);
3743    });
3744  
3745    // Hash tags without properties
3746    text = text.replace(/<([^>]+?)>[\s\S]*?<\/\1>/g, function (wm) {
3747      return hashHTMLSpan(wm);
3748    });
3749  
3750    // Hash tags with properties
3751    text = text.replace(/<([^>]+?)\s[^>]+?>[\s\S]*?<\/\1>/g, function (wm) {
3752      return hashHTMLSpan(wm);
3753    });
3754  
3755    // Hash self closing tags without />
3756    text = text.replace(/<[^>]+?>/gi, function (wm) {
3757      return hashHTMLSpan(wm);
3758    });
3759  
3760    /*showdown.helper.matchRecursiveRegExp(text, '<code\\b[^>]*>', '</code>', 'gi');*/
3761  
3762    text = globals.converter._dispatch('hashHTMLSpans.after', text, options, globals);
3763    return text;
3764  });
3765  
3766  /**
3767   * Unhash HTML spans
3768   */
3769  showdown.subParser('unhashHTMLSpans', function (text, options, globals) {
3770    'use strict';
3771    text = globals.converter._dispatch('unhashHTMLSpans.before', text, options, globals);
3772  
3773    for (var i = 0; i < globals.gHtmlSpans.length; ++i) {
3774      var repText = globals.gHtmlSpans[i],
3775          // limiter to prevent infinite loop (assume 10 as limit for recurse)
3776          limit = 0;
3777  
3778      while (/¨C(\d+)C/.test(repText)) {
3779        var num = RegExp.$1;
3780        repText = repText.replace('¨C' + num + 'C', globals.gHtmlSpans[num]);
3781        if (limit === 10) {
3782          console.error('maximum nesting of 10 spans reached!!!');
3783          break;
3784        }
3785        ++limit;
3786      }
3787      text = text.replace('¨C' + i + 'C', repText);
3788    }
3789  
3790    text = globals.converter._dispatch('unhashHTMLSpans.after', text, options, globals);
3791    return text;
3792  });
3793  
3794  /**
3795   * Hash and escape <pre><code> elements that should not be parsed as markdown
3796   */
3797  showdown.subParser('hashPreCodeTags', function (text, options, globals) {
3798    'use strict';
3799    text = globals.converter._dispatch('hashPreCodeTags.before', text, options, globals);
3800  
3801    var repFunc = function (wholeMatch, match, left, right) {
3802      // encode html entities
3803      var codeblock = left + showdown.subParser('encodeCode')(match, options, globals) + right;
3804      return '\n\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
3805    };
3806  
3807    // Hash <pre><code>
3808    text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^ {0,3}<pre\\b[^>]*>\\s*<code\\b[^>]*>', '^ {0,3}</code>\\s*</pre>', 'gim');
3809  
3810    text = globals.converter._dispatch('hashPreCodeTags.after', text, options, globals);
3811    return text;
3812  });
3813  
3814  showdown.subParser('headers', function (text, options, globals) {
3815    'use strict';
3816  
3817    text = globals.converter._dispatch('headers.before', text, options, globals);
3818  
3819    var headerLevelStart = (isNaN(parseInt(options.headerLevelStart))) ? 1 : parseInt(options.headerLevelStart),
3820  
3821        // Set text-style headers:
3822        //    Header 1
3823        //    ========
3824        //
3825        //    Header 2
3826        //    --------
3827        //
3828        setextRegexH1 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n={2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n=+[ \t]*\n+/gm,
3829        setextRegexH2 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n-{2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n-+[ \t]*\n+/gm;
3830  
3831    text = text.replace(setextRegexH1, function (wholeMatch, m1) {
3832  
3833      var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
3834          hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
3835          hLevel = headerLevelStart,
3836          hashBlock = '<h' + hLevel + hID + '>' + spanGamut + '</h' + hLevel + '>';
3837      return showdown.subParser('hashBlock')(hashBlock, options, globals);
3838    });
3839  
3840    text = text.replace(setextRegexH2, function (matchFound, m1) {
3841      var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
3842          hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
3843          hLevel = headerLevelStart + 1,
3844          hashBlock = '<h' + hLevel + hID + '>' + spanGamut + '</h' + hLevel + '>';
3845      return showdown.subParser('hashBlock')(hashBlock, options, globals);
3846    });
3847  
3848    // atx-style headers:
3849    //  # Header 1
3850    //  ## Header 2
3851    //  ## Header 2 with closing hashes ##
3852    //  ...
3853    //  ###### Header 6
3854    //
3855    var atxStyle = (options.requireSpaceBeforeHeadingText) ? /^(#{1,6})[ \t]+(.+?)[ \t]*#*\n+/gm : /^(#{1,6})[ \t]*(.+?)[ \t]*#*\n+/gm;
3856  
3857    text = text.replace(atxStyle, function (wholeMatch, m1, m2) {
3858      var hText = m2;
3859      if (options.customizedHeaderId) {
3860        hText = m2.replace(/\s?\{([^{]+?)}\s*$/, '');
3861      }
3862  
3863      var span = showdown.subParser('spanGamut')(hText, options, globals),
3864          hID = (options.noHeaderId) ? '' : ' id="' + headerId(m2) + '"',
3865          hLevel = headerLevelStart - 1 + m1.length,
3866          header = '<h' + hLevel + hID + '>' + span + '</h' + hLevel + '>';
3867  
3868      return showdown.subParser('hashBlock')(header, options, globals);
3869    });
3870  
3871    function headerId (m) {
3872      var title,
3873          prefix;
3874  
3875      // It is separate from other options to allow combining prefix and customized
3876      if (options.customizedHeaderId) {
3877        var match = m.match(/\{([^{]+?)}\s*$/);
3878        if (match && match[1]) {
3879          m = match[1];
3880        }
3881      }
3882  
3883      title = m;
3884  
3885      // Prefix id to prevent causing inadvertent pre-existing style matches.
3886      if (showdown.helper.isString(options.prefixHeaderId)) {
3887        prefix = options.prefixHeaderId;
3888      } else if (options.prefixHeaderId === true) {
3889        prefix = 'section-';
3890      } else {
3891        prefix = '';
3892      }
3893  
3894      if (!options.rawPrefixHeaderId) {
3895        title = prefix + title;
3896      }
3897  
3898      if (options.ghCompatibleHeaderId) {
3899        title = title
3900          .replace(/ /g, '-')
3901          // replace previously escaped chars (&, ¨ and $)
3902          .replace(/&amp;/g, '')
3903          .replace(/¨T/g, '')
3904          .replace(/¨D/g, '')
3905          // replace rest of the chars (&~$ are repeated as they might have been escaped)
3906          // borrowed from github's redcarpet (some they should produce similar results)
3907          .replace(/[&+$,\/:;=?@"#{}|^¨~\[\]`\\*)(%.!'<>]/g, '')
3908          .toLowerCase();
3909      } else if (options.rawHeaderId) {
3910        title = title
3911          .replace(/ /g, '-')
3912          // replace previously escaped chars (&, ¨ and $)
3913          .replace(/&amp;/g, '&')
3914          .replace(/¨T/g, '¨')
3915          .replace(/¨D/g, '$')
3916          // replace " and '
3917          .replace(/["']/g, '-')
3918          .toLowerCase();
3919      } else {
3920        title = title
3921          .replace(/[^\w]/g, '')
3922          .toLowerCase();
3923      }
3924  
3925      if (options.rawPrefixHeaderId) {
3926        title = prefix + title;
3927      }
3928  
3929      if (globals.hashLinkCounts[title]) {
3930        title = title + '-' + (globals.hashLinkCounts[title]++);
3931      } else {
3932        globals.hashLinkCounts[title] = 1;
3933      }
3934      return title;
3935    }
3936  
3937    text = globals.converter._dispatch('headers.after', text, options, globals);
3938    return text;
3939  });
3940  
3941  /**
3942   * Turn Markdown link shortcuts into XHTML <a> tags.
3943   */
3944  showdown.subParser('horizontalRule', function (text, options, globals) {
3945    'use strict';
3946    text = globals.converter._dispatch('horizontalRule.before', text, options, globals);
3947  
3948    var key = showdown.subParser('hashBlock')('<hr />', options, globals);
3949    text = text.replace(/^ {0,2}( ?-){3,}[ \t]*$/gm, key);
3950    text = text.replace(/^ {0,2}( ?\*){3,}[ \t]*$/gm, key);
3951    text = text.replace(/^ {0,2}( ?_){3,}[ \t]*$/gm, key);
3952  
3953    text = globals.converter._dispatch('horizontalRule.after', text, options, globals);
3954    return text;
3955  });
3956  
3957  /**
3958   * Turn Markdown image shortcuts into <img> tags.
3959   */
3960  showdown.subParser('images', function (text, options, globals) {
3961    'use strict';
3962  
3963    text = globals.converter._dispatch('images.before', text, options, globals);
3964  
3965    var inlineRegExp      = /!\[([^\]]*?)][ \t]*()\([ \t]?<?([\S]+?(?:\([\S]*?\)[\S]*?)?)>?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(["'])([^"]*?)\6)?[ \t]?\)/g,
3966        crazyRegExp       = /!\[([^\]]*?)][ \t]*()\([ \t]?<([^>]*)>(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(?:(["'])([^"]*?)\6))?[ \t]?\)/g,
3967        base64RegExp      = /!\[([^\]]*?)][ \t]*()\([ \t]?<?(data:.+?\/.+?;base64,[A-Za-z0-9+/=\n]+?)>?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(["'])([^"]*?)\6)?[ \t]?\)/g,
3968        referenceRegExp   = /!\[([^\]]*?)] ?(?:\n *)?\[([\s\S]*?)]()()()()()/g,
3969        refShortcutRegExp = /!\[([^\[\]]+)]()()()()()/g;
3970  
3971    function writeImageTagBase64 (wholeMatch, altText, linkId, url, width, height, m5, title) {
3972      url = url.replace(/\s/g, '');
3973      return writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title);
3974    }
3975  
3976    function writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title) {
3977  
3978      var gUrls   = globals.gUrls,
3979          gTitles = globals.gTitles,
3980          gDims   = globals.gDimensions;
3981  
3982      linkId = linkId.toLowerCase();
3983  
3984      if (!title) {
3985        title = '';
3986      }
3987      // Special case for explicit empty url
3988      if (wholeMatch.search(/\(<?\s*>? ?(['"].*['"])?\)$/m) > -1) {
3989        url = '';
3990  
3991      } else if (url === '' || url === null) {
3992        if (linkId === '' || linkId === null) {
3993          // lower-case and turn embedded newlines into spaces
3994          linkId = altText.toLowerCase().replace(/ ?\n/g, ' ');
3995        }
3996        url = '#' + linkId;
3997  
3998        if (!showdown.helper.isUndefined(gUrls[linkId])) {
3999          url = gUrls[linkId];
4000          if (!showdown.helper.isUndefined(gTitles[linkId])) {
4001            title = gTitles[linkId];
4002          }
4003          if (!showdown.helper.isUndefined(gDims[linkId])) {
4004            width = gDims[linkId].width;
4005            height = gDims[linkId].height;
4006          }
4007        } else {
4008          return wholeMatch;
4009        }
4010      }
4011  
4012      altText = altText
4013        .replace(/"/g, '&quot;')
4014      //altText = showdown.helper.escapeCharacters(altText, '*_', false);
4015        .replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
4016      //url = showdown.helper.escapeCharacters(url, '*_', false);
4017      url = url.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
4018      var result = '<img src="' + url + '" alt="' + altText + '"';
4019  
4020      if (title && showdown.helper.isString(title)) {
4021        title = title
4022          .replace(/"/g, '&quot;')
4023        //title = showdown.helper.escapeCharacters(title, '*_', false);
4024          .replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
4025        result += ' title="' + title + '"';
4026      }
4027  
4028      if (width && height) {
4029        width  = (width === '*') ? 'auto' : width;
4030        height = (height === '*') ? 'auto' : height;
4031  
4032        result += ' width="' + width + '"';
4033        result += ' height="' + height + '"';
4034      }
4035  
4036      result += ' />';
4037  
4038      return result;
4039    }
4040  
4041    // First, handle reference-style labeled images: ![alt text][id]
4042    text = text.replace(referenceRegExp, writeImageTag);
4043  
4044    // Next, handle inline images:  ![alt text](url =<width>x<height> "optional title")
4045  
4046    // base64 encoded images
4047    text = text.replace(base64RegExp, writeImageTagBase64);
4048  
4049    // cases with crazy urls like ./image/cat1).png
4050    text = text.replace(crazyRegExp, writeImageTag);
4051  
4052    // normal cases
4053    text = text.replace(inlineRegExp, writeImageTag);
4054  
4055    // handle reference-style shortcuts: ![img text]
4056    text = text.replace(refShortcutRegExp, writeImageTag);
4057  
4058    text = globals.converter._dispatch('images.after', text, options, globals);
4059    return text;
4060  });
4061  
4062  showdown.subParser('italicsAndBold', function (text, options, globals) {
4063    'use strict';
4064  
4065    text = globals.converter._dispatch('italicsAndBold.before', text, options, globals);
4066  
4067    // it's faster to have 3 separate regexes for each case than have just one
4068    // because of backtracing, in some cases, it could lead to an exponential effect
4069    // called "catastrophic backtrace". Ominous!
4070  
4071    function parseInside (txt, left, right) {
4072      /*
4073      if (options.simplifiedAutoLink) {
4074        txt = showdown.subParser('simplifiedAutoLinks')(txt, options, globals);
4075      }
4076      */
4077      return left + txt + right;
4078    }
4079  
4080    // Parse underscores
4081    if (options.literalMidWordUnderscores) {
4082      text = text.replace(/\b___(\S[\s\S]*?)___\b/g, function (wm, txt) {
4083        return parseInside (txt, '<strong><em>', '</em></strong>');
4084      });
4085      text = text.replace(/\b__(\S[\s\S]*?)__\b/g, function (wm, txt) {
4086        return parseInside (txt, '<strong>', '</strong>');
4087      });
4088      text = text.replace(/\b_(\S[\s\S]*?)_\b/g, function (wm, txt) {
4089        return parseInside (txt, '<em>', '</em>');
4090      });
4091    } else {
4092      text = text.replace(/___(\S[\s\S]*?)___/g, function (wm, m) {
4093        return (/\S$/.test(m)) ? parseInside (m, '<strong><em>', '</em></strong>') : wm;
4094      });
4095      text = text.replace(/__(\S[\s\S]*?)__/g, function (wm, m) {
4096        return (/\S$/.test(m)) ? parseInside (m, '<strong>', '</strong>') : wm;
4097      });
4098      text = text.replace(/_([^\s_][\s\S]*?)_/g, function (wm, m) {
4099        // !/^_[^_]/.test(m) - test if it doesn't start with __ (since it seems redundant, we removed it)
4100        return (/\S$/.test(m)) ? parseInside (m, '<em>', '</em>') : wm;
4101      });
4102    }
4103  
4104    // Now parse asterisks
4105    if (options.literalMidWordAsterisks) {
4106      text = text.replace(/([^*]|^)\B\*\*\*(\S[\s\S]*?)\*\*\*\B(?!\*)/g, function (wm, lead, txt) {
4107        return parseInside (txt, lead + '<strong><em>', '</em></strong>');
4108      });
4109      text = text.replace(/([^*]|^)\B\*\*(\S[\s\S]*?)\*\*\B(?!\*)/g, function (wm, lead, txt) {
4110        return parseInside (txt, lead + '<strong>', '</strong>');
4111      });
4112      text = text.replace(/([^*]|^)\B\*(\S[\s\S]*?)\*\B(?!\*)/g, function (wm, lead, txt) {
4113        return parseInside (txt, lead + '<em>', '</em>');
4114      });
4115    } else {
4116      text = text.replace(/\*\*\*(\S[\s\S]*?)\*\*\*/g, function (wm, m) {
4117        return (/\S$/.test(m)) ? parseInside (m, '<strong><em>', '</em></strong>') : wm;
4118      });
4119      text = text.replace(/\*\*(\S[\s\S]*?)\*\*/g, function (wm, m) {
4120        return (/\S$/.test(m)) ? parseInside (m, '<strong>', '</strong>') : wm;
4121      });
4122      text = text.replace(/\*([^\s*][\s\S]*?)\*/g, function (wm, m) {
4123        // !/^\*[^*]/.test(m) - test if it doesn't start with ** (since it seems redundant, we removed it)
4124        return (/\S$/.test(m)) ? parseInside (m, '<em>', '</em>') : wm;
4125      });
4126    }
4127  
4128  
4129    text = globals.converter._dispatch('italicsAndBold.after', text, options, globals);
4130    return text;
4131  });
4132  
4133  /**
4134   * Form HTML ordered (numbered) and unordered (bulleted) lists.
4135   */
4136  showdown.subParser('lists', function (text, options, globals) {
4137    'use strict';
4138  
4139    /**
4140     * Process the contents of a single ordered or unordered list, splitting it
4141     * into individual list items.
4142     * @param {string} listStr
4143     * @param {boolean} trimTrailing
4144     * @returns {string}
4145     */
4146    function processListItems (listStr, trimTrailing) {
4147      // The $g_list_level global keeps track of when we're inside a list.
4148      // Each time we enter a list, we increment it; when we leave a list,
4149      // we decrement. If it's zero, we're not in a list anymore.
4150      //
4151      // We do this because when we're not inside a list, we want to treat
4152      // something like this:
4153      //
4154      //    I recommend upgrading to version
4155      //    8. Oops, now this line is treated
4156      //    as a sub-list.
4157      //
4158      // As a single paragraph, despite the fact that the second line starts
4159      // with a digit-period-space sequence.
4160      //
4161      // Whereas when we're inside a list (or sub-list), that line will be
4162      // treated as the start of a sub-list. What a kludge, huh? This is
4163      // an aspect of Markdown's syntax that's hard to parse perfectly
4164      // without resorting to mind-reading. Perhaps the solution is to
4165      // change the syntax rules such that sub-lists must start with a
4166      // starting cardinal number; e.g. "1." or "a.".
4167      globals.gListLevel++;
4168  
4169      // trim trailing blank lines:
4170      listStr = listStr.replace(/\n{2,}$/, '\n');
4171  
4172      // attacklab: add sentinel to emulate \z
4173      listStr += '¨0';
4174  
4175      var rgx = /(\n)?(^ {0,3})([*+-]|\d+[.])[ \t]+((\[(x|X| )?])?[ \t]*[^\r]+?(\n{1,2}))(?=\n*(¨0| {0,3}([*+-]|\d+[.])[ \t]+))/gm,
4176          isParagraphed = (/\n[ \t]*\n(?!¨0)/.test(listStr));
4177  
4178      // Since version 1.5, nesting sublists requires 4 spaces (or 1 tab) indentation,
4179      // which is a syntax breaking change
4180      // activating this option reverts to old behavior
4181      if (options.disableForced4SpacesIndentedSublists) {
4182        rgx = /(\n)?(^ {0,3})([*+-]|\d+[.])[ \t]+((\[(x|X| )?])?[ \t]*[^\r]+?(\n{1,2}))(?=\n*(¨0|\2([*+-]|\d+[.])[ \t]+))/gm;
4183      }
4184  
4185      listStr = listStr.replace(rgx, function (wholeMatch, m1, m2, m3, m4, taskbtn, checked) {
4186        checked = (checked && checked.trim() !== '');
4187  
4188        var item = showdown.subParser('outdent')(m4, options, globals),
4189            bulletStyle = '';
4190  
4191        // Support for github tasklists
4192        if (taskbtn && options.tasklists) {
4193          bulletStyle = ' class="task-list-item" style="list-style-type: none;"';
4194          item = item.replace(/^[ \t]*\[(x|X| )?]/m, function () {
4195            var otp = '<input type="checkbox" disabled style="margin: 0px 0.35em 0.25em -1.6em; vertical-align: middle;"';
4196            if (checked) {
4197              otp += ' checked';
4198            }
4199            otp += '>';
4200            return otp;
4201          });
4202        }
4203  
4204        // ISSUE #312
4205        // This input: - - - a
4206        // causes trouble to the parser, since it interprets it as:
4207        // <ul><li><li><li>a</li></li></li></ul>
4208        // instead of:
4209        // <ul><li>- - a</li></ul>
4210        // So, to prevent it, we will put a marker (¨A)in the beginning of the line
4211        // Kind of hackish/monkey patching, but seems more effective than overcomplicating the list parser
4212        item = item.replace(/^([-*+]|\d\.)[ \t]+[\S\n ]*/g, function (wm2) {
4213          return '¨A' + wm2;
4214        });
4215  
4216        // m1 - Leading line or
4217        // Has a double return (multi paragraph) or
4218        // Has sublist
4219        if (m1 || (item.search(/\n{2,}/) > -1)) {
4220          item = showdown.subParser('githubCodeBlocks')(item, options, globals);
4221          item = showdown.subParser('blockGamut')(item, options, globals);
4222        } else {
4223          // Recursion for sub-lists:
4224          item = showdown.subParser('lists')(item, options, globals);
4225          item = item.replace(/\n$/, ''); // chomp(item)
4226          item = showdown.subParser('hashHTMLBlocks')(item, options, globals);
4227  
4228          // Colapse double linebreaks
4229          item = item.replace(/\n\n+/g, '\n\n');
4230          if (isParagraphed) {
4231            item = showdown.subParser('paragraphs')(item, options, globals);
4232          } else {
4233            item = showdown.subParser('spanGamut')(item, options, globals);
4234          }
4235        }
4236  
4237        // now we need to remove the marker (¨A)
4238        item = item.replace('¨A', '');
4239        // we can finally wrap the line in list item tags
4240        item =  '<li' + bulletStyle + '>' + item + '</li>\n';
4241  
4242        return item;
4243      });
4244  
4245      // attacklab: strip sentinel
4246      listStr = listStr.replace(/¨0/g, '');
4247  
4248      globals.gListLevel--;
4249  
4250      if (trimTrailing) {
4251        listStr = listStr.replace(/\s+$/, '');
4252      }
4253  
4254      return listStr;
4255    }
4256  
4257    function styleStartNumber (list, listType) {
4258      // check if ol and starts by a number different than 1
4259      if (listType === 'ol') {
4260        var res = list.match(/^ *(\d+)\./);
4261        if (res && res[1] !== '1') {
4262          return ' start="' + res[1] + '"';
4263        }
4264      }
4265      return '';
4266    }
4267  
4268    /**
4269     * Check and parse consecutive lists (better fix for issue #142)
4270     * @param {string} list
4271     * @param {string} listType
4272     * @param {boolean} trimTrailing
4273     * @returns {string}
4274     */
4275    function parseConsecutiveLists (list, listType, trimTrailing) {
4276      // check if we caught 2 or more consecutive lists by mistake
4277      // we use the counterRgx, meaning if listType is UL we look for OL and vice versa
4278      var olRgx = (options.disableForced4SpacesIndentedSublists) ? /^ ?\d+\.[ \t]/gm : /^ {0,3}\d+\.[ \t]/gm,
4279          ulRgx = (options.disableForced4SpacesIndentedSublists) ? /^ ?[*+-][ \t]/gm : /^ {0,3}[*+-][ \t]/gm,
4280          counterRxg = (listType === 'ul') ? olRgx : ulRgx,
4281          result = '';
4282  
4283      if (list.search(counterRxg) !== -1) {
4284        (function parseCL (txt) {
4285          var pos = txt.search(counterRxg),
4286              style = styleStartNumber(list, listType);
4287          if (pos !== -1) {
4288            // slice
4289            result += '\n\n<' + listType + style + '>\n' + processListItems(txt.slice(0, pos), !!trimTrailing) + '</' + listType + '>\n';
4290  
4291            // invert counterType and listType
4292            listType = (listType === 'ul') ? 'ol' : 'ul';
4293            counterRxg = (listType === 'ul') ? olRgx : ulRgx;
4294  
4295            //recurse
4296            parseCL(txt.slice(pos));
4297          } else {
4298            result += '\n\n<' + listType + style + '>\n' + processListItems(txt, !!trimTrailing) + '</' + listType + '>\n';
4299          }
4300        })(list);
4301      } else {
4302        var style = styleStartNumber(list, listType);
4303        result = '\n\n<' + listType + style + '>\n' + processListItems(list, !!trimTrailing) + '</' + listType + '>\n';
4304      }
4305  
4306      return result;
4307    }
4308  
4309    /** Start of list parsing **/
4310    text = globals.converter._dispatch('lists.before', text, options, globals);
4311    // add sentinel to hack around khtml/safari bug:
4312    // http://bugs.webkit.org/show_bug.cgi?id=11231
4313    text += '¨0';
4314  
4315    if (globals.gListLevel) {
4316      text = text.replace(/^(( {0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(¨0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm,
4317        function (wholeMatch, list, m2) {
4318          var listType = (m2.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
4319          return parseConsecutiveLists(list, listType, true);
4320        }
4321      );
4322    } else {
4323      text = text.replace(/(\n\n|^\n?)(( {0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(¨0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm,
4324        function (wholeMatch, m1, list, m3) {
4325          var listType = (m3.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
4326          return parseConsecutiveLists(list, listType, false);
4327        }
4328      );
4329    }
4330  
4331    // strip sentinel
4332    text = text.replace(/¨0/, '');
4333    text = globals.converter._dispatch('lists.after', text, options, globals);
4334    return text;
4335  });
4336  
4337  /**
4338   * Parse metadata at the top of the document
4339   */
4340  showdown.subParser('metadata', function (text, options, globals) {
4341    'use strict';
4342  
4343    if (!options.metadata) {
4344      return text;
4345    }
4346  
4347    text = globals.converter._dispatch('metadata.before', text, options, globals);
4348  
4349    function parseMetadataContents (content) {
4350      // raw is raw so it's not changed in any way
4351      globals.metadata.raw = content;
4352  
4353      // escape chars forbidden in html attributes
4354      // double quotes
4355      content = content
4356        // ampersand first
4357        .replace(/&/g, '&amp;')
4358        // double quotes
4359        .replace(/"/g, '&quot;');
4360  
4361      content = content.replace(/\n {4}/g, ' ');
4362      content.replace(/^([\S ]+): +([\s\S]+?)$/gm, function (wm, key, value) {
4363        globals.metadata.parsed[key] = value;
4364        return '';
4365      });
4366    }
4367  
4368    text = text.replace(/^\s*«««+(\S*?)\n([\s\S]+?)\n»»»+\n/, function (wholematch, format, content) {
4369      parseMetadataContents(content);
4370      return '¨M';
4371    });
4372  
4373    text = text.replace(/^\s*---+(\S*?)\n([\s\S]+?)\n---+\n/, function (wholematch, format, content) {
4374      if (format) {
4375        globals.metadata.format = format;
4376      }
4377      parseMetadataContents(content);
4378      return '¨M';
4379    });
4380  
4381    text = text.replace(/¨M/g, '');
4382  
4383    text = globals.converter._dispatch('metadata.after', text, options, globals);
4384    return text;
4385  });
4386  
4387  /**
4388   * Remove one level of line-leading tabs or spaces
4389   */
4390  showdown.subParser('outdent', function (text, options, globals) {
4391    'use strict';
4392    text = globals.converter._dispatch('outdent.before', text, options, globals);
4393  
4394    // attacklab: hack around Konqueror 3.5.4 bug:
4395    // "----------bug".replace(/^-/g,"") == "bug"
4396    text = text.replace(/^(\t|[ ]{1,4})/gm, '¨0'); // attacklab: g_tab_width
4397  
4398    // attacklab: clean up hack
4399    text = text.replace(/¨0/g, '');
4400  
4401    text = globals.converter._dispatch('outdent.after', text, options, globals);
4402    return text;
4403  });
4404  
4405  /**
4406   *
4407   */
4408  showdown.subParser('paragraphs', function (text, options, globals) {
4409    'use strict';
4410  
4411    text = globals.converter._dispatch('paragraphs.before', text, options, globals);
4412    // Strip leading and trailing lines:
4413    text = text.replace(/^\n+/g, '');
4414    text = text.replace(/\n+$/g, '');
4415  
4416    var grafs = text.split(/\n{2,}/g),
4417        grafsOut = [],
4418        end = grafs.length; // Wrap <p> tags
4419  
4420    for (var i = 0; i < end; i++) {
4421      var str = grafs[i];
4422      // if this is an HTML marker, copy it
4423      if (str.search(/¨(K|G)(\d+)\1/g) >= 0) {
4424        grafsOut.push(str);
4425  
4426      // test for presence of characters to prevent empty lines being parsed
4427      // as paragraphs (resulting in undesired extra empty paragraphs)
4428      } else if (str.search(/\S/) >= 0) {
4429        str = showdown.subParser('spanGamut')(str, options, globals);
4430        str = str.replace(/^([ \t]*)/g, '<p>');
4431        str += '</p>';
4432        grafsOut.push(str);
4433      }
4434    }
4435  
4436    /** Unhashify HTML blocks */
4437    end = grafsOut.length;
4438    for (i = 0; i < end; i++) {
4439      var blockText = '',
4440          grafsOutIt = grafsOut[i],
4441          codeFlag = false;
4442      // if this is a marker for an html block...
4443      // use RegExp.test instead of string.search because of QML bug
4444      while (/¨(K|G)(\d+)\1/.test(grafsOutIt)) {
4445        var delim = RegExp.$1,
4446            num   = RegExp.$2;
4447  
4448        if (delim === 'K') {
4449          blockText = globals.gHtmlBlocks[num];
4450        } else {
4451          // we need to check if ghBlock is a false positive
4452          if (codeFlag) {
4453            // use encoded version of all text
4454            blockText = showdown.subParser('encodeCode')(globals.ghCodeBlocks[num].text, options, globals);
4455          } else {
4456            blockText = globals.ghCodeBlocks[num].codeblock;
4457          }
4458        }
4459        blockText = blockText.replace(/\$/g, '$$$$'); // Escape any dollar signs
4460  
4461        grafsOutIt = grafsOutIt.replace(/(\n\n)?¨(K|G)\d+\2(\n\n)?/, blockText);
4462        // Check if grafsOutIt is a pre->code
4463        if (/^<pre\b[^>]*>\s*<code\b[^>]*>/.test(grafsOutIt)) {
4464          codeFlag = true;
4465        }
4466      }
4467      grafsOut[i] = grafsOutIt;
4468    }
4469    text = grafsOut.join('\n');
4470    // Strip leading and trailing lines:
4471    text = text.replace(/^\n+/g, '');
4472    text = text.replace(/\n+$/g, '');
4473    return globals.converter._dispatch('paragraphs.after', text, options, globals);
4474  });
4475  
4476  /**
4477   * Run extension
4478   */
4479  showdown.subParser('runExtension', function (ext, text, options, globals) {
4480    'use strict';
4481  
4482    if (ext.filter) {
4483      text = ext.filter(text, globals.converter, options);
4484  
4485    } else if (ext.regex) {
4486      // TODO remove this when old extension loading mechanism is deprecated
4487      var re = ext.regex;
4488      if (!(re instanceof RegExp)) {
4489        re = new RegExp(re, 'g');
4490      }
4491      text = text.replace(re, ext.replace);
4492    }
4493  
4494    return text;
4495  });
4496  
4497  /**
4498   * These are all the transformations that occur *within* block-level
4499   * tags like paragraphs, headers, and list items.
4500   */
4501  showdown.subParser('spanGamut', function (text, options, globals) {
4502    'use strict';
4503  
4504    text = globals.converter._dispatch('spanGamut.before', text, options, globals);
4505    text = showdown.subParser('codeSpans')(text, options, globals);
4506    text = showdown.subParser('escapeSpecialCharsWithinTagAttributes')(text, options, globals);
4507    text = showdown.subParser('encodeBackslashEscapes')(text, options, globals);
4508  
4509    // Process anchor and image tags. Images must come first,
4510    // because ![foo][f] looks like an anchor.
4511    text = showdown.subParser('images')(text, options, globals);
4512    text = showdown.subParser('anchors')(text, options, globals);
4513  
4514    // Make links out of things like `<http://example.com/>`
4515    // Must come after anchors, because you can use < and >
4516    // delimiters in inline links like [this](<url>).
4517    text = showdown.subParser('autoLinks')(text, options, globals);
4518    text = showdown.subParser('simplifiedAutoLinks')(text, options, globals);
4519    text = showdown.subParser('emoji')(text, options, globals);
4520    text = showdown.subParser('underline')(text, options, globals);
4521    text = showdown.subParser('italicsAndBold')(text, options, globals);
4522    text = showdown.subParser('strikethrough')(text, options, globals);
4523    text = showdown.subParser('ellipsis')(text, options, globals);
4524  
4525    // we need to hash HTML tags inside spans
4526    text = showdown.subParser('hashHTMLSpans')(text, options, globals);
4527  
4528    // now we encode amps and angles
4529    text = showdown.subParser('encodeAmpsAndAngles')(text, options, globals);
4530  
4531    // Do hard breaks
4532    if (options.simpleLineBreaks) {
4533      // GFM style hard breaks
4534      // only add line breaks if the text does not contain a block (special case for lists)
4535      if (!/\n\n¨K/.test(text)) {
4536        text = text.replace(/\n+/g, '<br />\n');
4537      }
4538    } else {
4539      // Vanilla hard breaks
4540      text = text.replace(/  +\n/g, '<br />\n');
4541    }
4542  
4543    text = globals.converter._dispatch('spanGamut.after', text, options, globals);
4544    return text;
4545  });
4546  
4547  showdown.subParser('strikethrough', function (text, options, globals) {
4548    'use strict';
4549  
4550    function parseInside (txt) {
4551      if (options.simplifiedAutoLink) {
4552        txt = showdown.subParser('simplifiedAutoLinks')(txt, options, globals);
4553      }
4554      return '<del>' + txt + '</del>';
4555    }
4556  
4557    if (options.strikethrough) {
4558      text = globals.converter._dispatch('strikethrough.before', text, options, globals);
4559      text = text.replace(/(?:~){2}([\s\S]+?)(?:~){2}/g, function (wm, txt) { return parseInside(txt); });
4560      text = globals.converter._dispatch('strikethrough.after', text, options, globals);
4561    }
4562  
4563    return text;
4564  });
4565  
4566  /**
4567   * Strips link definitions from text, stores the URLs and titles in
4568   * hash references.
4569   * Link defs are in the form: ^[id]: url "optional title"
4570   */
4571  showdown.subParser('stripLinkDefinitions', function (text, options, globals) {
4572    'use strict';
4573  
4574    var regex       = /^ {0,3}\[(.+)]:[ \t]*\n?[ \t]*<?([^>\s]+)>?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*\n?[ \t]*(?:(\n*)["|'(](.+?)["|')][ \t]*)?(?:\n+|(?=¨0))/gm,
4575        base64Regex = /^ {0,3}\[(.+)]:[ \t]*\n?[ \t]*<?(data:.+?\/.+?;base64,[A-Za-z0-9+/=\n]+?)>?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*\n?[ \t]*(?:(\n*)["|'(](.+?)["|')][ \t]*)?(?:\n\n|(?=¨0)|(?=\n\[))/gm;
4576  
4577    // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
4578    text += '¨0';
4579  
4580    var replaceFunc = function (wholeMatch, linkId, url, width, height, blankLines, title) {
4581      linkId = linkId.toLowerCase();
4582      if (url.match(/^data:.+?\/.+?;base64,/)) {
4583        // remove newlines
4584        globals.gUrls[linkId] = url.replace(/\s/g, '');
4585      } else {
4586        globals.gUrls[linkId] = showdown.subParser('encodeAmpsAndAngles')(url, options, globals);  // Link IDs are case-insensitive
4587      }
4588  
4589      if (blankLines) {
4590        // Oops, found blank lines, so it's not a title.
4591        // Put back the parenthetical statement we stole.
4592        return blankLines + title;
4593  
4594      } else {
4595        if (title) {
4596          globals.gTitles[linkId] = title.replace(/"|'/g, '&quot;');
4597        }
4598        if (options.parseImgDimensions && width && height) {
4599          globals.gDimensions[linkId] = {
4600            width:  width,
4601            height: height
4602          };
4603        }
4604      }
4605      // Completely remove the definition from the text
4606      return '';
4607    };
4608  
4609    // first we try to find base64 link references
4610    text = text.replace(base64Regex, replaceFunc);
4611  
4612    text = text.replace(regex, replaceFunc);
4613  
4614    // attacklab: strip sentinel
4615    text = text.replace(/¨0/, '');
4616  
4617    return text;
4618  });
4619  
4620  showdown.subParser('tables', function (text, options, globals) {
4621    'use strict';
4622  
4623    if (!options.tables) {
4624      return text;
4625    }
4626  
4627    var tableRgx       = /^ {0,3}\|?.+\|.+\n {0,3}\|?[ \t]*:?[ \t]*(?:[-=]){2,}[ \t]*:?[ \t]*\|[ \t]*:?[ \t]*(?:[-=]){2,}[\s\S]+?(?:\n\n|¨0)/gm,
4628        //singeColTblRgx = /^ {0,3}\|.+\|\n {0,3}\|[ \t]*:?[ \t]*(?:[-=]){2,}[ \t]*:?[ \t]*\|[ \t]*\n(?: {0,3}\|.+\|\n)+(?:\n\n|¨0)/gm;
4629        singeColTblRgx = /^ {0,3}\|.+\|[ \t]*\n {0,3}\|[ \t]*:?[ \t]*(?:[-=]){2,}[ \t]*:?[ \t]*\|[ \t]*\n( {0,3}\|.+\|[ \t]*\n)*(?:\n|¨0)/gm;
4630  
4631    function parseStyles (sLine) {
4632      if (/^:[ \t]*--*$/.test(sLine)) {
4633        return ' style="text-align:left;"';
4634      } else if (/^--*[ \t]*:[ \t]*$/.test(sLine)) {
4635        return ' style="text-align:right;"';
4636      } else if (/^:[ \t]*--*[ \t]*:$/.test(sLine)) {
4637        return ' style="text-align:center;"';
4638      } else {
4639        return '';
4640      }
4641    }
4642  
4643    function parseHeaders (header, style) {
4644      var id = '';
4645      header = header.trim();
4646      // support both tablesHeaderId and tableHeaderId due to error in documentation so we don't break backwards compatibility
4647      if (options.tablesHeaderId || options.tableHeaderId) {
4648        id = ' id="' + header.replace(/ /g, '_').toLowerCase() + '"';
4649      }
4650      header = showdown.subParser('spanGamut')(header, options, globals);
4651  
4652      return '<th' + id + style + '>' + header + '</th>\n';
4653    }
4654  
4655    function parseCells (cell, style) {
4656      var subText = showdown.subParser('spanGamut')(cell, options, globals);
4657      return '<td' + style + '>' + subText + '</td>\n';
4658    }
4659  
4660    function buildTable (headers, cells) {
4661      var tb = '<table>\n<thead>\n<tr>\n',
4662          tblLgn = headers.length;
4663  
4664      for (var i = 0; i < tblLgn; ++i) {
4665        tb += headers[i];
4666      }
4667      tb += '</tr>\n</thead>\n<tbody>\n';
4668  
4669      for (i = 0; i < cells.length; ++i) {
4670        tb += '<tr>\n';
4671        for (var ii = 0; ii < tblLgn; ++ii) {
4672          tb += cells[i][ii];
4673        }
4674        tb += '</tr>\n';
4675      }
4676      tb += '</tbody>\n</table>\n';
4677      return tb;
4678    }
4679  
4680    function parseTable (rawTable) {
4681      var i, tableLines = rawTable.split('\n');
4682  
4683      for (i = 0; i < tableLines.length; ++i) {
4684        // strip wrong first and last column if wrapped tables are used
4685        if (/^ {0,3}\|/.test(tableLines[i])) {
4686          tableLines[i] = tableLines[i].replace(/^ {0,3}\|/, '');
4687        }
4688        if (/\|[ \t]*$/.test(tableLines[i])) {
4689          tableLines[i] = tableLines[i].replace(/\|[ \t]*$/, '');
4690        }
4691        // parse code spans first, but we only support one line code spans
4692        tableLines[i] = showdown.subParser('codeSpans')(tableLines[i], options, globals);
4693      }
4694  
4695      var rawHeaders = tableLines[0].split('|').map(function (s) { return s.trim();}),
4696          rawStyles = tableLines[1].split('|').map(function (s) { return s.trim();}),
4697          rawCells = [],
4698          headers = [],
4699          styles = [],
4700          cells = [];
4701  
4702      tableLines.shift();
4703      tableLines.shift();
4704  
4705      for (i = 0; i < tableLines.length; ++i) {
4706        if (tableLines[i].trim() === '') {
4707          continue;
4708        }
4709        rawCells.push(
4710          tableLines[i]
4711            .split('|')
4712            .map(function (s) {
4713              return s.trim();
4714            })
4715        );
4716      }
4717  
4718      if (rawHeaders.length < rawStyles.length) {
4719        return rawTable;
4720      }
4721  
4722      for (i = 0; i < rawStyles.length; ++i) {
4723        styles.push(parseStyles(rawStyles[i]));
4724      }
4725  
4726      for (i = 0; i < rawHeaders.length; ++i) {
4727        if (showdown.helper.isUndefined(styles[i])) {
4728          styles[i] = '';
4729        }
4730        headers.push(parseHeaders(rawHeaders[i], styles[i]));
4731      }
4732  
4733      for (i = 0; i < rawCells.length; ++i) {
4734        var row = [];
4735        for (var ii = 0; ii < headers.length; ++ii) {
4736          if (showdown.helper.isUndefined(rawCells[i][ii])) {
4737  
4738          }
4739          row.push(parseCells(rawCells[i][ii], styles[ii]));
4740        }
4741        cells.push(row);
4742      }
4743  
4744      return buildTable(headers, cells);
4745    }
4746  
4747    text = globals.converter._dispatch('tables.before', text, options, globals);
4748  
4749    // find escaped pipe characters
4750    text = text.replace(/\\(\|)/g, showdown.helper.escapeCharactersCallback);
4751  
4752    // parse multi column tables
4753    text = text.replace(tableRgx, parseTable);
4754  
4755    // parse one column tables
4756    text = text.replace(singeColTblRgx, parseTable);
4757  
4758    text = globals.converter._dispatch('tables.after', text, options, globals);
4759  
4760    return text;
4761  });
4762  
4763  showdown.subParser('underline', function (text, options, globals) {
4764    'use strict';
4765  
4766    if (!options.underline) {
4767      return text;
4768    }
4769  
4770    text = globals.converter._dispatch('underline.before', text, options, globals);
4771  
4772    if (options.literalMidWordUnderscores) {
4773      text = text.replace(/\b___(\S[\s\S]*?)___\b/g, function (wm, txt) {
4774        return '<u>' + txt + '</u>';
4775      });
4776      text = text.replace(/\b__(\S[\s\S]*?)__\b/g, function (wm, txt) {
4777        return '<u>' + txt + '</u>';
4778      });
4779    } else {
4780      text = text.replace(/___(\S[\s\S]*?)___/g, function (wm, m) {
4781        return (/\S$/.test(m)) ? '<u>' + m + '</u>' : wm;
4782      });
4783      text = text.replace(/__(\S[\s\S]*?)__/g, function (wm, m) {
4784        return (/\S$/.test(m)) ? '<u>' + m + '</u>' : wm;
4785      });
4786    }
4787  
4788    // escape remaining underscores to prevent them being parsed by italic and bold
4789    text = text.replace(/(_)/g, showdown.helper.escapeCharactersCallback);
4790  
4791    text = globals.converter._dispatch('underline.after', text, options, globals);
4792  
4793    return text;
4794  });
4795  
4796  /**
4797   * Swap back in all the special characters we've hidden.
4798   */
4799  showdown.subParser('unescapeSpecialChars', function (text, options, globals) {
4800    'use strict';
4801    text = globals.converter._dispatch('unescapeSpecialChars.before', text, options, globals);
4802  
4803    text = text.replace(/¨E(\d+)E/g, function (wholeMatch, m1) {
4804      var charCodeToReplace = parseInt(m1);
4805      return String.fromCharCode(charCodeToReplace);
4806    });
4807  
4808    text = globals.converter._dispatch('unescapeSpecialChars.after', text, options, globals);
4809    return text;
4810  });
4811  
4812  showdown.subParser('makeMarkdown.blockquote', function (node, globals) {
4813    'use strict';
4814  
4815    var txt = '';
4816    if (node.hasChildNodes()) {
4817      var children = node.childNodes,
4818          childrenLength = children.length;
4819  
4820      for (var i = 0; i < childrenLength; ++i) {
4821        var innerTxt = showdown.subParser('makeMarkdown.node')(children[i], globals);
4822  
4823        if (innerTxt === '') {
4824          continue;
4825        }
4826        txt += innerTxt;
4827      }
4828    }
4829    // cleanup
4830    txt = txt.trim();
4831    txt = '> ' + txt.split('\n').join('\n> ');
4832    return txt;
4833  });
4834  
4835  showdown.subParser('makeMarkdown.codeBlock', function (node, globals) {
4836    'use strict';
4837  
4838    var lang = node.getAttribute('language'),
4839        num  = node.getAttribute('precodenum');
4840    return '```' + lang + '\n' + globals.preList[num] + '\n```';
4841  });
4842  
4843  showdown.subParser('makeMarkdown.codeSpan', function (node) {
4844    'use strict';
4845  
4846    return '`' + node.innerHTML + '`';
4847  });
4848  
4849  showdown.subParser('makeMarkdown.emphasis', function (node, globals) {
4850    'use strict';
4851  
4852    var txt = '';
4853    if (node.hasChildNodes()) {
4854      txt += '*';
4855      var children = node.childNodes,
4856          childrenLength = children.length;
4857      for (var i = 0; i < childrenLength; ++i) {
4858        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
4859      }
4860      txt += '*';
4861    }
4862    return txt;
4863  });
4864  
4865  showdown.subParser('makeMarkdown.header', function (node, globals, headerLevel) {
4866    'use strict';
4867  
4868    var headerMark = new Array(headerLevel + 1).join('#'),
4869        txt = '';
4870  
4871    if (node.hasChildNodes()) {
4872      txt = headerMark + ' ';
4873      var children = node.childNodes,
4874          childrenLength = children.length;
4875  
4876      for (var i = 0; i < childrenLength; ++i) {
4877        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
4878      }
4879    }
4880    return txt;
4881  });
4882  
4883  showdown.subParser('makeMarkdown.hr', function () {
4884    'use strict';
4885  
4886    return '---';
4887  });
4888  
4889  showdown.subParser('makeMarkdown.image', function (node) {
4890    'use strict';
4891  
4892    var txt = '';
4893    if (node.hasAttribute('src')) {
4894      txt += '![' + node.getAttribute('alt') + '](';
4895      txt += '<' + node.getAttribute('src') + '>';
4896      if (node.hasAttribute('width') && node.hasAttribute('height')) {
4897        txt += ' =' + node.getAttribute('width') + 'x' + node.getAttribute('height');
4898      }
4899  
4900      if (node.hasAttribute('title')) {
4901        txt += ' "' + node.getAttribute('title') + '"';
4902      }
4903      txt += ')';
4904    }
4905    return txt;
4906  });
4907  
4908  showdown.subParser('makeMarkdown.links', function (node, globals) {
4909    'use strict';
4910  
4911    var txt = '';
4912    if (node.hasChildNodes() && node.hasAttribute('href')) {
4913      var children = node.childNodes,
4914          childrenLength = children.length;
4915      txt = '[';
4916      for (var i = 0; i < childrenLength; ++i) {
4917        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
4918      }
4919      txt += '](';
4920      txt += '<' + node.getAttribute('href') + '>';
4921      if (node.hasAttribute('title')) {
4922        txt += ' "' + node.getAttribute('title') + '"';
4923      }
4924      txt += ')';
4925    }
4926    return txt;
4927  });
4928  
4929  showdown.subParser('makeMarkdown.list', function (node, globals, type) {
4930    'use strict';
4931  
4932    var txt = '';
4933    if (!node.hasChildNodes()) {
4934      return '';
4935    }
4936    var listItems       = node.childNodes,
4937        listItemsLenght = listItems.length,
4938        listNum = node.getAttribute('start') || 1;
4939  
4940    for (var i = 0; i < listItemsLenght; ++i) {
4941      if (typeof listItems[i].tagName === 'undefined' || listItems[i].tagName.toLowerCase() !== 'li') {
4942        continue;
4943      }
4944  
4945      // define the bullet to use in list
4946      var bullet = '';
4947      if (type === 'ol') {
4948        bullet = listNum.toString() + '. ';
4949      } else {
4950        bullet = '- ';
4951      }
4952  
4953      // parse list item
4954      txt += bullet + showdown.subParser('makeMarkdown.listItem')(listItems[i], globals);
4955      ++listNum;
4956    }
4957  
4958    // add comment at the end to prevent consecutive lists to be parsed as one
4959    txt += '\n<!-- -->\n';
4960    return txt.trim();
4961  });
4962  
4963  showdown.subParser('makeMarkdown.listItem', function (node, globals) {
4964    'use strict';
4965  
4966    var listItemTxt = '';
4967  
4968    var children = node.childNodes,
4969        childrenLenght = children.length;
4970  
4971    for (var i = 0; i < childrenLenght; ++i) {
4972      listItemTxt += showdown.subParser('makeMarkdown.node')(children[i], globals);
4973    }
4974    // if it's only one liner, we need to add a newline at the end
4975    if (!/\n$/.test(listItemTxt)) {
4976      listItemTxt += '\n';
4977    } else {
4978      // it's multiparagraph, so we need to indent
4979      listItemTxt = listItemTxt
4980        .split('\n')
4981        .join('\n    ')
4982        .replace(/^ {4}$/gm, '')
4983        .replace(/\n\n+/g, '\n\n');
4984    }
4985  
4986    return listItemTxt;
4987  });
4988  
4989  
4990  
4991  showdown.subParser('makeMarkdown.node', function (node, globals, spansOnly) {
4992    'use strict';
4993  
4994    spansOnly = spansOnly || false;
4995  
4996    var txt = '';
4997  
4998    // edge case of text without wrapper paragraph
4999    if (node.nodeType === 3) {
5000      return showdown.subParser('makeMarkdown.txt')(node, globals);
5001    }
5002  
5003    // HTML comment
5004    if (node.nodeType === 8) {
5005      return '<!--' + node.data + '-->\n\n';
5006    }
5007  
5008    // process only node elements
5009    if (node.nodeType !== 1) {
5010      return '';
5011    }
5012  
5013    var tagName = node.tagName.toLowerCase();
5014  
5015    switch (tagName) {
5016  
5017      //
5018      // BLOCKS
5019      //
5020      case 'h1':
5021        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 1) + '\n\n'; }
5022        break;
5023      case 'h2':
5024        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 2) + '\n\n'; }
5025        break;
5026      case 'h3':
5027        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 3) + '\n\n'; }
5028        break;
5029      case 'h4':
5030        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 4) + '\n\n'; }
5031        break;
5032      case 'h5':
5033        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 5) + '\n\n'; }
5034        break;
5035      case 'h6':
5036        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 6) + '\n\n'; }
5037        break;
5038  
5039      case 'p':
5040        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.paragraph')(node, globals) + '\n\n'; }
5041        break;
5042  
5043      case 'blockquote':
5044        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.blockquote')(node, globals) + '\n\n'; }
5045        break;
5046  
5047      case 'hr':
5048        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.hr')(node, globals) + '\n\n'; }
5049        break;
5050  
5051      case 'ol':
5052        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.list')(node, globals, 'ol') + '\n\n'; }
5053        break;
5054  
5055      case 'ul':
5056        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.list')(node, globals, 'ul') + '\n\n'; }
5057        break;
5058  
5059      case 'precode':
5060        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.codeBlock')(node, globals) + '\n\n'; }
5061        break;
5062  
5063      case 'pre':
5064        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.pre')(node, globals) + '\n\n'; }
5065        break;
5066  
5067      case 'table':
5068        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.table')(node, globals) + '\n\n'; }
5069        break;
5070  
5071      //
5072      // SPANS
5073      //
5074      case 'code':
5075        txt = showdown.subParser('makeMarkdown.codeSpan')(node, globals);
5076        break;
5077  
5078      case 'em':
5079      case 'i':
5080        txt = showdown.subParser('makeMarkdown.emphasis')(node, globals);
5081        break;
5082  
5083      case 'strong':
5084      case 'b':
5085        txt = showdown.subParser('makeMarkdown.strong')(node, globals);
5086        break;
5087  
5088      case 'del':
5089        txt = showdown.subParser('makeMarkdown.strikethrough')(node, globals);
5090        break;
5091  
5092      case 'a':
5093        txt = showdown.subParser('makeMarkdown.links')(node, globals);
5094        break;
5095  
5096      case 'img':
5097        txt = showdown.subParser('makeMarkdown.image')(node, globals);
5098        break;
5099  
5100      default:
5101        txt = node.outerHTML + '\n\n';
5102    }
5103  
5104    // common normalization
5105    // TODO eventually
5106  
5107    return txt;
5108  });
5109  
5110  showdown.subParser('makeMarkdown.paragraph', function (node, globals) {
5111    'use strict';
5112  
5113    var txt = '';
5114    if (node.hasChildNodes()) {
5115      var children = node.childNodes,
5116          childrenLength = children.length;
5117      for (var i = 0; i < childrenLength; ++i) {
5118        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5119      }
5120    }
5121  
5122    // some text normalization
5123    txt = txt.trim();
5124  
5125    return txt;
5126  });
5127  
5128  showdown.subParser('makeMarkdown.pre', function (node, globals) {
5129    'use strict';
5130  
5131    var num  = node.getAttribute('prenum');
5132    return '<pre>' + globals.preList[num] + '</pre>';
5133  });
5134  
5135  showdown.subParser('makeMarkdown.strikethrough', function (node, globals) {
5136    'use strict';
5137  
5138    var txt = '';
5139    if (node.hasChildNodes()) {
5140      txt += '~~';
5141      var children = node.childNodes,
5142          childrenLength = children.length;
5143      for (var i = 0; i < childrenLength; ++i) {
5144        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5145      }
5146      txt += '~~';
5147    }
5148    return txt;
5149  });
5150  
5151  showdown.subParser('makeMarkdown.strong', function (node, globals) {
5152    'use strict';
5153  
5154    var txt = '';
5155    if (node.hasChildNodes()) {
5156      txt += '**';
5157      var children = node.childNodes,
5158          childrenLength = children.length;
5159      for (var i = 0; i < childrenLength; ++i) {
5160        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5161      }
5162      txt += '**';
5163    }
5164    return txt;
5165  });
5166  
5167  showdown.subParser('makeMarkdown.table', function (node, globals) {
5168    'use strict';
5169  
5170    var txt = '',
5171        tableArray = [[], []],
5172        headings   = node.querySelectorAll('thead>tr>th'),
5173        rows       = node.querySelectorAll('tbody>tr'),
5174        i, ii;
5175    for (i = 0; i < headings.length; ++i) {
5176      var headContent = showdown.subParser('makeMarkdown.tableCell')(headings[i], globals),
5177          allign = '---';
5178  
5179      if (headings[i].hasAttribute('style')) {
5180        var style = headings[i].getAttribute('style').toLowerCase().replace(/\s/g, '');
5181        switch (style) {
5182          case 'text-align:left;':
5183            allign = ':---';
5184            break;
5185          case 'text-align:right;':
5186            allign = '---:';
5187            break;
5188          case 'text-align:center;':
5189            allign = ':---:';
5190            break;
5191        }
5192      }
5193      tableArray[0][i] = headContent.trim();
5194      tableArray[1][i] = allign;
5195    }
5196  
5197    for (i = 0; i < rows.length; ++i) {
5198      var r = tableArray.push([]) - 1,
5199          cols = rows[i].getElementsByTagName('td');
5200  
5201      for (ii = 0; ii < headings.length; ++ii) {
5202        var cellContent = ' ';
5203        if (typeof cols[ii] !== 'undefined') {
5204          cellContent = showdown.subParser('makeMarkdown.tableCell')(cols[ii], globals);
5205        }
5206        tableArray[r].push(cellContent);
5207      }
5208    }
5209  
5210    var cellSpacesCount = 3;
5211    for (i = 0; i < tableArray.length; ++i) {
5212      for (ii = 0; ii < tableArray[i].length; ++ii) {
5213        var strLen = tableArray[i][ii].length;
5214        if (strLen > cellSpacesCount) {
5215          cellSpacesCount = strLen;
5216        }
5217      }
5218    }
5219  
5220    for (i = 0; i < tableArray.length; ++i) {
5221      for (ii = 0; ii < tableArray[i].length; ++ii) {
5222        if (i === 1) {
5223          if (tableArray[i][ii].slice(-1) === ':') {
5224            tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii].slice(-1), cellSpacesCount - 1, '-') + ':';
5225          } else {
5226            tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount, '-');
5227          }
5228        } else {
5229          tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount);
5230        }
5231      }
5232      txt += '| ' + tableArray[i].join(' | ') + ' |\n';
5233    }
5234  
5235    return txt.trim();
5236  });
5237  
5238  showdown.subParser('makeMarkdown.tableCell', function (node, globals) {
5239    'use strict';
5240  
5241    var txt = '';
5242    if (!node.hasChildNodes()) {
5243      return '';
5244    }
5245    var children = node.childNodes,
5246        childrenLength = children.length;
5247  
5248    for (var i = 0; i < childrenLength; ++i) {
5249      txt += showdown.subParser('makeMarkdown.node')(children[i], globals, true);
5250    }
5251    return txt.trim();
5252  });
5253  
5254  showdown.subParser('makeMarkdown.txt', function (node) {
5255    'use strict';
5256  
5257    var txt = node.nodeValue;
5258  
5259    // multiple spaces are collapsed
5260    txt = txt.replace(/ +/g, ' ');
5261  
5262    // replace the custom ¨NBSP; with a space
5263    txt = txt.replace(/¨NBSP;/g, ' ');
5264  
5265    // ", <, > and & should replace escaped html entities
5266    txt = showdown.helper.unescapeHTMLEntities(txt);
5267  
5268    // escape markdown magic characters
5269    // emphasis, strong and strikethrough - can appear everywhere
5270    // we also escape pipe (|) because of tables
5271    // and escape ` because of code blocks and spans
5272    txt = txt.replace(/([*_~|`])/g, '\\$1');
5273  
5274    // escape > because of blockquotes
5275    txt = txt.replace(/^(\s*)>/g, '\\$1>');
5276  
5277    // hash character, only troublesome at the beginning of a line because of headers
5278    txt = txt.replace(/^#/gm, '\\#');
5279  
5280    // horizontal rules
5281    txt = txt.replace(/^(\s*)([-=]{3,})(\s*)$/, '$1\\$2$3');
5282  
5283    // dot, because of ordered lists, only troublesome at the beginning of a line when preceded by an integer
5284    txt = txt.replace(/^( {0,3}\d+)\./gm, '$1\\.');
5285  
5286    // +, * and -, at the beginning of a line becomes a list, so we need to escape them also (asterisk was already escaped)
5287    txt = txt.replace(/^( {0,3})([+-])/gm, '$1\\$2');
5288  
5289    // images and links, ] followed by ( is problematic, so we escape it
5290    txt = txt.replace(/]([\s]*)\(/g, '\\]$1\\(');
5291  
5292    // reference URIs must also be escaped
5293    txt = txt.replace(/^ {0,3}\[([\S \t]*?)]:/gm, '\\[$1]:');
5294  
5295    return txt;
5296  });
5297  
5298  var root = this;
5299  
5300  // AMD Loader
5301  if (true) {
5302    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {
5303      'use strict';
5304      return showdown;
5305    }).call(exports, __webpack_require__, exports, module),
5306          __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
5307  
5308  // CommonJS/nodeJS Loader
5309  } else {}
5310  }).call(this);
5311  
5312  
5313  
5314  
5315  /***/ })
5316  
5317  /******/     });
5318  /************************************************************************/
5319  /******/     // The module cache
5320  /******/     var __webpack_module_cache__ = {};
5321  /******/     
5322  /******/     // The require function
5323  /******/ 	function __webpack_require__(moduleId) {
5324  /******/         // Check if module is in cache
5325  /******/         var cachedModule = __webpack_module_cache__[moduleId];
5326  /******/         if (cachedModule !== undefined) {
5327  /******/             return cachedModule.exports;
5328  /******/         }
5329  /******/         // Create a new module (and put it into the cache)
5330  /******/         var module = __webpack_module_cache__[moduleId] = {
5331  /******/             // no module.id needed
5332  /******/             // no module.loaded needed
5333  /******/             exports: {}
5334  /******/         };
5335  /******/     
5336  /******/         // Execute the module function
5337  /******/         __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
5338  /******/     
5339  /******/         // Return the exports of the module
5340  /******/         return module.exports;
5341  /******/     }
5342  /******/     
5343  /************************************************************************/
5344  /******/     /* webpack/runtime/compat get default export */
5345  /******/     !function() {
5346  /******/         // getDefaultExport function for compatibility with non-harmony modules
5347  /******/         __webpack_require__.n = function(module) {
5348  /******/             var getter = module && module.__esModule ?
5349  /******/                 function() { return module['default']; } :
5350  /******/                 function() { return module; };
5351  /******/             __webpack_require__.d(getter, { a: getter });
5352  /******/             return getter;
5353  /******/         };
5354  /******/     }();
5355  /******/     
5356  /******/     /* webpack/runtime/define property getters */
5357  /******/     !function() {
5358  /******/         // define getter functions for harmony exports
5359  /******/         __webpack_require__.d = function(exports, definition) {
5360  /******/             for(var key in definition) {
5361  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
5362  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
5363  /******/                 }
5364  /******/             }
5365  /******/         };
5366  /******/     }();
5367  /******/     
5368  /******/     /* webpack/runtime/hasOwnProperty shorthand */
5369  /******/     !function() {
5370  /******/         __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
5371  /******/     }();
5372  /******/     
5373  /******/     /* webpack/runtime/make namespace object */
5374  /******/     !function() {
5375  /******/         // define __esModule on exports
5376  /******/         __webpack_require__.r = function(exports) {
5377  /******/             if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
5378  /******/                 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
5379  /******/             }
5380  /******/             Object.defineProperty(exports, '__esModule', { value: true });
5381  /******/         };
5382  /******/     }();
5383  /******/     
5384  /************************************************************************/
5385  var __webpack_exports__ = {};
5386  // This entry need to be wrapped in an IIFE because it need to be in strict mode.
5387  !function() {
5388  "use strict";
5389  // ESM COMPAT FLAG
5390  __webpack_require__.r(__webpack_exports__);
5391  
5392  // EXPORTS
5393  __webpack_require__.d(__webpack_exports__, {
5394    "__EXPERIMENTAL_ELEMENTS": function() { return /* reexport */ __EXPERIMENTAL_ELEMENTS; },
5395    "__EXPERIMENTAL_PATHS_WITH_MERGE": function() { return /* reexport */ __EXPERIMENTAL_PATHS_WITH_MERGE; },
5396    "__EXPERIMENTAL_STYLE_PROPERTY": function() { return /* reexport */ __EXPERIMENTAL_STYLE_PROPERTY; },
5397    "__experimentalCloneSanitizedBlock": function() { return /* reexport */ __experimentalCloneSanitizedBlock; },
5398    "__experimentalGetAccessibleBlockLabel": function() { return /* reexport */ getAccessibleBlockLabel; },
5399    "__experimentalGetBlockAttributesNamesByRole": function() { return /* reexport */ __experimentalGetBlockAttributesNamesByRole; },
5400    "__experimentalGetBlockLabel": function() { return /* reexport */ getBlockLabel; },
5401    "__experimentalSanitizeBlockAttributes": function() { return /* reexport */ __experimentalSanitizeBlockAttributes; },
5402    "__unstableGetBlockProps": function() { return /* reexport */ getBlockProps; },
5403    "__unstableGetInnerBlocksProps": function() { return /* reexport */ getInnerBlocksProps; },
5404    "__unstableSerializeAndClean": function() { return /* reexport */ __unstableSerializeAndClean; },
5405    "children": function() { return /* reexport */ children; },
5406    "cloneBlock": function() { return /* reexport */ cloneBlock; },
5407    "createBlock": function() { return /* reexport */ createBlock; },
5408    "createBlocksFromInnerBlocksTemplate": function() { return /* reexport */ createBlocksFromInnerBlocksTemplate; },
5409    "doBlocksMatchTemplate": function() { return /* reexport */ doBlocksMatchTemplate; },
5410    "findTransform": function() { return /* reexport */ findTransform; },
5411    "getBlockAttributes": function() { return /* reexport */ getBlockAttributes; },
5412    "getBlockContent": function() { return /* reexport */ getBlockInnerHTML; },
5413    "getBlockDefaultClassName": function() { return /* reexport */ getBlockDefaultClassName; },
5414    "getBlockFromExample": function() { return /* reexport */ getBlockFromExample; },
5415    "getBlockMenuDefaultClassName": function() { return /* reexport */ getBlockMenuDefaultClassName; },
5416    "getBlockSupport": function() { return /* reexport */ registration_getBlockSupport; },
5417    "getBlockTransforms": function() { return /* reexport */ getBlockTransforms; },
5418    "getBlockType": function() { return /* reexport */ registration_getBlockType; },
5419    "getBlockTypes": function() { return /* reexport */ registration_getBlockTypes; },
5420    "getBlockVariations": function() { return /* reexport */ registration_getBlockVariations; },
5421    "getCategories": function() { return /* reexport */ categories_getCategories; },
5422    "getChildBlockNames": function() { return /* reexport */ registration_getChildBlockNames; },
5423    "getDefaultBlockName": function() { return /* reexport */ registration_getDefaultBlockName; },
5424    "getFreeformContentHandlerName": function() { return /* reexport */ getFreeformContentHandlerName; },
5425    "getGroupingBlockName": function() { return /* reexport */ registration_getGroupingBlockName; },
5426    "getPhrasingContentSchema": function() { return /* reexport */ deprecatedGetPhrasingContentSchema; },
5427    "getPossibleBlockTransformations": function() { return /* reexport */ getPossibleBlockTransformations; },
5428    "getSaveContent": function() { return /* reexport */ getSaveContent; },
5429    "getSaveElement": function() { return /* reexport */ getSaveElement; },
5430    "getUnregisteredTypeHandlerName": function() { return /* reexport */ getUnregisteredTypeHandlerName; },
5431    "hasBlockSupport": function() { return /* reexport */ registration_hasBlockSupport; },
5432    "hasChildBlocks": function() { return /* reexport */ registration_hasChildBlocks; },
5433    "hasChildBlocksWithInserterSupport": function() { return /* reexport */ registration_hasChildBlocksWithInserterSupport; },
5434    "isReusableBlock": function() { return /* reexport */ isReusableBlock; },
5435    "isTemplatePart": function() { return /* reexport */ isTemplatePart; },
5436    "isUnmodifiedDefaultBlock": function() { return /* reexport */ isUnmodifiedDefaultBlock; },
5437    "isValidBlockContent": function() { return /* reexport */ isValidBlockContent; },
5438    "isValidIcon": function() { return /* reexport */ isValidIcon; },
5439    "node": function() { return /* reexport */ node; },
5440    "normalizeIconObject": function() { return /* reexport */ normalizeIconObject; },
5441    "parse": function() { return /* reexport */ parser_parse; },
5442    "parseWithAttributeSchema": function() { return /* reexport */ parseWithAttributeSchema; },
5443    "pasteHandler": function() { return /* reexport */ pasteHandler; },
5444    "rawHandler": function() { return /* reexport */ rawHandler; },
5445    "registerBlockCollection": function() { return /* reexport */ registerBlockCollection; },
5446    "registerBlockStyle": function() { return /* reexport */ registerBlockStyle; },
5447    "registerBlockType": function() { return /* reexport */ registerBlockType; },
5448    "registerBlockVariation": function() { return /* reexport */ registerBlockVariation; },
5449    "serialize": function() { return /* reexport */ serializer_serialize; },
5450    "serializeRawBlock": function() { return /* reexport */ serializeRawBlock; },
5451    "setCategories": function() { return /* reexport */ categories_setCategories; },
5452    "setDefaultBlockName": function() { return /* reexport */ setDefaultBlockName; },
5453    "setFreeformContentHandlerName": function() { return /* reexport */ setFreeformContentHandlerName; },
5454    "setGroupingBlockName": function() { return /* reexport */ setGroupingBlockName; },
5455    "setUnregisteredTypeHandlerName": function() { return /* reexport */ setUnregisteredTypeHandlerName; },
5456    "store": function() { return /* reexport */ store; },
5457    "switchToBlockType": function() { return /* reexport */ switchToBlockType; },
5458    "synchronizeBlocksWithTemplate": function() { return /* reexport */ synchronizeBlocksWithTemplate; },
5459    "unregisterBlockStyle": function() { return /* reexport */ unregisterBlockStyle; },
5460    "unregisterBlockType": function() { return /* reexport */ unregisterBlockType; },
5461    "unregisterBlockVariation": function() { return /* reexport */ unregisterBlockVariation; },
5462    "unstable__bootstrapServerSideBlockDefinitions": function() { return /* reexport */ unstable__bootstrapServerSideBlockDefinitions; },
5463    "updateCategory": function() { return /* reexport */ categories_updateCategory; },
5464    "validateBlock": function() { return /* reexport */ validateBlock; },
5465    "withBlockContentContext": function() { return /* reexport */ withBlockContentContext; }
5466  });
5467  
5468  // NAMESPACE OBJECT: ./node_modules/@wordpress/blocks/build-module/store/selectors.js
5469  var selectors_namespaceObject = {};
5470  __webpack_require__.r(selectors_namespaceObject);
5471  __webpack_require__.d(selectors_namespaceObject, {
5472    "__experimentalGetUnprocessedBlockTypes": function() { return __experimentalGetUnprocessedBlockTypes; },
5473    "getActiveBlockVariation": function() { return getActiveBlockVariation; },
5474    "getBlockStyles": function() { return getBlockStyles; },
5475    "getBlockSupport": function() { return getBlockSupport; },
5476    "getBlockType": function() { return getBlockType; },
5477    "getBlockTypes": function() { return getBlockTypes; },
5478    "getBlockVariations": function() { return getBlockVariations; },
5479    "getCategories": function() { return getCategories; },
5480    "getChildBlockNames": function() { return getChildBlockNames; },
5481    "getCollections": function() { return getCollections; },
5482    "getDefaultBlockName": function() { return getDefaultBlockName; },
5483    "getDefaultBlockVariation": function() { return getDefaultBlockVariation; },
5484    "getFreeformFallbackBlockName": function() { return getFreeformFallbackBlockName; },
5485    "getGroupingBlockName": function() { return getGroupingBlockName; },
5486    "getUnregisteredFallbackBlockName": function() { return getUnregisteredFallbackBlockName; },
5487    "hasBlockSupport": function() { return hasBlockSupport; },
5488    "hasChildBlocks": function() { return hasChildBlocks; },
5489    "hasChildBlocksWithInserterSupport": function() { return hasChildBlocksWithInserterSupport; },
5490    "isMatchingSearchTerm": function() { return isMatchingSearchTerm; }
5491  });
5492  
5493  // NAMESPACE OBJECT: ./node_modules/@wordpress/blocks/build-module/store/actions.js
5494  var actions_namespaceObject = {};
5495  __webpack_require__.r(actions_namespaceObject);
5496  __webpack_require__.d(actions_namespaceObject, {
5497    "__experimentalReapplyBlockTypeFilters": function() { return __experimentalReapplyBlockTypeFilters; },
5498    "__experimentalRegisterBlockType": function() { return __experimentalRegisterBlockType; },
5499    "addBlockCollection": function() { return addBlockCollection; },
5500    "addBlockStyles": function() { return addBlockStyles; },
5501    "addBlockTypes": function() { return addBlockTypes; },
5502    "addBlockVariations": function() { return addBlockVariations; },
5503    "removeBlockCollection": function() { return removeBlockCollection; },
5504    "removeBlockStyles": function() { return removeBlockStyles; },
5505    "removeBlockTypes": function() { return removeBlockTypes; },
5506    "removeBlockVariations": function() { return removeBlockVariations; },
5507    "setCategories": function() { return setCategories; },
5508    "setDefaultBlockName": function() { return actions_setDefaultBlockName; },
5509    "setFreeformFallbackBlockName": function() { return setFreeformFallbackBlockName; },
5510    "setGroupingBlockName": function() { return actions_setGroupingBlockName; },
5511    "setUnregisteredFallbackBlockName": function() { return setUnregisteredFallbackBlockName; },
5512    "updateCategory": function() { return updateCategory; }
5513  });
5514  
5515  ;// CONCATENATED MODULE: external ["wp","data"]
5516  var external_wp_data_namespaceObject = window["wp"]["data"];
5517  ;// CONCATENATED MODULE: external "lodash"
5518  var external_lodash_namespaceObject = window["lodash"];
5519  ;// CONCATENATED MODULE: external ["wp","i18n"]
5520  var external_wp_i18n_namespaceObject = window["wp"]["i18n"];
5521  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/reducer.js
5522  /**
5523   * External dependencies
5524   */
5525  
5526  /**
5527   * WordPress dependencies
5528   */
5529  
5530  
5531  
5532  /**
5533   * @typedef {Object} WPBlockCategory
5534   *
5535   * @property {string} slug  Unique category slug.
5536   * @property {string} title Category label, for display in user interface.
5537   */
5538  
5539  /**
5540   * Default set of categories.
5541   *
5542   * @type {WPBlockCategory[]}
5543   */
5544  
5545  const DEFAULT_CATEGORIES = [{
5546    slug: 'text',
5547    title: (0,external_wp_i18n_namespaceObject.__)('Text')
5548  }, {
5549    slug: 'media',
5550    title: (0,external_wp_i18n_namespaceObject.__)('Media')
5551  }, {
5552    slug: 'design',
5553    title: (0,external_wp_i18n_namespaceObject.__)('Design')
5554  }, {
5555    slug: 'widgets',
5556    title: (0,external_wp_i18n_namespaceObject.__)('Widgets')
5557  }, {
5558    slug: 'theme',
5559    title: (0,external_wp_i18n_namespaceObject.__)('Theme')
5560  }, {
5561    slug: 'embed',
5562    title: (0,external_wp_i18n_namespaceObject.__)('Embeds')
5563  }, {
5564    slug: 'reusable',
5565    title: (0,external_wp_i18n_namespaceObject.__)('Reusable blocks')
5566  }];
5567  /**
5568   * Reducer managing the unprocessed block types in a form passed when registering the by block.
5569   * It's for internal use only. It allows recomputing the processed block types on-demand after block type filters
5570   * get added or removed.
5571   *
5572   * @param {Object} state  Current state.
5573   * @param {Object} action Dispatched action.
5574   *
5575   * @return {Object} Updated state.
5576   */
5577  
5578  function unprocessedBlockTypes() {
5579    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
5580    let action = arguments.length > 1 ? arguments[1] : undefined;
5581  
5582    switch (action.type) {
5583      case 'ADD_UNPROCESSED_BLOCK_TYPE':
5584        return { ...state,
5585          [action.blockType.name]: action.blockType
5586        };
5587  
5588      case 'REMOVE_BLOCK_TYPES':
5589        return (0,external_lodash_namespaceObject.omit)(state, action.names);
5590    }
5591  
5592    return state;
5593  }
5594  /**
5595   * Reducer managing the processed block types with all filters applied.
5596   * The state is derived from the `unprocessedBlockTypes` reducer.
5597   *
5598   * @param {Object} state  Current state.
5599   * @param {Object} action Dispatched action.
5600   *
5601   * @return {Object} Updated state.
5602   */
5603  
5604  function blockTypes() {
5605    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
5606    let action = arguments.length > 1 ? arguments[1] : undefined;
5607  
5608    switch (action.type) {
5609      case 'ADD_BLOCK_TYPES':
5610        return { ...state,
5611          ...(0,external_lodash_namespaceObject.keyBy)(action.blockTypes, 'name')
5612        };
5613  
5614      case 'REMOVE_BLOCK_TYPES':
5615        return (0,external_lodash_namespaceObject.omit)(state, action.names);
5616    }
5617  
5618    return state;
5619  }
5620  /**
5621   * Reducer managing the block style variations.
5622   *
5623   * @param {Object} state  Current state.
5624   * @param {Object} action Dispatched action.
5625   *
5626   * @return {Object} Updated state.
5627   */
5628  
5629  function blockStyles() {
5630    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
5631    let action = arguments.length > 1 ? arguments[1] : undefined;
5632  
5633    switch (action.type) {
5634      case 'ADD_BLOCK_TYPES':
5635        return { ...state,
5636          ...(0,external_lodash_namespaceObject.mapValues)((0,external_lodash_namespaceObject.keyBy)(action.blockTypes, 'name'), blockType => {
5637            return (0,external_lodash_namespaceObject.uniqBy)([...(0,external_lodash_namespaceObject.get)(blockType, ['styles'], []).map(style => ({ ...style,
5638              source: 'block'
5639            })), ...(0,external_lodash_namespaceObject.get)(state, [blockType.name], []).filter(_ref => {
5640              let {
5641                source
5642              } = _ref;
5643              return 'block' !== source;
5644            })], style => style.name);
5645          })
5646        };
5647  
5648      case 'ADD_BLOCK_STYLES':
5649        return { ...state,
5650          [action.blockName]: (0,external_lodash_namespaceObject.uniqBy)([...(0,external_lodash_namespaceObject.get)(state, [action.blockName], []), ...action.styles], style => style.name)
5651        };
5652  
5653      case 'REMOVE_BLOCK_STYLES':
5654        return { ...state,
5655          [action.blockName]: (0,external_lodash_namespaceObject.filter)((0,external_lodash_namespaceObject.get)(state, [action.blockName], []), style => action.styleNames.indexOf(style.name) === -1)
5656        };
5657    }
5658  
5659    return state;
5660  }
5661  /**
5662   * Reducer managing the block variations.
5663   *
5664   * @param {Object} state  Current state.
5665   * @param {Object} action Dispatched action.
5666   *
5667   * @return {Object} Updated state.
5668   */
5669  
5670  function blockVariations() {
5671    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
5672    let action = arguments.length > 1 ? arguments[1] : undefined;
5673  
5674    switch (action.type) {
5675      case 'ADD_BLOCK_TYPES':
5676        return { ...state,
5677          ...(0,external_lodash_namespaceObject.mapValues)((0,external_lodash_namespaceObject.keyBy)(action.blockTypes, 'name'), blockType => {
5678            return (0,external_lodash_namespaceObject.uniqBy)([...(0,external_lodash_namespaceObject.get)(blockType, ['variations'], []).map(variation => ({ ...variation,
5679              source: 'block'
5680            })), ...(0,external_lodash_namespaceObject.get)(state, [blockType.name], []).filter(_ref2 => {
5681              let {
5682                source
5683              } = _ref2;
5684              return 'block' !== source;
5685            })], variation => variation.name);
5686          })
5687        };
5688  
5689      case 'ADD_BLOCK_VARIATIONS':
5690        return { ...state,
5691          [action.blockName]: (0,external_lodash_namespaceObject.uniqBy)([...(0,external_lodash_namespaceObject.get)(state, [action.blockName], []), ...action.variations], variation => variation.name)
5692        };
5693  
5694      case 'REMOVE_BLOCK_VARIATIONS':
5695        return { ...state,
5696          [action.blockName]: (0,external_lodash_namespaceObject.filter)((0,external_lodash_namespaceObject.get)(state, [action.blockName], []), variation => action.variationNames.indexOf(variation.name) === -1)
5697        };
5698    }
5699  
5700    return state;
5701  }
5702  /**
5703   * Higher-order Reducer creating a reducer keeping track of given block name.
5704   *
5705   * @param {string} setActionType Action type.
5706   *
5707   * @return {Function} Reducer.
5708   */
5709  
5710  function createBlockNameSetterReducer(setActionType) {
5711    return function () {
5712      let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
5713      let action = arguments.length > 1 ? arguments[1] : undefined;
5714  
5715      switch (action.type) {
5716        case 'REMOVE_BLOCK_TYPES':
5717          if (action.names.indexOf(state) !== -1) {
5718            return null;
5719          }
5720  
5721          return state;
5722  
5723        case setActionType:
5724          return action.name || null;
5725      }
5726  
5727      return state;
5728    };
5729  }
5730  const defaultBlockName = createBlockNameSetterReducer('SET_DEFAULT_BLOCK_NAME');
5731  const freeformFallbackBlockName = createBlockNameSetterReducer('SET_FREEFORM_FALLBACK_BLOCK_NAME');
5732  const unregisteredFallbackBlockName = createBlockNameSetterReducer('SET_UNREGISTERED_FALLBACK_BLOCK_NAME');
5733  const groupingBlockName = createBlockNameSetterReducer('SET_GROUPING_BLOCK_NAME');
5734  /**
5735   * Reducer managing the categories
5736   *
5737   * @param {WPBlockCategory[]} state  Current state.
5738   * @param {Object}            action Dispatched action.
5739   *
5740   * @return {WPBlockCategory[]} Updated state.
5741   */
5742  
5743  function categories() {
5744    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_CATEGORIES;
5745    let action = arguments.length > 1 ? arguments[1] : undefined;
5746  
5747    switch (action.type) {
5748      case 'SET_CATEGORIES':
5749        return action.categories || [];
5750  
5751      case 'UPDATE_CATEGORY':
5752        {
5753          if (!action.category || (0,external_lodash_namespaceObject.isEmpty)(action.category)) {
5754            return state;
5755          }
5756  
5757          const categoryToChange = (0,external_lodash_namespaceObject.find)(state, ['slug', action.slug]);
5758  
5759          if (categoryToChange) {
5760            return (0,external_lodash_namespaceObject.map)(state, category => {
5761              if (category.slug === action.slug) {
5762                return { ...category,
5763                  ...action.category
5764                };
5765              }
5766  
5767              return category;
5768            });
5769          }
5770        }
5771    }
5772  
5773    return state;
5774  }
5775  function collections() {
5776    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
5777    let action = arguments.length > 1 ? arguments[1] : undefined;
5778  
5779    switch (action.type) {
5780      case 'ADD_BLOCK_COLLECTION':
5781        return { ...state,
5782          [action.namespace]: {
5783            title: action.title,
5784            icon: action.icon
5785          }
5786        };
5787  
5788      case 'REMOVE_BLOCK_COLLECTION':
5789        return (0,external_lodash_namespaceObject.omit)(state, action.namespace);
5790    }
5791  
5792    return state;
5793  }
5794  /* harmony default export */ var reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
5795    unprocessedBlockTypes,
5796    blockTypes,
5797    blockStyles,
5798    blockVariations,
5799    defaultBlockName,
5800    freeformFallbackBlockName,
5801    unregisteredFallbackBlockName,
5802    groupingBlockName,
5803    categories,
5804    collections
5805  }));
5806  
5807  ;// CONCATENATED MODULE: ./node_modules/rememo/es/rememo.js
5808  
5809  
5810  var LEAF_KEY, hasWeakMap;
5811  
5812  /**
5813   * Arbitrary value used as key for referencing cache object in WeakMap tree.
5814   *
5815   * @type {Object}
5816   */
5817  LEAF_KEY = {};
5818  
5819  /**
5820   * Whether environment supports WeakMap.
5821   *
5822   * @type {boolean}
5823   */
5824  hasWeakMap = typeof WeakMap !== 'undefined';
5825  
5826  /**
5827   * Returns the first argument as the sole entry in an array.
5828   *
5829   * @param {*} value Value to return.
5830   *
5831   * @return {Array} Value returned as entry in array.
5832   */
5833  function arrayOf( value ) {
5834      return [ value ];
5835  }
5836  
5837  /**
5838   * Returns true if the value passed is object-like, or false otherwise. A value
5839   * is object-like if it can support property assignment, e.g. object or array.
5840   *
5841   * @param {*} value Value to test.
5842   *
5843   * @return {boolean} Whether value is object-like.
5844   */
5845  function isObjectLike( value ) {
5846      return !! value && 'object' === typeof value;
5847  }
5848  
5849  /**
5850   * Creates and returns a new cache object.
5851   *
5852   * @return {Object} Cache object.
5853   */
5854  function createCache() {
5855      var cache = {
5856          clear: function() {
5857              cache.head = null;
5858          },
5859      };
5860  
5861      return cache;
5862  }
5863  
5864  /**
5865   * Returns true if entries within the two arrays are strictly equal by
5866   * reference from a starting index.
5867   *
5868   * @param {Array}  a         First array.
5869   * @param {Array}  b         Second array.
5870   * @param {number} fromIndex Index from which to start comparison.
5871   *
5872   * @return {boolean} Whether arrays are shallowly equal.
5873   */
5874  function isShallowEqual( a, b, fromIndex ) {
5875      var i;
5876  
5877      if ( a.length !== b.length ) {
5878          return false;
5879      }
5880  
5881      for ( i = fromIndex; i < a.length; i++ ) {
5882          if ( a[ i ] !== b[ i ] ) {
5883              return false;
5884          }
5885      }
5886  
5887      return true;
5888  }
5889  
5890  /**
5891   * Returns a memoized selector function. The getDependants function argument is
5892   * called before the memoized selector and is expected to return an immutable
5893   * reference or array of references on which the selector depends for computing
5894   * its own return value. The memoize cache is preserved only as long as those
5895   * dependant references remain the same. If getDependants returns a different
5896   * reference(s), the cache is cleared and the selector value regenerated.
5897   *
5898   * @param {Function} selector      Selector function.
5899   * @param {Function} getDependants Dependant getter returning an immutable
5900   *                                 reference or array of reference used in
5901   *                                 cache bust consideration.
5902   *
5903   * @return {Function} Memoized selector.
5904   */
5905  /* harmony default export */ function rememo(selector, getDependants ) {
5906      var rootCache, getCache;
5907  
5908      // Use object source as dependant if getter not provided
5909      if ( ! getDependants ) {
5910          getDependants = arrayOf;
5911      }
5912  
5913      /**
5914       * Returns the root cache. If WeakMap is supported, this is assigned to the
5915       * root WeakMap cache set, otherwise it is a shared instance of the default
5916       * cache object.
5917       *
5918       * @return {(WeakMap|Object)} Root cache object.
5919       */
5920  	function getRootCache() {
5921          return rootCache;
5922      }
5923  
5924      /**
5925       * Returns the cache for a given dependants array. When possible, a WeakMap
5926       * will be used to create a unique cache for each set of dependants. This
5927       * is feasible due to the nature of WeakMap in allowing garbage collection
5928       * to occur on entries where the key object is no longer referenced. Since
5929       * WeakMap requires the key to be an object, this is only possible when the
5930       * dependant is object-like. The root cache is created as a hierarchy where
5931       * each top-level key is the first entry in a dependants set, the value a
5932       * WeakMap where each key is the next dependant, and so on. This continues
5933       * so long as the dependants are object-like. If no dependants are object-
5934       * like, then the cache is shared across all invocations.
5935       *
5936       * @see isObjectLike
5937       *
5938       * @param {Array} dependants Selector dependants.
5939       *
5940       * @return {Object} Cache object.
5941       */
5942  	function getWeakMapCache( dependants ) {
5943          var caches = rootCache,
5944              isUniqueByDependants = true,
5945              i, dependant, map, cache;
5946  
5947          for ( i = 0; i < dependants.length; i++ ) {
5948              dependant = dependants[ i ];
5949  
5950              // Can only compose WeakMap from object-like key.
5951              if ( ! isObjectLike( dependant ) ) {
5952                  isUniqueByDependants = false;
5953                  break;
5954              }
5955  
5956              // Does current segment of cache already have a WeakMap?
5957              if ( caches.has( dependant ) ) {
5958                  // Traverse into nested WeakMap.
5959                  caches = caches.get( dependant );
5960              } else {
5961                  // Create, set, and traverse into a new one.
5962                  map = new WeakMap();
5963                  caches.set( dependant, map );
5964                  caches = map;
5965              }
5966          }
5967  
5968          // We use an arbitrary (but consistent) object as key for the last item
5969          // in the WeakMap to serve as our running cache.
5970          if ( ! caches.has( LEAF_KEY ) ) {
5971              cache = createCache();
5972              cache.isUniqueByDependants = isUniqueByDependants;
5973              caches.set( LEAF_KEY, cache );
5974          }
5975  
5976          return caches.get( LEAF_KEY );
5977      }
5978  
5979      // Assign cache handler by availability of WeakMap
5980      getCache = hasWeakMap ? getWeakMapCache : getRootCache;
5981  
5982      /**
5983       * Resets root memoization cache.
5984       */
5985  	function clear() {
5986          rootCache = hasWeakMap ? new WeakMap() : createCache();
5987      }
5988  
5989      // eslint-disable-next-line jsdoc/check-param-names
5990      /**
5991       * The augmented selector call, considering first whether dependants have
5992       * changed before passing it to underlying memoize function.
5993       *
5994       * @param {Object} source    Source object for derivation.
5995       * @param {...*}   extraArgs Additional arguments to pass to selector.
5996       *
5997       * @return {*} Selector result.
5998       */
5999  	function callSelector( /* source, ...extraArgs */ ) {
6000          var len = arguments.length,
6001              cache, node, i, args, dependants;
6002  
6003          // Create copy of arguments (avoid leaking deoptimization).
6004          args = new Array( len );
6005          for ( i = 0; i < len; i++ ) {
6006              args[ i ] = arguments[ i ];
6007          }
6008  
6009          dependants = getDependants.apply( null, args );
6010          cache = getCache( dependants );
6011  
6012          // If not guaranteed uniqueness by dependants (primitive type or lack
6013          // of WeakMap support), shallow compare against last dependants and, if
6014          // references have changed, destroy cache to recalculate result.
6015          if ( ! cache.isUniqueByDependants ) {
6016              if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) {
6017                  cache.clear();
6018              }
6019  
6020              cache.lastDependants = dependants;
6021          }
6022  
6023          node = cache.head;
6024          while ( node ) {
6025              // Check whether node arguments match arguments
6026              if ( ! isShallowEqual( node.args, args, 1 ) ) {
6027                  node = node.next;
6028                  continue;
6029              }
6030  
6031              // At this point we can assume we've found a match
6032  
6033              // Surface matched node to head if not already
6034              if ( node !== cache.head ) {
6035                  // Adjust siblings to point to each other.
6036                  node.prev.next = node.next;
6037                  if ( node.next ) {
6038                      node.next.prev = node.prev;
6039                  }
6040  
6041                  node.next = cache.head;
6042                  node.prev = null;
6043                  cache.head.prev = node;
6044                  cache.head = node;
6045              }
6046  
6047              // Return immediately
6048              return node.val;
6049          }
6050  
6051          // No cached value found. Continue to insertion phase:
6052  
6053          node = {
6054              // Generate the result from original function
6055              val: selector.apply( null, args ),
6056          };
6057  
6058          // Avoid including the source object in the cache.
6059          args[ 0 ] = null;
6060          node.args = args;
6061  
6062          // Don't need to check whether node is already head, since it would
6063          // have been returned above already if it was
6064  
6065          // Shift existing head down list
6066          if ( cache.head ) {
6067              cache.head.prev = node;
6068              node.next = cache.head;
6069          }
6070  
6071          cache.head = node;
6072  
6073          return node.val;
6074      }
6075  
6076      callSelector.getDependants = getDependants;
6077      callSelector.clear = clear;
6078      clear();
6079  
6080      return callSelector;
6081  }
6082  
6083  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/selectors.js
6084  /**
6085   * External dependencies
6086   */
6087  
6088  
6089  /** @typedef {import('../api/registration').WPBlockVariation} WPBlockVariation */
6090  
6091  /** @typedef {import('../api/registration').WPBlockVariationScope} WPBlockVariationScope */
6092  
6093  /** @typedef {import('./reducer').WPBlockCategory} WPBlockCategory */
6094  
6095  /**
6096   * Given a block name or block type object, returns the corresponding
6097   * normalized block type object.
6098   *
6099   * @param {Object}          state      Blocks state.
6100   * @param {(string|Object)} nameOrType Block name or type object
6101   *
6102   * @return {Object} Block type object.
6103   */
6104  
6105  const getNormalizedBlockType = (state, nameOrType) => 'string' === typeof nameOrType ? getBlockType(state, nameOrType) : nameOrType;
6106  /**
6107   * Returns all the unprocessed block types as passed during the registration.
6108   *
6109   * @param {Object} state Data state.
6110   *
6111   * @return {Array} Unprocessed block types.
6112   */
6113  
6114  
6115  function __experimentalGetUnprocessedBlockTypes(state) {
6116    return state.unprocessedBlockTypes;
6117  }
6118  /**
6119   * Returns all the available block types.
6120   *
6121   * @param {Object} state Data state.
6122   *
6123   * @return {Array} Block Types.
6124   */
6125  
6126  const getBlockTypes = rememo(state => Object.values(state.blockTypes), state => [state.blockTypes]);
6127  /**
6128   * Returns a block type by name.
6129   *
6130   * @param {Object} state Data state.
6131   * @param {string} name  Block type name.
6132   *
6133   * @return {Object?} Block Type.
6134   */
6135  
6136  function getBlockType(state, name) {
6137    return state.blockTypes[name];
6138  }
6139  /**
6140   * Returns block styles by block name.
6141   *
6142   * @param {Object} state Data state.
6143   * @param {string} name  Block type name.
6144   *
6145   * @return {Array?} Block Styles.
6146   */
6147  
6148  function getBlockStyles(state, name) {
6149    return state.blockStyles[name];
6150  }
6151  /**
6152   * Returns block variations by block name.
6153   *
6154   * @param {Object}                state     Data state.
6155   * @param {string}                blockName Block type name.
6156   * @param {WPBlockVariationScope} [scope]   Block variation scope name.
6157   *
6158   * @return {(WPBlockVariation[]|void)} Block variations.
6159   */
6160  
6161  const getBlockVariations = rememo((state, blockName, scope) => {
6162    const variations = state.blockVariations[blockName];
6163  
6164    if (!variations || !scope) {
6165      return variations;
6166    }
6167  
6168    return variations.filter(variation => {
6169      // For backward compatibility reasons, variation's scope defaults to
6170      // `block` and `inserter` when not set.
6171      return (variation.scope || ['block', 'inserter']).includes(scope);
6172    });
6173  }, (state, blockName) => [state.blockVariations[blockName]]);
6174  /**
6175   * Returns the active block variation for a given block based on its attributes.
6176   * Variations are determined by their `isActive` property.
6177   * Which is either an array of block attribute keys or a function.
6178   *
6179   * In case of an array of block attribute keys, the `attributes` are compared
6180   * to the variation's attributes using strict equality check.
6181   *
6182   * In case of function type, the function should accept a block's attributes
6183   * and the variation's attributes and determines if a variation is active.
6184   * A function that accepts a block's attributes and the variation's attributes and determines if a variation is active.
6185   *
6186   * @param {Object}                state      Data state.
6187   * @param {string}                blockName  Name of block (example: “core/columns”).
6188   * @param {Object}                attributes Block attributes used to determine active variation.
6189   * @param {WPBlockVariationScope} [scope]    Block variation scope name.
6190   *
6191   * @return {(WPBlockVariation|undefined)} Active block variation.
6192   */
6193  
6194  function getActiveBlockVariation(state, blockName, attributes, scope) {
6195    const variations = getBlockVariations(state, blockName, scope);
6196    const match = variations === null || variations === void 0 ? void 0 : variations.find(variation => {
6197      var _variation$isActive;
6198  
6199      if (Array.isArray(variation.isActive)) {
6200        const blockType = getBlockType(state, blockName);
6201        const attributeKeys = Object.keys((blockType === null || blockType === void 0 ? void 0 : blockType.attributes) || {});
6202        const definedAttributes = variation.isActive.filter(attribute => attributeKeys.includes(attribute));
6203  
6204        if (definedAttributes.length === 0) {
6205          return false;
6206        }
6207  
6208        return definedAttributes.every(attribute => attributes[attribute] === variation.attributes[attribute]);
6209      }
6210  
6211      return (_variation$isActive = variation.isActive) === null || _variation$isActive === void 0 ? void 0 : _variation$isActive.call(variation, attributes, variation.attributes);
6212    });
6213    return match;
6214  }
6215  /**
6216   * Returns the default block variation for the given block type.
6217   * When there are multiple variations annotated as the default one,
6218   * the last added item is picked. This simplifies registering overrides.
6219   * When there is no default variation set, it returns the first item.
6220   *
6221   * @param {Object}                state     Data state.
6222   * @param {string}                blockName Block type name.
6223   * @param {WPBlockVariationScope} [scope]   Block variation scope name.
6224   *
6225   * @return {?WPBlockVariation} The default block variation.
6226   */
6227  
6228  function getDefaultBlockVariation(state, blockName, scope) {
6229    const variations = getBlockVariations(state, blockName, scope);
6230    return (0,external_lodash_namespaceObject.findLast)(variations, 'isDefault') || (0,external_lodash_namespaceObject.first)(variations);
6231  }
6232  /**
6233   * Returns all the available categories.
6234   *
6235   * @param {Object} state Data state.
6236   *
6237   * @return {WPBlockCategory[]} Categories list.
6238   */
6239  
6240  function getCategories(state) {
6241    return state.categories;
6242  }
6243  /**
6244   * Returns all the available collections.
6245   *
6246   * @param {Object} state Data state.
6247   *
6248   * @return {Object} Collections list.
6249   */
6250  
6251  function getCollections(state) {
6252    return state.collections;
6253  }
6254  /**
6255   * Returns the name of the default block name.
6256   *
6257   * @param {Object} state Data state.
6258   *
6259   * @return {string?} Default block name.
6260   */
6261  
6262  function getDefaultBlockName(state) {
6263    return state.defaultBlockName;
6264  }
6265  /**
6266   * Returns the name of the block for handling non-block content.
6267   *
6268   * @param {Object} state Data state.
6269   *
6270   * @return {string?} Name of the block for handling non-block content.
6271   */
6272  
6273  function getFreeformFallbackBlockName(state) {
6274    return state.freeformFallbackBlockName;
6275  }
6276  /**
6277   * Returns the name of the block for handling unregistered blocks.
6278   *
6279   * @param {Object} state Data state.
6280   *
6281   * @return {string?} Name of the block for handling unregistered blocks.
6282   */
6283  
6284  function getUnregisteredFallbackBlockName(state) {
6285    return state.unregisteredFallbackBlockName;
6286  }
6287  /**
6288   * Returns the name of the block for handling unregistered blocks.
6289   *
6290   * @param {Object} state Data state.
6291   *
6292   * @return {string?} Name of the block for handling unregistered blocks.
6293   */
6294  
6295  function getGroupingBlockName(state) {
6296    return state.groupingBlockName;
6297  }
6298  /**
6299   * Returns an array with the child blocks of a given block.
6300   *
6301   * @param {Object} state     Data state.
6302   * @param {string} blockName Block type name.
6303   *
6304   * @return {Array} Array of child block names.
6305   */
6306  
6307  const getChildBlockNames = rememo((state, blockName) => {
6308    return (0,external_lodash_namespaceObject.map)((0,external_lodash_namespaceObject.filter)(state.blockTypes, blockType => {
6309      return (0,external_lodash_namespaceObject.includes)(blockType.parent, blockName);
6310    }), _ref => {
6311      let {
6312        name
6313      } = _ref;
6314      return name;
6315    });
6316  }, state => [state.blockTypes]);
6317  /**
6318   * Returns the block support value for a feature, if defined.
6319   *
6320   * @param {Object}          state           Data state.
6321   * @param {(string|Object)} nameOrType      Block name or type object
6322   * @param {Array|string}    feature         Feature to retrieve
6323   * @param {*}               defaultSupports Default value to return if not
6324   *                                          explicitly defined
6325   *
6326   * @return {?*} Block support value
6327   */
6328  
6329  const getBlockSupport = (state, nameOrType, feature, defaultSupports) => {
6330    const blockType = getNormalizedBlockType(state, nameOrType);
6331  
6332    if (!(blockType !== null && blockType !== void 0 && blockType.supports)) {
6333      return defaultSupports;
6334    }
6335  
6336    return (0,external_lodash_namespaceObject.get)(blockType.supports, feature, defaultSupports);
6337  };
6338  /**
6339   * Returns true if the block defines support for a feature, or false otherwise.
6340   *
6341   * @param {Object}          state           Data state.
6342   * @param {(string|Object)} nameOrType      Block name or type object.
6343   * @param {string}          feature         Feature to test.
6344   * @param {boolean}         defaultSupports Whether feature is supported by
6345   *                                          default if not explicitly defined.
6346   *
6347   * @return {boolean} Whether block supports feature.
6348   */
6349  
6350  function hasBlockSupport(state, nameOrType, feature, defaultSupports) {
6351    return !!getBlockSupport(state, nameOrType, feature, defaultSupports);
6352  }
6353  /**
6354   * Returns true if the block type by the given name or object value matches a
6355   * search term, or false otherwise.
6356   *
6357   * @param {Object}          state      Blocks state.
6358   * @param {(string|Object)} nameOrType Block name or type object.
6359   * @param {string}          searchTerm Search term by which to filter.
6360   *
6361   * @return {Object[]} Whether block type matches search term.
6362   */
6363  
6364  function isMatchingSearchTerm(state, nameOrType, searchTerm) {
6365    const blockType = getNormalizedBlockType(state, nameOrType);
6366    const getNormalizedSearchTerm = (0,external_lodash_namespaceObject.flow)([// Disregard diacritics.
6367    //  Input: "média"
6368    external_lodash_namespaceObject.deburr, // Lowercase.
6369    //  Input: "MEDIA"
6370    term => term.toLowerCase(), // Strip leading and trailing whitespace.
6371    //  Input: " media "
6372    term => term.trim()]);
6373    const normalizedSearchTerm = getNormalizedSearchTerm(searchTerm);
6374    const isSearchMatch = (0,external_lodash_namespaceObject.flow)([getNormalizedSearchTerm, normalizedCandidate => (0,external_lodash_namespaceObject.includes)(normalizedCandidate, normalizedSearchTerm)]);
6375    return isSearchMatch(blockType.title) || (0,external_lodash_namespaceObject.some)(blockType.keywords, isSearchMatch) || isSearchMatch(blockType.category) || isSearchMatch(blockType.description);
6376  }
6377  /**
6378   * Returns a boolean indicating if a block has child blocks or not.
6379   *
6380   * @param {Object} state     Data state.
6381   * @param {string} blockName Block type name.
6382   *
6383   * @return {boolean} True if a block contains child blocks and false otherwise.
6384   */
6385  
6386  const hasChildBlocks = (state, blockName) => {
6387    return getChildBlockNames(state, blockName).length > 0;
6388  };
6389  /**
6390   * Returns a boolean indicating if a block has at least one child block with inserter support.
6391   *
6392   * @param {Object} state     Data state.
6393   * @param {string} blockName Block type name.
6394   *
6395   * @return {boolean} True if a block contains at least one child blocks with inserter support
6396   *                   and false otherwise.
6397   */
6398  
6399  const hasChildBlocksWithInserterSupport = (state, blockName) => {
6400    return (0,external_lodash_namespaceObject.some)(getChildBlockNames(state, blockName), childBlockName => {
6401      return hasBlockSupport(state, childBlockName, 'inserter', true);
6402    });
6403  };
6404  
6405  ;// CONCATENATED MODULE: external ["wp","hooks"]
6406  var external_wp_hooks_namespaceObject = window["wp"]["hooks"];
6407  ;// CONCATENATED MODULE: ./node_modules/colord/index.mjs
6408  var r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return"string"==typeof r?r.length>0:"number"==typeof r},n=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=Math.pow(10,t)),Math.round(n*r)/n+0},e=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=1),r>n?n:r>t?r:t},u=function(r){return(r=isFinite(r)?r%360:0)>0?r:r+360},a=function(r){return{r:e(r.r,0,255),g:e(r.g,0,255),b:e(r.b,0,255),a:e(r.a)}},o=function(r){return{r:n(r.r),g:n(r.g),b:n(r.b),a:n(r.a,3)}},i=/^#([0-9a-f]{3,8})$/i,s=function(r){var t=r.toString(16);return t.length<2?"0"+t:t},h=function(r){var t=r.r,n=r.g,e=r.b,u=r.a,a=Math.max(t,n,e),o=a-Math.min(t,n,e),i=o?a===t?(n-e)/o:a===n?2+(e-t)/o:4+(t-n)/o:0;return{h:60*(i<0?i+6:i),s:a?o/a*100:0,v:a/255*100,a:u}},b=function(r){var t=r.h,n=r.s,e=r.v,u=r.a;t=t/360*6,n/=100,e/=100;var a=Math.floor(t),o=e*(1-n),i=e*(1-(t-a)*n),s=e*(1-(1-t+a)*n),h=a%6;return{r:255*[e,i,o,o,s,e][h],g:255*[s,e,e,i,o,o][h],b:255*[o,o,s,e,e,i][h],a:u}},g=function(r){return{h:u(r.h),s:e(r.s,0,100),l:e(r.l,0,100),a:e(r.a)}},d=function(r){return{h:n(r.h),s:n(r.s),l:n(r.l),a:n(r.a,3)}},f=function(r){return b((n=(t=r).s,{h:t.h,s:(n*=((e=t.l)<50?e:100-e)/100)>0?2*n/(e+n)*100:0,v:e+n,a:t.a}));var t,n,e},c=function(r){return{h:(t=h(r)).h,s:(u=(200-(n=t.s))*(e=t.v)/100)>0&&u<200?n*e/100/(u<=100?u:200-u)*100:0,l:u/2,a:t.a};var t,n,e,u},l=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,p=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,v=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,m=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,y={string:[[function(r){var t=i.exec(r);return t?(r=t[1]).length<=4?{r:parseInt(r[0]+r[0],16),g:parseInt(r[1]+r[1],16),b:parseInt(r[2]+r[2],16),a:4===r.length?n(parseInt(r[3]+r[3],16)/255,2):1}:6===r.length||8===r.length?{r:parseInt(r.substr(0,2),16),g:parseInt(r.substr(2,2),16),b:parseInt(r.substr(4,2),16),a:8===r.length?n(parseInt(r.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(r){var t=v.exec(r)||m.exec(r);return t?t[2]!==t[4]||t[4]!==t[6]?null:a({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:void 0===t[7]?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(t){var n=l.exec(t)||p.exec(t);if(!n)return null;var e,u,a=g({h:(e=n[1],u=n[2],void 0===u&&(u="deg"),Number(e)*(r[u]||1)),s:Number(n[3]),l:Number(n[4]),a:void 0===n[5]?1:Number(n[5])/(n[6]?100:1)});return f(a)},"hsl"]],object:[[function(r){var n=r.r,e=r.g,u=r.b,o=r.a,i=void 0===o?1:o;return t(n)&&t(e)&&t(u)?a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},"rgb"],[function(r){var n=r.h,e=r.s,u=r.l,a=r.a,o=void 0===a?1:a;if(!t(n)||!t(e)||!t(u))return null;var i=g({h:Number(n),s:Number(e),l:Number(u),a:Number(o)});return f(i)},"hsl"],[function(r){var n=r.h,a=r.s,o=r.v,i=r.a,s=void 0===i?1:i;if(!t(n)||!t(a)||!t(o))return null;var h=function(r){return{h:u(r.h),s:e(r.s,0,100),v:e(r.v,0,100),a:e(r.a)}}({h:Number(n),s:Number(a),v:Number(o),a:Number(s)});return b(h)},"hsv"]]},N=function(r,t){for(var n=0;n<t.length;n++){var e=t[n][0](r);if(e)return[e,t[n][1]]}return[null,void 0]},x=function(r){return"string"==typeof r?N(r.trim(),y.string):"object"==typeof r&&null!==r?N(r,y.object):[null,void 0]},I=function(r){return x(r)[1]},M=function(r,t){var n=c(r);return{h:n.h,s:e(n.s+100*t,0,100),l:n.l,a:n.a}},H=function(r){return(299*r.r+587*r.g+114*r.b)/1e3/255},$=function(r,t){var n=c(r);return{h:n.h,s:n.s,l:e(n.l+100*t,0,100),a:n.a}},j=function(){function r(r){this.parsed=x(r)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1}}return r.prototype.isValid=function(){return null!==this.parsed},r.prototype.brightness=function(){return n(H(this.rgba),2)},r.prototype.isDark=function(){return H(this.rgba)<.5},r.prototype.isLight=function(){return H(this.rgba)>=.5},r.prototype.toHex=function(){return r=o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)<1?s(n(255*a)):"","#"+s(t)+s(e)+s(u)+i;var r,t,e,u,a,i},r.prototype.toRgb=function(){return o(this.rgba)},r.prototype.toRgbString=function(){return r=o(this.rgba),t=r.r,n=r.g,e=r.b,(u=r.a)<1?"rgba("+t+", "+n+", "+e+", "+u+")":"rgb("+t+", "+n+", "+e+")";var r,t,n,e,u},r.prototype.toHsl=function(){return d(c(this.rgba))},r.prototype.toHslString=function(){return r=d(c(this.rgba)),t=r.h,n=r.s,e=r.l,(u=r.a)<1?"hsla("+t+", "+n+"%, "+e+"%, "+u+")":"hsl("+t+", "+n+"%, "+e+"%)";var r,t,n,e,u},r.prototype.toHsv=function(){return r=h(this.rgba),{h:n(r.h),s:n(r.s),v:n(r.v),a:n(r.a,3)};var r},r.prototype.invert=function(){return w({r:255-(r=this.rgba).r,g:255-r.g,b:255-r.b,a:r.a});var r},r.prototype.saturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,-r))},r.prototype.grayscale=function(){return w(M(this.rgba,-1))},r.prototype.lighten=function(r){return void 0===r&&(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&&(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&&(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return"number"==typeof r?w({r:(t=this.rgba).r,g:t.g,b:t.b,a:r}):n(this.rgba.a,3);var t},r.prototype.hue=function(r){var t=c(this.rgba);return"number"==typeof r?w({h:r,s:t.s,l:t.l,a:t.a}):n(t.h)},r.prototype.isEqual=function(r){return this.toHex()===w(r).toHex()},r}(),w=function(r){return r instanceof j?r:new j(r)},S=[],k=function(r){r.forEach(function(r){S.indexOf(r)<0&&(r(j,y),S.push(r))})},E=function(){return new j({r:255*Math.random(),g:255*Math.random(),b:255*Math.random()})};
6409  
6410  ;// CONCATENATED MODULE: ./node_modules/colord/plugins/names.mjs
6411  /* harmony default export */ function names(e,f){var a={white:"#ffffff",bisque:"#ffe4c4",blue:"#0000ff",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",antiquewhite:"#faebd7",aqua:"#00ffff",azure:"#f0ffff",whitesmoke:"#f5f5f5",papayawhip:"#ffefd5",plum:"#dda0dd",blanchedalmond:"#ffebcd",black:"#000000",gold:"#ffd700",goldenrod:"#daa520",gainsboro:"#dcdcdc",cornsilk:"#fff8dc",cornflowerblue:"#6495ed",burlywood:"#deb887",aquamarine:"#7fffd4",beige:"#f5f5dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkkhaki:"#bdb76b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",peachpuff:"#ffdab9",darkmagenta:"#8b008b",darkred:"#8b0000",darkorchid:"#9932cc",darkorange:"#ff8c00",darkslateblue:"#483d8b",gray:"#808080",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",deeppink:"#ff1493",deepskyblue:"#00bfff",wheat:"#f5deb3",firebrick:"#b22222",floralwhite:"#fffaf0",ghostwhite:"#f8f8ff",darkviolet:"#9400d3",magenta:"#ff00ff",green:"#008000",dodgerblue:"#1e90ff",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",blueviolet:"#8a2be2",forestgreen:"#228b22",lawngreen:"#7cfc00",indianred:"#cd5c5c",indigo:"#4b0082",fuchsia:"#ff00ff",brown:"#a52a2a",maroon:"#800000",mediumblue:"#0000cd",lightcoral:"#f08080",darkturquoise:"#00ced1",lightcyan:"#e0ffff",ivory:"#fffff0",lightyellow:"#ffffe0",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",linen:"#faf0e6",mediumaquamarine:"#66cdaa",lemonchiffon:"#fffacd",lime:"#00ff00",khaki:"#f0e68c",mediumseagreen:"#3cb371",limegreen:"#32cd32",mediumspringgreen:"#00fa9a",lightskyblue:"#87cefa",lightblue:"#add8e6",midnightblue:"#191970",lightpink:"#ffb6c1",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",mintcream:"#f5fffa",lightslategray:"#778899",lightslategrey:"#778899",navajowhite:"#ffdead",navy:"#000080",mediumvioletred:"#c71585",powderblue:"#b0e0e6",palegoldenrod:"#eee8aa",oldlace:"#fdf5e6",paleturquoise:"#afeeee",mediumturquoise:"#48d1cc",mediumorchid:"#ba55d3",rebeccapurple:"#663399",lightsteelblue:"#b0c4de",mediumslateblue:"#7b68ee",thistle:"#d8bfd8",tan:"#d2b48c",orchid:"#da70d6",mediumpurple:"#9370db",purple:"#800080",pink:"#ffc0cb",skyblue:"#87ceeb",springgreen:"#00ff7f",palegreen:"#98fb98",red:"#ff0000",yellow:"#ffff00",slateblue:"#6a5acd",lavenderblush:"#fff0f5",peru:"#cd853f",palevioletred:"#db7093",violet:"#ee82ee",teal:"#008080",slategray:"#708090",slategrey:"#708090",aliceblue:"#f0f8ff",darkseagreen:"#8fbc8f",darkolivegreen:"#556b2f",greenyellow:"#adff2f",seagreen:"#2e8b57",seashell:"#fff5ee",tomato:"#ff6347",silver:"#c0c0c0",sienna:"#a0522d",lavender:"#e6e6fa",lightgreen:"#90ee90",orange:"#ffa500",orangered:"#ff4500",steelblue:"#4682b4",royalblue:"#4169e1",turquoise:"#40e0d0",yellowgreen:"#9acd32",salmon:"#fa8072",saddlebrown:"#8b4513",sandybrown:"#f4a460",rosybrown:"#bc8f8f",darksalmon:"#e9967a",lightgoldenrodyellow:"#fafad2",snow:"#fffafa",lightgrey:"#d3d3d3",lightgray:"#d3d3d3",dimgray:"#696969",dimgrey:"#696969",olivedrab:"#6b8e23",olive:"#808000"},r={};for(var d in a)r[a[d]]=d;var l={};e.prototype.toName=function(f){if(!(this.rgba.a||this.rgba.r||this.rgba.g||this.rgba.b))return"transparent";var d,i,n=r[this.toHex()];if(n)return n;if(null==f?void 0:f.closest){var o=this.toRgb(),t=1/0,b="black";if(!l.length)for(var c in a)l[c]=new e(a[c]).toRgb();for(var g in a){var u=(d=o,i=l[g],Math.pow(d.r-i.r,2)+Math.pow(d.g-i.g,2)+Math.pow(d.b-i.b,2));u<t&&(t=u,b=g)}return b}};f.string.push([function(f){var r=f.toLowerCase(),d="transparent"===r?"#0000":a[r];return d?new e(d).toRgb():null},"name"])}
6412  
6413  ;// CONCATENATED MODULE: ./node_modules/colord/plugins/a11y.mjs
6414  var a11y_o=function(o){var t=o/255;return t<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)},a11y_t=function(t){return.2126*a11y_o(t.r)+.7152*a11y_o(t.g)+.0722*a11y_o(t.b)};/* harmony default export */ function a11y(o){o.prototype.luminance=function(){return o=a11y_t(this.rgba),void 0===(r=2)&&(r=0),void 0===n&&(n=Math.pow(10,r)),Math.round(n*o)/n+0;var o,r,n},o.prototype.contrast=function(r){void 0===r&&(r="#FFF");var n,a,i,e,v,u,d,c=r instanceof o?r:new o(r);return e=this.rgba,v=c.toRgb(),u=a11y_t(e),d=a11y_t(v),n=u>d?(u+.05)/(d+.05):(d+.05)/(u+.05),void 0===(a=2)&&(a=0),void 0===i&&(i=Math.pow(10,a)),Math.floor(i*n)/i+0},o.prototype.isReadable=function(o,t){return void 0===o&&(o="#FFF"),void 0===t&&(t={}),this.contrast(o)>=(e=void 0===(i=(r=t).size)?"normal":i,"AAA"===(a=void 0===(n=r.level)?"AA":n)&&"normal"===e?7:"AA"===a&&"large"===e?3:4.5);var r,n,a,i,e}}
6415  
6416  ;// CONCATENATED MODULE: external ["wp","element"]
6417  var external_wp_element_namespaceObject = window["wp"]["element"];
6418  ;// CONCATENATED MODULE: external ["wp","dom"]
6419  var external_wp_dom_namespaceObject = window["wp"]["dom"];
6420  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/constants.js
6421  const BLOCK_ICON_DEFAULT = 'block-default';
6422  /**
6423   * Array of valid keys in a block type settings deprecation object.
6424   *
6425   * @type {string[]}
6426   */
6427  
6428  const DEPRECATED_ENTRY_KEYS = ['attributes', 'supports', 'save', 'migrate', 'isEligible', 'apiVersion'];
6429  const __EXPERIMENTAL_STYLE_PROPERTY = {
6430    // Kept for back-compatibility purposes.
6431    '--wp--style--color--link': {
6432      value: ['color', 'link'],
6433      support: ['color', 'link']
6434    },
6435    background: {
6436      value: ['color', 'gradient'],
6437      support: ['color', 'gradients']
6438    },
6439    backgroundColor: {
6440      value: ['color', 'background'],
6441      support: ['color', 'background'],
6442      requiresOptOut: true
6443    },
6444    borderColor: {
6445      value: ['border', 'color'],
6446      support: ['__experimentalBorder', 'color']
6447    },
6448    borderRadius: {
6449      value: ['border', 'radius'],
6450      support: ['__experimentalBorder', 'radius'],
6451      properties: {
6452        borderTopLeftRadius: 'topLeft',
6453        borderTopRightRadius: 'topRight',
6454        borderBottomLeftRadius: 'bottomLeft',
6455        borderBottomRightRadius: 'bottomRight'
6456      }
6457    },
6458    borderStyle: {
6459      value: ['border', 'style'],
6460      support: ['__experimentalBorder', 'style']
6461    },
6462    borderWidth: {
6463      value: ['border', 'width'],
6464      support: ['__experimentalBorder', 'width']
6465    },
6466    color: {
6467      value: ['color', 'text'],
6468      support: ['color', 'text'],
6469      requiresOptOut: true
6470    },
6471    filter: {
6472      value: ['filter', 'duotone'],
6473      support: ['color', '__experimentalDuotone']
6474    },
6475    linkColor: {
6476      value: ['elements', 'link', 'color', 'text'],
6477      support: ['color', 'link']
6478    },
6479    fontFamily: {
6480      value: ['typography', 'fontFamily'],
6481      support: ['typography', '__experimentalFontFamily']
6482    },
6483    fontSize: {
6484      value: ['typography', 'fontSize'],
6485      support: ['typography', 'fontSize']
6486    },
6487    fontStyle: {
6488      value: ['typography', 'fontStyle'],
6489      support: ['typography', '__experimentalFontStyle']
6490    },
6491    fontWeight: {
6492      value: ['typography', 'fontWeight'],
6493      support: ['typography', '__experimentalFontWeight']
6494    },
6495    lineHeight: {
6496      value: ['typography', 'lineHeight'],
6497      support: ['typography', 'lineHeight']
6498    },
6499    margin: {
6500      value: ['spacing', 'margin'],
6501      support: ['spacing', 'margin'],
6502      properties: {
6503        marginTop: 'top',
6504        marginRight: 'right',
6505        marginBottom: 'bottom',
6506        marginLeft: 'left'
6507      },
6508      useEngine: true
6509    },
6510    padding: {
6511      value: ['spacing', 'padding'],
6512      support: ['spacing', 'padding'],
6513      properties: {
6514        paddingTop: 'top',
6515        paddingRight: 'right',
6516        paddingBottom: 'bottom',
6517        paddingLeft: 'left'
6518      },
6519      useEngine: true
6520    },
6521    textDecoration: {
6522      value: ['typography', 'textDecoration'],
6523      support: ['typography', '__experimentalTextDecoration']
6524    },
6525    textTransform: {
6526      value: ['typography', 'textTransform'],
6527      support: ['typography', '__experimentalTextTransform']
6528    },
6529    letterSpacing: {
6530      value: ['typography', 'letterSpacing'],
6531      support: ['typography', '__experimentalLetterSpacing']
6532    },
6533    '--wp--style--block-gap': {
6534      value: ['spacing', 'blockGap'],
6535      support: ['spacing', 'blockGap']
6536    }
6537  };
6538  const __EXPERIMENTAL_ELEMENTS = {
6539    link: 'a',
6540    h1: 'h1',
6541    h2: 'h2',
6542    h3: 'h3',
6543    h4: 'h4',
6544    h5: 'h5',
6545    h6: 'h6'
6546  };
6547  const __EXPERIMENTAL_PATHS_WITH_MERGE = {
6548    'color.duotone': true,
6549    'color.gradients': true,
6550    'color.palette': true,
6551    'typography.fontFamilies': true,
6552    'typography.fontSizes': true
6553  };
6554  
6555  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/registration.js
6556  /* eslint no-console: [ 'error', { allow: [ 'error', 'warn' ] } ] */
6557  
6558  /**
6559   * External dependencies
6560   */
6561  
6562  /**
6563   * WordPress dependencies
6564   */
6565  
6566  
6567  
6568  /**
6569   * Internal dependencies
6570   */
6571  
6572  const i18nBlockSchema = {
6573    title: "block title",
6574    description: "block description",
6575    keywords: ["block keyword"],
6576    styles: [{
6577      label: "block style label"
6578    }],
6579    variations: [{
6580      title: "block variation title",
6581      description: "block variation description",
6582      keywords: ["block variation keyword"]
6583    }]
6584  };
6585  
6586  
6587  /**
6588   * An icon type definition. One of a Dashicon slug, an element,
6589   * or a component.
6590   *
6591   * @typedef {(string|WPElement|WPComponent)} WPIcon
6592   *
6593   * @see https://developer.wordpress.org/resource/dashicons/
6594   */
6595  
6596  /**
6597   * Render behavior of a block type icon; one of a Dashicon slug, an element,
6598   * or a component.
6599   *
6600   * @typedef {WPIcon} WPBlockTypeIconRender
6601   */
6602  
6603  /**
6604   * An object describing a normalized block type icon.
6605   *
6606   * @typedef {Object} WPBlockTypeIconDescriptor
6607   *
6608   * @property {WPBlockTypeIconRender} src         Render behavior of the icon,
6609   *                                               one of a Dashicon slug, an
6610   *                                               element, or a component.
6611   * @property {string}                background  Optimal background hex string
6612   *                                               color when displaying icon.
6613   * @property {string}                foreground  Optimal foreground hex string
6614   *                                               color when displaying icon.
6615   * @property {string}                shadowColor Optimal shadow hex string
6616   *                                               color when displaying icon.
6617   */
6618  
6619  /**
6620   * Value to use to render the icon for a block type in an editor interface,
6621   * either a Dashicon slug, an element, a component, or an object describing
6622   * the icon.
6623   *
6624   * @typedef {(WPBlockTypeIconDescriptor|WPBlockTypeIconRender)} WPBlockTypeIcon
6625   */
6626  
6627  /**
6628   * Named block variation scopes.
6629   *
6630   * @typedef {'block'|'inserter'|'transform'} WPBlockVariationScope
6631   */
6632  
6633  /**
6634   * An object describing a variation defined for the block type.
6635   *
6636   * @typedef {Object} WPBlockVariation
6637   *
6638   * @property {string}                  name          The unique and machine-readable name.
6639   * @property {string}                  title         A human-readable variation title.
6640   * @property {string}                  [description] A detailed variation description.
6641   * @property {string}                  [category]    Block type category classification,
6642   *                                                   used in search interfaces to arrange
6643   *                                                   block types by category.
6644   * @property {WPIcon}                  [icon]        An icon helping to visualize the variation.
6645   * @property {boolean}                 [isDefault]   Indicates whether the current variation is
6646   *                                                   the default one. Defaults to `false`.
6647   * @property {Object}                  [attributes]  Values which override block attributes.
6648   * @property {Array[]}                 [innerBlocks] Initial configuration of nested blocks.
6649   * @property {Object}                  [example]     Example provides structured data for
6650   *                                                   the block preview. You can set to
6651   *                                                   `undefined` to disable the preview shown
6652   *                                                   for the block type.
6653   * @property {WPBlockVariationScope[]} [scope]       The list of scopes where the variation
6654   *                                                   is applicable. When not provided, it
6655   *                                                   assumes all available scopes.
6656   * @property {string[]}                [keywords]    An array of terms (which can be translated)
6657   *                                                   that help users discover the variation
6658   *                                                   while searching.
6659   * @property {Function|string[]}       [isActive]    This can be a function or an array of block attributes.
6660   *                                                   Function that accepts a block's attributes and the
6661   *                                                   variation's attributes and determines if a variation is active.
6662   *                                                   This function doesn't try to find a match dynamically based
6663   *                                                   on all block's attributes, as in many cases some attributes are irrelevant.
6664   *                                                   An example would be for `embed` block where we only care
6665   *                                                   about `providerNameSlug` attribute's value.
6666   *                                                   We can also use a `string[]` to tell which attributes
6667   *                                                   should be compared as a shorthand. Each attributes will
6668   *                                                   be matched and the variation will be active if all of them are matching.
6669   */
6670  
6671  /**
6672   * Defined behavior of a block type.
6673   *
6674   * @typedef {Object} WPBlockType
6675   *
6676   * @property {string}             name          Block type's namespaced name.
6677   * @property {string}             title         Human-readable block type label.
6678   * @property {string}             [description] A detailed block type description.
6679   * @property {string}             [category]    Block type category classification,
6680   *                                              used in search interfaces to arrange
6681   *                                              block types by category.
6682   * @property {WPBlockTypeIcon}    [icon]        Block type icon.
6683   * @property {string[]}           [keywords]    Additional keywords to produce block
6684   *                                              type as result in search interfaces.
6685   * @property {Object}             [attributes]  Block type attributes.
6686   * @property {WPComponent}        [save]        Optional component describing
6687   *                                              serialized markup structure of a
6688   *                                              block type.
6689   * @property {WPComponent}        edit          Component rendering an element to
6690   *                                              manipulate the attributes of a block
6691   *                                              in the context of an editor.
6692   * @property {WPBlockVariation[]} [variations]  The list of block variations.
6693   * @property {Object}             [example]     Example provides structured data for
6694   *                                              the block preview. When not defined
6695   *                                              then no preview is shown.
6696   */
6697  
6698  const serverSideBlockDefinitions = {};
6699  /**
6700   * Sets the server side block definition of blocks.
6701   *
6702   * @param {Object} definitions Server-side block definitions
6703   */
6704  // eslint-disable-next-line camelcase
6705  
6706  function unstable__bootstrapServerSideBlockDefinitions(definitions) {
6707    for (const blockName of Object.keys(definitions)) {
6708      // Don't overwrite if already set. It covers the case when metadata
6709      // was initialized from the server.
6710      if (serverSideBlockDefinitions[blockName]) {
6711        // We still need to polyfill `apiVersion` for WordPress version
6712        // lower than 5.7. If it isn't present in the definition shared
6713        // from the server, we try to fallback to the definition passed.
6714        // @see https://github.com/WordPress/gutenberg/pull/29279
6715        if (serverSideBlockDefinitions[blockName].apiVersion === undefined && definitions[blockName].apiVersion) {
6716          serverSideBlockDefinitions[blockName].apiVersion = definitions[blockName].apiVersion;
6717        } // The `ancestor` prop is not included in the definitions shared
6718        // from the server yet, so it needs to be polyfilled as well.
6719        // @see https://github.com/WordPress/gutenberg/pull/39894
6720  
6721  
6722        if (serverSideBlockDefinitions[blockName].ancestor === undefined && definitions[blockName].ancestor) {
6723          serverSideBlockDefinitions[blockName].ancestor = definitions[blockName].ancestor;
6724        }
6725  
6726        continue;
6727      }
6728  
6729      serverSideBlockDefinitions[blockName] = (0,external_lodash_namespaceObject.mapKeys)((0,external_lodash_namespaceObject.pickBy)(definitions[blockName], value => !(0,external_lodash_namespaceObject.isNil)(value)), (value, key) => (0,external_lodash_namespaceObject.camelCase)(key));
6730    }
6731  }
6732  /**
6733   * Gets block settings from metadata loaded from `block.json` file.
6734   *
6735   * @param {Object} metadata            Block metadata loaded from `block.json`.
6736   * @param {string} metadata.textdomain Textdomain to use with translations.
6737   *
6738   * @return {Object} Block settings.
6739   */
6740  
6741  function getBlockSettingsFromMetadata(_ref) {
6742    let {
6743      textdomain,
6744      ...metadata
6745    } = _ref;
6746    const allowedFields = ['apiVersion', 'title', 'category', 'parent', 'ancestor', 'icon', 'description', 'keywords', 'attributes', 'providesContext', 'usesContext', 'supports', 'styles', 'example', 'variations'];
6747    const settings = (0,external_lodash_namespaceObject.pick)(metadata, allowedFields);
6748  
6749    if (textdomain) {
6750      Object.keys(i18nBlockSchema).forEach(key => {
6751        if (!settings[key]) {
6752          return;
6753        }
6754  
6755        settings[key] = translateBlockSettingUsingI18nSchema(i18nBlockSchema[key], settings[key], textdomain);
6756      });
6757    }
6758  
6759    return settings;
6760  }
6761  /**
6762   * Registers a new block provided a unique name and an object defining its
6763   * behavior. Once registered, the block is made available as an option to any
6764   * editor interface where blocks are implemented.
6765   *
6766   * @param {string|Object} blockNameOrMetadata Block type name or its metadata.
6767   * @param {Object}        settings            Block settings.
6768   *
6769   * @return {?WPBlockType} The block, if it has been successfully registered;
6770   *                    otherwise `undefined`.
6771   */
6772  
6773  
6774  function registerBlockType(blockNameOrMetadata, settings) {
6775    const name = (0,external_lodash_namespaceObject.isObject)(blockNameOrMetadata) ? blockNameOrMetadata.name : blockNameOrMetadata;
6776  
6777    if (typeof name !== 'string') {
6778      console.error('Block names must be strings.');
6779      return;
6780    }
6781  
6782    if (!/^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(name)) {
6783      console.error('Block names must contain a namespace prefix, include only lowercase alphanumeric characters or dashes, and start with a letter. Example: my-plugin/my-custom-block');
6784      return;
6785    }
6786  
6787    if ((0,external_wp_data_namespaceObject.select)(store).getBlockType(name)) {
6788      console.error('Block "' + name + '" is already registered.');
6789      return;
6790    }
6791  
6792    if ((0,external_lodash_namespaceObject.isObject)(blockNameOrMetadata)) {
6793      unstable__bootstrapServerSideBlockDefinitions({
6794        [name]: getBlockSettingsFromMetadata(blockNameOrMetadata)
6795      });
6796    }
6797  
6798    const blockType = {
6799      name,
6800      icon: BLOCK_ICON_DEFAULT,
6801      keywords: [],
6802      attributes: {},
6803      providesContext: {},
6804      usesContext: [],
6805      supports: {},
6806      styles: [],
6807      variations: [],
6808      save: () => null,
6809      ...(serverSideBlockDefinitions === null || serverSideBlockDefinitions === void 0 ? void 0 : serverSideBlockDefinitions[name]),
6810      ...settings
6811    };
6812  
6813    (0,external_wp_data_namespaceObject.dispatch)(store).__experimentalRegisterBlockType(blockType);
6814  
6815    return (0,external_wp_data_namespaceObject.select)(store).getBlockType(name);
6816  }
6817  /**
6818   * Translates block settings provided with metadata using the i18n schema.
6819   *
6820   * @param {string|string[]|Object[]} i18nSchema   I18n schema for the block setting.
6821   * @param {string|string[]|Object[]} settingValue Value for the block setting.
6822   * @param {string}                   textdomain   Textdomain to use with translations.
6823   *
6824   * @return {string|string[]|Object[]} Translated setting.
6825   */
6826  
6827  function translateBlockSettingUsingI18nSchema(i18nSchema, settingValue, textdomain) {
6828    if ((0,external_lodash_namespaceObject.isString)(i18nSchema) && (0,external_lodash_namespaceObject.isString)(settingValue)) {
6829      // eslint-disable-next-line @wordpress/i18n-no-variables, @wordpress/i18n-text-domain
6830      return (0,external_wp_i18n_namespaceObject._x)(settingValue, i18nSchema, textdomain);
6831    }
6832  
6833    if ((0,external_lodash_namespaceObject.isArray)(i18nSchema) && !(0,external_lodash_namespaceObject.isEmpty)(i18nSchema) && (0,external_lodash_namespaceObject.isArray)(settingValue)) {
6834      return settingValue.map(value => translateBlockSettingUsingI18nSchema(i18nSchema[0], value, textdomain));
6835    }
6836  
6837    if ((0,external_lodash_namespaceObject.isObject)(i18nSchema) && !(0,external_lodash_namespaceObject.isEmpty)(i18nSchema) && (0,external_lodash_namespaceObject.isObject)(settingValue)) {
6838      return Object.keys(settingValue).reduce((accumulator, key) => {
6839        if (!i18nSchema[key]) {
6840          accumulator[key] = settingValue[key];
6841          return accumulator;
6842        }
6843  
6844        accumulator[key] = translateBlockSettingUsingI18nSchema(i18nSchema[key], settingValue[key], textdomain);
6845        return accumulator;
6846      }, {});
6847    }
6848  
6849    return settingValue;
6850  }
6851  /**
6852   * Registers a new block collection to group blocks in the same namespace in the inserter.
6853   *
6854   * @param {string} namespace       The namespace to group blocks by in the inserter; corresponds to the block namespace.
6855   * @param {Object} settings        The block collection settings.
6856   * @param {string} settings.title  The title to display in the block inserter.
6857   * @param {Object} [settings.icon] The icon to display in the block inserter.
6858   */
6859  
6860  
6861  function registerBlockCollection(namespace, _ref2) {
6862    let {
6863      title,
6864      icon
6865    } = _ref2;
6866    (0,external_wp_data_namespaceObject.dispatch)(store).addBlockCollection(namespace, title, icon);
6867  }
6868  /**
6869   * Unregisters a block collection
6870   *
6871   * @param {string} namespace The namespace to group blocks by in the inserter; corresponds to the block namespace
6872   *
6873   */
6874  
6875  function unregisterBlockCollection(namespace) {
6876    dispatch(blocksStore).removeBlockCollection(namespace);
6877  }
6878  /**
6879   * Unregisters a block.
6880   *
6881   * @param {string} name Block name.
6882   *
6883   * @return {?WPBlockType} The previous block value, if it has been successfully
6884   *                    unregistered; otherwise `undefined`.
6885   */
6886  
6887  function unregisterBlockType(name) {
6888    const oldBlock = (0,external_wp_data_namespaceObject.select)(store).getBlockType(name);
6889  
6890    if (!oldBlock) {
6891      console.error('Block "' + name + '" is not registered.');
6892      return;
6893    }
6894  
6895    (0,external_wp_data_namespaceObject.dispatch)(store).removeBlockTypes(name);
6896    return oldBlock;
6897  }
6898  /**
6899   * Assigns name of block for handling non-block content.
6900   *
6901   * @param {string} blockName Block name.
6902   */
6903  
6904  function setFreeformContentHandlerName(blockName) {
6905    (0,external_wp_data_namespaceObject.dispatch)(store).setFreeformFallbackBlockName(blockName);
6906  }
6907  /**
6908   * Retrieves name of block handling non-block content, or undefined if no
6909   * handler has been defined.
6910   *
6911   * @return {?string} Block name.
6912   */
6913  
6914  function getFreeformContentHandlerName() {
6915    return (0,external_wp_data_namespaceObject.select)(store).getFreeformFallbackBlockName();
6916  }
6917  /**
6918   * Retrieves name of block used for handling grouping interactions.
6919   *
6920   * @return {?string} Block name.
6921   */
6922  
6923  function registration_getGroupingBlockName() {
6924    return (0,external_wp_data_namespaceObject.select)(store).getGroupingBlockName();
6925  }
6926  /**
6927   * Assigns name of block handling unregistered block types.
6928   *
6929   * @param {string} blockName Block name.
6930   */
6931  
6932  function setUnregisteredTypeHandlerName(blockName) {
6933    (0,external_wp_data_namespaceObject.dispatch)(store).setUnregisteredFallbackBlockName(blockName);
6934  }
6935  /**
6936   * Retrieves name of block handling unregistered block types, or undefined if no
6937   * handler has been defined.
6938   *
6939   * @return {?string} Block name.
6940   */
6941  
6942  function getUnregisteredTypeHandlerName() {
6943    return (0,external_wp_data_namespaceObject.select)(store).getUnregisteredFallbackBlockName();
6944  }
6945  /**
6946   * Assigns the default block name.
6947   *
6948   * @param {string} name Block name.
6949   */
6950  
6951  function setDefaultBlockName(name) {
6952    (0,external_wp_data_namespaceObject.dispatch)(store).setDefaultBlockName(name);
6953  }
6954  /**
6955   * Assigns name of block for handling block grouping interactions.
6956   *
6957   * @param {string} name Block name.
6958   */
6959  
6960  function setGroupingBlockName(name) {
6961    (0,external_wp_data_namespaceObject.dispatch)(store).setGroupingBlockName(name);
6962  }
6963  /**
6964   * Retrieves the default block name.
6965   *
6966   * @return {?string} Block name.
6967   */
6968  
6969  function registration_getDefaultBlockName() {
6970    return (0,external_wp_data_namespaceObject.select)(store).getDefaultBlockName();
6971  }
6972  /**
6973   * Returns a registered block type.
6974   *
6975   * @param {string} name Block name.
6976   *
6977   * @return {?Object} Block type.
6978   */
6979  
6980  function registration_getBlockType(name) {
6981    var _select;
6982  
6983    return (_select = (0,external_wp_data_namespaceObject.select)(store)) === null || _select === void 0 ? void 0 : _select.getBlockType(name);
6984  }
6985  /**
6986   * Returns all registered blocks.
6987   *
6988   * @return {Array} Block settings.
6989   */
6990  
6991  function registration_getBlockTypes() {
6992    return (0,external_wp_data_namespaceObject.select)(store).getBlockTypes();
6993  }
6994  /**
6995   * Returns the block support value for a feature, if defined.
6996   *
6997   * @param {(string|Object)} nameOrType      Block name or type object
6998   * @param {string}          feature         Feature to retrieve
6999   * @param {*}               defaultSupports Default value to return if not
7000   *                                          explicitly defined
7001   *
7002   * @return {?*} Block support value
7003   */
7004  
7005  function registration_getBlockSupport(nameOrType, feature, defaultSupports) {
7006    return (0,external_wp_data_namespaceObject.select)(store).getBlockSupport(nameOrType, feature, defaultSupports);
7007  }
7008  /**
7009   * Returns true if the block defines support for a feature, or false otherwise.
7010   *
7011   * @param {(string|Object)} nameOrType      Block name or type object.
7012   * @param {string}          feature         Feature to test.
7013   * @param {boolean}         defaultSupports Whether feature is supported by
7014   *                                          default if not explicitly defined.
7015   *
7016   * @return {boolean} Whether block supports feature.
7017   */
7018  
7019  function registration_hasBlockSupport(nameOrType, feature, defaultSupports) {
7020    return (0,external_wp_data_namespaceObject.select)(store).hasBlockSupport(nameOrType, feature, defaultSupports);
7021  }
7022  /**
7023   * Determines whether or not the given block is a reusable block. This is a
7024   * special block type that is used to point to a global block stored via the
7025   * API.
7026   *
7027   * @param {Object} blockOrType Block or Block Type to test.
7028   *
7029   * @return {boolean} Whether the given block is a reusable block.
7030   */
7031  
7032  function isReusableBlock(blockOrType) {
7033    return (blockOrType === null || blockOrType === void 0 ? void 0 : blockOrType.name) === 'core/block';
7034  }
7035  /**
7036   * Determines whether or not the given block is a template part. This is a
7037   * special block type that allows composing a page template out of reusable
7038   * design elements.
7039   *
7040   * @param {Object} blockOrType Block or Block Type to test.
7041   *
7042   * @return {boolean} Whether the given block is a template part.
7043   */
7044  
7045  function isTemplatePart(blockOrType) {
7046    return blockOrType.name === 'core/template-part';
7047  }
7048  /**
7049   * Returns an array with the child blocks of a given block.
7050   *
7051   * @param {string} blockName Name of block (example: “latest-posts”).
7052   *
7053   * @return {Array} Array of child block names.
7054   */
7055  
7056  const registration_getChildBlockNames = blockName => {
7057    return (0,external_wp_data_namespaceObject.select)(store).getChildBlockNames(blockName);
7058  };
7059  /**
7060   * Returns a boolean indicating if a block has child blocks or not.
7061   *
7062   * @param {string} blockName Name of block (example: “latest-posts”).
7063   *
7064   * @return {boolean} True if a block contains child blocks and false otherwise.
7065   */
7066  
7067  const registration_hasChildBlocks = blockName => {
7068    return (0,external_wp_data_namespaceObject.select)(store).hasChildBlocks(blockName);
7069  };
7070  /**
7071   * Returns a boolean indicating if a block has at least one child block with inserter support.
7072   *
7073   * @param {string} blockName Block type name.
7074   *
7075   * @return {boolean} True if a block contains at least one child blocks with inserter support
7076   *                   and false otherwise.
7077   */
7078  
7079  const registration_hasChildBlocksWithInserterSupport = blockName => {
7080    return (0,external_wp_data_namespaceObject.select)(store).hasChildBlocksWithInserterSupport(blockName);
7081  };
7082  /**
7083   * Registers a new block style variation for the given block.
7084   *
7085   * @param {string} blockName      Name of block (example: “core/latest-posts”).
7086   * @param {Object} styleVariation Object containing `name` which is the class name applied to the block and `label` which identifies the variation to the user.
7087   */
7088  
7089  const registerBlockStyle = (blockName, styleVariation) => {
7090    (0,external_wp_data_namespaceObject.dispatch)(store).addBlockStyles(blockName, styleVariation);
7091  };
7092  /**
7093   * Unregisters a block style variation for the given block.
7094   *
7095   * @param {string} blockName          Name of block (example: “core/latest-posts”).
7096   * @param {string} styleVariationName Name of class applied to the block.
7097   */
7098  
7099  const unregisterBlockStyle = (blockName, styleVariationName) => {
7100    (0,external_wp_data_namespaceObject.dispatch)(store).removeBlockStyles(blockName, styleVariationName);
7101  };
7102  /**
7103   * Returns an array with the variations of a given block type.
7104   *
7105   * @param {string}                blockName Name of block (example: “core/columns”).
7106   * @param {WPBlockVariationScope} [scope]   Block variation scope name.
7107   *
7108   * @return {(WPBlockVariation[]|void)} Block variations.
7109   */
7110  
7111  const registration_getBlockVariations = (blockName, scope) => {
7112    return (0,external_wp_data_namespaceObject.select)(store).getBlockVariations(blockName, scope);
7113  };
7114  /**
7115   * Registers a new block variation for the given block type.
7116   *
7117   * @param {string}           blockName Name of the block (example: “core/columns”).
7118   * @param {WPBlockVariation} variation Object describing a block variation.
7119   */
7120  
7121  const registerBlockVariation = (blockName, variation) => {
7122    (0,external_wp_data_namespaceObject.dispatch)(store).addBlockVariations(blockName, variation);
7123  };
7124  /**
7125   * Unregisters a block variation defined for the given block type.
7126   *
7127   * @param {string} blockName     Name of the block (example: “core/columns”).
7128   * @param {string} variationName Name of the variation defined for the block.
7129   */
7130  
7131  const unregisterBlockVariation = (blockName, variationName) => {
7132    (0,external_wp_data_namespaceObject.dispatch)(store).removeBlockVariations(blockName, variationName);
7133  };
7134  
7135  ;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/rng.js
7136  // Unique ID creation requires a high quality random # generator. In the browser we therefore
7137  // require the crypto API and do not support built-in fallback to lower quality random number
7138  // generators (like Math.random()).
7139  var getRandomValues;
7140  var rnds8 = new Uint8Array(16);
7141  function rng() {
7142    // lazy load so that environments that need to polyfill have a chance to do so
7143    if (!getRandomValues) {
7144      // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
7145      // find the complete implementation of crypto (msCrypto) on IE11.
7146      getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
7147  
7148      if (!getRandomValues) {
7149        throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
7150      }
7151    }
7152  
7153    return getRandomValues(rnds8);
7154  }
7155  ;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/regex.js
7156  /* harmony default export */ var regex = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i);
7157  ;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/validate.js
7158  
7159  
7160  function validate(uuid) {
7161    return typeof uuid === 'string' && regex.test(uuid);
7162  }
7163  
7164  /* harmony default export */ var esm_browser_validate = (validate);
7165  ;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/stringify.js
7166  
7167  /**
7168   * Convert array of 16 byte values to UUID string format of the form:
7169   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
7170   */
7171  
7172  var byteToHex = [];
7173  
7174  for (var stringify_i = 0; stringify_i < 256; ++stringify_i) {
7175    byteToHex.push((stringify_i + 0x100).toString(16).substr(1));
7176  }
7177  
7178  function stringify(arr) {
7179    var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
7180    // Note: Be careful editing this code!  It's been tuned for performance
7181    // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
7182    var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
7183    // of the following:
7184    // - One or more input array values don't map to a hex octet (leading to
7185    // "undefined" in the uuid)
7186    // - Invalid input values for the RFC `version` or `variant` fields
7187  
7188    if (!esm_browser_validate(uuid)) {
7189      throw TypeError('Stringified UUID is invalid');
7190    }
7191  
7192    return uuid;
7193  }
7194  
7195  /* harmony default export */ var esm_browser_stringify = (stringify);
7196  ;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/v4.js
7197  
7198  
7199  
7200  function v4(options, buf, offset) {
7201    options = options || {};
7202    var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
7203  
7204    rnds[6] = rnds[6] & 0x0f | 0x40;
7205    rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
7206  
7207    if (buf) {
7208      offset = offset || 0;
7209  
7210      for (var i = 0; i < 16; ++i) {
7211        buf[offset + i] = rnds[i];
7212      }
7213  
7214      return buf;
7215    }
7216  
7217    return esm_browser_stringify(rnds);
7218  }
7219  
7220  /* harmony default export */ var esm_browser_v4 = (v4);
7221  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/factory.js
7222  /**
7223   * External dependencies
7224   */
7225  
7226  
7227  /**
7228   * WordPress dependencies
7229   */
7230  
7231  
7232  /**
7233   * Internal dependencies
7234   */
7235  
7236  
7237  
7238  /**
7239   * Returns a block object given its type and attributes.
7240   *
7241   * @param {string} name        Block name.
7242   * @param {Object} attributes  Block attributes.
7243   * @param {?Array} innerBlocks Nested blocks.
7244   *
7245   * @return {Object} Block object.
7246   */
7247  
7248  function createBlock(name) {
7249    let attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
7250    let innerBlocks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
7251  
7252    const sanitizedAttributes = __experimentalSanitizeBlockAttributes(name, attributes);
7253  
7254    const clientId = esm_browser_v4(); // Blocks are stored with a unique ID, the assigned type name, the block
7255    // attributes, and their inner blocks.
7256  
7257    return {
7258      clientId,
7259      name,
7260      isValid: true,
7261      attributes: sanitizedAttributes,
7262      innerBlocks
7263    };
7264  }
7265  /**
7266   * Given an array of InnerBlocks templates or Block Objects,
7267   * returns an array of created Blocks from them.
7268   * It handles the case of having InnerBlocks as Blocks by
7269   * converting them to the proper format to continue recursively.
7270   *
7271   * @param {Array} innerBlocksOrTemplate Nested blocks or InnerBlocks templates.
7272   *
7273   * @return {Object[]} Array of Block objects.
7274   */
7275  
7276  function createBlocksFromInnerBlocksTemplate() {
7277    let innerBlocksOrTemplate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
7278    return innerBlocksOrTemplate.map(innerBlock => {
7279      const innerBlockTemplate = Array.isArray(innerBlock) ? innerBlock : [innerBlock.name, innerBlock.attributes, innerBlock.innerBlocks];
7280      const [name, attributes, innerBlocks = []] = innerBlockTemplate;
7281      return createBlock(name, attributes, createBlocksFromInnerBlocksTemplate(innerBlocks));
7282    });
7283  }
7284  /**
7285   * Given a block object, returns a copy of the block object while sanitizing its attributes,
7286   * optionally merging new attributes and/or replacing its inner blocks.
7287   *
7288   * @param {Object} block           Block instance.
7289   * @param {Object} mergeAttributes Block attributes.
7290   * @param {?Array} newInnerBlocks  Nested blocks.
7291   *
7292   * @return {Object} A cloned block.
7293   */
7294  
7295  function __experimentalCloneSanitizedBlock(block) {
7296    let mergeAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
7297    let newInnerBlocks = arguments.length > 2 ? arguments[2] : undefined;
7298    const clientId = esm_browser_v4();
7299  
7300    const sanitizedAttributes = __experimentalSanitizeBlockAttributes(block.name, { ...block.attributes,
7301      ...mergeAttributes
7302    });
7303  
7304    return { ...block,
7305      clientId,
7306      attributes: sanitizedAttributes,
7307      innerBlocks: newInnerBlocks || block.innerBlocks.map(innerBlock => __experimentalCloneSanitizedBlock(innerBlock))
7308    };
7309  }
7310  /**
7311   * Given a block object, returns a copy of the block object,
7312   * optionally merging new attributes and/or replacing its inner blocks.
7313   *
7314   * @param {Object} block           Block instance.
7315   * @param {Object} mergeAttributes Block attributes.
7316   * @param {?Array} newInnerBlocks  Nested blocks.
7317   *
7318   * @return {Object} A cloned block.
7319   */
7320  
7321  function cloneBlock(block) {
7322    let mergeAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
7323    let newInnerBlocks = arguments.length > 2 ? arguments[2] : undefined;
7324    const clientId = esm_browser_v4();
7325    return { ...block,
7326      clientId,
7327      attributes: { ...block.attributes,
7328        ...mergeAttributes
7329      },
7330      innerBlocks: newInnerBlocks || block.innerBlocks.map(innerBlock => cloneBlock(innerBlock))
7331    };
7332  }
7333  /**
7334   * Returns a boolean indicating whether a transform is possible based on
7335   * various bits of context.
7336   *
7337   * @param {Object} transform The transform object to validate.
7338   * @param {string} direction Is this a 'from' or 'to' transform.
7339   * @param {Array}  blocks    The blocks to transform from.
7340   *
7341   * @return {boolean} Is the transform possible?
7342   */
7343  
7344  const isPossibleTransformForSource = (transform, direction, blocks) => {
7345    if ((0,external_lodash_namespaceObject.isEmpty)(blocks)) {
7346      return false;
7347    } // If multiple blocks are selected, only multi block transforms
7348    // or wildcard transforms are allowed.
7349  
7350  
7351    const isMultiBlock = blocks.length > 1;
7352    const firstBlockName = (0,external_lodash_namespaceObject.first)(blocks).name;
7353    const isValidForMultiBlocks = isWildcardBlockTransform(transform) || !isMultiBlock || transform.isMultiBlock;
7354  
7355    if (!isValidForMultiBlocks) {
7356      return false;
7357    } // Check non-wildcard transforms to ensure that transform is valid
7358    // for a block selection of multiple blocks of different types.
7359  
7360  
7361    if (!isWildcardBlockTransform(transform) && !(0,external_lodash_namespaceObject.every)(blocks, {
7362      name: firstBlockName
7363    })) {
7364      return false;
7365    } // Only consider 'block' type transforms as valid.
7366  
7367  
7368    const isBlockType = transform.type === 'block';
7369  
7370    if (!isBlockType) {
7371      return false;
7372    } // Check if the transform's block name matches the source block (or is a wildcard)
7373    // only if this is a transform 'from'.
7374  
7375  
7376    const sourceBlock = (0,external_lodash_namespaceObject.first)(blocks);
7377    const hasMatchingName = direction !== 'from' || transform.blocks.indexOf(sourceBlock.name) !== -1 || isWildcardBlockTransform(transform);
7378  
7379    if (!hasMatchingName) {
7380      return false;
7381    } // Don't allow single Grouping blocks to be transformed into
7382    // a Grouping block.
7383  
7384  
7385    if (!isMultiBlock && isContainerGroupBlock(sourceBlock.name) && isContainerGroupBlock(transform.blockName)) {
7386      return false;
7387    } // If the transform has a `isMatch` function specified, check that it returns true.
7388  
7389  
7390    if ((0,external_lodash_namespaceObject.isFunction)(transform.isMatch)) {
7391      const attributes = transform.isMultiBlock ? blocks.map(block => block.attributes) : sourceBlock.attributes;
7392      const block = transform.isMultiBlock ? blocks : sourceBlock;
7393  
7394      if (!transform.isMatch(attributes, block)) {
7395        return false;
7396      }
7397    }
7398  
7399    if (transform.usingMobileTransformations && isWildcardBlockTransform(transform) && !isContainerGroupBlock(sourceBlock.name)) {
7400      return false;
7401    }
7402  
7403    return true;
7404  };
7405  /**
7406   * Returns block types that the 'blocks' can be transformed into, based on
7407   * 'from' transforms on other blocks.
7408   *
7409   * @param {Array} blocks The blocks to transform from.
7410   *
7411   * @return {Array} Block types that the blocks can be transformed into.
7412   */
7413  
7414  
7415  const getBlockTypesForPossibleFromTransforms = blocks => {
7416    if ((0,external_lodash_namespaceObject.isEmpty)(blocks)) {
7417      return [];
7418    }
7419  
7420    const allBlockTypes = registration_getBlockTypes(); // filter all blocks to find those with a 'from' transform.
7421  
7422    const blockTypesWithPossibleFromTransforms = (0,external_lodash_namespaceObject.filter)(allBlockTypes, blockType => {
7423      const fromTransforms = getBlockTransforms('from', blockType.name);
7424      return !!findTransform(fromTransforms, transform => {
7425        return isPossibleTransformForSource(transform, 'from', blocks);
7426      });
7427    });
7428    return blockTypesWithPossibleFromTransforms;
7429  };
7430  /**
7431   * Returns block types that the 'blocks' can be transformed into, based on
7432   * the source block's own 'to' transforms.
7433   *
7434   * @param {Array} blocks The blocks to transform from.
7435   *
7436   * @return {Array} Block types that the source can be transformed into.
7437   */
7438  
7439  
7440  const getBlockTypesForPossibleToTransforms = blocks => {
7441    if ((0,external_lodash_namespaceObject.isEmpty)(blocks)) {
7442      return [];
7443    }
7444  
7445    const sourceBlock = (0,external_lodash_namespaceObject.first)(blocks);
7446    const blockType = registration_getBlockType(sourceBlock.name);
7447    const transformsTo = blockType ? getBlockTransforms('to', blockType.name) : []; // filter all 'to' transforms to find those that are possible.
7448  
7449    const possibleTransforms = (0,external_lodash_namespaceObject.filter)(transformsTo, transform => {
7450      return transform && isPossibleTransformForSource(transform, 'to', blocks);
7451    }); // Build a list of block names using the possible 'to' transforms.
7452  
7453    const blockNames = (0,external_lodash_namespaceObject.flatMap)(possibleTransforms, transformation => transformation.blocks); // Map block names to block types.
7454  
7455    return blockNames.map(name => name === '*' ? name : registration_getBlockType(name));
7456  };
7457  /**
7458   * Determines whether transform is a "block" type
7459   * and if so whether it is a "wildcard" transform
7460   * ie: targets "any" block type
7461   *
7462   * @param {Object} t the Block transform object
7463   *
7464   * @return {boolean} whether transform is a wildcard transform
7465   */
7466  
7467  
7468  const isWildcardBlockTransform = t => t && t.type === 'block' && Array.isArray(t.blocks) && t.blocks.includes('*');
7469  /**
7470   * Determines whether the given Block is the core Block which
7471   * acts as a container Block for other Blocks as part of the
7472   * Grouping mechanics
7473   *
7474   * @param {string} name the name of the Block to test against
7475   *
7476   * @return {boolean} whether or not the Block is the container Block type
7477   */
7478  
7479  const isContainerGroupBlock = name => name === registration_getGroupingBlockName();
7480  /**
7481   * Returns an array of block types that the set of blocks received as argument
7482   * can be transformed into.
7483   *
7484   * @param {Array} blocks Blocks array.
7485   *
7486   * @return {Array} Block types that the blocks argument can be transformed to.
7487   */
7488  
7489  function getPossibleBlockTransformations(blocks) {
7490    if ((0,external_lodash_namespaceObject.isEmpty)(blocks)) {
7491      return [];
7492    }
7493  
7494    const blockTypesForFromTransforms = getBlockTypesForPossibleFromTransforms(blocks);
7495    const blockTypesForToTransforms = getBlockTypesForPossibleToTransforms(blocks);
7496    return (0,external_lodash_namespaceObject.uniq)([...blockTypesForFromTransforms, ...blockTypesForToTransforms]);
7497  }
7498  /**
7499   * Given an array of transforms, returns the highest-priority transform where
7500   * the predicate function returns a truthy value. A higher-priority transform
7501   * is one with a lower priority value (i.e. first in priority order). Returns
7502   * null if the transforms set is empty or the predicate function returns a
7503   * falsey value for all entries.
7504   *
7505   * @param {Object[]} transforms Transforms to search.
7506   * @param {Function} predicate  Function returning true on matching transform.
7507   *
7508   * @return {?Object} Highest-priority transform candidate.
7509   */
7510  
7511  function findTransform(transforms, predicate) {
7512    // The hooks library already has built-in mechanisms for managing priority
7513    // queue, so leverage via locally-defined instance.
7514    const hooks = (0,external_wp_hooks_namespaceObject.createHooks)();
7515  
7516    for (let i = 0; i < transforms.length; i++) {
7517      const candidate = transforms[i];
7518  
7519      if (predicate(candidate)) {
7520        hooks.addFilter('transform', 'transform/' + i.toString(), result => result ? result : candidate, candidate.priority);
7521      }
7522    } // Filter name is arbitrarily chosen but consistent with above aggregation.
7523  
7524  
7525    return hooks.applyFilters('transform', null);
7526  }
7527  /**
7528   * Returns normal block transforms for a given transform direction, optionally
7529   * for a specific block by name, or an empty array if there are no transforms.
7530   * If no block name is provided, returns transforms for all blocks. A normal
7531   * transform object includes `blockName` as a property.
7532   *
7533   * @param {string}        direction       Transform direction ("to", "from").
7534   * @param {string|Object} blockTypeOrName Block type or name.
7535   *
7536   * @return {Array} Block transforms for direction.
7537   */
7538  
7539  function getBlockTransforms(direction, blockTypeOrName) {
7540    // When retrieving transforms for all block types, recurse into self.
7541    if (blockTypeOrName === undefined) {
7542      return (0,external_lodash_namespaceObject.flatMap)(registration_getBlockTypes(), _ref => {
7543        let {
7544          name
7545        } = _ref;
7546        return getBlockTransforms(direction, name);
7547      });
7548    } // Validate that block type exists and has array of direction.
7549  
7550  
7551    const blockType = normalizeBlockType(blockTypeOrName);
7552    const {
7553      name: blockName,
7554      transforms
7555    } = blockType || {};
7556  
7557    if (!transforms || !Array.isArray(transforms[direction])) {
7558      return [];
7559    }
7560  
7561    const usingMobileTransformations = transforms.supportedMobileTransforms && Array.isArray(transforms.supportedMobileTransforms);
7562    const filteredTransforms = usingMobileTransformations ? (0,external_lodash_namespaceObject.filter)(transforms[direction], t => {
7563      if (t.type === 'raw') {
7564        return true;
7565      }
7566  
7567      if (!t.blocks || !t.blocks.length) {
7568        return false;
7569      }
7570  
7571      if (isWildcardBlockTransform(t)) {
7572        return true;
7573      }
7574  
7575      return (0,external_lodash_namespaceObject.every)(t.blocks, transformBlockName => transforms.supportedMobileTransforms.includes(transformBlockName));
7576    }) : transforms[direction]; // Map transforms to normal form.
7577  
7578    return filteredTransforms.map(transform => ({ ...transform,
7579      blockName,
7580      usingMobileTransformations
7581    }));
7582  }
7583  /**
7584   * Switch one or more blocks into one or more blocks of the new block type.
7585   *
7586   * @param {Array|Object} blocks Blocks array or block object.
7587   * @param {string}       name   Block name.
7588   *
7589   * @return {?Array} Array of blocks or null.
7590   */
7591  
7592  function switchToBlockType(blocks, name) {
7593    const blocksArray = (0,external_lodash_namespaceObject.castArray)(blocks);
7594    const isMultiBlock = blocksArray.length > 1;
7595    const firstBlock = blocksArray[0];
7596    const sourceName = firstBlock.name; // Find the right transformation by giving priority to the "to"
7597    // transformation.
7598  
7599    const transformationsFrom = getBlockTransforms('from', name);
7600    const transformationsTo = getBlockTransforms('to', sourceName);
7601    const transformation = findTransform(transformationsTo, t => t.type === 'block' && (isWildcardBlockTransform(t) || t.blocks.indexOf(name) !== -1) && (!isMultiBlock || t.isMultiBlock)) || findTransform(transformationsFrom, t => t.type === 'block' && (isWildcardBlockTransform(t) || t.blocks.indexOf(sourceName) !== -1) && (!isMultiBlock || t.isMultiBlock)); // Stop if there is no valid transformation.
7602  
7603    if (!transformation) {
7604      return null;
7605    }
7606  
7607    let transformationResults;
7608  
7609    if (transformation.isMultiBlock) {
7610      if ((0,external_lodash_namespaceObject.has)(transformation, '__experimentalConvert')) {
7611        transformationResults = transformation.__experimentalConvert(blocksArray);
7612      } else {
7613        transformationResults = transformation.transform(blocksArray.map(currentBlock => currentBlock.attributes), blocksArray.map(currentBlock => currentBlock.innerBlocks));
7614      }
7615    } else if ((0,external_lodash_namespaceObject.has)(transformation, '__experimentalConvert')) {
7616      transformationResults = transformation.__experimentalConvert(firstBlock);
7617    } else {
7618      transformationResults = transformation.transform(firstBlock.attributes, firstBlock.innerBlocks);
7619    } // Ensure that the transformation function returned an object or an array
7620    // of objects.
7621  
7622  
7623    if (!(0,external_lodash_namespaceObject.isObjectLike)(transformationResults)) {
7624      return null;
7625    } // If the transformation function returned a single object, we want to work
7626    // with an array instead.
7627  
7628  
7629    transformationResults = (0,external_lodash_namespaceObject.castArray)(transformationResults); // Ensure that every block object returned by the transformation has a
7630    // valid block type.
7631  
7632    if (transformationResults.some(result => !registration_getBlockType(result.name))) {
7633      return null;
7634    }
7635  
7636    const hasSwitchedBlock = name === '*' || (0,external_lodash_namespaceObject.some)(transformationResults, result => result.name === name); // Ensure that at least one block object returned by the transformation has
7637    // the expected "destination" block type.
7638  
7639    if (!hasSwitchedBlock) {
7640      return null;
7641    }
7642  
7643    const ret = transformationResults.map((result, index, results) => {
7644      /**
7645       * Filters an individual transform result from block transformation.
7646       * All of the original blocks are passed, since transformations are
7647       * many-to-many, not one-to-one.
7648       *
7649       * @param {Object}   transformedBlock The transformed block.
7650       * @param {Object[]} blocks           Original blocks transformed.
7651       * @param {Object[]} index            Index of the transformed block on the array of results.
7652       * @param {Object[]} results          An array all the blocks that resulted from the transformation.
7653       */
7654      return (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.switchToBlockType.transformedBlock', result, blocks, index, results);
7655    });
7656    return ret;
7657  }
7658  /**
7659   * Create a block object from the example API.
7660   *
7661   * @param {string} name
7662   * @param {Object} example
7663   *
7664   * @return {Object} block.
7665   */
7666  
7667  const getBlockFromExample = (name, example) => {
7668    return createBlock(name, example.attributes, (0,external_lodash_namespaceObject.map)(example.innerBlocks, innerBlock => getBlockFromExample(innerBlock.name, innerBlock)));
7669  };
7670  
7671  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/utils.js
7672  /**
7673   * External dependencies
7674   */
7675  
7676  
7677  
7678  
7679  /**
7680   * WordPress dependencies
7681   */
7682  
7683  
7684  
7685  
7686  /**
7687   * Internal dependencies
7688   */
7689  
7690  
7691  
7692  
7693  k([names, a11y]);
7694  /**
7695   * Array of icon colors containing a color to be used if the icon color
7696   * was not explicitly set but the icon background color was.
7697   *
7698   * @type {Object}
7699   */
7700  
7701  const ICON_COLORS = ['#191e23', '#f8f9f9'];
7702  /**
7703   * Determines whether the block is a default block
7704   * and its attributes are equal to the default attributes
7705   * which means the block is unmodified.
7706   *
7707   * @param {WPBlock} block Block Object
7708   *
7709   * @return {boolean} Whether the block is an unmodified default block
7710   */
7711  
7712  function isUnmodifiedDefaultBlock(block) {
7713    const defaultBlockName = registration_getDefaultBlockName();
7714  
7715    if (block.name !== defaultBlockName) {
7716      return false;
7717    } // Cache a created default block if no cache exists or the default block
7718    // name changed.
7719  
7720  
7721    if (!isUnmodifiedDefaultBlock.block || isUnmodifiedDefaultBlock.block.name !== defaultBlockName) {
7722      isUnmodifiedDefaultBlock.block = createBlock(defaultBlockName);
7723    }
7724  
7725    const newDefaultBlock = isUnmodifiedDefaultBlock.block;
7726    const blockType = registration_getBlockType(defaultBlockName);
7727    return (0,external_lodash_namespaceObject.every)(blockType === null || blockType === void 0 ? void 0 : blockType.attributes, (value, key) => newDefaultBlock.attributes[key] === block.attributes[key]);
7728  }
7729  /**
7730   * Function that checks if the parameter is a valid icon.
7731   *
7732   * @param {*} icon Parameter to be checked.
7733   *
7734   * @return {boolean} True if the parameter is a valid icon and false otherwise.
7735   */
7736  
7737  function isValidIcon(icon) {
7738    return !!icon && ((0,external_lodash_namespaceObject.isString)(icon) || (0,external_wp_element_namespaceObject.isValidElement)(icon) || (0,external_lodash_namespaceObject.isFunction)(icon) || icon instanceof external_wp_element_namespaceObject.Component);
7739  }
7740  /**
7741   * Function that receives an icon as set by the blocks during the registration
7742   * and returns a new icon object that is normalized so we can rely on just on possible icon structure
7743   * in the codebase.
7744   *
7745   * @param {WPBlockTypeIconRender} icon Render behavior of a block type icon;
7746   *                                     one of a Dashicon slug, an element, or a
7747   *                                     component.
7748   *
7749   * @return {WPBlockTypeIconDescriptor} Object describing the icon.
7750   */
7751  
7752  function normalizeIconObject(icon) {
7753    icon = icon || BLOCK_ICON_DEFAULT;
7754  
7755    if (isValidIcon(icon)) {
7756      return {
7757        src: icon
7758      };
7759    }
7760  
7761    if ((0,external_lodash_namespaceObject.has)(icon, ['background'])) {
7762      const colordBgColor = w(icon.background);
7763      return { ...icon,
7764        foreground: icon.foreground ? icon.foreground : (0,external_lodash_namespaceObject.maxBy)(ICON_COLORS, iconColor => colordBgColor.contrast(iconColor)),
7765        shadowColor: colordBgColor.alpha(0.3).toRgbString()
7766      };
7767    }
7768  
7769    return icon;
7770  }
7771  /**
7772   * Normalizes block type passed as param. When string is passed then
7773   * it converts it to the matching block type object.
7774   * It passes the original object otherwise.
7775   *
7776   * @param {string|Object} blockTypeOrName Block type or name.
7777   *
7778   * @return {?Object} Block type.
7779   */
7780  
7781  function normalizeBlockType(blockTypeOrName) {
7782    if ((0,external_lodash_namespaceObject.isString)(blockTypeOrName)) {
7783      return registration_getBlockType(blockTypeOrName);
7784    }
7785  
7786    return blockTypeOrName;
7787  }
7788  /**
7789   * Get the label for the block, usually this is either the block title,
7790   * or the value of the block's `label` function when that's specified.
7791   *
7792   * @param {Object} blockType  The block type.
7793   * @param {Object} attributes The values of the block's attributes.
7794   * @param {Object} context    The intended use for the label.
7795   *
7796   * @return {string} The block label.
7797   */
7798  
7799  function getBlockLabel(blockType, attributes) {
7800    let context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'visual';
7801    const {
7802      __experimentalLabel: getLabel,
7803      title
7804    } = blockType;
7805    const label = getLabel && getLabel(attributes, {
7806      context
7807    });
7808  
7809    if (!label) {
7810      return title;
7811    } // Strip any HTML (i.e. RichText formatting) before returning.
7812  
7813  
7814    return (0,external_wp_dom_namespaceObject.__unstableStripHTML)(label);
7815  }
7816  /**
7817   * Get a label for the block for use by screenreaders, this is more descriptive
7818   * than the visual label and includes the block title and the value of the
7819   * `getLabel` function if it's specified.
7820   *
7821   * @param {Object}  blockType              The block type.
7822   * @param {Object}  attributes             The values of the block's attributes.
7823   * @param {?number} position               The position of the block in the block list.
7824   * @param {string}  [direction='vertical'] The direction of the block layout.
7825   *
7826   * @return {string} The block label.
7827   */
7828  
7829  function getAccessibleBlockLabel(blockType, attributes, position) {
7830    let direction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'vertical';
7831    // `title` is already localized, `label` is a user-supplied value.
7832    const title = blockType === null || blockType === void 0 ? void 0 : blockType.title;
7833    const label = blockType ? getBlockLabel(blockType, attributes, 'accessibility') : '';
7834    const hasPosition = position !== undefined; // getBlockLabel returns the block title as a fallback when there's no label,
7835    // if it did return the title, this function needs to avoid adding the
7836    // title twice within the accessible label. Use this `hasLabel` boolean to
7837    // handle that.
7838  
7839    const hasLabel = label && label !== title;
7840  
7841    if (hasPosition && direction === 'vertical') {
7842      if (hasLabel) {
7843        return (0,external_wp_i18n_namespaceObject.sprintf)(
7844        /* translators: accessibility text. 1: The block title. 2: The block row number. 3: The block label.. */
7845        (0,external_wp_i18n_namespaceObject.__)('%1$s Block. Row %2$d. %3$s'), title, position, label);
7846      }
7847  
7848      return (0,external_wp_i18n_namespaceObject.sprintf)(
7849      /* translators: accessibility text. 1: The block title. 2: The block row number. */
7850      (0,external_wp_i18n_namespaceObject.__)('%1$s Block. Row %2$d'), title, position);
7851    } else if (hasPosition && direction === 'horizontal') {
7852      if (hasLabel) {
7853        return (0,external_wp_i18n_namespaceObject.sprintf)(
7854        /* translators: accessibility text. 1: The block title. 2: The block column number. 3: The block label.. */
7855        (0,external_wp_i18n_namespaceObject.__)('%1$s Block. Column %2$d. %3$s'), title, position, label);
7856      }
7857  
7858      return (0,external_wp_i18n_namespaceObject.sprintf)(
7859      /* translators: accessibility text. 1: The block title. 2: The block column number. */
7860      (0,external_wp_i18n_namespaceObject.__)('%1$s Block. Column %2$d'), title, position);
7861    }
7862  
7863    if (hasLabel) {
7864      return (0,external_wp_i18n_namespaceObject.sprintf)(
7865      /* translators: accessibility text. %1: The block title. %2: The block label. */
7866      (0,external_wp_i18n_namespaceObject.__)('%1$s Block. %2$s'), title, label);
7867    }
7868  
7869    return (0,external_wp_i18n_namespaceObject.sprintf)(
7870    /* translators: accessibility text. %s: The block title. */
7871    (0,external_wp_i18n_namespaceObject.__)('%s Block'), title);
7872  }
7873  /**
7874   * Ensure attributes contains only values defined by block type, and merge
7875   * default values for missing attributes.
7876   *
7877   * @param {string} name       The block's name.
7878   * @param {Object} attributes The block's attributes.
7879   * @return {Object} The sanitized attributes.
7880   */
7881  
7882  function __experimentalSanitizeBlockAttributes(name, attributes) {
7883    // Get the type definition associated with a registered block.
7884    const blockType = registration_getBlockType(name);
7885  
7886    if (undefined === blockType) {
7887      throw new Error(`Block type '$name}' is not registered.`);
7888    }
7889  
7890    return (0,external_lodash_namespaceObject.reduce)(blockType.attributes, (accumulator, schema, key) => {
7891      const value = attributes[key];
7892  
7893      if (undefined !== value) {
7894        accumulator[key] = value;
7895      } else if (schema.hasOwnProperty('default')) {
7896        accumulator[key] = schema.default;
7897      }
7898  
7899      if (['node', 'children'].indexOf(schema.source) !== -1) {
7900        // Ensure value passed is always an array, which we're expecting in
7901        // the RichText component to handle the deprecated value.
7902        if (typeof accumulator[key] === 'string') {
7903          accumulator[key] = [accumulator[key]];
7904        } else if (!Array.isArray(accumulator[key])) {
7905          accumulator[key] = [];
7906        }
7907      }
7908  
7909      return accumulator;
7910    }, {});
7911  }
7912  /**
7913   * Filter block attributes by `role` and return their names.
7914   *
7915   * @param {string} name Block attribute's name.
7916   * @param {string} role The role of a block attribute.
7917   *
7918   * @return {string[]} The attribute names that have the provided role.
7919   */
7920  
7921  function __experimentalGetBlockAttributesNamesByRole(name, role) {
7922    var _getBlockType;
7923  
7924    const attributes = (_getBlockType = registration_getBlockType(name)) === null || _getBlockType === void 0 ? void 0 : _getBlockType.attributes;
7925    if (!attributes) return [];
7926    const attributesNames = Object.keys(attributes);
7927    if (!role) return attributesNames;
7928    return attributesNames.filter(attributeName => {
7929      var _attributes$attribute;
7930  
7931      return ((_attributes$attribute = attributes[attributeName]) === null || _attributes$attribute === void 0 ? void 0 : _attributes$attribute.__experimentalRole) === role;
7932    });
7933  }
7934  
7935  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/actions.js
7936  /**
7937   * External dependencies
7938   */
7939  
7940  /**
7941   * WordPress dependencies
7942   */
7943  
7944  
7945  /**
7946   * Internal dependencies
7947   */
7948  
7949  
7950  
7951  /** @typedef {import('../api/registration').WPBlockVariation} WPBlockVariation */
7952  
7953  const {
7954    error,
7955    warn
7956  } = window.console;
7957  /**
7958   * Mapping of legacy category slugs to their latest normal values, used to
7959   * accommodate updates of the default set of block categories.
7960   *
7961   * @type {Record<string,string>}
7962   */
7963  
7964  const LEGACY_CATEGORY_MAPPING = {
7965    common: 'text',
7966    formatting: 'text',
7967    layout: 'design'
7968  };
7969  /**
7970   * Takes the unprocessed block type data and applies all the existing filters for the registered block type.
7971   * Next, it validates all the settings and performs additional processing to the block type definition.
7972   *
7973   * @param {WPBlockType} blockType        Unprocessed block type settings.
7974   * @param {Object}      thunkArgs        Argument object for the thunk middleware.
7975   * @param {Function}    thunkArgs.select Function to select from the store.
7976   *
7977   * @return {?WPBlockType} The block, if it has been successfully registered; otherwise `undefined`.
7978   */
7979  
7980  const processBlockType = (blockType, _ref) => {
7981    let {
7982      select
7983    } = _ref;
7984    const {
7985      name
7986    } = blockType;
7987    const settings = (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.registerBlockType', { ...blockType
7988    }, name);
7989  
7990    if (settings.deprecated) {
7991      settings.deprecated = settings.deprecated.map(deprecation => (0,external_lodash_namespaceObject.pick)( // Only keep valid deprecation keys.
7992      (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.registerBlockType', // Merge deprecation keys with pre-filter settings
7993      // so that filters that depend on specific keys being
7994      // present don't fail.
7995      { // Omit deprecation keys here so that deprecations
7996        // can opt out of specific keys like "supports".
7997        ...(0,external_lodash_namespaceObject.omit)(blockType, DEPRECATED_ENTRY_KEYS),
7998        ...deprecation
7999      }, name), DEPRECATED_ENTRY_KEYS));
8000    }
8001  
8002    if (!(0,external_lodash_namespaceObject.isPlainObject)(settings)) {
8003      error('Block settings must be a valid object.');
8004      return;
8005    }
8006  
8007    if (!(0,external_lodash_namespaceObject.isFunction)(settings.save)) {
8008      error('The "save" property must be a valid function.');
8009      return;
8010    }
8011  
8012    if ('edit' in settings && !(0,external_lodash_namespaceObject.isFunction)(settings.edit)) {
8013      error('The "edit" property must be a valid function.');
8014      return;
8015    } // Canonicalize legacy categories to equivalent fallback.
8016  
8017  
8018    if (LEGACY_CATEGORY_MAPPING.hasOwnProperty(settings.category)) {
8019      settings.category = LEGACY_CATEGORY_MAPPING[settings.category];
8020    }
8021  
8022    if ('category' in settings && !(0,external_lodash_namespaceObject.some)(select.getCategories(), {
8023      slug: settings.category
8024    })) {
8025      warn('The block "' + name + '" is registered with an invalid category "' + settings.category + '".');
8026      delete settings.category;
8027    }
8028  
8029    if (!('title' in settings) || settings.title === '') {
8030      error('The block "' + name + '" must have a title.');
8031      return;
8032    }
8033  
8034    if (typeof settings.title !== 'string') {
8035      error('Block titles must be strings.');
8036      return;
8037    }
8038  
8039    settings.icon = normalizeIconObject(settings.icon);
8040  
8041    if (!isValidIcon(settings.icon.src)) {
8042      error('The icon passed is invalid. ' + 'The icon should be a string, an element, a function, or an object following the specifications documented in https://developer.wordpress.org/block-editor/developers/block-api/block-registration/#icon-optional');
8043      return;
8044    }
8045  
8046    return settings;
8047  };
8048  /**
8049   * Returns an action object used in signalling that block types have been added.
8050   *
8051   * @param {Array|Object} blockTypes Block types received.
8052   *
8053   * @return {Object} Action object.
8054   */
8055  
8056  
8057  function addBlockTypes(blockTypes) {
8058    return {
8059      type: 'ADD_BLOCK_TYPES',
8060      blockTypes: (0,external_lodash_namespaceObject.castArray)(blockTypes)
8061    };
8062  }
8063  /**
8064   * Signals that the passed block type's settings should be stored in the state.
8065   *
8066   * @param {WPBlockType} blockType Unprocessed block type settings.
8067   */
8068  
8069  const __experimentalRegisterBlockType = blockType => _ref2 => {
8070    let {
8071      dispatch,
8072      select
8073    } = _ref2;
8074    dispatch({
8075      type: 'ADD_UNPROCESSED_BLOCK_TYPE',
8076      blockType
8077    });
8078    const processedBlockType = processBlockType(blockType, {
8079      select
8080    });
8081  
8082    if (!processedBlockType) {
8083      return;
8084    }
8085  
8086    dispatch.addBlockTypes(processedBlockType);
8087  };
8088  /**
8089   * Signals that all block types should be computed again.
8090   * It uses stored unprocessed block types and all the most recent list of registered filters.
8091   *
8092   * It addresses the issue where third party block filters get registered after third party blocks. A sample sequence:
8093   *   1. Filter A.
8094   *   2. Block B.
8095   *   3. Block C.
8096   *   4. Filter D.
8097   *   5. Filter E.
8098   *   6. Block F.
8099   *   7. Filter G.
8100   * In this scenario some filters would not get applied for all blocks because they are registered too late.
8101   */
8102  
8103  const __experimentalReapplyBlockTypeFilters = () => _ref3 => {
8104    let {
8105      dispatch,
8106      select
8107    } = _ref3;
8108  
8109    const unprocessedBlockTypes = select.__experimentalGetUnprocessedBlockTypes();
8110  
8111    const processedBlockTypes = Object.keys(unprocessedBlockTypes).reduce((accumulator, blockName) => {
8112      const result = processBlockType(unprocessedBlockTypes[blockName], {
8113        select
8114      });
8115  
8116      if (result) {
8117        accumulator.push(result);
8118      }
8119  
8120      return accumulator;
8121    }, []);
8122  
8123    if (!processedBlockTypes.length) {
8124      return;
8125    }
8126  
8127    dispatch.addBlockTypes(processedBlockTypes);
8128  };
8129  /**
8130   * Returns an action object used to remove a registered block type.
8131   *
8132   * @param {string|Array} names Block name.
8133   *
8134   * @return {Object} Action object.
8135   */
8136  
8137  function removeBlockTypes(names) {
8138    return {
8139      type: 'REMOVE_BLOCK_TYPES',
8140      names: (0,external_lodash_namespaceObject.castArray)(names)
8141    };
8142  }
8143  /**
8144   * Returns an action object used in signalling that new block styles have been added.
8145   *
8146   * @param {string}       blockName Block name.
8147   * @param {Array|Object} styles    Block styles.
8148   *
8149   * @return {Object} Action object.
8150   */
8151  
8152  function addBlockStyles(blockName, styles) {
8153    return {
8154      type: 'ADD_BLOCK_STYLES',
8155      styles: (0,external_lodash_namespaceObject.castArray)(styles),
8156      blockName
8157    };
8158  }
8159  /**
8160   * Returns an action object used in signalling that block styles have been removed.
8161   *
8162   * @param {string}       blockName  Block name.
8163   * @param {Array|string} styleNames Block style names.
8164   *
8165   * @return {Object} Action object.
8166   */
8167  
8168  function removeBlockStyles(blockName, styleNames) {
8169    return {
8170      type: 'REMOVE_BLOCK_STYLES',
8171      styleNames: (0,external_lodash_namespaceObject.castArray)(styleNames),
8172      blockName
8173    };
8174  }
8175  /**
8176   * Returns an action object used in signalling that new block variations have been added.
8177   *
8178   * @param {string}                              blockName  Block name.
8179   * @param {WPBlockVariation|WPBlockVariation[]} variations Block variations.
8180   *
8181   * @return {Object} Action object.
8182   */
8183  
8184  function addBlockVariations(blockName, variations) {
8185    return {
8186      type: 'ADD_BLOCK_VARIATIONS',
8187      variations: (0,external_lodash_namespaceObject.castArray)(variations),
8188      blockName
8189    };
8190  }
8191  /**
8192   * Returns an action object used in signalling that block variations have been removed.
8193   *
8194   * @param {string}          blockName      Block name.
8195   * @param {string|string[]} variationNames Block variation names.
8196   *
8197   * @return {Object} Action object.
8198   */
8199  
8200  function removeBlockVariations(blockName, variationNames) {
8201    return {
8202      type: 'REMOVE_BLOCK_VARIATIONS',
8203      variationNames: (0,external_lodash_namespaceObject.castArray)(variationNames),
8204      blockName
8205    };
8206  }
8207  /**
8208   * Returns an action object used to set the default block name.
8209   *
8210   * @param {string} name Block name.
8211   *
8212   * @return {Object} Action object.
8213   */
8214  
8215  function actions_setDefaultBlockName(name) {
8216    return {
8217      type: 'SET_DEFAULT_BLOCK_NAME',
8218      name
8219    };
8220  }
8221  /**
8222   * Returns an action object used to set the name of the block used as a fallback
8223   * for non-block content.
8224   *
8225   * @param {string} name Block name.
8226   *
8227   * @return {Object} Action object.
8228   */
8229  
8230  function setFreeformFallbackBlockName(name) {
8231    return {
8232      type: 'SET_FREEFORM_FALLBACK_BLOCK_NAME',
8233      name
8234    };
8235  }
8236  /**
8237   * Returns an action object used to set the name of the block used as a fallback
8238   * for unregistered blocks.
8239   *
8240   * @param {string} name Block name.
8241   *
8242   * @return {Object} Action object.
8243   */
8244  
8245  function setUnregisteredFallbackBlockName(name) {
8246    return {
8247      type: 'SET_UNREGISTERED_FALLBACK_BLOCK_NAME',
8248      name
8249    };
8250  }
8251  /**
8252   * Returns an action object used to set the name of the block used
8253   * when grouping other blocks
8254   * eg: in "Group/Ungroup" interactions
8255   *
8256   * @param {string} name Block name.
8257   *
8258   * @return {Object} Action object.
8259   */
8260  
8261  function actions_setGroupingBlockName(name) {
8262    return {
8263      type: 'SET_GROUPING_BLOCK_NAME',
8264      name
8265    };
8266  }
8267  /**
8268   * Returns an action object used to set block categories.
8269   *
8270   * @param {Object[]} categories Block categories.
8271   *
8272   * @return {Object} Action object.
8273   */
8274  
8275  function setCategories(categories) {
8276    return {
8277      type: 'SET_CATEGORIES',
8278      categories
8279    };
8280  }
8281  /**
8282   * Returns an action object used to update a category.
8283   *
8284   * @param {string} slug     Block category slug.
8285   * @param {Object} category Object containing the category properties that should be updated.
8286   *
8287   * @return {Object} Action object.
8288   */
8289  
8290  function updateCategory(slug, category) {
8291    return {
8292      type: 'UPDATE_CATEGORY',
8293      slug,
8294      category
8295    };
8296  }
8297  /**
8298   * Returns an action object used to add block collections
8299   *
8300   * @param {string} namespace The namespace of the blocks to put in the collection
8301   * @param {string} title     The title to display in the block inserter
8302   * @param {Object} icon      (optional) The icon to display in the block inserter
8303   *
8304   * @return {Object} Action object.
8305   */
8306  
8307  function addBlockCollection(namespace, title, icon) {
8308    return {
8309      type: 'ADD_BLOCK_COLLECTION',
8310      namespace,
8311      title,
8312      icon
8313    };
8314  }
8315  /**
8316   * Returns an action object used to remove block collections
8317   *
8318   * @param {string} namespace The namespace of the blocks to put in the collection
8319   *
8320   * @return {Object} Action object.
8321   */
8322  
8323  function removeBlockCollection(namespace) {
8324    return {
8325      type: 'REMOVE_BLOCK_COLLECTION',
8326      namespace
8327    };
8328  }
8329  
8330  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/constants.js
8331  const STORE_NAME = 'core/blocks';
8332  
8333  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/index.js
8334  /**
8335   * WordPress dependencies
8336   */
8337  
8338  /**
8339   * Internal dependencies
8340   */
8341  
8342  
8343  
8344  
8345  
8346  /**
8347   * Store definition for the blocks namespace.
8348   *
8349   * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
8350   *
8351   * @type {Object}
8352   */
8353  
8354  const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, {
8355    reducer: reducer,
8356    selectors: selectors_namespaceObject,
8357    actions: actions_namespaceObject
8358  });
8359  (0,external_wp_data_namespaceObject.register)(store);
8360  
8361  ;// CONCATENATED MODULE: external ["wp","blockSerializationDefaultParser"]
8362  var external_wp_blockSerializationDefaultParser_namespaceObject = window["wp"]["blockSerializationDefaultParser"];
8363  ;// CONCATENATED MODULE: external ["wp","autop"]
8364  var external_wp_autop_namespaceObject = window["wp"]["autop"];
8365  ;// CONCATENATED MODULE: external ["wp","isShallowEqual"]
8366  var external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
8367  var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
8368  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/parser/serialize-raw-block.js
8369  /**
8370   * Internal dependencies
8371   */
8372  
8373  /**
8374   * @typedef {Object}   Options                   Serialization options.
8375   * @property {boolean} [isCommentDelimited=true] Whether to output HTML comments around blocks.
8376   */
8377  
8378  /** @typedef {import("./").WPRawBlock} WPRawBlock */
8379  
8380  /**
8381   * Serializes a block node into the native HTML-comment-powered block format.
8382   * CAVEAT: This function is intended for re-serializing blocks as parsed by
8383   * valid parsers and skips any validation steps. This is NOT a generic
8384   * serialization function for in-memory blocks. For most purposes, see the
8385   * following functions available in the `@wordpress/blocks` package:
8386   *
8387   * @see serializeBlock
8388   * @see serialize
8389   *
8390   * For more on the format of block nodes as returned by valid parsers:
8391   *
8392   * @see `@wordpress/block-serialization-default-parser` package
8393   * @see `@wordpress/block-serialization-spec-parser` package
8394   *
8395   * @param {WPRawBlock} rawBlock     A block node as returned by a valid parser.
8396   * @param {Options}    [options={}] Serialization options.
8397   *
8398   * @return {string} An HTML string representing a block.
8399   */
8400  
8401  function serializeRawBlock(rawBlock) {
8402    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
8403    const {
8404      isCommentDelimited = true
8405    } = options;
8406    const {
8407      blockName,
8408      attrs = {},
8409      innerBlocks = [],
8410      innerContent = []
8411    } = rawBlock;
8412    let childIndex = 0;
8413    const content = innerContent.map(item => // `null` denotes a nested block, otherwise we have an HTML fragment.
8414    item !== null ? item : serializeRawBlock(innerBlocks[childIndex++], options)).join('\n').replace(/\n+/g, '\n').trim();
8415    return isCommentDelimited ? getCommentDelimitedContent(blockName, attrs, content) : content;
8416  }
8417  
8418  ;// CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/serializer.js
8419  
8420  
8421  /**
8422   * External dependencies
8423   */
8424  
8425  /**
8426   * WordPress dependencies
8427   */
8428  
8429  
8430  
8431  
8432  
8433  /**
8434   * Internal dependencies
8435   */
8436  
8437  
8438  
8439  
8440  /** @typedef {import('./parser').WPBlock} WPBlock */
8441  
8442  /**
8443   * @typedef {Object} WPBlockSerializationOptions Serialization Options.
8444   *
8445   * @property {boolean} isInnerBlocks Whether we are serializing inner blocks.
8446   */
8447  
8448  /**
8449   * Returns the block's default classname from its name.
8450   *
8451   * @param {string} blockName The block name.
8452   *
8453   * @return {string} The block's default class.
8454   */
8455  
8456  function getBlockDefaultClassName(blockName) {
8457    // Generated HTML classes for blocks follow the `wp-block-{name}` nomenclature.
8458    // Blocks provided by WordPress drop the prefixes 'core/' or 'core-' (historically used in 'core-embed/').
8459    const className = 'wp-block-' + blockName.replace(/\//, '-').replace(/^core-/, '');
8460    return (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.getBlockDefaultClassName', className, blockName);
8461  }
8462  /**
8463   * Returns the block's default menu item classname from its name.
8464   *
8465   * @param {string} blockName The block name.
8466   *
8467   * @return {string} The block's default menu item class.
8468   */
8469  
8470  function getBlockMenuDefaultClassName(blockName) {
8471    // Generated HTML classes for blocks follow the `editor-block-list-item-{name}` nomenclature.
8472    // Blocks provided by WordPress drop the prefixes 'core/' or 'core-' (historically used in 'core-embed/').
8473    const className = 'editor-block-list-item-' + blockName.replace(/\//, '-').replace(/^core-/, '');
8474    return (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.getBlockMenuDefaultClassName', className, blockName);
8475  }
8476  const blockPropsProvider = {};
8477  const innerBlocksPropsProvider = {};
8478  /**
8479   * Call within a save function to get the props for the block wrapper.
8480   *
8481   * @param {Object} props Optional. Props to pass to the element.
8482   */
8483  
8484  function getBlockProps() {
8485    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
8486    const {
8487      blockType,
8488      attributes
8489    } = blockPropsProvider;
8490    return (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.getSaveContent.extraProps', { ...props
8491    }, blockType, attributes);
8492  }
8493  /**
8494   * Call within a save function to get the props for the inner blocks wrapper.
8495   *
8496   * @param {Object} props Optional. Props to pass to the element.
8497   */
8498  
8499  function getInnerBlocksProps() {
8500    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
8501    const {
8502      innerBlocks
8503    } = innerBlocksPropsProvider; // Value is an array of blocks, so defer to block serializer.
8504  
8505    const html = serializer_serialize(innerBlocks, {
8506      isInnerBlocks: true
8507    }); // Use special-cased raw HTML tag to avoid default escaping.
8508  
8509    const children = (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.RawHTML, null, html);
8510    return { ...props,
8511      children
8512    };
8513  }
8514  /**
8515   * Given a block type containing a save render implementation and attributes, returns the
8516   * enhanced element to be saved or string when raw HTML expected.
8517   *
8518   * @param {string|Object} blockTypeOrName Block type or name.
8519   * @param {Object}        attributes      Block attributes.
8520   * @param {?Array}        innerBlocks     Nested blocks.
8521   *
8522   * @return {Object|string} Save element or raw HTML string.
8523   */
8524  
8525  function getSaveElement(blockTypeOrName, attributes) {
8526    let innerBlocks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
8527    const blockType = normalizeBlockType(blockTypeOrName);
8528    let {
8529      save
8530    } = blockType; // Component classes are unsupported for save since serialization must
8531    // occur synchronously. For improved interoperability with higher-order
8532    // components which often return component class, emulate basic support.
8533  
8534    if (save.prototype instanceof external_wp_element_namespaceObject.Component) {
8535      const instance = new save({
8536        attributes
8537      });
8538      save = instance.render.bind(instance);
8539    }
8540  
8541    blockPropsProvider.blockType = blockType;
8542    blockPropsProvider.attributes = attributes;
8543    innerBlocksPropsProvider.innerBlocks = innerBlocks;
8544    let element = save({
8545      attributes,
8546      innerBlocks
8547    });
8548  
8549    if ((0,external_lodash_namespaceObject.isObject)(element) && (0,external_wp_hooks_namespaceObject.hasFilter)('blocks.getSaveContent.extraProps') && !(blockType.apiVersion > 1)) {
8550      /**
8551       * Filters the props applied to the block save result element.
8552       *
8553       * @param {Object}  props      Props applied to save element.
8554       * @param {WPBlock} blockType  Block type definition.
8555       * @param {Object}  attributes Block attributes.
8556       */
8557      const props = (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.getSaveContent.extraProps', { ...element.props
8558      }, blockType, attributes);
8559  
8560      if (!external_wp_isShallowEqual_default()(props, element.props)) {
8561        element = (0,external_wp_element_namespaceObject.cloneElement)(element, props);
8562      }
8563    }
8564    /**
8565     * Filters the save result of a block during serialization.
8566     *
8567     * @param {WPElement} element    Block save result.
8568     * @param {WPBlock}   blockType  Block type definition.
8569     * @param {Object}    attributes Block attributes.
8570     */
8571  
8572  
8573    return (0,external_wp_hooks_namespaceObject.applyFilters)('blocks.getSaveElement', element, blockType, attributes);
8574  }
8575  /**
8576   * Given a block type containing a save render implementation and attributes, returns the
8577   * static markup to be saved.
8578   *
8579   * @param {string|Object} blockTypeOrName Block type or name.
8580   * @param {Object}        attributes      Block attributes.
8581   * @param {?Array}        innerBlocks     Nested blocks.
8582   *
8583   * @return {string} Save content.
8584   */
8585  
8586  function getSaveContent(blockTypeOrName, attributes, innerBlocks) {
8587    const blockType = normalizeBlockType(blockTypeOrName);
8588    return (0,external_wp_element_namespaceObject.renderToString)(getSaveElement(blockType, attributes, innerBlocks));
8589  }
8590  /**
8591   * Returns attributes which are to be saved and serialized into the block
8592   * comment delimiter.
8593   *
8594   * When a block exists in memory it contains as its attributes both those
8595   * parsed the block comment delimiter _and_ those which matched from the
8596   * contents of the block.
8597   *
8598   * This function returns only those attributes which are needed to persist and
8599   * which cannot be matched from the block content.
8600   *
8601   * @param {Object<string,*>} blockType  Block type.
8602   * @param {Object<string,*>} attributes Attributes from in-memory block data.
8603   *
8604   * @return {Object<string,*>} Subset of attributes for comment serialization.
8605   */
8606  
8607  function getCommentAttributes(blockType, attributes) {
8608    return (0,external_lodash_namespaceObject.reduce)(blockType.attributes, (accumulator, attributeSchema, key) => {
8609      const value = attributes[key]; // Ignore undefined values.
8610  
8611      if (undefined === value) {
8612        return accumulator;
8613      } // Ignore all attributes but the ones with an "undefined" source
8614      // "undefined" source refers to attributes saved in the block comment.
8615  
8616  
8617      if (attributeSchema.source !== undefined) {
8618        return accumulator;
8619      } // Ignore default value.
8620  
8621  
8622      if ('default' in attributeSchema && attributeSchema.default === value) {
8623        return accumulator;
8624      } // Otherwise, include in comment set.
8625  
8626  
8627      accumulator[key] = value;
8628      return accumulator;
8629    }, {});
8630  }
8631  /**
8632   * Given an attributes object, returns a string in the serialized attributes
8633   * format prepared for post content.
8634   *
8635   * @param {Object} attributes Attributes object.
8636   *
8637   * @return {string} Serialized attributes.
8638   */
8639  
8640  function serializeAttributes(attributes) {
8641    return JSON.stringify(attributes) // Don't break HTML comments.
8642    .replace(/--/g, '\\u002d\\u002d') // Don't break non-standard-compliant tools.
8643    .replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026') // Bypass server stripslashes behavior which would unescape stringify's
8644    // escaping of quotation mark.
8645    //
8646    // See: https://developer.wordpress.org/reference/functions/wp_kses_stripslashes/
8647    .replace(/\\"/g, '\\u0022');
8648  }
8649  /**
8650   * Given a block object, returns the Block's Inner HTML markup.
8651   *
8652   * @param {Object} block Block instance.
8653   *
8654   * @return {string} HTML.
8655   */
8656  
8657  function getBlockInnerHTML(block) {
8658    // If block was parsed as invalid or encounters an error while generating
8659    // save content, use original content instead to avoid content loss. If a
8660    // block contains nested content, exempt it from this condition because we
8661    // otherwise have no access to its original content and content loss would
8662    // still occur.
8663    let saveContent = block.originalContent;
8664  
8665    if (block.isValid || block.innerBlocks.length) {
8666      try {
8667        saveContent = getSaveContent(block.name, block.attributes, block.innerBlocks);
8668      } catch (error) {}
8669    }
8670  
8671    return saveContent;
8672  }
8673  /**
8674   * Returns the content of a block, including comment delimiters.
8675   *
8676   * @param {string} rawBlockName Block name.
8677   * @param {Object} attributes   Block attributes.
8678   * @param {string} content      Block save content.
8679   *
8680   * @return {string} Comment-delimited block content.
8681   */
8682  
8683  function getCommentDelimitedContent(rawBlockName, attributes, content) {
8684    const serializedAttributes = !(0,external_lodash_namespaceObject.isEmpty)(attributes) ? serializeAttributes(attributes) + ' ' : ''; // Strip core blocks of their namespace prefix.
8685  
8686    const blockName = (0,external_lodash_namespaceObject.startsWith)(rawBlockName, 'core/') ? rawBlockName.slice(5) : rawBlockName; // @todo make the `wp:` prefix potentially configurable.
8687  
8688    if (!content) {
8689      return `<!-- wp:$blockName} $serializedAttributes}/-->`;
8690    }
8691  
8692    return `<!-- wp:$blockName} $serializedAttributes}-->\n` + content + `\n<!-- /wp:$blockName} -->`;
8693  }
8694  /**
8695   * Returns the content of a block, including comment delimiters, determining
8696   * serialized attributes and content form from the current state of the block.
8697   *
8698   * @param {WPBlock}                      block   Block instance.
8699   * @param {WPBlockSerializationOptions}  options Serialization options.
8700   *
8701   * @return {string} Serialized block.
8702   */
8703  
8704  function serializeBlock(block) {
8705    let {
8706      isInnerBlocks = false
8707    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
8708  
8709    if (!block.isValid && block.__unstableBlockSource) {
8710      return serializeRawBlock(block.__unstableBlockSource);
8711    }
8712  
8713    const blockName = block.name;
8714    const saveContent = getBlockInnerHTML(block);
8715  
8716    if (blockName === getUnregisteredTypeHandlerName() || !isInnerBlocks && blockName === getFreeformContentHandlerName()) {
8717      return saveContent;
8718    }
8719  
8720    const blockType = registration_getBlockType(blockName);
8721    const saveAttributes = getCommentAttributes(blockType, block.attributes);
8722    return getCommentDelimitedContent(blockName, saveAttributes, saveContent);
8723  }
8724  function __unstableSerializeAndClean(blocks) {
8725    // A single unmodified default block is assumed to
8726    // be equivalent to an empty post.
8727    if (blocks.length === 1 && isUnmodifiedDefaultBlock(blocks[0])) {
8728      blocks = [];
8729    }
8730  
8731    let content = serializer_serialize(blocks); // For compatibility, treat a post consisting of a
8732    // single freeform block as legacy content and apply
8733    // pre-block-editor removep'd content formatting.
8734  
8735    if (blocks.length === 1 && blocks[0].name === getFreeformContentHandlerName()) {
8736      content = (0,external_wp_autop_namespaceObject.removep)(content);
8737    }
8738  
8739    return content;
8740  }
8741  /**
8742   * Takes a block or set of blocks and returns the serialized post content.
8743   *
8744   * @param {Array}                       blocks  Block(s) to serialize.
8745   * @param {WPBlockSerializationOptions} options Serialization options.
8746   *
8747   * @return {string} The post content.
8748   */
8749  
8750  function serializer_serialize(blocks, options) {
8751    return (0,external_lodash_namespaceObject.castArray)(blocks).map(block => serializeBlock(block, options)).join('\n\n');
8752  }
8753  
8754  ;// CONCATENATED MODULE: ./node_modules/simple-html-tokenizer/dist/es6/index.js
8755  /**
8756   * generated from https://raw.githubusercontent.com/w3c/html/26b5126f96f736f796b9e29718138919dd513744/entities.json
8757   * do not edit
8758   */
8759  var namedCharRefs = {
8760      Aacute: "Á", aacute: "á", Abreve: "Ă", abreve: "ă", ac: "∾", acd: "∿", acE: "∾̳", Acirc: "Â", acirc: "â", acute: "´", Acy: "А", acy: "а", AElig: "Æ", aelig: "æ", af: "\u2061", Afr: "𝔄", afr: "𝔞", Agrave: "À", agrave: "à", alefsym: "ℵ", aleph: "ℵ", Alpha: "Α", alpha: "α", Amacr: "Ā", amacr: "ā", amalg: "⨿", amp: "&", AMP: "&", andand: "⩕", And: "⩓", and: "∧", andd: "⩜", andslope: "⩘", andv: "⩚", ang: "∠", ange: "⦤", angle: "∠", angmsdaa: "⦨", angmsdab: "⦩", angmsdac: "⦪", angmsdad: "⦫", angmsdae: "⦬", angmsdaf: "⦭", angmsdag: "⦮", angmsdah: "⦯", angmsd: "∡", angrt: "∟", angrtvb: "⊾", angrtvbd: "⦝", angsph: "∢", angst: "Å", angzarr: "⍼", Aogon: "Ą", aogon: "ą", Aopf: "𝔸", aopf: "𝕒", apacir: "⩯", ap: "≈", apE: "⩰", ape: "≊", apid: "≋", apos: "'", ApplyFunction: "\u2061", approx: "≈", approxeq: "≊", Aring: "Å", aring: "å", Ascr: "𝒜", ascr: "𝒶", Assign: "≔", ast: "*", asymp: "≈", asympeq: "≍", Atilde: "Ã", atilde: "ã", Auml: "Ä", auml: "ä", awconint: "∳", awint: "⨑", backcong: "≌", backepsilon: "϶", backprime: "‵", backsim: "∽", backsimeq: "⋍", Backslash: "∖", Barv: "⫧", barvee: "⊽", barwed: "⌅", Barwed: "⌆", barwedge: "⌅", bbrk: "⎵", bbrktbrk: "⎶", bcong: "≌", Bcy: "Б", bcy: "б", bdquo: "„", becaus: "∵", because: "∵", Because: "∵", bemptyv: "⦰", bepsi: "϶", bernou: "ℬ", Bernoullis: "ℬ", Beta: "Β", beta: "β", beth: "ℶ", between: "≬", Bfr: "𝔅", bfr: "𝔟", bigcap: "⋂", bigcirc: "◯", bigcup: "⋃", bigodot: "⨀", bigoplus: "⨁", bigotimes: "⨂", bigsqcup: "⨆", bigstar: "★", bigtriangledown: "▽", bigtriangleup: "△", biguplus: "⨄", bigvee: "⋁", bigwedge: "⋀", bkarow: "⤍", blacklozenge: "⧫", blacksquare: "▪", blacktriangle: "▴", blacktriangledown: "▾", blacktriangleleft: "◂", blacktriangleright: "▸", blank: "␣", blk12: "▒", blk14: "░", blk34: "▓", block: "█", bne: "=⃥", bnequiv: "≡⃥", bNot: "⫭", bnot: "⌐", Bopf: "𝔹", bopf: "𝕓", bot: "⊥", bottom: "⊥", bowtie: "⋈", boxbox: "⧉", boxdl: "┐", boxdL: "╕", boxDl: "╖", boxDL: "╗", boxdr: "┌", boxdR: "╒", boxDr: "╓", boxDR: "╔", boxh: "─", boxH: "═", boxhd: "┬", boxHd: "╤", boxhD: "╥", boxHD: "╦", boxhu: "┴", boxHu: "╧", boxhU: "╨", boxHU: "╩", boxminus: "⊟", boxplus: "⊞", boxtimes: "⊠", boxul: "┘", boxuL: "╛", boxUl: "╜", boxUL: "╝", boxur: "└", boxuR: "╘", boxUr: "╙", boxUR: "╚", boxv: "│", boxV: "║", boxvh: "┼", boxvH: "╪", boxVh: "╫", boxVH: "╬", boxvl: "┤", boxvL: "╡", boxVl: "╢", boxVL: "╣", boxvr: "├", boxvR: "╞", boxVr: "╟", boxVR: "╠", bprime: "‵", breve: "˘", Breve: "˘", brvbar: "¦", bscr: "𝒷", Bscr: "ℬ", bsemi: "⁏", bsim: "∽", bsime: "⋍", bsolb: "⧅", bsol: "\\", bsolhsub: "⟈", bull: "•", bullet: "•", bump: "≎", bumpE: "⪮", bumpe: "≏", Bumpeq: "≎", bumpeq: "≏", Cacute: "Ć", cacute: "ć", capand: "⩄", capbrcup: "⩉", capcap: "⩋", cap: "∩", Cap: "⋒", capcup: "⩇", capdot: "⩀", CapitalDifferentialD: "ⅅ", caps: "∩︀", caret: "⁁", caron: "ˇ", Cayleys: "ℭ", ccaps: "⩍", Ccaron: "Č", ccaron: "č", Ccedil: "Ç", ccedil: "ç", Ccirc: "Ĉ", ccirc: "ĉ", Cconint: "∰", ccups: "⩌", ccupssm: "⩐", Cdot: "Ċ", cdot: "ċ", cedil: "¸", Cedilla: "¸", cemptyv: "⦲", cent: "¢", centerdot: "·", CenterDot: "·", cfr: "𝔠", Cfr: "ℭ", CHcy: "Ч", chcy: "ч", check: "✓", checkmark: "✓", Chi: "Χ", chi: "χ", circ: "ˆ", circeq: "≗", circlearrowleft: "↺", circlearrowright: "↻", circledast: "⊛", circledcirc: "⊚", circleddash: "⊝", CircleDot: "⊙", circledR: "®", circledS: "Ⓢ", CircleMinus: "⊖", CirclePlus: "⊕", CircleTimes: "⊗", cir: "○", cirE: "⧃", cire: "≗", cirfnint: "⨐", cirmid: "⫯", cirscir: "⧂", ClockwiseContourIntegral: "∲", CloseCurlyDoubleQuote: "”", CloseCurlyQuote: "’", clubs: "♣", clubsuit: "♣", colon: ":", Colon: "∷", Colone: "⩴", colone: "≔", coloneq: "≔", comma: ",", commat: "@", comp: "∁", compfn: "∘", complement: "∁", complexes: "ℂ", cong: "≅", congdot: "⩭", Congruent: "≡", conint: "∮", Conint: "∯", ContourIntegral: "∮", copf: "𝕔", Copf: "ℂ", coprod: "∐", Coproduct: "∐", copy: "©", COPY: "©", copysr: "℗", CounterClockwiseContourIntegral: "∳", crarr: "↵", cross: "✗", Cross: "⨯", Cscr: "𝒞", cscr: "𝒸", csub: "⫏", csube: "⫑", csup: "⫐", csupe: "⫒", ctdot: "⋯", cudarrl: "⤸", cudarrr: "⤵", cuepr: "⋞", cuesc: "⋟", cularr: "↶", cularrp: "⤽", cupbrcap: "⩈", cupcap: "⩆", CupCap: "≍", cup: "∪", Cup: "⋓", cupcup: "⩊", cupdot: "⊍", cupor: "⩅", cups: "∪︀", curarr: "↷", curarrm: "⤼", curlyeqprec: "⋞", curlyeqsucc: "⋟", curlyvee: "⋎", curlywedge: "⋏", curren: "¤", curvearrowleft: "↶", curvearrowright: "↷", cuvee: "⋎", cuwed: "⋏", cwconint: "∲", cwint: "∱", cylcty: "⌭", dagger: "†", Dagger: "‡", daleth: "ℸ", darr: "↓", Darr: "↡", dArr: "⇓", dash: "‐", Dashv: "⫤", dashv: "⊣", dbkarow: "⤏", dblac: "˝", Dcaron: "Ď", dcaron: "ď", Dcy: "Д", dcy: "д", ddagger: "‡", ddarr: "⇊", DD: "ⅅ", dd: "ⅆ", DDotrahd: "⤑", ddotseq: "⩷", deg: "°", Del: "∇", Delta: "Δ", delta: "δ", demptyv: "⦱", dfisht: "⥿", Dfr: "𝔇", dfr: "𝔡", dHar: "⥥", dharl: "⇃", dharr: "⇂", DiacriticalAcute: "´", DiacriticalDot: "˙", DiacriticalDoubleAcute: "˝", DiacriticalGrave: "`", DiacriticalTilde: "˜", diam: "⋄", diamond: "⋄", Diamond: "⋄", diamondsuit: "♦", diams: "♦", die: "¨", DifferentialD: "ⅆ", digamma: "ϝ", disin: "⋲", div: "÷", divide: "÷", divideontimes: "⋇", divonx: "⋇", DJcy: "Ђ", djcy: "ђ", dlcorn: "⌞", dlcrop: "⌍", dollar: "$", Dopf: "𝔻", dopf: "𝕕", Dot: "¨", dot: "˙", DotDot: "⃜", doteq: "≐", doteqdot: "≑", DotEqual: "≐", dotminus: "∸", dotplus: "∔", dotsquare: "⊡", doublebarwedge: "⌆", DoubleContourIntegral: "∯", DoubleDot: "¨", DoubleDownArrow: "⇓", DoubleLeftArrow: "⇐", DoubleLeftRightArrow: "⇔", DoubleLeftTee: "⫤", DoubleLongLeftArrow: "⟸", DoubleLongLeftRightArrow: "⟺", DoubleLongRightArrow: "⟹", DoubleRightArrow: "⇒", DoubleRightTee: "⊨", DoubleUpArrow: "⇑", DoubleUpDownArrow: "⇕", DoubleVerticalBar: "∥", DownArrowBar: "⤓", downarrow: "↓", DownArrow: "↓", Downarrow: "⇓", DownArrowUpArrow: "⇵", DownBreve: "̑", downdownarrows: "⇊", downharpoonleft: "⇃", downharpoonright: "⇂", DownLeftRightVector: "⥐", DownLeftTeeVector: "⥞", DownLeftVectorBar: "⥖", DownLeftVector: "↽", DownRightTeeVector: "⥟", DownRightVectorBar: "⥗", DownRightVector: "⇁", DownTeeArrow: "↧", DownTee: "⊤", drbkarow: "⤐", drcorn: "⌟", drcrop: "⌌", Dscr: "𝒟", dscr: "𝒹", DScy: "Ѕ", dscy: "ѕ", dsol: "⧶", Dstrok: "Đ", dstrok: "đ", dtdot: "⋱", dtri: "▿", dtrif: "▾", duarr: "⇵", duhar: "⥯", dwangle: "⦦", DZcy: "Џ", dzcy: "џ", dzigrarr: "⟿", Eacute: "É", eacute: "é", easter: "⩮", Ecaron: "Ě", ecaron: "ě", Ecirc: "Ê", ecirc: "ê", ecir: "≖", ecolon: "≕", Ecy: "Э", ecy: "э", eDDot: "⩷", Edot: "Ė", edot: "ė", eDot: "≑", ee: "ⅇ", efDot: "≒", Efr: "𝔈", efr: "𝔢", eg: "⪚", Egrave: "È", egrave: "è", egs: "⪖", egsdot: "⪘", el: "⪙", Element: "∈", elinters: "⏧", ell: "ℓ", els: "⪕", elsdot: "⪗", Emacr: "Ē", emacr: "ē", empty: "∅", emptyset: "∅", EmptySmallSquare: "◻", emptyv: "∅", EmptyVerySmallSquare: "▫", emsp13: " ", emsp14: " ", emsp: " ", ENG: "Ŋ", eng: "ŋ", ensp: " ", Eogon: "Ę", eogon: "ę", Eopf: "𝔼", eopf: "𝕖", epar: "⋕", eparsl: "⧣", eplus: "⩱", epsi: "ε", Epsilon: "Ε", epsilon: "ε", epsiv: "ϵ", eqcirc: "≖", eqcolon: "≕", eqsim: "≂", eqslantgtr: "⪖", eqslantless: "⪕", Equal: "⩵", equals: "=", EqualTilde: "≂", equest: "≟", Equilibrium: "⇌", equiv: "≡", equivDD: "⩸", eqvparsl: "⧥", erarr: "⥱", erDot: "≓", escr: "ℯ", Escr: "ℰ", esdot: "≐", Esim: "⩳", esim: "≂", Eta: "Η", eta: "η", ETH: "Ð", eth: "ð", Euml: "Ë", euml: "ë", euro: "€", excl: "!", exist: "∃", Exists: "∃", expectation: "ℰ", exponentiale: "ⅇ", ExponentialE: "ⅇ", fallingdotseq: "≒", Fcy: "Ф", fcy: "ф", female: "♀", ffilig: "ffi", fflig: "ff", ffllig: "ffl", Ffr: "𝔉", ffr: "𝔣", filig: "fi", FilledSmallSquare: "◼", FilledVerySmallSquare: "▪", fjlig: "fj", flat: "♭", fllig: "fl", fltns: "▱", fnof: "ƒ", Fopf: "𝔽", fopf: "𝕗", forall: "∀", ForAll: "∀", fork: "⋔", forkv: "⫙", Fouriertrf: "ℱ", fpartint: "⨍", frac12: "½", frac13: "⅓", frac14: "¼", frac15: "⅕", frac16: "⅙", frac18: "⅛", frac23: "⅔", frac25: "⅖", frac34: "¾", frac35: "⅗", frac38: "⅜", frac45: "⅘", frac56: "⅚", frac58: "⅝", frac78: "⅞", frasl: "⁄", frown: "⌢", fscr: "𝒻", Fscr: "ℱ", gacute: "ǵ", Gamma: "Γ", gamma: "γ", Gammad: "Ϝ", gammad: "ϝ", gap: "⪆", Gbreve: "Ğ", gbreve: "ğ", Gcedil: "Ģ", Gcirc: "Ĝ", gcirc: "ĝ", Gcy: "Г", gcy: "г", Gdot: "Ġ", gdot: "ġ", ge: "≥", gE: "≧", gEl: "⪌", gel: "⋛", geq: "≥", geqq: "≧", geqslant: "⩾", gescc: "⪩", ges: "⩾", gesdot: "⪀", gesdoto: "⪂", gesdotol: "⪄", gesl: "⋛︀", gesles: "⪔", Gfr: "𝔊", gfr: "𝔤", gg: "≫", Gg: "⋙", ggg: "⋙", gimel: "ℷ", GJcy: "Ѓ", gjcy: "ѓ", gla: "⪥", gl: "≷", glE: "⪒", glj: "⪤", gnap: "⪊", gnapprox: "⪊", gne: "⪈", gnE: "≩", gneq: "⪈", gneqq: "≩", gnsim: "⋧", Gopf: "𝔾", gopf: "𝕘", grave: "`", GreaterEqual: "≥", GreaterEqualLess: "⋛", GreaterFullEqual: "≧", GreaterGreater: "⪢", GreaterLess: "≷", GreaterSlantEqual: "⩾", GreaterTilde: "≳", Gscr: "𝒢", gscr: "ℊ", gsim: "≳", gsime: "⪎", gsiml: "⪐", gtcc: "⪧", gtcir: "⩺", gt: ">", GT: ">", Gt: "≫", gtdot: "⋗", gtlPar: "⦕", gtquest: "⩼", gtrapprox: "⪆", gtrarr: "⥸", gtrdot: "⋗", gtreqless: "⋛", gtreqqless: "⪌", gtrless: "≷", gtrsim: "≳", gvertneqq: "≩︀", gvnE: "≩︀", Hacek: "ˇ", hairsp: " ", half: "½", hamilt: "ℋ", HARDcy: "Ъ", hardcy: "ъ", harrcir: "⥈", harr: "↔", hArr: "⇔", harrw: "↭", Hat: "^", hbar: "ℏ", Hcirc: "Ĥ", hcirc: "ĥ", hearts: "♥", heartsuit: "♥", hellip: "…", hercon: "⊹", hfr: "𝔥", Hfr: "ℌ", HilbertSpace: "ℋ", hksearow: "⤥", hkswarow: "⤦", hoarr: "⇿", homtht: "∻", hookleftarrow: "↩", hookrightarrow: "↪", hopf: "𝕙", Hopf: "ℍ", horbar: "―", HorizontalLine: "─", hscr: "𝒽", Hscr: "ℋ", hslash: "ℏ", Hstrok: "Ħ", hstrok: "ħ", HumpDownHump: "≎", HumpEqual: "≏", hybull: "⁃", hyphen: "‐", Iacute: "Í", iacute: "í", ic: "\u2063", Icirc: "Î", icirc: "î", Icy: "И", icy: "и", Idot: "İ", IEcy: "Е", iecy: "е", iexcl: "¡", iff: "⇔", ifr: "𝔦", Ifr: "ℑ", Igrave: "Ì", igrave: "ì", ii: "ⅈ", iiiint: "⨌", iiint: "∭", iinfin: "⧜", iiota: "℩", IJlig: "IJ", ijlig: "ij", Imacr: "Ī", imacr: "ī", image: "ℑ", ImaginaryI: "ⅈ", imagline: "ℐ", imagpart: "ℑ", imath: "ı", Im: "ℑ", imof: "⊷", imped: "Ƶ", Implies: "⇒", incare: "℅", in: "∈", infin: "∞", infintie: "⧝", inodot: "ı", intcal: "⊺", int: "∫", Int: "∬", integers: "ℤ", Integral: "∫", intercal: "⊺", Intersection: "⋂", intlarhk: "⨗", intprod: "⨼", InvisibleComma: "\u2063", InvisibleTimes: "\u2062", IOcy: "Ё", iocy: "ё", Iogon: "Į", iogon: "į", Iopf: "𝕀", iopf: "𝕚", Iota: "Ι", iota: "ι", iprod: "⨼", iquest: "¿", iscr: "𝒾", Iscr: "ℐ", isin: "∈", isindot: "⋵", isinE: "⋹", isins: "⋴", isinsv: "⋳", isinv: "∈", it: "\u2062", Itilde: "Ĩ", itilde: "ĩ", Iukcy: "І", iukcy: "і", Iuml: "Ï", iuml: "ï", Jcirc: "Ĵ", jcirc: "ĵ", Jcy: "Й", jcy: "й", Jfr: "𝔍", jfr: "𝔧", jmath: "ȷ", Jopf: "𝕁", jopf: "𝕛", Jscr: "𝒥", jscr: "𝒿", Jsercy: "Ј", jsercy: "ј", Jukcy: "Є", jukcy: "є", Kappa: "Κ", kappa: "κ", kappav: "ϰ", Kcedil: "Ķ", kcedil: "ķ", Kcy: "К", kcy: "к", Kfr: "𝔎", kfr: "𝔨", kgreen: "ĸ", KHcy: "Х", khcy: "х", KJcy: "Ќ", kjcy: "ќ", Kopf: "𝕂", kopf: "𝕜", Kscr: "𝒦", kscr: "𝓀", lAarr: "⇚", Lacute: "Ĺ", lacute: "ĺ", laemptyv: "⦴", lagran: "ℒ", Lambda: "Λ", lambda: "λ", lang: "⟨", Lang: "⟪", langd: "⦑", langle: "⟨", lap: "⪅", Laplacetrf: "ℒ", laquo: "«", larrb: "⇤", larrbfs: "⤟", larr: "←", Larr: "↞", lArr: "⇐", larrfs: "⤝", larrhk: "↩", larrlp: "↫", larrpl: "⤹", larrsim: "⥳", larrtl: "↢", latail: "⤙", lAtail: "⤛", lat: "⪫", late: "⪭", lates: "⪭︀", lbarr: "⤌", lBarr: "⤎", lbbrk: "❲", lbrace: "{", lbrack: "[", lbrke: "⦋", lbrksld: "⦏", lbrkslu: "⦍", Lcaron: "Ľ", lcaron: "ľ", Lcedil: "Ļ", lcedil: "ļ", lceil: "⌈", lcub: "{", Lcy: "Л", lcy: "л", ldca: "⤶", ldquo: "“", ldquor: "„", ldrdhar: "⥧", ldrushar: "⥋", ldsh: "↲", le: "≤", lE: "≦", LeftAngleBracket: "⟨", LeftArrowBar: "⇤", leftarrow: "←", LeftArrow: "←", Leftarrow: "⇐", LeftArrowRightArrow: "⇆", leftarrowtail: "↢", LeftCeiling: "⌈", LeftDoubleBracket: "⟦", LeftDownTeeVector: "⥡", LeftDownVectorBar: "⥙", LeftDownVector: "⇃", LeftFloor: "⌊", leftharpoondown: "↽", leftharpoonup: "↼", leftleftarrows: "⇇", leftrightarrow: "↔", LeftRightArrow: "↔", Leftrightarrow: "⇔", leftrightarrows: "⇆", leftrightharpoons: "⇋", leftrightsquigarrow: "↭", LeftRightVector: "⥎", LeftTeeArrow: "↤", LeftTee: "⊣", LeftTeeVector: "⥚", leftthreetimes: "⋋", LeftTriangleBar: "⧏", LeftTriangle: "⊲", LeftTriangleEqual: "⊴", LeftUpDownVector: "⥑", LeftUpTeeVector: "⥠", LeftUpVectorBar: "⥘", LeftUpVector: "↿", LeftVectorBar: "⥒", LeftVector: "↼", lEg: "⪋", leg: "⋚", leq: "≤", leqq: "≦", leqslant: "⩽", lescc: "⪨", les: "⩽", lesdot: "⩿", lesdoto: "⪁", lesdotor: "⪃", lesg: "⋚︀", lesges: "⪓", lessapprox: "⪅", lessdot: "⋖", lesseqgtr: "⋚", lesseqqgtr: "⪋", LessEqualGreater: "⋚", LessFullEqual: "≦", LessGreater: "≶", lessgtr: "≶", LessLess: "⪡", lesssim: "≲", LessSlantEqual: "⩽", LessTilde: "≲", lfisht: "⥼", lfloor: "⌊", Lfr: "𝔏", lfr: "𝔩", lg: "≶", lgE: "⪑", lHar: "⥢", lhard: "↽", lharu: "↼", lharul: "⥪", lhblk: "▄", LJcy: "Љ", ljcy: "љ", llarr: "⇇", ll: "≪", Ll: "⋘", llcorner: "⌞", Lleftarrow: "⇚", llhard: "⥫", lltri: "◺", Lmidot: "Ŀ", lmidot: "ŀ", lmoustache: "⎰", lmoust: "⎰", lnap: "⪉", lnapprox: "⪉", lne: "⪇", lnE: "≨", lneq: "⪇", lneqq: "≨", lnsim: "⋦", loang: "⟬", loarr: "⇽", lobrk: "⟦", longleftarrow: "⟵", LongLeftArrow: "⟵", Longleftarrow: "⟸", longleftrightarrow: "⟷", LongLeftRightArrow: "⟷", Longleftrightarrow: "⟺", longmapsto: "⟼", longrightarrow: "⟶", LongRightArrow: "⟶", Longrightarrow: "⟹", looparrowleft: "↫", looparrowright: "↬", lopar: "⦅", Lopf: "𝕃", lopf: "𝕝", loplus: "⨭", lotimes: "⨴", lowast: "∗", lowbar: "_", LowerLeftArrow: "↙", LowerRightArrow: "↘", loz: "◊", lozenge: "◊", lozf: "⧫", lpar: "(", lparlt: "⦓", lrarr: "⇆", lrcorner: "⌟", lrhar: "⇋", lrhard: "⥭", lrm: "\u200e", lrtri: "⊿", lsaquo: "‹", lscr: "𝓁", Lscr: "ℒ", lsh: "↰", Lsh: "↰", lsim: "≲", lsime: "⪍", lsimg: "⪏", lsqb: "[", lsquo: "‘", lsquor: "‚", Lstrok: "Ł", lstrok: "ł", ltcc: "⪦", ltcir: "⩹", lt: "<", LT: "<", Lt: "≪", ltdot: "⋖", lthree: "⋋", ltimes: "⋉", ltlarr: "⥶", ltquest: "⩻", ltri: "◃", ltrie: "⊴", ltrif: "◂", ltrPar: "⦖", lurdshar: "⥊", luruhar: "⥦", lvertneqq: "≨︀", lvnE: "≨︀", macr: "¯", male: "♂", malt: "✠", maltese: "✠", Map: "⤅", map: "↦", mapsto: "↦", mapstodown: "↧", mapstoleft: "↤", mapstoup: "↥", marker: "▮", mcomma: "⨩", Mcy: "М", mcy: "м", mdash: "—", mDDot: "∺", measuredangle: "∡", MediumSpace: " ", Mellintrf: "ℳ", Mfr: "𝔐", mfr: "𝔪", mho: "℧", micro: "µ", midast: "*", midcir: "⫰", mid: "∣", middot: "·", minusb: "⊟", minus: "−", minusd: "∸", minusdu: "⨪", MinusPlus: "∓", mlcp: "⫛", mldr: "…", mnplus: "∓", models: "⊧", Mopf: "𝕄", mopf: "𝕞", mp: "∓", mscr: "𝓂", Mscr: "ℳ", mstpos: "∾", Mu: "Μ", mu: "μ", multimap: "⊸", mumap: "⊸", nabla: "∇", Nacute: "Ń", nacute: "ń", nang: "∠⃒", nap: "≉", napE: "⩰̸", napid: "≋̸", napos: "ʼn", napprox: "≉", natural: "♮", naturals: "ℕ", natur: "♮", nbsp: " ", nbump: "≎̸", nbumpe: "≏̸", ncap: "⩃", Ncaron: "Ň", ncaron: "ň", Ncedil: "Ņ", ncedil: "ņ", ncong: "≇", ncongdot: "⩭̸", ncup: "⩂", Ncy: "Н", ncy: "н", ndash: "–", nearhk: "⤤", nearr: "↗", neArr: "⇗", nearrow: "↗", ne: "≠", nedot: "≐̸", NegativeMediumSpace: "​", NegativeThickSpace: "​", NegativeThinSpace: "​", NegativeVeryThinSpace: "​", nequiv: "≢", nesear: "⤨", nesim: "≂̸", NestedGreaterGreater: "≫", NestedLessLess: "≪", NewLine: "\u000a", nexist: "∄", nexists: "∄", Nfr: "𝔑", nfr: "𝔫", ngE: "≧̸", nge: "≱", ngeq: "≱", ngeqq: "≧̸", ngeqslant: "⩾̸", nges: "⩾̸", nGg: "⋙̸", ngsim: "≵", nGt: "≫⃒", ngt: "≯", ngtr: "≯", nGtv: "≫̸", nharr: "↮", nhArr: "⇎", nhpar: "⫲", ni: "∋", nis: "⋼", nisd: "⋺", niv: "∋", NJcy: "Њ", njcy: "њ", nlarr: "↚", nlArr: "⇍", nldr: "‥", nlE: "≦̸", nle: "≰", nleftarrow: "↚", nLeftarrow: "⇍", nleftrightarrow: "↮", nLeftrightarrow: "⇎", nleq: "≰", nleqq: "≦̸", nleqslant: "⩽̸", nles: "⩽̸", nless: "≮", nLl: "⋘̸", nlsim: "≴", nLt: "≪⃒", nlt: "≮", nltri: "⋪", nltrie: "⋬", nLtv: "≪̸", nmid: "∤", NoBreak: "\u2060", NonBreakingSpace: " ", nopf: "𝕟", Nopf: "ℕ", Not: "⫬", not: "¬", NotCongruent: "≢", NotCupCap: "≭", NotDoubleVerticalBar: "∦", NotElement: "∉", NotEqual: "≠", NotEqualTilde: "≂̸", NotExists: "∄", NotGreater: "≯", NotGreaterEqual: "≱", NotGreaterFullEqual: "≧̸", NotGreaterGreater: "≫̸", NotGreaterLess: "≹", NotGreaterSlantEqual: "⩾̸", NotGreaterTilde: "≵", NotHumpDownHump: "≎̸", NotHumpEqual: "≏̸", notin: "∉", notindot: "⋵̸", notinE: "⋹̸", notinva: "∉", notinvb: "⋷", notinvc: "⋶", NotLeftTriangleBar: "⧏̸", NotLeftTriangle: "⋪", NotLeftTriangleEqual: "⋬", NotLess: "≮", NotLessEqual: "≰", NotLessGreater: "≸", NotLessLess: "≪̸", NotLessSlantEqual: "⩽̸", NotLessTilde: "≴", NotNestedGreaterGreater: "⪢̸", NotNestedLessLess: "⪡̸", notni: "∌", notniva: "∌", notnivb: "⋾", notnivc: "⋽", NotPrecedes: "⊀", NotPrecedesEqual: "⪯̸", NotPrecedesSlantEqual: "⋠", NotReverseElement: "∌", NotRightTriangleBar: "⧐̸", NotRightTriangle: "⋫", NotRightTriangleEqual: "⋭", NotSquareSubset: "⊏̸", NotSquareSubsetEqual: "⋢", NotSquareSuperset: "⊐̸", NotSquareSupersetEqual: "⋣", NotSubset: "⊂⃒", NotSubsetEqual: "⊈", NotSucceeds: "⊁", NotSucceedsEqual: "⪰̸", NotSucceedsSlantEqual: "⋡", NotSucceedsTilde: "≿̸", NotSuperset: "⊃⃒", NotSupersetEqual: "⊉", NotTilde: "≁", NotTildeEqual: "≄", NotTildeFullEqual: "≇", NotTildeTilde: "≉", NotVerticalBar: "∤", nparallel: "∦", npar: "∦", nparsl: "⫽⃥", npart: "∂̸", npolint: "⨔", npr: "⊀", nprcue: "⋠", nprec: "⊀", npreceq: "⪯̸", npre: "⪯̸", nrarrc: "⤳̸", nrarr: "↛", nrArr: "⇏", nrarrw: "↝̸", nrightarrow: "↛", nRightarrow: "⇏", nrtri: "⋫", nrtrie: "⋭", nsc: "⊁", nsccue: "⋡", nsce: "⪰̸", Nscr: "𝒩", nscr: "𝓃", nshortmid: "∤", nshortparallel: "∦", nsim: "≁", nsime: "≄", nsimeq: "≄", nsmid: "∤", nspar: "∦", nsqsube: "⋢", nsqsupe: "⋣", nsub: "⊄", nsubE: "⫅̸", nsube: "⊈", nsubset: "⊂⃒", nsubseteq: "⊈", nsubseteqq: "⫅̸", nsucc: "⊁", nsucceq: "⪰̸", nsup: "⊅", nsupE: "⫆̸", nsupe: "⊉", nsupset: "⊃⃒", nsupseteq: "⊉", nsupseteqq: "⫆̸", ntgl: "≹", Ntilde: "Ñ", ntilde: "ñ", ntlg: "≸", ntriangleleft: "⋪", ntrianglelefteq: "⋬", ntriangleright: "⋫", ntrianglerighteq: "⋭", Nu: "Ν", nu: "ν", num: "#", numero: "№", numsp: " ", nvap: "≍⃒", nvdash: "⊬", nvDash: "⊭", nVdash: "⊮", nVDash: "⊯", nvge: "≥⃒", nvgt: ">⃒", nvHarr: "⤄", nvinfin: "⧞", nvlArr: "⤂", nvle: "≤⃒", nvlt: "<⃒", nvltrie: "⊴⃒", nvrArr: "⤃", nvrtrie: "⊵⃒", nvsim: "∼⃒", nwarhk: "⤣", nwarr: "↖", nwArr: "⇖", nwarrow: "↖", nwnear: "⤧", Oacute: "Ó", oacute: "ó", oast: "⊛", Ocirc: "Ô", ocirc: "ô", ocir: "⊚", Ocy: "О", ocy: "о", odash: "⊝", Odblac: "Ő", odblac: "ő", odiv: "⨸", odot: "⊙", odsold: "⦼", OElig: "Œ", oelig: "œ", ofcir: "⦿", Ofr: "𝔒", ofr: "𝔬", ogon: "˛", Ograve: "Ò", ograve: "ò", ogt: "⧁", ohbar: "⦵", ohm: "Ω", oint: "∮", olarr: "↺", olcir: "⦾", olcross: "⦻", oline: "‾", olt: "⧀", Omacr: "Ō", omacr: "ō", Omega: "Ω", omega: "ω", Omicron: "Ο", omicron: "ο", omid: "⦶", ominus: "⊖", Oopf: "𝕆", oopf: "𝕠", opar: "⦷", OpenCurlyDoubleQuote: "“", OpenCurlyQuote: "‘", operp: "⦹", oplus: "⊕", orarr: "↻", Or: "⩔", or: "∨", ord: "⩝", order: "ℴ", orderof: "ℴ", ordf: "ª", ordm: "º", origof: "⊶", oror: "⩖", orslope: "⩗", orv: "⩛", oS: "Ⓢ", Oscr: "𝒪", oscr: "ℴ", Oslash: "Ø", oslash: "ø", osol: "⊘", Otilde: "Õ", otilde: "õ", otimesas: "⨶", Otimes: "⨷", otimes: "⊗", Ouml: "Ö", ouml: "ö", ovbar: "⌽", OverBar: "‾", OverBrace: "⏞", OverBracket: "⎴", OverParenthesis: "⏜", para: "¶", parallel: "∥", par: "∥", parsim: "⫳", parsl: "⫽", part: "∂", PartialD: "∂", Pcy: "П", pcy: "п", percnt: "%", period: ".", permil: "‰", perp: "⊥", pertenk: "‱", Pfr: "𝔓", pfr: "𝔭", Phi: "Φ", phi: "φ", phiv: "ϕ", phmmat: "ℳ", phone: "☎", Pi: "Π", pi: "π", pitchfork: "⋔", piv: "ϖ", planck: "ℏ", planckh: "ℎ", plankv: "ℏ", plusacir: "⨣", plusb: "⊞", pluscir: "⨢", plus: "+", plusdo: "∔", plusdu: "⨥", pluse: "⩲", PlusMinus: "±", plusmn: "±", plussim: "⨦", plustwo: "⨧", pm: "±", Poincareplane: "ℌ", pointint: "⨕", popf: "𝕡", Popf: "ℙ", pound: "£", prap: "⪷", Pr: "⪻", pr: "≺", prcue: "≼", precapprox: "⪷", prec: "≺", preccurlyeq: "≼", Precedes: "≺", PrecedesEqual: "⪯", PrecedesSlantEqual: "≼", PrecedesTilde: "≾", preceq: "⪯", precnapprox: "⪹", precneqq: "⪵", precnsim: "⋨", pre: "⪯", prE: "⪳", precsim: "≾", prime: "′", Prime: "″", primes: "ℙ", prnap: "⪹", prnE: "⪵", prnsim: "⋨", prod: "∏", Product: "∏", profalar: "⌮", profline: "⌒", profsurf: "⌓", prop: "∝", Proportional: "∝", Proportion: "∷", propto: "∝", prsim: "≾", prurel: "⊰", Pscr: "𝒫", pscr: "𝓅", Psi: "Ψ", psi: "ψ", puncsp: " ", Qfr: "𝔔", qfr: "𝔮", qint: "⨌", qopf: "𝕢", Qopf: "ℚ", qprime: "⁗", Qscr: "𝒬", qscr: "𝓆", quaternions: "ℍ", quatint: "⨖", quest: "?", questeq: "≟", quot: "\"", QUOT: "\"", rAarr: "⇛", race: "∽̱", Racute: "Ŕ", racute: "ŕ", radic: "√", raemptyv: "⦳", rang: "⟩", Rang: "⟫", rangd: "⦒", range: "⦥", rangle: "⟩", raquo: "»", rarrap: "⥵", rarrb: "⇥", rarrbfs: "⤠", rarrc: "⤳", rarr: "→", Rarr: "↠", rArr: "⇒", rarrfs: "⤞", rarrhk: "↪", rarrlp: "↬", rarrpl: "⥅", rarrsim: "⥴", Rarrtl: "⤖", rarrtl: "↣", rarrw: "↝", ratail: "⤚", rAtail: "⤜", ratio: "∶", rationals: "ℚ", rbarr: "⤍", rBarr: "⤏", RBarr: "⤐", rbbrk: "❳", rbrace: "}", rbrack: "]", rbrke: "⦌", rbrksld: "⦎", rbrkslu: "⦐", Rcaron: "Ř", rcaron: "ř", Rcedil: "Ŗ", rcedil: "ŗ", rceil: "⌉", rcub: "}", Rcy: "Р", rcy: "р", rdca: "⤷", rdldhar: "⥩", rdquo: "”", rdquor: "”", rdsh: "↳", real: "ℜ", realine: "ℛ", realpart: "ℜ", reals: "ℝ", Re: "ℜ", rect: "▭", reg: "®", REG: "®", ReverseElement: "∋", ReverseEquilibrium: "⇋", ReverseUpEquilibrium: "⥯", rfisht: "⥽", rfloor: "⌋", rfr: "𝔯", Rfr: "ℜ", rHar: "⥤", rhard: "⇁", rharu: "⇀", rharul: "⥬", Rho: "Ρ", rho: "ρ", rhov: "ϱ", RightAngleBracket: "⟩", RightArrowBar: "⇥", rightarrow: "→", RightArrow: "→", Rightarrow: "⇒", RightArrowLeftArrow: "⇄", rightarrowtail: "↣", RightCeiling: "⌉", RightDoubleBracket: "⟧", RightDownTeeVector: "⥝", RightDownVectorBar: "⥕", RightDownVector: "⇂", RightFloor: "⌋", rightharpoondown: "⇁", rightharpoonup: "⇀", rightleftarrows: "⇄", rightleftharpoons: "⇌", rightrightarrows: "⇉", rightsquigarrow: "↝", RightTeeArrow: "↦", RightTee: "⊢", RightTeeVector: "⥛", rightthreetimes: "⋌", RightTriangleBar: "⧐", RightTriangle: "⊳", RightTriangleEqual: "⊵", RightUpDownVector: "⥏", RightUpTeeVector: "⥜", RightUpVectorBar: "⥔", RightUpVector: "↾", RightVectorBar: "⥓", RightVector: "⇀", ring: "˚", risingdotseq: "≓", rlarr: "⇄", rlhar: "⇌", rlm: "\u200f", rmoustache: "⎱", rmoust: "⎱", rnmid: "⫮", roang: "⟭", roarr: "⇾", robrk: "⟧", ropar: "⦆", ropf: "𝕣", Ropf: "ℝ", roplus: "⨮", rotimes: "⨵", RoundImplies: "⥰", rpar: ")", rpargt: "⦔", rppolint: "⨒", rrarr: "⇉", Rrightarrow: "⇛", rsaquo: "›", rscr: "𝓇", Rscr: "ℛ", rsh: "↱", Rsh: "↱", rsqb: "]", rsquo: "’", rsquor: "’", rthree: "⋌", rtimes: "⋊", rtri: "▹", rtrie: "⊵", rtrif: "▸", rtriltri: "⧎", RuleDelayed: "⧴", ruluhar: "⥨", rx: "℞", Sacute: "Ś", sacute: "ś", sbquo: "‚", scap: "⪸", Scaron: "Š", scaron: "š", Sc: "⪼", sc: "≻", sccue: "≽", sce: "⪰", scE: "⪴", Scedil: "Ş", scedil: "ş", Scirc: "Ŝ", scirc: "ŝ", scnap: "⪺", scnE: "⪶", scnsim: "⋩", scpolint: "⨓", scsim: "≿", Scy: "С", scy: "с", sdotb: "⊡", sdot: "⋅", sdote: "⩦", searhk: "⤥", searr: "↘", seArr: "⇘", searrow: "↘", sect: "§", semi: ";", seswar: "⤩", setminus: "∖", setmn: "∖", sext: "✶", Sfr: "𝔖", sfr: "𝔰", sfrown: "⌢", sharp: "♯", SHCHcy: "Щ", shchcy: "щ", SHcy: "Ш", shcy: "ш", ShortDownArrow: "↓", ShortLeftArrow: "←", shortmid: "∣", shortparallel: "∥", ShortRightArrow: "→", ShortUpArrow: "↑", shy: "\u00ad", Sigma: "Σ", sigma: "σ", sigmaf: "ς", sigmav: "ς", sim: "∼", simdot: "⩪", sime: "≃", simeq: "≃", simg: "⪞", simgE: "⪠", siml: "⪝", simlE: "⪟", simne: "≆", simplus: "⨤", simrarr: "⥲", slarr: "←", SmallCircle: "∘", smallsetminus: "∖", smashp: "⨳", smeparsl: "⧤", smid: "∣", smile: "⌣", smt: "⪪", smte: "⪬", smtes: "⪬︀", SOFTcy: "Ь", softcy: "ь", solbar: "⌿", solb: "⧄", sol: "/", Sopf: "𝕊", sopf: "𝕤", spades: "♠", spadesuit: "♠", spar: "∥", sqcap: "⊓", sqcaps: "⊓︀", sqcup: "⊔", sqcups: "⊔︀", Sqrt: "√", sqsub: "⊏", sqsube: "⊑", sqsubset: "⊏", sqsubseteq: "⊑", sqsup: "⊐", sqsupe: "⊒", sqsupset: "⊐", sqsupseteq: "⊒", square: "□", Square: "□", SquareIntersection: "⊓", SquareSubset: "⊏", SquareSubsetEqual: "⊑", SquareSuperset: "⊐", SquareSupersetEqual: "⊒", SquareUnion: "⊔", squarf: "▪", squ: "□", squf: "▪", srarr: "→", Sscr: "𝒮", sscr: "𝓈", ssetmn: "∖", ssmile: "⌣", sstarf: "⋆", Star: "⋆", star: "☆", starf: "★", straightepsilon: "ϵ", straightphi: "ϕ", strns: "¯", sub: "⊂", Sub: "⋐", subdot: "⪽", subE: "⫅", sube: "⊆", subedot: "⫃", submult: "⫁", subnE: "⫋", subne: "⊊", subplus: "⪿", subrarr: "⥹", subset: "⊂", Subset: "⋐", subseteq: "⊆", subseteqq: "⫅", SubsetEqual: "⊆", subsetneq: "⊊", subsetneqq: "⫋", subsim: "⫇", subsub: "⫕", subsup: "⫓", succapprox: "⪸", succ: "≻", succcurlyeq: "≽", Succeeds: "≻", SucceedsEqual: "⪰", SucceedsSlantEqual: "≽", SucceedsTilde: "≿", succeq: "⪰", succnapprox: "⪺", succneqq: "⪶", succnsim: "⋩", succsim: "≿", SuchThat: "∋", sum: "∑", Sum: "∑", sung: "♪", sup1: "¹", sup2: "²", sup3: "³", sup: "⊃", Sup: "⋑", supdot: "⪾", supdsub: "⫘", supE: "⫆", supe: "⊇", supedot: "⫄", Superset: "⊃", SupersetEqual: "⊇", suphsol: "⟉", suphsub: "⫗", suplarr: "⥻", supmult: "⫂", supnE: "⫌", supne: "⊋", supplus: "⫀", supset: "⊃", Supset: "⋑", supseteq: "⊇", supseteqq: "⫆", supsetneq: "⊋", supsetneqq: "⫌", supsim: "⫈", supsub: "⫔", supsup: "⫖", swarhk: "⤦", swarr: "↙", swArr: "⇙", swarrow: "↙", swnwar: "⤪", szlig: "ß", Tab: "\u0009", target: "⌖", Tau: "Τ", tau: "τ", tbrk: "⎴", Tcaron: "Ť", tcaron: "ť", Tcedil: "Ţ", tcedil: "ţ", Tcy: "Т", tcy: "т", tdot: "⃛", telrec: "⌕", Tfr: "𝔗", tfr: "𝔱", there4: "∴", therefore: "∴", Therefore: "∴", Theta: "Θ", theta: "θ", thetasym: "ϑ", thetav: "ϑ", thickapprox: "≈", thicksim: "∼", ThickSpace: "  ", ThinSpace: " ", thinsp: &