{"version":3,"file":"59db4916c4b5a13aafae75b6a2471b2b83dc6355-e369b3af313ec89e6cc5.js","mappings":"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","sources":["webpack://gatsby-starter-default/./node_modules/moment/moment.js","webpack://gatsby-starter-default/./node_modules/@ungap/structured-clone/esm/types.js","webpack://gatsby-starter-default/./node_modules/@ungap/structured-clone/esm/deserialize.js","webpack://gatsby-starter-default/./node_modules/@ungap/structured-clone/esm/serialize.js","webpack://gatsby-starter-default/./node_modules/@ungap/structured-clone/esm/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/hast-util-parse-selector/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/hastscript/lib/create-h.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/hastscript/lib/svg-case-sensitive-tag-names.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/hastscript/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/vfile-location/lib/index.js","webpack://gatsby-starter-default/./node_modules/web-namespaces/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/hast-util-from-parse5/lib/index.js","webpack://gatsby-starter-default/./node_modules/zwitch/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/hast-util-to-parse5/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/html-void-elements/index.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/common/unicode.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/common/error-codes.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/tokenizer/preprocessor.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/common/token.js","webpack://gatsby-starter-default/./node_modules/entities/lib/esm/generated/decode-data-html.js","webpack://gatsby-starter-default/./node_modules/entities/lib/esm/decode_codepoint.js","webpack://gatsby-starter-default/./node_modules/entities/lib/esm/generated/decode-data-xml.js","webpack://gatsby-starter-default/./node_modules/entities/lib/esm/decode.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/common/html.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/tokenizer/index.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/parser/open-element-stack.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/parser/formatting-element-list.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/tree-adapters/default.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/common/doctype.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/common/foreign-content.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/parser/index.js","webpack://gatsby-starter-default/./node_modules/entities/lib/esm/escape.js","webpack://gatsby-starter-default/./node_modules/parse5/dist/serializer/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/unist-util-position/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/unist-util-is/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/unist-util-visit-parents/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/hast-util-raw/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/node_modules/unist-util-visit/lib/index.js","webpack://gatsby-starter-default/./node_modules/rehype-raw/lib/index.js","webpack://gatsby-starter-default/./src/assets/image/demo.jpg","webpack://gatsby-starter-default/./src/components/Card.jsx"],"sourcesContent":["//! moment.js\n//! version : 2.29.4\n//! authors : Tim Wood, Iskren Chernev, Moment.js contributors\n//! license : MIT\n//! momentjs.com\n\n;\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : global.moment = factory();\n})(this, function () {\n  'use strict';\n\n  var hookCallback;\n  function hooks() {\n    return hookCallback.apply(null, arguments);\n  }\n\n  // This is done to register the method called with moment()\n  // without creating circular dependencies.\n  function setHookCallback(callback) {\n    hookCallback = callback;\n  }\n  function isArray(input) {\n    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';\n  }\n  function isObject(input) {\n    // IE8 will treat undefined and null as object if it wasn't for\n    // input != null\n    return input != null && Object.prototype.toString.call(input) === '[object Object]';\n  }\n  function hasOwnProp(a, b) {\n    return Object.prototype.hasOwnProperty.call(a, b);\n  }\n  function isObjectEmpty(obj) {\n    if (Object.getOwnPropertyNames) {\n      return Object.getOwnPropertyNames(obj).length === 0;\n    } else {\n      var k;\n      for (k in obj) {\n        if (hasOwnProp(obj, k)) {\n          return false;\n        }\n      }\n      return true;\n    }\n  }\n  function isUndefined(input) {\n    return input === void 0;\n  }\n  function isNumber(input) {\n    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';\n  }\n  function isDate(input) {\n    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';\n  }\n  function map(arr, fn) {\n    var res = [],\n      i,\n      arrLen = arr.length;\n    for (i = 0; i < arrLen; ++i) {\n      res.push(fn(arr[i], i));\n    }\n    return res;\n  }\n  function extend(a, b) {\n    for (var i in b) {\n      if (hasOwnProp(b, i)) {\n        a[i] = b[i];\n      }\n    }\n    if (hasOwnProp(b, 'toString')) {\n      a.toString = b.toString;\n    }\n    if (hasOwnProp(b, 'valueOf')) {\n      a.valueOf = b.valueOf;\n    }\n    return a;\n  }\n  function createUTC(input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, true).utc();\n  }\n  function defaultParsingFlags() {\n    // We need to deep clone this object.\n    return {\n      empty: false,\n      unusedTokens: [],\n      unusedInput: [],\n      overflow: -2,\n      charsLeftOver: 0,\n      nullInput: false,\n      invalidEra: null,\n      invalidMonth: null,\n      invalidFormat: false,\n      userInvalidated: false,\n      iso: false,\n      parsedDateParts: [],\n      era: null,\n      meridiem: null,\n      rfc2822: false,\n      weekdayMismatch: false\n    };\n  }\n  function getParsingFlags(m) {\n    if (m._pf == null) {\n      m._pf = defaultParsingFlags();\n    }\n    return m._pf;\n  }\n  var some;\n  if (Array.prototype.some) {\n    some = Array.prototype.some;\n  } else {\n    some = function (fun) {\n      var t = Object(this),\n        len = t.length >>> 0,\n        i;\n      for (i = 0; i < len; i++) {\n        if (i in t && fun.call(this, t[i], i, t)) {\n          return true;\n        }\n      }\n      return false;\n    };\n  }\n  function isValid(m) {\n    if (m._isValid == null) {\n      var flags = getParsingFlags(m),\n        parsedParts = some.call(flags.parsedDateParts, function (i) {\n          return i != null;\n        }),\n        isNowValid = !isNaN(m._d.getTime()) && flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts);\n      if (m._strict) {\n        isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === undefined;\n      }\n      if (Object.isFrozen == null || !Object.isFrozen(m)) {\n        m._isValid = isNowValid;\n      } else {\n        return isNowValid;\n      }\n    }\n    return m._isValid;\n  }\n  function createInvalid(flags) {\n    var m = createUTC(NaN);\n    if (flags != null) {\n      extend(getParsingFlags(m), flags);\n    } else {\n      getParsingFlags(m).userInvalidated = true;\n    }\n    return m;\n  }\n\n  // Plugins that add properties should also add the key here (null value),\n  // so we can properly clone ourselves.\n  var momentProperties = hooks.momentProperties = [],\n    updateInProgress = false;\n  function copyConfig(to, from) {\n    var i,\n      prop,\n      val,\n      momentPropertiesLen = momentProperties.length;\n    if (!isUndefined(from._isAMomentObject)) {\n      to._isAMomentObject = from._isAMomentObject;\n    }\n    if (!isUndefined(from._i)) {\n      to._i = from._i;\n    }\n    if (!isUndefined(from._f)) {\n      to._f = from._f;\n    }\n    if (!isUndefined(from._l)) {\n      to._l = from._l;\n    }\n    if (!isUndefined(from._strict)) {\n      to._strict = from._strict;\n    }\n    if (!isUndefined(from._tzm)) {\n      to._tzm = from._tzm;\n    }\n    if (!isUndefined(from._isUTC)) {\n      to._isUTC = from._isUTC;\n    }\n    if (!isUndefined(from._offset)) {\n      to._offset = from._offset;\n    }\n    if (!isUndefined(from._pf)) {\n      to._pf = getParsingFlags(from);\n    }\n    if (!isUndefined(from._locale)) {\n      to._locale = from._locale;\n    }\n    if (momentPropertiesLen > 0) {\n      for (i = 0; i < momentPropertiesLen; i++) {\n        prop = momentProperties[i];\n        val = from[prop];\n        if (!isUndefined(val)) {\n          to[prop] = val;\n        }\n      }\n    }\n    return to;\n  }\n\n  // Moment prototype object\n  function Moment(config) {\n    copyConfig(this, config);\n    this._d = new Date(config._d != null ? config._d.getTime() : NaN);\n    if (!this.isValid()) {\n      this._d = new Date(NaN);\n    }\n    // Prevent infinite loop in case updateOffset creates new moment\n    // objects.\n    if (updateInProgress === false) {\n      updateInProgress = true;\n      hooks.updateOffset(this);\n      updateInProgress = false;\n    }\n  }\n  function isMoment(obj) {\n    return obj instanceof Moment || obj != null && obj._isAMomentObject != null;\n  }\n  function warn(msg) {\n    if (hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {\n      console.warn('Deprecation warning: ' + msg);\n    }\n  }\n  function deprecate(msg, fn) {\n    var firstTime = true;\n    return extend(function () {\n      if (hooks.deprecationHandler != null) {\n        hooks.deprecationHandler(null, msg);\n      }\n      if (firstTime) {\n        var args = [],\n          arg,\n          i,\n          key,\n          argLen = arguments.length;\n        for (i = 0; i < argLen; i++) {\n          arg = '';\n          if (typeof arguments[i] === 'object') {\n            arg += '\\n[' + i + '] ';\n            for (key in arguments[0]) {\n              if (hasOwnProp(arguments[0], key)) {\n                arg += key + ': ' + arguments[0][key] + ', ';\n              }\n            }\n            arg = arg.slice(0, -2); // Remove trailing comma and space\n          } else {\n            arg = arguments[i];\n          }\n          args.push(arg);\n        }\n        warn(msg + '\\nArguments: ' + Array.prototype.slice.call(args).join('') + '\\n' + new Error().stack);\n        firstTime = false;\n      }\n      return fn.apply(this, arguments);\n    }, fn);\n  }\n  var deprecations = {};\n  function deprecateSimple(name, msg) {\n    if (hooks.deprecationHandler != null) {\n      hooks.deprecationHandler(name, msg);\n    }\n    if (!deprecations[name]) {\n      warn(msg);\n      deprecations[name] = true;\n    }\n  }\n  hooks.suppressDeprecationWarnings = false;\n  hooks.deprecationHandler = null;\n  function isFunction(input) {\n    return typeof Function !== 'undefined' && input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';\n  }\n  function set(config) {\n    var prop, i;\n    for (i in config) {\n      if (hasOwnProp(config, i)) {\n        prop = config[i];\n        if (isFunction(prop)) {\n          this[i] = prop;\n        } else {\n          this['_' + i] = prop;\n        }\n      }\n    }\n    this._config = config;\n    // Lenient ordinal parsing accepts just a number in addition to\n    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    this._dayOfMonthOrdinalParseLenient = new RegExp((this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + '|' + /\\d{1,2}/.source);\n  }\n  function mergeConfigs(parentConfig, childConfig) {\n    var res = extend({}, parentConfig),\n      prop;\n    for (prop in childConfig) {\n      if (hasOwnProp(childConfig, prop)) {\n        if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {\n          res[prop] = {};\n          extend(res[prop], parentConfig[prop]);\n          extend(res[prop], childConfig[prop]);\n        } else if (childConfig[prop] != null) {\n          res[prop] = childConfig[prop];\n        } else {\n          delete res[prop];\n        }\n      }\n    }\n    for (prop in parentConfig) {\n      if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) {\n        // make sure changes to properties don't modify parent config\n        res[prop] = extend({}, res[prop]);\n      }\n    }\n    return res;\n  }\n  function Locale(config) {\n    if (config != null) {\n      this.set(config);\n    }\n  }\n  var keys;\n  if (Object.keys) {\n    keys = Object.keys;\n  } else {\n    keys = function (obj) {\n      var i,\n        res = [];\n      for (i in obj) {\n        if (hasOwnProp(obj, i)) {\n          res.push(i);\n        }\n      }\n      return res;\n    };\n  }\n  var defaultCalendar = {\n    sameDay: '[Today at] LT',\n    nextDay: '[Tomorrow at] LT',\n    nextWeek: 'dddd [at] LT',\n    lastDay: '[Yesterday at] LT',\n    lastWeek: '[Last] dddd [at] LT',\n    sameElse: 'L'\n  };\n  function calendar(key, mom, now) {\n    var output = this._calendar[key] || this._calendar['sameElse'];\n    return isFunction(output) ? output.call(mom, now) : output;\n  }\n  function zeroFill(number, targetLength, forceSign) {\n    var absNumber = '' + Math.abs(number),\n      zerosToFill = targetLength - absNumber.length,\n      sign = number >= 0;\n    return (sign ? forceSign ? '+' : '' : '-') + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;\n  }\n  var formattingTokens = /(\\[[^\\[]*\\])|(\\\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,\n    localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g,\n    formatFunctions = {},\n    formatTokenFunctions = {};\n\n  // token:    'M'\n  // padded:   ['MM', 2]\n  // ordinal:  'Mo'\n  // callback: function () { this.month() + 1 }\n  function addFormatToken(token, padded, ordinal, callback) {\n    var func = callback;\n    if (typeof callback === 'string') {\n      func = function () {\n        return this[callback]();\n      };\n    }\n    if (token) {\n      formatTokenFunctions[token] = func;\n    }\n    if (padded) {\n      formatTokenFunctions[padded[0]] = function () {\n        return zeroFill(func.apply(this, arguments), padded[1], padded[2]);\n      };\n    }\n    if (ordinal) {\n      formatTokenFunctions[ordinal] = function () {\n        return this.localeData().ordinal(func.apply(this, arguments), token);\n      };\n    }\n  }\n  function removeFormattingTokens(input) {\n    if (input.match(/\\[[\\s\\S]/)) {\n      return input.replace(/^\\[|\\]$/g, '');\n    }\n    return input.replace(/\\\\/g, '');\n  }\n  function makeFormatFunction(format) {\n    var array = format.match(formattingTokens),\n      i,\n      length;\n    for (i = 0, length = array.length; i < length; i++) {\n      if (formatTokenFunctions[array[i]]) {\n        array[i] = formatTokenFunctions[array[i]];\n      } else {\n        array[i] = removeFormattingTokens(array[i]);\n      }\n    }\n    return function (mom) {\n      var output = '',\n        i;\n      for (i = 0; i < length; i++) {\n        output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];\n      }\n      return output;\n    };\n  }\n\n  // format date using native date object\n  function formatMoment(m, format) {\n    if (!m.isValid()) {\n      return m.localeData().invalidDate();\n    }\n    format = expandFormat(format, m.localeData());\n    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);\n    return formatFunctions[format](m);\n  }\n  function expandFormat(format, locale) {\n    var i = 5;\n    function replaceLongDateFormatTokens(input) {\n      return locale.longDateFormat(input) || input;\n    }\n    localFormattingTokens.lastIndex = 0;\n    while (i >= 0 && localFormattingTokens.test(format)) {\n      format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);\n      localFormattingTokens.lastIndex = 0;\n      i -= 1;\n    }\n    return format;\n  }\n  var defaultLongDateFormat = {\n    LTS: 'h:mm:ss A',\n    LT: 'h:mm A',\n    L: 'MM/DD/YYYY',\n    LL: 'MMMM D, YYYY',\n    LLL: 'MMMM D, YYYY h:mm A',\n    LLLL: 'dddd, MMMM D, YYYY h:mm A'\n  };\n  function longDateFormat(key) {\n    var format = this._longDateFormat[key],\n      formatUpper = this._longDateFormat[key.toUpperCase()];\n    if (format || !formatUpper) {\n      return format;\n    }\n    this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function (tok) {\n      if (tok === 'MMMM' || tok === 'MM' || tok === 'DD' || tok === 'dddd') {\n        return tok.slice(1);\n      }\n      return tok;\n    }).join('');\n    return this._longDateFormat[key];\n  }\n  var defaultInvalidDate = 'Invalid date';\n  function invalidDate() {\n    return this._invalidDate;\n  }\n  var defaultOrdinal = '%d',\n    defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n  function ordinal(number) {\n    return this._ordinal.replace('%d', number);\n  }\n  var defaultRelativeTime = {\n    future: 'in %s',\n    past: '%s ago',\n    s: 'a few seconds',\n    ss: '%d seconds',\n    m: 'a minute',\n    mm: '%d minutes',\n    h: 'an hour',\n    hh: '%d hours',\n    d: 'a day',\n    dd: '%d days',\n    w: 'a week',\n    ww: '%d weeks',\n    M: 'a month',\n    MM: '%d months',\n    y: 'a year',\n    yy: '%d years'\n  };\n  function relativeTime(number, withoutSuffix, string, isFuture) {\n    var output = this._relativeTime[string];\n    return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number);\n  }\n  function pastFuture(diff, output) {\n    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n    return isFunction(format) ? format(output) : format.replace(/%s/i, output);\n  }\n  var aliases = {};\n  function addUnitAlias(unit, shorthand) {\n    var lowerCase = unit.toLowerCase();\n    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n  }\n  function normalizeUnits(units) {\n    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;\n  }\n  function normalizeObjectUnits(inputObject) {\n    var normalizedInput = {},\n      normalizedProp,\n      prop;\n    for (prop in inputObject) {\n      if (hasOwnProp(inputObject, prop)) {\n        normalizedProp = normalizeUnits(prop);\n        if (normalizedProp) {\n          normalizedInput[normalizedProp] = inputObject[prop];\n        }\n      }\n    }\n    return normalizedInput;\n  }\n  var priorities = {};\n  function addUnitPriority(unit, priority) {\n    priorities[unit] = priority;\n  }\n  function getPrioritizedUnits(unitsObj) {\n    var units = [],\n      u;\n    for (u in unitsObj) {\n      if (hasOwnProp(unitsObj, u)) {\n        units.push({\n          unit: u,\n          priority: priorities[u]\n        });\n      }\n    }\n    units.sort(function (a, b) {\n      return a.priority - b.priority;\n    });\n    return units;\n  }\n  function isLeapYear(year) {\n    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n  }\n  function absFloor(number) {\n    if (number < 0) {\n      // -0 -> 0\n      return Math.ceil(number) || 0;\n    } else {\n      return Math.floor(number);\n    }\n  }\n  function toInt(argumentForCoercion) {\n    var coercedNumber = +argumentForCoercion,\n      value = 0;\n    if (coercedNumber !== 0 && isFinite(coercedNumber)) {\n      value = absFloor(coercedNumber);\n    }\n    return value;\n  }\n  function makeGetSet(unit, keepTime) {\n    return function (value) {\n      if (value != null) {\n        set$1(this, unit, value);\n        hooks.updateOffset(this, keepTime);\n        return this;\n      } else {\n        return get(this, unit);\n      }\n    };\n  }\n  function get(mom, unit) {\n    return mom.isValid() ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;\n  }\n  function set$1(mom, unit, value) {\n    if (mom.isValid() && !isNaN(value)) {\n      if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {\n        value = toInt(value);\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));\n      } else {\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);\n      }\n    }\n  }\n\n  // MOMENTS\n\n  function stringGet(units) {\n    units = normalizeUnits(units);\n    if (isFunction(this[units])) {\n      return this[units]();\n    }\n    return this;\n  }\n  function stringSet(units, value) {\n    if (typeof units === 'object') {\n      units = normalizeObjectUnits(units);\n      var prioritized = getPrioritizedUnits(units),\n        i,\n        prioritizedLen = prioritized.length;\n      for (i = 0; i < prioritizedLen; i++) {\n        this[prioritized[i].unit](units[prioritized[i].unit]);\n      }\n    } else {\n      units = normalizeUnits(units);\n      if (isFunction(this[units])) {\n        return this[units](value);\n      }\n    }\n    return this;\n  }\n  var match1 = /\\d/,\n    //       0 - 9\n    match2 = /\\d\\d/,\n    //      00 - 99\n    match3 = /\\d{3}/,\n    //     000 - 999\n    match4 = /\\d{4}/,\n    //    0000 - 9999\n    match6 = /[+-]?\\d{6}/,\n    // -999999 - 999999\n    match1to2 = /\\d\\d?/,\n    //       0 - 99\n    match3to4 = /\\d\\d\\d\\d?/,\n    //     999 - 9999\n    match5to6 = /\\d\\d\\d\\d\\d\\d?/,\n    //   99999 - 999999\n    match1to3 = /\\d{1,3}/,\n    //       0 - 999\n    match1to4 = /\\d{1,4}/,\n    //       0 - 9999\n    match1to6 = /[+-]?\\d{1,6}/,\n    // -999999 - 999999\n    matchUnsigned = /\\d+/,\n    //       0 - inf\n    matchSigned = /[+-]?\\d+/,\n    //    -inf - inf\n    matchOffset = /Z|[+-]\\d\\d:?\\d\\d/gi,\n    // +00:00 -00:00 +0000 -0000 or Z\n    matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi,\n    // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n    matchTimestamp = /[+-]?\\d+(\\.\\d{1,3})?/,\n    // 123456789 123456789.123\n    // any word (or two) characters or numbers including two/three word month in arabic.\n    // includes scottish gaelic two word and hyphenated months\n    matchWord = /[0-9]{0,256}['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFF07\\uFF10-\\uFFEF]{1,256}|[\\u0600-\\u06FF\\/]{1,256}(\\s*?[\\u0600-\\u06FF]{1,256}){1,2}/i,\n    regexes;\n  regexes = {};\n  function addRegexToken(token, regex, strictRegex) {\n    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {\n      return isStrict && strictRegex ? strictRegex : regex;\n    };\n  }\n  function getParseRegexForToken(token, config) {\n    if (!hasOwnProp(regexes, token)) {\n      return new RegExp(unescapeFormat(token));\n    }\n    return regexes[token](config._strict, config._locale);\n  }\n\n  // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript\n  function unescapeFormat(s) {\n    return regexEscape(s.replace('\\\\', '').replace(/\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g, function (matched, p1, p2, p3, p4) {\n      return p1 || p2 || p3 || p4;\n    }));\n  }\n  function regexEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n  }\n  var tokens = {};\n  function addParseToken(token, callback) {\n    var i,\n      func = callback,\n      tokenLen;\n    if (typeof token === 'string') {\n      token = [token];\n    }\n    if (isNumber(callback)) {\n      func = function (input, array) {\n        array[callback] = toInt(input);\n      };\n    }\n    tokenLen = token.length;\n    for (i = 0; i < tokenLen; i++) {\n      tokens[token[i]] = func;\n    }\n  }\n  function addWeekParseToken(token, callback) {\n    addParseToken(token, function (input, array, config, token) {\n      config._w = config._w || {};\n      callback(input, config._w, config, token);\n    });\n  }\n  function addTimeToArrayFromToken(token, input, config) {\n    if (input != null && hasOwnProp(tokens, token)) {\n      tokens[token](input, config._a, config, token);\n    }\n  }\n  var YEAR = 0,\n    MONTH = 1,\n    DATE = 2,\n    HOUR = 3,\n    MINUTE = 4,\n    SECOND = 5,\n    MILLISECOND = 6,\n    WEEK = 7,\n    WEEKDAY = 8;\n  function mod(n, x) {\n    return (n % x + x) % x;\n  }\n  var indexOf;\n  if (Array.prototype.indexOf) {\n    indexOf = Array.prototype.indexOf;\n  } else {\n    indexOf = function (o) {\n      // I know\n      var i;\n      for (i = 0; i < this.length; ++i) {\n        if (this[i] === o) {\n          return i;\n        }\n      }\n      return -1;\n    };\n  }\n  function daysInMonth(year, month) {\n    if (isNaN(year) || isNaN(month)) {\n      return NaN;\n    }\n    var modMonth = mod(month, 12);\n    year += (month - modMonth) / 12;\n    return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2;\n  }\n\n  // FORMATTING\n\n  addFormatToken('M', ['MM', 2], 'Mo', function () {\n    return this.month() + 1;\n  });\n  addFormatToken('MMM', 0, 0, function (format) {\n    return this.localeData().monthsShort(this, format);\n  });\n  addFormatToken('MMMM', 0, 0, function (format) {\n    return this.localeData().months(this, format);\n  });\n\n  // ALIASES\n\n  addUnitAlias('month', 'M');\n\n  // PRIORITY\n\n  addUnitPriority('month', 8);\n\n  // PARSING\n\n  addRegexToken('M', match1to2);\n  addRegexToken('MM', match1to2, match2);\n  addRegexToken('MMM', function (isStrict, locale) {\n    return locale.monthsShortRegex(isStrict);\n  });\n  addRegexToken('MMMM', function (isStrict, locale) {\n    return locale.monthsRegex(isStrict);\n  });\n  addParseToken(['M', 'MM'], function (input, array) {\n    array[MONTH] = toInt(input) - 1;\n  });\n  addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {\n    var month = config._locale.monthsParse(input, token, config._strict);\n    // if we didn't find a month name, mark the date as invalid.\n    if (month != null) {\n      array[MONTH] = month;\n    } else {\n      getParsingFlags(config).invalidMonth = input;\n    }\n  });\n\n  // LOCALES\n\n  var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),\n    defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),\n    MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/,\n    defaultMonthsShortRegex = matchWord,\n    defaultMonthsRegex = matchWord;\n  function localeMonths(m, format) {\n    if (!m) {\n      return isArray(this._months) ? this._months : this._months['standalone'];\n    }\n    return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];\n  }\n  function localeMonthsShort(m, format) {\n    if (!m) {\n      return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort['standalone'];\n    }\n    return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];\n  }\n  function handleStrictParse(monthName, format, strict) {\n    var i,\n      ii,\n      mom,\n      llc = monthName.toLocaleLowerCase();\n    if (!this._monthsParse) {\n      // this is not used\n      this._monthsParse = [];\n      this._longMonthsParse = [];\n      this._shortMonthsParse = [];\n      for (i = 0; i < 12; ++i) {\n        mom = createUTC([2000, i]);\n        this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();\n        this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();\n      }\n    }\n    if (strict) {\n      if (format === 'MMM') {\n        ii = indexOf.call(this._shortMonthsParse, llc);\n        return ii !== -1 ? ii : null;\n      } else {\n        ii = indexOf.call(this._longMonthsParse, llc);\n        return ii !== -1 ? ii : null;\n      }\n    } else {\n      if (format === 'MMM') {\n        ii = indexOf.call(this._shortMonthsParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._longMonthsParse, llc);\n        return ii !== -1 ? ii : null;\n      } else {\n        ii = indexOf.call(this._longMonthsParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._shortMonthsParse, llc);\n        return ii !== -1 ? ii : null;\n      }\n    }\n  }\n  function localeMonthsParse(monthName, format, strict) {\n    var i, mom, regex;\n    if (this._monthsParseExact) {\n      return handleStrictParse.call(this, monthName, format, strict);\n    }\n    if (!this._monthsParse) {\n      this._monthsParse = [];\n      this._longMonthsParse = [];\n      this._shortMonthsParse = [];\n    }\n\n    // TODO: add sorting\n    // Sorting makes sure if one month (or abbr) is a prefix of another\n    // see sorting in computeMonthsParse\n    for (i = 0; i < 12; i++) {\n      // make the regex if we don't have it already\n      mom = createUTC([2000, i]);\n      if (strict && !this._longMonthsParse[i]) {\n        this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');\n        this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');\n      }\n      if (!strict && !this._monthsParse[i]) {\n        regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n        this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n      }\n      // test the regex\n      if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {\n        return i;\n      } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {\n        return i;\n      } else if (!strict && this._monthsParse[i].test(monthName)) {\n        return i;\n      }\n    }\n  }\n\n  // MOMENTS\n\n  function setMonth(mom, value) {\n    var dayOfMonth;\n    if (!mom.isValid()) {\n      // No op\n      return mom;\n    }\n    if (typeof value === 'string') {\n      if (/^\\d+$/.test(value)) {\n        value = toInt(value);\n      } else {\n        value = mom.localeData().monthsParse(value);\n        // TODO: Another silent failure?\n        if (!isNumber(value)) {\n          return mom;\n        }\n      }\n    }\n    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));\n    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);\n    return mom;\n  }\n  function getSetMonth(value) {\n    if (value != null) {\n      setMonth(this, value);\n      hooks.updateOffset(this, true);\n      return this;\n    } else {\n      return get(this, 'Month');\n    }\n  }\n  function getDaysInMonth() {\n    return daysInMonth(this.year(), this.month());\n  }\n  function monthsShortRegex(isStrict) {\n    if (this._monthsParseExact) {\n      if (!hasOwnProp(this, '_monthsRegex')) {\n        computeMonthsParse.call(this);\n      }\n      if (isStrict) {\n        return this._monthsShortStrictRegex;\n      } else {\n        return this._monthsShortRegex;\n      }\n    } else {\n      if (!hasOwnProp(this, '_monthsShortRegex')) {\n        this._monthsShortRegex = defaultMonthsShortRegex;\n      }\n      return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex;\n    }\n  }\n  function monthsRegex(isStrict) {\n    if (this._monthsParseExact) {\n      if (!hasOwnProp(this, '_monthsRegex')) {\n        computeMonthsParse.call(this);\n      }\n      if (isStrict) {\n        return this._monthsStrictRegex;\n      } else {\n        return this._monthsRegex;\n      }\n    } else {\n      if (!hasOwnProp(this, '_monthsRegex')) {\n        this._monthsRegex = defaultMonthsRegex;\n      }\n      return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex;\n    }\n  }\n  function computeMonthsParse() {\n    function cmpLenRev(a, b) {\n      return b.length - a.length;\n    }\n    var shortPieces = [],\n      longPieces = [],\n      mixedPieces = [],\n      i,\n      mom;\n    for (i = 0; i < 12; i++) {\n      // make the regex if we don't have it already\n      mom = createUTC([2000, i]);\n      shortPieces.push(this.monthsShort(mom, ''));\n      longPieces.push(this.months(mom, ''));\n      mixedPieces.push(this.months(mom, ''));\n      mixedPieces.push(this.monthsShort(mom, ''));\n    }\n    // Sorting makes sure if one month (or abbr) is a prefix of another it\n    // will match the longer piece.\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 12; i++) {\n      shortPieces[i] = regexEscape(shortPieces[i]);\n      longPieces[i] = regexEscape(longPieces[i]);\n    }\n    for (i = 0; i < 24; i++) {\n      mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._monthsShortRegex = this._monthsRegex;\n    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n  }\n\n  // FORMATTING\n\n  addFormatToken('Y', 0, 0, function () {\n    var y = this.year();\n    return y <= 9999 ? zeroFill(y, 4) : '+' + y;\n  });\n  addFormatToken(0, ['YY', 2], 0, function () {\n    return this.year() % 100;\n  });\n  addFormatToken(0, ['YYYY', 4], 0, 'year');\n  addFormatToken(0, ['YYYYY', 5], 0, 'year');\n  addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n  // ALIASES\n\n  addUnitAlias('year', 'y');\n\n  // PRIORITIES\n\n  addUnitPriority('year', 1);\n\n  // PARSING\n\n  addRegexToken('Y', matchSigned);\n  addRegexToken('YY', match1to2, match2);\n  addRegexToken('YYYY', match1to4, match4);\n  addRegexToken('YYYYY', match1to6, match6);\n  addRegexToken('YYYYYY', match1to6, match6);\n  addParseToken(['YYYYY', 'YYYYYY'], YEAR);\n  addParseToken('YYYY', function (input, array) {\n    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n  });\n  addParseToken('YY', function (input, array) {\n    array[YEAR] = hooks.parseTwoDigitYear(input);\n  });\n  addParseToken('Y', function (input, array) {\n    array[YEAR] = parseInt(input, 10);\n  });\n\n  // HELPERS\n\n  function daysInYear(year) {\n    return isLeapYear(year) ? 366 : 365;\n  }\n\n  // HOOKS\n\n  hooks.parseTwoDigitYear = function (input) {\n    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n  };\n\n  // MOMENTS\n\n  var getSetYear = makeGetSet('FullYear', true);\n  function getIsLeapYear() {\n    return isLeapYear(this.year());\n  }\n  function createDate(y, m, d, h, M, s, ms) {\n    // can't just apply() to create a date:\n    // https://stackoverflow.com/q/181348\n    var date;\n    // the date constructor remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0) {\n      // preserve leap years using a full 400 year cycle, then reset\n      date = new Date(y + 400, m, d, h, M, s, ms);\n      if (isFinite(date.getFullYear())) {\n        date.setFullYear(y);\n      }\n    } else {\n      date = new Date(y, m, d, h, M, s, ms);\n    }\n    return date;\n  }\n  function createUTCDate(y) {\n    var date, args;\n    // the Date.UTC function remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0) {\n      args = Array.prototype.slice.call(arguments);\n      // preserve leap years using a full 400 year cycle, then reset\n      args[0] = y + 400;\n      date = new Date(Date.UTC.apply(null, args));\n      if (isFinite(date.getUTCFullYear())) {\n        date.setUTCFullYear(y);\n      }\n    } else {\n      date = new Date(Date.UTC.apply(null, arguments));\n    }\n    return date;\n  }\n\n  // start-of-first-week - start-of-year\n  function firstWeekOffset(year, dow, doy) {\n    var\n      // first-week day -- which january is always in the first week (4 for iso, 1 for other)\n      fwd = 7 + dow - doy,\n      // first-week day local weekday -- which local weekday is fwd\n      fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;\n    return -fwdlw + fwd - 1;\n  }\n\n  // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday\n  function dayOfYearFromWeeks(year, week, weekday, dow, doy) {\n    var localWeekday = (7 + weekday - dow) % 7,\n      weekOffset = firstWeekOffset(year, dow, doy),\n      dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,\n      resYear,\n      resDayOfYear;\n    if (dayOfYear <= 0) {\n      resYear = year - 1;\n      resDayOfYear = daysInYear(resYear) + dayOfYear;\n    } else if (dayOfYear > daysInYear(year)) {\n      resYear = year + 1;\n      resDayOfYear = dayOfYear - daysInYear(year);\n    } else {\n      resYear = year;\n      resDayOfYear = dayOfYear;\n    }\n    return {\n      year: resYear,\n      dayOfYear: resDayOfYear\n    };\n  }\n  function weekOfYear(mom, dow, doy) {\n    var weekOffset = firstWeekOffset(mom.year(), dow, doy),\n      week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,\n      resWeek,\n      resYear;\n    if (week < 1) {\n      resYear = mom.year() - 1;\n      resWeek = week + weeksInYear(resYear, dow, doy);\n    } else if (week > weeksInYear(mom.year(), dow, doy)) {\n      resWeek = week - weeksInYear(mom.year(), dow, doy);\n      resYear = mom.year() + 1;\n    } else {\n      resYear = mom.year();\n      resWeek = week;\n    }\n    return {\n      week: resWeek,\n      year: resYear\n    };\n  }\n  function weeksInYear(year, dow, doy) {\n    var weekOffset = firstWeekOffset(year, dow, doy),\n      weekOffsetNext = firstWeekOffset(year + 1, dow, doy);\n    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;\n  }\n\n  // FORMATTING\n\n  addFormatToken('w', ['ww', 2], 'wo', 'week');\n  addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n  // ALIASES\n\n  addUnitAlias('week', 'w');\n  addUnitAlias('isoWeek', 'W');\n\n  // PRIORITIES\n\n  addUnitPriority('week', 5);\n  addUnitPriority('isoWeek', 5);\n\n  // PARSING\n\n  addRegexToken('w', match1to2);\n  addRegexToken('ww', match1to2, match2);\n  addRegexToken('W', match1to2);\n  addRegexToken('WW', match1to2, match2);\n  addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {\n    week[token.substr(0, 1)] = toInt(input);\n  });\n\n  // HELPERS\n\n  // LOCALES\n\n  function localeWeek(mom) {\n    return weekOfYear(mom, this._week.dow, this._week.doy).week;\n  }\n  var defaultLocaleWeek = {\n    dow: 0,\n    // Sunday is the first day of the week.\n    doy: 6 // The week that contains Jan 6th is the first week of the year.\n  };\n\n  function localeFirstDayOfWeek() {\n    return this._week.dow;\n  }\n  function localeFirstDayOfYear() {\n    return this._week.doy;\n  }\n\n  // MOMENTS\n\n  function getSetWeek(input) {\n    var week = this.localeData().week(this);\n    return input == null ? week : this.add((input - week) * 7, 'd');\n  }\n  function getSetISOWeek(input) {\n    var week = weekOfYear(this, 1, 4).week;\n    return input == null ? week : this.add((input - week) * 7, 'd');\n  }\n\n  // FORMATTING\n\n  addFormatToken('d', 0, 'do', 'day');\n  addFormatToken('dd', 0, 0, function (format) {\n    return this.localeData().weekdaysMin(this, format);\n  });\n  addFormatToken('ddd', 0, 0, function (format) {\n    return this.localeData().weekdaysShort(this, format);\n  });\n  addFormatToken('dddd', 0, 0, function (format) {\n    return this.localeData().weekdays(this, format);\n  });\n  addFormatToken('e', 0, 0, 'weekday');\n  addFormatToken('E', 0, 0, 'isoWeekday');\n\n  // ALIASES\n\n  addUnitAlias('day', 'd');\n  addUnitAlias('weekday', 'e');\n  addUnitAlias('isoWeekday', 'E');\n\n  // PRIORITY\n  addUnitPriority('day', 11);\n  addUnitPriority('weekday', 11);\n  addUnitPriority('isoWeekday', 11);\n\n  // PARSING\n\n  addRegexToken('d', match1to2);\n  addRegexToken('e', match1to2);\n  addRegexToken('E', match1to2);\n  addRegexToken('dd', function (isStrict, locale) {\n    return locale.weekdaysMinRegex(isStrict);\n  });\n  addRegexToken('ddd', function (isStrict, locale) {\n    return locale.weekdaysShortRegex(isStrict);\n  });\n  addRegexToken('dddd', function (isStrict, locale) {\n    return locale.weekdaysRegex(isStrict);\n  });\n  addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {\n    var weekday = config._locale.weekdaysParse(input, token, config._strict);\n    // if we didn't get a weekday name, mark the date as invalid\n    if (weekday != null) {\n      week.d = weekday;\n    } else {\n      getParsingFlags(config).invalidWeekday = input;\n    }\n  });\n  addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n    week[token] = toInt(input);\n  });\n\n  // HELPERS\n\n  function parseWeekday(input, locale) {\n    if (typeof input !== 'string') {\n      return input;\n    }\n    if (!isNaN(input)) {\n      return parseInt(input, 10);\n    }\n    input = locale.weekdaysParse(input);\n    if (typeof input === 'number') {\n      return input;\n    }\n    return null;\n  }\n  function parseIsoWeekday(input, locale) {\n    if (typeof input === 'string') {\n      return locale.weekdaysParse(input) % 7 || 7;\n    }\n    return isNaN(input) ? null : input;\n  }\n\n  // LOCALES\n  function shiftWeekdays(ws, n) {\n    return ws.slice(n, 7).concat(ws.slice(0, n));\n  }\n  var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),\n    defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),\n    defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),\n    defaultWeekdaysRegex = matchWord,\n    defaultWeekdaysShortRegex = matchWord,\n    defaultWeekdaysMinRegex = matchWord;\n  function localeWeekdays(m, format) {\n    var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m && m !== true && this._weekdays.isFormat.test(format) ? 'format' : 'standalone'];\n    return m === true ? shiftWeekdays(weekdays, this._week.dow) : m ? weekdays[m.day()] : weekdays;\n  }\n  function localeWeekdaysShort(m) {\n    return m === true ? shiftWeekdays(this._weekdaysShort, this._week.dow) : m ? this._weekdaysShort[m.day()] : this._weekdaysShort;\n  }\n  function localeWeekdaysMin(m) {\n    return m === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m ? this._weekdaysMin[m.day()] : this._weekdaysMin;\n  }\n  function handleStrictParse$1(weekdayName, format, strict) {\n    var i,\n      ii,\n      mom,\n      llc = weekdayName.toLocaleLowerCase();\n    if (!this._weekdaysParse) {\n      this._weekdaysParse = [];\n      this._shortWeekdaysParse = [];\n      this._minWeekdaysParse = [];\n      for (i = 0; i < 7; ++i) {\n        mom = createUTC([2000, 1]).day(i);\n        this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();\n        this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();\n        this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();\n      }\n    }\n    if (strict) {\n      if (format === 'dddd') {\n        ii = indexOf.call(this._weekdaysParse, llc);\n        return ii !== -1 ? ii : null;\n      } else if (format === 'ddd') {\n        ii = indexOf.call(this._shortWeekdaysParse, llc);\n        return ii !== -1 ? ii : null;\n      } else {\n        ii = indexOf.call(this._minWeekdaysParse, llc);\n        return ii !== -1 ? ii : null;\n      }\n    } else {\n      if (format === 'dddd') {\n        ii = indexOf.call(this._weekdaysParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._shortWeekdaysParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._minWeekdaysParse, llc);\n        return ii !== -1 ? ii : null;\n      } else if (format === 'ddd') {\n        ii = indexOf.call(this._shortWeekdaysParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._weekdaysParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._minWeekdaysParse, llc);\n        return ii !== -1 ? ii : null;\n      } else {\n        ii = indexOf.call(this._minWeekdaysParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._weekdaysParse, llc);\n        if (ii !== -1) {\n          return ii;\n        }\n        ii = indexOf.call(this._shortWeekdaysParse, llc);\n        return ii !== -1 ? ii : null;\n      }\n    }\n  }\n  function localeWeekdaysParse(weekdayName, format, strict) {\n    var i, mom, regex;\n    if (this._weekdaysParseExact) {\n      return handleStrictParse$1.call(this, weekdayName, format, strict);\n    }\n    if (!this._weekdaysParse) {\n      this._weekdaysParse = [];\n      this._minWeekdaysParse = [];\n      this._shortWeekdaysParse = [];\n      this._fullWeekdaysParse = [];\n    }\n    for (i = 0; i < 7; i++) {\n      // make the regex if we don't have it already\n\n      mom = createUTC([2000, 1]).day(i);\n      if (strict && !this._fullWeekdaysParse[i]) {\n        this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\\\.?') + '$', 'i');\n        this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\\\.?') + '$', 'i');\n        this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\\\.?') + '$', 'i');\n      }\n      if (!this._weekdaysParse[i]) {\n        regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');\n        this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');\n      }\n      // test the regex\n      if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {\n        return i;\n      } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {\n        return i;\n      } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {\n        return i;\n      } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {\n        return i;\n      }\n    }\n  }\n\n  // MOMENTS\n\n  function getSetDayOfWeek(input) {\n    if (!this.isValid()) {\n      return input != null ? this : NaN;\n    }\n    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n    if (input != null) {\n      input = parseWeekday(input, this.localeData());\n      return this.add(input - day, 'd');\n    } else {\n      return day;\n    }\n  }\n  function getSetLocaleDayOfWeek(input) {\n    if (!this.isValid()) {\n      return input != null ? this : NaN;\n    }\n    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;\n    return input == null ? weekday : this.add(input - weekday, 'd');\n  }\n  function getSetISODayOfWeek(input) {\n    if (!this.isValid()) {\n      return input != null ? this : NaN;\n    }\n\n    // behaves the same as moment#day except\n    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)\n    // as a setter, sunday should belong to the previous week.\n\n    if (input != null) {\n      var weekday = parseIsoWeekday(input, this.localeData());\n      return this.day(this.day() % 7 ? weekday : weekday - 7);\n    } else {\n      return this.day() || 7;\n    }\n  }\n  function weekdaysRegex(isStrict) {\n    if (this._weekdaysParseExact) {\n      if (!hasOwnProp(this, '_weekdaysRegex')) {\n        computeWeekdaysParse.call(this);\n      }\n      if (isStrict) {\n        return this._weekdaysStrictRegex;\n      } else {\n        return this._weekdaysRegex;\n      }\n    } else {\n      if (!hasOwnProp(this, '_weekdaysRegex')) {\n        this._weekdaysRegex = defaultWeekdaysRegex;\n      }\n      return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex;\n    }\n  }\n  function weekdaysShortRegex(isStrict) {\n    if (this._weekdaysParseExact) {\n      if (!hasOwnProp(this, '_weekdaysRegex')) {\n        computeWeekdaysParse.call(this);\n      }\n      if (isStrict) {\n        return this._weekdaysShortStrictRegex;\n      } else {\n        return this._weekdaysShortRegex;\n      }\n    } else {\n      if (!hasOwnProp(this, '_weekdaysShortRegex')) {\n        this._weekdaysShortRegex = defaultWeekdaysShortRegex;\n      }\n      return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex;\n    }\n  }\n  function weekdaysMinRegex(isStrict) {\n    if (this._weekdaysParseExact) {\n      if (!hasOwnProp(this, '_weekdaysRegex')) {\n        computeWeekdaysParse.call(this);\n      }\n      if (isStrict) {\n        return this._weekdaysMinStrictRegex;\n      } else {\n        return this._weekdaysMinRegex;\n      }\n    } else {\n      if (!hasOwnProp(this, '_weekdaysMinRegex')) {\n        this._weekdaysMinRegex = defaultWeekdaysMinRegex;\n      }\n      return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex;\n    }\n  }\n  function computeWeekdaysParse() {\n    function cmpLenRev(a, b) {\n      return b.length - a.length;\n    }\n    var minPieces = [],\n      shortPieces = [],\n      longPieces = [],\n      mixedPieces = [],\n      i,\n      mom,\n      minp,\n      shortp,\n      longp;\n    for (i = 0; i < 7; i++) {\n      // make the regex if we don't have it already\n      mom = createUTC([2000, 1]).day(i);\n      minp = regexEscape(this.weekdaysMin(mom, ''));\n      shortp = regexEscape(this.weekdaysShort(mom, ''));\n      longp = regexEscape(this.weekdays(mom, ''));\n      minPieces.push(minp);\n      shortPieces.push(shortp);\n      longPieces.push(longp);\n      mixedPieces.push(minp);\n      mixedPieces.push(shortp);\n      mixedPieces.push(longp);\n    }\n    // Sorting makes sure if one weekday (or abbr) is a prefix of another it\n    // will match the longer piece.\n    minPieces.sort(cmpLenRev);\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._weekdaysShortRegex = this._weekdaysRegex;\n    this._weekdaysMinRegex = this._weekdaysRegex;\n    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');\n  }\n\n  // FORMATTING\n\n  function hFormat() {\n    return this.hours() % 12 || 12;\n  }\n  function kFormat() {\n    return this.hours() || 24;\n  }\n  addFormatToken('H', ['HH', 2], 0, 'hour');\n  addFormatToken('h', ['hh', 2], 0, hFormat);\n  addFormatToken('k', ['kk', 2], 0, kFormat);\n  addFormatToken('hmm', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n  });\n  addFormatToken('hmmss', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);\n  });\n  addFormatToken('Hmm', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2);\n  });\n  addFormatToken('Hmmss', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2);\n  });\n  function meridiem(token, lowercase) {\n    addFormatToken(token, 0, 0, function () {\n      return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);\n    });\n  }\n  meridiem('a', true);\n  meridiem('A', false);\n\n  // ALIASES\n\n  addUnitAlias('hour', 'h');\n\n  // PRIORITY\n  addUnitPriority('hour', 13);\n\n  // PARSING\n\n  function matchMeridiem(isStrict, locale) {\n    return locale._meridiemParse;\n  }\n  addRegexToken('a', matchMeridiem);\n  addRegexToken('A', matchMeridiem);\n  addRegexToken('H', match1to2);\n  addRegexToken('h', match1to2);\n  addRegexToken('k', match1to2);\n  addRegexToken('HH', match1to2, match2);\n  addRegexToken('hh', match1to2, match2);\n  addRegexToken('kk', match1to2, match2);\n  addRegexToken('hmm', match3to4);\n  addRegexToken('hmmss', match5to6);\n  addRegexToken('Hmm', match3to4);\n  addRegexToken('Hmmss', match5to6);\n  addParseToken(['H', 'HH'], HOUR);\n  addParseToken(['k', 'kk'], function (input, array, config) {\n    var kInput = toInt(input);\n    array[HOUR] = kInput === 24 ? 0 : kInput;\n  });\n  addParseToken(['a', 'A'], function (input, array, config) {\n    config._isPm = config._locale.isPM(input);\n    config._meridiem = input;\n  });\n  addParseToken(['h', 'hh'], function (input, array, config) {\n    array[HOUR] = toInt(input);\n    getParsingFlags(config).bigHour = true;\n  });\n  addParseToken('hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n    getParsingFlags(config).bigHour = true;\n  });\n  addParseToken('hmmss', function (input, array, config) {\n    var pos1 = input.length - 4,\n      pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n    getParsingFlags(config).bigHour = true;\n  });\n  addParseToken('Hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n  });\n  addParseToken('Hmmss', function (input, array, config) {\n    var pos1 = input.length - 4,\n      pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n  });\n\n  // LOCALES\n\n  function localeIsPM(input) {\n    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays\n    // Using charAt should be more compatible.\n    return (input + '').toLowerCase().charAt(0) === 'p';\n  }\n  var defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i,\n    // Setting the hour should keep the time, because the user explicitly\n    // specified which hour they want. So trying to maintain the same hour (in\n    // a new timezone) makes sense. Adding/subtracting hours does not follow\n    // this rule.\n    getSetHour = makeGetSet('Hours', true);\n  function localeMeridiem(hours, minutes, isLower) {\n    if (hours > 11) {\n      return isLower ? 'pm' : 'PM';\n    } else {\n      return isLower ? 'am' : 'AM';\n    }\n  }\n  var baseConfig = {\n    calendar: defaultCalendar,\n    longDateFormat: defaultLongDateFormat,\n    invalidDate: defaultInvalidDate,\n    ordinal: defaultOrdinal,\n    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,\n    relativeTime: defaultRelativeTime,\n    months: defaultLocaleMonths,\n    monthsShort: defaultLocaleMonthsShort,\n    week: defaultLocaleWeek,\n    weekdays: defaultLocaleWeekdays,\n    weekdaysMin: defaultLocaleWeekdaysMin,\n    weekdaysShort: defaultLocaleWeekdaysShort,\n    meridiemParse: defaultLocaleMeridiemParse\n  };\n\n  // internal storage for locale config files\n  var locales = {},\n    localeFamilies = {},\n    globalLocale;\n  function commonPrefix(arr1, arr2) {\n    var i,\n      minl = Math.min(arr1.length, arr2.length);\n    for (i = 0; i < minl; i += 1) {\n      if (arr1[i] !== arr2[i]) {\n        return i;\n      }\n    }\n    return minl;\n  }\n  function normalizeLocale(key) {\n    return key ? key.toLowerCase().replace('_', '-') : key;\n  }\n\n  // pick the locale from the array\n  // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n  // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root\n  function chooseLocale(names) {\n    var i = 0,\n      j,\n      next,\n      locale,\n      split;\n    while (i < names.length) {\n      split = normalizeLocale(names[i]).split('-');\n      j = split.length;\n      next = normalizeLocale(names[i + 1]);\n      next = next ? next.split('-') : null;\n      while (j > 0) {\n        locale = loadLocale(split.slice(0, j).join('-'));\n        if (locale) {\n          return locale;\n        }\n        if (next && next.length >= j && commonPrefix(split, next) >= j - 1) {\n          //the next array item is better than a shallower substring of this one\n          break;\n        }\n        j--;\n      }\n      i++;\n    }\n    return globalLocale;\n  }\n  function isLocaleNameSane(name) {\n    // Prevent names that look like filesystem paths, i.e contain '/' or '\\'\n    return name.match('^[^/\\\\\\\\]*$') != null;\n  }\n  function loadLocale(name) {\n    var oldLocale = null,\n      aliasedRequire;\n    // TODO: Find a better way to register and load all the locales in Node\n    if (locales[name] === undefined && typeof module !== 'undefined' && module && module.exports && isLocaleNameSane(name)) {\n      try {\n        oldLocale = globalLocale._abbr;\n        aliasedRequire = require;\n        aliasedRequire('./locale/' + name);\n        getSetGlobalLocale(oldLocale);\n      } catch (e) {\n        // mark as not found to avoid repeating expensive file require call causing high CPU\n        // when trying to find en-US, en_US, en-us for every format call\n        locales[name] = null; // null means not found\n      }\n    }\n\n    return locales[name];\n  }\n\n  // This function will load locale and then set the global locale.  If\n  // no arguments are passed in, it will simply return the current global\n  // locale key.\n  function getSetGlobalLocale(key, values) {\n    var data;\n    if (key) {\n      if (isUndefined(values)) {\n        data = getLocale(key);\n      } else {\n        data = defineLocale(key, values);\n      }\n      if (data) {\n        // moment.duration._locale = moment._locale = data;\n        globalLocale = data;\n      } else {\n        if (typeof console !== 'undefined' && console.warn) {\n          //warn user if arguments are passed but the locale could not be set\n          console.warn('Locale ' + key + ' not found. Did you forget to load it?');\n        }\n      }\n    }\n    return globalLocale._abbr;\n  }\n  function defineLocale(name, config) {\n    if (config !== null) {\n      var locale,\n        parentConfig = baseConfig;\n      config.abbr = name;\n      if (locales[name] != null) {\n        deprecateSimple('defineLocaleOverride', 'use moment.updateLocale(localeName, config) to change ' + 'an existing locale. moment.defineLocale(localeName, ' + 'config) should only be used for creating a new locale ' + 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');\n        parentConfig = locales[name]._config;\n      } else if (config.parentLocale != null) {\n        if (locales[config.parentLocale] != null) {\n          parentConfig = locales[config.parentLocale]._config;\n        } else {\n          locale = loadLocale(config.parentLocale);\n          if (locale != null) {\n            parentConfig = locale._config;\n          } else {\n            if (!localeFamilies[config.parentLocale]) {\n              localeFamilies[config.parentLocale] = [];\n            }\n            localeFamilies[config.parentLocale].push({\n              name: name,\n              config: config\n            });\n            return null;\n          }\n        }\n      }\n      locales[name] = new Locale(mergeConfigs(parentConfig, config));\n      if (localeFamilies[name]) {\n        localeFamilies[name].forEach(function (x) {\n          defineLocale(x.name, x.config);\n        });\n      }\n\n      // backwards compat for now: also set the locale\n      // make sure we set the locale AFTER all child locales have been\n      // created, so we won't end up with the child locale set.\n      getSetGlobalLocale(name);\n      return locales[name];\n    } else {\n      // useful for testing\n      delete locales[name];\n      return null;\n    }\n  }\n  function updateLocale(name, config) {\n    if (config != null) {\n      var locale,\n        tmpLocale,\n        parentConfig = baseConfig;\n      if (locales[name] != null && locales[name].parentLocale != null) {\n        // Update existing child locale in-place to avoid memory-leaks\n        locales[name].set(mergeConfigs(locales[name]._config, config));\n      } else {\n        // MERGE\n        tmpLocale = loadLocale(name);\n        if (tmpLocale != null) {\n          parentConfig = tmpLocale._config;\n        }\n        config = mergeConfigs(parentConfig, config);\n        if (tmpLocale == null) {\n          // updateLocale is called for creating a new locale\n          // Set abbr so it will have a name (getters return\n          // undefined otherwise).\n          config.abbr = name;\n        }\n        locale = new Locale(config);\n        locale.parentLocale = locales[name];\n        locales[name] = locale;\n      }\n\n      // backwards compat for now: also set the locale\n      getSetGlobalLocale(name);\n    } else {\n      // pass null for config to unupdate, useful for tests\n      if (locales[name] != null) {\n        if (locales[name].parentLocale != null) {\n          locales[name] = locales[name].parentLocale;\n          if (name === getSetGlobalLocale()) {\n            getSetGlobalLocale(name);\n          }\n        } else if (locales[name] != null) {\n          delete locales[name];\n        }\n      }\n    }\n    return locales[name];\n  }\n\n  // returns locale data\n  function getLocale(key) {\n    var locale;\n    if (key && key._locale && key._locale._abbr) {\n      key = key._locale._abbr;\n    }\n    if (!key) {\n      return globalLocale;\n    }\n    if (!isArray(key)) {\n      //short-circuit everything else\n      locale = loadLocale(key);\n      if (locale) {\n        return locale;\n      }\n      key = [key];\n    }\n    return chooseLocale(key);\n  }\n  function listLocales() {\n    return keys(locales);\n  }\n  function checkOverflow(m) {\n    var overflow,\n      a = m._a;\n    if (a && getParsingFlags(m).overflow === -2) {\n      overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1;\n      if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {\n        overflow = DATE;\n      }\n      if (getParsingFlags(m)._overflowWeeks && overflow === -1) {\n        overflow = WEEK;\n      }\n      if (getParsingFlags(m)._overflowWeekday && overflow === -1) {\n        overflow = WEEKDAY;\n      }\n      getParsingFlags(m).overflow = overflow;\n    }\n    return m;\n  }\n\n  // iso 8601 regex\n  // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\n  var extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([+-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/,\n    basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d|))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([+-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/,\n    tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/,\n    isoDates = [['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/], ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/], ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/], ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false], ['YYYY-DDD', /\\d{4}-\\d{3}/], ['YYYY-MM', /\\d{4}-\\d\\d/, false], ['YYYYYYMMDD', /[+-]\\d{10}/], ['YYYYMMDD', /\\d{8}/], ['GGGG[W]WWE', /\\d{4}W\\d{3}/], ['GGGG[W]WW', /\\d{4}W\\d{2}/, false], ['YYYYDDD', /\\d{7}/], ['YYYYMM', /\\d{6}/, false], ['YYYY', /\\d{4}/, false]],\n    // iso time formats and regexes\n    isoTimes = [['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/], ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/], ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/], ['HH:mm', /\\d\\d:\\d\\d/], ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/], ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/], ['HHmmss', /\\d\\d\\d\\d\\d\\d/], ['HHmm', /\\d\\d\\d\\d/], ['HH', /\\d\\d/]],\n    aspNetJsonRegex = /^\\/?Date\\((-?\\d+)/i,\n    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\n    rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d{1,2})\\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(\\d{2,4})\\s(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\\d{4}))$/,\n    obsOffsets = {\n      UT: 0,\n      GMT: 0,\n      EDT: -4 * 60,\n      EST: -5 * 60,\n      CDT: -5 * 60,\n      CST: -6 * 60,\n      MDT: -6 * 60,\n      MST: -7 * 60,\n      PDT: -7 * 60,\n      PST: -8 * 60\n    };\n\n  // date from iso format\n  function configFromISO(config) {\n    var i,\n      l,\n      string = config._i,\n      match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),\n      allowTime,\n      dateFormat,\n      timeFormat,\n      tzFormat,\n      isoDatesLen = isoDates.length,\n      isoTimesLen = isoTimes.length;\n    if (match) {\n      getParsingFlags(config).iso = true;\n      for (i = 0, l = isoDatesLen; i < l; i++) {\n        if (isoDates[i][1].exec(match[1])) {\n          dateFormat = isoDates[i][0];\n          allowTime = isoDates[i][2] !== false;\n          break;\n        }\n      }\n      if (dateFormat == null) {\n        config._isValid = false;\n        return;\n      }\n      if (match[3]) {\n        for (i = 0, l = isoTimesLen; i < l; i++) {\n          if (isoTimes[i][1].exec(match[3])) {\n            // match[2] should be 'T' or space\n            timeFormat = (match[2] || ' ') + isoTimes[i][0];\n            break;\n          }\n        }\n        if (timeFormat == null) {\n          config._isValid = false;\n          return;\n        }\n      }\n      if (!allowTime && timeFormat != null) {\n        config._isValid = false;\n        return;\n      }\n      if (match[4]) {\n        if (tzRegex.exec(match[4])) {\n          tzFormat = 'Z';\n        } else {\n          config._isValid = false;\n          return;\n        }\n      }\n      config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n      configFromStringAndFormat(config);\n    } else {\n      config._isValid = false;\n    }\n  }\n  function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {\n    var result = [untruncateYear(yearStr), defaultLocaleMonthsShort.indexOf(monthStr), parseInt(dayStr, 10), parseInt(hourStr, 10), parseInt(minuteStr, 10)];\n    if (secondStr) {\n      result.push(parseInt(secondStr, 10));\n    }\n    return result;\n  }\n  function untruncateYear(yearStr) {\n    var year = parseInt(yearStr, 10);\n    if (year <= 49) {\n      return 2000 + year;\n    } else if (year <= 999) {\n      return 1900 + year;\n    }\n    return year;\n  }\n  function preprocessRFC2822(s) {\n    // Remove comments and folding whitespace and replace multiple-spaces with a single space\n    return s.replace(/\\([^()]*\\)|[\\n\\t]/g, ' ').replace(/(\\s\\s+)/g, ' ').replace(/^\\s\\s*/, '').replace(/\\s\\s*$/, '');\n  }\n  function checkWeekday(weekdayStr, parsedInput, config) {\n    if (weekdayStr) {\n      // TODO: Replace the vanilla JS Date object with an independent day-of-week check.\n      var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),\n        weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();\n      if (weekdayProvided !== weekdayActual) {\n        getParsingFlags(config).weekdayMismatch = true;\n        config._isValid = false;\n        return false;\n      }\n    }\n    return true;\n  }\n  function calculateOffset(obsOffset, militaryOffset, numOffset) {\n    if (obsOffset) {\n      return obsOffsets[obsOffset];\n    } else if (militaryOffset) {\n      // the only allowed military tz is Z\n      return 0;\n    } else {\n      var hm = parseInt(numOffset, 10),\n        m = hm % 100,\n        h = (hm - m) / 100;\n      return h * 60 + m;\n    }\n  }\n\n  // date and time from ref 2822 format\n  function configFromRFC2822(config) {\n    var match = rfc2822.exec(preprocessRFC2822(config._i)),\n      parsedArray;\n    if (match) {\n      parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);\n      if (!checkWeekday(match[1], parsedArray, config)) {\n        return;\n      }\n      config._a = parsedArray;\n      config._tzm = calculateOffset(match[8], match[9], match[10]);\n      config._d = createUTCDate.apply(null, config._a);\n      config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n      getParsingFlags(config).rfc2822 = true;\n    } else {\n      config._isValid = false;\n    }\n  }\n\n  // date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict\n  function configFromString(config) {\n    var matched = aspNetJsonRegex.exec(config._i);\n    if (matched !== null) {\n      config._d = new Date(+matched[1]);\n      return;\n    }\n    configFromISO(config);\n    if (config._isValid === false) {\n      delete config._isValid;\n    } else {\n      return;\n    }\n    configFromRFC2822(config);\n    if (config._isValid === false) {\n      delete config._isValid;\n    } else {\n      return;\n    }\n    if (config._strict) {\n      config._isValid = false;\n    } else {\n      // Final attempt, use Input Fallback\n      hooks.createFromInputFallback(config);\n    }\n  }\n  hooks.createFromInputFallback = deprecate('value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + 'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.', function (config) {\n    config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n  });\n\n  // Pick the first defined of two or three arguments.\n  function defaults(a, b, c) {\n    if (a != null) {\n      return a;\n    }\n    if (b != null) {\n      return b;\n    }\n    return c;\n  }\n  function currentDateArray(config) {\n    // hooks is actually the exported moment object\n    var nowValue = new Date(hooks.now());\n    if (config._useUTC) {\n      return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];\n    }\n    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n  }\n\n  // convert an array to a date.\n  // the array should mirror the parameters below\n  // note: all values past the year are optional and will default to the lowest possible value.\n  // [year, month, day , hour, minute, second, millisecond]\n  function configFromArray(config) {\n    var i,\n      date,\n      input = [],\n      currentDate,\n      expectedWeekday,\n      yearToUse;\n    if (config._d) {\n      return;\n    }\n    currentDate = currentDateArray(config);\n\n    //compute day of the year from weeks and weekdays\n    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n      dayOfYearFromWeekInfo(config);\n    }\n\n    //if the day of the year is set, figure out what it is\n    if (config._dayOfYear != null) {\n      yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n      if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {\n        getParsingFlags(config)._overflowDayOfYear = true;\n      }\n      date = createUTCDate(yearToUse, 0, config._dayOfYear);\n      config._a[MONTH] = date.getUTCMonth();\n      config._a[DATE] = date.getUTCDate();\n    }\n\n    // Default to current date.\n    // * if no year, month, day of month are given, default to today\n    // * if day of month is given, default month and year\n    // * if month is given, default only year\n    // * if year is given, don't default anything\n    for (i = 0; i < 3 && config._a[i] == null; ++i) {\n      config._a[i] = input[i] = currentDate[i];\n    }\n\n    // Zero out whatever was not defaulted, including time\n    for (; i < 7; i++) {\n      config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i];\n    }\n\n    // Check for 24:00:00.000\n    if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {\n      config._nextDay = true;\n      config._a[HOUR] = 0;\n    }\n    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);\n    expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();\n\n    // Apply timezone offset from input. The actual utcOffset can be changed\n    // with parseZone.\n    if (config._tzm != null) {\n      config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n    }\n    if (config._nextDay) {\n      config._a[HOUR] = 24;\n    }\n\n    // check for mismatching day of week\n    if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {\n      getParsingFlags(config).weekdayMismatch = true;\n    }\n  }\n  function dayOfYearFromWeekInfo(config) {\n    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;\n    w = config._w;\n    if (w.GG != null || w.W != null || w.E != null) {\n      dow = 1;\n      doy = 4;\n\n      // TODO: We need to take the current isoWeekYear, but that depends on\n      // how we interpret now (local, utc, fixed offset). So create\n      // a now version of current config (take local/utc/offset flags, and\n      // create now).\n      weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);\n      week = defaults(w.W, 1);\n      weekday = defaults(w.E, 1);\n      if (weekday < 1 || weekday > 7) {\n        weekdayOverflow = true;\n      }\n    } else {\n      dow = config._locale._week.dow;\n      doy = config._locale._week.doy;\n      curWeek = weekOfYear(createLocal(), dow, doy);\n      weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n      // Default to current week.\n      week = defaults(w.w, curWeek.week);\n      if (w.d != null) {\n        // weekday -- low day numbers are considered next week\n        weekday = w.d;\n        if (weekday < 0 || weekday > 6) {\n          weekdayOverflow = true;\n        }\n      } else if (w.e != null) {\n        // local weekday -- counting starts from beginning of week\n        weekday = w.e + dow;\n        if (w.e < 0 || w.e > 6) {\n          weekdayOverflow = true;\n        }\n      } else {\n        // default to beginning of week\n        weekday = dow;\n      }\n    }\n    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n      getParsingFlags(config)._overflowWeeks = true;\n    } else if (weekdayOverflow != null) {\n      getParsingFlags(config)._overflowWeekday = true;\n    } else {\n      temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n      config._a[YEAR] = temp.year;\n      config._dayOfYear = temp.dayOfYear;\n    }\n  }\n\n  // constant that refers to the ISO standard\n  hooks.ISO_8601 = function () {};\n\n  // constant that refers to the RFC 2822 form\n  hooks.RFC_2822 = function () {};\n\n  // date from string and format string\n  function configFromStringAndFormat(config) {\n    // TODO: Move this to another part of the creation flow to prevent circular deps\n    if (config._f === hooks.ISO_8601) {\n      configFromISO(config);\n      return;\n    }\n    if (config._f === hooks.RFC_2822) {\n      configFromRFC2822(config);\n      return;\n    }\n    config._a = [];\n    getParsingFlags(config).empty = true;\n\n    // This array is used to make a Date, either with `new Date` or `Date.UTC`\n    var string = '' + config._i,\n      i,\n      parsedInput,\n      tokens,\n      token,\n      skipped,\n      stringLength = string.length,\n      totalParsedInputLength = 0,\n      era,\n      tokenLen;\n    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];\n    tokenLen = tokens.length;\n    for (i = 0; i < tokenLen; i++) {\n      token = tokens[i];\n      parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];\n      if (parsedInput) {\n        skipped = string.substr(0, string.indexOf(parsedInput));\n        if (skipped.length > 0) {\n          getParsingFlags(config).unusedInput.push(skipped);\n        }\n        string = string.slice(string.indexOf(parsedInput) + parsedInput.length);\n        totalParsedInputLength += parsedInput.length;\n      }\n      // don't parse if it's not a known token\n      if (formatTokenFunctions[token]) {\n        if (parsedInput) {\n          getParsingFlags(config).empty = false;\n        } else {\n          getParsingFlags(config).unusedTokens.push(token);\n        }\n        addTimeToArrayFromToken(token, parsedInput, config);\n      } else if (config._strict && !parsedInput) {\n        getParsingFlags(config).unusedTokens.push(token);\n      }\n    }\n\n    // add remaining unparsed input length to the string\n    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;\n    if (string.length > 0) {\n      getParsingFlags(config).unusedInput.push(string);\n    }\n\n    // clear _12h flag if hour is <= 12\n    if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) {\n      getParsingFlags(config).bigHour = undefined;\n    }\n    getParsingFlags(config).parsedDateParts = config._a.slice(0);\n    getParsingFlags(config).meridiem = config._meridiem;\n    // handle meridiem\n    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);\n\n    // handle era\n    era = getParsingFlags(config).era;\n    if (era !== null) {\n      config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);\n    }\n    configFromArray(config);\n    checkOverflow(config);\n  }\n  function meridiemFixWrap(locale, hour, meridiem) {\n    var isPm;\n    if (meridiem == null) {\n      // nothing to do\n      return hour;\n    }\n    if (locale.meridiemHour != null) {\n      return locale.meridiemHour(hour, meridiem);\n    } else if (locale.isPM != null) {\n      // Fallback\n      isPm = locale.isPM(meridiem);\n      if (isPm && hour < 12) {\n        hour += 12;\n      }\n      if (!isPm && hour === 12) {\n        hour = 0;\n      }\n      return hour;\n    } else {\n      // this is not supposed to happen\n      return hour;\n    }\n  }\n\n  // date from string and array of format strings\n  function configFromStringAndArray(config) {\n    var tempConfig,\n      bestMoment,\n      scoreToBeat,\n      i,\n      currentScore,\n      validFormatFound,\n      bestFormatIsValid = false,\n      configfLen = config._f.length;\n    if (configfLen === 0) {\n      getParsingFlags(config).invalidFormat = true;\n      config._d = new Date(NaN);\n      return;\n    }\n    for (i = 0; i < configfLen; i++) {\n      currentScore = 0;\n      validFormatFound = false;\n      tempConfig = copyConfig({}, config);\n      if (config._useUTC != null) {\n        tempConfig._useUTC = config._useUTC;\n      }\n      tempConfig._f = config._f[i];\n      configFromStringAndFormat(tempConfig);\n      if (isValid(tempConfig)) {\n        validFormatFound = true;\n      }\n\n      // if there is any input that was not parsed add a penalty for that format\n      currentScore += getParsingFlags(tempConfig).charsLeftOver;\n\n      //or tokens\n      currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;\n      getParsingFlags(tempConfig).score = currentScore;\n      if (!bestFormatIsValid) {\n        if (scoreToBeat == null || currentScore < scoreToBeat || validFormatFound) {\n          scoreToBeat = currentScore;\n          bestMoment = tempConfig;\n          if (validFormatFound) {\n            bestFormatIsValid = true;\n          }\n        }\n      } else {\n        if (currentScore < scoreToBeat) {\n          scoreToBeat = currentScore;\n          bestMoment = tempConfig;\n        }\n      }\n    }\n    extend(config, bestMoment || tempConfig);\n  }\n  function configFromObject(config) {\n    if (config._d) {\n      return;\n    }\n    var i = normalizeObjectUnits(config._i),\n      dayOrDate = i.day === undefined ? i.date : i.day;\n    config._a = map([i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond], function (obj) {\n      return obj && parseInt(obj, 10);\n    });\n    configFromArray(config);\n  }\n  function createFromConfig(config) {\n    var res = new Moment(checkOverflow(prepareConfig(config)));\n    if (res._nextDay) {\n      // Adding is smart enough around DST\n      res.add(1, 'd');\n      res._nextDay = undefined;\n    }\n    return res;\n  }\n  function prepareConfig(config) {\n    var input = config._i,\n      format = config._f;\n    config._locale = config._locale || getLocale(config._l);\n    if (input === null || format === undefined && input === '') {\n      return createInvalid({\n        nullInput: true\n      });\n    }\n    if (typeof input === 'string') {\n      config._i = input = config._locale.preparse(input);\n    }\n    if (isMoment(input)) {\n      return new Moment(checkOverflow(input));\n    } else if (isDate(input)) {\n      config._d = input;\n    } else if (isArray(format)) {\n      configFromStringAndArray(config);\n    } else if (format) {\n      configFromStringAndFormat(config);\n    } else {\n      configFromInput(config);\n    }\n    if (!isValid(config)) {\n      config._d = null;\n    }\n    return config;\n  }\n  function configFromInput(config) {\n    var input = config._i;\n    if (isUndefined(input)) {\n      config._d = new Date(hooks.now());\n    } else if (isDate(input)) {\n      config._d = new Date(input.valueOf());\n    } else if (typeof input === 'string') {\n      configFromString(config);\n    } else if (isArray(input)) {\n      config._a = map(input.slice(0), function (obj) {\n        return parseInt(obj, 10);\n      });\n      configFromArray(config);\n    } else if (isObject(input)) {\n      configFromObject(config);\n    } else if (isNumber(input)) {\n      // from milliseconds\n      config._d = new Date(input);\n    } else {\n      hooks.createFromInputFallback(config);\n    }\n  }\n  function createLocalOrUTC(input, format, locale, strict, isUTC) {\n    var c = {};\n    if (format === true || format === false) {\n      strict = format;\n      format = undefined;\n    }\n    if (locale === true || locale === false) {\n      strict = locale;\n      locale = undefined;\n    }\n    if (isObject(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) {\n      input = undefined;\n    }\n    // object construction must be done this way.\n    // https://github.com/moment/moment/issues/1423\n    c._isAMomentObject = true;\n    c._useUTC = c._isUTC = isUTC;\n    c._l = locale;\n    c._i = input;\n    c._f = format;\n    c._strict = strict;\n    return createFromConfig(c);\n  }\n  function createLocal(input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, false);\n  }\n  var prototypeMin = deprecate('moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', function () {\n      var other = createLocal.apply(null, arguments);\n      if (this.isValid() && other.isValid()) {\n        return other < this ? this : other;\n      } else {\n        return createInvalid();\n      }\n    }),\n    prototypeMax = deprecate('moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', function () {\n      var other = createLocal.apply(null, arguments);\n      if (this.isValid() && other.isValid()) {\n        return other > this ? this : other;\n      } else {\n        return createInvalid();\n      }\n    });\n\n  // Pick a moment m from moments so that m[fn](other) is true for all\n  // other. This relies on the function fn to be transitive.\n  //\n  // moments should either be an array of moment objects or an array, whose\n  // first element is an array of moment objects.\n  function pickBy(fn, moments) {\n    var res, i;\n    if (moments.length === 1 && isArray(moments[0])) {\n      moments = moments[0];\n    }\n    if (!moments.length) {\n      return createLocal();\n    }\n    res = moments[0];\n    for (i = 1; i < moments.length; ++i) {\n      if (!moments[i].isValid() || moments[i][fn](res)) {\n        res = moments[i];\n      }\n    }\n    return res;\n  }\n\n  // TODO: Use [].sort instead?\n  function min() {\n    var args = [].slice.call(arguments, 0);\n    return pickBy('isBefore', args);\n  }\n  function max() {\n    var args = [].slice.call(arguments, 0);\n    return pickBy('isAfter', args);\n  }\n  var now = function () {\n    return Date.now ? Date.now() : +new Date();\n  };\n  var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];\n  function isDurationValid(m) {\n    var key,\n      unitHasDecimal = false,\n      i,\n      orderLen = ordering.length;\n    for (key in m) {\n      if (hasOwnProp(m, key) && !(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {\n        return false;\n      }\n    }\n    for (i = 0; i < orderLen; ++i) {\n      if (m[ordering[i]]) {\n        if (unitHasDecimal) {\n          return false; // only allow non-integers for smallest unit\n        }\n\n        if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {\n          unitHasDecimal = true;\n        }\n      }\n    }\n    return true;\n  }\n  function isValid$1() {\n    return this._isValid;\n  }\n  function createInvalid$1() {\n    return createDuration(NaN);\n  }\n  function Duration(duration) {\n    var normalizedInput = normalizeObjectUnits(duration),\n      years = normalizedInput.year || 0,\n      quarters = normalizedInput.quarter || 0,\n      months = normalizedInput.month || 0,\n      weeks = normalizedInput.week || normalizedInput.isoWeek || 0,\n      days = normalizedInput.day || 0,\n      hours = normalizedInput.hour || 0,\n      minutes = normalizedInput.minute || 0,\n      seconds = normalizedInput.second || 0,\n      milliseconds = normalizedInput.millisecond || 0;\n    this._isValid = isDurationValid(normalizedInput);\n\n    // representation for dateAddRemove\n    this._milliseconds = +milliseconds + seconds * 1e3 +\n    // 1000\n    minutes * 6e4 +\n    // 1000 * 60\n    hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n    // Because of dateAddRemove treats 24 hours as different from a\n    // day when working around DST, we need to store them separately\n    this._days = +days + weeks * 7;\n    // It is impossible to translate months into days without knowing\n    // which months you are are talking about, so we have to store\n    // it separately.\n    this._months = +months + quarters * 3 + years * 12;\n    this._data = {};\n    this._locale = getLocale();\n    this._bubble();\n  }\n  function isDuration(obj) {\n    return obj instanceof Duration;\n  }\n  function absRound(number) {\n    if (number < 0) {\n      return Math.round(-1 * number) * -1;\n    } else {\n      return Math.round(number);\n    }\n  }\n\n  // compare two arrays, return the number of differences\n  function compareArrays(array1, array2, dontConvert) {\n    var len = Math.min(array1.length, array2.length),\n      lengthDiff = Math.abs(array1.length - array2.length),\n      diffs = 0,\n      i;\n    for (i = 0; i < len; i++) {\n      if (dontConvert && array1[i] !== array2[i] || !dontConvert && toInt(array1[i]) !== toInt(array2[i])) {\n        diffs++;\n      }\n    }\n    return diffs + lengthDiff;\n  }\n\n  // FORMATTING\n\n  function offset(token, separator) {\n    addFormatToken(token, 0, 0, function () {\n      var offset = this.utcOffset(),\n        sign = '+';\n      if (offset < 0) {\n        offset = -offset;\n        sign = '-';\n      }\n      return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~offset % 60, 2);\n    });\n  }\n  offset('Z', ':');\n  offset('ZZ', '');\n\n  // PARSING\n\n  addRegexToken('Z', matchShortOffset);\n  addRegexToken('ZZ', matchShortOffset);\n  addParseToken(['Z', 'ZZ'], function (input, array, config) {\n    config._useUTC = true;\n    config._tzm = offsetFromString(matchShortOffset, input);\n  });\n\n  // HELPERS\n\n  // timezone chunker\n  // '+10:00' > ['10',  '00']\n  // '-1530'  > ['-15', '30']\n  var chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n  function offsetFromString(matcher, string) {\n    var matches = (string || '').match(matcher),\n      chunk,\n      parts,\n      minutes;\n    if (matches === null) {\n      return null;\n    }\n    chunk = matches[matches.length - 1] || [];\n    parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];\n    minutes = +(parts[1] * 60) + toInt(parts[2]);\n    return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;\n  }\n\n  // Return a moment from input, that is local/utc/zone equivalent to model.\n  function cloneWithOffset(input, model) {\n    var res, diff;\n    if (model._isUTC) {\n      res = model.clone();\n      diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();\n      // Use low-level api, because this fn is low-level api.\n      res._d.setTime(res._d.valueOf() + diff);\n      hooks.updateOffset(res, false);\n      return res;\n    } else {\n      return createLocal(input).local();\n    }\n  }\n  function getDateOffset(m) {\n    // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n    // https://github.com/moment/moment/pull/1871\n    return -Math.round(m._d.getTimezoneOffset());\n  }\n\n  // HOOKS\n\n  // This function will be called whenever a moment is mutated.\n  // It is intended to keep the offset in sync with the timezone.\n  hooks.updateOffset = function () {};\n\n  // MOMENTS\n\n  // keepLocalTime = true means only change the timezone, without\n  // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n  // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n  // +0200, so we adjust the time as needed, to be valid.\n  //\n  // Keeping the time actually adds/subtracts (one hour)\n  // from the actual represented time. That is why we call updateOffset\n  // a second time. In case it wants us to change the offset again\n  // _changeInProgress == true case, then we have to adjust, because\n  // there is no such time in the given timezone.\n  function getSetOffset(input, keepLocalTime, keepMinutes) {\n    var offset = this._offset || 0,\n      localAdjust;\n    if (!this.isValid()) {\n      return input != null ? this : NaN;\n    }\n    if (input != null) {\n      if (typeof input === 'string') {\n        input = offsetFromString(matchShortOffset, input);\n        if (input === null) {\n          return this;\n        }\n      } else if (Math.abs(input) < 16 && !keepMinutes) {\n        input = input * 60;\n      }\n      if (!this._isUTC && keepLocalTime) {\n        localAdjust = getDateOffset(this);\n      }\n      this._offset = input;\n      this._isUTC = true;\n      if (localAdjust != null) {\n        this.add(localAdjust, 'm');\n      }\n      if (offset !== input) {\n        if (!keepLocalTime || this._changeInProgress) {\n          addSubtract(this, createDuration(input - offset, 'm'), 1, false);\n        } else if (!this._changeInProgress) {\n          this._changeInProgress = true;\n          hooks.updateOffset(this, true);\n          this._changeInProgress = null;\n        }\n      }\n      return this;\n    } else {\n      return this._isUTC ? offset : getDateOffset(this);\n    }\n  }\n  function getSetZone(input, keepLocalTime) {\n    if (input != null) {\n      if (typeof input !== 'string') {\n        input = -input;\n      }\n      this.utcOffset(input, keepLocalTime);\n      return this;\n    } else {\n      return -this.utcOffset();\n    }\n  }\n  function setOffsetToUTC(keepLocalTime) {\n    return this.utcOffset(0, keepLocalTime);\n  }\n  function setOffsetToLocal(keepLocalTime) {\n    if (this._isUTC) {\n      this.utcOffset(0, keepLocalTime);\n      this._isUTC = false;\n      if (keepLocalTime) {\n        this.subtract(getDateOffset(this), 'm');\n      }\n    }\n    return this;\n  }\n  function setOffsetToParsedOffset() {\n    if (this._tzm != null) {\n      this.utcOffset(this._tzm, false, true);\n    } else if (typeof this._i === 'string') {\n      var tZone = offsetFromString(matchOffset, this._i);\n      if (tZone != null) {\n        this.utcOffset(tZone);\n      } else {\n        this.utcOffset(0, true);\n      }\n    }\n    return this;\n  }\n  function hasAlignedHourOffset(input) {\n    if (!this.isValid()) {\n      return false;\n    }\n    input = input ? createLocal(input).utcOffset() : 0;\n    return (this.utcOffset() - input) % 60 === 0;\n  }\n  function isDaylightSavingTime() {\n    return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset();\n  }\n  function isDaylightSavingTimeShifted() {\n    if (!isUndefined(this._isDSTShifted)) {\n      return this._isDSTShifted;\n    }\n    var c = {},\n      other;\n    copyConfig(c, this);\n    c = prepareConfig(c);\n    if (c._a) {\n      other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n      this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0;\n    } else {\n      this._isDSTShifted = false;\n    }\n    return this._isDSTShifted;\n  }\n  function isLocal() {\n    return this.isValid() ? !this._isUTC : false;\n  }\n  function isUtcOffset() {\n    return this.isValid() ? this._isUTC : false;\n  }\n  function isUtc() {\n    return this.isValid() ? this._isUTC && this._offset === 0 : false;\n  }\n\n  // ASP.NET json date format regex\n  var aspNetRegex = /^(-|\\+)?(?:(\\d*)[. ])?(\\d+):(\\d+)(?::(\\d+)(\\.\\d*)?)?$/,\n    // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n    // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n    // and further modified to allow for strings containing both week and day\n    isoRegex = /^(-|\\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;\n  function createDuration(input, key) {\n    var duration = input,\n      // matching against regexp is expensive, do it on demand\n      match = null,\n      sign,\n      ret,\n      diffRes;\n    if (isDuration(input)) {\n      duration = {\n        ms: input._milliseconds,\n        d: input._days,\n        M: input._months\n      };\n    } else if (isNumber(input) || !isNaN(+input)) {\n      duration = {};\n      if (key) {\n        duration[key] = +input;\n      } else {\n        duration.milliseconds = +input;\n      }\n    } else if (match = aspNetRegex.exec(input)) {\n      sign = match[1] === '-' ? -1 : 1;\n      duration = {\n        y: 0,\n        d: toInt(match[DATE]) * sign,\n        h: toInt(match[HOUR]) * sign,\n        m: toInt(match[MINUTE]) * sign,\n        s: toInt(match[SECOND]) * sign,\n        ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match\n      };\n    } else if (match = isoRegex.exec(input)) {\n      sign = match[1] === '-' ? -1 : 1;\n      duration = {\n        y: parseIso(match[2], sign),\n        M: parseIso(match[3], sign),\n        w: parseIso(match[4], sign),\n        d: parseIso(match[5], sign),\n        h: parseIso(match[6], sign),\n        m: parseIso(match[7], sign),\n        s: parseIso(match[8], sign)\n      };\n    } else if (duration == null) {\n      // checks for null or undefined\n      duration = {};\n    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {\n      diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));\n      duration = {};\n      duration.ms = diffRes.milliseconds;\n      duration.M = diffRes.months;\n    }\n    ret = new Duration(duration);\n    if (isDuration(input) && hasOwnProp(input, '_locale')) {\n      ret._locale = input._locale;\n    }\n    if (isDuration(input) && hasOwnProp(input, '_isValid')) {\n      ret._isValid = input._isValid;\n    }\n    return ret;\n  }\n  createDuration.fn = Duration.prototype;\n  createDuration.invalid = createInvalid$1;\n  function parseIso(inp, sign) {\n    // We'd normally use ~~inp for this, but unfortunately it also\n    // converts floats to ints.\n    // inp may be undefined, so careful calling replace on it.\n    var res = inp && parseFloat(inp.replace(',', '.'));\n    // apply sign while we're at it\n    return (isNaN(res) ? 0 : res) * sign;\n  }\n  function positiveMomentsDifference(base, other) {\n    var res = {};\n    res.months = other.month() - base.month() + (other.year() - base.year()) * 12;\n    if (base.clone().add(res.months, 'M').isAfter(other)) {\n      --res.months;\n    }\n    res.milliseconds = +other - +base.clone().add(res.months, 'M');\n    return res;\n  }\n  function momentsDifference(base, other) {\n    var res;\n    if (!(base.isValid() && other.isValid())) {\n      return {\n        milliseconds: 0,\n        months: 0\n      };\n    }\n    other = cloneWithOffset(other, base);\n    if (base.isBefore(other)) {\n      res = positiveMomentsDifference(base, other);\n    } else {\n      res = positiveMomentsDifference(other, base);\n      res.milliseconds = -res.milliseconds;\n      res.months = -res.months;\n    }\n    return res;\n  }\n\n  // TODO: remove 'name' arg after deprecation is removed\n  function createAdder(direction, name) {\n    return function (val, period) {\n      var dur, tmp;\n      //invert the arguments, but complain about it\n      if (period !== null && !isNaN(+period)) {\n        deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' + 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');\n        tmp = val;\n        val = period;\n        period = tmp;\n      }\n      dur = createDuration(val, period);\n      addSubtract(this, dur, direction);\n      return this;\n    };\n  }\n  function addSubtract(mom, duration, isAdding, updateOffset) {\n    var milliseconds = duration._milliseconds,\n      days = absRound(duration._days),\n      months = absRound(duration._months);\n    if (!mom.isValid()) {\n      // No op\n      return;\n    }\n    updateOffset = updateOffset == null ? true : updateOffset;\n    if (months) {\n      setMonth(mom, get(mom, 'Month') + months * isAdding);\n    }\n    if (days) {\n      set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);\n    }\n    if (milliseconds) {\n      mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);\n    }\n    if (updateOffset) {\n      hooks.updateOffset(mom, days || months);\n    }\n  }\n  var add = createAdder(1, 'add'),\n    subtract = createAdder(-1, 'subtract');\n  function isString(input) {\n    return typeof input === 'string' || input instanceof String;\n  }\n\n  // type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined\n  function isMomentInput(input) {\n    return isMoment(input) || isDate(input) || isString(input) || isNumber(input) || isNumberOrStringArray(input) || isMomentInputObject(input) || input === null || input === undefined;\n  }\n  function isMomentInputObject(input) {\n    var objectTest = isObject(input) && !isObjectEmpty(input),\n      propertyTest = false,\n      properties = ['years', 'year', 'y', 'months', 'month', 'M', 'days', 'day', 'd', 'dates', 'date', 'D', 'hours', 'hour', 'h', 'minutes', 'minute', 'm', 'seconds', 'second', 's', 'milliseconds', 'millisecond', 'ms'],\n      i,\n      property,\n      propertyLen = properties.length;\n    for (i = 0; i < propertyLen; i += 1) {\n      property = properties[i];\n      propertyTest = propertyTest || hasOwnProp(input, property);\n    }\n    return objectTest && propertyTest;\n  }\n  function isNumberOrStringArray(input) {\n    var arrayTest = isArray(input),\n      dataTypeTest = false;\n    if (arrayTest) {\n      dataTypeTest = input.filter(function (item) {\n        return !isNumber(item) && isString(input);\n      }).length === 0;\n    }\n    return arrayTest && dataTypeTest;\n  }\n  function isCalendarSpec(input) {\n    var objectTest = isObject(input) && !isObjectEmpty(input),\n      propertyTest = false,\n      properties = ['sameDay', 'nextDay', 'lastDay', 'nextWeek', 'lastWeek', 'sameElse'],\n      i,\n      property;\n    for (i = 0; i < properties.length; i += 1) {\n      property = properties[i];\n      propertyTest = propertyTest || hasOwnProp(input, property);\n    }\n    return objectTest && propertyTest;\n  }\n  function getCalendarFormat(myMoment, now) {\n    var diff = myMoment.diff(now, 'days', true);\n    return diff < -6 ? 'sameElse' : diff < -1 ? 'lastWeek' : diff < 0 ? 'lastDay' : diff < 1 ? 'sameDay' : diff < 2 ? 'nextDay' : diff < 7 ? 'nextWeek' : 'sameElse';\n  }\n  function calendar$1(time, formats) {\n    // Support for single parameter, formats only overload to the calendar function\n    if (arguments.length === 1) {\n      if (!arguments[0]) {\n        time = undefined;\n        formats = undefined;\n      } else if (isMomentInput(arguments[0])) {\n        time = arguments[0];\n        formats = undefined;\n      } else if (isCalendarSpec(arguments[0])) {\n        formats = arguments[0];\n        time = undefined;\n      }\n    }\n    // We want to compare the start of today, vs this.\n    // Getting start-of-today depends on whether we're local/utc/offset or not.\n    var now = time || createLocal(),\n      sod = cloneWithOffset(now, this).startOf('day'),\n      format = hooks.calendarFormat(this, sod) || 'sameElse',\n      output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);\n    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));\n  }\n  function clone() {\n    return new Moment(this);\n  }\n  function isAfter(input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n      return false;\n    }\n    units = normalizeUnits(units) || 'millisecond';\n    if (units === 'millisecond') {\n      return this.valueOf() > localInput.valueOf();\n    } else {\n      return localInput.valueOf() < this.clone().startOf(units).valueOf();\n    }\n  }\n  function isBefore(input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n      return false;\n    }\n    units = normalizeUnits(units) || 'millisecond';\n    if (units === 'millisecond') {\n      return this.valueOf() < localInput.valueOf();\n    } else {\n      return this.clone().endOf(units).valueOf() < localInput.valueOf();\n    }\n  }\n  function isBetween(from, to, units, inclusivity) {\n    var localFrom = isMoment(from) ? from : createLocal(from),\n      localTo = isMoment(to) ? to : createLocal(to);\n    if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {\n      return false;\n    }\n    inclusivity = inclusivity || '()';\n    return (inclusivity[0] === '(' ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && (inclusivity[1] === ')' ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));\n  }\n  function isSame(input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input),\n      inputMs;\n    if (!(this.isValid() && localInput.isValid())) {\n      return false;\n    }\n    units = normalizeUnits(units) || 'millisecond';\n    if (units === 'millisecond') {\n      return this.valueOf() === localInput.valueOf();\n    } else {\n      inputMs = localInput.valueOf();\n      return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();\n    }\n  }\n  function isSameOrAfter(input, units) {\n    return this.isSame(input, units) || this.isAfter(input, units);\n  }\n  function isSameOrBefore(input, units) {\n    return this.isSame(input, units) || this.isBefore(input, units);\n  }\n  function diff(input, units, asFloat) {\n    var that, zoneDelta, output;\n    if (!this.isValid()) {\n      return NaN;\n    }\n    that = cloneWithOffset(input, this);\n    if (!that.isValid()) {\n      return NaN;\n    }\n    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;\n    units = normalizeUnits(units);\n    switch (units) {\n      case 'year':\n        output = monthDiff(this, that) / 12;\n        break;\n      case 'month':\n        output = monthDiff(this, that);\n        break;\n      case 'quarter':\n        output = monthDiff(this, that) / 3;\n        break;\n      case 'second':\n        output = (this - that) / 1e3;\n        break;\n      // 1000\n      case 'minute':\n        output = (this - that) / 6e4;\n        break;\n      // 1000 * 60\n      case 'hour':\n        output = (this - that) / 36e5;\n        break;\n      // 1000 * 60 * 60\n      case 'day':\n        output = (this - that - zoneDelta) / 864e5;\n        break;\n      // 1000 * 60 * 60 * 24, negate dst\n      case 'week':\n        output = (this - that - zoneDelta) / 6048e5;\n        break;\n      // 1000 * 60 * 60 * 24 * 7, negate dst\n      default:\n        output = this - that;\n    }\n    return asFloat ? output : absFloor(output);\n  }\n  function monthDiff(a, b) {\n    if (a.date() < b.date()) {\n      // end-of-month calculations work correct when the start month has more\n      // days than the end month.\n      return -monthDiff(b, a);\n    }\n    // difference in months\n    var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),\n      // b is in (anchor - 1 month, anchor + 1 month)\n      anchor = a.clone().add(wholeMonthDiff, 'months'),\n      anchor2,\n      adjust;\n    if (b - anchor < 0) {\n      anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');\n      // linear across the month\n      adjust = (b - anchor) / (anchor - anchor2);\n    } else {\n      anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');\n      // linear across the month\n      adjust = (b - anchor) / (anchor2 - anchor);\n    }\n\n    //check for negative zero, return zero if negative zero\n    return -(wholeMonthDiff + adjust) || 0;\n  }\n  hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\n  hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n  function toString() {\n    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n  }\n  function toISOString(keepOffset) {\n    if (!this.isValid()) {\n      return null;\n    }\n    var utc = keepOffset !== true,\n      m = utc ? this.clone().utc() : this;\n    if (m.year() < 0 || m.year() > 9999) {\n      return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');\n    }\n    if (isFunction(Date.prototype.toISOString)) {\n      // native implementation is ~50x faster, use it when we can\n      if (utc) {\n        return this.toDate().toISOString();\n      } else {\n        return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));\n      }\n    }\n    return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');\n  }\n\n  /**\n   * Return a human readable representation of a moment that can\n   * also be evaluated to get a new moment which is the same\n   *\n   * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects\n   */\n  function inspect() {\n    if (!this.isValid()) {\n      return 'moment.invalid(/* ' + this._i + ' */)';\n    }\n    var func = 'moment',\n      zone = '',\n      prefix,\n      year,\n      datetime,\n      suffix;\n    if (!this.isLocal()) {\n      func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';\n      zone = 'Z';\n    }\n    prefix = '[' + func + '(\"]';\n    year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';\n    datetime = '-MM-DD[T]HH:mm:ss.SSS';\n    suffix = zone + '[\")]';\n    return this.format(prefix + year + datetime + suffix);\n  }\n  function format(inputString) {\n    if (!inputString) {\n      inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;\n    }\n    var output = formatMoment(this, inputString);\n    return this.localeData().postformat(output);\n  }\n  function from(time, withoutSuffix) {\n    if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {\n      return createDuration({\n        to: this,\n        from: time\n      }).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n      return this.localeData().invalidDate();\n    }\n  }\n  function fromNow(withoutSuffix) {\n    return this.from(createLocal(), withoutSuffix);\n  }\n  function to(time, withoutSuffix) {\n    if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) {\n      return createDuration({\n        from: this,\n        to: time\n      }).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n      return this.localeData().invalidDate();\n    }\n  }\n  function toNow(withoutSuffix) {\n    return this.to(createLocal(), withoutSuffix);\n  }\n\n  // If passed a locale key, it will set the locale for this\n  // instance.  Otherwise, it will return the locale configuration\n  // variables for this instance.\n  function locale(key) {\n    var newLocaleData;\n    if (key === undefined) {\n      return this._locale._abbr;\n    } else {\n      newLocaleData = getLocale(key);\n      if (newLocaleData != null) {\n        this._locale = newLocaleData;\n      }\n      return this;\n    }\n  }\n  var lang = deprecate('moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', function (key) {\n    if (key === undefined) {\n      return this.localeData();\n    } else {\n      return this.locale(key);\n    }\n  });\n  function localeData() {\n    return this._locale;\n  }\n  var MS_PER_SECOND = 1000,\n    MS_PER_MINUTE = 60 * MS_PER_SECOND,\n    MS_PER_HOUR = 60 * MS_PER_MINUTE,\n    MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;\n\n  // actual modulo - handles negative numbers (for dates before 1970):\n  function mod$1(dividend, divisor) {\n    return (dividend % divisor + divisor) % divisor;\n  }\n  function localStartOfDate(y, m, d) {\n    // the date constructor remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0) {\n      // preserve leap years using a full 400 year cycle, then reset\n      return new Date(y + 400, m, d) - MS_PER_400_YEARS;\n    } else {\n      return new Date(y, m, d).valueOf();\n    }\n  }\n  function utcStartOfDate(y, m, d) {\n    // Date.UTC remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0) {\n      // preserve leap years using a full 400 year cycle, then reset\n      return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;\n    } else {\n      return Date.UTC(y, m, d);\n    }\n  }\n  function startOf(units) {\n    var time, startOfDate;\n    units = normalizeUnits(units);\n    if (units === undefined || units === 'millisecond' || !this.isValid()) {\n      return this;\n    }\n    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;\n    switch (units) {\n      case 'year':\n        time = startOfDate(this.year(), 0, 1);\n        break;\n      case 'quarter':\n        time = startOfDate(this.year(), this.month() - this.month() % 3, 1);\n        break;\n      case 'month':\n        time = startOfDate(this.year(), this.month(), 1);\n        break;\n      case 'week':\n        time = startOfDate(this.year(), this.month(), this.date() - this.weekday());\n        break;\n      case 'isoWeek':\n        time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1));\n        break;\n      case 'day':\n      case 'date':\n        time = startOfDate(this.year(), this.month(), this.date());\n        break;\n      case 'hour':\n        time = this._d.valueOf();\n        time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);\n        break;\n      case 'minute':\n        time = this._d.valueOf();\n        time -= mod$1(time, MS_PER_MINUTE);\n        break;\n      case 'second':\n        time = this._d.valueOf();\n        time -= mod$1(time, MS_PER_SECOND);\n        break;\n    }\n    this._d.setTime(time);\n    hooks.updateOffset(this, true);\n    return this;\n  }\n  function endOf(units) {\n    var time, startOfDate;\n    units = normalizeUnits(units);\n    if (units === undefined || units === 'millisecond' || !this.isValid()) {\n      return this;\n    }\n    startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;\n    switch (units) {\n      case 'year':\n        time = startOfDate(this.year() + 1, 0, 1) - 1;\n        break;\n      case 'quarter':\n        time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1;\n        break;\n      case 'month':\n        time = startOfDate(this.year(), this.month() + 1, 1) - 1;\n        break;\n      case 'week':\n        time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1;\n        break;\n      case 'isoWeek':\n        time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) - 1;\n        break;\n      case 'day':\n      case 'date':\n        time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;\n        break;\n      case 'hour':\n        time = this._d.valueOf();\n        time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1;\n        break;\n      case 'minute':\n        time = this._d.valueOf();\n        time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;\n        break;\n      case 'second':\n        time = this._d.valueOf();\n        time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;\n        break;\n    }\n    this._d.setTime(time);\n    hooks.updateOffset(this, true);\n    return this;\n  }\n  function valueOf() {\n    return this._d.valueOf() - (this._offset || 0) * 60000;\n  }\n  function unix() {\n    return Math.floor(this.valueOf() / 1000);\n  }\n  function toDate() {\n    return new Date(this.valueOf());\n  }\n  function toArray() {\n    var m = this;\n    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];\n  }\n  function toObject() {\n    var m = this;\n    return {\n      years: m.year(),\n      months: m.month(),\n      date: m.date(),\n      hours: m.hours(),\n      minutes: m.minutes(),\n      seconds: m.seconds(),\n      milliseconds: m.milliseconds()\n    };\n  }\n  function toJSON() {\n    // new Date(NaN).toJSON() === null\n    return this.isValid() ? this.toISOString() : null;\n  }\n  function isValid$2() {\n    return isValid(this);\n  }\n  function parsingFlags() {\n    return extend({}, getParsingFlags(this));\n  }\n  function invalidAt() {\n    return getParsingFlags(this).overflow;\n  }\n  function creationData() {\n    return {\n      input: this._i,\n      format: this._f,\n      locale: this._locale,\n      isUTC: this._isUTC,\n      strict: this._strict\n    };\n  }\n  addFormatToken('N', 0, 0, 'eraAbbr');\n  addFormatToken('NN', 0, 0, 'eraAbbr');\n  addFormatToken('NNN', 0, 0, 'eraAbbr');\n  addFormatToken('NNNN', 0, 0, 'eraName');\n  addFormatToken('NNNNN', 0, 0, 'eraNarrow');\n  addFormatToken('y', ['y', 1], 'yo', 'eraYear');\n  addFormatToken('y', ['yy', 2], 0, 'eraYear');\n  addFormatToken('y', ['yyy', 3], 0, 'eraYear');\n  addFormatToken('y', ['yyyy', 4], 0, 'eraYear');\n  addRegexToken('N', matchEraAbbr);\n  addRegexToken('NN', matchEraAbbr);\n  addRegexToken('NNN', matchEraAbbr);\n  addRegexToken('NNNN', matchEraName);\n  addRegexToken('NNNNN', matchEraNarrow);\n  addParseToken(['N', 'NN', 'NNN', 'NNNN', 'NNNNN'], function (input, array, config, token) {\n    var era = config._locale.erasParse(input, token, config._strict);\n    if (era) {\n      getParsingFlags(config).era = era;\n    } else {\n      getParsingFlags(config).invalidEra = input;\n    }\n  });\n  addRegexToken('y', matchUnsigned);\n  addRegexToken('yy', matchUnsigned);\n  addRegexToken('yyy', matchUnsigned);\n  addRegexToken('yyyy', matchUnsigned);\n  addRegexToken('yo', matchEraYearOrdinal);\n  addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR);\n  addParseToken(['yo'], function (input, array, config, token) {\n    var match;\n    if (config._locale._eraYearOrdinalRegex) {\n      match = input.match(config._locale._eraYearOrdinalRegex);\n    }\n    if (config._locale.eraYearOrdinalParse) {\n      array[YEAR] = config._locale.eraYearOrdinalParse(input, match);\n    } else {\n      array[YEAR] = parseInt(input, 10);\n    }\n  });\n  function localeEras(m, format) {\n    var i,\n      l,\n      date,\n      eras = this._eras || getLocale('en')._eras;\n    for (i = 0, l = eras.length; i < l; ++i) {\n      switch (typeof eras[i].since) {\n        case 'string':\n          // truncate time\n          date = hooks(eras[i].since).startOf('day');\n          eras[i].since = date.valueOf();\n          break;\n      }\n      switch (typeof eras[i].until) {\n        case 'undefined':\n          eras[i].until = +Infinity;\n          break;\n        case 'string':\n          // truncate time\n          date = hooks(eras[i].until).startOf('day').valueOf();\n          eras[i].until = date.valueOf();\n          break;\n      }\n    }\n    return eras;\n  }\n  function localeErasParse(eraName, format, strict) {\n    var i,\n      l,\n      eras = this.eras(),\n      name,\n      abbr,\n      narrow;\n    eraName = eraName.toUpperCase();\n    for (i = 0, l = eras.length; i < l; ++i) {\n      name = eras[i].name.toUpperCase();\n      abbr = eras[i].abbr.toUpperCase();\n      narrow = eras[i].narrow.toUpperCase();\n      if (strict) {\n        switch (format) {\n          case 'N':\n          case 'NN':\n          case 'NNN':\n            if (abbr === eraName) {\n              return eras[i];\n            }\n            break;\n          case 'NNNN':\n            if (name === eraName) {\n              return eras[i];\n            }\n            break;\n          case 'NNNNN':\n            if (narrow === eraName) {\n              return eras[i];\n            }\n            break;\n        }\n      } else if ([name, abbr, narrow].indexOf(eraName) >= 0) {\n        return eras[i];\n      }\n    }\n  }\n  function localeErasConvertYear(era, year) {\n    var dir = era.since <= era.until ? +1 : -1;\n    if (year === undefined) {\n      return hooks(era.since).year();\n    } else {\n      return hooks(era.since).year() + (year - era.offset) * dir;\n    }\n  }\n  function getEraName() {\n    var i,\n      l,\n      val,\n      eras = this.localeData().eras();\n    for (i = 0, l = eras.length; i < l; ++i) {\n      // truncate time\n      val = this.clone().startOf('day').valueOf();\n      if (eras[i].since <= val && val <= eras[i].until) {\n        return eras[i].name;\n      }\n      if (eras[i].until <= val && val <= eras[i].since) {\n        return eras[i].name;\n      }\n    }\n    return '';\n  }\n  function getEraNarrow() {\n    var i,\n      l,\n      val,\n      eras = this.localeData().eras();\n    for (i = 0, l = eras.length; i < l; ++i) {\n      // truncate time\n      val = this.clone().startOf('day').valueOf();\n      if (eras[i].since <= val && val <= eras[i].until) {\n        return eras[i].narrow;\n      }\n      if (eras[i].until <= val && val <= eras[i].since) {\n        return eras[i].narrow;\n      }\n    }\n    return '';\n  }\n  function getEraAbbr() {\n    var i,\n      l,\n      val,\n      eras = this.localeData().eras();\n    for (i = 0, l = eras.length; i < l; ++i) {\n      // truncate time\n      val = this.clone().startOf('day').valueOf();\n      if (eras[i].since <= val && val <= eras[i].until) {\n        return eras[i].abbr;\n      }\n      if (eras[i].until <= val && val <= eras[i].since) {\n        return eras[i].abbr;\n      }\n    }\n    return '';\n  }\n  function getEraYear() {\n    var i,\n      l,\n      dir,\n      val,\n      eras = this.localeData().eras();\n    for (i = 0, l = eras.length; i < l; ++i) {\n      dir = eras[i].since <= eras[i].until ? +1 : -1;\n\n      // truncate time\n      val = this.clone().startOf('day').valueOf();\n      if (eras[i].since <= val && val <= eras[i].until || eras[i].until <= val && val <= eras[i].since) {\n        return (this.year() - hooks(eras[i].since).year()) * dir + eras[i].offset;\n      }\n    }\n    return this.year();\n  }\n  function erasNameRegex(isStrict) {\n    if (!hasOwnProp(this, '_erasNameRegex')) {\n      computeErasParse.call(this);\n    }\n    return isStrict ? this._erasNameRegex : this._erasRegex;\n  }\n  function erasAbbrRegex(isStrict) {\n    if (!hasOwnProp(this, '_erasAbbrRegex')) {\n      computeErasParse.call(this);\n    }\n    return isStrict ? this._erasAbbrRegex : this._erasRegex;\n  }\n  function erasNarrowRegex(isStrict) {\n    if (!hasOwnProp(this, '_erasNarrowRegex')) {\n      computeErasParse.call(this);\n    }\n    return isStrict ? this._erasNarrowRegex : this._erasRegex;\n  }\n  function matchEraAbbr(isStrict, locale) {\n    return locale.erasAbbrRegex(isStrict);\n  }\n  function matchEraName(isStrict, locale) {\n    return locale.erasNameRegex(isStrict);\n  }\n  function matchEraNarrow(isStrict, locale) {\n    return locale.erasNarrowRegex(isStrict);\n  }\n  function matchEraYearOrdinal(isStrict, locale) {\n    return locale._eraYearOrdinalRegex || matchUnsigned;\n  }\n  function computeErasParse() {\n    var abbrPieces = [],\n      namePieces = [],\n      narrowPieces = [],\n      mixedPieces = [],\n      i,\n      l,\n      eras = this.eras();\n    for (i = 0, l = eras.length; i < l; ++i) {\n      namePieces.push(regexEscape(eras[i].name));\n      abbrPieces.push(regexEscape(eras[i].abbr));\n      narrowPieces.push(regexEscape(eras[i].narrow));\n      mixedPieces.push(regexEscape(eras[i].name));\n      mixedPieces.push(regexEscape(eras[i].abbr));\n      mixedPieces.push(regexEscape(eras[i].narrow));\n    }\n    this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i');\n    this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i');\n    this._erasNarrowRegex = new RegExp('^(' + narrowPieces.join('|') + ')', 'i');\n  }\n\n  // FORMATTING\n\n  addFormatToken(0, ['gg', 2], 0, function () {\n    return this.weekYear() % 100;\n  });\n  addFormatToken(0, ['GG', 2], 0, function () {\n    return this.isoWeekYear() % 100;\n  });\n  function addWeekYearFormatToken(token, getter) {\n    addFormatToken(0, [token, token.length], 0, getter);\n  }\n  addWeekYearFormatToken('gggg', 'weekYear');\n  addWeekYearFormatToken('ggggg', 'weekYear');\n  addWeekYearFormatToken('GGGG', 'isoWeekYear');\n  addWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n  // ALIASES\n\n  addUnitAlias('weekYear', 'gg');\n  addUnitAlias('isoWeekYear', 'GG');\n\n  // PRIORITY\n\n  addUnitPriority('weekYear', 1);\n  addUnitPriority('isoWeekYear', 1);\n\n  // PARSING\n\n  addRegexToken('G', matchSigned);\n  addRegexToken('g', matchSigned);\n  addRegexToken('GG', match1to2, match2);\n  addRegexToken('gg', match1to2, match2);\n  addRegexToken('GGGG', match1to4, match4);\n  addRegexToken('gggg', match1to4, match4);\n  addRegexToken('GGGGG', match1to6, match6);\n  addRegexToken('ggggg', match1to6, match6);\n  addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {\n    week[token.substr(0, 2)] = toInt(input);\n  });\n  addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n    week[token] = hooks.parseTwoDigitYear(input);\n  });\n\n  // MOMENTS\n\n  function getSetWeekYear(input) {\n    return getSetWeekYearHelper.call(this, input, this.week(), this.weekday(), this.localeData()._week.dow, this.localeData()._week.doy);\n  }\n  function getSetISOWeekYear(input) {\n    return getSetWeekYearHelper.call(this, input, this.isoWeek(), this.isoWeekday(), 1, 4);\n  }\n  function getISOWeeksInYear() {\n    return weeksInYear(this.year(), 1, 4);\n  }\n  function getISOWeeksInISOWeekYear() {\n    return weeksInYear(this.isoWeekYear(), 1, 4);\n  }\n  function getWeeksInYear() {\n    var weekInfo = this.localeData()._week;\n    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n  }\n  function getWeeksInWeekYear() {\n    var weekInfo = this.localeData()._week;\n    return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);\n  }\n  function getSetWeekYearHelper(input, week, weekday, dow, doy) {\n    var weeksTarget;\n    if (input == null) {\n      return weekOfYear(this, dow, doy).year;\n    } else {\n      weeksTarget = weeksInYear(input, dow, doy);\n      if (week > weeksTarget) {\n        week = weeksTarget;\n      }\n      return setWeekAll.call(this, input, week, weekday, dow, doy);\n    }\n  }\n  function setWeekAll(weekYear, week, weekday, dow, doy) {\n    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),\n      date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);\n    this.year(date.getUTCFullYear());\n    this.month(date.getUTCMonth());\n    this.date(date.getUTCDate());\n    return this;\n  }\n\n  // FORMATTING\n\n  addFormatToken('Q', 0, 'Qo', 'quarter');\n\n  // ALIASES\n\n  addUnitAlias('quarter', 'Q');\n\n  // PRIORITY\n\n  addUnitPriority('quarter', 7);\n\n  // PARSING\n\n  addRegexToken('Q', match1);\n  addParseToken('Q', function (input, array) {\n    array[MONTH] = (toInt(input) - 1) * 3;\n  });\n\n  // MOMENTS\n\n  function getSetQuarter(input) {\n    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);\n  }\n\n  // FORMATTING\n\n  addFormatToken('D', ['DD', 2], 'Do', 'date');\n\n  // ALIASES\n\n  addUnitAlias('date', 'D');\n\n  // PRIORITY\n  addUnitPriority('date', 9);\n\n  // PARSING\n\n  addRegexToken('D', match1to2);\n  addRegexToken('DD', match1to2, match2);\n  addRegexToken('Do', function (isStrict, locale) {\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    return isStrict ? locale._dayOfMonthOrdinalParse || locale._ordinalParse : locale._dayOfMonthOrdinalParseLenient;\n  });\n  addParseToken(['D', 'DD'], DATE);\n  addParseToken('Do', function (input, array) {\n    array[DATE] = toInt(input.match(match1to2)[0]);\n  });\n\n  // MOMENTS\n\n  var getSetDayOfMonth = makeGetSet('Date', true);\n\n  // FORMATTING\n\n  addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n  // ALIASES\n\n  addUnitAlias('dayOfYear', 'DDD');\n\n  // PRIORITY\n  addUnitPriority('dayOfYear', 4);\n\n  // PARSING\n\n  addRegexToken('DDD', match1to3);\n  addRegexToken('DDDD', match3);\n  addParseToken(['DDD', 'DDDD'], function (input, array, config) {\n    config._dayOfYear = toInt(input);\n  });\n\n  // HELPERS\n\n  // MOMENTS\n\n  function getSetDayOfYear(input) {\n    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;\n    return input == null ? dayOfYear : this.add(input - dayOfYear, 'd');\n  }\n\n  // FORMATTING\n\n  addFormatToken('m', ['mm', 2], 0, 'minute');\n\n  // ALIASES\n\n  addUnitAlias('minute', 'm');\n\n  // PRIORITY\n\n  addUnitPriority('minute', 14);\n\n  // PARSING\n\n  addRegexToken('m', match1to2);\n  addRegexToken('mm', match1to2, match2);\n  addParseToken(['m', 'mm'], MINUTE);\n\n  // MOMENTS\n\n  var getSetMinute = makeGetSet('Minutes', false);\n\n  // FORMATTING\n\n  addFormatToken('s', ['ss', 2], 0, 'second');\n\n  // ALIASES\n\n  addUnitAlias('second', 's');\n\n  // PRIORITY\n\n  addUnitPriority('second', 15);\n\n  // PARSING\n\n  addRegexToken('s', match1to2);\n  addRegexToken('ss', match1to2, match2);\n  addParseToken(['s', 'ss'], SECOND);\n\n  // MOMENTS\n\n  var getSetSecond = makeGetSet('Seconds', false);\n\n  // FORMATTING\n\n  addFormatToken('S', 0, 0, function () {\n    return ~~(this.millisecond() / 100);\n  });\n  addFormatToken(0, ['SS', 2], 0, function () {\n    return ~~(this.millisecond() / 10);\n  });\n  addFormatToken(0, ['SSS', 3], 0, 'millisecond');\n  addFormatToken(0, ['SSSS', 4], 0, function () {\n    return this.millisecond() * 10;\n  });\n  addFormatToken(0, ['SSSSS', 5], 0, function () {\n    return this.millisecond() * 100;\n  });\n  addFormatToken(0, ['SSSSSS', 6], 0, function () {\n    return this.millisecond() * 1000;\n  });\n  addFormatToken(0, ['SSSSSSS', 7], 0, function () {\n    return this.millisecond() * 10000;\n  });\n  addFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n    return this.millisecond() * 100000;\n  });\n  addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n    return this.millisecond() * 1000000;\n  });\n\n  // ALIASES\n\n  addUnitAlias('millisecond', 'ms');\n\n  // PRIORITY\n\n  addUnitPriority('millisecond', 16);\n\n  // PARSING\n\n  addRegexToken('S', match1to3, match1);\n  addRegexToken('SS', match1to3, match2);\n  addRegexToken('SSS', match1to3, match3);\n  var token, getSetMillisecond;\n  for (token = 'SSSS'; token.length <= 9; token += 'S') {\n    addRegexToken(token, matchUnsigned);\n  }\n  function parseMs(input, array) {\n    array[MILLISECOND] = toInt(('0.' + input) * 1000);\n  }\n  for (token = 'S'; token.length <= 9; token += 'S') {\n    addParseToken(token, parseMs);\n  }\n  getSetMillisecond = makeGetSet('Milliseconds', false);\n\n  // FORMATTING\n\n  addFormatToken('z', 0, 0, 'zoneAbbr');\n  addFormatToken('zz', 0, 0, 'zoneName');\n\n  // MOMENTS\n\n  function getZoneAbbr() {\n    return this._isUTC ? 'UTC' : '';\n  }\n  function getZoneName() {\n    return this._isUTC ? 'Coordinated Universal Time' : '';\n  }\n  var proto = Moment.prototype;\n  proto.add = add;\n  proto.calendar = calendar$1;\n  proto.clone = clone;\n  proto.diff = diff;\n  proto.endOf = endOf;\n  proto.format = format;\n  proto.from = from;\n  proto.fromNow = fromNow;\n  proto.to = to;\n  proto.toNow = toNow;\n  proto.get = stringGet;\n  proto.invalidAt = invalidAt;\n  proto.isAfter = isAfter;\n  proto.isBefore = isBefore;\n  proto.isBetween = isBetween;\n  proto.isSame = isSame;\n  proto.isSameOrAfter = isSameOrAfter;\n  proto.isSameOrBefore = isSameOrBefore;\n  proto.isValid = isValid$2;\n  proto.lang = lang;\n  proto.locale = locale;\n  proto.localeData = localeData;\n  proto.max = prototypeMax;\n  proto.min = prototypeMin;\n  proto.parsingFlags = parsingFlags;\n  proto.set = stringSet;\n  proto.startOf = startOf;\n  proto.subtract = subtract;\n  proto.toArray = toArray;\n  proto.toObject = toObject;\n  proto.toDate = toDate;\n  proto.toISOString = toISOString;\n  proto.inspect = inspect;\n  if (typeof Symbol !== 'undefined' && Symbol.for != null) {\n    proto[Symbol.for('nodejs.util.inspect.custom')] = function () {\n      return 'Moment<' + this.format() + '>';\n    };\n  }\n  proto.toJSON = toJSON;\n  proto.toString = toString;\n  proto.unix = unix;\n  proto.valueOf = valueOf;\n  proto.creationData = creationData;\n  proto.eraName = getEraName;\n  proto.eraNarrow = getEraNarrow;\n  proto.eraAbbr = getEraAbbr;\n  proto.eraYear = getEraYear;\n  proto.year = getSetYear;\n  proto.isLeapYear = getIsLeapYear;\n  proto.weekYear = getSetWeekYear;\n  proto.isoWeekYear = getSetISOWeekYear;\n  proto.quarter = proto.quarters = getSetQuarter;\n  proto.month = getSetMonth;\n  proto.daysInMonth = getDaysInMonth;\n  proto.week = proto.weeks = getSetWeek;\n  proto.isoWeek = proto.isoWeeks = getSetISOWeek;\n  proto.weeksInYear = getWeeksInYear;\n  proto.weeksInWeekYear = getWeeksInWeekYear;\n  proto.isoWeeksInYear = getISOWeeksInYear;\n  proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;\n  proto.date = getSetDayOfMonth;\n  proto.day = proto.days = getSetDayOfWeek;\n  proto.weekday = getSetLocaleDayOfWeek;\n  proto.isoWeekday = getSetISODayOfWeek;\n  proto.dayOfYear = getSetDayOfYear;\n  proto.hour = proto.hours = getSetHour;\n  proto.minute = proto.minutes = getSetMinute;\n  proto.second = proto.seconds = getSetSecond;\n  proto.millisecond = proto.milliseconds = getSetMillisecond;\n  proto.utcOffset = getSetOffset;\n  proto.utc = setOffsetToUTC;\n  proto.local = setOffsetToLocal;\n  proto.parseZone = setOffsetToParsedOffset;\n  proto.hasAlignedHourOffset = hasAlignedHourOffset;\n  proto.isDST = isDaylightSavingTime;\n  proto.isLocal = isLocal;\n  proto.isUtcOffset = isUtcOffset;\n  proto.isUtc = isUtc;\n  proto.isUTC = isUtc;\n  proto.zoneAbbr = getZoneAbbr;\n  proto.zoneName = getZoneName;\n  proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);\n  proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);\n  proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);\n  proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);\n  proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);\n  function createUnix(input) {\n    return createLocal(input * 1000);\n  }\n  function createInZone() {\n    return createLocal.apply(null, arguments).parseZone();\n  }\n  function preParsePostFormat(string) {\n    return string;\n  }\n  var proto$1 = Locale.prototype;\n  proto$1.calendar = calendar;\n  proto$1.longDateFormat = longDateFormat;\n  proto$1.invalidDate = invalidDate;\n  proto$1.ordinal = ordinal;\n  proto$1.preparse = preParsePostFormat;\n  proto$1.postformat = preParsePostFormat;\n  proto$1.relativeTime = relativeTime;\n  proto$1.pastFuture = pastFuture;\n  proto$1.set = set;\n  proto$1.eras = localeEras;\n  proto$1.erasParse = localeErasParse;\n  proto$1.erasConvertYear = localeErasConvertYear;\n  proto$1.erasAbbrRegex = erasAbbrRegex;\n  proto$1.erasNameRegex = erasNameRegex;\n  proto$1.erasNarrowRegex = erasNarrowRegex;\n  proto$1.months = localeMonths;\n  proto$1.monthsShort = localeMonthsShort;\n  proto$1.monthsParse = localeMonthsParse;\n  proto$1.monthsRegex = monthsRegex;\n  proto$1.monthsShortRegex = monthsShortRegex;\n  proto$1.week = localeWeek;\n  proto$1.firstDayOfYear = localeFirstDayOfYear;\n  proto$1.firstDayOfWeek = localeFirstDayOfWeek;\n  proto$1.weekdays = localeWeekdays;\n  proto$1.weekdaysMin = localeWeekdaysMin;\n  proto$1.weekdaysShort = localeWeekdaysShort;\n  proto$1.weekdaysParse = localeWeekdaysParse;\n  proto$1.weekdaysRegex = weekdaysRegex;\n  proto$1.weekdaysShortRegex = weekdaysShortRegex;\n  proto$1.weekdaysMinRegex = weekdaysMinRegex;\n  proto$1.isPM = localeIsPM;\n  proto$1.meridiem = localeMeridiem;\n  function get$1(format, index, field, setter) {\n    var locale = getLocale(),\n      utc = createUTC().set(setter, index);\n    return locale[field](utc, format);\n  }\n  function listMonthsImpl(format, index, field) {\n    if (isNumber(format)) {\n      index = format;\n      format = undefined;\n    }\n    format = format || '';\n    if (index != null) {\n      return get$1(format, index, field, 'month');\n    }\n    var i,\n      out = [];\n    for (i = 0; i < 12; i++) {\n      out[i] = get$1(format, i, field, 'month');\n    }\n    return out;\n  }\n\n  // ()\n  // (5)\n  // (fmt, 5)\n  // (fmt)\n  // (true)\n  // (true, 5)\n  // (true, fmt, 5)\n  // (true, fmt)\n  function listWeekdaysImpl(localeSorted, format, index, field) {\n    if (typeof localeSorted === 'boolean') {\n      if (isNumber(format)) {\n        index = format;\n        format = undefined;\n      }\n      format = format || '';\n    } else {\n      format = localeSorted;\n      index = format;\n      localeSorted = false;\n      if (isNumber(format)) {\n        index = format;\n        format = undefined;\n      }\n      format = format || '';\n    }\n    var locale = getLocale(),\n      shift = localeSorted ? locale._week.dow : 0,\n      i,\n      out = [];\n    if (index != null) {\n      return get$1(format, (index + shift) % 7, field, 'day');\n    }\n    for (i = 0; i < 7; i++) {\n      out[i] = get$1(format, (i + shift) % 7, field, 'day');\n    }\n    return out;\n  }\n  function listMonths(format, index) {\n    return listMonthsImpl(format, index, 'months');\n  }\n  function listMonthsShort(format, index) {\n    return listMonthsImpl(format, index, 'monthsShort');\n  }\n  function listWeekdays(localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n  }\n  function listWeekdaysShort(localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n  }\n  function listWeekdaysMin(localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n  }\n  getSetGlobalLocale('en', {\n    eras: [{\n      since: '0001-01-01',\n      until: +Infinity,\n      offset: 1,\n      name: 'Anno Domini',\n      narrow: 'AD',\n      abbr: 'AD'\n    }, {\n      since: '0000-12-31',\n      until: -Infinity,\n      offset: 1,\n      name: 'Before Christ',\n      narrow: 'BC',\n      abbr: 'BC'\n    }],\n    dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n    ordinal: function (number) {\n      var b = number % 10,\n        output = toInt(number % 100 / 10) === 1 ? 'th' : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';\n      return number + output;\n    }\n  });\n\n  // Side effect imports\n\n  hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);\n  hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);\n  var mathAbs = Math.abs;\n  function abs() {\n    var data = this._data;\n    this._milliseconds = mathAbs(this._milliseconds);\n    this._days = mathAbs(this._days);\n    this._months = mathAbs(this._months);\n    data.milliseconds = mathAbs(data.milliseconds);\n    data.seconds = mathAbs(data.seconds);\n    data.minutes = mathAbs(data.minutes);\n    data.hours = mathAbs(data.hours);\n    data.months = mathAbs(data.months);\n    data.years = mathAbs(data.years);\n    return this;\n  }\n  function addSubtract$1(duration, input, value, direction) {\n    var other = createDuration(input, value);\n    duration._milliseconds += direction * other._milliseconds;\n    duration._days += direction * other._days;\n    duration._months += direction * other._months;\n    return duration._bubble();\n  }\n\n  // supports only 2.0-style add(1, 's') or add(duration)\n  function add$1(input, value) {\n    return addSubtract$1(this, input, value, 1);\n  }\n\n  // supports only 2.0-style subtract(1, 's') or subtract(duration)\n  function subtract$1(input, value) {\n    return addSubtract$1(this, input, value, -1);\n  }\n  function absCeil(number) {\n    if (number < 0) {\n      return Math.floor(number);\n    } else {\n      return Math.ceil(number);\n    }\n  }\n  function bubble() {\n    var milliseconds = this._milliseconds,\n      days = this._days,\n      months = this._months,\n      data = this._data,\n      seconds,\n      minutes,\n      hours,\n      years,\n      monthsFromDays;\n\n    // if we have a mix of positive and negative values, bubble down first\n    // check: https://github.com/moment/moment/issues/2166\n    if (!(milliseconds >= 0 && days >= 0 && months >= 0 || milliseconds <= 0 && days <= 0 && months <= 0)) {\n      milliseconds += absCeil(monthsToDays(months) + days) * 864e5;\n      days = 0;\n      months = 0;\n    }\n\n    // The following code bubbles up values, see the tests for\n    // examples of what that means.\n    data.milliseconds = milliseconds % 1000;\n    seconds = absFloor(milliseconds / 1000);\n    data.seconds = seconds % 60;\n    minutes = absFloor(seconds / 60);\n    data.minutes = minutes % 60;\n    hours = absFloor(minutes / 60);\n    data.hours = hours % 24;\n    days += absFloor(hours / 24);\n\n    // convert days to months\n    monthsFromDays = absFloor(daysToMonths(days));\n    months += monthsFromDays;\n    days -= absCeil(monthsToDays(monthsFromDays));\n\n    // 12 months -> 1 year\n    years = absFloor(months / 12);\n    months %= 12;\n    data.days = days;\n    data.months = months;\n    data.years = years;\n    return this;\n  }\n  function daysToMonths(days) {\n    // 400 years have 146097 days (taking into account leap year rules)\n    // 400 years have 12 months === 4800\n    return days * 4800 / 146097;\n  }\n  function monthsToDays(months) {\n    // the reverse of daysToMonths\n    return months * 146097 / 4800;\n  }\n  function as(units) {\n    if (!this.isValid()) {\n      return NaN;\n    }\n    var days,\n      months,\n      milliseconds = this._milliseconds;\n    units = normalizeUnits(units);\n    if (units === 'month' || units === 'quarter' || units === 'year') {\n      days = this._days + milliseconds / 864e5;\n      months = this._months + daysToMonths(days);\n      switch (units) {\n        case 'month':\n          return months;\n        case 'quarter':\n          return months / 3;\n        case 'year':\n          return months / 12;\n      }\n    } else {\n      // handle milliseconds separately because of floating point math errors (issue #1867)\n      days = this._days + Math.round(monthsToDays(this._months));\n      switch (units) {\n        case 'week':\n          return days / 7 + milliseconds / 6048e5;\n        case 'day':\n          return days + milliseconds / 864e5;\n        case 'hour':\n          return days * 24 + milliseconds / 36e5;\n        case 'minute':\n          return days * 1440 + milliseconds / 6e4;\n        case 'second':\n          return days * 86400 + milliseconds / 1000;\n        // Math.floor prevents floating point math errors here\n        case 'millisecond':\n          return Math.floor(days * 864e5) + milliseconds;\n        default:\n          throw new Error('Unknown unit ' + units);\n      }\n    }\n  }\n\n  // TODO: Use this.as('ms')?\n  function valueOf$1() {\n    if (!this.isValid()) {\n      return NaN;\n    }\n    return this._milliseconds + this._days * 864e5 + this._months % 12 * 2592e6 + toInt(this._months / 12) * 31536e6;\n  }\n  function makeAs(alias) {\n    return function () {\n      return this.as(alias);\n    };\n  }\n  var asMilliseconds = makeAs('ms'),\n    asSeconds = makeAs('s'),\n    asMinutes = makeAs('m'),\n    asHours = makeAs('h'),\n    asDays = makeAs('d'),\n    asWeeks = makeAs('w'),\n    asMonths = makeAs('M'),\n    asQuarters = makeAs('Q'),\n    asYears = makeAs('y');\n  function clone$1() {\n    return createDuration(this);\n  }\n  function get$2(units) {\n    units = normalizeUnits(units);\n    return this.isValid() ? this[units + 's']() : NaN;\n  }\n  function makeGetter(name) {\n    return function () {\n      return this.isValid() ? this._data[name] : NaN;\n    };\n  }\n  var milliseconds = makeGetter('milliseconds'),\n    seconds = makeGetter('seconds'),\n    minutes = makeGetter('minutes'),\n    hours = makeGetter('hours'),\n    days = makeGetter('days'),\n    months = makeGetter('months'),\n    years = makeGetter('years');\n  function weeks() {\n    return absFloor(this.days() / 7);\n  }\n  var round = Math.round,\n    thresholds = {\n      ss: 44,\n      // a few seconds to seconds\n      s: 45,\n      // seconds to minute\n      m: 45,\n      // minutes to hour\n      h: 22,\n      // hours to day\n      d: 26,\n      // days to month/week\n      w: null,\n      // weeks to month\n      M: 11 // months to year\n    };\n\n  // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\n  function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n  }\n  function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {\n    var duration = createDuration(posNegDuration).abs(),\n      seconds = round(duration.as('s')),\n      minutes = round(duration.as('m')),\n      hours = round(duration.as('h')),\n      days = round(duration.as('d')),\n      months = round(duration.as('M')),\n      weeks = round(duration.as('w')),\n      years = round(duration.as('y')),\n      a = seconds <= thresholds.ss && ['s', seconds] || seconds < thresholds.s && ['ss', seconds] || minutes <= 1 && ['m'] || minutes < thresholds.m && ['mm', minutes] || hours <= 1 && ['h'] || hours < thresholds.h && ['hh', hours] || days <= 1 && ['d'] || days < thresholds.d && ['dd', days];\n    if (thresholds.w != null) {\n      a = a || weeks <= 1 && ['w'] || weeks < thresholds.w && ['ww', weeks];\n    }\n    a = a || months <= 1 && ['M'] || months < thresholds.M && ['MM', months] || years <= 1 && ['y'] || ['yy', years];\n    a[2] = withoutSuffix;\n    a[3] = +posNegDuration > 0;\n    a[4] = locale;\n    return substituteTimeAgo.apply(null, a);\n  }\n\n  // This function allows you to set the rounding function for relative time strings\n  function getSetRelativeTimeRounding(roundingFunction) {\n    if (roundingFunction === undefined) {\n      return round;\n    }\n    if (typeof roundingFunction === 'function') {\n      round = roundingFunction;\n      return true;\n    }\n    return false;\n  }\n\n  // This function allows you to set a threshold for relative time strings\n  function getSetRelativeTimeThreshold(threshold, limit) {\n    if (thresholds[threshold] === undefined) {\n      return false;\n    }\n    if (limit === undefined) {\n      return thresholds[threshold];\n    }\n    thresholds[threshold] = limit;\n    if (threshold === 's') {\n      thresholds.ss = limit - 1;\n    }\n    return true;\n  }\n  function humanize(argWithSuffix, argThresholds) {\n    if (!this.isValid()) {\n      return this.localeData().invalidDate();\n    }\n    var withSuffix = false,\n      th = thresholds,\n      locale,\n      output;\n    if (typeof argWithSuffix === 'object') {\n      argThresholds = argWithSuffix;\n      argWithSuffix = false;\n    }\n    if (typeof argWithSuffix === 'boolean') {\n      withSuffix = argWithSuffix;\n    }\n    if (typeof argThresholds === 'object') {\n      th = Object.assign({}, thresholds, argThresholds);\n      if (argThresholds.s != null && argThresholds.ss == null) {\n        th.ss = argThresholds.s - 1;\n      }\n    }\n    locale = this.localeData();\n    output = relativeTime$1(this, !withSuffix, th, locale);\n    if (withSuffix) {\n      output = locale.pastFuture(+this, output);\n    }\n    return locale.postformat(output);\n  }\n  var abs$1 = Math.abs;\n  function sign(x) {\n    return (x > 0) - (x < 0) || +x;\n  }\n  function toISOString$1() {\n    // for ISO strings we do not use the normal bubbling rules:\n    //  * milliseconds bubble up until they become hours\n    //  * days do not bubble at all\n    //  * months bubble up until they become years\n    // This is because there is no context-free conversion between hours and days\n    // (think of clock changes)\n    // and also not between days and months (28-31 days per month)\n    if (!this.isValid()) {\n      return this.localeData().invalidDate();\n    }\n    var seconds = abs$1(this._milliseconds) / 1000,\n      days = abs$1(this._days),\n      months = abs$1(this._months),\n      minutes,\n      hours,\n      years,\n      s,\n      total = this.asSeconds(),\n      totalSign,\n      ymSign,\n      daysSign,\n      hmsSign;\n    if (!total) {\n      // this is the same as C#'s (Noda) and python (isodate)...\n      // but not other JS (goog.date)\n      return 'P0D';\n    }\n\n    // 3600 seconds -> 60 minutes -> 1 hour\n    minutes = absFloor(seconds / 60);\n    hours = absFloor(minutes / 60);\n    seconds %= 60;\n    minutes %= 60;\n\n    // 12 months -> 1 year\n    years = absFloor(months / 12);\n    months %= 12;\n\n    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js\n    s = seconds ? seconds.toFixed(3).replace(/\\.?0+$/, '') : '';\n    totalSign = total < 0 ? '-' : '';\n    ymSign = sign(this._months) !== sign(total) ? '-' : '';\n    daysSign = sign(this._days) !== sign(total) ? '-' : '';\n    hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';\n    return totalSign + 'P' + (years ? ymSign + years + 'Y' : '') + (months ? ymSign + months + 'M' : '') + (days ? daysSign + days + 'D' : '') + (hours || minutes || seconds ? 'T' : '') + (hours ? hmsSign + hours + 'H' : '') + (minutes ? hmsSign + minutes + 'M' : '') + (seconds ? hmsSign + s + 'S' : '');\n  }\n  var proto$2 = Duration.prototype;\n  proto$2.isValid = isValid$1;\n  proto$2.abs = abs;\n  proto$2.add = add$1;\n  proto$2.subtract = subtract$1;\n  proto$2.as = as;\n  proto$2.asMilliseconds = asMilliseconds;\n  proto$2.asSeconds = asSeconds;\n  proto$2.asMinutes = asMinutes;\n  proto$2.asHours = asHours;\n  proto$2.asDays = asDays;\n  proto$2.asWeeks = asWeeks;\n  proto$2.asMonths = asMonths;\n  proto$2.asQuarters = asQuarters;\n  proto$2.asYears = asYears;\n  proto$2.valueOf = valueOf$1;\n  proto$2._bubble = bubble;\n  proto$2.clone = clone$1;\n  proto$2.get = get$2;\n  proto$2.milliseconds = milliseconds;\n  proto$2.seconds = seconds;\n  proto$2.minutes = minutes;\n  proto$2.hours = hours;\n  proto$2.days = days;\n  proto$2.weeks = weeks;\n  proto$2.months = months;\n  proto$2.years = years;\n  proto$2.humanize = humanize;\n  proto$2.toISOString = toISOString$1;\n  proto$2.toString = toISOString$1;\n  proto$2.toJSON = toISOString$1;\n  proto$2.locale = locale;\n  proto$2.localeData = localeData;\n  proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);\n  proto$2.lang = lang;\n\n  // FORMATTING\n\n  addFormatToken('X', 0, 0, 'unix');\n  addFormatToken('x', 0, 0, 'valueOf');\n\n  // PARSING\n\n  addRegexToken('x', matchSigned);\n  addRegexToken('X', matchTimestamp);\n  addParseToken('X', function (input, array, config) {\n    config._d = new Date(parseFloat(input) * 1000);\n  });\n  addParseToken('x', function (input, array, config) {\n    config._d = new Date(toInt(input));\n  });\n\n  //! moment.js\n\n  hooks.version = '2.29.4';\n  setHookCallback(createLocal);\n  hooks.fn = proto;\n  hooks.min = min;\n  hooks.max = max;\n  hooks.now = now;\n  hooks.utc = createUTC;\n  hooks.unix = createUnix;\n  hooks.months = listMonths;\n  hooks.isDate = isDate;\n  hooks.locale = getSetGlobalLocale;\n  hooks.invalid = createInvalid;\n  hooks.duration = createDuration;\n  hooks.isMoment = isMoment;\n  hooks.weekdays = listWeekdays;\n  hooks.parseZone = createInZone;\n  hooks.localeData = getLocale;\n  hooks.isDuration = isDuration;\n  hooks.monthsShort = listMonthsShort;\n  hooks.weekdaysMin = listWeekdaysMin;\n  hooks.defineLocale = defineLocale;\n  hooks.updateLocale = updateLocale;\n  hooks.locales = listLocales;\n  hooks.weekdaysShort = listWeekdaysShort;\n  hooks.normalizeUnits = normalizeUnits;\n  hooks.relativeTimeRounding = getSetRelativeTimeRounding;\n  hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\n  hooks.calendarFormat = getCalendarFormat;\n  hooks.prototype = proto;\n\n  // currently HTML5 input type only supports 24-hour formats\n  hooks.HTML5_FMT = {\n    DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm',\n    // <input type=\"datetime-local\" />\n    DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss',\n    // <input type=\"datetime-local\" step=\"1\" />\n    DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS',\n    // <input type=\"datetime-local\" step=\"0.001\" />\n    DATE: 'YYYY-MM-DD',\n    // <input type=\"date\" />\n    TIME: 'HH:mm',\n    // <input type=\"time\" />\n    TIME_SECONDS: 'HH:mm:ss',\n    // <input type=\"time\" step=\"1\" />\n    TIME_MS: 'HH:mm:ss.SSS',\n    // <input type=\"time\" step=\"0.001\" />\n    WEEK: 'GGGG-[W]WW',\n    // <input type=\"week\" />\n    MONTH: 'YYYY-MM' // <input type=\"month\" />\n  };\n\n  return hooks;\n});","export const VOID = -1;\nexport const PRIMITIVE = 0;\nexport const ARRAY = 1;\nexport const OBJECT = 2;\nexport const DATE = 3;\nexport const REGEXP = 4;\nexport const MAP = 5;\nexport const SET = 6;\nexport const ERROR = 7;\nexport const BIGINT = 8;\n// export const SYMBOL = 9;","import { VOID, PRIMITIVE, ARRAY, OBJECT, DATE, REGEXP, MAP, SET, ERROR, BIGINT } from './types.js';\nconst env = typeof self === 'object' ? self : globalThis;\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n  const unpair = index => {\n    if ($.has(index)) return $.get(index);\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY:\n        {\n          const arr = as([], index);\n          for (const index of value) arr.push(unpair(index));\n          return arr;\n        }\n      case OBJECT:\n        {\n          const object = as({}, index);\n          for (const [key, index] of value) object[unpair(key)] = unpair(index);\n          return object;\n        }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP:\n        {\n          const {\n            source,\n            flags\n          } = value;\n          return as(new RegExp(source, flags), index);\n        }\n      case MAP:\n        {\n          const map = as(new Map(), index);\n          for (const [key, index] of value) map.set(unpair(key), unpair(index));\n          return map;\n        }\n      case SET:\n        {\n          const set = as(new Set(), index);\n          for (const index of value) set.add(unpair(index));\n          return set;\n        }\n      case ERROR:\n        {\n          const {\n            name,\n            message\n          } = value;\n          return as(new env[name](message), index);\n        }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n    }\n    return as(new env[type](value), index);\n  };\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map(), serialized)(0);","import { VOID, PRIMITIVE, ARRAY, OBJECT, DATE, REGEXP, MAP, SET, ERROR, BIGINT } from './types.js';\nconst EMPTY = '';\nconst {\n  toString\n} = {};\nconst {\n  keys\n} = Object;\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value) return [PRIMITIVE, type];\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n  }\n  if (asString.includes('Array')) return [ARRAY, asString];\n  if (asString.includes('Error')) return [ERROR, asString];\n  return [OBJECT, asString];\n};\nconst shouldSkip = _ref => {\n  let [TYPE, type] = _ref;\n  return TYPE === PRIMITIVE && (type === 'function' || type === 'symbol');\n};\nconst serializer = (strict, json, $, _) => {\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n  const pair = value => {\n    if ($.has(value)) return $.get(value);\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE:\n        {\n          let entry = value;\n          switch (type) {\n            case 'bigint':\n              TYPE = BIGINT;\n              entry = value.toString();\n              break;\n            case 'function':\n            case 'symbol':\n              if (strict) throw new TypeError('unable to serialize ' + type);\n              entry = null;\n              break;\n            case 'undefined':\n              return as([VOID], value);\n          }\n          return as([TYPE, entry], value);\n        }\n      case ARRAY:\n        {\n          if (type) return as([type, [...value]], value);\n          const arr = [];\n          const index = as([TYPE, arr], value);\n          for (const entry of value) arr.push(pair(entry));\n          return index;\n        }\n      case OBJECT:\n        {\n          if (type) {\n            switch (type) {\n              case 'BigInt':\n                return as([type, value.toString()], value);\n              case 'Boolean':\n              case 'Number':\n              case 'String':\n                return as([type, value.valueOf()], value);\n            }\n          }\n          if (json && 'toJSON' in value) return pair(value.toJSON());\n          const entries = [];\n          const index = as([TYPE, entries], value);\n          for (const key of keys(value)) {\n            if (strict || !shouldSkip(typeOf(value[key]))) entries.push([pair(key), pair(value[key])]);\n          }\n          return index;\n        }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP:\n        {\n          const {\n            source,\n            flags\n          } = value;\n          return as([TYPE, {\n            source,\n            flags\n          }], value);\n        }\n      case MAP:\n        {\n          const entries = [];\n          const index = as([TYPE, entries], value);\n          for (const [key, entry] of value) {\n            if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry)))) entries.push([pair(key), pair(entry)]);\n          }\n          return index;\n        }\n      case SET:\n        {\n          const entries = [];\n          const index = as([TYPE, entries], value);\n          for (const entry of value) {\n            if (strict || !shouldSkip(typeOf(entry))) entries.push(pair(entry));\n          }\n          return index;\n        }\n    }\n    const {\n      message\n    } = value;\n    return as([TYPE, {\n      name: type,\n      message\n    }], value);\n  };\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\nexport const serialize = function (value) {\n  let {\n    json,\n    lossy\n  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map(), _)(value), _;\n};","import { deserialize } from './deserialize.js';\nimport { serialize } from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ? /* c8 ignore start */\n(any, options) => options && ('json' in options || 'lossy' in options) ? deserialize(serialize(any, options)) : structuredClone(any) : (any, options) => deserialize(serialize(any, options));\n/* c8 ignore stop */\n\nexport { deserialize, serialize };","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n */\n\n/**\n * @template {string} SimpleSelector\n *   Selector type.\n * @template {string} DefaultTagName\n *   Default tag name.\n * @typedef {(\n *   SimpleSelector extends ''\n *     ? DefaultTagName\n *     : SimpleSelector extends `${infer TagName}.${infer Rest}`\n *     ? ExtractTagName<TagName, DefaultTagName>\n *     : SimpleSelector extends `${infer TagName}#${infer Rest}`\n *     ? ExtractTagName<TagName, DefaultTagName>\n *     : SimpleSelector extends string\n *     ? SimpleSelector\n *     : DefaultTagName\n * )} ExtractTagName\n *   Extract tag name from a simple selector.\n */\n\nconst search = /[#.]/g;\n\n/**\n * Create a hast element from a simple CSS selector.\n *\n * @template {string} Selector\n *   Type of selector.\n * @template {string} [DefaultTagName='div']\n *   Type of default tag name (default: `'div'`).\n * @param {Selector | null | undefined} [selector]\n *   Simple CSS selector (optional).\n *\n *   Can contain a tag name (`foo`), classes (`.bar`), and an ID (`#baz`).\n *   Multiple classes are allowed.\n *   Uses the last ID if multiple IDs are found.\n * @param {DefaultTagName | null | undefined} [defaultTagName='div']\n *   Tag name to use if `selector` does not specify one (default: `'div'`).\n * @returns {Element & {tagName: ExtractTagName<Selector, DefaultTagName>}}\n *   Built element.\n */\nexport function parseSelector(selector, defaultTagName) {\n  const value = selector || '';\n  /** @type {Properties} */\n  const props = {};\n  let start = 0;\n  /** @type {string | undefined} */\n  let previous;\n  /** @type {string | undefined} */\n  let tagName;\n  while (start < value.length) {\n    search.lastIndex = start;\n    const match = search.exec(value);\n    const subvalue = value.slice(start, match ? match.index : value.length);\n    if (subvalue) {\n      if (!previous) {\n        tagName = subvalue;\n      } else if (previous === '#') {\n        props.id = subvalue;\n      } else if (Array.isArray(props.className)) {\n        props.className.push(subvalue);\n      } else {\n        props.className = [subvalue];\n      }\n      start += subvalue.length;\n    }\n    if (match) {\n      previous = match[0];\n      start++;\n    }\n  }\n  return {\n    type: 'element',\n    // @ts-expect-error: tag name is parsed.\n    tagName: tagName || defaultTagName || 'div',\n    properties: props,\n    children: []\n  };\n}","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n *\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n */\n\n/**\n * @typedef {Element | Root} Result\n *   Result from a `h` (or `s`) call.\n *\n * @typedef {number | string} StyleValue\n *   Value for a CSS style field.\n * @typedef {Record<string, StyleValue>} Style\n *   Supported value of a `style` prop.\n * @typedef {boolean | number | string | null | undefined} PrimitiveValue\n *   Primitive property value.\n * @typedef {Array<number | string>} ArrayValue\n *   List of property values for space- or comma separated values (such as `className`).\n * @typedef {ArrayValue | PrimitiveValue} PropertyValue\n *   Primitive value or list value.\n * @typedef {{[property: string]: PropertyValue | Style}} Properties\n *   Acceptable value for element properties.\n *\n * @typedef {number | string | null | undefined} PrimitiveChild\n *   Primitive children, either ignored (nullish), or turned into text nodes.\n * @typedef {Array<ArrayChildNested | Nodes | PrimitiveChild>} ArrayChild\n *   List of children.\n * @typedef {Array<Nodes | PrimitiveChild>} ArrayChildNested\n *   List of children (deep).\n * @typedef {ArrayChild | Nodes | PrimitiveChild} Child\n *   Acceptable child value.\n */\n\nimport { parse as commas } from 'comma-separated-tokens';\nimport { parseSelector } from 'hast-util-parse-selector';\nimport { find, normalize } from 'property-information';\nimport { parse as spaces } from 'space-separated-tokens';\nconst buttonTypes = new Set(['button', 'menu', 'reset', 'submit']);\nconst own = {}.hasOwnProperty;\n\n/**\n * @param {Schema} schema\n *   Schema to use.\n * @param {string} defaultTagName\n *   Default tag name.\n * @param {Array<string> | undefined} [caseSensitive]\n *   Case-sensitive tag names (default: `undefined`).\n * @returns\n *   `h`.\n */\nexport function createH(schema, defaultTagName, caseSensitive) {\n  const adjust = caseSensitive && createAdjustMap(caseSensitive);\n\n  /**\n   * Hyperscript compatible DSL for creating virtual hast trees.\n   *\n   * @overload\n   * @param {null | undefined} [selector]\n   * @param {...Child} children\n   * @returns {Root}\n   *\n   * @overload\n   * @param {string} selector\n   * @param {Properties} properties\n   * @param {...Child} children\n   * @returns {Element}\n   *\n   * @overload\n   * @param {string} selector\n   * @param {...Child} children\n   * @returns {Element}\n   *\n   * @param {string | null | undefined} [selector]\n   *   Selector.\n   * @param {Child | Properties | null | undefined} [properties]\n   *   Properties (or first child) (default: `undefined`).\n   * @param {...Child} children\n   *   Children.\n   * @returns {Result}\n   *   Result.\n   */\n  function h(selector, properties) {\n    let index = -1;\n    /** @type {Result} */\n    let node;\n    for (var _len = arguments.length, children = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n      children[_key - 2] = arguments[_key];\n    }\n    if (selector === undefined || selector === null) {\n      node = {\n        type: 'root',\n        children: []\n      };\n      // Properties are not supported for roots.\n      const child = /** @type {Child} */properties;\n      children.unshift(child);\n    } else {\n      node = parseSelector(selector, defaultTagName);\n      // Normalize the name.\n      node.tagName = node.tagName.toLowerCase();\n      if (adjust && own.call(adjust, node.tagName)) {\n        node.tagName = adjust[node.tagName];\n      }\n\n      // Handle props.\n      if (isProperties(properties, node.tagName)) {\n        /** @type {string} */\n        let key;\n        for (key in properties) {\n          if (own.call(properties, key)) {\n            addProperty(schema, node.properties, key, properties[key]);\n          }\n        }\n      } else {\n        children.unshift(properties);\n      }\n    }\n\n    // Handle children.\n    while (++index < children.length) {\n      addChild(node.children, children[index]);\n    }\n    if (node.type === 'element' && node.tagName === 'template') {\n      node.content = {\n        type: 'root',\n        children: node.children\n      };\n      node.children = [];\n    }\n    return node;\n  }\n  return h;\n}\n\n/**\n * Check if something is properties or a child.\n *\n * @param {Child | Properties} value\n *   Value to check.\n * @param {string} name\n *   Tag name.\n * @returns {value is Properties}\n *   Whether `value` is a properties object.\n */\nfunction isProperties(value, name) {\n  if (value === null || value === undefined || typeof value !== 'object' || Array.isArray(value)) {\n    return false;\n  }\n  if (name === 'input' || !value.type || typeof value.type !== 'string') {\n    return true;\n  }\n  if ('children' in value && Array.isArray(value.children)) {\n    return false;\n  }\n  if (name === 'button') {\n    return buttonTypes.has(value.type.toLowerCase());\n  }\n  return !('value' in value);\n}\n\n/**\n * @param {Schema} schema\n *   Schema.\n * @param {Properties} properties\n *   Properties object.\n * @param {string} key\n *   Property name.\n * @param {PropertyValue | Style} value\n *   Property value.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addProperty(schema, properties, key, value) {\n  const info = find(schema, key);\n  let index = -1;\n  /** @type {PropertyValue} */\n  let result;\n\n  // Ignore nullish and NaN values.\n  if (value === undefined || value === null) return;\n  if (typeof value === 'number') {\n    // Ignore NaN.\n    if (Number.isNaN(value)) return;\n    result = value;\n  }\n  // Booleans.\n  else if (typeof value === 'boolean') {\n    result = value;\n  }\n  // Handle list values.\n  else if (typeof value === 'string') {\n    if (info.spaceSeparated) {\n      result = spaces(value);\n    } else if (info.commaSeparated) {\n      result = commas(value);\n    } else if (info.commaOrSpaceSeparated) {\n      result = spaces(commas(value).join(' '));\n    } else {\n      result = parsePrimitive(info, info.property, value);\n    }\n  } else if (Array.isArray(value)) {\n    result = value.concat();\n  } else {\n    result = info.property === 'style' ? style(value) : String(value);\n  }\n  if (Array.isArray(result)) {\n    /** @type {Array<number | string>} */\n    const finalResult = [];\n    while (++index < result.length) {\n      // Assume no booleans in array.\n      const value = /** @type {number | string} */\n      parsePrimitive(info, info.property, result[index]);\n      finalResult[index] = value;\n    }\n    result = finalResult;\n  }\n\n  // Class names (which can be added both on the `selector` and here).\n  if (info.property === 'className' && Array.isArray(properties.className)) {\n    // Assume no booleans in `className`.\n    const value = /** @type {number | string} */result;\n    result = properties.className.concat(value);\n  }\n  properties[info.property] = result;\n}\n\n/**\n * @param {Array<RootContent>} nodes\n *   Children.\n * @param {Child} value\n *   Child.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addChild(nodes, value) {\n  let index = -1;\n  if (value === undefined || value === null) {\n    // Empty.\n  } else if (typeof value === 'string' || typeof value === 'number') {\n    nodes.push({\n      type: 'text',\n      value: String(value)\n    });\n  } else if (Array.isArray(value)) {\n    while (++index < value.length) {\n      addChild(nodes, value[index]);\n    }\n  } else if (typeof value === 'object' && 'type' in value) {\n    if (value.type === 'root') {\n      addChild(nodes, value.children);\n    } else {\n      nodes.push(value);\n    }\n  } else {\n    throw new Error('Expected node, nodes, or string, got `' + value + '`');\n  }\n}\n\n/**\n * Parse a single primitives.\n *\n * @param {Info} info\n *   Property information.\n * @param {string} name\n *   Property name.\n * @param {PrimitiveValue} value\n *   Property value.\n * @returns {PrimitiveValue}\n *   Property value.\n */\nfunction parsePrimitive(info, name, value) {\n  if (typeof value === 'string') {\n    if (info.number && value && !Number.isNaN(Number(value))) {\n      return Number(value);\n    }\n    if ((info.boolean || info.overloadedBoolean) && (value === '' || normalize(value) === normalize(name))) {\n      return true;\n    }\n  }\n  return value;\n}\n\n/**\n * Serialize a `style` object as a string.\n *\n * @param {Style} value\n *   Style object.\n * @returns {string}\n *   CSS string.\n */\nfunction style(value) {\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {string} */\n  let key;\n  for (key in value) {\n    if (own.call(value, key)) {\n      result.push([key, value[key]].join(': '));\n    }\n  }\n  return result.join('; ');\n}\n\n/**\n * Create a map to adjust casing.\n *\n * @param {Array<string>} values\n *   List of properly cased keys.\n * @returns {Record<string, string>}\n *   Map of lowercase keys to uppercase keys.\n */\nfunction createAdjustMap(values) {\n  /** @type {Record<string, string>} */\n  const result = {};\n  let index = -1;\n  while (++index < values.length) {\n    result[values[index].toLowerCase()] = values[index];\n  }\n  return result;\n}","export const svgCaseSensitiveTagNames = ['altGlyph', 'altGlyphDef', 'altGlyphItem', 'animateColor', 'animateMotion', 'animateTransform', 'clipPath', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence', 'foreignObject', 'glyphRef', 'linearGradient', 'radialGradient', 'solidColor', 'textArea', 'textPath'];","/**\n * @typedef {import('./create-h.js').Child} Child\n *   Acceptable child value.\n * @typedef {import('./create-h.js').Properties} Properties\n *   Acceptable value for element properties.\n * @typedef {import('./create-h.js').Result} Result\n *   Result from a `h` (or `s`) call.\n */\n\n// Register the JSX namespace on `h`.\n/**\n * @typedef {import('./jsx-classic.js').Element} h.JSX.Element\n * @typedef {import('./jsx-classic.js').ElementChildrenAttribute} h.JSX.ElementChildrenAttribute\n * @typedef {import('./jsx-classic.js').IntrinsicAttributes} h.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic.js').IntrinsicElements} h.JSX.IntrinsicElements\n */\n\n// Register the JSX namespace on `s`.\n/**\n * @typedef {import('./jsx-classic.js').Element} s.JSX.Element\n * @typedef {import('./jsx-classic.js').ElementChildrenAttribute} s.JSX.ElementChildrenAttribute\n * @typedef {import('./jsx-classic.js').IntrinsicAttributes} s.JSX.IntrinsicAttributes\n * @typedef {import('./jsx-classic.js').IntrinsicElements} s.JSX.IntrinsicElements\n */\n\nimport { html, svg } from 'property-information';\nimport { createH } from './create-h.js';\nimport { svgCaseSensitiveTagNames } from './svg-case-sensitive-tag-names.js';\n\n// Note: this explicit type is needed, otherwise TS creates broken types.\n/** @type {ReturnType<createH>} */\nexport const h = createH(html, 'div');\n\n// Note: this explicit type is needed, otherwise TS creates broken types.\n/** @type {ReturnType<createH>} */\nexport const s = createH(svg, 'g', svgCaseSensitiveTagNames);","/**\n * @typedef {import('vfile').VFile} VFile\n * @typedef {import('vfile').Value} Value\n * @typedef {import('unist').Point} UnistPoint\n */\n\n/**\n *\n * @typedef PointLike\n *   unist point, allowed as input.\n * @property {number | null | undefined} [line]\n *   Line.\n * @property {number | null | undefined} [column]\n *   Column.\n * @property {number | null | undefined} [offset]\n *   Offset.\n *\n * @callback ToPoint\n *   Get the line/column based `Point` for `offset` in the bound indices.\n *\n *   Returns `undefined` when given out of bounds input.\n *\n *   Also implemented in Rust in [`wooorm/markdown-rs`][markdown-rs].\n *\n *   [markdown-rs]: https://github.com/wooorm/markdown-rs/blob/main/src/util/location.rs\n * @param {number | null | undefined} [offset]\n *   Something that should be an `offset.\n * @returns {UnistPoint | undefined}\n *   Point, if `offset` is valid and in-bounds input.\n *\n * @callback ToOffset\n *   Get the `offset` from a line/column based `Point` in the bound indices.\n * @param {PointLike | null | undefined} [point]\n *   Something that should be a `point.\n * @returns {number | undefined}\n *   Offset (`number`) or `undefined` for invalid or out of bounds input.\n *\n * @typedef Location\n *   Accessors for index.\n * @property {ToPoint} toPoint\n *   Get the line/column based `Point` for `offset` in the bound indices.\n * @property {ToOffset} toOffset\n *   Get the `offset` from a line/column based `Point` in the bound indices.\n */\n\nconst search = /\\r?\\n|\\r/g;\n\n/**\n * Create an index of the given document to translate between line/column and\n * offset based positional info.\n *\n * Also implemented in Rust in [`wooorm/markdown-rs`][markdown-rs].\n *\n * [markdown-rs]: https://github.com/wooorm/markdown-rs/blob/main/src/util/location.rs\n *\n * @param {VFile | Value} file\n *   File to index.\n * @returns {Location}\n *   Accessors for index.\n */\nexport function location(file) {\n  const value = String(file);\n  /**\n   * List, where each index is a line number (0-based), and each value is the\n   * byte index *after* where the line ends.\n   *\n   * @type {Array<number>}\n   */\n  const indices = [];\n  search.lastIndex = 0;\n  while (search.test(value)) {\n    indices.push(search.lastIndex);\n  }\n  indices.push(value.length + 1);\n  return {\n    toPoint,\n    toOffset\n  };\n\n  /** @type {ToPoint} */\n  function toPoint(offset) {\n    let index = -1;\n    if (typeof offset === 'number' && offset > -1 && offset < indices[indices.length - 1]) {\n      while (++index < indices.length) {\n        if (indices[index] > offset) {\n          return {\n            line: index + 1,\n            column: offset - (index > 0 ? indices[index - 1] : 0) + 1,\n            offset\n          };\n        }\n      }\n    }\n  }\n\n  /** @type {ToOffset} */\n  function toOffset(point) {\n    const line = point && point.line;\n    const column = point && point.column;\n    if (typeof line === 'number' && typeof column === 'number' && !Number.isNaN(line) && !Number.isNaN(column) && line - 1 in indices) {\n      const offset = (indices[line - 2] || 0) + column - 1 || 0;\n      if (offset > -1 && offset < indices[indices.length - 1]) {\n        return offset;\n      }\n    }\n  }\n}","/**\n * Map of web namespaces.\n *\n * @type {Record<string, string>}\n */\nexport const webNamespaces = {\n  html: 'http://www.w3.org/1999/xhtml',\n  mathml: 'http://www.w3.org/1998/Math/MathML',\n  svg: 'http://www.w3.org/2000/svg',\n  xlink: 'http://www.w3.org/1999/xlink',\n  xml: 'http://www.w3.org/XML/1998/namespace',\n  xmlns: 'http://www.w3.org/2000/xmlns/'\n};","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementData} ElementData\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n *\n * @typedef {import('parse5').DefaultTreeAdapterMap} DefaultTreeAdapterMap\n * @typedef {import('parse5').Token.ElementLocation} P5ElementLocation\n * @typedef {import('parse5').Token.Location} P5Location\n *\n * @typedef {import('property-information').Schema} Schema\n *\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n *\n * @typedef {import('vfile').VFile} VFile\n */\n\n/**\n * @typedef {DefaultTreeAdapterMap['document']} P5Document\n * @typedef {DefaultTreeAdapterMap['documentFragment']} P5DocumentFragment\n * @typedef {DefaultTreeAdapterMap['documentType']} P5DocumentType\n * @typedef {DefaultTreeAdapterMap['commentNode']} P5Comment\n * @typedef {DefaultTreeAdapterMap['textNode']} P5Text\n * @typedef {DefaultTreeAdapterMap['element']} P5Element\n * @typedef {DefaultTreeAdapterMap['node']} P5Node\n * @typedef {DefaultTreeAdapterMap['template']} P5Template\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {Space | null | undefined} [space='html']\n *   Which space the document is in (default: `'html'`).\n *\n *   When an `<svg>` element is found in the HTML space, this package already\n *   automatically switches to and from the SVG space when entering and exiting\n *   it.\n * @property {VFile | null | undefined} [file]\n *   File used to add positional info to nodes (optional).\n *\n *   If given, the file should represent the original HTML source.\n * @property {boolean | null | undefined} [verbose=false]\n *   Whether to add extra positional info about starting tags, closing tags,\n *   and attributes to elements (default: `false`).\n *\n *   > 👉 **Note**: only used when `file` is given.\n *\n * @typedef {'html' | 'svg'} Space\n *   Namespace.\n *\n * @typedef State\n *   Info passed around about the current state.\n * @property {VFile | undefined} file\n *   Corresponding file.\n * @property {boolean} location\n *   Whether location info was found.\n * @property {Schema} schema\n *   Current schema.\n * @property {boolean | undefined} verbose\n *   Add extra positional info.\n */\n\nimport { ok as assert } from 'devlop';\nimport { h, s } from 'hastscript';\nimport { find, html, svg } from 'property-information';\nimport { location } from 'vfile-location';\nimport { webNamespaces } from 'web-namespaces';\nconst own = {}.hasOwnProperty;\n/** @type {unknown} */\n// type-coverage:ignore-next-line\nconst proto = Object.prototype;\n\n/**\n * Transform a `parse5` AST to hast.\n *\n * @param {P5Node} tree\n *   `parse5` tree to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {Nodes}\n *   hast tree.\n */\nexport function fromParse5(tree, options) {\n  const settings = options || {};\n  return one({\n    file: settings.file || undefined,\n    location: false,\n    schema: settings.space === 'svg' ? svg : html,\n    verbose: settings.verbose || false\n  }, tree);\n}\n\n/**\n * Transform a node.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {P5Node} node\n *   p5 node.\n * @returns {Nodes}\n *   hast node.\n */\nfunction one(state, node) {\n  /** @type {Nodes} */\n  let result;\n  switch (node.nodeName) {\n    case '#comment':\n      {\n        const reference = /** @type {P5Comment} */node;\n        result = {\n          type: 'comment',\n          value: reference.data\n        };\n        patch(state, reference, result);\n        return result;\n      }\n    case '#document':\n    case '#document-fragment':\n      {\n        const reference = /** @type {P5Document | P5DocumentFragment} */node;\n        const quirksMode = 'mode' in reference ? reference.mode === 'quirks' || reference.mode === 'limited-quirks' : false;\n        result = {\n          type: 'root',\n          children: all(state, node.childNodes),\n          data: {\n            quirksMode\n          }\n        };\n        if (state.file && state.location) {\n          const doc = String(state.file);\n          const loc = location(doc);\n          const start = loc.toPoint(0);\n          const end = loc.toPoint(doc.length);\n          // Always defined as we give valid input.\n          assert(start, 'expected `start`');\n          assert(end, 'expected `end`');\n          result.position = {\n            start,\n            end\n          };\n        }\n        return result;\n      }\n    case '#documentType':\n      {\n        const reference = /** @type {P5DocumentType} */node;\n        result = {\n          type: 'doctype'\n        };\n        patch(state, reference, result);\n        return result;\n      }\n    case '#text':\n      {\n        const reference = /** @type {P5Text} */node;\n        result = {\n          type: 'text',\n          value: reference.value\n        };\n        patch(state, reference, result);\n        return result;\n      }\n\n    // Element.\n    default:\n      {\n        const reference = /** @type {P5Element} */node;\n        result = element(state, reference);\n        return result;\n      }\n  }\n}\n\n/**\n * Transform children.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Array<P5Node>} nodes\n *   Nodes.\n * @returns {Array<RootContent>}\n *   hast nodes.\n */\nfunction all(state, nodes) {\n  let index = -1;\n  /** @type {Array<RootContent>} */\n  const results = [];\n  while (++index < nodes.length) {\n    // Assume no roots in `nodes`.\n    const result = /** @type {RootContent} */one(state, nodes[index]);\n    results.push(result);\n  }\n  return results;\n}\n\n/**\n * Transform an element.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {P5Element} node\n *   `parse5` node to transform.\n * @returns {Element}\n *   hast node.\n */\nfunction element(state, node) {\n  const schema = state.schema;\n  state.schema = node.namespaceURI === webNamespaces.svg ? svg : html;\n\n  // Props.\n  let index = -1;\n  /** @type {Record<string, string>} */\n  const props = {};\n  while (++index < node.attrs.length) {\n    const attribute = node.attrs[index];\n    const name = (attribute.prefix ? attribute.prefix + ':' : '') + attribute.name;\n    if (!own.call(proto, name)) {\n      props[name] = attribute.value;\n    }\n  }\n\n  // Build.\n  const fn = state.schema.space === 'svg' ? s : h;\n  const result = fn(node.tagName, props, all(state, node.childNodes));\n  patch(state, node, result);\n\n  // Switch content.\n  if (result.tagName === 'template') {\n    const reference = /** @type {P5Template} */node;\n    const pos = reference.sourceCodeLocation;\n    const startTag = pos && pos.startTag && position(pos.startTag);\n    const endTag = pos && pos.endTag && position(pos.endTag);\n\n    // Root in, root out.\n    const content = /** @type {Root} */one(state, reference.content);\n    if (startTag && endTag && state.file) {\n      content.position = {\n        start: startTag.end,\n        end: endTag.start\n      };\n    }\n    result.content = content;\n  }\n  state.schema = schema;\n  return result;\n}\n\n/**\n * Patch positional info from `from` onto `to`.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {P5Node} from\n *   p5 node.\n * @param {Nodes} to\n *   hast node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(state, from, to) {\n  if ('sourceCodeLocation' in from && from.sourceCodeLocation && state.file) {\n    const position = createLocation(state, to, from.sourceCodeLocation);\n    if (position) {\n      state.location = true;\n      to.position = position;\n    }\n  }\n}\n\n/**\n * Create clean positional information.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Nodes} node\n *   hast node.\n * @param {P5ElementLocation} location\n *   p5 location info.\n * @returns {Position | undefined}\n *   Position, or nothing.\n */\nfunction createLocation(state, node, location) {\n  const result = position(location);\n  if (node.type === 'element') {\n    const tail = node.children[node.children.length - 1];\n\n    // Bug for unclosed with children.\n    // See: <https://github.com/inikulin/parse5/issues/109>.\n    if (result && !location.endTag && tail && tail.position && tail.position.end) {\n      result.end = Object.assign({}, tail.position.end);\n    }\n    if (state.verbose) {\n      /** @type {Record<string, Position | undefined>} */\n      const props = {};\n      /** @type {string} */\n      let key;\n      if (location.attrs) {\n        for (key in location.attrs) {\n          if (own.call(location.attrs, key)) {\n            props[find(state.schema, key).property] = position(location.attrs[key]);\n          }\n        }\n      }\n      assert(location.startTag, 'a start tag should exist');\n      const opening = position(location.startTag);\n      const closing = location.endTag ? position(location.endTag) : undefined;\n      /** @type {ElementData['position']} */\n      const data = {\n        opening\n      };\n      if (closing) data.closing = closing;\n      data.properties = props;\n      node.data = {\n        position: data\n      };\n    }\n  }\n  return result;\n}\n\n/**\n * Turn a p5 location into a position.\n *\n * @param {P5Location} loc\n *   Location.\n * @returns {Position | undefined}\n *   Position or nothing.\n */\nfunction position(loc) {\n  const start = point({\n    line: loc.startLine,\n    column: loc.startCol,\n    offset: loc.startOffset\n  });\n  const end = point({\n    line: loc.endLine,\n    column: loc.endCol,\n    offset: loc.endOffset\n  });\n\n  // @ts-expect-error: we do use `undefined` for points if one or the other\n  // exists.\n  return start || end ? {\n    start,\n    end\n  } : undefined;\n}\n\n/**\n * Filter out invalid points.\n *\n * @param {Point} point\n *   Point with potentially `undefined` values.\n * @returns {Point | undefined}\n *   Point or nothing.\n */\nfunction point(point) {\n  return point.line && point.column ? point : undefined;\n}","/**\n * @callback Handler\n *   Handle a value, with a certain ID field set to a certain value.\n *   The ID field is passed to `zwitch`, and it’s value is this function’s\n *   place on the `handlers` record.\n * @param {...any} parameters\n *   Arbitrary parameters passed to the zwitch.\n *   The first will be an object with a certain ID field set to a certain value.\n * @returns {any}\n *   Anything!\n */\n\n/**\n * @callback UnknownHandler\n *   Handle values that do have a certain ID field, but it’s set to a value\n *   that is not listed in the `handlers` record.\n * @param {unknown} value\n *   An object with a certain ID field set to an unknown value.\n * @param {...any} rest\n *   Arbitrary parameters passed to the zwitch.\n * @returns {any}\n *   Anything!\n */\n\n/**\n * @callback InvalidHandler\n *   Handle values that do not have a certain ID field.\n * @param {unknown} value\n *   Any unknown value.\n * @param {...any} rest\n *   Arbitrary parameters passed to the zwitch.\n * @returns {void|null|undefined|never}\n *   This should crash or return nothing.\n */\n\n/**\n * @template {InvalidHandler} [Invalid=InvalidHandler]\n * @template {UnknownHandler} [Unknown=UnknownHandler]\n * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]\n * @typedef Options\n *   Configuration (required).\n * @property {Invalid} [invalid]\n *   Handler to use for invalid values.\n * @property {Unknown} [unknown]\n *   Handler to use for unknown values.\n * @property {Handlers} [handlers]\n *   Handlers to use.\n */\n\nconst own = {}.hasOwnProperty;\n\n/**\n * Handle values based on a field.\n *\n * @template {InvalidHandler} [Invalid=InvalidHandler]\n * @template {UnknownHandler} [Unknown=UnknownHandler]\n * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]\n * @param {string} key\n *   Field to switch on.\n * @param {Options<Invalid, Unknown, Handlers>} [options]\n *   Configuration (required).\n * @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}\n */\nexport function zwitch(key, options) {\n  const settings = options || {};\n\n  /**\n   * Handle one value.\n   *\n   * Based on the bound `key`, a respective handler will be called.\n   * If `value` is not an object, or doesn’t have a `key` property, the special\n   * “invalid” handler will be called.\n   * If `value` has an unknown `key`, the special “unknown” handler will be\n   * called.\n   *\n   * All arguments, and the context object, are passed through to the handler,\n   * and it’s result is returned.\n   *\n   * @this {unknown}\n   *   Any context object.\n   * @param {unknown} [value]\n   *   Any value.\n   * @param {...unknown} parameters\n   *   Arbitrary parameters passed to the zwitch.\n   * @property {Handler} invalid\n   *   Handle for values that do not have a certain ID field.\n   * @property {Handler} unknown\n   *   Handle values that do have a certain ID field, but it’s set to a value\n   *   that is not listed in the `handlers` record.\n   * @property {Handlers} handlers\n   *   Record of handlers.\n   * @returns {unknown}\n   *   Anything.\n   */\n  function one(value) {\n    /** @type {Handler|undefined} */\n    let fn = one.invalid;\n    const handlers = one.handlers;\n    if (value && own.call(value, key)) {\n      // @ts-expect-error Indexable.\n      const id = String(value[key]);\n      // @ts-expect-error Indexable.\n      fn = own.call(handlers, id) ? handlers[id] : one.unknown;\n    }\n    if (fn) {\n      for (var _len = arguments.length, parameters = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        parameters[_key - 1] = arguments[_key];\n      }\n      return fn.call(this, value, ...parameters);\n    }\n  }\n  one.handlers = settings.handlers || {};\n  one.invalid = settings.invalid;\n  one.unknown = settings.unknown;\n\n  // @ts-expect-error: matches!\n  return one;\n}","/**\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Doctype} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n * @typedef {import('hast').Text} Text\n *\n * @typedef {import('parse5').DefaultTreeAdapterMap['document']} Parse5Document\n * @typedef {import('parse5').DefaultTreeAdapterMap['documentFragment']} Parse5Fragment\n * @typedef {import('parse5').DefaultTreeAdapterMap['element']} Parse5Element\n * @typedef {import('parse5').DefaultTreeAdapterMap['node']} Parse5Nodes\n * @typedef {import('parse5').DefaultTreeAdapterMap['documentType']} Parse5Doctype\n * @typedef {import('parse5').DefaultTreeAdapterMap['commentNode']} Parse5Comment\n * @typedef {import('parse5').DefaultTreeAdapterMap['textNode']} Parse5Text\n * @typedef {import('parse5').DefaultTreeAdapterMap['parentNode']} Parse5Parent\n * @typedef {import('parse5').Token.Attribute} Parse5Attribute\n *\n * @typedef {import('property-information').Schema} Schema\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {Space | null | undefined} [space='html']\n *   Which space the document is in (default: `'html'`).\n *\n *   When an `<svg>` element is found in the HTML space, this package already\n *   automatically switches to and from the SVG space when entering and exiting\n *   it.\n *\n * @typedef {Exclude<Parse5Nodes, Parse5Document | Parse5Fragment>} Parse5Content\n *\n * @typedef {'html' | 'svg'} Space\n */\n\nimport { stringify as commas } from 'comma-separated-tokens';\nimport { ok as assert } from 'devlop';\nimport { find, html, svg } from 'property-information';\nimport { stringify as spaces } from 'space-separated-tokens';\nimport { webNamespaces } from 'web-namespaces';\nimport { zwitch } from 'zwitch';\n\n/** @type {Options} */\nconst emptyOptions = {};\nconst own = {}.hasOwnProperty;\nconst one = zwitch('type', {\n  handlers: {\n    root,\n    element,\n    text,\n    comment,\n    doctype\n  }\n});\n\n/**\n * Transform a hast tree to a `parse5` AST.\n *\n * @param {Nodes} tree\n *   Tree to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {Parse5Nodes}\n *   `parse5` node.\n */\nexport function toParse5(tree, options) {\n  const settings = options || emptyOptions;\n  const space = settings.space;\n  return one(tree, space === 'svg' ? svg : html);\n}\n\n/**\n * @param {Root} node\n *   Node (hast) to transform.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Parse5Document}\n *   Parse5 node.\n */\nfunction root(node, schema) {\n  /** @type {Parse5Document} */\n  const result = {\n    nodeName: '#document',\n    // @ts-expect-error: `parse5` uses enums, which are actually strings.\n    mode: (node.data || {}).quirksMode ? 'quirks' : 'no-quirks',\n    childNodes: []\n  };\n  result.childNodes = all(node.children, result, schema);\n  patch(node, result);\n  return result;\n}\n\n/**\n * @param {Root} node\n *   Node (hast) to transform.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Parse5Fragment}\n *   Parse5 node.\n */\nfunction fragment(node, schema) {\n  /** @type {Parse5Fragment} */\n  const result = {\n    nodeName: '#document-fragment',\n    childNodes: []\n  };\n  result.childNodes = all(node.children, result, schema);\n  patch(node, result);\n  return result;\n}\n\n/**\n * @param {Doctype} node\n *   Node (hast) to transform.\n * @returns {Parse5Doctype}\n *   Parse5 node.\n */\nfunction doctype(node) {\n  /** @type {Parse5Doctype} */\n  const result = {\n    nodeName: '#documentType',\n    name: 'html',\n    publicId: '',\n    systemId: '',\n    parentNode: null\n  };\n  patch(node, result);\n  return result;\n}\n\n/**\n * @param {Text} node\n *   Node (hast) to transform.\n * @returns {Parse5Text}\n *   Parse5 node.\n */\nfunction text(node) {\n  /** @type {Parse5Text} */\n  const result = {\n    nodeName: '#text',\n    value: node.value,\n    parentNode: null\n  };\n  patch(node, result);\n  return result;\n}\n\n/**\n * @param {Comment} node\n *   Node (hast) to transform.\n * @returns {Parse5Comment}\n *   Parse5 node.\n */\nfunction comment(node) {\n  /** @type {Parse5Comment} */\n  const result = {\n    nodeName: '#comment',\n    data: node.value,\n    parentNode: null\n  };\n  patch(node, result);\n  return result;\n}\n\n/**\n * @param {Element} node\n *   Node (hast) to transform.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Parse5Element}\n *   Parse5 node.\n */\nfunction element(node, schema) {\n  const parentSchema = schema;\n  let currentSchema = parentSchema;\n  if (node.type === 'element' && node.tagName.toLowerCase() === 'svg' && parentSchema.space === 'html') {\n    currentSchema = svg;\n  }\n\n  /** @type {Array<Parse5Attribute>} */\n  const attrs = [];\n  /** @type {string} */\n  let prop;\n  if (node.properties) {\n    for (prop in node.properties) {\n      if (prop !== 'children' && own.call(node.properties, prop)) {\n        const result = createProperty(currentSchema, prop, node.properties[prop]);\n        if (result) {\n          attrs.push(result);\n        }\n      }\n    }\n  }\n  const space = currentSchema.space;\n  // `html` and `svg` both have a space.\n  assert(space);\n\n  /** @type {Parse5Element} */\n  const result = {\n    nodeName: node.tagName,\n    tagName: node.tagName,\n    attrs,\n    // @ts-expect-error: `parse5` types are wrong.\n    namespaceURI: webNamespaces[space],\n    childNodes: [],\n    parentNode: null\n  };\n  result.childNodes = all(node.children, result, currentSchema);\n  patch(node, result);\n  if (node.tagName === 'template' && node.content) {\n    // @ts-expect-error: `parse5` types are wrong.\n    result.content = fragment(node.content, currentSchema);\n  }\n  return result;\n}\n\n/**\n * Handle a property.\n *\n * @param {Schema} schema\n *   Current schema.\n * @param {string} prop\n *   Key.\n * @param {Array<number | string> | boolean | number | string | null | undefined} value\n *   hast property value.\n * @returns {Parse5Attribute | undefined}\n *   Field for runtime, optional.\n */\nfunction createProperty(schema, prop, value) {\n  const info = find(schema, prop);\n\n  // Ignore nullish and `NaN` values.\n  if (value === false || value === null || value === undefined || typeof value === 'number' && Number.isNaN(value) || !value && info.boolean) {\n    return;\n  }\n  if (Array.isArray(value)) {\n    // Accept `array`.\n    // Most props are space-separated.\n    value = info.commaSeparated ? commas(value) : spaces(value);\n  }\n\n  /** @type {Parse5Attribute} */\n  const attribute = {\n    name: info.attribute,\n    value: value === true ? '' : String(value)\n  };\n  if (info.space && info.space !== 'html' && info.space !== 'svg') {\n    const index = attribute.name.indexOf(':');\n    if (index < 0) {\n      attribute.prefix = '';\n    } else {\n      attribute.name = attribute.name.slice(index + 1);\n      attribute.prefix = info.attribute.slice(0, index);\n    }\n    attribute.namespace = webNamespaces[info.space];\n  }\n  return attribute;\n}\n\n/**\n * Transform all hast nodes.\n *\n * @param {Array<RootContent>} children\n *   List of children.\n * @param {Parse5Parent} parentNode\n *   `parse5` parent node.\n * @param {Schema} schema\n *   Current schema.\n * @returns {Array<Parse5Content>}\n *   Transformed children.\n */\nfunction all(children, parentNode, schema) {\n  let index = -1;\n  /** @type {Array<Parse5Content>} */\n  const results = [];\n  if (children) {\n    while (++index < children.length) {\n      /** @type {Parse5Content} */\n      const child = one(children[index], schema);\n      child.parentNode = parentNode;\n      results.push(child);\n    }\n  }\n  return results;\n}\n\n/**\n * Add position info from `from` to `to`.\n *\n * @param {Nodes} from\n *   hast node.\n * @param {Parse5Nodes} to\n *   `parse5` node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  const position = from.position;\n  if (position && position.start && position.end) {\n    assert(typeof position.start.offset === 'number');\n    assert(typeof position.end.offset === 'number');\n    to.sourceCodeLocation = {\n      startLine: position.start.line,\n      startCol: position.start.column,\n      startOffset: position.start.offset,\n      endLine: position.end.line,\n      endCol: position.end.column,\n      endOffset: position.end.offset\n    };\n  }\n}","/**\n * List of HTML void tag names.\n *\n * @type {Array<string>}\n */\nexport const htmlVoidElements = ['area', 'base', 'basefont', 'bgsound', 'br', 'col', 'command', 'embed', 'frame', 'hr', 'image', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];","const UNDEFINED_CODE_POINTS = new Set([65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214, 393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894, 720895, 786430, 786431, 851966, 851967, 917502, 917503, 983038, 983039, 1048574, 1048575, 1114110, 1114111]);\nexport const REPLACEMENT_CHARACTER = '\\uFFFD';\nexport var CODE_POINTS;\n(function (CODE_POINTS) {\n  CODE_POINTS[CODE_POINTS[\"EOF\"] = -1] = \"EOF\";\n  CODE_POINTS[CODE_POINTS[\"NULL\"] = 0] = \"NULL\";\n  CODE_POINTS[CODE_POINTS[\"TABULATION\"] = 9] = \"TABULATION\";\n  CODE_POINTS[CODE_POINTS[\"CARRIAGE_RETURN\"] = 13] = \"CARRIAGE_RETURN\";\n  CODE_POINTS[CODE_POINTS[\"LINE_FEED\"] = 10] = \"LINE_FEED\";\n  CODE_POINTS[CODE_POINTS[\"FORM_FEED\"] = 12] = \"FORM_FEED\";\n  CODE_POINTS[CODE_POINTS[\"SPACE\"] = 32] = \"SPACE\";\n  CODE_POINTS[CODE_POINTS[\"EXCLAMATION_MARK\"] = 33] = \"EXCLAMATION_MARK\";\n  CODE_POINTS[CODE_POINTS[\"QUOTATION_MARK\"] = 34] = \"QUOTATION_MARK\";\n  CODE_POINTS[CODE_POINTS[\"NUMBER_SIGN\"] = 35] = \"NUMBER_SIGN\";\n  CODE_POINTS[CODE_POINTS[\"AMPERSAND\"] = 38] = \"AMPERSAND\";\n  CODE_POINTS[CODE_POINTS[\"APOSTROPHE\"] = 39] = \"APOSTROPHE\";\n  CODE_POINTS[CODE_POINTS[\"HYPHEN_MINUS\"] = 45] = \"HYPHEN_MINUS\";\n  CODE_POINTS[CODE_POINTS[\"SOLIDUS\"] = 47] = \"SOLIDUS\";\n  CODE_POINTS[CODE_POINTS[\"DIGIT_0\"] = 48] = \"DIGIT_0\";\n  CODE_POINTS[CODE_POINTS[\"DIGIT_9\"] = 57] = \"DIGIT_9\";\n  CODE_POINTS[CODE_POINTS[\"SEMICOLON\"] = 59] = \"SEMICOLON\";\n  CODE_POINTS[CODE_POINTS[\"LESS_THAN_SIGN\"] = 60] = \"LESS_THAN_SIGN\";\n  CODE_POINTS[CODE_POINTS[\"EQUALS_SIGN\"] = 61] = \"EQUALS_SIGN\";\n  CODE_POINTS[CODE_POINTS[\"GREATER_THAN_SIGN\"] = 62] = \"GREATER_THAN_SIGN\";\n  CODE_POINTS[CODE_POINTS[\"QUESTION_MARK\"] = 63] = \"QUESTION_MARK\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_A\"] = 65] = \"LATIN_CAPITAL_A\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_F\"] = 70] = \"LATIN_CAPITAL_F\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_X\"] = 88] = \"LATIN_CAPITAL_X\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_CAPITAL_Z\"] = 90] = \"LATIN_CAPITAL_Z\";\n  CODE_POINTS[CODE_POINTS[\"RIGHT_SQUARE_BRACKET\"] = 93] = \"RIGHT_SQUARE_BRACKET\";\n  CODE_POINTS[CODE_POINTS[\"GRAVE_ACCENT\"] = 96] = \"GRAVE_ACCENT\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_A\"] = 97] = \"LATIN_SMALL_A\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_F\"] = 102] = \"LATIN_SMALL_F\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_X\"] = 120] = \"LATIN_SMALL_X\";\n  CODE_POINTS[CODE_POINTS[\"LATIN_SMALL_Z\"] = 122] = \"LATIN_SMALL_Z\";\n  CODE_POINTS[CODE_POINTS[\"REPLACEMENT_CHARACTER\"] = 65533] = \"REPLACEMENT_CHARACTER\";\n})(CODE_POINTS = CODE_POINTS || (CODE_POINTS = {}));\nexport const SEQUENCES = {\n  DASH_DASH: '--',\n  CDATA_START: '[CDATA[',\n  DOCTYPE: 'doctype',\n  SCRIPT: 'script',\n  PUBLIC: 'public',\n  SYSTEM: 'system'\n};\n//Surrogates\nexport function isSurrogate(cp) {\n  return cp >= 55296 && cp <= 57343;\n}\nexport function isSurrogatePair(cp) {\n  return cp >= 56320 && cp <= 57343;\n}\nexport function getSurrogatePairCodePoint(cp1, cp2) {\n  return (cp1 - 55296) * 1024 + 9216 + cp2;\n}\n//NOTE: excluding NULL and ASCII whitespace\nexport function isControlCodePoint(cp) {\n  return cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f || cp >= 0x7f && cp <= 0x9f;\n}\nexport function isUndefinedCodePoint(cp) {\n  return cp >= 64976 && cp <= 65007 || UNDEFINED_CODE_POINTS.has(cp);\n}","export var ERR;\n(function (ERR) {\n  ERR[\"controlCharacterInInputStream\"] = \"control-character-in-input-stream\";\n  ERR[\"noncharacterInInputStream\"] = \"noncharacter-in-input-stream\";\n  ERR[\"surrogateInInputStream\"] = \"surrogate-in-input-stream\";\n  ERR[\"nonVoidHtmlElementStartTagWithTrailingSolidus\"] = \"non-void-html-element-start-tag-with-trailing-solidus\";\n  ERR[\"endTagWithAttributes\"] = \"end-tag-with-attributes\";\n  ERR[\"endTagWithTrailingSolidus\"] = \"end-tag-with-trailing-solidus\";\n  ERR[\"unexpectedSolidusInTag\"] = \"unexpected-solidus-in-tag\";\n  ERR[\"unexpectedNullCharacter\"] = \"unexpected-null-character\";\n  ERR[\"unexpectedQuestionMarkInsteadOfTagName\"] = \"unexpected-question-mark-instead-of-tag-name\";\n  ERR[\"invalidFirstCharacterOfTagName\"] = \"invalid-first-character-of-tag-name\";\n  ERR[\"unexpectedEqualsSignBeforeAttributeName\"] = \"unexpected-equals-sign-before-attribute-name\";\n  ERR[\"missingEndTagName\"] = \"missing-end-tag-name\";\n  ERR[\"unexpectedCharacterInAttributeName\"] = \"unexpected-character-in-attribute-name\";\n  ERR[\"unknownNamedCharacterReference\"] = \"unknown-named-character-reference\";\n  ERR[\"missingSemicolonAfterCharacterReference\"] = \"missing-semicolon-after-character-reference\";\n  ERR[\"unexpectedCharacterAfterDoctypeSystemIdentifier\"] = \"unexpected-character-after-doctype-system-identifier\";\n  ERR[\"unexpectedCharacterInUnquotedAttributeValue\"] = \"unexpected-character-in-unquoted-attribute-value\";\n  ERR[\"eofBeforeTagName\"] = \"eof-before-tag-name\";\n  ERR[\"eofInTag\"] = \"eof-in-tag\";\n  ERR[\"missingAttributeValue\"] = \"missing-attribute-value\";\n  ERR[\"missingWhitespaceBetweenAttributes\"] = \"missing-whitespace-between-attributes\";\n  ERR[\"missingWhitespaceAfterDoctypePublicKeyword\"] = \"missing-whitespace-after-doctype-public-keyword\";\n  ERR[\"missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers\"] = \"missing-whitespace-between-doctype-public-and-system-identifiers\";\n  ERR[\"missingWhitespaceAfterDoctypeSystemKeyword\"] = \"missing-whitespace-after-doctype-system-keyword\";\n  ERR[\"missingQuoteBeforeDoctypePublicIdentifier\"] = \"missing-quote-before-doctype-public-identifier\";\n  ERR[\"missingQuoteBeforeDoctypeSystemIdentifier\"] = \"missing-quote-before-doctype-system-identifier\";\n  ERR[\"missingDoctypePublicIdentifier\"] = \"missing-doctype-public-identifier\";\n  ERR[\"missingDoctypeSystemIdentifier\"] = \"missing-doctype-system-identifier\";\n  ERR[\"abruptDoctypePublicIdentifier\"] = \"abrupt-doctype-public-identifier\";\n  ERR[\"abruptDoctypeSystemIdentifier\"] = \"abrupt-doctype-system-identifier\";\n  ERR[\"cdataInHtmlContent\"] = \"cdata-in-html-content\";\n  ERR[\"incorrectlyOpenedComment\"] = \"incorrectly-opened-comment\";\n  ERR[\"eofInScriptHtmlCommentLikeText\"] = \"eof-in-script-html-comment-like-text\";\n  ERR[\"eofInDoctype\"] = \"eof-in-doctype\";\n  ERR[\"nestedComment\"] = \"nested-comment\";\n  ERR[\"abruptClosingOfEmptyComment\"] = \"abrupt-closing-of-empty-comment\";\n  ERR[\"eofInComment\"] = \"eof-in-comment\";\n  ERR[\"incorrectlyClosedComment\"] = \"incorrectly-closed-comment\";\n  ERR[\"eofInCdata\"] = \"eof-in-cdata\";\n  ERR[\"absenceOfDigitsInNumericCharacterReference\"] = \"absence-of-digits-in-numeric-character-reference\";\n  ERR[\"nullCharacterReference\"] = \"null-character-reference\";\n  ERR[\"surrogateCharacterReference\"] = \"surrogate-character-reference\";\n  ERR[\"characterReferenceOutsideUnicodeRange\"] = \"character-reference-outside-unicode-range\";\n  ERR[\"controlCharacterReference\"] = \"control-character-reference\";\n  ERR[\"noncharacterCharacterReference\"] = \"noncharacter-character-reference\";\n  ERR[\"missingWhitespaceBeforeDoctypeName\"] = \"missing-whitespace-before-doctype-name\";\n  ERR[\"missingDoctypeName\"] = \"missing-doctype-name\";\n  ERR[\"invalidCharacterSequenceAfterDoctypeName\"] = \"invalid-character-sequence-after-doctype-name\";\n  ERR[\"duplicateAttribute\"] = \"duplicate-attribute\";\n  ERR[\"nonConformingDoctype\"] = \"non-conforming-doctype\";\n  ERR[\"missingDoctype\"] = \"missing-doctype\";\n  ERR[\"misplacedDoctype\"] = \"misplaced-doctype\";\n  ERR[\"endTagWithoutMatchingOpenElement\"] = \"end-tag-without-matching-open-element\";\n  ERR[\"closingOfElementWithOpenChildElements\"] = \"closing-of-element-with-open-child-elements\";\n  ERR[\"disallowedContentInNoscriptInHead\"] = \"disallowed-content-in-noscript-in-head\";\n  ERR[\"openElementsLeftAfterEof\"] = \"open-elements-left-after-eof\";\n  ERR[\"abandonedHeadElementChild\"] = \"abandoned-head-element-child\";\n  ERR[\"misplacedStartTagForHeadElement\"] = \"misplaced-start-tag-for-head-element\";\n  ERR[\"nestedNoscriptInHead\"] = \"nested-noscript-in-head\";\n  ERR[\"eofInElementThatCanContainOnlyText\"] = \"eof-in-element-that-can-contain-only-text\";\n})(ERR = ERR || (ERR = {}));","import { CODE_POINTS as $, getSurrogatePairCodePoint, isControlCodePoint, isSurrogate, isSurrogatePair, isUndefinedCodePoint } from '../common/unicode.js';\nimport { ERR } from '../common/error-codes.js';\n//Const\nconst DEFAULT_BUFFER_WATERLINE = 1 << 16;\n//Preprocessor\n//NOTE: HTML input preprocessing\n//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream)\nexport class Preprocessor {\n  constructor(handler) {\n    this.handler = handler;\n    this.html = '';\n    this.pos = -1;\n    // NOTE: Initial `lastGapPos` is -2, to ensure `col` on initialisation is 0\n    this.lastGapPos = -2;\n    this.gapStack = [];\n    this.skipNextNewLine = false;\n    this.lastChunkWritten = false;\n    this.endOfChunkHit = false;\n    this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;\n    this.isEol = false;\n    this.lineStartPos = 0;\n    this.droppedBufferSize = 0;\n    this.line = 1;\n    //NOTE: avoid reporting errors twice on advance/retreat\n    this.lastErrOffset = -1;\n  }\n  /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */\n  get col() {\n    return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos);\n  }\n  get offset() {\n    return this.droppedBufferSize + this.pos;\n  }\n  getError(code) {\n    const {\n      line,\n      col,\n      offset\n    } = this;\n    return {\n      code,\n      startLine: line,\n      endLine: line,\n      startCol: col,\n      endCol: col,\n      startOffset: offset,\n      endOffset: offset\n    };\n  }\n  _err(code) {\n    if (this.handler.onParseError && this.lastErrOffset !== this.offset) {\n      this.lastErrOffset = this.offset;\n      this.handler.onParseError(this.getError(code));\n    }\n  }\n  _addGap() {\n    this.gapStack.push(this.lastGapPos);\n    this.lastGapPos = this.pos;\n  }\n  _processSurrogate(cp) {\n    //NOTE: try to peek a surrogate pair\n    if (this.pos !== this.html.length - 1) {\n      const nextCp = this.html.charCodeAt(this.pos + 1);\n      if (isSurrogatePair(nextCp)) {\n        //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.\n        this.pos++;\n        //NOTE: add a gap that should be avoided during retreat\n        this._addGap();\n        return getSurrogatePairCodePoint(cp, nextCp);\n      }\n    }\n    //NOTE: we are at the end of a chunk, therefore we can't infer the surrogate pair yet.\n    else if (!this.lastChunkWritten) {\n      this.endOfChunkHit = true;\n      return $.EOF;\n    }\n    //NOTE: isolated surrogate\n    this._err(ERR.surrogateInInputStream);\n    return cp;\n  }\n  willDropParsedChunk() {\n    return this.pos > this.bufferWaterline;\n  }\n  dropParsedChunk() {\n    if (this.willDropParsedChunk()) {\n      this.html = this.html.substring(this.pos);\n      this.lineStartPos -= this.pos;\n      this.droppedBufferSize += this.pos;\n      this.pos = 0;\n      this.lastGapPos = -2;\n      this.gapStack.length = 0;\n    }\n  }\n  write(chunk, isLastChunk) {\n    if (this.html.length > 0) {\n      this.html += chunk;\n    } else {\n      this.html = chunk;\n    }\n    this.endOfChunkHit = false;\n    this.lastChunkWritten = isLastChunk;\n  }\n  insertHtmlAtCurrentPos(chunk) {\n    this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1);\n    this.endOfChunkHit = false;\n  }\n  startsWith(pattern, caseSensitive) {\n    // Check if our buffer has enough characters\n    if (this.pos + pattern.length > this.html.length) {\n      this.endOfChunkHit = !this.lastChunkWritten;\n      return false;\n    }\n    if (caseSensitive) {\n      return this.html.startsWith(pattern, this.pos);\n    }\n    for (let i = 0; i < pattern.length; i++) {\n      const cp = this.html.charCodeAt(this.pos + i) | 0x20;\n      if (cp !== pattern.charCodeAt(i)) {\n        return false;\n      }\n    }\n    return true;\n  }\n  peek(offset) {\n    const pos = this.pos + offset;\n    if (pos >= this.html.length) {\n      this.endOfChunkHit = !this.lastChunkWritten;\n      return $.EOF;\n    }\n    const code = this.html.charCodeAt(pos);\n    return code === $.CARRIAGE_RETURN ? $.LINE_FEED : code;\n  }\n  advance() {\n    this.pos++;\n    //NOTE: LF should be in the last column of the line\n    if (this.isEol) {\n      this.isEol = false;\n      this.line++;\n      this.lineStartPos = this.pos;\n    }\n    if (this.pos >= this.html.length) {\n      this.endOfChunkHit = !this.lastChunkWritten;\n      return $.EOF;\n    }\n    let cp = this.html.charCodeAt(this.pos);\n    //NOTE: all U+000D CARRIAGE RETURN (CR) characters must be converted to U+000A LINE FEED (LF) characters\n    if (cp === $.CARRIAGE_RETURN) {\n      this.isEol = true;\n      this.skipNextNewLine = true;\n      return $.LINE_FEED;\n    }\n    //NOTE: any U+000A LINE FEED (LF) characters that immediately follow a U+000D CARRIAGE RETURN (CR) character\n    //must be ignored.\n    if (cp === $.LINE_FEED) {\n      this.isEol = true;\n      if (this.skipNextNewLine) {\n        // `line` will be bumped again in the recursive call.\n        this.line--;\n        this.skipNextNewLine = false;\n        this._addGap();\n        return this.advance();\n      }\n    }\n    this.skipNextNewLine = false;\n    if (isSurrogate(cp)) {\n      cp = this._processSurrogate(cp);\n    }\n    //OPTIMIZATION: first check if code point is in the common allowed\n    //range (ASCII alphanumeric, whitespaces, big chunk of BMP)\n    //before going into detailed performance cost validation.\n    const isCommonValidRange = this.handler.onParseError === null || cp > 0x1f && cp < 0x7f || cp === $.LINE_FEED || cp === $.CARRIAGE_RETURN || cp > 0x9f && cp < 64976;\n    if (!isCommonValidRange) {\n      this._checkForProblematicCharacters(cp);\n    }\n    return cp;\n  }\n  _checkForProblematicCharacters(cp) {\n    if (isControlCodePoint(cp)) {\n      this._err(ERR.controlCharacterInInputStream);\n    } else if (isUndefinedCodePoint(cp)) {\n      this._err(ERR.noncharacterInInputStream);\n    }\n  }\n  retreat(count) {\n    this.pos -= count;\n    while (this.pos < this.lastGapPos) {\n      this.lastGapPos = this.gapStack.pop();\n      this.pos--;\n    }\n    this.isEol = false;\n  }\n}","export var TokenType;\n(function (TokenType) {\n  TokenType[TokenType[\"CHARACTER\"] = 0] = \"CHARACTER\";\n  TokenType[TokenType[\"NULL_CHARACTER\"] = 1] = \"NULL_CHARACTER\";\n  TokenType[TokenType[\"WHITESPACE_CHARACTER\"] = 2] = \"WHITESPACE_CHARACTER\";\n  TokenType[TokenType[\"START_TAG\"] = 3] = \"START_TAG\";\n  TokenType[TokenType[\"END_TAG\"] = 4] = \"END_TAG\";\n  TokenType[TokenType[\"COMMENT\"] = 5] = \"COMMENT\";\n  TokenType[TokenType[\"DOCTYPE\"] = 6] = \"DOCTYPE\";\n  TokenType[TokenType[\"EOF\"] = 7] = \"EOF\";\n  TokenType[TokenType[\"HIBERNATION\"] = 8] = \"HIBERNATION\";\n})(TokenType = TokenType || (TokenType = {}));\nexport function getTokenAttr(token, attrName) {\n  for (let i = token.attrs.length - 1; i >= 0; i--) {\n    if (token.attrs[i].name === attrName) {\n      return token.attrs[i].value;\n    }\n  }\n  return null;\n}","// Generated using scripts/write-decode-map.ts\nexport default new Uint16Array(\n// prettier-ignore\n\"\\u1d41<\\xd5\\u0131\\u028a\\u049d\\u057b\\u05d0\\u0675\\u06de\\u07a2\\u07d6\\u080f\\u0a4a\\u0a91\\u0da1\\u0e6d\\u0f09\\u0f26\\u10ca\\u1228\\u12e1\\u1415\\u149d\\u14c3\\u14df\\u1525\\0\\0\\0\\0\\0\\0\\u156b\\u16cd\\u198d\\u1c12\\u1ddd\\u1f7e\\u2060\\u21b0\\u228d\\u23c0\\u23fb\\u2442\\u2824\\u2912\\u2d08\\u2e48\\u2fce\\u3016\\u32ba\\u3639\\u37ac\\u38fe\\u3a28\\u3a71\\u3ae0\\u3b2e\\u0800EMabcfglmnoprstu\\\\bfms\\x7f\\x84\\x8b\\x90\\x95\\x98\\xa6\\xb3\\xb9\\xc8\\xcflig\\u803b\\xc6\\u40c6P\\u803b&\\u4026cute\\u803b\\xc1\\u40c1reve;\\u4102\\u0100iyx}rc\\u803b\\xc2\\u40c2;\\u4410r;\\uc000\\ud835\\udd04rave\\u803b\\xc0\\u40c0pha;\\u4391acr;\\u4100d;\\u6a53\\u0100gp\\x9d\\xa1on;\\u4104f;\\uc000\\ud835\\udd38plyFunction;\\u6061ing\\u803b\\xc5\\u40c5\\u0100cs\\xbe\\xc3r;\\uc000\\ud835\\udc9cign;\\u6254ilde\\u803b\\xc3\\u40c3ml\\u803b\\xc4\\u40c4\\u0400aceforsu\\xe5\\xfb\\xfe\\u0117\\u011c\\u0122\\u0127\\u012a\\u0100cr\\xea\\xf2kslash;\\u6216\\u0176\\xf6\\xf8;\\u6ae7ed;\\u6306y;\\u4411\\u0180crt\\u0105\\u010b\\u0114ause;\\u6235noullis;\\u612ca;\\u4392r;\\uc000\\ud835\\udd05pf;\\uc000\\ud835\\udd39eve;\\u42d8c\\xf2\\u0113mpeq;\\u624e\\u0700HOacdefhilorsu\\u014d\\u0151\\u0156\\u0180\\u019e\\u01a2\\u01b5\\u01b7\\u01ba\\u01dc\\u0215\\u0273\\u0278\\u027ecy;\\u4427PY\\u803b\\xa9\\u40a9\\u0180cpy\\u015d\\u0162\\u017aute;\\u4106\\u0100;i\\u0167\\u0168\\u62d2talDifferentialD;\\u6145leys;\\u612d\\u0200aeio\\u0189\\u018e\\u0194\\u0198ron;\\u410cdil\\u803b\\xc7\\u40c7rc;\\u4108nint;\\u6230ot;\\u410a\\u0100dn\\u01a7\\u01adilla;\\u40b8terDot;\\u40b7\\xf2\\u017fi;\\u43a7rcle\\u0200DMPT\\u01c7\\u01cb\\u01d1\\u01d6ot;\\u6299inus;\\u6296lus;\\u6295imes;\\u6297o\\u0100cs\\u01e2\\u01f8kwiseContourIntegral;\\u6232eCurly\\u0100DQ\\u0203\\u020foubleQuote;\\u601duote;\\u6019\\u0200lnpu\\u021e\\u0228\\u0247\\u0255on\\u0100;e\\u0225\\u0226\\u6237;\\u6a74\\u0180git\\u022f\\u0236\\u023aruent;\\u6261nt;\\u622fourIntegral;\\u622e\\u0100fr\\u024c\\u024e;\\u6102oduct;\\u6210nterClockwiseContourIntegral;\\u6233oss;\\u6a2fcr;\\uc000\\ud835\\udc9ep\\u0100;C\\u0284\\u0285\\u62d3ap;\\u624d\\u0580DJSZacefios\\u02a0\\u02ac\\u02b0\\u02b4\\u02b8\\u02cb\\u02d7\\u02e1\\u02e6\\u0333\\u048d\\u0100;o\\u0179\\u02a5trahd;\\u6911cy;\\u4402cy;\\u4405cy;\\u440f\\u0180grs\\u02bf\\u02c4\\u02c7ger;\\u6021r;\\u61a1hv;\\u6ae4\\u0100ay\\u02d0\\u02d5ron;\\u410e;\\u4414l\\u0100;t\\u02dd\\u02de\\u6207a;\\u4394r;\\uc000\\ud835\\udd07\\u0100af\\u02eb\\u0327\\u0100cm\\u02f0\\u0322ritical\\u0200ADGT\\u0300\\u0306\\u0316\\u031ccute;\\u40b4o\\u0174\\u030b\\u030d;\\u42d9bleAcute;\\u42ddrave;\\u4060ilde;\\u42dcond;\\u62c4ferentialD;\\u6146\\u0470\\u033d\\0\\0\\0\\u0342\\u0354\\0\\u0405f;\\uc000\\ud835\\udd3b\\u0180;DE\\u0348\\u0349\\u034d\\u40a8ot;\\u60dcqual;\\u6250ble\\u0300CDLRUV\\u0363\\u0372\\u0382\\u03cf\\u03e2\\u03f8ontourIntegra\\xec\\u0239o\\u0274\\u0379\\0\\0\\u037b\\xbb\\u0349nArrow;\\u61d3\\u0100eo\\u0387\\u03a4ft\\u0180ART\\u0390\\u0396\\u03a1rrow;\\u61d0ightArrow;\\u61d4e\\xe5\\u02cang\\u0100LR\\u03ab\\u03c4eft\\u0100AR\\u03b3\\u03b9rrow;\\u67f8ightArrow;\\u67faightArrow;\\u67f9ight\\u0100AT\\u03d8\\u03derrow;\\u61d2ee;\\u62a8p\\u0241\\u03e9\\0\\0\\u03efrrow;\\u61d1ownArrow;\\u61d5erticalBar;\\u6225n\\u0300ABLRTa\\u0412\\u042a\\u0430\\u045e\\u047f\\u037crrow\\u0180;BU\\u041d\\u041e\\u0422\\u6193ar;\\u6913pArrow;\\u61f5reve;\\u4311eft\\u02d2\\u043a\\0\\u0446\\0\\u0450ightVector;\\u6950eeVector;\\u695eector\\u0100;B\\u0459\\u045a\\u61bdar;\\u6956ight\\u01d4\\u0467\\0\\u0471eeVector;\\u695fector\\u0100;B\\u047a\\u047b\\u61c1ar;\\u6957ee\\u0100;A\\u0486\\u0487\\u62a4rrow;\\u61a7\\u0100ct\\u0492\\u0497r;\\uc000\\ud835\\udc9frok;\\u4110\\u0800NTacdfglmopqstux\\u04bd\\u04c0\\u04c4\\u04cb\\u04de\\u04e2\\u04e7\\u04ee\\u04f5\\u0521\\u052f\\u0536\\u0552\\u055d\\u0560\\u0565G;\\u414aH\\u803b\\xd0\\u40d0cute\\u803b\\xc9\\u40c9\\u0180aiy\\u04d2\\u04d7\\u04dcron;\\u411arc\\u803b\\xca\\u40ca;\\u442dot;\\u4116r;\\uc000\\ud835\\udd08rave\\u803b\\xc8\\u40c8ement;\\u6208\\u0100ap\\u04fa\\u04fecr;\\u4112ty\\u0253\\u0506\\0\\0\\u0512mallSquare;\\u65fberySmallSquare;\\u65ab\\u0100gp\\u0526\\u052aon;\\u4118f;\\uc000\\ud835\\udd3csilon;\\u4395u\\u0100ai\\u053c\\u0549l\\u0100;T\\u0542\\u0543\\u6a75ilde;\\u6242librium;\\u61cc\\u0100ci\\u0557\\u055ar;\\u6130m;\\u6a73a;\\u4397ml\\u803b\\xcb\\u40cb\\u0100ip\\u056a\\u056fsts;\\u6203onentialE;\\u6147\\u0280cfios\\u0585\\u0588\\u058d\\u05b2\\u05ccy;\\u4424r;\\uc000\\ud835\\udd09lled\\u0253\\u0597\\0\\0\\u05a3mallSquare;\\u65fcerySmallSquare;\\u65aa\\u0370\\u05ba\\0\\u05bf\\0\\0\\u05c4f;\\uc000\\ud835\\udd3dAll;\\u6200riertrf;\\u6131c\\xf2\\u05cb\\u0600JTabcdfgorst\\u05e8\\u05ec\\u05ef\\u05fa\\u0600\\u0612\\u0616\\u061b\\u061d\\u0623\\u066c\\u0672cy;\\u4403\\u803b>\\u403emma\\u0100;d\\u05f7\\u05f8\\u4393;\\u43dcreve;\\u411e\\u0180eiy\\u0607\\u060c\\u0610dil;\\u4122rc;\\u411c;\\u4413ot;\\u4120r;\\uc000\\ud835\\udd0a;\\u62d9pf;\\uc000\\ud835\\udd3eeater\\u0300EFGLST\\u0635\\u0644\\u064e\\u0656\\u065b\\u0666qual\\u0100;L\\u063e\\u063f\\u6265ess;\\u62dbullEqual;\\u6267reater;\\u6aa2ess;\\u6277lantEqual;\\u6a7eilde;\\u6273cr;\\uc000\\ud835\\udca2;\\u626b\\u0400Aacfiosu\\u0685\\u068b\\u0696\\u069b\\u069e\\u06aa\\u06be\\u06caRDcy;\\u442a\\u0100ct\\u0690\\u0694ek;\\u42c7;\\u405eirc;\\u4124r;\\u610clbertSpace;\\u610b\\u01f0\\u06af\\0\\u06b2f;\\u610dizontalLine;\\u6500\\u0100ct\\u06c3\\u06c5\\xf2\\u06a9rok;\\u4126mp\\u0144\\u06d0\\u06d8ownHum\\xf0\\u012fqual;\\u624f\\u0700EJOacdfgmnostu\\u06fa\\u06fe\\u0703\\u0707\\u070e\\u071a\\u071e\\u0721\\u0728\\u0744\\u0778\\u078b\\u078f\\u0795cy;\\u4415lig;\\u4132cy;\\u4401cute\\u803b\\xcd\\u40cd\\u0100iy\\u0713\\u0718rc\\u803b\\xce\\u40ce;\\u4418ot;\\u4130r;\\u6111rave\\u803b\\xcc\\u40cc\\u0180;ap\\u0720\\u072f\\u073f\\u0100cg\\u0734\\u0737r;\\u412ainaryI;\\u6148lie\\xf3\\u03dd\\u01f4\\u0749\\0\\u0762\\u0100;e\\u074d\\u074e\\u622c\\u0100gr\\u0753\\u0758ral;\\u622bsection;\\u62c2isible\\u0100CT\\u076c\\u0772omma;\\u6063imes;\\u6062\\u0180gpt\\u077f\\u0783\\u0788on;\\u412ef;\\uc000\\ud835\\udd40a;\\u4399cr;\\u6110ilde;\\u4128\\u01eb\\u079a\\0\\u079ecy;\\u4406l\\u803b\\xcf\\u40cf\\u0280cfosu\\u07ac\\u07b7\\u07bc\\u07c2\\u07d0\\u0100iy\\u07b1\\u07b5rc;\\u4134;\\u4419r;\\uc000\\ud835\\udd0dpf;\\uc000\\ud835\\udd41\\u01e3\\u07c7\\0\\u07ccr;\\uc000\\ud835\\udca5rcy;\\u4408kcy;\\u4404\\u0380HJacfos\\u07e4\\u07e8\\u07ec\\u07f1\\u07fd\\u0802\\u0808cy;\\u4425cy;\\u440cppa;\\u439a\\u0100ey\\u07f6\\u07fbdil;\\u4136;\\u441ar;\\uc000\\ud835\\udd0epf;\\uc000\\ud835\\udd42cr;\\uc000\\ud835\\udca6\\u0580JTaceflmost\\u0825\\u0829\\u082c\\u0850\\u0863\\u09b3\\u09b8\\u09c7\\u09cd\\u0a37\\u0a47cy;\\u4409\\u803b<\\u403c\\u0280cmnpr\\u0837\\u083c\\u0841\\u0844\\u084dute;\\u4139bda;\\u439bg;\\u67ealacetrf;\\u6112r;\\u619e\\u0180aey\\u0857\\u085c\\u0861ron;\\u413ddil;\\u413b;\\u441b\\u0100fs\\u0868\\u0970t\\u0500ACDFRTUVar\\u087e\\u08a9\\u08b1\\u08e0\\u08e6\\u08fc\\u092f\\u095b\\u0390\\u096a\\u0100nr\\u0883\\u088fgleBracket;\\u67e8row\\u0180;BR\\u0899\\u089a\\u089e\\u6190ar;\\u61e4ightArrow;\\u61c6eiling;\\u6308o\\u01f5\\u08b7\\0\\u08c3bleBracket;\\u67e6n\\u01d4\\u08c8\\0\\u08d2eeVector;\\u6961ector\\u0100;B\\u08db\\u08dc\\u61c3ar;\\u6959loor;\\u630aight\\u0100AV\\u08ef\\u08f5rrow;\\u6194ector;\\u694e\\u0100er\\u0901\\u0917e\\u0180;AV\\u0909\\u090a\\u0910\\u62a3rrow;\\u61a4ector;\\u695aiangle\\u0180;BE\\u0924\\u0925\\u0929\\u62b2ar;\\u69cfqual;\\u62b4p\\u0180DTV\\u0937\\u0942\\u094cownVector;\\u6951eeVector;\\u6960ector\\u0100;B\\u0956\\u0957\\u61bfar;\\u6958ector\\u0100;B\\u0965\\u0966\\u61bcar;\\u6952ight\\xe1\\u039cs\\u0300EFGLST\\u097e\\u098b\\u0995\\u099d\\u09a2\\u09adqualGreater;\\u62daullEqual;\\u6266reater;\\u6276ess;\\u6aa1lantEqual;\\u6a7dilde;\\u6272r;\\uc000\\ud835\\udd0f\\u0100;e\\u09bd\\u09be\\u62d8ftarrow;\\u61daidot;\\u413f\\u0180npw\\u09d4\\u0a16\\u0a1bg\\u0200LRlr\\u09de\\u09f7\\u0a02\\u0a10eft\\u0100AR\\u09e6\\u09ecrrow;\\u67f5ightArrow;\\u67f7ightArrow;\\u67f6eft\\u0100ar\\u03b3\\u0a0aight\\xe1\\u03bfight\\xe1\\u03caf;\\uc000\\ud835\\udd43er\\u0100LR\\u0a22\\u0a2ceftArrow;\\u6199ightArrow;\\u6198\\u0180cht\\u0a3e\\u0a40\\u0a42\\xf2\\u084c;\\u61b0rok;\\u4141;\\u626a\\u0400acefiosu\\u0a5a\\u0a5d\\u0a60\\u0a77\\u0a7c\\u0a85\\u0a8b\\u0a8ep;\\u6905y;\\u441c\\u0100dl\\u0a65\\u0a6fiumSpace;\\u605flintrf;\\u6133r;\\uc000\\ud835\\udd10nusPlus;\\u6213pf;\\uc000\\ud835\\udd44c\\xf2\\u0a76;\\u439c\\u0480Jacefostu\\u0aa3\\u0aa7\\u0aad\\u0ac0\\u0b14\\u0b19\\u0d91\\u0d97\\u0d9ecy;\\u440acute;\\u4143\\u0180aey\\u0ab4\\u0ab9\\u0aberon;\\u4147dil;\\u4145;\\u441d\\u0180gsw\\u0ac7\\u0af0\\u0b0eative\\u0180MTV\\u0ad3\\u0adf\\u0ae8ediumSpace;\\u600bhi\\u0100cn\\u0ae6\\u0ad8\\xeb\\u0ad9eryThi\\xee\\u0ad9ted\\u0100GL\\u0af8\\u0b06reaterGreate\\xf2\\u0673essLes\\xf3\\u0a48Line;\\u400ar;\\uc000\\ud835\\udd11\\u0200Bnpt\\u0b22\\u0b28\\u0b37\\u0b3areak;\\u6060BreakingSpace;\\u40a0f;\\u6115\\u0680;CDEGHLNPRSTV\\u0b55\\u0b56\\u0b6a\\u0b7c\\u0ba1\\u0beb\\u0c04\\u0c5e\\u0c84\\u0ca6\\u0cd8\\u0d61\\u0d85\\u6aec\\u0100ou\\u0b5b\\u0b64ngruent;\\u6262pCap;\\u626doubleVerticalBar;\\u6226\\u0180lqx\\u0b83\\u0b8a\\u0b9bement;\\u6209ual\\u0100;T\\u0b92\\u0b93\\u6260ilde;\\uc000\\u2242\\u0338ists;\\u6204reater\\u0380;EFGLST\\u0bb6\\u0bb7\\u0bbd\\u0bc9\\u0bd3\\u0bd8\\u0be5\\u626fqual;\\u6271ullEqual;\\uc000\\u2267\\u0338reater;\\uc000\\u226b\\u0338ess;\\u6279lantEqual;\\uc000\\u2a7e\\u0338ilde;\\u6275ump\\u0144\\u0bf2\\u0bfdownHump;\\uc000\\u224e\\u0338qual;\\uc000\\u224f\\u0338e\\u0100fs\\u0c0a\\u0c27tTriangle\\u0180;BE\\u0c1a\\u0c1b\\u0c21\\u62eaar;\\uc000\\u29cf\\u0338qual;\\u62ecs\\u0300;EGLST\\u0c35\\u0c36\\u0c3c\\u0c44\\u0c4b\\u0c58\\u626equal;\\u6270reater;\\u6278ess;\\uc000\\u226a\\u0338lantEqual;\\uc000\\u2a7d\\u0338ilde;\\u6274ested\\u0100GL\\u0c68\\u0c79reaterGreater;\\uc000\\u2aa2\\u0338essLess;\\uc000\\u2aa1\\u0338recedes\\u0180;ES\\u0c92\\u0c93\\u0c9b\\u6280qual;\\uc000\\u2aaf\\u0338lantEqual;\\u62e0\\u0100ei\\u0cab\\u0cb9verseElement;\\u620cghtTriangle\\u0180;BE\\u0ccb\\u0ccc\\u0cd2\\u62ebar;\\uc000\\u29d0\\u0338qual;\\u62ed\\u0100qu\\u0cdd\\u0d0cuareSu\\u0100bp\\u0ce8\\u0cf9set\\u0100;E\\u0cf0\\u0cf3\\uc000\\u228f\\u0338qual;\\u62e2erset\\u0100;E\\u0d03\\u0d06\\uc000\\u2290\\u0338qual;\\u62e3\\u0180bcp\\u0d13\\u0d24\\u0d4eset\\u0100;E\\u0d1b\\u0d1e\\uc000\\u2282\\u20d2qual;\\u6288ceeds\\u0200;EST\\u0d32\\u0d33\\u0d3b\\u0d46\\u6281qual;\\uc000\\u2ab0\\u0338lantEqual;\\u62e1ilde;\\uc000\\u227f\\u0338erset\\u0100;E\\u0d58\\u0d5b\\uc000\\u2283\\u20d2qual;\\u6289ilde\\u0200;EFT\\u0d6e\\u0d6f\\u0d75\\u0d7f\\u6241qual;\\u6244ullEqual;\\u6247ilde;\\u6249erticalBar;\\u6224cr;\\uc000\\ud835\\udca9ilde\\u803b\\xd1\\u40d1;\\u439d\\u0700Eacdfgmoprstuv\\u0dbd\\u0dc2\\u0dc9\\u0dd5\\u0ddb\\u0de0\\u0de7\\u0dfc\\u0e02\\u0e20\\u0e22\\u0e32\\u0e3f\\u0e44lig;\\u4152cute\\u803b\\xd3\\u40d3\\u0100iy\\u0dce\\u0dd3rc\\u803b\\xd4\\u40d4;\\u441eblac;\\u4150r;\\uc000\\ud835\\udd12rave\\u803b\\xd2\\u40d2\\u0180aei\\u0dee\\u0df2\\u0df6cr;\\u414cga;\\u43a9cron;\\u439fpf;\\uc000\\ud835\\udd46enCurly\\u0100DQ\\u0e0e\\u0e1aoubleQuote;\\u601cuote;\\u6018;\\u6a54\\u0100cl\\u0e27\\u0e2cr;\\uc000\\ud835\\udcaaash\\u803b\\xd8\\u40d8i\\u016c\\u0e37\\u0e3cde\\u803b\\xd5\\u40d5es;\\u6a37ml\\u803b\\xd6\\u40d6er\\u0100BP\\u0e4b\\u0e60\\u0100ar\\u0e50\\u0e53r;\\u603eac\\u0100ek\\u0e5a\\u0e5c;\\u63deet;\\u63b4arenthesis;\\u63dc\\u0480acfhilors\\u0e7f\\u0e87\\u0e8a\\u0e8f\\u0e92\\u0e94\\u0e9d\\u0eb0\\u0efcrtialD;\\u6202y;\\u441fr;\\uc000\\ud835\\udd13i;\\u43a6;\\u43a0usMinus;\\u40b1\\u0100ip\\u0ea2\\u0eadncareplan\\xe5\\u069df;\\u6119\\u0200;eio\\u0eb9\\u0eba\\u0ee0\\u0ee4\\u6abbcedes\\u0200;EST\\u0ec8\\u0ec9\\u0ecf\\u0eda\\u627aqual;\\u6aaflantEqual;\\u627cilde;\\u627eme;\\u6033\\u0100dp\\u0ee9\\u0eeeuct;\\u620fortion\\u0100;a\\u0225\\u0ef9l;\\u621d\\u0100ci\\u0f01\\u0f06r;\\uc000\\ud835\\udcab;\\u43a8\\u0200Ufos\\u0f11\\u0f16\\u0f1b\\u0f1fOT\\u803b\\\"\\u4022r;\\uc000\\ud835\\udd14pf;\\u611acr;\\uc000\\ud835\\udcac\\u0600BEacefhiorsu\\u0f3e\\u0f43\\u0f47\\u0f60\\u0f73\\u0fa7\\u0faa\\u0fad\\u1096\\u10a9\\u10b4\\u10bearr;\\u6910G\\u803b\\xae\\u40ae\\u0180cnr\\u0f4e\\u0f53\\u0f56ute;\\u4154g;\\u67ebr\\u0100;t\\u0f5c\\u0f5d\\u61a0l;\\u6916\\u0180aey\\u0f67\\u0f6c\\u0f71ron;\\u4158dil;\\u4156;\\u4420\\u0100;v\\u0f78\\u0f79\\u611cerse\\u0100EU\\u0f82\\u0f99\\u0100lq\\u0f87\\u0f8eement;\\u620builibrium;\\u61cbpEquilibrium;\\u696fr\\xbb\\u0f79o;\\u43a1ght\\u0400ACDFTUVa\\u0fc1\\u0feb\\u0ff3\\u1022\\u1028\\u105b\\u1087\\u03d8\\u0100nr\\u0fc6\\u0fd2gleBracket;\\u67e9row\\u0180;BL\\u0fdc\\u0fdd\\u0fe1\\u6192ar;\\u61e5eftArrow;\\u61c4eiling;\\u6309o\\u01f5\\u0ff9\\0\\u1005bleBracket;\\u67e7n\\u01d4\\u100a\\0\\u1014eeVector;\\u695dector\\u0100;B\\u101d\\u101e\\u61c2ar;\\u6955loor;\\u630b\\u0100er\\u102d\\u1043e\\u0180;AV\\u1035\\u1036\\u103c\\u62a2rrow;\\u61a6ector;\\u695biangle\\u0180;BE\\u1050\\u1051\\u1055\\u62b3ar;\\u69d0qual;\\u62b5p\\u0180DTV\\u1063\\u106e\\u1078ownVector;\\u694feeVector;\\u695cector\\u0100;B\\u1082\\u1083\\u61bear;\\u6954ector\\u0100;B\\u1091\\u1092\\u61c0ar;\\u6953\\u0100pu\\u109b\\u109ef;\\u611dndImplies;\\u6970ightarrow;\\u61db\\u0100ch\\u10b9\\u10bcr;\\u611b;\\u61b1leDelayed;\\u69f4\\u0680HOacfhimoqstu\\u10e4\\u10f1\\u10f7\\u10fd\\u1119\\u111e\\u1151\\u1156\\u1161\\u1167\\u11b5\\u11bb\\u11bf\\u0100Cc\\u10e9\\u10eeHcy;\\u4429y;\\u4428FTcy;\\u442ccute;\\u415a\\u0280;aeiy\\u1108\\u1109\\u110e\\u1113\\u1117\\u6abcron;\\u4160dil;\\u415erc;\\u415c;\\u4421r;\\uc000\\ud835\\udd16ort\\u0200DLRU\\u112a\\u1134\\u113e\\u1149ownArrow\\xbb\\u041eeftArrow\\xbb\\u089aightArrow\\xbb\\u0fddpArrow;\\u6191gma;\\u43a3allCircle;\\u6218pf;\\uc000\\ud835\\udd4a\\u0272\\u116d\\0\\0\\u1170t;\\u621aare\\u0200;ISU\\u117b\\u117c\\u1189\\u11af\\u65a1ntersection;\\u6293u\\u0100bp\\u118f\\u119eset\\u0100;E\\u1197\\u1198\\u628fqual;\\u6291erset\\u0100;E\\u11a8\\u11a9\\u6290qual;\\u6292nion;\\u6294cr;\\uc000\\ud835\\udcaear;\\u62c6\\u0200bcmp\\u11c8\\u11db\\u1209\\u120b\\u0100;s\\u11cd\\u11ce\\u62d0et\\u0100;E\\u11cd\\u11d5qual;\\u6286\\u0100ch\\u11e0\\u1205eeds\\u0200;EST\\u11ed\\u11ee\\u11f4\\u11ff\\u627bqual;\\u6ab0lantEqual;\\u627dilde;\\u627fTh\\xe1\\u0f8c;\\u6211\\u0180;es\\u1212\\u1213\\u1223\\u62d1rset\\u0100;E\\u121c\\u121d\\u6283qual;\\u6287et\\xbb\\u1213\\u0580HRSacfhiors\\u123e\\u1244\\u1249\\u1255\\u125e\\u1271\\u1276\\u129f\\u12c2\\u12c8\\u12d1ORN\\u803b\\xde\\u40deADE;\\u6122\\u0100Hc\\u124e\\u1252cy;\\u440by;\\u4426\\u0100bu\\u125a\\u125c;\\u4009;\\u43a4\\u0180aey\\u1265\\u126a\\u126fron;\\u4164dil;\\u4162;\\u4422r;\\uc000\\ud835\\udd17\\u0100ei\\u127b\\u1289\\u01f2\\u1280\\0\\u1287efore;\\u6234a;\\u4398\\u0100cn\\u128e\\u1298kSpace;\\uc000\\u205f\\u200aSpace;\\u6009lde\\u0200;EFT\\u12ab\\u12ac\\u12b2\\u12bc\\u623cqual;\\u6243ullEqual;\\u6245ilde;\\u6248pf;\\uc000\\ud835\\udd4bipleDot;\\u60db\\u0100ct\\u12d6\\u12dbr;\\uc000\\ud835\\udcafrok;\\u4166\\u0ae1\\u12f7\\u130e\\u131a\\u1326\\0\\u132c\\u1331\\0\\0\\0\\0\\0\\u1338\\u133d\\u1377\\u1385\\0\\u13ff\\u1404\\u140a\\u1410\\u0100cr\\u12fb\\u1301ute\\u803b\\xda\\u40dar\\u0100;o\\u1307\\u1308\\u619fcir;\\u6949r\\u01e3\\u1313\\0\\u1316y;\\u440eve;\\u416c\\u0100iy\\u131e\\u1323rc\\u803b\\xdb\\u40db;\\u4423blac;\\u4170r;\\uc000\\ud835\\udd18rave\\u803b\\xd9\\u40d9acr;\\u416a\\u0100di\\u1341\\u1369er\\u0100BP\\u1348\\u135d\\u0100ar\\u134d\\u1350r;\\u405fac\\u0100ek\\u1357\\u1359;\\u63dfet;\\u63b5arenthesis;\\u63ddon\\u0100;P\\u1370\\u1371\\u62c3lus;\\u628e\\u0100gp\\u137b\\u137fon;\\u4172f;\\uc000\\ud835\\udd4c\\u0400ADETadps\\u1395\\u13ae\\u13b8\\u13c4\\u03e8\\u13d2\\u13d7\\u13f3rrow\\u0180;BD\\u1150\\u13a0\\u13a4ar;\\u6912ownArrow;\\u61c5ownArrow;\\u6195quilibrium;\\u696eee\\u0100;A\\u13cb\\u13cc\\u62a5rrow;\\u61a5own\\xe1\\u03f3er\\u0100LR\\u13de\\u13e8eftArrow;\\u6196ightArrow;\\u6197i\\u0100;l\\u13f9\\u13fa\\u43d2on;\\u43a5ing;\\u416ecr;\\uc000\\ud835\\udcb0ilde;\\u4168ml\\u803b\\xdc\\u40dc\\u0480Dbcdefosv\\u1427\\u142c\\u1430\\u1433\\u143e\\u1485\\u148a\\u1490\\u1496ash;\\u62abar;\\u6aeby;\\u4412ash\\u0100;l\\u143b\\u143c\\u62a9;\\u6ae6\\u0100er\\u1443\\u1445;\\u62c1\\u0180bty\\u144c\\u1450\\u147aar;\\u6016\\u0100;i\\u144f\\u1455cal\\u0200BLST\\u1461\\u1465\\u146a\\u1474ar;\\u6223ine;\\u407ceparator;\\u6758ilde;\\u6240ThinSpace;\\u600ar;\\uc000\\ud835\\udd19pf;\\uc000\\ud835\\udd4dcr;\\uc000\\ud835\\udcb1dash;\\u62aa\\u0280cefos\\u14a7\\u14ac\\u14b1\\u14b6\\u14bcirc;\\u4174dge;\\u62c0r;\\uc000\\ud835\\udd1apf;\\uc000\\ud835\\udd4ecr;\\uc000\\ud835\\udcb2\\u0200fios\\u14cb\\u14d0\\u14d2\\u14d8r;\\uc000\\ud835\\udd1b;\\u439epf;\\uc000\\ud835\\udd4fcr;\\uc000\\ud835\\udcb3\\u0480AIUacfosu\\u14f1\\u14f5\\u14f9\\u14fd\\u1504\\u150f\\u1514\\u151a\\u1520cy;\\u442fcy;\\u4407cy;\\u442ecute\\u803b\\xdd\\u40dd\\u0100iy\\u1509\\u150drc;\\u4176;\\u442br;\\uc000\\ud835\\udd1cpf;\\uc000\\ud835\\udd50cr;\\uc000\\ud835\\udcb4ml;\\u4178\\u0400Hacdefos\\u1535\\u1539\\u153f\\u154b\\u154f\\u155d\\u1560\\u1564cy;\\u4416cute;\\u4179\\u0100ay\\u1544\\u1549ron;\\u417d;\\u4417ot;\\u417b\\u01f2\\u1554\\0\\u155boWidt\\xe8\\u0ad9a;\\u4396r;\\u6128pf;\\u6124cr;\\uc000\\ud835\\udcb5\\u0be1\\u1583\\u158a\\u1590\\0\\u15b0\\u15b6\\u15bf\\0\\0\\0\\0\\u15c6\\u15db\\u15eb\\u165f\\u166d\\0\\u1695\\u169b\\u16b2\\u16b9\\0\\u16becute\\u803b\\xe1\\u40e1reve;\\u4103\\u0300;Ediuy\\u159c\\u159d\\u15a1\\u15a3\\u15a8\\u15ad\\u623e;\\uc000\\u223e\\u0333;\\u623frc\\u803b\\xe2\\u40e2te\\u80bb\\xb4\\u0306;\\u4430lig\\u803b\\xe6\\u40e6\\u0100;r\\xb2\\u15ba;\\uc000\\ud835\\udd1erave\\u803b\\xe0\\u40e0\\u0100ep\\u15ca\\u15d6\\u0100fp\\u15cf\\u15d4sym;\\u6135\\xe8\\u15d3ha;\\u43b1\\u0100ap\\u15dfc\\u0100cl\\u15e4\\u15e7r;\\u4101g;\\u6a3f\\u0264\\u15f0\\0\\0\\u160a\\u0280;adsv\\u15fa\\u15fb\\u15ff\\u1601\\u1607\\u6227nd;\\u6a55;\\u6a5clope;\\u6a58;\\u6a5a\\u0380;elmrsz\\u1618\\u1619\\u161b\\u161e\\u163f\\u164f\\u1659\\u6220;\\u69a4e\\xbb\\u1619sd\\u0100;a\\u1625\\u1626\\u6221\\u0461\\u1630\\u1632\\u1634\\u1636\\u1638\\u163a\\u163c\\u163e;\\u69a8;\\u69a9;\\u69aa;\\u69ab;\\u69ac;\\u69ad;\\u69ae;\\u69aft\\u0100;v\\u1645\\u1646\\u621fb\\u0100;d\\u164c\\u164d\\u62be;\\u699d\\u0100pt\\u1654\\u1657h;\\u6222\\xbb\\xb9arr;\\u637c\\u0100gp\\u1663\\u1667on;\\u4105f;\\uc000\\ud835\\udd52\\u0380;Eaeiop\\u12c1\\u167b\\u167d\\u1682\\u1684\\u1687\\u168a;\\u6a70cir;\\u6a6f;\\u624ad;\\u624bs;\\u4027rox\\u0100;e\\u12c1\\u1692\\xf1\\u1683ing\\u803b\\xe5\\u40e5\\u0180cty\\u16a1\\u16a6\\u16a8r;\\uc000\\ud835\\udcb6;\\u402amp\\u0100;e\\u12c1\\u16af\\xf1\\u0288ilde\\u803b\\xe3\\u40e3ml\\u803b\\xe4\\u40e4\\u0100ci\\u16c2\\u16c8onin\\xf4\\u0272nt;\\u6a11\\u0800Nabcdefiklnoprsu\\u16ed\\u16f1\\u1730\\u173c\\u1743\\u1748\\u1778\\u177d\\u17e0\\u17e6\\u1839\\u1850\\u170d\\u193d\\u1948\\u1970ot;\\u6aed\\u0100cr\\u16f6\\u171ek\\u0200ceps\\u1700\\u1705\\u170d\\u1713ong;\\u624cpsilon;\\u43f6rime;\\u6035im\\u0100;e\\u171a\\u171b\\u623dq;\\u62cd\\u0176\\u1722\\u1726ee;\\u62bded\\u0100;g\\u172c\\u172d\\u6305e\\xbb\\u172drk\\u0100;t\\u135c\\u1737brk;\\u63b6\\u0100oy\\u1701\\u1741;\\u4431quo;\\u601e\\u0280cmprt\\u1753\\u175b\\u1761\\u1764\\u1768aus\\u0100;e\\u010a\\u0109ptyv;\\u69b0s\\xe9\\u170cno\\xf5\\u0113\\u0180ahw\\u176f\\u1771\\u1773;\\u43b2;\\u6136een;\\u626cr;\\uc000\\ud835\\udd1fg\\u0380costuvw\\u178d\\u179d\\u17b3\\u17c1\\u17d5\\u17db\\u17de\\u0180aiu\\u1794\\u1796\\u179a\\xf0\\u0760rc;\\u65efp\\xbb\\u1371\\u0180dpt\\u17a4\\u17a8\\u17adot;\\u6a00lus;\\u6a01imes;\\u6a02\\u0271\\u17b9\\0\\0\\u17becup;\\u6a06ar;\\u6605riangle\\u0100du\\u17cd\\u17d2own;\\u65bdp;\\u65b3plus;\\u6a04e\\xe5\\u1444\\xe5\\u14adarow;\\u690d\\u0180ako\\u17ed\\u1826\\u1835\\u0100cn\\u17f2\\u1823k\\u0180lst\\u17fa\\u05ab\\u1802ozenge;\\u69ebriangle\\u0200;dlr\\u1812\\u1813\\u1818\\u181d\\u65b4own;\\u65beeft;\\u65c2ight;\\u65b8k;\\u6423\\u01b1\\u182b\\0\\u1833\\u01b2\\u182f\\0\\u1831;\\u6592;\\u65914;\\u6593ck;\\u6588\\u0100eo\\u183e\\u184d\\u0100;q\\u1843\\u1846\\uc000=\\u20e5uiv;\\uc000\\u2261\\u20e5t;\\u6310\\u0200ptwx\\u1859\\u185e\\u1867\\u186cf;\\uc000\\ud835\\udd53\\u0100;t\\u13cb\\u1863om\\xbb\\u13cctie;\\u62c8\\u0600DHUVbdhmptuv\\u1885\\u1896\\u18aa\\u18bb\\u18d7\\u18db\\u18ec\\u18ff\\u1905\\u190a\\u1910\\u1921\\u0200LRlr\\u188e\\u1890\\u1892\\u1894;\\u6557;\\u6554;\\u6556;\\u6553\\u0280;DUdu\\u18a1\\u18a2\\u18a4\\u18a6\\u18a8\\u6550;\\u6566;\\u6569;\\u6564;\\u6567\\u0200LRlr\\u18b3\\u18b5\\u18b7\\u18b9;\\u655d;\\u655a;\\u655c;\\u6559\\u0380;HLRhlr\\u18ca\\u18cb\\u18cd\\u18cf\\u18d1\\u18d3\\u18d5\\u6551;\\u656c;\\u6563;\\u6560;\\u656b;\\u6562;\\u655fox;\\u69c9\\u0200LRlr\\u18e4\\u18e6\\u18e8\\u18ea;\\u6555;\\u6552;\\u6510;\\u650c\\u0280;DUdu\\u06bd\\u18f7\\u18f9\\u18fb\\u18fd;\\u6565;\\u6568;\\u652c;\\u6534inus;\\u629flus;\\u629eimes;\\u62a0\\u0200LRlr\\u1919\\u191b\\u191d\\u191f;\\u655b;\\u6558;\\u6518;\\u6514\\u0380;HLRhlr\\u1930\\u1931\\u1933\\u1935\\u1937\\u1939\\u193b\\u6502;\\u656a;\\u6561;\\u655e;\\u653c;\\u6524;\\u651c\\u0100ev\\u0123\\u1942bar\\u803b\\xa6\\u40a6\\u0200ceio\\u1951\\u1956\\u195a\\u1960r;\\uc000\\ud835\\udcb7mi;\\u604fm\\u0100;e\\u171a\\u171cl\\u0180;bh\\u1968\\u1969\\u196b\\u405c;\\u69c5sub;\\u67c8\\u016c\\u1974\\u197el\\u0100;e\\u1979\\u197a\\u6022t\\xbb\\u197ap\\u0180;Ee\\u012f\\u1985\\u1987;\\u6aae\\u0100;q\\u06dc\\u06db\\u0ce1\\u19a7\\0\\u19e8\\u1a11\\u1a15\\u1a32\\0\\u1a37\\u1a50\\0\\0\\u1ab4\\0\\0\\u1ac1\\0\\0\\u1b21\\u1b2e\\u1b4d\\u1b52\\0\\u1bfd\\0\\u1c0c\\u0180cpr\\u19ad\\u19b2\\u19ddute;\\u4107\\u0300;abcds\\u19bf\\u19c0\\u19c4\\u19ca\\u19d5\\u19d9\\u6229nd;\\u6a44rcup;\\u6a49\\u0100au\\u19cf\\u19d2p;\\u6a4bp;\\u6a47ot;\\u6a40;\\uc000\\u2229\\ufe00\\u0100eo\\u19e2\\u19e5t;\\u6041\\xee\\u0693\\u0200aeiu\\u19f0\\u19fb\\u1a01\\u1a05\\u01f0\\u19f5\\0\\u19f8s;\\u6a4don;\\u410ddil\\u803b\\xe7\\u40e7rc;\\u4109ps\\u0100;s\\u1a0c\\u1a0d\\u6a4cm;\\u6a50ot;\\u410b\\u0180dmn\\u1a1b\\u1a20\\u1a26il\\u80bb\\xb8\\u01adptyv;\\u69b2t\\u8100\\xa2;e\\u1a2d\\u1a2e\\u40a2r\\xe4\\u01b2r;\\uc000\\ud835\\udd20\\u0180cei\\u1a3d\\u1a40\\u1a4dy;\\u4447ck\\u0100;m\\u1a47\\u1a48\\u6713ark\\xbb\\u1a48;\\u43c7r\\u0380;Ecefms\\u1a5f\\u1a60\\u1a62\\u1a6b\\u1aa4\\u1aaa\\u1aae\\u65cb;\\u69c3\\u0180;el\\u1a69\\u1a6a\\u1a6d\\u42c6q;\\u6257e\\u0261\\u1a74\\0\\0\\u1a88rrow\\u0100lr\\u1a7c\\u1a81eft;\\u61baight;\\u61bb\\u0280RSacd\\u1a92\\u1a94\\u1a96\\u1a9a\\u1a9f\\xbb\\u0f47;\\u64c8st;\\u629birc;\\u629aash;\\u629dnint;\\u6a10id;\\u6aefcir;\\u69c2ubs\\u0100;u\\u1abb\\u1abc\\u6663it\\xbb\\u1abc\\u02ec\\u1ac7\\u1ad4\\u1afa\\0\\u1b0aon\\u0100;e\\u1acd\\u1ace\\u403a\\u0100;q\\xc7\\xc6\\u026d\\u1ad9\\0\\0\\u1ae2a\\u0100;t\\u1ade\\u1adf\\u402c;\\u4040\\u0180;fl\\u1ae8\\u1ae9\\u1aeb\\u6201\\xee\\u1160e\\u0100mx\\u1af1\\u1af6ent\\xbb\\u1ae9e\\xf3\\u024d\\u01e7\\u1afe\\0\\u1b07\\u0100;d\\u12bb\\u1b02ot;\\u6a6dn\\xf4\\u0246\\u0180fry\\u1b10\\u1b14\\u1b17;\\uc000\\ud835\\udd54o\\xe4\\u0254\\u8100\\xa9;s\\u0155\\u1b1dr;\\u6117\\u0100ao\\u1b25\\u1b29rr;\\u61b5ss;\\u6717\\u0100cu\\u1b32\\u1b37r;\\uc000\\ud835\\udcb8\\u0100bp\\u1b3c\\u1b44\\u0100;e\\u1b41\\u1b42\\u6acf;\\u6ad1\\u0100;e\\u1b49\\u1b4a\\u6ad0;\\u6ad2dot;\\u62ef\\u0380delprvw\\u1b60\\u1b6c\\u1b77\\u1b82\\u1bac\\u1bd4\\u1bf9arr\\u0100lr\\u1b68\\u1b6a;\\u6938;\\u6935\\u0270\\u1b72\\0\\0\\u1b75r;\\u62dec;\\u62dfarr\\u0100;p\\u1b7f\\u1b80\\u61b6;\\u693d\\u0300;bcdos\\u1b8f\\u1b90\\u1b96\\u1ba1\\u1ba5\\u1ba8\\u622arcap;\\u6a48\\u0100au\\u1b9b\\u1b9ep;\\u6a46p;\\u6a4aot;\\u628dr;\\u6a45;\\uc000\\u222a\\ufe00\\u0200alrv\\u1bb5\\u1bbf\\u1bde\\u1be3rr\\u0100;m\\u1bbc\\u1bbd\\u61b7;\\u693cy\\u0180evw\\u1bc7\\u1bd4\\u1bd8q\\u0270\\u1bce\\0\\0\\u1bd2re\\xe3\\u1b73u\\xe3\\u1b75ee;\\u62ceedge;\\u62cfen\\u803b\\xa4\\u40a4earrow\\u0100lr\\u1bee\\u1bf3eft\\xbb\\u1b80ight\\xbb\\u1bbde\\xe4\\u1bdd\\u0100ci\\u1c01\\u1c07onin\\xf4\\u01f7nt;\\u6231lcty;\\u632d\\u0980AHabcdefhijlorstuwz\\u1c38\\u1c3b\\u1c3f\\u1c5d\\u1c69\\u1c75\\u1c8a\\u1c9e\\u1cac\\u1cb7\\u1cfb\\u1cff\\u1d0d\\u1d7b\\u1d91\\u1dab\\u1dbb\\u1dc6\\u1dcdr\\xf2\\u0381ar;\\u6965\\u0200glrs\\u1c48\\u1c4d\\u1c52\\u1c54ger;\\u6020eth;\\u6138\\xf2\\u1133h\\u0100;v\\u1c5a\\u1c5b\\u6010\\xbb\\u090a\\u016b\\u1c61\\u1c67arow;\\u690fa\\xe3\\u0315\\u0100ay\\u1c6e\\u1c73ron;\\u410f;\\u4434\\u0180;ao\\u0332\\u1c7c\\u1c84\\u0100gr\\u02bf\\u1c81r;\\u61catseq;\\u6a77\\u0180glm\\u1c91\\u1c94\\u1c98\\u803b\\xb0\\u40b0ta;\\u43b4ptyv;\\u69b1\\u0100ir\\u1ca3\\u1ca8sht;\\u697f;\\uc000\\ud835\\udd21ar\\u0100lr\\u1cb3\\u1cb5\\xbb\\u08dc\\xbb\\u101e\\u0280aegsv\\u1cc2\\u0378\\u1cd6\\u1cdc\\u1ce0m\\u0180;os\\u0326\\u1cca\\u1cd4nd\\u0100;s\\u0326\\u1cd1uit;\\u6666amma;\\u43ddin;\\u62f2\\u0180;io\\u1ce7\\u1ce8\\u1cf8\\u40f7de\\u8100\\xf7;o\\u1ce7\\u1cf0ntimes;\\u62c7n\\xf8\\u1cf7cy;\\u4452c\\u026f\\u1d06\\0\\0\\u1d0arn;\\u631eop;\\u630d\\u0280lptuw\\u1d18\\u1d1d\\u1d22\\u1d49\\u1d55lar;\\u4024f;\\uc000\\ud835\\udd55\\u0280;emps\\u030b\\u1d2d\\u1d37\\u1d3d\\u1d42q\\u0100;d\\u0352\\u1d33ot;\\u6251inus;\\u6238lus;\\u6214quare;\\u62a1blebarwedg\\xe5\\xfan\\u0180adh\\u112e\\u1d5d\\u1d67ownarrow\\xf3\\u1c83arpoon\\u0100lr\\u1d72\\u1d76ef\\xf4\\u1cb4igh\\xf4\\u1cb6\\u0162\\u1d7f\\u1d85karo\\xf7\\u0f42\\u026f\\u1d8a\\0\\0\\u1d8ern;\\u631fop;\\u630c\\u0180cot\\u1d98\\u1da3\\u1da6\\u0100ry\\u1d9d\\u1da1;\\uc000\\ud835\\udcb9;\\u4455l;\\u69f6rok;\\u4111\\u0100dr\\u1db0\\u1db4ot;\\u62f1i\\u0100;f\\u1dba\\u1816\\u65bf\\u0100ah\\u1dc0\\u1dc3r\\xf2\\u0429a\\xf2\\u0fa6angle;\\u69a6\\u0100ci\\u1dd2\\u1dd5y;\\u445fgrarr;\\u67ff\\u0900Dacdefglmnopqrstux\\u1e01\\u1e09\\u1e19\\u1e38\\u0578\\u1e3c\\u1e49\\u1e61\\u1e7e\\u1ea5\\u1eaf\\u1ebd\\u1ee1\\u1f2a\\u1f37\\u1f44\\u1f4e\\u1f5a\\u0100Do\\u1e06\\u1d34o\\xf4\\u1c89\\u0100cs\\u1e0e\\u1e14ute\\u803b\\xe9\\u40e9ter;\\u6a6e\\u0200aioy\\u1e22\\u1e27\\u1e31\\u1e36ron;\\u411br\\u0100;c\\u1e2d\\u1e2e\\u6256\\u803b\\xea\\u40ealon;\\u6255;\\u444dot;\\u4117\\u0100Dr\\u1e41\\u1e45ot;\\u6252;\\uc000\\ud835\\udd22\\u0180;rs\\u1e50\\u1e51\\u1e57\\u6a9aave\\u803b\\xe8\\u40e8\\u0100;d\\u1e5c\\u1e5d\\u6a96ot;\\u6a98\\u0200;ils\\u1e6a\\u1e6b\\u1e72\\u1e74\\u6a99nters;\\u63e7;\\u6113\\u0100;d\\u1e79\\u1e7a\\u6a95ot;\\u6a97\\u0180aps\\u1e85\\u1e89\\u1e97cr;\\u4113ty\\u0180;sv\\u1e92\\u1e93\\u1e95\\u6205et\\xbb\\u1e93p\\u01001;\\u1e9d\\u1ea4\\u0133\\u1ea1\\u1ea3;\\u6004;\\u6005\\u6003\\u0100gs\\u1eaa\\u1eac;\\u414bp;\\u6002\\u0100gp\\u1eb4\\u1eb8on;\\u4119f;\\uc000\\ud835\\udd56\\u0180als\\u1ec4\\u1ece\\u1ed2r\\u0100;s\\u1eca\\u1ecb\\u62d5l;\\u69e3us;\\u6a71i\\u0180;lv\\u1eda\\u1edb\\u1edf\\u43b5on\\xbb\\u1edb;\\u43f5\\u0200csuv\\u1eea\\u1ef3\\u1f0b\\u1f23\\u0100io\\u1eef\\u1e31rc\\xbb\\u1e2e\\u0269\\u1ef9\\0\\0\\u1efb\\xed\\u0548ant\\u0100gl\\u1f02\\u1f06tr\\xbb\\u1e5dess\\xbb\\u1e7a\\u0180aei\\u1f12\\u1f16\\u1f1als;\\u403dst;\\u625fv\\u0100;D\\u0235\\u1f20D;\\u6a78parsl;\\u69e5\\u0100Da\\u1f2f\\u1f33ot;\\u6253rr;\\u6971\\u0180cdi\\u1f3e\\u1f41\\u1ef8r;\\u612fo\\xf4\\u0352\\u0100ah\\u1f49\\u1f4b;\\u43b7\\u803b\\xf0\\u40f0\\u0100mr\\u1f53\\u1f57l\\u803b\\xeb\\u40ebo;\\u60ac\\u0180cip\\u1f61\\u1f64\\u1f67l;\\u4021s\\xf4\\u056e\\u0100eo\\u1f6c\\u1f74ctatio\\xee\\u0559nential\\xe5\\u0579\\u09e1\\u1f92\\0\\u1f9e\\0\\u1fa1\\u1fa7\\0\\0\\u1fc6\\u1fcc\\0\\u1fd3\\0\\u1fe6\\u1fea\\u2000\\0\\u2008\\u205allingdotse\\xf1\\u1e44y;\\u4444male;\\u6640\\u0180ilr\\u1fad\\u1fb3\\u1fc1lig;\\u8000\\ufb03\\u0269\\u1fb9\\0\\0\\u1fbdg;\\u8000\\ufb00ig;\\u8000\\ufb04;\\uc000\\ud835\\udd23lig;\\u8000\\ufb01lig;\\uc000fj\\u0180alt\\u1fd9\\u1fdc\\u1fe1t;\\u666dig;\\u8000\\ufb02ns;\\u65b1of;\\u4192\\u01f0\\u1fee\\0\\u1ff3f;\\uc000\\ud835\\udd57\\u0100ak\\u05bf\\u1ff7\\u0100;v\\u1ffc\\u1ffd\\u62d4;\\u6ad9artint;\\u6a0d\\u0100ao\\u200c\\u2055\\u0100cs\\u2011\\u2052\\u03b1\\u201a\\u2030\\u2038\\u2045\\u2048\\0\\u2050\\u03b2\\u2022\\u2025\\u2027\\u202a\\u202c\\0\\u202e\\u803b\\xbd\\u40bd;\\u6153\\u803b\\xbc\\u40bc;\\u6155;\\u6159;\\u615b\\u01b3\\u2034\\0\\u2036;\\u6154;\\u6156\\u02b4\\u203e\\u2041\\0\\0\\u2043\\u803b\\xbe\\u40be;\\u6157;\\u615c5;\\u6158\\u01b6\\u204c\\0\\u204e;\\u615a;\\u615d8;\\u615el;\\u6044wn;\\u6322cr;\\uc000\\ud835\\udcbb\\u0880Eabcdefgijlnorstv\\u2082\\u2089\\u209f\\u20a5\\u20b0\\u20b4\\u20f0\\u20f5\\u20fa\\u20ff\\u2103\\u2112\\u2138\\u0317\\u213e\\u2152\\u219e\\u0100;l\\u064d\\u2087;\\u6a8c\\u0180cmp\\u2090\\u2095\\u209dute;\\u41f5ma\\u0100;d\\u209c\\u1cda\\u43b3;\\u6a86reve;\\u411f\\u0100iy\\u20aa\\u20aerc;\\u411d;\\u4433ot;\\u4121\\u0200;lqs\\u063e\\u0642\\u20bd\\u20c9\\u0180;qs\\u063e\\u064c\\u20c4lan\\xf4\\u0665\\u0200;cdl\\u0665\\u20d2\\u20d5\\u20e5c;\\u6aa9ot\\u0100;o\\u20dc\\u20dd\\u6a80\\u0100;l\\u20e2\\u20e3\\u6a82;\\u6a84\\u0100;e\\u20ea\\u20ed\\uc000\\u22db\\ufe00s;\\u6a94r;\\uc000\\ud835\\udd24\\u0100;g\\u0673\\u061bmel;\\u6137cy;\\u4453\\u0200;Eaj\\u065a\\u210c\\u210e\\u2110;\\u6a92;\\u6aa5;\\u6aa4\\u0200Eaes\\u211b\\u211d\\u2129\\u2134;\\u6269p\\u0100;p\\u2123\\u2124\\u6a8arox\\xbb\\u2124\\u0100;q\\u212e\\u212f\\u6a88\\u0100;q\\u212e\\u211bim;\\u62e7pf;\\uc000\\ud835\\udd58\\u0100ci\\u2143\\u2146r;\\u610am\\u0180;el\\u066b\\u214e\\u2150;\\u6a8e;\\u6a90\\u8300>;cdlqr\\u05ee\\u2160\\u216a\\u216e\\u2173\\u2179\\u0100ci\\u2165\\u2167;\\u6aa7r;\\u6a7aot;\\u62d7Par;\\u6995uest;\\u6a7c\\u0280adels\\u2184\\u216a\\u2190\\u0656\\u219b\\u01f0\\u2189\\0\\u218epro\\xf8\\u209er;\\u6978q\\u0100lq\\u063f\\u2196les\\xf3\\u2088i\\xed\\u066b\\u0100en\\u21a3\\u21adrtneqq;\\uc000\\u2269\\ufe00\\xc5\\u21aa\\u0500Aabcefkosy\\u21c4\\u21c7\\u21f1\\u21f5\\u21fa\\u2218\\u221d\\u222f\\u2268\\u227dr\\xf2\\u03a0\\u0200ilmr\\u21d0\\u21d4\\u21d7\\u21dbrs\\xf0\\u1484f\\xbb\\u2024il\\xf4\\u06a9\\u0100dr\\u21e0\\u21e4cy;\\u444a\\u0180;cw\\u08f4\\u21eb\\u21efir;\\u6948;\\u61adar;\\u610firc;\\u4125\\u0180alr\\u2201\\u220e\\u2213rts\\u0100;u\\u2209\\u220a\\u6665it\\xbb\\u220alip;\\u6026con;\\u62b9r;\\uc000\\ud835\\udd25s\\u0100ew\\u2223\\u2229arow;\\u6925arow;\\u6926\\u0280amopr\\u223a\\u223e\\u2243\\u225e\\u2263rr;\\u61fftht;\\u623bk\\u0100lr\\u2249\\u2253eftarrow;\\u61a9ightarrow;\\u61aaf;\\uc000\\ud835\\udd59bar;\\u6015\\u0180clt\\u226f\\u2274\\u2278r;\\uc000\\ud835\\udcbdas\\xe8\\u21f4rok;\\u4127\\u0100bp\\u2282\\u2287ull;\\u6043hen\\xbb\\u1c5b\\u0ae1\\u22a3\\0\\u22aa\\0\\u22b8\\u22c5\\u22ce\\0\\u22d5\\u22f3\\0\\0\\u22f8\\u2322\\u2367\\u2362\\u237f\\0\\u2386\\u23aa\\u23b4cute\\u803b\\xed\\u40ed\\u0180;iy\\u0771\\u22b0\\u22b5rc\\u803b\\xee\\u40ee;\\u4438\\u0100cx\\u22bc\\u22bfy;\\u4435cl\\u803b\\xa1\\u40a1\\u0100fr\\u039f\\u22c9;\\uc000\\ud835\\udd26rave\\u803b\\xec\\u40ec\\u0200;ino\\u073e\\u22dd\\u22e9\\u22ee\\u0100in\\u22e2\\u22e6nt;\\u6a0ct;\\u622dfin;\\u69dcta;\\u6129lig;\\u4133\\u0180aop\\u22fe\\u231a\\u231d\\u0180cgt\\u2305\\u2308\\u2317r;\\u412b\\u0180elp\\u071f\\u230f\\u2313in\\xe5\\u078ear\\xf4\\u0720h;\\u4131f;\\u62b7ed;\\u41b5\\u0280;cfot\\u04f4\\u232c\\u2331\\u233d\\u2341are;\\u6105in\\u0100;t\\u2338\\u2339\\u621eie;\\u69dddo\\xf4\\u2319\\u0280;celp\\u0757\\u234c\\u2350\\u235b\\u2361al;\\u62ba\\u0100gr\\u2355\\u2359er\\xf3\\u1563\\xe3\\u234darhk;\\u6a17rod;\\u6a3c\\u0200cgpt\\u236f\\u2372\\u2376\\u237by;\\u4451on;\\u412ff;\\uc000\\ud835\\udd5aa;\\u43b9uest\\u803b\\xbf\\u40bf\\u0100ci\\u238a\\u238fr;\\uc000\\ud835\\udcben\\u0280;Edsv\\u04f4\\u239b\\u239d\\u23a1\\u04f3;\\u62f9ot;\\u62f5\\u0100;v\\u23a6\\u23a7\\u62f4;\\u62f3\\u0100;i\\u0777\\u23aelde;\\u4129\\u01eb\\u23b8\\0\\u23bccy;\\u4456l\\u803b\\xef\\u40ef\\u0300cfmosu\\u23cc\\u23d7\\u23dc\\u23e1\\u23e7\\u23f5\\u0100iy\\u23d1\\u23d5rc;\\u4135;\\u4439r;\\uc000\\ud835\\udd27ath;\\u4237pf;\\uc000\\ud835\\udd5b\\u01e3\\u23ec\\0\\u23f1r;\\uc000\\ud835\\udcbfrcy;\\u4458kcy;\\u4454\\u0400acfghjos\\u240b\\u2416\\u2422\\u2427\\u242d\\u2431\\u2435\\u243bppa\\u0100;v\\u2413\\u2414\\u43ba;\\u43f0\\u0100ey\\u241b\\u2420dil;\\u4137;\\u443ar;\\uc000\\ud835\\udd28reen;\\u4138cy;\\u4445cy;\\u445cpf;\\uc000\\ud835\\udd5ccr;\\uc000\\ud835\\udcc0\\u0b80ABEHabcdefghjlmnoprstuv\\u2470\\u2481\\u2486\\u248d\\u2491\\u250e\\u253d\\u255a\\u2580\\u264e\\u265e\\u2665\\u2679\\u267d\\u269a\\u26b2\\u26d8\\u275d\\u2768\\u278b\\u27c0\\u2801\\u2812\\u0180art\\u2477\\u247a\\u247cr\\xf2\\u09c6\\xf2\\u0395ail;\\u691barr;\\u690e\\u0100;g\\u0994\\u248b;\\u6a8bar;\\u6962\\u0963\\u24a5\\0\\u24aa\\0\\u24b1\\0\\0\\0\\0\\0\\u24b5\\u24ba\\0\\u24c6\\u24c8\\u24cd\\0\\u24f9ute;\\u413amptyv;\\u69b4ra\\xee\\u084cbda;\\u43bbg\\u0180;dl\\u088e\\u24c1\\u24c3;\\u6991\\xe5\\u088e;\\u6a85uo\\u803b\\xab\\u40abr\\u0400;bfhlpst\\u0899\\u24de\\u24e6\\u24e9\\u24eb\\u24ee\\u24f1\\u24f5\\u0100;f\\u089d\\u24e3s;\\u691fs;\\u691d\\xeb\\u2252p;\\u61abl;\\u6939im;\\u6973l;\\u61a2\\u0180;ae\\u24ff\\u2500\\u2504\\u6aabil;\\u6919\\u0100;s\\u2509\\u250a\\u6aad;\\uc000\\u2aad\\ufe00\\u0180abr\\u2515\\u2519\\u251drr;\\u690crk;\\u6772\\u0100ak\\u2522\\u252cc\\u0100ek\\u2528\\u252a;\\u407b;\\u405b\\u0100es\\u2531\\u2533;\\u698bl\\u0100du\\u2539\\u253b;\\u698f;\\u698d\\u0200aeuy\\u2546\\u254b\\u2556\\u2558ron;\\u413e\\u0100di\\u2550\\u2554il;\\u413c\\xec\\u08b0\\xe2\\u2529;\\u443b\\u0200cqrs\\u2563\\u2566\\u256d\\u257da;\\u6936uo\\u0100;r\\u0e19\\u1746\\u0100du\\u2572\\u2577har;\\u6967shar;\\u694bh;\\u61b2\\u0280;fgqs\\u258b\\u258c\\u0989\\u25f3\\u25ff\\u6264t\\u0280ahlrt\\u2598\\u25a4\\u25b7\\u25c2\\u25e8rrow\\u0100;t\\u0899\\u25a1a\\xe9\\u24f6arpoon\\u0100du\\u25af\\u25b4own\\xbb\\u045ap\\xbb\\u0966eftarrows;\\u61c7ight\\u0180ahs\\u25cd\\u25d6\\u25derrow\\u0100;s\\u08f4\\u08a7arpoon\\xf3\\u0f98quigarro\\xf7\\u21f0hreetimes;\\u62cb\\u0180;qs\\u258b\\u0993\\u25falan\\xf4\\u09ac\\u0280;cdgs\\u09ac\\u260a\\u260d\\u261d\\u2628c;\\u6aa8ot\\u0100;o\\u2614\\u2615\\u6a7f\\u0100;r\\u261a\\u261b\\u6a81;\\u6a83\\u0100;e\\u2622\\u2625\\uc000\\u22da\\ufe00s;\\u6a93\\u0280adegs\\u2633\\u2639\\u263d\\u2649\\u264bppro\\xf8\\u24c6ot;\\u62d6q\\u0100gq\\u2643\\u2645\\xf4\\u0989gt\\xf2\\u248c\\xf4\\u099bi\\xed\\u09b2\\u0180ilr\\u2655\\u08e1\\u265asht;\\u697c;\\uc000\\ud835\\udd29\\u0100;E\\u099c\\u2663;\\u6a91\\u0161\\u2669\\u2676r\\u0100du\\u25b2\\u266e\\u0100;l\\u0965\\u2673;\\u696alk;\\u6584cy;\\u4459\\u0280;acht\\u0a48\\u2688\\u268b\\u2691\\u2696r\\xf2\\u25c1orne\\xf2\\u1d08ard;\\u696bri;\\u65fa\\u0100io\\u269f\\u26a4dot;\\u4140ust\\u0100;a\\u26ac\\u26ad\\u63b0che\\xbb\\u26ad\\u0200Eaes\\u26bb\\u26bd\\u26c9\\u26d4;\\u6268p\\u0100;p\\u26c3\\u26c4\\u6a89rox\\xbb\\u26c4\\u0100;q\\u26ce\\u26cf\\u6a87\\u0100;q\\u26ce\\u26bbim;\\u62e6\\u0400abnoptwz\\u26e9\\u26f4\\u26f7\\u271a\\u272f\\u2741\\u2747\\u2750\\u0100nr\\u26ee\\u26f1g;\\u67ecr;\\u61fdr\\xeb\\u08c1g\\u0180lmr\\u26ff\\u270d\\u2714eft\\u0100ar\\u09e6\\u2707ight\\xe1\\u09f2apsto;\\u67fcight\\xe1\\u09fdparrow\\u0100lr\\u2725\\u2729ef\\xf4\\u24edight;\\u61ac\\u0180afl\\u2736\\u2739\\u273dr;\\u6985;\\uc000\\ud835\\udd5dus;\\u6a2dimes;\\u6a34\\u0161\\u274b\\u274fst;\\u6217\\xe1\\u134e\\u0180;ef\\u2757\\u2758\\u1800\\u65cange\\xbb\\u2758ar\\u0100;l\\u2764\\u2765\\u4028t;\\u6993\\u0280achmt\\u2773\\u2776\\u277c\\u2785\\u2787r\\xf2\\u08a8orne\\xf2\\u1d8car\\u0100;d\\u0f98\\u2783;\\u696d;\\u600eri;\\u62bf\\u0300achiqt\\u2798\\u279d\\u0a40\\u27a2\\u27ae\\u27bbquo;\\u6039r;\\uc000\\ud835\\udcc1m\\u0180;eg\\u09b2\\u27aa\\u27ac;\\u6a8d;\\u6a8f\\u0100bu\\u252a\\u27b3o\\u0100;r\\u0e1f\\u27b9;\\u601arok;\\u4142\\u8400<;cdhilqr\\u082b\\u27d2\\u2639\\u27dc\\u27e0\\u27e5\\u27ea\\u27f0\\u0100ci\\u27d7\\u27d9;\\u6aa6r;\\u6a79re\\xe5\\u25f2mes;\\u62c9arr;\\u6976uest;\\u6a7b\\u0100Pi\\u27f5\\u27f9ar;\\u6996\\u0180;ef\\u2800\\u092d\\u181b\\u65c3r\\u0100du\\u2807\\u280dshar;\\u694ahar;\\u6966\\u0100en\\u2817\\u2821rtneqq;\\uc000\\u2268\\ufe00\\xc5\\u281e\\u0700Dacdefhilnopsu\\u2840\\u2845\\u2882\\u288e\\u2893\\u28a0\\u28a5\\u28a8\\u28da\\u28e2\\u28e4\\u0a83\\u28f3\\u2902Dot;\\u623a\\u0200clpr\\u284e\\u2852\\u2863\\u287dr\\u803b\\xaf\\u40af\\u0100et\\u2857\\u2859;\\u6642\\u0100;e\\u285e\\u285f\\u6720se\\xbb\\u285f\\u0100;s\\u103b\\u2868to\\u0200;dlu\\u103b\\u2873\\u2877\\u287bow\\xee\\u048cef\\xf4\\u090f\\xf0\\u13d1ker;\\u65ae\\u0100oy\\u2887\\u288cmma;\\u6a29;\\u443cash;\\u6014asuredangle\\xbb\\u1626r;\\uc000\\ud835\\udd2ao;\\u6127\\u0180cdn\\u28af\\u28b4\\u28c9ro\\u803b\\xb5\\u40b5\\u0200;acd\\u1464\\u28bd\\u28c0\\u28c4s\\xf4\\u16a7ir;\\u6af0ot\\u80bb\\xb7\\u01b5us\\u0180;bd\\u28d2\\u1903\\u28d3\\u6212\\u0100;u\\u1d3c\\u28d8;\\u6a2a\\u0163\\u28de\\u28e1p;\\u6adb\\xf2\\u2212\\xf0\\u0a81\\u0100dp\\u28e9\\u28eeels;\\u62a7f;\\uc000\\ud835\\udd5e\\u0100ct\\u28f8\\u28fdr;\\uc000\\ud835\\udcc2pos\\xbb\\u159d\\u0180;lm\\u2909\\u290a\\u290d\\u43bctimap;\\u62b8\\u0c00GLRVabcdefghijlmoprstuvw\\u2942\\u2953\\u297e\\u2989\\u2998\\u29da\\u29e9\\u2a15\\u2a1a\\u2a58\\u2a5d\\u2a83\\u2a95\\u2aa4\\u2aa8\\u2b04\\u2b07\\u2b44\\u2b7f\\u2bae\\u2c34\\u2c67\\u2c7c\\u2ce9\\u0100gt\\u2947\\u294b;\\uc000\\u22d9\\u0338\\u0100;v\\u2950\\u0bcf\\uc000\\u226b\\u20d2\\u0180elt\\u295a\\u2972\\u2976ft\\u0100ar\\u2961\\u2967rrow;\\u61cdightarrow;\\u61ce;\\uc000\\u22d8\\u0338\\u0100;v\\u297b\\u0c47\\uc000\\u226a\\u20d2ightarrow;\\u61cf\\u0100Dd\\u298e\\u2993ash;\\u62afash;\\u62ae\\u0280bcnpt\\u29a3\\u29a7\\u29ac\\u29b1\\u29ccla\\xbb\\u02deute;\\u4144g;\\uc000\\u2220\\u20d2\\u0280;Eiop\\u0d84\\u29bc\\u29c0\\u29c5\\u29c8;\\uc000\\u2a70\\u0338d;\\uc000\\u224b\\u0338s;\\u4149ro\\xf8\\u0d84ur\\u0100;a\\u29d3\\u29d4\\u666el\\u0100;s\\u29d3\\u0b38\\u01f3\\u29df\\0\\u29e3p\\u80bb\\xa0\\u0b37mp\\u0100;e\\u0bf9\\u0c00\\u0280aeouy\\u29f4\\u29fe\\u2a03\\u2a10\\u2a13\\u01f0\\u29f9\\0\\u29fb;\\u6a43on;\\u4148dil;\\u4146ng\\u0100;d\\u0d7e\\u2a0aot;\\uc000\\u2a6d\\u0338p;\\u6a42;\\u443dash;\\u6013\\u0380;Aadqsx\\u0b92\\u2a29\\u2a2d\\u2a3b\\u2a41\\u2a45\\u2a50rr;\\u61d7r\\u0100hr\\u2a33\\u2a36k;\\u6924\\u0100;o\\u13f2\\u13f0ot;\\uc000\\u2250\\u0338ui\\xf6\\u0b63\\u0100ei\\u2a4a\\u2a4ear;\\u6928\\xed\\u0b98ist\\u0100;s\\u0ba0\\u0b9fr;\\uc000\\ud835\\udd2b\\u0200Eest\\u0bc5\\u2a66\\u2a79\\u2a7c\\u0180;qs\\u0bbc\\u2a6d\\u0be1\\u0180;qs\\u0bbc\\u0bc5\\u2a74lan\\xf4\\u0be2i\\xed\\u0bea\\u0100;r\\u0bb6\\u2a81\\xbb\\u0bb7\\u0180Aap\\u2a8a\\u2a8d\\u2a91r\\xf2\\u2971rr;\\u61aear;\\u6af2\\u0180;sv\\u0f8d\\u2a9c\\u0f8c\\u0100;d\\u2aa1\\u2aa2\\u62fc;\\u62facy;\\u445a\\u0380AEadest\\u2ab7\\u2aba\\u2abe\\u2ac2\\u2ac5\\u2af6\\u2af9r\\xf2\\u2966;\\uc000\\u2266\\u0338rr;\\u619ar;\\u6025\\u0200;fqs\\u0c3b\\u2ace\\u2ae3\\u2aeft\\u0100ar\\u2ad4\\u2ad9rro\\xf7\\u2ac1ightarro\\xf7\\u2a90\\u0180;qs\\u0c3b\\u2aba\\u2aealan\\xf4\\u0c55\\u0100;s\\u0c55\\u2af4\\xbb\\u0c36i\\xed\\u0c5d\\u0100;r\\u0c35\\u2afei\\u0100;e\\u0c1a\\u0c25i\\xe4\\u0d90\\u0100pt\\u2b0c\\u2b11f;\\uc000\\ud835\\udd5f\\u8180\\xac;in\\u2b19\\u2b1a\\u2b36\\u40acn\\u0200;Edv\\u0b89\\u2b24\\u2b28\\u2b2e;\\uc000\\u22f9\\u0338ot;\\uc000\\u22f5\\u0338\\u01e1\\u0b89\\u2b33\\u2b35;\\u62f7;\\u62f6i\\u0100;v\\u0cb8\\u2b3c\\u01e1\\u0cb8\\u2b41\\u2b43;\\u62fe;\\u62fd\\u0180aor\\u2b4b\\u2b63\\u2b69r\\u0200;ast\\u0b7b\\u2b55\\u2b5a\\u2b5flle\\xec\\u0b7bl;\\uc000\\u2afd\\u20e5;\\uc000\\u2202\\u0338lint;\\u6a14\\u0180;ce\\u0c92\\u2b70\\u2b73u\\xe5\\u0ca5\\u0100;c\\u0c98\\u2b78\\u0100;e\\u0c92\\u2b7d\\xf1\\u0c98\\u0200Aait\\u2b88\\u2b8b\\u2b9d\\u2ba7r\\xf2\\u2988rr\\u0180;cw\\u2b94\\u2b95\\u2b99\\u619b;\\uc000\\u2933\\u0338;\\uc000\\u219d\\u0338ghtarrow\\xbb\\u2b95ri\\u0100;e\\u0ccb\\u0cd6\\u0380chimpqu\\u2bbd\\u2bcd\\u2bd9\\u2b04\\u0b78\\u2be4\\u2bef\\u0200;cer\\u0d32\\u2bc6\\u0d37\\u2bc9u\\xe5\\u0d45;\\uc000\\ud835\\udcc3ort\\u026d\\u2b05\\0\\0\\u2bd6ar\\xe1\\u2b56m\\u0100;e\\u0d6e\\u2bdf\\u0100;q\\u0d74\\u0d73su\\u0100bp\\u2beb\\u2bed\\xe5\\u0cf8\\xe5\\u0d0b\\u0180bcp\\u2bf6\\u2c11\\u2c19\\u0200;Ees\\u2bff\\u2c00\\u0d22\\u2c04\\u6284;\\uc000\\u2ac5\\u0338et\\u0100;e\\u0d1b\\u2c0bq\\u0100;q\\u0d23\\u2c00c\\u0100;e\\u0d32\\u2c17\\xf1\\u0d38\\u0200;Ees\\u2c22\\u2c23\\u0d5f\\u2c27\\u6285;\\uc000\\u2ac6\\u0338et\\u0100;e\\u0d58\\u2c2eq\\u0100;q\\u0d60\\u2c23\\u0200gilr\\u2c3d\\u2c3f\\u2c45\\u2c47\\xec\\u0bd7lde\\u803b\\xf1\\u40f1\\xe7\\u0c43iangle\\u0100lr\\u2c52\\u2c5ceft\\u0100;e\\u0c1a\\u2c5a\\xf1\\u0c26ight\\u0100;e\\u0ccb\\u2c65\\xf1\\u0cd7\\u0100;m\\u2c6c\\u2c6d\\u43bd\\u0180;es\\u2c74\\u2c75\\u2c79\\u4023ro;\\u6116p;\\u6007\\u0480DHadgilrs\\u2c8f\\u2c94\\u2c99\\u2c9e\\u2ca3\\u2cb0\\u2cb6\\u2cd3\\u2ce3ash;\\u62adarr;\\u6904p;\\uc000\\u224d\\u20d2ash;\\u62ac\\u0100et\\u2ca8\\u2cac;\\uc000\\u2265\\u20d2;\\uc000>\\u20d2nfin;\\u69de\\u0180Aet\\u2cbd\\u2cc1\\u2cc5rr;\\u6902;\\uc000\\u2264\\u20d2\\u0100;r\\u2cca\\u2ccd\\uc000<\\u20d2ie;\\uc000\\u22b4\\u20d2\\u0100At\\u2cd8\\u2cdcrr;\\u6903rie;\\uc000\\u22b5\\u20d2im;\\uc000\\u223c\\u20d2\\u0180Aan\\u2cf0\\u2cf4\\u2d02rr;\\u61d6r\\u0100hr\\u2cfa\\u2cfdk;\\u6923\\u0100;o\\u13e7\\u13e5ear;\\u6927\\u1253\\u1a95\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\u2d2d\\0\\u2d38\\u2d48\\u2d60\\u2d65\\u2d72\\u2d84\\u1b07\\0\\0\\u2d8d\\u2dab\\0\\u2dc8\\u2dce\\0\\u2ddc\\u2e19\\u2e2b\\u2e3e\\u2e43\\u0100cs\\u2d31\\u1a97ute\\u803b\\xf3\\u40f3\\u0100iy\\u2d3c\\u2d45r\\u0100;c\\u1a9e\\u2d42\\u803b\\xf4\\u40f4;\\u443e\\u0280abios\\u1aa0\\u2d52\\u2d57\\u01c8\\u2d5alac;\\u4151v;\\u6a38old;\\u69bclig;\\u4153\\u0100cr\\u2d69\\u2d6dir;\\u69bf;\\uc000\\ud835\\udd2c\\u036f\\u2d79\\0\\0\\u2d7c\\0\\u2d82n;\\u42dbave\\u803b\\xf2\\u40f2;\\u69c1\\u0100bm\\u2d88\\u0df4ar;\\u69b5\\u0200acit\\u2d95\\u2d98\\u2da5\\u2da8r\\xf2\\u1a80\\u0100ir\\u2d9d\\u2da0r;\\u69beoss;\\u69bbn\\xe5\\u0e52;\\u69c0\\u0180aei\\u2db1\\u2db5\\u2db9cr;\\u414dga;\\u43c9\\u0180cdn\\u2dc0\\u2dc5\\u01cdron;\\u43bf;\\u69b6pf;\\uc000\\ud835\\udd60\\u0180ael\\u2dd4\\u2dd7\\u01d2r;\\u69b7rp;\\u69b9\\u0380;adiosv\\u2dea\\u2deb\\u2dee\\u2e08\\u2e0d\\u2e10\\u2e16\\u6228r\\xf2\\u1a86\\u0200;efm\\u2df7\\u2df8\\u2e02\\u2e05\\u6a5dr\\u0100;o\\u2dfe\\u2dff\\u6134f\\xbb\\u2dff\\u803b\\xaa\\u40aa\\u803b\\xba\\u40bagof;\\u62b6r;\\u6a56lope;\\u6a57;\\u6a5b\\u0180clo\\u2e1f\\u2e21\\u2e27\\xf2\\u2e01ash\\u803b\\xf8\\u40f8l;\\u6298i\\u016c\\u2e2f\\u2e34de\\u803b\\xf5\\u40f5es\\u0100;a\\u01db\\u2e3as;\\u6a36ml\\u803b\\xf6\\u40f6bar;\\u633d\\u0ae1\\u2e5e\\0\\u2e7d\\0\\u2e80\\u2e9d\\0\\u2ea2\\u2eb9\\0\\0\\u2ecb\\u0e9c\\0\\u2f13\\0\\0\\u2f2b\\u2fbc\\0\\u2fc8r\\u0200;ast\\u0403\\u2e67\\u2e72\\u0e85\\u8100\\xb6;l\\u2e6d\\u2e6e\\u40b6le\\xec\\u0403\\u0269\\u2e78\\0\\0\\u2e7bm;\\u6af3;\\u6afdy;\\u443fr\\u0280cimpt\\u2e8b\\u2e8f\\u2e93\\u1865\\u2e97nt;\\u4025od;\\u402eil;\\u6030enk;\\u6031r;\\uc000\\ud835\\udd2d\\u0180imo\\u2ea8\\u2eb0\\u2eb4\\u0100;v\\u2ead\\u2eae\\u43c6;\\u43d5ma\\xf4\\u0a76ne;\\u660e\\u0180;tv\\u2ebf\\u2ec0\\u2ec8\\u43c0chfork\\xbb\\u1ffd;\\u43d6\\u0100au\\u2ecf\\u2edfn\\u0100ck\\u2ed5\\u2eddk\\u0100;h\\u21f4\\u2edb;\\u610e\\xf6\\u21f4s\\u0480;abcdemst\\u2ef3\\u2ef4\\u1908\\u2ef9\\u2efd\\u2f04\\u2f06\\u2f0a\\u2f0e\\u402bcir;\\u6a23ir;\\u6a22\\u0100ou\\u1d40\\u2f02;\\u6a25;\\u6a72n\\u80bb\\xb1\\u0e9dim;\\u6a26wo;\\u6a27\\u0180ipu\\u2f19\\u2f20\\u2f25ntint;\\u6a15f;\\uc000\\ud835\\udd61nd\\u803b\\xa3\\u40a3\\u0500;Eaceinosu\\u0ec8\\u2f3f\\u2f41\\u2f44\\u2f47\\u2f81\\u2f89\\u2f92\\u2f7e\\u2fb6;\\u6ab3p;\\u6ab7u\\xe5\\u0ed9\\u0100;c\\u0ece\\u2f4c\\u0300;acens\\u0ec8\\u2f59\\u2f5f\\u2f66\\u2f68\\u2f7eppro\\xf8\\u2f43urlye\\xf1\\u0ed9\\xf1\\u0ece\\u0180aes\\u2f6f\\u2f76\\u2f7approx;\\u6ab9qq;\\u6ab5im;\\u62e8i\\xed\\u0edfme\\u0100;s\\u2f88\\u0eae\\u6032\\u0180Eas\\u2f78\\u2f90\\u2f7a\\xf0\\u2f75\\u0180dfp\\u0eec\\u2f99\\u2faf\\u0180als\\u2fa0\\u2fa5\\u2faalar;\\u632eine;\\u6312urf;\\u6313\\u0100;t\\u0efb\\u2fb4\\xef\\u0efbrel;\\u62b0\\u0100ci\\u2fc0\\u2fc5r;\\uc000\\ud835\\udcc5;\\u43c8ncsp;\\u6008\\u0300fiopsu\\u2fda\\u22e2\\u2fdf\\u2fe5\\u2feb\\u2ff1r;\\uc000\\ud835\\udd2epf;\\uc000\\ud835\\udd62rime;\\u6057cr;\\uc000\\ud835\\udcc6\\u0180aeo\\u2ff8\\u3009\\u3013t\\u0100ei\\u2ffe\\u3005rnion\\xf3\\u06b0nt;\\u6a16st\\u0100;e\\u3010\\u3011\\u403f\\xf1\\u1f19\\xf4\\u0f14\\u0a80ABHabcdefhilmnoprstux\\u3040\\u3051\\u3055\\u3059\\u30e0\\u310e\\u312b\\u3147\\u3162\\u3172\\u318e\\u3206\\u3215\\u3224\\u3229\\u3258\\u326e\\u3272\\u3290\\u32b0\\u32b7\\u0180art\\u3047\\u304a\\u304cr\\xf2\\u10b3\\xf2\\u03ddail;\\u691car\\xf2\\u1c65ar;\\u6964\\u0380cdenqrt\\u3068\\u3075\\u3078\\u307f\\u308f\\u3094\\u30cc\\u0100eu\\u306d\\u3071;\\uc000\\u223d\\u0331te;\\u4155i\\xe3\\u116emptyv;\\u69b3g\\u0200;del\\u0fd1\\u3089\\u308b\\u308d;\\u6992;\\u69a5\\xe5\\u0fd1uo\\u803b\\xbb\\u40bbr\\u0580;abcfhlpstw\\u0fdc\\u30ac\\u30af\\u30b7\\u30b9\\u30bc\\u30be\\u30c0\\u30c3\\u30c7\\u30cap;\\u6975\\u0100;f\\u0fe0\\u30b4s;\\u6920;\\u6933s;\\u691e\\xeb\\u225d\\xf0\\u272el;\\u6945im;\\u6974l;\\u61a3;\\u619d\\u0100ai\\u30d1\\u30d5il;\\u691ao\\u0100;n\\u30db\\u30dc\\u6236al\\xf3\\u0f1e\\u0180abr\\u30e7\\u30ea\\u30eer\\xf2\\u17e5rk;\\u6773\\u0100ak\\u30f3\\u30fdc\\u0100ek\\u30f9\\u30fb;\\u407d;\\u405d\\u0100es\\u3102\\u3104;\\u698cl\\u0100du\\u310a\\u310c;\\u698e;\\u6990\\u0200aeuy\\u3117\\u311c\\u3127\\u3129ron;\\u4159\\u0100di\\u3121\\u3125il;\\u4157\\xec\\u0ff2\\xe2\\u30fa;\\u4440\\u0200clqs\\u3134\\u3137\\u313d\\u3144a;\\u6937dhar;\\u6969uo\\u0100;r\\u020e\\u020dh;\\u61b3\\u0180acg\\u314e\\u315f\\u0f44l\\u0200;ips\\u0f78\\u3158\\u315b\\u109cn\\xe5\\u10bbar\\xf4\\u0fa9t;\\u65ad\\u0180ilr\\u3169\\u1023\\u316esht;\\u697d;\\uc000\\ud835\\udd2f\\u0100ao\\u3177\\u3186r\\u0100du\\u317d\\u317f\\xbb\\u047b\\u0100;l\\u1091\\u3184;\\u696c\\u0100;v\\u318b\\u318c\\u43c1;\\u43f1\\u0180gns\\u3195\\u31f9\\u31fcht\\u0300ahlrst\\u31a4\\u31b0\\u31c2\\u31d8\\u31e4\\u31eerrow\\u0100;t\\u0fdc\\u31ada\\xe9\\u30c8arpoon\\u0100du\\u31bb\\u31bfow\\xee\\u317ep\\xbb\\u1092eft\\u0100ah\\u31ca\\u31d0rrow\\xf3\\u0feaarpoon\\xf3\\u0551ightarrows;\\u61c9quigarro\\xf7\\u30cbhreetimes;\\u62ccg;\\u42daingdotse\\xf1\\u1f32\\u0180ahm\\u320d\\u3210\\u3213r\\xf2\\u0feaa\\xf2\\u0551;\\u600foust\\u0100;a\\u321e\\u321f\\u63b1che\\xbb\\u321fmid;\\u6aee\\u0200abpt\\u3232\\u323d\\u3240\\u3252\\u0100nr\\u3237\\u323ag;\\u67edr;\\u61fer\\xeb\\u1003\\u0180afl\\u3247\\u324a\\u324er;\\u6986;\\uc000\\ud835\\udd63us;\\u6a2eimes;\\u6a35\\u0100ap\\u325d\\u3267r\\u0100;g\\u3263\\u3264\\u4029t;\\u6994olint;\\u6a12ar\\xf2\\u31e3\\u0200achq\\u327b\\u3280\\u10bc\\u3285quo;\\u603ar;\\uc000\\ud835\\udcc7\\u0100bu\\u30fb\\u328ao\\u0100;r\\u0214\\u0213\\u0180hir\\u3297\\u329b\\u32a0re\\xe5\\u31f8mes;\\u62cai\\u0200;efl\\u32aa\\u1059\\u1821\\u32ab\\u65b9tri;\\u69celuhar;\\u6968;\\u611e\\u0d61\\u32d5\\u32db\\u32df\\u332c\\u3338\\u3371\\0\\u337a\\u33a4\\0\\0\\u33ec\\u33f0\\0\\u3428\\u3448\\u345a\\u34ad\\u34b1\\u34ca\\u34f1\\0\\u3616\\0\\0\\u3633cute;\\u415bqu\\xef\\u27ba\\u0500;Eaceinpsy\\u11ed\\u32f3\\u32f5\\u32ff\\u3302\\u330b\\u330f\\u331f\\u3326\\u3329;\\u6ab4\\u01f0\\u32fa\\0\\u32fc;\\u6ab8on;\\u4161u\\xe5\\u11fe\\u0100;d\\u11f3\\u3307il;\\u415frc;\\u415d\\u0180Eas\\u3316\\u3318\\u331b;\\u6ab6p;\\u6abaim;\\u62e9olint;\\u6a13i\\xed\\u1204;\\u4441ot\\u0180;be\\u3334\\u1d47\\u3335\\u62c5;\\u6a66\\u0380Aacmstx\\u3346\\u334a\\u3357\\u335b\\u335e\\u3363\\u336drr;\\u61d8r\\u0100hr\\u3350\\u3352\\xeb\\u2228\\u0100;o\\u0a36\\u0a34t\\u803b\\xa7\\u40a7i;\\u403bwar;\\u6929m\\u0100in\\u3369\\xf0nu\\xf3\\xf1t;\\u6736r\\u0100;o\\u3376\\u2055\\uc000\\ud835\\udd30\\u0200acoy\\u3382\\u3386\\u3391\\u33a0rp;\\u666f\\u0100hy\\u338b\\u338fcy;\\u4449;\\u4448rt\\u026d\\u3399\\0\\0\\u339ci\\xe4\\u1464ara\\xec\\u2e6f\\u803b\\xad\\u40ad\\u0100gm\\u33a8\\u33b4ma\\u0180;fv\\u33b1\\u33b2\\u33b2\\u43c3;\\u43c2\\u0400;deglnpr\\u12ab\\u33c5\\u33c9\\u33ce\\u33d6\\u33de\\u33e1\\u33e6ot;\\u6a6a\\u0100;q\\u12b1\\u12b0\\u0100;E\\u33d3\\u33d4\\u6a9e;\\u6aa0\\u0100;E\\u33db\\u33dc\\u6a9d;\\u6a9fe;\\u6246lus;\\u6a24arr;\\u6972ar\\xf2\\u113d\\u0200aeit\\u33f8\\u3408\\u340f\\u3417\\u0100ls\\u33fd\\u3404lsetm\\xe9\\u336ahp;\\u6a33parsl;\\u69e4\\u0100dl\\u1463\\u3414e;\\u6323\\u0100;e\\u341c\\u341d\\u6aaa\\u0100;s\\u3422\\u3423\\u6aac;\\uc000\\u2aac\\ufe00\\u0180flp\\u342e\\u3433\\u3442tcy;\\u444c\\u0100;b\\u3438\\u3439\\u402f\\u0100;a\\u343e\\u343f\\u69c4r;\\u633ff;\\uc000\\ud835\\udd64a\\u0100dr\\u344d\\u0402es\\u0100;u\\u3454\\u3455\\u6660it\\xbb\\u3455\\u0180csu\\u3460\\u3479\\u349f\\u0100au\\u3465\\u346fp\\u0100;s\\u1188\\u346b;\\uc000\\u2293\\ufe00p\\u0100;s\\u11b4\\u3475;\\uc000\\u2294\\ufe00u\\u0100bp\\u347f\\u348f\\u0180;es\\u1197\\u119c\\u3486et\\u0100;e\\u1197\\u348d\\xf1\\u119d\\u0180;es\\u11a8\\u11ad\\u3496et\\u0100;e\\u11a8\\u349d\\xf1\\u11ae\\u0180;af\\u117b\\u34a6\\u05b0r\\u0165\\u34ab\\u05b1\\xbb\\u117car\\xf2\\u1148\\u0200cemt\\u34b9\\u34be\\u34c2\\u34c5r;\\uc000\\ud835\\udcc8tm\\xee\\xf1i\\xec\\u3415ar\\xe6\\u11be\\u0100ar\\u34ce\\u34d5r\\u0100;f\\u34d4\\u17bf\\u6606\\u0100an\\u34da\\u34edight\\u0100ep\\u34e3\\u34eapsilo\\xee\\u1ee0h\\xe9\\u2eafs\\xbb\\u2852\\u0280bcmnp\\u34fb\\u355e\\u1209\\u358b\\u358e\\u0480;Edemnprs\\u350e\\u350f\\u3511\\u3515\\u351e\\u3523\\u352c\\u3531\\u3536\\u6282;\\u6ac5ot;\\u6abd\\u0100;d\\u11da\\u351aot;\\u6ac3ult;\\u6ac1\\u0100Ee\\u3528\\u352a;\\u6acb;\\u628alus;\\u6abfarr;\\u6979\\u0180eiu\\u353d\\u3552\\u3555t\\u0180;en\\u350e\\u3545\\u354bq\\u0100;q\\u11da\\u350feq\\u0100;q\\u352b\\u3528m;\\u6ac7\\u0100bp\\u355a\\u355c;\\u6ad5;\\u6ad3c\\u0300;acens\\u11ed\\u356c\\u3572\\u3579\\u357b\\u3326ppro\\xf8\\u32faurlye\\xf1\\u11fe\\xf1\\u11f3\\u0180aes\\u3582\\u3588\\u331bppro\\xf8\\u331aq\\xf1\\u3317g;\\u666a\\u0680123;Edehlmnps\\u35a9\\u35ac\\u35af\\u121c\\u35b2\\u35b4\\u35c0\\u35c9\\u35d5\\u35da\\u35df\\u35e8\\u35ed\\u803b\\xb9\\u40b9\\u803b\\xb2\\u40b2\\u803b\\xb3\\u40b3;\\u6ac6\\u0100os\\u35b9\\u35bct;\\u6abeub;\\u6ad8\\u0100;d\\u1222\\u35c5ot;\\u6ac4s\\u0100ou\\u35cf\\u35d2l;\\u67c9b;\\u6ad7arr;\\u697bult;\\u6ac2\\u0100Ee\\u35e4\\u35e6;\\u6acc;\\u628blus;\\u6ac0\\u0180eiu\\u35f4\\u3609\\u360ct\\u0180;en\\u121c\\u35fc\\u3602q\\u0100;q\\u1222\\u35b2eq\\u0100;q\\u35e7\\u35e4m;\\u6ac8\\u0100bp\\u3611\\u3613;\\u6ad4;\\u6ad6\\u0180Aan\\u361c\\u3620\\u362drr;\\u61d9r\\u0100hr\\u3626\\u3628\\xeb\\u222e\\u0100;o\\u0a2b\\u0a29war;\\u692alig\\u803b\\xdf\\u40df\\u0be1\\u3651\\u365d\\u3660\\u12ce\\u3673\\u3679\\0\\u367e\\u36c2\\0\\0\\0\\0\\0\\u36db\\u3703\\0\\u3709\\u376c\\0\\0\\0\\u3787\\u0272\\u3656\\0\\0\\u365bget;\\u6316;\\u43c4r\\xeb\\u0e5f\\u0180aey\\u3666\\u366b\\u3670ron;\\u4165dil;\\u4163;\\u4442lrec;\\u6315r;\\uc000\\ud835\\udd31\\u0200eiko\\u3686\\u369d\\u36b5\\u36bc\\u01f2\\u368b\\0\\u3691e\\u01004f\\u1284\\u1281a\\u0180;sv\\u3698\\u3699\\u369b\\u43b8ym;\\u43d1\\u0100cn\\u36a2\\u36b2k\\u0100as\\u36a8\\u36aeppro\\xf8\\u12c1im\\xbb\\u12acs\\xf0\\u129e\\u0100as\\u36ba\\u36ae\\xf0\\u12c1rn\\u803b\\xfe\\u40fe\\u01ec\\u031f\\u36c6\\u22e7es\\u8180\\xd7;bd\\u36cf\\u36d0\\u36d8\\u40d7\\u0100;a\\u190f\\u36d5r;\\u6a31;\\u6a30\\u0180eps\\u36e1\\u36e3\\u3700\\xe1\\u2a4d\\u0200;bcf\\u0486\\u36ec\\u36f0\\u36f4ot;\\u6336ir;\\u6af1\\u0100;o\\u36f9\\u36fc\\uc000\\ud835\\udd65rk;\\u6ada\\xe1\\u3362rime;\\u6034\\u0180aip\\u370f\\u3712\\u3764d\\xe5\\u1248\\u0380adempst\\u3721\\u374d\\u3740\\u3751\\u3757\\u375c\\u375fngle\\u0280;dlqr\\u3730\\u3731\\u3736\\u3740\\u3742\\u65b5own\\xbb\\u1dbbeft\\u0100;e\\u2800\\u373e\\xf1\\u092e;\\u625cight\\u0100;e\\u32aa\\u374b\\xf1\\u105aot;\\u65ecinus;\\u6a3alus;\\u6a39b;\\u69cdime;\\u6a3bezium;\\u63e2\\u0180cht\\u3772\\u377d\\u3781\\u0100ry\\u3777\\u377b;\\uc000\\ud835\\udcc9;\\u4446cy;\\u445brok;\\u4167\\u0100io\\u378b\\u378ex\\xf4\\u1777head\\u0100lr\\u3797\\u37a0eftarro\\xf7\\u084fightarrow\\xbb\\u0f5d\\u0900AHabcdfghlmoprstuw\\u37d0\\u37d3\\u37d7\\u37e4\\u37f0\\u37fc\\u380e\\u381c\\u3823\\u3834\\u3851\\u385d\\u386b\\u38a9\\u38cc\\u38d2\\u38ea\\u38f6r\\xf2\\u03edar;\\u6963\\u0100cr\\u37dc\\u37e2ute\\u803b\\xfa\\u40fa\\xf2\\u1150r\\u01e3\\u37ea\\0\\u37edy;\\u445eve;\\u416d\\u0100iy\\u37f5\\u37farc\\u803b\\xfb\\u40fb;\\u4443\\u0180abh\\u3803\\u3806\\u380br\\xf2\\u13adlac;\\u4171a\\xf2\\u13c3\\u0100ir\\u3813\\u3818sht;\\u697e;\\uc000\\ud835\\udd32rave\\u803b\\xf9\\u40f9\\u0161\\u3827\\u3831r\\u0100lr\\u382c\\u382e\\xbb\\u0957\\xbb\\u1083lk;\\u6580\\u0100ct\\u3839\\u384d\\u026f\\u383f\\0\\0\\u384arn\\u0100;e\\u3845\\u3846\\u631cr\\xbb\\u3846op;\\u630fri;\\u65f8\\u0100al\\u3856\\u385acr;\\u416b\\u80bb\\xa8\\u0349\\u0100gp\\u3862\\u3866on;\\u4173f;\\uc000\\ud835\\udd66\\u0300adhlsu\\u114b\\u3878\\u387d\\u1372\\u3891\\u38a0own\\xe1\\u13b3arpoon\\u0100lr\\u3888\\u388cef\\xf4\\u382digh\\xf4\\u382fi\\u0180;hl\\u3899\\u389a\\u389c\\u43c5\\xbb\\u13faon\\xbb\\u389aparrows;\\u61c8\\u0180cit\\u38b0\\u38c4\\u38c8\\u026f\\u38b6\\0\\0\\u38c1rn\\u0100;e\\u38bc\\u38bd\\u631dr\\xbb\\u38bdop;\\u630eng;\\u416fri;\\u65f9cr;\\uc000\\ud835\\udcca\\u0180dir\\u38d9\\u38dd\\u38e2ot;\\u62f0lde;\\u4169i\\u0100;f\\u3730\\u38e8\\xbb\\u1813\\u0100am\\u38ef\\u38f2r\\xf2\\u38a8l\\u803b\\xfc\\u40fcangle;\\u69a7\\u0780ABDacdeflnoprsz\\u391c\\u391f\\u3929\\u392d\\u39b5\\u39b8\\u39bd\\u39df\\u39e4\\u39e8\\u39f3\\u39f9\\u39fd\\u3a01\\u3a20r\\xf2\\u03f7ar\\u0100;v\\u3926\\u3927\\u6ae8;\\u6ae9as\\xe8\\u03e1\\u0100nr\\u3932\\u3937grt;\\u699c\\u0380eknprst\\u34e3\\u3946\\u394b\\u3952\\u395d\\u3964\\u3996app\\xe1\\u2415othin\\xe7\\u1e96\\u0180hir\\u34eb\\u2ec8\\u3959op\\xf4\\u2fb5\\u0100;h\\u13b7\\u3962\\xef\\u318d\\u0100iu\\u3969\\u396dgm\\xe1\\u33b3\\u0100bp\\u3972\\u3984setneq\\u0100;q\\u397d\\u3980\\uc000\\u228a\\ufe00;\\uc000\\u2acb\\ufe00setneq\\u0100;q\\u398f\\u3992\\uc000\\u228b\\ufe00;\\uc000\\u2acc\\ufe00\\u0100hr\\u399b\\u399fet\\xe1\\u369ciangle\\u0100lr\\u39aa\\u39afeft\\xbb\\u0925ight\\xbb\\u1051y;\\u4432ash\\xbb\\u1036\\u0180elr\\u39c4\\u39d2\\u39d7\\u0180;be\\u2dea\\u39cb\\u39cfar;\\u62bbq;\\u625alip;\\u62ee\\u0100bt\\u39dc\\u1468a\\xf2\\u1469r;\\uc000\\ud835\\udd33tr\\xe9\\u39aesu\\u0100bp\\u39ef\\u39f1\\xbb\\u0d1c\\xbb\\u0d59pf;\\uc000\\ud835\\udd67ro\\xf0\\u0efbtr\\xe9\\u39b4\\u0100cu\\u3a06\\u3a0br;\\uc000\\ud835\\udccb\\u0100bp\\u3a10\\u3a18n\\u0100Ee\\u3980\\u3a16\\xbb\\u397en\\u0100Ee\\u3992\\u3a1e\\xbb\\u3990igzag;\\u699a\\u0380cefoprs\\u3a36\\u3a3b\\u3a56\\u3a5b\\u3a54\\u3a61\\u3a6airc;\\u4175\\u0100di\\u3a40\\u3a51\\u0100bg\\u3a45\\u3a49ar;\\u6a5fe\\u0100;q\\u15fa\\u3a4f;\\u6259erp;\\u6118r;\\uc000\\ud835\\udd34pf;\\uc000\\ud835\\udd68\\u0100;e\\u1479\\u3a66at\\xe8\\u1479cr;\\uc000\\ud835\\udccc\\u0ae3\\u178e\\u3a87\\0\\u3a8b\\0\\u3a90\\u3a9b\\0\\0\\u3a9d\\u3aa8\\u3aab\\u3aaf\\0\\0\\u3ac3\\u3ace\\0\\u3ad8\\u17dc\\u17dftr\\xe9\\u17d1r;\\uc000\\ud835\\udd35\\u0100Aa\\u3a94\\u3a97r\\xf2\\u03c3r\\xf2\\u09f6;\\u43be\\u0100Aa\\u3aa1\\u3aa4r\\xf2\\u03b8r\\xf2\\u09eba\\xf0\\u2713is;\\u62fb\\u0180dpt\\u17a4\\u3ab5\\u3abe\\u0100fl\\u3aba\\u17a9;\\uc000\\ud835\\udd69im\\xe5\\u17b2\\u0100Aa\\u3ac7\\u3acar\\xf2\\u03cer\\xf2\\u0a01\\u0100cq\\u3ad2\\u17b8r;\\uc000\\ud835\\udccd\\u0100pt\\u17d6\\u3adcr\\xe9\\u17d4\\u0400acefiosu\\u3af0\\u3afd\\u3b08\\u3b0c\\u3b11\\u3b15\\u3b1b\\u3b21c\\u0100uy\\u3af6\\u3afbte\\u803b\\xfd\\u40fd;\\u444f\\u0100iy\\u3b02\\u3b06rc;\\u4177;\\u444bn\\u803b\\xa5\\u40a5r;\\uc000\\ud835\\udd36cy;\\u4457pf;\\uc000\\ud835\\udd6acr;\\uc000\\ud835\\udcce\\u0100cm\\u3b26\\u3b29y;\\u444el\\u803b\\xff\\u40ff\\u0500acdefhiosw\\u3b42\\u3b48\\u3b54\\u3b58\\u3b64\\u3b69\\u3b6d\\u3b74\\u3b7a\\u3b80cute;\\u417a\\u0100ay\\u3b4d\\u3b52ron;\\u417e;\\u4437ot;\\u417c\\u0100et\\u3b5d\\u3b61tr\\xe6\\u155fa;\\u43b6r;\\uc000\\ud835\\udd37cy;\\u4436grarr;\\u61ddpf;\\uc000\\ud835\\udd6bcr;\\uc000\\ud835\\udccf\\u0100jn\\u3b85\\u3b87;\\u600dj;\\u600c\".split(\"\").map(c => c.charCodeAt(0)));","// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\nvar _a;\nconst decodeMap = new Map([[0, 65533],\n// C1 Unicode control character reference replacements\n[128, 8364], [130, 8218], [131, 402], [132, 8222], [133, 8230], [134, 8224], [135, 8225], [136, 710], [137, 8240], [138, 352], [139, 8249], [140, 338], [142, 381], [145, 8216], [146, 8217], [147, 8220], [148, 8221], [149, 8226], [150, 8211], [151, 8212], [152, 732], [153, 8482], [154, 353], [155, 8250], [156, 339], [158, 382], [159, 376]]);\n/**\n * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.\n */\nexport const fromCodePoint =\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins\n(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {\n  let output = \"\";\n  if (codePoint > 0xffff) {\n    codePoint -= 0x10000;\n    output += String.fromCharCode(codePoint >>> 10 & 0x3ff | 0xd800);\n    codePoint = 0xdc00 | codePoint & 0x3ff;\n  }\n  output += String.fromCharCode(codePoint);\n  return output;\n};\n/**\n * Replace the given code point with a replacement character if it is a\n * surrogate or is outside the valid range. Otherwise return the code\n * point unchanged.\n */\nexport function replaceCodePoint(codePoint) {\n  var _a;\n  if (codePoint >= 0xd800 && codePoint <= 0xdfff || codePoint > 0x10ffff) {\n    return 0xfffd;\n  }\n  return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;\n}\n/**\n * Replace the code point if relevant, then convert it to a string.\n *\n * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.\n * @param codePoint The code point to decode.\n * @returns The decoded code point.\n */\nexport default function decodeCodePoint(codePoint) {\n  return fromCodePoint(replaceCodePoint(codePoint));\n}","// Generated using scripts/write-decode-map.ts\nexport default new Uint16Array(\n// prettier-ignore\n\"\\u0200aglq\\t\\x15\\x18\\x1b\\u026d\\x0f\\0\\0\\x12p;\\u4026os;\\u4027t;\\u403et;\\u403cuot;\\u4022\".split(\"\").map(c => c.charCodeAt(0)));","import htmlDecodeTree from \"./generated/decode-data-html.js\";\nimport xmlDecodeTree from \"./generated/decode-data-xml.js\";\nimport decodeCodePoint, { replaceCodePoint, fromCodePoint } from \"./decode_codepoint.js\";\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree, xmlDecodeTree, decodeCodePoint };\nexport { replaceCodePoint, fromCodePoint } from \"./decode_codepoint.js\";\nvar CharCodes;\n(function (CharCodes) {\n  CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n  CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n  CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n  CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n  CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n  CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n  CharCodes[CharCodes[\"LOWER_F\"] = 102] = \"LOWER_F\";\n  CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n  CharCodes[CharCodes[\"LOWER_Z\"] = 122] = \"LOWER_Z\";\n  CharCodes[CharCodes[\"UPPER_A\"] = 65] = \"UPPER_A\";\n  CharCodes[CharCodes[\"UPPER_F\"] = 70] = \"UPPER_F\";\n  CharCodes[CharCodes[\"UPPER_Z\"] = 90] = \"UPPER_Z\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 0b100000;\nexport var BinTrieFlags;\n(function (BinTrieFlags) {\n  BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n  BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 16256] = \"BRANCH_LENGTH\";\n  BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n})(BinTrieFlags || (BinTrieFlags = {}));\nfunction isNumber(code) {\n  return code >= CharCodes.ZERO && code <= CharCodes.NINE;\n}\nfunction isHexadecimalCharacter(code) {\n  return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F;\n}\nfunction isAsciiAlphaNumeric(code) {\n  return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z || isNumber(code);\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n  return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n  EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n  EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n  EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n  EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n  EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\nexport var DecodingMode;\n(function (DecodingMode) {\n  /** Entities in text nodes that can end with any character. */\n  DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n  /** Only allow entities terminated with a semicolon. */\n  DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n  /** Entities in attributes have limitations on ending characters. */\n  DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n  constructor( /** The tree used to decode entities. */\n  decodeTree,\n  /**\n   * The function that is called when a codepoint is decoded.\n   *\n   * For multi-byte named entities, this will be called multiple times,\n   * with the second codepoint, and the same `consumed` value.\n   *\n   * @param codepoint The decoded codepoint.\n   * @param consumed The number of bytes consumed by the decoder.\n   */\n  emitCodePoint, /** An object that is used to produce errors. */\n  errors) {\n    this.decodeTree = decodeTree;\n    this.emitCodePoint = emitCodePoint;\n    this.errors = errors;\n    /** The current state of the decoder. */\n    this.state = EntityDecoderState.EntityStart;\n    /** Characters that were consumed while parsing an entity. */\n    this.consumed = 1;\n    /**\n     * The result of the entity.\n     *\n     * Either the result index of a numeric entity, or the codepoint of a\n     * numeric entity.\n     */\n    this.result = 0;\n    /** The current index in the decode tree. */\n    this.treeIndex = 0;\n    /** The number of characters that were consumed in excess. */\n    this.excess = 1;\n    /** The mode in which the decoder is operating. */\n    this.decodeMode = DecodingMode.Strict;\n  }\n  /** Resets the instance to make it reusable. */\n  startEntity(decodeMode) {\n    this.decodeMode = decodeMode;\n    this.state = EntityDecoderState.EntityStart;\n    this.result = 0;\n    this.treeIndex = 0;\n    this.excess = 1;\n    this.consumed = 1;\n  }\n  /**\n   * Write an entity to the decoder. This can be called multiple times with partial entities.\n   * If the entity is incomplete, the decoder will return -1.\n   *\n   * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the\n   * entity is incomplete, and resume when the next string is written.\n   *\n   * @param string The string containing the entity (or a continuation of the entity).\n   * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n   */\n  write(str, offset) {\n    switch (this.state) {\n      case EntityDecoderState.EntityStart:\n        {\n          if (str.charCodeAt(offset) === CharCodes.NUM) {\n            this.state = EntityDecoderState.NumericStart;\n            this.consumed += 1;\n            return this.stateNumericStart(str, offset + 1);\n          }\n          this.state = EntityDecoderState.NamedEntity;\n          return this.stateNamedEntity(str, offset);\n        }\n      case EntityDecoderState.NumericStart:\n        {\n          return this.stateNumericStart(str, offset);\n        }\n      case EntityDecoderState.NumericDecimal:\n        {\n          return this.stateNumericDecimal(str, offset);\n        }\n      case EntityDecoderState.NumericHex:\n        {\n          return this.stateNumericHex(str, offset);\n        }\n      case EntityDecoderState.NamedEntity:\n        {\n          return this.stateNamedEntity(str, offset);\n        }\n    }\n  }\n  /**\n   * Switches between the numeric decimal and hexadecimal states.\n   *\n   * Equivalent to the `Numeric character reference state` in the HTML spec.\n   *\n   * @param str The string containing the entity (or a continuation of the entity).\n   * @param offset The current offset.\n   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n   */\n  stateNumericStart(str, offset) {\n    if (offset >= str.length) {\n      return -1;\n    }\n    if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n      this.state = EntityDecoderState.NumericHex;\n      this.consumed += 1;\n      return this.stateNumericHex(str, offset + 1);\n    }\n    this.state = EntityDecoderState.NumericDecimal;\n    return this.stateNumericDecimal(str, offset);\n  }\n  addToNumericResult(str, start, end, base) {\n    if (start !== end) {\n      const digitCount = end - start;\n      this.result = this.result * Math.pow(base, digitCount) + parseInt(str.substr(start, digitCount), base);\n      this.consumed += digitCount;\n    }\n  }\n  /**\n   * Parses a hexadecimal numeric entity.\n   *\n   * Equivalent to the `Hexademical character reference state` in the HTML spec.\n   *\n   * @param str The string containing the entity (or a continuation of the entity).\n   * @param offset The current offset.\n   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n   */\n  stateNumericHex(str, offset) {\n    const startIdx = offset;\n    while (offset < str.length) {\n      const char = str.charCodeAt(offset);\n      if (isNumber(char) || isHexadecimalCharacter(char)) {\n        offset += 1;\n      } else {\n        this.addToNumericResult(str, startIdx, offset, 16);\n        return this.emitNumericEntity(char, 3);\n      }\n    }\n    this.addToNumericResult(str, startIdx, offset, 16);\n    return -1;\n  }\n  /**\n   * Parses a decimal numeric entity.\n   *\n   * Equivalent to the `Decimal character reference state` in the HTML spec.\n   *\n   * @param str The string containing the entity (or a continuation of the entity).\n   * @param offset The current offset.\n   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n   */\n  stateNumericDecimal(str, offset) {\n    const startIdx = offset;\n    while (offset < str.length) {\n      const char = str.charCodeAt(offset);\n      if (isNumber(char)) {\n        offset += 1;\n      } else {\n        this.addToNumericResult(str, startIdx, offset, 10);\n        return this.emitNumericEntity(char, 2);\n      }\n    }\n    this.addToNumericResult(str, startIdx, offset, 10);\n    return -1;\n  }\n  /**\n   * Validate and emit a numeric entity.\n   *\n   * Implements the logic from the `Hexademical character reference start\n   * state` and `Numeric character reference end state` in the HTML spec.\n   *\n   * @param lastCp The last code point of the entity. Used to see if the\n   *               entity was terminated with a semicolon.\n   * @param expectedLength The minimum number of characters that should be\n   *                       consumed. Used to validate that at least one digit\n   *                       was consumed.\n   * @returns The number of characters that were consumed.\n   */\n  emitNumericEntity(lastCp, expectedLength) {\n    var _a;\n    // Ensure we consumed at least one digit.\n    if (this.consumed <= expectedLength) {\n      (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n      return 0;\n    }\n    // Figure out if this is a legit end of the entity\n    if (lastCp === CharCodes.SEMI) {\n      this.consumed += 1;\n    } else if (this.decodeMode === DecodingMode.Strict) {\n      return 0;\n    }\n    this.emitCodePoint(replaceCodePoint(this.result), this.consumed);\n    if (this.errors) {\n      if (lastCp !== CharCodes.SEMI) {\n        this.errors.missingSemicolonAfterCharacterReference();\n      }\n      this.errors.validateNumericCharacterReference(this.result);\n    }\n    return this.consumed;\n  }\n  /**\n   * Parses a named entity.\n   *\n   * Equivalent to the `Named character reference state` in the HTML spec.\n   *\n   * @param str The string containing the entity (or a continuation of the entity).\n   * @param offset The current offset.\n   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n   */\n  stateNamedEntity(str, offset) {\n    const {\n      decodeTree\n    } = this;\n    let current = decodeTree[this.treeIndex];\n    // The mask is the number of bytes of the value, including the current byte.\n    let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n    for (; offset < str.length; offset++, this.excess++) {\n      const char = str.charCodeAt(offset);\n      this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);\n      if (this.treeIndex < 0) {\n        return this.result === 0 ||\n        // If we are parsing an attribute\n        this.decodeMode === DecodingMode.Attribute && (\n        // We shouldn't have consumed any characters after the entity,\n        valueLength === 0 ||\n        // And there should be no invalid characters.\n        isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();\n      }\n      current = decodeTree[this.treeIndex];\n      valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n      // If the branch is a value, store it and continue\n      if (valueLength !== 0) {\n        // If the entity is terminated by a semicolon, we are done.\n        if (char === CharCodes.SEMI) {\n          return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);\n        }\n        // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.\n        if (this.decodeMode !== DecodingMode.Strict) {\n          this.result = this.treeIndex;\n          this.consumed += this.excess;\n          this.excess = 0;\n        }\n      }\n    }\n    return -1;\n  }\n  /**\n   * Emit a named entity that was not terminated with a semicolon.\n   *\n   * @returns The number of characters consumed.\n   */\n  emitNotTerminatedNamedEntity() {\n    var _a;\n    const {\n      result,\n      decodeTree\n    } = this;\n    const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;\n    this.emitNamedEntityData(result, valueLength, this.consumed);\n    (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();\n    return this.consumed;\n  }\n  /**\n   * Emit a named entity.\n   *\n   * @param result The index of the entity in the decode tree.\n   * @param valueLength The number of bytes in the entity.\n   * @param consumed The number of characters consumed.\n   *\n   * @returns The number of characters consumed.\n   */\n  emitNamedEntityData(result, valueLength, consumed) {\n    const {\n      decodeTree\n    } = this;\n    this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH : decodeTree[result + 1], consumed);\n    if (valueLength === 3) {\n      // For multi-byte values, we need to emit the second byte.\n      this.emitCodePoint(decodeTree[result + 2], consumed);\n    }\n    return consumed;\n  }\n  /**\n   * Signal to the parser that the end of the input was reached.\n   *\n   * Remaining data will be emitted and relevant errors will be produced.\n   *\n   * @returns The number of characters consumed.\n   */\n  end() {\n    var _a;\n    switch (this.state) {\n      case EntityDecoderState.NamedEntity:\n        {\n          // Emit a named entity if we have one.\n          return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;\n        }\n      // Otherwise, emit a numeric entity if we have one.\n      case EntityDecoderState.NumericDecimal:\n        {\n          return this.emitNumericEntity(0, 2);\n        }\n      case EntityDecoderState.NumericHex:\n        {\n          return this.emitNumericEntity(0, 3);\n        }\n      case EntityDecoderState.NumericStart:\n        {\n          (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n          return 0;\n        }\n      case EntityDecoderState.EntityStart:\n        {\n          // Return 0 if we have no entity.\n          return 0;\n        }\n    }\n  }\n}\n/**\n * Creates a function that decodes entities in a string.\n *\n * @param decodeTree The decode tree.\n * @returns A function that decodes entities in a string.\n */\nfunction getDecoder(decodeTree) {\n  let ret = \"\";\n  const decoder = new EntityDecoder(decodeTree, str => ret += fromCodePoint(str));\n  return function decodeWithTrie(str, decodeMode) {\n    let lastIndex = 0;\n    let offset = 0;\n    while ((offset = str.indexOf(\"&\", offset)) >= 0) {\n      ret += str.slice(lastIndex, offset);\n      decoder.startEntity(decodeMode);\n      const len = decoder.write(str,\n      // Skip the \"&\"\n      offset + 1);\n      if (len < 0) {\n        lastIndex = offset + decoder.end();\n        break;\n      }\n      lastIndex = offset + len;\n      // If `len` is 0, skip the current `&` and continue.\n      offset = len === 0 ? lastIndex + 1 : lastIndex;\n    }\n    const result = ret + str.slice(lastIndex);\n    // Make sure we don't keep a reference to the final string.\n    ret = \"\";\n    return result;\n  };\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * @param decodeTree The trie.\n * @param current The current node.\n * @param nodeIdx The index right after the current node and its value.\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIdx, char) {\n  const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n  const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n  // Case 1: Single branch encoded in jump offset\n  if (branchCount === 0) {\n    return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;\n  }\n  // Case 2: Multiple branches encoded in jump table\n  if (jumpOffset) {\n    const value = char - jumpOffset;\n    return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIdx + value] - 1;\n  }\n  // Case 3: Multiple branches encoded in dictionary\n  // Binary search for the character.\n  let lo = nodeIdx;\n  let hi = lo + branchCount - 1;\n  while (lo <= hi) {\n    const mid = lo + hi >>> 1;\n    const midVal = decodeTree[mid];\n    if (midVal < char) {\n      lo = mid + 1;\n    } else if (midVal > char) {\n      hi = mid - 1;\n    } else {\n      return decodeTree[mid + branchCount];\n    }\n  }\n  return -1;\n}\nconst htmlDecoder = getDecoder(htmlDecodeTree);\nconst xmlDecoder = getDecoder(xmlDecodeTree);\n/**\n * Decodes an HTML string.\n *\n * @param str The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(str) {\n  let mode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DecodingMode.Legacy;\n  return htmlDecoder(str, mode);\n}\n/**\n * Decodes an HTML string in an attribute.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(str) {\n  return htmlDecoder(str, DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(str) {\n  return htmlDecoder(str, DecodingMode.Strict);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * @param str The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(str) {\n  return xmlDecoder(str, DecodingMode.Strict);\n}","/** All valid namespaces in HTML. */\nexport var NS;\n(function (NS) {\n  NS[\"HTML\"] = \"http://www.w3.org/1999/xhtml\";\n  NS[\"MATHML\"] = \"http://www.w3.org/1998/Math/MathML\";\n  NS[\"SVG\"] = \"http://www.w3.org/2000/svg\";\n  NS[\"XLINK\"] = \"http://www.w3.org/1999/xlink\";\n  NS[\"XML\"] = \"http://www.w3.org/XML/1998/namespace\";\n  NS[\"XMLNS\"] = \"http://www.w3.org/2000/xmlns/\";\n})(NS = NS || (NS = {}));\nexport var ATTRS;\n(function (ATTRS) {\n  ATTRS[\"TYPE\"] = \"type\";\n  ATTRS[\"ACTION\"] = \"action\";\n  ATTRS[\"ENCODING\"] = \"encoding\";\n  ATTRS[\"PROMPT\"] = \"prompt\";\n  ATTRS[\"NAME\"] = \"name\";\n  ATTRS[\"COLOR\"] = \"color\";\n  ATTRS[\"FACE\"] = \"face\";\n  ATTRS[\"SIZE\"] = \"size\";\n})(ATTRS = ATTRS || (ATTRS = {}));\n/**\n * The mode of the document.\n *\n * @see {@link https://dom.spec.whatwg.org/#concept-document-limited-quirks}\n */\nexport var DOCUMENT_MODE;\n(function (DOCUMENT_MODE) {\n  DOCUMENT_MODE[\"NO_QUIRKS\"] = \"no-quirks\";\n  DOCUMENT_MODE[\"QUIRKS\"] = \"quirks\";\n  DOCUMENT_MODE[\"LIMITED_QUIRKS\"] = \"limited-quirks\";\n})(DOCUMENT_MODE = DOCUMENT_MODE || (DOCUMENT_MODE = {}));\nexport var TAG_NAMES;\n(function (TAG_NAMES) {\n  TAG_NAMES[\"A\"] = \"a\";\n  TAG_NAMES[\"ADDRESS\"] = \"address\";\n  TAG_NAMES[\"ANNOTATION_XML\"] = \"annotation-xml\";\n  TAG_NAMES[\"APPLET\"] = \"applet\";\n  TAG_NAMES[\"AREA\"] = \"area\";\n  TAG_NAMES[\"ARTICLE\"] = \"article\";\n  TAG_NAMES[\"ASIDE\"] = \"aside\";\n  TAG_NAMES[\"B\"] = \"b\";\n  TAG_NAMES[\"BASE\"] = \"base\";\n  TAG_NAMES[\"BASEFONT\"] = \"basefont\";\n  TAG_NAMES[\"BGSOUND\"] = \"bgsound\";\n  TAG_NAMES[\"BIG\"] = \"big\";\n  TAG_NAMES[\"BLOCKQUOTE\"] = \"blockquote\";\n  TAG_NAMES[\"BODY\"] = \"body\";\n  TAG_NAMES[\"BR\"] = \"br\";\n  TAG_NAMES[\"BUTTON\"] = \"button\";\n  TAG_NAMES[\"CAPTION\"] = \"caption\";\n  TAG_NAMES[\"CENTER\"] = \"center\";\n  TAG_NAMES[\"CODE\"] = \"code\";\n  TAG_NAMES[\"COL\"] = \"col\";\n  TAG_NAMES[\"COLGROUP\"] = \"colgroup\";\n  TAG_NAMES[\"DD\"] = \"dd\";\n  TAG_NAMES[\"DESC\"] = \"desc\";\n  TAG_NAMES[\"DETAILS\"] = \"details\";\n  TAG_NAMES[\"DIALOG\"] = \"dialog\";\n  TAG_NAMES[\"DIR\"] = \"dir\";\n  TAG_NAMES[\"DIV\"] = \"div\";\n  TAG_NAMES[\"DL\"] = \"dl\";\n  TAG_NAMES[\"DT\"] = \"dt\";\n  TAG_NAMES[\"EM\"] = \"em\";\n  TAG_NAMES[\"EMBED\"] = \"embed\";\n  TAG_NAMES[\"FIELDSET\"] = \"fieldset\";\n  TAG_NAMES[\"FIGCAPTION\"] = \"figcaption\";\n  TAG_NAMES[\"FIGURE\"] = \"figure\";\n  TAG_NAMES[\"FONT\"] = \"font\";\n  TAG_NAMES[\"FOOTER\"] = \"footer\";\n  TAG_NAMES[\"FOREIGN_OBJECT\"] = \"foreignObject\";\n  TAG_NAMES[\"FORM\"] = \"form\";\n  TAG_NAMES[\"FRAME\"] = \"frame\";\n  TAG_NAMES[\"FRAMESET\"] = \"frameset\";\n  TAG_NAMES[\"H1\"] = \"h1\";\n  TAG_NAMES[\"H2\"] = \"h2\";\n  TAG_NAMES[\"H3\"] = \"h3\";\n  TAG_NAMES[\"H4\"] = \"h4\";\n  TAG_NAMES[\"H5\"] = \"h5\";\n  TAG_NAMES[\"H6\"] = \"h6\";\n  TAG_NAMES[\"HEAD\"] = \"head\";\n  TAG_NAMES[\"HEADER\"] = \"header\";\n  TAG_NAMES[\"HGROUP\"] = \"hgroup\";\n  TAG_NAMES[\"HR\"] = \"hr\";\n  TAG_NAMES[\"HTML\"] = \"html\";\n  TAG_NAMES[\"I\"] = \"i\";\n  TAG_NAMES[\"IMG\"] = \"img\";\n  TAG_NAMES[\"IMAGE\"] = \"image\";\n  TAG_NAMES[\"INPUT\"] = \"input\";\n  TAG_NAMES[\"IFRAME\"] = \"iframe\";\n  TAG_NAMES[\"KEYGEN\"] = \"keygen\";\n  TAG_NAMES[\"LABEL\"] = \"label\";\n  TAG_NAMES[\"LI\"] = \"li\";\n  TAG_NAMES[\"LINK\"] = \"link\";\n  TAG_NAMES[\"LISTING\"] = \"listing\";\n  TAG_NAMES[\"MAIN\"] = \"main\";\n  TAG_NAMES[\"MALIGNMARK\"] = \"malignmark\";\n  TAG_NAMES[\"MARQUEE\"] = \"marquee\";\n  TAG_NAMES[\"MATH\"] = \"math\";\n  TAG_NAMES[\"MENU\"] = \"menu\";\n  TAG_NAMES[\"META\"] = \"meta\";\n  TAG_NAMES[\"MGLYPH\"] = \"mglyph\";\n  TAG_NAMES[\"MI\"] = \"mi\";\n  TAG_NAMES[\"MO\"] = \"mo\";\n  TAG_NAMES[\"MN\"] = \"mn\";\n  TAG_NAMES[\"MS\"] = \"ms\";\n  TAG_NAMES[\"MTEXT\"] = \"mtext\";\n  TAG_NAMES[\"NAV\"] = \"nav\";\n  TAG_NAMES[\"NOBR\"] = \"nobr\";\n  TAG_NAMES[\"NOFRAMES\"] = \"noframes\";\n  TAG_NAMES[\"NOEMBED\"] = \"noembed\";\n  TAG_NAMES[\"NOSCRIPT\"] = \"noscript\";\n  TAG_NAMES[\"OBJECT\"] = \"object\";\n  TAG_NAMES[\"OL\"] = \"ol\";\n  TAG_NAMES[\"OPTGROUP\"] = \"optgroup\";\n  TAG_NAMES[\"OPTION\"] = \"option\";\n  TAG_NAMES[\"P\"] = \"p\";\n  TAG_NAMES[\"PARAM\"] = \"param\";\n  TAG_NAMES[\"PLAINTEXT\"] = \"plaintext\";\n  TAG_NAMES[\"PRE\"] = \"pre\";\n  TAG_NAMES[\"RB\"] = \"rb\";\n  TAG_NAMES[\"RP\"] = \"rp\";\n  TAG_NAMES[\"RT\"] = \"rt\";\n  TAG_NAMES[\"RTC\"] = \"rtc\";\n  TAG_NAMES[\"RUBY\"] = \"ruby\";\n  TAG_NAMES[\"S\"] = \"s\";\n  TAG_NAMES[\"SCRIPT\"] = \"script\";\n  TAG_NAMES[\"SECTION\"] = \"section\";\n  TAG_NAMES[\"SELECT\"] = \"select\";\n  TAG_NAMES[\"SOURCE\"] = \"source\";\n  TAG_NAMES[\"SMALL\"] = \"small\";\n  TAG_NAMES[\"SPAN\"] = \"span\";\n  TAG_NAMES[\"STRIKE\"] = \"strike\";\n  TAG_NAMES[\"STRONG\"] = \"strong\";\n  TAG_NAMES[\"STYLE\"] = \"style\";\n  TAG_NAMES[\"SUB\"] = \"sub\";\n  TAG_NAMES[\"SUMMARY\"] = \"summary\";\n  TAG_NAMES[\"SUP\"] = \"sup\";\n  TAG_NAMES[\"TABLE\"] = \"table\";\n  TAG_NAMES[\"TBODY\"] = \"tbody\";\n  TAG_NAMES[\"TEMPLATE\"] = \"template\";\n  TAG_NAMES[\"TEXTAREA\"] = \"textarea\";\n  TAG_NAMES[\"TFOOT\"] = \"tfoot\";\n  TAG_NAMES[\"TD\"] = \"td\";\n  TAG_NAMES[\"TH\"] = \"th\";\n  TAG_NAMES[\"THEAD\"] = \"thead\";\n  TAG_NAMES[\"TITLE\"] = \"title\";\n  TAG_NAMES[\"TR\"] = \"tr\";\n  TAG_NAMES[\"TRACK\"] = \"track\";\n  TAG_NAMES[\"TT\"] = \"tt\";\n  TAG_NAMES[\"U\"] = \"u\";\n  TAG_NAMES[\"UL\"] = \"ul\";\n  TAG_NAMES[\"SVG\"] = \"svg\";\n  TAG_NAMES[\"VAR\"] = \"var\";\n  TAG_NAMES[\"WBR\"] = \"wbr\";\n  TAG_NAMES[\"XMP\"] = \"xmp\";\n})(TAG_NAMES = TAG_NAMES || (TAG_NAMES = {}));\n/**\n * Tag IDs are numeric IDs for known tag names.\n *\n * We use tag IDs to improve the performance of tag name comparisons.\n */\nexport var TAG_ID;\n(function (TAG_ID) {\n  TAG_ID[TAG_ID[\"UNKNOWN\"] = 0] = \"UNKNOWN\";\n  TAG_ID[TAG_ID[\"A\"] = 1] = \"A\";\n  TAG_ID[TAG_ID[\"ADDRESS\"] = 2] = \"ADDRESS\";\n  TAG_ID[TAG_ID[\"ANNOTATION_XML\"] = 3] = \"ANNOTATION_XML\";\n  TAG_ID[TAG_ID[\"APPLET\"] = 4] = \"APPLET\";\n  TAG_ID[TAG_ID[\"AREA\"] = 5] = \"AREA\";\n  TAG_ID[TAG_ID[\"ARTICLE\"] = 6] = \"ARTICLE\";\n  TAG_ID[TAG_ID[\"ASIDE\"] = 7] = \"ASIDE\";\n  TAG_ID[TAG_ID[\"B\"] = 8] = \"B\";\n  TAG_ID[TAG_ID[\"BASE\"] = 9] = \"BASE\";\n  TAG_ID[TAG_ID[\"BASEFONT\"] = 10] = \"BASEFONT\";\n  TAG_ID[TAG_ID[\"BGSOUND\"] = 11] = \"BGSOUND\";\n  TAG_ID[TAG_ID[\"BIG\"] = 12] = \"BIG\";\n  TAG_ID[TAG_ID[\"BLOCKQUOTE\"] = 13] = \"BLOCKQUOTE\";\n  TAG_ID[TAG_ID[\"BODY\"] = 14] = \"BODY\";\n  TAG_ID[TAG_ID[\"BR\"] = 15] = \"BR\";\n  TAG_ID[TAG_ID[\"BUTTON\"] = 16] = \"BUTTON\";\n  TAG_ID[TAG_ID[\"CAPTION\"] = 17] = \"CAPTION\";\n  TAG_ID[TAG_ID[\"CENTER\"] = 18] = \"CENTER\";\n  TAG_ID[TAG_ID[\"CODE\"] = 19] = \"CODE\";\n  TAG_ID[TAG_ID[\"COL\"] = 20] = \"COL\";\n  TAG_ID[TAG_ID[\"COLGROUP\"] = 21] = \"COLGROUP\";\n  TAG_ID[TAG_ID[\"DD\"] = 22] = \"DD\";\n  TAG_ID[TAG_ID[\"DESC\"] = 23] = \"DESC\";\n  TAG_ID[TAG_ID[\"DETAILS\"] = 24] = \"DETAILS\";\n  TAG_ID[TAG_ID[\"DIALOG\"] = 25] = \"DIALOG\";\n  TAG_ID[TAG_ID[\"DIR\"] = 26] = \"DIR\";\n  TAG_ID[TAG_ID[\"DIV\"] = 27] = \"DIV\";\n  TAG_ID[TAG_ID[\"DL\"] = 28] = \"DL\";\n  TAG_ID[TAG_ID[\"DT\"] = 29] = \"DT\";\n  TAG_ID[TAG_ID[\"EM\"] = 30] = \"EM\";\n  TAG_ID[TAG_ID[\"EMBED\"] = 31] = \"EMBED\";\n  TAG_ID[TAG_ID[\"FIELDSET\"] = 32] = \"FIELDSET\";\n  TAG_ID[TAG_ID[\"FIGCAPTION\"] = 33] = \"FIGCAPTION\";\n  TAG_ID[TAG_ID[\"FIGURE\"] = 34] = \"FIGURE\";\n  TAG_ID[TAG_ID[\"FONT\"] = 35] = \"FONT\";\n  TAG_ID[TAG_ID[\"FOOTER\"] = 36] = \"FOOTER\";\n  TAG_ID[TAG_ID[\"FOREIGN_OBJECT\"] = 37] = \"FOREIGN_OBJECT\";\n  TAG_ID[TAG_ID[\"FORM\"] = 38] = \"FORM\";\n  TAG_ID[TAG_ID[\"FRAME\"] = 39] = \"FRAME\";\n  TAG_ID[TAG_ID[\"FRAMESET\"] = 40] = \"FRAMESET\";\n  TAG_ID[TAG_ID[\"H1\"] = 41] = \"H1\";\n  TAG_ID[TAG_ID[\"H2\"] = 42] = \"H2\";\n  TAG_ID[TAG_ID[\"H3\"] = 43] = \"H3\";\n  TAG_ID[TAG_ID[\"H4\"] = 44] = \"H4\";\n  TAG_ID[TAG_ID[\"H5\"] = 45] = \"H5\";\n  TAG_ID[TAG_ID[\"H6\"] = 46] = \"H6\";\n  TAG_ID[TAG_ID[\"HEAD\"] = 47] = \"HEAD\";\n  TAG_ID[TAG_ID[\"HEADER\"] = 48] = \"HEADER\";\n  TAG_ID[TAG_ID[\"HGROUP\"] = 49] = \"HGROUP\";\n  TAG_ID[TAG_ID[\"HR\"] = 50] = \"HR\";\n  TAG_ID[TAG_ID[\"HTML\"] = 51] = \"HTML\";\n  TAG_ID[TAG_ID[\"I\"] = 52] = \"I\";\n  TAG_ID[TAG_ID[\"IMG\"] = 53] = \"IMG\";\n  TAG_ID[TAG_ID[\"IMAGE\"] = 54] = \"IMAGE\";\n  TAG_ID[TAG_ID[\"INPUT\"] = 55] = \"INPUT\";\n  TAG_ID[TAG_ID[\"IFRAME\"] = 56] = \"IFRAME\";\n  TAG_ID[TAG_ID[\"KEYGEN\"] = 57] = \"KEYGEN\";\n  TAG_ID[TAG_ID[\"LABEL\"] = 58] = \"LABEL\";\n  TAG_ID[TAG_ID[\"LI\"] = 59] = \"LI\";\n  TAG_ID[TAG_ID[\"LINK\"] = 60] = \"LINK\";\n  TAG_ID[TAG_ID[\"LISTING\"] = 61] = \"LISTING\";\n  TAG_ID[TAG_ID[\"MAIN\"] = 62] = \"MAIN\";\n  TAG_ID[TAG_ID[\"MALIGNMARK\"] = 63] = \"MALIGNMARK\";\n  TAG_ID[TAG_ID[\"MARQUEE\"] = 64] = \"MARQUEE\";\n  TAG_ID[TAG_ID[\"MATH\"] = 65] = \"MATH\";\n  TAG_ID[TAG_ID[\"MENU\"] = 66] = \"MENU\";\n  TAG_ID[TAG_ID[\"META\"] = 67] = \"META\";\n  TAG_ID[TAG_ID[\"MGLYPH\"] = 68] = \"MGLYPH\";\n  TAG_ID[TAG_ID[\"MI\"] = 69] = \"MI\";\n  TAG_ID[TAG_ID[\"MO\"] = 70] = \"MO\";\n  TAG_ID[TAG_ID[\"MN\"] = 71] = \"MN\";\n  TAG_ID[TAG_ID[\"MS\"] = 72] = \"MS\";\n  TAG_ID[TAG_ID[\"MTEXT\"] = 73] = \"MTEXT\";\n  TAG_ID[TAG_ID[\"NAV\"] = 74] = \"NAV\";\n  TAG_ID[TAG_ID[\"NOBR\"] = 75] = \"NOBR\";\n  TAG_ID[TAG_ID[\"NOFRAMES\"] = 76] = \"NOFRAMES\";\n  TAG_ID[TAG_ID[\"NOEMBED\"] = 77] = \"NOEMBED\";\n  TAG_ID[TAG_ID[\"NOSCRIPT\"] = 78] = \"NOSCRIPT\";\n  TAG_ID[TAG_ID[\"OBJECT\"] = 79] = \"OBJECT\";\n  TAG_ID[TAG_ID[\"OL\"] = 80] = \"OL\";\n  TAG_ID[TAG_ID[\"OPTGROUP\"] = 81] = \"OPTGROUP\";\n  TAG_ID[TAG_ID[\"OPTION\"] = 82] = \"OPTION\";\n  TAG_ID[TAG_ID[\"P\"] = 83] = \"P\";\n  TAG_ID[TAG_ID[\"PARAM\"] = 84] = \"PARAM\";\n  TAG_ID[TAG_ID[\"PLAINTEXT\"] = 85] = \"PLAINTEXT\";\n  TAG_ID[TAG_ID[\"PRE\"] = 86] = \"PRE\";\n  TAG_ID[TAG_ID[\"RB\"] = 87] = \"RB\";\n  TAG_ID[TAG_ID[\"RP\"] = 88] = \"RP\";\n  TAG_ID[TAG_ID[\"RT\"] = 89] = \"RT\";\n  TAG_ID[TAG_ID[\"RTC\"] = 90] = \"RTC\";\n  TAG_ID[TAG_ID[\"RUBY\"] = 91] = \"RUBY\";\n  TAG_ID[TAG_ID[\"S\"] = 92] = \"S\";\n  TAG_ID[TAG_ID[\"SCRIPT\"] = 93] = \"SCRIPT\";\n  TAG_ID[TAG_ID[\"SECTION\"] = 94] = \"SECTION\";\n  TAG_ID[TAG_ID[\"SELECT\"] = 95] = \"SELECT\";\n  TAG_ID[TAG_ID[\"SOURCE\"] = 96] = \"SOURCE\";\n  TAG_ID[TAG_ID[\"SMALL\"] = 97] = \"SMALL\";\n  TAG_ID[TAG_ID[\"SPAN\"] = 98] = \"SPAN\";\n  TAG_ID[TAG_ID[\"STRIKE\"] = 99] = \"STRIKE\";\n  TAG_ID[TAG_ID[\"STRONG\"] = 100] = \"STRONG\";\n  TAG_ID[TAG_ID[\"STYLE\"] = 101] = \"STYLE\";\n  TAG_ID[TAG_ID[\"SUB\"] = 102] = \"SUB\";\n  TAG_ID[TAG_ID[\"SUMMARY\"] = 103] = \"SUMMARY\";\n  TAG_ID[TAG_ID[\"SUP\"] = 104] = \"SUP\";\n  TAG_ID[TAG_ID[\"TABLE\"] = 105] = \"TABLE\";\n  TAG_ID[TAG_ID[\"TBODY\"] = 106] = \"TBODY\";\n  TAG_ID[TAG_ID[\"TEMPLATE\"] = 107] = \"TEMPLATE\";\n  TAG_ID[TAG_ID[\"TEXTAREA\"] = 108] = \"TEXTAREA\";\n  TAG_ID[TAG_ID[\"TFOOT\"] = 109] = \"TFOOT\";\n  TAG_ID[TAG_ID[\"TD\"] = 110] = \"TD\";\n  TAG_ID[TAG_ID[\"TH\"] = 111] = \"TH\";\n  TAG_ID[TAG_ID[\"THEAD\"] = 112] = \"THEAD\";\n  TAG_ID[TAG_ID[\"TITLE\"] = 113] = \"TITLE\";\n  TAG_ID[TAG_ID[\"TR\"] = 114] = \"TR\";\n  TAG_ID[TAG_ID[\"TRACK\"] = 115] = \"TRACK\";\n  TAG_ID[TAG_ID[\"TT\"] = 116] = \"TT\";\n  TAG_ID[TAG_ID[\"U\"] = 117] = \"U\";\n  TAG_ID[TAG_ID[\"UL\"] = 118] = \"UL\";\n  TAG_ID[TAG_ID[\"SVG\"] = 119] = \"SVG\";\n  TAG_ID[TAG_ID[\"VAR\"] = 120] = \"VAR\";\n  TAG_ID[TAG_ID[\"WBR\"] = 121] = \"WBR\";\n  TAG_ID[TAG_ID[\"XMP\"] = 122] = \"XMP\";\n})(TAG_ID = TAG_ID || (TAG_ID = {}));\nconst TAG_NAME_TO_ID = new Map([[TAG_NAMES.A, TAG_ID.A], [TAG_NAMES.ADDRESS, TAG_ID.ADDRESS], [TAG_NAMES.ANNOTATION_XML, TAG_ID.ANNOTATION_XML], [TAG_NAMES.APPLET, TAG_ID.APPLET], [TAG_NAMES.AREA, TAG_ID.AREA], [TAG_NAMES.ARTICLE, TAG_ID.ARTICLE], [TAG_NAMES.ASIDE, TAG_ID.ASIDE], [TAG_NAMES.B, TAG_ID.B], [TAG_NAMES.BASE, TAG_ID.BASE], [TAG_NAMES.BASEFONT, TAG_ID.BASEFONT], [TAG_NAMES.BGSOUND, TAG_ID.BGSOUND], [TAG_NAMES.BIG, TAG_ID.BIG], [TAG_NAMES.BLOCKQUOTE, TAG_ID.BLOCKQUOTE], [TAG_NAMES.BODY, TAG_ID.BODY], [TAG_NAMES.BR, TAG_ID.BR], [TAG_NAMES.BUTTON, TAG_ID.BUTTON], [TAG_NAMES.CAPTION, TAG_ID.CAPTION], [TAG_NAMES.CENTER, TAG_ID.CENTER], [TAG_NAMES.CODE, TAG_ID.CODE], [TAG_NAMES.COL, TAG_ID.COL], [TAG_NAMES.COLGROUP, TAG_ID.COLGROUP], [TAG_NAMES.DD, TAG_ID.DD], [TAG_NAMES.DESC, TAG_ID.DESC], [TAG_NAMES.DETAILS, TAG_ID.DETAILS], [TAG_NAMES.DIALOG, TAG_ID.DIALOG], [TAG_NAMES.DIR, TAG_ID.DIR], [TAG_NAMES.DIV, TAG_ID.DIV], [TAG_NAMES.DL, TAG_ID.DL], [TAG_NAMES.DT, TAG_ID.DT], [TAG_NAMES.EM, TAG_ID.EM], [TAG_NAMES.EMBED, TAG_ID.EMBED], [TAG_NAMES.FIELDSET, TAG_ID.FIELDSET], [TAG_NAMES.FIGCAPTION, TAG_ID.FIGCAPTION], [TAG_NAMES.FIGURE, TAG_ID.FIGURE], [TAG_NAMES.FONT, TAG_ID.FONT], [TAG_NAMES.FOOTER, TAG_ID.FOOTER], [TAG_NAMES.FOREIGN_OBJECT, TAG_ID.FOREIGN_OBJECT], [TAG_NAMES.FORM, TAG_ID.FORM], [TAG_NAMES.FRAME, TAG_ID.FRAME], [TAG_NAMES.FRAMESET, TAG_ID.FRAMESET], [TAG_NAMES.H1, TAG_ID.H1], [TAG_NAMES.H2, TAG_ID.H2], [TAG_NAMES.H3, TAG_ID.H3], [TAG_NAMES.H4, TAG_ID.H4], [TAG_NAMES.H5, TAG_ID.H5], [TAG_NAMES.H6, TAG_ID.H6], [TAG_NAMES.HEAD, TAG_ID.HEAD], [TAG_NAMES.HEADER, TAG_ID.HEADER], [TAG_NAMES.HGROUP, TAG_ID.HGROUP], [TAG_NAMES.HR, TAG_ID.HR], [TAG_NAMES.HTML, TAG_ID.HTML], [TAG_NAMES.I, TAG_ID.I], [TAG_NAMES.IMG, TAG_ID.IMG], [TAG_NAMES.IMAGE, TAG_ID.IMAGE], [TAG_NAMES.INPUT, TAG_ID.INPUT], [TAG_NAMES.IFRAME, TAG_ID.IFRAME], [TAG_NAMES.KEYGEN, TAG_ID.KEYGEN], [TAG_NAMES.LABEL, TAG_ID.LABEL], [TAG_NAMES.LI, TAG_ID.LI], [TAG_NAMES.LINK, TAG_ID.LINK], [TAG_NAMES.LISTING, TAG_ID.LISTING], [TAG_NAMES.MAIN, TAG_ID.MAIN], [TAG_NAMES.MALIGNMARK, TAG_ID.MALIGNMARK], [TAG_NAMES.MARQUEE, TAG_ID.MARQUEE], [TAG_NAMES.MATH, TAG_ID.MATH], [TAG_NAMES.MENU, TAG_ID.MENU], [TAG_NAMES.META, TAG_ID.META], [TAG_NAMES.MGLYPH, TAG_ID.MGLYPH], [TAG_NAMES.MI, TAG_ID.MI], [TAG_NAMES.MO, TAG_ID.MO], [TAG_NAMES.MN, TAG_ID.MN], [TAG_NAMES.MS, TAG_ID.MS], [TAG_NAMES.MTEXT, TAG_ID.MTEXT], [TAG_NAMES.NAV, TAG_ID.NAV], [TAG_NAMES.NOBR, TAG_ID.NOBR], [TAG_NAMES.NOFRAMES, TAG_ID.NOFRAMES], [TAG_NAMES.NOEMBED, TAG_ID.NOEMBED], [TAG_NAMES.NOSCRIPT, TAG_ID.NOSCRIPT], [TAG_NAMES.OBJECT, TAG_ID.OBJECT], [TAG_NAMES.OL, TAG_ID.OL], [TAG_NAMES.OPTGROUP, TAG_ID.OPTGROUP], [TAG_NAMES.OPTION, TAG_ID.OPTION], [TAG_NAMES.P, TAG_ID.P], [TAG_NAMES.PARAM, TAG_ID.PARAM], [TAG_NAMES.PLAINTEXT, TAG_ID.PLAINTEXT], [TAG_NAMES.PRE, TAG_ID.PRE], [TAG_NAMES.RB, TAG_ID.RB], [TAG_NAMES.RP, TAG_ID.RP], [TAG_NAMES.RT, TAG_ID.RT], [TAG_NAMES.RTC, TAG_ID.RTC], [TAG_NAMES.RUBY, TAG_ID.RUBY], [TAG_NAMES.S, TAG_ID.S], [TAG_NAMES.SCRIPT, TAG_ID.SCRIPT], [TAG_NAMES.SECTION, TAG_ID.SECTION], [TAG_NAMES.SELECT, TAG_ID.SELECT], [TAG_NAMES.SOURCE, TAG_ID.SOURCE], [TAG_NAMES.SMALL, TAG_ID.SMALL], [TAG_NAMES.SPAN, TAG_ID.SPAN], [TAG_NAMES.STRIKE, TAG_ID.STRIKE], [TAG_NAMES.STRONG, TAG_ID.STRONG], [TAG_NAMES.STYLE, TAG_ID.STYLE], [TAG_NAMES.SUB, TAG_ID.SUB], [TAG_NAMES.SUMMARY, TAG_ID.SUMMARY], [TAG_NAMES.SUP, TAG_ID.SUP], [TAG_NAMES.TABLE, TAG_ID.TABLE], [TAG_NAMES.TBODY, TAG_ID.TBODY], [TAG_NAMES.TEMPLATE, TAG_ID.TEMPLATE], [TAG_NAMES.TEXTAREA, TAG_ID.TEXTAREA], [TAG_NAMES.TFOOT, TAG_ID.TFOOT], [TAG_NAMES.TD, TAG_ID.TD], [TAG_NAMES.TH, TAG_ID.TH], [TAG_NAMES.THEAD, TAG_ID.THEAD], [TAG_NAMES.TITLE, TAG_ID.TITLE], [TAG_NAMES.TR, TAG_ID.TR], [TAG_NAMES.TRACK, TAG_ID.TRACK], [TAG_NAMES.TT, TAG_ID.TT], [TAG_NAMES.U, TAG_ID.U], [TAG_NAMES.UL, TAG_ID.UL], [TAG_NAMES.SVG, TAG_ID.SVG], [TAG_NAMES.VAR, TAG_ID.VAR], [TAG_NAMES.WBR, TAG_ID.WBR], [TAG_NAMES.XMP, TAG_ID.XMP]]);\nexport function getTagID(tagName) {\n  var _a;\n  return (_a = TAG_NAME_TO_ID.get(tagName)) !== null && _a !== void 0 ? _a : TAG_ID.UNKNOWN;\n}\nconst $ = TAG_ID;\nexport const SPECIAL_ELEMENTS = {\n  [NS.HTML]: new Set([$.ADDRESS, $.APPLET, $.AREA, $.ARTICLE, $.ASIDE, $.BASE, $.BASEFONT, $.BGSOUND, $.BLOCKQUOTE, $.BODY, $.BR, $.BUTTON, $.CAPTION, $.CENTER, $.COL, $.COLGROUP, $.DD, $.DETAILS, $.DIR, $.DIV, $.DL, $.DT, $.EMBED, $.FIELDSET, $.FIGCAPTION, $.FIGURE, $.FOOTER, $.FORM, $.FRAME, $.FRAMESET, $.H1, $.H2, $.H3, $.H4, $.H5, $.H6, $.HEAD, $.HEADER, $.HGROUP, $.HR, $.HTML, $.IFRAME, $.IMG, $.INPUT, $.LI, $.LINK, $.LISTING, $.MAIN, $.MARQUEE, $.MENU, $.META, $.NAV, $.NOEMBED, $.NOFRAMES, $.NOSCRIPT, $.OBJECT, $.OL, $.P, $.PARAM, $.PLAINTEXT, $.PRE, $.SCRIPT, $.SECTION, $.SELECT, $.SOURCE, $.STYLE, $.SUMMARY, $.TABLE, $.TBODY, $.TD, $.TEMPLATE, $.TEXTAREA, $.TFOOT, $.TH, $.THEAD, $.TITLE, $.TR, $.TRACK, $.UL, $.WBR, $.XMP]),\n  [NS.MATHML]: new Set([$.MI, $.MO, $.MN, $.MS, $.MTEXT, $.ANNOTATION_XML]),\n  [NS.SVG]: new Set([$.TITLE, $.FOREIGN_OBJECT, $.DESC]),\n  [NS.XLINK]: new Set(),\n  [NS.XML]: new Set(),\n  [NS.XMLNS]: new Set()\n};\nexport function isNumberedHeader(tn) {\n  return tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6;\n}\nconst UNESCAPED_TEXT = new Set([TAG_NAMES.STYLE, TAG_NAMES.SCRIPT, TAG_NAMES.XMP, TAG_NAMES.IFRAME, TAG_NAMES.NOEMBED, TAG_NAMES.NOFRAMES, TAG_NAMES.PLAINTEXT]);\nexport function hasUnescapedText(tn, scriptingEnabled) {\n  return UNESCAPED_TEXT.has(tn) || scriptingEnabled && tn === TAG_NAMES.NOSCRIPT;\n}","import { Preprocessor } from './preprocessor.js';\nimport { CODE_POINTS as $, SEQUENCES as $$, REPLACEMENT_CHARACTER, isSurrogate, isUndefinedCodePoint, isControlCodePoint } from '../common/unicode.js';\nimport { TokenType, getTokenAttr } from '../common/token.js';\nimport { htmlDecodeTree, BinTrieFlags, determineBranch } from 'entities/lib/decode.js';\nimport { ERR } from '../common/error-codes.js';\nimport { TAG_ID, getTagID } from '../common/html.js';\n//C1 Unicode control character reference replacements\nconst C1_CONTROLS_REFERENCE_REPLACEMENTS = new Map([[0x80, 8364], [0x82, 8218], [0x83, 402], [0x84, 8222], [0x85, 8230], [0x86, 8224], [0x87, 8225], [0x88, 710], [0x89, 8240], [0x8a, 352], [0x8b, 8249], [0x8c, 338], [0x8e, 381], [0x91, 8216], [0x92, 8217], [0x93, 8220], [0x94, 8221], [0x95, 8226], [0x96, 8211], [0x97, 8212], [0x98, 732], [0x99, 8482], [0x9a, 353], [0x9b, 8250], [0x9c, 339], [0x9e, 382], [0x9f, 376]]);\n//States\nvar State;\n(function (State) {\n  State[State[\"DATA\"] = 0] = \"DATA\";\n  State[State[\"RCDATA\"] = 1] = \"RCDATA\";\n  State[State[\"RAWTEXT\"] = 2] = \"RAWTEXT\";\n  State[State[\"SCRIPT_DATA\"] = 3] = \"SCRIPT_DATA\";\n  State[State[\"PLAINTEXT\"] = 4] = \"PLAINTEXT\";\n  State[State[\"TAG_OPEN\"] = 5] = \"TAG_OPEN\";\n  State[State[\"END_TAG_OPEN\"] = 6] = \"END_TAG_OPEN\";\n  State[State[\"TAG_NAME\"] = 7] = \"TAG_NAME\";\n  State[State[\"RCDATA_LESS_THAN_SIGN\"] = 8] = \"RCDATA_LESS_THAN_SIGN\";\n  State[State[\"RCDATA_END_TAG_OPEN\"] = 9] = \"RCDATA_END_TAG_OPEN\";\n  State[State[\"RCDATA_END_TAG_NAME\"] = 10] = \"RCDATA_END_TAG_NAME\";\n  State[State[\"RAWTEXT_LESS_THAN_SIGN\"] = 11] = \"RAWTEXT_LESS_THAN_SIGN\";\n  State[State[\"RAWTEXT_END_TAG_OPEN\"] = 12] = \"RAWTEXT_END_TAG_OPEN\";\n  State[State[\"RAWTEXT_END_TAG_NAME\"] = 13] = \"RAWTEXT_END_TAG_NAME\";\n  State[State[\"SCRIPT_DATA_LESS_THAN_SIGN\"] = 14] = \"SCRIPT_DATA_LESS_THAN_SIGN\";\n  State[State[\"SCRIPT_DATA_END_TAG_OPEN\"] = 15] = \"SCRIPT_DATA_END_TAG_OPEN\";\n  State[State[\"SCRIPT_DATA_END_TAG_NAME\"] = 16] = \"SCRIPT_DATA_END_TAG_NAME\";\n  State[State[\"SCRIPT_DATA_ESCAPE_START\"] = 17] = \"SCRIPT_DATA_ESCAPE_START\";\n  State[State[\"SCRIPT_DATA_ESCAPE_START_DASH\"] = 18] = \"SCRIPT_DATA_ESCAPE_START_DASH\";\n  State[State[\"SCRIPT_DATA_ESCAPED\"] = 19] = \"SCRIPT_DATA_ESCAPED\";\n  State[State[\"SCRIPT_DATA_ESCAPED_DASH\"] = 20] = \"SCRIPT_DATA_ESCAPED_DASH\";\n  State[State[\"SCRIPT_DATA_ESCAPED_DASH_DASH\"] = 21] = \"SCRIPT_DATA_ESCAPED_DASH_DASH\";\n  State[State[\"SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN\"] = 22] = \"SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN\";\n  State[State[\"SCRIPT_DATA_ESCAPED_END_TAG_OPEN\"] = 23] = \"SCRIPT_DATA_ESCAPED_END_TAG_OPEN\";\n  State[State[\"SCRIPT_DATA_ESCAPED_END_TAG_NAME\"] = 24] = \"SCRIPT_DATA_ESCAPED_END_TAG_NAME\";\n  State[State[\"SCRIPT_DATA_DOUBLE_ESCAPE_START\"] = 25] = \"SCRIPT_DATA_DOUBLE_ESCAPE_START\";\n  State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED\"] = 26] = \"SCRIPT_DATA_DOUBLE_ESCAPED\";\n  State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED_DASH\"] = 27] = \"SCRIPT_DATA_DOUBLE_ESCAPED_DASH\";\n  State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH\"] = 28] = \"SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH\";\n  State[State[\"SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN\"] = 29] = \"SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN\";\n  State[State[\"SCRIPT_DATA_DOUBLE_ESCAPE_END\"] = 30] = \"SCRIPT_DATA_DOUBLE_ESCAPE_END\";\n  State[State[\"BEFORE_ATTRIBUTE_NAME\"] = 31] = \"BEFORE_ATTRIBUTE_NAME\";\n  State[State[\"ATTRIBUTE_NAME\"] = 32] = \"ATTRIBUTE_NAME\";\n  State[State[\"AFTER_ATTRIBUTE_NAME\"] = 33] = \"AFTER_ATTRIBUTE_NAME\";\n  State[State[\"BEFORE_ATTRIBUTE_VALUE\"] = 34] = \"BEFORE_ATTRIBUTE_VALUE\";\n  State[State[\"ATTRIBUTE_VALUE_DOUBLE_QUOTED\"] = 35] = \"ATTRIBUTE_VALUE_DOUBLE_QUOTED\";\n  State[State[\"ATTRIBUTE_VALUE_SINGLE_QUOTED\"] = 36] = \"ATTRIBUTE_VALUE_SINGLE_QUOTED\";\n  State[State[\"ATTRIBUTE_VALUE_UNQUOTED\"] = 37] = \"ATTRIBUTE_VALUE_UNQUOTED\";\n  State[State[\"AFTER_ATTRIBUTE_VALUE_QUOTED\"] = 38] = \"AFTER_ATTRIBUTE_VALUE_QUOTED\";\n  State[State[\"SELF_CLOSING_START_TAG\"] = 39] = \"SELF_CLOSING_START_TAG\";\n  State[State[\"BOGUS_COMMENT\"] = 40] = \"BOGUS_COMMENT\";\n  State[State[\"MARKUP_DECLARATION_OPEN\"] = 41] = \"MARKUP_DECLARATION_OPEN\";\n  State[State[\"COMMENT_START\"] = 42] = \"COMMENT_START\";\n  State[State[\"COMMENT_START_DASH\"] = 43] = \"COMMENT_START_DASH\";\n  State[State[\"COMMENT\"] = 44] = \"COMMENT\";\n  State[State[\"COMMENT_LESS_THAN_SIGN\"] = 45] = \"COMMENT_LESS_THAN_SIGN\";\n  State[State[\"COMMENT_LESS_THAN_SIGN_BANG\"] = 46] = \"COMMENT_LESS_THAN_SIGN_BANG\";\n  State[State[\"COMMENT_LESS_THAN_SIGN_BANG_DASH\"] = 47] = \"COMMENT_LESS_THAN_SIGN_BANG_DASH\";\n  State[State[\"COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH\"] = 48] = \"COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH\";\n  State[State[\"COMMENT_END_DASH\"] = 49] = \"COMMENT_END_DASH\";\n  State[State[\"COMMENT_END\"] = 50] = \"COMMENT_END\";\n  State[State[\"COMMENT_END_BANG\"] = 51] = \"COMMENT_END_BANG\";\n  State[State[\"DOCTYPE\"] = 52] = \"DOCTYPE\";\n  State[State[\"BEFORE_DOCTYPE_NAME\"] = 53] = \"BEFORE_DOCTYPE_NAME\";\n  State[State[\"DOCTYPE_NAME\"] = 54] = \"DOCTYPE_NAME\";\n  State[State[\"AFTER_DOCTYPE_NAME\"] = 55] = \"AFTER_DOCTYPE_NAME\";\n  State[State[\"AFTER_DOCTYPE_PUBLIC_KEYWORD\"] = 56] = \"AFTER_DOCTYPE_PUBLIC_KEYWORD\";\n  State[State[\"BEFORE_DOCTYPE_PUBLIC_IDENTIFIER\"] = 57] = \"BEFORE_DOCTYPE_PUBLIC_IDENTIFIER\";\n  State[State[\"DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED\"] = 58] = \"DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED\";\n  State[State[\"DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED\"] = 59] = \"DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED\";\n  State[State[\"AFTER_DOCTYPE_PUBLIC_IDENTIFIER\"] = 60] = \"AFTER_DOCTYPE_PUBLIC_IDENTIFIER\";\n  State[State[\"BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS\"] = 61] = \"BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS\";\n  State[State[\"AFTER_DOCTYPE_SYSTEM_KEYWORD\"] = 62] = \"AFTER_DOCTYPE_SYSTEM_KEYWORD\";\n  State[State[\"BEFORE_DOCTYPE_SYSTEM_IDENTIFIER\"] = 63] = \"BEFORE_DOCTYPE_SYSTEM_IDENTIFIER\";\n  State[State[\"DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED\"] = 64] = \"DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED\";\n  State[State[\"DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED\"] = 65] = \"DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED\";\n  State[State[\"AFTER_DOCTYPE_SYSTEM_IDENTIFIER\"] = 66] = \"AFTER_DOCTYPE_SYSTEM_IDENTIFIER\";\n  State[State[\"BOGUS_DOCTYPE\"] = 67] = \"BOGUS_DOCTYPE\";\n  State[State[\"CDATA_SECTION\"] = 68] = \"CDATA_SECTION\";\n  State[State[\"CDATA_SECTION_BRACKET\"] = 69] = \"CDATA_SECTION_BRACKET\";\n  State[State[\"CDATA_SECTION_END\"] = 70] = \"CDATA_SECTION_END\";\n  State[State[\"CHARACTER_REFERENCE\"] = 71] = \"CHARACTER_REFERENCE\";\n  State[State[\"NAMED_CHARACTER_REFERENCE\"] = 72] = \"NAMED_CHARACTER_REFERENCE\";\n  State[State[\"AMBIGUOUS_AMPERSAND\"] = 73] = \"AMBIGUOUS_AMPERSAND\";\n  State[State[\"NUMERIC_CHARACTER_REFERENCE\"] = 74] = \"NUMERIC_CHARACTER_REFERENCE\";\n  State[State[\"HEXADEMICAL_CHARACTER_REFERENCE_START\"] = 75] = \"HEXADEMICAL_CHARACTER_REFERENCE_START\";\n  State[State[\"HEXADEMICAL_CHARACTER_REFERENCE\"] = 76] = \"HEXADEMICAL_CHARACTER_REFERENCE\";\n  State[State[\"DECIMAL_CHARACTER_REFERENCE\"] = 77] = \"DECIMAL_CHARACTER_REFERENCE\";\n  State[State[\"NUMERIC_CHARACTER_REFERENCE_END\"] = 78] = \"NUMERIC_CHARACTER_REFERENCE_END\";\n})(State || (State = {}));\n//Tokenizer initial states for different modes\nexport const TokenizerMode = {\n  DATA: State.DATA,\n  RCDATA: State.RCDATA,\n  RAWTEXT: State.RAWTEXT,\n  SCRIPT_DATA: State.SCRIPT_DATA,\n  PLAINTEXT: State.PLAINTEXT,\n  CDATA_SECTION: State.CDATA_SECTION\n};\n//Utils\n//OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline\n//this functions if they will be situated in another module due to context switch.\n//Always perform inlining check before modifying this functions ('node --trace-inlining').\nfunction isAsciiDigit(cp) {\n  return cp >= $.DIGIT_0 && cp <= $.DIGIT_9;\n}\nfunction isAsciiUpper(cp) {\n  return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_Z;\n}\nfunction isAsciiLower(cp) {\n  return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_Z;\n}\nfunction isAsciiLetter(cp) {\n  return isAsciiLower(cp) || isAsciiUpper(cp);\n}\nfunction isAsciiAlphaNumeric(cp) {\n  return isAsciiLetter(cp) || isAsciiDigit(cp);\n}\nfunction isAsciiUpperHexDigit(cp) {\n  return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F;\n}\nfunction isAsciiLowerHexDigit(cp) {\n  return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F;\n}\nfunction isAsciiHexDigit(cp) {\n  return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);\n}\nfunction toAsciiLower(cp) {\n  return cp + 32;\n}\nfunction isWhitespace(cp) {\n  return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;\n}\nfunction isEntityInAttributeInvalidEnd(nextCp) {\n  return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);\n}\nfunction isScriptDataDoubleEscapeSequenceEnd(cp) {\n  return isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN;\n}\n//Tokenizer\nexport class Tokenizer {\n  constructor(options, handler) {\n    this.options = options;\n    this.handler = handler;\n    this.paused = false;\n    /** Ensures that the parsing loop isn't run multiple times at once. */\n    this.inLoop = false;\n    /**\n     * Indicates that the current adjusted node exists, is not an element in the HTML namespace,\n     * and that it is not an integration point for either MathML or HTML.\n     *\n     * @see {@link https://html.spec.whatwg.org/multipage/parsing.html#tree-construction}\n     */\n    this.inForeignNode = false;\n    this.lastStartTagName = '';\n    this.active = false;\n    this.state = State.DATA;\n    this.returnState = State.DATA;\n    this.charRefCode = -1;\n    this.consumedAfterSnapshot = -1;\n    this.currentCharacterToken = null;\n    this.currentToken = null;\n    this.currentAttr = {\n      name: '',\n      value: ''\n    };\n    this.preprocessor = new Preprocessor(handler);\n    this.currentLocation = this.getCurrentLocation(-1);\n  }\n  //Errors\n  _err(code) {\n    var _a, _b;\n    (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code));\n  }\n  // NOTE: `offset` may never run across line boundaries.\n  getCurrentLocation(offset) {\n    if (!this.options.sourceCodeLocationInfo) {\n      return null;\n    }\n    return {\n      startLine: this.preprocessor.line,\n      startCol: this.preprocessor.col - offset,\n      startOffset: this.preprocessor.offset - offset,\n      endLine: -1,\n      endCol: -1,\n      endOffset: -1\n    };\n  }\n  _runParsingLoop() {\n    if (this.inLoop) return;\n    this.inLoop = true;\n    while (this.active && !this.paused) {\n      this.consumedAfterSnapshot = 0;\n      const cp = this._consume();\n      if (!this._ensureHibernation()) {\n        this._callState(cp);\n      }\n    }\n    this.inLoop = false;\n  }\n  //API\n  pause() {\n    this.paused = true;\n  }\n  resume(writeCallback) {\n    if (!this.paused) {\n      throw new Error('Parser was already resumed');\n    }\n    this.paused = false;\n    // Necessary for synchronous resume.\n    if (this.inLoop) return;\n    this._runParsingLoop();\n    if (!this.paused) {\n      writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback();\n    }\n  }\n  write(chunk, isLastChunk, writeCallback) {\n    this.active = true;\n    this.preprocessor.write(chunk, isLastChunk);\n    this._runParsingLoop();\n    if (!this.paused) {\n      writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback();\n    }\n  }\n  insertHtmlAtCurrentPos(chunk) {\n    this.active = true;\n    this.preprocessor.insertHtmlAtCurrentPos(chunk);\n    this._runParsingLoop();\n  }\n  //Hibernation\n  _ensureHibernation() {\n    if (this.preprocessor.endOfChunkHit) {\n      this._unconsume(this.consumedAfterSnapshot);\n      this.active = false;\n      return true;\n    }\n    return false;\n  }\n  //Consumption\n  _consume() {\n    this.consumedAfterSnapshot++;\n    return this.preprocessor.advance();\n  }\n  _unconsume(count) {\n    this.consumedAfterSnapshot -= count;\n    this.preprocessor.retreat(count);\n  }\n  _reconsumeInState(state, cp) {\n    this.state = state;\n    this._callState(cp);\n  }\n  _advanceBy(count) {\n    this.consumedAfterSnapshot += count;\n    for (let i = 0; i < count; i++) {\n      this.preprocessor.advance();\n    }\n  }\n  _consumeSequenceIfMatch(pattern, caseSensitive) {\n    if (this.preprocessor.startsWith(pattern, caseSensitive)) {\n      // We will already have consumed one character before calling this method.\n      this._advanceBy(pattern.length - 1);\n      return true;\n    }\n    return false;\n  }\n  //Token creation\n  _createStartTagToken() {\n    this.currentToken = {\n      type: TokenType.START_TAG,\n      tagName: '',\n      tagID: TAG_ID.UNKNOWN,\n      selfClosing: false,\n      ackSelfClosing: false,\n      attrs: [],\n      location: this.getCurrentLocation(1)\n    };\n  }\n  _createEndTagToken() {\n    this.currentToken = {\n      type: TokenType.END_TAG,\n      tagName: '',\n      tagID: TAG_ID.UNKNOWN,\n      selfClosing: false,\n      ackSelfClosing: false,\n      attrs: [],\n      location: this.getCurrentLocation(2)\n    };\n  }\n  _createCommentToken(offset) {\n    this.currentToken = {\n      type: TokenType.COMMENT,\n      data: '',\n      location: this.getCurrentLocation(offset)\n    };\n  }\n  _createDoctypeToken(initialName) {\n    this.currentToken = {\n      type: TokenType.DOCTYPE,\n      name: initialName,\n      forceQuirks: false,\n      publicId: null,\n      systemId: null,\n      location: this.currentLocation\n    };\n  }\n  _createCharacterToken(type, chars) {\n    this.currentCharacterToken = {\n      type,\n      chars,\n      location: this.currentLocation\n    };\n  }\n  //Tag attributes\n  _createAttr(attrNameFirstCh) {\n    this.currentAttr = {\n      name: attrNameFirstCh,\n      value: ''\n    };\n    this.currentLocation = this.getCurrentLocation(0);\n  }\n  _leaveAttrName() {\n    var _a;\n    var _b;\n    const token = this.currentToken;\n    if (getTokenAttr(token, this.currentAttr.name) === null) {\n      token.attrs.push(this.currentAttr);\n      if (token.location && this.currentLocation) {\n        const attrLocations = (_a = (_b = token.location).attrs) !== null && _a !== void 0 ? _a : _b.attrs = Object.create(null);\n        attrLocations[this.currentAttr.name] = this.currentLocation;\n        // Set end location\n        this._leaveAttrValue();\n      }\n    } else {\n      this._err(ERR.duplicateAttribute);\n    }\n  }\n  _leaveAttrValue() {\n    if (this.currentLocation) {\n      this.currentLocation.endLine = this.preprocessor.line;\n      this.currentLocation.endCol = this.preprocessor.col;\n      this.currentLocation.endOffset = this.preprocessor.offset;\n    }\n  }\n  //Token emission\n  prepareToken(ct) {\n    this._emitCurrentCharacterToken(ct.location);\n    this.currentToken = null;\n    if (ct.location) {\n      ct.location.endLine = this.preprocessor.line;\n      ct.location.endCol = this.preprocessor.col + 1;\n      ct.location.endOffset = this.preprocessor.offset + 1;\n    }\n    this.currentLocation = this.getCurrentLocation(-1);\n  }\n  emitCurrentTagToken() {\n    const ct = this.currentToken;\n    this.prepareToken(ct);\n    ct.tagID = getTagID(ct.tagName);\n    if (ct.type === TokenType.START_TAG) {\n      this.lastStartTagName = ct.tagName;\n      this.handler.onStartTag(ct);\n    } else {\n      if (ct.attrs.length > 0) {\n        this._err(ERR.endTagWithAttributes);\n      }\n      if (ct.selfClosing) {\n        this._err(ERR.endTagWithTrailingSolidus);\n      }\n      this.handler.onEndTag(ct);\n    }\n    this.preprocessor.dropParsedChunk();\n  }\n  emitCurrentComment(ct) {\n    this.prepareToken(ct);\n    this.handler.onComment(ct);\n    this.preprocessor.dropParsedChunk();\n  }\n  emitCurrentDoctype(ct) {\n    this.prepareToken(ct);\n    this.handler.onDoctype(ct);\n    this.preprocessor.dropParsedChunk();\n  }\n  _emitCurrentCharacterToken(nextLocation) {\n    if (this.currentCharacterToken) {\n      //NOTE: if we have a pending character token, make it's end location equal to the\n      //current token's start location.\n      if (nextLocation && this.currentCharacterToken.location) {\n        this.currentCharacterToken.location.endLine = nextLocation.startLine;\n        this.currentCharacterToken.location.endCol = nextLocation.startCol;\n        this.currentCharacterToken.location.endOffset = nextLocation.startOffset;\n      }\n      switch (this.currentCharacterToken.type) {\n        case TokenType.CHARACTER:\n          {\n            this.handler.onCharacter(this.currentCharacterToken);\n            break;\n          }\n        case TokenType.NULL_CHARACTER:\n          {\n            this.handler.onNullCharacter(this.currentCharacterToken);\n            break;\n          }\n        case TokenType.WHITESPACE_CHARACTER:\n          {\n            this.handler.onWhitespaceCharacter(this.currentCharacterToken);\n            break;\n          }\n      }\n      this.currentCharacterToken = null;\n    }\n  }\n  _emitEOFToken() {\n    const location = this.getCurrentLocation(0);\n    if (location) {\n      location.endLine = location.startLine;\n      location.endCol = location.startCol;\n      location.endOffset = location.startOffset;\n    }\n    this._emitCurrentCharacterToken(location);\n    this.handler.onEof({\n      type: TokenType.EOF,\n      location\n    });\n    this.active = false;\n  }\n  //Characters emission\n  //OPTIMIZATION: specification uses only one type of character tokens (one token per character).\n  //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.\n  //If we have a sequence of characters that belong to the same group, the parser can process it\n  //as a single solid character token.\n  //So, there are 3 types of character tokens in parse5:\n  //1)TokenType.NULL_CHARACTER - \\u0000-character sequences (e.g. '\\u0000\\u0000\\u0000')\n  //2)TokenType.WHITESPACE_CHARACTER - any whitespace/new-line character sequences (e.g. '\\n  \\r\\t   \\f')\n  //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')\n  _appendCharToCurrentCharacterToken(type, ch) {\n    if (this.currentCharacterToken) {\n      if (this.currentCharacterToken.type !== type) {\n        this.currentLocation = this.getCurrentLocation(0);\n        this._emitCurrentCharacterToken(this.currentLocation);\n        this.preprocessor.dropParsedChunk();\n      } else {\n        this.currentCharacterToken.chars += ch;\n        return;\n      }\n    }\n    this._createCharacterToken(type, ch);\n  }\n  _emitCodePoint(cp) {\n    const type = isWhitespace(cp) ? TokenType.WHITESPACE_CHARACTER : cp === $.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER;\n    this._appendCharToCurrentCharacterToken(type, String.fromCodePoint(cp));\n  }\n  //NOTE: used when we emit characters explicitly.\n  //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks.\n  _emitChars(ch) {\n    this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch);\n  }\n  // Character reference helpers\n  _matchNamedCharacterReference(cp) {\n    let result = null;\n    let excess = 0;\n    let withoutSemicolon = false;\n    for (let i = 0, current = htmlDecodeTree[0]; i >= 0; cp = this._consume()) {\n      i = determineBranch(htmlDecodeTree, current, i + 1, cp);\n      if (i < 0) break;\n      excess += 1;\n      current = htmlDecodeTree[i];\n      const masked = current & BinTrieFlags.VALUE_LENGTH;\n      // If the branch is a value, store it and continue\n      if (masked) {\n        // The mask is the number of bytes of the value, including the current byte.\n        const valueLength = (masked >> 14) - 1;\n        // Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n        // See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n        if (cp !== $.SEMICOLON && this._isCharacterReferenceInAttribute() && isEntityInAttributeInvalidEnd(this.preprocessor.peek(1))) {\n          //NOTE: we don't flush all consumed code points here, and instead switch back to the original state after\n          //emitting an ampersand. This is fine, as alphanumeric characters won't be parsed differently in attributes.\n          result = [$.AMPERSAND];\n          // Skip over the value.\n          i += valueLength;\n        } else {\n          // If this is a surrogate pair, consume the next two bytes.\n          result = valueLength === 0 ? [htmlDecodeTree[i] & ~BinTrieFlags.VALUE_LENGTH] : valueLength === 1 ? [htmlDecodeTree[++i]] : [htmlDecodeTree[++i], htmlDecodeTree[++i]];\n          excess = 0;\n          withoutSemicolon = cp !== $.SEMICOLON;\n        }\n        if (valueLength === 0) {\n          // If the value is zero-length, we're done.\n          this._consume();\n          break;\n        }\n      }\n    }\n    this._unconsume(excess);\n    if (withoutSemicolon && !this.preprocessor.endOfChunkHit) {\n      this._err(ERR.missingSemicolonAfterCharacterReference);\n    }\n    // We want to emit the error above on the code point after the entity.\n    // We always consume one code point too many in the loop, and we wait to\n    // unconsume it until after the error is emitted.\n    this._unconsume(1);\n    return result;\n  }\n  _isCharacterReferenceInAttribute() {\n    return this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_SINGLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_UNQUOTED;\n  }\n  _flushCodePointConsumedAsCharacterReference(cp) {\n    if (this._isCharacterReferenceInAttribute()) {\n      this.currentAttr.value += String.fromCodePoint(cp);\n    } else {\n      this._emitCodePoint(cp);\n    }\n  }\n  // Calling states this way turns out to be much faster than any other approach.\n  _callState(cp) {\n    switch (this.state) {\n      case State.DATA:\n        {\n          this._stateData(cp);\n          break;\n        }\n      case State.RCDATA:\n        {\n          this._stateRcdata(cp);\n          break;\n        }\n      case State.RAWTEXT:\n        {\n          this._stateRawtext(cp);\n          break;\n        }\n      case State.SCRIPT_DATA:\n        {\n          this._stateScriptData(cp);\n          break;\n        }\n      case State.PLAINTEXT:\n        {\n          this._statePlaintext(cp);\n          break;\n        }\n      case State.TAG_OPEN:\n        {\n          this._stateTagOpen(cp);\n          break;\n        }\n      case State.END_TAG_OPEN:\n        {\n          this._stateEndTagOpen(cp);\n          break;\n        }\n      case State.TAG_NAME:\n        {\n          this._stateTagName(cp);\n          break;\n        }\n      case State.RCDATA_LESS_THAN_SIGN:\n        {\n          this._stateRcdataLessThanSign(cp);\n          break;\n        }\n      case State.RCDATA_END_TAG_OPEN:\n        {\n          this._stateRcdataEndTagOpen(cp);\n          break;\n        }\n      case State.RCDATA_END_TAG_NAME:\n        {\n          this._stateRcdataEndTagName(cp);\n          break;\n        }\n      case State.RAWTEXT_LESS_THAN_SIGN:\n        {\n          this._stateRawtextLessThanSign(cp);\n          break;\n        }\n      case State.RAWTEXT_END_TAG_OPEN:\n        {\n          this._stateRawtextEndTagOpen(cp);\n          break;\n        }\n      case State.RAWTEXT_END_TAG_NAME:\n        {\n          this._stateRawtextEndTagName(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_LESS_THAN_SIGN:\n        {\n          this._stateScriptDataLessThanSign(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_END_TAG_OPEN:\n        {\n          this._stateScriptDataEndTagOpen(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_END_TAG_NAME:\n        {\n          this._stateScriptDataEndTagName(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPE_START:\n        {\n          this._stateScriptDataEscapeStart(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPE_START_DASH:\n        {\n          this._stateScriptDataEscapeStartDash(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPED:\n        {\n          this._stateScriptDataEscaped(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPED_DASH:\n        {\n          this._stateScriptDataEscapedDash(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPED_DASH_DASH:\n        {\n          this._stateScriptDataEscapedDashDash(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN:\n        {\n          this._stateScriptDataEscapedLessThanSign(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN:\n        {\n          this._stateScriptDataEscapedEndTagOpen(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME:\n        {\n          this._stateScriptDataEscapedEndTagName(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_DOUBLE_ESCAPE_START:\n        {\n          this._stateScriptDataDoubleEscapeStart(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_DOUBLE_ESCAPED:\n        {\n          this._stateScriptDataDoubleEscaped(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH:\n        {\n          this._stateScriptDataDoubleEscapedDash(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH:\n        {\n          this._stateScriptDataDoubleEscapedDashDash(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN:\n        {\n          this._stateScriptDataDoubleEscapedLessThanSign(cp);\n          break;\n        }\n      case State.SCRIPT_DATA_DOUBLE_ESCAPE_END:\n        {\n          this._stateScriptDataDoubleEscapeEnd(cp);\n          break;\n        }\n      case State.BEFORE_ATTRIBUTE_NAME:\n        {\n          this._stateBeforeAttributeName(cp);\n          break;\n        }\n      case State.ATTRIBUTE_NAME:\n        {\n          this._stateAttributeName(cp);\n          break;\n        }\n      case State.AFTER_ATTRIBUTE_NAME:\n        {\n          this._stateAfterAttributeName(cp);\n          break;\n        }\n      case State.BEFORE_ATTRIBUTE_VALUE:\n        {\n          this._stateBeforeAttributeValue(cp);\n          break;\n        }\n      case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED:\n        {\n          this._stateAttributeValueDoubleQuoted(cp);\n          break;\n        }\n      case State.ATTRIBUTE_VALUE_SINGLE_QUOTED:\n        {\n          this._stateAttributeValueSingleQuoted(cp);\n          break;\n        }\n      case State.ATTRIBUTE_VALUE_UNQUOTED:\n        {\n          this._stateAttributeValueUnquoted(cp);\n          break;\n        }\n      case State.AFTER_ATTRIBUTE_VALUE_QUOTED:\n        {\n          this._stateAfterAttributeValueQuoted(cp);\n          break;\n        }\n      case State.SELF_CLOSING_START_TAG:\n        {\n          this._stateSelfClosingStartTag(cp);\n          break;\n        }\n      case State.BOGUS_COMMENT:\n        {\n          this._stateBogusComment(cp);\n          break;\n        }\n      case State.MARKUP_DECLARATION_OPEN:\n        {\n          this._stateMarkupDeclarationOpen(cp);\n          break;\n        }\n      case State.COMMENT_START:\n        {\n          this._stateCommentStart(cp);\n          break;\n        }\n      case State.COMMENT_START_DASH:\n        {\n          this._stateCommentStartDash(cp);\n          break;\n        }\n      case State.COMMENT:\n        {\n          this._stateComment(cp);\n          break;\n        }\n      case State.COMMENT_LESS_THAN_SIGN:\n        {\n          this._stateCommentLessThanSign(cp);\n          break;\n        }\n      case State.COMMENT_LESS_THAN_SIGN_BANG:\n        {\n          this._stateCommentLessThanSignBang(cp);\n          break;\n        }\n      case State.COMMENT_LESS_THAN_SIGN_BANG_DASH:\n        {\n          this._stateCommentLessThanSignBangDash(cp);\n          break;\n        }\n      case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH:\n        {\n          this._stateCommentLessThanSignBangDashDash(cp);\n          break;\n        }\n      case State.COMMENT_END_DASH:\n        {\n          this._stateCommentEndDash(cp);\n          break;\n        }\n      case State.COMMENT_END:\n        {\n          this._stateCommentEnd(cp);\n          break;\n        }\n      case State.COMMENT_END_BANG:\n        {\n          this._stateCommentEndBang(cp);\n          break;\n        }\n      case State.DOCTYPE:\n        {\n          this._stateDoctype(cp);\n          break;\n        }\n      case State.BEFORE_DOCTYPE_NAME:\n        {\n          this._stateBeforeDoctypeName(cp);\n          break;\n        }\n      case State.DOCTYPE_NAME:\n        {\n          this._stateDoctypeName(cp);\n          break;\n        }\n      case State.AFTER_DOCTYPE_NAME:\n        {\n          this._stateAfterDoctypeName(cp);\n          break;\n        }\n      case State.AFTER_DOCTYPE_PUBLIC_KEYWORD:\n        {\n          this._stateAfterDoctypePublicKeyword(cp);\n          break;\n        }\n      case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER:\n        {\n          this._stateBeforeDoctypePublicIdentifier(cp);\n          break;\n        }\n      case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED:\n        {\n          this._stateDoctypePublicIdentifierDoubleQuoted(cp);\n          break;\n        }\n      case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED:\n        {\n          this._stateDoctypePublicIdentifierSingleQuoted(cp);\n          break;\n        }\n      case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER:\n        {\n          this._stateAfterDoctypePublicIdentifier(cp);\n          break;\n        }\n      case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS:\n        {\n          this._stateBetweenDoctypePublicAndSystemIdentifiers(cp);\n          break;\n        }\n      case State.AFTER_DOCTYPE_SYSTEM_KEYWORD:\n        {\n          this._stateAfterDoctypeSystemKeyword(cp);\n          break;\n        }\n      case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:\n        {\n          this._stateBeforeDoctypeSystemIdentifier(cp);\n          break;\n        }\n      case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED:\n        {\n          this._stateDoctypeSystemIdentifierDoubleQuoted(cp);\n          break;\n        }\n      case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED:\n        {\n          this._stateDoctypeSystemIdentifierSingleQuoted(cp);\n          break;\n        }\n      case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER:\n        {\n          this._stateAfterDoctypeSystemIdentifier(cp);\n          break;\n        }\n      case State.BOGUS_DOCTYPE:\n        {\n          this._stateBogusDoctype(cp);\n          break;\n        }\n      case State.CDATA_SECTION:\n        {\n          this._stateCdataSection(cp);\n          break;\n        }\n      case State.CDATA_SECTION_BRACKET:\n        {\n          this._stateCdataSectionBracket(cp);\n          break;\n        }\n      case State.CDATA_SECTION_END:\n        {\n          this._stateCdataSectionEnd(cp);\n          break;\n        }\n      case State.CHARACTER_REFERENCE:\n        {\n          this._stateCharacterReference(cp);\n          break;\n        }\n      case State.NAMED_CHARACTER_REFERENCE:\n        {\n          this._stateNamedCharacterReference(cp);\n          break;\n        }\n      case State.AMBIGUOUS_AMPERSAND:\n        {\n          this._stateAmbiguousAmpersand(cp);\n          break;\n        }\n      case State.NUMERIC_CHARACTER_REFERENCE:\n        {\n          this._stateNumericCharacterReference(cp);\n          break;\n        }\n      case State.HEXADEMICAL_CHARACTER_REFERENCE_START:\n        {\n          this._stateHexademicalCharacterReferenceStart(cp);\n          break;\n        }\n      case State.HEXADEMICAL_CHARACTER_REFERENCE:\n        {\n          this._stateHexademicalCharacterReference(cp);\n          break;\n        }\n      case State.DECIMAL_CHARACTER_REFERENCE:\n        {\n          this._stateDecimalCharacterReference(cp);\n          break;\n        }\n      case State.NUMERIC_CHARACTER_REFERENCE_END:\n        {\n          this._stateNumericCharacterReferenceEnd(cp);\n          break;\n        }\n      default:\n        {\n          throw new Error('Unknown state');\n        }\n    }\n  }\n  // State machine\n  // Data state\n  //------------------------------------------------------------------\n  _stateData(cp) {\n    switch (cp) {\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.TAG_OPEN;\n          break;\n        }\n      case $.AMPERSAND:\n        {\n          this.returnState = State.DATA;\n          this.state = State.CHARACTER_REFERENCE;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._emitCodePoint(cp);\n          break;\n        }\n      case $.EOF:\n        {\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  //  RCDATA state\n  //------------------------------------------------------------------\n  _stateRcdata(cp) {\n    switch (cp) {\n      case $.AMPERSAND:\n        {\n          this.returnState = State.RCDATA;\n          this.state = State.CHARACTER_REFERENCE;\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.RCDATA_LESS_THAN_SIGN;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // RAWTEXT state\n  //------------------------------------------------------------------\n  _stateRawtext(cp) {\n    switch (cp) {\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.RAWTEXT_LESS_THAN_SIGN;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Script data state\n  //------------------------------------------------------------------\n  _stateScriptData(cp) {\n    switch (cp) {\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA_LESS_THAN_SIGN;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // PLAINTEXT state\n  //------------------------------------------------------------------\n  _statePlaintext(cp) {\n    switch (cp) {\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Tag open state\n  //------------------------------------------------------------------\n  _stateTagOpen(cp) {\n    if (isAsciiLetter(cp)) {\n      this._createStartTagToken();\n      this.state = State.TAG_NAME;\n      this._stateTagName(cp);\n    } else switch (cp) {\n      case $.EXCLAMATION_MARK:\n        {\n          this.state = State.MARKUP_DECLARATION_OPEN;\n          break;\n        }\n      case $.SOLIDUS:\n        {\n          this.state = State.END_TAG_OPEN;\n          break;\n        }\n      case $.QUESTION_MARK:\n        {\n          this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);\n          this._createCommentToken(1);\n          this.state = State.BOGUS_COMMENT;\n          this._stateBogusComment(cp);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofBeforeTagName);\n          this._emitChars('<');\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.invalidFirstCharacterOfTagName);\n          this._emitChars('<');\n          this.state = State.DATA;\n          this._stateData(cp);\n        }\n    }\n  }\n  // End tag open state\n  //------------------------------------------------------------------\n  _stateEndTagOpen(cp) {\n    if (isAsciiLetter(cp)) {\n      this._createEndTagToken();\n      this.state = State.TAG_NAME;\n      this._stateTagName(cp);\n    } else switch (cp) {\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.missingEndTagName);\n          this.state = State.DATA;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofBeforeTagName);\n          this._emitChars('</');\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.invalidFirstCharacterOfTagName);\n          this._createCommentToken(2);\n          this.state = State.BOGUS_COMMENT;\n          this._stateBogusComment(cp);\n        }\n    }\n  }\n  // Tag name state\n  //------------------------------------------------------------------\n  _stateTagName(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this.state = State.BEFORE_ATTRIBUTE_NAME;\n          break;\n        }\n      case $.SOLIDUS:\n        {\n          this.state = State.SELF_CLOSING_START_TAG;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          this.emitCurrentTagToken();\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.tagName += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInTag);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.tagName += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);\n        }\n    }\n  }\n  // RCDATA less-than sign state\n  //------------------------------------------------------------------\n  _stateRcdataLessThanSign(cp) {\n    if (cp === $.SOLIDUS) {\n      this.state = State.RCDATA_END_TAG_OPEN;\n    } else {\n      this._emitChars('<');\n      this.state = State.RCDATA;\n      this._stateRcdata(cp);\n    }\n  }\n  // RCDATA end tag open state\n  //------------------------------------------------------------------\n  _stateRcdataEndTagOpen(cp) {\n    if (isAsciiLetter(cp)) {\n      this.state = State.RCDATA_END_TAG_NAME;\n      this._stateRcdataEndTagName(cp);\n    } else {\n      this._emitChars('</');\n      this.state = State.RCDATA;\n      this._stateRcdata(cp);\n    }\n  }\n  handleSpecialEndTag(_cp) {\n    if (!this.preprocessor.startsWith(this.lastStartTagName, false)) {\n      return !this._ensureHibernation();\n    }\n    this._createEndTagToken();\n    const token = this.currentToken;\n    token.tagName = this.lastStartTagName;\n    const cp = this.preprocessor.peek(this.lastStartTagName.length);\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this._advanceBy(this.lastStartTagName.length);\n          this.state = State.BEFORE_ATTRIBUTE_NAME;\n          return false;\n        }\n      case $.SOLIDUS:\n        {\n          this._advanceBy(this.lastStartTagName.length);\n          this.state = State.SELF_CLOSING_START_TAG;\n          return false;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._advanceBy(this.lastStartTagName.length);\n          this.emitCurrentTagToken();\n          this.state = State.DATA;\n          return false;\n        }\n      default:\n        {\n          return !this._ensureHibernation();\n        }\n    }\n  }\n  // RCDATA end tag name state\n  //------------------------------------------------------------------\n  _stateRcdataEndTagName(cp) {\n    if (this.handleSpecialEndTag(cp)) {\n      this._emitChars('</');\n      this.state = State.RCDATA;\n      this._stateRcdata(cp);\n    }\n  }\n  // RAWTEXT less-than sign state\n  //------------------------------------------------------------------\n  _stateRawtextLessThanSign(cp) {\n    if (cp === $.SOLIDUS) {\n      this.state = State.RAWTEXT_END_TAG_OPEN;\n    } else {\n      this._emitChars('<');\n      this.state = State.RAWTEXT;\n      this._stateRawtext(cp);\n    }\n  }\n  // RAWTEXT end tag open state\n  //------------------------------------------------------------------\n  _stateRawtextEndTagOpen(cp) {\n    if (isAsciiLetter(cp)) {\n      this.state = State.RAWTEXT_END_TAG_NAME;\n      this._stateRawtextEndTagName(cp);\n    } else {\n      this._emitChars('</');\n      this.state = State.RAWTEXT;\n      this._stateRawtext(cp);\n    }\n  }\n  // RAWTEXT end tag name state\n  //------------------------------------------------------------------\n  _stateRawtextEndTagName(cp) {\n    if (this.handleSpecialEndTag(cp)) {\n      this._emitChars('</');\n      this.state = State.RAWTEXT;\n      this._stateRawtext(cp);\n    }\n  }\n  // Script data less-than sign state\n  //------------------------------------------------------------------\n  _stateScriptDataLessThanSign(cp) {\n    switch (cp) {\n      case $.SOLIDUS:\n        {\n          this.state = State.SCRIPT_DATA_END_TAG_OPEN;\n          break;\n        }\n      case $.EXCLAMATION_MARK:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPE_START;\n          this._emitChars('<!');\n          break;\n        }\n      default:\n        {\n          this._emitChars('<');\n          this.state = State.SCRIPT_DATA;\n          this._stateScriptData(cp);\n        }\n    }\n  }\n  // Script data end tag open state\n  //------------------------------------------------------------------\n  _stateScriptDataEndTagOpen(cp) {\n    if (isAsciiLetter(cp)) {\n      this.state = State.SCRIPT_DATA_END_TAG_NAME;\n      this._stateScriptDataEndTagName(cp);\n    } else {\n      this._emitChars('</');\n      this.state = State.SCRIPT_DATA;\n      this._stateScriptData(cp);\n    }\n  }\n  // Script data end tag name state\n  //------------------------------------------------------------------\n  _stateScriptDataEndTagName(cp) {\n    if (this.handleSpecialEndTag(cp)) {\n      this._emitChars('</');\n      this.state = State.SCRIPT_DATA;\n      this._stateScriptData(cp);\n    }\n  }\n  // Script data escape start state\n  //------------------------------------------------------------------\n  _stateScriptDataEscapeStart(cp) {\n    if (cp === $.HYPHEN_MINUS) {\n      this.state = State.SCRIPT_DATA_ESCAPE_START_DASH;\n      this._emitChars('-');\n    } else {\n      this.state = State.SCRIPT_DATA;\n      this._stateScriptData(cp);\n    }\n  }\n  // Script data escape start dash state\n  //------------------------------------------------------------------\n  _stateScriptDataEscapeStartDash(cp) {\n    if (cp === $.HYPHEN_MINUS) {\n      this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;\n      this._emitChars('-');\n    } else {\n      this.state = State.SCRIPT_DATA;\n      this._stateScriptData(cp);\n    }\n  }\n  // Script data escaped state\n  //------------------------------------------------------------------\n  _stateScriptDataEscaped(cp) {\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPED_DASH;\n          this._emitChars('-');\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInScriptHtmlCommentLikeText);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Script data escaped dash state\n  //------------------------------------------------------------------\n  _stateScriptDataEscapedDash(cp) {\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;\n          this._emitChars('-');\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.state = State.SCRIPT_DATA_ESCAPED;\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInScriptHtmlCommentLikeText);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPED;\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Script data escaped dash dash state\n  //------------------------------------------------------------------\n  _stateScriptDataEscapedDashDash(cp) {\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this._emitChars('-');\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA;\n          this._emitChars('>');\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.state = State.SCRIPT_DATA_ESCAPED;\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInScriptHtmlCommentLikeText);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this.state = State.SCRIPT_DATA_ESCAPED;\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Script data escaped less-than sign state\n  //------------------------------------------------------------------\n  _stateScriptDataEscapedLessThanSign(cp) {\n    if (cp === $.SOLIDUS) {\n      this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN;\n    } else if (isAsciiLetter(cp)) {\n      this._emitChars('<');\n      this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START;\n      this._stateScriptDataDoubleEscapeStart(cp);\n    } else {\n      this._emitChars('<');\n      this.state = State.SCRIPT_DATA_ESCAPED;\n      this._stateScriptDataEscaped(cp);\n    }\n  }\n  // Script data escaped end tag open state\n  //------------------------------------------------------------------\n  _stateScriptDataEscapedEndTagOpen(cp) {\n    if (isAsciiLetter(cp)) {\n      this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_NAME;\n      this._stateScriptDataEscapedEndTagName(cp);\n    } else {\n      this._emitChars('</');\n      this.state = State.SCRIPT_DATA_ESCAPED;\n      this._stateScriptDataEscaped(cp);\n    }\n  }\n  // Script data escaped end tag name state\n  //------------------------------------------------------------------\n  _stateScriptDataEscapedEndTagName(cp) {\n    if (this.handleSpecialEndTag(cp)) {\n      this._emitChars('</');\n      this.state = State.SCRIPT_DATA_ESCAPED;\n      this._stateScriptDataEscaped(cp);\n    }\n  }\n  // Script data double escape start state\n  //------------------------------------------------------------------\n  _stateScriptDataDoubleEscapeStart(cp) {\n    if (this.preprocessor.startsWith($$.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek($$.SCRIPT.length))) {\n      this._emitCodePoint(cp);\n      for (let i = 0; i < $$.SCRIPT.length; i++) {\n        this._emitCodePoint(this._consume());\n      }\n      this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n    } else if (!this._ensureHibernation()) {\n      this.state = State.SCRIPT_DATA_ESCAPED;\n      this._stateScriptDataEscaped(cp);\n    }\n  }\n  // Script data double escaped state\n  //------------------------------------------------------------------\n  _stateScriptDataDoubleEscaped(cp) {\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH;\n          this._emitChars('-');\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;\n          this._emitChars('<');\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInScriptHtmlCommentLikeText);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Script data double escaped dash state\n  //------------------------------------------------------------------\n  _stateScriptDataDoubleEscapedDash(cp) {\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;\n          this._emitChars('-');\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;\n          this._emitChars('<');\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInScriptHtmlCommentLikeText);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Script data double escaped dash dash state\n  //------------------------------------------------------------------\n  _stateScriptDataDoubleEscapedDashDash(cp) {\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this._emitChars('-');\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;\n          this._emitChars('<');\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.SCRIPT_DATA;\n          this._emitChars('>');\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n          this._emitChars(REPLACEMENT_CHARACTER);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInScriptHtmlCommentLikeText);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // Script data double escaped less-than sign state\n  //------------------------------------------------------------------\n  _stateScriptDataDoubleEscapedLessThanSign(cp) {\n    if (cp === $.SOLIDUS) {\n      this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_END;\n      this._emitChars('/');\n    } else {\n      this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n      this._stateScriptDataDoubleEscaped(cp);\n    }\n  }\n  // Script data double escape end state\n  //------------------------------------------------------------------\n  _stateScriptDataDoubleEscapeEnd(cp) {\n    if (this.preprocessor.startsWith($$.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek($$.SCRIPT.length))) {\n      this._emitCodePoint(cp);\n      for (let i = 0; i < $$.SCRIPT.length; i++) {\n        this._emitCodePoint(this._consume());\n      }\n      this.state = State.SCRIPT_DATA_ESCAPED;\n    } else if (!this._ensureHibernation()) {\n      this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;\n      this._stateScriptDataDoubleEscaped(cp);\n    }\n  }\n  // Before attribute name state\n  //------------------------------------------------------------------\n  _stateBeforeAttributeName(cp) {\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.SOLIDUS:\n      case $.GREATER_THAN_SIGN:\n      case $.EOF:\n        {\n          this.state = State.AFTER_ATTRIBUTE_NAME;\n          this._stateAfterAttributeName(cp);\n          break;\n        }\n      case $.EQUALS_SIGN:\n        {\n          this._err(ERR.unexpectedEqualsSignBeforeAttributeName);\n          this._createAttr('=');\n          this.state = State.ATTRIBUTE_NAME;\n          break;\n        }\n      default:\n        {\n          this._createAttr('');\n          this.state = State.ATTRIBUTE_NAME;\n          this._stateAttributeName(cp);\n        }\n    }\n  }\n  // Attribute name state\n  //------------------------------------------------------------------\n  _stateAttributeName(cp) {\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n      case $.SOLIDUS:\n      case $.GREATER_THAN_SIGN:\n      case $.EOF:\n        {\n          this._leaveAttrName();\n          this.state = State.AFTER_ATTRIBUTE_NAME;\n          this._stateAfterAttributeName(cp);\n          break;\n        }\n      case $.EQUALS_SIGN:\n        {\n          this._leaveAttrName();\n          this.state = State.BEFORE_ATTRIBUTE_VALUE;\n          break;\n        }\n      case $.QUOTATION_MARK:\n      case $.APOSTROPHE:\n      case $.LESS_THAN_SIGN:\n        {\n          this._err(ERR.unexpectedCharacterInAttributeName);\n          this.currentAttr.name += String.fromCodePoint(cp);\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.currentAttr.name += REPLACEMENT_CHARACTER;\n          break;\n        }\n      default:\n        {\n          this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);\n        }\n    }\n  }\n  // After attribute name state\n  //------------------------------------------------------------------\n  _stateAfterAttributeName(cp) {\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.SOLIDUS:\n        {\n          this.state = State.SELF_CLOSING_START_TAG;\n          break;\n        }\n      case $.EQUALS_SIGN:\n        {\n          this.state = State.BEFORE_ATTRIBUTE_VALUE;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          this.emitCurrentTagToken();\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInTag);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._createAttr('');\n          this.state = State.ATTRIBUTE_NAME;\n          this._stateAttributeName(cp);\n        }\n    }\n  }\n  // Before attribute value state\n  //------------------------------------------------------------------\n  _stateBeforeAttributeValue(cp) {\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.QUOTATION_MARK:\n        {\n          this.state = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;\n          break;\n        }\n      case $.APOSTROPHE:\n        {\n          this.state = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.missingAttributeValue);\n          this.state = State.DATA;\n          this.emitCurrentTagToken();\n          break;\n        }\n      default:\n        {\n          this.state = State.ATTRIBUTE_VALUE_UNQUOTED;\n          this._stateAttributeValueUnquoted(cp);\n        }\n    }\n  }\n  // Attribute value (double-quoted) state\n  //------------------------------------------------------------------\n  _stateAttributeValueDoubleQuoted(cp) {\n    switch (cp) {\n      case $.QUOTATION_MARK:\n        {\n          this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;\n          break;\n        }\n      case $.AMPERSAND:\n        {\n          this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;\n          this.state = State.CHARACTER_REFERENCE;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.currentAttr.value += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInTag);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this.currentAttr.value += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // Attribute value (single-quoted) state\n  //------------------------------------------------------------------\n  _stateAttributeValueSingleQuoted(cp) {\n    switch (cp) {\n      case $.APOSTROPHE:\n        {\n          this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;\n          break;\n        }\n      case $.AMPERSAND:\n        {\n          this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;\n          this.state = State.CHARACTER_REFERENCE;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.currentAttr.value += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInTag);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this.currentAttr.value += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // Attribute value (unquoted) state\n  //------------------------------------------------------------------\n  _stateAttributeValueUnquoted(cp) {\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this._leaveAttrValue();\n          this.state = State.BEFORE_ATTRIBUTE_NAME;\n          break;\n        }\n      case $.AMPERSAND:\n        {\n          this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED;\n          this.state = State.CHARACTER_REFERENCE;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._leaveAttrValue();\n          this.state = State.DATA;\n          this.emitCurrentTagToken();\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this.currentAttr.value += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.QUOTATION_MARK:\n      case $.APOSTROPHE:\n      case $.LESS_THAN_SIGN:\n      case $.EQUALS_SIGN:\n      case $.GRAVE_ACCENT:\n        {\n          this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);\n          this.currentAttr.value += String.fromCodePoint(cp);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInTag);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this.currentAttr.value += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // After attribute value (quoted) state\n  //------------------------------------------------------------------\n  _stateAfterAttributeValueQuoted(cp) {\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this._leaveAttrValue();\n          this.state = State.BEFORE_ATTRIBUTE_NAME;\n          break;\n        }\n      case $.SOLIDUS:\n        {\n          this._leaveAttrValue();\n          this.state = State.SELF_CLOSING_START_TAG;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._leaveAttrValue();\n          this.state = State.DATA;\n          this.emitCurrentTagToken();\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInTag);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingWhitespaceBetweenAttributes);\n          this.state = State.BEFORE_ATTRIBUTE_NAME;\n          this._stateBeforeAttributeName(cp);\n        }\n    }\n  }\n  // Self-closing start tag state\n  //------------------------------------------------------------------\n  _stateSelfClosingStartTag(cp) {\n    switch (cp) {\n      case $.GREATER_THAN_SIGN:\n        {\n          const token = this.currentToken;\n          token.selfClosing = true;\n          this.state = State.DATA;\n          this.emitCurrentTagToken();\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInTag);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.unexpectedSolidusInTag);\n          this.state = State.BEFORE_ATTRIBUTE_NAME;\n          this._stateBeforeAttributeName(cp);\n        }\n    }\n  }\n  // Bogus comment state\n  //------------------------------------------------------------------\n  _stateBogusComment(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          this.emitCurrentComment(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this.emitCurrentComment(token);\n          this._emitEOFToken();\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.data += REPLACEMENT_CHARACTER;\n          break;\n        }\n      default:\n        {\n          token.data += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // Markup declaration open state\n  //------------------------------------------------------------------\n  _stateMarkupDeclarationOpen(cp) {\n    if (this._consumeSequenceIfMatch($$.DASH_DASH, true)) {\n      this._createCommentToken($$.DASH_DASH.length + 1);\n      this.state = State.COMMENT_START;\n    } else if (this._consumeSequenceIfMatch($$.DOCTYPE, false)) {\n      // NOTE: Doctypes tokens are created without fixed offsets. We keep track of the moment a doctype *might* start here.\n      this.currentLocation = this.getCurrentLocation($$.DOCTYPE.length + 1);\n      this.state = State.DOCTYPE;\n    } else if (this._consumeSequenceIfMatch($$.CDATA_START, true)) {\n      if (this.inForeignNode) {\n        this.state = State.CDATA_SECTION;\n      } else {\n        this._err(ERR.cdataInHtmlContent);\n        this._createCommentToken($$.CDATA_START.length + 1);\n        this.currentToken.data = '[CDATA[';\n        this.state = State.BOGUS_COMMENT;\n      }\n    }\n    //NOTE: Sequence lookups can be abrupted by hibernation. In that case, lookup\n    //results are no longer valid and we will need to start over.\n    else if (!this._ensureHibernation()) {\n      this._err(ERR.incorrectlyOpenedComment);\n      this._createCommentToken(2);\n      this.state = State.BOGUS_COMMENT;\n      this._stateBogusComment(cp);\n    }\n  }\n  // Comment start state\n  //------------------------------------------------------------------\n  _stateCommentStart(cp) {\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.COMMENT_START_DASH;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.abruptClosingOfEmptyComment);\n          this.state = State.DATA;\n          const token = this.currentToken;\n          this.emitCurrentComment(token);\n          break;\n        }\n      default:\n        {\n          this.state = State.COMMENT;\n          this._stateComment(cp);\n        }\n    }\n  }\n  // Comment start dash state\n  //------------------------------------------------------------------\n  _stateCommentStartDash(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.COMMENT_END;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.abruptClosingOfEmptyComment);\n          this.state = State.DATA;\n          this.emitCurrentComment(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInComment);\n          this.emitCurrentComment(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.data += '-';\n          this.state = State.COMMENT;\n          this._stateComment(cp);\n        }\n    }\n  }\n  // Comment state\n  //------------------------------------------------------------------\n  _stateComment(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.COMMENT_END_DASH;\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          token.data += '<';\n          this.state = State.COMMENT_LESS_THAN_SIGN;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.data += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInComment);\n          this.emitCurrentComment(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.data += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // Comment less-than sign state\n  //------------------------------------------------------------------\n  _stateCommentLessThanSign(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.EXCLAMATION_MARK:\n        {\n          token.data += '!';\n          this.state = State.COMMENT_LESS_THAN_SIGN_BANG;\n          break;\n        }\n      case $.LESS_THAN_SIGN:\n        {\n          token.data += '<';\n          break;\n        }\n      default:\n        {\n          this.state = State.COMMENT;\n          this._stateComment(cp);\n        }\n    }\n  }\n  // Comment less-than sign bang state\n  //------------------------------------------------------------------\n  _stateCommentLessThanSignBang(cp) {\n    if (cp === $.HYPHEN_MINUS) {\n      this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH;\n    } else {\n      this.state = State.COMMENT;\n      this._stateComment(cp);\n    }\n  }\n  // Comment less-than sign bang dash state\n  //------------------------------------------------------------------\n  _stateCommentLessThanSignBangDash(cp) {\n    if (cp === $.HYPHEN_MINUS) {\n      this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH;\n    } else {\n      this.state = State.COMMENT_END_DASH;\n      this._stateCommentEndDash(cp);\n    }\n  }\n  // Comment less-than sign bang dash dash state\n  //------------------------------------------------------------------\n  _stateCommentLessThanSignBangDashDash(cp) {\n    if (cp !== $.GREATER_THAN_SIGN && cp !== $.EOF) {\n      this._err(ERR.nestedComment);\n    }\n    this.state = State.COMMENT_END;\n    this._stateCommentEnd(cp);\n  }\n  // Comment end dash state\n  //------------------------------------------------------------------\n  _stateCommentEndDash(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          this.state = State.COMMENT_END;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInComment);\n          this.emitCurrentComment(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.data += '-';\n          this.state = State.COMMENT;\n          this._stateComment(cp);\n        }\n    }\n  }\n  // Comment end state\n  //------------------------------------------------------------------\n  _stateCommentEnd(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          this.emitCurrentComment(token);\n          break;\n        }\n      case $.EXCLAMATION_MARK:\n        {\n          this.state = State.COMMENT_END_BANG;\n          break;\n        }\n      case $.HYPHEN_MINUS:\n        {\n          token.data += '-';\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInComment);\n          this.emitCurrentComment(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.data += '--';\n          this.state = State.COMMENT;\n          this._stateComment(cp);\n        }\n    }\n  }\n  // Comment end bang state\n  //------------------------------------------------------------------\n  _stateCommentEndBang(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.HYPHEN_MINUS:\n        {\n          token.data += '--!';\n          this.state = State.COMMENT_END_DASH;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.incorrectlyClosedComment);\n          this.state = State.DATA;\n          this.emitCurrentComment(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInComment);\n          this.emitCurrentComment(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.data += '--!';\n          this.state = State.COMMENT;\n          this._stateComment(cp);\n        }\n    }\n  }\n  // DOCTYPE state\n  //------------------------------------------------------------------\n  _stateDoctype(cp) {\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this.state = State.BEFORE_DOCTYPE_NAME;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.BEFORE_DOCTYPE_NAME;\n          this._stateBeforeDoctypeName(cp);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          this._createDoctypeToken(null);\n          const token = this.currentToken;\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingWhitespaceBeforeDoctypeName);\n          this.state = State.BEFORE_DOCTYPE_NAME;\n          this._stateBeforeDoctypeName(cp);\n        }\n    }\n  }\n  // Before DOCTYPE name state\n  //------------------------------------------------------------------\n  _stateBeforeDoctypeName(cp) {\n    if (isAsciiUpper(cp)) {\n      this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp)));\n      this.state = State.DOCTYPE_NAME;\n    } else switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          this._createDoctypeToken(REPLACEMENT_CHARACTER);\n          this.state = State.DOCTYPE_NAME;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.missingDoctypeName);\n          this._createDoctypeToken(null);\n          const token = this.currentToken;\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          this._createDoctypeToken(null);\n          const token = this.currentToken;\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._createDoctypeToken(String.fromCodePoint(cp));\n          this.state = State.DOCTYPE_NAME;\n        }\n    }\n  }\n  // DOCTYPE name state\n  //------------------------------------------------------------------\n  _stateDoctypeName(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this.state = State.AFTER_DOCTYPE_NAME;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          this.emitCurrentDoctype(token);\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.name += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);\n        }\n    }\n  }\n  // After DOCTYPE name state\n  //------------------------------------------------------------------\n  _stateAfterDoctypeName(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          this.emitCurrentDoctype(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          if (this._consumeSequenceIfMatch($$.PUBLIC, false)) {\n            this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD;\n          } else if (this._consumeSequenceIfMatch($$.SYSTEM, false)) {\n            this.state = State.AFTER_DOCTYPE_SYSTEM_KEYWORD;\n          }\n          //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup\n          //results are no longer valid and we will need to start over.\n          else if (!this._ensureHibernation()) {\n            this._err(ERR.invalidCharacterSequenceAfterDoctypeName);\n            token.forceQuirks = true;\n            this.state = State.BOGUS_DOCTYPE;\n            this._stateBogusDoctype(cp);\n          }\n        }\n    }\n  }\n  // After DOCTYPE public keyword state\n  //------------------------------------------------------------------\n  _stateAfterDoctypePublicKeyword(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this.state = State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;\n          break;\n        }\n      case $.QUOTATION_MARK:\n        {\n          this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);\n          token.publicId = '';\n          this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;\n          break;\n        }\n      case $.APOSTROPHE:\n        {\n          this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);\n          token.publicId = '';\n          this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.missingDoctypePublicIdentifier);\n          token.forceQuirks = true;\n          this.state = State.DATA;\n          this.emitCurrentDoctype(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);\n          token.forceQuirks = true;\n          this.state = State.BOGUS_DOCTYPE;\n          this._stateBogusDoctype(cp);\n        }\n    }\n  }\n  // Before DOCTYPE public identifier state\n  //------------------------------------------------------------------\n  _stateBeforeDoctypePublicIdentifier(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.QUOTATION_MARK:\n        {\n          token.publicId = '';\n          this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;\n          break;\n        }\n      case $.APOSTROPHE:\n        {\n          token.publicId = '';\n          this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.missingDoctypePublicIdentifier);\n          token.forceQuirks = true;\n          this.state = State.DATA;\n          this.emitCurrentDoctype(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);\n          token.forceQuirks = true;\n          this.state = State.BOGUS_DOCTYPE;\n          this._stateBogusDoctype(cp);\n        }\n    }\n  }\n  // DOCTYPE public identifier (double-quoted) state\n  //------------------------------------------------------------------\n  _stateDoctypePublicIdentifierDoubleQuoted(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.QUOTATION_MARK:\n        {\n          this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.publicId += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.abruptDoctypePublicIdentifier);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.publicId += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // DOCTYPE public identifier (single-quoted) state\n  //------------------------------------------------------------------\n  _stateDoctypePublicIdentifierSingleQuoted(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.APOSTROPHE:\n        {\n          this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.publicId += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.abruptDoctypePublicIdentifier);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.publicId += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // After DOCTYPE public identifier state\n  //------------------------------------------------------------------\n  _stateAfterDoctypePublicIdentifier(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this.state = State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          this.emitCurrentDoctype(token);\n          break;\n        }\n      case $.QUOTATION_MARK:\n        {\n          this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n          break;\n        }\n      case $.APOSTROPHE:\n        {\n          this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.state = State.BOGUS_DOCTYPE;\n          this._stateBogusDoctype(cp);\n        }\n    }\n  }\n  // Between DOCTYPE public and system identifiers state\n  //------------------------------------------------------------------\n  _stateBetweenDoctypePublicAndSystemIdentifiers(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.QUOTATION_MARK:\n        {\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n          break;\n        }\n      case $.APOSTROPHE:\n        {\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.state = State.BOGUS_DOCTYPE;\n          this._stateBogusDoctype(cp);\n        }\n    }\n  }\n  // After DOCTYPE system keyword state\n  //------------------------------------------------------------------\n  _stateAfterDoctypeSystemKeyword(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          this.state = State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER;\n          break;\n        }\n      case $.QUOTATION_MARK:\n        {\n          this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n          break;\n        }\n      case $.APOSTROPHE:\n        {\n          this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.missingDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.state = State.DATA;\n          this.emitCurrentDoctype(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.state = State.BOGUS_DOCTYPE;\n          this._stateBogusDoctype(cp);\n        }\n    }\n  }\n  // Before DOCTYPE system identifier state\n  //------------------------------------------------------------------\n  _stateBeforeDoctypeSystemIdentifier(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.QUOTATION_MARK:\n        {\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;\n          break;\n        }\n      case $.APOSTROPHE:\n        {\n          token.systemId = '';\n          this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.missingDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.state = State.DATA;\n          this.emitCurrentDoctype(token);\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.state = State.BOGUS_DOCTYPE;\n          this._stateBogusDoctype(cp);\n        }\n    }\n  }\n  // DOCTYPE system identifier (double-quoted) state\n  //------------------------------------------------------------------\n  _stateDoctypeSystemIdentifierDoubleQuoted(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.QUOTATION_MARK:\n        {\n          this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.systemId += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.abruptDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.systemId += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // DOCTYPE system identifier (single-quoted) state\n  //------------------------------------------------------------------\n  _stateDoctypeSystemIdentifierSingleQuoted(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.APOSTROPHE:\n        {\n          this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          token.systemId += REPLACEMENT_CHARACTER;\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this._err(ERR.abruptDoctypeSystemIdentifier);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          token.systemId += String.fromCodePoint(cp);\n        }\n    }\n  }\n  // After DOCTYPE system identifier state\n  //------------------------------------------------------------------\n  _stateAfterDoctypeSystemIdentifier(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.SPACE:\n      case $.LINE_FEED:\n      case $.TABULATION:\n      case $.FORM_FEED:\n        {\n          // Ignore whitespace\n          break;\n        }\n      case $.GREATER_THAN_SIGN:\n        {\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInDoctype);\n          token.forceQuirks = true;\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);\n          this.state = State.BOGUS_DOCTYPE;\n          this._stateBogusDoctype(cp);\n        }\n    }\n  }\n  // Bogus DOCTYPE state\n  //------------------------------------------------------------------\n  _stateBogusDoctype(cp) {\n    const token = this.currentToken;\n    switch (cp) {\n      case $.GREATER_THAN_SIGN:\n        {\n          this.emitCurrentDoctype(token);\n          this.state = State.DATA;\n          break;\n        }\n      case $.NULL:\n        {\n          this._err(ERR.unexpectedNullCharacter);\n          break;\n        }\n      case $.EOF:\n        {\n          this.emitCurrentDoctype(token);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n  // CDATA section state\n  //------------------------------------------------------------------\n  _stateCdataSection(cp) {\n    switch (cp) {\n      case $.RIGHT_SQUARE_BRACKET:\n        {\n          this.state = State.CDATA_SECTION_BRACKET;\n          break;\n        }\n      case $.EOF:\n        {\n          this._err(ERR.eofInCdata);\n          this._emitEOFToken();\n          break;\n        }\n      default:\n        {\n          this._emitCodePoint(cp);\n        }\n    }\n  }\n  // CDATA section bracket state\n  //------------------------------------------------------------------\n  _stateCdataSectionBracket(cp) {\n    if (cp === $.RIGHT_SQUARE_BRACKET) {\n      this.state = State.CDATA_SECTION_END;\n    } else {\n      this._emitChars(']');\n      this.state = State.CDATA_SECTION;\n      this._stateCdataSection(cp);\n    }\n  }\n  // CDATA section end state\n  //------------------------------------------------------------------\n  _stateCdataSectionEnd(cp) {\n    switch (cp) {\n      case $.GREATER_THAN_SIGN:\n        {\n          this.state = State.DATA;\n          break;\n        }\n      case $.RIGHT_SQUARE_BRACKET:\n        {\n          this._emitChars(']');\n          break;\n        }\n      default:\n        {\n          this._emitChars(']]');\n          this.state = State.CDATA_SECTION;\n          this._stateCdataSection(cp);\n        }\n    }\n  }\n  // Character reference state\n  //------------------------------------------------------------------\n  _stateCharacterReference(cp) {\n    if (cp === $.NUMBER_SIGN) {\n      this.state = State.NUMERIC_CHARACTER_REFERENCE;\n    } else if (isAsciiAlphaNumeric(cp)) {\n      this.state = State.NAMED_CHARACTER_REFERENCE;\n      this._stateNamedCharacterReference(cp);\n    } else {\n      this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n      this._reconsumeInState(this.returnState, cp);\n    }\n  }\n  // Named character reference state\n  //------------------------------------------------------------------\n  _stateNamedCharacterReference(cp) {\n    const matchResult = this._matchNamedCharacterReference(cp);\n    //NOTE: Matching can be abrupted by hibernation. In that case, match\n    //results are no longer valid and we will need to start over.\n    if (this._ensureHibernation()) {\n      // Stay in the state, try again.\n    } else if (matchResult) {\n      for (let i = 0; i < matchResult.length; i++) {\n        this._flushCodePointConsumedAsCharacterReference(matchResult[i]);\n      }\n      this.state = this.returnState;\n    } else {\n      this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n      this.state = State.AMBIGUOUS_AMPERSAND;\n    }\n  }\n  // Ambiguos ampersand state\n  //------------------------------------------------------------------\n  _stateAmbiguousAmpersand(cp) {\n    if (isAsciiAlphaNumeric(cp)) {\n      this._flushCodePointConsumedAsCharacterReference(cp);\n    } else {\n      if (cp === $.SEMICOLON) {\n        this._err(ERR.unknownNamedCharacterReference);\n      }\n      this._reconsumeInState(this.returnState, cp);\n    }\n  }\n  // Numeric character reference state\n  //------------------------------------------------------------------\n  _stateNumericCharacterReference(cp) {\n    this.charRefCode = 0;\n    if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {\n      this.state = State.HEXADEMICAL_CHARACTER_REFERENCE_START;\n    }\n    // Inlined decimal character reference start state\n    else if (isAsciiDigit(cp)) {\n      this.state = State.DECIMAL_CHARACTER_REFERENCE;\n      this._stateDecimalCharacterReference(cp);\n    } else {\n      this._err(ERR.absenceOfDigitsInNumericCharacterReference);\n      this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n      this._flushCodePointConsumedAsCharacterReference($.NUMBER_SIGN);\n      this._reconsumeInState(this.returnState, cp);\n    }\n  }\n  // Hexademical character reference start state\n  //------------------------------------------------------------------\n  _stateHexademicalCharacterReferenceStart(cp) {\n    if (isAsciiHexDigit(cp)) {\n      this.state = State.HEXADEMICAL_CHARACTER_REFERENCE;\n      this._stateHexademicalCharacterReference(cp);\n    } else {\n      this._err(ERR.absenceOfDigitsInNumericCharacterReference);\n      this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);\n      this._flushCodePointConsumedAsCharacterReference($.NUMBER_SIGN);\n      this._unconsume(2);\n      this.state = this.returnState;\n    }\n  }\n  // Hexademical character reference state\n  //------------------------------------------------------------------\n  _stateHexademicalCharacterReference(cp) {\n    if (isAsciiUpperHexDigit(cp)) {\n      this.charRefCode = this.charRefCode * 16 + cp - 0x37;\n    } else if (isAsciiLowerHexDigit(cp)) {\n      this.charRefCode = this.charRefCode * 16 + cp - 0x57;\n    } else if (isAsciiDigit(cp)) {\n      this.charRefCode = this.charRefCode * 16 + cp - 0x30;\n    } else if (cp === $.SEMICOLON) {\n      this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n    } else {\n      this._err(ERR.missingSemicolonAfterCharacterReference);\n      this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n      this._stateNumericCharacterReferenceEnd(cp);\n    }\n  }\n  // Decimal character reference state\n  //------------------------------------------------------------------\n  _stateDecimalCharacterReference(cp) {\n    if (isAsciiDigit(cp)) {\n      this.charRefCode = this.charRefCode * 10 + cp - 0x30;\n    } else if (cp === $.SEMICOLON) {\n      this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n    } else {\n      this._err(ERR.missingSemicolonAfterCharacterReference);\n      this.state = State.NUMERIC_CHARACTER_REFERENCE_END;\n      this._stateNumericCharacterReferenceEnd(cp);\n    }\n  }\n  // Numeric character reference end state\n  //------------------------------------------------------------------\n  _stateNumericCharacterReferenceEnd(cp) {\n    if (this.charRefCode === $.NULL) {\n      this._err(ERR.nullCharacterReference);\n      this.charRefCode = $.REPLACEMENT_CHARACTER;\n    } else if (this.charRefCode > 1114111) {\n      this._err(ERR.characterReferenceOutsideUnicodeRange);\n      this.charRefCode = $.REPLACEMENT_CHARACTER;\n    } else if (isSurrogate(this.charRefCode)) {\n      this._err(ERR.surrogateCharacterReference);\n      this.charRefCode = $.REPLACEMENT_CHARACTER;\n    } else if (isUndefinedCodePoint(this.charRefCode)) {\n      this._err(ERR.noncharacterCharacterReference);\n    } else if (isControlCodePoint(this.charRefCode) || this.charRefCode === $.CARRIAGE_RETURN) {\n      this._err(ERR.controlCharacterReference);\n      const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS.get(this.charRefCode);\n      if (replacement !== undefined) {\n        this.charRefCode = replacement;\n      }\n    }\n    this._flushCodePointConsumedAsCharacterReference(this.charRefCode);\n    this._reconsumeInState(this.returnState, cp);\n  }\n}","import { TAG_ID as $, NS, isNumberedHeader } from '../common/html.js';\n//Element utils\nconst IMPLICIT_END_TAG_REQUIRED = new Set([$.DD, $.DT, $.LI, $.OPTGROUP, $.OPTION, $.P, $.RB, $.RP, $.RT, $.RTC]);\nconst IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([...IMPLICIT_END_TAG_REQUIRED, $.CAPTION, $.COLGROUP, $.TBODY, $.TD, $.TFOOT, $.TH, $.THEAD, $.TR]);\nconst SCOPING_ELEMENT_NS = new Map([[$.APPLET, NS.HTML], [$.CAPTION, NS.HTML], [$.HTML, NS.HTML], [$.MARQUEE, NS.HTML], [$.OBJECT, NS.HTML], [$.TABLE, NS.HTML], [$.TD, NS.HTML], [$.TEMPLATE, NS.HTML], [$.TH, NS.HTML], [$.ANNOTATION_XML, NS.MATHML], [$.MI, NS.MATHML], [$.MN, NS.MATHML], [$.MO, NS.MATHML], [$.MS, NS.MATHML], [$.MTEXT, NS.MATHML], [$.DESC, NS.SVG], [$.FOREIGN_OBJECT, NS.SVG], [$.TITLE, NS.SVG]]);\nconst NAMED_HEADERS = [$.H1, $.H2, $.H3, $.H4, $.H5, $.H6];\nconst TABLE_ROW_CONTEXT = [$.TR, $.TEMPLATE, $.HTML];\nconst TABLE_BODY_CONTEXT = [$.TBODY, $.TFOOT, $.THEAD, $.TEMPLATE, $.HTML];\nconst TABLE_CONTEXT = [$.TABLE, $.TEMPLATE, $.HTML];\nconst TABLE_CELLS = [$.TD, $.TH];\n//Stack of open elements\nexport class OpenElementStack {\n  get currentTmplContentOrNode() {\n    return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current;\n  }\n  constructor(document, treeAdapter, handler) {\n    this.treeAdapter = treeAdapter;\n    this.handler = handler;\n    this.items = [];\n    this.tagIDs = [];\n    this.stackTop = -1;\n    this.tmplCount = 0;\n    this.currentTagId = $.UNKNOWN;\n    this.current = document;\n  }\n  //Index of element\n  _indexOf(element) {\n    return this.items.lastIndexOf(element, this.stackTop);\n  }\n  //Update current element\n  _isInTemplate() {\n    return this.currentTagId === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;\n  }\n  _updateCurrentElement() {\n    this.current = this.items[this.stackTop];\n    this.currentTagId = this.tagIDs[this.stackTop];\n  }\n  //Mutations\n  push(element, tagID) {\n    this.stackTop++;\n    this.items[this.stackTop] = element;\n    this.current = element;\n    this.tagIDs[this.stackTop] = tagID;\n    this.currentTagId = tagID;\n    if (this._isInTemplate()) {\n      this.tmplCount++;\n    }\n    this.handler.onItemPush(element, tagID, true);\n  }\n  pop() {\n    const popped = this.current;\n    if (this.tmplCount > 0 && this._isInTemplate()) {\n      this.tmplCount--;\n    }\n    this.stackTop--;\n    this._updateCurrentElement();\n    this.handler.onItemPop(popped, true);\n  }\n  replace(oldElement, newElement) {\n    const idx = this._indexOf(oldElement);\n    this.items[idx] = newElement;\n    if (idx === this.stackTop) {\n      this.current = newElement;\n    }\n  }\n  insertAfter(referenceElement, newElement, newElementID) {\n    const insertionIdx = this._indexOf(referenceElement) + 1;\n    this.items.splice(insertionIdx, 0, newElement);\n    this.tagIDs.splice(insertionIdx, 0, newElementID);\n    this.stackTop++;\n    if (insertionIdx === this.stackTop) {\n      this._updateCurrentElement();\n    }\n    this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop);\n  }\n  popUntilTagNamePopped(tagName) {\n    let targetIdx = this.stackTop + 1;\n    do {\n      targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1);\n    } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML);\n    this.shortenToLength(targetIdx < 0 ? 0 : targetIdx);\n  }\n  shortenToLength(idx) {\n    while (this.stackTop >= idx) {\n      const popped = this.current;\n      if (this.tmplCount > 0 && this._isInTemplate()) {\n        this.tmplCount -= 1;\n      }\n      this.stackTop--;\n      this._updateCurrentElement();\n      this.handler.onItemPop(popped, this.stackTop < idx);\n    }\n  }\n  popUntilElementPopped(element) {\n    const idx = this._indexOf(element);\n    this.shortenToLength(idx < 0 ? 0 : idx);\n  }\n  popUntilPopped(tagNames, targetNS) {\n    const idx = this._indexOfTagNames(tagNames, targetNS);\n    this.shortenToLength(idx < 0 ? 0 : idx);\n  }\n  popUntilNumberedHeaderPopped() {\n    this.popUntilPopped(NAMED_HEADERS, NS.HTML);\n  }\n  popUntilTableCellPopped() {\n    this.popUntilPopped(TABLE_CELLS, NS.HTML);\n  }\n  popAllUpToHtmlElement() {\n    //NOTE: here we assume that the root <html> element is always first in the open element stack, so\n    //we perform this fast stack clean up.\n    this.tmplCount = 0;\n    this.shortenToLength(1);\n  }\n  _indexOfTagNames(tagNames, namespace) {\n    for (let i = this.stackTop; i >= 0; i--) {\n      if (tagNames.includes(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) {\n        return i;\n      }\n    }\n    return -1;\n  }\n  clearBackTo(tagNames, targetNS) {\n    const idx = this._indexOfTagNames(tagNames, targetNS);\n    this.shortenToLength(idx + 1);\n  }\n  clearBackToTableContext() {\n    this.clearBackTo(TABLE_CONTEXT, NS.HTML);\n  }\n  clearBackToTableBodyContext() {\n    this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML);\n  }\n  clearBackToTableRowContext() {\n    this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML);\n  }\n  remove(element) {\n    const idx = this._indexOf(element);\n    if (idx >= 0) {\n      if (idx === this.stackTop) {\n        this.pop();\n      } else {\n        this.items.splice(idx, 1);\n        this.tagIDs.splice(idx, 1);\n        this.stackTop--;\n        this._updateCurrentElement();\n        this.handler.onItemPop(element, false);\n      }\n    }\n  }\n  //Search\n  tryPeekProperlyNestedBodyElement() {\n    //Properly nested <body> element (should be second element in stack).\n    return this.stackTop >= 1 && this.tagIDs[1] === $.BODY ? this.items[1] : null;\n  }\n  contains(element) {\n    return this._indexOf(element) > -1;\n  }\n  getCommonAncestor(element) {\n    const elementIdx = this._indexOf(element) - 1;\n    return elementIdx >= 0 ? this.items[elementIdx] : null;\n  }\n  isRootHtmlElementCurrent() {\n    return this.stackTop === 0 && this.tagIDs[0] === $.HTML;\n  }\n  //Element in scope\n  hasInScope(tagName) {\n    for (let i = this.stackTop; i >= 0; i--) {\n      const tn = this.tagIDs[i];\n      const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n      if (tn === tagName && ns === NS.HTML) {\n        return true;\n      }\n      if (SCOPING_ELEMENT_NS.get(tn) === ns) {\n        return false;\n      }\n    }\n    return true;\n  }\n  hasNumberedHeaderInScope() {\n    for (let i = this.stackTop; i >= 0; i--) {\n      const tn = this.tagIDs[i];\n      const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n      if (isNumberedHeader(tn) && ns === NS.HTML) {\n        return true;\n      }\n      if (SCOPING_ELEMENT_NS.get(tn) === ns) {\n        return false;\n      }\n    }\n    return true;\n  }\n  hasInListItemScope(tagName) {\n    for (let i = this.stackTop; i >= 0; i--) {\n      const tn = this.tagIDs[i];\n      const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n      if (tn === tagName && ns === NS.HTML) {\n        return true;\n      }\n      if ((tn === $.UL || tn === $.OL) && ns === NS.HTML || SCOPING_ELEMENT_NS.get(tn) === ns) {\n        return false;\n      }\n    }\n    return true;\n  }\n  hasInButtonScope(tagName) {\n    for (let i = this.stackTop; i >= 0; i--) {\n      const tn = this.tagIDs[i];\n      const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n      if (tn === tagName && ns === NS.HTML) {\n        return true;\n      }\n      if (tn === $.BUTTON && ns === NS.HTML || SCOPING_ELEMENT_NS.get(tn) === ns) {\n        return false;\n      }\n    }\n    return true;\n  }\n  hasInTableScope(tagName) {\n    for (let i = this.stackTop; i >= 0; i--) {\n      const tn = this.tagIDs[i];\n      const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n      if (ns !== NS.HTML) {\n        continue;\n      }\n      if (tn === tagName) {\n        return true;\n      }\n      if (tn === $.TABLE || tn === $.TEMPLATE || tn === $.HTML) {\n        return false;\n      }\n    }\n    return true;\n  }\n  hasTableBodyContextInTableScope() {\n    for (let i = this.stackTop; i >= 0; i--) {\n      const tn = this.tagIDs[i];\n      const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n      if (ns !== NS.HTML) {\n        continue;\n      }\n      if (tn === $.TBODY || tn === $.THEAD || tn === $.TFOOT) {\n        return true;\n      }\n      if (tn === $.TABLE || tn === $.HTML) {\n        return false;\n      }\n    }\n    return true;\n  }\n  hasInSelectScope(tagName) {\n    for (let i = this.stackTop; i >= 0; i--) {\n      const tn = this.tagIDs[i];\n      const ns = this.treeAdapter.getNamespaceURI(this.items[i]);\n      if (ns !== NS.HTML) {\n        continue;\n      }\n      if (tn === tagName) {\n        return true;\n      }\n      if (tn !== $.OPTION && tn !== $.OPTGROUP) {\n        return false;\n      }\n    }\n    return true;\n  }\n  //Implied end tags\n  generateImpliedEndTags() {\n    while (IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) {\n      this.pop();\n    }\n  }\n  generateImpliedEndTagsThoroughly() {\n    while (IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {\n      this.pop();\n    }\n  }\n  generateImpliedEndTagsWithExclusion(exclusionId) {\n    while (this.currentTagId !== exclusionId && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {\n      this.pop();\n    }\n  }\n}","//Const\nconst NOAH_ARK_CAPACITY = 3;\nexport var EntryType;\n(function (EntryType) {\n  EntryType[EntryType[\"Marker\"] = 0] = \"Marker\";\n  EntryType[EntryType[\"Element\"] = 1] = \"Element\";\n})(EntryType = EntryType || (EntryType = {}));\nconst MARKER = {\n  type: EntryType.Marker\n};\n//List of formatting elements\nexport class FormattingElementList {\n  constructor(treeAdapter) {\n    this.treeAdapter = treeAdapter;\n    this.entries = [];\n    this.bookmark = null;\n  }\n  //Noah Ark's condition\n  //OPTIMIZATION: at first we try to find possible candidates for exclusion using\n  //lightweight heuristics without thorough attributes check.\n  _getNoahArkConditionCandidates(newElement, neAttrs) {\n    const candidates = [];\n    const neAttrsLength = neAttrs.length;\n    const neTagName = this.treeAdapter.getTagName(newElement);\n    const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);\n    for (let i = 0; i < this.entries.length; i++) {\n      const entry = this.entries[i];\n      if (entry.type === EntryType.Marker) {\n        break;\n      }\n      const {\n        element\n      } = entry;\n      if (this.treeAdapter.getTagName(element) === neTagName && this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) {\n        const elementAttrs = this.treeAdapter.getAttrList(element);\n        if (elementAttrs.length === neAttrsLength) {\n          candidates.push({\n            idx: i,\n            attrs: elementAttrs\n          });\n        }\n      }\n    }\n    return candidates;\n  }\n  _ensureNoahArkCondition(newElement) {\n    if (this.entries.length < NOAH_ARK_CAPACITY) return;\n    const neAttrs = this.treeAdapter.getAttrList(newElement);\n    const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs);\n    if (candidates.length < NOAH_ARK_CAPACITY) return;\n    //NOTE: build attrs map for the new element, so we can perform fast lookups\n    const neAttrsMap = new Map(neAttrs.map(neAttr => [neAttr.name, neAttr.value]));\n    let validCandidates = 0;\n    //NOTE: remove bottommost candidates, until Noah's Ark condition will not be met\n    for (let i = 0; i < candidates.length; i++) {\n      const candidate = candidates[i];\n      // We know that `candidate.attrs.length === neAttrs.length`\n      if (candidate.attrs.every(cAttr => neAttrsMap.get(cAttr.name) === cAttr.value)) {\n        validCandidates += 1;\n        if (validCandidates >= NOAH_ARK_CAPACITY) {\n          this.entries.splice(candidate.idx, 1);\n        }\n      }\n    }\n  }\n  //Mutations\n  insertMarker() {\n    this.entries.unshift(MARKER);\n  }\n  pushElement(element, token) {\n    this._ensureNoahArkCondition(element);\n    this.entries.unshift({\n      type: EntryType.Element,\n      element,\n      token\n    });\n  }\n  insertElementAfterBookmark(element, token) {\n    const bookmarkIdx = this.entries.indexOf(this.bookmark);\n    this.entries.splice(bookmarkIdx, 0, {\n      type: EntryType.Element,\n      element,\n      token\n    });\n  }\n  removeEntry(entry) {\n    const entryIndex = this.entries.indexOf(entry);\n    if (entryIndex >= 0) {\n      this.entries.splice(entryIndex, 1);\n    }\n  }\n  /**\n   * Clears the list of formatting elements up to the last marker.\n   *\n   * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker\n   */\n  clearToLastMarker() {\n    const markerIdx = this.entries.indexOf(MARKER);\n    if (markerIdx >= 0) {\n      this.entries.splice(0, markerIdx + 1);\n    } else {\n      this.entries.length = 0;\n    }\n  }\n  //Search\n  getElementEntryInScopeWithTagName(tagName) {\n    const entry = this.entries.find(entry => entry.type === EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName);\n    return entry && entry.type === EntryType.Element ? entry : null;\n  }\n  getElementEntry(element) {\n    return this.entries.find(entry => entry.type === EntryType.Element && entry.element === element);\n  }\n}","import { DOCUMENT_MODE } from '../common/html.js';\nfunction createTextNode(value) {\n  return {\n    nodeName: '#text',\n    value,\n    parentNode: null\n  };\n}\nexport const defaultTreeAdapter = {\n  //Node construction\n  createDocument() {\n    return {\n      nodeName: '#document',\n      mode: DOCUMENT_MODE.NO_QUIRKS,\n      childNodes: []\n    };\n  },\n  createDocumentFragment() {\n    return {\n      nodeName: '#document-fragment',\n      childNodes: []\n    };\n  },\n  createElement(tagName, namespaceURI, attrs) {\n    return {\n      nodeName: tagName,\n      tagName,\n      attrs,\n      namespaceURI,\n      childNodes: [],\n      parentNode: null\n    };\n  },\n  createCommentNode(data) {\n    return {\n      nodeName: '#comment',\n      data,\n      parentNode: null\n    };\n  },\n  //Tree mutation\n  appendChild(parentNode, newNode) {\n    parentNode.childNodes.push(newNode);\n    newNode.parentNode = parentNode;\n  },\n  insertBefore(parentNode, newNode, referenceNode) {\n    const insertionIdx = parentNode.childNodes.indexOf(referenceNode);\n    parentNode.childNodes.splice(insertionIdx, 0, newNode);\n    newNode.parentNode = parentNode;\n  },\n  setTemplateContent(templateElement, contentElement) {\n    templateElement.content = contentElement;\n  },\n  getTemplateContent(templateElement) {\n    return templateElement.content;\n  },\n  setDocumentType(document, name, publicId, systemId) {\n    const doctypeNode = document.childNodes.find(node => node.nodeName === '#documentType');\n    if (doctypeNode) {\n      doctypeNode.name = name;\n      doctypeNode.publicId = publicId;\n      doctypeNode.systemId = systemId;\n    } else {\n      const node = {\n        nodeName: '#documentType',\n        name,\n        publicId,\n        systemId,\n        parentNode: null\n      };\n      defaultTreeAdapter.appendChild(document, node);\n    }\n  },\n  setDocumentMode(document, mode) {\n    document.mode = mode;\n  },\n  getDocumentMode(document) {\n    return document.mode;\n  },\n  detachNode(node) {\n    if (node.parentNode) {\n      const idx = node.parentNode.childNodes.indexOf(node);\n      node.parentNode.childNodes.splice(idx, 1);\n      node.parentNode = null;\n    }\n  },\n  insertText(parentNode, text) {\n    if (parentNode.childNodes.length > 0) {\n      const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];\n      if (defaultTreeAdapter.isTextNode(prevNode)) {\n        prevNode.value += text;\n        return;\n      }\n    }\n    defaultTreeAdapter.appendChild(parentNode, createTextNode(text));\n  },\n  insertTextBefore(parentNode, text, referenceNode) {\n    const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];\n    if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) {\n      prevNode.value += text;\n    } else {\n      defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode);\n    }\n  },\n  adoptAttributes(recipient, attrs) {\n    const recipientAttrsMap = new Set(recipient.attrs.map(attr => attr.name));\n    for (let j = 0; j < attrs.length; j++) {\n      if (!recipientAttrsMap.has(attrs[j].name)) {\n        recipient.attrs.push(attrs[j]);\n      }\n    }\n  },\n  //Tree traversing\n  getFirstChild(node) {\n    return node.childNodes[0];\n  },\n  getChildNodes(node) {\n    return node.childNodes;\n  },\n  getParentNode(node) {\n    return node.parentNode;\n  },\n  getAttrList(element) {\n    return element.attrs;\n  },\n  //Node data\n  getTagName(element) {\n    return element.tagName;\n  },\n  getNamespaceURI(element) {\n    return element.namespaceURI;\n  },\n  getTextNodeContent(textNode) {\n    return textNode.value;\n  },\n  getCommentNodeContent(commentNode) {\n    return commentNode.data;\n  },\n  getDocumentTypeNodeName(doctypeNode) {\n    return doctypeNode.name;\n  },\n  getDocumentTypeNodePublicId(doctypeNode) {\n    return doctypeNode.publicId;\n  },\n  getDocumentTypeNodeSystemId(doctypeNode) {\n    return doctypeNode.systemId;\n  },\n  //Node types\n  isTextNode(node) {\n    return node.nodeName === '#text';\n  },\n  isCommentNode(node) {\n    return node.nodeName === '#comment';\n  },\n  isDocumentTypeNode(node) {\n    return node.nodeName === '#documentType';\n  },\n  isElementNode(node) {\n    return Object.prototype.hasOwnProperty.call(node, 'tagName');\n  },\n  // Source code location\n  setNodeSourceCodeLocation(node, location) {\n    node.sourceCodeLocation = location;\n  },\n  getNodeSourceCodeLocation(node) {\n    return node.sourceCodeLocation;\n  },\n  updateNodeSourceCodeLocation(node, endLocation) {\n    node.sourceCodeLocation = {\n      ...node.sourceCodeLocation,\n      ...endLocation\n    };\n  }\n};","import { DOCUMENT_MODE } from './html.js';\n//Const\nconst VALID_DOCTYPE_NAME = 'html';\nconst VALID_SYSTEM_ID = 'about:legacy-compat';\nconst QUIRKS_MODE_SYSTEM_ID = 'http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd';\nconst QUIRKS_MODE_PUBLIC_ID_PREFIXES = ['+//silmaril//dtd html pro v0r11 19970101//', '-//as//dtd html 3.0 aswedit + extensions//', '-//advasoft ltd//dtd html 3.0 aswedit + extensions//', '-//ietf//dtd html 2.0 level 1//', '-//ietf//dtd html 2.0 level 2//', '-//ietf//dtd html 2.0 strict level 1//', '-//ietf//dtd html 2.0 strict level 2//', '-//ietf//dtd html 2.0 strict//', '-//ietf//dtd html 2.0//', '-//ietf//dtd html 2.1e//', '-//ietf//dtd html 3.0//', '-//ietf//dtd html 3.2 final//', '-//ietf//dtd html 3.2//', '-//ietf//dtd html 3//', '-//ietf//dtd html level 0//', '-//ietf//dtd html level 1//', '-//ietf//dtd html level 2//', '-//ietf//dtd html level 3//', '-//ietf//dtd html strict level 0//', '-//ietf//dtd html strict level 1//', '-//ietf//dtd html strict level 2//', '-//ietf//dtd html strict level 3//', '-//ietf//dtd html strict//', '-//ietf//dtd html//', '-//metrius//dtd metrius presentational//', '-//microsoft//dtd internet explorer 2.0 html strict//', '-//microsoft//dtd internet explorer 2.0 html//', '-//microsoft//dtd internet explorer 2.0 tables//', '-//microsoft//dtd internet explorer 3.0 html strict//', '-//microsoft//dtd internet explorer 3.0 html//', '-//microsoft//dtd internet explorer 3.0 tables//', '-//netscape comm. corp.//dtd html//', '-//netscape comm. corp.//dtd strict html//', \"-//o'reilly and associates//dtd html 2.0//\", \"-//o'reilly and associates//dtd html extended 1.0//\", \"-//o'reilly and associates//dtd html extended relaxed 1.0//\", '-//sq//dtd html 2.0 hotmetal + extensions//', '-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//', '-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//', '-//spyglass//dtd html 2.0 extended//', '-//sun microsystems corp.//dtd hotjava html//', '-//sun microsystems corp.//dtd hotjava strict html//', '-//w3c//dtd html 3 1995-03-24//', '-//w3c//dtd html 3.2 draft//', '-//w3c//dtd html 3.2 final//', '-//w3c//dtd html 3.2//', '-//w3c//dtd html 3.2s draft//', '-//w3c//dtd html 4.0 frameset//', '-//w3c//dtd html 4.0 transitional//', '-//w3c//dtd html experimental 19960712//', '-//w3c//dtd html experimental 970421//', '-//w3c//dtd w3 html//', '-//w3o//dtd w3 html 3.0//', '-//webtechs//dtd mozilla html 2.0//', '-//webtechs//dtd mozilla html//'];\nconst QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = [...QUIRKS_MODE_PUBLIC_ID_PREFIXES, '-//w3c//dtd html 4.01 frameset//', '-//w3c//dtd html 4.01 transitional//'];\nconst QUIRKS_MODE_PUBLIC_IDS = new Set(['-//w3o//dtd w3 html strict 3.0//en//', '-/w3c/dtd html 4.0 transitional/en', 'html']);\nconst LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ['-//w3c//dtd xhtml 1.0 frameset//', '-//w3c//dtd xhtml 1.0 transitional//'];\nconst LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = [...LIMITED_QUIRKS_PUBLIC_ID_PREFIXES, '-//w3c//dtd html 4.01 frameset//', '-//w3c//dtd html 4.01 transitional//'];\n//Utils\nfunction hasPrefix(publicId, prefixes) {\n  return prefixes.some(prefix => publicId.startsWith(prefix));\n}\n//API\nexport function isConforming(token) {\n  return token.name === VALID_DOCTYPE_NAME && token.publicId === null && (token.systemId === null || token.systemId === VALID_SYSTEM_ID);\n}\nexport function getDocumentMode(token) {\n  if (token.name !== VALID_DOCTYPE_NAME) {\n    return DOCUMENT_MODE.QUIRKS;\n  }\n  const {\n    systemId\n  } = token;\n  if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) {\n    return DOCUMENT_MODE.QUIRKS;\n  }\n  let {\n    publicId\n  } = token;\n  if (publicId !== null) {\n    publicId = publicId.toLowerCase();\n    if (QUIRKS_MODE_PUBLIC_IDS.has(publicId)) {\n      return DOCUMENT_MODE.QUIRKS;\n    }\n    let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES;\n    if (hasPrefix(publicId, prefixes)) {\n      return DOCUMENT_MODE.QUIRKS;\n    }\n    prefixes = systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES;\n    if (hasPrefix(publicId, prefixes)) {\n      return DOCUMENT_MODE.LIMITED_QUIRKS;\n    }\n  }\n  return DOCUMENT_MODE.NO_QUIRKS;\n}","import { TAG_ID as $, NS, ATTRS, getTagID } from './html.js';\n//MIME types\nconst MIME_TYPES = {\n  TEXT_HTML: 'text/html',\n  APPLICATION_XML: 'application/xhtml+xml'\n};\n//Attributes\nconst DEFINITION_URL_ATTR = 'definitionurl';\nconst ADJUSTED_DEFINITION_URL_ATTR = 'definitionURL';\nconst SVG_ATTRS_ADJUSTMENT_MAP = new Map(['attributeName', 'attributeType', 'baseFrequency', 'baseProfile', 'calcMode', 'clipPathUnits', 'diffuseConstant', 'edgeMode', 'filterUnits', 'glyphRef', 'gradientTransform', 'gradientUnits', 'kernelMatrix', 'kernelUnitLength', 'keyPoints', 'keySplines', 'keyTimes', 'lengthAdjust', 'limitingConeAngle', 'markerHeight', 'markerUnits', 'markerWidth', 'maskContentUnits', 'maskUnits', 'numOctaves', 'pathLength', 'patternContentUnits', 'patternTransform', 'patternUnits', 'pointsAtX', 'pointsAtY', 'pointsAtZ', 'preserveAlpha', 'preserveAspectRatio', 'primitiveUnits', 'refX', 'refY', 'repeatCount', 'repeatDur', 'requiredExtensions', 'requiredFeatures', 'specularConstant', 'specularExponent', 'spreadMethod', 'startOffset', 'stdDeviation', 'stitchTiles', 'surfaceScale', 'systemLanguage', 'tableValues', 'targetX', 'targetY', 'textLength', 'viewBox', 'viewTarget', 'xChannelSelector', 'yChannelSelector', 'zoomAndPan'].map(attr => [attr.toLowerCase(), attr]));\nconst XML_ATTRS_ADJUSTMENT_MAP = new Map([['xlink:actuate', {\n  prefix: 'xlink',\n  name: 'actuate',\n  namespace: NS.XLINK\n}], ['xlink:arcrole', {\n  prefix: 'xlink',\n  name: 'arcrole',\n  namespace: NS.XLINK\n}], ['xlink:href', {\n  prefix: 'xlink',\n  name: 'href',\n  namespace: NS.XLINK\n}], ['xlink:role', {\n  prefix: 'xlink',\n  name: 'role',\n  namespace: NS.XLINK\n}], ['xlink:show', {\n  prefix: 'xlink',\n  name: 'show',\n  namespace: NS.XLINK\n}], ['xlink:title', {\n  prefix: 'xlink',\n  name: 'title',\n  namespace: NS.XLINK\n}], ['xlink:type', {\n  prefix: 'xlink',\n  name: 'type',\n  namespace: NS.XLINK\n}], ['xml:base', {\n  prefix: 'xml',\n  name: 'base',\n  namespace: NS.XML\n}], ['xml:lang', {\n  prefix: 'xml',\n  name: 'lang',\n  namespace: NS.XML\n}], ['xml:space', {\n  prefix: 'xml',\n  name: 'space',\n  namespace: NS.XML\n}], ['xmlns', {\n  prefix: '',\n  name: 'xmlns',\n  namespace: NS.XMLNS\n}], ['xmlns:xlink', {\n  prefix: 'xmlns',\n  name: 'xlink',\n  namespace: NS.XMLNS\n}]]);\n//SVG tag names adjustment map\nexport const SVG_TAG_NAMES_ADJUSTMENT_MAP = new Map(['altGlyph', 'altGlyphDef', 'altGlyphItem', 'animateColor', 'animateMotion', 'animateTransform', 'clipPath', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence', 'foreignObject', 'glyphRef', 'linearGradient', 'radialGradient', 'textPath'].map(tn => [tn.toLowerCase(), tn]));\n//Tags that causes exit from foreign content\nconst EXITS_FOREIGN_CONTENT = new Set([$.B, $.BIG, $.BLOCKQUOTE, $.BODY, $.BR, $.CENTER, $.CODE, $.DD, $.DIV, $.DL, $.DT, $.EM, $.EMBED, $.H1, $.H2, $.H3, $.H4, $.H5, $.H6, $.HEAD, $.HR, $.I, $.IMG, $.LI, $.LISTING, $.MENU, $.META, $.NOBR, $.OL, $.P, $.PRE, $.RUBY, $.S, $.SMALL, $.SPAN, $.STRONG, $.STRIKE, $.SUB, $.SUP, $.TABLE, $.TT, $.U, $.UL, $.VAR]);\n//Check exit from foreign content\nexport function causesExit(startTagToken) {\n  const tn = startTagToken.tagID;\n  const isFontWithAttrs = tn === $.FONT && startTagToken.attrs.some(_ref => {\n    let {\n      name\n    } = _ref;\n    return name === ATTRS.COLOR || name === ATTRS.SIZE || name === ATTRS.FACE;\n  });\n  return isFontWithAttrs || EXITS_FOREIGN_CONTENT.has(tn);\n}\n//Token adjustments\nexport function adjustTokenMathMLAttrs(token) {\n  for (let i = 0; i < token.attrs.length; i++) {\n    if (token.attrs[i].name === DEFINITION_URL_ATTR) {\n      token.attrs[i].name = ADJUSTED_DEFINITION_URL_ATTR;\n      break;\n    }\n  }\n}\nexport function adjustTokenSVGAttrs(token) {\n  for (let i = 0; i < token.attrs.length; i++) {\n    const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);\n    if (adjustedAttrName != null) {\n      token.attrs[i].name = adjustedAttrName;\n    }\n  }\n}\nexport function adjustTokenXMLAttrs(token) {\n  for (let i = 0; i < token.attrs.length; i++) {\n    const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);\n    if (adjustedAttrEntry) {\n      token.attrs[i].prefix = adjustedAttrEntry.prefix;\n      token.attrs[i].name = adjustedAttrEntry.name;\n      token.attrs[i].namespace = adjustedAttrEntry.namespace;\n    }\n  }\n}\nexport function adjustTokenSVGTagName(token) {\n  const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP.get(token.tagName);\n  if (adjustedTagName != null) {\n    token.tagName = adjustedTagName;\n    token.tagID = getTagID(token.tagName);\n  }\n}\n//Integration points\nfunction isMathMLTextIntegrationPoint(tn, ns) {\n  return ns === NS.MATHML && (tn === $.MI || tn === $.MO || tn === $.MN || tn === $.MS || tn === $.MTEXT);\n}\nfunction isHtmlIntegrationPoint(tn, ns, attrs) {\n  if (ns === NS.MATHML && tn === $.ANNOTATION_XML) {\n    for (let i = 0; i < attrs.length; i++) {\n      if (attrs[i].name === ATTRS.ENCODING) {\n        const value = attrs[i].value.toLowerCase();\n        return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML;\n      }\n    }\n  }\n  return ns === NS.SVG && (tn === $.FOREIGN_OBJECT || tn === $.DESC || tn === $.TITLE);\n}\nexport function isIntegrationPoint(tn, ns, attrs, foreignNS) {\n  return (!foreignNS || foreignNS === NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs) || (!foreignNS || foreignNS === NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns);\n}","import { Tokenizer, TokenizerMode } from '../tokenizer/index.js';\nimport { OpenElementStack } from './open-element-stack.js';\nimport { FormattingElementList, EntryType } from './formatting-element-list.js';\nimport { defaultTreeAdapter } from '../tree-adapters/default.js';\nimport * as doctype from '../common/doctype.js';\nimport * as foreignContent from '../common/foreign-content.js';\nimport { ERR } from '../common/error-codes.js';\nimport * as unicode from '../common/unicode.js';\nimport { TAG_ID as $, TAG_NAMES as TN, NS, ATTRS, SPECIAL_ELEMENTS, DOCUMENT_MODE, isNumberedHeader, getTagID } from '../common/html.js';\nimport { TokenType, getTokenAttr } from '../common/token.js';\n//Misc constants\nconst HIDDEN_INPUT_TYPE = 'hidden';\n//Adoption agency loops iteration count\nconst AA_OUTER_LOOP_ITER = 8;\nconst AA_INNER_LOOP_ITER = 3;\n//Insertion modes\nvar InsertionMode;\n(function (InsertionMode) {\n  InsertionMode[InsertionMode[\"INITIAL\"] = 0] = \"INITIAL\";\n  InsertionMode[InsertionMode[\"BEFORE_HTML\"] = 1] = \"BEFORE_HTML\";\n  InsertionMode[InsertionMode[\"BEFORE_HEAD\"] = 2] = \"BEFORE_HEAD\";\n  InsertionMode[InsertionMode[\"IN_HEAD\"] = 3] = \"IN_HEAD\";\n  InsertionMode[InsertionMode[\"IN_HEAD_NO_SCRIPT\"] = 4] = \"IN_HEAD_NO_SCRIPT\";\n  InsertionMode[InsertionMode[\"AFTER_HEAD\"] = 5] = \"AFTER_HEAD\";\n  InsertionMode[InsertionMode[\"IN_BODY\"] = 6] = \"IN_BODY\";\n  InsertionMode[InsertionMode[\"TEXT\"] = 7] = \"TEXT\";\n  InsertionMode[InsertionMode[\"IN_TABLE\"] = 8] = \"IN_TABLE\";\n  InsertionMode[InsertionMode[\"IN_TABLE_TEXT\"] = 9] = \"IN_TABLE_TEXT\";\n  InsertionMode[InsertionMode[\"IN_CAPTION\"] = 10] = \"IN_CAPTION\";\n  InsertionMode[InsertionMode[\"IN_COLUMN_GROUP\"] = 11] = \"IN_COLUMN_GROUP\";\n  InsertionMode[InsertionMode[\"IN_TABLE_BODY\"] = 12] = \"IN_TABLE_BODY\";\n  InsertionMode[InsertionMode[\"IN_ROW\"] = 13] = \"IN_ROW\";\n  InsertionMode[InsertionMode[\"IN_CELL\"] = 14] = \"IN_CELL\";\n  InsertionMode[InsertionMode[\"IN_SELECT\"] = 15] = \"IN_SELECT\";\n  InsertionMode[InsertionMode[\"IN_SELECT_IN_TABLE\"] = 16] = \"IN_SELECT_IN_TABLE\";\n  InsertionMode[InsertionMode[\"IN_TEMPLATE\"] = 17] = \"IN_TEMPLATE\";\n  InsertionMode[InsertionMode[\"AFTER_BODY\"] = 18] = \"AFTER_BODY\";\n  InsertionMode[InsertionMode[\"IN_FRAMESET\"] = 19] = \"IN_FRAMESET\";\n  InsertionMode[InsertionMode[\"AFTER_FRAMESET\"] = 20] = \"AFTER_FRAMESET\";\n  InsertionMode[InsertionMode[\"AFTER_AFTER_BODY\"] = 21] = \"AFTER_AFTER_BODY\";\n  InsertionMode[InsertionMode[\"AFTER_AFTER_FRAMESET\"] = 22] = \"AFTER_AFTER_FRAMESET\";\n})(InsertionMode || (InsertionMode = {}));\nconst BASE_LOC = {\n  startLine: -1,\n  startCol: -1,\n  startOffset: -1,\n  endLine: -1,\n  endCol: -1,\n  endOffset: -1\n};\nconst TABLE_STRUCTURE_TAGS = new Set([$.TABLE, $.TBODY, $.TFOOT, $.THEAD, $.TR]);\nconst defaultParserOptions = {\n  scriptingEnabled: true,\n  sourceCodeLocationInfo: false,\n  treeAdapter: defaultTreeAdapter,\n  onParseError: null\n};\n//Parser\nexport class Parser {\n  constructor(options, document) {\n    let fragmentContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n    let scriptHandler = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n    this.fragmentContext = fragmentContext;\n    this.scriptHandler = scriptHandler;\n    this.currentToken = null;\n    this.stopped = false;\n    this.insertionMode = InsertionMode.INITIAL;\n    this.originalInsertionMode = InsertionMode.INITIAL;\n    this.headElement = null;\n    this.formElement = null;\n    /** Indicates that the current node is not an element in the HTML namespace */\n    this.currentNotInHTML = false;\n    /**\n     * The template insertion mode stack is maintained from the left.\n     * Ie. the topmost element will always have index 0.\n     */\n    this.tmplInsertionModeStack = [];\n    this.pendingCharacterTokens = [];\n    this.hasNonWhitespacePendingCharacterToken = false;\n    this.framesetOk = true;\n    this.skipNextNewLine = false;\n    this.fosterParentingEnabled = false;\n    this.options = {\n      ...defaultParserOptions,\n      ...options\n    };\n    this.treeAdapter = this.options.treeAdapter;\n    this.onParseError = this.options.onParseError;\n    // Always enable location info if we report parse errors.\n    if (this.onParseError) {\n      this.options.sourceCodeLocationInfo = true;\n    }\n    this.document = document !== null && document !== void 0 ? document : this.treeAdapter.createDocument();\n    this.tokenizer = new Tokenizer(this.options, this);\n    this.activeFormattingElements = new FormattingElementList(this.treeAdapter);\n    this.fragmentContextID = fragmentContext ? getTagID(this.treeAdapter.getTagName(fragmentContext)) : $.UNKNOWN;\n    this._setContextModes(fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : this.document, this.fragmentContextID);\n    this.openElements = new OpenElementStack(this.document, this.treeAdapter, this);\n  }\n  // API\n  static parse(html, options) {\n    const parser = new this(options);\n    parser.tokenizer.write(html, true);\n    return parser.document;\n  }\n  static getFragmentParser(fragmentContext, options) {\n    const opts = {\n      ...defaultParserOptions,\n      ...options\n    };\n    //NOTE: use a <template> element as the fragment context if no context element was provided,\n    //so we will parse in a \"forgiving\" manner\n    fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : fragmentContext = opts.treeAdapter.createElement(TN.TEMPLATE, NS.HTML, []);\n    //NOTE: create a fake element which will be used as the `document` for fragment parsing.\n    //This is important for jsdom, where a new `document` cannot be created. This led to\n    //fragment parsing messing with the main `document`.\n    const documentMock = opts.treeAdapter.createElement('documentmock', NS.HTML, []);\n    const parser = new this(opts, documentMock, fragmentContext);\n    if (parser.fragmentContextID === $.TEMPLATE) {\n      parser.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);\n    }\n    parser._initTokenizerForFragmentParsing();\n    parser._insertFakeRootElement();\n    parser._resetInsertionMode();\n    parser._findFormInFragmentContext();\n    return parser;\n  }\n  getFragment() {\n    const rootElement = this.treeAdapter.getFirstChild(this.document);\n    const fragment = this.treeAdapter.createDocumentFragment();\n    this._adoptNodes(rootElement, fragment);\n    return fragment;\n  }\n  //Errors\n  _err(token, code, beforeToken) {\n    var _a;\n    if (!this.onParseError) return;\n    const loc = (_a = token.location) !== null && _a !== void 0 ? _a : BASE_LOC;\n    const err = {\n      code,\n      startLine: loc.startLine,\n      startCol: loc.startCol,\n      startOffset: loc.startOffset,\n      endLine: beforeToken ? loc.startLine : loc.endLine,\n      endCol: beforeToken ? loc.startCol : loc.endCol,\n      endOffset: beforeToken ? loc.startOffset : loc.endOffset\n    };\n    this.onParseError(err);\n  }\n  //Stack events\n  onItemPush(node, tid, isTop) {\n    var _a, _b;\n    (_b = (_a = this.treeAdapter).onItemPush) === null || _b === void 0 ? void 0 : _b.call(_a, node);\n    if (isTop && this.openElements.stackTop > 0) this._setContextModes(node, tid);\n  }\n  onItemPop(node, isTop) {\n    var _a, _b;\n    if (this.options.sourceCodeLocationInfo) {\n      this._setEndLocation(node, this.currentToken);\n    }\n    (_b = (_a = this.treeAdapter).onItemPop) === null || _b === void 0 ? void 0 : _b.call(_a, node, this.openElements.current);\n    if (isTop) {\n      let current;\n      let currentTagId;\n      if (this.openElements.stackTop === 0 && this.fragmentContext) {\n        current = this.fragmentContext;\n        currentTagId = this.fragmentContextID;\n      } else {\n        ({\n          current,\n          currentTagId\n        } = this.openElements);\n      }\n      this._setContextModes(current, currentTagId);\n    }\n  }\n  _setContextModes(current, tid) {\n    const isHTML = current === this.document || this.treeAdapter.getNamespaceURI(current) === NS.HTML;\n    this.currentNotInHTML = !isHTML;\n    this.tokenizer.inForeignNode = !isHTML && !this._isIntegrationPoint(tid, current);\n  }\n  _switchToTextParsing(currentToken, nextTokenizerState) {\n    this._insertElement(currentToken, NS.HTML);\n    this.tokenizer.state = nextTokenizerState;\n    this.originalInsertionMode = this.insertionMode;\n    this.insertionMode = InsertionMode.TEXT;\n  }\n  switchToPlaintextParsing() {\n    this.insertionMode = InsertionMode.TEXT;\n    this.originalInsertionMode = InsertionMode.IN_BODY;\n    this.tokenizer.state = TokenizerMode.PLAINTEXT;\n  }\n  //Fragment parsing\n  _getAdjustedCurrentElement() {\n    return this.openElements.stackTop === 0 && this.fragmentContext ? this.fragmentContext : this.openElements.current;\n  }\n  _findFormInFragmentContext() {\n    let node = this.fragmentContext;\n    while (node) {\n      if (this.treeAdapter.getTagName(node) === TN.FORM) {\n        this.formElement = node;\n        break;\n      }\n      node = this.treeAdapter.getParentNode(node);\n    }\n  }\n  _initTokenizerForFragmentParsing() {\n    if (!this.fragmentContext || this.treeAdapter.getNamespaceURI(this.fragmentContext) !== NS.HTML) {\n      return;\n    }\n    switch (this.fragmentContextID) {\n      case $.TITLE:\n      case $.TEXTAREA:\n        {\n          this.tokenizer.state = TokenizerMode.RCDATA;\n          break;\n        }\n      case $.STYLE:\n      case $.XMP:\n      case $.IFRAME:\n      case $.NOEMBED:\n      case $.NOFRAMES:\n      case $.NOSCRIPT:\n        {\n          this.tokenizer.state = TokenizerMode.RAWTEXT;\n          break;\n        }\n      case $.SCRIPT:\n        {\n          this.tokenizer.state = TokenizerMode.SCRIPT_DATA;\n          break;\n        }\n      case $.PLAINTEXT:\n        {\n          this.tokenizer.state = TokenizerMode.PLAINTEXT;\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n  //Tree mutation\n  _setDocumentType(token) {\n    const name = token.name || '';\n    const publicId = token.publicId || '';\n    const systemId = token.systemId || '';\n    this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);\n    if (token.location) {\n      const documentChildren = this.treeAdapter.getChildNodes(this.document);\n      const docTypeNode = documentChildren.find(node => this.treeAdapter.isDocumentTypeNode(node));\n      if (docTypeNode) {\n        this.treeAdapter.setNodeSourceCodeLocation(docTypeNode, token.location);\n      }\n    }\n  }\n  _attachElementToTree(element, location) {\n    if (this.options.sourceCodeLocationInfo) {\n      const loc = location && {\n        ...location,\n        startTag: location\n      };\n      this.treeAdapter.setNodeSourceCodeLocation(element, loc);\n    }\n    if (this._shouldFosterParentOnInsertion()) {\n      this._fosterParentElement(element);\n    } else {\n      const parent = this.openElements.currentTmplContentOrNode;\n      this.treeAdapter.appendChild(parent, element);\n    }\n  }\n  _appendElement(token, namespaceURI) {\n    const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);\n    this._attachElementToTree(element, token.location);\n  }\n  _insertElement(token, namespaceURI) {\n    const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);\n    this._attachElementToTree(element, token.location);\n    this.openElements.push(element, token.tagID);\n  }\n  _insertFakeElement(tagName, tagID) {\n    const element = this.treeAdapter.createElement(tagName, NS.HTML, []);\n    this._attachElementToTree(element, null);\n    this.openElements.push(element, tagID);\n  }\n  _insertTemplate(token) {\n    const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);\n    const content = this.treeAdapter.createDocumentFragment();\n    this.treeAdapter.setTemplateContent(tmpl, content);\n    this._attachElementToTree(tmpl, token.location);\n    this.openElements.push(tmpl, token.tagID);\n    if (this.options.sourceCodeLocationInfo) this.treeAdapter.setNodeSourceCodeLocation(content, null);\n  }\n  _insertFakeRootElement() {\n    const element = this.treeAdapter.createElement(TN.HTML, NS.HTML, []);\n    if (this.options.sourceCodeLocationInfo) this.treeAdapter.setNodeSourceCodeLocation(element, null);\n    this.treeAdapter.appendChild(this.openElements.current, element);\n    this.openElements.push(element, $.HTML);\n  }\n  _appendCommentNode(token, parent) {\n    const commentNode = this.treeAdapter.createCommentNode(token.data);\n    this.treeAdapter.appendChild(parent, commentNode);\n    if (this.options.sourceCodeLocationInfo) {\n      this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);\n    }\n  }\n  _insertCharacters(token) {\n    let parent;\n    let beforeElement;\n    if (this._shouldFosterParentOnInsertion()) {\n      ({\n        parent,\n        beforeElement\n      } = this._findFosterParentingLocation());\n      if (beforeElement) {\n        this.treeAdapter.insertTextBefore(parent, token.chars, beforeElement);\n      } else {\n        this.treeAdapter.insertText(parent, token.chars);\n      }\n    } else {\n      parent = this.openElements.currentTmplContentOrNode;\n      this.treeAdapter.insertText(parent, token.chars);\n    }\n    if (!token.location) return;\n    const siblings = this.treeAdapter.getChildNodes(parent);\n    const textNodeIdx = beforeElement ? siblings.lastIndexOf(beforeElement) : siblings.length;\n    const textNode = siblings[textNodeIdx - 1];\n    //NOTE: if we have a location assigned by another token, then just update the end position\n    const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);\n    if (tnLoc) {\n      const {\n        endLine,\n        endCol,\n        endOffset\n      } = token.location;\n      this.treeAdapter.updateNodeSourceCodeLocation(textNode, {\n        endLine,\n        endCol,\n        endOffset\n      });\n    } else if (this.options.sourceCodeLocationInfo) {\n      this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);\n    }\n  }\n  _adoptNodes(donor, recipient) {\n    for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {\n      this.treeAdapter.detachNode(child);\n      this.treeAdapter.appendChild(recipient, child);\n    }\n  }\n  _setEndLocation(element, closingToken) {\n    if (this.treeAdapter.getNodeSourceCodeLocation(element) && closingToken.location) {\n      const ctLoc = closingToken.location;\n      const tn = this.treeAdapter.getTagName(element);\n      const endLoc =\n      // NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing\n      // tag and for cases like <td> <p> </td> - 'p' closes without a closing tag.\n      closingToken.type === TokenType.END_TAG && tn === closingToken.tagName ? {\n        endTag: {\n          ...ctLoc\n        },\n        endLine: ctLoc.endLine,\n        endCol: ctLoc.endCol,\n        endOffset: ctLoc.endOffset\n      } : {\n        endLine: ctLoc.startLine,\n        endCol: ctLoc.startCol,\n        endOffset: ctLoc.startOffset\n      };\n      this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);\n    }\n  }\n  //Token processing\n  shouldProcessStartTagTokenInForeignContent(token) {\n    // Check that neither current === document, or ns === NS.HTML\n    if (!this.currentNotInHTML) return false;\n    let current;\n    let currentTagId;\n    if (this.openElements.stackTop === 0 && this.fragmentContext) {\n      current = this.fragmentContext;\n      currentTagId = this.fragmentContextID;\n    } else {\n      ({\n        current,\n        currentTagId\n      } = this.openElements);\n    }\n    if (token.tagID === $.SVG && this.treeAdapter.getTagName(current) === TN.ANNOTATION_XML && this.treeAdapter.getNamespaceURI(current) === NS.MATHML) {\n      return false;\n    }\n    return (\n      // Check that `current` is not an integration point for HTML or MathML elements.\n      this.tokenizer.inForeignNode ||\n      // If it _is_ an integration point, then we might have to check that it is not an HTML\n      // integration point.\n      (token.tagID === $.MGLYPH || token.tagID === $.MALIGNMARK) && !this._isIntegrationPoint(currentTagId, current, NS.HTML)\n    );\n  }\n  _processToken(token) {\n    switch (token.type) {\n      case TokenType.CHARACTER:\n        {\n          this.onCharacter(token);\n          break;\n        }\n      case TokenType.NULL_CHARACTER:\n        {\n          this.onNullCharacter(token);\n          break;\n        }\n      case TokenType.COMMENT:\n        {\n          this.onComment(token);\n          break;\n        }\n      case TokenType.DOCTYPE:\n        {\n          this.onDoctype(token);\n          break;\n        }\n      case TokenType.START_TAG:\n        {\n          this._processStartTag(token);\n          break;\n        }\n      case TokenType.END_TAG:\n        {\n          this.onEndTag(token);\n          break;\n        }\n      case TokenType.EOF:\n        {\n          this.onEof(token);\n          break;\n        }\n      case TokenType.WHITESPACE_CHARACTER:\n        {\n          this.onWhitespaceCharacter(token);\n          break;\n        }\n    }\n  }\n  //Integration points\n  _isIntegrationPoint(tid, element, foreignNS) {\n    const ns = this.treeAdapter.getNamespaceURI(element);\n    const attrs = this.treeAdapter.getAttrList(element);\n    return foreignContent.isIntegrationPoint(tid, ns, attrs, foreignNS);\n  }\n  //Active formatting elements reconstruction\n  _reconstructActiveFormattingElements() {\n    const listLength = this.activeFormattingElements.entries.length;\n    if (listLength) {\n      const endIndex = this.activeFormattingElements.entries.findIndex(entry => entry.type === EntryType.Marker || this.openElements.contains(entry.element));\n      const unopenIdx = endIndex < 0 ? listLength - 1 : endIndex - 1;\n      for (let i = unopenIdx; i >= 0; i--) {\n        const entry = this.activeFormattingElements.entries[i];\n        this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));\n        entry.element = this.openElements.current;\n      }\n    }\n  }\n  //Close elements\n  _closeTableCell() {\n    this.openElements.generateImpliedEndTags();\n    this.openElements.popUntilTableCellPopped();\n    this.activeFormattingElements.clearToLastMarker();\n    this.insertionMode = InsertionMode.IN_ROW;\n  }\n  _closePElement() {\n    this.openElements.generateImpliedEndTagsWithExclusion($.P);\n    this.openElements.popUntilTagNamePopped($.P);\n  }\n  //Insertion modes\n  _resetInsertionMode() {\n    for (let i = this.openElements.stackTop; i >= 0; i--) {\n      //Insertion mode reset map\n      switch (i === 0 && this.fragmentContext ? this.fragmentContextID : this.openElements.tagIDs[i]) {\n        case $.TR:\n          {\n            this.insertionMode = InsertionMode.IN_ROW;\n            return;\n          }\n        case $.TBODY:\n        case $.THEAD:\n        case $.TFOOT:\n          {\n            this.insertionMode = InsertionMode.IN_TABLE_BODY;\n            return;\n          }\n        case $.CAPTION:\n          {\n            this.insertionMode = InsertionMode.IN_CAPTION;\n            return;\n          }\n        case $.COLGROUP:\n          {\n            this.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n            return;\n          }\n        case $.TABLE:\n          {\n            this.insertionMode = InsertionMode.IN_TABLE;\n            return;\n          }\n        case $.BODY:\n          {\n            this.insertionMode = InsertionMode.IN_BODY;\n            return;\n          }\n        case $.FRAMESET:\n          {\n            this.insertionMode = InsertionMode.IN_FRAMESET;\n            return;\n          }\n        case $.SELECT:\n          {\n            this._resetInsertionModeForSelect(i);\n            return;\n          }\n        case $.TEMPLATE:\n          {\n            this.insertionMode = this.tmplInsertionModeStack[0];\n            return;\n          }\n        case $.HTML:\n          {\n            this.insertionMode = this.headElement ? InsertionMode.AFTER_HEAD : InsertionMode.BEFORE_HEAD;\n            return;\n          }\n        case $.TD:\n        case $.TH:\n          {\n            if (i > 0) {\n              this.insertionMode = InsertionMode.IN_CELL;\n              return;\n            }\n            break;\n          }\n        case $.HEAD:\n          {\n            if (i > 0) {\n              this.insertionMode = InsertionMode.IN_HEAD;\n              return;\n            }\n            break;\n          }\n      }\n    }\n    this.insertionMode = InsertionMode.IN_BODY;\n  }\n  _resetInsertionModeForSelect(selectIdx) {\n    if (selectIdx > 0) {\n      for (let i = selectIdx - 1; i > 0; i--) {\n        const tn = this.openElements.tagIDs[i];\n        if (tn === $.TEMPLATE) {\n          break;\n        } else if (tn === $.TABLE) {\n          this.insertionMode = InsertionMode.IN_SELECT_IN_TABLE;\n          return;\n        }\n      }\n    }\n    this.insertionMode = InsertionMode.IN_SELECT;\n  }\n  //Foster parenting\n  _isElementCausesFosterParenting(tn) {\n    return TABLE_STRUCTURE_TAGS.has(tn);\n  }\n  _shouldFosterParentOnInsertion() {\n    return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.currentTagId);\n  }\n  _findFosterParentingLocation() {\n    for (let i = this.openElements.stackTop; i >= 0; i--) {\n      const openElement = this.openElements.items[i];\n      switch (this.openElements.tagIDs[i]) {\n        case $.TEMPLATE:\n          {\n            if (this.treeAdapter.getNamespaceURI(openElement) === NS.HTML) {\n              return {\n                parent: this.treeAdapter.getTemplateContent(openElement),\n                beforeElement: null\n              };\n            }\n            break;\n          }\n        case $.TABLE:\n          {\n            const parent = this.treeAdapter.getParentNode(openElement);\n            if (parent) {\n              return {\n                parent,\n                beforeElement: openElement\n              };\n            }\n            return {\n              parent: this.openElements.items[i - 1],\n              beforeElement: null\n            };\n          }\n        default:\n        // Do nothing\n      }\n    }\n\n    return {\n      parent: this.openElements.items[0],\n      beforeElement: null\n    };\n  }\n  _fosterParentElement(element) {\n    const location = this._findFosterParentingLocation();\n    if (location.beforeElement) {\n      this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);\n    } else {\n      this.treeAdapter.appendChild(location.parent, element);\n    }\n  }\n  //Special elements\n  _isSpecialElement(element, id) {\n    const ns = this.treeAdapter.getNamespaceURI(element);\n    return SPECIAL_ELEMENTS[ns].has(id);\n  }\n  onCharacter(token) {\n    this.skipNextNewLine = false;\n    if (this.tokenizer.inForeignNode) {\n      characterInForeignContent(this, token);\n      return;\n    }\n    switch (this.insertionMode) {\n      case InsertionMode.INITIAL:\n        {\n          tokenInInitialMode(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HTML:\n        {\n          tokenBeforeHtml(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HEAD:\n        {\n          tokenBeforeHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD:\n        {\n          tokenInHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n        {\n          tokenInHeadNoScript(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_HEAD:\n        {\n          tokenAfterHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_BODY:\n      case InsertionMode.IN_CAPTION:\n      case InsertionMode.IN_CELL:\n      case InsertionMode.IN_TEMPLATE:\n        {\n          characterInBody(this, token);\n          break;\n        }\n      case InsertionMode.TEXT:\n      case InsertionMode.IN_SELECT:\n      case InsertionMode.IN_SELECT_IN_TABLE:\n        {\n          this._insertCharacters(token);\n          break;\n        }\n      case InsertionMode.IN_TABLE:\n      case InsertionMode.IN_TABLE_BODY:\n      case InsertionMode.IN_ROW:\n        {\n          characterInTable(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_TEXT:\n        {\n          characterInTableText(this, token);\n          break;\n        }\n      case InsertionMode.IN_COLUMN_GROUP:\n        {\n          tokenInColumnGroup(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_BODY:\n        {\n          tokenAfterBody(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_AFTER_BODY:\n        {\n          tokenAfterAfterBody(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n\n  onNullCharacter(token) {\n    this.skipNextNewLine = false;\n    if (this.tokenizer.inForeignNode) {\n      nullCharacterInForeignContent(this, token);\n      return;\n    }\n    switch (this.insertionMode) {\n      case InsertionMode.INITIAL:\n        {\n          tokenInInitialMode(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HTML:\n        {\n          tokenBeforeHtml(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HEAD:\n        {\n          tokenBeforeHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD:\n        {\n          tokenInHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n        {\n          tokenInHeadNoScript(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_HEAD:\n        {\n          tokenAfterHead(this, token);\n          break;\n        }\n      case InsertionMode.TEXT:\n        {\n          this._insertCharacters(token);\n          break;\n        }\n      case InsertionMode.IN_TABLE:\n      case InsertionMode.IN_TABLE_BODY:\n      case InsertionMode.IN_ROW:\n        {\n          characterInTable(this, token);\n          break;\n        }\n      case InsertionMode.IN_COLUMN_GROUP:\n        {\n          tokenInColumnGroup(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_BODY:\n        {\n          tokenAfterBody(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_AFTER_BODY:\n        {\n          tokenAfterAfterBody(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n\n  onComment(token) {\n    this.skipNextNewLine = false;\n    if (this.currentNotInHTML) {\n      appendComment(this, token);\n      return;\n    }\n    switch (this.insertionMode) {\n      case InsertionMode.INITIAL:\n      case InsertionMode.BEFORE_HTML:\n      case InsertionMode.BEFORE_HEAD:\n      case InsertionMode.IN_HEAD:\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n      case InsertionMode.AFTER_HEAD:\n      case InsertionMode.IN_BODY:\n      case InsertionMode.IN_TABLE:\n      case InsertionMode.IN_CAPTION:\n      case InsertionMode.IN_COLUMN_GROUP:\n      case InsertionMode.IN_TABLE_BODY:\n      case InsertionMode.IN_ROW:\n      case InsertionMode.IN_CELL:\n      case InsertionMode.IN_SELECT:\n      case InsertionMode.IN_SELECT_IN_TABLE:\n      case InsertionMode.IN_TEMPLATE:\n      case InsertionMode.IN_FRAMESET:\n      case InsertionMode.AFTER_FRAMESET:\n        {\n          appendComment(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_TEXT:\n        {\n          tokenInTableText(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_BODY:\n        {\n          appendCommentToRootHtmlElement(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_AFTER_BODY:\n      case InsertionMode.AFTER_AFTER_FRAMESET:\n        {\n          appendCommentToDocument(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n\n  onDoctype(token) {\n    this.skipNextNewLine = false;\n    switch (this.insertionMode) {\n      case InsertionMode.INITIAL:\n        {\n          doctypeInInitialMode(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HEAD:\n      case InsertionMode.IN_HEAD:\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n      case InsertionMode.AFTER_HEAD:\n        {\n          this._err(token, ERR.misplacedDoctype);\n          break;\n        }\n      case InsertionMode.IN_TABLE_TEXT:\n        {\n          tokenInTableText(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n\n  onStartTag(token) {\n    this.skipNextNewLine = false;\n    this.currentToken = token;\n    this._processStartTag(token);\n    if (token.selfClosing && !token.ackSelfClosing) {\n      this._err(token, ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);\n    }\n  }\n  /**\n   * Processes a given start tag.\n   *\n   * `onStartTag` checks if a self-closing tag was recognized. When a token\n   * is moved inbetween multiple insertion modes, this check for self-closing\n   * could lead to false positives. To avoid this, `_processStartTag` is used\n   * for nested calls.\n   *\n   * @param token The token to process.\n   */\n  _processStartTag(token) {\n    if (this.shouldProcessStartTagTokenInForeignContent(token)) {\n      startTagInForeignContent(this, token);\n    } else {\n      this._startTagOutsideForeignContent(token);\n    }\n  }\n  _startTagOutsideForeignContent(token) {\n    switch (this.insertionMode) {\n      case InsertionMode.INITIAL:\n        {\n          tokenInInitialMode(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HTML:\n        {\n          startTagBeforeHtml(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HEAD:\n        {\n          startTagBeforeHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD:\n        {\n          startTagInHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n        {\n          startTagInHeadNoScript(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_HEAD:\n        {\n          startTagAfterHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_BODY:\n        {\n          startTagInBody(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE:\n        {\n          startTagInTable(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_TEXT:\n        {\n          tokenInTableText(this, token);\n          break;\n        }\n      case InsertionMode.IN_CAPTION:\n        {\n          startTagInCaption(this, token);\n          break;\n        }\n      case InsertionMode.IN_COLUMN_GROUP:\n        {\n          startTagInColumnGroup(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_BODY:\n        {\n          startTagInTableBody(this, token);\n          break;\n        }\n      case InsertionMode.IN_ROW:\n        {\n          startTagInRow(this, token);\n          break;\n        }\n      case InsertionMode.IN_CELL:\n        {\n          startTagInCell(this, token);\n          break;\n        }\n      case InsertionMode.IN_SELECT:\n        {\n          startTagInSelect(this, token);\n          break;\n        }\n      case InsertionMode.IN_SELECT_IN_TABLE:\n        {\n          startTagInSelectInTable(this, token);\n          break;\n        }\n      case InsertionMode.IN_TEMPLATE:\n        {\n          startTagInTemplate(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_BODY:\n        {\n          startTagAfterBody(this, token);\n          break;\n        }\n      case InsertionMode.IN_FRAMESET:\n        {\n          startTagInFrameset(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_FRAMESET:\n        {\n          startTagAfterFrameset(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_AFTER_BODY:\n        {\n          startTagAfterAfterBody(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_AFTER_FRAMESET:\n        {\n          startTagAfterAfterFrameset(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n\n  onEndTag(token) {\n    this.skipNextNewLine = false;\n    this.currentToken = token;\n    if (this.currentNotInHTML) {\n      endTagInForeignContent(this, token);\n    } else {\n      this._endTagOutsideForeignContent(token);\n    }\n  }\n  _endTagOutsideForeignContent(token) {\n    switch (this.insertionMode) {\n      case InsertionMode.INITIAL:\n        {\n          tokenInInitialMode(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HTML:\n        {\n          endTagBeforeHtml(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HEAD:\n        {\n          endTagBeforeHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD:\n        {\n          endTagInHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n        {\n          endTagInHeadNoScript(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_HEAD:\n        {\n          endTagAfterHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_BODY:\n        {\n          endTagInBody(this, token);\n          break;\n        }\n      case InsertionMode.TEXT:\n        {\n          endTagInText(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE:\n        {\n          endTagInTable(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_TEXT:\n        {\n          tokenInTableText(this, token);\n          break;\n        }\n      case InsertionMode.IN_CAPTION:\n        {\n          endTagInCaption(this, token);\n          break;\n        }\n      case InsertionMode.IN_COLUMN_GROUP:\n        {\n          endTagInColumnGroup(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_BODY:\n        {\n          endTagInTableBody(this, token);\n          break;\n        }\n      case InsertionMode.IN_ROW:\n        {\n          endTagInRow(this, token);\n          break;\n        }\n      case InsertionMode.IN_CELL:\n        {\n          endTagInCell(this, token);\n          break;\n        }\n      case InsertionMode.IN_SELECT:\n        {\n          endTagInSelect(this, token);\n          break;\n        }\n      case InsertionMode.IN_SELECT_IN_TABLE:\n        {\n          endTagInSelectInTable(this, token);\n          break;\n        }\n      case InsertionMode.IN_TEMPLATE:\n        {\n          endTagInTemplate(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_BODY:\n        {\n          endTagAfterBody(this, token);\n          break;\n        }\n      case InsertionMode.IN_FRAMESET:\n        {\n          endTagInFrameset(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_FRAMESET:\n        {\n          endTagAfterFrameset(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_AFTER_BODY:\n        {\n          tokenAfterAfterBody(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n\n  onEof(token) {\n    switch (this.insertionMode) {\n      case InsertionMode.INITIAL:\n        {\n          tokenInInitialMode(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HTML:\n        {\n          tokenBeforeHtml(this, token);\n          break;\n        }\n      case InsertionMode.BEFORE_HEAD:\n        {\n          tokenBeforeHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD:\n        {\n          tokenInHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n        {\n          tokenInHeadNoScript(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_HEAD:\n        {\n          tokenAfterHead(this, token);\n          break;\n        }\n      case InsertionMode.IN_BODY:\n      case InsertionMode.IN_TABLE:\n      case InsertionMode.IN_CAPTION:\n      case InsertionMode.IN_COLUMN_GROUP:\n      case InsertionMode.IN_TABLE_BODY:\n      case InsertionMode.IN_ROW:\n      case InsertionMode.IN_CELL:\n      case InsertionMode.IN_SELECT:\n      case InsertionMode.IN_SELECT_IN_TABLE:\n        {\n          eofInBody(this, token);\n          break;\n        }\n      case InsertionMode.TEXT:\n        {\n          eofInText(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_TEXT:\n        {\n          tokenInTableText(this, token);\n          break;\n        }\n      case InsertionMode.IN_TEMPLATE:\n        {\n          eofInTemplate(this, token);\n          break;\n        }\n      case InsertionMode.AFTER_BODY:\n      case InsertionMode.IN_FRAMESET:\n      case InsertionMode.AFTER_FRAMESET:\n      case InsertionMode.AFTER_AFTER_BODY:\n      case InsertionMode.AFTER_AFTER_FRAMESET:\n        {\n          stopParsing(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n\n  onWhitespaceCharacter(token) {\n    if (this.skipNextNewLine) {\n      this.skipNextNewLine = false;\n      if (token.chars.charCodeAt(0) === unicode.CODE_POINTS.LINE_FEED) {\n        if (token.chars.length === 1) {\n          return;\n        }\n        token.chars = token.chars.substr(1);\n      }\n    }\n    if (this.tokenizer.inForeignNode) {\n      this._insertCharacters(token);\n      return;\n    }\n    switch (this.insertionMode) {\n      case InsertionMode.IN_HEAD:\n      case InsertionMode.IN_HEAD_NO_SCRIPT:\n      case InsertionMode.AFTER_HEAD:\n      case InsertionMode.TEXT:\n      case InsertionMode.IN_COLUMN_GROUP:\n      case InsertionMode.IN_SELECT:\n      case InsertionMode.IN_SELECT_IN_TABLE:\n      case InsertionMode.IN_FRAMESET:\n      case InsertionMode.AFTER_FRAMESET:\n        {\n          this._insertCharacters(token);\n          break;\n        }\n      case InsertionMode.IN_BODY:\n      case InsertionMode.IN_CAPTION:\n      case InsertionMode.IN_CELL:\n      case InsertionMode.IN_TEMPLATE:\n      case InsertionMode.AFTER_BODY:\n      case InsertionMode.AFTER_AFTER_BODY:\n      case InsertionMode.AFTER_AFTER_FRAMESET:\n        {\n          whitespaceCharacterInBody(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE:\n      case InsertionMode.IN_TABLE_BODY:\n      case InsertionMode.IN_ROW:\n        {\n          characterInTable(this, token);\n          break;\n        }\n      case InsertionMode.IN_TABLE_TEXT:\n        {\n          whitespaceCharacterInTableText(this, token);\n          break;\n        }\n      default:\n      // Do nothing\n    }\n  }\n}\n//Adoption agency algorithm\n//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)\n//------------------------------------------------------------------\n//Steps 5-8 of the algorithm\nfunction aaObtainFormattingElementEntry(p, token) {\n  let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);\n  if (formattingElementEntry) {\n    if (!p.openElements.contains(formattingElementEntry.element)) {\n      p.activeFormattingElements.removeEntry(formattingElementEntry);\n      formattingElementEntry = null;\n    } else if (!p.openElements.hasInScope(token.tagID)) {\n      formattingElementEntry = null;\n    }\n  } else {\n    genericEndTagInBody(p, token);\n  }\n  return formattingElementEntry;\n}\n//Steps 9 and 10 of the algorithm\nfunction aaObtainFurthestBlock(p, formattingElementEntry) {\n  let furthestBlock = null;\n  let idx = p.openElements.stackTop;\n  for (; idx >= 0; idx--) {\n    const element = p.openElements.items[idx];\n    if (element === formattingElementEntry.element) {\n      break;\n    }\n    if (p._isSpecialElement(element, p.openElements.tagIDs[idx])) {\n      furthestBlock = element;\n    }\n  }\n  if (!furthestBlock) {\n    p.openElements.shortenToLength(idx < 0 ? 0 : idx);\n    p.activeFormattingElements.removeEntry(formattingElementEntry);\n  }\n  return furthestBlock;\n}\n//Step 13 of the algorithm\nfunction aaInnerLoop(p, furthestBlock, formattingElement) {\n  let lastElement = furthestBlock;\n  let nextElement = p.openElements.getCommonAncestor(furthestBlock);\n  for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {\n    //NOTE: store the next element for the next loop iteration (it may be deleted from the stack by step 9.5)\n    nextElement = p.openElements.getCommonAncestor(element);\n    const elementEntry = p.activeFormattingElements.getElementEntry(element);\n    const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;\n    const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;\n    if (shouldRemoveFromOpenElements) {\n      if (counterOverflow) {\n        p.activeFormattingElements.removeEntry(elementEntry);\n      }\n      p.openElements.remove(element);\n    } else {\n      element = aaRecreateElementFromEntry(p, elementEntry);\n      if (lastElement === furthestBlock) {\n        p.activeFormattingElements.bookmark = elementEntry;\n      }\n      p.treeAdapter.detachNode(lastElement);\n      p.treeAdapter.appendChild(element, lastElement);\n      lastElement = element;\n    }\n  }\n  return lastElement;\n}\n//Step 13.7 of the algorithm\nfunction aaRecreateElementFromEntry(p, elementEntry) {\n  const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);\n  const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);\n  p.openElements.replace(elementEntry.element, newElement);\n  elementEntry.element = newElement;\n  return newElement;\n}\n//Step 14 of the algorithm\nfunction aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {\n  const tn = p.treeAdapter.getTagName(commonAncestor);\n  const tid = getTagID(tn);\n  if (p._isElementCausesFosterParenting(tid)) {\n    p._fosterParentElement(lastElement);\n  } else {\n    const ns = p.treeAdapter.getNamespaceURI(commonAncestor);\n    if (tid === $.TEMPLATE && ns === NS.HTML) {\n      commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);\n    }\n    p.treeAdapter.appendChild(commonAncestor, lastElement);\n  }\n}\n//Steps 15-19 of the algorithm\nfunction aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {\n  const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);\n  const {\n    token\n  } = formattingElementEntry;\n  const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);\n  p._adoptNodes(furthestBlock, newElement);\n  p.treeAdapter.appendChild(furthestBlock, newElement);\n  p.activeFormattingElements.insertElementAfterBookmark(newElement, token);\n  p.activeFormattingElements.removeEntry(formattingElementEntry);\n  p.openElements.remove(formattingElementEntry.element);\n  p.openElements.insertAfter(furthestBlock, newElement, token.tagID);\n}\n//Algorithm entry point\nfunction callAdoptionAgency(p, token) {\n  for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {\n    const formattingElementEntry = aaObtainFormattingElementEntry(p, token);\n    if (!formattingElementEntry) {\n      break;\n    }\n    const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);\n    if (!furthestBlock) {\n      break;\n    }\n    p.activeFormattingElements.bookmark = formattingElementEntry;\n    const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);\n    const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);\n    p.treeAdapter.detachNode(lastElement);\n    if (commonAncestor) aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);\n    aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);\n  }\n}\n//Generic token handlers\n//------------------------------------------------------------------\nfunction appendComment(p, token) {\n  p._appendCommentNode(token, p.openElements.currentTmplContentOrNode);\n}\nfunction appendCommentToRootHtmlElement(p, token) {\n  p._appendCommentNode(token, p.openElements.items[0]);\n}\nfunction appendCommentToDocument(p, token) {\n  p._appendCommentNode(token, p.document);\n}\nfunction stopParsing(p, token) {\n  p.stopped = true;\n  // NOTE: Set end locations for elements that remain on the open element stack.\n  if (token.location) {\n    // NOTE: If we are not in a fragment, `html` and `body` will stay on the stack.\n    // This is a problem, as we might overwrite their end position here.\n    const target = p.fragmentContext ? 0 : 2;\n    for (let i = p.openElements.stackTop; i >= target; i--) {\n      p._setEndLocation(p.openElements.items[i], token);\n    }\n    // Handle `html` and `body`\n    if (!p.fragmentContext && p.openElements.stackTop >= 0) {\n      const htmlElement = p.openElements.items[0];\n      const htmlLocation = p.treeAdapter.getNodeSourceCodeLocation(htmlElement);\n      if (htmlLocation && !htmlLocation.endTag) {\n        p._setEndLocation(htmlElement, token);\n        if (p.openElements.stackTop >= 1) {\n          const bodyElement = p.openElements.items[1];\n          const bodyLocation = p.treeAdapter.getNodeSourceCodeLocation(bodyElement);\n          if (bodyLocation && !bodyLocation.endTag) {\n            p._setEndLocation(bodyElement, token);\n          }\n        }\n      }\n    }\n  }\n}\n// The \"initial\" insertion mode\n//------------------------------------------------------------------\nfunction doctypeInInitialMode(p, token) {\n  p._setDocumentType(token);\n  const mode = token.forceQuirks ? DOCUMENT_MODE.QUIRKS : doctype.getDocumentMode(token);\n  if (!doctype.isConforming(token)) {\n    p._err(token, ERR.nonConformingDoctype);\n  }\n  p.treeAdapter.setDocumentMode(p.document, mode);\n  p.insertionMode = InsertionMode.BEFORE_HTML;\n}\nfunction tokenInInitialMode(p, token) {\n  p._err(token, ERR.missingDoctype, true);\n  p.treeAdapter.setDocumentMode(p.document, DOCUMENT_MODE.QUIRKS);\n  p.insertionMode = InsertionMode.BEFORE_HTML;\n  p._processToken(token);\n}\n// The \"before html\" insertion mode\n//------------------------------------------------------------------\nfunction startTagBeforeHtml(p, token) {\n  if (token.tagID === $.HTML) {\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = InsertionMode.BEFORE_HEAD;\n  } else {\n    tokenBeforeHtml(p, token);\n  }\n}\nfunction endTagBeforeHtml(p, token) {\n  const tn = token.tagID;\n  if (tn === $.HTML || tn === $.HEAD || tn === $.BODY || tn === $.BR) {\n    tokenBeforeHtml(p, token);\n  }\n}\nfunction tokenBeforeHtml(p, token) {\n  p._insertFakeRootElement();\n  p.insertionMode = InsertionMode.BEFORE_HEAD;\n  p._processToken(token);\n}\n// The \"before head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagBeforeHead(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.HEAD:\n      {\n        p._insertElement(token, NS.HTML);\n        p.headElement = p.openElements.current;\n        p.insertionMode = InsertionMode.IN_HEAD;\n        break;\n      }\n    default:\n      {\n        tokenBeforeHead(p, token);\n      }\n  }\n}\nfunction endTagBeforeHead(p, token) {\n  const tn = token.tagID;\n  if (tn === $.HEAD || tn === $.BODY || tn === $.HTML || tn === $.BR) {\n    tokenBeforeHead(p, token);\n  } else {\n    p._err(token, ERR.endTagWithoutMatchingOpenElement);\n  }\n}\nfunction tokenBeforeHead(p, token) {\n  p._insertFakeElement(TN.HEAD, $.HEAD);\n  p.headElement = p.openElements.current;\n  p.insertionMode = InsertionMode.IN_HEAD;\n  p._processToken(token);\n}\n// The \"in head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInHead(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.BASE:\n    case $.BASEFONT:\n    case $.BGSOUND:\n    case $.LINK:\n    case $.META:\n      {\n        p._appendElement(token, NS.HTML);\n        token.ackSelfClosing = true;\n        break;\n      }\n    case $.TITLE:\n      {\n        p._switchToTextParsing(token, TokenizerMode.RCDATA);\n        break;\n      }\n    case $.NOSCRIPT:\n      {\n        if (p.options.scriptingEnabled) {\n          p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n        } else {\n          p._insertElement(token, NS.HTML);\n          p.insertionMode = InsertionMode.IN_HEAD_NO_SCRIPT;\n        }\n        break;\n      }\n    case $.NOFRAMES:\n    case $.STYLE:\n      {\n        p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n        break;\n      }\n    case $.SCRIPT:\n      {\n        p._switchToTextParsing(token, TokenizerMode.SCRIPT_DATA);\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        p._insertTemplate(token);\n        p.activeFormattingElements.insertMarker();\n        p.framesetOk = false;\n        p.insertionMode = InsertionMode.IN_TEMPLATE;\n        p.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);\n        break;\n      }\n    case $.HEAD:\n      {\n        p._err(token, ERR.misplacedStartTagForHeadElement);\n        break;\n      }\n    default:\n      {\n        tokenInHead(p, token);\n      }\n  }\n}\nfunction endTagInHead(p, token) {\n  switch (token.tagID) {\n    case $.HEAD:\n      {\n        p.openElements.pop();\n        p.insertionMode = InsertionMode.AFTER_HEAD;\n        break;\n      }\n    case $.BODY:\n    case $.BR:\n    case $.HTML:\n      {\n        tokenInHead(p, token);\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        templateEndTagInHead(p, token);\n        break;\n      }\n    default:\n      {\n        p._err(token, ERR.endTagWithoutMatchingOpenElement);\n      }\n  }\n}\nfunction templateEndTagInHead(p, token) {\n  if (p.openElements.tmplCount > 0) {\n    p.openElements.generateImpliedEndTagsThoroughly();\n    if (p.openElements.currentTagId !== $.TEMPLATE) {\n      p._err(token, ERR.closingOfElementWithOpenChildElements);\n    }\n    p.openElements.popUntilTagNamePopped($.TEMPLATE);\n    p.activeFormattingElements.clearToLastMarker();\n    p.tmplInsertionModeStack.shift();\n    p._resetInsertionMode();\n  } else {\n    p._err(token, ERR.endTagWithoutMatchingOpenElement);\n  }\n}\nfunction tokenInHead(p, token) {\n  p.openElements.pop();\n  p.insertionMode = InsertionMode.AFTER_HEAD;\n  p._processToken(token);\n}\n// The \"in head no script\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInHeadNoScript(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.BASEFONT:\n    case $.BGSOUND:\n    case $.HEAD:\n    case $.LINK:\n    case $.META:\n    case $.NOFRAMES:\n    case $.STYLE:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    case $.NOSCRIPT:\n      {\n        p._err(token, ERR.nestedNoscriptInHead);\n        break;\n      }\n    default:\n      {\n        tokenInHeadNoScript(p, token);\n      }\n  }\n}\nfunction endTagInHeadNoScript(p, token) {\n  switch (token.tagID) {\n    case $.NOSCRIPT:\n      {\n        p.openElements.pop();\n        p.insertionMode = InsertionMode.IN_HEAD;\n        break;\n      }\n    case $.BR:\n      {\n        tokenInHeadNoScript(p, token);\n        break;\n      }\n    default:\n      {\n        p._err(token, ERR.endTagWithoutMatchingOpenElement);\n      }\n  }\n}\nfunction tokenInHeadNoScript(p, token) {\n  const errCode = token.type === TokenType.EOF ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;\n  p._err(token, errCode);\n  p.openElements.pop();\n  p.insertionMode = InsertionMode.IN_HEAD;\n  p._processToken(token);\n}\n// The \"after head\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterHead(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.BODY:\n      {\n        p._insertElement(token, NS.HTML);\n        p.framesetOk = false;\n        p.insertionMode = InsertionMode.IN_BODY;\n        break;\n      }\n    case $.FRAMESET:\n      {\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = InsertionMode.IN_FRAMESET;\n        break;\n      }\n    case $.BASE:\n    case $.BASEFONT:\n    case $.BGSOUND:\n    case $.LINK:\n    case $.META:\n    case $.NOFRAMES:\n    case $.SCRIPT:\n    case $.STYLE:\n    case $.TEMPLATE:\n    case $.TITLE:\n      {\n        p._err(token, ERR.abandonedHeadElementChild);\n        p.openElements.push(p.headElement, $.HEAD);\n        startTagInHead(p, token);\n        p.openElements.remove(p.headElement);\n        break;\n      }\n    case $.HEAD:\n      {\n        p._err(token, ERR.misplacedStartTagForHeadElement);\n        break;\n      }\n    default:\n      {\n        tokenAfterHead(p, token);\n      }\n  }\n}\nfunction endTagAfterHead(p, token) {\n  switch (token.tagID) {\n    case $.BODY:\n    case $.HTML:\n    case $.BR:\n      {\n        tokenAfterHead(p, token);\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        templateEndTagInHead(p, token);\n        break;\n      }\n    default:\n      {\n        p._err(token, ERR.endTagWithoutMatchingOpenElement);\n      }\n  }\n}\nfunction tokenAfterHead(p, token) {\n  p._insertFakeElement(TN.BODY, $.BODY);\n  p.insertionMode = InsertionMode.IN_BODY;\n  modeInBody(p, token);\n}\n// The \"in body\" insertion mode\n//------------------------------------------------------------------\nfunction modeInBody(p, token) {\n  switch (token.type) {\n    case TokenType.CHARACTER:\n      {\n        characterInBody(p, token);\n        break;\n      }\n    case TokenType.WHITESPACE_CHARACTER:\n      {\n        whitespaceCharacterInBody(p, token);\n        break;\n      }\n    case TokenType.COMMENT:\n      {\n        appendComment(p, token);\n        break;\n      }\n    case TokenType.START_TAG:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case TokenType.END_TAG:\n      {\n        endTagInBody(p, token);\n        break;\n      }\n    case TokenType.EOF:\n      {\n        eofInBody(p, token);\n        break;\n      }\n    default:\n    // Do nothing\n  }\n}\n\nfunction whitespaceCharacterInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._insertCharacters(token);\n}\nfunction characterInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._insertCharacters(token);\n  p.framesetOk = false;\n}\nfunction htmlStartTagInBody(p, token) {\n  if (p.openElements.tmplCount === 0) {\n    p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);\n  }\n}\nfunction bodyStartTagInBody(p, token) {\n  const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n  if (bodyElement && p.openElements.tmplCount === 0) {\n    p.framesetOk = false;\n    p.treeAdapter.adoptAttributes(bodyElement, token.attrs);\n  }\n}\nfunction framesetStartTagInBody(p, token) {\n  const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n  if (p.framesetOk && bodyElement) {\n    p.treeAdapter.detachNode(bodyElement);\n    p.openElements.popAllUpToHtmlElement();\n    p._insertElement(token, NS.HTML);\n    p.insertionMode = InsertionMode.IN_FRAMESET;\n  }\n}\nfunction addressStartTagInBody(p, token) {\n  if (p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  p._insertElement(token, NS.HTML);\n}\nfunction numberedHeaderStartTagInBody(p, token) {\n  if (p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  if (isNumberedHeader(p.openElements.currentTagId)) {\n    p.openElements.pop();\n  }\n  p._insertElement(token, NS.HTML);\n}\nfunction preStartTagInBody(p, token) {\n  if (p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  p._insertElement(token, NS.HTML);\n  //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move\n  //on to the next one. (Newlines at the start of pre blocks are ignored as an authoring convenience.)\n  p.skipNextNewLine = true;\n  p.framesetOk = false;\n}\nfunction formStartTagInBody(p, token) {\n  const inTemplate = p.openElements.tmplCount > 0;\n  if (!p.formElement || inTemplate) {\n    if (p.openElements.hasInButtonScope($.P)) {\n      p._closePElement();\n    }\n    p._insertElement(token, NS.HTML);\n    if (!inTemplate) {\n      p.formElement = p.openElements.current;\n    }\n  }\n}\nfunction listItemStartTagInBody(p, token) {\n  p.framesetOk = false;\n  const tn = token.tagID;\n  for (let i = p.openElements.stackTop; i >= 0; i--) {\n    const elementId = p.openElements.tagIDs[i];\n    if (tn === $.LI && elementId === $.LI || (tn === $.DD || tn === $.DT) && (elementId === $.DD || elementId === $.DT)) {\n      p.openElements.generateImpliedEndTagsWithExclusion(elementId);\n      p.openElements.popUntilTagNamePopped(elementId);\n      break;\n    }\n    if (elementId !== $.ADDRESS && elementId !== $.DIV && elementId !== $.P && p._isSpecialElement(p.openElements.items[i], elementId)) {\n      break;\n    }\n  }\n  if (p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  p._insertElement(token, NS.HTML);\n}\nfunction plaintextStartTagInBody(p, token) {\n  if (p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  p._insertElement(token, NS.HTML);\n  p.tokenizer.state = TokenizerMode.PLAINTEXT;\n}\nfunction buttonStartTagInBody(p, token) {\n  if (p.openElements.hasInScope($.BUTTON)) {\n    p.openElements.generateImpliedEndTags();\n    p.openElements.popUntilTagNamePopped($.BUTTON);\n  }\n  p._reconstructActiveFormattingElements();\n  p._insertElement(token, NS.HTML);\n  p.framesetOk = false;\n}\nfunction aStartTagInBody(p, token) {\n  const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(TN.A);\n  if (activeElementEntry) {\n    callAdoptionAgency(p, token);\n    p.openElements.remove(activeElementEntry.element);\n    p.activeFormattingElements.removeEntry(activeElementEntry);\n  }\n  p._reconstructActiveFormattingElements();\n  p._insertElement(token, NS.HTML);\n  p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\nfunction bStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._insertElement(token, NS.HTML);\n  p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\nfunction nobrStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  if (p.openElements.hasInScope($.NOBR)) {\n    callAdoptionAgency(p, token);\n    p._reconstructActiveFormattingElements();\n  }\n  p._insertElement(token, NS.HTML);\n  p.activeFormattingElements.pushElement(p.openElements.current, token);\n}\nfunction appletStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._insertElement(token, NS.HTML);\n  p.activeFormattingElements.insertMarker();\n  p.framesetOk = false;\n}\nfunction tableStartTagInBody(p, token) {\n  if (p.treeAdapter.getDocumentMode(p.document) !== DOCUMENT_MODE.QUIRKS && p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  p._insertElement(token, NS.HTML);\n  p.framesetOk = false;\n  p.insertionMode = InsertionMode.IN_TABLE;\n}\nfunction areaStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._appendElement(token, NS.HTML);\n  p.framesetOk = false;\n  token.ackSelfClosing = true;\n}\nfunction isHiddenInput(token) {\n  const inputType = getTokenAttr(token, ATTRS.TYPE);\n  return inputType != null && inputType.toLowerCase() === HIDDEN_INPUT_TYPE;\n}\nfunction inputStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._appendElement(token, NS.HTML);\n  if (!isHiddenInput(token)) {\n    p.framesetOk = false;\n  }\n  token.ackSelfClosing = true;\n}\nfunction paramStartTagInBody(p, token) {\n  p._appendElement(token, NS.HTML);\n  token.ackSelfClosing = true;\n}\nfunction hrStartTagInBody(p, token) {\n  if (p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  p._appendElement(token, NS.HTML);\n  p.framesetOk = false;\n  token.ackSelfClosing = true;\n}\nfunction imageStartTagInBody(p, token) {\n  token.tagName = TN.IMG;\n  token.tagID = $.IMG;\n  areaStartTagInBody(p, token);\n}\nfunction textareaStartTagInBody(p, token) {\n  p._insertElement(token, NS.HTML);\n  //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move\n  //on to the next one. (Newlines at the start of textarea elements are ignored as an authoring convenience.)\n  p.skipNextNewLine = true;\n  p.tokenizer.state = TokenizerMode.RCDATA;\n  p.originalInsertionMode = p.insertionMode;\n  p.framesetOk = false;\n  p.insertionMode = InsertionMode.TEXT;\n}\nfunction xmpStartTagInBody(p, token) {\n  if (p.openElements.hasInButtonScope($.P)) {\n    p._closePElement();\n  }\n  p._reconstructActiveFormattingElements();\n  p.framesetOk = false;\n  p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n}\nfunction iframeStartTagInBody(p, token) {\n  p.framesetOk = false;\n  p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n}\n//NOTE: here we assume that we always act as an user agent with enabled plugins, so we parse\n//<noembed> as rawtext.\nfunction noembedStartTagInBody(p, token) {\n  p._switchToTextParsing(token, TokenizerMode.RAWTEXT);\n}\nfunction selectStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._insertElement(token, NS.HTML);\n  p.framesetOk = false;\n  p.insertionMode = p.insertionMode === InsertionMode.IN_TABLE || p.insertionMode === InsertionMode.IN_CAPTION || p.insertionMode === InsertionMode.IN_TABLE_BODY || p.insertionMode === InsertionMode.IN_ROW || p.insertionMode === InsertionMode.IN_CELL ? InsertionMode.IN_SELECT_IN_TABLE : InsertionMode.IN_SELECT;\n}\nfunction optgroupStartTagInBody(p, token) {\n  if (p.openElements.currentTagId === $.OPTION) {\n    p.openElements.pop();\n  }\n  p._reconstructActiveFormattingElements();\n  p._insertElement(token, NS.HTML);\n}\nfunction rbStartTagInBody(p, token) {\n  if (p.openElements.hasInScope($.RUBY)) {\n    p.openElements.generateImpliedEndTags();\n  }\n  p._insertElement(token, NS.HTML);\n}\nfunction rtStartTagInBody(p, token) {\n  if (p.openElements.hasInScope($.RUBY)) {\n    p.openElements.generateImpliedEndTagsWithExclusion($.RTC);\n  }\n  p._insertElement(token, NS.HTML);\n}\nfunction mathStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  foreignContent.adjustTokenMathMLAttrs(token);\n  foreignContent.adjustTokenXMLAttrs(token);\n  if (token.selfClosing) {\n    p._appendElement(token, NS.MATHML);\n  } else {\n    p._insertElement(token, NS.MATHML);\n  }\n  token.ackSelfClosing = true;\n}\nfunction svgStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  foreignContent.adjustTokenSVGAttrs(token);\n  foreignContent.adjustTokenXMLAttrs(token);\n  if (token.selfClosing) {\n    p._appendElement(token, NS.SVG);\n  } else {\n    p._insertElement(token, NS.SVG);\n  }\n  token.ackSelfClosing = true;\n}\nfunction genericStartTagInBody(p, token) {\n  p._reconstructActiveFormattingElements();\n  p._insertElement(token, NS.HTML);\n}\nfunction startTagInBody(p, token) {\n  switch (token.tagID) {\n    case $.I:\n    case $.S:\n    case $.B:\n    case $.U:\n    case $.EM:\n    case $.TT:\n    case $.BIG:\n    case $.CODE:\n    case $.FONT:\n    case $.SMALL:\n    case $.STRIKE:\n    case $.STRONG:\n      {\n        bStartTagInBody(p, token);\n        break;\n      }\n    case $.A:\n      {\n        aStartTagInBody(p, token);\n        break;\n      }\n    case $.H1:\n    case $.H2:\n    case $.H3:\n    case $.H4:\n    case $.H5:\n    case $.H6:\n      {\n        numberedHeaderStartTagInBody(p, token);\n        break;\n      }\n    case $.P:\n    case $.DL:\n    case $.OL:\n    case $.UL:\n    case $.DIV:\n    case $.DIR:\n    case $.NAV:\n    case $.MAIN:\n    case $.MENU:\n    case $.ASIDE:\n    case $.CENTER:\n    case $.FIGURE:\n    case $.FOOTER:\n    case $.HEADER:\n    case $.HGROUP:\n    case $.DIALOG:\n    case $.DETAILS:\n    case $.ADDRESS:\n    case $.ARTICLE:\n    case $.SECTION:\n    case $.SUMMARY:\n    case $.FIELDSET:\n    case $.BLOCKQUOTE:\n    case $.FIGCAPTION:\n      {\n        addressStartTagInBody(p, token);\n        break;\n      }\n    case $.LI:\n    case $.DD:\n    case $.DT:\n      {\n        listItemStartTagInBody(p, token);\n        break;\n      }\n    case $.BR:\n    case $.IMG:\n    case $.WBR:\n    case $.AREA:\n    case $.EMBED:\n    case $.KEYGEN:\n      {\n        areaStartTagInBody(p, token);\n        break;\n      }\n    case $.HR:\n      {\n        hrStartTagInBody(p, token);\n        break;\n      }\n    case $.RB:\n    case $.RTC:\n      {\n        rbStartTagInBody(p, token);\n        break;\n      }\n    case $.RT:\n    case $.RP:\n      {\n        rtStartTagInBody(p, token);\n        break;\n      }\n    case $.PRE:\n    case $.LISTING:\n      {\n        preStartTagInBody(p, token);\n        break;\n      }\n    case $.XMP:\n      {\n        xmpStartTagInBody(p, token);\n        break;\n      }\n    case $.SVG:\n      {\n        svgStartTagInBody(p, token);\n        break;\n      }\n    case $.HTML:\n      {\n        htmlStartTagInBody(p, token);\n        break;\n      }\n    case $.BASE:\n    case $.LINK:\n    case $.META:\n    case $.STYLE:\n    case $.TITLE:\n    case $.SCRIPT:\n    case $.BGSOUND:\n    case $.BASEFONT:\n    case $.TEMPLATE:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    case $.BODY:\n      {\n        bodyStartTagInBody(p, token);\n        break;\n      }\n    case $.FORM:\n      {\n        formStartTagInBody(p, token);\n        break;\n      }\n    case $.NOBR:\n      {\n        nobrStartTagInBody(p, token);\n        break;\n      }\n    case $.MATH:\n      {\n        mathStartTagInBody(p, token);\n        break;\n      }\n    case $.TABLE:\n      {\n        tableStartTagInBody(p, token);\n        break;\n      }\n    case $.INPUT:\n      {\n        inputStartTagInBody(p, token);\n        break;\n      }\n    case $.PARAM:\n    case $.TRACK:\n    case $.SOURCE:\n      {\n        paramStartTagInBody(p, token);\n        break;\n      }\n    case $.IMAGE:\n      {\n        imageStartTagInBody(p, token);\n        break;\n      }\n    case $.BUTTON:\n      {\n        buttonStartTagInBody(p, token);\n        break;\n      }\n    case $.APPLET:\n    case $.OBJECT:\n    case $.MARQUEE:\n      {\n        appletStartTagInBody(p, token);\n        break;\n      }\n    case $.IFRAME:\n      {\n        iframeStartTagInBody(p, token);\n        break;\n      }\n    case $.SELECT:\n      {\n        selectStartTagInBody(p, token);\n        break;\n      }\n    case $.OPTION:\n    case $.OPTGROUP:\n      {\n        optgroupStartTagInBody(p, token);\n        break;\n      }\n    case $.NOEMBED:\n      {\n        noembedStartTagInBody(p, token);\n        break;\n      }\n    case $.FRAMESET:\n      {\n        framesetStartTagInBody(p, token);\n        break;\n      }\n    case $.TEXTAREA:\n      {\n        textareaStartTagInBody(p, token);\n        break;\n      }\n    case $.NOSCRIPT:\n      {\n        if (p.options.scriptingEnabled) {\n          noembedStartTagInBody(p, token);\n        } else {\n          genericStartTagInBody(p, token);\n        }\n        break;\n      }\n    case $.PLAINTEXT:\n      {\n        plaintextStartTagInBody(p, token);\n        break;\n      }\n    case $.COL:\n    case $.TH:\n    case $.TD:\n    case $.TR:\n    case $.HEAD:\n    case $.FRAME:\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n    case $.CAPTION:\n    case $.COLGROUP:\n      {\n        // Ignore token\n        break;\n      }\n    default:\n      {\n        genericStartTagInBody(p, token);\n      }\n  }\n}\nfunction bodyEndTagInBody(p, token) {\n  if (p.openElements.hasInScope($.BODY)) {\n    p.insertionMode = InsertionMode.AFTER_BODY;\n    //NOTE: <body> is never popped from the stack, so we need to updated\n    //the end location explicitly.\n    if (p.options.sourceCodeLocationInfo) {\n      const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();\n      if (bodyElement) {\n        p._setEndLocation(bodyElement, token);\n      }\n    }\n  }\n}\nfunction htmlEndTagInBody(p, token) {\n  if (p.openElements.hasInScope($.BODY)) {\n    p.insertionMode = InsertionMode.AFTER_BODY;\n    endTagAfterBody(p, token);\n  }\n}\nfunction addressEndTagInBody(p, token) {\n  const tn = token.tagID;\n  if (p.openElements.hasInScope(tn)) {\n    p.openElements.generateImpliedEndTags();\n    p.openElements.popUntilTagNamePopped(tn);\n  }\n}\nfunction formEndTagInBody(p) {\n  const inTemplate = p.openElements.tmplCount > 0;\n  const {\n    formElement\n  } = p;\n  if (!inTemplate) {\n    p.formElement = null;\n  }\n  if ((formElement || inTemplate) && p.openElements.hasInScope($.FORM)) {\n    p.openElements.generateImpliedEndTags();\n    if (inTemplate) {\n      p.openElements.popUntilTagNamePopped($.FORM);\n    } else if (formElement) {\n      p.openElements.remove(formElement);\n    }\n  }\n}\nfunction pEndTagInBody(p) {\n  if (!p.openElements.hasInButtonScope($.P)) {\n    p._insertFakeElement(TN.P, $.P);\n  }\n  p._closePElement();\n}\nfunction liEndTagInBody(p) {\n  if (p.openElements.hasInListItemScope($.LI)) {\n    p.openElements.generateImpliedEndTagsWithExclusion($.LI);\n    p.openElements.popUntilTagNamePopped($.LI);\n  }\n}\nfunction ddEndTagInBody(p, token) {\n  const tn = token.tagID;\n  if (p.openElements.hasInScope(tn)) {\n    p.openElements.generateImpliedEndTagsWithExclusion(tn);\n    p.openElements.popUntilTagNamePopped(tn);\n  }\n}\nfunction numberedHeaderEndTagInBody(p) {\n  if (p.openElements.hasNumberedHeaderInScope()) {\n    p.openElements.generateImpliedEndTags();\n    p.openElements.popUntilNumberedHeaderPopped();\n  }\n}\nfunction appletEndTagInBody(p, token) {\n  const tn = token.tagID;\n  if (p.openElements.hasInScope(tn)) {\n    p.openElements.generateImpliedEndTags();\n    p.openElements.popUntilTagNamePopped(tn);\n    p.activeFormattingElements.clearToLastMarker();\n  }\n}\nfunction brEndTagInBody(p) {\n  p._reconstructActiveFormattingElements();\n  p._insertFakeElement(TN.BR, $.BR);\n  p.openElements.pop();\n  p.framesetOk = false;\n}\nfunction genericEndTagInBody(p, token) {\n  const tn = token.tagName;\n  const tid = token.tagID;\n  for (let i = p.openElements.stackTop; i > 0; i--) {\n    const element = p.openElements.items[i];\n    const elementId = p.openElements.tagIDs[i];\n    // Compare the tag name here, as the tag might not be a known tag with an ID.\n    if (tid === elementId && (tid !== $.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) {\n      p.openElements.generateImpliedEndTagsWithExclusion(tid);\n      if (p.openElements.stackTop >= i) p.openElements.shortenToLength(i);\n      break;\n    }\n    if (p._isSpecialElement(element, elementId)) {\n      break;\n    }\n  }\n}\nfunction endTagInBody(p, token) {\n  switch (token.tagID) {\n    case $.A:\n    case $.B:\n    case $.I:\n    case $.S:\n    case $.U:\n    case $.EM:\n    case $.TT:\n    case $.BIG:\n    case $.CODE:\n    case $.FONT:\n    case $.NOBR:\n    case $.SMALL:\n    case $.STRIKE:\n    case $.STRONG:\n      {\n        callAdoptionAgency(p, token);\n        break;\n      }\n    case $.P:\n      {\n        pEndTagInBody(p);\n        break;\n      }\n    case $.DL:\n    case $.UL:\n    case $.OL:\n    case $.DIR:\n    case $.DIV:\n    case $.NAV:\n    case $.PRE:\n    case $.MAIN:\n    case $.MENU:\n    case $.ASIDE:\n    case $.BUTTON:\n    case $.CENTER:\n    case $.FIGURE:\n    case $.FOOTER:\n    case $.HEADER:\n    case $.HGROUP:\n    case $.DIALOG:\n    case $.ADDRESS:\n    case $.ARTICLE:\n    case $.DETAILS:\n    case $.SECTION:\n    case $.SUMMARY:\n    case $.LISTING:\n    case $.FIELDSET:\n    case $.BLOCKQUOTE:\n    case $.FIGCAPTION:\n      {\n        addressEndTagInBody(p, token);\n        break;\n      }\n    case $.LI:\n      {\n        liEndTagInBody(p);\n        break;\n      }\n    case $.DD:\n    case $.DT:\n      {\n        ddEndTagInBody(p, token);\n        break;\n      }\n    case $.H1:\n    case $.H2:\n    case $.H3:\n    case $.H4:\n    case $.H5:\n    case $.H6:\n      {\n        numberedHeaderEndTagInBody(p);\n        break;\n      }\n    case $.BR:\n      {\n        brEndTagInBody(p);\n        break;\n      }\n    case $.BODY:\n      {\n        bodyEndTagInBody(p, token);\n        break;\n      }\n    case $.HTML:\n      {\n        htmlEndTagInBody(p, token);\n        break;\n      }\n    case $.FORM:\n      {\n        formEndTagInBody(p);\n        break;\n      }\n    case $.APPLET:\n    case $.OBJECT:\n    case $.MARQUEE:\n      {\n        appletEndTagInBody(p, token);\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        templateEndTagInHead(p, token);\n        break;\n      }\n    default:\n      {\n        genericEndTagInBody(p, token);\n      }\n  }\n}\nfunction eofInBody(p, token) {\n  if (p.tmplInsertionModeStack.length > 0) {\n    eofInTemplate(p, token);\n  } else {\n    stopParsing(p, token);\n  }\n}\n// The \"text\" insertion mode\n//------------------------------------------------------------------\nfunction endTagInText(p, token) {\n  var _a;\n  if (token.tagID === $.SCRIPT) {\n    (_a = p.scriptHandler) === null || _a === void 0 ? void 0 : _a.call(p, p.openElements.current);\n  }\n  p.openElements.pop();\n  p.insertionMode = p.originalInsertionMode;\n}\nfunction eofInText(p, token) {\n  p._err(token, ERR.eofInElementThatCanContainOnlyText);\n  p.openElements.pop();\n  p.insertionMode = p.originalInsertionMode;\n  p.onEof(token);\n}\n// The \"in table\" insertion mode\n//------------------------------------------------------------------\nfunction characterInTable(p, token) {\n  if (TABLE_STRUCTURE_TAGS.has(p.openElements.currentTagId)) {\n    p.pendingCharacterTokens.length = 0;\n    p.hasNonWhitespacePendingCharacterToken = false;\n    p.originalInsertionMode = p.insertionMode;\n    p.insertionMode = InsertionMode.IN_TABLE_TEXT;\n    switch (token.type) {\n      case TokenType.CHARACTER:\n        {\n          characterInTableText(p, token);\n          break;\n        }\n      case TokenType.WHITESPACE_CHARACTER:\n        {\n          whitespaceCharacterInTableText(p, token);\n          break;\n        }\n      // Ignore null\n    }\n  } else {\n    tokenInTable(p, token);\n  }\n}\nfunction captionStartTagInTable(p, token) {\n  p.openElements.clearBackToTableContext();\n  p.activeFormattingElements.insertMarker();\n  p._insertElement(token, NS.HTML);\n  p.insertionMode = InsertionMode.IN_CAPTION;\n}\nfunction colgroupStartTagInTable(p, token) {\n  p.openElements.clearBackToTableContext();\n  p._insertElement(token, NS.HTML);\n  p.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n}\nfunction colStartTagInTable(p, token) {\n  p.openElements.clearBackToTableContext();\n  p._insertFakeElement(TN.COLGROUP, $.COLGROUP);\n  p.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n  startTagInColumnGroup(p, token);\n}\nfunction tbodyStartTagInTable(p, token) {\n  p.openElements.clearBackToTableContext();\n  p._insertElement(token, NS.HTML);\n  p.insertionMode = InsertionMode.IN_TABLE_BODY;\n}\nfunction tdStartTagInTable(p, token) {\n  p.openElements.clearBackToTableContext();\n  p._insertFakeElement(TN.TBODY, $.TBODY);\n  p.insertionMode = InsertionMode.IN_TABLE_BODY;\n  startTagInTableBody(p, token);\n}\nfunction tableStartTagInTable(p, token) {\n  if (p.openElements.hasInTableScope($.TABLE)) {\n    p.openElements.popUntilTagNamePopped($.TABLE);\n    p._resetInsertionMode();\n    p._processStartTag(token);\n  }\n}\nfunction inputStartTagInTable(p, token) {\n  if (isHiddenInput(token)) {\n    p._appendElement(token, NS.HTML);\n  } else {\n    tokenInTable(p, token);\n  }\n  token.ackSelfClosing = true;\n}\nfunction formStartTagInTable(p, token) {\n  if (!p.formElement && p.openElements.tmplCount === 0) {\n    p._insertElement(token, NS.HTML);\n    p.formElement = p.openElements.current;\n    p.openElements.pop();\n  }\n}\nfunction startTagInTable(p, token) {\n  switch (token.tagID) {\n    case $.TD:\n    case $.TH:\n    case $.TR:\n      {\n        tdStartTagInTable(p, token);\n        break;\n      }\n    case $.STYLE:\n    case $.SCRIPT:\n    case $.TEMPLATE:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    case $.COL:\n      {\n        colStartTagInTable(p, token);\n        break;\n      }\n    case $.FORM:\n      {\n        formStartTagInTable(p, token);\n        break;\n      }\n    case $.TABLE:\n      {\n        tableStartTagInTable(p, token);\n        break;\n      }\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n      {\n        tbodyStartTagInTable(p, token);\n        break;\n      }\n    case $.INPUT:\n      {\n        inputStartTagInTable(p, token);\n        break;\n      }\n    case $.CAPTION:\n      {\n        captionStartTagInTable(p, token);\n        break;\n      }\n    case $.COLGROUP:\n      {\n        colgroupStartTagInTable(p, token);\n        break;\n      }\n    default:\n      {\n        tokenInTable(p, token);\n      }\n  }\n}\nfunction endTagInTable(p, token) {\n  switch (token.tagID) {\n    case $.TABLE:\n      {\n        if (p.openElements.hasInTableScope($.TABLE)) {\n          p.openElements.popUntilTagNamePopped($.TABLE);\n          p._resetInsertionMode();\n        }\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        templateEndTagInHead(p, token);\n        break;\n      }\n    case $.BODY:\n    case $.CAPTION:\n    case $.COL:\n    case $.COLGROUP:\n    case $.HTML:\n    case $.TBODY:\n    case $.TD:\n    case $.TFOOT:\n    case $.TH:\n    case $.THEAD:\n    case $.TR:\n      {\n        // Ignore token\n        break;\n      }\n    default:\n      {\n        tokenInTable(p, token);\n      }\n  }\n}\nfunction tokenInTable(p, token) {\n  const savedFosterParentingState = p.fosterParentingEnabled;\n  p.fosterParentingEnabled = true;\n  // Process token in `In Body` mode\n  modeInBody(p, token);\n  p.fosterParentingEnabled = savedFosterParentingState;\n}\n// The \"in table text\" insertion mode\n//------------------------------------------------------------------\nfunction whitespaceCharacterInTableText(p, token) {\n  p.pendingCharacterTokens.push(token);\n}\nfunction characterInTableText(p, token) {\n  p.pendingCharacterTokens.push(token);\n  p.hasNonWhitespacePendingCharacterToken = true;\n}\nfunction tokenInTableText(p, token) {\n  let i = 0;\n  if (p.hasNonWhitespacePendingCharacterToken) {\n    for (; i < p.pendingCharacterTokens.length; i++) {\n      tokenInTable(p, p.pendingCharacterTokens[i]);\n    }\n  } else {\n    for (; i < p.pendingCharacterTokens.length; i++) {\n      p._insertCharacters(p.pendingCharacterTokens[i]);\n    }\n  }\n  p.insertionMode = p.originalInsertionMode;\n  p._processToken(token);\n}\n// The \"in caption\" insertion mode\n//------------------------------------------------------------------\nconst TABLE_VOID_ELEMENTS = new Set([$.CAPTION, $.COL, $.COLGROUP, $.TBODY, $.TD, $.TFOOT, $.TH, $.THEAD, $.TR]);\nfunction startTagInCaption(p, token) {\n  const tn = token.tagID;\n  if (TABLE_VOID_ELEMENTS.has(tn)) {\n    if (p.openElements.hasInTableScope($.CAPTION)) {\n      p.openElements.generateImpliedEndTags();\n      p.openElements.popUntilTagNamePopped($.CAPTION);\n      p.activeFormattingElements.clearToLastMarker();\n      p.insertionMode = InsertionMode.IN_TABLE;\n      startTagInTable(p, token);\n    }\n  } else {\n    startTagInBody(p, token);\n  }\n}\nfunction endTagInCaption(p, token) {\n  const tn = token.tagID;\n  switch (tn) {\n    case $.CAPTION:\n    case $.TABLE:\n      {\n        if (p.openElements.hasInTableScope($.CAPTION)) {\n          p.openElements.generateImpliedEndTags();\n          p.openElements.popUntilTagNamePopped($.CAPTION);\n          p.activeFormattingElements.clearToLastMarker();\n          p.insertionMode = InsertionMode.IN_TABLE;\n          if (tn === $.TABLE) {\n            endTagInTable(p, token);\n          }\n        }\n        break;\n      }\n    case $.BODY:\n    case $.COL:\n    case $.COLGROUP:\n    case $.HTML:\n    case $.TBODY:\n    case $.TD:\n    case $.TFOOT:\n    case $.TH:\n    case $.THEAD:\n    case $.TR:\n      {\n        // Ignore token\n        break;\n      }\n    default:\n      {\n        endTagInBody(p, token);\n      }\n  }\n}\n// The \"in column group\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInColumnGroup(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.COL:\n      {\n        p._appendElement(token, NS.HTML);\n        token.ackSelfClosing = true;\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    default:\n      {\n        tokenInColumnGroup(p, token);\n      }\n  }\n}\nfunction endTagInColumnGroup(p, token) {\n  switch (token.tagID) {\n    case $.COLGROUP:\n      {\n        if (p.openElements.currentTagId === $.COLGROUP) {\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE;\n        }\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        templateEndTagInHead(p, token);\n        break;\n      }\n    case $.COL:\n      {\n        // Ignore token\n        break;\n      }\n    default:\n      {\n        tokenInColumnGroup(p, token);\n      }\n  }\n}\nfunction tokenInColumnGroup(p, token) {\n  if (p.openElements.currentTagId === $.COLGROUP) {\n    p.openElements.pop();\n    p.insertionMode = InsertionMode.IN_TABLE;\n    p._processToken(token);\n  }\n}\n// The \"in table body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInTableBody(p, token) {\n  switch (token.tagID) {\n    case $.TR:\n      {\n        p.openElements.clearBackToTableBodyContext();\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = InsertionMode.IN_ROW;\n        break;\n      }\n    case $.TH:\n    case $.TD:\n      {\n        p.openElements.clearBackToTableBodyContext();\n        p._insertFakeElement(TN.TR, $.TR);\n        p.insertionMode = InsertionMode.IN_ROW;\n        startTagInRow(p, token);\n        break;\n      }\n    case $.CAPTION:\n    case $.COL:\n    case $.COLGROUP:\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n      {\n        if (p.openElements.hasTableBodyContextInTableScope()) {\n          p.openElements.clearBackToTableBodyContext();\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE;\n          startTagInTable(p, token);\n        }\n        break;\n      }\n    default:\n      {\n        startTagInTable(p, token);\n      }\n  }\n}\nfunction endTagInTableBody(p, token) {\n  const tn = token.tagID;\n  switch (token.tagID) {\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n      {\n        if (p.openElements.hasInTableScope(tn)) {\n          p.openElements.clearBackToTableBodyContext();\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE;\n        }\n        break;\n      }\n    case $.TABLE:\n      {\n        if (p.openElements.hasTableBodyContextInTableScope()) {\n          p.openElements.clearBackToTableBodyContext();\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE;\n          endTagInTable(p, token);\n        }\n        break;\n      }\n    case $.BODY:\n    case $.CAPTION:\n    case $.COL:\n    case $.COLGROUP:\n    case $.HTML:\n    case $.TD:\n    case $.TH:\n    case $.TR:\n      {\n        // Ignore token\n        break;\n      }\n    default:\n      {\n        endTagInTable(p, token);\n      }\n  }\n}\n// The \"in row\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInRow(p, token) {\n  switch (token.tagID) {\n    case $.TH:\n    case $.TD:\n      {\n        p.openElements.clearBackToTableRowContext();\n        p._insertElement(token, NS.HTML);\n        p.insertionMode = InsertionMode.IN_CELL;\n        p.activeFormattingElements.insertMarker();\n        break;\n      }\n    case $.CAPTION:\n    case $.COL:\n    case $.COLGROUP:\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n    case $.TR:\n      {\n        if (p.openElements.hasInTableScope($.TR)) {\n          p.openElements.clearBackToTableRowContext();\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE_BODY;\n          startTagInTableBody(p, token);\n        }\n        break;\n      }\n    default:\n      {\n        startTagInTable(p, token);\n      }\n  }\n}\nfunction endTagInRow(p, token) {\n  switch (token.tagID) {\n    case $.TR:\n      {\n        if (p.openElements.hasInTableScope($.TR)) {\n          p.openElements.clearBackToTableRowContext();\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE_BODY;\n        }\n        break;\n      }\n    case $.TABLE:\n      {\n        if (p.openElements.hasInTableScope($.TR)) {\n          p.openElements.clearBackToTableRowContext();\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE_BODY;\n          endTagInTableBody(p, token);\n        }\n        break;\n      }\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n      {\n        if (p.openElements.hasInTableScope(token.tagID) || p.openElements.hasInTableScope($.TR)) {\n          p.openElements.clearBackToTableRowContext();\n          p.openElements.pop();\n          p.insertionMode = InsertionMode.IN_TABLE_BODY;\n          endTagInTableBody(p, token);\n        }\n        break;\n      }\n    case $.BODY:\n    case $.CAPTION:\n    case $.COL:\n    case $.COLGROUP:\n    case $.HTML:\n    case $.TD:\n    case $.TH:\n      {\n        // Ignore end tag\n        break;\n      }\n    default:\n      {\n        endTagInTable(p, token);\n      }\n  }\n}\n// The \"in cell\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInCell(p, token) {\n  const tn = token.tagID;\n  if (TABLE_VOID_ELEMENTS.has(tn)) {\n    if (p.openElements.hasInTableScope($.TD) || p.openElements.hasInTableScope($.TH)) {\n      p._closeTableCell();\n      startTagInRow(p, token);\n    }\n  } else {\n    startTagInBody(p, token);\n  }\n}\nfunction endTagInCell(p, token) {\n  const tn = token.tagID;\n  switch (tn) {\n    case $.TD:\n    case $.TH:\n      {\n        if (p.openElements.hasInTableScope(tn)) {\n          p.openElements.generateImpliedEndTags();\n          p.openElements.popUntilTagNamePopped(tn);\n          p.activeFormattingElements.clearToLastMarker();\n          p.insertionMode = InsertionMode.IN_ROW;\n        }\n        break;\n      }\n    case $.TABLE:\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n    case $.TR:\n      {\n        if (p.openElements.hasInTableScope(tn)) {\n          p._closeTableCell();\n          endTagInRow(p, token);\n        }\n        break;\n      }\n    case $.BODY:\n    case $.CAPTION:\n    case $.COL:\n    case $.COLGROUP:\n    case $.HTML:\n      {\n        // Ignore token\n        break;\n      }\n    default:\n      {\n        endTagInBody(p, token);\n      }\n  }\n}\n// The \"in select\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInSelect(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.OPTION:\n      {\n        if (p.openElements.currentTagId === $.OPTION) {\n          p.openElements.pop();\n        }\n        p._insertElement(token, NS.HTML);\n        break;\n      }\n    case $.OPTGROUP:\n      {\n        if (p.openElements.currentTagId === $.OPTION) {\n          p.openElements.pop();\n        }\n        if (p.openElements.currentTagId === $.OPTGROUP) {\n          p.openElements.pop();\n        }\n        p._insertElement(token, NS.HTML);\n        break;\n      }\n    case $.INPUT:\n    case $.KEYGEN:\n    case $.TEXTAREA:\n    case $.SELECT:\n      {\n        if (p.openElements.hasInSelectScope($.SELECT)) {\n          p.openElements.popUntilTagNamePopped($.SELECT);\n          p._resetInsertionMode();\n          if (token.tagID !== $.SELECT) {\n            p._processStartTag(token);\n          }\n        }\n        break;\n      }\n    case $.SCRIPT:\n    case $.TEMPLATE:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    default:\n    // Do nothing\n  }\n}\n\nfunction endTagInSelect(p, token) {\n  switch (token.tagID) {\n    case $.OPTGROUP:\n      {\n        if (p.openElements.stackTop > 0 && p.openElements.currentTagId === $.OPTION && p.openElements.tagIDs[p.openElements.stackTop - 1] === $.OPTGROUP) {\n          p.openElements.pop();\n        }\n        if (p.openElements.currentTagId === $.OPTGROUP) {\n          p.openElements.pop();\n        }\n        break;\n      }\n    case $.OPTION:\n      {\n        if (p.openElements.currentTagId === $.OPTION) {\n          p.openElements.pop();\n        }\n        break;\n      }\n    case $.SELECT:\n      {\n        if (p.openElements.hasInSelectScope($.SELECT)) {\n          p.openElements.popUntilTagNamePopped($.SELECT);\n          p._resetInsertionMode();\n        }\n        break;\n      }\n    case $.TEMPLATE:\n      {\n        templateEndTagInHead(p, token);\n        break;\n      }\n    default:\n    // Do nothing\n  }\n}\n// The \"in select in table\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInSelectInTable(p, token) {\n  const tn = token.tagID;\n  if (tn === $.CAPTION || tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR || tn === $.TD || tn === $.TH) {\n    p.openElements.popUntilTagNamePopped($.SELECT);\n    p._resetInsertionMode();\n    p._processStartTag(token);\n  } else {\n    startTagInSelect(p, token);\n  }\n}\nfunction endTagInSelectInTable(p, token) {\n  const tn = token.tagID;\n  if (tn === $.CAPTION || tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR || tn === $.TD || tn === $.TH) {\n    if (p.openElements.hasInTableScope(tn)) {\n      p.openElements.popUntilTagNamePopped($.SELECT);\n      p._resetInsertionMode();\n      p.onEndTag(token);\n    }\n  } else {\n    endTagInSelect(p, token);\n  }\n}\n// The \"in template\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInTemplate(p, token) {\n  switch (token.tagID) {\n    // First, handle tags that can start without a mode change\n    case $.BASE:\n    case $.BASEFONT:\n    case $.BGSOUND:\n    case $.LINK:\n    case $.META:\n    case $.NOFRAMES:\n    case $.SCRIPT:\n    case $.STYLE:\n    case $.TEMPLATE:\n    case $.TITLE:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    // Re-process the token in the appropriate mode\n    case $.CAPTION:\n    case $.COLGROUP:\n    case $.TBODY:\n    case $.TFOOT:\n    case $.THEAD:\n      {\n        p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE;\n        p.insertionMode = InsertionMode.IN_TABLE;\n        startTagInTable(p, token);\n        break;\n      }\n    case $.COL:\n      {\n        p.tmplInsertionModeStack[0] = InsertionMode.IN_COLUMN_GROUP;\n        p.insertionMode = InsertionMode.IN_COLUMN_GROUP;\n        startTagInColumnGroup(p, token);\n        break;\n      }\n    case $.TR:\n      {\n        p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE_BODY;\n        p.insertionMode = InsertionMode.IN_TABLE_BODY;\n        startTagInTableBody(p, token);\n        break;\n      }\n    case $.TD:\n    case $.TH:\n      {\n        p.tmplInsertionModeStack[0] = InsertionMode.IN_ROW;\n        p.insertionMode = InsertionMode.IN_ROW;\n        startTagInRow(p, token);\n        break;\n      }\n    default:\n      {\n        p.tmplInsertionModeStack[0] = InsertionMode.IN_BODY;\n        p.insertionMode = InsertionMode.IN_BODY;\n        startTagInBody(p, token);\n      }\n  }\n}\nfunction endTagInTemplate(p, token) {\n  if (token.tagID === $.TEMPLATE) {\n    templateEndTagInHead(p, token);\n  }\n}\nfunction eofInTemplate(p, token) {\n  if (p.openElements.tmplCount > 0) {\n    p.openElements.popUntilTagNamePopped($.TEMPLATE);\n    p.activeFormattingElements.clearToLastMarker();\n    p.tmplInsertionModeStack.shift();\n    p._resetInsertionMode();\n    p.onEof(token);\n  } else {\n    stopParsing(p, token);\n  }\n}\n// The \"after body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterBody(p, token) {\n  if (token.tagID === $.HTML) {\n    startTagInBody(p, token);\n  } else {\n    tokenAfterBody(p, token);\n  }\n}\nfunction endTagAfterBody(p, token) {\n  var _a;\n  if (token.tagID === $.HTML) {\n    if (!p.fragmentContext) {\n      p.insertionMode = InsertionMode.AFTER_AFTER_BODY;\n    }\n    //NOTE: <html> is never popped from the stack, so we need to updated\n    //the end location explicitly.\n    if (p.options.sourceCodeLocationInfo && p.openElements.tagIDs[0] === $.HTML) {\n      p._setEndLocation(p.openElements.items[0], token);\n      // Update the body element, if it doesn't have an end tag\n      const bodyElement = p.openElements.items[1];\n      if (bodyElement && !((_a = p.treeAdapter.getNodeSourceCodeLocation(bodyElement)) === null || _a === void 0 ? void 0 : _a.endTag)) {\n        p._setEndLocation(bodyElement, token);\n      }\n    }\n  } else {\n    tokenAfterBody(p, token);\n  }\n}\nfunction tokenAfterBody(p, token) {\n  p.insertionMode = InsertionMode.IN_BODY;\n  modeInBody(p, token);\n}\n// The \"in frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagInFrameset(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.FRAMESET:\n      {\n        p._insertElement(token, NS.HTML);\n        break;\n      }\n    case $.FRAME:\n      {\n        p._appendElement(token, NS.HTML);\n        token.ackSelfClosing = true;\n        break;\n      }\n    case $.NOFRAMES:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    default:\n    // Do nothing\n  }\n}\n\nfunction endTagInFrameset(p, token) {\n  if (token.tagID === $.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {\n    p.openElements.pop();\n    if (!p.fragmentContext && p.openElements.currentTagId !== $.FRAMESET) {\n      p.insertionMode = InsertionMode.AFTER_FRAMESET;\n    }\n  }\n}\n// The \"after frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterFrameset(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.NOFRAMES:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    default:\n    // Do nothing\n  }\n}\n\nfunction endTagAfterFrameset(p, token) {\n  if (token.tagID === $.HTML) {\n    p.insertionMode = InsertionMode.AFTER_AFTER_FRAMESET;\n  }\n}\n// The \"after after body\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterAfterBody(p, token) {\n  if (token.tagID === $.HTML) {\n    startTagInBody(p, token);\n  } else {\n    tokenAfterAfterBody(p, token);\n  }\n}\nfunction tokenAfterAfterBody(p, token) {\n  p.insertionMode = InsertionMode.IN_BODY;\n  modeInBody(p, token);\n}\n// The \"after after frameset\" insertion mode\n//------------------------------------------------------------------\nfunction startTagAfterAfterFrameset(p, token) {\n  switch (token.tagID) {\n    case $.HTML:\n      {\n        startTagInBody(p, token);\n        break;\n      }\n    case $.NOFRAMES:\n      {\n        startTagInHead(p, token);\n        break;\n      }\n    default:\n    // Do nothing\n  }\n}\n// The rules for parsing tokens in foreign content\n//------------------------------------------------------------------\nfunction nullCharacterInForeignContent(p, token) {\n  token.chars = unicode.REPLACEMENT_CHARACTER;\n  p._insertCharacters(token);\n}\nfunction characterInForeignContent(p, token) {\n  p._insertCharacters(token);\n  p.framesetOk = false;\n}\nfunction popUntilHtmlOrIntegrationPoint(p) {\n  while (p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML && !p._isIntegrationPoint(p.openElements.currentTagId, p.openElements.current)) {\n    p.openElements.pop();\n  }\n}\nfunction startTagInForeignContent(p, token) {\n  if (foreignContent.causesExit(token)) {\n    popUntilHtmlOrIntegrationPoint(p);\n    p._startTagOutsideForeignContent(token);\n  } else {\n    const current = p._getAdjustedCurrentElement();\n    const currentNs = p.treeAdapter.getNamespaceURI(current);\n    if (currentNs === NS.MATHML) {\n      foreignContent.adjustTokenMathMLAttrs(token);\n    } else if (currentNs === NS.SVG) {\n      foreignContent.adjustTokenSVGTagName(token);\n      foreignContent.adjustTokenSVGAttrs(token);\n    }\n    foreignContent.adjustTokenXMLAttrs(token);\n    if (token.selfClosing) {\n      p._appendElement(token, currentNs);\n    } else {\n      p._insertElement(token, currentNs);\n    }\n    token.ackSelfClosing = true;\n  }\n}\nfunction endTagInForeignContent(p, token) {\n  if (token.tagID === $.P || token.tagID === $.BR) {\n    popUntilHtmlOrIntegrationPoint(p);\n    p._endTagOutsideForeignContent(token);\n    return;\n  }\n  for (let i = p.openElements.stackTop; i > 0; i--) {\n    const element = p.openElements.items[i];\n    if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {\n      p._endTagOutsideForeignContent(token);\n      break;\n    }\n    const tagName = p.treeAdapter.getTagName(element);\n    if (tagName.toLowerCase() === token.tagName) {\n      //NOTE: update the token tag name for `_setEndLocation`.\n      token.tagName = tagName;\n      p.openElements.shortenToLength(i);\n      break;\n    }\n  }\n}","export const xmlReplacer = /[\"&'<>$\\x80-\\uFFFF]/g;\nconst xmlCodeMap = new Map([[34, \"&quot;\"], [38, \"&amp;\"], [39, \"&apos;\"], [60, \"&lt;\"], [62, \"&gt;\"]]);\n// For compatibility with node < 4, we wrap `codePointAt`\nexport const getCodePoint =\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\nString.prototype.codePointAt != null ? (str, index) => str.codePointAt(index) :\n// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n(c, index) => (c.charCodeAt(index) & 0xfc00) === 0xd800 ? (c.charCodeAt(index) - 0xd800) * 0x400 + c.charCodeAt(index + 1) - 0xdc00 + 0x10000 : c.charCodeAt(index);\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using XML entities.\n *\n * If a character has no equivalent entity, a\n * numeric hexadecimal reference (eg. `&#xfc;`) will be used.\n */\nexport function encodeXML(str) {\n  let ret = \"\";\n  let lastIdx = 0;\n  let match;\n  while ((match = xmlReplacer.exec(str)) !== null) {\n    const i = match.index;\n    const char = str.charCodeAt(i);\n    const next = xmlCodeMap.get(char);\n    if (next !== undefined) {\n      ret += str.substring(lastIdx, i) + next;\n      lastIdx = i + 1;\n    } else {\n      ret += `${str.substring(lastIdx, i)}&#x${getCodePoint(str, i).toString(16)};`;\n      // Increase by 1 if we have a surrogate pair\n      lastIdx = xmlReplacer.lastIndex += Number((char & 0xfc00) === 0xd800);\n    }\n  }\n  return ret + str.substr(lastIdx);\n}\n/**\n * Encodes all non-ASCII characters, as well as characters not valid in XML\n * documents using numeric hexadecimal reference (eg. `&#xfc;`).\n *\n * Have a look at `escapeUTF8` if you want a more concise output at the expense\n * of reduced transportability.\n *\n * @param data String to escape.\n */\nexport const escape = encodeXML;\n/**\n * Creates a function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n *\n * @param regex Regular expression to match characters to escape.\n * @param map Map of characters to escape to their entities.\n *\n * @returns Function that escapes all characters matched by the given regular\n * expression using the given map of characters to escape to their entities.\n */\nfunction getEscaper(regex, map) {\n  return function escape(data) {\n    let match;\n    let lastIdx = 0;\n    let result = \"\";\n    while (match = regex.exec(data)) {\n      if (lastIdx !== match.index) {\n        result += data.substring(lastIdx, match.index);\n      }\n      // We know that this character will be in the map.\n      result += map.get(match[0].charCodeAt(0));\n      // Every match will be of length 1\n      lastIdx = match.index + 1;\n    }\n    return result + data.substring(lastIdx);\n  };\n}\n/**\n * Encodes all characters not valid in XML documents using XML entities.\n *\n * Note that the output will be character-set dependent.\n *\n * @param data String to escape.\n */\nexport const escapeUTF8 = getEscaper(/[&<>'\"]/g, xmlCodeMap);\n/**\n * Encodes all characters that have to be escaped in HTML attributes,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexport const escapeAttribute = getEscaper(/[\"&\\u00A0]/g, new Map([[34, \"&quot;\"], [38, \"&amp;\"], [160, \"&nbsp;\"]]));\n/**\n * Encodes all characters that have to be escaped in HTML text,\n * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.\n *\n * @param data String to escape.\n */\nexport const escapeText = getEscaper(/[&<>\\u00A0]/g, new Map([[38, \"&amp;\"], [60, \"&lt;\"], [62, \"&gt;\"], [160, \"&nbsp;\"]]));","import { TAG_NAMES as $, NS, hasUnescapedText } from '../common/html.js';\nimport { escapeText, escapeAttribute } from 'entities/lib/escape.js';\nimport { defaultTreeAdapter } from '../tree-adapters/default.js';\n// Sets\nconst VOID_ELEMENTS = new Set([$.AREA, $.BASE, $.BASEFONT, $.BGSOUND, $.BR, $.COL, $.EMBED, $.FRAME, $.HR, $.IMG, $.INPUT, $.KEYGEN, $.LINK, $.META, $.PARAM, $.SOURCE, $.TRACK, $.WBR]);\nfunction isVoidElement(node, options) {\n  return options.treeAdapter.isElementNode(node) && options.treeAdapter.getNamespaceURI(node) === NS.HTML && VOID_ELEMENTS.has(options.treeAdapter.getTagName(node));\n}\nconst defaultOpts = {\n  treeAdapter: defaultTreeAdapter,\n  scriptingEnabled: true\n};\n/**\n * Serializes an AST node to an HTML string.\n *\n * @example\n *\n * ```js\n * const parse5 = require('parse5');\n *\n * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');\n *\n * // Serializes a document.\n * const html = parse5.serialize(document);\n *\n * // Serializes the <html> element content.\n * const str = parse5.serialize(document.childNodes[1]);\n *\n * console.log(str); //> '<head></head><body>Hi there!</body>'\n * ```\n *\n * @param node Node to serialize.\n * @param options Serialization options.\n */\nexport function serialize(node, options) {\n  const opts = {\n    ...defaultOpts,\n    ...options\n  };\n  if (isVoidElement(node, opts)) {\n    return '';\n  }\n  return serializeChildNodes(node, opts);\n}\n/**\n * Serializes an AST element node to an HTML string, including the element node.\n *\n * @example\n *\n * ```js\n * const parse5 = require('parse5');\n *\n * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');\n *\n * // Serializes the <div> element.\n * const html = parse5.serializeOuter(document.childNodes[0]);\n *\n * console.log(str); //> '<div>Hello, <b>world</b>!</div>'\n * ```\n *\n * @param node Node to serialize.\n * @param options Serialization options.\n */\nexport function serializeOuter(node, options) {\n  const opts = {\n    ...defaultOpts,\n    ...options\n  };\n  return serializeNode(node, opts);\n}\nfunction serializeChildNodes(parentNode, options) {\n  let html = '';\n  // Get container of the child nodes\n  const container = options.treeAdapter.isElementNode(parentNode) && options.treeAdapter.getTagName(parentNode) === $.TEMPLATE && options.treeAdapter.getNamespaceURI(parentNode) === NS.HTML ? options.treeAdapter.getTemplateContent(parentNode) : parentNode;\n  const childNodes = options.treeAdapter.getChildNodes(container);\n  if (childNodes) {\n    for (const currentNode of childNodes) {\n      html += serializeNode(currentNode, options);\n    }\n  }\n  return html;\n}\nfunction serializeNode(node, options) {\n  if (options.treeAdapter.isElementNode(node)) {\n    return serializeElement(node, options);\n  }\n  if (options.treeAdapter.isTextNode(node)) {\n    return serializeTextNode(node, options);\n  }\n  if (options.treeAdapter.isCommentNode(node)) {\n    return serializeCommentNode(node, options);\n  }\n  if (options.treeAdapter.isDocumentTypeNode(node)) {\n    return serializeDocumentTypeNode(node, options);\n  }\n  // Return an empty string for unknown nodes\n  return '';\n}\nfunction serializeElement(node, options) {\n  const tn = options.treeAdapter.getTagName(node);\n  return `<${tn}${serializeAttributes(node, options)}>${isVoidElement(node, options) ? '' : `${serializeChildNodes(node, options)}</${tn}>`}`;\n}\nfunction serializeAttributes(node, _ref) {\n  let {\n    treeAdapter\n  } = _ref;\n  let html = '';\n  for (const attr of treeAdapter.getAttrList(node)) {\n    html += ' ';\n    if (!attr.namespace) {\n      html += attr.name;\n    } else switch (attr.namespace) {\n      case NS.XML:\n        {\n          html += `xml:${attr.name}`;\n          break;\n        }\n      case NS.XMLNS:\n        {\n          if (attr.name !== 'xmlns') {\n            html += 'xmlns:';\n          }\n          html += attr.name;\n          break;\n        }\n      case NS.XLINK:\n        {\n          html += `xlink:${attr.name}`;\n          break;\n        }\n      default:\n        {\n          html += `${attr.prefix}:${attr.name}`;\n        }\n    }\n    html += `=\"${escapeAttribute(attr.value)}\"`;\n  }\n  return html;\n}\nfunction serializeTextNode(node, options) {\n  const {\n    treeAdapter\n  } = options;\n  const content = treeAdapter.getTextNodeContent(node);\n  const parent = treeAdapter.getParentNode(node);\n  const parentTn = parent && treeAdapter.isElementNode(parent) && treeAdapter.getTagName(parent);\n  return parentTn && treeAdapter.getNamespaceURI(parent) === NS.HTML && hasUnescapedText(parentTn, options.scriptingEnabled) ? content : escapeText(content);\n}\nfunction serializeCommentNode(node, _ref2) {\n  let {\n    treeAdapter\n  } = _ref2;\n  return `<!--${treeAdapter.getCommentNodeContent(node)}-->`;\n}\nfunction serializeDocumentTypeNode(node, _ref3) {\n  let {\n    treeAdapter\n  } = _ref3;\n  return `<!DOCTYPE ${treeAdapter.getDocumentTypeNodeName(node)}>`;\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Get the ending point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointEnd = point('end');\n\n/**\n * Get the starting point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointStart = point('start');\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'end' | 'start'} type\n *   Side.\n * @returns\n *   Getter.\n */\nfunction point(type) {\n  return point;\n\n  /**\n   * Get the point info of `node` at a bound side.\n   *\n   * @param {Node | NodeLike | null | undefined} [node]\n   * @returns {Point | undefined}\n   */\n  function point(node) {\n    const point = node && node.position && node.position[type] || {};\n    if (typeof point.line === 'number' && point.line > 0 && typeof point.column === 'number' && point.column > 0) {\n      return {\n        line: point.line,\n        column: point.column,\n        offset: typeof point.offset === 'number' && point.offset > -1 ? point.offset : undefined\n      };\n    }\n  }\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {Node | NodeLike | null | undefined} [node]\n *   Node.\n * @returns {Position | undefined}\n *   Position.\n */\nexport function position(node) {\n  const start = pointStart(node);\n  const end = pointEnd(node);\n  if (start && end) {\n    return {\n      start,\n      end\n    };\n  }\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n// Note: overloads in JSDoc can’t yet use different `@template`s.\n/**\n * @type {(\n *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n *   ((node?: null | undefined) => false) &\n *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n * )}\n */\n\n/**\n * @param {unknown} [node]\n * @param {Test} [test]\n * @param {number | null | undefined} [index]\n * @param {Parent | null | undefined} [parent]\n * @param {unknown} [context]\n * @returns {boolean}\n */\n// eslint-disable-next-line max-params\nfunction (node, test, index, parent, context) {\n  const check = convert(test);\n  if (index !== undefined && index !== null && (typeof index !== 'number' || index < 0 || index === Number.POSITIVE_INFINITY)) {\n    throw new Error('Expected positive finite index');\n  }\n  if (parent !== undefined && parent !== null && (!is(parent) || !parent.children)) {\n    throw new Error('Expected parent node');\n  }\n  if ((parent === undefined || parent === null) !== (index === undefined || index === null)) {\n    throw new Error('Expected both parent and index');\n  }\n  return looksLikeANode(node) ? check.call(context, node, index, parent) : false;\n};\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n// Note: overloads in JSDoc can’t yet use different `@template`s.\n/**\n * @type {(\n *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n *   ((test?: Test) => Check)\n * )}\n */\n\n/**\n * @param {Test} [test]\n * @returns {Check}\n */\nfunction (test) {\n  if (test === null || test === undefined) {\n    return ok;\n  }\n  if (typeof test === 'function') {\n    return castFactory(test);\n  }\n  if (typeof test === 'object') {\n    return Array.isArray(test) ? anyFactory(test) : propsFactory(test);\n  }\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n  throw new Error('Expected function, string, or object as test');\n};\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = [];\n  let index = -1;\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n  return castFactory(any);\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any() {\n    let index = -1;\n    for (var _len = arguments.length, parameters = new Array(_len), _key = 0; _key < _len; _key++) {\n      parameters[_key] = arguments[_key];\n    }\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true;\n    }\n    return false;\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propsFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */check;\n  return castFactory(all);\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */\n    /** @type {unknown} */node;\n\n    /** @type {string} */\n    let key;\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false;\n    }\n    return true;\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type);\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check;\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check;\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(looksLikeANode(value) && testFunction.call(this, value, typeof index === 'number' ? index : undefined, parent || undefined));\n  }\n}\nfunction ok() {\n  return true;\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value;\n}","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport { convert } from 'unist-util-is';\nimport { color } from 'unist-util-visit-parents/do-not-use-color';\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = [];\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true;\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false;\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip';\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check;\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test;\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test;\n  }\n  const is = convert(check);\n  const step = reverse ? -1 : 1;\n  factory(tree, undefined, [])();\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */\n    node && typeof node === 'object' ? node : {};\n    if (typeof value.type === 'string') {\n      const name =\n      // `hast`\n      typeof value.tagName === 'string' ? value.tagName :\n      // `xast`\n      typeof value.name === 'string' ? value.name : undefined;\n      Object.defineProperty(visit, 'name', {\n        value: 'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      });\n    }\n    return visit;\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty;\n      /** @type {Readonly<ActionTuple>} */\n      let subresult;\n      /** @type {number} */\n      let offset;\n      /** @type {Array<UnistParent>} */\n      let grandparents;\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents));\n        if (result[0] === EXIT) {\n          return result;\n        }\n      }\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */node;\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step;\n          grandparents = parents.concat(nodeAsParent);\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset];\n            subresult = factory(child, offset, grandparents)();\n            if (subresult[0] === EXIT) {\n              return subresult;\n            }\n            offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n          }\n        }\n      }\n      return result;\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value;\n  }\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n  return value === null || value === undefined ? empty : [value];\n}","/**\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Doctype} Doctype\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').RootContent} RootContent\n * @typedef {import('hast').Text} Text\n *\n * @typedef {import('mdast-util-to-hast').Raw} Raw\n *\n * @typedef {import('parse5').DefaultTreeAdapterMap} DefaultTreeAdapterMap\n * @typedef {import('parse5').ParserOptions<DefaultTreeAdapterMap>} ParserOptions\n * @typedef {import('parse5').Token.CharacterToken} CharacterToken\n * @typedef {import('parse5').Token.CommentToken} CommentToken\n * @typedef {import('parse5').Token.DoctypeToken} DoctypeToken\n * @typedef {import('parse5').Token.Location} Location\n * @typedef {import('parse5').Token.TagToken} TagToken\n *\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('vfile').VFile} VFile\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {Array<Nodes['type']> | null | undefined} [passThrough]\n *   List of custom hast node types to pass through (as in, keep) (optional).\n *\n *   If the passed through nodes have children, those children are expected to\n *   be hast again and will be handled.\n *\n * @typedef State\n *   Info passed around about the current state.\n * @property {(node: Nodes) => undefined} handle\n *   Add a hast node to the parser.\n * @property {Options} options\n *   User configuration.\n * @property {Parser<DefaultTreeAdapterMap>} parser\n *   Current parser.\n * @property {boolean} stitches\n *   Whether there are stitches.\n *\n * @typedef {{type: 'comment', value: {stitch: Nodes}}} Stitch\n *   Custom comment-like value we pass through parse5, which contains a\n *   replacement node that we’ll swap back in afterwards.\n */\n\nimport structuredClone from '@ungap/structured-clone';\nimport { fromParse5 } from 'hast-util-from-parse5';\nimport { toParse5 } from 'hast-util-to-parse5';\nimport { htmlVoidElements } from 'html-void-elements';\nimport { Parser, Token, TokenizerMode, html } from 'parse5';\nimport { pointEnd, pointStart } from 'unist-util-position';\nimport { visit } from 'unist-util-visit';\nimport { webNamespaces } from 'web-namespaces';\nimport { zwitch } from 'zwitch';\n\n// Node types associated with MDX.\n// <https://github.com/mdx-js/mdx/blob/8a56312/packages/mdx/lib/node-types.js>\nconst knownMdxNames = new Set(['mdxFlowExpression', 'mdxJsxFlowElement', 'mdxJsxTextElement', 'mdxTextExpression', 'mdxjsEsm']);\n\n/** @type {ParserOptions} */\nconst parseOptions = {\n  sourceCodeLocationInfo: true,\n  scriptingEnabled: false\n};\n\n/**\n * Pass a hast tree through an HTML parser, which will fix nesting, and turn\n * raw nodes into actual nodes.\n *\n * @param {Nodes} tree\n *   Original hast tree to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {Nodes}\n *   Parsed again tree.\n */\nexport function raw(tree, options) {\n  const document = documentMode(tree);\n  /** @type {(node: Nodes, state: State) => undefined} */\n  const one = zwitch('type', {\n    handlers: {\n      root,\n      element,\n      text,\n      comment,\n      doctype,\n      raw: handleRaw\n    },\n    unknown\n  });\n\n  /** @type {State} */\n  const state = {\n    parser: document ? new Parser(parseOptions) : Parser.getFragmentParser(undefined, parseOptions),\n    handle(node) {\n      one(node, state);\n    },\n    stitches: false,\n    options: options || {}\n  };\n  one(tree, state);\n  resetTokenizer(state, pointStart());\n  const p5 = document ? state.parser.document : state.parser.getFragment();\n  const result = fromParse5(p5, {\n    // To do: support `space`?\n    file: state.options.file\n  });\n  if (state.stitches) {\n    visit(result, 'comment', function (node, index, parent) {\n      const stitch = /** @type {Stitch} */ /** @type {unknown} */node;\n      if (stitch.value.stitch && parent && index !== undefined) {\n        /** @type {Array<RootContent>} */\n        const siblings = parent.children;\n        // @ts-expect-error: assume the stitch is allowed.\n        siblings[index] = stitch.value.stitch;\n        return index;\n      }\n    });\n  }\n\n  // Unpack if possible and when not given a `root`.\n  if (result.type === 'root' && result.children.length === 1 && result.children[0].type === tree.type) {\n    return result.children[0];\n  }\n  return result;\n}\n\n/**\n * Transform all nodes\n *\n * @param {Array<RootContent>} nodes\n *   hast content.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction all(nodes, state) {\n  let index = -1;\n\n  /* istanbul ignore else - invalid nodes, see rehypejs/rehype-raw#7. */\n  if (nodes) {\n    while (++index < nodes.length) {\n      state.handle(nodes[index]);\n    }\n  }\n}\n\n/**\n * Transform a root.\n *\n * @param {Root} node\n *   hast root node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction root(node, state) {\n  all(node.children, state);\n}\n\n/**\n * Transform an element.\n *\n * @param {Element} node\n *   hast element node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction element(node, state) {\n  startTag(node, state);\n  all(node.children, state);\n  endTag(node, state);\n}\n\n/**\n * Transform a text.\n *\n * @param {Text} node\n *   hast text node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction text(node, state) {\n  /** @type {CharacterToken} */\n  const token = {\n    type: Token.TokenType.CHARACTER,\n    chars: node.value,\n    location: createParse5Location(node)\n  };\n  resetTokenizer(state, pointStart(node));\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = token;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken);\n}\n\n/**\n * Transform a doctype.\n *\n * @param {Doctype} node\n *   hast doctype node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction doctype(node, state) {\n  /** @type {DoctypeToken} */\n  const token = {\n    type: Token.TokenType.DOCTYPE,\n    name: 'html',\n    forceQuirks: false,\n    publicId: '',\n    systemId: '',\n    location: createParse5Location(node)\n  };\n  resetTokenizer(state, pointStart(node));\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = token;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken);\n}\n\n/**\n * Transform a stitch.\n *\n * @param {Nodes} node\n *   unknown node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction stitch(node, state) {\n  // Mark that there are stitches, so we need to walk the tree and revert them.\n  state.stitches = true;\n\n  /** @type {Nodes} */\n  const clone = cloneWithoutChildren(node);\n\n  // Recurse, because to somewhat handle `[<x>]</x>` (where `[]` denotes the\n  // passed through node).\n  if ('children' in node && 'children' in clone) {\n    // Root in root out.\n    const fakeRoot = /** @type {Root} */\n    raw({\n      type: 'root',\n      children: node.children\n    }, state.options);\n    clone.children = fakeRoot.children;\n  }\n\n  // Hack: `value` is supposed to be a string, but as none of the tools\n  // (`parse5` or `hast-util-from-parse5`) looks at it, we can pass nodes\n  // through.\n  comment({\n    type: 'comment',\n    value: {\n      stitch: clone\n    }\n  }, state);\n}\n\n/**\n * Transform a comment (or stitch).\n *\n * @param {Comment | Stitch} node\n *   hast comment node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction comment(node, state) {\n  /** @type {string} */\n  // @ts-expect-error: we pass stitches through.\n  const data = node.value;\n\n  /** @type {CommentToken} */\n  const token = {\n    type: Token.TokenType.COMMENT,\n    data,\n    location: createParse5Location(node)\n  };\n  resetTokenizer(state, pointStart(node));\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = token;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken);\n}\n\n/**\n * Transform a raw node.\n *\n * @param {Raw} node\n *   hast raw node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction handleRaw(node, state) {\n  // Reset preprocessor:\n  // See: <https://github.com/inikulin/parse5/blob/6f7ca60/packages/parse5/lib/tokenizer/preprocessor.ts#L18-L31>.\n  state.parser.tokenizer.preprocessor.html = '';\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.pos = -1;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.lastGapPos = -2;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.gapStack = [];\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.skipNextNewLine = false;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.lastChunkWritten = false;\n  state.parser.tokenizer.preprocessor.endOfChunkHit = false;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.preprocessor.isEol = false;\n\n  // Now pass `node.value`.\n  setPoint(state, pointStart(node));\n  state.parser.tokenizer.write(node.value, false);\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer._runParsingLoop();\n\n  // Character references hang, so if we ended there, we need to flush\n  // those too.\n  // We reset the preprocessor as if the document ends here.\n  // Then one single call to the relevant state does the trick, parse5\n  // consumes the whole token.\n\n  // Note: `State` is not exposed by `parse5`, so these numbers are fragile.\n  // See: <https://github.com/inikulin/parse5/blob/46cba43/packages/parse5/lib/tokenizer/index.ts#L58>\n  // Note: a change to `parse5`, which breaks this, was merged but not released.\n  // Investigate when it is.\n  if (state.parser.tokenizer.state === 72 /* NAMED_CHARACTER_REFERENCE */ || state.parser.tokenizer.state === 78 /* NUMERIC_CHARACTER_REFERENCE_END */) {\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer.preprocessor.lastChunkWritten = true;\n    /** @type {number} */\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    const cp = state.parser.tokenizer._consume();\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer._callState(cp);\n  }\n}\n\n/**\n * Crash on an unknown node.\n *\n * @param {unknown} node_\n *   unknown node.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Never.\n */\nfunction unknown(node_, state) {\n  const node = /** @type {Nodes} */node_;\n  if (state.options.passThrough && state.options.passThrough.includes(node.type)) {\n    stitch(node, state);\n  } else {\n    let extra = '';\n    if (knownMdxNames.has(node.type)) {\n      extra = \". It looks like you are using MDX nodes with `hast-util-raw` (or `rehype-raw`). If you use this because you are using remark or rehype plugins that inject `'html'` nodes, then please raise an issue with that plugin, as its a bad and slow idea. If you use this because you are using markdown syntax, then you have to configure this utility (or plugin) to pass through these nodes (see `passThrough` in docs), but you can also migrate to use the MDX syntax\";\n    }\n    throw new Error('Cannot compile `' + node.type + '` node' + extra);\n  }\n}\n\n/**\n * Reset the tokenizer of a parser.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Point | undefined} point\n *   Point.\n * @returns {undefined}\n *   Nothing.\n */\nfunction resetTokenizer(state, point) {\n  setPoint(state, point);\n\n  // Process final characters if they’re still there after hibernating.\n  /** @type {CharacterToken} */\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  const token = state.parser.tokenizer.currentCharacterToken;\n  if (token && token.location) {\n    token.location.endLine = state.parser.tokenizer.preprocessor.line;\n    token.location.endCol = state.parser.tokenizer.preprocessor.col + 1;\n    token.location.endOffset = state.parser.tokenizer.preprocessor.offset + 1;\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.currentToken = token;\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser._processToken(state.parser.currentToken);\n  }\n\n  // Reset tokenizer:\n  // See: <https://github.com/inikulin/parse5/blob/6f7ca60/packages/parse5/lib/tokenizer/index.ts#L187-L223>.\n  // Especially putting it back in the `data` state is useful: some elements,\n  // like textareas and iframes, change the state.\n  // See GH-7.\n  // But also if broken HTML is in `raw`, and then a correct element is given.\n  // See GH-11.\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.paused = false;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.inLoop = false;\n\n  // Note: don’t reset `state`, `inForeignNode`, or `lastStartTagName`, we\n  // manually update those when needed.\n  state.parser.tokenizer.active = false;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.returnState = TokenizerMode.DATA;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.charRefCode = -1;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.consumedAfterSnapshot = -1;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentLocation = null;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentCharacterToken = null;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentToken = null;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.tokenizer.currentAttr = {\n    name: '',\n    value: ''\n  };\n}\n\n/**\n * Set current location.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Point | undefined} point\n *   Point.\n * @returns {undefined}\n *   Nothing.\n */\nfunction setPoint(state, point) {\n  if (point && point.offset !== undefined) {\n    /** @type {Location} */\n    const location = {\n      startLine: point.line,\n      startCol: point.column,\n      startOffset: point.offset,\n      endLine: -1,\n      endCol: -1,\n      endOffset: -1\n    };\n\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer.preprocessor.lineStartPos = -point.column + 1; // Looks weird, but ensures we get correct positional info.\n    state.parser.tokenizer.preprocessor.droppedBufferSize = point.offset;\n    state.parser.tokenizer.preprocessor.line = point.line;\n    // @ts-expect-error: private.\n    // type-coverage:ignore-next-line\n    state.parser.tokenizer.currentLocation = location;\n  }\n}\n\n/**\n * Emit a start tag.\n *\n * @param {Element} node\n *   Element.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction startTag(node, state) {\n  // Ignore tags if we’re in plain text.\n  if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return;\n  resetTokenizer(state, pointStart(node));\n  const current = state.parser.openElements.current;\n  let ns = 'namespaceURI' in current ? current.namespaceURI : webNamespaces.html;\n  if (ns === webNamespaces.html && node.tagName === 'svg') {\n    ns = webNamespaces.svg;\n  }\n  const result = toParse5(\n  // Shallow clone to not delve into `children`: we only need the attributes.\n  {\n    ...node,\n    children: []\n  }, {\n    space: ns === webNamespaces.svg ? 'svg' : 'html'\n  });\n  // Always element.\n  /* c8 ignore next */\n  const attrs = 'attrs' in result ? result.attrs : [];\n\n  /** @type {TagToken} */\n  const tag = {\n    type: Token.TokenType.START_TAG,\n    tagName: node.tagName,\n    tagID: html.getTagID(node.tagName),\n    // We always send start and end tags.\n    selfClosing: false,\n    ackSelfClosing: false,\n    attrs,\n    location: createParse5Location(node)\n  };\n\n  // The HTML parsing algorithm works by doing half of the state management in\n  // the tokenizer and half in the parser.\n  // We can’t use the tokenizer here, as we don’t have strings.\n  // So we act *as if* the tokenizer emits tokens:\n\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = tag;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken);\n\n  // …but then we still need a bunch of work that the tokenizer would normally\n  // do, such as:\n\n  // Set a tag name, similar to how the tokenizer would do it.\n  state.parser.tokenizer.lastStartTagName = node.tagName;\n\n  // `inForeignNode` is correctly set by the parser.\n}\n\n/**\n * Emit an end tag.\n *\n * @param {Element} node\n *   Element.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {undefined}\n *   Nothing.\n */\nfunction endTag(node, state) {\n  // Do not emit closing tags for HTML void elements.\n  if (!state.parser.tokenizer.inForeignNode && htmlVoidElements.includes(node.tagName)) {\n    return;\n  }\n\n  // Ignore tags if we’re in plain text.\n  if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return;\n  resetTokenizer(state, pointEnd(node));\n\n  /** @type {TagToken} */\n  const tag = {\n    type: Token.TokenType.END_TAG,\n    tagName: node.tagName,\n    tagID: html.getTagID(node.tagName),\n    selfClosing: false,\n    ackSelfClosing: false,\n    attrs: [],\n    location: createParse5Location(node)\n  };\n\n  // The HTML parsing algorithm works by doing half of the state management in\n  // the tokenizer and half in the parser.\n  // We can’t use the tokenizer here, as we don’t have strings.\n  // So we act *as if* the tokenizer emits tokens:\n\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser.currentToken = tag;\n  // @ts-expect-error: private.\n  // type-coverage:ignore-next-line\n  state.parser._processToken(state.parser.currentToken);\n\n  // …but then we still need a bunch of work that the tokenizer would normally\n  // do, such as:\n\n  // Switch back to the data state after alternative states that don’t accept\n  // tags:\n  if (\n  // Current element is closed.\n  tag.tagName === state.parser.tokenizer.lastStartTagName && (\n  // `<textarea>` and `<title>`\n  state.parser.tokenizer.state === TokenizerMode.RCDATA ||\n  // `<iframe>`, `<noembed>`, `<style>`, `<xmp>`\n  state.parser.tokenizer.state === TokenizerMode.RAWTEXT ||\n  // `<script>`\n  state.parser.tokenizer.state === TokenizerMode.SCRIPT_DATA)) {\n    state.parser.tokenizer.state = TokenizerMode.DATA;\n  }\n}\n\n/**\n * Check if `node` represents a whole document or a fragment.\n *\n * @param {Nodes} node\n *   hast node.\n * @returns {boolean}\n *   Whether this represents a whole document or a fragment.\n */\nfunction documentMode(node) {\n  const head = node.type === 'root' ? node.children[0] : node;\n  return Boolean(head && (head.type === 'doctype' || head.type === 'element' && head.tagName === 'html'));\n}\n\n/**\n * Get a `parse5` location from a node.\n *\n * @param {Nodes | Stitch} node\n *   hast node.\n * @returns {Location}\n *   `parse5` location.\n */\nfunction createParse5Location(node) {\n  const start = pointStart(node) || {\n    line: undefined,\n    column: undefined,\n    offset: undefined\n  };\n  const end = pointEnd(node) || {\n    line: undefined,\n    column: undefined,\n    offset: undefined\n  };\n\n  /** @type {Record<keyof Location, number | undefined>} */\n  const location = {\n    startLine: start.line,\n    startCol: start.column,\n    startOffset: start.offset,\n    endLine: end.line,\n    endCol: end.column,\n    endOffset: end.offset\n  };\n\n  // @ts-expect-error: unist point values can be `undefined` in hast, which\n  // `parse5` types don’t want.\n  return location;\n}\n\n/**\n * @template {Nodes} NodeType\n *   Node type.\n * @param {NodeType} node\n *   Node to clone.\n * @returns {NodeType}\n *   Cloned node, without children.\n */\nfunction cloneWithoutChildren(node) {\n  return 'children' in node ? structuredClone({\n    ...node,\n    children: []\n  }) : structuredClone(node);\n}","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport { visitParents } from 'unist-util-visit-parents';\nexport { CONTINUE, EXIT, SKIP } from 'unist-util-visit-parents';\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse;\n  /** @type {Test} */\n  let test;\n  /** @type {Visitor} */\n  let visitor;\n  if (typeof testOrVisitor === 'function' && typeof visitorOrReverse !== 'function') {\n    test = undefined;\n    visitor = testOrVisitor;\n    reverse = visitorOrReverse;\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor;\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse;\n    reverse = maybeReverse;\n  }\n  visitParents(tree, test, overload, reverse);\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1];\n    const index = parent ? parent.children.indexOf(node) : undefined;\n    return visitor(node, index, parent);\n  }\n}","/**\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-raw').Options} RawOptions\n * @typedef {import('vfile').VFile} VFile\n */\n\n/**\n * @typedef {Omit<RawOptions, 'file'>} Options\n *   Configuration.\n */\n\nimport { raw } from 'hast-util-raw';\n\n/**\n * Parse the tree (and raw nodes) again, keeping positional info okay.\n *\n * @param {Options | null | undefined}  [options]\n *   Configuration (optional).\n * @returns\n *   Transform.\n */\nexport default function rehypeRaw(options) {\n  /**\n   * @param {Root} tree\n   *   Tree.\n   * @param {VFile} file\n   *   File.\n   * @returns {Root}\n   *   New tree.\n   */\n  return function (tree, file) {\n    // Assume root in -> root out.\n    const result = /** @type {Root} */raw(tree, {\n      ...options,\n      file\n    });\n    return result;\n  };\n}","export default __webpack_public_path__ + \"static/demo-49f8e262a47eb7558929e7fa8938f3b6.jpg\";","import React from \"react\"\nimport ProfilePic from \"../assets/image/demo.jpg\"\nimport { Link } from \"gatsby\"\nimport moment from \"moment\"\nimport ReactMarkdown from \"react-markdown\"\nimport rehypeRaw from \"rehype-raw\"\n\n// const info = require(\"../assets/data/blogsContent.json\")\nfunction Card(props) {\n  return (\n    // <div style={{ display: \"inline-block\" }}>\n    <Link to={`/blogs/${props.url}`} style={{ display: \"inline-block\" }}>\n      <div className=\"border border-gray-300 p-1 rounded-lg blog-box sm:mx-4 my-3 sm:m-6 hover:shadow-xl relative \">\n        <div className=\"border-bottom bg-orange-light1 absolute top-full left-6 right-6 h-1.5 rounded-b-xl\"></div>\n        <div className=\"blog-img-container\">\n          <img src={props.img} className=\"w-full\" />\n        </div>\n        <div className=\"px-3 pt-4\">\n          <p className=\"text-md blue-dark1 font-semibold mt-4 box-title\">\n            {props.catgory}\n          </p>\n          <p className=\"text-md blue-dark1 font-semibold my-4 box-title\">\n            {props.title}\n          </p>\n          <p className=\"text text-sm box-text my-4\"> <ReactMarkdown rehypePlugins={[rehypeRaw]}>{props.description}</ReactMarkdown></p>\n        </div>\n        <div className=\"flex items-center my-3 px-3 text-sm\">\n          <img\n            src={props.author_thumbnail}\n            className=\"rounded-full h-12 w-12\"\n          />\n          <div className=\"flex flex-col sm:flex-row items-center\">\n            <p className=\"font-semibold mx-6\">{props.author_name}</p>\n            <p>{moment(props.published).format(\"DD MMM Y\")}</p>\n          </div>\n        </div>\n      </div>\n    </Link>\n    // </div>\n  )\n}\n\nexport default Card\n"],"names":["exports","hookCallback","some","hooks","apply","arguments","setHookCallback","callback","isArray","input","Array","Object","prototype","toString","call","isObject","hasOwnProp","a","b","hasOwnProperty","isObjectEmpty","obj","getOwnPropertyNames","length","k","isUndefined","isNumber","isDate","Date","map","arr","fn","i","res","arrLen","push","extend","valueOf","createUTC","format","locale","strict","createLocalOrUTC","utc","defaultParsingFlags","empty","unusedTokens","unusedInput","overflow","charsLeftOver","nullInput","invalidEra","invalidMonth","invalidFormat","userInvalidated","iso","parsedDateParts","era","meridiem","rfc2822","weekdayMismatch","getParsingFlags","m","_pf","isValid","_isValid","flags","parsedParts","isNowValid","isNaN","_d","getTime","invalidWeekday","_strict","undefined","bigHour","isFrozen","createInvalid","NaN","fun","t","this","len","momentProperties","updateInProgress","copyConfig","to","from","prop","val","momentPropertiesLen","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","Moment","config","updateOffset","isMoment","warn","msg","suppressDeprecationWarnings","console","deprecate","firstTime","deprecationHandler","arg","key","args","argLen","slice","join","Error","stack","keys","deprecations","deprecateSimple","name","isFunction","Function","set","_config","_dayOfMonthOrdinalParseLenient","RegExp","_dayOfMonthOrdinalParse","source","_ordinalParse","mergeConfigs","parentConfig","childConfig","Locale","defaultCalendar","sameDay","nextDay","nextWeek","lastDay","lastWeek","sameElse","calendar","mom","now","output","_calendar","zeroFill","number","targetLength","forceSign","absNumber","Math","abs","zerosToFill","pow","max","substr","formattingTokens","localFormattingTokens","formatFunctions","formatTokenFunctions","addFormatToken","token","padded","ordinal","func","localeData","removeFormattingTokens","match","replace","makeFormatFunction","array","formatMoment","expandFormat","invalidDate","replaceLongDateFormatTokens","longDateFormat","lastIndex","test","defaultLongDateFormat","LTS","LT","L","LL","LLL","LLLL","_longDateFormat","formatUpper","toUpperCase","tok","defaultInvalidDate","_invalidDate","defaultOrdinal","defaultDayOfMonthOrdinalParse","_ordinal","defaultRelativeTime","future","past","s","ss","mm","h","hh","d","dd","w","ww","M","MM","y","yy","relativeTime","withoutSuffix","string","isFuture","_relativeTime","pastFuture","diff","aliases","addUnitAlias","unit","shorthand","lowerCase","toLowerCase","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedProp","normalizedInput","priorities","addUnitPriority","priority","getPrioritizedUnits","unitsObj","u","sort","isLeapYear","year","absFloor","ceil","floor","toInt","argumentForCoercion","coercedNumber","value","isFinite","makeGetSet","keepTime","set$1","get","month","date","daysInMonth","stringGet","stringSet","prioritized","prioritizedLen","regexes","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchOffset","matchShortOffset","matchTimestamp","matchWord","addRegexToken","regex","strictRegex","isStrict","getParseRegexForToken","unescapeFormat","regexEscape","matched","p1","p2","p3","p4","tokens","addParseToken","tokenLen","addWeekParseToken","_w","addTimeToArrayFromToken","_a","indexOf","YEAR","MONTH","DATE","HOUR","MINUTE","SECOND","MILLISECOND","WEEK","WEEKDAY","mod","n","x","modMonth","o","monthsShort","months","monthsShortRegex","monthsRegex","monthsParse","defaultLocaleMonths","split","defaultLocaleMonthsShort","MONTHS_IN_FORMAT","defaultMonthsShortRegex","defaultMonthsRegex","localeMonths","_months","isFormat","localeMonthsShort","_monthsShort","handleStrictParse","monthName","ii","llc","toLocaleLowerCase","_monthsParse","_longMonthsParse","_shortMonthsParse","localeMonthsParse","_monthsParseExact","setMonth","dayOfMonth","min","getSetMonth","getDaysInMonth","computeMonthsParse","_monthsShortStrictRegex","_monthsShortRegex","_monthsStrictRegex","_monthsRegex","cmpLenRev","shortPieces","longPieces","mixedPieces","daysInYear","parseTwoDigitYear","parseInt","getSetYear","getIsLeapYear","createDate","ms","getFullYear","setFullYear","createUTCDate","UTC","getUTCFullYear","setUTCFullYear","firstWeekOffset","dow","doy","fwd","getUTCDay","dayOfYearFromWeeks","week","weekday","resYear","resDayOfYear","dayOfYear","weekOfYear","resWeek","weekOffset","weeksInYear","weekOffsetNext","localeWeek","_week","defaultLocaleWeek","localeFirstDayOfWeek","localeFirstDayOfYear","getSetWeek","add","getSetISOWeek","parseWeekday","weekdaysParse","parseIsoWeekday","shiftWeekdays","ws","concat","weekdaysMin","weekdaysShort","weekdays","weekdaysMinRegex","weekdaysShortRegex","weekdaysRegex","defaultLocaleWeekdays","defaultLocaleWeekdaysShort","defaultLocaleWeekdaysMin","defaultWeekdaysRegex","defaultWeekdaysShortRegex","defaultWeekdaysMinRegex","localeWeekdays","_weekdays","day","localeWeekdaysShort","_weekdaysShort","localeWeekdaysMin","_weekdaysMin","handleStrictParse$1","weekdayName","_weekdaysParse","_shortWeekdaysParse","_minWeekdaysParse","localeWeekdaysParse","_weekdaysParseExact","_fullWeekdaysParse","getSetDayOfWeek","getDay","getSetLocaleDayOfWeek","getSetISODayOfWeek","computeWeekdaysParse","_weekdaysStrictRegex","_weekdaysRegex","_weekdaysShortStrictRegex","_weekdaysShortRegex","_weekdaysMinStrictRegex","_weekdaysMinRegex","minp","shortp","longp","minPieces","hFormat","hours","kFormat","lowercase","minutes","matchMeridiem","_meridiemParse","localeIsPM","charAt","seconds","kInput","_isPm","isPM","_meridiem","pos","pos1","pos2","defaultLocaleMeridiemParse","getSetHour","localeMeridiem","isLower","globalLocale","baseConfig","dayOfMonthOrdinalParse","meridiemParse","locales","localeFamilies","commonPrefix","arr1","arr2","minl","normalizeLocale","chooseLocale","names","j","next","loadLocale","isLocaleNameSane","oldLocale","module","_abbr","getSetGlobalLocale","e","values","data","getLocale","defineLocale","abbr","parentLocale","forEach","updateLocale","tmpLocale","listLocales","checkOverflow","_overflowDayOfYear","_overflowWeeks","_overflowWeekday","extendedIsoRegex","basicIsoRegex","tzRegex","isoDates","isoTimes","aspNetJsonRegex","obsOffsets","UT","GMT","EDT","EST","CDT","CST","MDT","MST","PDT","PST","configFromISO","l","allowTime","dateFormat","timeFormat","tzFormat","exec","isoDatesLen","isoTimesLen","configFromStringAndFormat","extractFromRFC2822Strings","yearStr","monthStr","dayStr","hourStr","minuteStr","secondStr","result","untruncateYear","preprocessRFC2822","checkWeekday","weekdayStr","parsedInput","calculateOffset","obsOffset","militaryOffset","numOffset","hm","configFromRFC2822","parsedArray","setUTCMinutes","getUTCMinutes","configFromString","createFromInputFallback","defaults","c","currentDateArray","nowValue","_useUTC","getUTCMonth","getUTCDate","getMonth","getDate","configFromArray","currentDate","expectedWeekday","yearToUse","dayOfYearFromWeekInfo","_dayOfYear","_nextDay","weekYear","temp","weekdayOverflow","curWeek","GG","W","E","createLocal","gg","ISO_8601","RFC_2822","skipped","stringLength","totalParsedInputLength","meridiemFixWrap","erasConvertYear","hour","isPm","meridiemHour","configFromStringAndArray","tempConfig","bestMoment","scoreToBeat","currentScore","validFormatFound","bestFormatIsValid","configfLen","score","configFromObject","dayOrDate","minute","second","millisecond","createFromConfig","prepareConfig","preparse","configFromInput","isUTC","prototypeMin","other","prototypeMax","pickBy","moments","ordering","isDurationValid","unitHasDecimal","orderLen","parseFloat","isValid$1","createInvalid$1","createDuration","Duration","duration","years","quarters","quarter","weeks","isoWeek","days","milliseconds","_milliseconds","_days","_data","_bubble","isDuration","absRound","round","compareArrays","array1","array2","dontConvert","lengthDiff","diffs","offset","separator","utcOffset","sign","offsetFromString","chunkOffset","matcher","parts","matches","cloneWithOffset","model","clone","setTime","local","getDateOffset","getTimezoneOffset","getSetOffset","keepLocalTime","keepMinutes","localAdjust","_changeInProgress","addSubtract","getSetZone","setOffsetToUTC","setOffsetToLocal","subtract","setOffsetToParsedOffset","tZone","hasAlignedHourOffset","isDaylightSavingTime","isDaylightSavingTimeShifted","_isDSTShifted","toArray","isLocal","isUtcOffset","isUtc","aspNetRegex","isoRegex","ret","diffRes","parseIso","momentsDifference","inp","positiveMomentsDifference","base","isAfter","isBefore","createAdder","direction","period","tmp","isAdding","invalid","isString","String","isMomentInput","isNumberOrStringArray","isMomentInputObject","property","objectTest","propertyTest","properties","propertyLen","arrayTest","dataTypeTest","filter","item","isCalendarSpec","getCalendarFormat","myMoment","calendar$1","time","formats","sod","startOf","calendarFormat","localInput","endOf","isBetween","inclusivity","localFrom","localTo","isSame","inputMs","isSameOrAfter","isSameOrBefore","asFloat","that","zoneDelta","monthDiff","wholeMonthDiff","anchor","toISOString","keepOffset","toDate","inspect","prefix","datetime","suffix","zone","inputString","defaultFormatUtc","defaultFormat","postformat","humanize","fromNow","toNow","newLocaleData","lang","MS_PER_SECOND","MS_PER_MINUTE","MS_PER_HOUR","MS_PER_400_YEARS","mod$1","dividend","divisor","localStartOfDate","utcStartOfDate","startOfDate","isoWeekday","unix","toObject","toJSON","isValid$2","parsingFlags","invalidAt","creationData","localeEras","eras","_eras","since","until","localeErasParse","eraName","narrow","localeErasConvertYear","dir","getEraName","getEraNarrow","getEraAbbr","getEraYear","erasNameRegex","computeErasParse","_erasNameRegex","_erasRegex","erasAbbrRegex","_erasAbbrRegex","erasNarrowRegex","_erasNarrowRegex","matchEraAbbr","matchEraName","matchEraNarrow","matchEraYearOrdinal","_eraYearOrdinalRegex","abbrPieces","namePieces","narrowPieces","addWeekYearFormatToken","getter","getSetWeekYear","getSetWeekYearHelper","getSetISOWeekYear","getISOWeeksInYear","getISOWeeksInISOWeekYear","isoWeekYear","getWeeksInYear","weekInfo","getWeeksInWeekYear","weeksTarget","setWeekAll","dayOfYearData","getSetQuarter","erasParse","eraYearOrdinalParse","getSetDayOfMonth","getSetDayOfYear","getSetMinute","getSetMillisecond","getSetSecond","parseMs","getZoneAbbr","getZoneName","proto","createUnix","createInZone","parseZone","preParsePostFormat","Symbol","for","eraNarrow","eraAbbr","eraYear","isoWeeks","weeksInWeekYear","isoWeeksInYear","isoWeeksInISOWeekYear","isDST","zoneAbbr","zoneName","dates","isDSTShifted","proto$1","get$1","index","field","setter","listMonthsImpl","out","listWeekdaysImpl","localeSorted","shift","listMonths","listMonthsShort","listWeekdays","listWeekdaysShort","listWeekdaysMin","firstDayOfYear","firstDayOfWeek","langData","mathAbs","addSubtract$1","add$1","subtract$1","absCeil","bubble","monthsFromDays","monthsToDays","daysToMonths","as","valueOf$1","makeAs","alias","asMilliseconds","asSeconds","asMinutes","asHours","asDays","asWeeks","asMonths","asQuarters","asYears","clone$1","get$2","makeGetter","thresholds","substituteTimeAgo","relativeTime$1","posNegDuration","getSetRelativeTimeRounding","roundingFunction","getSetRelativeTimeThreshold","threshold","limit","argWithSuffix","argThresholds","withSuffix","th","assign","abs$1","toISOString$1","totalSign","ymSign","daysSign","hmsSign","total","toFixed","proto$2","toIsoString","version","relativeTimeRounding","relativeTimeThreshold","HTML5_FMT","DATETIME_LOCAL","DATETIME_LOCAL_SECONDS","DATETIME_LOCAL_MS","TIME","TIME_SECONDS","TIME_MS","factory","env","self","globalThis","deserialize","serialized","$","_","unpair","has","type","object","Map","Set","message","BigInt","deserializer","EMPTY","typeOf","asString","includes","shouldSkip","_ref","TYPE","serialize","json","lossy","pair","entry","TypeError","entries","serializer","structuredClone","any","options","search","buttonTypes","own","createH","schema","defaultTagName","caseSensitive","adjust","createAdjustMap","selector","node","_len","children","_key","child","unshift","props","previous","tagName","start","subvalue","id","className","parseSelector","isProperties","addProperty","addChild","content","info","find","Number","spaceSeparated","commaSeparated","commaOrSpaceSeparated","parsePrimitive","style","finalResult","nodes","boolean","overloadedBoolean","normalize","webNamespaces","html","mathml","svg","xlink","xml","xmlns","fromParse5","tree","settings","one","file","location","space","verbose","state","nodeName","reference","patch","quirksMode","mode","childNodes","doc","loc","indices","toPoint","line","column","toOffset","point","end","position","namespaceURI","attrs","attribute","sourceCodeLocation","startTag","endTag","results","createLocation","tail","opening","closing","startLine","startCol","startOffset","endLine","endCol","endOffset","zwitch","handlers","unknown","parameters","emptyOptions","root","element","parentSchema","currentSchema","createProperty","parentNode","fragment","text","comment","doctype","publicId","systemId","namespace","htmlVoidElements","UNDEFINED_CODE_POINTS","REPLACEMENT_CHARACTER","CODE_POINTS","SEQUENCES","isSurrogate","cp","isControlCodePoint","isUndefinedCodePoint","ERR","Preprocessor","constructor","handler","lastGapPos","gapStack","skipNextNewLine","lastChunkWritten","endOfChunkHit","bufferWaterline","isEol","lineStartPos","droppedBufferSize","lastErrOffset","col","getError","code","_err","onParseError","_addGap","_processSurrogate","nextCp","charCodeAt","isSurrogatePair","EOF","surrogateInInputStream","willDropParsedChunk","dropParsedChunk","substring","write","chunk","isLastChunk","insertHtmlAtCurrentPos","startsWith","pattern","peek","CARRIAGE_RETURN","LINE_FEED","advance","_checkForProblematicCharacters","controlCharacterInInputStream","noncharacterInInputStream","retreat","count","pop","TokenType","getTokenAttr","attrName","Uint16Array","decodeMap","fromCodePoint","codePoint","fromCharCode","replaceCodePoint","CharCodes","BinTrieFlags","EntityDecoderState","DecodingMode","ZERO","NINE","isEntityInAttributeInvalidEnd","EQUALS","UPPER_A","UPPER_Z","LOWER_A","LOWER_Z","isAsciiAlphaNumeric","EntityDecoder","decodeTree","emitCodePoint","errors","EntityStart","consumed","treeIndex","excess","decodeMode","Strict","startEntity","str","NUM","NumericStart","stateNumericStart","NamedEntity","stateNamedEntity","NumericDecimal","stateNumericDecimal","NumericHex","stateNumericHex","LOWER_X","addToNumericResult","digitCount","startIdx","char","UPPER_F","LOWER_F","emitNumericEntity","lastCp","expectedLength","absenceOfDigitsInNumericCharacterReference","SEMI","missingSemicolonAfterCharacterReference","validateNumericCharacterReference","current","valueLength","VALUE_LENGTH","determineBranch","Attribute","emitNotTerminatedNamedEntity","emitNamedEntityData","getDecoder","decoder","nodeIdx","branchCount","BRANCH_LENGTH","jumpOffset","JUMP_TABLE","lo","hi","mid","midVal","ATTRS","DOCUMENT_MODE","TAG_NAMES","TAG_ID","NS","TAG_NAME_TO_ID","A","ADDRESS","ANNOTATION_XML","APPLET","AREA","ARTICLE","ASIDE","B","BASE","BASEFONT","BGSOUND","BIG","BLOCKQUOTE","BODY","BR","BUTTON","CAPTION","CENTER","CODE","COL","COLGROUP","DD","DESC","DETAILS","DIALOG","DIR","DIV","DL","DT","EM","EMBED","FIELDSET","FIGCAPTION","FIGURE","FONT","FOOTER","FOREIGN_OBJECT","FORM","FRAME","FRAMESET","H1","H2","H3","H4","H5","H6","HEAD","HEADER","HGROUP","HR","HTML","I","IMG","IMAGE","INPUT","IFRAME","KEYGEN","LABEL","LI","LINK","LISTING","MAIN","MALIGNMARK","MARQUEE","MATH","MENU","META","MGLYPH","MI","MO","MN","MS","MTEXT","NAV","NOBR","NOFRAMES","NOEMBED","NOSCRIPT","OBJECT","OL","OPTGROUP","OPTION","P","PARAM","PLAINTEXT","PRE","RB","RP","RT","RTC","RUBY","S","SCRIPT","SECTION","SELECT","SOURCE","SMALL","SPAN","STRIKE","STRONG","STYLE","SUB","SUMMARY","SUP","TABLE","TBODY","TEMPLATE","TEXTAREA","TFOOT","TD","TH","THEAD","TITLE","TR","TRACK","TT","U","UL","SVG","VAR","WBR","XMP","getTagID","UNKNOWN","SPECIAL_ELEMENTS","MATHML","XLINK","XML","XMLNS","isNumberedHeader","tn","C1_CONTROLS_REFERENCE_REPLACEMENTS","State","TokenizerMode","DATA","RCDATA","RAWTEXT","SCRIPT_DATA","CDATA_SECTION","isAsciiDigit","DIGIT_0","DIGIT_9","isAsciiUpper","LATIN_CAPITAL_A","LATIN_CAPITAL_Z","isAsciiLetter","LATIN_SMALL_A","LATIN_SMALL_Z","isAsciiLower","isAsciiUpperHexDigit","LATIN_CAPITAL_F","isAsciiLowerHexDigit","LATIN_SMALL_F","toAsciiLower","isWhitespace","SPACE","TABULATION","FORM_FEED","isScriptDataDoubleEscapeSequenceEnd","SOLIDUS","GREATER_THAN_SIGN","Tokenizer","paused","inLoop","inForeignNode","lastStartTagName","active","returnState","charRefCode","consumedAfterSnapshot","currentCharacterToken","currentToken","currentAttr","preprocessor","currentLocation","getCurrentLocation","_b","sourceCodeLocationInfo","_runParsingLoop","_consume","_ensureHibernation","_callState","pause","resume","writeCallback","_unconsume","_reconsumeInState","_advanceBy","_consumeSequenceIfMatch","_createStartTagToken","START_TAG","tagID","selfClosing","ackSelfClosing","_createEndTagToken","END_TAG","_createCommentToken","COMMENT","_createDoctypeToken","initialName","DOCTYPE","forceQuirks","_createCharacterToken","chars","_createAttr","attrNameFirstCh","_leaveAttrName","create","_leaveAttrValue","duplicateAttribute","prepareToken","ct","_emitCurrentCharacterToken","emitCurrentTagToken","onStartTag","endTagWithAttributes","endTagWithTrailingSolidus","onEndTag","emitCurrentComment","onComment","emitCurrentDoctype","onDoctype","nextLocation","CHARACTER","onCharacter","NULL_CHARACTER","onNullCharacter","WHITESPACE_CHARACTER","onWhitespaceCharacter","_emitEOFToken","onEof","_appendCharToCurrentCharacterToken","ch","_emitCodePoint","NULL","_emitChars","_matchNamedCharacterReference","withoutSemicolon","masked","SEMICOLON","_isCharacterReferenceInAttribute","EQUALS_SIGN","AMPERSAND","ATTRIBUTE_VALUE_DOUBLE_QUOTED","ATTRIBUTE_VALUE_SINGLE_QUOTED","ATTRIBUTE_VALUE_UNQUOTED","_flushCodePointConsumedAsCharacterReference","_stateData","_stateRcdata","_stateRawtext","_stateScriptData","_statePlaintext","TAG_OPEN","_stateTagOpen","END_TAG_OPEN","_stateEndTagOpen","TAG_NAME","_stateTagName","RCDATA_LESS_THAN_SIGN","_stateRcdataLessThanSign","RCDATA_END_TAG_OPEN","_stateRcdataEndTagOpen","RCDATA_END_TAG_NAME","_stateRcdataEndTagName","RAWTEXT_LESS_THAN_SIGN","_stateRawtextLessThanSign","RAWTEXT_END_TAG_OPEN","_stateRawtextEndTagOpen","RAWTEXT_END_TAG_NAME","_stateRawtextEndTagName","SCRIPT_DATA_LESS_THAN_SIGN","_stateScriptDataLessThanSign","SCRIPT_DATA_END_TAG_OPEN","_stateScriptDataEndTagOpen","SCRIPT_DATA_END_TAG_NAME","_stateScriptDataEndTagName","SCRIPT_DATA_ESCAPE_START","_stateScriptDataEscapeStart","SCRIPT_DATA_ESCAPE_START_DASH","_stateScriptDataEscapeStartDash","SCRIPT_DATA_ESCAPED","_stateScriptDataEscaped","SCRIPT_DATA_ESCAPED_DASH","_stateScriptDataEscapedDash","SCRIPT_DATA_ESCAPED_DASH_DASH","_stateScriptDataEscapedDashDash","SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN","_stateScriptDataEscapedLessThanSign","SCRIPT_DATA_ESCAPED_END_TAG_OPEN","_stateScriptDataEscapedEndTagOpen","SCRIPT_DATA_ESCAPED_END_TAG_NAME","_stateScriptDataEscapedEndTagName","SCRIPT_DATA_DOUBLE_ESCAPE_START","_stateScriptDataDoubleEscapeStart","SCRIPT_DATA_DOUBLE_ESCAPED","_stateScriptDataDoubleEscaped","SCRIPT_DATA_DOUBLE_ESCAPED_DASH","_stateScriptDataDoubleEscapedDash","SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH","_stateScriptDataDoubleEscapedDashDash","SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN","_stateScriptDataDoubleEscapedLessThanSign","SCRIPT_DATA_DOUBLE_ESCAPE_END","_stateScriptDataDoubleEscapeEnd","BEFORE_ATTRIBUTE_NAME","_stateBeforeAttributeName","ATTRIBUTE_NAME","_stateAttributeName","AFTER_ATTRIBUTE_NAME","_stateAfterAttributeName","BEFORE_ATTRIBUTE_VALUE","_stateBeforeAttributeValue","_stateAttributeValueDoubleQuoted","_stateAttributeValueSingleQuoted","_stateAttributeValueUnquoted","AFTER_ATTRIBUTE_VALUE_QUOTED","_stateAfterAttributeValueQuoted","SELF_CLOSING_START_TAG","_stateSelfClosingStartTag","BOGUS_COMMENT","_stateBogusComment","MARKUP_DECLARATION_OPEN","_stateMarkupDeclarationOpen","COMMENT_START","_stateCommentStart","COMMENT_START_DASH","_stateCommentStartDash","_stateComment","COMMENT_LESS_THAN_SIGN","_stateCommentLessThanSign","COMMENT_LESS_THAN_SIGN_BANG","_stateCommentLessThanSignBang","COMMENT_LESS_THAN_SIGN_BANG_DASH","_stateCommentLessThanSignBangDash","COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH","_stateCommentLessThanSignBangDashDash","COMMENT_END_DASH","_stateCommentEndDash","COMMENT_END","_stateCommentEnd","COMMENT_END_BANG","_stateCommentEndBang","_stateDoctype","BEFORE_DOCTYPE_NAME","_stateBeforeDoctypeName","DOCTYPE_NAME","_stateDoctypeName","AFTER_DOCTYPE_NAME","_stateAfterDoctypeName","AFTER_DOCTYPE_PUBLIC_KEYWORD","_stateAfterDoctypePublicKeyword","BEFORE_DOCTYPE_PUBLIC_IDENTIFIER","_stateBeforeDoctypePublicIdentifier","DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED","_stateDoctypePublicIdentifierDoubleQuoted","DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED","_stateDoctypePublicIdentifierSingleQuoted","AFTER_DOCTYPE_PUBLIC_IDENTIFIER","_stateAfterDoctypePublicIdentifier","BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS","_stateBetweenDoctypePublicAndSystemIdentifiers","AFTER_DOCTYPE_SYSTEM_KEYWORD","_stateAfterDoctypeSystemKeyword","BEFORE_DOCTYPE_SYSTEM_IDENTIFIER","_stateBeforeDoctypeSystemIdentifier","DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED","_stateDoctypeSystemIdentifierDoubleQuoted","DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED","_stateDoctypeSystemIdentifierSingleQuoted","AFTER_DOCTYPE_SYSTEM_IDENTIFIER","_stateAfterDoctypeSystemIdentifier","BOGUS_DOCTYPE","_stateBogusDoctype","_stateCdataSection","CDATA_SECTION_BRACKET","_stateCdataSectionBracket","CDATA_SECTION_END","_stateCdataSectionEnd","CHARACTER_REFERENCE","_stateCharacterReference","NAMED_CHARACTER_REFERENCE","_stateNamedCharacterReference","AMBIGUOUS_AMPERSAND","_stateAmbiguousAmpersand","NUMERIC_CHARACTER_REFERENCE","_stateNumericCharacterReference","HEXADEMICAL_CHARACTER_REFERENCE_START","_stateHexademicalCharacterReferenceStart","HEXADEMICAL_CHARACTER_REFERENCE","_stateHexademicalCharacterReference","DECIMAL_CHARACTER_REFERENCE","_stateDecimalCharacterReference","NUMERIC_CHARACTER_REFERENCE_END","_stateNumericCharacterReferenceEnd","LESS_THAN_SIGN","unexpectedNullCharacter","EXCLAMATION_MARK","QUESTION_MARK","unexpectedQuestionMarkInsteadOfTagName","eofBeforeTagName","invalidFirstCharacterOfTagName","missingEndTagName","eofInTag","handleSpecialEndTag","_cp","HYPHEN_MINUS","eofInScriptHtmlCommentLikeText","unexpectedEqualsSignBeforeAttributeName","QUOTATION_MARK","APOSTROPHE","unexpectedCharacterInAttributeName","missingAttributeValue","GRAVE_ACCENT","unexpectedCharacterInUnquotedAttributeValue","missingWhitespaceBetweenAttributes","unexpectedSolidusInTag","cdataInHtmlContent","incorrectlyOpenedComment","abruptClosingOfEmptyComment","eofInComment","nestedComment","incorrectlyClosedComment","eofInDoctype","missingWhitespaceBeforeDoctypeName","missingDoctypeName","invalidCharacterSequenceAfterDoctypeName","missingWhitespaceAfterDoctypePublicKeyword","missingDoctypePublicIdentifier","missingQuoteBeforeDoctypePublicIdentifier","abruptDoctypePublicIdentifier","missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers","missingQuoteBeforeDoctypeSystemIdentifier","missingWhitespaceAfterDoctypeSystemKeyword","missingDoctypeSystemIdentifier","abruptDoctypeSystemIdentifier","unexpectedCharacterAfterDoctypeSystemIdentifier","RIGHT_SQUARE_BRACKET","eofInCdata","NUMBER_SIGN","matchResult","unknownNamedCharacterReference","LATIN_SMALL_X","LATIN_CAPITAL_X","isAsciiHexDigit","nullCharacterReference","characterReferenceOutsideUnicodeRange","surrogateCharacterReference","noncharacterCharacterReference","controlCharacterReference","replacement","IMPLICIT_END_TAG_REQUIRED","IMPLICIT_END_TAG_REQUIRED_THOROUGHLY","SCOPING_ELEMENT_NS","NAMED_HEADERS","TABLE_ROW_CONTEXT","TABLE_BODY_CONTEXT","TABLE_CONTEXT","TABLE_CELLS","OpenElementStack","currentTmplContentOrNode","_isInTemplate","treeAdapter","getTemplateContent","document","items","tagIDs","stackTop","tmplCount","currentTagId","_indexOf","lastIndexOf","getNamespaceURI","_updateCurrentElement","onItemPush","popped","onItemPop","oldElement","newElement","idx","insertAfter","referenceElement","newElementID","insertionIdx","splice","popUntilTagNamePopped","targetIdx","shortenToLength","popUntilElementPopped","popUntilPopped","tagNames","targetNS","_indexOfTagNames","popUntilNumberedHeaderPopped","popUntilTableCellPopped","popAllUpToHtmlElement","clearBackTo","clearBackToTableContext","clearBackToTableBodyContext","clearBackToTableRowContext","remove","tryPeekProperlyNestedBodyElement","contains","getCommonAncestor","elementIdx","isRootHtmlElementCurrent","hasInScope","ns","hasNumberedHeaderInScope","hasInListItemScope","hasInButtonScope","hasInTableScope","hasTableBodyContextInTableScope","hasInSelectScope","generateImpliedEndTags","generateImpliedEndTagsThoroughly","generateImpliedEndTagsWithExclusion","exclusionId","EntryType","MARKER","Marker","FormattingElementList","bookmark","_getNoahArkConditionCandidates","neAttrs","candidates","neAttrsLength","neTagName","getTagName","neNamespaceURI","elementAttrs","getAttrList","_ensureNoahArkCondition","neAttrsMap","neAttr","validCandidates","candidate","every","cAttr","insertMarker","pushElement","Element","insertElementAfterBookmark","bookmarkIdx","removeEntry","entryIndex","clearToLastMarker","markerIdx","getElementEntryInScopeWithTagName","getElementEntry","createTextNode","defaultTreeAdapter","createDocument","NO_QUIRKS","createDocumentFragment","createElement","createCommentNode","appendChild","newNode","insertBefore","referenceNode","setTemplateContent","templateElement","contentElement","setDocumentType","doctypeNode","setDocumentMode","getDocumentMode","detachNode","insertText","prevNode","isTextNode","insertTextBefore","adoptAttributes","recipient","recipientAttrsMap","attr","getFirstChild","getChildNodes","getParentNode","getTextNodeContent","textNode","getCommentNodeContent","commentNode","getDocumentTypeNodeName","getDocumentTypeNodePublicId","getDocumentTypeNodeSystemId","isCommentNode","isDocumentTypeNode","isElementNode","setNodeSourceCodeLocation","getNodeSourceCodeLocation","updateNodeSourceCodeLocation","endLocation","VALID_DOCTYPE_NAME","VALID_SYSTEM_ID","QUIRKS_MODE_SYSTEM_ID","QUIRKS_MODE_PUBLIC_ID_PREFIXES","QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES","QUIRKS_MODE_PUBLIC_IDS","LIMITED_QUIRKS_PUBLIC_ID_PREFIXES","LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES","hasPrefix","prefixes","MIME_TYPES","TEXT_HTML","APPLICATION_XML","DEFINITION_URL_ATTR","ADJUSTED_DEFINITION_URL_ATTR","SVG_ATTRS_ADJUSTMENT_MAP","XML_ATTRS_ADJUSTMENT_MAP","SVG_TAG_NAMES_ADJUSTMENT_MAP","EXITS_FOREIGN_CONTENT","adjustTokenMathMLAttrs","adjustTokenSVGAttrs","adjustedAttrName","adjustTokenXMLAttrs","adjustedAttrEntry","isIntegrationPoint","foreignNS","ENCODING","isHtmlIntegrationPoint","isMathMLTextIntegrationPoint","HIDDEN_INPUT_TYPE","AA_OUTER_LOOP_ITER","AA_INNER_LOOP_ITER","InsertionMode","BASE_LOC","TABLE_STRUCTURE_TAGS","defaultParserOptions","scriptingEnabled","fragmentContext","scriptHandler","stopped","insertionMode","INITIAL","originalInsertionMode","headElement","formElement","currentNotInHTML","tmplInsertionModeStack","pendingCharacterTokens","hasNonWhitespacePendingCharacterToken","framesetOk","fosterParentingEnabled","tokenizer","activeFormattingElements","fragmentContextID","_setContextModes","openElements","parse","parser","getFragmentParser","opts","documentMock","IN_TEMPLATE","_initTokenizerForFragmentParsing","_insertFakeRootElement","_resetInsertionMode","_findFormInFragmentContext","getFragment","rootElement","_adoptNodes","beforeToken","err","tid","isTop","_setEndLocation","isHTML","_isIntegrationPoint","_switchToTextParsing","nextTokenizerState","_insertElement","TEXT","switchToPlaintextParsing","IN_BODY","_getAdjustedCurrentElement","_setDocumentType","docTypeNode","_attachElementToTree","_shouldFosterParentOnInsertion","_fosterParentElement","parent","_appendElement","_insertFakeElement","_insertTemplate","tmpl","_appendCommentNode","_insertCharacters","beforeElement","_findFosterParentingLocation","siblings","textNodeIdx","donor","closingToken","ctLoc","endLoc","shouldProcessStartTagTokenInForeignContent","_processToken","_processStartTag","_reconstructActiveFormattingElements","listLength","endIndex","findIndex","_closeTableCell","IN_ROW","_closePElement","IN_TABLE_BODY","IN_CAPTION","IN_COLUMN_GROUP","IN_TABLE","IN_FRAMESET","_resetInsertionModeForSelect","AFTER_HEAD","BEFORE_HEAD","IN_CELL","IN_HEAD","selectIdx","IN_SELECT_IN_TABLE","IN_SELECT","_isElementCausesFosterParenting","openElement","_isSpecialElement","p","characterInForeignContent","tokenInInitialMode","BEFORE_HTML","tokenBeforeHtml","tokenBeforeHead","tokenInHead","IN_HEAD_NO_SCRIPT","tokenInHeadNoScript","tokenAfterHead","characterInBody","characterInTable","IN_TABLE_TEXT","characterInTableText","tokenInColumnGroup","AFTER_BODY","tokenAfterBody","AFTER_AFTER_BODY","tokenAfterAfterBody","nullCharacterInForeignContent","appendComment","AFTER_FRAMESET","tokenInTableText","appendCommentToRootHtmlElement","AFTER_AFTER_FRAMESET","appendCommentToDocument","QUIRKS","LIMITED_QUIRKS","nonConformingDoctype","doctypeInInitialMode","misplacedDoctype","nonVoidHtmlElementStartTagWithTrailingSolidus","startTagToken","COLOR","SIZE","FACE","popUntilHtmlOrIntegrationPoint","_startTagOutsideForeignContent","currentNs","adjustedTagName","startTagInForeignContent","startTagBeforeHtml","startTagInBody","startTagBeforeHead","startTagInHead","nestedNoscriptInHead","startTagInHeadNoScript","abandonedHeadElementChild","misplacedStartTagForHeadElement","startTagAfterHead","startTagInTable","TABLE_VOID_ELEMENTS","startTagInCaption","startTagInColumnGroup","startTagInTableBody","startTagInRow","startTagInCell","startTagInSelect","startTagInSelectInTable","startTagInTemplate","startTagAfterBody","startTagInFrameset","startTagAfterFrameset","startTagAfterAfterBody","startTagAfterAfterFrameset","_endTagOutsideForeignContent","endTagInForeignContent","endTagBeforeHtml","endTagWithoutMatchingOpenElement","endTagBeforeHead","templateEndTagInHead","endTagInHead","endTagInHeadNoScript","endTagAfterHead","endTagInBody","endTagInText","endTagInTable","endTagInCaption","endTagInColumnGroup","endTagInTableBody","endTagInRow","endTagInCell","endTagInSelect","endTagInSelectInTable","endTagInTemplate","endTagAfterBody","endTagInFrameset","endTagAfterFrameset","eofInBody","eofInElementThatCanContainOnlyText","eofInText","eofInTemplate","stopParsing","whitespaceCharacterInBody","whitespaceCharacterInTableText","aaObtainFormattingElementEntry","formattingElementEntry","genericEndTagInBody","aaObtainFurthestBlock","furthestBlock","aaInnerLoop","formattingElement","lastElement","nextElement","elementEntry","counterOverflow","aaRecreateElementFromEntry","aaInsertLastNodeInCommonAncestor","commonAncestor","aaReplaceFormattingElement","callAdoptionAgency","target","htmlElement","htmlLocation","bodyElement","bodyLocation","missingDoctype","closingOfElementWithOpenChildElements","errCode","openElementsLeftAfterEof","disallowedContentInNoscriptInHead","modeInBody","areaStartTagInBody","isHiddenInput","inputType","noembedStartTagInBody","genericStartTagInBody","bStartTagInBody","activeElementEntry","aStartTagInBody","numberedHeaderStartTagInBody","addressStartTagInBody","elementId","listItemStartTagInBody","hrStartTagInBody","rbStartTagInBody","rtStartTagInBody","preStartTagInBody","xmpStartTagInBody","svgStartTagInBody","htmlStartTagInBody","bodyStartTagInBody","inTemplate","formStartTagInBody","nobrStartTagInBody","mathStartTagInBody","tableStartTagInBody","inputStartTagInBody","paramStartTagInBody","imageStartTagInBody","buttonStartTagInBody","appletStartTagInBody","iframeStartTagInBody","selectStartTagInBody","optgroupStartTagInBody","framesetStartTagInBody","textareaStartTagInBody","plaintextStartTagInBody","pEndTagInBody","addressEndTagInBody","liEndTagInBody","ddEndTagInBody","numberedHeaderEndTagInBody","brEndTagInBody","bodyEndTagInBody","htmlEndTagInBody","formEndTagInBody","appletEndTagInBody","tokenInTable","tdStartTagInTable","colStartTagInTable","formStartTagInTable","tableStartTagInTable","tbodyStartTagInTable","inputStartTagInTable","captionStartTagInTable","colgroupStartTagInTable","savedFosterParentingState","xmlCodeMap","codePointAt","getEscaper","lastIdx","pointEnd","pointStart","convert","castFactory","tests","checks","anyFactory","check","checkAsRecord","all","nodeAsRecord","propsFactory","typeFactory","testFunction","Boolean","looksLikeANode","CONTINUE","EXIT","SKIP","visitParents","visitor","reverse","is","step","parents","defineProperty","visit","subresult","grandparents","toResult","nodeAsParent","knownMdxNames","parseOptions","raw","head","documentMode","handleRaw","handle","stitches","resetTokenizer","testOrVisitor","visitorOrReverse","maybeReverse","stitch","toParse5","tag","createParse5Location","cloneWithoutChildren","fakeRoot","setPoint","node_","passThrough","extra","rehypeRaw","React","Link","url","display","src","img","catgory","title","ReactMarkdown","rehypePlugins","description","author_thumbnail","author_name","moment","published"],"sourceRoot":""}