/*
         * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token
         * is optional. But the grammar is defined so that there is only one case we have to handle:
         *
         * token.content = [
         *     <span class="punctuation">```</span>,
         *     <span class="code-language">xxxx</span>,
         *     '\n', // exactly one new lines (\r or \n or \r\n)
         *     <span class="code-block">...</span>,
         *     '\n', // exactly one new lines again
         *     <span class="punctuation">```</span>
         * ];
         */

/*
       * A git command can contain a parameter starting by a single or a double dash followed by a string
       * For instance:
       * $ git diff --cached
       * $ git log -p
       */

/*
   * A simple one line comment like in a git status command
   * For instance:
   * $ git status
   * # On branch infinite-scroll
   * # Your branch and 'origin/sharedBranches/frontendTeam/infinite-scroll' have diverged,
   * # and have 1 and 2 different commits each, respectively.
   * nothing to commit (working directory clean)
   */

/*
   * Coordinates displayed in a git diff command
   * For instance:
   * $ git diff
   * diff --git file.txt file.txt
   * index 6214953..1d54a52 100644
   * --- file.txt
   * +++ file.txt
   * @@ -1 +1,2 @@
   * -Here's my tetx file
   * +Here's my text file
   * +And this is the second line
   */

/*
   * Match a "commit [SHA1]" line in a git log output.
   * For instance:
   * $ git log
   * commit a11a14ef7e26f2ca62d4b35eac455ce636d0dc09
   * Author: lgiraudel
   * Date:   Mon Feb 17 11:18:34 2014 +0100
   *
   *     Add of a new line
   */

/*
   * Regexp to match the changed lines in a git diff output. Check the example below.
   */

/*
   * a git command. It starts with a random prompt finishing by a $, then "git" then some other parameters
   * For instance:
   * $ git add file.txt
   */

/*
   * a string (double and simple quote)
   */

/* ! */

/* "prismjs/components/prism-actionscript" */

/* "prismjs/components/prism-bash" */

/* "prismjs/components/prism-c" */

/* "prismjs/components/prism-clike" */

/* "prismjs/components/prism-coffeescript" */

/* "prismjs/components/prism-cpp" */

/* "prismjs/components/prism-css" */

/* "prismjs/components/prism-css-extras" */

/* "prismjs/components/prism-diff" */

/* "prismjs/components/prism-flow" */

/* "prismjs/components/prism-git" */

/* "prismjs/components/prism-go" */

/* "prismjs/components/prism-graphql" */

/* "prismjs/components/prism-handlebars" */

/* "prismjs/components/prism-java" */

/* "prismjs/components/prism-javadoclike" */

/* "prismjs/components/prism-javascript" */

/* "prismjs/components/prism-js-extras" */

/* "prismjs/components/prism-js-templates" */

/* "prismjs/components/prism-jsdoc" */

/* "prismjs/components/prism-json" */

/* "prismjs/components/prism-jsx" */

/* "prismjs/components/prism-less" */

/* "prismjs/components/prism-makefile" */

/* "prismjs/components/prism-markdown" */

/* "prismjs/components/prism-markup" */

/* "prismjs/components/prism-markup-templating" */

/* "prismjs/components/prism-n4js" */

/* "prismjs/components/prism-objectivec" */

/* "prismjs/components/prism-ocaml" */

/* "prismjs/components/prism-php" */

/* "prismjs/components/prism-python" */

/* "prismjs/components/prism-reason" */

/* "prismjs/components/prism-sass" */

/* "prismjs/components/prism-scss" */

/* "prismjs/components/prism-sql" */

/* "prismjs/components/prism-stylus" */

/* "prismjs/components/prism-tsx" */

/* "prismjs/components/prism-typescript" */

/* "prismjs/components/prism-wasm" */

/* "prismjs/components/prism-yaml" */

/* $ */

/* && typeof token.content !== 'string' */

/* '\' */

/* ( */

/* ) */

/* * */

/* + */

/* , */

/* - */

/* . */

/* / */

/* 0 */

/* 1 */

/* 7 */

/* 9 */

/* : */

/* < */

/* <BS> */

/* <ZWJ> */

/* <ZWNJ> */

/* = */

/* > */

/* ? */

/* A */

/* B */

/* CSS */

/* D */

/* F */

/* FIXME :
 :extend() is not handled specifically : its highlighting is buggy.
 Mixin usage must be inside a ruleset to be highlighted.
 At-rules (e.g. import) containing interpolations are buggy.
 Detached rulesets are highlighted as at-rules.
 A comment before a mixin usage prevents the latter to be properly highlighted.
 */

/* Means: The term is empty */

/* P */

/* Patterns in command substitution. */

/* S */

/* This content is auto-generated to include some prismjs language components: */

/* W */

/* WEBPACK VAR INJECTION */

/* Z */

/* [ */

/* \ */

/* \f */

/* \n */

/* \r */

/* \t */

/* \v */

/* ^ */

/* _ */

/* a */

/* b */

/* c */

/* d */

/* empty */

/* eslint-disable no-underscore-dangle */

/* f */

/* falls through */

/* global global */

/* harmony default export */

/* harmony export (binding) */

/* harmony import */

/* harmony reexport (safe) */

/* istanbul ignore next */

/* k */

/* n */

/* p */

/* r */

/* rawLength */

/* s */

/* t */

/* u */

/* v */

/* w */

/* x */

/* z */

/* { */

/* | */

/* } */

/*!
 * regjsgen 0.5.2
 * Copyright 2014-2020 Benjamin Tan <https://ofcr.se/>
 * Available under the MIT license <https://github.com/bnjmnt4n/regjsgen/blob/master/LICENSE-MIT.txt>
 */

/*! https://mths.be/regenerate v1.3.3 by @mathias | MIT license */

/*#__PURE__*/

/**
           * A JavaScript template-string token will look like this:
           *
           * ["template-string", [
           *     ["template-punctuation", "`"],
           *     (
           *         An array of "string" and "interpolation" tokens. This is the simple string case.
           *         or
           *         ["embedded-code", "..."] This is the token containing the embedded code.
           *                                  It also has an alias which is the language of the embedded code.
           *     ),
           *     ["template-punctuation", "`"]
           * ]]
           */

/**
       * Insert a token before another token in a language literal
       * As this needs to recreate the object (we cannot actually insert before keys in object literals),
       * we cannot just provide an object, we need anobject and a key.
       * @param inside The key (or language id) of the parent
       * @param before The key to insert before. If not provided, the function appends instead.
       * @param insert Object with the key/value pairs to insert
       * @param root The object that contains `inside`. If equal to Prism.languages, it can be omitted.
       */

/**
       * Replace placeholders with proper tokens after tokenizing.
       *
       * @param {object} env The environment of the `after-tokenize` hook.
       * @param {string} language The language id.
       */

/**
       * The token array will look like this
       * [
       *     ["interpolation-punctuation", "${"]
       *     "..." // JavaScript expression of the interpolation
       *     ["interpolation-punctuation", "}"]
       * ]
       */

/**
       * Tokenize all inline templating expressions matching `placeholderPattern`.
       *
       * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
       * `true` will be replaced.
       *
       * @param {object} env The environment of the `before-tokenize` hook.
       * @param {string} language The language id.
       * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
       * @param {(match: string) => boolean} [replaceFilter]
       */

/**
     *
     * @param {(Token|string)[]} tokens
     * @returns {void}
     */

/**
     * Finds and tokenizes all template strings with an embedded languages.
     *
     * @param {(Token | string)[]} tokens
     * @returns {void}
     */

/**
   * A map from the name of a block to its line prefix.
   *
   * @type {Object<string, string>}
   */

/**
   * Adds an inlined language to markup.
   *
   * An example of an inlined language is CSS with `<style>` tags.
   *
   * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
   * case insensitive.
   * @param {string} lang The language key.
   * @example
   * addInlined('style', 'css');
   */

/**
   * Adds doc comment support to the given language and calls a given callback on each doc comment pattern.
   *
   * @param {string} lang the language add doc comment support to.
   * @param {(pattern: {inside: {rest: undefined}}) => void} callback the function called with each doc comment pattern as argument.
   */

/**
   * Adds doc-comment support to the given languages for the given documentation language.
   *
   * @param {string[]|string} languages
   * @param {Object} docLanguage
   */

/**
   * Creates a new pattern to match a template string with a special tag.
   *
   * This will return `undefined` if there is no grammar with the given language id.
   *
   * @param {string} language The language id of the embedded language. E.g. `markdown`.
   * @param {string} tag The regex pattern to match the tag.
   * @returns {object | undefined}
   * @example
   * createTemplate('css', /\bcss/.source);
   */

/**
   * Returns a specific placeholder literal for the given language.
   *
   * @param {number} counter
   * @param {string} language
   * @returns {string}
   */

/**
   * Returns the placeholder for the given language id and index.
   *
   * @param {string} language
   * @param {string|number} index
   * @returns {string}
   */

/**
   * Returns the string content of a token or token stream.
   *
   * @param {string | Token | (string | Token)[]} value
   * @returns {string}
   */

/**
   * Returns the token of the given JavaScript interpolation expression.
   *
   * @param {string} expression The code of the expression. E.g. `"${42}"`
   * @returns {Token}
   */

/**
   * Returns the tokens of `Prism.tokenize` but also runs the `before-tokenize` and `after-tokenize` hooks.
   *
   * @param {string} code
   * @param {any} grammar
   * @param {string} language
   * @returns {(string|Token)[]}
   */

/**
   * The languages for which JS templating will handle tagged template literals.
   *
   * JS templating isn't active for only JavaScript but also related languages like TypeScript, JSX, and TSX.
   */

/**
   * This function is intended for the creation of the bold or italic pattern.
   *
   * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.
   *
   * _Note:_ Keep in mind that this adds a capturing group.
   *
   * @param {string} pattern
   * @param {boolean} starAlternative Whether to also add an alternative where all `_`s are replaced with `*`s.
   * @returns {RegExp}
   */

/**
   * Tokenizes the given code with support for JavaScript interpolation expressions mixed in.
   *
   * This function has 3 phases:
   *
   * 1. Replace all JavaScript interpolation expression with a placeholder.
   *    The placeholder will have the syntax of a identify of the target language.
   * 2. Tokenize the code with placeholders.
   * 3. Tokenize the interpolation expressions and re-insert them into the tokenize code.
   *    The insertion only works if a placeholder hasn't been "ripped apart" meaning that the placeholder has been
   *    tokenized as two tokens by the grammar of the embedded language.
   *
   * @param {string} code
   * @param {object} grammar
   * @param {string} language
   * @returns {Token}
   */

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 
 */

/**
 * Copyright (c) 2014-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

/**
 * Original by Aaron Harun: http://aahacreative.com/2012/07/31/php-syntax-highlighting-prism/
 * Modified by Miles Johnson: http://milesj.me
 *
 * Supports the following:
 * 		- Extends clike syntax
 * 		- Support for PHP 5.3+ (namespaces, traits, generators, etc)
 * 		- Smarter constant and function matching
 *
 * Adds the following new token classes:
 * 		constant, delimiter, variable, function, package
 */

/**
 * Prism: Lightweight, robust, elegant syntax highlighting
 * MIT license http://www.opensource.org/licenses/mit-license.php/
 * @author Lea Verou http://lea.verou.me
 */

/**
 * Similar to invariant but only logs a warning if the condition is not met.
 * This can be used to log issues in development environments in critical
 * paths. Removing the logging code for production environments will keep the
 * same logic and follow the same code paths.
 */

/**
 * This function accepts and discards inputs; it has no side effects. This is
 * primarily useful idiomatically for overridable function endpoints which
 * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
 */

/**
 * Validate the flags part of a given RegExpLiteral.
 *
 * @param {RegExpValidationState} state The state to validate RegExp.
 * @returns {void}
 */

/**
 * Validate the pattern part of a given RegExpLiteral.
 *
 * @param {RegExpValidationState} state The state to validate RegExp.
 * @returns {void}
 */

/**
 * prism-react-renderer:
 * This file has been modified to remove:
 * - globals and window dependency
 * - worker support
 * - highlightAll and other element dependent methods
 * - _.hooks helpers
 * - UMD/node-specific hacks
 * It has also been run through prettier
 */

/** @type {(Token|string)[]} */

/** @type {Array} */

/** @type {string} */

/***/

/*--------------------------------------------------------------------------*/

/*@__PURE__*/

//

//     	+ '\\u' + pad(hex(lowSurrogate(codePoint)), 4);

//          A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

//          a b c d e f g h i j k l m n o p q r s t u v w x y z

//       [ highSurrogates1, lowSurrogates1 ],

//       [ highSurrogates2, lowSurrogates2 ]

//      $

//      ( ? ! Disjunction )

//      ( ? : Disjunction )

//      ( ? < ! Disjunction )

//      ( ? < = Disjunction )

//      ( ? = Disjunction )

//      ( Disjunction )

//      ( GroupSpecifier Disjunction )

//      *

//      +

//      -

//      .

//      < RegExpIdentifierName >

//      <ZWJ>

//      <ZWNJ>

//      ?

//      ? GroupName

//      Alternative

//      Alternative Term

//      Alternative | Disjunction

//      Anchor

//      Atom

//      Atom Quantifier

//      CharacterClass

//      CharacterClassEscape

//      CharacterClassEscape :: one of d D s S w W

//      CharacterEscape

//      ClassAtom

//      ClassAtom - ClassAtom ClassRanges

//      ClassAtom NonemptyClassRangesNoDash

//      ClassAtomNoDash

//      ClassAtomNoDash - ClassAtom ClassRanges

//      ClassAtomNoDash NonemptyClassRangesNoDash

//      ControlEscape

//      DecimalEscape

//      DecimalIntegerLiteral [lookahead ∉ DecimalDigit]

//      Disjunction

//      ExtendedPatternCharacter

//      HexEscapeSequence

//      IdentityEscape

//      IdentityEscape[?U]

//      NonemptyClassRanges

//      PatternCharacter

//      QuantifierPrefix

//      QuantifierPrefix ?

//      RegExpIdentifierName RegExpIdentifierContinue

//      RegExpIdentifierStart

//      RegExpUnicodeEscapeSequence[?U] (ES6)

//      SourceCharacter but not any of: ^ $ \ . * + ? ( ) [ ] { } |

//      SourceCharacter but not c

//      SourceCharacter but not one of \ or ] or -

//      SourceCharacter but not one of ^$\.*+?()[|

//      UnicodeEscapeSequence

//      UnicodeIDContinue

//      UnicodeIDStart

//      [ [lookahead ∉ {^}] ClassRanges ]

//      [ ^ ClassRanges ]

//      [empty]

//      \ AtomEscape

//      \ B

//      \ ClassEscape

//      \ RegExpUnicodeEscapeSequence

//      \ b

//      ^

//      _

//      b

//      c ControlLetter

//      k GroupName

//      one of

//      one of d D s S w W

//      one of f n r t v

//      { DecimalDigits , DecimalDigits }

//      { DecimalDigits , }

//      { DecimalDigits }

//     [

//     [ surrogateMapping1, surrogateMapping2 ]

//     [+U] -

//     ]

//     `...` DestructuringAssignmentTarget[Yield, Await]

//     b

//     string = '\\u' + pad(hex(highSurrogate(codePoint)), 4)

//     super . IdentifierName

//     super Arguments

//     super [ Expression ]

//   /\091/.exec('\091')[0].length === 3

//   <ZWJ>

//   <ZWNJ>

//   AssignmentRestProperty[Yield, Await] :

//   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.

//   LoneUnicodePropertyNameOrValue

//   RegExpIdentifierName[?U] RegExpIdentifierPart[?U]

//   RegExpIdentifierStart[?U]

//   UnicodeIDContinue

//   UnicodeIDStart

//   UnicodePropertyName `=` UnicodePropertyValue

//   UnicodePropertyNameCharacters

//   UnicodePropertyValueCharacters

//   [empty]

//   `$`

//   `<` RegExpIdentifierName[?U] `>`

//   `?` GroupName[?U]

//   `\` RegExpUnicodeEscapeSequence[?U]

//   `_`

//   a) this is on a separate line, or

//   b) there are no children but there are attributes

//   css`a { color: #25F; }`

//   implementations: ']'.match(/]/);

//   styled.h1`color: red;`

//   term "Anchor" is used.

// ","

// ";"

// "\"

// "deleted-sign" -> "deleted"

// "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"

// # title 1

// ## Parser utilities

// ## Token types

// ## Tokenizer

// ### Expression parsing

// ### Statement parsing

// ### Token reading

// ###### title 6

// $ (dollar) and _ (underscore)

// $ set | grep '^[A-Z][^[:space:]]*=' | cut -d= -f1 | tr '\n' '|'

// $FlowFixMe

// ' '

// ' \n'

// '"', "'"

// '%*'

// '&'

// '*'

// '+-'

// '-'

// '.'

// '/'

// '0'

// '0b', '0B' - binary number

// '0o', '0O' - octal number

// '0x', '0X' - hex number

// '<'

// '<>'

// '=!'

// '=>'

// '\'

// '\r\n'

// '^'

// '`'

// '`', '${'

// 'atomic', nondivisible expression types at the bottom. Most of

// 'b' -> '\b'

// 'class-name' must be matched *after* 'constructor' defined below

// 'eE'

// 'f' -> '\f'

// 'let' indicating that the lval creates a lexical ('let' or 'const') binding

// 'n' -> '\n'

// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references

// 'r' -> '\r'

// 't' -> '\t'

// 'u'

// 'v' -> '\u000b'

// 'var' indicating that the lval creates a 'var' binding

// 'x'

// '{'

// '{' and '['

// '|&'

// '~'

// (2019). This influences support for strict mode, the set of

// (if available) will be matched later.

// (non-standard) ParenthesizedExpression nodes

// (starting after '<'), attributes, contents and closing tag.

// (which is slow). Length 4 is assumed to be the most frequent, followed by

// * * *

// * item

// ***

// **strong**

// *em*

// *that* in the unary operator node.

// + LC_ALL, RANDOM, REPLY, SECONDS.

// + item

// + make sure PS1..4 are here as they are not always set,

// +1 for newline

// - 'async /*\n*/ function' is invalid.

// - 'async /*foo*/ function' is OK.

// - item

// - some useless things.

// ---

// -------

// -----------

// ... otherwise it needs to be interpreted as a octal (if the

// 0..9

// 0x

// 1-9

// 1. First filter out all interpolations

// 1. item

// 15.10.2.19

// 19.1.2.1 Object.assign(target, source, ...)

// 19.1.2.14 / 15.2.3.14 Object.keys(O)

// 19.1.3.1 Object.assign(target, source)

// 46 = dot '.'

// 7.1.1 ToPrimitive(input [, PreferredType])

// 7.1.13 ToObject(argument)

// 7.1.15 ToLength

// 7.1.4 ToInteger

// 7.2.1 RequireObjectCoercible(argument)

// =======

// ==================================================================

// > ...

// >0xffff code points that are a valid part of identifiers. The

// @flow

// @param {string} [baz.foo="bar"] foo bar

// @param {string} foo - foo bar

// @word, {@word}

// A `-->` line comment

// A function can be passed as `onComment` option, which will

// A function can be passed as `onToken` option, which will

// A list of lexically-declared names in the current lexical scope

// A list of var-declared names in the current lexical scope

// A previous entry exists and was in short interval

// A property/value pair cannot end with a comma or a brace

// A recursive descent parser operates by defining functions for all

// A second optional argument can be given to further configure

// A selector can contain parentheses only as part of a pseudo-element

// A..Z

// API][api].

// Acorn is organized as a tokenizer and a recursive-descent parser.

// Acorn uses an [operator precedence parser][opp] to handle binary

// Add the code points in the other item to this one.

// Add the new operation to the stack

// Add the params to varDeclaredNames to ensure that an error is thrown

// Alias added to make those easier to distinguish from strings.

// All in the name of speed.

// All token type variables start with an underscore, to make them

// Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)

// Allow for two levels of nesting

// Allow only one line break

// Allow passing other Regenerate instances.

// Allows only 0-377(octal) i.e. 0-255(decimal).

// Also assumes that first character was already checked

// Alternative ::

// Anchor ::

// And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence

// And merge text with adjacent text

// And, if locations are used, the {line, column} object

// Annotations in N4JS spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html#_annotations

// Anything else beginning with a digit is an integer, octal

// Append the previous high-surrogate-to-low-surrogate mappings.

// Apply the changes and update the offset

// Array#includes uses SameValueZero equality algorithm

// Array#indexOf ignores holes, Array#includes - not

// As the parser collects the number of capture groups as the string is

// Asserts that following token is given contextual keyword.

// AssignmentProperty has type === "Property"

// Astral code point; split in surrogate halves

// At this point, if `start` is `greater` than `codePoint`, insert a new

// Atom ::

// AtomEscape ::

// B.1.4

// B.1.4 ExtendedAtom

// BMP code point

// Based on https://mths.be/fromcodepoint by @mathias.

// Binary properties:

// Block regexp can contain comments and interpolation

// Block strings

// Built-in target names

// But eat eager.

// But if that’s what you need, just add an `else` block with this code:

// But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.

// By default, reserved words are only enforced if ecmaVersion >= 5.

// CSS selector regex is not appropriate for Sass

// Called at the end of every token. Sets `end`, `val`, and

// Called at the start of the parse and after every token. Skips

// Can be either `"script"` or `"module"`. This influences global

// Carriage Return <CR>

// CharSet containing the one character <BS> (Unicode value 0008).

// CharacterClass ::

// CharacterClassEscape ::

// CharacterEscape ::

// CharacterEscape[U] ::

// Check for existing strings

// Check for identical high surrogate ranges.

// Check if adding this code point causes two separate ranges to become

// Check if both `rangeStart` and `rangeEnd` are within the bounds of

// Check if only `rangeStart` is within the bounds of this pair.

// Check if property name clashes with already added.

// Check if the code point is already in the set.

// Check if the set only represents a single code point.

// Check if this range can be combined with the previous range.

// Check if this range pair is equal to, or forms a subset of, the range

// Checks function params for various disallowed patterns such as using "eval"

// Checks if an object has a property.

// ClassAtom - ClassAtom ClassRanges

// ClassAtom ::

// ClassAtomNoDash - ClassAtom ClassRanges

// ClassAtomNoDash ::

// ClassAtomNoDash NonemptyClassRangesNoDash

// ClassEscape ::

// ClassRanges ::

// Clean up some extranous whitespace

// Closing brace

// Closing tag

// Combine step 2 and step 3.

// Constructs a string by concatentating the output of each term.

// Consume a semicolon, or, failing that, see if we are allowed to

// Consumes contextual keyword if possible.

// ControlEscape

// ControlEscape ::

// ControlLetter ::

// Convert existing expression atom to assignable pattern

// Convert list of expression atoms to binding list.

// Convert the input to a string and treat the empty string special.

// Copy of the full string this token was created from

// Create Literal#value property value.

// Create a new line for each string on a new line

// Create a sparse array

// Custom operators are allowed

// DecimalEscape ::

// Decreate the stack depth

// Deep clone a language definition (e.g. to extend it)

// Detect free variable `module`.

// Detect free variables `exports`.

// Determine content and append type to types if necessary

// Directives

// Disambiguating between a `for` and a `for`/`in` or `for`/`of`

// Disjunction ::

// Do this check after everything has been initialized to find

// Don't enum bug & hidden keys

// Don't move it if it there was no text before cursor

// Don’t cache length as it changes during the loop

// E.g. (0, 0x10).

// E.g. (0, 0xD855).

// E.g. (0xD855, 0xD866).

// E.g. (0xDCFF, 0xDDFF).

// E.g. (0xFFAA, 0x10FFFF).

// E.g. `[0, 11, 12, 16]` and we’ve added 5-15, so we now have

// E.g. `[0, 11]` and you add 5-15 → `[0, 16]`.

// E.g. `[0, 3]` and you add 3-6 → `[0, 7]`.

// E.g. we have `[0, 11, 14, 31]` and want to remove 4-20

// E.g. we have `[0, 11, 40, 51]` and want to remove 0-10 → `[40, 51]`.

// E.g. we have `[0, 11]` and want to remove 4-20 → `[0, 4]`.

// E.g. we have `[0, 11]` and want to remove 4-6 → `[0, 4, 7, 11]`.

// E.g. we have `[40, 51]` and want to remove 0-100 → `[]`.

// ES2016

// ESTree requires null if it failed to instantiate RegExp object.

// Each scope gets a bitset that may contain these flags

// Early error:

// Else, just replace `end` with a new value.

// Empty lines need to contain a single empty token, denoted with { empty: true }

// End the previous range and start a new one.

// Ensure that `\0` null escapes followed by number symbols are not

// Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'

// Ensures that nodes have the correct types.

// Escape sequences from echo and printf's manuals, and escaped quotes.

// Example:

// Exit as soon as no more matching pairs can be found.

// Exit as soon as no more possibly overlapping pairs can be found.

// Exit early if `data` is an empty set.

// Expect a token of a given type. If found, consume it, otherwise,

// Export regjsgen.

// ExtendedAtom ::

// ExtendedAtom is defined in Apendix B of the ECMA-262 standard.

// ExtendedPatternCharacter ::

// Figure out if it's a module code.

// Finish an AST node, adding `type` and `end` properties.

// Finish node at given position

// For ClassEscape

// For RegExp validation

// For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape

// For tokens that include more information than their type, the value

// From JavaScript Prism keyword list and TypeScript language spec: https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#221-reserved-words

// Functions

// Generated using `npm run build`. Do not edit!

// Generated using `npm run build`. Do not edit.

// Generates a regular expression string based on an AST.

// Generates a string based on the given code point.

// Get the current line

// Get the next edit

// Get the previous edit

// Get the previous line

// Given a range of code points, add any case-folded code points in that range

// GroupName ::

// GroupName[U] ::

// GroupSpecifier ::

// GroupSpecifier[U] ::

// Handle `QuantifiableAssertion Quantifier` alternative.

// Here we are inside a tag, and not inside a JSX context.

// Here we might have entered a JSX context inside a tag

// Here we might have left a JSX context inside a tag

// Here-document with quotes around the tag

// Highlight variable names as variables in for and select beginnings.

// Highlight variable names as variables in the left-hand part

// IE 8- don't enum bug keys

// Identifier node, we switch to interpreting it as a label.

// Identifier or keyword. '\uXXXX' sequences are allowed in

// IdentityEscape ::

// If enabled, skip leading hashbang line.

// If expecting a statement and finding a slash operator, parse a

// If strarr[i] is a Token, then the match starts inside another Token, which is invalid

// If text is selected, wrap them in the characters

// If the number is not octal format and starts with zero (e.g. `091`)

// If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword

// If the statement does not start with a statement keyword or a

// If there is a $ sign at the beginning highlight $(( and )) as variable

// If there is no $ sign at the beginning highlight (( and )) as punctuation

// If this is a strict mode function, verify that argument names

// If token.content is an array, increase the stack depth and repeat this while-loop

// If u flag is given, this returns the code point at the index (it combines a surrogate pair).

// If we end up here, we have a case like /\91/. Then the

// If we're in an ES6 environment, make parsers iterable

// Ignore comments starting with { to privilege string interpolation highlighting

// Ignore selections

// In `return` (and `break`/`continue`), the keywords with

// Includes support for = and + shortcuts

// Incrementally adds only escaped chars, adding other chunks as-is

// Indent selected lines

// Initial look-ahead is used to prevent matching of blank selectors

// Initialize empty function node.

// Inlined Object.is polyfill.

// Insert indentation character at caret

// Insert tab character at caret

// Interpret and default an options object

// It can span multiple lines.

// It cannot have indented content unless it ended with a semicolon

// It could be a `General_Category` value or a binary property.

// It is not possible to accurately assert the low surrogates aren’t

// It is possible to parse multiple files into a single AST by

// It must end with a comma or an accolade or have indented content.

// It was modified only if it started with a tab

// Iterate over the data per `(start, end)` pair.

// Its start and end offset

// Its type

// It’s not a `General_Category` value, so check if it’s a binary

// JSXEmptyExpression is unique type since it doesn't actually parse anything,

// Just remove `start` and `end`.

// Just replace `end` with a new value.

// Just replace `start` with a new value.

// Just replace `start`.

// Keep track of references used before the corresponding group.

// Keyword token types.

// Keywords from N4JS language spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html

// Labels in scope.

// Limit the number of operations to 100

// Line Feed <LF>

// Line Separator <LS>

// LoneUnicodePropertyNameOrValue

// LoneUnicodePropertyNameOrValue ::

// Lookahead / Lookbehind

// Lots of redirections here, but not just that.

// Make sure the high surrogates aren’t part of a surrogate pair.

// Make sure the next range pair doesn’t overlap, e.g. `[0, 11, 12, 14]`

// Make the same message as V8.

// Make the same messages as V8.

// Match "@@ ... @@" coord lines in unified diff.

// Match all kinds of coord lines (prefixed by "+++", "---" or "***").

// Match coord lines in normal diff (starts with a number).

// Match the last word in the line

// Matches a whole line break (where CRLF is considered a single

// Merge with the next item.

// Modify this pair.

// More lines tabbed than spaced? Assume tabs, and

// Most types of statements are recognized by the keyword they

// Move the end cursor by total number of characters added

// Move the end cursor by total number of characters removed

// Move the index i to the element in strarr that is closest to from

// Move the start cursor by number of characters added in first line of selection

// Move the start cursor if first line in selection was modified

// Move to the next token

// Must be defined after the function pattern

// NOTE: Remove trailing semicolon to get an actual expression.

// NOTE: The ECMA-262 standard uses the term "Assertion" for /^/. Here the

// NOTE: This allows `yield import()` to parse correctly.

// Negative look-ahead prevents from matching things like String.capitalize

// New's precedence is slightly tricky. It must allow its argument to

// No wrapping needed.

// Nodes have their start and end characters offsets recorded in

// Non-binary properties:

// NonemptyClassRanges ::

// NonemptyClassRangesNoDash ::

// Note: `processTerm` mutates `tree` and `groups`.

// Note: `unicodeMatchPropertyValue` throws on invalid values.

// Note: `valueOf` is aliased as `toArray`.

// Note: the `- 1` makes `end` inclusive.

// Note: the `\b` escape sequence for U+0008 BACKSPACE in strings has a

// Note: the loop starts at the next index.

// Note: this updates `state.lastStringValue` property with the eaten name.

// Note: we cannot `return` just yet, in case any following pairs still

// Nothing to do here.

// Now that whole lines for other patterns are consumed,

// Number of tokens to delete and replace with the new match

// Object property

// Object type used to represent tokens. Note that normally, tokens

// Object/class getters and setters are not allowed to clash —

// Only allow octal numbers in the following. All matched numbers start

// Opening tag

// Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic

// Operators are parsed inline in tiny state machines. '=' (61) is

// Operators. These carry several kinds of properties to help the

// Optimized version since JSX identifiers can't contain

// Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).

// Otherwise, we need to guess the multiple

// Overwrite previous entry so that undo will remove whole word

// Parse JSX text

// Parse a `for`/`in` and `for`/`of` loop, which are almost

// Parse a class declaration or literal (depending on the

// Parse a full expression. The optional arguments are used to

// Parse a function declaration or literal (depending on the

// Parse a list of variable declarations.

// Parse a program. Initializes the parser, reads any number of

// Parse a regular `for` loop. The disambiguation code in

// Parse a semicolon-enclosed block of statements, handling `"use

// Parse a single statement.

// Parse a ternary conditional (`?:`) operator.

// Parse an assignment expression. This includes applications of

// Parse an atomic expression — either a single token that is an

// Parse an object literal or binding pattern.

// Parse argument.

// Parse arrow function expression with given parameters.

// Parse binary operators with the operator precedence parsing

// Parse call, dot, and `[]`-subscript expressions.

// Parse function body and check parameters.

// Parse namespaced identifier.

// Parse next token as JSX identifier

// Parse object or class method.

// Parse template expression.

// Parse the input a second time.

// Parse the next token as an identifier. If `liberal` is true (used

// Parse unary operators, both prefix and postfix.

// Parses JSX closing tag starting after '</'.

// Parses JSX expression enclosed into curly brackets.

// Parses JSX opening tag starting after '<'.

// Parses a comma-separated list of expressions, and returns them as

// Parses a comma-separated list of module exports.

// Parses a comma-separated list of module imports.

// Parses any type of JSX attribute value.

// Parses assignment pattern around given atom if possible.

// Parses element name in any form - namespaced, member

// Parses entire JSX element from current position.

// Parses entire JSX element, including it's opening tag

// Parses following JSX attribute name-value pair.

// Parses import declaration.

// Parses lvalue (assignable) atom.

// Parses module export declaration.

// Parses spread element.

// Parses yield expression inside generator.

// Parsing Atom and ExtendedAtom together due to redundancy.

// Pattern ::

// PatternCharacter ::

// Plugin to make entity title show the real entity, idea by Roman Komarov

// Pop matching opening tag

// Position information for the previous token

// Positions to delayed-check that yield/await does not exist in default parameters.

// Predicate that tests whether the next token is of the given

// Prefixed by 4 spaces or 1 tab and preceded by an empty line

// Preserve indentation on inserting a new line

// Prevent default delete behaviour

// Prevent focus change

// Process exclusion ranges

// Properties of the current token:

// Punctuation token types.

// Punctuation tokens.

// Quantifier ::

// QuantifierPrefix ::

// Quotes produce strings.

// Raise an unexpected token error.

// Read a JSX identifier (valid tag or attribute name).

// Read a single token, updating the parser object's token-related

// Read a string value, interpreting backslash-escapes.

// Read an identifier or keyword token. Will check for reserved

// Read an identifier, and return it as a string. Sets `this.containsEsc`

// Read an integer in the given radix. Return null if zero digits

// Read an integer, octal integer, or floating-point number.

// Reads a template token to search for the end, without validating any escape sequences

// Reads template string tokens.

// Recall the negative decision to decide if the input must be parsed

// RegExpIdentifierContinue ::

// RegExpIdentifierName ::

// RegExpIdentifierName[U] ::

// RegExpIdentifierPart[U] ::

// RegExpIdentifierStart ::

// RegExpIdentifierStart[U] ::

// Reject parenthesized strings.

// Remove ellipsis on spread property

// Remove tab character at caret

// Remove the other, now redundant, item.

// Remove the previously added `end` and the current `start`.

// Remove this pair.

// Replace : with = if Property::transpile inserted the :

// Replace `[start, end]` with `[startA, endA, startB, endB]`.

// Replace `[start, end]` with `[startB, endB]`.

// Replace `end` with `rangeStart`.

// Replace `end` with the new value.

// Reset output for async (no inline) evaluation

// Reset the position again, as maybe only parts of the previous

// RestElement inside of a function parameter must be an identifier

// Returns whether any transforms that will happen use `arguments`

// Reused empty array added for node fields that are always empty.

// SEE: https://github.com/jviereck/regjsparser/issues/70

// SEE: https://www.ecma-international.org/ecma-262/10.0/index.html#prod-annexB-ExtendedPatternCharacter

// Sass comments don't need to be closed, only indented

// Save current state of the input

// Save last selection state

// Save the changes

// Scope tracking for duplicate variable names (see scope.js)

// See 15.10.2.15:

// See ECMA-262 Standard: 15.10.1

// See below

// See https://github.com/mozilla/sweet.js/wiki/design

// Set `ExpressionStatement#directive` property for directive prologues.

// Set `allowReserved` to a boolean value to explicitly turn this on

// Set up token state

// Should we highlight user defined functions too?

// Something went terribly wrong, ABORT, ABORT!

// Sometimes, block scope declarations change name during transpilation

// Special case for function names as bound inside the function

// Split by newlines

// Start a new scope with regard to labels and the `inFunction`

// Start an AST node, attaching a start offset.

// Start the precedence parser.

// Step 1: `(startHigh, startLow)` to `(startHigh, LOW_SURROGATE_MAX)`.

// Step 2: `(startHigh + 1, LOW_SURROGATE_MIN)` to

// Step 3. `(endHigh, LOW_SURROGATE_MIN)` to `(endHigh, endLow)`.

// Strings are multiline

// Succinct definitions of keyword token types

// SuperCall:

// SuperProperty:

// Support for Here-documents https://en.wikipedia.org/wiki/Here_document

// Switch the grammar back

// Switch the grammar to markup

// SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term

// TODO deprecate this? not really very useful

// TODO https://gitlab.com/Rich-Harris/buble/issues/8

// TODO implement proper continue...

// TODO is this block necessary?...

// TODO is this right?

// TODO last chunk in the array may not be the last chunk, if it's moved...

// TODO other cases where it's safe

// TODO prefer single quotes?

// TODO there's a bunch of this sort of thing, needs cleaning up

// TODO this function is slightly flawed – it works on the original string,

// TODO: Optimize this by writing and using `dataIntersectionData()`.

// TODO: consider changing this at the regenerate level.

// Taken from the Esprima parser.

// Targets

// Term ::

// Test whether a given character code starts an identifier.

// Test whether a given character is part of an identifier.

// Test whether a semicolon can be inserted at the current position.

// Tests whether parsed token is a contextual keyword.

// Thank's IE8 for his funny defineProperty

// That's not a problem for the way that it's currently used, but it could

// That's plain text: drop any tokens matched.

// The `beforeExpr` property is used to disambiguate between regular

// The `default` clause is only here as a safeguard; it should never be

// The `getLineInfo` function is mostly useful when the

// The `startsExpr` property is used to check if the token ends a

// The `super` keyword can appear at below:

// The `tokenizer` export provides an interface to the tokenizer.

// The algorithm used to determine whether a regexp can appear at a

// The assignment of fine-grained, information-carrying type objects

// The check for `tt.name && exprAllowed` detects whether we are

// The context stack is used to superficially track syntactic

// The current position of the tokenizer in the input.

// The data set contains BMP code points that are not high surrogates

// The data set contains astral code points; append character classes

// The different types of PHP strings "replace" the C-like standard string

// The following will handle plain text inside tags

// The format of `surrogateMappings` is as follows:

// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.

// The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of

// The interpretation of a dot depends on whether it is followed

// The last word of the previous line and current line match

// The loop has finished without doing anything; add the new pair to the end

// The loop has finished; add the new pair to the end of the data set.

// The main exported interface (under `self.acorn` when in the

// The new range is a superset of the old range.

// The new range lies entirely within an existing range pair. No action

// The pattern consists of two parts, i.e. `Property=Value`.

// The production ClassEscape :: b evaluates by returning the

// The quantifier contains the atom. Therefore, the beginning of the

// The range has already been added to the set; at this point, we just

// The range starts and ends after the low surrogate range.

// The range starts and ends before the high surrogate range.

// The range starts and ends in the astral range.

// The range starts and ends in the high surrogate range.

// The range starts and ends in the low surrogate range.

// The range starts before the high surrogate range and ends after the

// The range starts before the high surrogate range and ends in the low

// The range starts before the high surrogate range and ends within it.

// The range starts in the high surrogate range and ends after the low

// The range starts in the high surrogate range and ends in the low

// The range starts in the low surrogate range and ends after the low

// The spec requires to interpret the `\2` in `/\2()()/` as backreference.

// There’s no need to account for astral symbols / surrogate pairs here,

// These are a run-length and offset encoded representation of the

// These are used when `options.locations` is on, for the

// These nest, from the most general expression type at the top to

// This duplicates behavior from Property::transpile which is disabled

// This function is used to raise exceptions on parse errors. It

// This function tries to parse a single expression at a given

// This has a complexity linear to the value of the code. The

// This is the function that is called to fetch the next token. It

// This looks ugly, but we're creating specialized arrays with a specific

// This must be declared before keyword because we use "function" inside the look-forward

// This value, if given, is stored in every node, whether

// To disallow parenthesized identifier via `this.toAssignable()`.

// To disallow trailing comma via `this.toAssignable()`.

// To fix https://github.com/acornjs/acorn/issues/575

// Toggle capturing tab key so users can focus away

// Toggle strict mode. Re-reads the next number or string to please

// Token-specific context update code

// Transforms JSX element name to string.

// Transpilation arguments

// Traverse a language definition with Depth First Search

// Trigger redo with Ctrl+Shift+Z on other platforms

// Trigger redo with Ctrl+Y on Windows

// Trigger redo with ⌘+Shift+Z on Mac

// Trigger undo with Ctrl+Z on other platforms

// Trigger undo with ⌘+Z on Mac

// Trim leading whitespace

// Trim trailing comma because it can easily become a leading comma which is illegal

// UTF-16 Decoding

// Unicode surrogate pair

// UnicodePropertyName ::

// UnicodePropertyName `=` UnicodePropertyValue

// UnicodePropertyValue ::

// UnicodePropertyValueExpression ::

// Unindent selected lines

// Unreachable since it threw "unterminated regular expression" error before.

// Update caret position

// Update information about previous labels on this node

// Update references in other language definitions

// Update values and selection state

// Use `\0` instead of `\x00` where possible.

// Used as a reference to the global object.

// Used in checkLVal and declareName to determine the type of a binding

// Used to check objects for own properties.

// Used to determine if values are of the language type `Object`.

// Used to generate strings for each node type.

// Used to read character escape sequences ('\x', '\u', '\U').

// Used to read escaped characters

// Used to signal to callers of `readWord1` whether the word

// Used to signify the start of a potential arrow function

// Validate pattern

// Variable declaration (the colon must be consumed!)

// Variable usage

// Verify that a node is an lval — something that can be assigned

// Verify that there is an actual destination to break or

// We are in an Object.assign context, so we need to wrap regular properties

// We can't match functions property, so let's not even try.

// We found a tag, now find its kind

// We want non-word chars around "-" because it is

// We want to consume the whole line

// When `locations` is on, `loc` properties holding objects with

// When `locations` is on, you can pass this to record the source

// When enabled, a return at the top level is not considered an

// When enabled, await identifiers are allowed to appear at the top-level scope,

// When enabled, hashbang directive in the beginning of file

// When enabled, import/export statements are not constrained to

// When enabled, parenthesized expressions are represented by

// When something updates, drop the redo operations

// When the `locations` option is on, two more parameters are

// Without the global flag, lastIndex won't work

// Wrap the pattern in a non-capturing group.

// [0]: Arithmetic Environment

// [1]: Command Substitution

// [2]: Brace expansion

// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API

// [example] [id]

// [example](http://example.com "Optional title")

// [example][id]

// [id]: <http://example.com> "Optional title"

// [id]: http://example.com "Optional title"

// [id]: http://example.com 'Optional title'

// [id]: http://example.com (Optional title)

// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser

// [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678

// [semi-standardized][range] `range` property holding a `[start,

// \[lookahead = c]

// \b \B

// ^, $

// __strong__

// _em_

// `(endHigh - 1, LOW_SURROGATE_MAX)`.

// `0,16` range that was previously added.

// `<!--`, an XML-style comment that should be interpreted as a line comment

// `NaN`, `+Infinity`, or `-Infinity`

// `[0, 16, 12, 16]`. Remove the `12,16` part, as it lies within the

// `[start, end]` pair before the current pair, or after the current pair

// `\2` is handled. In case the local decision turns out to be wrong after

// ```

// ```optional language

// ``code``

// `allowEmpty` can be turned on to allow subsequent commas with

// `binop`, when present, specifies that this operator is a binary

// `class` and `function` keywords push new context into this.context.

// `code`

// `ecmaVersion` indicates the ECMAScript version to parse. Must be

// `end` doesn’t. E.g. `[0, 11, 12, 31]` and we’ve added 5-15, so

// `end` lies within the range that was previously added as well,

// `if (foo) /blah/.exec(foo)`, where looking at the previous token

// `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as

// `isLoop` marks a keyword as starting a loop, which is important

// `isStatement` parameter).

// `locations` is on or off.

// `locations` option is off (for performance reasons) and you

// `minPrec` provides context that allows the function to stop and

// `new`, or an expression wrapped in punctuation like `()`, `[]`,

// `onInsertedSemicolon` can be a callback that will be called

// `onTrailingComma` is similar to `onInsertedSemicolon`, but for

// `parseStatement` will already have parsed the init statement or

// `prefix` and `postfix` mark the operator as a prefix or postfix

// `program` argument.  If present, the statements will be appended

// `program` option in subsequent parses. This will add the

// `sourceType` indicates the mode the code should be parsed in.

// `startLoc` and `endLoc` properties.

// `start` and `end` properties (directly on the node, rather than

// `start` and `end` properties in `{line, column}` form (with

// `start` lies within the range that was previously added, but

// `start` lies within the range that was previously added.

// `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion

// `text` is the content of the comment, and `start` and `end` are

// `true`.

// `tt.name`.

// `yield` expression. It is set on all token types that either can

// a capacity of 17 after pushing the first item), or slicing out a subarray

// a second time with the total normal-groups.

// a selector must start at the end of a property or after a brace (end of other rules or nesting)

// a single range, e.g. `dataAdd([0, 4, 5, 10], 4)` → `[0, 10]`.

// a) and c)

// a) function foo {

// a..z

// accepted in property names.

// account for dedented class constructors

// add 'maybe-class-name' to tokens which might be a class name

// add a token for each prefix

// add alias

// add doc comment: /** */

// add function

// additional transforms, not from

// advancing the input stream and returning an AST node. Precedence

// after a `yield` or `of` construct. See the `updateContext` for

// algorithm. `left` is the left-hand side of the operator.

// allow for multiline macro definitions

// allow function declarations in branches, but only in non-strict mode

// allow one nested instance of bold text using the same delimiter

// allow one nested instance of italic text using the same delimiter

// allows the tokenizer to store the information it has about a

// an array. `close` is the token type that ends the list, and

// an off. When this option has the value "never", reserved words

// and keywords can also not be used as property names.

// and object pattern might appear (so it's possible to raise

// and provide reference for storing '=' operator inside shorthand

// and so it should start at the end of last read token (left brace) and finish

// and the second argument - flag - preferred type is a string

// and you add 5-15 → `[0, 16]`, i.e. remove the `12,14` part.

// and, *if* the syntactic construct they handle is present, wrap

// appearing at the top of the program.

// are not repeated, and it does not try to bind the words `eval`

// argument list.

// argument to parseSubscripts to prevent it from consuming the

// as a micro-optimization.

// as normal characters.

// as second argument.

// associated segment data).

// assumption is that looking up astral identifier characters is

// at the beginning of the next one (right brace).

// b)

// b) foo() {

// based on the java naming conventions

// based on their surrogate pairs.

// be a `[]` or dot subscript expression, but not a call — at least,

// be followed by an expression (thus, a slash after them would be a

// be in future...

// be numeric, and `1 + 2 + '3' === '33'`)

// be used here.

// because they might be escaped, we need a lookbehind, so we use Prism

// binary operators with a very low precedence, that should result

// bind

// bind timers to global for call from export context

// bindingType can be either:

// bit hacky...

// boolean indicating whether this is a block (`/* */`) comment,

// brace, it's an ExpressionStatement or LabeledStatement. We

// breaks loose when it comes to block scoping

// browser) is a `parse` function that takes a code string and

// but in some cases (e.g. `for` statements), we need to create

// but not “foo {”

// but they are still not allowed in non-async functions.

// by a digit or another two dots.

// by isIdentifierStart in readToken.

// c ClassControlLetter

// c) function foo() {

// callback—that will corrupt its internal state.

// can "pass" as a selector- e.g: proper#{$erty})

// cause Acorn to call that function with `(block, text, start,

// cause Acorn to call that function with object in the same

// change parameter name when same as method name

// character offsets that denote the start and end of the comment.

// characters it is given as second argument, and returns a token

// characters.

// check 'async [no LineTerminator here] function'

// check for keywords used as local names

// circular references

// code block

// complexity.

// contain matching code points.

// contained any escape sequences. This is needed because words with

// contains in native

// context to predict whether a regular expression is allowed in a

// continue an expression (like the body of a string).

// continue jumps to that label.

// continue to.

// convert regex to object

// corresponding to those offsets

// create a synthetic block statement, otherwise all hell

// default to tabs in the case of a tie (or nothing

// defer further parser to one of its callers when it encounters an

// delayed syntax error at correct position).

// destructuring is part of an expression - need an rvalue

// different meaning in regular expressions (word boundary), so it cannot

// directly start an expression (like a quotation mark) or can

// disregard the `bar` in `class Foo { bar () {...} }`

// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`

// div.innerHTML = `<p></p>`

// do not consider JSX expr -> JSX open tag -> ... anymore

// does not help.

// due to its instance

// easy to recognize.

// edge case (#80)

// either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10

// either with each other or with an init property — and in

// enabled, it is given the location as a `{line, column}` object

// enclose run of non-spread properties in curlies

// end of the comments. Note that you are not allowed to call the

// end)` parameters whenever a comment is skipped. `block` is a

// end]` array with the same numbers, set the `ranges` option to

// ensure constructor is first

// erase trailing comma after last array element if not an array hole

// error.

// errors

// escape characters and so can be read as single slice.

// escape sequences must not be interpreted as keywords.

// eslint-disable-line no-console

// eslint-disable-line no-undef

// eslint-disable-line no-unused-vars

// eslint-disable-next-line camelcase

// eslint-disable-next-line comma-spacing

// eslint-disable-next-line no-constant-condition

// eslint-disable-next-line no-prototype-builtins

// eslint-disable-next-line no-self-compare

// eslint-disable-next-line no-unused-vars

// eslint-disable-next-line react/jsx-key

// exception if _P_ did not conform to the grammar, if any elements of _P_

// exponentiation operator ** and **=

// export

// export * from '...'

// export default ...

// export native or passed

// export var|const|let|function|class ...

// export { x, y as z } [from '...']

// expression, an expression started by a keyword like `function` or

// expression.

// expressions and divisions. It is set on all token types that can

// extend global

// fallback for non-array-like ES3 and non-enumerable old V8 strings

// falls through

// falls through to AssignmentPattern

// false -> Array#indexOf

// false indicates no spread elements

// file in every node's `loc` object.

// find start chunk

// first field

// first number only here - other number-characters

// first slash is to be ignored and the 9 & 1 to be treated

// first, the easy part – `**=` -> `=`

// flag (restore them to their old value afterwards).

// for array literals).

// for computed properties or if conciseMethodProperty is false

// forbid the `in` operator (in for loops initalization expressions)

// forced

// format as tokens returned from `tokenizer().getToken()`. Note

// found end chunk before start

// function bodies).

// function expression IDs belong to the child scope...

// function that parses unary prefix operators is called first, and

// functions to specify precedence, for all of the ten binary

// generated by bin/generate-identifier-regex.js

// get dirname

// get string content

// given point in the program is loosely based on sweet.js' approach.

// given position.

// global

// gql`...`, graphql`...`, graphql.experimental`...`

// handle block scoping

// highlight macro directives as keywords

// highlight predefined macros as constants

// highlight the path of the include statement as a string

// html`<p></p>`

// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is

// https://featuretests.io

// https://gist.github.com/mathiasbynens/bbe7f870208abcfec860

// https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028

// https://gitlab.com/Rich-Harris/buble/issues/154

// https://mathiasbynens.be/notes/javascript-encoding#surrogate-pairs

// https://mathiasbynens.be/notes/javascript-escapes#single

// https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative

// https://www.ecma-international.org/ecma-262/8.0/#prod-Atom

// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass

// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape

// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom

// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash

// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges

// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape

// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter

// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits

// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape

// https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction

// https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits

// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit

// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits

// https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence

// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges

// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash

// https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit

// https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern

// https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter

// https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier

// https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix

// https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence

// https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence

// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term

// https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html

// i.e. an arrow function expression like `a => a`

// i.e.:

// identifiers, so '\' also dispatches to that.

// identifiers.

// if a let/const declaration in the function clashes with one of the params.

// if chunk was trimmed, we have a new lastChunk

// if it's the empty string, but only if the second and

// if it's the entire body of a function without a block statement –

// if possible.

// if there is a known `lastIndex`.

// import '...'

// import defaultObj, { x, y as z } from '...'

// in AssignmentExpression nodes.

// in turn calls the function that parses `[]` subscripts — that

// include all expressions

// include all non-empty strings

// inside function expressions

// instead of `(!x)[1]` is handled by the fact that the parser

// instead of the ES6 spec version, we didn't implement @@toPrimitive case

// into it.

// into.

// is 9.

// is a QuantifiableAssertion.

// is a regular `for` loop.

// is allowed and treated as a line comment.

// is somewhat obscure, because it works in character codes rather

// it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable

// jviereck: allow ']', '}' here as well to be compatible with browser's

// keep in mind that we don't support arrays

// keywords are the first word in a line preceded be an `@` or surrounded by curly braces.

// length 1 (it's probably rare for a source substring to not have an

// length 5 (since not everything will have an associated name), followed by

// length. This is much faster than creating a new array (which v8 expands to

// like ordinary characters. Create a character for the

// line being 1-based and column 0-based) will be attached to the

// line break). Used to count lines.

// loop is non-trivial. Basically, we have to parse the init `var`

// low surrogate range. E.g. (0, 0x10FFFF).

// maintains `context` and `exprAllowed`, and skips the space after

// make prefixes available to Diff plugin

// matched numbers are actual octal numbers. E.g. in '019' only

// md`# h1`, markdown`## h2`

// message.

// minus `LineTerminator`s (https://mths.be/es6#sec-line-terminators):

// mixin parameters

// module.parent = undefined by default

// must be inserting at the end

// naked function expression

// need to get rid of the following ranges in case they overlap.

// needed for astral code points in the set.

// needed.

// next token is a colon and the expression was a simple

// no default

// no rvalue needed for expression statement

// nodes.

// noop

// normally the scope gets created here, during initialisation,

// not a valid Unicode code point

// not its current edited state.

// not support lookbehind.

// not without wrapping it in parentheses. Thus, it uses the noCalls

// nothing in between them to be parsed as `null` (which is needed

// now we have `[0, 16, 12, 31]`. This must be written as `[0, 31]`.

// number is in an octal format). If it is NOT octal format,

// number, or float.

// object literal concise method

// of an existing parse tree.

// of assignments (“=” and “+=”).

// of constructs (for example, the fact that `!x[1]` means `!(x[1])`

// of the data set.

// of the error message, and then raises a `SyntaxError` with that

// of the type given by its first argument.

// offset in a string. Useful for parsing mixed-language formats

// offset starts at 0x10000, and each pair of numbers represents an

// offset to the next range, and then a size of the range. They were

// offset. `input` should be the code string that the offset refers

// often referred to. `finishOp` simply skips the amount of

// omit space before closing paren if

// omit space before closing paren if this is on a separate line

// operator precedence, because it is much more compact than using

// operator that has a lower precedence than the set it is parsing.

// operator, and will refer to its precedence.

// operators like `+=`.

// optional / simple context binding

// optional arguments, we eagerly look for a semicolon or the

// options

// or "arguments" and duplicate parameters.

// or `arguments`.

// or `{}`.

// or single identifier.

// parsed it is impossible to make these decisions at the point when the

// parser from the callback—that will corrupt its internal state.

// parser use them properly (the presence of these properties is

// parsing contains a |GroupName|, reparse with the goal symbol

// part (semicolon immediately after the opening parenthesis), it

// part of a surrogate pair, since JavaScript regular expressions do

// passed, the full `{line, column}` locations of the start and

// passing the tree produced by parsing the first file as

// pattern: /^(?:[_].*(?:\r\n?|\n|(?![\s\S])))+/m

// pedantic tests (`"use strict"; 010;` should fail).

// possibility to insert one.

// pow(2, 53) - 1 == 9007199254740991

// precedence levels that JavaScript defines.

// pretend that there is a semicolon at this position.

// properties.

// property assignment in contexts where both object expression

// property. Note: `unicodeMatchProperty` throws on invalid properties.

// proto

// quantifier range is given by the beginning of the atom.

// raise an unexpected token error.

// rare.

// reached. Code coverage tools should ignore it.

// real proto method for `library`

// reconsider as closing tag context

// regjsparser

// regular expression literal. This is to handle cases like

// regular expression).

// remove arrow

// remove whitespace-only literals, unless on a single line

// replace all interpolations with a placeholder which is not in the code already

// replace newlines with spaces

// reserved words, and support for new syntax features. The default

// reset because shorthand default was used correctly

// returns an abstract syntax tree as specified by [Mozilla parser

// reverse Prism.util.encode

// right position.

// safe

// same from parser's perspective.

// save all loops up to the lexical boundary in case we need

// second field

// see if any block-scoped declarations are referenced

// see the pattern in prism-javascript.js

// selectors and mixins are considered the same

// set later on

// shadowing declarations after this expression

// should work with symbols and should have deterministic property order (V8 bug)

// simply exist as properties on the parser object. This is only

// simply start parsing an expression, and afterwards, if the

// since `codePointToString` is private and only used for BMP code points.

// since there can be lot more things (var, @ directive, nesting..)

// so remove this pair.

// spaces after the # character compile fine with gcc

// special case

// special case – [ ...arguments ]

// special case – `super( ...args )`

// special case – body-less if/for/while statements. TODO others?

// special case – https://gitlab.com/Rich-Harris/buble/issues/11

// special case – https://gitlab.com/Rich-Harris/buble/issues/150

// special case – we may be able to skip the first element,

// special case...

// standalone expression statement

// standard built-ins

// start opening tag context

// start with. Many are trivial to parse, some require a bit of

// statement or expression, disallowing the `in` operator (see

// statements, and wraps them in a Program node.  Optionally takes a

// static

// straightforward appendLeft and keep correct order...

// strict mode and parsing of `import` and `export` declarations.

// strict mode, init properties are also not allowed to be repeated.

// strict"` declarations when `allowStrict` is true (used for

// styled-components:

// styled-jsx:

// surrogate range. E.g. (0, 0xDCFF).

// surrogate range. E.g. (0xD855, 0x10FFFF).

// surrogate range. E.g. (0xD855, 0xDCFF).

// surrogate range. E.g. (0xDCFF, 0x10FFFF).

// svg`<path fill="#fff" d="M55.37 ..."/>`

// syntactic elements, and recursively calling those, each function

// takes an offset integer (into the current `input`) to indicate

// th position of the comma as an offset, and if `locations` is

// than characters, and because operator parsing has been inlined

// that embed JavaScript expressions.

// that you are not allowed to call the parser from the

// the '01' should be matched.

// the AST node that the inner parser gave them in another node.

// the `loc` object, which holds line/column data. To also add a

// the body of the statement

// the embedded language isn't registered.

// the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var

// the functions will simply let the function(s) below them parse,

// the location of the error, attaches the position to the end

// the only time we could have an identifier node without a parent is

// the parser process. These options are recognized:

// the parsing has finished, the input string is parsed a second time with

// the same node. We don't want to wrap an object twice

// the scope early, as it pertains to both the init block and

// the second parameter to `parseExpression`), and then check

// the technique outlined above, which uses different, nesting

// the token, so that the next one's `start` will point at the

// the total number of capture groups set.

// then only the zeros `0` is treated here and the `91` are ordinary

// then the slash is ignored and the number is matched later

// third elements aren't both expressions (since they maybe

// this contains only a few commonly used DOM variables

// this feels a tiny bit hacky, but we can't do a

// this is populated as and when reassignments occur

// this might be a language that Prism does not support

// this one was hard to do, so please be careful if you edit this one :)

// this pair.

// this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)

// title 1

// title 2

// to a set.

// to alias them later for block-scoped declarations

// to be removed.

// to go on)

// to indexed object, toObject with fallback for non-array-like ES3 strings

// to its body instead of creating a new node.

// to know when parsing a label, in order to allow or disallow

// to whether the word contained a '\u' escape.

// to.

// tokExprAllowed stays unchanged

// token in a way that is very cheap for the parser to look up.

// toplevel forms of the parsed file to the `Program` (top) node

// trailing commas.

// treat as beginning of JSX expression

// treated as backreferences.

// true  -> Array#includes

// true indicates some spread elements

// type bitmap

// type, and if yes, consumes it as a side effect.

// unary operator.

// url, compassified

// used for debugging, without the noise created by

// used for the onToken callback and the external tokenizer.

// vanilla template string

// var and interpolated vars

// variables and parameters

// want to find the line/column position for a given character

// way, it'll receive the node for `x[1]` already parsed, and wraps

// we make these non-enumerable, for sanity while debugging

// we might push to the array during consolidation, so don't cache length

// we need to handle super() and super.method() differently

// were not matched by the parse, or if any Early Error conditions exist.

// were read, the integer value otherwise. When `len` is given, this

// what categorizes them as operators).

// what's left should be selectors

// when a semicolon is automatically inserted. It will be passed

// when method name is a string or a number let's pretend it's a computed method

// when parsing properties), it will also convert keywords into

// whether the next token is `in` or `of`. When there is no init

// which variables are declared in the init statement?

// whitespace and comments, and.

// will return `null` unless the integer has exactly `len` digits.

// with a zero (if the do not, the previous if-branch is executed).

// with e.g. shorthand properties, key and value are

// words when necessary.

// workaround for Safari 9/WebKit bug:

// wrap

// wrap naked parameter

// wrap the whole thing in Object.assign

// zero-length edited chunks are a special case (overlapping replacements)

// { [name]: index }

// |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*

// ~strike~

// ~~strike through~~

// “Normal” string

// → No expansion (so no “inside”).

// → `[0, 4, 21, 31]`.

//# sourceMappingURL=buble-browser.es.js.map

//# sourceMappingURL=index.js.map

//# sourceMappingURL=sourcemap-codec.es.js.map
