@schmock/core 2.2.3 → 2.3.1

package/dist/plugin-pipeline.d.ts

@@ -2,14 +2,21 @@
 interface PipelineLogger {
     log(category: string, message: string, data?: unknown): void;
 }
+interface PipelineResult {
+    context: Schmock.PluginContext;
+    response?: unknown;
+    recoveredFromError?: boolean;
+    requestShortCircuited?: boolean;
+}
+/** Run request guards before route code is allowed to execute. */
+export declare function runPluginBeforeRequest(plugins: readonly Schmock.Plugin[], context: Schmock.PluginContext, logger: PipelineLogger, signal?: AbortSignal | undefined): Promise<PipelineResult>;
+/** Give pipeline error handlers a chance to recover a route-generator error. */
+export declare function recoverGeneratorError(plugins: readonly Schmock.Plugin[], context: Schmock.PluginContext, error: unknown, logger: PipelineLogger, signal?: AbortSignal | undefined): Promise<PipelineResult>;
 /**
  * Run all registered plugins in sequence
  * First plugin to set response becomes generator, subsequent plugins transform
  * Handles plugin errors via onError hooks
  */
-export declare function runPluginPipeline(plugins: Schmock.Plugin[], context: Schmock.PluginContext, initialResponse: unknown, logger: PipelineLogger): Promise<{
-    context: Schmock.PluginContext;
-    response?: unknown;
-}>;
+export declare function runPluginPipeline(plugins: readonly Schmock.Plugin[], context: Schmock.PluginContext, initialResponse: unknown, logger: PipelineLogger, signal?: AbortSignal | undefined): Promise<PipelineResult>;
 export {};
 //# sourceMappingURL=plugin-pipeline.d.ts.map

package/dist/plugin-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-pipeline.d.ts","sourceRoot":"","sources":["../src/plugin-pipeline.ts"],"names":[],"mappings":"AAGA,uEAAuE;AACvE,UAAU,cAAc;IACtB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9D;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,eAAe,EAAE,OAAO,EACxB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAoFjE"}
+{"version":3,"file":"plugin-pipeline.d.ts","sourceRoot":"","sources":["../src/plugin-pipeline.ts"],"names":[],"mappings":"AAGA,uEAAuE;AACvE,UAAU,cAAc;IACtB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9D;AAED,UAAU,cAAc;IACtB,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAmED,kEAAkE;AAClE,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,SAAS,OAAO,CAAC,MAAM,EAAE,EAClC,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,MAAM,EAAE,cAAc,EACtB,MAAM,0BAAiB,GACtB,OAAO,CAAC,cAAc,CAAC,CAwDzB;AAED,gFAAgF;AAChF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,SAAS,OAAO,CAAC,MAAM,EAAE,EAClC,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,cAAc,EACtB,MAAM,0BAAiB,GACtB,OAAO,CAAC,cAAc,CAAC,CAmBzB;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,SAAS,OAAO,CAAC,MAAM,EAAE,EAClC,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,eAAe,EAAE,OAAO,EACxB,MAAM,EAAE,cAAc,EACtB,MAAM,0BAAiB,GACtB,OAAO,CAAC,cAAc,CAAC,CAiEzB"}

package/dist/plugin-pipeline.js

@@ -1,22 +1,123 @@
-import { isStatusTuple } from "./constants.js";
+import { awaitWithAbort, throwIfAborted } from "./abort.js";
 import { errorMessage, PluginError } from "./errors.js";
+function isPluginResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "context" in value &&
+        typeof value.context === "object" &&
+        value.context !== null);
+}
+function preserveRequestSignal(context, signal) {
+    return context.signal === signal ? context : { ...context, signal };
+}
+async function recoverPluginError(plugins, startIndex, error, context, logger, signal) {
+    let currentError = error instanceof Error ? error : new Error(errorMessage(error));
+    for (let index = startIndex; index < plugins.length; index += 1) {
+        throwIfAborted(signal);
+        const plugin = plugins[index];
+        if (!plugin.onError)
+            continue;
+        try {
+            const errorResult = await awaitWithAbort(plugin.onError(currentError, context), signal);
+            throwIfAborted(signal);
+            if (errorResult instanceof Error) {
+                currentError = errorResult;
+                continue;
+            }
+            if (errorResult !== undefined) {
+                logger.log("pipeline", `Plugin ${plugin.name} handled error`);
+                return { handled: true, response: errorResult };
+            }
+        }
+        catch (hookError) {
+            throwIfAborted(signal);
+            currentError =
+                hookError instanceof Error
+                    ? hookError
+                    : new Error(errorMessage(hookError));
+            logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`);
+        }
+    }
+    return { handled: false, error: currentError };
+}
+/** Run request guards before route code is allowed to execute. */
+export async function runPluginBeforeRequest(plugins, context, logger, signal = context.signal) {
+    let currentContext = preserveRequestSignal(context, signal);
+    for (let index = 0; index < plugins.length; index += 1) {
+        throwIfAborted(signal);
+        const plugin = plugins[index];
+        if (!plugin.beforeRequest)
+            continue;
+        logger.log("pipeline", `Running beforeRequest: ${plugin.name}`);
+        try {
+            const result = await awaitWithAbort(plugin.beforeRequest(currentContext), signal);
+            throwIfAborted(signal);
+            if (result === undefined)
+                continue;
+            if (!isPluginResult(result)) {
+                throw new Error(`Plugin ${plugin.name} didn't return valid result`);
+            }
+            currentContext = preserveRequestSignal(result.context, signal);
+            if (result.response !== undefined) {
+                logger.log("pipeline", `Plugin ${plugin.name} rejected request`);
+                return {
+                    context: currentContext,
+                    response: result.response,
+                    requestShortCircuited: true,
+                };
+            }
+        }
+        catch (error) {
+            throwIfAborted(signal);
+            logger.log("pipeline", `Plugin ${plugin.name} beforeRequest failed: ${errorMessage(error)}`);
+            const recovery = await recoverPluginError(plugins, index, error, currentContext, logger, signal);
+            if (recovery.handled) {
+                return {
+                    context: currentContext,
+                    response: recovery.response,
+                    recoveredFromError: true,
+                    requestShortCircuited: true,
+                };
+            }
+            throw new PluginError(plugin.name, recovery.error);
+        }
+    }
+    return { context: currentContext };
+}
+/** Give pipeline error handlers a chance to recover a route-generator error. */
+export async function recoverGeneratorError(plugins, context, error, logger, signal = context.signal) {
+    throwIfAborted(signal);
+    const recovery = await recoverPluginError(plugins, 0, error, context, logger, signal);
+    throwIfAborted(signal);
+    if (recovery.handled) {
+        return {
+            context,
+            response: recovery.response,
+            recoveredFromError: true,
+        };
+    }
+    throw recovery.error;
+}
 /**
  * Run all registered plugins in sequence
  * First plugin to set response becomes generator, subsequent plugins transform
  * Handles plugin errors via onError hooks
  */
-export async function runPluginPipeline(plugins, context, initialResponse, logger) {
-    let currentContext = context;
+export async function runPluginPipeline(plugins, context, initialResponse, logger, signal = context.signal) {
+    let currentContext = preserveRequestSignal(context, signal);
     let response = initialResponse;
     logger.log("pipeline", `Running plugin pipeline for ${plugins.length} plugins`);
-    for (const plugin of plugins) {
+    for (let index = 0; index < plugins.length; index += 1) {
+        throwIfAborted(signal);
+        const plugin = plugins[index];
         logger.log("pipeline", `Processing plugin: ${plugin.name}`);
         try {
-            const result = await plugin.process(currentContext, response);
-            if (!result?.context) {
+            const result = await awaitWithAbort(plugin.process(currentContext, response), signal);
+            throwIfAborted(signal);
+            if (!isPluginResult(result)) {
                 throw new Error(`Plugin ${plugin.name} didn't return valid result`);
             }
-            currentContext = result.context;
+            currentContext = preserveRequestSignal(result.context, signal);
             // First plugin to set response becomes the generator
             if (result.response !== undefined &&
                 (response === undefined || response === null)) {
@@ -29,40 +130,17 @@ export async function runPluginPipeline(plugins, context, initialResponse, logge
             }
         }
         catch (error) {
+            throwIfAborted(signal);
             logger.log("pipeline", `Plugin ${plugin.name} failed: ${errorMessage(error)}`);
-            // Try error handling if plugin has onError hook
-            if (plugin.onError) {
-                try {
-                    const pluginError = error instanceof Error ? error : new Error(errorMessage(error));
-                    const errorResult = await plugin.onError(pluginError, currentContext);
-                    if (errorResult) {
-                        logger.log("pipeline", `Plugin ${plugin.name} handled error`);
-                        // Error return → transform the thrown error
-                        if (errorResult instanceof Error) {
-                            throw new PluginError(plugin.name, errorResult);
-                        }
-                        // ResponseResult return → recover, stop pipeline
-                        // Accept both object-with-status and status tuple [code, body] / [code, body, headers]
-                        if (isStatusTuple(errorResult) ||
-                            (typeof errorResult === "object" &&
-                                errorResult !== null &&
-                                "status" in errorResult)) {
-                            response = errorResult;
-                            break;
-                        }
-                    }
-                    // void/falsy return → propagate original error below
-                }
-                catch (hookError) {
-                    // If the hook itself threw (including our PluginError above), re-throw it
-                    if (hookError instanceof PluginError) {
-                        throw hookError;
-                    }
-                    logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`);
-                }
+            const recovery = await recoverPluginError(plugins, index, error, currentContext, logger, signal);
+            if (recovery.handled) {
+                return {
+                    context: currentContext,
+                    response: recovery.response,
+                    recoveredFromError: true,
+                };
             }
-            const cause = error instanceof Error ? error : new Error(errorMessage(error));
-            throw new PluginError(plugin.name, cause);
+            throw new PluginError(plugin.name, recovery.error);
         }
     }
     return { context: currentContext, response };

package/dist/response-normalizer.d.ts

@@ -0,0 +1,16 @@
+type OwnedBytes = ReturnType<typeof Uint8Array.of>;
+interface NormalizableResponse {
+    status: number;
+    body: unknown;
+    headers?: Record<string, string>;
+}
+/**
+ * Validate and stabilize a response before it reaches a transport adapter.
+ */
+export declare function normalizeResponse(response: NormalizableResponse, method: string): Schmock.Response;
+/**
+ * Encode a response body using its normalized content type semantics.
+ */
+export declare function serializeResponseBody(response: Schmock.Response): OwnedBytes | undefined;
+export {};
+//# sourceMappingURL=response-normalizer.d.ts.map

package/dist/response-normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-normalizer.d.ts","sourceRoot":"","sources":["../src/response-normalizer.ts"],"names":[],"mappings":"AAwBA,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,EAAE,CAAC,CAAC;AAEnD,UAAU,oBAAoB;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAmSD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,oBAAoB,EAC9B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,QAAQ,CAmClB;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,CAAC,QAAQ,GACzB,UAAU,GAAG,SAAS,CAcxB"}

package/dist/response-normalizer.js

@@ -0,0 +1,316 @@
+import { isBinaryBody } from "./binary.js";
+import { errorMessage, InvalidResponseError } from "./errors.js";
+const BODY_FORBIDDEN_STATUSES = new Set([204, 205, 304]);
+const HEADER_NAME_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const FRAMING_HEADERS = new Set([
+    "content-length",
+    "trailer",
+    "transfer-encoding",
+]);
+/**
+ * Headers that describe the connection rather than the message (RFC 9110 §7.6.1).
+ * Kept separate from {@link FRAMING_HEADERS}, which is parameterised by
+ * `preserveContentLength`: these are never a route's to send, so the strip is
+ * unconditional.
+ */
+const HOP_BY_HOP_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "upgrade",
+]);
+function hasInvalidHeaderValue(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code <= 8 || (code >= 10 && code <= 31) || code === 127)
+            return true;
+    }
+    return false;
+}
+function validateStatus(status) {
+    if (typeof status !== "number" ||
+        !Number.isFinite(status) ||
+        !Number.isInteger(status) ||
+        status < 200 ||
+        status > 599) {
+        throw new InvalidResponseError("status must be a finite integer from 200 through 599", { status });
+    }
+}
+function headerEntries(headers) {
+    if (typeof headers !== "object" ||
+        headers === null ||
+        Array.isArray(headers)) {
+        throw new InvalidResponseError("headers must be a string record");
+    }
+    try {
+        const entries = [];
+        for (const name of Reflect.ownKeys(headers)) {
+            const descriptor = Object.getOwnPropertyDescriptor(headers, name);
+            if (!descriptor?.enumerable)
+                continue;
+            if (typeof name !== "string") {
+                throw new InvalidResponseError("header names must be strings");
+            }
+            const value = headers[name];
+            if (typeof value !== "string") {
+                throw new InvalidResponseError("header values must be strings", {
+                    headerName: name,
+                });
+            }
+            entries.push([name, value]);
+        }
+        return entries;
+    }
+    catch (error) {
+        if (error instanceof InvalidResponseError)
+            throw error;
+        throw new InvalidResponseError("headers could not be read", {
+            cause: errorMessage(error),
+        });
+    }
+}
+function normalizeHeadersWithPlatform(entries, PlatformHeaders) {
+    try {
+        const normalized = {};
+        for (const [name, value] of entries) {
+            try {
+                const headers = new PlatformHeaders([[name, value]]);
+                normalized[name] = headers.get(name) ?? value;
+            }
+            catch (error) {
+                throw new InvalidResponseError("header is invalid", {
+                    cause: errorMessage(error),
+                    headerName: name,
+                });
+            }
+        }
+        return normalized;
+    }
+    catch (error) {
+        if (error instanceof InvalidResponseError)
+            throw error;
+        throw new InvalidResponseError("headers could not be normalized", {
+            cause: errorMessage(error),
+        });
+    }
+}
+function normalizeHeadersWithoutPlatform(entries) {
+    const normalized = {};
+    for (const [name, value] of entries) {
+        if (!HEADER_NAME_PATTERN.test(name) || hasInvalidHeaderValue(value)) {
+            throw new InvalidResponseError("header is invalid", {
+                headerName: name,
+            });
+        }
+        normalized[name] = value.replace(/^[\t ]+|[\t ]+$/g, "");
+    }
+    return normalized;
+}
+function normalizeHeaders(headers) {
+    const entries = headerEntries(headers);
+    const seenNames = new Set();
+    for (const [name, value] of entries) {
+        const normalizedName = name.toLowerCase();
+        if (seenNames.has(normalizedName)) {
+            throw new InvalidResponseError("header names must be unique", {
+                headerName: name,
+            });
+        }
+        if (!HEADER_NAME_PATTERN.test(name) || hasInvalidHeaderValue(value)) {
+            throw new InvalidResponseError("header is invalid", {
+                headerName: name,
+            });
+        }
+        seenNames.add(normalizedName);
+    }
+    const PlatformHeaders = globalThis.Headers;
+    return typeof PlatformHeaders === "function"
+        ? normalizeHeadersWithPlatform(entries, PlatformHeaders)
+        : normalizeHeadersWithoutPlatform(entries);
+}
+function copyBinaryBody(body) {
+    try {
+        if (body instanceof Uint8Array) {
+            // Uint8Array.prototype.slice species-creates, so subclasses such as
+            // Node's Buffer keep their type while the bytes are still copied.
+            // body.slice() would not: Buffer overrides slice() to return a view.
+            return Uint8Array.prototype.slice.call(body);
+        }
+        const source = body instanceof ArrayBuffer
+            ? new Uint8Array(body)
+            : new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+        return Uint8Array.from(source);
+    }
+    catch (error) {
+        throw new InvalidResponseError("binary body could not be copied", {
+            cause: errorMessage(error),
+        });
+    }
+}
+function bodyType(value) {
+    if (value === null)
+        return "null";
+    if (typeof value !== "object")
+        return typeof value;
+    try {
+        return Object.prototype.toString.call(value);
+    }
+    catch {
+        return "object";
+    }
+}
+function hasFunctionProperty(value, property) {
+    return typeof Reflect.get(value, property) === "function";
+}
+function assertJsonCompatible(value) {
+    if (value === null)
+        return;
+    switch (typeof value) {
+        case "boolean":
+        case "string":
+            return;
+        case "number":
+            if (Number.isFinite(value))
+                return;
+            throw new InvalidResponseError("body contains a non-finite number", {
+                bodyType: "number",
+            });
+        case "undefined":
+        case "function":
+        case "symbol":
+        case "bigint":
+            throw new InvalidResponseError(`body contains an unsupported ${typeof value} value`, { bodyType: typeof value });
+        case "object":
+            break;
+    }
+    try {
+        if (isBinaryBody(value)) {
+            throw new InvalidResponseError("binary values are supported only as the top-level body", { bodyType: bodyType(value) });
+        }
+        if (hasFunctionProperty(value, "then") ||
+            hasFunctionProperty(value, "getReader") ||
+            hasFunctionProperty(value, "getWriter") ||
+            (hasFunctionProperty(value, "pipe") &&
+                hasFunctionProperty(value, "on")) ||
+            hasFunctionProperty(value, Symbol.asyncIterator)) {
+            throw new InvalidResponseError("promise, iterable, and stream bodies are unsupported", { bodyType: bodyType(value) });
+        }
+        for (const key of Reflect.ownKeys(value)) {
+            if (typeof key === "symbol" &&
+                Object.getOwnPropertyDescriptor(value, key)?.enumerable) {
+                throw new InvalidResponseError("body contains an enumerable symbol property", { bodyType: bodyType(value) });
+            }
+        }
+        if (!Array.isArray(value) &&
+            Object.prototype.toString.call(value) !== "[object Object]") {
+            throw new InvalidResponseError("body contains an unsupported object", {
+                bodyType: bodyType(value),
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof InvalidResponseError)
+            throw error;
+        throw new InvalidResponseError("body could not be inspected", {
+            bodyType: bodyType(value),
+            cause: errorMessage(error),
+        });
+    }
+}
+function stringifyJsonBody(body) {
+    try {
+        const serialized = JSON.stringify(body, (_key, value) => {
+            assertJsonCompatible(value);
+            return value;
+        });
+        if (serialized !== undefined)
+            return serialized;
+        throw new InvalidResponseError("body did not produce JSON", {
+            bodyType: bodyType(body),
+        });
+    }
+    catch (error) {
+        if (error instanceof InvalidResponseError)
+            throw error;
+        throw new InvalidResponseError("body is not JSON-serializable", {
+            bodyType: bodyType(body),
+            cause: errorMessage(error),
+        });
+    }
+}
+function normalizeBody(body) {
+    if (body === undefined || typeof body === "string")
+        return body;
+    if (isBinaryBody(body))
+        return copyBinaryBody(body);
+    return JSON.parse(stringifyJsonBody(body));
+}
+function removeFramingHeaders(headers, preserveContentLength = false) {
+    for (const name of Object.keys(headers)) {
+        const normalizedName = name.toLowerCase();
+        if (FRAMING_HEADERS.has(normalizedName) &&
+            !(preserveContentLength && normalizedName === "content-length")) {
+            delete headers[name];
+        }
+    }
+}
+function removeHopByHopHeaders(headers) {
+    for (const name of Object.keys(headers)) {
+        if (HOP_BY_HOP_HEADERS.has(name.toLowerCase()))
+            delete headers[name];
+    }
+}
+/**
+ * Validate and stabilize a response before it reaches a transport adapter.
+ */
+export function normalizeResponse(response, method) {
+    const status = response.status;
+    validateStatus(status);
+    const headers = normalizeHeaders(response.headers ?? {});
+    const normalizedMethod = method.toUpperCase();
+    const body = normalizedMethod === "HEAD" || BODY_FORBIDDEN_STATUSES.has(status)
+        ? undefined
+        : normalizeBody(response.body);
+    // HEAD and 304 may keep an entity Content-Length (RFC 9110), but 204/205
+    // never carry one. Trailer and Transfer-Encoding are always removed —
+    // Node's writeHead rejects them on bodyless responses, killing the socket
+    // before any bytes reach the client.
+    if (status === 204 || status === 205) {
+        removeFramingHeaders(headers);
+    }
+    else {
+        removeFramingHeaders(headers, normalizedMethod === "HEAD" || status === 304);
+    }
+    // A hop-by-hop header belongs to the connection, which the transport owns:
+    // a route that emits `Connection: close` announces a close the server will
+    // not perform, and a conformant client then discards the next response on
+    // that socket. Adapters that genuinely mean it (an ingress rejection) add it
+    // after normalization, through their own extra-headers channel.
+    removeHopByHopHeaders(headers);
+    return {
+        status,
+        body,
+        headers,
+    };
+}
+/**
+ * Encode a response body using its normalized content type semantics.
+ */
+export function serializeResponseBody(response) {
+    const status = response.status;
+    validateStatus(status);
+    if (BODY_FORBIDDEN_STATUSES.has(status))
+        return undefined;
+    const body = response.body;
+    if (body === undefined)
+        return undefined;
+    if (isBinaryBody(body))
+        return copyBinaryBody(body);
+    // A string body is treated as pre-serialized wire bytes regardless of
+    // content type: quoting it under application/json would double-encode
+    // routes that return JSON.stringify(...) themselves.
+    const serialized = typeof body === "string" ? body : stringifyJsonBody(body);
+    return new TextEncoder().encode(serialized);
+}

package/dist/response-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-parser.d.ts","sourceRoot":"","sources":["../src/response-parser.ts"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,OAAO,CAAC,WAAW,GAC/B,OAAO,CAAC,QAAQ,CAmDlB"}
+{"version":3,"file":"response-parser.d.ts","sourceRoot":"","sources":["../src/response-parser.ts"],"names":[],"mappings":"AAwEA;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,OAAO,CAAC,WAAW,GAC/B,OAAO,CAAC,QAAQ,CAuElB"}