add doc

README.md

@@ -19,8 +19,192 @@ There are certain features of PCRE or Perl regular expressions that cannot be im
 
 ## Usage
 
+This document provides a series of examples demonstrating how to use RE2JS in your code. For more detailed information about regex syntax, please visit this page: [Google RE2 Syntax Documentation](https://github.com/google/re2/wiki/Syntax).
+
+### Compiling Patterns
+
+You can compile a regex pattern using the `RE2JS.compile()` function:
+
+```js
+import { RE2JS } from 're2js'
+
+const p = RE2JS.compile('abc');
+console.log(p.pattern()); // Outputs: 'abc'
+console.log(p.flags()); // Outputs: 0
+```
+
+The `RE2JS.compile()` function also supports flags:
+
+```js
+import { RE2JS } from 're2js'
+
+const p = RE2JS.compile('abc', RE2JS.CASE_INSENSITIVE | RE2JS.MULTILINE);
+console.log(p.pattern()); // Outputs: 'abc'
+console.log(p.flags()); // Outputs: 5
+```
+
+Supported flags:
+
+```js
+/**
+ * Flag: case insensitive matching.
+ */
+RE2JS.CASE_INSENSITIVE
+/**
+ * Flag: dot ({@code .}) matches all characters, including newline.
+ */
+RE2JS.DOTALL
+/**
+ * Flag: multiline matching: {@code ^} and {@code $} match at beginning and end of line, not just
+ * beginning and end of input.
+ */
+RE2JS.MULTILINE
+/**
+ * Flag: Unicode groups (e.g. {@code \p\ Greek\} ) will be syntax errors.
+ */
+RE2JS.DISABLE_UNICODE_GROUPS
+/**
+ * Flag: matches longest possible string.
+ */
+RE2JS.LONGEST_MATCH
+```
+
+### Checking for Matches
+
+RE2JS allows you to check if a string matches a given regex pattern using the `RE2JS.matches()` function
+
+```js
+import { RE2JS } from 're2js'
+
+RE2JS.matches('ab+c', 'abbbc') // true
+RE2JS.matches('ab+c', 'cbbba') // false
+// or
+RE2JS.compile('ab+c').matches('abbbc') // true
+RE2JS.compile('ab+c').matches('cbbba') // false
+// with flags
+RE2JS.compile('ab+c', RE2JS.CASE_INSENSITIVE).matches('AbBBc') // true
+```
+
+### Finding Matches
+
+To find a match for a given regex pattern in a string, you can use the `find()` function
+
+```js
+import { RE2JS } from 're2js'
+
+RE2JS.compile('ab+c').matcher('xxabbbc').find() // true
+RE2JS.compile('ab+c').matcher('cbbba').find() // false
+// with flags
+RE2JS.compile('ab+c', RE2JS.CASE_INSENSITIVE).matcher('abBBc').find() // true
+```
+
+The `find()` method searches for a pattern match in a string starting from a specific index
+
+```js
+import { RE2JS } from 're2js'
+
+const p = RE2JS.compile('.*[aeiou]')
+const matchString = p.matcher('abcdefgh')
+matchString.find(0) // true
+matchString.group() // 'abcde'
+matchString.find(1) // true
+matchString.group() // 'bcde'
+matchString.find(4) // true
+matchString.group() // 'e'
+matchString.find(7) // false
+```
+
+### Splitting Strings
+
+You can split a string based on a regex pattern using the `split()` function
+
+```js
+import { RE2JS } from 're2js'
+
+RE2JS.compile('/').split('abcde') // ['abcde']
+RE2JS.compile('/').split('a/b/cc//d/e//') // ['a', 'b', 'cc', '', 'd', 'e']
+RE2JS.compile(':').split(':a::b') // ['', 'a', '', 'b']
+```
+
+The `split()` function also supports a limit parameter
+
+```js
+import { RE2JS } from 're2js'
+
+RE2JS.compile('/').split('a/b/cc//d/e//', 3) // ['a', 'b', 'cc//d/e//']
+RE2JS.compile('/').split('a/b/cc//d/e//', 4) // ['a', 'b', 'cc', '/d/e//']
+RE2JS.compile('/').split('a/b/cc//d/e//', 9) // ['a', 'b', 'cc', '', 'd', 'e', '', '']
+RE2JS.compile(':').split('boo:and:foo', 2) // ['boo', 'and:foo']
+RE2JS.compile(':').split('boo:and:foo', 5) // ['boo', 'and', 'foo']
+```
+
+### Working with Groups
+
+RE2JS supports capturing groups in regex patterns
+
+#### Group Count
+
+You can get the count of groups in a pattern using the `groupCount()` function
+
+```js
+import { RE2JS } from 're2js'
+
+RE2JS.compile('(.*)ab(.*)a').groupCount() // 2
+RE2JS.compile('(.*)((a)b)(.*)a').groupCount() // 4
+RE2JS.compile('(.*)(\\(a\\)b)(.*)a').groupCount() // 3
+```
+
+#### Named Groups
+
+You can access the named groups in a pattern using the `namedGroups()` function
+
+```js
+import { RE2JS } from 're2js'
+
+RE2JS.compile('(?P<foo>\\d{2})').namedGroups() // { foo: 1 }
+RE2JS.compile('\\d{2}').namedGroups() // {}
+RE2JS.compile('(?P<foo>.*)(?P<bar>.*)').namedGroups() // { foo: 1, bar: 2 }
+```
+
+#### Group Content
+
+The `group()` method retrieves the content matched by a specific capturing group
+
+```js
+import { RE2JS } from 're2js'
+
+const p = RE2JS.compile('(a)(b(c)?)d?(e)')
+const matchString = p.matcher('xabdez')
+if (matchString.find()) {
+  matchString.group(0) // 'abde'
+  matchString.group(1) // 'a'
+  matchString.group(2) // 'b'
+  matchString.group(3) // null
+  matchString.group(4) // 'e'
+}
+```
+
+#### Named Group Content
+
+The `group()` method retrieves the content matched by a specific capturing group by name
+
+```js
+import { RE2JS } from 're2js'
+
+const p = RE2JS.compile('(?P<baz>f(?P<foo>b*a(?P<another>r+)){0,10})(?P<bag>bag)?(?P<nomatch>zzz)?')
+const matchString = p.matcher('fbbarrrrrbag')
+if (matchString.matches()) {
+  matchString.group('baz') // 'fbbarrrrr'
+  matchString.group('foo') // 'bbarrrrr'
+  matchString.group('another') // 'rrrrr'
+  matchString.group('bag') // 'bag'
+  matchString.group('nomatch') // null
+}
+```
+
+### Replacing Matches
+
 
-For more detailed information about regex syntax, please visit this page: [Google RE2 Syntax Documentation](https://github.com/google/re2/wiki/Syntax).
 
 ## Performance