surrge 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 blakbelt78
+
+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,403 @@
+# Surrge
+
+One-line observability for Node.js and Bun. Captures logs, HTTP requests, errors, and server metrics with zero configuration. Dashboard at `/surrge`.
+
+```bash
+# Bun
+bun --preload surrge/src/loader.ts app.ts
+
+# Node.js
+node --import surrge/loader.js app.js
+```
+
+## Features
+
+- **Logs**: Console output + structured loggers (pino, winston JSON)
+- **Requests**: Incoming HTTP + outgoing fetch calls
+- **Errors**: Uncaught exceptions with stack traces
+- **Metrics**: Memory, CPU, event loop lag, uptime
+- **Dashboard**: Real-time view at `/surrge`
+- **Storage**: SQLite via libSQL with 7-day retention
+
+## Architecture
+
+### Data Flow
+
+```mermaid
+flowchart TB
+    subgraph App["User Application"]
+        Console["console.log/warn/error"]
+        Fetch["fetch()"]
+        Logger["pino/winston"]
+        Server["HTTP Server"]
+    end
+
+    subgraph Hooks["hooks.ts (--preload)"]
+        StdoutPatch["process.stdout.write patch"]
+        FsPatch["fs.writeSync patch"]
+    end
+
+    subgraph Instrumentation["instrumentation/"]
+        ConsolePatch["console.ts"]
+        FetchPatch["fetch.ts"]
+        ErrorPatch["errors.ts"]
+    end
+
+    subgraph Patch["patch/"]
+        NodePatch["node.ts: http.createServer"]
+        BunPatch["bun.ts: Bun.serve"]
+    end
+
+    subgraph Core["Core"]
+        Collector["collector.ts (queue)"]
+        DB["storage/db.ts (libSQL)"]
+        Metrics["metrics.ts (polling)"]
+    end
+
+    subgraph Dashboard["dashboard/"]
+        Routes["index.ts (Hono)"]
+        HTML["html.ts"]
+    end
+
+    Console --> ConsolePatch --> Collector
+    Fetch --> FetchPatch --> Collector
+    Logger --> StdoutPatch --> Collector
+    Logger --> FsPatch --> Collector
+    Server --> NodePatch --> Collector
+    Server --> BunPatch --> Collector
+
+    App --> ErrorPatch --> Collector
+
+    Collector -->|batch insert| DB
+    Metrics -->|10s poll| DB
+
+    DB --> Routes
+    Routes --> HTML
+    HTML -->|/surrge| Server
+```
+
+### File Structure
+
+```mermaid
+flowchart LR
+    subgraph Entry["Entry Points"]
+        loader["loader.ts"]
+        hooks["hooks.ts"]
+        register["register.ts"]
+    end
+
+    subgraph Storage["storage/"]
+        db["db.ts"]
+        schema["schema.ts"]
+    end
+
+    subgraph Instr["instrumentation/"]
+        console["console.ts"]
+        fetch["fetch.ts"]
+        errors["errors.ts"]
+        stdout["stdout.ts"]
+    end
+
+    subgraph ServerPatch["patch/"]
+        node["node.ts"]
+        bun["bun.ts"]
+        utils["utils.ts"]
+    end
+
+    subgraph Dash["dashboard/"]
+        dashIndex["index.ts"]
+        html["html.ts"]
+    end
+
+    loader --> hooks
+    loader --> register
+    register --> Instr
+    register --> ServerPatch
+    register --> Storage
+    register --> collector["collector.ts"]
+    register --> metrics["metrics.ts"]
+
+    ServerPatch --> Dash
+    Dash --> Storage
+```
+
+### Request Lifecycle
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant Patch as Server Patch
+    participant App as User App
+    participant Collector
+    participant DB as SQLite
+
+    Client->>Patch: HTTP Request
+    Patch->>Patch: Check if /surrge
+
+    alt /surrge route
+        Patch->>DB: Query data
+        DB-->>Patch: Results
+        Patch-->>Client: Dashboard HTML
+    else App route
+        Patch->>Patch: Record start time
+        Patch->>App: Forward request
+        App-->>Patch: Response
+        Patch->>Collector: Track request
+        Collector->>Collector: Queue event
+        Patch-->>Client: Response
+    end
+
+    Note over Collector,DB: Every 1s or 100 items
+    Collector->>DB: Batch INSERT
+```
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `loader.ts` | Entry point for `--preload`. Imports hooks then register. |
+| `hooks.ts` | Patches stdout BEFORE any modules load. Captures pino/winston JSON. |
+| `register.ts` | Initializes DB, collector, instrumentation, metrics, server patches. |
+| `collector.ts` | Queue-based event collection. Batches INSERTs for performance. |
+| `storage/db.ts` | libSQL wrapper. All DB operations. |
+| `storage/schema.ts` | Table definitions. 5 tables + indexes. |
+| `patch/node.ts` | Patches `http.createServer` to intercept requests and serve dashboard. |
+| `patch/bun.ts` | Patches `Bun.serve` for same purpose. |
+| `dashboard/index.ts` | Hono routes for `/surrge`, `/surrge/api/*`. |
+| `dashboard/html.ts` | Single HTML string with inline CSS/JS. |
+
+## Database Schema
+
+```mermaid
+erDiagram
+    logs {
+        integer id PK
+        integer timestamp
+        text level
+        text message
+        text metadata
+    }
+
+    requests {
+        integer id PK
+        integer timestamp
+        text method
+        text url
+        integer status
+        integer duration_ms
+        text direction
+    }
+
+    errors {
+        integer id PK
+        integer timestamp
+        text message
+        text stack
+        text fingerprint
+    }
+
+    page_views {
+        integer id PK
+        integer timestamp
+        text path
+        text referrer
+        text visitor_id
+        text country
+        text device
+        text browser
+    }
+
+    server_metrics {
+        integer id PK
+        integer timestamp
+        integer memory_rss
+        integer memory_heap
+        real cpu_user
+        real cpu_system
+        real event_loop_lag
+        real load_avg
+    }
+```
+
+## Design Decisions
+
+### Why Loader Hooks?
+
+Pino and other structured loggers write directly to stdout via `fs.writeSync`, bypassing `console.log`. To capture these:
+
+1. `hooks.ts` loads via `--preload` BEFORE any user code
+2. Patches `fs.writeSync`, `process.stdout.write`, `Bun.write`
+3. Parses JSON lines and queues them
+4. `loader.ts` drains the queue after surrge initializes
+
+### Why libSQL?
+
+- Single API works in Node.js, Bun, Deno
+- SQLite-compatible (can use standard tools)
+- Supports local file, remote sync, embedded replicas
+- Open-source, self-hostable
+
+### Why Queue + Batch?
+
+Never block the request path:
+
+```typescript
+// Fast: just push to array
+queue.push(event);
+
+// Async: flush every 1s or 100 items
+setInterval(() => {
+  const batch = queue.splice(0, 100);
+  db.insertBatch(batch);
+}, 1000);
+```
+
+### Why Inline HTML?
+
+- Zero build step required
+- No static file serving complexity
+- Single import, everything works
+- Dashboard is ~10KB total
+
+## Known Limitations
+
+### Pino Worker Thread Transports
+
+When pino uses `transport: { targets: [...] }`, it spawns worker threads. These have their own `fs` module that isn't patched.
+
+```typescript
+// ❌ Logs NOT captured (worker thread)
+pino({ transport: { target: 'pino/file' } });
+
+// ✅ Logs captured (direct stdout)
+pino({ level: 'info' });  // no transport option
+```
+
+**Workaround:** Unset `OTLP_ENDPOINT` or any config that enables transports.
+
+### Framework Detection
+
+Surrge patches at runtime level, so it works with any framework. But it can't access framework-specific context (e.g., Express `req.user`). For richer data, add optional middleware.
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run tests
+bun test
+
+# Type check
+bun run typecheck
+
+# Test with an app
+bun --preload ./src/loader.ts /path/to/app.ts
+```
+
+### Build Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `bun run build` | Full build (dashboard + bundle + types) |
+| `bun run build:dashboard` | Compiles React UI → embeds into `html.ts` |
+| `bun run build:bundle` | Bundles TypeScript → JavaScript in `dist/` |
+| `bun run build:types` | Generates `.d.ts` declaration files |
+
+### Testing Locally
+
+```bash
+# 1. Build the package
+bun run build
+
+# 2. Create tarball
+npm pack
+# Creates surrge-0.1.0.tgz
+
+# 3. Install in another project (Bun)
+cd /path/to/test-project
+bun add /path/to/surrge/surrge-0.1.0.tgz
+
+# 3. Install in another project (Node/npm)
+cd /path/to/test-project
+npm install /path/to/surrge/surrge-0.1.0.tgz
+
+# 4. Use it (Bun)
+echo 'import "surrge/register"' > test.ts
+bun run test.ts
+
+# 4. Use it (Node)
+echo 'import "surrge/register"' > test.mjs
+node test.mjs
+```
+
+Alternative: use link for symlink-based development:
+
+```bash
+# Bun
+bun link              # in surrge directory
+bun link surrge       # in test project
+
+# npm
+npm link              # in surrge directory
+npm link surrge       # in test project
+```
+
+### Publishing
+
+```bash
+# First time: login to npm
+npm login
+
+# Bump version (auto-commits and tags)
+npm version patch   # 0.1.0 → 0.1.1
+npm version minor   # 0.1.0 → 0.2.0
+npm version major   # 0.1.0 → 1.0.0
+
+# Publish (runs typecheck, tests, build automatically)
+npm publish
+
+# Push version tag to git
+git push --follow-tags
+```
+
+### Pre-publish Checklist
+
+- [ ] `bun run typecheck` passes
+- [ ] `bun test` passes
+- [ ] `bun run build` succeeds
+- [ ] `npm pack --dry-run` shows expected files
+- [ ] Tested in a real project via tarball
+
+## Usage with rdltr
+
+```bash
+# From rdltr directory
+OTLP_ENDPOINT= NODE_ENV=production bun --preload ../surrge/src/loader.ts index.tsx
+
+# Open http://localhost:3000/surrge
+```
+
+## API Endpoints
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /surrge` | Dashboard HTML |
+| `GET /surrge/api/logs` | Recent logs (JSON) |
+| `GET /surrge/api/requests` | Recent requests (JSON) |
+| `GET /surrge/api/errors` | Recent errors (JSON) |
+| `GET /surrge/api/analytics` | Page view analytics (JSON) |
+| `GET /surrge/api/metrics` | Server metrics (JSON) |
+
+## Roadmap
+
+- [ ] Web analytics (User-Agent parsing, geo lookup)
+- [ ] Dashboard search/filtering
+- [ ] Charts for metrics over time
+- [x] npm package distribution
+- [ ] Multi-instance sync (Pro)
+- [ ] Alerts (Pro)
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+var args = process.argv.slice(2);
+if (args.length === 0) {
+  console.log("Usage: surrge [options] <script> [args...]");
+  console.log("       surrge node [options] <script> [args...]");
+  console.log("       surrge bun [options] <script> [args...]");
+  console.log("");
+  console.log("Options are passed through to the runtime (e.g., --hot, --watch)");
+  process.exit(1);
+}
+var loaderPath = resolve(dirname(fileURLToPath(import.meta.url)), "loader.js");
+var hasBun = () => {
+  const result = spawnSync("bun", ["--version"], { stdio: "ignore" });
+  return result.status === 0;
+};
+var runtime;
+var remaining;
+if (args[0] === "node" || args[0] === "bun") {
+  runtime = args[0];
+  remaining = args.slice(1);
+} else {
+  runtime = hasBun() ? "bun" : "node";
+  remaining = args;
+}
+var runtimeFlags = [];
+var scriptIndex = 0;
+for (let i = 0;i < remaining.length; i++) {
+  if (remaining[i].startsWith("-")) {
+    runtimeFlags.push(remaining[i]);
+  } else {
+    scriptIndex = i;
+    break;
+  }
+}
+var scriptArgs = remaining.slice(scriptIndex);
+if (scriptArgs.length === 0) {
+  console.log("Error: No script specified");
+  process.exit(1);
+}
+var flag = runtime === "bun" ? "--preload" : "--import";
+var child = spawn(runtime, [flag, loaderPath, ...runtimeFlags, ...scriptArgs], {
+  stdio: "inherit",
+  cwd: process.cwd(),
+  env: process.env
+});
+child.on("close", (code) => {
+  process.exit(code ?? 0);
+});

package/dist/collector.d.ts

@@ -0,0 +1,8 @@
+export declare const start: () => void;
+export declare const stop: () => void;
+export declare const log: (level: string, message: string, metadata?: Record<string, unknown>) => void;
+export declare const request: (method: string, url: string, status: number | null, duration: number | null, direction: "in" | "out") => void;
+export declare const error: (message: string, stack: string | null) => void;
+export declare const pageview: (path: string, referrer: string | null, visitor_id: string | null, country: string | null, device: string | null, browser: string | null) => void;
+export declare const metric: (memory_rss: number, memory_heap: number, cpu_user: number, cpu_system: number, event_loop_lag: number, load_avg: number) => void;
+//# sourceMappingURL=collector.d.ts.map

package/dist/collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../src/collector.ts"],"names":[],"mappings":"AA0HA,eAAO,MAAM,KAAK,QAAO,IAOxB,CAAC;AAEF,eAAO,MAAM,IAAI,QAAO,IAQvB,CAAC;AAGF,eAAO,MAAM,GAAG,GACd,OAAO,MAAM,EACb,SAAS,MAAM,EACf,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACjC,IAQF,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,QAAQ,MAAM,EACd,KAAK,MAAM,EACX,QAAQ,MAAM,GAAG,IAAI,EACrB,UAAU,MAAM,GAAG,IAAI,EACvB,WAAW,IAAI,GAAG,KAAK,KACtB,IAUF,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,SAAS,MAAM,EAAE,OAAO,MAAM,GAAG,IAAI,KAAG,IAW7D,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,MAAM,MAAM,EACZ,UAAU,MAAM,GAAG,IAAI,EACvB,YAAY,MAAM,GAAG,IAAI,EACzB,SAAS,MAAM,GAAG,IAAI,EACtB,QAAQ,MAAM,GAAG,IAAI,EACrB,SAAS,MAAM,GAAG,IAAI,KACrB,IAWF,CAAC;AAEF,eAAO,MAAM,MAAM,GACjB,YAAY,MAAM,EAClB,aAAa,MAAM,EACnB,UAAU,MAAM,EAChB,YAAY,MAAM,EAClB,gBAAgB,MAAM,EACtB,UAAU,MAAM,KACf,IAWF,CAAC"}

package/dist/dashboard/html.d.ts

@@ -0,0 +1,2 @@
+export declare const html: () => string;
+//# sourceMappingURL=html.d.ts.map

package/dist/dashboard/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../src/dashboard/html.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,IAAI,QAAO,MAAqkquB,CAAC"}

package/dist/dashboard/index.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+export declare const createDashboard: (basePath: string) => Hono;
+//# sourceMappingURL=index.d.ts.map

package/dist/dashboard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dashboard/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAI5B,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,IA0FlD,CAAC"}

package/dist/hooks.d.ts

@@ -0,0 +1,3 @@
+export declare const resolve: (specifier: string, context: unknown, nextResolve: Function) => Promise<any>;
+export declare const load: (url: string, context: unknown, nextLoad: Function) => Promise<any>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAyJA,eAAO,MAAM,OAAO,GAClB,WAAW,MAAM,EACjB,SAAS,OAAO,EAChB,aAAa,QAAQ,iBAGtB,CAAC;AAEF,eAAO,MAAM,IAAI,GACf,KAAK,MAAM,EACX,SAAS,OAAO,EAChB,UAAU,QAAQ,iBAGnB,CAAC"}

package/dist/hooks.js

@@ -0,0 +1,140 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/hooks.ts
+import fs from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+var STDOUT_FD = 1;
+var buffer = "";
+var originalWriteSync = fs.writeSync;
+var originalWrite = fs.write;
+var logQueue = [];
+globalThis.__surrge_log_queue = logQueue;
+var normalizeLevel = (level) => {
+  if (typeof level === "number") {
+    if (level >= 50)
+      return "error";
+    if (level >= 40)
+      return "warn";
+    if (level >= 30)
+      return "info";
+    return "debug";
+  }
+  if (typeof level === "string") {
+    const lower = level.toLowerCase();
+    if (["error", "err"].includes(lower))
+      return "error";
+    if (["warn", "warning"].includes(lower))
+      return "warn";
+    return lower;
+  }
+  return "info";
+};
+var captureOutput = (chunk) => {
+  const text = typeof chunk === "string" ? chunk : chunk.toString();
+  buffer += text;
+  const lines = buffer.split(`
+`);
+  buffer = lines.pop() ?? "";
+  for (const line of lines) {
+    if (!line.trim() || !line.startsWith("{"))
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      const level = normalizeLevel(parsed.level ?? parsed.severity ?? "info");
+      const message = String(parsed.msg ?? parsed.message ?? line);
+      const { level: _, msg: __, message: ___, ...metadata } = parsed;
+      logQueue.push({
+        level,
+        message,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined
+      });
+    } catch {}
+  }
+};
+var require2 = createRequire2(import.meta.url);
+var cjsFs = require2("node:fs");
+fs.writeSync = (fd, data, ...args) => {
+  if (fd === STDOUT_FD && (typeof data === "string" || Buffer.isBuffer(data))) {
+    captureOutput(data);
+  }
+  return originalWriteSync(fd, data, ...args);
+};
+fs.write = (fd, data, ...args) => {
+  if (fd === STDOUT_FD && (typeof data === "string" || Buffer.isBuffer(data))) {
+    captureOutput(data);
+  }
+  return originalWrite(fd, data, ...args);
+};
+var cjsOriginalWriteSync = cjsFs.writeSync;
+var cjsOriginalWrite = cjsFs.write;
+cjsFs.writeSync = (fd, data, ...args) => {
+  if (fd === STDOUT_FD && (typeof data === "string" || Buffer.isBuffer(data))) {
+    captureOutput(data);
+  }
+  return cjsOriginalWriteSync(fd, data, ...args);
+};
+cjsFs.write = (fd, data, ...args) => {
+  if (fd === STDOUT_FD && (typeof data === "string" || Buffer.isBuffer(data))) {
+    captureOutput(data);
+  }
+  return cjsOriginalWrite(fd, data, ...args);
+};
+var originalStdoutWrite = process.stdout.write.bind(process.stdout);
+process.stdout.write = (chunk, encodingOrCallback, callback) => {
+  if (typeof chunk === "string" || Buffer.isBuffer(chunk)) {
+    captureOutput(chunk);
+  }
+  if (typeof encodingOrCallback === "function") {
+    return originalStdoutWrite(chunk, encodingOrCallback);
+  }
+  return originalStdoutWrite(chunk, encodingOrCallback, callback);
+};
+var Bun = globalThis.Bun;
+var BunStdout = Bun?.stdout;
+if (Bun?.write) {
+  const originalBunWrite = Bun.write;
+  Bun.write = (dest, data, ...args) => {
+    const isStdout = dest === STDOUT_FD || dest === process.stdout || dest === BunStdout;
+    if (isStdout && (typeof data === "string" || Buffer.isBuffer(data))) {
+      captureOutput(data);
+    }
+    return originalBunWrite(dest, data, ...args);
+  };
+}
+var resolve = async (specifier, context, nextResolve) => {
+  return nextResolve(specifier, context);
+};
+var load = async (url, context, nextLoad) => {
+  return nextLoad(url, context);
+};
+export {
+  resolve,
+  load
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as collector from "./collector.js";
+export { createDashboard } from "./dashboard/index.js";
+export * as db from "./storage/db.js";
+import "./register.js";
+//# 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":"AAEA,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAGtC,OAAO,eAAe,CAAC"}