[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

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

   1  this["wp"] = this["wp"] || {}; this["wp"]["blocks"] =
   2  /******/ (function(modules) { // webpackBootstrap
   3  /******/     // The module cache
   4  /******/     var installedModules = {};
   5  /******/
   6  /******/     // The require function
   7  /******/ 	function __webpack_require__(moduleId) {
   8  /******/
   9  /******/         // Check if module is in cache
  10  /******/         if(installedModules[moduleId]) {
  11  /******/             return installedModules[moduleId].exports;
  12  /******/         }
  13  /******/         // Create a new module (and put it into the cache)
  14  /******/         var module = installedModules[moduleId] = {
  15  /******/             i: moduleId,
  16  /******/             l: false,
  17  /******/             exports: {}
  18  /******/         };
  19  /******/
  20  /******/         // Execute the module function
  21  /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  22  /******/
  23  /******/         // Flag the module as loaded
  24  /******/         module.l = true;
  25  /******/
  26  /******/         // Return the exports of the module
  27  /******/         return module.exports;
  28  /******/     }
  29  /******/
  30  /******/
  31  /******/     // expose the modules object (__webpack_modules__)
  32  /******/     __webpack_require__.m = modules;
  33  /******/
  34  /******/     // expose the module cache
  35  /******/     __webpack_require__.c = installedModules;
  36  /******/
  37  /******/     // define getter function for harmony exports
  38  /******/     __webpack_require__.d = function(exports, name, getter) {
  39  /******/         if(!__webpack_require__.o(exports, name)) {
  40  /******/             Object.defineProperty(exports, name, { enumerable: true, get: getter });
  41  /******/         }
  42  /******/     };
  43  /******/
  44  /******/     // define __esModule on exports
  45  /******/     __webpack_require__.r = function(exports) {
  46  /******/         if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  47  /******/             Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  48  /******/         }
  49  /******/         Object.defineProperty(exports, '__esModule', { value: true });
  50  /******/     };
  51  /******/
  52  /******/     // create a fake namespace object
  53  /******/     // mode & 1: value is a module id, require it
  54  /******/     // mode & 2: merge all properties of value into the ns
  55  /******/     // mode & 4: return value when already ns object
  56  /******/     // mode & 8|1: behave like require
  57  /******/     __webpack_require__.t = function(value, mode) {
  58  /******/         if(mode & 1) value = __webpack_require__(value);
  59  /******/         if(mode & 8) return value;
  60  /******/         if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  61  /******/         var ns = Object.create(null);
  62  /******/         __webpack_require__.r(ns);
  63  /******/         Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  64  /******/         if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  65  /******/         return ns;
  66  /******/     };
  67  /******/
  68  /******/     // getDefaultExport function for compatibility with non-harmony modules
  69  /******/     __webpack_require__.n = function(module) {
  70  /******/         var getter = module && module.__esModule ?
  71  /******/ 			function getDefault() { return module['default']; } :
  72  /******/ 			function getModuleExports() { return module; };
  73  /******/         __webpack_require__.d(getter, 'a', getter);
  74  /******/         return getter;
  75  /******/     };
  76  /******/
  77  /******/     // Object.prototype.hasOwnProperty.call
  78  /******/     __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  79  /******/
  80  /******/     // __webpack_public_path__
  81  /******/     __webpack_require__.p = "";
  82  /******/
  83  /******/
  84  /******/     // Load entry module and return exports
  85  /******/     return __webpack_require__(__webpack_require__.s = 459);
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ 0:
  91  /***/ (function(module, exports) {
  92  
  93  (function() { module.exports = this["wp"]["element"]; }());
  94  
  95  /***/ }),
  96  
  97  /***/ 1:
  98  /***/ (function(module, exports) {
  99  
 100  (function() { module.exports = this["wp"]["i18n"]; }());
 101  
 102  /***/ }),
 103  
 104  /***/ 10:
 105  /***/ (function(module, exports) {
 106  
 107  (function() { module.exports = this["wp"]["compose"]; }());
 108  
 109  /***/ }),
 110  
 111  /***/ 105:
 112  /***/ (function(module, exports) {
 113  
 114  (function() { module.exports = this["wp"]["autop"]; }());
 115  
 116  /***/ }),
 117  
 118  /***/ 12:
 119  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 120  
 121  "use strict";
 122  
 123  // EXPORTS
 124  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _slicedToArray; });
 125  
 126  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
 127  var arrayWithHoles = __webpack_require__(38);
 128  
 129  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
 130  function _iterableToArrayLimit(arr, i) {
 131    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
 132    var _arr = [];
 133    var _n = true;
 134    var _d = false;
 135    var _e = undefined;
 136  
 137    try {
 138      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
 139        _arr.push(_s.value);
 140  
 141        if (i && _arr.length === i) break;
 142      }
 143    } catch (err) {
 144      _d = true;
 145      _e = err;
 146    } finally {
 147      try {
 148        if (!_n && _i["return"] != null) _i["return"]();
 149      } finally {
 150        if (_d) throw _e;
 151      }
 152    }
 153  
 154    return _arr;
 155  }
 156  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 157  var unsupportedIterableToArray = __webpack_require__(30);
 158  
 159  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
 160  var nonIterableRest = __webpack_require__(39);
 161  
 162  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
 163  
 164  
 165  
 166  
 167  function _slicedToArray(arr, i) {
 168    return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(unsupportedIterableToArray["a" /* default */])(arr, i) || Object(nonIterableRest["a" /* default */])();
 169  }
 170  
 171  /***/ }),
 172  
 173  /***/ 130:
 174  /***/ (function(module, exports) {
 175  
 176  (function() { module.exports = this["wp"]["shortcode"]; }());
 177  
 178  /***/ }),
 179  
 180  /***/ 149:
 181  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 182  
 183  "use strict";
 184  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toArray; });
 185  /* harmony import */ var _arrayWithHoles__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(38);
 186  /* harmony import */ var _iterableToArray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(37);
 187  /* harmony import */ var _unsupportedIterableToArray__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(30);
 188  /* harmony import */ var _nonIterableRest__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(39);
 189  
 190  
 191  
 192  
 193  function _toArray(arr) {
 194    return Object(_arrayWithHoles__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(arr) || Object(_iterableToArray__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(arr) || Object(_unsupportedIterableToArray__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(arr) || Object(_nonIterableRest__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"])();
 195  }
 196  
 197  /***/ }),
 198  
 199  /***/ 17:
 200  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 201  
 202  "use strict";
 203  
 204  // EXPORTS
 205  __webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ _toConsumableArray; });
 206  
 207  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
 208  var arrayLikeToArray = __webpack_require__(27);
 209  
 210  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
 211  
 212  function _arrayWithoutHoles(arr) {
 213    if (Array.isArray(arr)) return Object(arrayLikeToArray["a" /* default */])(arr);
 214  }
 215  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js
 216  var iterableToArray = __webpack_require__(37);
 217  
 218  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
 219  var unsupportedIterableToArray = __webpack_require__(30);
 220  
 221  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
 222  function _nonIterableSpread() {
 223    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 224  }
 225  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
 226  
 227  
 228  
 229  
 230  function _toConsumableArray(arr) {
 231    return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || Object(unsupportedIterableToArray["a" /* default */])(arr) || _nonIterableSpread();
 232  }
 233  
 234  /***/ }),
 235  
 236  /***/ 2:
 237  /***/ (function(module, exports) {
 238  
 239  (function() { module.exports = this["lodash"]; }());
 240  
 241  /***/ }),
 242  
 243  /***/ 208:
 244  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 245  
 246  "use strict";
 247  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(0);
 248  /* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
 249  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
 250  /* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
 251  
 252  
 253  /**
 254   * WordPress dependencies
 255   */
 256  
 257  var blockDefault = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
 258    xmlns: "http://www.w3.org/2000/svg",
 259    viewBox: "0 0 24 24"
 260  }, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
 261    d: "M19 8h-1V6h-5v2h-2V6H6v2H5c-1.1 0-2 .9-2 2v8c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-8c0-1.1-.9-2-2-2zm.5 10c0 .3-.2.5-.5.5H5c-.3 0-.5-.2-.5-.5v-8c0-.3.2-.5.5-.5h14c.3 0 .5.2.5.5v8z"
 262  }));
 263  /* harmony default export */ __webpack_exports__["a"] = (blockDefault);
 264  
 265  
 266  /***/ }),
 267  
 268  /***/ 21:
 269  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 270  
 271  "use strict";
 272  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
 273  function _classCallCheck(instance, Constructor) {
 274    if (!(instance instanceof Constructor)) {
 275      throw new TypeError("Cannot call a class as a function");
 276    }
 277  }
 278  
 279  /***/ }),
 280  
 281  /***/ 22:
 282  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 283  
 284  "use strict";
 285  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });
 286  function _defineProperties(target, props) {
 287    for (var i = 0; i < props.length; i++) {
 288      var descriptor = props[i];
 289      descriptor.enumerable = descriptor.enumerable || false;
 290      descriptor.configurable = true;
 291      if ("value" in descriptor) descriptor.writable = true;
 292      Object.defineProperty(target, descriptor.key, descriptor);
 293    }
 294  }
 295  
 296  function _createClass(Constructor, protoProps, staticProps) {
 297    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 298    if (staticProps) _defineProperties(Constructor, staticProps);
 299    return Constructor;
 300  }
 301  
 302  /***/ }),
 303  
 304  /***/ 27:
 305  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 306  
 307  "use strict";
 308  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayLikeToArray; });
 309  function _arrayLikeToArray(arr, len) {
 310    if (len == null || len > arr.length) len = arr.length;
 311  
 312    for (var i = 0, arr2 = new Array(len); i < len; i++) {
 313      arr2[i] = arr[i];
 314    }
 315  
 316    return arr2;
 317  }
 318  
 319  /***/ }),
 320  
 321  /***/ 283:
 322  /***/ (function(module, exports) {
 323  
 324  (function() { module.exports = this["wp"]["blockSerializationDefaultParser"]; }());
 325  
 326  /***/ }),
 327  
 328  /***/ 284:
 329  /***/ (function(module, exports, __webpack_require__) {
 330  
 331  var __WEBPACK_AMD_DEFINE_RESULT__;;/*! showdown v 1.9.1 - 02-11-2019 */
 332  (function(){
 333  /**
 334   * Created by Tivie on 13-07-2015.
 335   */
 336  
 337  function getDefaultOpts (simple) {
 338    'use strict';
 339  
 340    var defaultOptions = {
 341      omitExtraWLInCodeBlocks: {
 342        defaultValue: false,
 343        describe: 'Omit the default extra whiteline added to code blocks',
 344        type: 'boolean'
 345      },
 346      noHeaderId: {
 347        defaultValue: false,
 348        describe: 'Turn on/off generated header id',
 349        type: 'boolean'
 350      },
 351      prefixHeaderId: {
 352        defaultValue: false,
 353        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',
 354        type: 'string'
 355      },
 356      rawPrefixHeaderId: {
 357        defaultValue: false,
 358        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)',
 359        type: 'boolean'
 360      },
 361      ghCompatibleHeaderId: {
 362        defaultValue: false,
 363        describe: 'Generate header ids compatible with github style (spaces are replaced with dashes, a bunch of non alphanumeric chars are removed)',
 364        type: 'boolean'
 365      },
 366      rawHeaderId: {
 367        defaultValue: false,
 368        describe: 'Remove only spaces, \' and " from generated header ids (including prefixes), replacing them with dashes (-). WARNING: This might result in malformed ids',
 369        type: 'boolean'
 370      },
 371      headerLevelStart: {
 372        defaultValue: false,
 373        describe: 'The header blocks level start',
 374        type: 'integer'
 375      },
 376      parseImgDimensions: {
 377        defaultValue: false,
 378        describe: 'Turn on/off image dimension parsing',
 379        type: 'boolean'
 380      },
 381      simplifiedAutoLink: {
 382        defaultValue: false,
 383        describe: 'Turn on/off GFM autolink style',
 384        type: 'boolean'
 385      },
 386      excludeTrailingPunctuationFromURLs: {
 387        defaultValue: false,
 388        describe: 'Excludes trailing punctuation from links generated with autoLinking',
 389        type: 'boolean'
 390      },
 391      literalMidWordUnderscores: {
 392        defaultValue: false,
 393        describe: 'Parse midword underscores as literal underscores',
 394        type: 'boolean'
 395      },
 396      literalMidWordAsterisks: {
 397        defaultValue: false,
 398        describe: 'Parse midword asterisks as literal asterisks',
 399        type: 'boolean'
 400      },
 401      strikethrough: {
 402        defaultValue: false,
 403        describe: 'Turn on/off strikethrough support',
 404        type: 'boolean'
 405      },
 406      tables: {
 407        defaultValue: false,
 408        describe: 'Turn on/off tables support',
 409        type: 'boolean'
 410      },
 411      tablesHeaderId: {
 412        defaultValue: false,
 413        describe: 'Add an id to table headers',
 414        type: 'boolean'
 415      },
 416      ghCodeBlocks: {
 417        defaultValue: true,
 418        describe: 'Turn on/off GFM fenced code blocks support',
 419        type: 'boolean'
 420      },
 421      tasklists: {
 422        defaultValue: false,
 423        describe: 'Turn on/off GFM tasklist support',
 424        type: 'boolean'
 425      },
 426      smoothLivePreview: {
 427        defaultValue: false,
 428        describe: 'Prevents weird effects in live previews due to incomplete input',
 429        type: 'boolean'
 430      },
 431      smartIndentationFix: {
 432        defaultValue: false,
 433        description: 'Tries to smartly fix indentation in es6 strings',
 434        type: 'boolean'
 435      },
 436      disableForced4SpacesIndentedSublists: {
 437        defaultValue: false,
 438        description: 'Disables the requirement of indenting nested sublists by 4 spaces',
 439        type: 'boolean'
 440      },
 441      simpleLineBreaks: {
 442        defaultValue: false,
 443        description: 'Parses simple line breaks as <br> (GFM Style)',
 444        type: 'boolean'
 445      },
 446      requireSpaceBeforeHeadingText: {
 447        defaultValue: false,
 448        description: 'Makes adding a space between `#` and the header text mandatory (GFM Style)',
 449        type: 'boolean'
 450      },
 451      ghMentions: {
 452        defaultValue: false,
 453        description: 'Enables github @mentions',
 454        type: 'boolean'
 455      },
 456      ghMentionsLink: {
 457        defaultValue: 'https://github.com/{u}',
 458        description: 'Changes the link generated by @mentions. Only applies if ghMentions option is enabled.',
 459        type: 'string'
 460      },
 461      encodeEmails: {
 462        defaultValue: true,
 463        description: 'Encode e-mail addresses through the use of Character Entities, transforming ASCII e-mail addresses into its equivalent decimal entities',
 464        type: 'boolean'
 465      },
 466      openLinksInNewWindow: {
 467        defaultValue: false,
 468        description: 'Open all links in new windows',
 469        type: 'boolean'
 470      },
 471      backslashEscapesHTMLTags: {
 472        defaultValue: false,
 473        description: 'Support for HTML Tag escaping. ex: \<div>foo\</div>',
 474        type: 'boolean'
 475      },
 476      emoji: {
 477        defaultValue: false,
 478        description: 'Enable emoji support. Ex: `this is a :smile: emoji`',
 479        type: 'boolean'
 480      },
 481      underline: {
 482        defaultValue: false,
 483        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>`',
 484        type: 'boolean'
 485      },
 486      completeHTMLDocument: {
 487        defaultValue: false,
 488        description: 'Outputs a complete html document, including `<html>`, `<head>` and `<body>` tags',
 489        type: 'boolean'
 490      },
 491      metadata: {
 492        defaultValue: false,
 493        description: 'Enable support for document metadata (defined at the top of the document between `«««` and `»»»` or between `---` and `---`).',
 494        type: 'boolean'
 495      },
 496      splitAdjacentBlockquotes: {
 497        defaultValue: false,
 498        description: 'Split adjacent blockquote blocks',
 499        type: 'boolean'
 500      }
 501    };
 502    if (simple === false) {
 503      return JSON.parse(JSON.stringify(defaultOptions));
 504    }
 505    var ret = {};
 506    for (var opt in defaultOptions) {
 507      if (defaultOptions.hasOwnProperty(opt)) {
 508        ret[opt] = defaultOptions[opt].defaultValue;
 509      }
 510    }
 511    return ret;
 512  }
 513  
 514  function allOptionsOn () {
 515    'use strict';
 516    var options = getDefaultOpts(true),
 517        ret = {};
 518    for (var opt in options) {
 519      if (options.hasOwnProperty(opt)) {
 520        ret[opt] = true;
 521      }
 522    }
 523    return ret;
 524  }
 525  
 526  /**
 527   * Created by Tivie on 06-01-2015.
 528   */
 529  
 530  // Private properties
 531  var showdown = {},
 532      parsers = {},
 533      extensions = {},
 534      globalOptions = getDefaultOpts(true),
 535      setFlavor = 'vanilla',
 536      flavor = {
 537        github: {
 538          omitExtraWLInCodeBlocks:              true,
 539          simplifiedAutoLink:                   true,
 540          excludeTrailingPunctuationFromURLs:   true,
 541          literalMidWordUnderscores:            true,
 542          strikethrough:                        true,
 543          tables:                               true,
 544          tablesHeaderId:                       true,
 545          ghCodeBlocks:                         true,
 546          tasklists:                            true,
 547          disableForced4SpacesIndentedSublists: true,
 548          simpleLineBreaks:                     true,
 549          requireSpaceBeforeHeadingText:        true,
 550          ghCompatibleHeaderId:                 true,
 551          ghMentions:                           true,
 552          backslashEscapesHTMLTags:             true,
 553          emoji:                                true,
 554          splitAdjacentBlockquotes:             true
 555        },
 556        original: {
 557          noHeaderId:                           true,
 558          ghCodeBlocks:                         false
 559        },
 560        ghost: {
 561          omitExtraWLInCodeBlocks:              true,
 562          parseImgDimensions:                   true,
 563          simplifiedAutoLink:                   true,
 564          excludeTrailingPunctuationFromURLs:   true,
 565          literalMidWordUnderscores:            true,
 566          strikethrough:                        true,
 567          tables:                               true,
 568          tablesHeaderId:                       true,
 569          ghCodeBlocks:                         true,
 570          tasklists:                            true,
 571          smoothLivePreview:                    true,
 572          simpleLineBreaks:                     true,
 573          requireSpaceBeforeHeadingText:        true,
 574          ghMentions:                           false,
 575          encodeEmails:                         true
 576        },
 577        vanilla: getDefaultOpts(true),
 578        allOn: allOptionsOn()
 579      };
 580  
 581  /**
 582   * helper namespace
 583   * @type {{}}
 584   */
 585  showdown.helper = {};
 586  
 587  /**
 588   * TODO LEGACY SUPPORT CODE
 589   * @type {{}}
 590   */
 591  showdown.extensions = {};
 592  
 593  /**
 594   * Set a global option
 595   * @static
 596   * @param {string} key
 597   * @param {*} value
 598   * @returns {showdown}
 599   */
 600  showdown.setOption = function (key, value) {
 601    'use strict';
 602    globalOptions[key] = value;
 603    return this;
 604  };
 605  
 606  /**
 607   * Get a global option
 608   * @static
 609   * @param {string} key
 610   * @returns {*}
 611   */
 612  showdown.getOption = function (key) {
 613    'use strict';
 614    return globalOptions[key];
 615  };
 616  
 617  /**
 618   * Get the global options
 619   * @static
 620   * @returns {{}}
 621   */
 622  showdown.getOptions = function () {
 623    'use strict';
 624    return globalOptions;
 625  };
 626  
 627  /**
 628   * Reset global options to the default values
 629   * @static
 630   */
 631  showdown.resetOptions = function () {
 632    'use strict';
 633    globalOptions = getDefaultOpts(true);
 634  };
 635  
 636  /**
 637   * Set the flavor showdown should use as default
 638   * @param {string} name
 639   */
 640  showdown.setFlavor = function (name) {
 641    'use strict';
 642    if (!flavor.hasOwnProperty(name)) {
 643      throw Error(name + ' flavor was not found');
 644    }
 645    showdown.resetOptions();
 646    var preset = flavor[name];
 647    setFlavor = name;
 648    for (var option in preset) {
 649      if (preset.hasOwnProperty(option)) {
 650        globalOptions[option] = preset[option];
 651      }
 652    }
 653  };
 654  
 655  /**
 656   * Get the currently set flavor
 657   * @returns {string}
 658   */
 659  showdown.getFlavor = function () {
 660    'use strict';
 661    return setFlavor;
 662  };
 663  
 664  /**
 665   * Get the options of a specified flavor. Returns undefined if the flavor was not found
 666   * @param {string} name Name of the flavor
 667   * @returns {{}|undefined}
 668   */
 669  showdown.getFlavorOptions = function (name) {
 670    'use strict';
 671    if (flavor.hasOwnProperty(name)) {
 672      return flavor[name];
 673    }
 674  };
 675  
 676  /**
 677   * Get the default options
 678   * @static
 679   * @param {boolean} [simple=true]
 680   * @returns {{}}
 681   */
 682  showdown.getDefaultOptions = function (simple) {
 683    'use strict';
 684    return getDefaultOpts(simple);
 685  };
 686  
 687  /**
 688   * Get or set a subParser
 689   *
 690   * subParser(name)       - Get a registered subParser
 691   * subParser(name, func) - Register a subParser
 692   * @static
 693   * @param {string} name
 694   * @param {function} [func]
 695   * @returns {*}
 696   */
 697  showdown.subParser = function (name, func) {
 698    'use strict';
 699    if (showdown.helper.isString(name)) {
 700      if (typeof func !== 'undefined') {
 701        parsers[name] = func;
 702      } else {
 703        if (parsers.hasOwnProperty(name)) {
 704          return parsers[name];
 705        } else {
 706          throw Error('SubParser named ' + name + ' not registered!');
 707        }
 708      }
 709    }
 710  };
 711  
 712  /**
 713   * Gets or registers an extension
 714   * @static
 715   * @param {string} name
 716   * @param {object|function=} ext
 717   * @returns {*}
 718   */
 719  showdown.extension = function (name, ext) {
 720    'use strict';
 721  
 722    if (!showdown.helper.isString(name)) {
 723      throw Error('Extension \'name\' must be a string');
 724    }
 725  
 726    name = showdown.helper.stdExtName(name);
 727  
 728    // Getter
 729    if (showdown.helper.isUndefined(ext)) {
 730      if (!extensions.hasOwnProperty(name)) {
 731        throw Error('Extension named ' + name + ' is not registered!');
 732      }
 733      return extensions[name];
 734  
 735      // Setter
 736    } else {
 737      // Expand extension if it's wrapped in a function
 738      if (typeof ext === 'function') {
 739        ext = ext();
 740      }
 741  
 742      // Ensure extension is an array
 743      if (!showdown.helper.isArray(ext)) {
 744        ext = [ext];
 745      }
 746  
 747      var validExtension = validate(ext, name);
 748  
 749      if (validExtension.valid) {
 750        extensions[name] = ext;
 751      } else {
 752        throw Error(validExtension.error);
 753      }
 754    }
 755  };
 756  
 757  /**
 758   * Gets all extensions registered
 759   * @returns {{}}
 760   */
 761  showdown.getAllExtensions = function () {
 762    'use strict';
 763    return extensions;
 764  };
 765  
 766  /**
 767   * Remove an extension
 768   * @param {string} name
 769   */
 770  showdown.removeExtension = function (name) {
 771    'use strict';
 772    delete extensions[name];
 773  };
 774  
 775  /**
 776   * Removes all extensions
 777   */
 778  showdown.resetExtensions = function () {
 779    'use strict';
 780    extensions = {};
 781  };
 782  
 783  /**
 784   * Validate extension
 785   * @param {array} extension
 786   * @param {string} name
 787   * @returns {{valid: boolean, error: string}}
 788   */
 789  function validate (extension, name) {
 790    'use strict';
 791  
 792    var errMsg = (name) ? 'Error in ' + name + ' extension->' : 'Error in unnamed extension',
 793        ret = {
 794          valid: true,
 795          error: ''
 796        };
 797  
 798    if (!showdown.helper.isArray(extension)) {
 799      extension = [extension];
 800    }
 801  
 802    for (var i = 0; i < extension.length; ++i) {
 803      var baseMsg = errMsg + ' sub-extension ' + i + ': ',
 804          ext = extension[i];
 805      if (typeof ext !== 'object') {
 806        ret.valid = false;
 807        ret.error = baseMsg + 'must be an object, but ' + typeof ext + ' given';
 808        return ret;
 809      }
 810  
 811      if (!showdown.helper.isString(ext.type)) {
 812        ret.valid = false;
 813        ret.error = baseMsg + 'property "type" must be a string, but ' + typeof ext.type + ' given';
 814        return ret;
 815      }
 816  
 817      var type = ext.type = ext.type.toLowerCase();
 818  
 819      // normalize extension type
 820      if (type === 'language') {
 821        type = ext.type = 'lang';
 822      }
 823  
 824      if (type === 'html') {
 825        type = ext.type = 'output';
 826      }
 827  
 828      if (type !== 'lang' && type !== 'output' && type !== 'listener') {
 829        ret.valid = false;
 830        ret.error = baseMsg + 'type ' + type + ' is not recognized. Valid values: "lang/language", "output/html" or "listener"';
 831        return ret;
 832      }
 833  
 834      if (type === 'listener') {
 835        if (showdown.helper.isUndefined(ext.listeners)) {
 836          ret.valid = false;
 837          ret.error = baseMsg + '. Extensions of type "listener" must have a property called "listeners"';
 838          return ret;
 839        }
 840      } else {
 841        if (showdown.helper.isUndefined(ext.filter) && showdown.helper.isUndefined(ext.regex)) {
 842          ret.valid = false;
 843          ret.error = baseMsg + type + ' extensions must define either a "regex" property or a "filter" method';
 844          return ret;
 845        }
 846      }
 847  
 848      if (ext.listeners) {
 849        if (typeof ext.listeners !== 'object') {
 850          ret.valid = false;
 851          ret.error = baseMsg + '"listeners" property must be an object but ' + typeof ext.listeners + ' given';
 852          return ret;
 853        }
 854        for (var ln in ext.listeners) {
 855          if (ext.listeners.hasOwnProperty(ln)) {
 856            if (typeof ext.listeners[ln] !== 'function') {
 857              ret.valid = false;
 858              ret.error = baseMsg + '"listeners" property must be an hash of [event name]: [callback]. listeners.' + ln +
 859                ' must be a function but ' + typeof ext.listeners[ln] + ' given';
 860              return ret;
 861            }
 862          }
 863        }
 864      }
 865  
 866      if (ext.filter) {
 867        if (typeof ext.filter !== 'function') {
 868          ret.valid = false;
 869          ret.error = baseMsg + '"filter" must be a function, but ' + typeof ext.filter + ' given';
 870          return ret;
 871        }
 872      } else if (ext.regex) {
 873        if (showdown.helper.isString(ext.regex)) {
 874          ext.regex = new RegExp(ext.regex, 'g');
 875        }
 876        if (!(ext.regex instanceof RegExp)) {
 877          ret.valid = false;
 878          ret.error = baseMsg + '"regex" property must either be a string or a RegExp object, but ' + typeof ext.regex + ' given';
 879          return ret;
 880        }
 881        if (showdown.helper.isUndefined(ext.replace)) {
 882          ret.valid = false;
 883          ret.error = baseMsg + '"regex" extensions must implement a replace string or function';
 884          return ret;
 885        }
 886      }
 887    }
 888    return ret;
 889  }
 890  
 891  /**
 892   * Validate extension
 893   * @param {object} ext
 894   * @returns {boolean}
 895   */
 896  showdown.validateExtension = function (ext) {
 897    'use strict';
 898  
 899    var validateExtension = validate(ext, null);
 900    if (!validateExtension.valid) {
 901      console.warn(validateExtension.error);
 902      return false;
 903    }
 904    return true;
 905  };
 906  
 907  /**
 908   * showdownjs helper functions
 909   */
 910  
 911  if (!showdown.hasOwnProperty('helper')) {
 912    showdown.helper = {};
 913  }
 914  
 915  /**
 916   * Check if var is string
 917   * @static
 918   * @param {string} a
 919   * @returns {boolean}
 920   */
 921  showdown.helper.isString = function (a) {
 922    'use strict';
 923    return (typeof a === 'string' || a instanceof String);
 924  };
 925  
 926  /**
 927   * Check if var is a function
 928   * @static
 929   * @param {*} a
 930   * @returns {boolean}
 931   */
 932  showdown.helper.isFunction = function (a) {
 933    'use strict';
 934    var getType = {};
 935    return a && getType.toString.call(a) === '[object Function]';
 936  };
 937  
 938  /**
 939   * isArray helper function
 940   * @static
 941   * @param {*} a
 942   * @returns {boolean}
 943   */
 944  showdown.helper.isArray = function (a) {
 945    'use strict';
 946    return Array.isArray(a);
 947  };
 948  
 949  /**
 950   * Check if value is undefined
 951   * @static
 952   * @param {*} value The value to check.
 953   * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
 954   */
 955  showdown.helper.isUndefined = function (value) {
 956    'use strict';
 957    return typeof value === 'undefined';
 958  };
 959  
 960  /**
 961   * ForEach helper function
 962   * Iterates over Arrays and Objects (own properties only)
 963   * @static
 964   * @param {*} obj
 965   * @param {function} callback Accepts 3 params: 1. value, 2. key, 3. the original array/object
 966   */
 967  showdown.helper.forEach = function (obj, callback) {
 968    'use strict';
 969    // check if obj is defined
 970    if (showdown.helper.isUndefined(obj)) {
 971      throw new Error('obj param is required');
 972    }
 973  
 974    if (showdown.helper.isUndefined(callback)) {
 975      throw new Error('callback param is required');
 976    }
 977  
 978    if (!showdown.helper.isFunction(callback)) {
 979      throw new Error('callback param must be a function/closure');
 980    }
 981  
 982    if (typeof obj.forEach === 'function') {
 983      obj.forEach(callback);
 984    } else if (showdown.helper.isArray(obj)) {
 985      for (var i = 0; i < obj.length; i++) {
 986        callback(obj[i], i, obj);
 987      }
 988    } else if (typeof (obj) === 'object') {
 989      for (var prop in obj) {
 990        if (obj.hasOwnProperty(prop)) {
 991          callback(obj[prop], prop, obj);
 992        }
 993      }
 994    } else {
 995      throw new Error('obj does not seem to be an array or an iterable object');
 996    }
 997  };
 998  
 999  /**
1000   * Standardidize extension name
1001   * @static
1002   * @param {string} s extension name
1003   * @returns {string}
1004   */
1005  showdown.helper.stdExtName = function (s) {
1006    'use strict';
1007    return s.replace(/[_?*+\/\\.^-]/g, '').replace(/\s/g, '').toLowerCase();
1008  };
1009  
1010  function escapeCharactersCallback (wholeMatch, m1) {
1011    'use strict';
1012    var charCodeToEscape = m1.charCodeAt(0);
1013    return '¨E' + charCodeToEscape + 'E';
1014  }
1015  
1016  /**
1017   * Callback used to escape characters when passing through String.replace
1018   * @static
1019   * @param {string} wholeMatch
1020   * @param {string} m1
1021   * @returns {string}
1022   */
1023  showdown.helper.escapeCharactersCallback = escapeCharactersCallback;
1024  
1025  /**
1026   * Escape characters in a string
1027   * @static
1028   * @param {string} text
1029   * @param {string} charsToEscape
1030   * @param {boolean} afterBackslash
1031   * @returns {XML|string|void|*}
1032   */
1033  showdown.helper.escapeCharacters = function (text, charsToEscape, afterBackslash) {
1034    'use strict';
1035    // First we have to escape the escape characters so that
1036    // we can build a character class out of them
1037    var regexString = '([' + charsToEscape.replace(/([\[\]\\])/g, '\\$1') + '])';
1038  
1039    if (afterBackslash) {
1040      regexString = '\\\\' + regexString;
1041    }
1042  
1043    var regex = new RegExp(regexString, 'g');
1044    text = text.replace(regex, escapeCharactersCallback);
1045  
1046    return text;
1047  };
1048  
1049  /**
1050   * Unescape HTML entities
1051   * @param txt
1052   * @returns {string}
1053   */
1054  showdown.helper.unescapeHTMLEntities = function (txt) {
1055    'use strict';
1056  
1057    return txt
1058      .replace(/&quot;/g, '"')
1059      .replace(/&lt;/g, '<')
1060      .replace(/&gt;/g, '>')
1061      .replace(/&amp;/g, '&');
1062  };
1063  
1064  var rgxFindMatchPos = function (str, left, right, flags) {
1065    'use strict';
1066    var f = flags || '',
1067        g = f.indexOf('g') > -1,
1068        x = new RegExp(left + '|' + right, 'g' + f.replace(/g/g, '')),
1069        l = new RegExp(left, f.replace(/g/g, '')),
1070        pos = [],
1071        t, s, m, start, end;
1072  
1073    do {
1074      t = 0;
1075      while ((m = x.exec(str))) {
1076        if (l.test(m[0])) {
1077          if (!(t++)) {
1078            s = x.lastIndex;
1079            start = s - m[0].length;
1080          }
1081        } else if (t) {
1082          if (!--t) {
1083            end = m.index + m[0].length;
1084            var obj = {
1085              left: {start: start, end: s},
1086              match: {start: s, end: m.index},
1087              right: {start: m.index, end: end},
1088              wholeMatch: {start: start, end: end}
1089            };
1090            pos.push(obj);
1091            if (!g) {
1092              return pos;
1093            }
1094          }
1095        }
1096      }
1097    } while (t && (x.lastIndex = s));
1098  
1099    return pos;
1100  };
1101  
1102  /**
1103   * matchRecursiveRegExp
1104   *
1105   * (c) 2007 Steven Levithan <stevenlevithan.com>
1106   * MIT License
1107   *
1108   * Accepts a string to search, a left and right format delimiter
1109   * as regex patterns, and optional regex flags. Returns an array
1110   * of matches, allowing nested instances of left/right delimiters.
1111   * Use the "g" flag to return all matches, otherwise only the
1112   * first is returned. Be careful to ensure that the left and
1113   * right format delimiters produce mutually exclusive matches.
1114   * Backreferences are not supported within the right delimiter
1115   * due to how it is internally combined with the left delimiter.
1116   * When matching strings whose format delimiters are unbalanced
1117   * to the left or right, the output is intentionally as a
1118   * conventional regex library with recursion support would
1119   * produce, e.g. "<<x>" and "<x>>" both produce ["x"] when using
1120   * "<" and ">" as the delimiters (both strings contain a single,
1121   * balanced instance of "<x>").
1122   *
1123   * examples:
1124   * matchRecursiveRegExp("test", "\\(", "\\)")
1125   * returns: []
1126   * matchRecursiveRegExp("<t<<e>><s>>t<>", "<", ">", "g")
1127   * returns: ["t<<e>><s>", ""]
1128   * matchRecursiveRegExp("<div id=\"x\">test</div>", "<div\\b[^>]*>", "</div>", "gi")
1129   * returns: ["test"]
1130   */
1131  showdown.helper.matchRecursiveRegExp = function (str, left, right, flags) {
1132    'use strict';
1133  
1134    var matchPos = rgxFindMatchPos (str, left, right, flags),
1135        results = [];
1136  
1137    for (var i = 0; i < matchPos.length; ++i) {
1138      results.push([
1139        str.slice(matchPos[i].wholeMatch.start, matchPos[i].wholeMatch.end),
1140        str.slice(matchPos[i].match.start, matchPos[i].match.end),
1141        str.slice(matchPos[i].left.start, matchPos[i].left.end),
1142        str.slice(matchPos[i].right.start, matchPos[i].right.end)
1143      ]);
1144    }
1145    return results;
1146  };
1147  
1148  /**
1149   *
1150   * @param {string} str
1151   * @param {string|function} replacement
1152   * @param {string} left
1153   * @param {string} right
1154   * @param {string} flags
1155   * @returns {string}
1156   */
1157  showdown.helper.replaceRecursiveRegExp = function (str, replacement, left, right, flags) {
1158    'use strict';
1159  
1160    if (!showdown.helper.isFunction(replacement)) {
1161      var repStr = replacement;
1162      replacement = function () {
1163        return repStr;
1164      };
1165    }
1166  
1167    var matchPos = rgxFindMatchPos(str, left, right, flags),
1168        finalStr = str,
1169        lng = matchPos.length;
1170  
1171    if (lng > 0) {
1172      var bits = [];
1173      if (matchPos[0].wholeMatch.start !== 0) {
1174        bits.push(str.slice(0, matchPos[0].wholeMatch.start));
1175      }
1176      for (var i = 0; i < lng; ++i) {
1177        bits.push(
1178          replacement(
1179            str.slice(matchPos[i].wholeMatch.start, matchPos[i].wholeMatch.end),
1180            str.slice(matchPos[i].match.start, matchPos[i].match.end),
1181            str.slice(matchPos[i].left.start, matchPos[i].left.end),
1182            str.slice(matchPos[i].right.start, matchPos[i].right.end)
1183          )
1184        );
1185        if (i < lng - 1) {
1186          bits.push(str.slice(matchPos[i].wholeMatch.end, matchPos[i + 1].wholeMatch.start));
1187        }
1188      }
1189      if (matchPos[lng - 1].wholeMatch.end < str.length) {
1190        bits.push(str.slice(matchPos[lng - 1].wholeMatch.end));
1191      }
1192      finalStr = bits.join('');
1193    }
1194    return finalStr;
1195  };
1196  
1197  /**
1198   * Returns the index within the passed String object of the first occurrence of the specified regex,
1199   * starting the search at fromIndex. Returns -1 if the value is not found.
1200   *
1201   * @param {string} str string to search
1202   * @param {RegExp} regex Regular expression to search
1203   * @param {int} [fromIndex = 0] Index to start the search
1204   * @returns {Number}
1205   * @throws InvalidArgumentError
1206   */
1207  showdown.helper.regexIndexOf = function (str, regex, fromIndex) {
1208    'use strict';
1209    if (!showdown.helper.isString(str)) {
1210      throw 'InvalidArgumentError: first parameter of showdown.helper.regexIndexOf function must be a string';
1211    }
1212    if (regex instanceof RegExp === false) {
1213      throw 'InvalidArgumentError: second parameter of showdown.helper.regexIndexOf function must be an instance of RegExp';
1214    }
1215    var indexOf = str.substring(fromIndex || 0).search(regex);
1216    return (indexOf >= 0) ? (indexOf + (fromIndex || 0)) : indexOf;
1217  };
1218  
1219  /**
1220   * Splits the passed string object at the defined index, and returns an array composed of the two substrings
1221   * @param {string} str string to split
1222   * @param {int} index index to split string at
1223   * @returns {[string,string]}
1224   * @throws InvalidArgumentError
1225   */
1226  showdown.helper.splitAtIndex = function (str, index) {
1227    'use strict';
1228    if (!showdown.helper.isString(str)) {
1229      throw 'InvalidArgumentError: first parameter of showdown.helper.regexIndexOf function must be a string';
1230    }
1231    return [str.substring(0, index), str.substring(index)];
1232  };
1233  
1234  /**
1235   * Obfuscate an e-mail address through the use of Character Entities,
1236   * transforming ASCII characters into their equivalent decimal or hex entities.
1237   *
1238   * Since it has a random component, subsequent calls to this function produce different results
1239   *
1240   * @param {string} mail
1241   * @returns {string}
1242   */
1243  showdown.helper.encodeEmailAddress = function (mail) {
1244    'use strict';
1245    var encode = [
1246      function (ch) {
1247        return '&#' + ch.charCodeAt(0) + ';';
1248      },
1249      function (ch) {
1250        return '&#x' + ch.charCodeAt(0).toString(16) + ';';
1251      },
1252      function (ch) {
1253        return ch;
1254      }
1255    ];
1256  
1257    mail = mail.replace(/./g, function (ch) {
1258      if (ch === '@') {
1259        // this *must* be encoded. I insist.
1260        ch = encode[Math.floor(Math.random() * 2)](ch);
1261      } else {
1262        var r = Math.random();
1263        // roughly 10% raw, 45% hex, 45% dec
1264        ch = (
1265          r > 0.9 ? encode[2](ch) : r > 0.45 ? encode[1](ch) : encode[0](ch)
1266        );
1267      }
1268      return ch;
1269    });
1270  
1271    return mail;
1272  };
1273  
1274  /**
1275   *
1276   * @param str
1277   * @param targetLength
1278   * @param padString
1279   * @returns {string}
1280   */
1281  showdown.helper.padEnd = function padEnd (str, targetLength, padString) {
1282    'use strict';
1283    /*jshint bitwise: false*/
1284    // eslint-disable-next-line space-infix-ops
1285    targetLength = targetLength>>0; //floor if number or convert non-number to 0;
1286    /*jshint bitwise: true*/
1287    padString = String(padString || ' ');
1288    if (str.length > targetLength) {
1289      return String(str);
1290    } else {
1291      targetLength = targetLength - str.length;
1292      if (targetLength > padString.length) {
1293        padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
1294      }
1295      return String(str) + padString.slice(0,targetLength);
1296    }
1297  };
1298  
1299  /**
1300   * POLYFILLS
1301   */
1302  // use this instead of builtin is undefined for IE8 compatibility
1303  if (typeof console === 'undefined') {
1304    console = {
1305      warn: function (msg) {
1306        'use strict';
1307        alert(msg);
1308      },
1309      log: function (msg) {
1310        'use strict';
1311        alert(msg);
1312      },
1313      error: function (msg) {
1314        'use strict';
1315        throw msg;
1316      }
1317    };
1318  }
1319  
1320  /**
1321   * Common regexes.
1322   * We declare some common regexes to improve performance
1323   */
1324  showdown.helper.regexes = {
1325    asteriskDashAndColon: /([*_:~])/g
1326  };
1327  
1328  /**
1329   * EMOJIS LIST
1330   */
1331  showdown.helper.emojis = {
1332    '+1':'\ud83d\udc4d',
1333    '-1':'\ud83d\udc4e',
1334    '100':'\ud83d\udcaf',
1335    '1234':'\ud83d\udd22',
1336    '1st_place_medal':'\ud83e\udd47',
1337    '2nd_place_medal':'\ud83e\udd48',
1338    '3rd_place_medal':'\ud83e\udd49',
1339    '8ball':'\ud83c\udfb1',
1340    'a':'\ud83c\udd70\ufe0f',
1341    'ab':'\ud83c\udd8e',
1342    'abc':'\ud83d\udd24',
1343    'abcd':'\ud83d\udd21',
1344    'accept':'\ud83c\ude51',
1345    'aerial_tramway':'\ud83d\udea1',
1346    'airplane':'\u2708\ufe0f',
1347    'alarm_clock':'\u23f0',
1348    'alembic':'\u2697\ufe0f',
1349    'alien':'\ud83d\udc7d',
1350    'ambulance':'\ud83d\ude91',
1351    'amphora':'\ud83c\udffa',
1352    'anchor':'\u2693\ufe0f',
1353    'angel':'\ud83d\udc7c',
1354    'anger':'\ud83d\udca2',
1355    'angry':'\ud83d\ude20',
1356    'anguished':'\ud83d\ude27',
1357    'ant':'\ud83d\udc1c',
1358    'apple':'\ud83c\udf4e',
1359    'aquarius':'\u2652\ufe0f',
1360    'aries':'\u2648\ufe0f',
1361    'arrow_backward':'\u25c0\ufe0f',
1362    'arrow_double_down':'\u23ec',
1363    'arrow_double_up':'\u23eb',
1364    'arrow_down':'\u2b07\ufe0f',
1365    'arrow_down_small':'\ud83d\udd3d',
1366    'arrow_forward':'\u25b6\ufe0f',
1367    'arrow_heading_down':'\u2935\ufe0f',
1368    'arrow_heading_up':'\u2934\ufe0f',
1369    'arrow_left':'\u2b05\ufe0f',
1370    'arrow_lower_left':'\u2199\ufe0f',
1371    'arrow_lower_right':'\u2198\ufe0f',
1372    'arrow_right':'\u27a1\ufe0f',
1373    'arrow_right_hook':'\u21aa\ufe0f',
1374    'arrow_up':'\u2b06\ufe0f',
1375    'arrow_up_down':'\u2195\ufe0f',
1376    'arrow_up_small':'\ud83d\udd3c',
1377    'arrow_upper_left':'\u2196\ufe0f',
1378    'arrow_upper_right':'\u2197\ufe0f',
1379    'arrows_clockwise':'\ud83d\udd03',
1380    'arrows_counterclockwise':'\ud83d\udd04',
1381    'art':'\ud83c\udfa8',
1382    'articulated_lorry':'\ud83d\ude9b',
1383    'artificial_satellite':'\ud83d\udef0',
1384    'astonished':'\ud83d\ude32',
1385    'athletic_shoe':'\ud83d\udc5f',
1386    'atm':'\ud83c\udfe7',
1387    'atom_symbol':'\u269b\ufe0f',
1388    'avocado':'\ud83e\udd51',
1389    'b':'\ud83c\udd71\ufe0f',
1390    'baby':'\ud83d\udc76',
1391    'baby_bottle':'\ud83c\udf7c',
1392    'baby_chick':'\ud83d\udc24',
1393    'baby_symbol':'\ud83d\udebc',
1394    'back':'\ud83d\udd19',
1395    'bacon':'\ud83e\udd53',
1396    'badminton':'\ud83c\udff8',
1397    'baggage_claim':'\ud83d\udec4',
1398    'baguette_bread':'\ud83e\udd56',
1399    'balance_scale':'\u2696\ufe0f',
1400    'balloon':'\ud83c\udf88',
1401    'ballot_box':'\ud83d\uddf3',
1402    'ballot_box_with_check':'\u2611\ufe0f',
1403    'bamboo':'\ud83c\udf8d',
1404    'banana':'\ud83c\udf4c',
1405    'bangbang':'\u203c\ufe0f',
1406    'bank':'\ud83c\udfe6',
1407    'bar_chart':'\ud83d\udcca',
1408    'barber':'\ud83d\udc88',
1409    'baseball':'\u26be\ufe0f',
1410    'basketball':'\ud83c\udfc0',
1411    'basketball_man':'\u26f9\ufe0f',
1412    'basketball_woman':'\u26f9\ufe0f&zwj;\u2640\ufe0f',
1413    'bat':'\ud83e\udd87',
1414    'bath':'\ud83d\udec0',
1415    'bathtub':'\ud83d\udec1',
1416    'battery':'\ud83d\udd0b',
1417    'beach_umbrella':'\ud83c\udfd6',
1418    'bear':'\ud83d\udc3b',
1419    'bed':'\ud83d\udecf',
1420    'bee':'\ud83d\udc1d',
1421    'beer':'\ud83c\udf7a',
1422    'beers':'\ud83c\udf7b',
1423    'beetle':'\ud83d\udc1e',
1424    'beginner':'\ud83d\udd30',
1425    'bell':'\ud83d\udd14',
1426    'bellhop_bell':'\ud83d\udece',
1427    'bento':'\ud83c\udf71',
1428    'biking_man':'\ud83d\udeb4',
1429    'bike':'\ud83d\udeb2',
1430    'biking_woman':'\ud83d\udeb4&zwj;\u2640\ufe0f',
1431    'bikini':'\ud83d\udc59',
1432    'biohazard':'\u2623\ufe0f',
1433    'bird':'\ud83d\udc26',
1434    'birthday':'\ud83c\udf82',
1435    'black_circle':'\u26ab\ufe0f',
1436    'black_flag':'\ud83c\udff4',
1437    'black_heart':'\ud83d\udda4',
1438    'black_joker':'\ud83c\udccf',
1439    'black_large_square':'\u2b1b\ufe0f',
1440    'black_medium_small_square':'\u25fe\ufe0f',
1441    'black_medium_square':'\u25fc\ufe0f',
1442    'black_nib':'\u2712\ufe0f',
1443    'black_small_square':'\u25aa\ufe0f',
1444    'black_square_button':'\ud83d\udd32',
1445    'blonde_man':'\ud83d\udc71',
1446    'blonde_woman':'\ud83d\udc71&zwj;\u2640\ufe0f',
1447    'blossom':'\ud83c\udf3c',
1448    'blowfish':'\ud83d\udc21',
1449    'blue_book':'\ud83d\udcd8',
1450    'blue_car':'\ud83d\ude99',
1451    'blue_heart':'\ud83d\udc99',
1452    'blush':'\ud83d\ude0a',
1453    'boar':'\ud83d\udc17',
1454    'boat':'\u26f5\ufe0f',
1455    'bomb':'\ud83d\udca3',
1456    'book':'\ud83d\udcd6',
1457    'bookmark':'\ud83d\udd16',
1458    'bookmark_tabs':'\ud83d\udcd1',
1459    'books':'\ud83d\udcda',
1460    'boom':'\ud83d\udca5',
1461    'boot':'\ud83d\udc62',
1462    'bouquet':'\ud83d\udc90',
1463    'bowing_man':'\ud83d\ude47',
1464    'bow_and_arrow':'\ud83c\udff9',
1465    'bowing_woman':'\ud83d\ude47&zwj;\u2640\ufe0f',
1466    'bowling':'\ud83c\udfb3',
1467    'boxing_glove':'\ud83e\udd4a',
1468    'boy':'\ud83d\udc66',
1469    'bread':'\ud83c\udf5e',
1470    'bride_with_veil':'\ud83d\udc70',
1471    'bridge_at_night':'\ud83c\udf09',
1472    'briefcase':'\ud83d\udcbc',
1473    'broken_heart':'\ud83d\udc94',
1474    'bug':'\ud83d\udc1b',
1475    'building_construction':'\ud83c\udfd7',
1476    'bulb':'\ud83d\udca1',
1477    'bullettrain_front':'\ud83d\ude85',
1478    'bullettrain_side':'\ud83d\ude84',
1479    'burrito':'\ud83c\udf2f',
1480    'bus':'\ud83d\ude8c',
1481    'business_suit_levitating':'\ud83d\udd74',
1482    'busstop':'\ud83d\ude8f',
1483    'bust_in_silhouette':'\ud83d\udc64',
1484    'busts_in_silhouette':'\ud83d\udc65',
1485    'butterfly':'\ud83e\udd8b',
1486    'cactus':'\ud83c\udf35',
1487    'cake':'\ud83c\udf70',
1488    'calendar':'\ud83d\udcc6',
1489    'call_me_hand':'\ud83e\udd19',
1490    'calling':'\ud83d\udcf2',
1491    'camel':'\ud83d\udc2b',
1492    'camera':'\ud83d\udcf7',
1493    'camera_flash':'\ud83d\udcf8',
1494    'camping':'\ud83c\udfd5',
1495    'cancer':'\u264b\ufe0f',
1496    'candle':'\ud83d\udd6f',
1497    'candy':'\ud83c\udf6c',
1498    'canoe':'\ud83d\udef6',
1499    'capital_abcd':'\ud83d\udd20',
1500    'capricorn':'\u2651\ufe0f',
1501    'car':'\ud83d\ude97',
1502    'card_file_box':'\ud83d\uddc3',
1503    'card_index':'\ud83d\udcc7',
1504    'card_index_dividers':'\ud83d\uddc2',
1505    'carousel_horse':'\ud83c\udfa0',
1506    'carrot':'\ud83e\udd55',
1507    'cat':'\ud83d\udc31',
1508    'cat2':'\ud83d\udc08',
1509    'cd':'\ud83d\udcbf',
1510    'chains':'\u26d3',
1511    'champagne':'\ud83c\udf7e',
1512    'chart':'\ud83d\udcb9',
1513    'chart_with_downwards_trend':'\ud83d\udcc9',
1514    'chart_with_upwards_trend':'\ud83d\udcc8',
1515    'checkered_flag':'\ud83c\udfc1',
1516    'cheese':'\ud83e\uddc0',
1517    'cherries':'\ud83c\udf52',
1518    'cherry_blossom':'\ud83c\udf38',
1519    'chestnut':'\ud83c\udf30',
1520    'chicken':'\ud83d\udc14',
1521    'children_crossing':'\ud83d\udeb8',
1522    'chipmunk':'\ud83d\udc3f',
1523    'chocolate_bar':'\ud83c\udf6b',
1524    'christmas_tree':'\ud83c\udf84',
1525    'church':'\u26ea\ufe0f',
1526    'cinema':'\ud83c\udfa6',
1527    'circus_tent':'\ud83c\udfaa',
1528    'city_sunrise':'\ud83c\udf07',
1529    'city_sunset':'\ud83c\udf06',
1530    'cityscape':'\ud83c\udfd9',
1531    'cl':'\ud83c\udd91',
1532    'clamp':'\ud83d\udddc',
1533    'clap':'\ud83d\udc4f',
1534    'clapper':'\ud83c\udfac',
1535    'classical_building':'\ud83c\udfdb',
1536    'clinking_glasses':'\ud83e\udd42',
1537    'clipboard':'\ud83d\udccb',
1538    'clock1':'\ud83d\udd50',
1539    'clock10':'\ud83d\udd59',
1540    'clock1030':'\ud83d\udd65',
1541    'clock11':'\ud83d\udd5a',
1542    'clock1130':'\ud83d\udd66',
1543    'clock12':'\ud83d\udd5b',
1544    'clock1230':'\ud83d\udd67',
1545    'clock130':'\ud83d\udd5c',
1546    'clock2':'\ud83d\udd51',
1547    'clock230':'\ud83d\udd5d',
1548    'clock3':'\ud83d\udd52',
1549    'clock330':'\ud83d\udd5e',
1550    'clock4':'\ud83d\udd53',
1551    'clock430':'\ud83d\udd5f',
1552    'clock5':'\ud83d\udd54',
1553    'clock530':'\ud83d\udd60',
1554    'clock6':'\ud83d\udd55',
1555    'clock630':'\ud83d\udd61',
1556    'clock7':'\ud83d\udd56',
1557    'clock730':'\ud83d\udd62',
1558    'clock8':'\ud83d\udd57',
1559    'clock830':'\ud83d\udd63',
1560    'clock9':'\ud83d\udd58',
1561    'clock930':'\ud83d\udd64',
1562    'closed_book':'\ud83d\udcd5',
1563    'closed_lock_with_key':'\ud83d\udd10',
1564    'closed_umbrella':'\ud83c\udf02',
1565    'cloud':'\u2601\ufe0f',
1566    'cloud_with_lightning':'\ud83c\udf29',
1567    'cloud_with_lightning_and_rain':'\u26c8',
1568    'cloud_with_rain':'\ud83c\udf27',
1569    'cloud_with_snow':'\ud83c\udf28',
1570    'clown_face':'\ud83e\udd21',
1571    'clubs':'\u2663\ufe0f',
1572    'cocktail':'\ud83c\udf78',
1573    'coffee':'\u2615\ufe0f',
1574    'coffin':'\u26b0\ufe0f',
1575    'cold_sweat':'\ud83d\ude30',
1576    'comet':'\u2604\ufe0f',
1577    'computer':'\ud83d\udcbb',
1578    'computer_mouse':'\ud83d\uddb1',
1579    'confetti_ball':'\ud83c\udf8a',
1580    'confounded':'\ud83d\ude16',
1581    'confused':'\ud83d\ude15',
1582    'congratulations':'\u3297\ufe0f',
1583    'construction':'\ud83d\udea7',
1584    'construction_worker_man':'\ud83d\udc77',
1585    'construction_worker_woman':'\ud83d\udc77&zwj;\u2640\ufe0f',
1586    'control_knobs':'\ud83c\udf9b',
1587    'convenience_store':'\ud83c\udfea',
1588    'cookie':'\ud83c\udf6a',
1589    'cool':'\ud83c\udd92',
1590    'policeman':'\ud83d\udc6e',
1591    'copyright':'\u00a9\ufe0f',
1592    'corn':'\ud83c\udf3d',
1593    'couch_and_lamp':'\ud83d\udecb',
1594    'couple':'\ud83d\udc6b',
1595    'couple_with_heart_woman_man':'\ud83d\udc91',
1596    'couple_with_heart_man_man':'\ud83d\udc68&zwj;\u2764\ufe0f&zwj;\ud83d\udc68',
1597    'couple_with_heart_woman_woman':'\ud83d\udc69&zwj;\u2764\ufe0f&zwj;\ud83d\udc69',
1598    'couplekiss_man_man':'\ud83d\udc68&zwj;\u2764\ufe0f&zwj;\ud83d\udc8b&zwj;\ud83d\udc68',
1599    'couplekiss_man_woman':'\ud83d\udc8f',
1600    'couplekiss_woman_woman':'\ud83d\udc69&zwj;\u2764\ufe0f&zwj;\ud83d\udc8b&zwj;\ud83d\udc69',
1601    'cow':'\ud83d\udc2e',
1602    'cow2':'\ud83d\udc04',
1603    'cowboy_hat_face':'\ud83e\udd20',
1604    'crab':'\ud83e\udd80',
1605    'crayon':'\ud83d\udd8d',
1606    'credit_card':'\ud83d\udcb3',
1607    'crescent_moon':'\ud83c\udf19',
1608    'cricket':'\ud83c\udfcf',
1609    'crocodile':'\ud83d\udc0a',
1610    'croissant':'\ud83e\udd50',
1611    'crossed_fingers':'\ud83e\udd1e',
1612    'crossed_flags':'\ud83c\udf8c',
1613    'crossed_swords':'\u2694\ufe0f',
1614    'crown':'\ud83d\udc51',
1615    'cry':'\ud83d\ude22',
1616    'crying_cat_face':'\ud83d\ude3f',
1617    'crystal_ball':'\ud83d\udd2e',
1618    'cucumber':'\ud83e\udd52',
1619    'cupid':'\ud83d\udc98',
1620    'curly_loop':'\u27b0',
1621    'currency_exchange':'\ud83d\udcb1',
1622    'curry':'\ud83c\udf5b',
1623    'custard':'\ud83c\udf6e',
1624    'customs':'\ud83d\udec3',
1625    'cyclone':'\ud83c\udf00',
1626    'dagger':'\ud83d\udde1',
1627    'dancer':'\ud83d\udc83',
1628    'dancing_women':'\ud83d\udc6f',
1629    'dancing_men':'\ud83d\udc6f&zwj;\u2642\ufe0f',
1630    'dango':'\ud83c\udf61',
1631    'dark_sunglasses':'\ud83d\udd76',
1632    'dart':'\ud83c\udfaf',
1633    'dash':'\ud83d\udca8',
1634    'date':'\ud83d\udcc5',
1635    'deciduous_tree':'\ud83c\udf33',
1636    'deer':'\ud83e\udd8c',
1637    'department_store':'\ud83c\udfec',
1638    'derelict_house':'\ud83c\udfda',
1639    'desert':'\ud83c\udfdc',
1640    'desert_island':'\ud83c\udfdd',
1641    'desktop_computer':'\ud83d\udda5',
1642    'male_detective':'\ud83d\udd75\ufe0f',
1643    'diamond_shape_with_a_dot_inside':'\ud83d\udca0',
1644    'diamonds':'\u2666\ufe0f',
1645    'disappointed':'\ud83d\ude1e',
1646    'disappointed_relieved':'\ud83d\ude25',
1647    'dizzy':'\ud83d\udcab',
1648    'dizzy_face':'\ud83d\ude35',
1649    'do_not_litter':'\ud83d\udeaf',
1650    'dog':'\ud83d\udc36',
1651    'dog2':'\ud83d\udc15',
1652    'dollar':'\ud83d\udcb5',
1653    'dolls':'\ud83c\udf8e',
1654    'dolphin':'\ud83d\udc2c',
1655    'door':'\ud83d\udeaa',
1656    'doughnut':'\ud83c\udf69',
1657    'dove':'\ud83d\udd4a',
1658    'dragon':'\ud83d\udc09',
1659    'dragon_face':'\ud83d\udc32',
1660    'dress':'\ud83d\udc57',
1661    'dromedary_camel':'\ud83d\udc2a',
1662    'drooling_face':'\ud83e\udd24',
1663    'droplet':'\ud83d\udca7',
1664    'drum':'\ud83e\udd41',
1665    'duck':'\ud83e\udd86',
1666    'dvd':'\ud83d\udcc0',
1667    'e-mail':'\ud83d\udce7',
1668    'eagle':'\ud83e\udd85',
1669    'ear':'\ud83d\udc42',
1670    'ear_of_rice':'\ud83c\udf3e',
1671    'earth_africa':'\ud83c\udf0d',
1672    'earth_americas':'\ud83c\udf0e',
1673    'earth_asia':'\ud83c\udf0f',
1674    'egg':'\ud83e\udd5a',
1675    'eggplant':'\ud83c\udf46',
1676    'eight_pointed_black_star':'\u2734\ufe0f',
1677    'eight_spoked_asterisk':'\u2733\ufe0f',
1678    'electric_plug':'\ud83d\udd0c',
1679    'elephant':'\ud83d\udc18',
1680    'email':'\u2709\ufe0f',
1681    'end':'\ud83d\udd1a',
1682    'envelope_with_arrow':'\ud83d\udce9',
1683    'euro':'\ud83d\udcb6',
1684    'european_castle':'\ud83c\udff0',
1685    'european_post_office':'\ud83c\udfe4',
1686    'evergreen_tree':'\ud83c\udf32',
1687    'exclamation':'\u2757\ufe0f',
1688    'expressionless':'\ud83d\ude11',
1689    'eye':'\ud83d\udc41',
1690    'eye_speech_bubble':'\ud83d\udc41&zwj;\ud83d\udde8',
1691    'eyeglasses':'\ud83d\udc53',
1692    'eyes':'\ud83d\udc40',
1693    'face_with_head_bandage':'\ud83e\udd15',
1694    'face_with_thermometer':'\ud83e\udd12',
1695    'fist_oncoming':'\ud83d\udc4a',
1696    'factory':'\ud83c\udfed',
1697    'fallen_leaf':'\ud83c\udf42',
1698    'family_man_woman_boy':'\ud83d\udc6a',
1699    'family_man_boy':'\ud83d\udc68&zwj;\ud83d\udc66',
1700    'family_man_boy_boy':'\ud83d\udc68&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1701    'family_man_girl':'\ud83d\udc68&zwj;\ud83d\udc67',
1702    'family_man_girl_boy':'\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1703    'family_man_girl_girl':'\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1704    'family_man_man_boy':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc66',
1705    'family_man_man_boy_boy':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1706    'family_man_man_girl':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc67',
1707    'family_man_man_girl_boy':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1708    'family_man_man_girl_girl':'\ud83d\udc68&zwj;\ud83d\udc68&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1709    'family_man_woman_boy_boy':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1710    'family_man_woman_girl':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc67',
1711    'family_man_woman_girl_boy':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1712    'family_man_woman_girl_girl':'\ud83d\udc68&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1713    'family_woman_boy':'\ud83d\udc69&zwj;\ud83d\udc66',
1714    'family_woman_boy_boy':'\ud83d\udc69&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1715    'family_woman_girl':'\ud83d\udc69&zwj;\ud83d\udc67',
1716    'family_woman_girl_boy':'\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1717    'family_woman_girl_girl':'\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1718    'family_woman_woman_boy':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc66',
1719    'family_woman_woman_boy_boy':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc66&zwj;\ud83d\udc66',
1720    'family_woman_woman_girl':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc67',
1721    'family_woman_woman_girl_boy':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc66',
1722    'family_woman_woman_girl_girl':'\ud83d\udc69&zwj;\ud83d\udc69&zwj;\ud83d\udc67&zwj;\ud83d\udc67',
1723    'fast_forward':'\u23e9',
1724    'fax':'\ud83d\udce0',
1725    'fearful':'\ud83d\ude28',
1726    'feet':'\ud83d\udc3e',
1727    'female_detective':'\ud83d\udd75\ufe0f&zwj;\u2640\ufe0f',
1728    'ferris_wheel':'\ud83c\udfa1',
1729    'ferry':'\u26f4',
1730    'field_hockey':'\ud83c\udfd1',
1731    'file_cabinet':'\ud83d\uddc4',
1732    'file_folder':'\ud83d\udcc1',
1733    'film_projector':'\ud83d\udcfd',
1734    'film_strip':'\ud83c\udf9e',
1735    'fire':'\ud83d\udd25',
1736    'fire_engine':'\ud83d\ude92',
1737    'fireworks':'\ud83c\udf86',
1738    'first_quarter_moon':'\ud83c\udf13',
1739    'first_quarter_moon_with_face':'\ud83c\udf1b',
1740    'fish':'\ud83d\udc1f',
1741    'fish_cake':'\ud83c\udf65',
1742    'fishing_pole_and_fish':'\ud83c\udfa3',
1743    'fist_raised':'\u270a',
1744    'fist_left':'\ud83e\udd1b',
1745    'fist_right':'\ud83e\udd1c',
1746    'flags':'\ud83c\udf8f',
1747    'flashlight':'\ud83d\udd26',
1748    'fleur_de_lis':'\u269c\ufe0f',
1749    'flight_arrival':'\ud83d\udeec',
1750    'flight_departure':'\ud83d\udeeb',
1751    'floppy_disk':'\ud83d\udcbe',
1752    'flower_playing_cards':'\ud83c\udfb4',
1753    'flushed':'\ud83d\ude33',
1754    'fog':'\ud83c\udf2b',
1755    'foggy':'\ud83c\udf01',
1756    'football':'\ud83c\udfc8',
1757    'footprints':'\ud83d\udc63',
1758    'fork_and_knife':'\ud83c\udf74',
1759    'fountain':'\u26f2\ufe0f',
1760    'fountain_pen':'\ud83d\udd8b',
1761    'four_leaf_clover':'\ud83c\udf40',
1762    'fox_face':'\ud83e\udd8a',
1763    'framed_picture':'\ud83d\uddbc',
1764    'free':'\ud83c\udd93',
1765    'fried_egg':'\ud83c\udf73',
1766    'fried_shrimp':'\ud83c\udf64',
1767    'fries':'\ud83c\udf5f',
1768    'frog':'\ud83d\udc38',
1769    'frowning':'\ud83d\ude26',
1770    'frowning_face':'\u2639\ufe0f',
1771    'frowning_man':'\ud83d\ude4d&zwj;\u2642\ufe0f',
1772    'frowning_woman':'\ud83d\ude4d',
1773    'middle_finger':'\ud83d\udd95',
1774    'fuelpump':'\u26fd\ufe0f',
1775    'full_moon':'\ud83c\udf15',
1776    'full_moon_with_face':'\ud83c\udf1d',
1777    'funeral_urn':'\u26b1\ufe0f',
1778    'game_die':'\ud83c\udfb2',
1779    'gear':'\u2699\ufe0f',
1780    'gem':'\ud83d\udc8e',
1781    'gemini':'\u264a\ufe0f',
1782    'ghost':'\ud83d\udc7b',
1783    'gift':'\ud83c\udf81',
1784    'gift_heart':'\ud83d\udc9d',
1785    'girl':'\ud83d\udc67',
1786    'globe_with_meridians':'\ud83c\udf10',
1787    'goal_net':'\ud83e\udd45',
1788    'goat':'\ud83d\udc10',
1789    'golf':'\u26f3\ufe0f',
1790    'golfing_man':'\ud83c\udfcc\ufe0f',
1791    'golfing_woman':'\ud83c\udfcc\ufe0f&zwj;\u2640\ufe0f',
1792    'gorilla':'\ud83e\udd8d',
1793    'grapes':'\ud83c\udf47',
1794    'green_apple':'\ud83c\udf4f',
1795    'green_book':'\ud83d\udcd7',
1796    'green_heart':'\ud83d\udc9a',
1797    'green_salad':'\ud83e\udd57',
1798    'grey_exclamation':'\u2755',
1799    'grey_question':'\u2754',
1800    'grimacing':'\ud83d\ude2c',
1801    'grin':'\ud83d\ude01',
1802    'grinning':'\ud83d\ude00',
1803    'guardsman':'\ud83d\udc82',
1804    'guardswoman':'\ud83d\udc82&zwj;\u2640\ufe0f',
1805    'guitar':'\ud83c\udfb8',
1806    'gun':'\ud83d\udd2b',
1807    'haircut_woman':'\ud83d\udc87',
1808    'haircut_man':'\ud83d\udc87&zwj;\u2642\ufe0f',
1809    'hamburger':'\ud83c\udf54',
1810    'hammer':'\ud83d\udd28',
1811    'hammer_and_pick':'\u2692',
1812    'hammer_and_wrench':'\ud83d\udee0',
1813    'hamster':'\ud83d\udc39',
1814    'hand':'\u270b',
1815    'handbag':'\ud83d\udc5c',
1816    'handshake':'\ud83e\udd1d',
1817    'hankey':'\ud83d\udca9',
1818    'hatched_chick':'\ud83d\udc25',
1819    'hatching_chick':'\ud83d\udc23',
1820    'headphones':'\ud83c\udfa7',
1821    'hear_no_evil':'\ud83d\ude49',
1822    'heart':'\u2764\ufe0f',
1823    'heart_decoration':'\ud83d\udc9f',
1824    'heart_eyes':'\ud83d\ude0d',
1825    'heart_eyes_cat':'\ud83d\ude3b',
1826    'heartbeat':'\ud83d\udc93',
1827    'heartpulse':'\ud83d\udc97',
1828    'hearts':'\u2665\ufe0f',
1829    'heavy_check_mark':'\u2714\ufe0f',
1830    'heavy_division_sign':'\u2797',
1831    'heavy_dollar_sign':'\ud83d\udcb2',
1832    'heavy_heart_exclamation':'\u2763\ufe0f',
1833    'heavy_minus_sign':'\u2796',
1834    'heavy_multiplication_x':'\u2716\ufe0f',
1835    'heavy_plus_sign':'\u2795',
1836    'helicopter':'\ud83d\ude81',
1837    'herb':'\ud83c\udf3f',
1838    'hibiscus':'\ud83c\udf3a',
1839    'high_brightness':'\ud83d\udd06',
1840    'high_heel':'\ud83d\udc60',
1841    'hocho':'\ud83d\udd2a',
1842    'hole':'\ud83d\udd73',
1843    'honey_pot':'\ud83c\udf6f',
1844    'horse':'\ud83d\udc34',
1845    'horse_racing':'\ud83c\udfc7',
1846    'hospital':'\ud83c\udfe5',
1847    'hot_pepper':'\ud83c\udf36',
1848    'hotdog':'\ud83c\udf2d',
1849    'hotel':'\ud83c\udfe8',
1850    'hotsprings':'\u2668\ufe0f',
1851    'hourglass':'\u231b\ufe0f',
1852    'hourglass_flowing_sand':'\u23f3',
1853    'house':'\ud83c\udfe0',
1854    'house_with_garden':'\ud83c\udfe1',
1855    'houses':'\ud83c\udfd8',
1856    'hugs':'\ud83e\udd17',
1857    'hushed':'\ud83d\ude2f',
1858    'ice_cream':'\ud83c\udf68',
1859    'ice_hockey':'\ud83c\udfd2',
1860    'ice_skate':'\u26f8',
1861    'icecream':'\ud83c\udf66',
1862    'id':'\ud83c\udd94',
1863    'ideograph_advantage':'\ud83c\ude50',
1864    'imp':'\ud83d\udc7f',
1865    'inbox_tray':'\ud83d\udce5',
1866    'incoming_envelope':'\ud83d\udce8',
1867    'tipping_hand_woman':'\ud83d\udc81',
1868    'information_source':'\u2139\ufe0f',
1869    'innocent':'\ud83d\ude07',
1870    'interrobang':'\u2049\ufe0f',
1871    'iphone':'\ud83d\udcf1',
1872    'izakaya_lantern':'\ud83c\udfee',
1873    'jack_o_lantern':'\ud83c\udf83',
1874    'japan':'\ud83d\uddfe',
1875    'japanese_castle':'\ud83c\udfef',
1876    'japanese_goblin':'\ud83d\udc7a',
1877    'japanese_ogre':'\ud83d\udc79',
1878    'jeans':'\ud83d\udc56',
1879    'joy':'\ud83d\ude02',
1880    'joy_cat':'\ud83d\ude39',
1881    'joystick':'\ud83d\udd79',
1882    'kaaba':'\ud83d\udd4b',
1883    'key':'\ud83d\udd11',
1884    'keyboard':'\u2328\ufe0f',
1885    'keycap_ten':'\ud83d\udd1f',
1886    'kick_scooter':'\ud83d\udef4',
1887    'kimono':'\ud83d\udc58',
1888    'kiss':'\ud83d\udc8b',
1889    'kissing':'\ud83d\ude17',
1890    'kissing_cat':'\ud83d\ude3d',
1891    'kissing_closed_eyes':'\ud83d\ude1a',
1892    'kissing_heart':'\ud83d\ude18',
1893    'kissing_smiling_eyes':'\ud83d\ude19',
1894    'kiwi_fruit':'\ud83e\udd5d',
1895    'koala':'\ud83d\udc28',
1896    'koko':'\ud83c\ude01',
1897    'label':'\ud83c\udff7',
1898    'large_blue_circle':'\ud83d\udd35',
1899    'large_blue_diamond':'\ud83d\udd37',
1900    'large_orange_diamond':'\ud83d\udd36',
1901    'last_quarter_moon':'\ud83c\udf17',
1902    'last_quarter_moon_with_face':'\ud83c\udf1c',
1903    'latin_cross':'\u271d\ufe0f',
1904    'laughing':'\ud83d\ude06',
1905    'leaves':'\ud83c\udf43',
1906    'ledger':'\ud83d\udcd2',
1907    'left_luggage':'\ud83d\udec5',
1908    'left_right_arrow':'\u2194\ufe0f',
1909    'leftwards_arrow_with_hook':'\u21a9\ufe0f',
1910    'lemon':'\ud83c\udf4b',
1911    'leo':'\u264c\ufe0f',
1912    'leopard':'\ud83d\udc06',
1913    'level_slider':'\ud83c\udf9a',
1914    'libra':'\u264e\ufe0f',
1915    'light_rail':'\ud83d\ude88',
1916    'link':'\ud83d\udd17',
1917    'lion':'\ud83e\udd81',
1918    'lips':'\ud83d\udc44',
1919    'lipstick':'\ud83d\udc84',
1920    'lizard':'\ud83e\udd8e',
1921    'lock':'\ud83d\udd12',
1922    'lock_with_ink_pen':'\ud83d\udd0f',
1923    'lollipop':'\ud83c\udf6d',
1924    'loop':'\u27bf',
1925    'loud_sound':'\ud83d\udd0a',
1926    'loudspeaker':'\ud83d\udce2',
1927    'love_hotel':'\ud83c\udfe9',
1928    'love_letter':'\ud83d\udc8c',
1929    'low_brightness':'\ud83d\udd05',
1930    'lying_face':'\ud83e\udd25',
1931    'm':'\u24c2\ufe0f',
1932    'mag':'\ud83d\udd0d',
1933    'mag_right':'\ud83d\udd0e',
1934    'mahjong':'\ud83c\udc04\ufe0f',
1935    'mailbox':'\ud83d\udceb',
1936    'mailbox_closed':'\ud83d\udcea',
1937    'mailbox_with_mail':'\ud83d\udcec',
1938    'mailbox_with_no_mail':'\ud83d\udced',
1939    'man':'\ud83d\udc68',
1940    'man_artist':'\ud83d\udc68&zwj;\ud83c\udfa8',
1941    'man_astronaut':'\ud83d\udc68&zwj;\ud83d\ude80',
1942    'man_cartwheeling':'\ud83e\udd38&zwj;\u2642\ufe0f',
1943    'man_cook':'\ud83d\udc68&zwj;\ud83c\udf73',
1944    'man_dancing':'\ud83d\udd7a',
1945    'man_facepalming':'\ud83e\udd26&zwj;\u2642\ufe0f',
1946    'man_factory_worker':'\ud83d\udc68&zwj;\ud83c\udfed',
1947    'man_farmer':'\ud83d\udc68&zwj;\ud83c\udf3e',
1948    'man_firefighter':'\ud83d\udc68&zwj;\ud83d\ude92',
1949    'man_health_worker':'\ud83d\udc68&zwj;\u2695\ufe0f',
1950    'man_in_tuxedo':'\ud83e\udd35',
1951    'man_judge':'\ud83d\udc68&zwj;\u2696\ufe0f',
1952    'man_juggling':'\ud83e\udd39&zwj;\u2642\ufe0f',
1953    'man_mechanic':'\ud83d\udc68&zwj;\ud83d\udd27',
1954    'man_office_worker':'\ud83d\udc68&zwj;\ud83d\udcbc',
1955    'man_pilot':'\ud83d\udc68&zwj;\u2708\ufe0f',
1956    'man_playing_handball':'\ud83e\udd3e&zwj;\u2642\ufe0f',
1957    'man_playing_water_polo':'\ud83e\udd3d&zwj;\u2642\ufe0f',
1958    'man_scientist':'\ud83d\udc68&zwj;\ud83d\udd2c',
1959    'man_shrugging':'\ud83e\udd37&zwj;\u2642\ufe0f',
1960    'man_singer':'\ud83d\udc68&zwj;\ud83c\udfa4',
1961    'man_student':'\ud83d\udc68&zwj;\ud83c\udf93',
1962    'man_teacher':'\ud83d\udc68&zwj;\ud83c\udfeb',
1963    'man_technologist':'\ud83d\udc68&zwj;\ud83d\udcbb',
1964    'man_with_gua_pi_mao':'\ud83d\udc72',
1965    'man_with_turban':'\ud83d\udc73',
1966    'tangerine':'\ud83c\udf4a',
1967    'mans_shoe':'\ud83d\udc5e',
1968    'mantelpiece_clock':'\ud83d\udd70',
1969    'maple_leaf':'\ud83c\udf41',
1970    'martial_arts_uniform':'\ud83e\udd4b',
1971    'mask':'\ud83d\ude37',
1972    'massage_woman':'\ud83d\udc86',
1973    'massage_man':'\ud83d\udc86&zwj;\u2642\ufe0f',
1974    'meat_on_bone':'\ud83c\udf56',
1975    'medal_military':'\ud83c\udf96',
1976    'medal_sports':'\ud83c\udfc5',
1977    'mega':'\ud83d\udce3',
1978    'melon':'\ud83c\udf48',
1979    'memo':'\ud83d\udcdd',
1980    'men_wrestling':'\ud83e\udd3c&zwj;\u2642\ufe0f',
1981    'menorah':'\ud83d\udd4e',
1982    'mens':'\ud83d\udeb9',
1983    'metal':'\ud83e\udd18',
1984    'metro':'\ud83d\ude87',
1985    'microphone':'\ud83c\udfa4',
1986    'microscope':'\ud83d\udd2c',
1987    'milk_glass':'\ud83e\udd5b',
1988    'milky_way':'\ud83c\udf0c',
1989    'minibus':'\ud83d\ude90',
1990    'minidisc':'\ud83d\udcbd',
1991    'mobile_phone_off':'\ud83d\udcf4',
1992    'money_mouth_face':'\ud83e\udd11',
1993    'money_with_wings':'\ud83d\udcb8',
1994    'moneybag':'\ud83d\udcb0',
1995    'monkey':'\ud83d\udc12',
1996    'monkey_face':'\ud83d\udc35',
1997    'monorail':'\ud83d\ude9d',
1998    'moon':'\ud83c\udf14',
1999    'mortar_board':'\ud83c\udf93',
2000    'mosque':'\ud83d\udd4c',
2001    'motor_boat':'\ud83d\udee5',
2002    'motor_scooter':'\ud83d\udef5',
2003    'motorcycle':'\ud83c\udfcd',
2004    'motorway':'\ud83d\udee3',
2005    'mount_fuji':'\ud83d\uddfb',
2006    'mountain':'\u26f0',
2007    'mountain_biking_man':'\ud83d\udeb5',
2008    'mountain_biking_woman':'\ud83d\udeb5&zwj;\u2640\ufe0f',
2009    'mountain_cableway':'\ud83d\udea0',
2010    'mountain_railway':'\ud83d\ude9e',
2011    'mountain_snow':'\ud83c\udfd4',
2012    'mouse':'\ud83d\udc2d',
2013    'mouse2':'\ud83d\udc01',
2014    'movie_camera':'\ud83c\udfa5',
2015    'moyai':'\ud83d\uddff',
2016    'mrs_claus':'\ud83e\udd36',
2017    'muscle':'\ud83d\udcaa',
2018    'mushroom':'\ud83c\udf44',
2019    'musical_keyboard':'\ud83c\udfb9',
2020    'musical_note':'\ud83c\udfb5',
2021    'musical_score':'\ud83c\udfbc',
2022    'mute':'\ud83d\udd07',
2023    'nail_care':'\ud83d\udc85',
2024    'name_badge':'\ud83d\udcdb',
2025    'national_park':'\ud83c\udfde',
2026    'nauseated_face':'\ud83e\udd22',
2027    'necktie':'\ud83d\udc54',
2028    'negative_squared_cross_mark':'\u274e',
2029    'nerd_face':'\ud83e\udd13',
2030    'neutral_face':'\ud83d\ude10',
2031    'new':'\ud83c\udd95',
2032    'new_moon':'\ud83c\udf11',
2033    'new_moon_with_face':'\ud83c\udf1a',
2034    'newspaper':'\ud83d\udcf0',
2035    'newspaper_roll':'\ud83d\uddde',
2036    'next_track_button':'\u23ed',
2037    'ng':'\ud83c\udd96',
2038    'no_good_man':'\ud83d\ude45&zwj;\u2642\ufe0f',
2039    'no_good_woman':'\ud83d\ude45',
2040    'night_with_stars':'\ud83c\udf03',
2041    'no_bell':'\ud83d\udd15',
2042    'no_bicycles':'\ud83d\udeb3',
2043    'no_entry':'\u26d4\ufe0f',
2044    'no_entry_sign':'\ud83d\udeab',
2045    'no_mobile_phones':'\ud83d\udcf5',
2046    'no_mouth':'\ud83d\ude36',
2047    'no_pedestrians':'\ud83d\udeb7',
2048    'no_smoking':'\ud83d\udead',
2049    'non-potable_water':'\ud83d\udeb1',
2050    'nose':'\ud83d\udc43',
2051    'notebook':'\ud83d\udcd3',
2052    'notebook_with_decorative_cover':'\ud83d\udcd4',
2053    'notes':'\ud83c\udfb6',
2054    'nut_and_bolt':'\ud83d\udd29',
2055    'o':'\u2b55\ufe0f',
2056    'o2':'\ud83c\udd7e\ufe0f',
2057    'ocean':'\ud83c\udf0a',
2058    'octopus':'\ud83d\udc19',
2059    'oden':'\ud83c\udf62',
2060    'office':'\ud83c\udfe2',
2061    'oil_drum':'\ud83d\udee2',
2062    'ok':'\ud83c\udd97',
2063    'ok_hand':'\ud83d\udc4c',
2064    'ok_man':'\ud83d\ude46&zwj;\u2642\ufe0f',
2065    'ok_woman':'\ud83d\ude46',
2066    'old_key':'\ud83d\udddd',
2067    'older_man':'\ud83d\udc74',
2068    'older_woman':'\ud83d\udc75',
2069    'om':'\ud83d\udd49',
2070    'on':'\ud83d\udd1b',
2071    'oncoming_automobile':'\ud83d\ude98',
2072    'oncoming_bus':'\ud83d\ude8d',
2073    'oncoming_police_car':'\ud83d\ude94',
2074    'oncoming_taxi':'\ud83d\ude96',
2075    'open_file_folder':'\ud83d\udcc2',
2076    'open_hands':'\ud83d\udc50',
2077    'open_mouth':'\ud83d\ude2e',
2078    'open_umbrella':'\u2602\ufe0f',
2079    'ophiuchus':'\u26ce',
2080    'orange_book':'\ud83d\udcd9',
2081    'orthodox_cross':'\u2626\ufe0f',
2082    'outbox_tray':'\ud83d\udce4',
2083    'owl':'\ud83e\udd89',
2084    'ox':'\ud83d\udc02',
2085    'package':'\ud83d\udce6',
2086    'page_facing_up':'\ud83d\udcc4',
2087    'page_with_curl':'\ud83d\udcc3',
2088    'pager':'\ud83d\udcdf',
2089    'paintbrush':'\ud83d\udd8c',
2090    'palm_tree':'\ud83c\udf34',
2091    'pancakes':'\ud83e\udd5e',
2092    'panda_face':'\ud83d\udc3c',
2093    'paperclip':'\ud83d\udcce',
2094    'paperclips':'\ud83d\udd87',
2095    'parasol_on_ground':'\u26f1',
2096    'parking':'\ud83c\udd7f\ufe0f',
2097    'part_alternation_mark':'\u303d\ufe0f',
2098    'partly_sunny':'\u26c5\ufe0f',
2099    'passenger_ship':'\ud83d\udef3',
2100    'passport_control':'\ud83d\udec2',
2101    'pause_button':'\u23f8',
2102    'peace_symbol':'\u262e\ufe0f',
2103    'peach':'\ud83c\udf51',
2104    'peanuts':'\ud83e\udd5c',
2105    'pear':'\ud83c\udf50',
2106    'pen':'\ud83d\udd8a',
2107    'pencil2':'\u270f\ufe0f',
2108    'penguin':'\ud83d\udc27',
2109    'pensive':'\ud83d\ude14',
2110    'performing_arts':'\ud83c\udfad',
2111    'persevere':'\ud83d\ude23',
2112    'person_fencing':'\ud83e\udd3a',
2113    'pouting_woman':'\ud83d\ude4e',
2114    'phone':'\u260e\ufe0f',
2115    'pick':'\u26cf',
2116    'pig':'\ud83d\udc37',
2117    'pig2':'\ud83d\udc16',
2118    'pig_nose':'\ud83d\udc3d',
2119    'pill':'\ud83d\udc8a',
2120    'pineapple':'\ud83c\udf4d',
2121    'ping_pong':'\ud83c\udfd3',
2122    'pisces':'\u2653\ufe0f',
2123    'pizza':'\ud83c\udf55',
2124    'place_of_worship':'\ud83d\uded0',
2125    'plate_with_cutlery':'\ud83c\udf7d',
2126    'play_or_pause_button':'\u23ef',
2127    'point_down':'\ud83d\udc47',
2128    'point_left':'\ud83d\udc48',
2129    'point_right':'\ud83d\udc49',
2130    'point_up':'\u261d\ufe0f',
2131    'point_up_2':'\ud83d\udc46',
2132    'police_car':'\ud83d\ude93',
2133    'policewoman':'\ud83d\udc6e&zwj;\u2640\ufe0f',
2134    'poodle':'\ud83d\udc29',
2135    'popcorn':'\ud83c\udf7f',
2136    'post_office':'\ud83c\udfe3',
2137    'postal_horn':'\ud83d\udcef',
2138    'postbox':'\ud83d\udcee',
2139    'potable_water':'\ud83d\udeb0',
2140    'potato':'\ud83e\udd54',
2141    'pouch':'\ud83d\udc5d',
2142    'poultry_leg':'\ud83c\udf57',
2143    'pound':'\ud83d\udcb7',
2144    'rage':'\ud83d\ude21',
2145    'pouting_cat':'\ud83d\ude3e',
2146    'pouting_man':'\ud83d\ude4e&zwj;\u2642\ufe0f',
2147    'pray':'\ud83d\ude4f',
2148    'prayer_beads':'\ud83d\udcff',
2149    'pregnant_woman':'\ud83e\udd30',
2150    'previous_track_button':'\u23ee',
2151    'prince':'\ud83e\udd34',
2152    'princess':'\ud83d\udc78',
2153    'printer':'\ud83d\udda8',
2154    'purple_heart':'\ud83d\udc9c',
2155    'purse':'\ud83d\udc5b',
2156    'pushpin':'\ud83d\udccc',
2157    'put_litter_in_its_place':'\ud83d\udeae',
2158    'question':'\u2753',
2159    'rabbit':'\ud83d\udc30',
2160    'rabbit2':'\ud83d\udc07',
2161    'racehorse':'\ud83d\udc0e',
2162    'racing_car':'\ud83c\udfce',
2163    'radio':'\ud83d\udcfb',
2164    'radio_button':'\ud83d\udd18',
2165    'radioactive':'\u2622\ufe0f',
2166    'railway_car':'\ud83d\ude83',
2167    'railway_track':'\ud83d\udee4',
2168    'rainbow':'\ud83c\udf08',
2169    'rainbow_flag':'\ud83c\udff3\ufe0f&zwj;\ud83c\udf08',
2170    'raised_back_of_hand':'\ud83e\udd1a',
2171    'raised_hand_with_fingers_splayed':'\ud83d\udd90',
2172    'raised_hands':'\ud83d\ude4c',
2173    'raising_hand_woman':'\ud83d\ude4b',
2174    'raising_hand_man':'\ud83d\ude4b&zwj;\u2642\ufe0f',
2175    'ram':'\ud83d\udc0f',
2176    'ramen':'\ud83c\udf5c',
2177    'rat':'\ud83d\udc00',
2178    'record_button':'\u23fa',
2179    'recycle':'\u267b\ufe0f',
2180    'red_circle':'\ud83d\udd34',
2181    'registered':'\u00ae\ufe0f',
2182    'relaxed':'\u263a\ufe0f',
2183    'relieved':'\ud83d\ude0c',
2184    'reminder_ribbon':'\ud83c\udf97',
2185    'repeat':'\ud83d\udd01',
2186    'repeat_one':'\ud83d\udd02',
2187    'rescue_worker_helmet':'\u26d1',
2188    'restroom':'\ud83d\udebb',
2189    'revolving_hearts':'\ud83d\udc9e',
2190    'rewind':'\u23ea',
2191    'rhinoceros':'\ud83e\udd8f',
2192    'ribbon':'\ud83c\udf80',
2193    'rice':'\ud83c\udf5a',
2194    'rice_ball':'\ud83c\udf59',
2195    'rice_cracker':'\ud83c\udf58',
2196    'rice_scene':'\ud83c\udf91',
2197    'right_anger_bubble':'\ud83d\uddef',
2198    'ring':'\ud83d\udc8d',
2199    'robot':'\ud83e\udd16',
2200    'rocket':'\ud83d\ude80',
2201    'rofl':'\ud83e\udd23',
2202    'roll_eyes':'\ud83d\ude44',
2203    'roller_coaster':'\ud83c\udfa2',
2204    'rooster':'\ud83d\udc13',
2205    'rose':'\ud83c\udf39',
2206    'rosette':'\ud83c\udff5',
2207    'rotating_light':'\ud83d\udea8',
2208    'round_pushpin':'\ud83d\udccd',
2209    'rowing_man':'\ud83d\udea3',
2210    'rowing_woman':'\ud83d\udea3&zwj;\u2640\ufe0f',
2211    'rugby_football':'\ud83c\udfc9',
2212    'running_man':'\ud83c\udfc3',
2213    'running_shirt_with_sash':'\ud83c\udfbd',
2214    'running_woman':'\ud83c\udfc3&zwj;\u2640\ufe0f',
2215    'sa':'\ud83c\ude02\ufe0f',
2216    'sagittarius':'\u2650\ufe0f',
2217    'sake':'\ud83c\udf76',
2218    'sandal':'\ud83d\udc61',
2219    'santa':'\ud83c\udf85',
2220    'satellite':'\ud83d\udce1',
2221    'saxophone':'\ud83c\udfb7',
2222    'school':'\ud83c\udfeb',
2223    'school_satchel':'\ud83c\udf92',
2224    'scissors':'\u2702\ufe0f',
2225    'scorpion':'\ud83e\udd82',
2226    'scorpius':'\u264f\ufe0f',
2227    'scream':'\ud83d\ude31',
2228    'scream_cat':'\ud83d\ude40',
2229    'scroll':'\ud83d\udcdc',
2230    'seat':'\ud83d\udcba',
2231    'secret':'\u3299\ufe0f',
2232    'see_no_evil':'\ud83d\ude48',
2233    'seedling':'\ud83c\udf31',
2234    'selfie':'\ud83e\udd33',
2235    'shallow_pan_of_food':'\ud83e\udd58',
2236    'shamrock':'\u2618\ufe0f',
2237    'shark':'\ud83e\udd88',
2238    'shaved_ice':'\ud83c\udf67',
2239    'sheep':'\ud83d\udc11',
2240    'shell':'\ud83d\udc1a',
2241    'shield':'\ud83d\udee1',
2242    'shinto_shrine':'\u26e9',
2243    'ship':'\ud83d\udea2',
2244    'shirt':'\ud83d\udc55',
2245    'shopping':'\ud83d\udecd',
2246    'shopping_cart':'\ud83d\uded2',
2247    'shower':'\ud83d\udebf',
2248    'shrimp':'\ud83e\udd90',
2249    'signal_strength':'\ud83d\udcf6',
2250    'six_pointed_star':'\ud83d\udd2f',
2251    'ski':'\ud83c\udfbf',
2252    'skier':'\u26f7',
2253    'skull':'\ud83d\udc80',
2254    'skull_and_crossbones':'\u2620\ufe0f',
2255    'sleeping':'\ud83d\ude34',
2256    'sleeping_bed':'\ud83d\udecc',
2257    'sleepy':'\ud83d\ude2a',
2258    'slightly_frowning_face':'\ud83d\ude41',
2259    'slightly_smiling_face':'\ud83d\ude42',
2260    'slot_machine':'\ud83c\udfb0',
2261    'small_airplane':'\ud83d\udee9',
2262    'small_blue_diamond':'\ud83d\udd39',
2263    'small_orange_diamond':'\ud83d\udd38',
2264    'small_red_triangle':'\ud83d\udd3a',
2265    'small_red_triangle_down':'\ud83d\udd3b',
2266    'smile':'\ud83d\ude04',
2267    'smile_cat':'\ud83d\ude38',
2268    'smiley':'\ud83d\ude03',
2269    'smiley_cat':'\ud83d\ude3a',
2270    'smiling_imp':'\ud83d\ude08',
2271    'smirk':'\ud83d\ude0f',
2272    'smirk_cat':'\ud83d\ude3c',
2273    'smoking':'\ud83d\udeac',
2274    'snail':'\ud83d\udc0c',
2275    'snake':'\ud83d\udc0d',
2276    'sneezing_face':'\ud83e\udd27',
2277    'snowboarder':'\ud83c\udfc2',
2278    'snowflake':'\u2744\ufe0f',
2279    'snowman':'\u26c4\ufe0f',
2280    'snowman_with_snow':'\u2603\ufe0f',
2281    'sob':'\ud83d\ude2d',
2282    'soccer':'\u26bd\ufe0f',
2283    'soon':'\ud83d\udd1c',
2284    'sos':'\ud83c\udd98',
2285    'sound':'\ud83d\udd09',
2286    'space_invader':'\ud83d\udc7e',
2287    'spades':'\u2660\ufe0f',
2288    'spaghetti':'\ud83c\udf5d',
2289    'sparkle':'\u2747\ufe0f',
2290    'sparkler':'\ud83c\udf87',
2291    'sparkles':'\u2728',
2292    'sparkling_heart':'\ud83d\udc96',
2293    'speak_no_evil':'\ud83d\ude4a',
2294    'speaker':'\ud83d\udd08',
2295    'speaking_head':'\ud83d\udde3',
2296    'speech_balloon':'\ud83d\udcac',
2297    'speedboat':'\ud83d\udea4',
2298    'spider':'\ud83d\udd77',
2299    'spider_web':'\ud83d\udd78',
2300    'spiral_calendar':'\ud83d\uddd3',
2301    'spiral_notepad':'\ud83d\uddd2',
2302    'spoon':'\ud83e\udd44',
2303    'squid':'\ud83e\udd91',
2304    'stadium':'\ud83c\udfdf',
2305    'star':'\u2b50\ufe0f',
2306    'star2':'\ud83c\udf1f',
2307    'star_and_crescent':'\u262a\ufe0f',
2308    'star_of_david':'\u2721\ufe0f',
2309    'stars':'\ud83c\udf20',
2310    'station':'\ud83d\ude89',
2311    'statue_of_liberty':'\ud83d\uddfd',
2312    'steam_locomotive':'\ud83d\ude82',
2313    'stew':'\ud83c\udf72',
2314    'stop_button':'\u23f9',
2315    'stop_sign':'\ud83d\uded1',
2316    'stopwatch':'\u23f1',
2317    'straight_ruler':'\ud83d\udccf',
2318    'strawberry':'\ud83c\udf53',
2319    'stuck_out_tongue':'\ud83d\ude1b',
2320    'stuck_out_tongue_closed_eyes':'\ud83d\ude1d',
2321    'stuck_out_tongue_winking_eye':'\ud83d\ude1c',
2322    'studio_microphone':'\ud83c\udf99',
2323    'stuffed_flatbread':'\ud83e\udd59',
2324    'sun_behind_large_cloud':'\ud83c\udf25',
2325    'sun_behind_rain_cloud':'\ud83c\udf26',
2326    'sun_behind_small_cloud':'\ud83c\udf24',
2327    'sun_with_face':'\ud83c\udf1e',
2328    'sunflower':'\ud83c\udf3b',
2329    'sunglasses':'\ud83d\ude0e',
2330    'sunny':'\u2600\ufe0f',
2331    'sunrise':'\ud83c\udf05',
2332    'sunrise_over_mountains':'\ud83c\udf04',
2333    'surfing_man':'\ud83c\udfc4',
2334    'surfing_woman':'\ud83c\udfc4&zwj;\u2640\ufe0f',
2335    'sushi':'\ud83c\udf63',
2336    'suspension_railway':'\ud83d\ude9f',
2337    'sweat':'\ud83d\ude13',
2338    'sweat_drops':'\ud83d\udca6',
2339    'sweat_smile':'\ud83d\ude05',
2340    'sweet_potato':'\ud83c\udf60',
2341    'swimming_man':'\ud83c\udfca',
2342    'swimming_woman':'\ud83c\udfca&zwj;\u2640\ufe0f',
2343    'symbols':'\ud83d\udd23',
2344    'synagogue':'\ud83d\udd4d',
2345    'syringe':'\ud83d\udc89',
2346    'taco':'\ud83c\udf2e',
2347    'tada':'\ud83c\udf89',
2348    'tanabata_tree':'\ud83c\udf8b',
2349    'taurus':'\u2649\ufe0f',
2350    'taxi':'\ud83d\ude95',
2351    'tea':'\ud83c\udf75',
2352    'telephone_receiver':'\ud83d\udcde',
2353    'telescope':'\ud83d\udd2d',
2354    'tennis':'\ud83c\udfbe',
2355    'tent':'\u26fa\ufe0f',
2356    'thermometer':'\ud83c\udf21',
2357    'thinking':'\ud83e\udd14',
2358    'thought_balloon':'\ud83d\udcad',
2359    'ticket':'\ud83c\udfab',
2360    'tickets':'\ud83c\udf9f',
2361    'tiger':'\ud83d\udc2f',
2362    'tiger2':'\ud83d\udc05',
2363    'timer_clock':'\u23f2',
2364    'tipping_hand_man':'\ud83d\udc81&zwj;\u2642\ufe0f',
2365    'tired_face':'\ud83d\ude2b',
2366    'tm':'\u2122\ufe0f',
2367    'toilet':'\ud83d\udebd',
2368    'tokyo_tower':'\ud83d\uddfc',
2369    'tomato':'\ud83c\udf45',
2370    'tongue':'\ud83d\udc45',
2371    'top':'\ud83d\udd1d',
2372    'tophat':'\ud83c\udfa9',
2373    'tornado':'\ud83c\udf2a',
2374    'trackball':'\ud83d\uddb2',
2375    'tractor':'\ud83d\ude9c',
2376    'traffic_light':'\ud83d\udea5',
2377    'train':'\ud83d\ude8b',
2378    'train2':'\ud83d\ude86',
2379    'tram':'\ud83d\ude8a',
2380    'triangular_flag_on_post':'\ud83d\udea9',
2381    'triangular_ruler':'\ud83d\udcd0',
2382    'trident':'\ud83d\udd31',
2383    'triumph':'\ud83d\ude24',
2384    'trolleybus':'\ud83d\ude8e',
2385    'trophy':'\ud83c\udfc6',
2386    'tropical_drink':'\ud83c\udf79',
2387    'tropical_fish':'\ud83d\udc20',
2388    'truck':'\ud83d\ude9a',
2389    'trumpet':'\ud83c\udfba',
2390    'tulip':'\ud83c\udf37',
2391    'tumbler_glass':'\ud83e\udd43',
2392    'turkey':'\ud83e\udd83',
2393    'turtle':'\ud83d\udc22',
2394    'tv':'\ud83d\udcfa',
2395    'twisted_rightwards_arrows':'\ud83d\udd00',
2396    'two_hearts':'\ud83d\udc95',
2397    'two_men_holding_hands':'\ud83d\udc6c',
2398    'two_women_holding_hands':'\ud83d\udc6d',
2399    'u5272':'\ud83c\ude39',
2400    'u5408':'\ud83c\ude34',
2401    'u55b6':'\ud83c\ude3a',
2402    'u6307':'\ud83c\ude2f\ufe0f',
2403    'u6708':'\ud83c\ude37\ufe0f',
2404    'u6709':'\ud83c\ude36',
2405    'u6e80':'\ud83c\ude35',
2406    'u7121':'\ud83c\ude1a\ufe0f',
2407    'u7533':'\ud83c\ude38',
2408    'u7981':'\ud83c\ude32',
2409    'u7a7a':'\ud83c\ude33',
2410    'umbrella':'\u2614\ufe0f',
2411    'unamused':'\ud83d\ude12',
2412    'underage':'\ud83d\udd1e',
2413    'unicorn':'\ud83e\udd84',
2414    'unlock':'\ud83d\udd13',
2415    'up':'\ud83c\udd99',
2416    'upside_down_face':'\ud83d\ude43',
2417    'v':'\u270c\ufe0f',
2418    'vertical_traffic_light':'\ud83d\udea6',
2419    'vhs':'\ud83d\udcfc',
2420    'vibration_mode':'\ud83d\udcf3',
2421    'video_camera':'\ud83d\udcf9',
2422    'video_game':'\ud83c\udfae',
2423    'violin':'\ud83c\udfbb',
2424    'virgo':'\u264d\ufe0f',
2425    'volcano':'\ud83c\udf0b',
2426    'volleyball':'\ud83c\udfd0',
2427    'vs':'\ud83c\udd9a',
2428    'vulcan_salute':'\ud83d\udd96',
2429    'walking_man':'\ud83d\udeb6',
2430    'walking_woman':'\ud83d\udeb6&zwj;\u2640\ufe0f',
2431    'waning_crescent_moon':'\ud83c\udf18',
2432    'waning_gibbous_moon':'\ud83c\udf16',
2433    'warning':'\u26a0\ufe0f',
2434    'wastebasket':'\ud83d\uddd1',
2435    'watch':'\u231a\ufe0f',
2436    'water_buffalo':'\ud83d\udc03',
2437    'watermelon':'\ud83c\udf49',
2438    'wave':'\ud83d\udc4b',
2439    'wavy_dash':'\u3030\ufe0f',
2440    'waxing_crescent_moon':'\ud83c\udf12',
2441    'wc':'\ud83d\udebe',
2442    'weary':'\ud83d\ude29',
2443    'wedding':'\ud83d\udc92',
2444    'weight_lifting_man':'\ud83c\udfcb\ufe0f',
2445    'weight_lifting_woman':'\ud83c\udfcb\ufe0f&zwj;\u2640\ufe0f',
2446    'whale':'\ud83d\udc33',
2447    'whale2':'\ud83d\udc0b',
2448    'wheel_of_dharma':'\u2638\ufe0f',
2449    'wheelchair':'\u267f\ufe0f',
2450    'white_check_mark':'\u2705',
2451    'white_circle':'\u26aa\ufe0f',
2452    'white_flag':'\ud83c\udff3\ufe0f',
2453    'white_flower':'\ud83d\udcae',
2454    'white_large_square':'\u2b1c\ufe0f',
2455    'white_medium_small_square':'\u25fd\ufe0f',
2456    'white_medium_square':'\u25fb\ufe0f',
2457    'white_small_square':'\u25ab\ufe0f',
2458    'white_square_button':'\ud83d\udd33',
2459    'wilted_flower':'\ud83e\udd40',
2460    'wind_chime':'\ud83c\udf90',
2461    'wind_face':'\ud83c\udf2c',
2462    'wine_glass':'\ud83c\udf77',
2463    'wink':'\ud83d\ude09',
2464    'wolf':'\ud83d\udc3a',
2465    'woman':'\ud83d\udc69',
2466    'woman_artist':'\ud83d\udc69&zwj;\ud83c\udfa8',
2467    'woman_astronaut':'\ud83d\udc69&zwj;\ud83d\ude80',
2468    'woman_cartwheeling':'\ud83e\udd38&zwj;\u2640\ufe0f',
2469    'woman_cook':'\ud83d\udc69&zwj;\ud83c\udf73',
2470    'woman_facepalming':'\ud83e\udd26&zwj;\u2640\ufe0f',
2471    'woman_factory_worker':'\ud83d\udc69&zwj;\ud83c\udfed',
2472    'woman_farmer':'\ud83d\udc69&zwj;\ud83c\udf3e',
2473    'woman_firefighter':'\ud83d\udc69&zwj;\ud83d\ude92',
2474    'woman_health_worker':'\ud83d\udc69&zwj;\u2695\ufe0f',
2475    'woman_judge':'\ud83d\udc69&zwj;\u2696\ufe0f',
2476    'woman_juggling':'\ud83e\udd39&zwj;\u2640\ufe0f',
2477    'woman_mechanic':'\ud83d\udc69&zwj;\ud83d\udd27',
2478    'woman_office_worker':'\ud83d\udc69&zwj;\ud83d\udcbc',
2479    'woman_pilot':'\ud83d\udc69&zwj;\u2708\ufe0f',
2480    'woman_playing_handball':'\ud83e\udd3e&zwj;\u2640\ufe0f',
2481    'woman_playing_water_polo':'\ud83e\udd3d&zwj;\u2640\ufe0f',
2482    'woman_scientist':'\ud83d\udc69&zwj;\ud83d\udd2c',
2483    'woman_shrugging':'\ud83e\udd37&zwj;\u2640\ufe0f',
2484    'woman_singer':'\ud83d\udc69&zwj;\ud83c\udfa4',
2485    'woman_student':'\ud83d\udc69&zwj;\ud83c\udf93',
2486    'woman_teacher':'\ud83d\udc69&zwj;\ud83c\udfeb',
2487    'woman_technologist':'\ud83d\udc69&zwj;\ud83d\udcbb',
2488    'woman_with_turban':'\ud83d\udc73&zwj;\u2640\ufe0f',
2489    'womans_clothes':'\ud83d\udc5a',
2490    'womans_hat':'\ud83d\udc52',
2491    'women_wrestling':'\ud83e\udd3c&zwj;\u2640\ufe0f',
2492    'womens':'\ud83d\udeba',
2493    'world_map':'\ud83d\uddfa',
2494    'worried':'\ud83d\ude1f',
2495    'wrench':'\ud83d\udd27',
2496    'writing_hand':'\u270d\ufe0f',
2497    'x':'\u274c',
2498    'yellow_heart':'\ud83d\udc9b',
2499    'yen':'\ud83d\udcb4',
2500    'yin_yang':'\u262f\ufe0f',
2501    'yum':'\ud83d\ude0b',
2502    'zap':'\u26a1\ufe0f',
2503    'zipper_mouth_face':'\ud83e\udd10',
2504    'zzz':'\ud83d\udca4',
2505  
2506    /* special emojis :P */
2507    'octocat':  '<img alt=":octocat:" height="20" width="20" align="absmiddle" src="https://assets-cdn.github.com/images/icons/emoji/octocat.png">',
2508    '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>'
2509  };
2510  
2511  /**
2512   * Created by Estevao on 31-05-2015.
2513   */
2514  
2515  /**
2516   * Showdown Converter class
2517   * @class
2518   * @param {object} [converterOptions]
2519   * @returns {Converter}
2520   */
2521  showdown.Converter = function (converterOptions) {
2522    'use strict';
2523  
2524    var
2525        /**
2526         * Options used by this converter
2527         * @private
2528         * @type {{}}
2529         */
2530        options = {},
2531  
2532        /**
2533         * Language extensions used by this converter
2534         * @private
2535         * @type {Array}
2536         */
2537        langExtensions = [],
2538  
2539        /**
2540         * Output modifiers extensions used by this converter
2541         * @private
2542         * @type {Array}
2543         */
2544        outputModifiers = [],
2545  
2546        /**
2547         * Event listeners
2548         * @private
2549         * @type {{}}
2550         */
2551        listeners = {},
2552  
2553        /**
2554         * The flavor set in this converter
2555         */
2556        setConvFlavor = setFlavor,
2557  
2558        /**
2559         * Metadata of the document
2560         * @type {{parsed: {}, raw: string, format: string}}
2561         */
2562        metadata = {
2563          parsed: {},
2564          raw: '',
2565          format: ''
2566        };
2567  
2568    _constructor();
2569  
2570    /**
2571     * Converter constructor
2572     * @private
2573     */
2574    function _constructor () {
2575      converterOptions = converterOptions || {};
2576  
2577      for (var gOpt in globalOptions) {
2578        if (globalOptions.hasOwnProperty(gOpt)) {
2579          options[gOpt] = globalOptions[gOpt];
2580        }
2581      }
2582  
2583      // Merge options
2584      if (typeof converterOptions === 'object') {
2585        for (var opt in converterOptions) {
2586          if (converterOptions.hasOwnProperty(opt)) {
2587            options[opt] = converterOptions[opt];
2588          }
2589        }
2590      } else {
2591        throw Error('Converter expects the passed parameter to be an object, but ' + typeof converterOptions +
2592        ' was passed instead.');
2593      }
2594  
2595      if (options.extensions) {
2596        showdown.helper.forEach(options.extensions, _parseExtension);
2597      }
2598    }
2599  
2600    /**
2601     * Parse extension
2602     * @param {*} ext
2603     * @param {string} [name='']
2604     * @private
2605     */
2606    function _parseExtension (ext, name) {
2607  
2608      name = name || null;
2609      // If it's a string, the extension was previously loaded
2610      if (showdown.helper.isString(ext)) {
2611        ext = showdown.helper.stdExtName(ext);
2612        name = ext;
2613  
2614        // LEGACY_SUPPORT CODE
2615        if (showdown.extensions[ext]) {
2616          console.warn('DEPRECATION WARNING: ' + ext + ' is an old extension that uses a deprecated loading method.' +
2617            'Please inform the developer that the extension should be updated!');
2618          legacyExtensionLoading(showdown.extensions[ext], ext);
2619          return;
2620          // END LEGACY SUPPORT CODE
2621  
2622        } else if (!showdown.helper.isUndefined(extensions[ext])) {
2623          ext = extensions[ext];
2624  
2625        } else {
2626          throw Error('Extension "' + ext + '" could not be loaded. It was either not found or is not a valid extension.');
2627        }
2628      }
2629  
2630      if (typeof ext === 'function') {
2631        ext = ext();
2632      }
2633  
2634      if (!showdown.helper.isArray(ext)) {
2635        ext = [ext];
2636      }
2637  
2638      var validExt = validate(ext, name);
2639      if (!validExt.valid) {
2640        throw Error(validExt.error);
2641      }
2642  
2643      for (var i = 0; i < ext.length; ++i) {
2644        switch (ext[i].type) {
2645  
2646          case 'lang':
2647            langExtensions.push(ext[i]);
2648            break;
2649  
2650          case 'output':
2651            outputModifiers.push(ext[i]);
2652            break;
2653        }
2654        if (ext[i].hasOwnProperty('listeners')) {
2655          for (var ln in ext[i].listeners) {
2656            if (ext[i].listeners.hasOwnProperty(ln)) {
2657              listen(ln, ext[i].listeners[ln]);
2658            }
2659          }
2660        }
2661      }
2662  
2663    }
2664  
2665    /**
2666     * LEGACY_SUPPORT
2667     * @param {*} ext
2668     * @param {string} name
2669     */
2670    function legacyExtensionLoading (ext, name) {
2671      if (typeof ext === 'function') {
2672        ext = ext(new showdown.Converter());
2673      }
2674      if (!showdown.helper.isArray(ext)) {
2675        ext = [ext];
2676      }
2677      var valid = validate(ext, name);
2678  
2679      if (!valid.valid) {
2680        throw Error(valid.error);
2681      }
2682  
2683      for (var i = 0; i < ext.length; ++i) {
2684        switch (ext[i].type) {
2685          case 'lang':
2686            langExtensions.push(ext[i]);
2687            break;
2688          case 'output':
2689            outputModifiers.push(ext[i]);
2690            break;
2691          default:// should never reach here
2692            throw Error('Extension loader error: Type unrecognized!!!');
2693        }
2694      }
2695    }
2696  
2697    /**
2698     * Listen to an event
2699     * @param {string} name
2700     * @param {function} callback
2701     */
2702    function listen (name, callback) {
2703      if (!showdown.helper.isString(name)) {
2704        throw Error('Invalid argument in converter.listen() method: name must be a string, but ' + typeof name + ' given');
2705      }
2706  
2707      if (typeof callback !== 'function') {
2708        throw Error('Invalid argument in converter.listen() method: callback must be a function, but ' + typeof callback + ' given');
2709      }
2710  
2711      if (!listeners.hasOwnProperty(name)) {
2712        listeners[name] = [];
2713      }
2714      listeners[name].push(callback);
2715    }
2716  
2717    function rTrimInputText (text) {
2718      var rsp = text.match(/^\s*/)[0].length,
2719          rgx = new RegExp('^\\s{0,' + rsp + '}', 'gm');
2720      return text.replace(rgx, '');
2721    }
2722  
2723    /**
2724     * Dispatch an event
2725     * @private
2726     * @param {string} evtName Event name
2727     * @param {string} text Text
2728     * @param {{}} options Converter Options
2729     * @param {{}} globals
2730     * @returns {string}
2731     */
2732    this._dispatch = function dispatch (evtName, text, options, globals) {
2733      if (listeners.hasOwnProperty(evtName)) {
2734        for (var ei = 0; ei < listeners[evtName].length; ++ei) {
2735          var nText = listeners[evtName][ei](evtName, text, this, options, globals);
2736          if (nText && typeof nText !== 'undefined') {
2737            text = nText;
2738          }
2739        }
2740      }
2741      return text;
2742    };
2743  
2744    /**
2745     * Listen to an event
2746     * @param {string} name
2747     * @param {function} callback
2748     * @returns {showdown.Converter}
2749     */
2750    this.listen = function (name, callback) {
2751      listen(name, callback);
2752      return this;
2753    };
2754  
2755    /**
2756     * Converts a markdown string into HTML
2757     * @param {string} text
2758     * @returns {*}
2759     */
2760    this.makeHtml = function (text) {
2761      //check if text is not falsy
2762      if (!text) {
2763        return text;
2764      }
2765  
2766      var globals = {
2767        gHtmlBlocks:     [],
2768        gHtmlMdBlocks:   [],
2769        gHtmlSpans:      [],
2770        gUrls:           {},
2771        gTitles:         {},
2772        gDimensions:     {},
2773        gListLevel:      0,
2774        hashLinkCounts:  {},
2775        langExtensions:  langExtensions,
2776        outputModifiers: outputModifiers,
2777        converter:       this,
2778        ghCodeBlocks:    [],
2779        metadata: {
2780          parsed: {},
2781          raw: '',
2782          format: ''
2783        }
2784      };
2785  
2786      // This lets us use ¨ trema as an escape char to avoid md5 hashes
2787      // The choice of character is arbitrary; anything that isn't
2788      // magic in Markdown will work.
2789      text = text.replace(/¨/g, '¨T');
2790  
2791      // Replace $ with ¨D
2792      // RegExp interprets $ as a special character
2793      // when it's in a replacement string
2794      text = text.replace(/\$/g, '¨D');
2795  
2796      // Standardize line endings
2797      text = text.replace(/\r\n/g, '\n'); // DOS to Unix
2798      text = text.replace(/\r/g, '\n'); // Mac to Unix
2799  
2800      // Stardardize line spaces
2801      text = text.replace(/\u00A0/g, '&nbsp;');
2802  
2803      if (options.smartIndentationFix) {
2804        text = rTrimInputText(text);
2805      }
2806  
2807      // Make sure text begins and ends with a couple of newlines:
2808      text = '\n\n' + text + '\n\n';
2809  
2810      // detab
2811      text = showdown.subParser('detab')(text, options, globals);
2812  
2813      /**
2814       * Strip any lines consisting only of spaces and tabs.
2815       * This makes subsequent regexs easier to write, because we can
2816       * match consecutive blank lines with /\n+/ instead of something
2817       * contorted like /[ \t]*\n+/
2818       */
2819      text = text.replace(/^[ \t]+$/mg, '');
2820  
2821      //run languageExtensions
2822      showdown.helper.forEach(langExtensions, function (ext) {
2823        text = showdown.subParser('runExtension')(ext, text, options, globals);
2824      });
2825  
2826      // run the sub parsers
2827      text = showdown.subParser('metadata')(text, options, globals);
2828      text = showdown.subParser('hashPreCodeTags')(text, options, globals);
2829      text = showdown.subParser('githubCodeBlocks')(text, options, globals);
2830      text = showdown.subParser('hashHTMLBlocks')(text, options, globals);
2831      text = showdown.subParser('hashCodeTags')(text, options, globals);
2832      text = showdown.subParser('stripLinkDefinitions')(text, options, globals);
2833      text = showdown.subParser('blockGamut')(text, options, globals);
2834      text = showdown.subParser('unhashHTMLSpans')(text, options, globals);
2835      text = showdown.subParser('unescapeSpecialChars')(text, options, globals);
2836  
2837      // attacklab: Restore dollar signs
2838      text = text.replace(/¨D/g, '$$');
2839  
2840      // attacklab: Restore tremas
2841      text = text.replace(/¨T/g, '¨');
2842  
2843      // render a complete html document instead of a partial if the option is enabled
2844      text = showdown.subParser('completeHTMLDocument')(text, options, globals);
2845  
2846      // Run output modifiers
2847      showdown.helper.forEach(outputModifiers, function (ext) {
2848        text = showdown.subParser('runExtension')(ext, text, options, globals);
2849      });
2850  
2851      // update metadata
2852      metadata = globals.metadata;
2853      return text;
2854    };
2855  
2856    /**
2857     * Converts an HTML string into a markdown string
2858     * @param src
2859     * @param [HTMLParser] A WHATWG DOM and HTML parser, such as JSDOM. If none is supplied, window.document will be used.
2860     * @returns {string}
2861     */
2862    this.makeMarkdown = this.makeMd = function (src, HTMLParser) {
2863  
2864      // replace \r\n with \n
2865      src = src.replace(/\r\n/g, '\n');
2866      src = src.replace(/\r/g, '\n'); // old macs
2867  
2868      // due to an edge case, we need to find this: > <
2869      // to prevent removing of non silent white spaces
2870      // ex: <em>this is</em> <strong>sparta</strong>
2871      src = src.replace(/>[ \t]+</, '>¨NBSP;<');
2872  
2873      if (!HTMLParser) {
2874        if (window && window.document) {
2875          HTMLParser = window.document;
2876        } else {
2877          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');
2878        }
2879      }
2880  
2881      var doc = HTMLParser.createElement('div');
2882      doc.innerHTML = src;
2883  
2884      var globals = {
2885        preList: substitutePreCodeTags(doc)
2886      };
2887  
2888      // remove all newlines and collapse spaces
2889      clean(doc);
2890  
2891      // some stuff, like accidental reference links must now be escaped
2892      // TODO
2893      // doc.innerHTML = doc.innerHTML.replace(/\[[\S\t ]]/);
2894  
2895      var nodes = doc.childNodes,
2896          mdDoc = '';
2897  
2898      for (var i = 0; i < nodes.length; i++) {
2899        mdDoc += showdown.subParser('makeMarkdown.node')(nodes[i], globals);
2900      }
2901  
2902      function clean (node) {
2903        for (var n = 0; n < node.childNodes.length; ++n) {
2904          var child = node.childNodes[n];
2905          if (child.nodeType === 3) {
2906            if (!/\S/.test(child.nodeValue)) {
2907              node.removeChild(child);
2908              --n;
2909            } else {
2910              child.nodeValue = child.nodeValue.split('\n').join(' ');
2911              child.nodeValue = child.nodeValue.replace(/(\s)+/g, '$1');
2912            }
2913          } else if (child.nodeType === 1) {
2914            clean(child);
2915          }
2916        }
2917      }
2918  
2919      // find all pre tags and replace contents with placeholder
2920      // we need this so that we can remove all indentation from html
2921      // to ease up parsing
2922      function substitutePreCodeTags (doc) {
2923  
2924        var pres = doc.querySelectorAll('pre'),
2925            presPH = [];
2926  
2927        for (var i = 0; i < pres.length; ++i) {
2928  
2929          if (pres[i].childElementCount === 1 && pres[i].firstChild.tagName.toLowerCase() === 'code') {
2930            var content = pres[i].firstChild.innerHTML.trim(),
2931                language = pres[i].firstChild.getAttribute('data-language') || '';
2932  
2933            // if data-language attribute is not defined, then we look for class language-*
2934            if (language === '') {
2935              var classes = pres[i].firstChild.className.split(' ');
2936              for (var c = 0; c < classes.length; ++c) {
2937                var matches = classes[c].match(/^language-(.+)$/);
2938                if (matches !== null) {
2939                  language = matches[1];
2940                  break;
2941                }
2942              }
2943            }
2944  
2945            // unescape html entities in content
2946            content = showdown.helper.unescapeHTMLEntities(content);
2947  
2948            presPH.push(content);
2949            pres[i].outerHTML = '<precode language="' + language + '" precodenum="' + i.toString() + '"></precode>';
2950          } else {
2951            presPH.push(pres[i].innerHTML);
2952            pres[i].innerHTML = '';
2953            pres[i].setAttribute('prenum', i.toString());
2954          }
2955        }
2956        return presPH;
2957      }
2958  
2959      return mdDoc;
2960    };
2961  
2962    /**
2963     * Set an option of this Converter instance
2964     * @param {string} key
2965     * @param {*} value
2966     */
2967    this.setOption = function (key, value) {
2968      options[key] = value;
2969    };
2970  
2971    /**
2972     * Get the option of this Converter instance
2973     * @param {string} key
2974     * @returns {*}
2975     */
2976    this.getOption = function (key) {
2977      return options[key];
2978    };
2979  
2980    /**
2981     * Get the options of this Converter instance
2982     * @returns {{}}
2983     */
2984    this.getOptions = function () {
2985      return options;
2986    };
2987  
2988    /**
2989     * Add extension to THIS converter
2990     * @param {{}} extension
2991     * @param {string} [name=null]
2992     */
2993    this.addExtension = function (extension, name) {
2994      name = name || null;
2995      _parseExtension(extension, name);
2996    };
2997  
2998    /**
2999     * Use a global registered extension with THIS converter
3000     * @param {string} extensionName Name of the previously registered extension
3001     */
3002    this.useExtension = function (extensionName) {
3003      _parseExtension(extensionName);
3004    };
3005  
3006    /**
3007     * Set the flavor THIS converter should use
3008     * @param {string} name
3009     */
3010    this.setFlavor = function (name) {
3011      if (!flavor.hasOwnProperty(name)) {
3012        throw Error(name + ' flavor was not found');
3013      }
3014      var preset = flavor[name];
3015      setConvFlavor = name;
3016      for (var option in preset) {
3017        if (preset.hasOwnProperty(option)) {
3018          options[option] = preset[option];
3019        }
3020      }
3021    };
3022  
3023    /**
3024     * Get the currently set flavor of this converter
3025     * @returns {string}
3026     */
3027    this.getFlavor = function () {
3028      return setConvFlavor;
3029    };
3030  
3031    /**
3032     * Remove an extension from THIS converter.
3033     * Note: This is a costly operation. It's better to initialize a new converter
3034     * and specify the extensions you wish to use
3035     * @param {Array} extension
3036     */
3037    this.removeExtension = function (extension) {
3038      if (!showdown.helper.isArray(extension)) {
3039        extension = [extension];
3040      }
3041      for (var a = 0; a < extension.length; ++a) {
3042        var ext = extension[a];
3043        for (var i = 0; i < langExtensions.length; ++i) {
3044          if (langExtensions[i] === ext) {
3045            langExtensions[i].splice(i, 1);
3046          }
3047        }
3048        for (var ii = 0; ii < outputModifiers.length; ++i) {
3049          if (outputModifiers[ii] === ext) {
3050            outputModifiers[ii].splice(i, 1);
3051          }
3052        }
3053      }
3054    };
3055  
3056    /**
3057     * Get all extension of THIS converter
3058     * @returns {{language: Array, output: Array}}
3059     */
3060    this.getAllExtensions = function () {
3061      return {
3062        language: langExtensions,
3063        output: outputModifiers
3064      };
3065    };
3066  
3067    /**
3068     * Get the metadata of the previously parsed document
3069     * @param raw
3070     * @returns {string|{}}
3071     */
3072    this.getMetadata = function (raw) {
3073      if (raw) {
3074        return metadata.raw;
3075      } else {
3076        return metadata.parsed;
3077      }
3078    };
3079  
3080    /**
3081     * Get the metadata format of the previously parsed document
3082     * @returns {string}
3083     */
3084    this.getMetadataFormat = function () {
3085      return metadata.format;
3086    };
3087  
3088    /**
3089     * Private: set a single key, value metadata pair
3090     * @param {string} key
3091     * @param {string} value
3092     */
3093    this._setMetadataPair = function (key, value) {
3094      metadata.parsed[key] = value;
3095    };
3096  
3097    /**
3098     * Private: set metadata format
3099     * @param {string} format
3100     */
3101    this._setMetadataFormat = function (format) {
3102      metadata.format = format;
3103    };
3104  
3105    /**
3106     * Private: set metadata raw text
3107     * @param {string} raw
3108     */
3109    this._setMetadataRaw = function (raw) {
3110      metadata.raw = raw;
3111    };
3112  };
3113  
3114  /**
3115   * Turn Markdown link shortcuts into XHTML <a> tags.
3116   */
3117  showdown.subParser('anchors', function (text, options, globals) {
3118    'use strict';
3119  
3120    text = globals.converter._dispatch('anchors.before', text, options, globals);
3121  
3122    var writeAnchorTag = function (wholeMatch, linkText, linkId, url, m5, m6, title) {
3123      if (showdown.helper.isUndefined(title)) {
3124        title = '';
3125      }
3126      linkId = linkId.toLowerCase();
3127  
3128      // Special case for explicit empty url
3129      if (wholeMatch.search(/\(<?\s*>? ?(['"].*['"])?\)$/m) > -1) {
3130        url = '';
3131      } else if (!url) {
3132        if (!linkId) {
3133          // lower-case and turn embedded newlines into spaces
3134          linkId = linkText.toLowerCase().replace(/ ?\n/g, ' ');
3135        }
3136        url = '#' + linkId;
3137  
3138        if (!showdown.helper.isUndefined(globals.gUrls[linkId])) {
3139          url = globals.gUrls[linkId];
3140          if (!showdown.helper.isUndefined(globals.gTitles[linkId])) {
3141            title = globals.gTitles[linkId];
3142          }
3143        } else {
3144          return wholeMatch;
3145        }
3146      }
3147  
3148      //url = showdown.helper.escapeCharacters(url, '*_', false); // replaced line to improve performance
3149      url = url.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
3150  
3151      var result = '<a href="' + url + '"';
3152  
3153      if (title !== '' && title !== null) {
3154        title = title.replace(/"/g, '&quot;');
3155        //title = showdown.helper.escapeCharacters(title, '*_', false); // replaced line to improve performance
3156        title = title.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
3157        result += ' title="' + title + '"';
3158      }
3159  
3160      // optionLinksInNewWindow only applies
3161      // to external links. Hash links (#) open in same page
3162      if (options.openLinksInNewWindow && !/^#/.test(url)) {
3163        // escaped _
3164        result += ' rel="noopener noreferrer" target="¨E95Eblank"';
3165      }
3166  
3167      result += '>' + linkText + '</a>';
3168  
3169      return result;
3170    };
3171  
3172    // First, handle reference-style links: [link text] [id]
3173    text = text.replace(/\[((?:\[[^\]]*]|[^\[\]])*)] ?(?:\n *)?\[(.*?)]()()()()/g, writeAnchorTag);
3174  
3175    // Next, inline-style links: [link text](url "optional title")
3176    // cases with crazy urls like ./image/cat1).png
3177    text = text.replace(/\[((?:\[[^\]]*]|[^\[\]])*)]()[ \t]*\([ \t]?<([^>]*)>(?:[ \t]*((["'])([^"]*?)\5))?[ \t]?\)/g,
3178      writeAnchorTag);
3179  
3180    // normal cases
3181    text = text.replace(/\[((?:\[[^\]]*]|[^\[\]])*)]()[ \t]*\([ \t]?<?([\S]+?(?:\([\S]*?\)[\S]*?)?)>?(?:[ \t]*((["'])([^"]*?)\5))?[ \t]?\)/g,
3182      writeAnchorTag);
3183  
3184    // handle reference-style shortcuts: [link text]
3185    // These must come last in case you've also got [link test][1]
3186    // or [link test](/foo)
3187    text = text.replace(/\[([^\[\]]+)]()()()()()/g, writeAnchorTag);
3188  
3189    // Lastly handle GithubMentions if option is enabled
3190    if (options.ghMentions) {
3191      text = text.replace(/(^|\s)(\\)?(@([a-z\d]+(?:[a-z\d.-]+?[a-z\d]+)*))/gmi, function (wm, st, escape, mentions, username) {
3192        if (escape === '\\') {
3193          return st + mentions;
3194        }
3195  
3196        //check if options.ghMentionsLink is a string
3197        if (!showdown.helper.isString(options.ghMentionsLink)) {
3198          throw new Error('ghMentionsLink option must be a string');
3199        }
3200        var lnk = options.ghMentionsLink.replace(/\{u}/g, username),
3201            target = '';
3202        if (options.openLinksInNewWindow) {
3203          target = ' rel="noopener noreferrer" target="¨E95Eblank"';
3204        }
3205        return st + '<a href="' + lnk + '"' + target + '>' + mentions + '</a>';
3206      });
3207    }
3208  
3209    text = globals.converter._dispatch('anchors.after', text, options, globals);
3210    return text;
3211  });
3212  
3213  // url allowed chars [a-z\d_.~:/?#[]@!$&'()*+,;=-]
3214  
3215  var simpleURLRegex  = /([*~_]+|\b)(((https?|ftp|dict):\/\/|www\.)[^'">\s]+?\.[^'">\s]+?)()(\1)?(?=\s|$)(?!["<>])/gi,
3216      simpleURLRegex2 = /([*~_]+|\b)(((https?|ftp|dict):\/\/|www\.)[^'">\s]+\.[^'">\s]+?)([.!?,()\[\]])?(\1)?(?=\s|$)(?!["<>])/gi,
3217      delimUrlRegex   = /()<(((https?|ftp|dict):\/\/|www\.)[^'">\s]+)()>()/gi,
3218      simpleMailRegex = /(^|\s)(?:mailto:)?([A-Za-z0-9!#$%&'*+-/=?^_`{|}~.]+@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)(?=$|\s)/gmi,
3219      delimMailRegex  = /<()(?:mailto:)?([-.\w]+@[-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+)>/gi,
3220  
3221      replaceLink = function (options) {
3222        'use strict';
3223        return function (wm, leadingMagicChars, link, m2, m3, trailingPunctuation, trailingMagicChars) {
3224          link = link.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
3225          var lnkTxt = link,
3226              append = '',
3227              target = '',
3228              lmc    = leadingMagicChars || '',
3229              tmc    = trailingMagicChars || '';
3230          if (/^www\./i.test(link)) {
3231            link = link.replace(/^www\./i, 'http://www.');
3232          }
3233          if (options.excludeTrailingPunctuationFromURLs && trailingPunctuation) {
3234            append = trailingPunctuation;
3235          }
3236          if (options.openLinksInNewWindow) {
3237            target = ' rel="noopener noreferrer" target="¨E95Eblank"';
3238          }
3239          return lmc + '<a href="' + link + '"' + target + '>' + lnkTxt + '</a>' + append + tmc;
3240        };
3241      },
3242  
3243      replaceMail = function (options, globals) {
3244        'use strict';
3245        return function (wholeMatch, b, mail) {
3246          var href = 'mailto:';
3247          b = b || '';
3248          mail = showdown.subParser('unescapeSpecialChars')(mail, options, globals);
3249          if (options.encodeEmails) {
3250            href = showdown.helper.encodeEmailAddress(href + mail);
3251            mail = showdown.helper.encodeEmailAddress(mail);
3252          } else {
3253            href = href + mail;
3254          }
3255          return b + '<a href="' + href + '">' + mail + '</a>';
3256        };
3257      };
3258  
3259  showdown.subParser('autoLinks', function (text, options, globals) {
3260    'use strict';
3261  
3262    text = globals.converter._dispatch('autoLinks.before', text, options, globals);
3263  
3264    text = text.replace(delimUrlRegex, replaceLink(options));
3265    text = text.replace(delimMailRegex, replaceMail(options, globals));
3266  
3267    text = globals.converter._dispatch('autoLinks.after', text, options, globals);
3268  
3269    return text;
3270  });
3271  
3272  showdown.subParser('simplifiedAutoLinks', function (text, options, globals) {
3273    'use strict';
3274  
3275    if (!options.simplifiedAutoLink) {
3276      return text;
3277    }
3278  
3279    text = globals.converter._dispatch('simplifiedAutoLinks.before', text, options, globals);
3280  
3281    if (options.excludeTrailingPunctuationFromURLs) {
3282      text = text.replace(simpleURLRegex2, replaceLink(options));
3283    } else {
3284      text = text.replace(simpleURLRegex, replaceLink(options));
3285    }
3286    text = text.replace(simpleMailRegex, replaceMail(options, globals));
3287  
3288    text = globals.converter._dispatch('simplifiedAutoLinks.after', text, options, globals);
3289  
3290    return text;
3291  });
3292  
3293  /**
3294   * These are all the transformations that form block-level
3295   * tags like paragraphs, headers, and list items.
3296   */
3297  showdown.subParser('blockGamut', function (text, options, globals) {
3298    'use strict';
3299  
3300    text = globals.converter._dispatch('blockGamut.before', text, options, globals);
3301  
3302    // we parse blockquotes first so that we can have headings and hrs
3303    // inside blockquotes
3304    text = showdown.subParser('blockQuotes')(text, options, globals);
3305    text = showdown.subParser('headers')(text, options, globals);
3306  
3307    // Do Horizontal Rules:
3308    text = showdown.subParser('horizontalRule')(text, options, globals);
3309  
3310    text = showdown.subParser('lists')(text, options, globals);
3311    text = showdown.subParser('codeBlocks')(text, options, globals);
3312    text = showdown.subParser('tables')(text, options, globals);
3313  
3314    // We already ran _HashHTMLBlocks() before, in Markdown(), but that
3315    // was to escape raw HTML in the original Markdown source. This time,
3316    // we're escaping the markup we've just created, so that we don't wrap
3317    // <p> tags around block-level tags.
3318    text = showdown.subParser('hashHTMLBlocks')(text, options, globals);
3319    text = showdown.subParser('paragraphs')(text, options, globals);
3320  
3321    text = globals.converter._dispatch('blockGamut.after', text, options, globals);
3322  
3323    return text;
3324  });
3325  
3326  showdown.subParser('blockQuotes', function (text, options, globals) {
3327    'use strict';
3328  
3329    text = globals.converter._dispatch('blockQuotes.before', text, options, globals);
3330  
3331    // add a couple extra lines after the text and endtext mark
3332    text = text + '\n\n';
3333  
3334    var rgx = /(^ {0,3}>[ \t]?.+\n(.+\n)*\n*)+/gm;
3335  
3336    if (options.splitAdjacentBlockquotes) {
3337      rgx = /^ {0,3}>[\s\S]*?(?:\n\n)/gm;
3338    }
3339  
3340    text = text.replace(rgx, function (bq) {
3341      // attacklab: hack around Konqueror 3.5.4 bug:
3342      // "----------bug".replace(/^-/g,"") == "bug"
3343      bq = bq.replace(/^[ \t]*>[ \t]?/gm, ''); // trim one level of quoting
3344  
3345      // attacklab: clean up hack
3346      bq = bq.replace(/¨0/g, '');
3347  
3348      bq = bq.replace(/^[ \t]+$/gm, ''); // trim whitespace-only lines
3349      bq = showdown.subParser('githubCodeBlocks')(bq, options, globals);
3350      bq = showdown.subParser('blockGamut')(bq, options, globals); // recurse
3351  
3352      bq = bq.replace(/(^|\n)/g, '$1  ');
3353      // These leading spaces screw with <pre> content, so we need to fix that:
3354      bq = bq.replace(/(\s*<pre>[^\r]+?<\/pre>)/gm, function (wholeMatch, m1) {
3355        var pre = m1;
3356        // attacklab: hack around Konqueror 3.5.4 bug:
3357        pre = pre.replace(/^  /mg, '¨0');
3358        pre = pre.replace(/¨0/g, '');
3359        return pre;
3360      });
3361  
3362      return showdown.subParser('hashBlock')('<blockquote>\n' + bq + '\n</blockquote>', options, globals);
3363    });
3364  
3365    text = globals.converter._dispatch('blockQuotes.after', text, options, globals);
3366    return text;
3367  });
3368  
3369  /**
3370   * Process Markdown `<pre><code>` blocks.
3371   */
3372  showdown.subParser('codeBlocks', function (text, options, globals) {
3373    'use strict';
3374  
3375    text = globals.converter._dispatch('codeBlocks.before', text, options, globals);
3376  
3377    // sentinel workarounds for lack of \A and \Z, safari\khtml bug
3378    text += '¨0';
3379  
3380    var pattern = /(?:\n\n|^)((?:(?:[ ]{4}|\t).*\n+)+)(\n*[ ]{0,3}[^ \t\n]|(?=¨0))/g;
3381    text = text.replace(pattern, function (wholeMatch, m1, m2) {
3382      var codeblock = m1,
3383          nextChar = m2,
3384          end = '\n';
3385  
3386      codeblock = showdown.subParser('outdent')(codeblock, options, globals);
3387      codeblock = showdown.subParser('encodeCode')(codeblock, options, globals);
3388      codeblock = showdown.subParser('detab')(codeblock, options, globals);
3389      codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
3390      codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing newlines
3391  
3392      if (options.omitExtraWLInCodeBlocks) {
3393        end = '';
3394      }
3395  
3396      codeblock = '<pre><code>' + codeblock + end + '</code></pre>';
3397  
3398      return showdown.subParser('hashBlock')(codeblock, options, globals) + nextChar;
3399    });
3400  
3401    // strip sentinel
3402    text = text.replace(/¨0/, '');
3403  
3404    text = globals.converter._dispatch('codeBlocks.after', text, options, globals);
3405    return text;
3406  });
3407  
3408  /**
3409   *
3410   *   *  Backtick quotes are used for <code></code> spans.
3411   *
3412   *   *  You can use multiple backticks as the delimiters if you want to
3413   *     include literal backticks in the code span. So, this input:
3414   *
3415   *         Just type ``foo `bar` baz`` at the prompt.
3416   *
3417   *       Will translate to:
3418   *
3419   *         <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
3420   *
3421   *    There's no arbitrary limit to the number of backticks you
3422   *    can use as delimters. If you need three consecutive backticks
3423   *    in your code, use four for delimiters, etc.
3424   *
3425   *  *  You can use spaces to get literal backticks at the edges:
3426   *
3427   *         ... type `` `bar` `` ...
3428   *
3429   *       Turns to:
3430   *
3431   *         ... type <code>`bar`</code> ...
3432   */
3433  showdown.subParser('codeSpans', function (text, options, globals) {
3434    'use strict';
3435  
3436    text = globals.converter._dispatch('codeSpans.before', text, options, globals);
3437  
3438    if (typeof text === 'undefined') {
3439      text = '';
3440    }
3441    text = text.replace(/(^|[^\\])(`+)([^\r]*?[^`])\2(?!`)/gm,
3442      function (wholeMatch, m1, m2, m3) {
3443        var c = m3;
3444        c = c.replace(/^([ \t]*)/g, '');    // leading whitespace
3445        c = c.replace(/[ \t]*$/g, '');    // trailing whitespace
3446        c = showdown.subParser('encodeCode')(c, options, globals);
3447        c = m1 + '<code>' + c + '</code>';
3448        c = showdown.subParser('hashHTMLSpans')(c, options, globals);
3449        return c;
3450      }
3451    );
3452  
3453    text = globals.converter._dispatch('codeSpans.after', text, options, globals);
3454    return text;
3455  });
3456  
3457  /**
3458   * Create a full HTML document from the processed markdown
3459   */
3460  showdown.subParser('completeHTMLDocument', function (text, options, globals) {
3461    'use strict';
3462  
3463    if (!options.completeHTMLDocument) {
3464      return text;
3465    }
3466  
3467    text = globals.converter._dispatch('completeHTMLDocument.before', text, options, globals);
3468  
3469    var doctype = 'html',
3470        doctypeParsed = '<!DOCTYPE HTML>\n',
3471        title = '',
3472        charset = '<meta charset="utf-8">\n',
3473        lang = '',
3474        metadata = '';
3475  
3476    if (typeof globals.metadata.parsed.doctype !== 'undefined') {
3477      doctypeParsed = '<!DOCTYPE ' +  globals.metadata.parsed.doctype + '>\n';
3478      doctype = globals.metadata.parsed.doctype.toString().toLowerCase();
3479      if (doctype === 'html' || doctype === 'html5') {
3480        charset = '<meta charset="utf-8">';
3481      }
3482    }
3483  
3484    for (var meta in globals.metadata.parsed) {
3485      if (globals.metadata.parsed.hasOwnProperty(meta)) {
3486        switch (meta.toLowerCase()) {
3487          case 'doctype':
3488            break;
3489  
3490          case 'title':
3491            title = '<title>' +  globals.metadata.parsed.title + '</title>\n';
3492            break;
3493  
3494          case 'charset':
3495            if (doctype === 'html' || doctype === 'html5') {
3496              charset = '<meta charset="' + globals.metadata.parsed.charset + '">\n';
3497            } else {
3498              charset = '<meta name="charset" content="' + globals.metadata.parsed.charset + '">\n';
3499            }
3500            break;
3501  
3502          case 'language':
3503          case 'lang':
3504            lang = ' lang="' + globals.metadata.parsed[meta] + '"';
3505            metadata += '<meta name="' + meta + '" content="' + globals.metadata.parsed[meta] + '">\n';
3506            break;
3507  
3508          default:
3509            metadata += '<meta name="' + meta + '" content="' + globals.metadata.parsed[meta] + '">\n';
3510        }
3511      }
3512    }
3513  
3514    text = doctypeParsed + '<html' + lang + '>\n<head>\n' + title + charset + metadata + '</head>\n<body>\n' + text.trim() + '\n</body>\n</html>';
3515  
3516    text = globals.converter._dispatch('completeHTMLDocument.after', text, options, globals);
3517    return text;
3518  });
3519  
3520  /**
3521   * Convert all tabs to spaces
3522   */
3523  showdown.subParser('detab', function (text, options, globals) {
3524    'use strict';
3525    text = globals.converter._dispatch('detab.before', text, options, globals);
3526  
3527    // expand first n-1 tabs
3528    text = text.replace(/\t(?=\t)/g, '    '); // g_tab_width
3529  
3530    // replace the nth with two sentinels
3531    text = text.replace(/\t/g, '¨A¨B');
3532  
3533    // use the sentinel to anchor our regex so it doesn't explode
3534    text = text.replace(/¨B(.+?)¨A/g, function (wholeMatch, m1) {
3535      var leadingText = m1,
3536          numSpaces = 4 - leadingText.length % 4;  // g_tab_width
3537  
3538      // there *must* be a better way to do this:
3539      for (var i = 0; i < numSpaces; i++) {
3540        leadingText += ' ';
3541      }
3542  
3543      return leadingText;
3544    });
3545  
3546    // clean up sentinels
3547    text = text.replace(/¨A/g, '    ');  // g_tab_width
3548    text = text.replace(/¨B/g, '');
3549  
3550    text = globals.converter._dispatch('detab.after', text, options, globals);
3551    return text;
3552  });
3553  
3554  showdown.subParser('ellipsis', function (text, options, globals) {
3555    'use strict';
3556  
3557    text = globals.converter._dispatch('ellipsis.before', text, options, globals);
3558  
3559    text = text.replace(/\.\.\./g, '…');
3560  
3561    text = globals.converter._dispatch('ellipsis.after', text, options, globals);
3562  
3563    return text;
3564  });
3565  
3566  /**
3567   * Turn emoji codes into emojis
3568   *
3569   * List of supported emojis: https://github.com/showdownjs/showdown/wiki/Emojis
3570   */
3571  showdown.subParser('emoji', function (text, options, globals) {
3572    'use strict';
3573  
3574    if (!options.emoji) {
3575      return text;
3576    }
3577  
3578    text = globals.converter._dispatch('emoji.before', text, options, globals);
3579  
3580    var emojiRgx = /:([\S]+?):/g;
3581  
3582    text = text.replace(emojiRgx, function (wm, emojiCode) {
3583      if (showdown.helper.emojis.hasOwnProperty(emojiCode)) {
3584        return showdown.helper.emojis[emojiCode];
3585      }
3586      return wm;
3587    });
3588  
3589    text = globals.converter._dispatch('emoji.after', text, options, globals);
3590  
3591    return text;
3592  });
3593  
3594  /**
3595   * Smart processing for ampersands and angle brackets that need to be encoded.
3596   */
3597  showdown.subParser('encodeAmpsAndAngles', function (text, options, globals) {
3598    'use strict';
3599    text = globals.converter._dispatch('encodeAmpsAndAngles.before', text, options, globals);
3600  
3601    // Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
3602    // http://bumppo.net/projects/amputator/
3603    text = text.replace(/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/g, '&amp;');
3604  
3605    // Encode naked <'s
3606    text = text.replace(/<(?![a-z\/?$!])/gi, '&lt;');
3607  
3608    // Encode <
3609    text = text.replace(/</g, '&lt;');
3610  
3611    // Encode >
3612    text = text.replace(/>/g, '&gt;');
3613  
3614    text = globals.converter._dispatch('encodeAmpsAndAngles.after', text, options, globals);
3615    return text;
3616  });
3617  
3618  /**
3619   * Returns the string, with after processing the following backslash escape sequences.
3620   *
3621   * attacklab: The polite way to do this is with the new escapeCharacters() function:
3622   *
3623   *    text = escapeCharacters(text,"\\",true);
3624   *    text = escapeCharacters(text,"`*_{}[]()>#+-.!",true);
3625   *
3626   * ...but we're sidestepping its use of the (slow) RegExp constructor
3627   * as an optimization for Firefox.  This function gets called a LOT.
3628   */
3629  showdown.subParser('encodeBackslashEscapes', function (text, options, globals) {
3630    'use strict';
3631    text = globals.converter._dispatch('encodeBackslashEscapes.before', text, options, globals);
3632  
3633    text = text.replace(/\\(\\)/g, showdown.helper.escapeCharactersCallback);
3634    text = text.replace(/\\([`*_{}\[\]()>#+.!~=|-])/g, showdown.helper.escapeCharactersCallback);
3635  
3636    text = globals.converter._dispatch('encodeBackslashEscapes.after', text, options, globals);
3637    return text;
3638  });
3639  
3640  /**
3641   * Encode/escape certain characters inside Markdown code runs.
3642   * The point is that in code, these characters are literals,
3643   * and lose their special Markdown meanings.
3644   */
3645  showdown.subParser('encodeCode', function (text, options, globals) {
3646    'use strict';
3647  
3648    text = globals.converter._dispatch('encodeCode.before', text, options, globals);
3649  
3650    // Encode all ampersands; HTML entities are not
3651    // entities within a Markdown code span.
3652    text = text
3653      .replace(/&/g, '&amp;')
3654    // Do the angle bracket song and dance:
3655      .replace(/</g, '&lt;')
3656      .replace(/>/g, '&gt;')
3657    // Now, escape characters that are magic in Markdown:
3658      .replace(/([*_{}\[\]\\=~-])/g, showdown.helper.escapeCharactersCallback);
3659  
3660    text = globals.converter._dispatch('encodeCode.after', text, options, globals);
3661    return text;
3662  });
3663  
3664  /**
3665   * Within tags -- meaning between < and > -- encode [\ ` * _ ~ =] so they
3666   * don't conflict with their use in Markdown for code, italics and strong.
3667   */
3668  showdown.subParser('escapeSpecialCharsWithinTagAttributes', function (text, options, globals) {
3669    'use strict';
3670    text = globals.converter._dispatch('escapeSpecialCharsWithinTagAttributes.before', text, options, globals);
3671  
3672    // Build a regex to find HTML tags.
3673    var tags     = /<\/?[a-z\d_:-]+(?:[\s]+[\s\S]+?)?>/gi,
3674        comments = /<!(--(?:(?:[^>-]|-[^>])(?:[^-]|-[^-])*)--)>/gi;
3675  
3676    text = text.replace(tags, function (wholeMatch) {
3677      return wholeMatch
3678        .replace(/(.)<\/?code>(?=.)/g, '$1`')
3679        .replace(/([\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);
3680    });
3681  
3682    text = text.replace(comments, function (wholeMatch) {
3683      return wholeMatch
3684        .replace(/([\\`*_~=|])/g, showdown.helper.escapeCharactersCallback);
3685    });
3686  
3687    text = globals.converter._dispatch('escapeSpecialCharsWithinTagAttributes.after', text, options, globals);
3688    return text;
3689  });
3690  
3691  /**
3692   * Handle github codeblocks prior to running HashHTML so that
3693   * HTML contained within the codeblock gets escaped properly
3694   * Example:
3695   * ```ruby
3696   *     def hello_world(x)
3697   *       puts "Hello, #{x}"
3698   *     end
3699   * ```
3700   */
3701  showdown.subParser('githubCodeBlocks', function (text, options, globals) {
3702    'use strict';
3703  
3704    // early exit if option is not enabled
3705    if (!options.ghCodeBlocks) {
3706      return text;
3707    }
3708  
3709    text = globals.converter._dispatch('githubCodeBlocks.before', text, options, globals);
3710  
3711    text += '¨0';
3712  
3713    text = text.replace(/(?:^|\n)(?: {0,3})(```+|~~~+)(?: *)([^\s`~]*)\n([\s\S]*?)\n(?: {0,3})\1/g, function (wholeMatch, delim, language, codeblock) {
3714      var end = (options.omitExtraWLInCodeBlocks) ? '' : '\n';
3715  
3716      // First parse the github code block
3717      codeblock = showdown.subParser('encodeCode')(codeblock, options, globals);
3718      codeblock = showdown.subParser('detab')(codeblock, options, globals);
3719      codeblock = codeblock.replace(/^\n+/g, ''); // trim leading newlines
3720      codeblock = codeblock.replace(/\n+$/g, ''); // trim trailing whitespace
3721  
3722      codeblock = '<pre><code' + (language ? ' class="' + language + ' language-' + language + '"' : '') + '>' + codeblock + end + '</code></pre>';
3723  
3724      codeblock = showdown.subParser('hashBlock')(codeblock, options, globals);
3725  
3726      // Since GHCodeblocks can be false positives, we need to
3727      // store the primitive text and the parsed text in a global var,
3728      // and then return a token
3729      return '\n\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
3730    });
3731  
3732    // attacklab: strip sentinel
3733    text = text.replace(/¨0/, '');
3734  
3735    return globals.converter._dispatch('githubCodeBlocks.after', text, options, globals);
3736  });
3737  
3738  showdown.subParser('hashBlock', function (text, options, globals) {
3739    'use strict';
3740    text = globals.converter._dispatch('hashBlock.before', text, options, globals);
3741    text = text.replace(/(^\n+|\n+$)/g, '');
3742    text = '\n\n¨K' + (globals.gHtmlBlocks.push(text) - 1) + 'K\n\n';
3743    text = globals.converter._dispatch('hashBlock.after', text, options, globals);
3744    return text;
3745  });
3746  
3747  /**
3748   * Hash and escape <code> elements that should not be parsed as markdown
3749   */
3750  showdown.subParser('hashCodeTags', function (text, options, globals) {
3751    'use strict';
3752    text = globals.converter._dispatch('hashCodeTags.before', text, options, globals);
3753  
3754    var repFunc = function (wholeMatch, match, left, right) {
3755      var codeblock = left + showdown.subParser('encodeCode')(match, options, globals) + right;
3756      return '¨C' + (globals.gHtmlSpans.push(codeblock) - 1) + 'C';
3757    };
3758  
3759    // Hash naked <code>
3760    text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '<code\\b[^>]*>', '</code>', 'gim');
3761  
3762    text = globals.converter._dispatch('hashCodeTags.after', text, options, globals);
3763    return text;
3764  });
3765  
3766  showdown.subParser('hashElement', function (text, options, globals) {
3767    'use strict';
3768  
3769    return function (wholeMatch, m1) {
3770      var blockText = m1;
3771  
3772      // Undo double lines
3773      blockText = blockText.replace(/\n\n/g, '\n');
3774      blockText = blockText.replace(/^\n/, '');
3775  
3776      // strip trailing blank lines
3777      blockText = blockText.replace(/\n+$/g, '');
3778  
3779      // Replace the element text with a marker ("¨KxK" where x is its key)
3780      blockText = '\n\n¨K' + (globals.gHtmlBlocks.push(blockText) - 1) + 'K\n\n';
3781  
3782      return blockText;
3783    };
3784  });
3785  
3786  showdown.subParser('hashHTMLBlocks', function (text, options, globals) {
3787    'use strict';
3788    text = globals.converter._dispatch('hashHTMLBlocks.before', text, options, globals);
3789  
3790    var blockTags = [
3791          'pre',
3792          'div',
3793          'h1',
3794          'h2',
3795          'h3',
3796          'h4',
3797          'h5',
3798          'h6',
3799          'blockquote',
3800          'table',
3801          'dl',
3802          'ol',
3803          'ul',
3804          'script',
3805          'noscript',
3806          'form',
3807          'fieldset',
3808          'iframe',
3809          'math',
3810          'style',
3811          'section',
3812          'header',
3813          'footer',
3814          'nav',
3815          'article',
3816          'aside',
3817          'address',
3818          'audio',
3819          'canvas',
3820          'figure',
3821          'hgroup',
3822          'output',
3823          'video',
3824          'p'
3825        ],
3826        repFunc = function (wholeMatch, match, left, right) {
3827          var txt = wholeMatch;
3828          // check if this html element is marked as markdown
3829          // if so, it's contents should be parsed as markdown
3830          if (left.search(/\bmarkdown\b/) !== -1) {
3831            txt = left + globals.converter.makeHtml(match) + right;
3832          }
3833          return '\n\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
3834        };
3835  
3836    if (options.backslashEscapesHTMLTags) {
3837      // encode backslash escaped HTML tags
3838      text = text.replace(/\\<(\/?[^>]+?)>/g, function (wm, inside) {
3839        return '&lt;' + inside + '&gt;';
3840      });
3841    }
3842  
3843    // hash HTML Blocks
3844    for (var i = 0; i < blockTags.length; ++i) {
3845  
3846      var opTagPos,
3847          rgx1     = new RegExp('^ {0,3}(<' + blockTags[i] + '\\b[^>]*>)', 'im'),
3848          patLeft  = '<' + blockTags[i] + '\\b[^>]*>',
3849          patRight = '</' + blockTags[i] + '>';
3850      // 1. Look for the first position of the first opening HTML tag in the text
3851      while ((opTagPos = showdown.helper.regexIndexOf(text, rgx1)) !== -1) {
3852  
3853        // if the HTML tag is \ escaped, we need to escape it and break
3854  
3855  
3856        //2. Split the text in that position
3857        var subTexts = showdown.helper.splitAtIndex(text, opTagPos),
3858            //3. Match recursively
3859            newSubText1 = showdown.helper.replaceRecursiveRegExp(subTexts[1], repFunc, patLeft, patRight, 'im');
3860  
3861        // prevent an infinite loop
3862        if (newSubText1 === subTexts[1]) {
3863          break;
3864        }
3865        text = subTexts[0].concat(newSubText1);
3866      }
3867    }
3868    // HR SPECIAL CASE
3869    text = text.replace(/(\n {0,3}(<(hr)\b([^<>])*?\/?>)[ \t]*(?=\n{2,}))/g,
3870      showdown.subParser('hashElement')(text, options, globals));
3871  
3872    // Special case for standalone HTML comments
3873    text = showdown.helper.replaceRecursiveRegExp(text, function (txt) {
3874      return '\n\n¨K' + (globals.gHtmlBlocks.push(txt) - 1) + 'K\n\n';
3875    }, '^ {0,3}<!--', '-->', 'gm');
3876  
3877    // PHP and ASP-style processor instructions (<?...?> and <%...%>)
3878    text = text.replace(/(?:\n\n)( {0,3}(?:<([?%])[^\r]*?\2>)[ \t]*(?=\n{2,}))/g,
3879      showdown.subParser('hashElement')(text, options, globals));
3880  
3881    text = globals.converter._dispatch('hashHTMLBlocks.after', text, options, globals);
3882    return text;
3883  });
3884  
3885  /**
3886   * Hash span elements that should not be parsed as markdown
3887   */
3888  showdown.subParser('hashHTMLSpans', function (text, options, globals) {
3889    'use strict';
3890    text = globals.converter._dispatch('hashHTMLSpans.before', text, options, globals);
3891  
3892    function hashHTMLSpan (html) {
3893      return '¨C' + (globals.gHtmlSpans.push(html) - 1) + 'C';
3894    }
3895  
3896    // Hash Self Closing tags
3897    text = text.replace(/<[^>]+?\/>/gi, function (wm) {
3898      return hashHTMLSpan(wm);
3899    });
3900  
3901    // Hash tags without properties
3902    text = text.replace(/<([^>]+?)>[\s\S]*?<\/\1>/g, function (wm) {
3903      return hashHTMLSpan(wm);
3904    });
3905  
3906    // Hash tags with properties
3907    text = text.replace(/<([^>]+?)\s[^>]+?>[\s\S]*?<\/\1>/g, function (wm) {
3908      return hashHTMLSpan(wm);
3909    });
3910  
3911    // Hash self closing tags without />
3912    text = text.replace(/<[^>]+?>/gi, function (wm) {
3913      return hashHTMLSpan(wm);
3914    });
3915  
3916    /*showdown.helper.matchRecursiveRegExp(text, '<code\\b[^>]*>', '</code>', 'gi');*/
3917  
3918    text = globals.converter._dispatch('hashHTMLSpans.after', text, options, globals);
3919    return text;
3920  });
3921  
3922  /**
3923   * Unhash HTML spans
3924   */
3925  showdown.subParser('unhashHTMLSpans', function (text, options, globals) {
3926    'use strict';
3927    text = globals.converter._dispatch('unhashHTMLSpans.before', text, options, globals);
3928  
3929    for (var i = 0; i < globals.gHtmlSpans.length; ++i) {
3930      var repText = globals.gHtmlSpans[i],
3931          // limiter to prevent infinite loop (assume 10 as limit for recurse)
3932          limit = 0;
3933  
3934      while (/¨C(\d+)C/.test(repText)) {
3935        var num = RegExp.$1;
3936        repText = repText.replace('¨C' + num + 'C', globals.gHtmlSpans[num]);
3937        if (limit === 10) {
3938          console.error('maximum nesting of 10 spans reached!!!');
3939          break;
3940        }
3941        ++limit;
3942      }
3943      text = text.replace('¨C' + i + 'C', repText);
3944    }
3945  
3946    text = globals.converter._dispatch('unhashHTMLSpans.after', text, options, globals);
3947    return text;
3948  });
3949  
3950  /**
3951   * Hash and escape <pre><code> elements that should not be parsed as markdown
3952   */
3953  showdown.subParser('hashPreCodeTags', function (text, options, globals) {
3954    'use strict';
3955    text = globals.converter._dispatch('hashPreCodeTags.before', text, options, globals);
3956  
3957    var repFunc = function (wholeMatch, match, left, right) {
3958      // encode html entities
3959      var codeblock = left + showdown.subParser('encodeCode')(match, options, globals) + right;
3960      return '\n\n¨G' + (globals.ghCodeBlocks.push({text: wholeMatch, codeblock: codeblock}) - 1) + 'G\n\n';
3961    };
3962  
3963    // Hash <pre><code>
3964    text = showdown.helper.replaceRecursiveRegExp(text, repFunc, '^ {0,3}<pre\\b[^>]*>\\s*<code\\b[^>]*>', '^ {0,3}</code>\\s*</pre>', 'gim');
3965  
3966    text = globals.converter._dispatch('hashPreCodeTags.after', text, options, globals);
3967    return text;
3968  });
3969  
3970  showdown.subParser('headers', function (text, options, globals) {
3971    'use strict';
3972  
3973    text = globals.converter._dispatch('headers.before', text, options, globals);
3974  
3975    var headerLevelStart = (isNaN(parseInt(options.headerLevelStart))) ? 1 : parseInt(options.headerLevelStart),
3976  
3977        // Set text-style headers:
3978        //    Header 1
3979        //    ========
3980        //
3981        //    Header 2
3982        //    --------
3983        //
3984        setextRegexH1 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n={2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n=+[ \t]*\n+/gm,
3985        setextRegexH2 = (options.smoothLivePreview) ? /^(.+)[ \t]*\n-{2,}[ \t]*\n+/gm : /^(.+)[ \t]*\n-+[ \t]*\n+/gm;
3986  
3987    text = text.replace(setextRegexH1, function (wholeMatch, m1) {
3988  
3989      var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
3990          hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
3991          hLevel = headerLevelStart,
3992          hashBlock = '<h' + hLevel + hID + '>' + spanGamut + '</h' + hLevel + '>';
3993      return showdown.subParser('hashBlock')(hashBlock, options, globals);
3994    });
3995  
3996    text = text.replace(setextRegexH2, function (matchFound, m1) {
3997      var spanGamut = showdown.subParser('spanGamut')(m1, options, globals),
3998          hID = (options.noHeaderId) ? '' : ' id="' + headerId(m1) + '"',
3999          hLevel = headerLevelStart + 1,
4000          hashBlock = '<h' + hLevel + hID + '>' + spanGamut + '</h' + hLevel + '>';
4001      return showdown.subParser('hashBlock')(hashBlock, options, globals);
4002    });
4003  
4004    // atx-style headers:
4005    //  # Header 1
4006    //  ## Header 2
4007    //  ## Header 2 with closing hashes ##
4008    //  ...
4009    //  ###### Header 6
4010    //
4011    var atxStyle = (options.requireSpaceBeforeHeadingText) ? /^(#{1,6})[ \t]+(.+?)[ \t]*#*\n+/gm : /^(#{1,6})[ \t]*(.+?)[ \t]*#*\n+/gm;
4012  
4013    text = text.replace(atxStyle, function (wholeMatch, m1, m2) {
4014      var hText = m2;
4015      if (options.customizedHeaderId) {
4016        hText = m2.replace(/\s?\{([^{]+?)}\s*$/, '');
4017      }
4018  
4019      var span = showdown.subParser('spanGamut')(hText, options, globals),
4020          hID = (options.noHeaderId) ? '' : ' id="' + headerId(m2) + '"',
4021          hLevel = headerLevelStart - 1 + m1.length,
4022          header = '<h' + hLevel + hID + '>' + span + '</h' + hLevel + '>';
4023  
4024      return showdown.subParser('hashBlock')(header, options, globals);
4025    });
4026  
4027    function headerId (m) {
4028      var title,
4029          prefix;
4030  
4031      // It is separate from other options to allow combining prefix and customized
4032      if (options.customizedHeaderId) {
4033        var match = m.match(/\{([^{]+?)}\s*$/);
4034        if (match && match[1]) {
4035          m = match[1];
4036        }
4037      }
4038  
4039      title = m;
4040  
4041      // Prefix id to prevent causing inadvertent pre-existing style matches.
4042      if (showdown.helper.isString(options.prefixHeaderId)) {
4043        prefix = options.prefixHeaderId;
4044      } else if (options.prefixHeaderId === true) {
4045        prefix = 'section-';
4046      } else {
4047        prefix = '';
4048      }
4049  
4050      if (!options.rawPrefixHeaderId) {
4051        title = prefix + title;
4052      }
4053  
4054      if (options.ghCompatibleHeaderId) {
4055        title = title
4056          .replace(/ /g, '-')
4057          // replace previously escaped chars (&, ¨ and $)
4058          .replace(/&amp;/g, '')
4059          .replace(/¨T/g, '')
4060          .replace(/¨D/g, '')
4061          // replace rest of the chars (&~$ are repeated as they might have been escaped)
4062          // borrowed from github's redcarpet (some they should produce similar results)
4063          .replace(/[&+$,\/:;=?@"#{}|^¨~\[\]`\\*)(%.!'<>]/g, '')
4064          .toLowerCase();
4065      } else if (options.rawHeaderId) {
4066        title = title
4067          .replace(/ /g, '-')
4068          // replace previously escaped chars (&, ¨ and $)
4069          .replace(/&amp;/g, '&')
4070          .replace(/¨T/g, '¨')
4071          .replace(/¨D/g, '$')
4072          // replace " and '
4073          .replace(/["']/g, '-')
4074          .toLowerCase();
4075      } else {
4076        title = title
4077          .replace(/[^\w]/g, '')
4078          .toLowerCase();
4079      }
4080  
4081      if (options.rawPrefixHeaderId) {
4082        title = prefix + title;
4083      }
4084  
4085      if (globals.hashLinkCounts[title]) {
4086        title = title + '-' + (globals.hashLinkCounts[title]++);
4087      } else {
4088        globals.hashLinkCounts[title] = 1;
4089      }
4090      return title;
4091    }
4092  
4093    text = globals.converter._dispatch('headers.after', text, options, globals);
4094    return text;
4095  });
4096  
4097  /**
4098   * Turn Markdown link shortcuts into XHTML <a> tags.
4099   */
4100  showdown.subParser('horizontalRule', function (text, options, globals) {
4101    'use strict';
4102    text = globals.converter._dispatch('horizontalRule.before', text, options, globals);
4103  
4104    var key = showdown.subParser('hashBlock')('<hr />', options, globals);
4105    text = text.replace(/^ {0,2}( ?-){3,}[ \t]*$/gm, key);
4106    text = text.replace(/^ {0,2}( ?\*){3,}[ \t]*$/gm, key);
4107    text = text.replace(/^ {0,2}( ?_){3,}[ \t]*$/gm, key);
4108  
4109    text = globals.converter._dispatch('horizontalRule.after', text, options, globals);
4110    return text;
4111  });
4112  
4113  /**
4114   * Turn Markdown image shortcuts into <img> tags.
4115   */
4116  showdown.subParser('images', function (text, options, globals) {
4117    'use strict';
4118  
4119    text = globals.converter._dispatch('images.before', text, options, globals);
4120  
4121    var inlineRegExp      = /!\[([^\]]*?)][ \t]*()\([ \t]?<?([\S]+?(?:\([\S]*?\)[\S]*?)?)>?(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(["'])([^"]*?)\6)?[ \t]?\)/g,
4122        crazyRegExp       = /!\[([^\]]*?)][ \t]*()\([ \t]?<([^>]*)>(?: =([*\d]+[A-Za-z%]{0,4})x([*\d]+[A-Za-z%]{0,4}))?[ \t]*(?:(?:(["'])([^"]*?)\6))?[ \t]?\)/g,
4123        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,
4124        referenceRegExp   = /!\[([^\]]*?)] ?(?:\n *)?\[([\s\S]*?)]()()()()()/g,
4125        refShortcutRegExp = /!\[([^\[\]]+)]()()()()()/g;
4126  
4127    function writeImageTagBase64 (wholeMatch, altText, linkId, url, width, height, m5, title) {
4128      url = url.replace(/\s/g, '');
4129      return writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title);
4130    }
4131  
4132    function writeImageTag (wholeMatch, altText, linkId, url, width, height, m5, title) {
4133  
4134      var gUrls   = globals.gUrls,
4135          gTitles = globals.gTitles,
4136          gDims   = globals.gDimensions;
4137  
4138      linkId = linkId.toLowerCase();
4139  
4140      if (!title) {
4141        title = '';
4142      }
4143      // Special case for explicit empty url
4144      if (wholeMatch.search(/\(<?\s*>? ?(['"].*['"])?\)$/m) > -1) {
4145        url = '';
4146  
4147      } else if (url === '' || url === null) {
4148        if (linkId === '' || linkId === null) {
4149          // lower-case and turn embedded newlines into spaces
4150          linkId = altText.toLowerCase().replace(/ ?\n/g, ' ');
4151        }
4152        url = '#' + linkId;
4153  
4154        if (!showdown.helper.isUndefined(gUrls[linkId])) {
4155          url = gUrls[linkId];
4156          if (!showdown.helper.isUndefined(gTitles[linkId])) {
4157            title = gTitles[linkId];
4158          }
4159          if (!showdown.helper.isUndefined(gDims[linkId])) {
4160            width = gDims[linkId].width;
4161            height = gDims[linkId].height;
4162          }
4163        } else {
4164          return wholeMatch;
4165        }
4166      }
4167  
4168      altText = altText
4169        .replace(/"/g, '&quot;')
4170      //altText = showdown.helper.escapeCharacters(altText, '*_', false);
4171        .replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
4172      //url = showdown.helper.escapeCharacters(url, '*_', false);
4173      url = url.replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
4174      var result = '<img src="' + url + '" alt="' + altText + '"';
4175  
4176      if (title && showdown.helper.isString(title)) {
4177        title = title
4178          .replace(/"/g, '&quot;')
4179        //title = showdown.helper.escapeCharacters(title, '*_', false);
4180          .replace(showdown.helper.regexes.asteriskDashAndColon, showdown.helper.escapeCharactersCallback);
4181        result += ' title="' + title + '"';
4182      }
4183  
4184      if (width && height) {
4185        width  = (width === '*') ? 'auto' : width;
4186        height = (height === '*') ? 'auto' : height;
4187  
4188        result += ' width="' + width + '"';
4189        result += ' height="' + height + '"';
4190      }
4191  
4192      result += ' />';
4193  
4194      return result;
4195    }
4196  
4197    // First, handle reference-style labeled images: ![alt text][id]
4198    text = text.replace(referenceRegExp, writeImageTag);
4199  
4200    // Next, handle inline images:  ![alt text](url =<width>x<height> "optional title")
4201  
4202    // base64 encoded images
4203    text = text.replace(base64RegExp, writeImageTagBase64);
4204  
4205    // cases with crazy urls like ./image/cat1).png
4206    text = text.replace(crazyRegExp, writeImageTag);
4207  
4208    // normal cases
4209    text = text.replace(inlineRegExp, writeImageTag);
4210  
4211    // handle reference-style shortcuts: ![img text]
4212    text = text.replace(refShortcutRegExp, writeImageTag);
4213  
4214    text = globals.converter._dispatch('images.after', text, options, globals);
4215    return text;
4216  });
4217  
4218  showdown.subParser('italicsAndBold', function (text, options, globals) {
4219    'use strict';
4220  
4221    text = globals.converter._dispatch('italicsAndBold.before', text, options, globals);
4222  
4223    // it's faster to have 3 separate regexes for each case than have just one
4224    // because of backtracing, in some cases, it could lead to an exponential effect
4225    // called "catastrophic backtrace". Ominous!
4226  
4227    function parseInside (txt, left, right) {
4228      /*
4229      if (options.simplifiedAutoLink) {
4230        txt = showdown.subParser('simplifiedAutoLinks')(txt, options, globals);
4231      }
4232      */
4233      return left + txt + right;
4234    }
4235  
4236    // Parse underscores
4237    if (options.literalMidWordUnderscores) {
4238      text = text.replace(/\b___(\S[\s\S]*?)___\b/g, function (wm, txt) {
4239        return parseInside (txt, '<strong><em>', '</em></strong>');
4240      });
4241      text = text.replace(/\b__(\S[\s\S]*?)__\b/g, function (wm, txt) {
4242        return parseInside (txt, '<strong>', '</strong>');
4243      });
4244      text = text.replace(/\b_(\S[\s\S]*?)_\b/g, function (wm, txt) {
4245        return parseInside (txt, '<em>', '</em>');
4246      });
4247    } else {
4248      text = text.replace(/___(\S[\s\S]*?)___/g, function (wm, m) {
4249        return (/\S$/.test(m)) ? parseInside (m, '<strong><em>', '</em></strong>') : wm;
4250      });
4251      text = text.replace(/__(\S[\s\S]*?)__/g, function (wm, m) {
4252        return (/\S$/.test(m)) ? parseInside (m, '<strong>', '</strong>') : wm;
4253      });
4254      text = text.replace(/_([^\s_][\s\S]*?)_/g, function (wm, m) {
4255        // !/^_[^_]/.test(m) - test if it doesn't start with __ (since it seems redundant, we removed it)
4256        return (/\S$/.test(m)) ? parseInside (m, '<em>', '</em>') : wm;
4257      });
4258    }
4259  
4260    // Now parse asterisks
4261    if (options.literalMidWordAsterisks) {
4262      text = text.replace(/([^*]|^)\B\*\*\*(\S[\s\S]*?)\*\*\*\B(?!\*)/g, function (wm, lead, txt) {
4263        return parseInside (txt, lead + '<strong><em>', '</em></strong>');
4264      });
4265      text = text.replace(/([^*]|^)\B\*\*(\S[\s\S]*?)\*\*\B(?!\*)/g, function (wm, lead, txt) {
4266        return parseInside (txt, lead + '<strong>', '</strong>');
4267      });
4268      text = text.replace(/([^*]|^)\B\*(\S[\s\S]*?)\*\B(?!\*)/g, function (wm, lead, txt) {
4269        return parseInside (txt, lead + '<em>', '</em>');
4270      });
4271    } else {
4272      text = text.replace(/\*\*\*(\S[\s\S]*?)\*\*\*/g, function (wm, m) {
4273        return (/\S$/.test(m)) ? parseInside (m, '<strong><em>', '</em></strong>') : wm;
4274      });
4275      text = text.replace(/\*\*(\S[\s\S]*?)\*\*/g, function (wm, m) {
4276        return (/\S$/.test(m)) ? parseInside (m, '<strong>', '</strong>') : wm;
4277      });
4278      text = text.replace(/\*([^\s*][\s\S]*?)\*/g, function (wm, m) {
4279        // !/^\*[^*]/.test(m) - test if it doesn't start with ** (since it seems redundant, we removed it)
4280        return (/\S$/.test(m)) ? parseInside (m, '<em>', '</em>') : wm;
4281      });
4282    }
4283  
4284  
4285    text = globals.converter._dispatch('italicsAndBold.after', text, options, globals);
4286    return text;
4287  });
4288  
4289  /**
4290   * Form HTML ordered (numbered) and unordered (bulleted) lists.
4291   */
4292  showdown.subParser('lists', function (text, options, globals) {
4293    'use strict';
4294  
4295    /**
4296     * Process the contents of a single ordered or unordered list, splitting it
4297     * into individual list items.
4298     * @param {string} listStr
4299     * @param {boolean} trimTrailing
4300     * @returns {string}
4301     */
4302    function processListItems (listStr, trimTrailing) {
4303      // The $g_list_level global keeps track of when we're inside a list.
4304      // Each time we enter a list, we increment it; when we leave a list,
4305      // we decrement. If it's zero, we're not in a list anymore.
4306      //
4307      // We do this because when we're not inside a list, we want to treat
4308      // something like this:
4309      //
4310      //    I recommend upgrading to version
4311      //    8. Oops, now this line is treated
4312      //    as a sub-list.
4313      //
4314      // As a single paragraph, despite the fact that the second line starts
4315      // with a digit-period-space sequence.
4316      //
4317      // Whereas when we're inside a list (or sub-list), that line will be
4318      // treated as the start of a sub-list. What a kludge, huh? This is
4319      // an aspect of Markdown's syntax that's hard to parse perfectly
4320      // without resorting to mind-reading. Perhaps the solution is to
4321      // change the syntax rules such that sub-lists must start with a
4322      // starting cardinal number; e.g. "1." or "a.".
4323      globals.gListLevel++;
4324  
4325      // trim trailing blank lines:
4326      listStr = listStr.replace(/\n{2,}$/, '\n');
4327  
4328      // attacklab: add sentinel to emulate \z
4329      listStr += '¨0';
4330  
4331      var rgx = /(\n)?(^ {0,3})([*+-]|\d+[.])[ \t]+((\[(x|X| )?])?[ \t]*[^\r]+?(\n{1,2}))(?=\n*(¨0| {0,3}([*+-]|\d+[.])[ \t]+))/gm,
4332          isParagraphed = (/\n[ \t]*\n(?!¨0)/.test(listStr));
4333  
4334      // Since version 1.5, nesting sublists requires 4 spaces (or 1 tab) indentation,
4335      // which is a syntax breaking change
4336      // activating this option reverts to old behavior
4337      if (options.disableForced4SpacesIndentedSublists) {
4338        rgx = /(\n)?(^ {0,3})([*+-]|\d+[.])[ \t]+((\[(x|X| )?])?[ \t]*[^\r]+?(\n{1,2}))(?=\n*(¨0|\2([*+-]|\d+[.])[ \t]+))/gm;
4339      }
4340  
4341      listStr = listStr.replace(rgx, function (wholeMatch, m1, m2, m3, m4, taskbtn, checked) {
4342        checked = (checked && checked.trim() !== '');
4343  
4344        var item = showdown.subParser('outdent')(m4, options, globals),
4345            bulletStyle = '';
4346  
4347        // Support for github tasklists
4348        if (taskbtn && options.tasklists) {
4349          bulletStyle = ' class="task-list-item" style="list-style-type: none;"';
4350          item = item.replace(/^[ \t]*\[(x|X| )?]/m, function () {
4351            var otp = '<input type="checkbox" disabled style="margin: 0px 0.35em 0.25em -1.6em; vertical-align: middle;"';
4352            if (checked) {
4353              otp += ' checked';
4354            }
4355            otp += '>';
4356            return otp;
4357          });
4358        }
4359  
4360        // ISSUE #312
4361        // This input: - - - a
4362        // causes trouble to the parser, since it interprets it as:
4363        // <ul><li><li><li>a</li></li></li></ul>
4364        // instead of:
4365        // <ul><li>- - a</li></ul>
4366        // So, to prevent it, we will put a marker (¨A)in the beginning of the line
4367        // Kind of hackish/monkey patching, but seems more effective than overcomplicating the list parser
4368        item = item.replace(/^([-*+]|\d\.)[ \t]+[\S\n ]*/g, function (wm2) {
4369          return '¨A' + wm2;
4370        });
4371  
4372        // m1 - Leading line or
4373        // Has a double return (multi paragraph) or
4374        // Has sublist
4375        if (m1 || (item.search(/\n{2,}/) > -1)) {
4376          item = showdown.subParser('githubCodeBlocks')(item, options, globals);
4377          item = showdown.subParser('blockGamut')(item, options, globals);
4378        } else {
4379          // Recursion for sub-lists:
4380          item = showdown.subParser('lists')(item, options, globals);
4381          item = item.replace(/\n$/, ''); // chomp(item)
4382          item = showdown.subParser('hashHTMLBlocks')(item, options, globals);
4383  
4384          // Colapse double linebreaks
4385          item = item.replace(/\n\n+/g, '\n\n');
4386          if (isParagraphed) {
4387            item = showdown.subParser('paragraphs')(item, options, globals);
4388          } else {
4389            item = showdown.subParser('spanGamut')(item, options, globals);
4390          }
4391        }
4392  
4393        // now we need to remove the marker (¨A)
4394        item = item.replace('¨A', '');
4395        // we can finally wrap the line in list item tags
4396        item =  '<li' + bulletStyle + '>' + item + '</li>\n';
4397  
4398        return item;
4399      });
4400  
4401      // attacklab: strip sentinel
4402      listStr = listStr.replace(/¨0/g, '');
4403  
4404      globals.gListLevel--;
4405  
4406      if (trimTrailing) {
4407        listStr = listStr.replace(/\s+$/, '');
4408      }
4409  
4410      return listStr;
4411    }
4412  
4413    function styleStartNumber (list, listType) {
4414      // check if ol and starts by a number different than 1
4415      if (listType === 'ol') {
4416        var res = list.match(/^ *(\d+)\./);
4417        if (res && res[1] !== '1') {
4418          return ' start="' + res[1] + '"';
4419        }
4420      }
4421      return '';
4422    }
4423  
4424    /**
4425     * Check and parse consecutive lists (better fix for issue #142)
4426     * @param {string} list
4427     * @param {string} listType
4428     * @param {boolean} trimTrailing
4429     * @returns {string}
4430     */
4431    function parseConsecutiveLists (list, listType, trimTrailing) {
4432      // check if we caught 2 or more consecutive lists by mistake
4433      // we use the counterRgx, meaning if listType is UL we look for OL and vice versa
4434      var olRgx = (options.disableForced4SpacesIndentedSublists) ? /^ ?\d+\.[ \t]/gm : /^ {0,3}\d+\.[ \t]/gm,
4435          ulRgx = (options.disableForced4SpacesIndentedSublists) ? /^ ?[*+-][ \t]/gm : /^ {0,3}[*+-][ \t]/gm,
4436          counterRxg = (listType === 'ul') ? olRgx : ulRgx,
4437          result = '';
4438  
4439      if (list.search(counterRxg) !== -1) {
4440        (function parseCL (txt) {
4441          var pos = txt.search(counterRxg),
4442              style = styleStartNumber(list, listType);
4443          if (pos !== -1) {
4444            // slice
4445            result += '\n\n<' + listType + style + '>\n' + processListItems(txt.slice(0, pos), !!trimTrailing) + '</' + listType + '>\n';
4446  
4447            // invert counterType and listType
4448            listType = (listType === 'ul') ? 'ol' : 'ul';
4449            counterRxg = (listType === 'ul') ? olRgx : ulRgx;
4450  
4451            //recurse
4452            parseCL(txt.slice(pos));
4453          } else {
4454            result += '\n\n<' + listType + style + '>\n' + processListItems(txt, !!trimTrailing) + '</' + listType + '>\n';
4455          }
4456        })(list);
4457      } else {
4458        var style = styleStartNumber(list, listType);
4459        result = '\n\n<' + listType + style + '>\n' + processListItems(list, !!trimTrailing) + '</' + listType + '>\n';
4460      }
4461  
4462      return result;
4463    }
4464  
4465    /** Start of list parsing **/
4466    text = globals.converter._dispatch('lists.before', text, options, globals);
4467    // add sentinel to hack around khtml/safari bug:
4468    // http://bugs.webkit.org/show_bug.cgi?id=11231
4469    text += '¨0';
4470  
4471    if (globals.gListLevel) {
4472      text = text.replace(/^(( {0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(¨0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm,
4473        function (wholeMatch, list, m2) {
4474          var listType = (m2.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
4475          return parseConsecutiveLists(list, listType, true);
4476        }
4477      );
4478    } else {
4479      text = text.replace(/(\n\n|^\n?)(( {0,3}([*+-]|\d+[.])[ \t]+)[^\r]+?(¨0|\n{2,}(?=\S)(?![ \t]*(?:[*+-]|\d+[.])[ \t]+)))/gm,
4480        function (wholeMatch, m1, list, m3) {
4481          var listType = (m3.search(/[*+-]/g) > -1) ? 'ul' : 'ol';
4482          return parseConsecutiveLists(list, listType, false);
4483        }
4484      );
4485    }
4486  
4487    // strip sentinel
4488    text = text.replace(/¨0/, '');
4489    text = globals.converter._dispatch('lists.after', text, options, globals);
4490    return text;
4491  });
4492  
4493  /**
4494   * Parse metadata at the top of the document
4495   */
4496  showdown.subParser('metadata', function (text, options, globals) {
4497    'use strict';
4498  
4499    if (!options.metadata) {
4500      return text;
4501    }
4502  
4503    text = globals.converter._dispatch('metadata.before', text, options, globals);
4504  
4505    function parseMetadataContents (content) {
4506      // raw is raw so it's not changed in any way
4507      globals.metadata.raw = content;
4508  
4509      // escape chars forbidden in html attributes
4510      // double quotes
4511      content = content
4512        // ampersand first
4513        .replace(/&/g, '&amp;')
4514        // double quotes
4515        .replace(/"/g, '&quot;');
4516  
4517      content = content.replace(/\n {4}/g, ' ');
4518      content.replace(/^([\S ]+): +([\s\S]+?)$/gm, function (wm, key, value) {
4519        globals.metadata.parsed[key] = value;
4520        return '';
4521      });
4522    }
4523  
4524    text = text.replace(/^\s*«««+(\S*?)\n([\s\S]+?)\n»»»+\n/, function (wholematch, format, content) {
4525      parseMetadataContents(content);
4526      return '¨M';
4527    });
4528  
4529    text = text.replace(/^\s*---+(\S*?)\n([\s\S]+?)\n---+\n/, function (wholematch, format, content) {
4530      if (format) {
4531        globals.metadata.format = format;
4532      }
4533      parseMetadataContents(content);
4534      return '¨M';
4535    });
4536  
4537    text = text.replace(/¨M/g, '');
4538  
4539    text = globals.converter._dispatch('metadata.after', text, options, globals);
4540    return text;
4541  });
4542  
4543  /**
4544   * Remove one level of line-leading tabs or spaces
4545   */
4546  showdown.subParser('outdent', function (text, options, globals) {
4547    'use strict';
4548    text = globals.converter._dispatch('outdent.before', text, options, globals);
4549  
4550    // attacklab: hack around Konqueror 3.5.4 bug:
4551    // "----------bug".replace(/^-/g,"") == "bug"
4552    text = text.replace(/^(\t|[ ]{1,4})/gm, '¨0'); // attacklab: g_tab_width
4553  
4554    // attacklab: clean up hack
4555    text = text.replace(/¨0/g, '');
4556  
4557    text = globals.converter._dispatch('outdent.after', text, options, globals);
4558    return text;
4559  });
4560  
4561  /**
4562   *
4563   */
4564  showdown.subParser('paragraphs', function (text, options, globals) {
4565    'use strict';
4566  
4567    text = globals.converter._dispatch('paragraphs.before', text, options, globals);
4568    // Strip leading and trailing lines:
4569    text = text.replace(/^\n+/g, '');
4570    text = text.replace(/\n+$/g, '');
4571  
4572    var grafs = text.split(/\n{2,}/g),
4573        grafsOut = [],
4574        end = grafs.length; // Wrap <p> tags
4575  
4576    for (var i = 0; i < end; i++) {
4577      var str = grafs[i];
4578      // if this is an HTML marker, copy it
4579      if (str.search(/¨(K|G)(\d+)\1/g) >= 0) {
4580        grafsOut.push(str);
4581  
4582      // test for presence of characters to prevent empty lines being parsed
4583      // as paragraphs (resulting in undesired extra empty paragraphs)
4584      } else if (str.search(/\S/) >= 0) {
4585        str = showdown.subParser('spanGamut')(str, options, globals);
4586        str = str.replace(/^([ \t]*)/g, '<p>');
4587        str += '</p>';
4588        grafsOut.push(str);
4589      }
4590    }
4591  
4592    /** Unhashify HTML blocks */
4593    end = grafsOut.length;
4594    for (i = 0; i < end; i++) {
4595      var blockText = '',
4596          grafsOutIt = grafsOut[i],
4597          codeFlag = false;
4598      // if this is a marker for an html block...
4599      // use RegExp.test instead of string.search because of QML bug
4600      while (/¨(K|G)(\d+)\1/.test(grafsOutIt)) {
4601        var delim = RegExp.$1,
4602            num   = RegExp.$2;
4603  
4604        if (delim === 'K') {
4605          blockText = globals.gHtmlBlocks[num];
4606        } else {
4607          // we need to check if ghBlock is a false positive
4608          if (codeFlag) {
4609            // use encoded version of all text
4610            blockText = showdown.subParser('encodeCode')(globals.ghCodeBlocks[num].text, options, globals);
4611          } else {
4612            blockText = globals.ghCodeBlocks[num].codeblock;
4613          }
4614        }
4615        blockText = blockText.replace(/\$/g, '$$$$'); // Escape any dollar signs
4616  
4617        grafsOutIt = grafsOutIt.replace(/(\n\n)?¨(K|G)\d+\2(\n\n)?/, blockText);
4618        // Check if grafsOutIt is a pre->code
4619        if (/^<pre\b[^>]*>\s*<code\b[^>]*>/.test(grafsOutIt)) {
4620          codeFlag = true;
4621        }
4622      }
4623      grafsOut[i] = grafsOutIt;
4624    }
4625    text = grafsOut.join('\n');
4626    // Strip leading and trailing lines:
4627    text = text.replace(/^\n+/g, '');
4628    text = text.replace(/\n+$/g, '');
4629    return globals.converter._dispatch('paragraphs.after', text, options, globals);
4630  });
4631  
4632  /**
4633   * Run extension
4634   */
4635  showdown.subParser('runExtension', function (ext, text, options, globals) {
4636    'use strict';
4637  
4638    if (ext.filter) {
4639      text = ext.filter(text, globals.converter, options);
4640  
4641    } else if (ext.regex) {
4642      // TODO remove this when old extension loading mechanism is deprecated
4643      var re = ext.regex;
4644      if (!(re instanceof RegExp)) {
4645        re = new RegExp(re, 'g');
4646      }
4647      text = text.replace(re, ext.replace);
4648    }
4649  
4650    return text;
4651  });
4652  
4653  /**
4654   * These are all the transformations that occur *within* block-level
4655   * tags like paragraphs, headers, and list items.
4656   */
4657  showdown.subParser('spanGamut', function (text, options, globals) {
4658    'use strict';
4659  
4660    text = globals.converter._dispatch('spanGamut.before', text, options, globals);
4661    text = showdown.subParser('codeSpans')(text, options, globals);
4662    text = showdown.subParser('escapeSpecialCharsWithinTagAttributes')(text, options, globals);
4663    text = showdown.subParser('encodeBackslashEscapes')(text, options, globals);
4664  
4665    // Process anchor and image tags. Images must come first,
4666    // because ![foo][f] looks like an anchor.
4667    text = showdown.subParser('images')(text, options, globals);
4668    text = showdown.subParser('anchors')(text, options, globals);
4669  
4670    // Make links out of things like `<http://example.com/>`
4671    // Must come after anchors, because you can use < and >
4672    // delimiters in inline links like [this](<url>).
4673    text = showdown.subParser('autoLinks')(text, options, globals);
4674    text = showdown.subParser('simplifiedAutoLinks')(text, options, globals);
4675    text = showdown.subParser('emoji')(text, options, globals);
4676    text = showdown.subParser('underline')(text, options, globals);
4677    text = showdown.subParser('italicsAndBold')(text, options, globals);
4678    text = showdown.subParser('strikethrough')(text, options, globals);
4679    text = showdown.subParser('ellipsis')(text, options, globals);
4680  
4681    // we need to hash HTML tags inside spans
4682    text = showdown.subParser('hashHTMLSpans')(text, options, globals);
4683  
4684    // now we encode amps and angles
4685    text = showdown.subParser('encodeAmpsAndAngles')(text, options, globals);
4686  
4687    // Do hard breaks
4688    if (options.simpleLineBreaks) {
4689      // GFM style hard breaks
4690      // only add line breaks if the text does not contain a block (special case for lists)
4691      if (!/\n\n¨K/.test(text)) {
4692        text = text.replace(/\n+/g, '<br />\n');
4693      }
4694    } else {
4695      // Vanilla hard breaks
4696      text = text.replace(/  +\n/g, '<br />\n');
4697    }
4698  
4699    text = globals.converter._dispatch('spanGamut.after', text, options, globals);
4700    return text;
4701  });
4702  
4703  showdown.subParser('strikethrough', function (text, options, globals) {
4704    'use strict';
4705  
4706    function parseInside (txt) {
4707      if (options.simplifiedAutoLink) {
4708        txt = showdown.subParser('simplifiedAutoLinks')(txt, options, globals);
4709      }
4710      return '<del>' + txt + '</del>';
4711    }
4712  
4713    if (options.strikethrough) {
4714      text = globals.converter._dispatch('strikethrough.before', text, options, globals);
4715      text = text.replace(/(?:~){2}([\s\S]+?)(?:~){2}/g, function (wm, txt) { return parseInside(txt); });
4716      text = globals.converter._dispatch('strikethrough.after', text, options, globals);
4717    }
4718  
4719    return text;
4720  });
4721  
4722  /**
4723   * Strips link definitions from text, stores the URLs and titles in
4724   * hash references.
4725   * Link defs are in the form: ^[id]: url "optional title"
4726   */
4727  showdown.subParser('stripLinkDefinitions', function (text, options, globals) {
4728    'use strict';
4729  
4730    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,
4731        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;
4732  
4733    // attacklab: sentinel workarounds for lack of \A and \Z, safari\khtml bug
4734    text += '¨0';
4735  
4736    var replaceFunc = function (wholeMatch, linkId, url, width, height, blankLines, title) {
4737      linkId = linkId.toLowerCase();
4738      if (url.match(/^data:.+?\/.+?;base64,/)) {
4739        // remove newlines
4740        globals.gUrls[linkId] = url.replace(/\s/g, '');
4741      } else {
4742        globals.gUrls[linkId] = showdown.subParser('encodeAmpsAndAngles')(url, options, globals);  // Link IDs are case-insensitive
4743      }
4744  
4745      if (blankLines) {
4746        // Oops, found blank lines, so it's not a title.
4747        // Put back the parenthetical statement we stole.
4748        return blankLines + title;
4749  
4750      } else {
4751        if (title) {
4752          globals.gTitles[linkId] = title.replace(/"|'/g, '&quot;');
4753        }
4754        if (options.parseImgDimensions && width && height) {
4755          globals.gDimensions[linkId] = {
4756            width:  width,
4757            height: height
4758          };
4759        }
4760      }
4761      // Completely remove the definition from the text
4762      return '';
4763    };
4764  
4765    // first we try to find base64 link references
4766    text = text.replace(base64Regex, replaceFunc);
4767  
4768    text = text.replace(regex, replaceFunc);
4769  
4770    // attacklab: strip sentinel
4771    text = text.replace(/¨0/, '');
4772  
4773    return text;
4774  });
4775  
4776  showdown.subParser('tables', function (text, options, globals) {
4777    'use strict';
4778  
4779    if (!options.tables) {
4780      return text;
4781    }
4782  
4783    var tableRgx       = /^ {0,3}\|?.+\|.+\n {0,3}\|?[ \t]*:?[ \t]*(?:[-=]){2,}[ \t]*:?[ \t]*\|[ \t]*:?[ \t]*(?:[-=]){2,}[\s\S]+?(?:\n\n|¨0)/gm,
4784        //singeColTblRgx = /^ {0,3}\|.+\|\n {0,3}\|[ \t]*:?[ \t]*(?:[-=]){2,}[ \t]*:?[ \t]*\|[ \t]*\n(?: {0,3}\|.+\|\n)+(?:\n\n|¨0)/gm;
4785        singeColTblRgx = /^ {0,3}\|.+\|[ \t]*\n {0,3}\|[ \t]*:?[ \t]*(?:[-=]){2,}[ \t]*:?[ \t]*\|[ \t]*\n( {0,3}\|.+\|[ \t]*\n)*(?:\n|¨0)/gm;
4786  
4787    function parseStyles (sLine) {
4788      if (/^:[ \t]*--*$/.test(sLine)) {
4789        return ' style="text-align:left;"';
4790      } else if (/^--*[ \t]*:[ \t]*$/.test(sLine)) {
4791        return ' style="text-align:right;"';
4792      } else if (/^:[ \t]*--*[ \t]*:$/.test(sLine)) {
4793        return ' style="text-align:center;"';
4794      } else {
4795        return '';
4796      }
4797    }
4798  
4799    function parseHeaders (header, style) {
4800      var id = '';
4801      header = header.trim();
4802      // support both tablesHeaderId and tableHeaderId due to error in documentation so we don't break backwards compatibility
4803      if (options.tablesHeaderId || options.tableHeaderId) {
4804        id = ' id="' + header.replace(/ /g, '_').toLowerCase() + '"';
4805      }
4806      header = showdown.subParser('spanGamut')(header, options, globals);
4807  
4808      return '<th' + id + style + '>' + header + '</th>\n';
4809    }
4810  
4811    function parseCells (cell, style) {
4812      var subText = showdown.subParser('spanGamut')(cell, options, globals);
4813      return '<td' + style + '>' + subText + '</td>\n';
4814    }
4815  
4816    function buildTable (headers, cells) {
4817      var tb = '<table>\n<thead>\n<tr>\n',
4818          tblLgn = headers.length;
4819  
4820      for (var i = 0; i < tblLgn; ++i) {
4821        tb += headers[i];
4822      }
4823      tb += '</tr>\n</thead>\n<tbody>\n';
4824  
4825      for (i = 0; i < cells.length; ++i) {
4826        tb += '<tr>\n';
4827        for (var ii = 0; ii < tblLgn; ++ii) {
4828          tb += cells[i][ii];
4829        }
4830        tb += '</tr>\n';
4831      }
4832      tb += '</tbody>\n</table>\n';
4833      return tb;
4834    }
4835  
4836    function parseTable (rawTable) {
4837      var i, tableLines = rawTable.split('\n');
4838  
4839      for (i = 0; i < tableLines.length; ++i) {
4840        // strip wrong first and last column if wrapped tables are used
4841        if (/^ {0,3}\|/.test(tableLines[i])) {
4842          tableLines[i] = tableLines[i].replace(/^ {0,3}\|/, '');
4843        }
4844        if (/\|[ \t]*$/.test(tableLines[i])) {
4845          tableLines[i] = tableLines[i].replace(/\|[ \t]*$/, '');
4846        }
4847        // parse code spans first, but we only support one line code spans
4848        tableLines[i] = showdown.subParser('codeSpans')(tableLines[i], options, globals);
4849      }
4850  
4851      var rawHeaders = tableLines[0].split('|').map(function (s) { return s.trim();}),
4852          rawStyles = tableLines[1].split('|').map(function (s) { return s.trim();}),
4853          rawCells = [],
4854          headers = [],
4855          styles = [],
4856          cells = [];
4857  
4858      tableLines.shift();
4859      tableLines.shift();
4860  
4861      for (i = 0; i < tableLines.length; ++i) {
4862        if (tableLines[i].trim() === '') {
4863          continue;
4864        }
4865        rawCells.push(
4866          tableLines[i]
4867            .split('|')
4868            .map(function (s) {
4869              return s.trim();
4870            })
4871        );
4872      }
4873  
4874      if (rawHeaders.length < rawStyles.length) {
4875        return rawTable;
4876      }
4877  
4878      for (i = 0; i < rawStyles.length; ++i) {
4879        styles.push(parseStyles(rawStyles[i]));
4880      }
4881  
4882      for (i = 0; i < rawHeaders.length; ++i) {
4883        if (showdown.helper.isUndefined(styles[i])) {
4884          styles[i] = '';
4885        }
4886        headers.push(parseHeaders(rawHeaders[i], styles[i]));
4887      }
4888  
4889      for (i = 0; i < rawCells.length; ++i) {
4890        var row = [];
4891        for (var ii = 0; ii < headers.length; ++ii) {
4892          if (showdown.helper.isUndefined(rawCells[i][ii])) {
4893  
4894          }
4895          row.push(parseCells(rawCells[i][ii], styles[ii]));
4896        }
4897        cells.push(row);
4898      }
4899  
4900      return buildTable(headers, cells);
4901    }
4902  
4903    text = globals.converter._dispatch('tables.before', text, options, globals);
4904  
4905    // find escaped pipe characters
4906    text = text.replace(/\\(\|)/g, showdown.helper.escapeCharactersCallback);
4907  
4908    // parse multi column tables
4909    text = text.replace(tableRgx, parseTable);
4910  
4911    // parse one column tables
4912    text = text.replace(singeColTblRgx, parseTable);
4913  
4914    text = globals.converter._dispatch('tables.after', text, options, globals);
4915  
4916    return text;
4917  });
4918  
4919  showdown.subParser('underline', function (text, options, globals) {
4920    'use strict';
4921  
4922    if (!options.underline) {
4923      return text;
4924    }
4925  
4926    text = globals.converter._dispatch('underline.before', text, options, globals);
4927  
4928    if (options.literalMidWordUnderscores) {
4929      text = text.replace(/\b___(\S[\s\S]*?)___\b/g, function (wm, txt) {
4930        return '<u>' + txt + '</u>';
4931      });
4932      text = text.replace(/\b__(\S[\s\S]*?)__\b/g, function (wm, txt) {
4933        return '<u>' + txt + '</u>';
4934      });
4935    } else {
4936      text = text.replace(/___(\S[\s\S]*?)___/g, function (wm, m) {
4937        return (/\S$/.test(m)) ? '<u>' + m + '</u>' : wm;
4938      });
4939      text = text.replace(/__(\S[\s\S]*?)__/g, function (wm, m) {
4940        return (/\S$/.test(m)) ? '<u>' + m + '</u>' : wm;
4941      });
4942    }
4943  
4944    // escape remaining underscores to prevent them being parsed by italic and bold
4945    text = text.replace(/(_)/g, showdown.helper.escapeCharactersCallback);
4946  
4947    text = globals.converter._dispatch('underline.after', text, options, globals);
4948  
4949    return text;
4950  });
4951  
4952  /**
4953   * Swap back in all the special characters we've hidden.
4954   */
4955  showdown.subParser('unescapeSpecialChars', function (text, options, globals) {
4956    'use strict';
4957    text = globals.converter._dispatch('unescapeSpecialChars.before', text, options, globals);
4958  
4959    text = text.replace(/¨E(\d+)E/g, function (wholeMatch, m1) {
4960      var charCodeToReplace = parseInt(m1);
4961      return String.fromCharCode(charCodeToReplace);
4962    });
4963  
4964    text = globals.converter._dispatch('unescapeSpecialChars.after', text, options, globals);
4965    return text;
4966  });
4967  
4968  showdown.subParser('makeMarkdown.blockquote', function (node, globals) {
4969    'use strict';
4970  
4971    var txt = '';
4972    if (node.hasChildNodes()) {
4973      var children = node.childNodes,
4974          childrenLength = children.length;
4975  
4976      for (var i = 0; i < childrenLength; ++i) {
4977        var innerTxt = showdown.subParser('makeMarkdown.node')(children[i], globals);
4978  
4979        if (innerTxt === '') {
4980          continue;
4981        }
4982        txt += innerTxt;
4983      }
4984    }
4985    // cleanup
4986    txt = txt.trim();
4987    txt = '> ' + txt.split('\n').join('\n> ');
4988    return txt;
4989  });
4990  
4991  showdown.subParser('makeMarkdown.codeBlock', function (node, globals) {
4992    'use strict';
4993  
4994    var lang = node.getAttribute('language'),
4995        num  = node.getAttribute('precodenum');
4996    return '```' + lang + '\n' + globals.preList[num] + '\n```';
4997  });
4998  
4999  showdown.subParser('makeMarkdown.codeSpan', function (node) {
5000    'use strict';
5001  
5002    return '`' + node.innerHTML + '`';
5003  });
5004  
5005  showdown.subParser('makeMarkdown.emphasis', function (node, globals) {
5006    'use strict';
5007  
5008    var txt = '';
5009    if (node.hasChildNodes()) {
5010      txt += '*';
5011      var children = node.childNodes,
5012          childrenLength = children.length;
5013      for (var i = 0; i < childrenLength; ++i) {
5014        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5015      }
5016      txt += '*';
5017    }
5018    return txt;
5019  });
5020  
5021  showdown.subParser('makeMarkdown.header', function (node, globals, headerLevel) {
5022    'use strict';
5023  
5024    var headerMark = new Array(headerLevel + 1).join('#'),
5025        txt = '';
5026  
5027    if (node.hasChildNodes()) {
5028      txt = headerMark + ' ';
5029      var children = node.childNodes,
5030          childrenLength = children.length;
5031  
5032      for (var i = 0; i < childrenLength; ++i) {
5033        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5034      }
5035    }
5036    return txt;
5037  });
5038  
5039  showdown.subParser('makeMarkdown.hr', function () {
5040    'use strict';
5041  
5042    return '---';
5043  });
5044  
5045  showdown.subParser('makeMarkdown.image', function (node) {
5046    'use strict';
5047  
5048    var txt = '';
5049    if (node.hasAttribute('src')) {
5050      txt += '![' + node.getAttribute('alt') + '](';
5051      txt += '<' + node.getAttribute('src') + '>';
5052      if (node.hasAttribute('width') && node.hasAttribute('height')) {
5053        txt += ' =' + node.getAttribute('width') + 'x' + node.getAttribute('height');
5054      }
5055  
5056      if (node.hasAttribute('title')) {
5057        txt += ' "' + node.getAttribute('title') + '"';
5058      }
5059      txt += ')';
5060    }
5061    return txt;
5062  });
5063  
5064  showdown.subParser('makeMarkdown.links', function (node, globals) {
5065    'use strict';
5066  
5067    var txt = '';
5068    if (node.hasChildNodes() && node.hasAttribute('href')) {
5069      var children = node.childNodes,
5070          childrenLength = children.length;
5071      txt = '[';
5072      for (var i = 0; i < childrenLength; ++i) {
5073        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5074      }
5075      txt += '](';
5076      txt += '<' + node.getAttribute('href') + '>';
5077      if (node.hasAttribute('title')) {
5078        txt += ' "' + node.getAttribute('title') + '"';
5079      }
5080      txt += ')';
5081    }
5082    return txt;
5083  });
5084  
5085  showdown.subParser('makeMarkdown.list', function (node, globals, type) {
5086    'use strict';
5087  
5088    var txt = '';
5089    if (!node.hasChildNodes()) {
5090      return '';
5091    }
5092    var listItems       = node.childNodes,
5093        listItemsLenght = listItems.length,
5094        listNum = node.getAttribute('start') || 1;
5095  
5096    for (var i = 0; i < listItemsLenght; ++i) {
5097      if (typeof listItems[i].tagName === 'undefined' || listItems[i].tagName.toLowerCase() !== 'li') {
5098        continue;
5099      }
5100  
5101      // define the bullet to use in list
5102      var bullet = '';
5103      if (type === 'ol') {
5104        bullet = listNum.toString() + '. ';
5105      } else {
5106        bullet = '- ';
5107      }
5108  
5109      // parse list item
5110      txt += bullet + showdown.subParser('makeMarkdown.listItem')(listItems[i], globals);
5111      ++listNum;
5112    }
5113  
5114    // add comment at the end to prevent consecutive lists to be parsed as one
5115    txt += '\n<!-- -->\n';
5116    return txt.trim();
5117  });
5118  
5119  showdown.subParser('makeMarkdown.listItem', function (node, globals) {
5120    'use strict';
5121  
5122    var listItemTxt = '';
5123  
5124    var children = node.childNodes,
5125        childrenLenght = children.length;
5126  
5127    for (var i = 0; i < childrenLenght; ++i) {
5128      listItemTxt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5129    }
5130    // if it's only one liner, we need to add a newline at the end
5131    if (!/\n$/.test(listItemTxt)) {
5132      listItemTxt += '\n';
5133    } else {
5134      // it's multiparagraph, so we need to indent
5135      listItemTxt = listItemTxt
5136        .split('\n')
5137        .join('\n    ')
5138        .replace(/^ {4}$/gm, '')
5139        .replace(/\n\n+/g, '\n\n');
5140    }
5141  
5142    return listItemTxt;
5143  });
5144  
5145  
5146  
5147  showdown.subParser('makeMarkdown.node', function (node, globals, spansOnly) {
5148    'use strict';
5149  
5150    spansOnly = spansOnly || false;
5151  
5152    var txt = '';
5153  
5154    // edge case of text without wrapper paragraph
5155    if (node.nodeType === 3) {
5156      return showdown.subParser('makeMarkdown.txt')(node, globals);
5157    }
5158  
5159    // HTML comment
5160    if (node.nodeType === 8) {
5161      return '<!--' + node.data + '-->\n\n';
5162    }
5163  
5164    // process only node elements
5165    if (node.nodeType !== 1) {
5166      return '';
5167    }
5168  
5169    var tagName = node.tagName.toLowerCase();
5170  
5171    switch (tagName) {
5172  
5173      //
5174      // BLOCKS
5175      //
5176      case 'h1':
5177        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 1) + '\n\n'; }
5178        break;
5179      case 'h2':
5180        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 2) + '\n\n'; }
5181        break;
5182      case 'h3':
5183        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 3) + '\n\n'; }
5184        break;
5185      case 'h4':
5186        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 4) + '\n\n'; }
5187        break;
5188      case 'h5':
5189        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 5) + '\n\n'; }
5190        break;
5191      case 'h6':
5192        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.header')(node, globals, 6) + '\n\n'; }
5193        break;
5194  
5195      case 'p':
5196        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.paragraph')(node, globals) + '\n\n'; }
5197        break;
5198  
5199      case 'blockquote':
5200        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.blockquote')(node, globals) + '\n\n'; }
5201        break;
5202  
5203      case 'hr':
5204        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.hr')(node, globals) + '\n\n'; }
5205        break;
5206  
5207      case 'ol':
5208        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.list')(node, globals, 'ol') + '\n\n'; }
5209        break;
5210  
5211      case 'ul':
5212        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.list')(node, globals, 'ul') + '\n\n'; }
5213        break;
5214  
5215      case 'precode':
5216        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.codeBlock')(node, globals) + '\n\n'; }
5217        break;
5218  
5219      case 'pre':
5220        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.pre')(node, globals) + '\n\n'; }
5221        break;
5222  
5223      case 'table':
5224        if (!spansOnly) { txt = showdown.subParser('makeMarkdown.table')(node, globals) + '\n\n'; }
5225        break;
5226  
5227      //
5228      // SPANS
5229      //
5230      case 'code':
5231        txt = showdown.subParser('makeMarkdown.codeSpan')(node, globals);
5232        break;
5233  
5234      case 'em':
5235      case 'i':
5236        txt = showdown.subParser('makeMarkdown.emphasis')(node, globals);
5237        break;
5238  
5239      case 'strong':
5240      case 'b':
5241        txt = showdown.subParser('makeMarkdown.strong')(node, globals);
5242        break;
5243  
5244      case 'del':
5245        txt = showdown.subParser('makeMarkdown.strikethrough')(node, globals);
5246        break;
5247  
5248      case 'a':
5249        txt = showdown.subParser('makeMarkdown.links')(node, globals);
5250        break;
5251  
5252      case 'img':
5253        txt = showdown.subParser('makeMarkdown.image')(node, globals);
5254        break;
5255  
5256      default:
5257        txt = node.outerHTML + '\n\n';
5258    }
5259  
5260    // common normalization
5261    // TODO eventually
5262  
5263    return txt;
5264  });
5265  
5266  showdown.subParser('makeMarkdown.paragraph', function (node, globals) {
5267    'use strict';
5268  
5269    var txt = '';
5270    if (node.hasChildNodes()) {
5271      var children = node.childNodes,
5272          childrenLength = children.length;
5273      for (var i = 0; i < childrenLength; ++i) {
5274        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5275      }
5276    }
5277  
5278    // some text normalization
5279    txt = txt.trim();
5280  
5281    return txt;
5282  });
5283  
5284  showdown.subParser('makeMarkdown.pre', function (node, globals) {
5285    'use strict';
5286  
5287    var num  = node.getAttribute('prenum');
5288    return '<pre>' + globals.preList[num] + '</pre>';
5289  });
5290  
5291  showdown.subParser('makeMarkdown.strikethrough', function (node, globals) {
5292    'use strict';
5293  
5294    var txt = '';
5295    if (node.hasChildNodes()) {
5296      txt += '~~';
5297      var children = node.childNodes,
5298          childrenLength = children.length;
5299      for (var i = 0; i < childrenLength; ++i) {
5300        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5301      }
5302      txt += '~~';
5303    }
5304    return txt;
5305  });
5306  
5307  showdown.subParser('makeMarkdown.strong', function (node, globals) {
5308    'use strict';
5309  
5310    var txt = '';
5311    if (node.hasChildNodes()) {
5312      txt += '**';
5313      var children = node.childNodes,
5314          childrenLength = children.length;
5315      for (var i = 0; i < childrenLength; ++i) {
5316        txt += showdown.subParser('makeMarkdown.node')(children[i], globals);
5317      }
5318      txt += '**';
5319    }
5320    return txt;
5321  });
5322  
5323  showdown.subParser('makeMarkdown.table', function (node, globals) {
5324    'use strict';
5325  
5326    var txt = '',
5327        tableArray = [[], []],
5328        headings   = node.querySelectorAll('thead>tr>th'),
5329        rows       = node.querySelectorAll('tbody>tr'),
5330        i, ii;
5331    for (i = 0; i < headings.length; ++i) {
5332      var headContent = showdown.subParser('makeMarkdown.tableCell')(headings[i], globals),
5333          allign = '---';
5334  
5335      if (headings[i].hasAttribute('style')) {
5336        var style = headings[i].getAttribute('style').toLowerCase().replace(/\s/g, '');
5337        switch (style) {
5338          case 'text-align:left;':
5339            allign = ':---';
5340            break;
5341          case 'text-align:right;':
5342            allign = '---:';
5343            break;
5344          case 'text-align:center;':
5345            allign = ':---:';
5346            break;
5347        }
5348      }
5349      tableArray[0][i] = headContent.trim();
5350      tableArray[1][i] = allign;
5351    }
5352  
5353    for (i = 0; i < rows.length; ++i) {
5354      var r = tableArray.push([]) - 1,
5355          cols = rows[i].getElementsByTagName('td');
5356  
5357      for (ii = 0; ii < headings.length; ++ii) {
5358        var cellContent = ' ';
5359        if (typeof cols[ii] !== 'undefined') {
5360          cellContent = showdown.subParser('makeMarkdown.tableCell')(cols[ii], globals);
5361        }
5362        tableArray[r].push(cellContent);
5363      }
5364    }
5365  
5366    var cellSpacesCount = 3;
5367    for (i = 0; i < tableArray.length; ++i) {
5368      for (ii = 0; ii < tableArray[i].length; ++ii) {
5369        var strLen = tableArray[i][ii].length;
5370        if (strLen > cellSpacesCount) {
5371          cellSpacesCount = strLen;
5372        }
5373      }
5374    }
5375  
5376    for (i = 0; i < tableArray.length; ++i) {
5377      for (ii = 0; ii < tableArray[i].length; ++ii) {
5378        if (i === 1) {
5379          if (tableArray[i][ii].slice(-1) === ':') {
5380            tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii].slice(-1), cellSpacesCount - 1, '-') + ':';
5381          } else {
5382            tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount, '-');
5383          }
5384        } else {
5385          tableArray[i][ii] = showdown.helper.padEnd(tableArray[i][ii], cellSpacesCount);
5386        }
5387      }
5388      txt += '| ' + tableArray[i].join(' | ') + ' |\n';
5389    }
5390  
5391    return txt.trim();
5392  });
5393  
5394  showdown.subParser('makeMarkdown.tableCell', function (node, globals) {
5395    'use strict';
5396  
5397    var txt = '';
5398    if (!node.hasChildNodes()) {
5399      return '';
5400    }
5401    var children = node.childNodes,
5402        childrenLength = children.length;
5403  
5404    for (var i = 0; i < childrenLength; ++i) {
5405      txt += showdown.subParser('makeMarkdown.node')(children[i], globals, true);
5406    }
5407    return txt.trim();
5408  });
5409  
5410  showdown.subParser('makeMarkdown.txt', function (node) {
5411    'use strict';
5412  
5413    var txt = node.nodeValue;
5414  
5415    // multiple spaces are collapsed
5416    txt = txt.replace(/ +/g, ' ');
5417  
5418    // replace the custom ¨NBSP; with a space
5419    txt = txt.replace(/¨NBSP;/g, ' ');
5420  
5421    // ", <, > and & should replace escaped html entities
5422    txt = showdown.helper.unescapeHTMLEntities(txt);
5423  
5424    // escape markdown magic characters
5425    // emphasis, strong and strikethrough - can appear everywhere
5426    // we also escape pipe (|) because of tables
5427    // and escape ` because of code blocks and spans
5428    txt = txt.replace(/([*_~|`])/g, '\\$1');
5429  
5430    // escape > because of blockquotes
5431    txt = txt.replace(/^(\s*)>/g, '\\$1>');
5432  
5433    // hash character, only troublesome at the beginning of a line because of headers
5434    txt = txt.replace(/^#/gm, '\\#');
5435  
5436    // horizontal rules
5437    txt = txt.replace(/^(\s*)([-=]{3,})(\s*)$/, '$1\\$2$3');
5438  
5439    // dot, because of ordered lists, only troublesome at the beginning of a line when preceded by an integer
5440    txt = txt.replace(/^( {0,3}\d+)\./gm, '$1\\.');
5441  
5442    // +, * and -, at the beginning of a line becomes a list, so we need to escape them also (asterisk was already escaped)
5443    txt = txt.replace(/^( {0,3})([+-])/gm, '$1\\$2');
5444  
5445    // images and links, ] followed by ( is problematic, so we escape it
5446    txt = txt.replace(/]([\s]*)\(/g, '\\]$1\\(');
5447  
5448    // reference URIs must also be escaped
5449    txt = txt.replace(/^ {0,3}\[([\S \t]*?)]:/gm, '\\[$1]:');
5450  
5451    return txt;
5452  });
5453  
5454  var root = this;
5455  
5456  // AMD Loader
5457  if (true) {
5458    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {
5459      'use strict';
5460      return showdown;
5461    }).call(exports, __webpack_require__, exports, module),
5462                  __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
5463  
5464  // CommonJS/nodeJS Loader
5465  } else {}
5466  }).call(this);
5467  
5468  
5469  
5470  /***/ }),
5471  
5472  /***/ 29:
5473  /***/ (function(module, exports) {
5474  
5475  (function() { module.exports = this["wp"]["dom"]; }());
5476  
5477  /***/ }),
5478  
5479  /***/ 30:
5480  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5481  
5482  "use strict";
5483  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _unsupportedIterableToArray; });
5484  /* harmony import */ var _arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(27);
5485  
5486  function _unsupportedIterableToArray(o, minLen) {
5487    if (!o) return;
5488    if (typeof o === "string") return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
5489    var n = Object.prototype.toString.call(o).slice(8, -1);
5490    if (n === "Object" && o.constructor) n = o.constructor.name;
5491    if (n === "Map" || n === "Set") return Array.from(o);
5492    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Object(_arrayLikeToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(o, minLen);
5493  }
5494  
5495  /***/ }),
5496  
5497  /***/ 33:
5498  /***/ (function(module, exports) {
5499  
5500  (function() { module.exports = this["wp"]["hooks"]; }());
5501  
5502  /***/ }),
5503  
5504  /***/ 36:
5505  /***/ (function(module, exports) {
5506  
5507  (function() { module.exports = this["wp"]["deprecated"]; }());
5508  
5509  /***/ }),
5510  
5511  /***/ 37:
5512  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5513  
5514  "use strict";
5515  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });
5516  function _iterableToArray(iter) {
5517    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
5518  }
5519  
5520  /***/ }),
5521  
5522  /***/ 38:
5523  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5524  
5525  "use strict";
5526  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; });
5527  function _arrayWithHoles(arr) {
5528    if (Array.isArray(arr)) return arr;
5529  }
5530  
5531  /***/ }),
5532  
5533  /***/ 39:
5534  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5535  
5536  "use strict";
5537  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; });
5538  function _nonIterableRest() {
5539    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
5540  }
5541  
5542  /***/ }),
5543  
5544  /***/ 4:
5545  /***/ (function(module, exports) {
5546  
5547  (function() { module.exports = this["wp"]["data"]; }());
5548  
5549  /***/ }),
5550  
5551  /***/ 41:
5552  /***/ (function(module, exports) {
5553  
5554  (function() { module.exports = this["wp"]["blob"]; }());
5555  
5556  /***/ }),
5557  
5558  /***/ 42:
5559  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5560  
5561  "use strict";
5562  
5563  
5564  var LEAF_KEY, hasWeakMap;
5565  
5566  /**
5567   * Arbitrary value used as key for referencing cache object in WeakMap tree.
5568   *
5569   * @type {Object}
5570   */
5571  LEAF_KEY = {};
5572  
5573  /**
5574   * Whether environment supports WeakMap.
5575   *
5576   * @type {boolean}
5577   */
5578  hasWeakMap = typeof WeakMap !== 'undefined';
5579  
5580  /**
5581   * Returns the first argument as the sole entry in an array.
5582   *
5583   * @param {*} value Value to return.
5584   *
5585   * @return {Array} Value returned as entry in array.
5586   */
5587  function arrayOf( value ) {
5588      return [ value ];
5589  }
5590  
5591  /**
5592   * Returns true if the value passed is object-like, or false otherwise. A value
5593   * is object-like if it can support property assignment, e.g. object or array.
5594   *
5595   * @param {*} value Value to test.
5596   *
5597   * @return {boolean} Whether value is object-like.
5598   */
5599  function isObjectLike( value ) {
5600      return !! value && 'object' === typeof value;
5601  }
5602  
5603  /**
5604   * Creates and returns a new cache object.
5605   *
5606   * @return {Object} Cache object.
5607   */
5608  function createCache() {
5609      var cache = {
5610          clear: function() {
5611              cache.head = null;
5612          },
5613      };
5614  
5615      return cache;
5616  }
5617  
5618  /**
5619   * Returns true if entries within the two arrays are strictly equal by
5620   * reference from a starting index.
5621   *
5622   * @param {Array}  a         First array.
5623   * @param {Array}  b         Second array.
5624   * @param {number} fromIndex Index from which to start comparison.
5625   *
5626   * @return {boolean} Whether arrays are shallowly equal.
5627   */
5628  function isShallowEqual( a, b, fromIndex ) {
5629      var i;
5630  
5631      if ( a.length !== b.length ) {
5632          return false;
5633      }
5634  
5635      for ( i = fromIndex; i < a.length; i++ ) {
5636          if ( a[ i ] !== b[ i ] ) {
5637              return false;
5638          }
5639      }
5640  
5641      return true;
5642  }
5643  
5644  /**
5645   * Returns a memoized selector function. The getDependants function argument is
5646   * called before the memoized selector and is expected to return an immutable
5647   * reference or array of references on which the selector depends for computing
5648   * its own return value. The memoize cache is preserved only as long as those
5649   * dependant references remain the same. If getDependants returns a different
5650   * reference(s), the cache is cleared and the selector value regenerated.
5651   *
5652   * @param {Function} selector      Selector function.
5653   * @param {Function} getDependants Dependant getter returning an immutable
5654   *                                 reference or array of reference used in
5655   *                                 cache bust consideration.
5656   *
5657   * @return {Function} Memoized selector.
5658   */
5659  /* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) {
5660      var rootCache, getCache;
5661  
5662      // Use object source as dependant if getter not provided
5663      if ( ! getDependants ) {
5664          getDependants = arrayOf;
5665      }
5666  
5667      /**
5668       * Returns the root cache. If WeakMap is supported, this is assigned to the
5669       * root WeakMap cache set, otherwise it is a shared instance of the default
5670       * cache object.
5671       *
5672       * @return {(WeakMap|Object)} Root cache object.
5673       */
5674  	function getRootCache() {
5675          return rootCache;
5676      }
5677  
5678      /**
5679       * Returns the cache for a given dependants array. When possible, a WeakMap
5680       * will be used to create a unique cache for each set of dependants. This
5681       * is feasible due to the nature of WeakMap in allowing garbage collection
5682       * to occur on entries where the key object is no longer referenced. Since
5683       * WeakMap requires the key to be an object, this is only possible when the
5684       * dependant is object-like. The root cache is created as a hierarchy where
5685       * each top-level key is the first entry in a dependants set, the value a
5686       * WeakMap where each key is the next dependant, and so on. This continues
5687       * so long as the dependants are object-like. If no dependants are object-
5688       * like, then the cache is shared across all invocations.
5689       *
5690       * @see isObjectLike
5691       *
5692       * @param {Array} dependants Selector dependants.
5693       *
5694       * @return {Object} Cache object.
5695       */
5696  	function getWeakMapCache( dependants ) {
5697          var caches = rootCache,
5698              isUniqueByDependants = true,
5699              i, dependant, map, cache;
5700  
5701          for ( i = 0; i < dependants.length; i++ ) {
5702              dependant = dependants[ i ];
5703  
5704              // Can only compose WeakMap from object-like key.
5705              if ( ! isObjectLike( dependant ) ) {
5706                  isUniqueByDependants = false;
5707                  break;
5708              }
5709  
5710              // Does current segment of cache already have a WeakMap?
5711              if ( caches.has( dependant ) ) {
5712                  // Traverse into nested WeakMap.
5713                  caches = caches.get( dependant );
5714              } else {
5715                  // Create, set, and traverse into a new one.
5716                  map = new WeakMap();
5717                  caches.set( dependant, map );
5718                  caches = map;
5719              }
5720          }
5721  
5722          // We use an arbitrary (but consistent) object as key for the last item
5723          // in the WeakMap to serve as our running cache.
5724          if ( ! caches.has( LEAF_KEY ) ) {
5725              cache = createCache();
5726              cache.isUniqueByDependants = isUniqueByDependants;
5727              caches.set( LEAF_KEY, cache );
5728          }
5729  
5730          return caches.get( LEAF_KEY );
5731      }
5732  
5733      // Assign cache handler by availability of WeakMap
5734      getCache = hasWeakMap ? getWeakMapCache : getRootCache;
5735  
5736      /**
5737       * Resets root memoization cache.
5738       */
5739  	function clear() {
5740          rootCache = hasWeakMap ? new WeakMap() : createCache();
5741      }
5742  
5743      // eslint-disable-next-line jsdoc/check-param-names
5744      /**
5745       * The augmented selector call, considering first whether dependants have
5746       * changed before passing it to underlying memoize function.
5747       *
5748       * @param {Object} source    Source object for derivation.
5749       * @param {...*}   extraArgs Additional arguments to pass to selector.
5750       *
5751       * @return {*} Selector result.
5752       */
5753  	function callSelector( /* source, ...extraArgs */ ) {
5754          var len = arguments.length,
5755              cache, node, i, args, dependants;
5756  
5757          // Create copy of arguments (avoid leaking deoptimization).
5758          args = new Array( len );
5759          for ( i = 0; i < len; i++ ) {
5760              args[ i ] = arguments[ i ];
5761          }
5762  
5763          dependants = getDependants.apply( null, args );
5764          cache = getCache( dependants );
5765  
5766          // If not guaranteed uniqueness by dependants (primitive type or lack
5767          // of WeakMap support), shallow compare against last dependants and, if
5768          // references have changed, destroy cache to recalculate result.
5769          if ( ! cache.isUniqueByDependants ) {
5770              if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) {
5771                  cache.clear();
5772              }
5773  
5774              cache.lastDependants = dependants;
5775          }
5776  
5777          node = cache.head;
5778          while ( node ) {
5779              // Check whether node arguments match arguments
5780              if ( ! isShallowEqual( node.args, args, 1 ) ) {
5781                  node = node.next;
5782                  continue;
5783              }
5784  
5785              // At this point we can assume we've found a match
5786  
5787              // Surface matched node to head if not already
5788              if ( node !== cache.head ) {
5789                  // Adjust siblings to point to each other.
5790                  node.prev.next = node.next;
5791                  if ( node.next ) {
5792                      node.next.prev = node.prev;
5793                  }
5794  
5795                  node.next = cache.head;
5796                  node.prev = null;
5797                  cache.head.prev = node;
5798                  cache.head = node;
5799              }
5800  
5801              // Return immediately
5802              return node.val;
5803          }
5804  
5805          // No cached value found. Continue to insertion phase:
5806  
5807          node = {
5808              // Generate the result from original function
5809              val: selector.apply( null, args ),
5810          };
5811  
5812          // Avoid including the source object in the cache.
5813          args[ 0 ] = null;
5814          node.args = args;
5815  
5816          // Don't need to check whether node is already head, since it would
5817          // have been returned above already if it was
5818  
5819          // Shift existing head down list
5820          if ( cache.head ) {
5821              cache.head.prev = node;
5822              node.next = cache.head;
5823          }
5824  
5825          cache.head = node;
5826  
5827          return node.val;
5828      }
5829  
5830      callSelector.getDependants = getDependants;
5831      callSelector.clear = clear;
5832      clear();
5833  
5834      return callSelector;
5835  });
5836  
5837  
5838  /***/ }),
5839  
5840  /***/ 459:
5841  /***/ (function(module, __webpack_exports__, __webpack_require__) {
5842  
5843  "use strict";
5844  // ESM COMPAT FLAG
5845  __webpack_require__.r(__webpack_exports__);
5846  
5847  // EXPORTS
5848  __webpack_require__.d(__webpack_exports__, "createBlock", function() { return /* reexport */ createBlock; });
5849  __webpack_require__.d(__webpack_exports__, "createBlocksFromInnerBlocksTemplate", function() { return /* reexport */ createBlocksFromInnerBlocksTemplate; });
5850  __webpack_require__.d(__webpack_exports__, "cloneBlock", function() { return /* reexport */ cloneBlock; });
5851  __webpack_require__.d(__webpack_exports__, "getPossibleBlockTransformations", function() { return /* reexport */ getPossibleBlockTransformations; });
5852  __webpack_require__.d(__webpack_exports__, "switchToBlockType", function() { return /* reexport */ switchToBlockType; });
5853  __webpack_require__.d(__webpack_exports__, "getBlockTransforms", function() { return /* reexport */ getBlockTransforms; });
5854  __webpack_require__.d(__webpack_exports__, "findTransform", function() { return /* reexport */ findTransform; });
5855  __webpack_require__.d(__webpack_exports__, "getBlockFromExample", function() { return /* reexport */ factory_getBlockFromExample; });
5856  __webpack_require__.d(__webpack_exports__, "parse", function() { return /* reexport */ parser; });
5857  __webpack_require__.d(__webpack_exports__, "getBlockAttributes", function() { return /* reexport */ getBlockAttributes; });
5858  __webpack_require__.d(__webpack_exports__, "parseWithAttributeSchema", function() { return /* reexport */ parseWithAttributeSchema; });
5859  __webpack_require__.d(__webpack_exports__, "pasteHandler", function() { return /* reexport */ pasteHandler; });
5860  __webpack_require__.d(__webpack_exports__, "rawHandler", function() { return /* reexport */ rawHandler; });
5861  __webpack_require__.d(__webpack_exports__, "getPhrasingContentSchema", function() { return /* reexport */ deprecatedGetPhrasingContentSchema; });
5862  __webpack_require__.d(__webpack_exports__, "serialize", function() { return /* reexport */ serialize; });
5863  __webpack_require__.d(__webpack_exports__, "getBlockContent", function() { return /* reexport */ getBlockContent; });
5864  __webpack_require__.d(__webpack_exports__, "getBlockDefaultClassName", function() { return /* reexport */ getBlockDefaultClassName; });
5865  __webpack_require__.d(__webpack_exports__, "getBlockMenuDefaultClassName", function() { return /* reexport */ getBlockMenuDefaultClassName; });
5866  __webpack_require__.d(__webpack_exports__, "getSaveElement", function() { return /* reexport */ getSaveElement; });
5867  __webpack_require__.d(__webpack_exports__, "getSaveContent", function() { return /* reexport */ getSaveContent; });
5868  __webpack_require__.d(__webpack_exports__, "__unstableGetBlockProps", function() { return /* reexport */ getBlockProps; });
5869  __webpack_require__.d(__webpack_exports__, "isValidBlockContent", function() { return /* reexport */ isValidBlockContent; });
5870  __webpack_require__.d(__webpack_exports__, "getCategories", function() { return /* reexport */ categories_getCategories; });
5871  __webpack_require__.d(__webpack_exports__, "setCategories", function() { return /* reexport */ categories_setCategories; });
5872  __webpack_require__.d(__webpack_exports__, "updateCategory", function() { return /* reexport */ categories_updateCategory; });
5873  __webpack_require__.d(__webpack_exports__, "registerBlockType", function() { return /* reexport */ registerBlockType; });
5874  __webpack_require__.d(__webpack_exports__, "registerBlockCollection", function() { return /* reexport */ registerBlockCollection; });
5875  __webpack_require__.d(__webpack_exports__, "unregisterBlockType", function() { return /* reexport */ unregisterBlockType; });
5876  __webpack_require__.d(__webpack_exports__, "setFreeformContentHandlerName", function() { return /* reexport */ setFreeformContentHandlerName; });
5877  __webpack_require__.d(__webpack_exports__, "getFreeformContentHandlerName", function() { return /* reexport */ getFreeformContentHandlerName; });
5878  __webpack_require__.d(__webpack_exports__, "setUnregisteredTypeHandlerName", function() { return /* reexport */ setUnregisteredTypeHandlerName; });
5879  __webpack_require__.d(__webpack_exports__, "getUnregisteredTypeHandlerName", function() { return /* reexport */ getUnregisteredTypeHandlerName; });
5880  __webpack_require__.d(__webpack_exports__, "setDefaultBlockName", function() { return /* reexport */ registration_setDefaultBlockName; });
5881  __webpack_require__.d(__webpack_exports__, "getDefaultBlockName", function() { return /* reexport */ registration_getDefaultBlockName; });
5882  __webpack_require__.d(__webpack_exports__, "setGroupingBlockName", function() { return /* reexport */ registration_setGroupingBlockName; });
5883  __webpack_require__.d(__webpack_exports__, "getGroupingBlockName", function() { return /* reexport */ registration_getGroupingBlockName; });
5884  __webpack_require__.d(__webpack_exports__, "getBlockType", function() { return /* reexport */ registration_getBlockType; });
5885  __webpack_require__.d(__webpack_exports__, "getBlockTypes", function() { return /* reexport */ registration_getBlockTypes; });
5886  __webpack_require__.d(__webpack_exports__, "getBlockSupport", function() { return /* reexport */ registration_getBlockSupport; });
5887  __webpack_require__.d(__webpack_exports__, "hasBlockSupport", function() { return /* reexport */ registration_hasBlockSupport; });
5888  __webpack_require__.d(__webpack_exports__, "getBlockVariations", function() { return /* reexport */ registration_getBlockVariations; });
5889  __webpack_require__.d(__webpack_exports__, "isReusableBlock", function() { return /* reexport */ isReusableBlock; });
5890  __webpack_require__.d(__webpack_exports__, "getChildBlockNames", function() { return /* reexport */ registration_getChildBlockNames; });
5891  __webpack_require__.d(__webpack_exports__, "hasChildBlocks", function() { return /* reexport */ registration_hasChildBlocks; });
5892  __webpack_require__.d(__webpack_exports__, "hasChildBlocksWithInserterSupport", function() { return /* reexport */ registration_hasChildBlocksWithInserterSupport; });
5893  __webpack_require__.d(__webpack_exports__, "unstable__bootstrapServerSideBlockDefinitions", function() { return /* reexport */ unstable__bootstrapServerSideBlockDefinitions; });
5894  __webpack_require__.d(__webpack_exports__, "registerBlockStyle", function() { return /* reexport */ registration_registerBlockStyle; });
5895  __webpack_require__.d(__webpack_exports__, "unregisterBlockStyle", function() { return /* reexport */ registration_unregisterBlockStyle; });
5896  __webpack_require__.d(__webpack_exports__, "registerBlockVariation", function() { return /* reexport */ registration_registerBlockVariation; });
5897  __webpack_require__.d(__webpack_exports__, "unregisterBlockVariation", function() { return /* reexport */ registration_unregisterBlockVariation; });
5898  __webpack_require__.d(__webpack_exports__, "isUnmodifiedDefaultBlock", function() { return /* reexport */ isUnmodifiedDefaultBlock; });
5899  __webpack_require__.d(__webpack_exports__, "normalizeIconObject", function() { return /* reexport */ normalizeIconObject; });
5900  __webpack_require__.d(__webpack_exports__, "isValidIcon", function() { return /* reexport */ isValidIcon; });
5901  __webpack_require__.d(__webpack_exports__, "__experimentalGetBlockLabel", function() { return /* reexport */ getBlockLabel; });
5902  __webpack_require__.d(__webpack_exports__, "__experimentalGetAccessibleBlockLabel", function() { return /* reexport */ getAccessibleBlockLabel; });
5903  __webpack_require__.d(__webpack_exports__, "doBlocksMatchTemplate", function() { return /* reexport */ doBlocksMatchTemplate; });
5904  __webpack_require__.d(__webpack_exports__, "synchronizeBlocksWithTemplate", function() { return /* reexport */ synchronizeBlocksWithTemplate; });
5905  __webpack_require__.d(__webpack_exports__, "children", function() { return /* reexport */ api_children; });
5906  __webpack_require__.d(__webpack_exports__, "node", function() { return /* reexport */ api_node; });
5907  __webpack_require__.d(__webpack_exports__, "__EXPERIMENTAL_STYLE_PROPERTY", function() { return /* reexport */ __EXPERIMENTAL_STYLE_PROPERTY; });
5908  __webpack_require__.d(__webpack_exports__, "withBlockContentContext", function() { return /* reexport */ withBlockContentContext; });
5909  
5910  // NAMESPACE OBJECT: ./node_modules/@wordpress/blocks/build-module/store/selectors.js
5911  var selectors_namespaceObject = {};
5912  __webpack_require__.r(selectors_namespaceObject);
5913  __webpack_require__.d(selectors_namespaceObject, "getBlockTypes", function() { return getBlockTypes; });
5914  __webpack_require__.d(selectors_namespaceObject, "getBlockType", function() { return getBlockType; });
5915  __webpack_require__.d(selectors_namespaceObject, "getBlockStyles", function() { return getBlockStyles; });
5916  __webpack_require__.d(selectors_namespaceObject, "getBlockVariations", function() { return selectors_getBlockVariations; });
5917  __webpack_require__.d(selectors_namespaceObject, "getDefaultBlockVariation", function() { return getDefaultBlockVariation; });
5918  __webpack_require__.d(selectors_namespaceObject, "getCategories", function() { return getCategories; });
5919  __webpack_require__.d(selectors_namespaceObject, "getCollections", function() { return getCollections; });
5920  __webpack_require__.d(selectors_namespaceObject, "getDefaultBlockName", function() { return getDefaultBlockName; });
5921  __webpack_require__.d(selectors_namespaceObject, "getFreeformFallbackBlockName", function() { return getFreeformFallbackBlockName; });
5922  __webpack_require__.d(selectors_namespaceObject, "getUnregisteredFallbackBlockName", function() { return getUnregisteredFallbackBlockName; });
5923  __webpack_require__.d(selectors_namespaceObject, "getGroupingBlockName", function() { return getGroupingBlockName; });
5924  __webpack_require__.d(selectors_namespaceObject, "getChildBlockNames", function() { return selectors_getChildBlockNames; });
5925  __webpack_require__.d(selectors_namespaceObject, "getBlockSupport", function() { return selectors_getBlockSupport; });
5926  __webpack_require__.d(selectors_namespaceObject, "hasBlockSupport", function() { return hasBlockSupport; });
5927  __webpack_require__.d(selectors_namespaceObject, "isMatchingSearchTerm", function() { return isMatchingSearchTerm; });
5928  __webpack_require__.d(selectors_namespaceObject, "hasChildBlocks", function() { return selectors_hasChildBlocks; });
5929  __webpack_require__.d(selectors_namespaceObject, "hasChildBlocksWithInserterSupport", function() { return selectors_hasChildBlocksWithInserterSupport; });
5930  
5931  // NAMESPACE OBJECT: ./node_modules/@wordpress/blocks/build-module/store/actions.js
5932  var actions_namespaceObject = {};
5933  __webpack_require__.r(actions_namespaceObject);
5934  __webpack_require__.d(actions_namespaceObject, "addBlockTypes", function() { return addBlockTypes; });
5935  __webpack_require__.d(actions_namespaceObject, "removeBlockTypes", function() { return removeBlockTypes; });
5936  __webpack_require__.d(actions_namespaceObject, "addBlockStyles", function() { return addBlockStyles; });
5937  __webpack_require__.d(actions_namespaceObject, "removeBlockStyles", function() { return removeBlockStyles; });
5938  __webpack_require__.d(actions_namespaceObject, "addBlockVariations", function() { return addBlockVariations; });
5939  __webpack_require__.d(actions_namespaceObject, "removeBlockVariations", function() { return removeBlockVariations; });
5940  __webpack_require__.d(actions_namespaceObject, "setDefaultBlockName", function() { return setDefaultBlockName; });
5941  __webpack_require__.d(actions_namespaceObject, "setFreeformFallbackBlockName", function() { return setFreeformFallbackBlockName; });
5942  __webpack_require__.d(actions_namespaceObject, "setUnregisteredFallbackBlockName", function() { return setUnregisteredFallbackBlockName; });
5943  __webpack_require__.d(actions_namespaceObject, "setGroupingBlockName", function() { return setGroupingBlockName; });
5944  __webpack_require__.d(actions_namespaceObject, "setCategories", function() { return setCategories; });
5945  __webpack_require__.d(actions_namespaceObject, "updateCategory", function() { return updateCategory; });
5946  __webpack_require__.d(actions_namespaceObject, "addBlockCollection", function() { return addBlockCollection; });
5947  __webpack_require__.d(actions_namespaceObject, "removeBlockCollection", function() { return removeBlockCollection; });
5948  
5949  // EXTERNAL MODULE: external {"this":["wp","data"]}
5950  var external_this_wp_data_ = __webpack_require__(4);
5951  
5952  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
5953  var toConsumableArray = __webpack_require__(17);
5954  
5955  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
5956  var defineProperty = __webpack_require__(5);
5957  
5958  // EXTERNAL MODULE: external {"this":"lodash"}
5959  var external_this_lodash_ = __webpack_require__(2);
5960  
5961  // EXTERNAL MODULE: external {"this":["wp","i18n"]}
5962  var external_this_wp_i18n_ = __webpack_require__(1);
5963  
5964  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/reducer.js
5965  
5966  
5967  
5968  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
5969  
5970  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
5971  
5972  /**
5973   * External dependencies
5974   */
5975  
5976  /**
5977   * WordPress dependencies
5978   */
5979  
5980  
5981  
5982  /**
5983   * @typedef {Object} WPBlockCategory
5984   *
5985   * @property {string} slug  Unique category slug.
5986   * @property {string} title Category label, for display in user interface.
5987   */
5988  
5989  /**
5990   * Default set of categories.
5991   *
5992   * @type {WPBlockCategory[]}
5993   */
5994  
5995  var DEFAULT_CATEGORIES = [{
5996    slug: 'text',
5997    title: Object(external_this_wp_i18n_["__"])('Text')
5998  }, {
5999    slug: 'media',
6000    title: Object(external_this_wp_i18n_["__"])('Media')
6001  }, {
6002    slug: 'design',
6003    title: Object(external_this_wp_i18n_["__"])('Design')
6004  }, {
6005    slug: 'widgets',
6006    title: Object(external_this_wp_i18n_["__"])('Widgets')
6007  }, {
6008    slug: 'embed',
6009    title: Object(external_this_wp_i18n_["__"])('Embeds')
6010  }, {
6011    slug: 'reusable',
6012    title: Object(external_this_wp_i18n_["__"])('Reusable blocks')
6013  }];
6014  /**
6015   * Reducer managing the block types
6016   *
6017   * @param {Object} state  Current state.
6018   * @param {Object} action Dispatched action.
6019   *
6020   * @return {Object} Updated state.
6021   */
6022  
6023  function reducer_blockTypes() {
6024    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
6025    var action = arguments.length > 1 ? arguments[1] : undefined;
6026  
6027    switch (action.type) {
6028      case 'ADD_BLOCK_TYPES':
6029        return _objectSpread(_objectSpread({}, state), Object(external_this_lodash_["keyBy"])(Object(external_this_lodash_["map"])(action.blockTypes, function (blockType) {
6030          return Object(external_this_lodash_["omit"])(blockType, 'styles ');
6031        }), 'name'));
6032  
6033      case 'REMOVE_BLOCK_TYPES':
6034        return Object(external_this_lodash_["omit"])(state, action.names);
6035    }
6036  
6037    return state;
6038  }
6039  /**
6040   * Reducer managing the block style variations.
6041   *
6042   * @param {Object} state  Current state.
6043   * @param {Object} action Dispatched action.
6044   *
6045   * @return {Object} Updated state.
6046   */
6047  
6048  function blockStyles() {
6049    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
6050    var action = arguments.length > 1 ? arguments[1] : undefined;
6051  
6052    switch (action.type) {
6053      case 'ADD_BLOCK_TYPES':
6054        return _objectSpread(_objectSpread({}, state), Object(external_this_lodash_["mapValues"])(Object(external_this_lodash_["keyBy"])(action.blockTypes, 'name'), function (blockType) {
6055          return Object(external_this_lodash_["uniqBy"])([].concat(Object(toConsumableArray["a" /* default */])(Object(external_this_lodash_["get"])(blockType, ['styles'], [])), Object(toConsumableArray["a" /* default */])(Object(external_this_lodash_["get"])(state, [blockType.name], []))), function (style) {
6056            return style.name;
6057          });
6058        }));
6059  
6060      case 'ADD_BLOCK_STYLES':
6061        return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, action.blockName, Object(external_this_lodash_["uniqBy"])([].concat(Object(toConsumableArray["a" /* default */])(Object(external_this_lodash_["get"])(state, [action.blockName], [])), Object(toConsumableArray["a" /* default */])(action.styles)), function (style) {
6062          return style.name;
6063        })));
6064  
6065      case 'REMOVE_BLOCK_STYLES':
6066        return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, action.blockName, Object(external_this_lodash_["filter"])(Object(external_this_lodash_["get"])(state, [action.blockName], []), function (style) {
6067          return action.styleNames.indexOf(style.name) === -1;
6068        })));
6069    }
6070  
6071    return state;
6072  }
6073  /**
6074   * Reducer managing the block variations.
6075   *
6076   * @param {Object} state  Current state.
6077   * @param {Object} action Dispatched action.
6078   *
6079   * @return {Object} Updated state.
6080   */
6081  
6082  function blockVariations() {
6083    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
6084    var action = arguments.length > 1 ? arguments[1] : undefined;
6085  
6086    switch (action.type) {
6087      case 'ADD_BLOCK_TYPES':
6088        return _objectSpread(_objectSpread({}, state), Object(external_this_lodash_["mapValues"])(Object(external_this_lodash_["keyBy"])(action.blockTypes, 'name'), function (blockType) {
6089          return Object(external_this_lodash_["uniqBy"])([].concat(Object(toConsumableArray["a" /* default */])(Object(external_this_lodash_["get"])(blockType, ['variations'], [])), Object(toConsumableArray["a" /* default */])(Object(external_this_lodash_["get"])(state, [blockType.name], []))), function (variation) {
6090            return variation.name;
6091          });
6092        }));
6093  
6094      case 'ADD_BLOCK_VARIATIONS':
6095        return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, action.blockName, Object(external_this_lodash_["uniqBy"])([].concat(Object(toConsumableArray["a" /* default */])(Object(external_this_lodash_["get"])(state, [action.blockName], [])), Object(toConsumableArray["a" /* default */])(action.variations)), function (variation) {
6096          return variation.name;
6097        })));
6098  
6099      case 'REMOVE_BLOCK_VARIATIONS':
6100        return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, action.blockName, Object(external_this_lodash_["filter"])(Object(external_this_lodash_["get"])(state, [action.blockName], []), function (variation) {
6101          return action.variationNames.indexOf(variation.name) === -1;
6102        })));
6103    }
6104  
6105    return state;
6106  }
6107  /**
6108   * Higher-order Reducer creating a reducer keeping track of given block name.
6109   *
6110   * @param {string} setActionType  Action type.
6111   *
6112   * @return {Function} Reducer.
6113   */
6114  
6115  function createBlockNameSetterReducer(setActionType) {
6116    return function () {
6117      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
6118      var action = arguments.length > 1 ? arguments[1] : undefined;
6119  
6120      switch (action.type) {
6121        case 'REMOVE_BLOCK_TYPES':
6122          if (action.names.indexOf(state) !== -1) {
6123            return null;
6124          }
6125  
6126          return state;
6127  
6128        case setActionType:
6129          return action.name || null;
6130      }
6131  
6132      return state;
6133    };
6134  }
6135  var reducer_defaultBlockName = createBlockNameSetterReducer('SET_DEFAULT_BLOCK_NAME');
6136  var freeformFallbackBlockName = createBlockNameSetterReducer('SET_FREEFORM_FALLBACK_BLOCK_NAME');
6137  var unregisteredFallbackBlockName = createBlockNameSetterReducer('SET_UNREGISTERED_FALLBACK_BLOCK_NAME');
6138  var groupingBlockName = createBlockNameSetterReducer('SET_GROUPING_BLOCK_NAME');
6139  /**
6140   * Reducer managing the categories
6141   *
6142   * @param {WPBlockCategory[]} state  Current state.
6143   * @param {Object}            action Dispatched action.
6144   *
6145   * @return {WPBlockCategory[]} Updated state.
6146   */
6147  
6148  function reducer_categories() {
6149    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_CATEGORIES;
6150    var action = arguments.length > 1 ? arguments[1] : undefined;
6151  
6152    switch (action.type) {
6153      case 'SET_CATEGORIES':
6154        return action.categories || [];
6155  
6156      case 'UPDATE_CATEGORY':
6157        {
6158          if (!action.category || Object(external_this_lodash_["isEmpty"])(action.category)) {
6159            return state;
6160          }
6161  
6162          var categoryToChange = Object(external_this_lodash_["find"])(state, ['slug', action.slug]);
6163  
6164          if (categoryToChange) {
6165            return Object(external_this_lodash_["map"])(state, function (category) {
6166              if (category.slug === action.slug) {
6167                return _objectSpread(_objectSpread({}, category), action.category);
6168              }
6169  
6170              return category;
6171            });
6172          }
6173        }
6174    }
6175  
6176    return state;
6177  }
6178  function collections() {
6179    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
6180    var action = arguments.length > 1 ? arguments[1] : undefined;
6181  
6182    switch (action.type) {
6183      case 'ADD_BLOCK_COLLECTION':
6184        return _objectSpread(_objectSpread({}, state), {}, Object(defineProperty["a" /* default */])({}, action.namespace, {
6185          title: action.title,
6186          icon: action.icon
6187        }));
6188  
6189      case 'REMOVE_BLOCK_COLLECTION':
6190        return Object(external_this_lodash_["omit"])(state, action.namespace);
6191    }
6192  
6193    return state;
6194  }
6195  /* harmony default export */ var reducer = (Object(external_this_wp_data_["combineReducers"])({
6196    blockTypes: reducer_blockTypes,
6197    blockStyles: blockStyles,
6198    blockVariations: blockVariations,
6199    defaultBlockName: reducer_defaultBlockName,
6200    freeformFallbackBlockName: freeformFallbackBlockName,
6201    unregisteredFallbackBlockName: unregisteredFallbackBlockName,
6202    groupingBlockName: groupingBlockName,
6203    categories: reducer_categories,
6204    collections: collections
6205  }));
6206  
6207  // EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js
6208  var rememo = __webpack_require__(42);
6209  
6210  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/selectors.js
6211  
6212  
6213  
6214  function selectors_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
6215  
6216  function selectors_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { selectors_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { selectors_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
6217  
6218  /**
6219   * External dependencies
6220   */
6221  
6222  
6223  /** @typedef {import('../api/registration').WPBlockVariation} WPBlockVariation */
6224  
6225  /** @typedef {import('../api/registration').WPBlockVariationScope} WPBlockVariationScope */
6226  
6227  /** @typedef {import('./reducer').WPBlockCategory} WPBlockCategory */
6228  
6229  /**
6230   * Given a block name or block type object, returns the corresponding
6231   * normalized block type object.
6232   *
6233   * @param {Object}          state      Blocks state.
6234   * @param {(string|Object)} nameOrType Block name or type object
6235   *
6236   * @return {Object} Block type object.
6237   */
6238  
6239  var getNormalizedBlockType = function getNormalizedBlockType(state, nameOrType) {
6240    return 'string' === typeof nameOrType ? getBlockType(state, nameOrType) : nameOrType;
6241  };
6242  /**
6243   * Returns all the available block types.
6244   *
6245   * @param {Object} state Data state.
6246   *
6247   * @return {Array} Block Types.
6248   */
6249  
6250  
6251  var getBlockTypes = Object(rememo["a" /* default */])(function (state) {
6252    return Object.values(state.blockTypes).map(function (blockType) {
6253      return selectors_objectSpread(selectors_objectSpread({}, blockType), {}, {
6254        variations: selectors_getBlockVariations(state, blockType.name)
6255      });
6256    });
6257  }, function (state) {
6258    return [state.blockTypes, state.blockVariations];
6259  });
6260  /**
6261   * Returns a block type by name.
6262   *
6263   * @param {Object} state Data state.
6264   * @param {string} name Block type name.
6265   *
6266   * @return {Object?} Block Type.
6267   */
6268  
6269  function getBlockType(state, name) {
6270    return state.blockTypes[name];
6271  }
6272  /**
6273   * Returns block styles by block name.
6274   *
6275   * @param {Object} state Data state.
6276   * @param {string} name  Block type name.
6277   *
6278   * @return {Array?} Block Styles.
6279   */
6280  
6281  function getBlockStyles(state, name) {
6282    return state.blockStyles[name];
6283  }
6284  /**
6285   * Returns block variations by block name.
6286   *
6287   * @param {Object}                state     Data state.
6288   * @param {string}                blockName Block type name.
6289   * @param {WPBlockVariationScope} [scope]   Block variation scope name.
6290   *
6291   * @return {(WPBlockVariation[]|void)} Block variations.
6292   */
6293  
6294  function selectors_getBlockVariations(state, blockName, scope) {
6295    var variations = state.blockVariations[blockName];
6296  
6297    if (!variations || !scope) {
6298      return variations;
6299    }
6300  
6301    return variations.filter(function (variation) {
6302      return !variation.scope || variation.scope.includes(scope);
6303    });
6304  }
6305  /**
6306   * Returns the default block variation for the given block type.
6307   * When there are multiple variations annotated as the default one,
6308   * the last added item is picked. This simplifies registering overrides.
6309   * When there is no default variation set, it returns the first item.
6310   *
6311   * @param {Object}                state     Data state.
6312   * @param {string}                blockName Block type name.
6313   * @param {WPBlockVariationScope} [scope]   Block variation scope name.
6314   *
6315   * @return {?WPBlockVariation} The default block variation.
6316   */
6317  
6318  function getDefaultBlockVariation(state, blockName, scope) {
6319    var variations = selectors_getBlockVariations(state, blockName, scope);
6320    return Object(external_this_lodash_["findLast"])(variations, 'isDefault') || Object(external_this_lodash_["first"])(variations);
6321  }
6322  /**
6323   * Returns all the available categories.
6324   *
6325   * @param {Object} state Data state.
6326   *
6327   * @return {WPBlockCategory[]} Categories list.
6328   */
6329  
6330  function getCategories(state) {
6331    return state.categories;
6332  }
6333  /**
6334   * Returns all the available collections.
6335   *
6336   * @param {Object} state Data state.
6337   *
6338   * @return {Object} Collections list.
6339   */
6340  
6341  function getCollections(state) {
6342    return state.collections;
6343  }
6344  /**
6345   * Returns the name of the default block name.
6346   *
6347   * @param {Object} state Data state.
6348   *
6349   * @return {string?} Default block name.
6350   */
6351  
6352  function getDefaultBlockName(state) {
6353    return state.defaultBlockName;
6354  }
6355  /**
6356   * Returns the name of the block for handling non-block content.
6357   *
6358   * @param {Object} state Data state.
6359   *
6360   * @return {string?} Name of the block for handling non-block content.
6361   */
6362  
6363  function getFreeformFallbackBlockName(state) {
6364    return state.freeformFallbackBlockName;
6365  }
6366  /**
6367   * Returns the name of the block for handling unregistered blocks.
6368   *
6369   * @param {Object} state Data state.
6370   *
6371   * @return {string?} Name of the block for handling unregistered blocks.
6372   */
6373  
6374  function getUnregisteredFallbackBlockName(state) {
6375    return state.unregisteredFallbackBlockName;
6376  }
6377  /**
6378   * Returns the name of the block for handling unregistered blocks.
6379   *
6380   * @param {Object} state Data state.
6381   *
6382   * @return {string?} Name of the block for handling unregistered blocks.
6383   */
6384  
6385  function getGroupingBlockName(state) {
6386    return state.groupingBlockName;
6387  }
6388  /**
6389   * Returns an array with the child blocks of a given block.
6390   *
6391   * @param {Object} state     Data state.
6392   * @param {string} blockName Block type name.
6393   *
6394   * @return {Array} Array of child block names.
6395   */
6396  
6397  var selectors_getChildBlockNames = Object(rememo["a" /* default */])(function (state, blockName) {
6398    return Object(external_this_lodash_["map"])(Object(external_this_lodash_["filter"])(state.blockTypes, function (blockType) {
6399      return Object(external_this_lodash_["includes"])(blockType.parent, blockName);
6400    }), function (_ref) {
6401      var name = _ref.name;
6402      return name;
6403    });
6404  }, function (state) {
6405    return [state.blockTypes];
6406  });
6407  /**
6408   * Returns the block support value for a feature, if defined.
6409   *
6410   * @param  {Object}          state           Data state.
6411   * @param  {(string|Object)} nameOrType      Block name or type object
6412   * @param  {string}          feature         Feature to retrieve
6413   * @param  {*}               defaultSupports Default value to return if not
6414   *                                           explicitly defined
6415   *
6416   * @return {?*} Block support value
6417   */
6418  
6419  var selectors_getBlockSupport = function getBlockSupport(state, nameOrType, feature, defaultSupports) {
6420    var blockType = getNormalizedBlockType(state, nameOrType);
6421    return Object(external_this_lodash_["get"])(blockType, ['supports'].concat(Object(toConsumableArray["a" /* default */])(feature.split('.'))), defaultSupports);
6422  };
6423  /**
6424   * Returns true if the block defines support for a feature, or false otherwise.
6425   *
6426   * @param  {Object}         state           Data state.
6427   * @param {(string|Object)} nameOrType      Block name or type object.
6428   * @param {string}          feature         Feature to test.
6429   * @param {boolean}         defaultSupports Whether feature is supported by
6430   *                                          default if not explicitly defined.
6431   *
6432   * @return {boolean} Whether block supports feature.
6433   */
6434  
6435  function hasBlockSupport(state, nameOrType, feature, defaultSupports) {
6436    return !!selectors_getBlockSupport(state, nameOrType, feature, defaultSupports);
6437  }
6438  /**
6439   * Returns true if the block type by the given name or object value matches a
6440   * search term, or false otherwise.
6441   *
6442   * @param {Object}          state      Blocks state.
6443   * @param {(string|Object)} nameOrType Block name or type object.
6444   * @param {string}          searchTerm Search term by which to filter.
6445   *
6446   * @return {Object[]} Whether block type matches search term.
6447   */
6448  
6449  function isMatchingSearchTerm(state, nameOrType, searchTerm) {
6450    var blockType = getNormalizedBlockType(state, nameOrType);
6451    var getNormalizedSearchTerm = Object(external_this_lodash_["flow"])([// Disregard diacritics.
6452    //  Input: "média"
6453    external_this_lodash_["deburr"], // Lowercase.
6454    //  Input: "MEDIA"
6455    function (term) {
6456      return term.toLowerCase();
6457    }, // Strip leading and trailing whitespace.
6458    //  Input: " media "
6459    function (term) {
6460      return term.trim();
6461    }]);
6462    var normalizedSearchTerm = getNormalizedSearchTerm(searchTerm);
6463    var isSearchMatch = Object(external_this_lodash_["flow"])([getNormalizedSearchTerm, function (normalizedCandidate) {
6464      return Object(external_this_lodash_["includes"])(normalizedCandidate, normalizedSearchTerm);
6465    }]);
6466    return isSearchMatch(blockType.title) || Object(external_this_lodash_["some"])(blockType.keywords, isSearchMatch) || isSearchMatch(blockType.category);
6467  }
6468  /**
6469   * Returns a boolean indicating if a block has child blocks or not.
6470   *
6471   * @param {Object} state     Data state.
6472   * @param {string} blockName Block type name.
6473   *
6474   * @return {boolean} True if a block contains child blocks and false otherwise.
6475   */
6476  
6477  var selectors_hasChildBlocks = function hasChildBlocks(state, blockName) {
6478    return selectors_getChildBlockNames(state, blockName).length > 0;
6479  };
6480  /**
6481   * Returns a boolean indicating if a block has at least one child block with inserter support.
6482   *
6483   * @param {Object} state     Data state.
6484   * @param {string} blockName Block type name.
6485   *
6486   * @return {boolean} True if a block contains at least one child blocks with inserter support
6487   *                   and false otherwise.
6488   */
6489  
6490  var selectors_hasChildBlocksWithInserterSupport = function hasChildBlocksWithInserterSupport(state, blockName) {
6491    return Object(external_this_lodash_["some"])(selectors_getChildBlockNames(state, blockName), function (childBlockName) {
6492      return hasBlockSupport(state, childBlockName, 'inserter', true);
6493    });
6494  };
6495  
6496  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/actions.js
6497  /**
6498   * External dependencies
6499   */
6500  
6501  /** @typedef {import('../api/registration').WPBlockVariation} WPBlockVariation */
6502  
6503  /**
6504   * Returns an action object used in signalling that block types have been added.
6505   *
6506   * @param {Array|Object} blockTypes Block types received.
6507   *
6508   * @return {Object} Action object.
6509   */
6510  
6511  function addBlockTypes(blockTypes) {
6512    return {
6513      type: 'ADD_BLOCK_TYPES',
6514      blockTypes: Object(external_this_lodash_["castArray"])(blockTypes)
6515    };
6516  }
6517  /**
6518   * Returns an action object used to remove a registered block type.
6519   *
6520   * @param {string|Array} names Block name.
6521   *
6522   * @return {Object} Action object.
6523   */
6524  
6525  function removeBlockTypes(names) {
6526    return {
6527      type: 'REMOVE_BLOCK_TYPES',
6528      names: Object(external_this_lodash_["castArray"])(names)
6529    };
6530  }
6531  /**
6532   * Returns an action object used in signalling that new block styles have been added.
6533   *
6534   * @param {string}       blockName  Block name.
6535   * @param {Array|Object} styles     Block styles.
6536   *
6537   * @return {Object} Action object.
6538   */
6539  
6540  function addBlockStyles(blockName, styles) {
6541    return {
6542      type: 'ADD_BLOCK_STYLES',
6543      styles: Object(external_this_lodash_["castArray"])(styles),
6544      blockName: blockName
6545    };
6546  }
6547  /**
6548   * Returns an action object used in signalling that block styles have been removed.
6549   *
6550   * @param {string}       blockName  Block name.
6551   * @param {Array|string} styleNames Block style names.
6552   *
6553   * @return {Object} Action object.
6554   */
6555  
6556  function removeBlockStyles(blockName, styleNames) {
6557    return {
6558      type: 'REMOVE_BLOCK_STYLES',
6559      styleNames: Object(external_this_lodash_["castArray"])(styleNames),
6560      blockName: blockName
6561    };
6562  }
6563  /**
6564   * Returns an action object used in signalling that new block variations have been added.
6565   *
6566   * @param {string}                              blockName  Block name.
6567   * @param {WPBlockVariation|WPBlockVariation[]} variations Block variations.
6568   *
6569   * @return {Object} Action object.
6570   */
6571  
6572  function addBlockVariations(blockName, variations) {
6573    return {
6574      type: 'ADD_BLOCK_VARIATIONS',
6575      variations: Object(external_this_lodash_["castArray"])(variations),
6576      blockName: blockName
6577    };
6578  }
6579  /**
6580   * Returns an action object used in signalling that block variations have been removed.
6581   *
6582   * @param {string}          blockName      Block name.
6583   * @param {string|string[]} variationNames Block variation names.
6584   *
6585   * @return {Object} Action object.
6586   */
6587  
6588  function removeBlockVariations(blockName, variationNames) {
6589    return {
6590      type: 'REMOVE_BLOCK_VARIATIONS',
6591      variationNames: Object(external_this_lodash_["castArray"])(variationNames),
6592      blockName: blockName
6593    };
6594  }
6595  /**
6596   * Returns an action object used to set the default block name.
6597   *
6598   * @param {string} name Block name.
6599   *
6600   * @return {Object} Action object.
6601   */
6602  
6603  function setDefaultBlockName(name) {
6604    return {
6605      type: 'SET_DEFAULT_BLOCK_NAME',
6606      name: name
6607    };
6608  }
6609  /**
6610   * Returns an action object used to set the name of the block used as a fallback
6611   * for non-block content.
6612   *
6613   * @param {string} name Block name.
6614   *
6615   * @return {Object} Action object.
6616   */
6617  
6618  function setFreeformFallbackBlockName(name) {
6619    return {
6620      type: 'SET_FREEFORM_FALLBACK_BLOCK_NAME',
6621      name: name
6622    };
6623  }
6624  /**
6625   * Returns an action object used to set the name of the block used as a fallback
6626   * for unregistered blocks.
6627   *
6628   * @param {string} name Block name.
6629   *
6630   * @return {Object} Action object.
6631   */
6632  
6633  function setUnregisteredFallbackBlockName(name) {
6634    return {
6635      type: 'SET_UNREGISTERED_FALLBACK_BLOCK_NAME',
6636      name: name
6637    };
6638  }
6639  /**
6640   * Returns an action object used to set the name of the block used
6641   * when grouping other blocks
6642   * eg: in "Group/Ungroup" interactions
6643   *
6644   * @param {string} name Block name.
6645   *
6646   * @return {Object} Action object.
6647   */
6648  
6649  function setGroupingBlockName(name) {
6650    return {
6651      type: 'SET_GROUPING_BLOCK_NAME',
6652      name: name
6653    };
6654  }
6655  /**
6656   * Returns an action object used to set block categories.
6657   *
6658   * @param {Object[]} categories Block categories.
6659   *
6660   * @return {Object} Action object.
6661   */
6662  
6663  function setCategories(categories) {
6664    return {
6665      type: 'SET_CATEGORIES',
6666      categories: categories
6667    };
6668  }
6669  /**
6670   * Returns an action object used to update a category.
6671   *
6672   * @param {string} slug     Block category slug.
6673   * @param {Object} category Object containing the category properties that should be updated.
6674   *
6675   * @return {Object} Action object.
6676   */
6677  
6678  function updateCategory(slug, category) {
6679    return {
6680      type: 'UPDATE_CATEGORY',
6681      slug: slug,
6682      category: category
6683    };
6684  }
6685  /**
6686   * Returns an action object used to add block collections
6687   *
6688   * @param {string} namespace       The namespace of the blocks to put in the collection
6689   * @param {string} title           The title to display in the block inserter
6690   * @param {Object} icon (optional) The icon to display in the block inserter
6691   *
6692   * @return {Object} Action object.
6693   */
6694  
6695  function addBlockCollection(namespace, title, icon) {
6696    return {
6697      type: 'ADD_BLOCK_COLLECTION',
6698      namespace: namespace,
6699      title: title,
6700      icon: icon
6701    };
6702  }
6703  /**
6704   * Returns an action object used to remove block collections
6705   *
6706   * @param {string} namespace       The namespace of the blocks to put in the collection
6707   *
6708   * @return {Object} Action object.
6709   */
6710  
6711  function removeBlockCollection(namespace) {
6712    return {
6713      type: 'REMOVE_BLOCK_COLLECTION',
6714      namespace: namespace
6715    };
6716  }
6717  
6718  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/store/index.js
6719  /**
6720   * WordPress dependencies
6721   */
6722  
6723  /**
6724   * Internal dependencies
6725   */
6726  
6727  
6728  
6729  
6730  Object(external_this_wp_data_["registerStore"])('core/blocks', {
6731    reducer: reducer,
6732    selectors: selectors_namespaceObject,
6733    actions: actions_namespaceObject
6734  });
6735  
6736  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
6737  var slicedToArray = __webpack_require__(12);
6738  
6739  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/node_modules/uuid/dist/esm-browser/rng.js
6740  // Unique ID creation requires a high quality random # generator. In the browser we therefore
6741  // require the crypto API and do not support built-in fallback to lower quality random number
6742  // generators (like Math.random()).
6743  // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
6744  // find the complete implementation of crypto (msCrypto) on IE11.
6745  var getRandomValues = typeof crypto != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto != 'undefined' && typeof msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto);
6746  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
6747  
6748  function rng() {
6749    if (!getRandomValues) {
6750      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
6751    }
6752  
6753    return getRandomValues(rnds8);
6754  }
6755  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/node_modules/uuid/dist/esm-browser/bytesToUuid.js
6756  /**
6757   * Convert array of 16 byte values to UUID string format of the form:
6758   * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
6759   */
6760  var byteToHex = [];
6761  
6762  for (var bytesToUuid_i = 0; bytesToUuid_i < 256; ++bytesToUuid_i) {
6763    byteToHex[bytesToUuid_i] = (bytesToUuid_i + 0x100).toString(16).substr(1);
6764  }
6765  
6766  function bytesToUuid(buf, offset) {
6767    var i = offset || 0;
6768    var bth = byteToHex; // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
6769  
6770    return [bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]]].join('');
6771  }
6772  
6773  /* harmony default export */ var esm_browser_bytesToUuid = (bytesToUuid);
6774  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/node_modules/uuid/dist/esm-browser/v4.js
6775  
6776  
6777  
6778  function v4(options, buf, offset) {
6779    var i = buf && offset || 0;
6780  
6781    if (typeof options == 'string') {
6782      buf = options === 'binary' ? new Array(16) : null;
6783      options = null;
6784    }
6785  
6786    options = options || {};
6787    var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
6788  
6789    rnds[6] = rnds[6] & 0x0f | 0x40;
6790    rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
6791  
6792    if (buf) {
6793      for (var ii = 0; ii < 16; ++ii) {
6794        buf[i + ii] = rnds[ii];
6795      }
6796    }
6797  
6798    return buf || esm_browser_bytesToUuid(rnds);
6799  }
6800  
6801  /* harmony default export */ var esm_browser_v4 = (v4);
6802  // EXTERNAL MODULE: external {"this":["wp","hooks"]}
6803  var external_this_wp_hooks_ = __webpack_require__(33);
6804  
6805  // EXTERNAL MODULE: ./node_modules/@wordpress/icons/build-module/library/block-default.js
6806  var block_default = __webpack_require__(208);
6807  
6808  // EXTERNAL MODULE: ./node_modules/tinycolor2/tinycolor.js
6809  var tinycolor = __webpack_require__(66);
6810  var tinycolor_default = /*#__PURE__*/__webpack_require__.n(tinycolor);
6811  
6812  // EXTERNAL MODULE: external {"this":["wp","element"]}
6813  var external_this_wp_element_ = __webpack_require__(0);
6814  
6815  // EXTERNAL MODULE: external {"this":["wp","dom"]}
6816  var external_this_wp_dom_ = __webpack_require__(29);
6817  
6818  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/utils.js
6819  
6820  
6821  function utils_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
6822  
6823  function utils_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { utils_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { utils_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
6824  
6825  /**
6826   * External dependencies
6827   */
6828  
6829  
6830  /**
6831   * WordPress dependencies
6832   */
6833  
6834  
6835  
6836  
6837  /**
6838   * Internal dependencies
6839   */
6840  
6841  
6842  
6843  /**
6844   * Array of icon colors containing a color to be used if the icon color
6845   * was not explicitly set but the icon background color was.
6846   *
6847   * @type {Object}
6848   */
6849  
6850  var ICON_COLORS = ['#191e23', '#f8f9f9'];
6851  /**
6852   * Determines whether the block is a default block
6853   * and its attributes are equal to the default attributes
6854   * which means the block is unmodified.
6855   *
6856   * @param  {WPBlock} block Block Object
6857   *
6858   * @return {boolean}       Whether the block is an unmodified default block
6859   */
6860  
6861  function isUnmodifiedDefaultBlock(block) {
6862    var defaultBlockName = registration_getDefaultBlockName();
6863  
6864    if (block.name !== defaultBlockName) {
6865      return false;
6866    } // Cache a created default block if no cache exists or the default block
6867    // name changed.
6868  
6869  
6870    if (!isUnmodifiedDefaultBlock.block || isUnmodifiedDefaultBlock.block.name !== defaultBlockName) {
6871      isUnmodifiedDefaultBlock.block = createBlock(defaultBlockName);
6872    }
6873  
6874    var newDefaultBlock = isUnmodifiedDefaultBlock.block;
6875    var blockType = registration_getBlockType(defaultBlockName);
6876    return Object(external_this_lodash_["every"])(blockType.attributes, function (value, key) {
6877      return newDefaultBlock.attributes[key] === block.attributes[key];
6878    });
6879  }
6880  /**
6881   * Function that checks if the parameter is a valid icon.
6882   *
6883   * @param {*} icon  Parameter to be checked.
6884   *
6885   * @return {boolean} True if the parameter is a valid icon and false otherwise.
6886   */
6887  
6888  function isValidIcon(icon) {
6889    return !!icon && (Object(external_this_lodash_["isString"])(icon) || Object(external_this_wp_element_["isValidElement"])(icon) || Object(external_this_lodash_["isFunction"])(icon) || icon instanceof external_this_wp_element_["Component"]);
6890  }
6891  /**
6892   * Function that receives an icon as set by the blocks during the registration
6893   * and returns a new icon object that is normalized so we can rely on just on possible icon structure
6894   * in the codebase.
6895   *
6896   * @param {WPBlockTypeIconRender} icon Render behavior of a block type icon;
6897   *                                     one of a Dashicon slug, an element, or a
6898   *                                     component.
6899   *
6900   * @return {WPBlockTypeIconDescriptor} Object describing the icon.
6901   */
6902  
6903  function normalizeIconObject(icon) {
6904    if (isValidIcon(icon)) {
6905      return {
6906        src: icon
6907      };
6908    }
6909  
6910    if (Object(external_this_lodash_["has"])(icon, ['background'])) {
6911      var tinyBgColor = tinycolor_default()(icon.background);
6912      return utils_objectSpread(utils_objectSpread({}, icon), {}, {
6913        foreground: icon.foreground ? icon.foreground : Object(tinycolor["mostReadable"])(tinyBgColor, ICON_COLORS, {
6914          includeFallbackColors: true,
6915          level: 'AA',
6916          size: 'large'
6917        }).toHexString(),
6918        shadowColor: tinyBgColor.setAlpha(0.3).toRgbString()
6919      });
6920    }
6921  
6922    return icon;
6923  }
6924  /**
6925   * Normalizes block type passed as param. When string is passed then
6926   * it converts it to the matching block type object.
6927   * It passes the original object otherwise.
6928   *
6929   * @param {string|Object} blockTypeOrName  Block type or name.
6930   *
6931   * @return {?Object} Block type.
6932   */
6933  
6934  function normalizeBlockType(blockTypeOrName) {
6935    if (Object(external_this_lodash_["isString"])(blockTypeOrName)) {
6936      return registration_getBlockType(blockTypeOrName);
6937    }
6938  
6939    return blockTypeOrName;
6940  }
6941  /**
6942   * Get the label for the block, usually this is either the block title,
6943   * or the value of the block's `label` function when that's specified.
6944   *
6945   * @param {Object} blockType  The block type.
6946   * @param {Object} attributes The values of the block's attributes.
6947   * @param {Object} context    The intended use for the label.
6948   *
6949   * @return {string} The block label.
6950   */
6951  
6952  function getBlockLabel(blockType, attributes) {
6953    var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'visual';
6954    var getLabel = blockType.__experimentalLabel,
6955        title = blockType.title;
6956    var label = getLabel && getLabel(attributes, {
6957      context: context
6958    });
6959  
6960    if (!label) {
6961      return title;
6962    } // Strip any HTML (i.e. RichText formatting) before returning.
6963  
6964  
6965    return Object(external_this_wp_dom_["__unstableStripHTML"])(label);
6966  }
6967  /**
6968   * Get a label for the block for use by screenreaders, this is more descriptive
6969   * than the visual label and includes the block title and the value of the
6970   * `getLabel` function if it's specified.
6971   *
6972   * @param {Object}  blockType              The block type.
6973   * @param {Object}  attributes             The values of the block's attributes.
6974   * @param {?number} position               The position of the block in the block list.
6975   * @param {string}  [direction='vertical'] The direction of the block layout.
6976   *
6977   * @return {string} The block label.
6978   */
6979  
6980  function getAccessibleBlockLabel(blockType, attributes, position) {
6981    var direction = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'vertical';
6982    // `title` is already localized, `label` is a user-supplied value.
6983    var title = blockType.title;
6984    var label = getBlockLabel(blockType, attributes, 'accessibility');
6985    var hasPosition = position !== undefined; // getBlockLabel returns the block title as a fallback when there's no label,
6986    // if it did return the title, this function needs to avoid adding the
6987    // title twice within the accessible label. Use this `hasLabel` boolean to
6988    // handle that.
6989  
6990    var hasLabel = label && label !== title;
6991  
6992    if (hasPosition && direction === 'vertical') {
6993      if (hasLabel) {
6994        return Object(external_this_wp_i18n_["sprintf"])(
6995        /* translators: accessibility text. 1: The block title. 2: The block row number. 3: The block label.. */
6996        Object(external_this_wp_i18n_["__"])('%1$s Block. Row %2$d. %3$s'), title, position, label);
6997      }
6998  
6999      return Object(external_this_wp_i18n_["sprintf"])(
7000      /* translators: accessibility text. 1: The block title. 2: The block row number. */
7001      Object(external_this_wp_i18n_["__"])('%1$s Block. Row %2$d'), title, position);
7002    } else if (hasPosition && direction === 'horizontal') {
7003      if (hasLabel) {
7004        return Object(external_this_wp_i18n_["sprintf"])(
7005        /* translators: accessibility text. 1: The block title. 2: The block column number. 3: The block label.. */
7006        Object(external_this_wp_i18n_["__"])('%1$s Block. Column %2$d. %3$s'), title, position, label);
7007      }
7008  
7009      return Object(external_this_wp_i18n_["sprintf"])(
7010      /* translators: accessibility text. 1: The block title. 2: The block column number. */
7011      Object(external_this_wp_i18n_["__"])('%1$s Block. Column %2$d'), title, position);
7012    }
7013  
7014    if (hasLabel) {
7015      return Object(external_this_wp_i18n_["sprintf"])(
7016      /* translators: accessibility text. %1: The block title. %2: The block label. */
7017      Object(external_this_wp_i18n_["__"])('%1$s Block. %2$s'), title, label);
7018    }
7019  
7020    return Object(external_this_wp_i18n_["sprintf"])(
7021    /* translators: accessibility text. %s: The block title. */
7022    Object(external_this_wp_i18n_["__"])('%s Block'), title);
7023  }
7024  
7025  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/constants.js
7026  /**
7027   * Array of valid keys in a block type settings deprecation object.
7028   *
7029   * @type {string[]}
7030   */
7031  var DEPRECATED_ENTRY_KEYS = ['attributes', 'supports', 'save', 'migrate', 'isEligible', 'apiVersion'];
7032  var __EXPERIMENTAL_STYLE_PROPERTY = {
7033    '--wp--style--color--link': ['color', 'link'],
7034    background: ['color', 'gradient'],
7035    backgroundColor: ['color', 'background'],
7036    color: ['color', 'text'],
7037    fontSize: ['typography', 'fontSize'],
7038    lineHeight: ['typography', 'lineHeight'],
7039    paddingBottom: ['spacing', 'padding', 'bottom'],
7040    paddingLeft: ['spacing', 'padding', 'left'],
7041    paddingRight: ['spacing', 'padding', 'right'],
7042    paddingTop: ['spacing', 'padding', 'top']
7043  };
7044  
7045  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/registration.js
7046  
7047  
7048  function registration_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
7049  
7050  function registration_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { registration_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { registration_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
7051  
7052  /* eslint no-console: [ 'error', { allow: [ 'error', 'warn' ] } ] */
7053  
7054  /**
7055   * External dependencies
7056   */
7057  
7058  /**
7059   * WordPress dependencies
7060   */
7061  
7062  
7063  
7064  
7065  /**
7066   * Internal dependencies
7067   */
7068  
7069  
7070  
7071  /**
7072   * An icon type definition. One of a Dashicon slug, an element,
7073   * or a component.
7074   *
7075   * @typedef {(string|WPElement|WPComponent)} WPIcon
7076   *
7077   * @see https://developer.wordpress.org/resource/dashicons/
7078   */
7079  
7080  /**
7081   * Render behavior of a block type icon; one of a Dashicon slug, an element,
7082   * or a component.
7083   *
7084   * @typedef {WPIcon} WPBlockTypeIconRender
7085   */
7086  
7087  /**
7088   * An object describing a normalized block type icon.
7089   *
7090   * @typedef {Object} WPBlockTypeIconDescriptor
7091   *
7092   * @property {WPBlockTypeIconRender} src         Render behavior of the icon,
7093   *                                               one of a Dashicon slug, an
7094   *                                               element, or a component.
7095   * @property {string}                background  Optimal background hex string
7096   *                                               color when displaying icon.
7097   * @property {string}                foreground  Optimal foreground hex string
7098   *                                               color when displaying icon.
7099   * @property {string}                shadowColor Optimal shadow hex string
7100   *                                               color when displaying icon.
7101   */
7102  
7103  /**
7104   * Value to use to render the icon for a block type in an editor interface,
7105   * either a Dashicon slug, an element, a component, or an object describing
7106   * the icon.
7107   *
7108   * @typedef {(WPBlockTypeIconDescriptor|WPBlockTypeIconRender)} WPBlockTypeIcon
7109   */
7110  
7111  /**
7112   * Named block variation scopes.
7113   *
7114   * @typedef {'block'|'inserter'} WPBlockVariationScope
7115   */
7116  
7117  /**
7118   * An object describing a variation defined for the block type.
7119   *
7120   * @typedef {Object} WPBlockVariation
7121   *
7122   * @property {string}   name                   The unique and machine-readable name.
7123   * @property {string}   title                  A human-readable variation title.
7124   * @property {string}   [description]          A detailed variation description.
7125   * @property {WPIcon}   [icon]                 An icon helping to visualize the variation.
7126   * @property {boolean}  [isDefault]            Indicates whether the current variation is
7127   *                                             the default one. Defaults to `false`.
7128   * @property {Object}   [attributes]           Values which override block attributes.
7129   * @property {Array[]}  [innerBlocks]          Initial configuration of nested blocks.
7130   * @property {Object}   [example]              Example provides structured data for
7131   *                                             the block preview. You can set to
7132   *                                             `undefined` to disable the preview shown
7133   *                                             for the block type.
7134   * @property {WPBlockVariationScope[]} [scope] The list of scopes where the variation
7135   *                                             is applicable. When not provided, it
7136   *                                             assumes all available scopes.
7137   * @property {string[]} [keywords]             An array of terms (which can be translated)
7138   *                                             that help users discover the variation
7139   *                                             while searching.
7140   */
7141  
7142  /**
7143   * Defined behavior of a block type.
7144   *
7145   * @typedef {Object} WPBlock
7146   *
7147   * @property {string}             name          Block type's namespaced name.
7148   * @property {string}             title         Human-readable block type label.
7149   * @property {string}             [description] A detailed block type description.
7150   * @property {string}             [category]    Block type category classification,
7151   *                                              used in search interfaces to arrange
7152   *                                              block types by category.
7153   * @property {WPBlockTypeIcon}    [icon]        Block type icon.
7154   * @property {string[]}           [keywords]    Additional keywords to produce block
7155   *                                              type as result in search interfaces.
7156   * @property {Object}             [attributes]  Block type attributes.
7157   * @property {WPComponent}        [save]        Optional component describing
7158   *                                              serialized markup structure of a
7159   *                                              block type.
7160   * @property {WPComponent}        edit          Component rendering an element to
7161   *                                              manipulate the attributes of a block
7162   *                                              in the context of an editor.
7163   * @property {WPBlockVariation[]} [variations]  The list of block variations.
7164   * @property {Object}             [example]     Example provides structured data for
7165   *                                              the block preview. When not defined
7166   *                                              then no preview is shown.
7167   */
7168  
7169  /**
7170   * Mapping of legacy category slugs to their latest normal values, used to
7171   * accommodate updates of the default set of block categories.
7172   *
7173   * @type {Record<string,string>}
7174   */
7175  
7176  var LEGACY_CATEGORY_MAPPING = {
7177    common: 'text',
7178    formatting: 'text',
7179    layout: 'design'
7180  };
7181  var serverSideBlockDefinitions = {};
7182  /**
7183   * Sets the server side block definition of blocks.
7184   *
7185   * @param {Object} definitions Server-side block definitions
7186   */
7187  // eslint-disable-next-line camelcase
7188  
7189  function unstable__bootstrapServerSideBlockDefinitions(definitions) {
7190    serverSideBlockDefinitions = registration_objectSpread(registration_objectSpread({}, serverSideBlockDefinitions), definitions);
7191  }
7192  /**
7193   * Registers a new block provided a unique name and an object defining its
7194   * behavior. Once registered, the block is made available as an option to any
7195   * editor interface where blocks are implemented.
7196   *
7197   * @param {string} name     Block name.
7198   * @param {Object} settings Block settings.
7199   *
7200   * @return {?WPBlock} The block, if it has been successfully registered;
7201   *                    otherwise `undefined`.
7202   */
7203  
7204  function registerBlockType(name, settings) {
7205    settings = registration_objectSpread(registration_objectSpread({
7206      name: name,
7207      icon: block_default["a" /* default */],
7208      keywords: [],
7209      attributes: {},
7210      providesContext: {},
7211      usesContext: [],
7212      supports: {},
7213      styles: [],
7214      save: function save() {
7215        return null;
7216      }
7217    }, Object(external_this_lodash_["pickBy"])(Object(external_this_lodash_["get"])(serverSideBlockDefinitions, name, {}), function (value) {
7218      return !Object(external_this_lodash_["isNil"])(value);
7219    })), settings);
7220  
7221    if (typeof name !== 'string') {
7222      console.error('Block names must be strings.');
7223      return;
7224    }
7225  
7226    if (!/^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(name)) {
7227      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');
7228      return;
7229    }
7230  
7231    if (Object(external_this_wp_data_["select"])('core/blocks').getBlockType(name)) {
7232      console.error('Block "' + name + '" is already registered.');
7233      return;
7234    }
7235  
7236    var preFilterSettings = registration_objectSpread({}, settings);
7237  
7238    settings = Object(external_this_wp_hooks_["applyFilters"])('blocks.registerBlockType', settings, name);
7239  
7240    if (settings.deprecated) {
7241      settings.deprecated = settings.deprecated.map(function (deprecation) {
7242        return Object(external_this_lodash_["pick"])( // Only keep valid deprecation keys.
7243        Object(external_this_wp_hooks_["applyFilters"])('blocks.registerBlockType', // Merge deprecation keys with pre-filter settings
7244        // so that filters that depend on specific keys being
7245        // present don't fail.
7246        registration_objectSpread(registration_objectSpread({}, Object(external_this_lodash_["omit"])(preFilterSettings, DEPRECATED_ENTRY_KEYS)), deprecation), name), DEPRECATED_ENTRY_KEYS);
7247      });
7248    }
7249  
7250    if (!Object(external_this_lodash_["isPlainObject"])(settings)) {
7251      console.error('Block settings must be a valid object.');
7252      return;
7253    }
7254  
7255    if (!Object(external_this_lodash_["isFunction"])(settings.save)) {
7256      console.error('The "save" property must be a valid function.');
7257      return;
7258    }
7259  
7260    if ('edit' in settings && !Object(external_this_lodash_["isFunction"])(settings.edit)) {
7261      console.error('The "edit" property must be a valid function.');
7262      return;
7263    } // Canonicalize legacy categories to equivalent fallback.
7264  
7265  
7266    if (LEGACY_CATEGORY_MAPPING.hasOwnProperty(settings.category)) {
7267      settings.category = LEGACY_CATEGORY_MAPPING[settings.category];
7268    }
7269  
7270    if ('category' in settings && !Object(external_this_lodash_["some"])(Object(external_this_wp_data_["select"])('core/blocks').getCategories(), {
7271      slug: settings.category
7272    })) {
7273      console.warn('The block "' + name + '" is registered with an invalid category "' + settings.category + '".');
7274      delete settings.category;
7275    }
7276  
7277    if (!('title' in settings) || settings.title === '') {
7278      console.error('The block "' + name + '" must have a title.');
7279      return;
7280    }
7281  
7282    if (typeof settings.title !== 'string') {
7283      console.error('Block titles must be strings.');
7284      return;
7285    }
7286  
7287    settings.icon = normalizeIconObject(settings.icon);
7288  
7289    if (!isValidIcon(settings.icon.src)) {
7290      console.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');
7291      return;
7292    }
7293  
7294    Object(external_this_wp_data_["dispatch"])('core/blocks').addBlockTypes(settings);
7295    return settings;
7296  }
7297  /**
7298   * Registers a new block collection to group blocks in the same namespace in the inserter.
7299   *
7300   * @param {string} namespace       The namespace to group blocks by in the inserter; corresponds to the block namespace.
7301   * @param {Object} settings        The block collection settings.
7302   * @param {string} settings.title  The title to display in the block inserter.
7303   * @param {Object} [settings.icon] The icon to display in the block inserter.
7304   */
7305  
7306  function registerBlockCollection(namespace, _ref) {
7307    var title = _ref.title,
7308        icon = _ref.icon;
7309    Object(external_this_wp_data_["dispatch"])('core/blocks').addBlockCollection(namespace, title, icon);
7310  }
7311  /**
7312   * Unregisters a block collection
7313   *
7314   * @param {string} namespace The namespace to group blocks by in the inserter; corresponds to the block namespace
7315   *
7316   */
7317  
7318  function unregisterBlockCollection(namespace) {
7319    Object(external_this_wp_data_["dispatch"])('core/blocks').removeBlockCollection(namespace);
7320  }
7321  /**
7322   * Unregisters a block.
7323   *
7324   * @param {string} name Block name.
7325   *
7326   * @return {?WPBlock} The previous block value, if it has been successfully
7327   *                    unregistered; otherwise `undefined`.
7328   */
7329  
7330  function unregisterBlockType(name) {
7331    var oldBlock = Object(external_this_wp_data_["select"])('core/blocks').getBlockType(name);
7332  
7333    if (!oldBlock) {
7334      console.error('Block "' + name + '" is not registered.');
7335      return;
7336    }
7337  
7338    Object(external_this_wp_data_["dispatch"])('core/blocks').removeBlockTypes(name);
7339    return oldBlock;
7340  }
7341  /**
7342   * Assigns name of block for handling non-block content.
7343   *
7344   * @param {string} blockName Block name.
7345   */
7346  
7347  function setFreeformContentHandlerName(blockName) {
7348    Object(external_this_wp_data_["dispatch"])('core/blocks').setFreeformFallbackBlockName(blockName);
7349  }
7350  /**
7351   * Retrieves name of block handling non-block content, or undefined if no
7352   * handler has been defined.
7353   *
7354   * @return {?string} Block name.
7355   */
7356  
7357  function getFreeformContentHandlerName() {
7358    return Object(external_this_wp_data_["select"])('core/blocks').getFreeformFallbackBlockName();
7359  }
7360  /**
7361   * Retrieves name of block used for handling grouping interactions.
7362   *
7363   * @return {?string} Block name.
7364   */
7365  
7366  function registration_getGroupingBlockName() {
7367    return Object(external_this_wp_data_["select"])('core/blocks').getGroupingBlockName();
7368  }
7369  /**
7370   * Assigns name of block handling unregistered block types.
7371   *
7372   * @param {string} blockName Block name.
7373   */
7374  
7375  function setUnregisteredTypeHandlerName(blockName) {
7376    Object(external_this_wp_data_["dispatch"])('core/blocks').setUnregisteredFallbackBlockName(blockName);
7377  }
7378  /**
7379   * Retrieves name of block handling unregistered block types, or undefined if no
7380   * handler has been defined.
7381   *
7382   * @return {?string} Block name.
7383   */
7384  
7385  function getUnregisteredTypeHandlerName() {
7386    return Object(external_this_wp_data_["select"])('core/blocks').getUnregisteredFallbackBlockName();
7387  }
7388  /**
7389   * Assigns the default block name.
7390   *
7391   * @param {string} name Block name.
7392   */
7393  
7394  function registration_setDefaultBlockName(name) {
7395    Object(external_this_wp_data_["dispatch"])('core/blocks').setDefaultBlockName(name);
7396  }
7397  /**
7398   * Assigns name of block for handling block grouping interactions.
7399   *
7400   * @param {string} name Block name.
7401   */
7402  
7403  function registration_setGroupingBlockName(name) {
7404    Object(external_this_wp_data_["dispatch"])('core/blocks').setGroupingBlockName(name);
7405  }
7406  /**
7407   * Retrieves the default block name.
7408   *
7409   * @return {?string} Block name.
7410   */
7411  
7412  function registration_getDefaultBlockName() {
7413    return Object(external_this_wp_data_["select"])('core/blocks').getDefaultBlockName();
7414  }
7415  /**
7416   * Returns a registered block type.
7417   *
7418   * @param {string} name Block name.
7419   *
7420   * @return {?Object} Block type.
7421   */
7422  
7423  function registration_getBlockType(name) {
7424    return Object(external_this_wp_data_["select"])('core/blocks').getBlockType(name);
7425  }
7426  /**
7427   * Returns all registered blocks.
7428   *
7429   * @return {Array} Block settings.
7430   */
7431  
7432  function registration_getBlockTypes() {
7433    return Object(external_this_wp_data_["select"])('core/blocks').getBlockTypes();
7434  }
7435  /**
7436   * Returns the block support value for a feature, if defined.
7437   *
7438   * @param  {(string|Object)} nameOrType      Block name or type object
7439   * @param  {string}          feature         Feature to retrieve
7440   * @param  {*}               defaultSupports Default value to return if not
7441   *                                           explicitly defined
7442   *
7443   * @return {?*} Block support value
7444   */
7445  
7446  function registration_getBlockSupport(nameOrType, feature, defaultSupports) {
7447    return Object(external_this_wp_data_["select"])('core/blocks').getBlockSupport(nameOrType, feature, defaultSupports);
7448  }
7449  /**
7450   * Returns true if the block defines support for a feature, or false otherwise.
7451   *
7452   * @param {(string|Object)} nameOrType      Block name or type object.
7453   * @param {string}          feature         Feature to test.
7454   * @param {boolean}         defaultSupports Whether feature is supported by
7455   *                                          default if not explicitly defined.
7456   *
7457   * @return {boolean} Whether block supports feature.
7458   */
7459  
7460  function registration_hasBlockSupport(nameOrType, feature, defaultSupports) {
7461    return Object(external_this_wp_data_["select"])('core/blocks').hasBlockSupport(nameOrType, feature, defaultSupports);
7462  }
7463  /**
7464   * Determines whether or not the given block is a reusable block. This is a
7465   * special block type that is used to point to a global block stored via the
7466   * API.
7467   *
7468   * @param {Object} blockOrType Block or Block Type to test.
7469   *
7470   * @return {boolean} Whether the given block is a reusable block.
7471   */
7472  
7473  function isReusableBlock(blockOrType) {
7474    return blockOrType.name === 'core/block';
7475  }
7476  /**
7477   * Returns an array with the child blocks of a given block.
7478   *
7479   * @param {string} blockName Name of block (example: “latest-posts”).
7480   *
7481   * @return {Array} Array of child block names.
7482   */
7483  
7484  var registration_getChildBlockNames = function getChildBlockNames(blockName) {
7485    return Object(external_this_wp_data_["select"])('core/blocks').getChildBlockNames(blockName);
7486  };
7487  /**
7488   * Returns a boolean indicating if a block has child blocks or not.
7489   *
7490   * @param {string} blockName Name of block (example: “latest-posts”).
7491   *
7492   * @return {boolean} True if a block contains child blocks and false otherwise.
7493   */
7494  
7495  var registration_hasChildBlocks = function hasChildBlocks(blockName) {
7496    return Object(external_this_wp_data_["select"])('core/blocks').hasChildBlocks(blockName);
7497  };
7498  /**
7499   * Returns a boolean indicating if a block has at least one child block with inserter support.
7500   *
7501   * @param {string} blockName Block type name.
7502   *
7503   * @return {boolean} True if a block contains at least one child blocks with inserter support
7504   *                   and false otherwise.
7505   */
7506  
7507  var registration_hasChildBlocksWithInserterSupport = function hasChildBlocksWithInserterSupport(blockName) {
7508    return Object(external_this_wp_data_["select"])('core/blocks').hasChildBlocksWithInserterSupport(blockName);
7509  };
7510  /**
7511   * Registers a new block style variation for the given block.
7512   *
7513   * @param {string} blockName      Name of block (example: “core/latest-posts”).
7514   * @param {Object} styleVariation Object containing `name` which is the class name applied to the block and `label` which identifies the variation to the user.
7515   */
7516  
7517  var registration_registerBlockStyle = function registerBlockStyle(blockName, styleVariation) {
7518    Object(external_this_wp_data_["dispatch"])('core/blocks').addBlockStyles(blockName, styleVariation);
7519  };
7520  /**
7521   * Unregisters a block style variation for the given block.
7522   *
7523   * @param {string} blockName          Name of block (example: “core/latest-posts”).
7524   * @param {string} styleVariationName Name of class applied to the block.
7525   */
7526  
7527  var registration_unregisterBlockStyle = function unregisterBlockStyle(blockName, styleVariationName) {
7528    Object(external_this_wp_data_["dispatch"])('core/blocks').removeBlockStyles(blockName, styleVariationName);
7529  };
7530  /**
7531   * Returns an array with the variations of a given block type.
7532   *
7533   * @param {string}                blockName Name of block (example: “core/columns”).
7534   * @param {WPBlockVariationScope} [scope]   Block variation scope name.
7535   *
7536   * @return {(WPBlockVariation[]|void)} Block variations.
7537   */
7538  
7539  var registration_getBlockVariations = function getBlockVariations(blockName, scope) {
7540    return Object(external_this_wp_data_["select"])('core/blocks').getBlockVariations(blockName, scope);
7541  };
7542  /**
7543   * Registers a new block variation for the given block type.
7544   *
7545   * @param {string}           blockName Name of the block (example: “core/columns”).
7546   * @param {WPBlockVariation} variation Object describing a block variation.
7547   */
7548  
7549  var registration_registerBlockVariation = function registerBlockVariation(blockName, variation) {
7550    Object(external_this_wp_data_["dispatch"])('core/blocks').addBlockVariations(blockName, variation);
7551  };
7552  /**
7553   * Unregisters a block variation defined for the given block type.
7554   *
7555   * @param {string} blockName     Name of the block (example: “core/columns”).
7556   * @param {string} variationName Name of the variation defined for the block.
7557   */
7558  
7559  var registration_unregisterBlockVariation = function unregisterBlockVariation(blockName, variationName) {
7560    Object(external_this_wp_data_["dispatch"])('core/blocks').removeBlockVariations(blockName, variationName);
7561  };
7562  
7563  // CONCATENATED MODULE: ./node_modules/@wordpress/blocks/build-module/api/factory.js
7564  
7565  
7566  
7567  
7568  function factory_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
7569  
7570  function factory_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { factory_ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { factory_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
7571  
7572  /**
7573   * External dependencies
7574   */
7575  
7576  
7577  /**
7578   * WordPress dependencies
7579   */
7580  
7581  
7582  /**
7583   * Internal dependencies
7584   */
7585  
7586  
7587  
7588  /**
7589   * Returns a block object given its type and attributes.
7590   *
7591   * @param {string} name        Block name.
7592   * @param {Object} attributes  Block attributes.
7593   * @param {?Array} innerBlocks Nested blocks.
7594   *
7595   * @return {Object} Block object.
7596   */
7597  
7598  function createBlock(name) {
7599    var attributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
7600    var innerBlocks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
7601    // Get the type definition associated with a registered block.
7602    var blockType = registration_getBlockType(name);
7603  
7604    if (undefined === blockType) {
7605      throw new Error("Block type '".concat(name, "' is not registered."));
7606    } // Ensure attributes contains only values defined by block type, and merge
7607    // default values for missing attributes.
7608  
7609  
7610    var sanitizedAttributes = Object(external_this_lodash_["reduce"])(blockType.attributes, function (accumulator, schema, key) {
7611      var value = attributes[key];
7612  
7613      if (undefined !== value) {
7614        accumulator[key] = value;
7615      } else if (schema.hasOwnProperty('default')) {
7616        accumulator[key] = schema.default;
7617      }
7618  
7619      if (['node', 'children'].indexOf(schema.source) !== -1) {
7620        // Ensure value passed is always an array, which we're expecting in
7621        // the RichText component to handle the deprecated value.
7622        if (typeof accumulator[key] === 'string') {
7623          accumulator[key] = [accumulator[key]];
7624        } else if (!Array.isArray(accumulator[key])) {
7625          accumulator[key] = [];
7626        }
7627      }
7628  
7629      return accumulator;
7630    }, {});
7631    var clientId = esm_browser_v4(); // Blocks are stored with a unique ID, the assigned type name, the block
7632    // attributes, and their inner blocks.
7633  
7634    return {
7635      clientId: clientId,
7636      name: name,
7637      isValid: true,
7638      attributes: sanitizedAttributes,
7639      innerBlocks: innerBlocks
7640    };
7641  }
7642  /**
7643   * Given an array of InnerBlocks templates or Block Objects,
7644   * returns an array of created Blocks from them.
7645   * It handles the case of having InnerBlocks as Blocks by
7646   * converting them to the proper format to continue recursively.
7647   *
7648   * @param {Array} innerBlocksOrTemplate Nested blocks or InnerBlocks templates.
7649   *
7650   * @return {Object[]} Array of Block objects.
7651   */
7652  
7653  function createBlocksFromInnerBlocksTemplate() {
7654    var innerBlocksOrTemplate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
7655    return innerBlocksOrTemplate.map(function (innerBlock) {
7656      var innerBlockTemplate = Array.isArray(innerBlock) ? innerBlock : [innerBlock.name, innerBlock.attributes, innerBlock.innerBlocks];
7657  
7658      var _innerBlockTemplate = Object(slicedToArray["a" /* default */])(innerBlockTemplate, 3),
7659          name = _innerBlockTemplate[0],
7660          attributes = _innerBlockTemplate[1],
7661          _innerBlockTemplate$ = _innerBlockTemplate[2],
7662          innerBlocks = _innerBlockTemplate$ === void 0 ? [] : _innerBlockTemplate$;
7663  
7664      return createBlock(name, attributes, createBlocksFromInnerBlocksTemplate(innerBlocks));
7665    });
7666  }
7667  /**
7668   * Given a block object, returns a copy of the block object, optionally merging
7669   * new attributes and/or replacing its inner blocks.
7670   *
7671   * @param {Object} block              Block instance.
7672   * @param {Object} mergeAttributes    Block attributes.
7673   * @param {?Array} newInnerBlocks     Nested blocks.
7674   *
7675   * @return {Object} A cloned block.
7676   */
7677  
7678  function cloneBlock(block) {
7679    var mergeAttributes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
7680    var newInnerBlocks = arguments.length > 2 ? arguments[2] : undefined;
7681    var clientId = esm_browser_v4();
7682    return factory_objectSpread(factory_objectSpread({}, block), {}, {
7683      clientId: clientId,
7684      attributes: factory_objectSpread(factory_objectSpread({}, block.attributes), mergeAttributes),
7685      innerBlocks: newInnerBlocks || block.innerBlocks.map(function (innerBlock) {
7686        return cloneBlock(innerBlock);
7687      })
7688    });
7689  }
7690  /**
7691   * Returns a boolean indicating whether a transform is possible based on
7692   * various bits of context.
7693   *
7694   * @param {Object} transform The transform object to validate.
7695   * @param {string} direction Is this a 'from' or 'to' transform.
7696   * @param {Array} blocks The blocks to transform from.
7697   *
7698   * @return {boolean} Is the transform possible?
7699   */
7700  
7701  var factory_isPossibleTransformForSource = function isPossibleTransformForSource(transform, direction, blocks) {
7702    if (Object(external_this_lodash_["isEmpty"])(blocks)) {
7703      return false;
7704    } // If multiple blocks are selected, only multi block transforms
7705    // or wildcard transforms are allowed.
7706  
7707  
7708    var isMultiBlock = blocks.length > 1;
7709    var firstBlockName = Object(external_this_lodash_["first"])(blocks).name;
7710    var isValidForMultiBlocks = isWildcardBlockTransform(transform) || !isMultiBlock || transform.isMultiBlock;
7711  
7712    if (!isValidForMultiBlocks) {
7713      return false;
7714    } // Check non-wildcard transforms to ensure that transform is valid
7715    // for a block selection of multiple blocks of different types
7716  
7717  
7718    if (!isWildcardBlockTransform(transform) && !Object(external_this_lodash_["every"])(blocks, {
7719      name: firstBlockName
7720    })) {
7721      return false;
7722    } // Only consider 'block' type transforms as valid.
7723  
7724  
7725    var isBlockType = transform.type === 'block';
7726  
7727    if (!isBlockType) {
7728      return false;
7729    } // Check if the transform's block name matches the source block (or is a wildcard)
7730    // only if this is a transform 'from'.
7731  
7732  
7733    var sourceBlock = Object(external_this_lodash_["first"])(blocks);
7734    var hasMatchingName = direction !== 'from' || transform.blocks.indexOf(sourceBlock.name) !== -1 || isWildcardBlockTransform(transform);
7735  
7736    if (!hasMatchingName) {
7737      return false;
7738    } // Don't allow single Grouping blocks to be transformed into
7739    // a Grouping block.
7740  
7741  
7742    if (!isMultiBlock && factory_isContainerGroupBlock(sourceBlock.name) && factory_isContainerGroupBlock(transform.blockName)) {
7743      return false;
7744    } // If the transform has a `isMatch` function specified, check that it returns true.
7745  
7746  
7747    if (Object(external_this_lodash_["isFunction"])(transform.isMatch)) {
7748      var attributes = transform.isMultiBlock ? blocks.map(function (block) {
7749        return block.attributes;
7750      }) : sourceBlock.attributes;
7751  
7752      if (!transform.isMatch(attributes)) {
7753        return false;
7754      }
7755    }
7756  
7757    return true;
7758  };
7759  /**
7760   * Returns block types that the 'blocks' can be transformed into, based on
7761   * 'from' transforms on other blocks.
7762   *
7763   * @param {Array}  blocks  The blocks to transform from.
7764   *
7765   * @return {Array} Block types that the blocks can be transformed into.
7766   */
7767  
7768  
7769  var factory_getBlockTypesForPossibleFromTransforms = function getBlockTypesForPossibleFromTransforms(blocks) {
7770    if (Object(external_this_lodash_["isEmpty"])(blocks)) {
7771      return [];
7772    }
7773  
7774    var allBlockTypes = registration_getBlockTypes(); // filter all blocks to find those with a 'from' transform.
7775  
7776    var blockTypesWithPossibleFromTransforms = Object(external_this_lodash_["filter"])(allBlockTypes, function (blockType) {
7777      var fromTransforms = getBlockTransforms('from', blockType.name);
7778      return !!findTransform(fromTransforms, function (transform) {
7779        return factory_isPossibleTransformForSource(transform, 'from', blocks);
7780      });
7781    });
7782    return blockTypesWithPossibleFromTransforms;
7783  };
7784  /**
7785   * Returns block types that the 'blocks' can be transformed into, based on
7786   * the source block's own 'to' transforms.
7787   *
7788   * @param {Array} blocks The blocks to transform from.
7789   *
7790   * @return {Array} Block types that the source can be transformed into.
7791   */
7792  
7793  
7794  var factory_getBlockTypesForPossibleToTransforms = function getBlockTypesForPossibleToTransforms(blocks) {
7795    if (Object(external_this_lodash_["isEmpty"])(blocks)) {
7796      return [];
7797    }
7798  
7799    var sourceBlock = Object(external_this_lodash_["first"])(blocks);
7800    var blockType = registration_getBlockType(sourceBlock.name);
7801    var transformsTo = getBlockTransforms('to', blockType.name); // filter all 'to' transforms to find those that are possible.
7802  
7803    var possibleTransforms = Object(external_this_lodash_["filter"])(transformsTo, function (transform) {
7804      return transform && factory_isPossibleTransformForSource(transform, 'to', blocks);
7805    }); // Build a list of block names using the possible 'to' transforms.
7806  
7807    var blockNames = Object(external_this_lodash_["flatMap"])(possibleTransforms, function (transformation) {
7808      return transformation.blocks;
7809    }); // Map block names to block types.
7810  
7811    return blockNames.map(function (name) {
7812      return registration_getBlockType(name);
7813    });
7814  };
7815  /**
7816   * Determines whether transform is a "block" type
7817   * and if so whether it is a "wildcard" transform
7818   * ie: targets "any" block type
7819   *
7820   * @param {Object} t the Block transform object
7821   *
7822   * @return {boolean} whether transform is a wildcard transform
7823   */
7824  
7825  
7826  var isWildcardBlockTransform = function isWildcardBlockTransform(t) {
7827    return t && t.type === 'block' && Array.isArray(t.blocks) && t.blocks.includes('*');
7828  };
7829  /**
7830   * Determines whether the given Block is the core Block which
7831   * acts as a container Block for other Blocks as part of the
7832   * Grouping mechanics
7833   *
7834   * @param  {string} name the name of the Block to test against
7835   *
7836   * @return {boolean} whether or not the Block is the container Block type
7837   */
7838  
7839  var factory_isContainerGroupBlock = function isContainerGroupBlock(name) {
7840    return name === registration_getGroupingBlockName();
7841  };
7842  /**
7843   * Returns an array of block types that the set of blocks received as argument
7844   * can be transformed into.
7845   *
7846   * @param {Array} blocks Blocks array.
7847   *
7848   * @return {Array} Block types that the blocks argument can be transformed to.
7849   */
7850  
7851  function getPossibleBlockTransformations(blocks) {
7852    if (Object(external_this_lodash_["isEmpty"])(blocks)) {
7853      return [];
7854    }
7855  
7856    var blockTypesForFromTransforms = factory_getBlockTypesForPossibleFromTransforms(blocks);
7857    var blockTypesForToTransforms = factory_getBlockTypesForPossibleToTransforms(blocks);
7858    return Object(external_this_lodash_["uniq"])([].concat(Object(toConsumableArray["a" /* default */])(blockTypesForFromTransforms), Object(toConsumableArray["a" /* default */])(blockTypesForToTransforms)));
7859  }
7860  /**
7861   * Given an array of transforms, returns the highest-priority transform where
7862   * the predicate function returns a truthy value. A higher-priority transform
7863   * is one with a lower priority value (i.e. first in priority order). Returns
7864   * null if the transforms set is empty or the predicate function returns a
7865   * falsey value for all entries.
7866   *
7867   * @param {Object[]} transforms Transforms to search.
7868   * @param {Function} predicate  Function returning true on matching transform.
7869   *
7870   * @return {?Object} Highest-priority transform candidate.
7871   */
7872  
7873  function findTransform(transforms, predicate) {
7874    // The hooks library already has built-in mechanisms for managing priority
7875    // queue, so leverage via locally-defined instance.
7876    var hooks = Object(external_this_wp_hooks_["createHooks"])();
7877  
7878    var _loop = function _loop(i) {
7879      var candidate = transforms[i];
7880  
7881      if (predicate(candidate)) {
7882        hooks.addFilter('transform', 'transform/' + i.toString(), function (result) {
7883          return result ? result : candidate;
7884        }, candidate.priority);
7885      }
7886    };
7887  
7888    for (var i = 0; i < transforms.length; i++) {
7889      _loop(i);
7890    } // Filter name is arbitrarily chosen but consistent with above aggregation.
7891  
7892  
7893    return hooks.applyFilters('transform', null);
7894  }
7895  /**
7896   * Returns normal block transforms for a given transform direction, optionally
7897   * for a specific block by name, or an empty array if there are no transforms.
7898   * If no block name is provided, returns transforms for all blocks. A normal
7899   * transform object includes `blockName` as a property.
7900   *
7901   * @param {string}  direction Transform direction ("to", "from").
7902   * @param {string|Object} blockTypeOrName  Block type or name.
7903   *
7904   * @return {Array} Block transforms for direction.
7905   */
7906  
7907  function getBlockTransforms(direction, blockTypeOrName) {
7908    // When retrieving transforms for all block types, recurse into self.
7909    if (blockTypeOrName === undefined) {
7910      return Object(external_this_lodash_["flatMap"])(registration_getBlockTypes(), function (_ref) {
7911        var name = _ref.name;
7912        return getBlockTransforms(direction, name);
7913      });
7914    } // Validate that block type exists and has array of direction.
7915  
7916  
7917    var blockType = normalizeBlockType(blockTypeOrName);
7918  
7919    var _ref2 = blockType || {},
7920        blockName = _ref2.name,
7921        transforms = _ref2.transforms;
7922  
7923    if (!transforms || !Array.isArray(transforms[direction])) {
7924      return [];
7925    } // Map transforms to normal form.
7926  
7927  
7928    return transforms[direction].map(function (transform) {
7929      return factory_objectSpread(factory_objectSpread({}, transform), {}, {
7930        blockName: blockName
7931      });
7932    });
7933  }
7934  /**
7935   * Switch one or more blocks into one or more blocks of the new block type.
7936   *
7937   * @param {Array|Object} blocks Blocks array or block object.
7938   * @param {string}       name   Block name.
7939   *
7940   * @return {?Array} Array of blocks or null.
7941   */
7942  
7943  function switchToBlockType(blocks, name) {
7944    var blocksArray = Object(external_this_lodash_["castArray"])(blocks);
7945    var isMultiBlock = blocksArray.length > 1;
7946    var firstBlock = blocksArray[0];
7947    var sourceName = firstBlock.name; // Find the right transformation by giving priority to the "to"
7948    // transformation.
7949  
7950    var transformationsFrom = getBlockTransforms('from', name);
7951    var transformationsTo = getBlockTransforms('to', sourceName);
7952    var transformation = findTransform(transformationsTo, function (t) {
7953      return t.type === 'block' && (isWildcardBlockTransform(t) || t.blocks.indexOf(name) !== -1) && (!isMultiBlock || t.isMultiBlock);
7954    }) || findTransform(transformationsFrom, function (t) {
7955      return t.type === 'block' && (isWildcardBlockTransform(t) || t.blocks.indexOf(sourceName) !== -1) && (!isMultiBlock || t.isMultiBlock);
7956    }); // Stop if there is no valid transformation.
7957  
7958    if (!transformation) {
7959      return null;
7960    }
7961  
7962    var transformationResults;
7963  
7964    if (transformation.isMultiBlock) {
7965      if (Object(external_this_lodash_["has"])(transformation, '__experimentalConvert')) {
7966        transformationResults = transformation.__experimentalConvert(blocksArray);
7967      } else {
7968        transformationResults = transformation.transform(blocksArray.map(function (currentBlock) {
7969          return currentBlock.attributes;
7970        }), blocksArray.map(function (currentBlock) {
7971          return currentBlock.innerBlocks;
7972        }));
7973      }
7974    } else if (Object(external_this_lodash_["has"])(transformation, '__experimentalConvert')) {
7975      transformationResults = transformation.__experimentalConvert(firstBlock);
7976    } else {
7977      transformationResults = transformation.transform(firstBlock.attributes, firstBlock.innerBlocks);
7978    } // Ensure that the transformation function returned an object or an array
7979    // of objects.
7980  
7981  
7982    if (!Object(external_this_lodash_["isObjectLike"])(transformationResults)) {
7983      return null;
7984    } // If the transformation function returned a single object, we want to work
7985    // with an array instead.
7986  
7987  
7988    transformationResults = Object(external_this_lodash_["castArray"])(transformationResults); // Ensure that every block object returned by the transformation has a
7989    // valid block type.
7990  
7991    if (transformationResults.some(function (result) {
7992      return !registration_getBlockType(result.name);
7993    })) {
7994      return null;
7995    }
7996  
7997    var firstSwitchedBlock = Object(external_this_lodash_["findIndex"])(transformationResults, function (result) {
7998      return result.name === name;
7999    }); // Ensure that at least one block object returned by the transformation has
8000    // the expected "destination" block type.
8001  
8002    if (firstSwitchedBlock < 0) {
8003      return null;
8004    }
8005  
8006    return transformationResults.map(function (result, index) {
8007      var transformedBlock = factory_objectSpread(factory_objectSpread({}, result), {}, {
8008        // The first transformed block whose type matches the "destination"
8009        // type gets to keep the existing client ID of the first block.
8010        clientId: index === firstSwitchedBlock ? firstBlock.clientId : result.clientId
8011      });
8012      /**
8013       * Filters an individual transform result from block transformation.
8014       * All of the original blocks are passed, since transformations are
8015       * many-to-many, not one-to-one.
8016       *
8017       * @param {Object}   transformedBlock The transformed block.
8018       * @param {Object[]} blocks           Original blocks transformed.
8019       */
8020  
8021  
8022      return Object(external_this_wp_hooks_["applyFilters"])('blocks.switchToBlockType.transformedBlock', transformedBlock, blocks);
8023    });
8024  }
8025  /**
8026   * Create a block object from the example API.
8027   *
8028   * @param {string} name
8029   * @param {Object} example
8030   *
8031   * @return {Object} block.
8032   */
8033  
8034  var factory_getBlockFromExample = function getBlockFromExample(name, example) {
8035    return createBlock(name, example.attributes, Object(external_this_lodash_["map"])(example.innerBlocks, function (innerBlock) {
8036      return getBlockFromExample(innerBlock.name, innerBlock);
8037    }));
8038  };
8039  
8040  // CONCATENATED MODULE: ./node_modules/hpq/es/get-path.js
8041  /**
8042   * Given object and string of dot-delimited path segments, returns value at
8043   * path or undefined if path cannot be resolved.
8044   *
8045   * @param  {Object} object Lookup object
8046   * @param  {string} path   Path to resolve
8047   * @return {?*}            Resolved value
8048   */
8049  function getPath(object, path) {
8050    var segments = path.split('.');
8051    var segment;
8052  
8053    while (segment = segments.shift()) {
8054      if (!(segment in object)) {
8055        return;
8056      }
8057  
8058      object = object[segment];
8059    }
8060  
8061    return object;
8062  }
8063  // CONCATENATED MODULE: ./node_modules/hpq/es/index.js
8064  /**
8065   * Internal dependencies
8066   */
8067  
8068  /**
8069   * Function returning a DOM document created by `createHTMLDocument`. The same
8070   * document is returned between invocations.
8071   *
8072   * @return {Document} DOM document.
8073   */
8074  
8075  var getDocument = function () {
8076    var doc;
8077    return function () {
8078      if (!doc) {
8079        doc = document.implementation.createHTMLDocument('');
8080      }
8081  
8082      return doc;
8083    };
8084  }();
8085  /**
8086   * Given a markup string or DOM element, creates an object aligning with the
8087   * shape of the matchers object, or the value returned by the matcher.
8088   *
8089   * @param  {(string|Element)}  source   Source content
8090   * @param  {(Object|Function)} matchers Matcher function or object of matchers
8091   * @return {(Object|*)}                 Matched value(s), shaped by object
8092   */
8093  
8094  
8095  function es_parse(source, matchers) {
8096    if (!matchers) {
8097      return;
8098    } // Coerce to element
8099  
8100  
8101    if ('string' === typeof source) {
8102      var doc = getDocument();
8103      doc.body.innerHTML = source;
8104      source = doc.body;
8105    } // Return singular value
8106  
8107  
8108    if ('function' === typeof matchers) {
8109      return matchers(source);
8110    } // Bail if we can't handle matchers
8111  
8112  
8113    if (Object !== matchers.constructor) {
8114      return;
8115    } // Shape result by matcher object
8116  
8117  
8118    return Object.keys(matchers).reduce(function (memo, key) {
8119      memo[key] = es_parse(source, matchers[key]);
8120      return memo;
8121    }, {});
8122  }
8123  /**
8124   * Generates a function which matches node of type selector, returning an
8125   * attribute by property if the attribute exists. If no selector is passed,
8126   * returns property of the query element.
8127   *
8128   * @param  {?string} selector Optional selector
8129   * @param  {string}  name     Property name
8130   * @return {*}                Property value
8131   */
8132  
8133  function prop(selector, name) {
8134    if (1 === arguments.length) {
8135      name = selector;
8136      selector = undefined;
8137    }
8138  
8139    return function (node) {
8140      var match = node;
8141  
8142      if (selector) {
8143        match = node.querySelector(selector);
8144      }
8145  
8146      if (match) {
8147        return getPath(match, name);
8148      }
8149    };
8150  }
8151  /**
8152   * Generates a function which matches node of type selector, returning an
8153   * attribute by name if the attribute exists. If no selector is passed,
8154   * returns attribute of the query element.
8155   *
8156   * @param  {?string} selector Optional selector
8157   * @param  {string}  name     Attribute name
8158   * @return {?string}          Attribute value
8159   */
8160  
8161  function attr(selector, name) {
8162    if (1 === arguments.length) {
8163      name = selector;
8164      selector = undefined;
8165    }
8166  
8167    return function (node) {
8168      var attributes = prop(selector, 'attributes')(node);
8169  
8170      if (attributes && attributes.hasOwnProperty(name)) {
8171        return attributes[name].value;
8172      }
8173    };
8174  }
8175  /**
8176   * Convenience for `prop( selector, 'innerHTML' )`.
8177   *
8178   * @see prop()
8179   *
8180   * @param  {?string} selector Optional selector
8181   * @return {string}           Inner HTML
8182   */
8183  
8184  function es_html(selector) {
8185    return prop(selector, 'innerHTML');
8186  }
8187  /**
8188   * Convenience for `prop( selector, 'textContent' )`.
8189   *
8190   * @see prop()
8191   *
8192   * @param  {?string} selector Optional selector
8193   * @return {string}           Text content
8194   */
8195  
8196  function es_text(selector) {
8197    return prop(selector, 'textContent');
8198  }
8199  /**
8200   * Creates a new matching context by first finding elements matching selector
8201   * using querySelectorAll before then running another `parse` on `matchers`
8202   * scoped to the matched elements.
8203   *
8204   * @see parse()
8205   *
8206   * @param  {string}            selector Selector to match
8207   * @param  {(Object|Function)} matchers Matcher function or object of matchers
8208   * @return {Array.<*,Object>}           Array of matched value(s)
8209   */
8210  
8211  function query(selector, matchers) {
8212    return function (node) {
8213      var matches = node.querySelectorAll(selector);
8214      return [].map.call(matches, function (match) {
8215        return es_parse(match, matchers);
8216      });
8217    };
8218  }
8219  // EXTERNAL MODULE: external {"this":["wp","autop"]}
8220  var external_this_wp_autop_ = __webpack_require__(105);
8221  
8222  // EXTERNAL MODULE: external {"this":["wp","blockSerializationDefaultParser"]}
8223  var external_this_wp_blockSerializationDefaultParser_ = __webpack_require__(283);
8224  
8225  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toArray.js
8226  var toArray = __webpack_require__(149);
8227  
8228  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
8229  var classCallCheck = __webpack_require__(21);
8230  
8231  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
8232  var createClass = __webpack_require__(22);
8233  
8234  // CONCATENATED MODULE: ./node_modules/simple-html-tokenizer/dist/es6/index.js
8235  /**
8236   * generated from https://raw.githubusercontent.com/w3c/html/26b5126f96f736f796b9e29718138919dd513744/entities.json
8237   * do not edit
8238   */
8239  var namedCharRefs = {
8240      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: " ", thkap: "≈", thksim: "∼", THORN: "Þ", thorn: "þ", tilde: "˜", Tilde: "∼", TildeEqual: "≃", TildeFullEqual: "≅", TildeTilde: "≈", timesbar: "⨱", timesb: "⊠", times: "×", timesd: "⨰", tint: "∭", toea: "⤨", topbot: "⌶", topcir: "⫱", top: "⊤", Topf: "𝕋", topf: "𝕥", topfork: "⫚", tosa: "⤩", tprime: "‴", trade: "™", TRADE: "™", triangle: "▵", triangledown: "▿", triangleleft: "◃", trianglelefteq: "⊴", triangleq: "≜", triangleright: "▹", trianglerighteq: "⊵", tridot: "◬", trie: "≜", triminus: "⨺", TripleDot: "⃛", triplus: "⨹", trisb: "⧍", tritime: "⨻", trpezium: "⏢", Tscr: "𝒯", tscr: "𝓉", TScy: "Ц", tscy: "ц", TSHcy: "Ћ", tshcy: "ћ", Tstrok: "Ŧ", tstrok: "ŧ", twixt: "≬", twoheadleftarrow: "↞", twoheadrightarrow: "↠", Uacute: "Ú", uacute: "ú", uarr: "↑", Uarr: "↟", uArr: "⇑", Uarrocir: "⥉", Ubrcy: "Ў", ubrcy: "ў", Ubreve: "Ŭ", ubreve: "ŭ", Ucirc: "Û", ucirc: "û", Ucy: "У", ucy: "у", udarr: "⇅", Udblac: "Ű", udblac: "ű", udhar: "⥮", ufisht: "⥾", Ufr: "𝔘", ufr: "𝔲", Ugrave: "Ù", ugrave: "ù", uHar: "⥣", uharl: "↿", uharr: "↾", uhblk: "▀", ulcorn: "⌜", ulcorner: "⌜", ulcrop: "⌏", ultri: "◸", Umacr: "Ū", umacr: "ū", uml: "¨", UnderBar: "_", UnderBrace: "⏟", UnderBracket: "⎵", UnderParenthesis: "⏝", Union: "⋃", UnionPlus: "⊎", Uogon: "Ų", uogon: "ų", Uopf: "𝕌", uopf: "𝕦", UpArrowBar: "⤒", uparrow: "↑", UpArrow: "↑", Uparrow: "⇑", UpArrowDownArrow: "⇅", updownarrow: "↕", UpDownArrow: "↕", Updownarrow: "⇕", UpEquilibrium: "⥮", upharpoonleft: "↿", upharpoonright: "↾", uplus: "⊎", UpperLeftArrow: "↖", UpperRightArrow: "↗", upsi: "υ", Upsi: "ϒ", upsih: "ϒ", Upsilon: "Υ", upsilon: "υ", UpTeeArrow: "↥", UpTee: "⊥", upuparrows: "⇈", urcorn: "⌝", urcorner: "⌝", urcrop: "⌎", Uring: "Ů", uring: "ů", urtri: "◹", Uscr: "𝒰", uscr: "𝓊", utdot: "⋰", Utilde: "Ũ", utilde: "ũ", utri: "▵", utrif: "▴", uuarr: "⇈", Uuml: "Ü", uuml: "ü", uwangle: "⦧", vangrt: "⦜", varepsilon: "ϵ", varkappa: "ϰ", varnothing: "∅", varphi: "ϕ", varpi: "ϖ", varpropto: "∝", varr: "↕", vArr: "⇕", varrho: "ϱ", varsigma: "ς", varsubsetneq: "⊊︀", varsubsetneqq: "⫋︀", varsupsetneq: "⊋︀", varsupsetneqq: "⫌︀", vartheta: "ϑ", vartriangleleft: "⊲", vartriangleright: "⊳", vBar: "⫨", Vbar: "⫫", vBarv: "⫩", Vcy: "В", vcy: "в", vdash: "⊢", vDash: "⊨", Vdash: "⊩", VDash: "⊫", Vdashl: "⫦", veebar: "⊻", vee: "∨", Vee: "⋁", veeeq: "≚", vellip: "⋮", verbar: "|", Verbar: "‖", vert: "|", Vert: "‖", VerticalBar: "∣", VerticalLine: "|", VerticalSeparator: "❘", VerticalTilde: "≀", VeryThinSpace: " ", Vfr: "𝔙", vfr: "𝔳", vltri: "⊲", vnsub: "⊂⃒", vnsup: "⊃⃒", Vopf: "𝕍", vopf: "𝕧", vprop: "∝", vrtri: "⊳", Vscr: "𝒱", vscr: "𝓋", vsubnE: "⫋︀", vsubne: "⊊︀", vsupnE: "⫌︀", vsupne: "⊋︀", Vvdash: "⊪", vzigzag: "⦚", Wcirc: "Ŵ", wcirc: "ŵ", wedbar: "⩟", wedge: "∧", Wedge: "⋀", wedgeq: "≙", weierp: "℘", Wfr: "𝔚", wfr: "𝔴", Wopf: "𝕎", wopf: "𝕨", wp: "℘", wr: "≀", wreath: "≀", Wscr: "𝒲", wscr: "𝓌", xcap: "⋂", xcirc: "◯", xcup: "⋃", xdtri: "▽", Xfr: "𝔛", xfr: "𝔵", xharr: "⟷", xhArr: "⟺", Xi: "Ξ", xi: "ξ", xlarr: "⟵", xlArr: "⟸", xmap: "⟼", xnis: "⋻", xodot: "⨀", Xopf: "𝕏", xopf: "𝕩", xoplus: "⨁", xotime: "⨂", xrarr: "⟶", xrArr: "⟹", Xscr: "𝒳", xscr: "𝓍", xsqcup: "⨆", xuplus: "⨄", xutri: "△", xvee: "⋁", xwedge: "⋀", Yacute: "Ý", yacute: "ý", YAcy: "Я", yacy: "я", Ycirc: "Ŷ", ycirc: "ŷ", Ycy: "Ы", ycy: "ы", yen: "¥", Yfr: "𝔜", yfr: "𝔶", YIcy: "Ї", yicy: "ї", Yopf: "𝕐", yopf: "𝕪", Yscr: "𝒴", yscr: "𝓎", YUcy: "Ю", yucy: "ю", yuml: "ÿ", Yuml: "Ÿ", Zacute: "Ź", zacute: "ź", Zcaron: "Ž", zcaron: "ž", Zcy: "З", zcy: "з", Zdot: "Ż", zdot: "ż", zeetrf: "ℨ", ZeroWidthSpace: "​", Zeta: "Ζ", zeta: "ζ", zfr: "𝔷", Zfr: "ℨ", ZHcy: "Ж", zhcy: "ж", zigrarr: "⇝", zopf: "𝕫", Zopf: "ℤ", Zscr: "𝒵", zscr: "𝓏", zwj: "\u200d", zwnj: "\u200c"
8241  };
8242  
8243  var HEXCHARCODE = /^#[xX]([A-Fa-f0-9]+)$/;
8244  var CHARCODE = /^#([0-9]+)$/;
8245  var NAMED = /^([A-Za-z0-9]+)$/;
8246  var EntityParser = /** @class */ (function () {
8247      function EntityParser(named) {
8248          this.named = named;
8249      }
8250      EntityParser.prototype.parse = function (entity) {
8251          if (!entity) {
8252              return;
8253          }
8254          var matches = entity.match(HEXCHARCODE);
8255          if (matches) {
8256              return String.fromCharCode(parseInt(matches[1], 16));
8257          }
8258          matches = entity.match(CHARCODE);
8259          if (matches) {
8260              return String.fromCharCode(parseInt(matches[1], 10));
8261          }
8262          matches = entity.match(NAMED);
8263          if (matches) {
8264              return this.named[matches[1]];
8265          }
8266      };
8267      return EntityParser;
8268  }());
8269  
8270  var WSP = /[\t\n\f ]/;
8271  var ALPHA = /[A-Za-z]/;
8272  var CRLF = /\r\n?/g;
8273  function isSpace(char) {
8274      return WSP.test(char);
8275  }
8276  function isAlpha(char) {
8277      return ALPHA.test(char);
8278  }
8279  function preprocessInput(input) {
8280      return input.replace(CRLF, '\n');
8281  }
8282  
8283  var EventedTokenizer = /** @class */ (function () {
8284      function EventedTokenizer(delegate, entityParser, mode) {
8285          if (mode === void 0) { mode = 'precompile'; }
8286          this.delegate = delegate;
8287          this.entityParser = entityParser;
8288          this.mode = mode;
8289          this.state = "beforeData" /* beforeData */;
8290          this.line = -1;
8291          this.column = -1;
8292          this.input = '';
8293          this.index = -1;
8294          this.tagNameBuffer = '';
8295          this.states = {
8296              beforeData: function () {
8297                  var char = this.peek();
8298                  if (char === '<' && !this.isIgnoredEndTag()) {
8299                      this.transitionTo("tagOpen" /* tagOpen */);
8300                      this.markTagStart();
8301                      this.consume();
8302                  }
8303                  else {
8304                      if (this.mode === 'precompile' && char === '\n') {
8305                          var tag = this.tagNameBuffer.toLowerCase();
8306                          if (tag === 'pre' || tag === 'textarea') {
8307                              this.consume();
8308                          }
8309                      }
8310                      this.transitionTo("data" /* data */);
8311                      this.delegate.beginData();
8312                  }
8313              },
8314              data: function () {
8315                  var char = this.peek();
8316                  var tag = this.tagNameBuffer;
8317                  if (char === '<' && !this.isIgnoredEndTag()) {
8318                      this.delegate.finishData();
8319                      this.transitionTo("tagOpen" /* tagOpen */);
8320                      this.markTagStart();
8321                      this.consume();
8322                  }
8323                  else if (char === '&' && tag !== 'script' && tag !== 'style') {
8324                      this.consume();
8325                      this.delegate.appendToData(this.consumeCharRef() || '&');
8326                  }
8327                  else {
8328                      this.consume();
8329                      this.delegate.appendToData(char);
8330                  }
8331              },
8332              tagOpen: function () {
8333                  var char = this.consume();
8334                  if (char === '!') {
8335                      this.transitionTo("markupDeclarationOpen" /* markupDeclarationOpen */);
8336                  }
8337                  else if (char === '/') {
8338                      this.transitionTo("endTagOpen" /* endTagOpen */);
8339                  }
8340                  else if (char === '@' || char === ':' || isAlpha(char)) {
8341                      this.transitionTo("tagName" /* tagName */);
8342                      this.tagNameBuffer = '';
8343                      this.delegate.beginStartTag();
8344                      this.appendToTagName(char);
8345                  }
8346              },
8347              markupDeclarationOpen: function () {
8348                  var char = this.consume();
8349                  if (char === '-' && this.peek() === '-') {
8350                      this.consume();
8351                      this.transitionTo("commentStart" /* commentStart */);
8352                      this.delegate.beginComment();
8353                  }
8354              },
8355              commentStart: function () {
8356                  var char = this.consume();
8357                  if (char === '-') {
8358                      this.transitionTo("commentStartDash" /* commentStartDash */);
8359                  }
8360                  else if (char === '>') {
8361                      this.delegate.finishComment();
8362                      this.transitionTo("beforeData" /* beforeData */);
8363                  }
8364                  else {
8365                      this.delegate.appendToCommentData(char);
8366                      this.transitionTo("comment" /* comment */);
8367                  }
8368              },
8369              commentStartDash: function () {
8370                  var char = this.consume();
8371                  if (char === '-') {
8372                      this.transitionTo("commentEnd" /* commentEnd */);
8373                  }
8374                  else if (char === '>') {
8375                      this.delegate.finishComment();
8376                      this.transitionTo("beforeData" /* beforeData */);
8377                  }
8378                  else {
8379                      this.delegate.appendToCommentData('-');
8380                      this.transitionTo("comment" /* comment */);
8381                  }
8382              },
8383              comment: function () {
8384                  var char = this.consume();
8385                  if (char === '-') {
8386                      this.transitionTo("commentEndDash" /* commentEndDash */);
8387                  }
8388                  else {
8389                      this.delegate.appendToCommentData(char);
8390                  }
8391              },
8392              commentEndDash: function () {
8393                  var char = this.consume();
8394                  if (char === '-') {
8395                      this.transitionTo("commentEnd" /* commentEnd */);
8396                  }
8397                  else {
8398                      this.delegate.appendToCommentData('-' + char);
8399                      this.transitionTo("comment" /* comment */);
8400                  }
8401              },
8402              commentEnd: function () {
8403                  var char = this.consume();
8404                  if (char === '>') {
8405                      this.delegate.finishComment();
8406                      this.transitionTo("beforeData" /* beforeData */);
8407                  }
8408                  else {
8409                      this.delegate.appendToCommentData('--' + char);
8410                      this.transitionTo("comment" /* comment */);
8411                  }
8412              },
8413              tagName: function () {
8414                  var char = this.consume();
8415                  if (isSpace(char)) {
8416                      this.transitionTo("beforeAttributeName" /* beforeAttributeName */);
8417                  }
8418                  else if (char === '/') {
8419                      this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */);
8420                  }
8421                  else if (char === '>') {
8422                      this.delegate.finishTag();
8423                      this.transitionTo("beforeData" /* beforeData */);
8424                  }
8425                  else {
8426                      this.appendToTagName(char);
8427                  }
8428              },
8429              endTagName: function () {
8430                  var char = this.consume();
8431                  if (isSpace(char)) {
8432                      this.transitionTo("beforeAttributeName" /* beforeAttributeName */);
8433                      this.tagNameBuffer = '';
8434                  }
8435                  else if (char === '/') {
8436                      this.transitionTo("selfClosingStartTag" /* selfClosingStartTag */);
8437                      this.tagNameBuffer = '';
8438                  }
8439                  else if (char === '>') {
8440                      this.delegate.finishTag();
8441                      this.transitionTo("beforeData" /* beforeData */);
8442                      this.tagNameBuffer = '';
8443                  }
8444                  else {
8445                      this.appendToTagName(char);
8446                  }
8447              },
8448              beforeAttributeName: function () {
8449                  var char = this.peek();
8450