@zvndev/powdb-client 0.3.0

package/README.md

@@ -0,0 +1,309 @@
+# @zvndev/powdb-client
+
+TypeScript client for [PowDB](https://github.com/zvndev/powdb) — speaks the native binary wire protocol over TCP (or TLS).
+
+## Install
+
+```bash
+npm install @zvndev/powdb-client
+```
+
+## Usage
+
+```typescript
+import { Client, powql, ident } from "@zvndev/powdb-client";
+
+const client = await Client.connect({
+  host: "localhost",
+  port: 5433,
+});
+
+// Create a table
+await client.query("type User { required name: str, required email: str, age: int }");
+
+// Insert data — use `powql` to interpolate values safely
+const name = 'O"Brien';
+const age = 30;
+await client.query(powql`insert User { name := ${name}, email := ${"alice@example.com"}, age := ${age} }`);
+
+// Query
+const result = await client.query(powql`User filter .age > ${25} { .name, .age }`);
+if (result.kind === "rows") {
+  console.table(result.rows);
+}
+
+// Aggregates
+const count = await client.query(powql`count(${ident("User")})`);
+if (count.kind === "scalar") {
+  console.log(`Total users: ${count.value}`);
+}
+
+await client.close();
+```
+
+## Safe query composition
+
+**Never build PowQL with template literals or string concatenation of untrusted values.** PowQL has its own injection class — the same risk as SQL injection.
+
+Use the `powql` tagged template. Values are escaped as literals by default; wrap identifiers (table/column names) in `ident(...)`.
+
+```typescript
+import { powql, ident, escapeLiteral, escapeIdent } from "@zvndev/powdb-client";
+
+// powql — recommended. Interpolations are escaped automatically.
+const q = powql`${ident("User")} filter .city = ${city} and .age > ${age} { .name }`;
+
+// Manual escaping — for when you need raw strings.
+escapeLiteral("O\"Brien");  // → "\"O\\\"Brien\""
+escapeIdent("User");        // → "User" (throws on invalid)
+```
+
+`escapeLiteral` accepts `string | number | bigint | boolean | null`. It rejects `NaN`/`Infinity`, `undefined`, objects, arrays, symbols, and `Date` — convert those yourself before passing them in.
+
+## Connection pooling
+
+For multi-query workloads (web servers, batch jobs), use `Pool`:
+
+```typescript
+import { Pool } from "@zvndev/powdb-client";
+
+const pool = new Pool({
+  host: "localhost",
+  port: 5433,
+  max: 10,
+});
+
+// Acquire, use, release — or let `withClient` handle it.
+const rows = await pool.withClient(async (client) => {
+  const r = await client.query("User { .name }");
+  return r.kind === "rows" ? r.rows : [];
+});
+
+await pool.close();
+```
+
+## TLS
+
+```typescript
+const client = await Client.connect({
+  host: "db.example.com",
+  port: 5433,
+  tls: true,                        // system defaults
+  // or: tls: { ca: fs.readFileSync("ca.pem") }
+});
+```
+
+## Typed rows
+
+The wire protocol serialises every value as a string. If you want JS types
+back (numbers, `Date`, booleans), call `queryTyped` with a schema:
+
+```typescript
+import { Client } from "@zvndev/powdb-client";
+
+const client = await Client.connect({ host: "localhost", port: 5433 });
+
+const rows = await client.queryTyped(
+  "User { .id, .name, .age, .active, .created_at }",
+  {
+    id: "int",        // number — or bigint if > Number.MAX_SAFE_INTEGER
+    age: "int",
+    active: "bool",
+    created_at: "datetime",
+    // columns not in the schema (like `name`) pass through as strings
+  },
+);
+
+rows[0].age;         // typeof number
+rows[0].created_at;  // instanceof Date
+```
+
+Supported column types: `int` | `float` | `bool` | `str` | `datetime` | `uuid`.
+Bytes columns are intentionally unsupported (the wire format is lossy —
+it renders `<N bytes>`) and throw on coercion. Declare `str` if you just
+want the placeholder.
+
+## Structured errors
+
+Every error thrown by the client is a `PowDBError` with a stable `.code`:
+
+```typescript
+import { Client, PowDBError, isPowDBError } from "@zvndev/powdb-client";
+
+try {
+  await client.query("bogus");
+} catch (err) {
+  if (isPowDBError(err)) {
+    switch (err.code) {
+      case "connect_failed":
+      case "timeout":
+        // transient — safe to retry
+        break;
+      case "auth_failed":
+      case "query_failed":
+      case "protocol_error":
+        // not transient — surface to the caller
+        break;
+      case "aborted":
+        // caller asked to stop — never retry
+        break;
+    }
+  }
+}
+```
+
+The full taxonomy: `connect_failed`, `auth_failed`, `query_failed`,
+`aborted`, `size_exceeded`, `protocol_error`, `closed`, `timeout`,
+`type_coercion_failed`.
+
+## Polling watch
+
+For simple change-polling (the server doesn't ship a subscription
+protocol yet), `watch` re-runs a query on an interval and invokes a
+callback with the latest rows:
+
+```typescript
+const handle = client.watch("User filter .active = true { .id, .name }", {
+  intervalMs: 1000,
+  onRows: (rows, columns) => {
+    console.log(`${rows.length} active users`);
+  },
+  onError: (err) => {
+    console.error("watch error:", err);
+  },
+});
+
+// ...later
+handle.stop();
+```
+
+If a query takes longer than `intervalMs` the next tick is skipped rather
+than piling up. The watcher does not keep the event loop alive on its own
+(it uses `timer.unref()`).
+
+## Observability
+
+`Client` is an `EventEmitter`. Wire it into your logger or metrics
+pipeline:
+
+```typescript
+client.on("query", ({ query, durationMs, ok, kind, error }) => {
+  metrics.histogram("powdb_query_ms", durationMs, { ok: String(ok) });
+});
+
+client.on("close", ({ error }) => {
+  if (error) logger.warn({ err: error }, "powdb connection lost");
+});
+```
+
+Events:
+
+| Event | Payload | Fires when |
+|---|---|---|
+| `query` | `{ query, durationMs, ok, kind?, error? }` | After every query completes (success or failure) |
+| `close` | `{ error: Error \| null }` | Exactly once per socket, on normal or error close |
+
+## Cancellation
+
+Pass an `AbortSignal` to cancel a query:
+
+```typescript
+const ctrl = new AbortController();
+setTimeout(() => ctrl.abort(), 1000);
+
+try {
+  await client.query("slow_query(...)", { signal: ctrl.signal });
+} catch (err) {
+  if (err.name === "AbortError") { /* cancelled */ }
+}
+```
+
+The socket stays open — the server's reply is silently discarded so other in-flight queries keep working.
+
+## API
+
+### `Client.connect(options)`
+
+Returns a `Promise<Client>`. Options:
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `host` | `string` | *(required)* | Server hostname or IP |
+| `port` | `number` | *(required)* | Server port |
+| `dbName` | `string` | `"default"` | Database name |
+| `password` | `string \| null` | `null` | Server password (if auth is enabled) |
+| `connectTimeoutMs` | `number` | `5000` | Connection timeout in milliseconds |
+| `tls` | `boolean \| tls.ConnectionOptions` | `false` | Enable TLS; `true` uses system defaults, or pass a `tls.connect` options object |
+
+### `client.query(query, opts?)`
+
+Sends a PowQL query and returns a `Promise<QueryResult>`:
+
+- `{ kind: "rows", columns: string[], rows: string[][] }` — for SELECT-like queries
+- `{ kind: "scalar", value: string }` — for aggregates (`count`, `sum`, `avg`, etc.)
+- `{ kind: "ok", affected: bigint }` — for mutations (`insert`, `update`, `delete`)
+
+`opts.signal?: AbortSignal` — aborts the returned promise (see Cancellation above).
+
+Throws a `PowDBError` (see Structured errors above) on any failure.
+
+### `client.queryTyped(query, schema, opts?)`
+
+Like `query()`, but coerces each row's string values to JS types using the
+supplied schema and returns `Promise<TypedRow[]>`. See Typed rows above.
+
+### `client.watch(query, options)`
+
+Re-runs `query` every `intervalMs` and pushes rows to `onRows`. Returns
+`{ stop(): void }`. See Polling watch above.
+
+### `client.on("query", handler)` / `client.on("close", handler)`
+
+`Client` extends `EventEmitter`. See Observability above.
+
+### `client.close()`
+
+Sends a disconnect message and closes the TCP socket.
+
+### `client.serverVersion`
+
+The PowDB server version string (e.g., `"0.2.0"`). On connect, the client warns once per `host:port` if the server's major version differs from the client's.
+
+### `Pool` (class)
+
+Constructor options extend `ClientOptions` with:
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `max` | `number` | `10` | Maximum concurrent connections |
+| `acquireTimeoutMs` | `number` | `30000` | How long `acquire()` waits before rejecting (pass `0` to disable) |
+| `connectRetries` | `number` | `3` | How many times to retry transient connect failures before giving up (set `0` to disable) |
+| `connectBackoffMs` | `number` | `100` | Initial delay between connect retries; doubles each attempt |
+| `connectMaxBackoffMs` | `number` | `2000` | Cap on the exponential backoff |
+
+Methods: `acquire()`, `release(client)`, `destroy(client)`, `withClient(fn)`, `close()`.
+Getters: `size`, `idle`, `closed`.
+
+### Safety helpers
+
+- `powql` — tagged template; escapes literals, validates identifiers
+- `ident(name)` — wrap a string so `powql` treats it as an identifier
+- `escapeLiteral(value)` — render a JS value as a PowQL literal
+- `escapeIdent(name)` — validate an identifier (throws `TypeError` on invalid)
+
+## Limits
+
+The client enforces the same frame limits as the server and throws on violation:
+
+- `MAX_PAYLOAD_SIZE` — 64 MiB per frame
+- `MAX_ROWS` — 10,000,000 rows per result
+- `MAX_COLUMNS` — 4,096 columns per result
+
+## Requirements
+
+- Node.js 18+ (uses `node:net`, `node:tls`)
+- A running PowDB server (`cargo run --release -p powdb-server`)
+
+## License
+
+MIT

package/dist/errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Structured error taxonomy for the PowDB client.
+ *
+ * Every error thrown by the client is a `PowDBError` with a stable `.code`
+ * so callers can branch without string-matching the message. The taxonomy
+ * is intentionally small — new codes are added only when a caller has a
+ * legitimate reason to handle them differently.
+ */
+export type PowDBErrorCode = 
+/** TCP/TLS connect, DNS, connect timeout. Transient — safe to retry. */
+"connect_failed"
+/** Server rejected the Connect handshake (bad password, unknown db). Not transient. */
+ | "auth_failed"
+/** Server returned an `Error` frame in response to a query. Not transient. */
+ | "query_failed"
+/** Caller's AbortSignal fired. Never retry — the caller asked to stop. */
+ | "aborted"
+/** Peer sent a frame that exceeds one of the configured caps. Likely a bug/attack — do not retry. */
+ | "size_exceeded"
+/** Wire protocol violation (bad framing, unknown message type, truncated payload). */
+ | "protocol_error"
+/** `close()` has been called on the client or pool. */
+ | "closed"
+/** An operation exceeded its configured time budget. */
+ | "timeout"
+/** Type coercion on a row failed (queryTyped). */
+ | "type_coercion_failed";
+/**
+ * All errors thrown by `@zvndev/powdb-client` are instances of this class.
+ * Use `err.code` to branch; `err.cause` optionally carries the underlying
+ * cause (e.g. the Node socket error).
+ */
+export declare class PowDBError extends Error {
+    readonly code: PowDBErrorCode;
+    constructor(message: string, code: PowDBErrorCode, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Narrow `unknown` to a PowDBError. Useful in catch blocks where you want
+ * to branch on `.code` but TypeScript sees `unknown`.
+ */
+export declare function isPowDBError(err: unknown): err is PowDBError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,cAAc;AACxB,wEAAwE;AACtE,gBAAgB;AAClB,uFAAuF;GACrF,aAAa;AACf,8EAA8E;GAC5E,cAAc;AAChB,0EAA0E;GACxE,SAAS;AACX,qGAAqG;GACnG,eAAe;AACjB,sFAAsF;GACpF,gBAAgB;AAClB,uDAAuD;GACrD,QAAQ;AACV,wDAAwD;GACtD,SAAS;AACX,kDAAkD;GAChD,sBAAsB,CAAC;AAE3B;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAQjF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,UAAU,CAE5D"}

package/dist/errors.js

@@ -0,0 +1,32 @@
+/**
+ * Structured error taxonomy for the PowDB client.
+ *
+ * Every error thrown by the client is a `PowDBError` with a stable `.code`
+ * so callers can branch without string-matching the message. The taxonomy
+ * is intentionally small — new codes are added only when a caller has a
+ * legitimate reason to handle them differently.
+ */
+/**
+ * All errors thrown by `@zvndev/powdb-client` are instances of this class.
+ * Use `err.code` to branch; `err.cause` optionally carries the underlying
+ * cause (e.g. the Node socket error).
+ */
+export class PowDBError extends Error {
+    code;
+    constructor(message, code, options) {
+        // ErrorOptions.cause is supported in Node 16.9+; we require Node 18+.
+        super(message, options);
+        this.name = "PowDBError";
+        this.code = code;
+        // Preserve the prototype chain across `target: es2020` and friends.
+        Object.setPrototypeOf(this, PowDBError.prototype);
+    }
+}
+/**
+ * Narrow `unknown` to a PowDBError. Useful in catch blocks where you want
+ * to branch on `.code` but TypeScript sees `unknown`.
+ */
+export function isPowDBError(err) {
+    return err instanceof PowDBError;
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAsBH;;;;GAIG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IAC1B,IAAI,CAAiB;IAE9B,YAAY,OAAe,EAAE,IAAoB,EAAE,OAA6B;QAC9E,sEAAsE;QACtE,KAAK,CAAC,OAAO,EAAE,OAAuB,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,oEAAoE;QACpE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,GAAY;IACvC,OAAO,GAAG,YAAY,UAAU,CAAC;AACnC,CAAC"}

package/dist/escape.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Safe PowQL composition helpers: literal and identifier escaping, plus a
+ * tagged-template convenience for building queries without string splicing.
+ *
+ *     const q = powql`insert ${ident("User")} { name := ${userName}, age := ${age} }`;
+ *     await client.query(q);
+ *
+ * Security model:
+ *   - Literals are rendered with quoting/escaping so interpolated values
+ *     cannot break out of the surrounding literal.
+ *   - Identifiers are validated against `^[A-Za-z_][A-Za-z0-9_]*$` and passed
+ *     through unchanged. Anything else throws a `TypeError`.
+ *
+ * PowQL string-escape rules (verified against `crates/query/src/lexer.rs`):
+ *   - Strings are delimited by `"`.
+ *   - `\\` → `\`, `\"` → `"`, `\n` → newline, `\t` → tab.
+ *   - For any other `\X`, the backslash is dropped and `X` is kept literally.
+ *   - A bare `"` terminates the string, so `"` inside must be `\"` and any
+ *     literal backslash must be `\\` (otherwise it would swallow the next char).
+ */
+/** Wrapper marking a string as an identifier (vs a literal) for `powql` tagged templates. */
+export declare class PowqlIdent {
+    readonly name: string;
+    constructor(name: string);
+}
+/** Factory for {@link PowqlIdent}. Prefer this over `new PowqlIdent(...)` at call sites. */
+export declare function ident(name: string): PowqlIdent;
+/**
+ * Validate a PowQL identifier (table name, field name, alias). Returns the
+ * identifier unchanged on success; throws `TypeError` on any invalid input
+ * (non-string, empty, or containing characters outside `[A-Za-z_][A-Za-z0-9_]*`).
+ */
+export declare function escapeIdent(name: string): string;
+/**
+ * Render a JS value as a PowQL literal. Supports `string`, `number`, `bigint`,
+ * `boolean`, and `null`. Rejects `NaN`/`±Infinity`, `undefined`, symbols,
+ * objects, and arrays with `TypeError`.
+ *
+ * - string → `"..."` with `\` and `"` backslash-escaped (C-style, per the
+ *   PowQL lexer). Backslash must be escaped first to avoid double-processing.
+ * - number → decimal; rejects non-finite
+ * - bigint → decimal digits
+ * - boolean → `true` / `false`
+ * - null   → `null`
+ */
+export declare function escapeLiteral(value: string | number | bigint | boolean | null): string;
+/**
+ * Tagged template for safe PowQL composition. Each interpolated value is
+ * escaped as a literal by default; wrap it in `ident(...)` to interpolate as
+ * an identifier.
+ *
+ *     const q = powql`insert ${ident(table)} { name := ${userName} }`;
+ */
+export declare function powql(strings: TemplateStringsArray, ...values: unknown[]): string;
+//# sourceMappingURL=escape.d.ts.map

package/dist/escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.d.ts","sourceRoot":"","sources":["../src/escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,6FAA6F;AAC7F,qBAAa,UAAU;aACO,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CACzC;AAED,4FAA4F;AAC5F,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAehD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAC/C,MAAM,CA+BR;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,oBAAoB,EAC7B,GAAG,MAAM,EAAE,OAAO,EAAE,GACnB,MAAM,CAOR"}

package/dist/escape.js

@@ -0,0 +1,124 @@
+/**
+ * Safe PowQL composition helpers: literal and identifier escaping, plus a
+ * tagged-template convenience for building queries without string splicing.
+ *
+ *     const q = powql`insert ${ident("User")} { name := ${userName}, age := ${age} }`;
+ *     await client.query(q);
+ *
+ * Security model:
+ *   - Literals are rendered with quoting/escaping so interpolated values
+ *     cannot break out of the surrounding literal.
+ *   - Identifiers are validated against `^[A-Za-z_][A-Za-z0-9_]*$` and passed
+ *     through unchanged. Anything else throws a `TypeError`.
+ *
+ * PowQL string-escape rules (verified against `crates/query/src/lexer.rs`):
+ *   - Strings are delimited by `"`.
+ *   - `\\` → `\`, `\"` → `"`, `\n` → newline, `\t` → tab.
+ *   - For any other `\X`, the backslash is dropped and `X` is kept literally.
+ *   - A bare `"` terminates the string, so `"` inside must be `\"` and any
+ *     literal backslash must be `\\` (otherwise it would swallow the next char).
+ */
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Wrapper marking a string as an identifier (vs a literal) for `powql` tagged templates. */
+export class PowqlIdent {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+/** Factory for {@link PowqlIdent}. Prefer this over `new PowqlIdent(...)` at call sites. */
+export function ident(name) {
+    return new PowqlIdent(name);
+}
+/**
+ * Validate a PowQL identifier (table name, field name, alias). Returns the
+ * identifier unchanged on success; throws `TypeError` on any invalid input
+ * (non-string, empty, or containing characters outside `[A-Za-z_][A-Za-z0-9_]*`).
+ */
+export function escapeIdent(name) {
+    if (typeof name !== "string") {
+        throw new TypeError(`escapeIdent: expected string, got ${typeof name}`);
+    }
+    if (name.length === 0) {
+        throw new TypeError("escapeIdent: identifier must not be empty");
+    }
+    if (!IDENT_RE.test(name)) {
+        throw new TypeError(`escapeIdent: invalid identifier ${JSON.stringify(name)} (must match /^[A-Za-z_][A-Za-z0-9_]*$/)`);
+    }
+    return name;
+}
+/**
+ * Render a JS value as a PowQL literal. Supports `string`, `number`, `bigint`,
+ * `boolean`, and `null`. Rejects `NaN`/`±Infinity`, `undefined`, symbols,
+ * objects, and arrays with `TypeError`.
+ *
+ * - string → `"..."` with `\` and `"` backslash-escaped (C-style, per the
+ *   PowQL lexer). Backslash must be escaped first to avoid double-processing.
+ * - number → decimal; rejects non-finite
+ * - bigint → decimal digits
+ * - boolean → `true` / `false`
+ * - null   → `null`
+ */
+export function escapeLiteral(value) {
+    if (value === null)
+        return "null";
+    const t = typeof value;
+    if (t === "string") {
+        const escaped = value
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"');
+        return `"${escaped}"`;
+    }
+    if (t === "number") {
+        const n = value;
+        if (!Number.isFinite(n)) {
+            throw new TypeError(`escapeLiteral: non-finite number ${String(n)} cannot be represented as a PowQL literal`);
+        }
+        return String(n);
+    }
+    if (t === "bigint") {
+        return value.toString(10);
+    }
+    if (t === "boolean") {
+        return value ? "true" : "false";
+    }
+    throw new TypeError(`escapeLiteral: unsupported type ${describe(value)}`);
+}
+/**
+ * Tagged template for safe PowQL composition. Each interpolated value is
+ * escaped as a literal by default; wrap it in `ident(...)` to interpolate as
+ * an identifier.
+ *
+ *     const q = powql`insert ${ident(table)} { name := ${userName} }`;
+ */
+export function powql(strings, ...values) {
+    let out = strings[0] ?? "";
+    for (let i = 0; i < values.length; i++) {
+        out += renderInterpolation(values[i]);
+        out += strings[i + 1] ?? "";
+    }
+    return out;
+}
+// ──────────────────────────────────────────────────────────
+// internals
+// ──────────────────────────────────────────────────────────
+function renderInterpolation(value) {
+    if (value instanceof PowqlIdent) {
+        return escapeIdent(value.name);
+    }
+    // `escapeLiteral` enforces the allowed set — for anything else it throws.
+    return escapeLiteral(value);
+}
+function describe(value) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    const t = typeof value;
+    if (t === "object")
+        return "object";
+    return t;
+}
+//# sourceMappingURL=escape.js.map

package/dist/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","sourceRoot":"","sources":["../src/escape.ts"],"names":[],"mappings":"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"}