rregex 1.1.4 → 1.1.5

package/README.md

@@ -1,25 +1,21 @@
 # rregex
 
-A WebAssembly build of [Rust Regex](https://docs.rs/regex/latest/regex/) for Javascript
-
-> Note: this project is not intended to be used in production jet
-
-* [Why Rust Regex](#why-rust-regex)
-* [Install](#install)
-* [API](#api)
-  * [`isMatch(text: string): boolean`](#ismatchtext-string-boolean)
-  * [`isMatchAt(text: string, limit: number): boolean`](#ismatchattext-string-limit-number-boolean)
-  * [`find(text: string): Match | undefined;`](#findtext-string-match--undefined)
-  * [`findAt(text: string): Match | undefined;`](#findattext-string-match--undefined)
-  * [`findAll(text: string): Match[];`](#findalltext-string-match)
-  * [`replace(text: string, rep: string): string;`](#replacetext-string-rep-string-string)
-  * [`replaceAll(text: string, rep: string): string;`](#replacealltext-string-rep-string-string)
-  * [`replacen(text: string, limit: number, rep: string): string;`](#replacentext-string-limit-number-rep-string-string)
-  * [`split(text: string): string[];`](#splittext-string-string)
-  * [`splitn(text: string, limit: number): string[];`](#splitntext-string-limit-number-string)
-  * [`shortestMatch(text: string): number | undefined;`](#shortestmatchtext-string-number--undefined)
-  * [`shortestMatchAt(text: string, limit: number): number | undefined;`](#shortestmatchattext-string-limit-number-number--undefined)
-* [Known Issues](#known-issues)
+A dependency-free WebAssembly build of [Rust Regex](https://docs.rs/regex/latest/regex/) for Javascript
+
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/2fd/rregex/release.yml?branch=master) ![GitHub Release](https://img.shields.io/github/v/release/2fd/rregex) ![NPM Version](https://img.shields.io/npm/v/rregex)
+[![JSR](https://jsr.io/badges/@rregex/rregex)](https://jsr.io/@rregex/rregex)
+
+- [Why Rust Regex](#why-rust-regex)
+- [Install](#install)
+- [Supported Runtimes](#supported-runtimes)
+- [API](https://tsdocs.dev/docs/rregex/latest)
+  - [`RRegex`](https://tsdocs.dev/docs/rregex/latest/classes/RRegex.html)
+  - [`RRegexSet`](https://tsdocs.dev/docs/rregex/latest/classes/RRegexSet.html)
+  - [`Match`](https://tsdocs.dev/docs/rregex/latest/types/Match.html)
+  - [`Captures`](https://tsdocs.dev/docs/rregex/latest/types/Captures.html)
+  - [`escape`](https://tsdocs.dev/docs/rregex/latest/functions/escape.html)
+- [Benchmarks](#benchmarks)
+- [Known Issues](#known-issues)
 
 ## Why Rust Regex
 
@@ -30,202 +26,95 @@ Rust has a powerful Regex library with a lot of features that don't exists en th
 ## Install
 
 ```bash
-npm install rregex
-```
-
-## API
-
-Similar to the native `Regex` object you can create a new `RRegex` instance using a string.
-
-```typescript
-import { RRegex } from "rregex";
-const re = new RRegex("^d{4}-d{2}-d{2}$");
-assert.equal(re.isMatch("2014-01-01"), true);
-```
+  # NPM
+  npm install rregex
 
-> Note: It doesn't take a second parameter because fags are part of the syntax ([See Documentation](https://docs.rs/regex/latest/regex/#grouping-and-flags))
+  # Yarn
+  yarn add rregex
 
-### `isMatch(text: string): boolean;`
+  # PNPM
+  pnpm add rregex
 
-Returns true if and only if there is a match for the regex in the string given. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.is_match))
+  # Deno
+  deno add @rregex/rregex
 
-```typescript
-const text = "I categorically deny having triskaidekaphobia.";
-const re = new RRegex("\\b\\w{13}\\b");
-expect(re.isMatch(text)).toEqual(true);
+  # JSR
+  npx jsr add @rregex/rregex
 ```
 
-### `isMatchAt(text: string, limit: number): boolean;`
+## Supported Runtimes
 
-Returns the same as is_match, but starts the search at the given offset. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.is_match_at))
+This package includes builds for multiple runtimes
 
-```typescript
-const text = "I categorically deny having triskaidekaphobia.";
-const re = new RRegex("\\b\\w{13}\\b");
-expect(re.isMatchAt(text, 1)).toBe(true);
-expect(re.isMatchAt(text, 5)).toBe(false);
-```
+| Runtime            | Import                                                  | version    |
+| ------------------ | ------------------------------------------------------- | ---------- |
+| Node.js (esm)      | `import { RRegex, RRegexSet } from 'rregex'`            | `*`        |
+| Node.js (commonjs) | `const { RRegex, RRegexSet } = require('rregex')`       | `*`        |
+| Deno               | `import { RRegex, RRegexSet } from '@rregex/rregex'`    | `>=1.10.8` |
+| Bun                | `import { RRegex, RRegexSet } from '@rregex/rregex'`    | `>=1.10.8` |
+| Cloudflare Workers | `import { RRegex, RRegexSet } from 'rregex/lib/cf.mjs'` | `>=1.10.8` |
+| Browser            | TODO                                                    |            |
+| Standalone         | TODO                                                    |            |
 
-### `find(text: string): Match | undefined;`
+## Benchmarks
 
-Returns the start and end byte range of the leftmost-first match in `text`. If no match exists, then `undefined` is returned. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.find))
+In general terms `rregex` is at least 1 order of magnitud slower than the native `RegExp` object, but still have a good performance. **Unless you required some of the features that `rregex` provides, you should always consider using the native `RegExp` object**
 
-```typescript
-const text = "I categorically deny having triskaidekaphobia.";
-const re = new RRegex("\\b\\w{13}\\b");
-expect(re.find(text)).toEqual({
-  value: "categorically",
-  start: 2,
-  end: 15,
-});
-```
+> Benchmarks are executed using [test/deno.bench.mjs](./test/deno.bench.mjs), and [test/node.bench.mjs](./test/node.bench.mjs)
 
-### `findAt(text: string): Match | undefined;`
+### Email
 
-Returns the same as find, but starts the search at the given offset. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.find_at))
+| benchmark |     time (avg) |  iter/s |
+| --------- | -------------: | ------: |
+| RegExp    |  254.8 µs/iter | 3,925.0 |
+| RRegex    |    1.7 ms/iter |   589.9 |
 
-```typescript
-const text = "I categorically deny having triskaidekaphobia.";
-const re = new RRegex("\\b\\w{13}\\b");
-expect(re.findAt(text, 1)).toEqual({
-  value: "categorically",
-  start: 2,
-  end: 15,
-});
+> summary: `RegExp` is 6.65x faster than `RRegex`
 
-expect(re.findAt(text, 5)).toEqual(undefined);
-```
-
-### `findAll(text: string): Match[];`
-
-Returns an array for each successive non-overlapping match in text, returning the start and end byte indices with respect to text ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.find_iter))
-
-```typescript
-    const text = 'Retroactively relinquishing remunerations is reprehensible.'
-    const re = new RRegex('\\b\\w{13}\\b')
-    expect(re.findAll(text)).toEqual([
-      {
-        "end": 13,
-        "start": 0,
-        "value": "Retroactively",
-      },
-      {
-        "end": 27,
-        "start": 14,
-        "value": "relinquishing",
-      },
-      {
-        "end": 41,
-        "start": 28,
-        "value": "remunerations",
-      },
-      {
-        "end": 58,
-        "start": 45,
-        "value": "reprehensible",
-      },
-    ])
-  })
-```
+### IP
 
-### `replace(text: string, rep: string): string;`
+| benchmark |    time (avg) |    iter/s |
+| --------- | ------------: | --------: |
+| RegExp    | 39.1 µs/iter | 25,600.0 |
+| RRegex    |  1.4 ms/iter |    698.1 |
 
-Replaces the leftmost-first match with the replacement provided.
+> summary: `RegExp` is 36.67x faster than `RRegex`
 
-If no match is found, then a copy of the string is returned unchanged. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace))
+### URI
 
-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 RRegex("[^01]+");
-expect(re.replace("1078910", "")).toBe("1010");
-```
-
-But this is a bit cumbersome to use all the time. Instead, a simple syntax is supported that expands `$name` into the corresponding capture group. Here’s the last example, but using this expansion technique with named capture groups:
-
-```typescript
-const re = new RRegex("(?P<last>[^,\\s]+),\\s+(?P<first>\\S+)");
-const result = re.replace("Springsteen, Bruce", "$first $last");
-expect(result).toEqual("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 RRegex("(?P<first>\\w+)\\s+(?P<second>\\w+)");
-const result = re.replace("deep fried", "${first}_$second");
-expect(result).toEqual("deep_fried");
-```
+| benchmark |     time (avg) |      iter/s |
+| --------- | -------------: | ----------: |
+| RegExp    | 422.7 ns/iter | 2,366,000.0 |
+| RRegex    |   1.5 ms/iter |      652.6 |
 
-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.
-
-### `replaceAll(text: string, 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 Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace_all))
-
-### `replacen(text: string, limit: number, 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 Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.replacen))
-
-### `split(text: 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. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.split))
-
-```typescript
-const re = new RRegex("[ \\t]+");
-const fields = re.split("a b \t  c\td    e");
-expect(fields).toEqual(["a", "b", "c", "d", "e"]);
-```
-
-### `splitn(text: string, limit: number): 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.([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.splitn))
-
-```typescript
-const re = new RRegex("\\W+");
-const fields = re.splitn("Hey! How are you?", 3);
-expect(fields).toEqual(["Hey", "How", "are you?"]);
-```
-
-### `shortestMatch(text: string): number | undefined;`
-
-Returns the end location of a match in the text given.
-
-This method may have the same performance characteristics as `is_match`, 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. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.shortest_match))
-
-```typescript
-    const text = 'aaaaa'
-    const pos = new RRegex('a+')
-    expect(pos.shortestMatch(text)).toBe(1)
-```
+> summary: `RegExp` is 3625x faster than `RRegex`
 
-### `shortestMatchAt(text: string, limit: number): number | undefined;`
+| benckmarks                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | benckmarks                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [![Simple IP](./img/rregex-vs-native_-simple-ip.png)](https://jsbenchmark.com/#eyJjYXNlcyI6W3siaWQiOiJlZl9VbGJvYThpRGNYeGM3VUl4YnMiLCJjb2RlIjoiREFUQS5tYXRjaCgnKD86KD86MjVbMC01XXwyWzAtNF1bMC05XXxbMDFdP1swLTldWzAtOV0pXFxcXC4pezN9KD86MjVbMC01XXwyWzAtNF1bMC05XXxbMDFdP1swLTldWzAtOV0pJykiLCJkZXBlbmRlbmNpZXMiOltdLCJuYW1lIjoiUmVnRXhwOiBJUCJ9LHsiaWQiOiI0QkxuZmtPd0p4ZTZhQ0NSVmpIOVUiLCJjb2RlIjoibmV3IHJyZWdleC5SUmVnZXgoXCIoPzooPzoyNVswLTVdfDJbMC00XVswLTldfFswMV0_WzAtOV1bMC05XSlcXFxcLil7M30oPzoyNVswLTVdfDJbMC00XVswLTldfFswMV0_WzAtOV1bMC05XSlcIikuZmluZChEQVRBKSIsImRlcGVuZGVuY2llcyI6W10sIm5hbWUiOiJSUmVnZXg6IElQIn1dLCJjb25maWciOnsibmFtZSI6IlJSZWdleCB2cyBOYXRpdmU6IElQIiwicGFyYWxsZWwiOnRydWUsImdsb2JhbFRlc3RDb25maWciOnsiZGVwZW5kZW5jaWVzIjpbeyJ1cmwiOiJodHRwczovL2Nkbi5qc2RlbGl2ci5uZXQvbnBtL3JyZWdleEAxLjEwLjEwL2xpYi93ZWIubWluLmpzIiwibmFtZSI6InJyZWdleCIsImVzbSI6dHJ1ZX1dfSwiZGF0YUNvZGUiOiJjb25zdCB3cmVzID0gYXdhaXQgZmV0Y2goJ2h0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vcnJlZ2V4QDEuMTAuMTAvbGliL3JyZWdleC53YXNtJylcbmNvbnN0IHcgPSBhd2FpdCB3cmVzLmFycmF5QnVmZmVyKClcbnJyZWdleC5pbml0U3luYyh3KVxuXG5yZXR1cm4gYFxuIyBodHRwczovL3d3dy5jbG91ZGZsYXJlLmNvbS9pcHMtdjQvI1xuMTczLjI0NS40OC4wLzIwXG4xMDMuMjEuMjQ0LjAvMjJcbjEwMy4yMi4yMDAuMC8yMlxuMTAzLjMxLjQuMC8yMlxuMTQxLjEwMS42NC4wLzE4XG4xMDguMTYyLjE5Mi4wLzE4XG4xOTAuOTMuMjQwLjAvMjBcbjE4OC4xMTQuOTYuMC8yMFxuMTk3LjIzNC4yNDAuMC8yMlxuMTk4LjQxLjEyOC4wLzE3XG4xNjIuMTU4LjAuMC8xNVxuMTA0LjE2LjAuMC8xM1xuMTA0LjI0LjAuMC8xNFxuMTcyLjY0LjAuMC8xM1xuMTMxLjAuNzIuMC8yMlxuYCJ9fQ) | [![IP](./img/rregex-vs-native_-ip.png)](https://jsbenchmark.com/#eyJjYXNlcyI6W3siaWQiOiJlZl9VbGJvYThpRGNYeGM3VUl4YnMiLCJjb2RlIjoiREFUQS5tYXRjaCgnKD86KD86MjVbMC01XXwyWzAtNF1bMC05XXxbMDFdP1swLTldWzAtOV0pXFxcXC4pezN9KD86MjVbMC01XXwyWzAtNF1bMC05XXxbMDFdP1swLTldWzAtOV0pJykiLCJkZXBlbmRlbmNpZXMiOltdLCJuYW1lIjoiUmVnRXhwOiBVUkkifSx7ImlkIjoiNEJMbmZrT3dKeGU2YUNDUlZqSDlVIiwiY29kZSI6Im5ldyBycmVnZXguUlJlZ2V4KFwiKD86KD86MjVbMC01XXwyWzAtNF1bMC05XXxbMDFdP1swLTldWzAtOV0pXFxcXC4pezN9KD86MjVbMC01XXwyWzAtNF1bMC05XXxbMDFdP1swLTldWzAtOV0pXCIpLmZpbmQoREFUQSkiLCJkZXBlbmRlbmNpZXMiOltdLCJuYW1lIjoiUlJlZ2V4OiBVUkkifV0sImNvbmZpZyI6eyJuYW1lIjoiUlJlZ2V4IHZzIE5hdGl2ZTogSVAiLCJwYXJhbGxlbCI6dHJ1ZSwiZ2xvYmFsVGVzdENvbmZpZyI6eyJkZXBlbmRlbmNpZXMiOlt7InVybCI6Imh0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vcnJlZ2V4QDEuMTAuMTAvbGliL3dlYi5taW4uanMiLCJuYW1lIjoicnJlZ2V4IiwiZXNtIjp0cnVlfV19LCJkYXRhQ29kZSI6ImNvbnN0IGRyZXMgPSBhd2FpdCBmZXRjaCgnaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL21hcmlvbWthL3JlZ2V4LWJlbmNobWFyay9tYXN0ZXIvaW5wdXQtdGV4dC50eHQnKVxuY29uc3QgZGF0YSA9IGF3YWl0IGRyZXMudGV4dCgpXG5cbmNvbnN0IHdyZXMgPSBhd2FpdCBmZXRjaCgnaHR0cHM6Ly9jZG4uanNkZWxpdnIubmV0L25wbS9ycmVnZXhAMS4xMC4xMC9saWIvcnJlZ2V4Lndhc20nKVxuY29uc3QgdyA9IGF3YWl0IHdyZXMuYXJyYXlCdWZmZXIoKVxucnJlZ2V4LmluaXRTeW5jKHcpXG5cbnJldHVybiBkYXRhLnNsaWNlKDAsIE1hdGguZmxvb3IoZGF0YS5sZW5ndGgvNSkpIn19) |
+| [![email](./img/rregex-vs-native_-email.png)](https://jsbenchmark.com/#eyJjYXNlcyI6W3siaWQiOiJlZl9VbGJvYThpRGNYeGM3VUl4YnMiLCJjb2RlIjoiREFUQS5tYXRjaCgnW1xcXFx3ListXStAW1xcXFx3Li1dK1xcXFwuW1xcXFx3Li1dKycpIiwiZGVwZW5kZW5jaWVzIjpbXSwibmFtZSI6IlJlZ0V4cDogZW1haWwifSx7ImlkIjoiNEJMbmZrT3dKeGU2YUNDUlZqSDlVIiwiY29kZSI6Im5ldyBycmVnZXguUlJlZ2V4KFwiW1xcXFx3XFxcXC4rLV0rQFtcXFxcd1xcXFwuLV0rXFxcXC5bXFxcXHdcXFxcLi1dK1wiKS5maW5kKERBVEEpIiwiZGVwZW5kZW5jaWVzIjpbXSwibmFtZSI6IlJSZWdleDogZW1haWwifV0sImNvbmZpZyI6eyJuYW1lIjoiUlJlZ2V4IHZzIE5hdGl2ZTogZW1haWwiLCJwYXJhbGxlbCI6dHJ1ZSwiZ2xvYmFsVGVzdENvbmZpZyI6eyJkZXBlbmRlbmNpZXMiOlt7InVybCI6Imh0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vcnJlZ2V4QDEuMTAuMTAvbGliL3dlYi5taW4uanMiLCJuYW1lIjoicnJlZ2V4IiwiZXNtIjp0cnVlfV19LCJkYXRhQ29kZSI6ImNvbnN0IGRyZXMgPSBhd2FpdCBmZXRjaCgnaHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL21hcmlvbWthL3JlZ2V4LWJlbmNobWFyay9tYXN0ZXIvaW5wdXQtdGV4dC50eHQnKVxuY29uc3QgZGF0YSA9IGF3YWl0IGRyZXMudGV4dCgpXG5cbmNvbnN0IHdyZXMgPSBhd2FpdCBmZXRjaCgnaHR0cHM6Ly9jZG4uanNkZWxpdnIubmV0L25wbS9ycmVnZXhAMS4xMC4xMC9saWIvcnJlZ2V4Lndhc20nKVxuY29uc3QgdyA9IGF3YWl0IHdyZXMuYXJyYXlCdWZmZXIoKVxucnJlZ2V4LmluaXRTeW5jKHcpXG5cbnJldHVybiBkYXRhLnNsaWNlKDAsIE1hdGguZmxvb3IoZGF0YS5sZW5ndGgvNSkpIn19)                                                                                                                                                                                                                                                                       | [![URI](./img/rregex-vs-native_-uri.png)](https://jsbenchmark.com/#eyJjYXNlcyI6W3siaWQiOiJlZl9VbGJvYThpRGNYeGM3VUl4YnMiLCJjb2RlIjoiREFUQS5tYXRjaCgnW1xcXFx3XSs6XFxcXC9cXFxcL1teXFxcXC9cXFxccz8jXStbXlxcXFxzPyNdKyg_OlxcXFw_W15cXFxccyNdKik_KD86I1teXFxcXHNdKik_JykiLCJkZXBlbmRlbmNpZXMiOltdLCJuYW1lIjoiUmVnRXhwOiBVUkkifSx7ImlkIjoiNEJMbmZrT3dKeGU2YUNDUlZqSDlVIiwiY29kZSI6Im5ldyBycmVnZXguUlJlZ2V4KFwiW1xcXFx3XSs6Ly9bXi9cXFxccz8jXStbXlxcXFxzPyNdKyg_OlxcXFw_W15cXFxccyNdKik_KD86I1teXFxcXHNdKik_XCIpLmZpbmQoREFUQSkiLCJkZXBlbmRlbmNpZXMiOltdLCJuYW1lIjoiUlJlZ2V4OiBVUkkifV0sImNvbmZpZyI6eyJuYW1lIjoiUlJlZ2V4IHZzIE5hdGl2ZTogVVJJIiwicGFyYWxsZWwiOnRydWUsImdsb2JhbFRlc3RDb25maWciOnsiZGVwZW5kZW5jaWVzIjpbeyJ1cmwiOiJodHRwczovL2Nkbi5qc2RlbGl2ci5uZXQvbnBtL3JyZWdleEAxLjEwLjEwL2xpYi93ZWIubWluLmpzIiwibmFtZSI6InJyZWdleCIsImVzbSI6dHJ1ZX1dfSwiZGF0YUNvZGUiOiJjb25zdCBkcmVzID0gYXdhaXQgZmV0Y2goJ2h0dHBzOi8vcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbS9tYXJpb21rYS9yZWdleC1iZW5jaG1hcmsvbWFzdGVyL2lucHV0LXRleHQudHh0JylcbmNvbnN0IGRhdGEgPSBhd2FpdCBkcmVzLnRleHQoKVxuXG5jb25zdCB3cmVzID0gYXdhaXQgZmV0Y2goJ2h0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vcnJlZ2V4QDEuMTAuMTAvbGliL3JyZWdleC53YXNtJylcbmNvbnN0IHcgPSBhd2FpdCB3cmVzLmFycmF5QnVmZmVyKClcbnJyZWdleC5pbml0U3luYyh3KVxuXG5yZXR1cm4gZGF0YS5zbGljZSgwLCBNYXRoLmZsb29yKGRhdGEubGVuZ3RoLzUpKSJ9fQ)                                     |
 
-Returns the same as shortest_match, but starts the search at the given offset. ([See Documentation](https://docs.rs/regex/latest/regex/struct.Regex.html#method.shortest_match_at))
+> **Note:** In order to compare with native regex these benchmarks follow the [`mariomka/regex-benchmark`](https://github.com/mariomka/regex-benchmark) structure
 
 ## Known Issues
 
-If you call `splitn(text, limit)` and the expected result length is equal to `limit - 1` the result will include an extra item `""`, this behavior does not happen if `limit` es greater.
+If you call `splitn(text, limit)` and the expected result length is equal to `limit - 1` the result will include an extra item `""`, this behavior does not happen if `limit` es greater. **`fixed at >=1.3`**
 
 ```ts
-  const regex = new RRegex(',')
-  expect(regex.splitn('a,b,c', 0)).toEqual([])
-  expect(regex.splitn('a,b,c', 1)).toEqual(['a,b,c'])
-  expect(regex.splitn('a,b,c', 2)).toEqual(['a', 'b,c'])
-  expect(regex.splitn('a,b,c', 3)).toEqual(['a', 'b', 'c'])
-
-  // This result includes an unexpected extra item
-  expect(regex.splitn('a,b,c', 4)).toEqual(['a', 'b', 'c', ''])
-  expect(regex.splitn('a,b,c', 5)).toEqual(['a', 'b', 'c'])
-
-  expect(regex.splitn('abc', 0)).toEqual([])
-  expect(regex.splitn('abc', 1)).toEqual(['abc'])
-
-  // This result includes an unexpected extra item
-  expect(regex.splitn('abc', 2)).toEqual(['abc', ''])
-  expect(regex.splitn('abc', 3)).toEqual(['abc'])
+const regex = new RRegex(",");
+expect(regex.splitn("a,b,c", 0)).toEqual([]);
+expect(regex.splitn("a,b,c", 1)).toEqual(["a,b,c"]);
+expect(regex.splitn("a,b,c", 2)).toEqual(["a", "b,c"]);
+expect(regex.splitn("a,b,c", 3)).toEqual(["a", "b", "c"]);
+
+// This result includes an unexpected extra item
+expect(regex.splitn("a,b,c", 4)).toEqual(["a", "b", "c", ""]);
+expect(regex.splitn("a,b,c", 5)).toEqual(["a", "b", "c"]);
+
+expect(regex.splitn("abc", 0)).toEqual([]);
+expect(regex.splitn("abc", 1)).toEqual(["abc"]);
+
+// This result includes an unexpected extra item
+expect(regex.splitn("abc", 2)).toEqual(["abc", ""]);
+expect(regex.splitn("abc", 3)).toEqual(["abc"]);
 ```

package/jsr.json

@@ -0,0 +1,17 @@
+{
+  "name": "@rregex/rregex",
+  "version": "0.0.0-development",
+  "description": "A dependency-free WebAssembly build of Rust Regex for Javascript",
+  "exports": "./lib/esm.mjs",
+  "publish": {
+    "include": [
+      "LICENSE",
+      "README.md",
+      "jsr.json",
+      "lib/rregex.wasm",
+      "lib/rregex.wasm.d.ts",
+      "lib/esm.mjs",
+      "lib/esm.d.ts"
+    ]
+  }
+}