rregex 1.8.1 → 1.8.2

package/lib/browser.d.ts

@@ -1,1077 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/**
-* Escapes all regular expression meta characters in `text`.
-*
-* The string returned may be safely used as a literal in a regular
-* expression.
-* @param {string} text
-* @returns {string}
-*/
-export function escape(text: string): string;
-/**
- * Represents a single match of a regex in a haystack.
- */
-export type Match = {
-  start: number
-  end: number
-  value: string
-}
-
-/**
- * Captures represents a group of captured strings for a single match.
- *
- * The 0th capture always corresponds to the entire match. Each subsequent index
- * corresponds to the next capture group in the regex. If a capture group is named,
- * then the matched string is also available via the name property. (Note that the
- * 0th capture is always unnamed and so must be accessed with the get property.)
- *
- * Positions returned from a capture group are always byte indices.
- */
-export type Captures = {
-  get: Match[]
-  name: Record<string, Match>
-}
-
-/**
- * A high-level intermediate representation (HIR) for a regular expression.
- */
-export type Hir = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::Hir'
-  kind: HirKind
-}
-
-/**
- * The underlying kind of an arbitrary `Hir` expression.
- *
- * An `HirKind` is principally useful for doing case analysis on the type of a
- * regular expression. If you're looking to build new `Hir` values, then you must
- * use the smart constructors defined on `Hir`, like `Hir::repetition`, to build
- * new `Hir` values. The API intentionally does not expose any way of building an
- * `Hir` directly from an `HirKind`.
- */
-export type HirKind =
-  | HirKindEmptyVariant
-  | HirKindLiteralVariant
-  | HirKindClassVariant
-  | HirKindLookVariant
-  | HirKindRepetitionVariant
-  | HirKindCaptureVariant
-  | HirKindConcatVariant
-  | HirKindAlternationVariant
-
-/**
- * The empty regular expression, which matches everything, including the empty string.
- */
-export type HirKindEmptyVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Empty'
-}
-
-/**
- * A literal string that matches exactly these bytes.
- */
-export type HirKindLiteralVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Literal'
-  '@values': [Literal]
-}
-
-/**
- * A single character class that matches any of the characters in the class.
- * A class can either consist of Unicode scalar values as characters, or it can
- * use bytes.
- *
- * A class may be empty. In which case, it matches nothing.
- */
-export type HirKindClassVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Class'
-  '@values': [Class]
-}
-
-/**
- * A look-around assertion. A look-around match always has zero length.
- */
-export type HirKindLookVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Look'
-  '@values': [Look]
-}
-
-/**
- * A repetition operation applied to a sub-expression.
- */
-export type HirKindRepetitionVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Repetition'
-  '@values': [Repetition]
-}
-
-/**
- * A capturing group, which contains a sub-expression.
- */
-export type HirKindCaptureVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Capture'
-  '@values': [Capture]
-}
-
-/**
- * A concatenation of expressions.
- *
- * A concatenation matches only if each of its sub-expressions match one after
- * the other.
- *
- * Concatenations are guaranteed by `Hir`'s smart constructors to always have at
- * least two sub-expressions.
- */
-export type HirKindConcatVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Concat'
-  '@values': [Hir[]]
-}
-
-/**
- * An alternation of expressions.
- *
- * An alternation matches only if at least one of its sub-expressions match.
- * If multiple sub-expressions match, then the leftmost is preferred.
- *
- * Alternations are guaranteed by `Hir`'s smart constructors to always have at
- * least two sub-expressions.
- */
-export type HirKindAlternationVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Alternation'
-  '@values': [Hir[]]
-}
-
-/**
- * The high-level intermediate representation of a literal.
- *
- * A literal corresponds to 0 or more bytes that should be matched literally.
- * The smart constructors defined on `Hir` will automatically concatenate adjacent
- * literals into one literal, and will even automatically replace empty literals
- * with `HirKind::Empty`.
- */
-export type Literal = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::Literal'
-  '@values': [Uint8Array]
-}
-
-/**
- * The high-level intermediate representation of a character class.
- *
- * A character class corresponds to a set of characters. A character is either
- * defined by a Unicode scalar value or a byte. Unicode characters are used by
- * default, while bytes are used when Unicode mode (via the `u` flag) is disabled.
- *
- * A character class, regardless of its character type, is represented by a
- * sequence of non-overlapping non-adjacent ranges of characters.
- *
- * Note that `Bytes` variant may be produced even when it exclusively matches
- * valid UTF-8. This is because a `Bytes` variant represents an intention by the
- * author of the regular expression to disable Unicode mode, which in turn
- * impacts the semantics of case insensitive matching. For example, `(?i)k` and
- * `(?i-u)k` will not match the same set of strings.
- */
-export type Class =
-  | ClassUnicodeVariant
-  | ClassByteVariant
-
-/**
- * A set of characters represented by Unicode scalar values.
- */
-export type ClassUnicodeVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::Class'
-  '@variant': 'Unicode'
-  '@values': [ClassUnicode]
-}
-
-/**
- * A set of characters represented by arbitrary bytes (one byte per character).
- */
-export type ClassByteVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::Class'
-  '@variant': 'Bytes'
-  '@values': [ClassBytes]
-}
-
-/**
- * A set of characters represented by Unicode scalar values.
- */
-export type ClassUnicode = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::ClassUnicode'
-
-  /** The underlying ranges as a slice. */
-  ranges: ClassUnicodeRange[]
-}
-
-/**
- * A single range of characters represented by Unicode scalar values.
- *
- * The range is closed. That is, the start and end of the range are included in
- * the range.
- */
-export type ClassUnicodeRange = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::ClassUnicodeRange'
-
-  /**
-   * Return the start of this range.
-   *
-   * The start of a range is always less than or equal to the end of the range.
-   */
-  start: string
-
-  /**
-   * Return the end of this range.
-   *
-   * The end of a range is always greater than or equal to the start of the range.
-   */
-  end: string
-
-  /**
-   * The number of codepoints in this range.
-   */
-  len: number
-}
-
-/**
- * A set of characters represented by arbitrary bytes (where one byte corresponds
- * to one character).
- */
-export type ClassBytes = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::ClassBytes'
-
-  /** The underlying ranges as a slice. */
-  ranges: ClassBytesRange[]
-}
-
-/**
- * A single range of characters represented by arbitrary bytes.
- *
- * The range is closed. That is, the start and end of the range are included in
- * the range.
- */
-export type ClassBytesRange = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::ClassBytesRange'
-
-  /**
-   * The start of this range.
-   *
-   * The start of a range is always less than or equal to the end of the range.
-   */
-  start: number
-
-  /**
-   * The end of this range.
-   *
-   * The end of a range is always greater than or equal to the start of the range.
-   */
-  end: number
-
-  /**
-   * The number of bytes in this range.
-   */
-  len: number
-}
-
- /**
- * The high-level intermediate representation for a look-around assertion.
- *
- * An assertion match is always zero-length. Also called an “empty match.”
- */
-export type Look =
-  | LookStartVariant
-  | LookEndVariant
-  | LookStartLFVariant
-  | LookEndLFVariant
-  | LookStartCRLFVariant
-  | LookEndCRLFVariant
-  | LookWordAsciiVariant
-  | LookWordAsciiNegateVariant
-  | LookWordUnicodeVariant
-  | LookWordUnicodeNegateVariant
-
-/**
- * Match the beginning of text. Specifically, this matches at the starting
- * position of the input.
- */
-export type LookStartVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'Start'
-}
-
-/**
- * Match the end of text. Specifically, this matches at the ending position of
- * the input.
- */
-export type LookEndVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'End'
-}
-
-/**
- * Match the beginning of a line or the beginning of text. Specifically, this
- * matches at the starting position of the input, or at the position immediately
- * following a `\n` character.
- */
-export type LookStartLFVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'StartLF'
-}
-
-/**
- * Match the end of a line or the end of text. Specifically, this matches at the
- * end position of the input, or at the position immediately preceding a `\n`
- * character.
- */
-export type LookEndLFVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'EndLF'
-}
-
-/**
- * Match the beginning of a line or the beginning of text. Specifically, this
- * matches at the starting position of the input, or at the position immediately
- * following either a `\r` or `\n` character, but never after a `\r` when a `\n`
- * follows.
- */
-export type LookStartCRLFVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'StartCRLF'
-}
-
-/**
- * Match the end of a line or the end of text. Specifically, this matches at the
- * end position of the input, or at the position immediately preceding a `\r` or
- * `\n` character, but never before a `\n` when a `\r` precedes it.
- */
-export type LookEndCRLFVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'EndCRLF'
-}
-
-/**
- * Match an ASCII-only word boundary. That is, this matches a position where the
- * left adjacent character and right adjacent character correspond to a word and
- * non-word or a non-word and word character.
- */
-export type LookWordAsciiVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordAscii'
-}
-
-/**
- * Match an ASCII-only negation of a word boundary.
- */
-export type LookWordAsciiNegateVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordAsciiNegate'
-}
-
-/**
- * Match a Unicode-aware word boundary. That is, this matches a position where
- * the left adjacent character and right adjacent character correspond to a word
- * and non-word or a non-word and word character.
- */
-export type LookWordUnicodeVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordUnicode'
-}
-
-/**
- * Match a Unicode-aware negation of a word boundary.
- */
-export type LookWordUnicodeNegateVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordUnicodeNegate'
-}
-
-/**
- * The high-level intermediate representation of a repetition operator.
- *
- * A repetition operator permits the repetition of an arbitrary sub-expression
- */
-export type Repetition = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::Repetition'
-
-  /**
-   * The minimum range of the repetition.
-   *
-   * Note that special cases like `?`, `+` and `*` all get translated into the
-   * ranges `{0,1}`, `{1,}` and `{0,}`, respectively.
-   *
-   * When `min` is zero, this expression can match the empty string regardless
-   * of what its sub-expression is.
-   */
-  min: number
-
-  /**
-   * The maximum range of the repetition.
-   *
-   * Note that when `max` is `undefined`, `min` acts as a lower bound but where
-   * there is no upper bound. For something like `x{5}` where the min and max
-   * are equivalent, `min` will be set to `5` and `max` will be set to `5`.
-   */
-  max?: number
-
-  /**
-   * Whether this repetition operator is greedy or not. A greedy operator will
-   * match as much as it can. A non-greedy operator will match as little as it
-   * can.
-   *
-   * Typically, operators are greedy by default and are only non-greedy when a
-   * `?` suffix is used, e.g., `(expr)*` is greedy while `(expr)*?` is not.
-   * However, this can be inverted via the `U` “ungreedy” flag.
-   */
-  greedy: boolean
-
-  /**
-   * The expression being repeated.
-   */
-  sub: Hir
-}
-
-/**
- * The high-level intermediate representation for a capturing group.
- *
- * A capturing group always has an index and a child expression. It may also
- * have a name associated with it (e.g., `(?P<foo>\w)`), but it's not necessary.
- *
- * Note that there is no explicit representation of a non-capturing group in a
- * `Hir`. Instead, non-capturing grouping is handled automatically by the
- * recursive structure of the `Hir` itself.
- */
-export type Capture = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::Capture'
-
-  /** The capture index of the capture. */
-  index: number
-
-  /** The name of the capture, if it exists. */
-  name?: String
-
-  /** The expression inside the capturing group, which may be empty. */
-  sub: Hir
-}
-
-/**
-* A compiled regular expression for matching Unicode strings.
-* @see https://docs.rs/regex/latest/regex/
-*/
-export class RRegex {
-  free(): void;
-/**
-* Compiles a regular expression. Once compiled, it can be used repeatedly
-* to search, split or replace text in a string.
-*
-* If an invalid expression is given, then an error is returned.
-* @param {string} re
-*/
-  constructor(re: string);
-/**
-* Returns true if and only if there is a match for the regex in the
-* string given.
-*
-* It is recommended to use this method if all you need to do is test
-* a match, since the underlying matching engine may be able to do less
-* work.
-*
-* # Example
-*
-* Test if some text contains at least one word with exactly 13
-* Unicode word characters:
-*
-* ```typescript
-* const text = "I categorically deny having triskaidekaphobia."
-* expect(new RRegex("\\b\\w{13}\\b").is_match(text)).toBe(true)
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.is_match
-* @param {string} text - The string against which to match the regular expression
-* @return {boolean}
-*/
-  isMatch(text: string): boolean;
-/**
-* Returns the same as is_match, but starts the search at the given offset.
-* The significance of the starting point is that it takes the surrounding
-* context into consideration. For example, the `\A` anchor can only match
-* when `start == 0`.
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.is_match_at
-* @param {string} text - The string against which to match the regular expression
-* @param {number} start - Zero-based index at which to start matching
-* @return {boolean}
-*/
-  isMatchAt(text: string, start: number): boolean;
-/**
-* Returns the start and end byte range of the leftmost-first match in
-* `text`. If no match exists, then `undefined` is returned.
-*
-* Note that this should only be used if you want to discover the position
-* of the match. Testing the existence of a match is faster if you use
-* `isMatch`.
-*
-* # Example
-*
-* Find the start and end location of the first word with exactly 13
-* Unicode word characters:
-*
-* ```typescript
-* const text = "I categorically deny having triskaidekaphobia."
-* const m = new Regex("\\b\\w{13}\\b").find(text)
-* expect(m.start).toBe(2)
-* expect(m.end).toBe(15)
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.find
-* @param {string} text - The string against which to match the regular expression
-* @return {Match}
-*/
-  find(text: string): Match | undefined;
-/**
-* Returns the same as find, but starts the search at the given
-* offset.
-*
-* The significance of the starting point is that it takes the surrounding
-* context into consideration. For example, the `\A` anchor can only
-* match when `start == 0`.
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.find_at
-* @param {string} text - The string against which to match the regular expression
-* @param {number} start - Zero-based index at which to start matching
-* @returns {Match}
-*/
-  findAt(text: string, start: number): Match | undefined;
-/**
-* Returns an array for each successive non-overlapping match in `text``,
-* returning the start and end byte indices with respect to `text`.
-*
-* # Example
-*
-* Find the start and end location of every word with exactly 13 Unicode
-* word characters:
-*
-* ```typescript
-* const text = "Retroactively relinquishing remunerations is reprehensible."
-* const matches = new Regex("\\b\\w{13}\\b").findAll(text)
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.find_iter
-* @param {string} text - The string against which to match the regular expression
-* @returns {Match}
-*/
-  findAll(text: string): Match[];
-/**
-* Returns a list of the capture names in this regex.
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.capture_names
-*/
-  captureNames(): (string | null)[];
-/**
-* Returns the capture groups corresponding to the leftmost-first
-* match in `text`. Capture group `0` always corresponds to the entire
-* match. If no match is found, then `undefined` is returned.
-*
-* You should only use `captures` if you need access to the location of
-* capturing group matches. Otherwise, `find` is faster for discovering
-* the location of the overall match.
-*
-* # Examples
-*
-* Say you have some text with movie names and their release years,
-* like "'Citizen Kane' (1941)". It'd be nice if we could search for text
-* looking like that, while also extracting the movie name and its release
-* year separately.
-*
-* ```typescript
-* const re = new Regex("'([^']+)'\\s+\\((\\d{4})\)")
-* const text = "Not my favorite movie: 'Citizen Kane' (1941)."
-* const caps = re.captures(text)
-* expect(caps.get[1].value).toBe("Citizen Kane")
-* expect(caps.get[2].value).toBe("1941")
-* expect(caps.get[0].value).toBe("'Citizen Kane' (1941)")
-* ```
-*
-* Note that the full match is at capture group `0`. Each subsequent
-* capture group is indexed by the order of its opening `(`.
-*
-* We can make this example a bit clearer by using *named* capture groups:
-*
-* ```typescript
-* const re = new Regex("'(?P<title>[^']+)'\\s+\\((?P<year>\\d{4})\)")
-* const text = "Not my favorite movie: 'Citizen Kane' (1941)."
-* const caps = re.captures(text)
-* expect(caps.name["title"].value).toBe("Citizen Kane")
-* expect(caps.name["year"].value).toBe("1941")
-* expect(caps.get[0].value).toBe("'Citizen Kane' (1941)")
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.captures
-* @param {string} text - The string against which to match the regular expression
-* @returns {Captures|undefined}
-*/
-  captures(text: string): Captures | undefined;
-/**
-* Returns a list with all the non-overlapping capture groups matched
-* in `text`. This is operationally the same as `findAll`, except it
-* returns information about capturing group matches.
-*
-* # Example
-*
-* We can use this to find all movie titles and their release years in
-* some text, where the movie is formatted like "'Title' (xxxx)":
-*
-* ```typescript
-* const re = new Regex("'(?P<title>[^']+)'\\s+\\((?P<year>\\d{4})\\)")
-* const text = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931)."
-* for caps of re.captures_iter(text) {
-*     console.log(
-*         "Movie:", caps.name["title"].value, ","
-*         "Released:", caps.name["year"].value
-*     );
-* }
-* // Output:
-* // Movie: Citizen Kane, Released: 1941
-* // Movie: The Wizard of Oz, Released: 1939
-* // Movie: M, Released: 1931
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.captures_iter
-* @param {string} text - The string against which to match the regular expression
-* @returns {Captures[]}
-*/
-  capturesAll(text: string): Captures[];
-/**
-* Returns the number of captures.
-*
-* This includes all named and unnamed groups, including the implicit
-* unnamed group that is always present and corresponds to the entire match.
-*
-* Since the implicit unnamed group is always included in this length, the
-* length returned is guaranteed to be greater than zero.
-*
-* ## Example
-*
-* ```typescript
-*  const re1 = new RRegex("(?P<y>\\d{4})-(?P<m>\\d{2})-(?P<d>\\d{2})")
-*  expect(re1.capturesLength()).toEqual(4)
-*
-*  const re2 = new RRegex("foo")
-*  expect(re2.capturesLength()).toEqual(1)
-*
-*  const re3 = new RRegex("(foo)")
-*  expect(re3.capturesLength()).toEqual(2)
-*
-*  const re4 = new RRegex("(?<a>.(?<b>.))(.)(?:.)(?<c>.)")
-*  expect(re4.capturesLength()).toEqual(5)
-*
-*  const re5 = new RRegex("[a&&b]")
-*  expect(re5.capturesLength()).toEqual(1)
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.captures_len
-* @returns {number}
-*/
-  capturesLength(): number;
-/**
-* Replaces the leftmost-first match with the replacement provided.
-* The replacement can be a regular string (where `$N` and `$name` are
-* expanded to match capture groups) or a function that takes the matches'
-* `Captures` and returns the replaced string.
-*
-* If no match is found, then a copy of the string is returned unchanged.
-*
-* # Replacement string syntax
-*
-* All instances of `$name` in the replacement text is replaced with the
-* corresponding capture group `name`.
-*
-* `name` may be an integer corresponding to the index of the
-* capture group (counted by order of opening parenthesis where `0` is the
-* entire match) or it can be a name (consisting of letters, digits or
-* underscores) corresponding to a named capture group.
-*
-* If `name` isn't a valid capture group (whether the name doesn't exist
-* or isn't a valid index), then it is replaced with the empty string.
-*
-* The longest possible name is used. e.g., `$1a` looks up the capture
-* group named `1a` and not the capture group at index `1`. To exert more
-* precise control over the name, use braces, e.g., `${1}a`.
-*
-* To write a literal `$` use `$$`.
-*
-* # Examples
-*
-* Note that this function is polymorphic with respect to the replacement.
-* In typical usage, this can just be a normal string:
-*
-* ```typescript
-* const re = new Regex("[^01]+")
-* expect(re.replace("1078910", "").toBe("1010")
-* ```
-*
-* Here's the example using this expansion technique with named capture
-* groups:
-*
-* ```typescript
-* const re = new Regex("(?P<last>[^,\\s]+),\\s+(?P<first>\\S+)")
-* const result = re.replace("Springsteen, Bruce", "$first $last")
-* expect(result).toBe("Bruce Springsteen")
-* ```
-*
-* Note that using `$2` instead of `$first` or `$1` instead of `$last`
-* would produce the same result. To write a literal `$` use `$$`.
-*
-* Sometimes the replacement string requires use of curly braces to
-* delineate a capture group replacement and surrounding literal text.
-* For example, if we wanted to join two words together with an
-* underscore:
-*
-* ```typescript
-* const re = new Regex("(?P<first>\\w+)\\s+(?P<second>\\w+)")
-* const result = re.replace("deep fried", "${first}_$second")
-* expect(result).toBe("deep_fried")
-* ```
-*
-* Without the curly braces, the capture group name `first_` would be
-* used, and since it doesn't exist, it would be replaced with the empty
-* string.
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace
-* @param {string} text - The string against which to match the regular expression
-* @param {string} rep - It's a string, it will replace the substring matched by `pattern`.
-* @returns {string}
-*/
-  replace(text: string, rep: string): string;
-/**
-* Replaces at most `limit` non-overlapping matches in `text` with the
-* replacement provided. If `limit` is 0, then all non-overlapping matches
-* are replaced.
-*
-* See the documentation for `replace` for details on how to access
-* capturing group matches in the replacement string.
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.replacen
-* @param {string} text - The string against which to match the regular expression
-* @param {number} limit - Max number of replacement
-* @param {string} rep - It's a string, it will replace the substring matched by `pattern`.
-* @returns {string}
-*/
-  replacen(text: string, limit: number, rep: string): string;
-/**
-* Replaces all non-overlapping matches in `text` with the replacement
-* provided. This is the same as calling `replacen` with `limit` set to
-* `0`.
-*
-* See the documentation for `replace` for details on how to access
-* capturing group matches in the replacement string.
-*
-* See the documentation for `replace` for details on how to access capturing group matches in the replacement string.
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace_all
-* @param {string} text - The string against which to match the regular expression
-* @param {string} rep - It's a string, it will replace the substring matched by `pattern`.
-* @returns {string}
-*/
-  replaceAll(text: string, rep: string): string;
-/**
-* Returns an iterator of substrings of `text` delimited by a match of the
-* regular expression. Namely, each element of the iterator corresponds to
-* text that *isn't* matched by the regular expression.
-*
-* This method will *not* copy the text given.
-*
-* # Example
-*
-* To split a string delimited by arbitrary amounts of spaces or tabs:
-*
-* ```typescript
-* const re = new Regex(r"[ \\t]+")
-* const fields = re.split("a b \t  c\td    e")
-* expect(fields).toEqual(["a", "b", "c", "d", "e"])
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.split
-* @param {string} text - The string against which to match the regular expression
-* @returns {string[]}
-*/
-  split(text: string): (string)[];
-/**
-* Returns an iterator of at most `limit` substrings of `text` delimited
-* by a match of the regular expression. (A `limit` of `0` will return no
-* substrings.) Namely, each element of the iterator corresponds to text
-* that *isn't* matched by the regular expression. The remainder of the
-* string that is not split will be the last element in the iterator.
-*
-* This method will *not* copy the text given.
-*
-* # Example
-*
-* Get the first two words in some text:
-*
-* ```typescript
-* const re = new Regex(r"\\W+")
-* const fields = re.splitn("Hey! How are you?", 3)
-* expect(fields).toEqual(["Hey", "How", "are you?"])
-* ```
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.splitn
-* @param {string} text - The string against which to match the regular expression
-* @param {number} limit - Max number result elements
-* @returns {string[]}
-*/
-  splitn(text: string, limit: number): (string)[];
-/**
-* Returns the end location of a match in the text given.
-*
-* This method may have the same performance characteristics as
-* `isMatch`, except it provides an end location for a match. In
-* particular, the location returned *may be shorter* than the proper end
-* of the leftmost-first match that you would find via `Regex.find`.
-*
-* Note that it is not guaranteed that this routine finds the shortest or
-* "earliest" possible match. Instead, the main idea of this API is that
-* it returns the offset at the point at which the internal regex engine
-* has determined that a match has occurred. This may vary depending on
-* which internal regex engine is used, and thus, the offset itself may
-* change.
-*
-* # Example
-*
-* Typically, `a+` would match the entire first sequence of `a` in some
-* text, but `shortest_match` can give up as soon as it sees the first
-* `a`.
-*
-* ```typescript
-* const text = "aaaaa"
-* const = new Regex("a+").shortest_match(text)
-* expect(pos).toBe(1)
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.shortest_match
-* @param {string} text - The string against which to match the regular expression
-* @returns {number|undefined}
-*/
-  shortestMatch(text: string): number | undefined;
-/**
-* Returns the same as `shortest_match`, but starts the search at the
-* given offset.
-*
-* The significance of the starting point is that it takes the surrounding
-* context into consideration. For example, the `\A` anchor can only match
-* when `start == 0`.
-* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.shortest_match_at
-* @param {string} text - The string against which to match the regular expression
-* @param {number} start - Zero-based index at which to start matching
-* @returns {number|undefined}
-*/
-  shortestMatchAt(text: string, start: number): number | undefined;
-/**
-* Returns the regular expression into a high level intermediate
-* representation.
-* @returns {any}
-*/
-  syntax(): Hir;
-/**
-* Returns a string representing the regular expression
-* @returns {string}
-*/
-  toString(): string;
-}
-/**
-* Match multiple (possibly overlapping) regular expressions in a single scan.
-* A regex set corresponds to the union of two or more regular expressions.
-*
-* That is, a regex set will match text where at least one of its constituent
-* regular expressions matches. A regex set as its formulated here provides a
-* touch more power: it will also report which regular expressions in the set match.
-* Indeed, this is the key difference between regex sets and a single `Regex`
-* with many alternates, since only one alternate can match at a time.
-*
-* @see https://docs.rs/regex/latest/regex/struct.RegexSet.html#method.empty
-*/
-export class RRegexSet {
-  free(): void;
-/**
-* Create a new regex set with the given regular expressions.
-*
-* This takes an of strings, if any item in the list is not a valid regular
-* expressions, then an error is returned.
-*
-* # Example
-*
-* Create a new regex set from an iterator of strings:
-*
-* ```typescript
-* const set = new RegexSet(["\\w+", "\\d+"])
-* expect(set.is_match("foo")).toBe(true)
-* ```
-* @param {Array<any>} list
-*/
-  constructor(list: Array<any>);
-/**
-* Returns true if and only if one of the regexes in this set matches
-* the text given.
-*
-* This method should be preferred if you only need to test whether any
-* of the regexes in the set should match, but don't care about *which*
-* regexes matched. This is because the underlying matching engine will
-* quit immediately after seeing the first match instead of continuing to
-* find all matches.
-*
-* Note that as with searches using `Regex`, the expression is unanchored
-* by default. That is, if the regex does not start with `^` or `\A`, or
-* end with `$` or `\z`, then it is permitted to match anywhere in the
-* text.
-*
-* # Example
-*
-* Tests whether a set matches some text:
-*
-* ```typescript
-* const set = new RegexSet(["\\w+", "\\d+"])
-* expect(set.is_match("foo")).toBe(true)
-* expect(!set.is_match("☃")).toBe(false)
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.RegexSet.html#method.is_match
-* @param {string} text - The string against which to match the regular expression
-* @return {boolean}
-*/
-  isMatch(text: string): boolean;
-/**
-* Returns the set of regular expressions that match in the given text.
-*
-* The set returned contains the index of each regular expression that
-* matches in the given text. The index is in correspondence with the
-* order of regular expressions given to `RegexSet`'s constructor.
-*
-* The set can also be used to iterate over the matched indices.
-*
-* Note that as with searches using `Regex`, the expression is unanchored
-* by default. That is, if the regex does not start with `^` or `\A`, or
-* end with `$` or `\z`, then it is permitted to match anywhere in the
-* text.
-*
-* # Example
-*
-* Tests which regular expressions match the given text:
-*
-* ```typescript
-* const set = new RegexSet([
-*     "\\w+",
-*     "\\d+",
-*     "\\pL+",
-*     "foo",
-*     "bar",
-*     "barfoo",
-*     "foobar",
-* ])
-* const matches = set.matches("foobar")
-* expect(matches).toBe([0, 2, 3, 4, 6])
-* ```
-*
-* @see https://docs.rs/regex/latest/regex/struct.RegexSet.html#method.matches
-* @param {string} text - The string against which to match the regular expression
-* @return {number[]}
-*/
-  matches(text: string): number[];
-}
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly __wbg_rregex_free: (a: number) => void;
-  readonly rregex_new: (a: number, b: number, c: number) => void;
-  readonly rregex_isMatch: (a: number, b: number, c: number) => number;
-  readonly rregex_isMatchAt: (a: number, b: number, c: number, d: number) => number;
-  readonly rregex_find: (a: number, b: number, c: number, d: number) => void;
-  readonly rregex_findAt: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly rregex_findAll: (a: number, b: number, c: number, d: number) => void;
-  readonly rregex_captureNames: (a: number, b: number) => void;
-  readonly rregex_captures: (a: number, b: number, c: number, d: number) => void;
-  readonly rregex_capturesAll: (a: number, b: number, c: number, d: number) => void;
-  readonly rregex_capturesLength: (a: number) => number;
-  readonly rregex_replace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly rregex_replacen: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-  readonly rregex_replaceAll: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly rregex_split: (a: number, b: number, c: number, d: number) => void;
-  readonly rregex_splitn: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly rregex_shortestMatch: (a: number, b: number, c: number, d: number) => void;
-  readonly rregex_shortestMatchAt: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly rregex_syntax: (a: number, b: number) => void;
-  readonly rregex_toString: (a: number, b: number) => void;
-  readonly escape: (a: number, b: number, c: number) => void;
-  readonly __wbg_rregexset_free: (a: number) => void;
-  readonly rregexset_new: (a: number, b: number) => void;
-  readonly rregexset_isMatch: (a: number, b: number, c: number) => number;
-  readonly rregexset_matches: (a: number, b: number, c: number, d: number) => void;
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_exn_store: (a: number) => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-/**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {SyncInitInput} module
-*
-* @returns {InitOutput}
-*/
-export function initSync(module: SyncInitInput): InitOutput;
-
-/**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {InitInput | Promise<InitInput>} module_or_path
-*
-* @returns {Promise<InitOutput>}
-*/
-export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
-
-export const metadata: {
-  "name": "rregex",
-  "description": "Rust Regex binding for Javascript",
-  "authors": [
-    "Fede Ramirez <i@2fd.me>"
-  ],
-  "homepage": "http://rregex.dev",
-  "repository": "https://github.com/2fd/rregex",
-  "regex": "1.8.4",
-  "regex-syntax": "0.7.5"
-}