@ozanarslan/corpus 0.0.1

package/dist/ParserBase/BodyParser/index.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Content-type-driven body reading for requests and responses alike.
+ *
+ * {@link BodyParser} is the implementation behind
+ * {@link ParsersRegistry.bodyParser}, which {@link App} uses to fill
+ * {@link Context.body}. It classifies the `Content-Type` header, then delegates
+ * structured payloads to {@link SearchParamsParser} and {@link FormDataParser}
+ * through the registry, so nesting and coercion rules stay identical across
+ * query strings, form posts and JSON.
+ *
+ * @module BodyParser
+ */
+import { Res } from "../../Res";
+/**
+ * What {@link BodyParser.parse} can produce.
+ *
+ * Structured types yield an object or an array, textual types a string, binary
+ * types the undrained stream so it can be piped rather than buffered, and a
+ * binary body that turned out to be absent yields `null`.
+ */
+type ParsedBody = Record<string, unknown> | Array<unknown> | string | ReadableStream<Uint8Array> | null;
+/**
+ * The public shape of a body parser, implemented by {@link BodyParser}.
+ *
+ * Assign an alternative implementation to
+ * {@link ParsersRegistry.bodyParser} through {@link setParsersRegistry} to
+ * replace body handling framework-wide.
+ */
+interface BodyParserInterface {
+    /**
+     * Reads and decodes a body according to its `Content-Type`.
+     *
+     * @param received - The request, response or {@link Res} to read from.
+     * @returns The decoded body.
+     */
+    parse(received: Request | Response | Res): Promise<ParsedBody>;
+}
+/**
+ * Default {@link BodyParserInterface} implementation.
+ *
+ * Reads are non-destructive for caller-supplied inputs: the body is cloned
+ * before being drained, so a {@link Middleware} can inspect a body and still
+ * leave it readable downstream. Empty bodies resolve to a null-prototype object
+ * from {@link createSafeObject} rather than a plain `{}`, which is what keeps a
+ * `__proto__` key in a payload from reaching `Object.prototype`.
+ */
+declare class BodyParser implements BodyParserInterface {
+    /**
+     * Reads a body and decodes it according to its `Content-Type`. This can be
+     * used for both request and response bodies.
+     *
+     * A {@link Res} is converted with {@link Res.toNativeResponse} first. The
+     * content type is read from that source rather than from the clone, because
+     * Bun derives it lazily for `FormData`-backed requests and a clone taken
+     * before the derivation does not carry it. The clone itself is skipped for a
+     * {@link Res}-derived response, which is freshly constructed and unshared.
+     *
+     * @param received - The request, response or {@link Res} whose body to read.
+     * @returns The decoded {@link ParsedBody}. A body-less input yields an empty
+     * safe object.
+     * @throws {@link Exception} with {@link Status.BAD_REQUEST} when the payload is
+     * malformed for its declared type — a `SyntaxError` from decoding is
+     * attributed to the client, and the offending content type is attached to the
+     * exception. Any other error propagates unchanged.
+     */
+    parse(received: Request | Response | Res): Promise<ParsedBody>;
+    /**
+     * Decodes an `application/json` body.
+     *
+     * @param input - The cloned request or response to drain.
+     * @returns The parsed value, or an empty safe object when the body is blank —
+     * an empty payload is treated as "nothing sent" rather than as a syntax error.
+     * @throws `SyntaxError` on malformed JSON, which {@link BodyParser.parse}
+     * converts into a {@link Status.BAD_REQUEST} {@link Exception}.
+     */
+    private getJsonBody;
+    /**
+     * Decodes an `application/x-www-form-urlencoded` body.
+     *
+     * The pairs are handed to {@link ParsersRegistry.searchParamsParser}, so a
+     * form post and a query string with the same shape produce the same object,
+     * including bracket nesting and repeated keys.
+     *
+     * @param input - The cloned request or response to drain.
+     * @returns The parsed object, or an empty safe object when the body is blank.
+     * Falls back to flat `URLSearchParams` entries if no search params parser is
+     * registered.
+     */
+    private getFormUrlEncodedBody;
+    /**
+     * Decodes a `multipart/form-data` body, delegating to
+     * {@link ParsersRegistry.formDataParser} so uploaded files and nested field
+     * names are handled consistently.
+     *
+     * @param input - The cloned request or response to drain.
+     * @returns The parsed object, or flat `FormData` entries if no form data
+     * parser is registered.
+     */
+    private getFormDataBody;
+    /**
+     * Decodes a textual body, honouring the `charset` parameter of the content
+     * type.
+     *
+     * `Body.text()` always decodes as UTF-8 per the fetch spec, ignoring the
+     * declared charset, so anything other than UTF-8 is decoded from the raw bytes
+     * with a matching `TextDecoder`. An unrecognised charset label falls back to
+     * UTF-8 rather than failing the request.
+     *
+     * @param input - The cloned request or response to drain.
+     * @param contentType - The full header value, used to extract `charset`.
+     * @returns The decoded text.
+     */
+    private getTextBody;
+    /**
+     * Passes a binary body through undrained, so large uploads can be streamed
+     * instead of buffered into memory.
+     *
+     * @param input - The cloned request or response.
+     * @returns The body stream, or `null` if there is none.
+     */
+    private getBinaryBody;
+    /**
+     * Handles a body whose content type matched nothing in
+     * {@link CONTENT_TYPE_MAP}, including requests that declared no type at all.
+     *
+     * The body is decoded as text and JSON is attempted opportunistically, so a
+     * client that omits its `Content-Type` still gets structured data. A failed
+     * parse is not an error here — the raw text is returned instead.
+     *
+     * @param input - The cloned request or response to drain.
+     * @param contentType - The full header value, forwarded for charset handling.
+     * @returns The parsed JSON value, the raw text, or an empty safe object when
+     * the body is blank.
+     */
+    private getUnknownBody;
+}
+export { type BodyParserInterface, BodyParser };
+//# sourceMappingURL=index.d.ts.map

package/dist/ParserBase/BodyParser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ParserBase/BodyParser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAAE,GAAG,EAAU,MAAM,OAAO,CAAC;AAWpC;;;;;;GAMG;AACH,KAAK,UAAU,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,KAAK,CAAC,OAAO,CAAC,GACd,MAAM,GACN,cAAc,CAAC,UAAU,CAAC,GAC1B,IAAI,CAAC;AAER;;;;;;GAMG;AACH,UAAU,mBAAmB;IAC5B;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,GAAG,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC/D;AAiCD;;;;;;;;GAQG;AACH,cAAM,UAAW,YAAW,mBAAmB;IAC9C;;;;;;;;;;;;;;;;;OAiBG;IACG,KAAK,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,GAAG,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC;IAwCpE;;;;;;;;OAQG;YACW,WAAW;IAQzB;;;;;;;;;;;OAWG;YACW,qBAAqB;IASnC;;;;;;;;OAQG;YACW,eAAe;IAO7B;;;;;;;;;;;;OAYG;YACW,WAAW;IAuBzB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;;;;;;;OAYG;YACW,cAAc;CAY5B;AAED,OAAO,EAAE,KAAK,mBAAmB,EAAE,UAAU,EAAE,CAAC"}

package/dist/ParserBase/FormDataParser/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Parsing `multipart/form-data` into a nested object.
+ *
+ * {@link FormDataParser} is the default {@link ParsersRegistry.formDataParser},
+ * reached through {@link BodyParser} rather than called directly. It applies the
+ * same bracket-notation nesting as {@link SearchParamsParser}, so a form post
+ * and a query string with matching field names produce the same shape — the
+ * difference is that a form can also carry files, which are kept as `File`
+ * objects instead of being coerced.
+ *
+ * @module FormDataParser
+ */
+import { ParserBase } from "..";
+/**
+ * Turns a `FormData` into a nested object.
+ *
+ * Field names are read as paths through {@link ParserBase.parseKey}, so
+ * `user[address][city]` and `tags[0]` build the objects and arrays they
+ * describe. Repeated names collect into an array, which is how a multi-select or
+ * a multi-file input arrives without any bracket notation at all.
+ *
+ * Values are coerced through {@link ParserBase.tryParseJSON}, so `"true"` and
+ * `"42"` arrive as a boolean and a number rather than as strings. Files are
+ * exempt — a `File` is passed through untouched.
+ */
+declare class FormDataParser extends ParserBase<FormData> {
+    /**
+     * Parses form data into a nested object.
+     *
+     * @param formData - The form data to parse, typically from
+     * `Request.formData()`.
+     * @returns The nested object, built on a null prototype by
+     * {@link createSafeObject} so a `__proto__` field name cannot reach
+     * `Object.prototype`.
+     */
+    parse(formData: FormData): Record<string, unknown>;
+    /**
+     * Writes a value at a path, creating the containers it passes through.
+     *
+     * Each missing level is created as an array when the next path part is a
+     * number and as an object otherwise, so the shape follows the field name
+     * rather than being guessed after the fact.
+     *
+     * The final slot collects rather than overwrites: an empty slot takes the
+     * value, a slot already holding an array appends, and a slot holding a single
+     * value is promoted to an array. That is what makes repeated field names
+     * accumulate — order of arrival is preserved.
+     *
+     * @param result - The object being built up.
+     * @param parts - The path from {@link ParserBase.parseKey}; numbers mean array
+     * indices, strings mean object keys.
+     * @param value - The value to write, already coerced or left as a `File`.
+     */
+    private setDeep;
+}
+export { FormDataParser };
+//# sourceMappingURL=index.d.ts.map

package/dist/ParserBase/FormDataParser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ParserBase/FormDataParser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C;;;;;;;;;;;GAWG;AACH,cAAM,cAAe,SAAQ,UAAU,CAAC,QAAQ,CAAC;IAChD;;;;;;;;OAQG;IACH,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAYlD;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,OAAO;CAoCf;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/ParserBase/SchemaParser/index.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Request validation against the schemas declared in a {@link RouteConfig}.
+ *
+ * Schemas are taken as [Standard Schema](https://standardschema.dev), so any
+ * library implementing that spec works — Zod, Valibot, ArkType and others —
+ * without corpus depending on any of them. The same interface also supplies the
+ * inferred types that flow into {@link Context}, so declaring a schema both
+ * validates the request and types the handler.
+ *
+ * {@link App} calls this after each surface is parsed, so what a handler sees on
+ * {@link Context.body}, {@link Context.search} and {@link Context.params} is
+ * already validated. A failure raises {@link Status.UNPROCESSABLE_ENTITY} with a
+ * message naming the offending fields, so the client is told what was wrong
+ * rather than just that something was.
+ *
+ * @module SchemaParser
+ */
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { RouteConfig } from "../../RouteBase";
+import type { Prettify } from "../../utils/object";
+/**
+ * Any Standard Schema validator producing `T`. This is the type
+ * {@link RouteConfig} fields accept.
+ *
+ * @typeParam T - What the schema validates to.
+ */
+type Schema<T = unknown> = StandardSchemaV1<unknown, T>;
+/**
+ * The type a schema accepts as input, before transformation.
+ *
+ * @typeParam T - The schema.
+ */
+type InferSchemaIn<T extends Schema> = StandardSchemaV1.InferInput<T>;
+/**
+ * The type a schema produces after validation. This is what a route's
+ * {@link Context} fields are typed as.
+ *
+ * @typeParam T - The schema.
+ */
+type InferSchemaOut<T extends Schema> = StandardSchemaV1.InferOutput<T>;
+/** The validation failures a schema reports. */
+type ValidationIssues = readonly StandardSchemaV1.Issue[];
+/** If you prefer to put all schemas into a single object, this will be helpful */
+type InferModel<T extends Record<string, any>> = {
+    [K in keyof T as K extends "prototype" ? never : K]: T[K] extends RouteConfig<any, any, any, any> ? Prettify<(T[K]["body"] extends Schema ? {
+        body: InferSchemaOut<T[K]["body"]>;
+    } : {}) & (T[K]["search"] extends Schema ? {
+        search: InferSchemaOut<T[K]["search"]>;
+    } : {}) & (T[K]["params"] extends Schema ? {
+        params: InferSchemaOut<T[K]["params"]>;
+    } : {}) & (T[K]["response"] extends Schema ? {
+        response: InferSchemaOut<T[K]["response"]>;
+    } : {})> : T[K] extends Schema ? InferSchemaOut<T[K]> : never;
+};
+/**
+ * The public shape of a schema parser, implemented by {@link SchemaParser}.
+ * Assign an alternative to {@link ParsersRegistry.schemaParser} to change how
+ * validation failures are reported.
+ */
+interface SchemaParserInterface {
+    /**
+     * Validates a value against a schema.
+     *
+     * @param label - Names the surface being validated, for the error message.
+     * @param input - The value to validate.
+     * @param schema - The schema. Omitting it passes the value through unchanged.
+     * @returns The validated value.
+     */
+    parse<T = Record<string, unknown>>(label: string, input: unknown, schema?: Schema<T>): Promise<T>;
+    /**
+     * Validates a value against a synchronous schema.
+     *
+     * @param label - Names the surface being validated, for the error message.
+     * @param input - The value to validate.
+     * @param schema - The schema. Omitting it passes the value through unchanged.
+     * @returns The validated value.
+     */
+    parseSync<T = Record<string, unknown>>(label: string, input: unknown, schema?: Schema<T>): T;
+}
+/**
+ * Default {@link SchemaParserInterface} implementation.
+ *
+ * A missing schema is not an error — the value passes through untouched, which
+ * is what makes {@link RouteConfig} entirely optional.
+ */
+declare class SchemaParser implements SchemaParserInterface {
+    /**
+     * Validates a value against a schema.
+     *
+     * This is what {@link App} uses during the request lifecycle, since a schema
+     * may validate asynchronously.
+     *
+     * @param label - Names the surface being validated — `"body"`, `"search"` or
+     * `"params"` — and appears in the error message.
+     * @param data - The value to validate, already parsed from the request.
+     * @param schema - The schema from the route's {@link RouteConfig}. Omitting it
+     * returns the data as-is.
+     * @returns The validated value, with whatever transformations the schema
+     * applies.
+     * @throws {@link Exception} with {@link Status.UNPROCESSABLE_ENTITY} when
+     * validation fails, carrying the rejected data as exception data.
+     */
+    parse<T = Record<string, unknown>>(label: string, data: unknown, schema?: Schema<T>): Promise<T>;
+    /**
+     * Validates a value without awaiting, for callers that cannot be async.
+     *
+     * Whether a schema validates synchronously is not visible in its type, so it
+     * is detected at runtime: a validator that returns a promise is rejected
+     * outright rather than having its result silently used as a value.
+     *
+     * @param label - Names the surface being validated, and appears in the error
+     * message.
+     * @param data - The value to validate.
+     * @param schema - The schema. Omitting it returns the data as-is.
+     * @returns The validated value.
+     * @throws {@link Error} when the schema validates asynchronously — use
+     * {@link SchemaParser.parse} instead.
+     * @throws {@link Exception} with {@link Status.UNPROCESSABLE_ENTITY} when
+     * validation fails.
+     */
+    parseSync<T = Record<string, unknown>>(label: string, data: unknown, schema?: Schema<T>): T;
+    /**
+     * Renders validation issues into the message sent to the client.
+     *
+     * Each issue is reported as `in <label> <path> (received <value>): <message>`,
+     * so a client can see which field failed and what it actually sent — a
+     * schema's own message alone rarely says which field it came from. Path
+     * segments are joined with dots, and the offending value is looked up by
+     * walking the original data along that path. Issues with no path are global to
+     * the surface and keep their message unadorned.
+     *
+     * Override this to change the wording or to withhold the received values.
+     *
+     * @param label - Names the surface being validated.
+     * @param data - The value that failed, walked to find each reported value.
+     * @param issues - The failures the schema reported.
+     * @returns One line per issue, newline-joined, or an empty string when there
+     * are none.
+     */
+    issuesToErrorMessage(label: string, data: unknown, issues: ValidationIssues): string;
+}
+export { type SchemaParserInterface, SchemaParser, type Schema, type InferSchemaIn, type InferSchemaOut, type ValidationIssues, type InferModel, };
+//# sourceMappingURL=index.d.ts.map

package/dist/ParserBase/SchemaParser/index.d.ts.map

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

package/dist/ParserBase/SearchParamsParser/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Parsing a query string into a nested object.
+ *
+ * {@link SearchParamsParser} is the default
+ * {@link ParsersRegistry.searchParamsParser}. It fills {@link Context.search},
+ * and {@link BodyParser} also routes `application/x-www-form-urlencoded` bodies
+ * through it, so a query string and a form post with matching field names
+ * produce the same shape.
+ *
+ * @module SearchParamsParser
+ */
+import { ParserBase } from "..";
+/**
+ * Turns `URLSearchParams` into a nested object.
+ *
+ * Keys are read as paths through {@link ParserBase.parseKey}, so
+ * `?filter[status]=open&tags[0]=a` builds the objects and arrays it describes.
+ * Repeated keys collect into an array, which is how `?tag=a&tag=b` arrives
+ * without any bracket notation.
+ *
+ * Values are coerced through {@link ParserBase.tryParseJSON}, so `?page=2` and
+ * `?active=true` arrive as a number and a boolean rather than as strings.
+ */
+declare class SearchParamsParser extends ParserBase<URLSearchParams> {
+    /**
+     * Parses a query string into a nested object.
+     *
+     * @param searchParams - The parameters to parse.
+     * @returns The nested object, built on a null prototype by
+     * {@link createSafeObject} so a `__proto__` key in the query string cannot
+     * reach `Object.prototype`.
+     */
+    parse(searchParams: URLSearchParams): Record<string, unknown>;
+    /**
+     * Writes a value at a path, creating the containers it passes through.
+     *
+     * Each missing level is created as an array when the next path part is a
+     * number and as an object otherwise, so the shape follows the key rather than
+     * being guessed after the fact. A scalar already occupying a level that must
+     * be descended into is replaced — query strings are client-controlled and
+     * arrive in arbitrary order, so `?a=1&a[b]=2` is resolved by letting the
+     * structured key win rather than throwing.
+     *
+     * The final slot collects rather than overwrites: an empty slot takes the
+     * value, a slot already holding an array appends, and a slot holding a single
+     * value is promoted to an array. That is what makes repeated keys accumulate,
+     * in arrival order.
+     *
+     * Deliberately kept separate from {@link FormDataParser}'s near-identical
+     * method: the two sources differ in what they can carry, and sharing the code
+     * would tie their behaviour together.
+     *
+     * @param result - The object being built up.
+     * @param parts - The path from {@link ParserBase.parseKey}; numbers mean array
+     * indices, strings mean object keys.
+     * @param value - The value to write, already coerced.
+     */
+    private setDeep;
+}
+export { SearchParamsParser };
+//# sourceMappingURL=index.d.ts.map

package/dist/ParserBase/SearchParamsParser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ParserBase/SearchParamsParser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C;;;;;;;;;;GAUG;AACH,cAAM,kBAAmB,SAAQ,UAAU,CAAC,eAAe,CAAC;IAC3D;;;;;;;OAOG;IACH,KAAK,CAAC,YAAY,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAY7D;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,OAAO;CAmCf;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/ParserBase/URLParamsParser/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Parsing path parameters into typed values.
+ *
+ * {@link URLParamsParser} is the default
+ * {@link ParsersRegistry.urlParamsParser}. It fills {@link Context.params} from
+ * the raw values Bun's router matched, decoding and coercing each one.
+ *
+ * @module URLParamsParser
+ */
+import { ParserBase } from "..";
+/**
+ * Turns matched path parameters into a typed object.
+ *
+ * The flattest of the parsers: path parameters are named by the route pattern,
+ * so there is no nesting to recover — no bracket notation, no repeated keys.
+ * Each value is percent-decoded and then coerced through
+ * {@link ParserBase.tryParseJSON}, so `/users/42` yields a number rather than a
+ * string.
+ */
+declare class URLParamsParser extends ParserBase<Record<string, string>> {
+    /**
+     * Parses matched path parameters.
+     *
+     * @param input - The raw parameters from the router, including the `*` key
+     * that {@link App} lifts out of a wildcard endpoint.
+     * @returns The decoded, coerced parameters, on a null prototype from
+     * {@link createSafeObject}.
+     */
+    parse(input: Record<string, string>): Record<string, unknown>;
+}
+export { URLParamsParser };
+//# sourceMappingURL=index.d.ts.map

package/dist/ParserBase/URLParamsParser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ParserBase/URLParamsParser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C;;;;;;;;GAQG;AACH,cAAM,eAAgB,SAAQ,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/D;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAO7D;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/ParserBase/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * The shared base for the input parsers that turn flat key/value pairs into
+ * nested objects.
+ *
+ * {@link URLParamsParser}, {@link SearchParamsParser} and
+ * {@link FormDataParser} all face the same problem: a source that only carries
+ * strings paired with strings, where structure has to be recovered from the key
+ * itself and types from the value. {@link ParserBase} supplies both halves —
+ * {@link ParserBase.parseKey} for the bracket notation and
+ * {@link ParserBase.tryParseJSON} for value coercion — so the three agree on
+ * what `user[roles][0]=admin` means regardless of which surface it arrived on.
+ *
+ * Subclass it to add a parser of your own, then register it through
+ * {@link setParsersRegistry}.
+ *
+ * @module ParserBase
+ */
+/**
+ * The public shape of an input parser. This is the type
+ * {@link ParsersRegistry.urlParamsParser}, {@link ParsersRegistry.searchParamsParser}
+ * and {@link ParsersRegistry.formDataParser} hold, so a replacement need only
+ * satisfy the contract rather than extend {@link ParserBase}.
+ *
+ * @typeParam T - The input the parser accepts — `URLSearchParams`, `FormData`,
+ * or a record of raw path parameters.
+ */
+interface ParserBaseInterface<T> {
+    /**
+     * Converts the input into a nested object.
+     *
+     * @param input - The source to parse.
+     * @returns The parsed object.
+     */
+    parse(input: T): Record<string, unknown>;
+}
+/**
+ * Base class for the input parsers.
+ *
+ * It provides the key and value handling; each subclass supplies
+ * {@link ParserBase.parse} for its own source and does the writing, since how
+ * repeated keys collect differs between a query string and a form.
+ *
+ * @typeParam T - The input the parser accepts.
+ */
+declare abstract class ParserBase<T> implements ParserBaseInterface<T> {
+    /**
+     * Converts the input into a nested object. Implemented per source.
+     *
+     * @param input - The source to parse.
+     * @returns The parsed object.
+     */
+    abstract parse(input: T): Record<string, unknown>;
+    /**
+     * Narrows a value to an indexable container so a path segment can be written
+     * into it.
+     *
+     * Purely a readability helper for the traversal loops — the value is used
+     * as-is, nothing is constructed.
+     *
+     * @param current - The level currently being written into.
+     * @returns The same value, typed for index access.
+     */
+    protected newContainer(current: unknown): Record<string | number, unknown>;
+    /**
+     * Splits a key into the path it describes.
+     *
+     * Dot and bracket notation are treated as equivalent, so `a[0].b[1][c]` and
+     * `a.0.b.1.c` both yield `["a", 0, "b", 1, "c"]`. A purely numeric segment
+     * becomes a number, which is how the subclasses know to create an array rather
+     * than an object at that level — subject to {@link ARRAY_INDEX_LIMIT}, above
+     * which the segment stays a string key.
+     *
+     * @param key - The raw field name.
+     * @returns The path segments: numbers for array indices, strings for object
+     * keys.
+     */
+    protected parseKey(key: string): (string | number)[];
+    /**
+     * Coerces a raw string value into whatever it represents.
+     *
+     * Since every value from these sources arrives as a string, `"42"`, `"true"`
+     * and `"null"` are decoded to their JSON equivalents. Anything that is not
+     * valid JSON — ordinary text, most of the time — is returned unchanged rather
+     * than treated as an error.
+     *
+     * @param value - The raw string value.
+     * @returns The decoded value, or the original string.
+     */
+    protected tryParseJSON(value: string): unknown;
+}
+export { type ParserBaseInterface, ParserBase };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ParserBase/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;GAQG;AACH,UAAU,mBAAmB,CAAC,CAAC;IAC9B;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAWD;;;;;;;;GAQG;AACH,uBAAe,UAAU,CAAC,CAAC,CAAE,YAAW,mBAAmB,CAAC,CAAC,CAAC;IAC7D;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAEjD;;;;;;;;;OASG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC;IAI1E;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE;IAepD;;;;;;;;;;OAUG;IACH,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAO9C;AAED,OAAO,EAAE,KAAK,mBAAmB,EAAE,UAAU,EAAE,CAAC"}