@zap-studio/fetch 0.5.5 → 1.0.0

package/CHANGELOG.md

@@ -1,35 +1,61 @@
-## @zap-studio/fetch@0.5.5
+# Changelog
 
-### Migrate to ultracite lint/format
+All notable changes to this project will be documented in this file.
 
-Internal formatting and lint cleanup only. No public API or behavior change.
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0]
+
+### Changed
+
+- Clarified tree-shakeable design in the package description and README (no code change).
+
+### Removed
+
+Collapsed the internal request pipeline (`_internal.ts`, `_methods.ts`, `constants.ts`, `headers.ts`, `request.ts`, `url.ts`) into implementation-only files. `mergeHeaders`, `normalizeRequest`, and `resolveRequestUrl` are no longer public API — they were pipeline internals, not meant for standalone use.
+
+- Removed the `./constants`, `./headers`, `./request`, `./url`, and `./fetch` subpath exports. Use the root `@zap-studio/fetch` entry instead.
+- `GLOBAL_DEFAULTS`, `FetchError`, `$fetch`, `api`, `createFetch`, and all public types are unaffected and still exported from `.`; `./errors` and `./types` subpaths are unaffected.
+
+## [0.5.6]
+
+### Added
+
+The package root now re-exports the full public API, so everything can be imported from `@zap-studio/fetch` directly (`$fetch`, `api`, `createFetch`, `FetchError`, `mergeHeaders`, `GLOBAL_DEFAULTS`, `normalizeRequest`, `resolveRequestUrl`, and all public types). All exports are side-effect free and tree-shakeable; granular subpath imports keep working.
+
+- The `$fetch`/`api`/`createFetch` implementation moved from the entrypoint into its own module, available as the new `./fetch` subpath.
 
-# @zap-studio/fetch
+### Removed
 
-## 0.5.4
+- Removed the `./internal` and `./methods` subpath exports. Both were implementation details (`fetchInternal`, `createMethod`) and are no longer part of the public API.
+
+## [0.5.5]
+
+### Changed
+
+Internal formatting and lint cleanup only. No public API or behavior change.
+
+## [0.5.4]
 
 ### Changed
 
 - Added fetch ecosystem benchmarks and grouped benchmark output for easier cross-library comparisons.
 - Applied small internal performance optimizations in request preparation, URL resolution, and header merging without changing public API behavior.
 
-## 0.5.3
+## [0.5.3]
 
 ### Changed
 
 - Refactor `createFetch(...)` to derive fallback defaults from `GLOBAL_DEFAULTS` instead of re-defining primitive defaults inline.
 
-## 0.5.2
+## [0.5.2]
 
 ### Changed
 
 - Expand TSDoc coverage across fetch modules and exported contracts for stronger JSR documentation completeness.
-
-### Dependencies
-
 - Updated dependency `@zap-studio/validation` to `0.3.4`.
 
-## 0.5.1
+## [0.5.1]
 
 ### Fixed
 
@@ -38,19 +64,18 @@ Internal formatting and lint cleanup only. No public API or behavior change.
 ### Changed
 
 - 2ea1a70: Cleaned up public option typings by removing redundant `| undefined` unions from fetch configuration types and overloads.
-
-### Dependencies
-
 - Updated dependency `@zap-studio/validation` to `0.3.3`.
 
-## 0.5.0
+## [0.5.0]
 
-### Breaking
+### Added
 
-- Request bodies are no longer auto-serialized from plain objects; use the explicit `json` option (or set `body` yourself). `body` and `json` are mutually exclusive at the type level and enforced at runtime.
+- Documented the throwable error surface for `$fetch`, `createFetch`, and internal request execution with explicit `@throws` tags (for example `FetchError`, `ValidationError`, `TypeError`, `DOMException`, `SyntaxError`, and validator-thrown errors).
+- Added full package test coverage across statements, branches, functions, and lines.
 
 ### Changed
 
+- **Breaking:** Request bodies are no longer auto-serialized from plain objects; use the explicit `json` option (or set `body` yourself). `body` and `json` are mutually exclusive at the type level and enforced at runtime.
 - Simplified the request API around web platform types.
   - The first argument is named `input` and typed as `FetchInput` (`Parameters<typeof fetch>[0]` from `lib.dom`), exported from `@zap-studio/fetch/types`, so allowed inputs track global `fetch` when DOM typings change.
   - Non-`Request` values (including `URL`) are normalized to a string URL before query merge.
@@ -62,46 +87,35 @@ Internal formatting and lint cleanup only. No public API or behavior change.
   - `body` and `json` are mutually exclusive in TypeScript and guarded at runtime.
 - Reworked URL handling to use the platform `URL` and `URLSearchParams` APIs while preserving relative URL output when no `baseURL` is configured.
 - Simplified the internal module structure and removed the old `utils` module.
+- Reworked tests to mirror the `src` module structure.
+- JSR dependency mapping now pins `@zap-studio/validation` to `0.3.2`.
 
 ### Fixed
 
 - Fixed absolute URL handling when no `baseURL` is configured.
 - `resolveSearchParams` keeps a trailing `#` when the input URL had an empty fragment (for example `.../path#`), matching typical `URL` serialization instead of dropping the delimiter.
 
-### Tests
-
-- Reworked tests to mirror the `src` module structure.
-- Added full package coverage across statements, branches, functions, and lines.
-
-### Documentation
-
-- Documented the throwable error surface for `$fetch`, `createFetch`, and internal request execution with explicit `@throws` tags (for example `FetchError`, `ValidationError`, `TypeError`, `DOMException`, `SyntaxError`, and validator-thrown errors).
-
-### Dependencies
+## [0.4.7]
 
-- JSR dependency mapping now pins `@zap-studio/validation` to `0.3.2`.
-
-## 0.4.7
-
-### Patch Changes
+### Changed
 
 - e26293e: Updated dependencies.
   - @zap-studio/validation@0.3.2
 
-## 0.4.6
+## [0.4.6]
 
-### Patch Changes
+### Changed
 
 - 5ea3d3b: Updated dependencies.
   - @zap-studio/validation@0.3.1
 
-## 0.4.5
+## [0.4.5]
 
-### Dependencies
+### Changed
 
 - f75b984: Updated dependency `@zap-studio/validation` to `0.3.0`.
 
-## 0.4.4
+## [0.4.4]
 
 ### Fixed
 
@@ -110,39 +124,33 @@ Internal formatting and lint cleanup only. No public API or behavior change.
   - Auto-stringify plain JSON body values even when no response schema is provided.
   - Set `Content-Type: application/json` only when auto-stringifying and no explicit content type is set.
 
-## 0.4.3
+## [0.4.3]
 
 ### Changed
 
 - e4542bb: Refined `standardValidate` typings so return types depend on `throwOnError`, and updated `@zap-studio/fetch` integration while preserving the existing boolean configuration API.
-
-### Dependencies
-
 - e4542bb: Updated dependency `@zap-studio/validation` to `0.2.1`.
 
-## 0.4.2
+## [0.4.2]
 
-### Dependencies
+### Changed
 
 - 2de8183: Updated dependency `@zap-studio/validation` to `0.2.0`.
 
-## 0.4.1
+## [0.4.1]
 
 ### Changed
 
 - 447dbda: Switched shared Standard Schema validation utilities to `@zap-studio/validation`.
-
-### Dependencies
-
 - 447dbda: Updated dependency `@zap-studio/validation` to `0.1.0`.
 
-## 0.4.0
+## [0.4.0]
 
 ### Added
 
 - 69057cd: Exposed fetch defaults constants and utility helpers as public exports.
 
-## 0.3.1
+## [0.3.1]
 
 ### Changed
 
@@ -151,31 +159,26 @@ Internal formatting and lint cleanup only. No public API or behavior change.
   - `throwOnValidationError: false` returns `Promise<StandardSchemaV1.Result<TSchema>>`.
   - This improves type safety and removes manual narrowing in default usage.
 
-## 0.3.0
+## [0.3.0]
 
 ### Added
 
 - 659621c: Added `searchParams` support in `createFetch` for factory-level default query parameters.
   - Per-request `searchParams` still override factory defaults.
 
-## 0.2.2
+## [0.2.2]
 
 ### Changed
 
 - 5c3abbf: Prepared JSR publish and `isolatedDeclarations` support with explicit `$Fetch` and `ApiMethods` types.
 
-## 0.2.1
+## [0.2.1]
 
 ### Changed
 
 - 82bac5c: Replaced regex-based slash trimming with more efficient string manipulation for URL normalization.
 
-## 0.2.0
-
-### Changed
-
-- 78afb76: Migrated from Zod-only validation to Standard Schema v1 for broader validator compatibility.
-  - Supported libraries include Zod, Valibot, ArkType, and other Standard Schema-compliant validators.
+## [0.2.0]
 
 ### Added
 
@@ -183,25 +186,27 @@ Internal formatting and lint cleanup only. No public API or behavior change.
 - 78afb76: Added smart URL behavior so absolute URLs bypass `baseURL`.
 - 78afb76: Added automatic JSON body serialization and `Content-Type` handling for schema-based requests.
 
-### Breaking
+### Changed
 
-- 78afb76: Standard Schema-compliant validator libraries are now required (for example Zod 3.23+, Valibot 1.0+, ArkType 2.0+).
-- 78afb76: Internal file structure was reorganized (affects deep imports).
-- 78afb76: `FetchError` constructor now requires `(message, response)`.
+- 78afb76: Migrated from Zod-only validation to Standard Schema v1 for broader validator compatibility.
+  - Supported libraries include Zod, Valibot, ArkType, and other Standard Schema-compliant validators.
+- 78afb76: **Breaking:** Standard Schema-compliant validator libraries are now required (for example Zod 3.23+, Valibot 1.0+, ArkType 2.0+).
+- 78afb76: **Breaking:** Internal file structure was reorganized (affects deep imports).
+- 78afb76: **Breaking:** `FetchError` constructor now requires `(message, response)`.
 
-## 0.1.2
+## [0.1.2]
 
 ### Changed
 
 - 69c2b21: Renamed `safeFetch` to `$fetch` while preserving `safeFetch` compatibility for legacy usage.
 
-## 0.1.1
+## [0.1.1]
 
 ### Changed
 
 - 5f1812b: Updated `files` in `package.json` to publish only required artifacts.
 
-## 0.1.0
+## [0.1.0]
 
 ### Added
 

package/README.md

@@ -2,13 +2,28 @@
 
 A small fetch wrapper with [**Standard Schema**](https://standardschema.dev/schema) response validation.
 
+Full documentation: [zapstudio.dev/fetch](https://www.zapstudio.dev/fetch)
+
 ## Installation
 
 ```bash
 npm install @zap-studio/fetch
 ```
 
-## Quick Example
+You also need a schema library that implements [Standard Schema](https://standardschema.dev/schema), such as Zod, Valibot, or ArkType.
+
+## Features
+
+- **Raw fetch mode** through `$fetch(input, options)` — behaves like native `fetch` and returns the `Response`.
+- **Validated fetch mode** through `$fetch(input, schema, options)` — parses and validates the JSON response.
+- **HTTP method helpers** through `api.get`, `api.post`, `api.put`, `api.patch`, and `api.delete`.
+- **Configured clients** through `createFetch(...)` with shared `baseURL`, headers, query params, and error defaults.
+- **JSON convenience** through the `json` option, which serializes the request body and sets `Content-Type`.
+- **Structured errors** with `FetchError` for HTTP failures and `ValidationError` for schema failures.
+- **Validator-agnostic** — works with any library that implements Standard Schema.
+- **Tree-shakeable** — every export is a standalone function with no shared internal state; unused exports are dropped by any modern bundler.
+
+## Quick Start
 
 ```ts
 import { api } from "@zap-studio/fetch";
@@ -17,45 +32,17 @@ import { z } from "zod";
 const UserSchema = z.object({
   id: z.number(),
   name: z.string(),
-  email: z.string().email(),
+  email: z.email(),
 });
 
 const user = await api.get("https://api.example.com/users/1", UserSchema);
 
-console.log(user.name);
-```
-
-## Before
-
-Without response validation, fetch code often needs unchecked assertions:
-
-```ts
-type User = {
-  id: number;
-  name: string;
-};
-
-const response = await fetch("/api/users/1");
-const data = await response.json();
-
-const user = data as User;
+console.log(user.name); // typed as string, validated at runtime
 ```
 
-## After
+## Raw Fetch Mode
 
-With `@zap-studio/fetch`, the response is validated before it is returned:
-
-```ts
-import { api } from "@zap-studio/fetch";
-
-const user = await api.get("/api/users/1", UserSchema);
-```
-
-The returned value is inferred from the schema.
-
-## Raw Fetch Usage
-
-Use `$fetch` without a schema when you want the normal `Response` object.
+Behaves like native `fetch` and returns the `Response`.
 
 ```ts
 import { $fetch } from "@zap-studio/fetch";
@@ -64,21 +51,9 @@ const response = await $fetch("/api/users/1");
 const user = await response.json();
 ```
 
-Native fetch options are passed through as `RequestInit`.
-
-```ts
-const response = await $fetch("/api/users", {
-  method: "POST",
-  body: JSON.stringify({ name: "Ada" }),
-  headers: {
-    "Content-Type": "application/json",
-  },
-});
-```
-
-## Validated Fetch Usage
+## Validated Fetch Mode
 
-Pass a Standard Schema as the second argument to validate the JSON response.
+Parses and validates the JSON response.
 
 ```ts
 import { $fetch } from "@zap-studio/fetch";
@@ -86,213 +61,79 @@ import { $fetch } from "@zap-studio/fetch";
 const user = await $fetch("/api/users/1", UserSchema);
 ```
 
-The schema validates the response body, not the request body.
+## HTTP Method Helpers
 
-When validation fails, a `ValidationError` is thrown by default.
-
-## API Method Helpers
-
-The `api` export provides common HTTP methods.
+`api.get`, `api.post`, `api.put`, `api.patch`, and `api.delete`.
 
 ```ts
 import { api } from "@zap-studio/fetch";
 
-const user = await api.get("/api/users/1", UserSchema);
-
 const created = await api.post("/api/users", UserSchema, {
-  json: {
-    name: "Ada",
-    email: "ada@example.com",
-  },
-});
-```
-
-In this example, `UserSchema` validates the response from `/api/users`. The `json` value is the outgoing request body and is not validated by `UserSchema`.
-
-These helpers set the HTTP method for you. For raw responses without validation, use `$fetch`.
-
-## JSON Request Bodies
-
-Use `json` when you want the package to serialize a JSON request body.
-
-```ts
-await api.post("/api/users", UserSchema, {
-  json: {
-    name: "Ada",
-  },
-});
-```
-
-The schema argument still validates the response. Validate request bodies separately before passing them to `json` if your application needs outgoing payload validation.
-
-This sets:
-
-- `body` to `JSON.stringify(json)`
-- `Content-Type` to `application/json` when no content type was already provided
-
-Use native `body` for standard fetch behavior.
-
-```ts
-await $fetch("/api/upload", {
-  method: "POST",
-  body: formData,
+  json: { name: "Ada", email: "ada@example.com" },
 });
 ```
 
-`body` and `json` are mutually exclusive.
-
-## Query Params
+## Configured Clients
 
-Use `searchParams` for per-request query params.
-
-```ts
-await api.get("/api/users", UserListSchema, {
-  searchParams: {
-    page: "1",
-    limit: "20",
-  },
-});
-```
-
-`searchParams` accepts the same input shapes as `new URLSearchParams(...)`.
-
-```ts
-await api.get("/api/users", UserListSchema, {
-  searchParams: new URLSearchParams({ q: "ada" }),
-});
-
-await api.get("/api/users", UserListSchema, {
-  searchParams: "q=ada&page=1",
-});
-
-await api.get("/api/users", UserListSchema, {
-  searchParams: [["q", "ada"]],
-});
-```
-
-When defaults, URL query params, and request params overlap, later values win:
-
-1. `createFetch({ searchParams })`
-2. query params already present in the URL
-3. per-request `searchParams`
-
-## Creating a Client
-
-Use `createFetch` to configure shared defaults.
+Shared `baseURL`, headers, query params, and error defaults.
 
 ```ts
 import { createFetch } from "@zap-studio/fetch";
 
-const { $fetch, api } = createFetch({
+const { api } = createFetch({
   baseURL: "https://api.example.com",
-  headers: {
-    Authorization: `Bearer ${token}`,
-  },
-  searchParams: {
-    locale: "en",
-  },
+  headers: { Authorization: `Bearer ${token}` },
 });
 
 const user = await api.get("/users/1", UserSchema);
-const response = await $fetch("/health");
 ```
 
-Supported defaults:
-
-| Option                   | Description                                     |
-| ------------------------ | ----------------------------------------------- |
-| `baseURL`                | Base URL for relative request URLs              |
-| `headers`                | Headers applied to every request                |
-| `searchParams`           | Query params applied to every request           |
-| `throwOnFetchError`      | Throw `FetchError` for non-ok responses         |
-| `throwOnValidationError` | Throw `ValidationError` for validation failures |
+## JSON Convenience
 
-## Non-throwing Validation
-
-Set `throwOnValidationError: false` to receive the raw Standard Schema result.
+Serializes the request body and sets `Content-Type`.
 
 ```ts
-const result = await api.get("/api/users/1", UserSchema, {
-  throwOnValidationError: false,
+await api.post("/api/users", UserSchema, {
+  json: { name: "Ada" }, // mutually exclusive with `body`
 });
-
-if (result.issues) {
-  console.error("Validation failed:", result.issues);
-} else {
-  console.log("Validation passed:", result.value);
-}
 ```
 
-## HTTP Errors
+## Structured Errors
 
-By default, non-ok responses throw a `FetchError`.
+`FetchError` for HTTP failures and `ValidationError` for schema failures.
 
 ```ts
-import { FetchError } from "@zap-studio/fetch/errors";
+import { FetchError } from "@zap-studio/fetch";
+import { ValidationError } from "@zap-studio/validation";
 
 try {
-  await api.get("/api/users/404", UserSchema);
+  await api.get("/api/users/1", UserSchema);
 } catch (error) {
-  if (error instanceof FetchError) {
-    console.error(error.status);
-    console.error(error.response);
-  }
+  if (error instanceof FetchError) console.error(error.status);
+  if (error instanceof ValidationError) console.error(error.issues);
 }
 ```
 
-Disable this behavior when you want to handle the raw response yourself.
+## Validator-Agnostic
 
-```ts
-const response = await $fetch("/api/users/404", {
-  throwOnFetchError: false,
-});
-
-console.log(response.status);
-```
-
-## Request Objects
-
-The first argument (`input`) uses the same type as global `fetch`.
+Works with any library that implements Standard Schema.
 
 ```ts
-const request = new Request("https://api.example.com/users/1", {
-  headers: {
-    Authorization: `Bearer ${token}`,
-  },
-});
-
-const user = await $fetch(request, UserSchema);
+// UserSchema can come from Zod, Valibot, ArkType, or any Standard Schema-compatible library
+import type { StandardSchemaV1 } from "@zap-studio/validation";
 ```
 
-Per-request options are merged on top of the `Request`.
-
-## Standard Schema
-
-`@zap-studio/fetch` validates responses through `@zap-studio/validation`, so it works with any validation library that implements Standard Schema.
-
-Examples include:
+## Runtime Support
 
-- [Zod](https://zod.dev/)
-- [Valibot](https://valibot.dev/)
-- [ArkType](https://arktype.io/)
-
-You can also import Standard Schema types from `@zap-studio/validation` when needed.
-
-```ts
-import type { StandardSchemaV1 } from "@zap-studio/validation";
-```
+| Runtime            | Minimum version                                  |
+| ------------------ | ------------------------------------------------ |
+| Node.js            | 18.0.0 (ships native `fetch`)                    |
+| Bun                | 1.0.0                                            |
+| Deno               | 1.42                                             |
+| Cloudflare Workers | Any current release                              |
+| Browsers           | Latest evergreen (Chrome, Edge, Firefox, Safari) |
 
-## Choosing the Right API
-
-| API           | Use when                                          |
-| ------------- | ------------------------------------------------- |
-| `$fetch`      | You want raw fetch behavior or a custom method    |
-| `api.get`     | You want a validated GET request                  |
-| `api.post`    | You want a validated POST request                 |
-| `api.put`     | You want a validated PUT request                  |
-| `api.patch`   | You want a validated PATCH request                |
-| `api.delete`  | You want a validated DELETE request               |
-| `createFetch` | You want shared defaults like base URL or headers |
+The package relies on the global `fetch` API and ships standard ESM only. Deno 1.42 is the first release that can install packages from JSR (`deno add jsr:@zap-studio/fetch`).
 
 ## License
 

package/dist/{errors.d.mts → errors.d.ts}

@@ -38,4 +38,4 @@ declare class FetchError extends Error {
 }
 //#endregion
 export { FetchError };
-//# sourceMappingURL=errors.d.mts.map
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cAwBa,mBAAmB;;;;EAI9B,QAAQ;;;;EAIR,UAAU;;;;EAKV,YAAY,iBAAiB,UAAU"}

package/dist/{errors.mjs → errors.js}

@@ -44,4 +44,4 @@ var FetchError = class extends Error {
 //#endregion
 export { FetchError };
 
-//# sourceMappingURL=errors.mjs.map
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Custom error types used by the fetch package.\n *\n * @module @zap-studio/fetch/errors\n */\n\n/**\n * Error thrown for HTTP errors (non-2xx responses)\n *\n * Includes the failing `Response` object and status code for\n * downstream error handling and response inspection.\n *\n * @example\n * import { FetchError } from \"@zap-studio/fetch/errors\";\n *\n * try {\n *   await $fetch(\"/users/404\");\n * } catch (error) {\n *   if (error instanceof FetchError) {\n *     console.error(error.status);\n *     console.error(await error.response.text());\n *   }\n * }\n */\nexport class FetchError extends Error {\n  /**\n   * HTTP status code from the failing response.\n   */\n  status: Response[\"status\"];\n  /**\n   * Full response object for additional inspection.\n   */\n  response: Response;\n\n  /**\n   * Creates a FetchError from a non-ok response.\n   */\n  constructor(message: string, response: Response) {\n    super(message);\n    this.name = \"FetchError\";\n    this.status = response.status;\n    this.response = response;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,aAAb,cAAgC,MAAM;;;;CAIpC;;;;CAIA;;;;CAKA,YAAY,SAAiB,UAAoB;EAC/C,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS,SAAS;EACvB,KAAK,WAAW;CAClB;AACF"}

package/dist/{index.d.mts → index.d.ts}

@@ -1,6 +1,19 @@
-import { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput } from "./types.mjs";
+import { FetchError } from "./errors.js";
+import { $Fetch, ApiMethods, ExtendedRequestInit, FetchDefaults, FetchInput, NormalizedRequest } from "./types.js";
 import { StandardSchemaV1 } from "@zap-studio/validation";
 //#region src/index.d.ts
+/**
+ * Default options for the global $fetch
+ *
+ * These defaults are used by the top-level `$fetch` export.
+ * Use `createFetch(...)` when you need per-client defaults.
+ *
+ * @example
+ * import { GLOBAL_DEFAULTS } from "@zap-studio/fetch";
+ *
+ * console.log(GLOBAL_DEFAULTS.throwOnFetchError); // true
+ */
+declare const GLOBAL_DEFAULTS: FetchDefaults;
 /**
  * Type-safe fetch wrapper with Standard Schema validation.
  *
@@ -110,5 +123,5 @@ declare const createFetch: (factoryOptions?: Partial<FetchDefaults>) => {
   api: ApiMethods;
 };
 //#endregion
-export { $fetch, api, createFetch };
-//# sourceMappingURL=index.d.mts.map
+export { type $Fetch, $fetch, type ApiMethods, type ExtendedRequestInit, type FetchDefaults, FetchError, type FetchInput, GLOBAL_DEFAULTS, type NormalizedRequest, api, createFetch };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;cA8Ca,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgYR,OAAO,gBAAgB,kBAC3C,OAAO,YACP,QAAQ,SACR,SAAS;EAAwB;IAChC,QAAQ,iBAAiB,OAAO,iBAAiB,YAAY;iBAE1C,OAAO,gBAAgB,kBAC3C,OAAO,YACP,QAAQ,SACR,UAAU;EAAwB;IACjC,QAAQ,iBAAiB,YAAY;iBAElB,OACpB,OAAO,YACP,UAAU,sBACT,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;cAqCE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,cACX,iBAAgB,QAAQ;EAExB,QAAQ;EACR,KAAK"}