rregex 1.2.0 → 1.2.1

package/lib/esm.mjs

@@ -0,0 +1,611 @@
+import { readFile } from "node:fs/promises";
+
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}
+${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+};
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+export function escape(text) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.escape(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+const RRegexFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rregex_free(ptr >>> 0, 1));
+/**
+ * A compiled regular expression for matching Unicode strings.
+ * @see https://docs.rs/regex/latest/regex/
+ */
+export class RRegex {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RRegexFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rregex_free(ptr, 0);
+    }
+    /**
+     * 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}
+     */
+    isMatchAt(text, start) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_isMatchAt(this.__wbg_ptr, ptr0, len0, start);
+        return ret !== 0;
+    }
+    /**
+     * 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}
+     */
+    replaceAll(text, rep) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(rep, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.rregex_replaceAll(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            deferred3_0 = ret[0];
+            deferred3_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * 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) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_shortestMatch(this.__wbg_ptr, ptr0, len0);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * 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, limit) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_shortestMatchAt(this.__wbg_ptr, ptr0, len0, limit);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * 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) {
+        const ptr0 = passStringToWasm0(re, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        RRegexFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * 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) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_find(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * 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) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_split(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * 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, limit) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_splitn(this.__wbg_ptr, ptr0, len0, limit);
+        return ret;
+    }
+    /**
+     * Return the Regex syntax object
+     * @returns {any}
+     */
+    syntax() {
+        const ret = wasm.rregex_syntax(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * 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}
+     */
+    findAt(text, start) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_findAt(this.__wbg_ptr, ptr0, len0, start);
+        return ret;
+    }
+    /**
+     * 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, rep) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(rep, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.rregex_replace(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            deferred3_0 = ret[0];
+            deferred3_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * 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}
+     */
+    findAll(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_findAll(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * 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}
+     */
+    isMatch(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregex_isMatch(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * 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
+     * @returns {string}
+     */
+    replacen(text, limit, rep) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(rep, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.rregex_replacen(this.__wbg_ptr, ptr0, len0, limit, ptr1, len1);
+            deferred3_0 = ret[0];
+            deferred3_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Returns a string representing the regular expression
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.rregex_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const RRegexSetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rregexset_free(ptr >>> 0, 1));
+/**
+ * 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 {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RRegexSetFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rregexset_free(ptr, 0);
+    }
+    /**
+     * Create a new regex set with the given regular expressions.
+     * @param {Array<any>} list
+     */
+    constructor(list) {
+        const ret = wasm.rregexset_new(list);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        RRegexSetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * 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}
+     */
+    matches(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregexset_matches(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * 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) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rregexset_isMatch(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+}
+
+const imports = {
+    wbg: {
+        __wbg_get_b9b93047fe3cf45b: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_length_e2d2a49132c1b256: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_new_405e22f390576ce2: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_78feb108b6472713: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_c68d7209be747379: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_push_737cfc8c1432c2c6: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_set_bb8cecf6a62b9f46: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments) },
+        __wbindgen_debug_string: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_export_2;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+            ;
+        },
+        __wbindgen_is_string: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
+        __wbindgen_number_new: function(arg0) {
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_string_get: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbindgen_string_new: function(arg0, arg1) {
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_throw: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+    },
+
+};
+
+const wasm_url = new URL('rregex.wasm', import.meta.url);
+let wasmCode = '';
+switch (wasm_url.protocol) {
+    case 'file:':
+    wasmCode = await readFile(wasm_url);
+    break
+    case 'https:':
+    case 'http:':
+    wasmCode = await (await fetch(wasm_url)).arrayBuffer();
+    break
+    default:
+    throw new Error(`Unsupported protocol: ${wasm_url.protocol}`);
+}
+
+const wasmInstance = (await WebAssembly.instantiate(wasmCode, imports)).instance;
+const wasm = wasmInstance.exports;
+export const __wasm = wasm;
+
+wasm.__wbindgen_start();
+
+
+/** Build metadata */
+export const metadata = {
+  "name": "rregex",
+  "description": "Rust Regex binding for Javascript",
+  "authors": [
+    "Fede Ramirez <i@2fd.me>"
+  ],
+  "homepage": "http://rregex.dev",
+  "repository": "https://github.com/2fd/rregex",
+  "regex": "1.2.1",
+  "regex-syntax": "0.6.11"
+}

package/lib/rregex.wasm.d.ts

@@ -1,29 +1,32 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export function escape(a: number, b: number, c: number): void;
-export function __wbg_rregex_free(a: number): void;
-export function rregex_new(a: number, b: number): number;
-export function rregex_isMatch(a: number, b: number, c: number): number;
-export function rregex_isMatchAt(a: number, b: number, c: number, d: number): number;
-export function rregex_find(a: number, b: number, c: number): number;
-export function rregex_findAt(a: number, b: number, c: number, d: number): number;
-export function rregex_findAll(a: number, b: number, c: number): number;
-export function rregex_replace(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function rregex_replacen(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
-export function rregex_replaceAll(a: number, b: number, c: number, d: number, e: number, f: number): void;
-export function rregex_split(a: number, b: number, c: number): number;
-export function rregex_splitn(a: number, b: number, c: number, d: number): number;
-export function rregex_shortestMatch(a: number, b: number, c: number, d: number): void;
-export function rregex_shortestMatchAt(a: number, b: number, c: number, d: number, e: number): void;
-export function rregex_syntax(a: number): number;
-export function rregex_toString(a: number, b: number): void;
-export function __wbg_rregexset_free(a: number): void;
-export function rregexset_new(a: number): number;
-export function rregexset_isMatch(a: number, b: number, c: number): number;
-export function rregexset_matches(a: number, b: number, c: number): number;
-export function __wbindgen_malloc(a: number): number;
-export function __wbindgen_realloc(a: number, b: number, c: number): number;
-export function __wbindgen_add_to_stack_pointer(a: number): number;
-export function __wbindgen_free(a: number, b: number): void;
-export function __wbindgen_exn_store(a: number): void;
+export const __wbg_rregex_free: (a: number, b: number) => void;
+export const rregex_find: (a: number, b: number, c: number) => any;
+export const rregex_findAll: (a: number, b: number, c: number) => any;
+export const rregex_findAt: (a: number, b: number, c: number, d: number) => any;
+export const rregex_isMatch: (a: number, b: number, c: number) => number;
+export const rregex_isMatchAt: (a: number, b: number, c: number, d: number) => number;
+export const rregex_new: (a: number, b: number) => [number, number, number];
+export const rregex_replace: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const rregex_replaceAll: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const rregex_replacen: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const rregex_shortestMatch: (a: number, b: number, c: number) => number;
+export const rregex_shortestMatchAt: (a: number, b: number, c: number, d: number) => number;
+export const rregex_split: (a: number, b: number, c: number) => any;
+export const rregex_splitn: (a: number, b: number, c: number, d: number) => any;
+export const rregex_syntax: (a: number) => any;
+export const rregex_toString: (a: number) => [number, number];
+export const __wbg_rregexset_free: (a: number, b: number) => void;
+export const escape: (a: number, b: number) => [number, number];
+export const rregexset_isMatch: (a: number, b: number, c: number) => number;
+export const rregexset_matches: (a: number, b: number, c: number) => any;
+export const rregexset_new: (a: any) => [number, number, number];
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_export_2: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;