@re2tools/re2-wasm-esm 1.0.0

package/DOCUMENTATION.md

@@ -0,0 +1,177 @@
+# re2-wasm-esm — Full documentation
+
+Standalone ESM build of [Google RE2](https://github.com/google/re2) as WebAssembly with **browser and Node** support. No dependency on the `re2-wasm` npm package; all code and artifacts live in this repo.
+
+---
+
+## 1. Overview
+
+- **What it is**: RE2 regex engine compiled to WebAssembly, with an ESM API and async init for browser and Node.
+- **Why it exists**: [re2-wasm](https://github.com/google/re2-wasm) is Node-only (CommonJS, sync). This package is a standalone fork: ESM, browser + Node, with everything vendored so nothing is pulled from re2-wasm at build or runtime.
+- **License**: Apache-2.0 (same as re2-wasm).
+
+---
+
+## 2. Package layout
+
+| Path | Purpose |
+|------|--------|
+| **`src/`** | TypeScript source. `loader.ts` loads WASM; `re2-wasm/` contains the vendored RE2 class and types (from google/re2-wasm). |
+| **`wasm/`** | **Build-time only.** Committed artifacts: `re2.wasm` (compiled RE2) and `re2-glue.js` (Emscripten glue). The build script copies these into `dist/`. |
+| **`dist/`** | **Runtime.** Output of `tsc` plus copied `re2.wasm` and `re2-glue.js`. This is what gets published and what Node/browser use at runtime. |
+| **`scripts/`** | `copy-wasm.cjs` copies `wasm/re2.wasm` and `wasm/re2-glue.js` into `dist/`; invoked by the `build` script. |
+
+**Exports:** The package exposes only `dist/` (and README). `main` / `module` / `types` point to `dist/index.js` and `dist/index.d.ts`.
+
+---
+
+## 3. Build
+
+```bash
+npm run build
+```
+
+- Runs `tsc` (emits JS and `.d.ts` into `dist/`).
+- Copies `wasm/re2.wasm` and `wasm/re2-glue.js` into `dist/`.  
+If `wasm/re2.wasm` is missing, the build throws.
+
+**Publish:** `prepublishOnly` runs `npm run build`, so published tarballs always include a built `dist/` with WASM and glue.
+
+---
+
+## 4. The `wasm/` folder
+
+### What it is
+
+- **`re2.wasm`** — The compiled RE2 engine. All regex behavior (match, exec, etc.) runs inside this binary.
+- **`re2-glue.js`** — Emscripten-generated JS that loads the WASM, creates the `Module` with `WrappedRE2`, and bridges C++ to JS.
+
+### When it’s used
+
+- **Build time only.** The build copies these two files into `dist/`. Runtime (Node and browser) always uses the **`dist/`** copies, never reads from `wasm/` directly.
+
+### Can the package work without `wasm/`?
+
+**No.** Without the WASM binary and glue there is no RE2 engine. Removing `wasm/` would mean nothing to copy to `dist/`, so Node would fail reading the files and the browser would fail fetching them. The package fundamentally depends on these artifacts; `wasm/` is simply where this repo stores them.
+
+### Does `wasm/` affect browser vs Node?
+
+**No.** Both environments use the same files that end up in `dist/`. Only the loading mechanism differs: Node reads from disk (`fs`), browser fetches by URL.
+
+---
+
+## 5. Runtime behavior
+
+### Node
+
+- `init()` uses `__dirname` relative to the **compiled** loader (i.e. `dist/`).
+- It reads `dist/re2.wasm` and `dist/re2-glue.js` from the filesystem, preloads the binary into `Module.wasmBinary`, and runs the glue so the Emscripten runtime uses sync instantiation and `onRuntimeInitialized` runs.
+
+### Browser
+
+- `init()` fetches `re2.wasm` and `re2-glue.js` from URLs (by default derived from `import.meta.url`, or you pass `baseUrl` / `wasmUrl` / `glueUrl`).
+- Those URLs must point to the same files (typically the ones from `dist/`, copied to your app’s public or CDN).
+
+Same code path for both; only the way the binary and glue are obtained differs.
+
+---
+
+## 6. Install and usage
+
+### Install
+
+```bash
+npm install @re2tools/re2-wasm-esm
+```
+
+### Node (ESM)
+
+```js
+import { init, getRE2 } from "@re2tools/re2-wasm-esm";
+
+await init();
+const RE2 = getRE2();
+const re = new RE2("a(b*)", "u");
+console.log(re.exec("abbc")); // [ "abb", "bb", ... ]
+```
+
+### Browser
+
+1. Ensure `dist/re2.wasm` and `dist/re2-glue.js` are served (same origin or pass URLs to `init()`).
+2. Call `await init()` before any RE2 use.
+
+```js
+import { init, getRE2 } from "@re2tools/re2-wasm-esm";
+
+await init();
+const RE2 = getRE2();
+const re = new RE2("a(b*)", "u");
+re.test("abbc"); // true
+```
+
+With a bundler (Vite, Webpack, etc.), either copy `node_modules/@re2tools/re2-wasm-esm/dist/re2.wasm` and `re2-glue.js` to your public/output directory, or pass a base URL:
+
+```js
+await init({ baseUrl: "https://your-cdn.com/@re2tools/re2-wasm-esm/" });
+```
+
+---
+
+## 7. API reference
+
+| Export | Description |
+|--------|-------------|
+| **`init(options?)`** | Initializes the WASM runtime. In browser, loads WASM and glue. Resolves when ready. Call once before `getRE2()`. |
+| **`getRE2()`** | Returns the RE2 class. Throws if `init()` has not been called. |
+| **`whenReady()`** | Returns a Promise that resolves to the WASM module when ready (for advanced use). |
+| **`getModule()`** | Returns the low-level WASM module (e.g. `WrappedRE2`). Throws if not ready. |
+
+**`init` options (all optional):**
+
+- **`baseUrl`** — Base URL for WASM and glue in browser (e.g. `"https://cdn.example.com/@re2tools/re2-wasm-esm/"`).
+- **`wasmUrl`** — Full URL for `re2.wasm` (overrides `baseUrl` for WASM only).
+- **`glueUrl`** — Full URL for `re2-glue.js` (overrides `baseUrl` for glue only).
+
+**RE2 API:** Matches a `RegExp`-like interface: `exec()`, `test()`, `match()`, `replace()`, `search()`, `split()`, flags `g`, `i`, `m`, `u`, etc. RE2 requires the **`u`** (unicode) flag.
+
+**Types:** `RE2ExecArray`, `RE2MatchArray`, `Re2WasmModule` are exported from the package.
+
+---
+
+## 8. Using as common utils in a monolith
+
+You can use this package only inside the repo (e.g. as a workspace dependency) without publishing to npm.
+
+1. **Add a workspace dependency** in the app or package that needs RE2:
+   ```json
+   "@re2tools/re2-wasm-esm": "workspace:*"
+   ```
+2. **Build the package** so `dist/` exists (e.g. from repo root: `pnpm --filter @re2tools/re2-wasm-esm build`, or as a pre-step of the app build).
+3. **In code:** `import { init, getRE2 } from "@re2tools/re2-wasm-esm";` then `await init();` and `getRE2()` as in the examples above.
+4. **Browser:** Ensure `dist/re2.wasm` and `dist/re2-glue.js` from the package are served (copy to public/output or set `init({ baseUrl: "…" })`).
+
+Using the TypeScript source “directly” (e.g. importing from `@re2tools/re2-wasm-esm/src`) doesn’t remove the need for the WASM and glue: the loader still expects to read or fetch those files at runtime, so they must still be produced (e.g. by the same copy step) and available from the right path.
+
+---
+
+## 9. Updating the WASM (maintainers)
+
+To refresh from upstream:
+
+1. Build [google/re2-wasm](https://github.com/google/re2-wasm).
+2. Copy its `build/wasm/re2.wasm` and `build/wasm/re2.js` into this repo’s **`wasm/`** as **`re2.wasm`** and **`re2-glue.js`**.
+3. Run `npm run build` and test.
+
+Until you do this, the package does not change when upstream re2-wasm changes.
+
+---
+
+## 10. Summary
+
+| Topic | Summary |
+|-------|--------|
+| **Layout** | `src/` = TS; `wasm/` = WASM + glue (build-time source); `dist/` = built output; `scripts/copy-wasm.cjs` = copy wasm → dist. |
+| **Build** | `tsc` + copy `wasm/*` → `dist/`. |
+| **wasm/** | Required. Holds the only source of the binary and glue; without it the package cannot work. |
+| **Node vs browser** | Both use `dist/`; Node reads files from disk, browser fetches by URL. |
+| **Common utils** | Use as a workspace dependency; build the package and serve `dist/re2.wasm` and `dist/re2-glue.js` in the browser when needed. |

package/README.md

@@ -0,0 +1,82 @@
+# re2-wasm-esm
+
+Standalone ESM build of [Google RE2](https://github.com/google/re2) as WebAssembly with **browser and Node** support. **No dependency on the re2-wasm package** — all code and artifacts live in this repo.
+
+📄 **[Full documentation](DOCUMENTATION.md)** — package layout, `wasm/` role, build, runtime (Node vs browser), API, using as common utils, updating upstream.
+
+- **Source**: RE2 class and types are vendored under `src/re2-wasm/` (from [google/re2-wasm/src](https://github.com/google/re2-wasm/tree/main/src), Apache-2.0).
+- **WASM**: `wasm/re2.wasm` and `wasm/re2-glue.js` (Emscripten glue) are committed in `wasm/`. Build copies them into `dist/` for publish and runtime.
+
+So if upstream re2-wasm changes, this package does not change until you explicitly update the vendored files.
+
+**Runtime:**
+
+- **Browser**: Loads the committed WASM and glue asynchronously; call `await init()` before using RE2.
+- **Node**: Uses the same committed WASM and glue from `dist/` (same as browser).
+
+## Install
+
+```bash
+npm install @re2tools/re2-wasm-esm
+```
+
+## Usage
+
+### Node (ESM)
+
+```js
+import { init, getRE2 } from "@re2tools/re2-wasm-esm";
+
+await init();
+const RE2 = getRE2();
+const re = new RE2("a(b*)", "u");
+console.log(re.exec("abbc")); // [ "abb", "bb", ... ]
+```
+
+### Browser
+
+1. Ensure `dist/re2.wasm` and `dist/re2-glue.js` are served from the same origin (or pass URLs to `init()`).
+2. Call `await init()` before any RE2 use.
+
+```js
+import { init, getRE2 } from "@re2tools/re2-wasm-esm";
+
+await init(); // loads WASM; required in browser
+const RE2 = getRE2();
+const re = new RE2("a(b*)", "u");
+re.test("abbc"); // true
+```
+
+With a bundler (Vite, Webpack, etc.), copy `node_modules/@re2tools/re2-wasm-esm/dist/re2.wasm` and `re2-glue.js` to your public/output directory, or pass a base URL:
+
+```js
+await init({ baseUrl: "https://your-cdn.com/@re2tools/re2-wasm-esm/" });
+```
+
+### API
+
+- **`init(options?: { wasmUrl?, glueUrl?, baseUrl? })`**  
+  Initializes the runtime. In browser, loads WASM and glue script. Resolves when ready. Call once before `getRE2()`.
+
+- **`getRE2()`**  
+  Returns the RE2 class. Throws if `init()` has not been called.
+
+- **`whenReady()`**  
+  Returns a Promise that resolves to the WASM module when ready (for advanced use).
+
+- **`getModule()`**  
+  Returns the low-level WASM module (e.g. `WrappedRE2`). Throws if not ready.
+
+RE2 API matches the standard `RegExp`-like interface: `exec()`, `test()`, `match()`, `replace()`, `search()`, `split()`, flags `g`, `i`, `m`, `u`, etc. RE2 requires the **`u`** (unicode) flag.
+
+## Why
+
+- [re2-wasm](https://github.com/google/re2-wasm) is Node-only (sync WASM, CommonJS). This package is a **standalone** fork: ESM, browser + Node, with all needed code and WASM committed here so nothing is pulled from re2-wasm at build or runtime.
+
+### Updating the WASM (maintainers)
+
+To refresh from upstream: build [google/re2-wasm](https://github.com/google/re2-wasm) and copy its `build/wasm/re2.wasm` and `build/wasm/re2.js` into this repo’s `wasm/` as `re2.wasm` and `re2-glue.js`.
+
+## License
+
+Apache-2.0 (same as re2-wasm).

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * re2-wasm-esm — Google RE2 as WASM, ESM + browser support.
+ * Uses vendored source from https://github.com/google/re2-wasm (Apache-2.0).
+ */
+export { init, getModule, whenReady } from "./loader.js";
+export type { Re2WasmModule } from "./loader.js";
+export type { RE2ExecArray, RE2MatchArray } from "./re2-wasm/re2.js";
+/**
+ * Returns the RE2 class. Must call await init() first.
+ *
+ * @example
+ * await init();
+ * const RE2 = getRE2();
+ * const re = new RE2("a(b*)", "u");
+ * re.exec("abbc");
+ */
+export declare function getRE2(): (new (pattern: string | RegExp, flags?: string) => import("./re2-wasm/re2.js").RE2);
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIrE;;;;;;;;GAQG;AACH,wBAAgB,MAAM,IAAI,CAAC,KACzB,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,KAAK,CAAC,EAAE,MAAM,KACX,OAAO,mBAAmB,EAAE,GAAG,CAAC,CAUpC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * re2-wasm-esm — Google RE2 as WASM, ESM + browser support.
+ * Uses vendored source from https://github.com/google/re2-wasm (Apache-2.0).
+ */
+export { init, getModule, whenReady } from "./loader.js";
+import { resolvedRE2Class } from "./loader.js";
+/**
+ * Returns the RE2 class. Must call await init() first.
+ *
+ * @example
+ * await init();
+ * const RE2 = getRE2();
+ * const re = new RE2("a(b*)", "u");
+ * re.exec("abbc");
+ */
+export function getRE2() {
+    if (!resolvedRE2Class) {
+        throw new Error("RE2 not ready. Call await init() before using getRE2().");
+    }
+    return resolvedRE2Class;
+}

package/dist/loader.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Async loader for RE2 WASM. Uses vendored re2-wasm build (wasm + Emscripten glue).
+ * Same code path for Node and browser; no dependency on re2-wasm at runtime.
+ * (C) Port for ESM/browser — original re2-wasm by Google (Apache-2.0).
+ */
+declare global {
+    interface Window {
+        Module?: Record<string, unknown>;
+    }
+    var Module: Record<string, unknown> | undefined;
+}
+/** Set by init(): the RE2 class (vendored from re2-wasm). */
+export declare let resolvedRE2Class: unknown;
+export interface Re2WasmModule {
+    WrappedRE2: new (pattern: string, ignoreCase: boolean, multiline: boolean, dotAll: boolean) => {
+        ok(): boolean;
+        error(): string;
+        pattern(): string;
+        match(input: string, start: number, getCapturingGroups: boolean): {
+            match: string;
+            index: number;
+            groups: (string | undefined)[];
+        };
+        capturingGroupNames(): {
+            keys(): {
+                get(i: number): number;
+                size(): number;
+            };
+            get(key: number): string;
+        };
+    };
+}
+/**
+ * Initialize the RE2 WASM runtime. Must be called before using RE2.
+ *
+ * @param options - Optional: wasmUrl, glueUrl (browser), or baseUrl
+ */
+export declare function init(options?: {
+    wasmUrl?: string;
+    glueUrl?: string;
+    baseUrl?: string;
+}): Promise<void>;
+export declare function getModule(): Re2WasmModule;
+export declare function whenReady(): Promise<Re2WasmModule>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAClC;IAED,IAAI,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CACjD;AAYD,6DAA6D;AAC7D,eAAO,IAAI,gBAAgB,EAAE,OAAc,CAAC;AAE5C,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,KACV,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,OAAO,EACnB,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,OAAO,KACZ;QACH,EAAE,IAAI,OAAO,CAAC;QACd,KAAK,IAAI,MAAM,CAAC;QAChB,OAAO,IAAI,MAAM,CAAC;QAClB,KAAK,CACH,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,kBAAkB,EAAE,OAAO,GAC1B;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAA;SAAE,CAAC;QACpE,mBAAmB,IAAI;YAAE,IAAI,IAAI;gBAAE,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;gBAAC,IAAI,IAAI,MAAM,CAAA;aAAE,CAAC;YAAC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC;KACzG,CAAC;CACH;AAoGD;;;;GAIG;AACH,wBAAsB,IAAI,CAAC,OAAO,CAAC,EAAE;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoChB;AAED,wBAAgB,SAAS,IAAI,aAAa,CAOzC;AAED,wBAAgB,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC,CAMlD"}

package/dist/loader.js

@@ -0,0 +1,146 @@
+/**
+ * Async loader for RE2 WASM. Uses vendored re2-wasm build (wasm + Emscripten glue).
+ * Same code path for Node and browser; no dependency on re2-wasm at runtime.
+ * (C) Port for ESM/browser — original re2-wasm by Google (Apache-2.0).
+ */
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+const isNode = typeof process !== "undefined" &&
+    typeof process.versions !== "undefined" &&
+    typeof process.versions.node === "string";
+let ready = null;
+let resolvedModule = null;
+/** Set by init(): the RE2 class (vendored from re2-wasm). */
+export let resolvedRE2Class = null;
+/**
+ * Resolve base URL for WASM and glue script (browser).
+ */
+function getBaseUrl() {
+    if (typeof import.meta !== "undefined" && import.meta.url) {
+        const u = import.meta.url;
+        return u.slice(0, u.lastIndexOf("/") + 1);
+    }
+    return "";
+}
+/**
+ * Load and run the RE2 WASM runtime (vendored wasm + glue from re2-wasm).
+ * In Node we preload wasm into Module.wasmBinary so the Emscripten glue uses sync
+ * instantiation and onRuntimeInitialized runs. In browser we use async instantiateWasm.
+ */
+function createLoader(getWasmBuffer, getGlueScript, nodeGlueContext) {
+    return new Promise((resolve, rej) => {
+        function onReady() {
+            resolvedModule = globalThis.Module ?? Module;
+            // Defer so Emscripten glue stack unwinds (Node). Use queueMicrotask so
+            // the loader's dynamic import runs after the current sync glue stack.
+            const doResolve = () => {
+                const re2Url = typeof import.meta.url !== "undefined"
+                    ? new URL("./re2-wasm/re2.js", import.meta.url).href
+                    : "./re2-wasm/re2.js";
+                import(/* @vite-ignore */ re2Url)
+                    .then((m) => {
+                    resolvedRE2Class = m.RE2;
+                    resolve(resolvedModule);
+                })
+                    .catch(rej);
+            };
+            queueMicrotask(doResolve);
+        }
+        const Module = {
+            locateFile(path) {
+                if (nodeGlueContext && path === "re2.wasm")
+                    return nodeGlueContext.wasmPath;
+                return path;
+            },
+            onRuntimeInitialized: onReady,
+            print: (typeof console !== "undefined" && console.log) ? (x) => console.log(x) : undefined,
+            printErr: (typeof console !== "undefined" && console.warn) ? (x) => console.warn(x) : undefined,
+        };
+        if (!nodeGlueContext) {
+            Module.instantiateWasm = function (imports, successCallback) {
+                getWasmBuffer()
+                    .then((buffer) => WebAssembly.instantiate(buffer, imports))
+                    .then(({ instance }) => successCallback(instance))
+                    .catch(rej);
+            };
+        }
+        globalThis.Module = Module;
+        const runGlue = async (scriptText) => {
+            try {
+                if (isNode && nodeGlueContext) {
+                    const { createRequire } = await import("module");
+                    const req = createRequire(import.meta.url);
+                    globalThis.require = req;
+                    const fn = new Function("__dirname", "__filename", scriptText);
+                    fn(nodeGlueContext.__dirname, nodeGlueContext.__filename);
+                    // Emscripten glue can overwrite Module['onRuntimeInitialized'] before doRun();
+                    // invoke our callback now that the runtime is ready.
+                    onReady();
+                }
+                else {
+                    const fn = new Function(scriptText);
+                    fn();
+                }
+            }
+            catch (e) {
+                rej(e);
+            }
+        };
+        if (isNode && nodeGlueContext) {
+            getWasmBuffer()
+                .then((buffer) => {
+                Module.wasmBinary = buffer;
+                return getGlueScript();
+            })
+                .then(runGlue)
+                .catch(rej);
+        }
+        else {
+            getGlueScript().then(runGlue).catch(rej);
+        }
+    });
+}
+/**
+ * Initialize the RE2 WASM runtime. Must be called before using RE2.
+ *
+ * @param options - Optional: wasmUrl, glueUrl (browser), or baseUrl
+ */
+export async function init(options) {
+    if (resolvedModule)
+        return;
+    if (isNode) {
+        const { readFile } = await import("fs/promises");
+        const { fileURLToPath } = await import("url");
+        const path = await import("path");
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const wasmPath = path.join(__dirname, "re2.wasm");
+        const gluePath = path.join(__dirname, "re2-glue.js");
+        ready = createLoader(() => readFile(wasmPath).then((b) => b.buffer), () => readFile(gluePath, "utf8"), { __dirname, __filename: gluePath, wasmPath });
+        await ready;
+        return;
+    }
+    if (isBrowser) {
+        if (!ready) {
+            const base = options?.baseUrl ?? getBaseUrl();
+            const wasmUrl = options?.wasmUrl ?? base + "re2.wasm";
+            const glueUrl = options?.glueUrl ?? base + "re2-glue.js";
+            ready = createLoader(() => fetch(wasmUrl).then((r) => r.arrayBuffer()), () => fetch(glueUrl).then((r) => r.text()));
+        }
+        await ready;
+        return;
+    }
+    throw new Error("Unsupported environment: not Node and not browser");
+}
+export function getModule() {
+    if (resolvedModule && typeof resolvedModule.WrappedRE2 === "function") {
+        return resolvedModule;
+    }
+    throw new Error("RE2 WASM not ready. Call await init() before using RE2 (required in browser).");
+}
+export function whenReady() {
+    if (resolvedModule)
+        return Promise.resolve(resolvedModule);
+    if (ready)
+        return ready;
+    return Promise.reject(new Error("Call init() first before using whenReady()"));
+}