rregex 1.13.3 → 2.0.0

package/lib/{esm.d.ts → core.d.cts}

@@ -6,7 +6,7 @@
  * The string returned may be safely used as a literal in a regular
  * expression.
  */
-export function escape(text: string): string;
+export declare function escape(text: string): string;
 /**
  * Represents a single match of a regex in a haystack.
  *
@@ -55,20 +55,18 @@ export function escape(text: string): string;
  * @see  @see https://docs.rs/regex/latest/regex/
  */
 export type Match = {
-  start: number
-  end: number
-  value: string
-}
-
+  start: number;
+  end: number;
+  value: string;
+};
 /**
  * A high-level intermediate representation (HIR) for a regular expression.
  */
 export type Hir = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::Hir'
-  kind: HirKind
-}
-
+  '@type': 'struct';
+  '@name': 'regex_syntax::hir::Hir';
+  kind: HirKind;
+};
 /**
  * The underlying kind of an arbitrary `Hir` expression.
  *
@@ -78,35 +76,24 @@ export type Hir = {
  * 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
-
+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'
-}
-
+  '@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]
-}
-
+  '@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
@@ -115,42 +102,38 @@ export type HirKindLiteralVariant = {
  * 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]
-}
-
+  '@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]
-}
-
+  '@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]
-}
-
+  '@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]
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir::HirKind';
+  '@variant': 'Capture';
+  '@values': [Capture];
+};
 /**
  * A concatenation of expressions.
  *
@@ -161,12 +144,11 @@ export type HirKindCaptureVariant = {
  * least two sub-expressions.
  */
 export type HirKindConcatVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Concat'
-  '@values': [Hir[]]
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir::HirKind';
+  '@variant': 'Concat';
+  '@values': [Hir[]];
+};
 /**
  * An alternation of expressions.
  *
@@ -177,12 +159,11 @@ export type HirKindConcatVariant = {
  * least two sub-expressions.
  */
 export type HirKindAlternationVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::HirKind'
-  '@variant': 'Alternation'
-  '@values': [Hir[]]
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir::HirKind';
+  '@variant': 'Alternation';
+  '@values': [Hir[]];
+};
 /**
  * The high-level intermediate representation of a literal.
  *
@@ -192,11 +173,10 @@ export type HirKindAlternationVariant = {
  * with `HirKind::Empty`.
  */
 export type Literal = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::Literal'
-  '@values': [Uint8Array]
-}
-
+  '@type': 'struct';
+  '@name': 'regex_syntax::hir::Literal';
+  '@values': [Uint8Array];
+};
 /**
  * The high-level intermediate representation of a character class.
  *
@@ -213,41 +193,34 @@ export type Literal = {
  * 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
-
+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]
-}
-
+  '@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]
-}
-
+  '@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'
-
+  '@type': 'struct';
+  '@name': 'regex_syntax::hir::ClassUnicode';
   /** The underlying ranges as a slice. */
-  ranges: ClassUnicodeRange[]
-}
-
+  ranges: ClassUnicodeRange[];
+};
 /**
  * A single range of characters represented by Unicode scalar values.
  *
@@ -255,41 +228,35 @@ export type ClassUnicode = {
  * the range.
  */
 export type ClassUnicodeRange = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::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
-
+  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
-
+  end: string;
   /**
    * The number of codepoints in this range.
    */
-  len: number
-}
-
+  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'
-
+  '@type': 'struct';
+  '@name': 'regex_syntax::hir::ClassBytes';
   /** The underlying ranges as a slice. */
-  ranges: ClassBytesRange[]
-}
-
+  ranges: ClassBytesRange[];
+};
 /**
  * A single range of characters represented by arbitrary bytes.
  *
@@ -297,96 +264,69 @@ export type ClassBytes = {
  * the range.
  */
 export type ClassBytesRange = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::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
-
+  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
-
+  end: number;
   /**
    * The number of bytes in this range.
    */
-  len: number
-}
-
- /**
+  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
-  | LookWordStartAsciiVariant
-  | LookWordEndAsciiVariant
-  | LookWordStartUnicodeVariant
-  | LookWordEndUnicodeVariant
-  | LookWordStartHalfAsciiVariant
-  | LookWordEndHalfAsciiVariant
-  | LookWordStartHalfUnicodeVariant
-  | LookWordEndHalfUnicodeVariant
-
+export type Look = LookStartVariant | LookEndVariant | LookStartLFVariant | LookEndLFVariant | LookStartCRLFVariant | LookEndCRLFVariant | LookWordAsciiVariant | LookWordAsciiNegateVariant | LookWordUnicodeVariant | LookWordUnicodeNegateVariant | LookWordStartAsciiVariant | LookWordEndAsciiVariant | LookWordStartUnicodeVariant | LookWordEndUnicodeVariant | LookWordStartHalfAsciiVariant | LookWordEndHalfAsciiVariant | LookWordStartHalfUnicodeVariant | LookWordEndHalfUnicodeVariant;
 /**
  * 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'
-}
-
+  '@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'
-}
-
+  '@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'
-}
-
+  '@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'
-}
-
+  '@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
@@ -394,62 +334,56 @@ export type LookEndLFVariant = {
  * follows.
  */
 export type LookStartCRLFVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'StartCRLF'
-}
-
+  '@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'
-}
-
+  '@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'
-}
-
+  '@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'
-}
-
+  '@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'
-}
-
+  '@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'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir:Look';
+  '@variant': 'WordUnicodeNegate';
+};
 /**
  * Match the start of an ASCII-only word boundary. That is, this matches a
  * position at either the beginning of the haystack or where the previous
@@ -457,97 +391,88 @@ export type LookWordUnicodeNegateVariant = {
  * character.
  */
 export type LookWordStartAsciiVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordStartAscii'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir:Look';
+  '@variant': 'WordStartAscii';
+};
 /**
  * Match the end of an ASCII-only word boundary. That is, this matches a
  * position at either the end of the haystack orwhere the previous character is
  * a word character and the following character is not a word character.
  */
 export type LookWordEndAsciiVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordEndAscii'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir:Look';
+  '@variant': 'WordEndAscii';
+};
 /**
  * Match the start of a Unicode word boundary. That is, this matches a position
  * at either the beginning of the haystack or where the previous character is
  * not a word character and the following character is a word character.
  */
 export type LookWordStartUnicodeVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordStartUnicode'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir:Look';
+  '@variant': 'WordStartUnicode';
+};
 /**
  * Match the end of a Unicode word boundary. That is, this matches a position at
  *  either the end of the haystack or where the previous character is a word
  * character and the following character is not a word character.
  */
 export type LookWordEndUnicodeVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir:Look'
-  '@variant': 'WordEndUnicode'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir:Look';
+  '@variant': 'WordEndUnicode';
+};
 /**
  * Match the start half of an ASCII-only word boundary. That is, this matches a
  * position at either the beginning of the haystack or where the previous
  * character is not a word character.
  */
 export type LookWordStartHalfAsciiVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::Look',
-  '@variant': 'WordStartHalfAscii'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir::Look';
+  '@variant': 'WordStartHalfAscii';
+};
 /**
  * Match the end half of an ASCII-only word boundary. That is, this matches a
  * position at either the end of the haystack or where the following character
  * is not a word character.
  */
 export type LookWordEndHalfAsciiVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::Look',
-  '@variant': 'WordEndHalfAscii'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir::Look';
+  '@variant': 'WordEndHalfAscii';
+};
 /**
  * Match the start half of a Unicode word boundary. That is, this matches a
  * position at either the beginning of the haystack or where the previous
  * character is not a word character.
  */
 export type LookWordStartHalfUnicodeVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::Look',
-  '@variant': 'WordStartHalfUnicode'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir::Look';
+  '@variant': 'WordStartHalfUnicode';
+};
 /**
  * Match the end half of a Unicode word boundary. That is, this matches a
  * position at either the end of the haystack or where the following character
  * is not a word character.
  */
 export type LookWordEndHalfUnicodeVariant = {
-  '@type': 'enum'
-  '@name': 'regex_syntax::hir::Look',
-  '@variant': 'WordEndHalfUnicode'
-}
-
+  '@type': 'enum';
+  '@name': 'regex_syntax::hir::Look';
+  '@variant': 'WordEndHalfUnicode';
+};
 /**
  * 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'
-
+  '@type': 'struct';
+  '@name': 'regex_syntax::hir::Repetition';
   /**
    * The minimum range of the repetition.
    *
@@ -557,8 +482,7 @@ export type Repetition = {
    * When `min` is zero, this expression can match the empty string regardless
    * of what its sub-expression is.
    */
-  min: number
-
+  min: number;
   /**
    * The maximum range of the repetition.
    *
@@ -566,8 +490,7 @@ export type Repetition = {
    * 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
-
+  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
@@ -577,14 +500,12 @@ export type Repetition = {
    * `?` suffix is used, e.g., `(expr)*` is greedy while `(expr)*?` is not.
    * However, this can be inverted via the `U` “ungreedy” flag.
    */
-  greedy: boolean
-
+  greedy: boolean;
   /**
    * The expression being repeated.
    */
-  sub: Hir
-}
-
+  sub: Hir;
+};
 /**
  * Represents the capture groups for a single match.
  *
@@ -629,10 +550,9 @@ export type Repetition = {
  * ```
  */
 export type Captures = {
-  get: Match[]
-  name: Record<string, Match>
-}
-
+  get: Match[];
+  name: Record<string, Match>;
+};
 /**
  * The high-level intermediate representation for a capturing group.
  *
@@ -644,19 +564,61 @@ export type Captures = {
  * recursive structure of the `Hir` itself.
  */
 export type Capture = {
-  '@type': 'struct'
-  '@name': 'regex_syntax::hir::Capture'
-
+  '@type': 'struct';
+  '@name': 'regex_syntax::hir::Capture';
   /** The capture index of the capture. */
-  index: number
-
+  index: number;
   /** The name of the capture, if it exists. */
-  name?: String
-
+  name?: String;
   /** The expression inside the capturing group, which may be empty. */
-  sub: Hir
-}
-
+  sub: Hir;
+};
+/**
+ * Options to compile a `RRegex` or a `RRegexSet`. Every option is optional
+ * and only applies to the instance that receives it.
+ *
+ * # Example
+ *
+ * ```typescript
+ * import { RRegex } from "rregex"
+ *
+ * // Unicode classes make this pattern exceed the default 10 MiB size limit
+ * const re = new RRegex("\\w{200}\\s\\w{200}", { sizeLimit: 200 * 1024 * 1024 })
+ * ```
+ *
+ * @see https://docs.rs/regex/latest/regex/struct.RegexBuilder.html
+ */
+export type RRegexOptions = {
+  /**
+   * The approximate size limit, in bytes, of the compiled regular expression.
+   * If the compiled regular expression is bigger, the constructor throws.
+   *
+   * Increase it only for patterns that need it: the compiled program uses
+   * WebAssembly memory, which does not shrink after the instance is freed.
+   *
+   * @default 10485760 (10 MiB)
+   * @see https://docs.rs/regex/latest/regex/struct.RegexBuilder.html#method.size_limit
+   */
+  sizeLimit?: number;
+  /**
+   * The approximate capacity, in bytes, of the cache of transitions used by
+   * the lazy DFA. A bigger cache can make searches on big patterns faster.
+   * If the cache is too small, the search uses a slower engine, it does not
+   * throw.
+   *
+   * @default 2097152 (2 MiB)
+   * @see https://docs.rs/regex/latest/regex/struct.RegexBuilder.html#method.dfa_size_limit
+   */
+  dfaSizeLimit?: number;
+  /**
+   * The nesting limit of the parser. If the pattern has more nested groups,
+   * classes or repetitions, the constructor throws.
+   *
+   * @default 250
+   * @see https://docs.rs/regex/latest/regex/struct.RegexBuilder.html#method.nest_limit
+   */
+  nestLimit?: number;
+};
 /**
  * A compiled regular expression for matching Unicode strings.
  *
@@ -698,7 +660,7 @@ export type Capture = {
  *
  * @see https://docs.rs/regex/latest/regex/
  */
-export class RRegex {
+export declare class RRegex {
   free(): void;
   /**
    * Returns the same as is_match, but starts the search at the given offset.
@@ -850,8 +812,9 @@ export class RRegex {
    * to search, split or replace text in a string.
    *
    * If an invalid expression is given, then an error is returned.
+   * Options only apply to this instance, see `RRegexOptions`.
    */
-  constructor(re: string);
+  constructor(re: string, options?: RRegexOptions | null);
   /**
    * Returns the start and end byte range of the leftmost-first match in
    * `text`. If no match exists, then `undefined` is returned.
@@ -1150,13 +1113,14 @@ export class RRegex {
  *
  * @see https://docs.rs/regex/latest/regex/struct.RegexSet.html#method.empty
  */
-export class RRegexSet {
+export declare 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.
+   * This takes an array of strings, if any item in the list is not a valid regular
+   * expression, then an error is returned. Options only apply to this
+   * instance, see `RRegexOptions`.
    *
    * # Example
    *
@@ -1169,7 +1133,7 @@ export class RRegexSet {
    * expect(set.is_match("foo")).toBe(true)
    * ```
    */
-  constructor(list: Array<any>);
+  constructor(list: string[], options?: RRegexOptions | null);
   /**
    * Returns the set of regular expressions that match in the given text.
    *
@@ -1242,3 +1206,82 @@ export class RRegexSet {
    */
   isMatch(text: string): boolean;
 }
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_rregex_free: (a: number, b: number) => void;
+  readonly rregex_captureNames: (a: number) => [number, number];
+  readonly rregex_captures: (a: number, b: number, c: number) => [number, number, number];
+  readonly rregex_capturesAll: (a: number, b: number, c: number) => [number, number, number];
+  readonly rregex_capturesLength: (a: number) => number;
+  readonly rregex_find: (a: number, b: number, c: number) => [number, number, number];
+  readonly rregex_findAll: (a: number, b: number, c: number) => [number, number, number];
+  readonly rregex_findAt: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly rregex_isMatch: (a: number, b: number, c: number) => number;
+  readonly rregex_isMatchAt: (a: number, b: number, c: number, d: number) => number;
+  readonly rregex_new: (a: number, b: number, c: number) => [number, number, number];
+  readonly rregex_replace: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly rregex_replaceAll: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly rregex_replacen: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+  readonly rregex_shortestMatch: (a: number, b: number, c: number) => number;
+  readonly rregex_shortestMatchAt: (a: number, b: number, c: number, d: number) => number;
+  readonly rregex_split: (a: number, b: number, c: number) => [number, number];
+  readonly rregex_splitn: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly rregex_syntax: (a: number) => [number, number, number];
+  readonly rregex_toString: (a: number) => [number, number];
+  readonly __wbg_rregexset_free: (a: number, b: number) => void;
+  readonly rregexset_isMatch: (a: number, b: number, c: number) => number;
+  readonly rregexset_matches: (a: number, b: number, c: number) => [number, number];
+  readonly rregexset_new: (a: any, b: number) => [number, number, number];
+  readonly escape: (a: number, b: number) => [number, number];
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __externref_drop_slice: (a: number, b: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/** Build metadata */
+export declare const metadata: {
+  readonly name: "rregex";
+  readonly description: "Rust Regex binding for Javascript";
+  readonly authors: readonly ["Fede Ramirez <i@2fd.me>"];
+  readonly homepage: "http://rregex.dev";
+  readonly repository: "https://github.com/2fd/rregex";
+  readonly regex: "1.13.1";
+  readonly "regex-syntax": "0.8.11";
+};
+export interface InitOptions {
+  /** Bytes, a compiled `WebAssembly.Module`, or a `Response`, URL or path to fetch. */
+  module_or_path: InitInput | Promise<InitInput>;
+}
+export interface InitSyncOptions {
+  /** Bytes or a compiled `WebAssembly.Module`. */
+  module: SyncInitInput;
+}
+/**
+ * The raw exports of the WebAssembly instance (`memory`, allocator, bindings),
+ * set by {@link init} and {@link initSync}. For tests and debugging only: it
+ * is not part of the public API and can change in any release.
+ *
+ * @internal
+ */
+export declare let __wasm: InitOutput | undefined;
+/** Returns `true` after the WebAssembly module has been instantiated. */
+export declare function isInitialized(): boolean;
+/**
+ * Instantiates the WebAssembly module synchronously. Calls after the first
+ * successful call have no effect.
+ *
+ * @param options - The module, or (deprecated) the module passed directly.
+ */
+export declare function initSync(options: InitSyncOptions | SyncInitInput): void;
+/**
+ * Instantiates the WebAssembly module asynchronously. Calls after the first
+ * successful call have no effect.
+ */
+export declare function init(options: InitOptions): Promise<void>;