rregex 1.10.1 → 1.10.3

package/lib/module.js

@@ -4,6 +4,26 @@ export function __wbg_set_wasm(val) {
 }
 
 
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
 const heap = new Array(128).fill(undefined);
 
 heap.push(undefined, null, true, false);
@@ -33,26 +53,6 @@ function takeObject(idx) {
     return ret;
 }
 
-const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
-
-let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-let cachedUint8Memory0 = null;
-
-function getUint8Memory0() {
-    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
-        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8Memory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
-}
-
 let WASM_VECTOR_LEN = 0;
 
 const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
@@ -186,6 +186,43 @@ function handleError(f, args) {
 }
 /**
 * A compiled regular expression for matching Unicode strings.
+*
+* A `RRegex` can be used to search haystacks, split haystacks into substrings
+* or replace substrings in a haystack with a different substring. All
+* searching is done with an implicit `(?s:.)*?` at the beginning and end of
+* an pattern. To force an expression to match the whole string (or a prefix
+* or a suffix), you must use an anchor like `^` or `$` (or `\A` and `\z`).
+*
+* While this library will handle Unicode strings (whether in the regular
+* expression or in the haystack), all positions returned are **byte
+* offsets**. Every byte offset is guaranteed to be at a Unicode code point
+* boundary. That is, all offsets returned by the `RRegex` API are guaranteed
+* to be ranges that can slice an `Uint8Array` created with a TextEncoder.
+*
+* # Example: slicing over UTF strings
+*
+* ```typescript
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("ä")
+* const m = re.find("äöü") // { start: 0, end: 2 }
+*
+* const buff = new TextEncoder().encode("äöü")
+* const slice = buff.slice(m.start, m.end)
+* expect(new TextDecoder().decode(slice)).toBe("ä")
+* ```
+*
+* # Example: find the offsets of a US phone number:
+*
+* ```typescript
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("[0-9]{3}-[0-9]{3}-[0-9]{4}");
+* const m = re.find("phone: 111-222-3333");
+* expect(m.start).toBe(7);
+* expect(m.end).toBe(19);
+* ```
+*
 * @see https://docs.rs/regex/latest/regex/
 */
 export class RRegex {
@@ -240,6 +277,8 @@ export class RRegex {
     * Unicode word characters:
     *
     * ```typescript
+    * import { RRegex } from "rregex"
+    *
     * const text = "I categorically deny having triskaidekaphobia."
     * expect(new RRegex("\\b\\w{13}\\b").is_match(text)).toBe(true)
     * ```
@@ -285,8 +324,10 @@ export class RRegex {
     * Unicode word characters:
     *
     * ```typescript
+    * import { RRegex } from "rregex"
+    *
     * const text = "I categorically deny having triskaidekaphobia."
-    * const m = new Regex("\\b\\w{13}\\b").find(text)
+    * const m = new RRegex("\\b\\w{13}\\b").find(text)
     * expect(m.start).toBe(2)
     * expect(m.end).toBe(15)
     * ```
@@ -352,8 +393,10 @@ export class RRegex {
     * word characters:
     *
     * ```typescript
+    * import { RRegex } from "rregex"
+    *
     * const text = "Retroactively relinquishing remunerations is reprehensible."
-    * const matches = new Regex("\\b\\w{13}\\b").findAll(text)
+    * const matches = new RRegex("\\b\\w{13}\\b").findAll(text)
     * ```
     *
     * @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.find_iter
@@ -412,7 +455,9 @@ export class RRegex {
     * year separately.
     *
     * ```typescript
-    * const re = new Regex("'([^']+)'\\s+\\((\\d{4})\)")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex("'([^']+)'\\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")
@@ -426,7 +471,9 @@ export class RRegex {
     * 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})\)")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex("'(?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")
@@ -466,7 +513,9 @@ export class RRegex {
     * some text, where the movie is formatted like "'Title' (xxxx)":
     *
     * ```typescript
-    * const re = new Regex("'(?P<title>[^']+)'\\s+\\((?P<year>\\d{4})\\)")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex("'(?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(
@@ -513,6 +562,8 @@ export class RRegex {
     * ## Example
     *
     * ```typescript
+    *  import { RRegex } from "rregex"
+    *
     *  const re1 = new RRegex("(?P<y>\\d{4})-(?P<m>\\d{2})-(?P<d>\\d{2})")
     *  expect(re1.capturesLength()).toEqual(4)
     *
@@ -569,7 +620,9 @@ export class RRegex {
     * In typical usage, this can just be a normal string:
     *
     * ```typescript
-    * const re = new Regex("[^01]+")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex("[^01]+")
     * expect(re.replace("1078910", "").toBe("1010")
     * ```
     *
@@ -577,7 +630,9 @@ export class RRegex {
     * groups:
     *
     * ```typescript
-    * const re = new Regex("(?P<last>[^,\\s]+),\\s+(?P<first>\\S+)")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex("(?P<last>[^,\\s]+),\\s+(?P<first>\\S+)")
     * const result = re.replace("Springsteen, Bruce", "$first $last")
     * expect(result).toBe("Bruce Springsteen")
     * ```
@@ -591,7 +646,9 @@ export class RRegex {
     * underscore:
     *
     * ```typescript
-    * const re = new Regex("(?P<first>\\w+)\\s+(?P<second>\\w+)")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex("(?P<first>\\w+)\\s+(?P<second>\\w+)")
     * const result = re.replace("deep fried", "${first}_$second")
     * expect(result).toBe("deep_fried")
     * ```
@@ -705,7 +762,9 @@ export class RRegex {
     * To split a string delimited by arbitrary amounts of spaces or tabs:
     *
     * ```typescript
-    * const re = new Regex(r"[ \\t]+")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex(r"[ \\t]+")
     * const fields = re.split("a b \t  c\td    e")
     * expect(fields).toEqual(["a", "b", "c", "d", "e"])
     * ```
@@ -743,7 +802,9 @@ export class RRegex {
     * Get the first two words in some text:
     *
     * ```typescript
-    * const re = new Regex(r"\\W+")
+    * import { RRegex } from "rregex"
+    *
+    * const re = new RRegex(r"\\W+")
     * const fields = re.splitn("Hey! How are you?", 3)
     * expect(fields).toEqual(["Hey", "How", "are you?"])
     * ```
@@ -789,8 +850,10 @@ export class RRegex {
     * `a`.
     *
     * ```typescript
+    * import { RRegex } from "rregex"
+    *
     * const text = "aaaaa"
-    * const = new Regex("a+").shortest_match(text)
+    * const = new RRegex("a+").shortest_match(text)
     * expect(pos).toBe(1)
     * ```
     *
@@ -913,6 +976,8 @@ export class RRegexSet {
     * Create a new regex set from an iterator of strings:
     *
     * ```typescript
+    * import { RegexSet } from "rregex"
+    *
     * const set = new RegexSet(["\\w+", "\\d+"])
     * expect(set.is_match("foo")).toBe(true)
     * ```
@@ -955,6 +1020,8 @@ export class RRegexSet {
     * Tests whether a set matches some text:
     *
     * ```typescript
+    * import { RegexSet } from "rregex"
+    *
     * const set = new RegexSet(["\\w+", "\\d+"])
     * expect(set.is_match("foo")).toBe(true)
     * expect(!set.is_match("☃")).toBe(false)
@@ -989,6 +1056,8 @@ export class RRegexSet {
     * Tests which regular expressions match the given text:
     *
     * ```typescript
+    * import { RegexSet } from "rregex"
+    *
     * const set = new RegexSet([
     *     "\\w+",
     *     "\\d+",
@@ -1023,8 +1092,8 @@ export class RRegexSet {
     }
 }
 
-export function __wbindgen_number_new(arg0) {
-    const ret = arg0;
+export function __wbindgen_string_new(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
     return addHeapObject(ret);
 };
 
@@ -1032,8 +1101,8 @@ export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 };
 
-export function __wbindgen_string_new(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
+export function __wbindgen_number_new(arg0) {
+    const ret = arg0;
     return addHeapObject(ret);
 };
 
@@ -1065,61 +1134,61 @@ export function __wbg_set_9182712abebf82ef(arg0, arg1, arg2) {
     getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 };
 
-export function __wbg_get_f01601b5a68d10e3(arg0, arg1) {
+export function __wbg_get_c43534c00f382c8a(arg0, arg1) {
     const ret = getObject(arg0)[arg1 >>> 0];
     return addHeapObject(ret);
 };
 
-export function __wbg_length_1009b1af0c481d7b(arg0) {
+export function __wbg_length_d99b680fd68bf71b(arg0) {
     const ret = getObject(arg0).length;
     return ret;
 };
 
-export function __wbg_new_ffc6d4d085022169() {
+export function __wbg_new_34c624469fb1d4fd() {
     const ret = new Array();
     return addHeapObject(ret);
 };
 
-export function __wbg_new_9fb8d994e1c0aaac() {
+export function __wbg_new_87d841e70661f6e9() {
     const ret = new Object();
     return addHeapObject(ret);
 };
 
-export function __wbg_set_f2740edb12e318cd(arg0, arg1, arg2) {
+export function __wbg_set_379b27f1d5f1bf9c(arg0, arg1, arg2) {
     getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
 };
 
-export function __wbg_from_71add2e723d1f1b2(arg0) {
+export function __wbg_from_a663e01d8dab8e44(arg0) {
     const ret = Array.from(getObject(arg0));
     return addHeapObject(ret);
 };
 
-export function __wbg_push_901f3914205d44de(arg0, arg1) {
+export function __wbg_push_906164999551d793(arg0, arg1) {
     const ret = getObject(arg0).push(getObject(arg1));
     return ret;
 };
 
-export function __wbg_fromCodePoint_fd9383eff8873c75() { return handleError(function (arg0) {
+export function __wbg_fromCodePoint_33fc13cdbfe3bca7() { return handleError(function (arg0) {
     const ret = String.fromCodePoint(arg0 >>> 0);
     return addHeapObject(ret);
 }, arguments) };
 
-export function __wbg_buffer_a448f833075b71ba(arg0) {
+export function __wbg_buffer_5d1b598a01b41a42(arg0) {
     const ret = getObject(arg0).buffer;
     return addHeapObject(ret);
 };
 
-export function __wbg_newwithbyteoffsetandlength_d0482f893617af71(arg0, arg1, arg2) {
+export function __wbg_newwithbyteoffsetandlength_d695c7957788f922(arg0, arg1, arg2) {
     const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
     return addHeapObject(ret);
 };
 
-export function __wbg_new_8f67e318f15d7254(arg0) {
+export function __wbg_new_ace717933ad7117f(arg0) {
     const ret = new Uint8Array(getObject(arg0));
     return addHeapObject(ret);
 };
 
-export function __wbg_set_759f75cd92b612d2() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_set_37a50e901587b477() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
     return ret;
 }, arguments) };

package/lib/types.d.ts

@@ -11,6 +11,50 @@
 export function escape(text: string): string;
 /**
  * Represents a single match of a regex in a haystack.
+ *
+ * A `Match` contains both the start and end byte offsets of the match and the
+ * actual substring corresponding to the range of those byte offsets. It is
+ * guaranteed that `start <= end`. When `start == end`, the match is empty.
+ *
+ * Since this `Match` can only be produced by the top-level `Regex` APIs
+ * that only support searching UTF-8 encoded strings, the byte offsets for a
+ * `Match` are guaranteed to fall on valid UTF-8 codepoint boundaries. That
+ * is, slicing an `Uint8Array` created with a TextEncoder is guaranteed to never
+ * be out of range.
+ *
+ * # Numbering
+ *
+ * The byte offsets in a `Match` form a half-open interval. That is, the
+ * start of the range is inclusive and the end of the range is exclusive.
+ * For example, given a haystack `abcFOOxyz` and a match of `FOO`, its byte
+ * offset range starts at `3` and ends at `6`. `3` corresponds to `F` and
+ * `6` corresponds to `x`, which is one past the end of the match. This
+ * corresponds to the same kind of slicing that Rust uses.
+ *
+ * For more on why this was chosen over other schemes (aside from being
+ * consistent with how Rust the language works), see [this discussion] and
+ * [Dijkstra's note on a related topic][note].
+ *
+ * [this discussion]: https://github.com/rust-lang/regex/discussions/866
+ * [note]: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html
+ *
+ * # Example
+ *
+ * This example shows the value of each of the methods on `Match` for a
+ * particular search.
+ *
+ * ```typescript
+ * import { RRegex } from "rregex"
+ *
+ * const re = new RRegex("\\p{Greek}+");
+ * const hay = "Greek: αβγδ";
+ * const m = re.find(hay);
+ * expect(m.start).toBe(7);
+ * expect(m.end).toBe(15);
+ * expect(m.value).toBe("αβγδ");
+ * ```
+ *
+ * @see  @see https://docs.rs/regex/latest/regex/
  */
 export type Match = {
   start: number
@@ -19,14 +63,47 @@ export type Match = {
 }
 
 /**
- * Captures represents a group of captured strings for a single match.
+ * Represents the capture groups for a single match.
+ *
+ * Capture groups refer to parts of a regex enclosed in parentheses. They can
+ * be optionally named. The purpose of capture groups is to be able to
+ * reference different parts of a match based on the original pattern. For
+ * example, say you want to match the individual letters in a 5-letter word:
  *
- * 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.)
+ * ```text
+ * (?<first>\w)(\w)(?:\w)\w(?<last>\w)
+ * ```
  *
- * Positions returned from a capture group are always byte indices.
+ * This regex has 4 capture groups:
+ *
+ * * The group at index `0` corresponds to the overall match. It is always
+ * present in every match and never has a name.
+ * * The group at index `1` with name `first` corresponding to the first
+ * letter.
+ * * The group at index `2` with no name corresponding to the second letter.
+ * * The group at index `3` with name `last` corresponding to the fifth and
+ * last letter.
+ *
+ * Notice that `(?:\w)` was not listed above as a capture group despite it
+ * being enclosed in parentheses. That's because `(?:pattern)` is a special
+ * syntax that permits grouping but *without* capturing. The reason for not
+ * treating it as a capture is that tracking and reporting capture groups
+ * requires additional state that may lead to slower searches. So using as few
+ * capture groups as possible can help performance. (Although the difference
+ * in performance of a couple of capture groups is likely immaterial.)
+ *
+ * # Example
+ *
+ * ```typescript
+ * import { RRegex } from "rregex"
+ *
+ * const re = new RRegex("(?<first>\\w)(\\w)(?:\\w)\\w(?<last>\\w)");
+ * const caps = re.captures("toady");
+ * expect(caps.get[0].value).toBe("toady");
+ * expect(caps.name["first"].value).toBe("t");
+ * expect(caps.get[2].value).toBe("o");
+ * expect(caps.name["last"].value).toBe("y");
+ * ```
  */
 export type Captures = {
   get: Match[]
@@ -584,6 +661,43 @@ export type Capture = {
 
 /**
 * A compiled regular expression for matching Unicode strings.
+*
+* A `RRegex` can be used to search haystacks, split haystacks into substrings
+* or replace substrings in a haystack with a different substring. All
+* searching is done with an implicit `(?s:.)*?` at the beginning and end of
+* an pattern. To force an expression to match the whole string (or a prefix
+* or a suffix), you must use an anchor like `^` or `$` (or `\A` and `\z`).
+*
+* While this library will handle Unicode strings (whether in the regular
+* expression or in the haystack), all positions returned are **byte
+* offsets**. Every byte offset is guaranteed to be at a Unicode code point
+* boundary. That is, all offsets returned by the `RRegex` API are guaranteed
+* to be ranges that can slice an `Uint8Array` created with a TextEncoder.
+*
+* # Example: slicing over UTF strings
+*
+* ```typescript
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("ä")
+* const m = re.find("äöü") // { start: 0, end: 2 }
+*
+* const buff = new TextEncoder().encode("äöü")
+* const slice = buff.slice(m.start, m.end)
+* expect(new TextDecoder().decode(slice)).toBe("ä")
+* ```
+*
+* # Example: find the offsets of a US phone number:
+*
+* ```typescript
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("[0-9]{3}-[0-9]{3}-[0-9]{4}");
+* const m = re.find("phone: 111-222-3333");
+* expect(m.start).toBe(7);
+* expect(m.end).toBe(19);
+* ```
+*
 * @see https://docs.rs/regex/latest/regex/
 */
 export class RRegex {
@@ -610,6 +724,8 @@ export class RRegex {
 * Unicode word characters:
 *
 * ```typescript
+* import { RRegex } from "rregex"
+*
 * const text = "I categorically deny having triskaidekaphobia."
 * expect(new RRegex("\\b\\w{13}\\b").is_match(text)).toBe(true)
 * ```
@@ -645,8 +761,10 @@ export class RRegex {
 * Unicode word characters:
 *
 * ```typescript
+* import { RRegex } from "rregex"
+*
 * const text = "I categorically deny having triskaidekaphobia."
-* const m = new Regex("\\b\\w{13}\\b").find(text)
+* const m = new RRegex("\\b\\w{13}\\b").find(text)
 * expect(m.start).toBe(2)
 * expect(m.end).toBe(15)
 * ```
@@ -680,8 +798,10 @@ export class RRegex {
 * word characters:
 *
 * ```typescript
+* import { RRegex } from "rregex"
+*
 * const text = "Retroactively relinquishing remunerations is reprehensible."
-* const matches = new Regex("\\b\\w{13}\\b").findAll(text)
+* const matches = new RRegex("\\b\\w{13}\\b").findAll(text)
 * ```
 *
 * @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.find_iter
@@ -712,7 +832,9 @@ export class RRegex {
 * year separately.
 *
 * ```typescript
-* const re = new Regex("'([^']+)'\\s+\\((\\d{4})\)")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("'([^']+)'\\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")
@@ -726,7 +848,9 @@ export class RRegex {
 * 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})\)")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("'(?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")
@@ -750,7 +874,9 @@ export class RRegex {
 * some text, where the movie is formatted like "'Title' (xxxx)":
 *
 * ```typescript
-* const re = new Regex("'(?P<title>[^']+)'\\s+\\((?P<year>\\d{4})\\)")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("'(?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(
@@ -781,6 +907,8 @@ export class RRegex {
 * ## Example
 *
 * ```typescript
+*  import { RRegex } from "rregex"
+*
 *  const re1 = new RRegex("(?P<y>\\d{4})-(?P<m>\\d{2})-(?P<d>\\d{2})")
 *  expect(re1.capturesLength()).toEqual(4)
 *
@@ -834,7 +962,9 @@ export class RRegex {
 * In typical usage, this can just be a normal string:
 *
 * ```typescript
-* const re = new Regex("[^01]+")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("[^01]+")
 * expect(re.replace("1078910", "").toBe("1010")
 * ```
 *
@@ -842,7 +972,9 @@ export class RRegex {
 * groups:
 *
 * ```typescript
-* const re = new Regex("(?P<last>[^,\\s]+),\\s+(?P<first>\\S+)")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("(?P<last>[^,\\s]+),\\s+(?P<first>\\S+)")
 * const result = re.replace("Springsteen, Bruce", "$first $last")
 * expect(result).toBe("Bruce Springsteen")
 * ```
@@ -856,7 +988,9 @@ export class RRegex {
 * underscore:
 *
 * ```typescript
-* const re = new Regex("(?P<first>\\w+)\\s+(?P<second>\\w+)")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex("(?P<first>\\w+)\\s+(?P<second>\\w+)")
 * const result = re.replace("deep fried", "${first}_$second")
 * expect(result).toBe("deep_fried")
 * ```
@@ -913,7 +1047,9 @@ export class RRegex {
 * To split a string delimited by arbitrary amounts of spaces or tabs:
 *
 * ```typescript
-* const re = new Regex(r"[ \\t]+")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex(r"[ \\t]+")
 * const fields = re.split("a b \t  c\td    e")
 * expect(fields).toEqual(["a", "b", "c", "d", "e"])
 * ```
@@ -937,7 +1073,9 @@ export class RRegex {
 * Get the first two words in some text:
 *
 * ```typescript
-* const re = new Regex(r"\\W+")
+* import { RRegex } from "rregex"
+*
+* const re = new RRegex(r"\\W+")
 * const fields = re.splitn("Hey! How are you?", 3)
 * expect(fields).toEqual(["Hey", "How", "are you?"])
 * ```
@@ -969,8 +1107,10 @@ export class RRegex {
 * `a`.
 *
 * ```typescript
+* import { RRegex } from "rregex"
+*
 * const text = "aaaaa"
-* const = new Regex("a+").shortest_match(text)
+* const = new RRegex("a+").shortest_match(text)
 * expect(pos).toBe(1)
 * ```
 *
@@ -1029,6 +1169,8 @@ export class RRegexSet {
 * Create a new regex set from an iterator of strings:
 *
 * ```typescript
+* import { RegexSet } from "rregex"
+*
 * const set = new RegexSet(["\\w+", "\\d+"])
 * expect(set.is_match("foo")).toBe(true)
 * ```
@@ -1055,6 +1197,8 @@ export class RRegexSet {
 * Tests whether a set matches some text:
 *
 * ```typescript
+* import { RegexSet } from "rregex"
+*
 * const set = new RegexSet(["\\w+", "\\d+"])
 * expect(set.is_match("foo")).toBe(true)
 * expect(!set.is_match("☃")).toBe(false)
@@ -1084,6 +1228,8 @@ export class RRegexSet {
 * Tests which regular expressions match the given text:
 *
 * ```typescript
+* import { RegexSet } from "rregex"
+*
 * const set = new RegexSet([
 *     "\\w+",
 *     "\\d+",
@@ -1169,6 +1315,6 @@ export const metadata: {
   ],
   "homepage": "http://rregex.dev",
   "repository": "https://github.com/2fd/rregex",
-  "regex": "1.10.2",
+  "regex": "1.10.3",
   "regex-syntax": "0.8.2"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rregex",
-  "version": "1.10.1",
+  "version": "1.10.3",
   "description": "Rust Regex binding for Javascript",
   "private": false,
   "main": "./lib/commonjs.js",