rregex 1.0.0 → 1.0.4

package/lib/types.d.ts

@@ -1,51 +1,416 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
-* @returns {any}
+* @param {string} text
+* @returns {string}
 */
-export function get_metadata(): any;
+export function escape(text: string): string;
+
+export type Hir = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Hir'
+  bold: boolean;
+  italic: boolean;
+  size: number;
+}
+
+
+
+export type HirKind =
+  | HirKindEmptyVariant
+  | HirKindLiteralVariant
+  | HirKindClassVariant
+  | HirKindAnchorVariant
+  | HirKindWordBoundaryVariant
+  | HirKindRepetitionVariant
+  | HirKindGroupVariant
+  | HirKindConcatVariant
+  | HirKindAlternationVariant
+
+export type HirKindEmptyVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Empty'
+}
+
+export type HirKindLiteralVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Literal'
+  'value': Literal
+}
+
+export type HirKindClassVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Class'
+  'value': Class
+}
+
+export type HirKindAnchorVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Anchor'
+  'value': Anchor
+}
+
+export type HirKindWordBoundaryVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'WordBoundary'
+  'value': WordBoundary
+}
+
+export type HirKindRepetitionVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Repetition'
+  'value': Repetition
+}
+
+export type HirKindGroupVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Group'
+  'value': Group
+}
+
+export type HirKindConcatVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Concat'
+  'value': Hir[]
+}
+
+export type HirKindAlternationVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::HirKind'
+  '@variant': 'Alternation'
+  'value': Hir[]
+}
+
+
+
+export type Literal =
+  | LiteralUnicodeVariant
+  | LiteralByteVariant
+
+export type LiteralUnicodeVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Literal'
+  '@variant': 'Unicode'
+  'value': string
+}
+
+export type LiteralByteVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Literal'
+  '@variant': 'Byte'
+  'value': number
+}
+
+
+
+export type Class =
+  | ClassUnicodeVariant
+  | ClassByteVariant
+
+export type ClassUnicodeVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Class'
+  '@variant': 'Unicode'
+  'value': ClassUnicode
+}
+
+export type ClassByteVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Class'
+  '@variant': 'Bytes'
+  'value': ClassBytes
+}
+
+
+
+export type ClassUnicode = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::ClassUnicode'
+  'ranges': ClassUnicodeRange[]
+}
+
+
+
+export type ClassUnicodeRange = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::ClassUnicodeRange'
+  start: string
+  end: string
+}
+
+
+
+export type ClassBytes = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::ClassBytes'
+  ranges: ClassBytesRange[]
+}
+
+
+
+export type ClassBytesRange = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::ClassBytesRange'
+  start: number
+  end: number
+}
+
+
+
+export type Anchor =
+  | AnchorStartLineVariant
+  | AnchorEndLineVariant
+  | AnchorStartTextVariant
+  | AnchorEndTextVariant
+
+export type AnchorStartLineVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Anchor'
+  '@variant': 'StartLine'
+}
+
+export type AnchorEndLineVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Anchor'
+  '@variant': 'EndLine'
+}
+
+export type AnchorStartTextVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Anchor'
+  '@variant': 'StartText'
+}
+
+export type AnchorEndTextVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Anchor'
+  '@variant': 'EndText'
+}
+
+
+
+export type WordBoundary =
+  | WordBoundaryAsciiVariant
+  | WordBoundaryAsciiNegateVariant
+  | WordBoundaryUnicodeVariant
+  | WordBoundaryUnicodeNegateVariant
+
+export type WordBoundaryAsciiVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::WordBoundary'
+  '@variant': 'Ascii'
+}
+
+export type WordBoundaryAsciiNegateVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::WordBoundary'
+  '@variant': 'AsciiNegate'
+}
+
+export type WordBoundaryUnicodeVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::WordBoundary'
+  '@variant': 'Unicode'
+}
+
+export type WordBoundaryUnicodeNegateVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::WordBoundary'
+  '@variant': 'UnicodeNegate'
+}
+
+
+
+export type Repetition = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Repetition'
+  greedy: boolean
+  kind: RepetitionKind
+  hir: Hir
+}
+
+
+
+export type RepetitionKind =
+  | RepetitionKindZeroOrOneVariant
+  | RepetitionKindZeroOrMoreVariant
+  | RepetitionKindOneOrMoreVariant
+  | RepetitionKindRangeVariant
+
+export type RepetitionKindZeroOrOneVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Repetition'
+  '@variant': 'ZeroOrOne'
+}
+
+export type RepetitionKindZeroOrMoreVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Repetition'
+  '@variant': 'ZeroOrMore'
+}
+
+export type RepetitionKindOneOrMoreVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Repetition'
+  '@variant': 'OneOrMore'
+}
+
+export type RepetitionKindRangeVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Repetition'
+  '@variant': 'Range'
+  value: RepetitionRange
+}
+
+
+
+export type RepetitionRange =
+  | RepetitionRangeExactlyVariant
+  | RepetitionRangeAtLeastVariant
+  | RepetitionRangeBoundedVariant
+
+export type RepetitionRangeExactlyVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::RepetitionRange'
+  '@variant': 'Exactly'
+  value: number
+}
+
+export type RepetitionRangeAtLeastVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::RepetitionRange'
+  '@variant': 'AtLeast'
+  value: number
+}
+
+export type RepetitionRangeBoundedVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::RepetitionRange'
+  '@variant': 'Bounded'
+  value: [number, number]
+}
+
+
+
+export type Group = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::Group'
+  kind: GroupKind
+  hir: Hir
+}
+
+
+
+export type GroupKind =
+  | GroupKindCaptureIndexVariant
+  | GroupKindCaptureNameVariant
+  | GroupKindNonCapturingVariant
+
+export type GroupKindCaptureIndexVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::GroupKind'
+  '@variant': 'CaptureIndex'
+  index: number
+}
+
+export type GroupKindCaptureNameVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::GroupKind'
+  '@variant': 'CaptureName'
+  index: number
+  name: string
+}
+
+export type GroupKindNonCapturingVariant = {
+  '@type': 'struct'
+  '@name': 'regex_syntax::hir::GroupKind'
+  '@variant': 'NonCapturing'
+}
+
+
+
+export type Match = {
+  start: number
+  end: number
+  value: string
+}
+
+
 /**
+* A compiled regular expression for matching Unicode strings.
+* @see https://docs.rs/regex/latest/regex/
 */
-export class RRegExp {
+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.
+* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.is_match
 * @param {string} text
 * @returns {boolean}
 */
-  is_match(text: string): 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
 * @param {number} start
 * @returns {boolean}
 */
-  is_match_at(text: string, start: number): 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 `is_match`.
+* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.find
 * @param {string} text
 * @returns {any}
 */
-  find(text: string): any;
+  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
 * @param {number} start
 * @returns {any}
 */
-  find_at(text: string, start: number): any;
+  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.
+* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.find_iter
 * @param {string} text
 * @returns {any}
 */
-  find_all(text: string): any;
+  findAll(text: string): Match[];
 /**
+* 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.
+* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace
 * @param {string} text
 * @param {string} rep
 * @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
 * @param {number} limit
 * @param {string} rep
@@ -53,46 +418,114 @@ export class RRegExp {
 */
   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 https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace_all
 * @param {string} text
 * @param {string} rep
 * @returns {string}
 */
-  replace_all(text: string, rep: string): 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.
+* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.split
 * @param {string} text
 * @returns {any}
 */
-  split(text: string): any;
+  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.
+* @see https://docs.rs/regex/latest/regex/struct.Regex.html#method.splitn
+* @param {string} text
+* @param {number} limit
+* @returns {any}
+*/
+  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 `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 https://docs.rs/regex/latest/regex/struct.Regex.html#method.shortest_match
+* @param {string} text
+* @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
 * @param {number} limit
+* @returns {number | undefined}
+*/
+  shortestMatchAt(text: string, limit: number): number | undefined;
+/**
+* Return the Regex syntax object
 * @returns {any}
 */
-  splitn(text: string, limit: number): 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.
+* @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.
+* @see https://docs.rs/regex/latest/regex/struct.RegexSet.html#method.is_match
+* @param {string} text
+* @returns {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.
+* @param {string} text
 * @returns {any}
 */
-  syntax(): any;
+  matches(text: string): any;
 }
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_rregexp_free: (a: number) => void;
-  readonly rregexp_new: (a: number, b: number) => number;
-  readonly rregexp_is_match: (a: number, b: number, c: number) => number;
-  readonly rregexp_is_match_at: (a: number, b: number, c: number, d: number) => number;
-  readonly rregexp_find: (a: number, b: number, c: number) => number;
-  readonly rregexp_find_at: (a: number, b: number, c: number, d: number) => number;
-  readonly rregexp_find_all: (a: number, b: number, c: number) => number;
-  readonly rregexp_replace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly rregexp_replacen: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-  readonly rregexp_replace_all: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly rregexp_split: (a: number, b: number, c: number) => number;
-  readonly rregexp_splitn: (a: number, b: number, c: number, d: number) => number;
-  readonly rregexp_syntax: (a: number) => number;
-  readonly get_metadata: () => number;
+  readonly __wbg_rregex_free: (a: number) => void;
+  readonly rregex_new: (a: number, b: 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_find: (a: number, b: number, c: number) => number;
+  readonly rregex_findAt: (a: number, b: number, c: number, d: number) => number;
+  readonly rregex_findAll: (a: number, b: number, c: 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) => number;
+  readonly rregex_splitn: (a: number, b: number, c: number, d: number) => number;
+  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) => number;
+  readonly rregex_toString: (a: number, b: number) => void;
+  readonly __wbg_rregexset_free: (a: number) => void;
+  readonly rregexset_new: (a: number) => number;
+  readonly rregexset_isMatch: (a: number, b: number, c: number) => number;
+  readonly rregexset_matches: (a: number, b: number, c: number) => number;
+  readonly escape: (a: number, b: number, c: number) => void;
   readonly __wbindgen_malloc: (a: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
@@ -109,3 +542,15 @@ export interface InitOutput {
 * @returns {Promise<InitOutput>}
 */
 export default function 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": "https://2fd.github.io/rregex",
+  "repository": "https://github.com/2fd/rregex",
+  "regex": "1.0.6",
+  "regex-syntax": "0.6.25"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rregex",
-  "version": "1.0.0",
+  "version": "1.0.4",
   "description": "Rust Regex binding for Javascript",
   "private": false,
   "main": "./lib/commonjs.js",
@@ -8,18 +8,41 @@
   "module": "./lib/module.js",
   "types": "./lib/types.d.ts",
   "devDependencies": {
-    "semantic-release": "^18.0.1"
+    "@babel/plugin-proposal-class-properties": "^7.16.0",
+    "@babel/preset-env": "^7.16.4",
+    "@babel/preset-typescript": "^7.16.0",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^16.11.11",
+    "babel-jest": "^27.4.2",
+    "jest": "^27.4.3",
+    "semantic-release": "^18.0.1",
+    "toml": "^3.0.0",
+    "typescript": "^4.5.2"
   },
   "scripts": {
     "setup": "./bin/install.sh",
     "build": "./bin/build.sh",
-    "test": "wasm-pack test",
+    "test": "wasm-pack test  --node && jest --passWithNoTests",
+    "test:rs": "wasm-pack test",
+    "test:ts": "jest",
     "semantic-release": "semantic-release"
   },
   "release": {
     "ci": false,
     "branches": [
-      "master"
+      {
+        "name": "1.0.x",
+        "range": "1.0.x",
+        "channel": "1.0.x"
+      },
+      {
+        "name": "1.1.x",
+        "range": "1.1.x",
+        "channel": "1.1.x"
+      },
+      {
+        "name": "master"
+      }
     ]
   },
   "repository": {