@nativewindow/webview 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Francesco Saverio Cannizzaro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,341 @@
+<p align="center">
+  <img src="docs/public/native-window.webp" alt="native-window" width="200" />
+</p>
+
+# @nativewindow/webview
+
+[![CI](https://github.com/nativewindow/webview/actions/workflows/ci.yml/badge.svg)](https://github.com/nativewindow/webview/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@nativewindow/webview)](https://www.npmjs.com/package/@nativewindow/webview)
+[![npm](https://img.shields.io/npm/v/@nativewindow/ipc?label=native-window-ipc)](https://www.npmjs.com/package/@nativewindow/ipc)
+[![npm](https://img.shields.io/npm/v/@nativewindow/react?label=native-window-ipc-react)](https://www.npmjs.com/package/@nativewindow/react)
+[![npm](https://img.shields.io/npm/v/@nativewindow/tsdb?label=native-window-tsdb)](https://www.npmjs.com/package/@nativewindow/tsdb)
+
+> [!WARNING]
+> This project is in **alpha**. APIs may change without notice and some features may be incomplete or unstable.
+
+Native OS webviews for Bun, Deno & Node.js. Create real desktop windows with embedded web content using [wry](https://github.com/tauri-apps/wry) + [tao](https://github.com/tauri-apps/tao) — providing WebKit on macOS and Linux, and WebView2 on Windows.
+
+## Features
+
+- **Native webviews** — powered by [wry](https://github.com/tauri-apps/wry) + [tao](https://github.com/tauri-apps/tao) (WebKit on macOS/Linux, WebView2 on Windows), no Electron or Chromium bundled
+- **Multi-window** — create and manage multiple independent windows
+- **HTML & URL loading** — load inline HTML strings or navigate to URLs
+- **Bidirectional IPC** — send messages between Bun/Deno/Node and the webview
+- **Typesafe IPC channels** — typed message layer with schema-based validation and compile-time checked event maps
+- **Full window control** — title, size, position, min/max size, decorations, transparency, always-on-top
+- **Window events** — close, resize, move, focus, blur, page load, title change
+- **Rust + napi-rs + wry + tao** — high-performance native addon, no runtime overhead
+- **Runtime detection** — check for WebView2 availability and auto-install on Windows
+
+## Packages
+
+| Package                                                     | Description                                               |
+| ----------------------------------------------------------- | --------------------------------------------------------- |
+| [`@nativewindow/webview`](./packages/webview)         | Rust napi-rs addon providing native window + webview APIs |
+| [`@nativewindow/ipc`](./packages/ipc)         | Pure TypeScript typesafe IPC channel layer                |
+| [`@nativewindow/react`](./packages/react) | React bindings for the typed IPC layer                    |
+| [`@nativewindow/tsdb`](./packages/tsdb)       | TanStack DB collection adapter for native-window IPC      |
+
+## Quick Start
+
+```ts
+import { init, pumpEvents, NativeWindow } from "native-window";
+
+init();
+const pump = setInterval(() => pumpEvents(), 16);
+
+const win = new NativeWindow({
+  title: "My App",
+  width: 800,
+  height: 600,
+});
+
+win.loadHtml(`
+  <h1>Hello from native webview!</h1>
+  <button onclick="window.ipc.postMessage('clicked')">Click me</button>
+`);
+
+win.onMessage((msg) => {
+  console.log("From webview:", msg);
+  win.postMessage(`Echo: ${msg}`);
+});
+
+win.onClose(() => {
+  clearInterval(pump);
+  process.exit(0);
+});
+```
+
+## Typed IPC
+
+Use `native-window-ipc` for compile-time checked messaging between Bun/Deno/Node and the webview. Schemas provide both types and runtime validation.
+
+### Host side (Bun/Deno/Node)
+
+```ts
+import { z } from "zod";
+import { createWindow } from "native-window-ipc";
+
+const ch = createWindow(
+  { title: "Typed IPC" },
+  {
+    schemas: {
+      "user-click": z.object({ x: z.number(), y: z.number() }),
+      "update-title": z.string(),
+      counter: z.number(),
+    },
+  },
+);
+
+ch.on("user-click", (pos) => {
+  // pos: { x: number; y: number }
+  console.log(`Click at ${pos.x}, ${pos.y}`);
+});
+
+ch.on("counter", (n) => {
+  // n: number
+  ch.send("update-title", `Count: ${n}`);
+});
+
+// ch.send("counter", "wrong");      // Type error!
+// ch.send("typo", 123);             // Type error!
+
+ch.window.loadHtml(`<html>...</html>`);
+```
+
+### Webview side (inline HTML)
+
+The `__channel__` object is auto-injected by `createWindow` / `createChannel`:
+
+```html
+<script>
+  __channel__.send("user-click", { x: 10, y: 20 });
+  __channel__.on("update-title", (title) => {
+    document.title = title;
+  });
+</script>
+```
+
+### Webview side (bundled app)
+
+For webview apps bundled with their own build step, import the client directly:
+
+```ts
+import { z } from "zod";
+import { createChannelClient } from "native-window-ipc/client";
+
+const ch = createChannelClient({
+  schemas: {
+    counter: z.number(),
+    "update-title": z.string(),
+  },
+});
+ch.send("counter", 42); // Typed!
+ch.on("update-title", (t) => {
+  // t: string
+  document.title = t;
+});
+```
+
+## Runtime Detection
+
+On Windows 10, the WebView2 runtime may not be installed. Use `checkRuntime()` to detect it and `ensureRuntime()` to auto-install if missing.
+
+```ts
+import { checkRuntime, ensureRuntime } from "native-window";
+
+const info = checkRuntime();
+console.log(info);
+// { available: true, version: "128.0.2739.42", platform: "windows" }
+// { available: false, version: undefined, platform: "windows" }
+// { available: true,  version: undefined,        platform: "macos" }
+// { available: true,  version: undefined,        platform: "linux" }
+
+if (!info.available) {
+  console.log("WebView2 not found, installing...");
+  const result = ensureRuntime(); // downloads ~2MB bootstrapper, runs silently
+  console.log("Installed:", result.version);
+}
+```
+
+On macOS, both functions return `{ available: true }` immediately — WKWebView is a system framework. On Linux, both functions also return `{ available: true }` — WebKitGTK is assumed to be installed. On Windows 11, WebView2 is pre-installed.
+
+## API Reference
+
+### `native-window`
+
+#### `init()`
+
+Initialize the native window system. Must be called once before creating any windows.
+
+#### `pumpEvents()`
+
+Process pending native UI events. Call periodically (~16ms via `setInterval`) to keep windows responsive.
+
+#### `checkRuntime(): RuntimeInfo`
+
+Check if the native webview runtime is available. Returns `{ available: boolean, version?: string, platform: "macos" | "windows" | "linux" | "unsupported" }`.
+
+#### `ensureRuntime(): RuntimeInfo`
+
+Check for the runtime and install it if missing (Windows only). Downloads the WebView2 Evergreen Bootstrapper (~2MB) from Microsoft and runs it silently. Throws on failure.
+
+#### `new NativeWindow(options?)`
+
+Create a native window with an embedded webview.
+
+**WindowOptions:**
+
+| Option                   | Type      | Default | Description                   |
+| ------------------------ | --------- | ------- | ----------------------------- |
+| `title`                  | `string`  | `""`    | Window title                  |
+| `width`                  | `number`  | `800`   | Inner width (logical pixels)  |
+| `height`                 | `number`  | `600`   | Inner height (logical pixels) |
+| `x`                      | `number`  | —       | X position                    |
+| `y`                      | `number`  | —       | Y position                    |
+| `minWidth` / `minHeight` | `number`  | —       | Minimum size                  |
+| `maxWidth` / `maxHeight` | `number`  | —       | Maximum size                  |
+| `resizable`              | `boolean` | `true`  | Allow resizing                |
+| `decorations`            | `boolean` | `true`  | Show title bar and borders    |
+| `transparent`            | `boolean` | `false` | Transparent background        |
+| `alwaysOnTop`            | `boolean` | `false` | Float above other windows     |
+| `visible`                | `boolean` | `true`  | Initially visible             |
+| `devtools`               | `boolean` | `false` | Enable devtools               |
+
+**Content methods:**
+
+| Method                      | Description                                                  |
+| --------------------------- | ------------------------------------------------------------ |
+| `loadUrl(url)`              | Navigate to a URL                                            |
+| `loadHtml(html)`            | Load an HTML string                                          |
+| `unsafe.evaluateJs(script)` | Execute JS in the webview (fire-and-forget)                  |
+| `postMessage(msg)`          | Send a string to the webview via `window.__native_message__` |
+
+**Window control:**
+
+| Method                                       | Description                  |
+| -------------------------------------------- | ---------------------------- |
+| `setTitle(title)`                            | Set the window title         |
+| `setSize(w, h)`                              | Set the window size          |
+| `setMinSize(w, h)` / `setMaxSize(w, h)`      | Set size constraints         |
+| `setPosition(x, y)`                          | Set window position          |
+| `setResizable(bool)`                         | Toggle resizability          |
+| `setDecorations(bool)`                       | Toggle decorations           |
+| `setAlwaysOnTop(bool)`                       | Toggle always-on-top         |
+| `show()` / `hide()`                          | Show or hide the window      |
+| `close()`                                    | Close and destroy the window |
+| `focus()`                                    | Bring the window to focus    |
+| `maximize()` / `minimize()` / `unmaximize()` | Window state                 |
+
+**Events:**
+
+| Method                       | Callback signature                                      |
+| ---------------------------- | ------------------------------------------------------- |
+| `onMessage(cb)`              | `(message: string) => void`                             |
+| `onClose(cb)`                | `() => void`                                            |
+| `onResize(cb)`               | `(width: number, height: number) => void`               |
+| `onMove(cb)`                 | `(x: number, y: number) => void`                        |
+| `onFocus(cb)` / `onBlur(cb)` | `() => void`                                            |
+| `onPageLoad(cb)`             | `(event: "started" \| "finished", url: string) => void` |
+| `onTitleChanged(cb)`         | `(title: string) => void`                               |
+
+### `native-window-ipc`
+
+#### `createChannel<S>(win, options): NativeWindowChannel<InferSchemaMap<S>>`
+
+Wrap an existing `NativeWindow` with a typed message channel. Schemas are required. Auto-injects the webview client script (disable with `{ injectClient: false }`).
+
+#### `createWindow<S>(windowOptions, channelOptions): NativeWindowChannel<InferSchemaMap<S>>`
+
+Convenience: creates a `NativeWindow` and wraps it with `createChannel`.
+
+#### `getClientScript(): string`
+
+Returns the webview-side client as a self-contained JS string for manual injection.
+
+#### `createChannelClient<S>(options): TypedChannel<InferSchemaMap<S>>` (from `native-window-ipc/client`)
+
+Create a typed channel client inside the webview. Schemas are required. For use in bundled webview apps.
+
+#### `TypedChannel<T>`
+
+```ts
+interface TypedChannel<T extends EventMap> {
+  send<K extends keyof T & string>(type: K, payload: T[K]): void;
+  on<K extends keyof T & string>(type: K, handler: (payload: T[K]) => void): void;
+  off<K extends keyof T & string>(type: K, handler: (payload: T[K]) => void): void;
+}
+```
+
+## Security
+
+All security hardening is compiled in by default on all supported platforms — no build-time feature flags required.
+
+- **URL scheme blocking** — `javascript:`, `file:`, `data:`, and `blob:` navigations are blocked at the native layer
+- **Content Security Policy** — inject a CSP via the `csp` option in `WindowOptions`
+- **Trusted origin filtering** — restrict IPC messages and client injection to specific origins at the native and IPC layers
+- **Webview surface hardening** — context menus, status bar, and built-in error page are disabled on Windows
+- **IPC bridge hardening** — `window.ipc` and `window.__channel__` are frozen, non-writable objects
+- **Message size limits** — 10 MB hard limit at the native layer, configurable 1 MB default at the IPC layer
+- **Schema-based validation** — all incoming IPC payloads are validated at runtime against user-defined schemas
+
+See the [Security documentation](https://native-window.dev/docs/security) for the full threat model and best practices.
+
+## Building
+
+### Prerequisites
+
+- [Bun](https://bun.sh) (v1.3+), [Deno](https://deno.com) (v2+), or [Node.js](https://nodejs.org) (v18+)
+- [Rust](https://rustup.rs) (stable)
+- macOS, Windows, or Linux (for native compilation)
+- On Linux: WebKitGTK development headers (e.g. `libwebkit2gtk-4.1-dev` on Ubuntu/Debian)
+
+### Install dependencies
+
+```bash
+bun install
+# or
+deno install
+```
+
+### Build the native addon
+
+```bash
+cd packages/webview
+bun run build          # release build
+bun run build:debug    # debug build
+```
+
+The build targets the current platform. Cross-compilation targets are configured in `packages/webview/package.json` under `napi.triples`.
+
+## Samples
+
+```bash
+# Raw IPC example
+bun samples/basic.ts
+
+# Typed IPC example
+bun samples/typed-ipc.ts
+```
+
+## Testing
+
+```bash
+# Run the IPC channel tests
+cd packages/ipc
+bun test
+```
+
+## Known Limitations
+
+- **~16ms event latency** from the `pumpEvents()` polling interval
+- **HTML null origin** — content loaded via `loadHtml()` has a null CORS origin; use a custom protocol or `loadUrl()` for fetch/XHR
+- **Windows 10** may require the [WebView2 Runtime](https://developer.microsoft.com/en-us/microsoft-edge/webview2/) — use `ensureRuntime()` to auto-install (included by default on Windows 11)
+- **Linux** requires [WebKitGTK](https://webkitgtk.org/) to be installed (e.g. `libwebkit2gtk-4.1-dev` on Ubuntu/Debian)
+- **No return values from `unsafe.evaluateJs()`** — use `postMessage`/`onMessage` to send results back
+- **2 MB HTML limit on Windows** when using `loadHtml()`
+- **Use `bun --watch`** instead of `bun --hot` for development (native addon reloading requires a process restart)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,268 @@
+import { checkRuntime, ensureRuntime, loadHtmlOrigin } from '../native-window.js';
+export { checkRuntime, ensureRuntime, loadHtmlOrigin };
+export type { WindowOptions, RuntimeInfo } from '../native-window.js';
+/**
+ * Operations that execute arbitrary code in the webview context.
+ * Grouped under {@link NativeWindow.unsafe} to signal injection risk.
+ *
+ * @security Never pass unsanitized user input to these methods.
+ * Use {@link sanitizeForJs} to escape strings before embedding them in
+ * script code.
+ */
+export interface UnsafeNamespace {
+    /**
+     * Evaluate arbitrary JavaScript in the webview context.
+     * Fire-and-forget — there is no return value.
+     * Use `postMessage`/`onMessage` to send results back.
+     *
+     * @security **Injection risk.** Never pass unsanitized user input directly.
+     * Use {@link sanitizeForJs} to escape strings before embedding them in
+     * script code.
+     */
+    evaluateJs(script: string): void;
+}
+/**
+ * Control the browser devtools panel for this window's webview.
+ * Grouped under {@link NativeWindow.devtools} for discoverability.
+ *
+ * Requires `devtools: true` in {@link WindowOptions} at window creation.
+ *
+ * @example
+ * ```ts
+ * const win = new NativeWindow({ devtools: true });
+ * win.devtools.open();
+ * console.log(win.devtools.isOpen()); // true
+ * win.devtools.close();
+ * ```
+ */
+export interface DevtoolsNamespace {
+    /** Open the browser devtools panel. */
+    open(): void;
+    /** Close the browser devtools panel. */
+    close(): void;
+    /** Check whether the devtools panel is currently open. */
+    isOpen(): boolean;
+}
+/**
+ * Information about a cookie from the native cookie store.
+ * Includes `HttpOnly` cookies that are invisible to `document.cookie`.
+ *
+ * @example
+ * ```ts
+ * win.onCookies((cookies) => {
+ *   for (const c of cookies) {
+ *     console.log(c.name, c.value, c.httpOnly);
+ *   }
+ * });
+ * win.getCookies("https://example.com");
+ * ```
+ */
+export interface CookieInfo {
+    /** Cookie name. */
+    name: string;
+    /** Cookie value. */
+    value: string;
+    /** Domain the cookie belongs to. */
+    domain: string;
+    /** Path the cookie is restricted to. */
+    path: string;
+    /** Whether the cookie is HttpOnly (inaccessible to JS). */
+    httpOnly: boolean;
+    /** Whether the cookie requires HTTPS. */
+    secure: boolean;
+    /** SameSite policy: "none", "lax", or "strict". */
+    sameSite: string;
+    /** Expiry as Unix timestamp (seconds). -1 for session cookies. */
+    expires: number;
+}
+type WindowOptions = import('../native-window.js').WindowOptions;
+/**
+ * A native OS window with an embedded webview.
+ *
+ * Automatically initializes the native subsystem and starts pumping
+ * events on first construction. Stops the pump when all windows close.
+ */
+export declare class NativeWindow {
+    /** @internal */
+    private _native;
+    /** @internal */
+    private _closed;
+    /** @internal */
+    private _unsafe?;
+    /** @internal */
+    private _devtools?;
+    constructor(options?: WindowOptions);
+    /** @internal */
+    private _handleClose;
+    /**
+     * Throws if the window has been closed.
+     * @internal
+     */
+    private _ensureOpen;
+    private _userCloseCallback?;
+    /**
+     * Register a handler for the window close event.
+     * The pump is automatically stopped when all windows are closed.
+     *
+     * Calling this multiple times replaces the previous handler.
+     */
+    onClose(callback: () => void): void;
+    /** Unique window ID */
+    get id(): number;
+    loadUrl(url: string): void;
+    /**
+     * Load raw HTML content into the webview.
+     *
+     * @security **Injection risk.** Never interpolate unsanitized user input
+     * into HTML strings. Use a dedicated sanitization library such as
+     * [DOMPurify](https://github.com/cure53/DOMPurify) or
+     * [sanitize-html](https://github.com/apostrophecms/sanitize-html) to
+     * sanitize untrusted content before embedding it.
+     */
+    loadHtml(html: string): void;
+    postMessage(message: string): void;
+    /**
+     * Namespace for operations that require extra care to avoid injection risks.
+     * Methods under `unsafe` execute arbitrary code in the webview context.
+     *
+     * @security Never pass unsanitized user input to these methods.
+     * Use {@link sanitizeForJs} to escape strings before embedding them in
+     * script code.
+     */
+    get unsafe(): UnsafeNamespace;
+    /**
+     * Namespace for controlling the browser devtools panel.
+     * Requires `devtools: true` in {@link WindowOptions} at window creation.
+     *
+     * @example
+     * ```ts
+     * const win = new NativeWindow({ devtools: true });
+     * win.devtools.open();
+     * console.log(win.devtools.isOpen()); // true
+     * win.devtools.close();
+     * ```
+     */
+    get devtools(): DevtoolsNamespace;
+    setTitle(title: string): void;
+    setSize(width: number, height: number): void;
+    setMinSize(width: number, height: number): void;
+    setMaxSize(width: number, height: number): void;
+    setPosition(x: number, y: number): void;
+    setResizable(resizable: boolean): void;
+    setDecorations(decorations: boolean): void;
+    setAlwaysOnTop(alwaysOnTop: boolean): void;
+    /**
+     * Set the window icon from a PNG or ICO file path.
+     * On macOS this is silently ignored (macOS doesn't support per-window icons).
+     * Relative paths resolve from the working directory.
+     */
+    setIcon(path: string): void;
+    show(): void;
+    hide(): void;
+    close(): void;
+    focus(): void;
+    maximize(): void;
+    minimize(): void;
+    unmaximize(): void;
+    reload(): void;
+    /**
+     * Register a handler for messages from the webview.
+     *
+     * @security **No origin filtering.** The raw `onMessage` API does not
+     * enforce origin restrictions. If your webview navigates to untrusted
+     * URLs, validate the `sourceUrl` parameter before processing messages.
+     * For automatic origin filtering, use `createChannel()` with the
+     * `trustedOrigins` option from `native-window-ipc`.
+     *
+     * @security **No rate limiting.** Messages from the webview are delivered
+     * without throttling. A malicious page can flood the host with messages.
+     * Consider implementing application-level rate limiting if loading
+     * untrusted content.
+     */
+    onMessage(callback: (message: string, sourceUrl: string) => void): void;
+    onResize(callback: (width: number, height: number) => void): void;
+    onMove(callback: (x: number, y: number) => void): void;
+    onFocus(callback: () => void): void;
+    onBlur(callback: () => void): void;
+    onPageLoad(callback: (event: "started" | "finished", url: string) => void): void;
+    onTitleChanged(callback: (title: string) => void): void;
+    onReload(callback: () => void): void;
+    /**
+     * Register a handler for blocked navigation events.
+     * Fired when a navigation is blocked by the {@link WindowOptions.allowedHosts}
+     * restriction. Receives the URL that was blocked.
+     *
+     * @example
+     * ```ts
+     * win.onNavigationBlocked((url) => {
+     *   console.log("Blocked navigation to:", url);
+     * });
+     * ```
+     */
+    onNavigationBlocked(callback: (url: string) => void): void;
+    /**
+     * Validate and parse a raw cookies JSON array from the native layer.
+     * Returns a cleaned {@link CookieInfo} array or `null` if the payload
+     * is malformed.
+     *
+     * @internal
+     */
+    private _validateCookies;
+    /**
+     * Query cookies from the native cookie store.
+     *
+     * Returns a Promise that resolves with validated {@link CookieInfo} objects,
+     * including `HttpOnly` cookies that are invisible to `document.cookie`.
+     *
+     * - **macOS**: Uses `WKHTTPCookieStore.getAllCookies` with client-side
+     *   URL filtering (domain + path match).
+     * - **Windows**: Uses `ICoreWebView2CookieManager.GetCookies` which
+     *   filters by URI natively.
+     *
+     * @param url  If provided, only cookies matching this URL are returned.
+     *             If omitted, all cookies in the webview's cookie store are returned.
+     *
+     * @example
+     * ```ts
+     * const cookies = await win.getCookies("https://example.com");
+     * const session = cookies.find((c) => c.name === "session_id");
+     * if (session) console.log("Session:", session.value, "HttpOnly:", session.httpOnly);
+     * ```
+     */
+    getCookies(url?: string): Promise<CookieInfo[]>;
+    /**
+     * Clear cookies from the native cookie store.
+     *
+     * - If `host` is provided, only cookies whose domain matches that host
+     *   are deleted (e.g. `"example.com"` deletes `.example.com` cookies).
+     * - If omitted, all cookies in the webview's cookie store are cleared.
+     *
+     * @example
+     * ```ts
+     * // Clear all cookies
+     * win.clearCookies();
+     *
+     * // Clear cookies for a specific host
+     * win.clearCookies("example.com");
+     * ```
+     */
+    clearCookies(host?: string): void;
+}
+/**
+ * Escape a string for safe embedding inside a JavaScript string literal.
+ * Handles backslashes, double quotes, newlines, carriage returns, null
+ * bytes, closing `</script>` tags, Unicode line/paragraph separators
+ * (U+2028, U+2029), backticks, and `${` template expressions.
+ *
+ * Safe for use in double-quoted, single-quoted, and template literal
+ * contexts.
+ *
+ * @example
+ * ```ts
+ * import { NativeWindow, sanitizeForJs } from "native-window";
+ *
+ * const userInput = 'He said "hello"\n<script>alert(1)</script>';
+ * win.unsafe.evaluateJs(`display("${sanitizeForJs(userInput)}")`);
+ * ```
+ */
+export declare function sanitizeForJs(input: string): string;