@markupai/api 0.1.1 → 0.2.0

package/dist/{core/auth/BasicAuth.js → esm/core/auth/BasicAuth.mjs}

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BasicAuth = void 0;
-const js_base64_1 = require("js-base64");
+import { base64Decode, base64Encode } from "../base64.mjs";
 const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
-exports.BasicAuth = {
+export const BasicAuth = {
     toAuthorizationHeader: (basicAuth) => {
         if (basicAuth == null) {
             return undefined;
         }
-        const token = js_base64_1.Base64.encode(`${basicAuth.username}:${basicAuth.password}`);
+        const token = base64Encode(`${basicAuth.username}:${basicAuth.password}`);
         return `Basic ${token}`;
     },
     fromAuthorizationHeader: (header) => {
         const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, "");
-        const decoded = js_base64_1.Base64.decode(credentials);
+        const decoded = base64Decode(credentials);
         const [username, password] = decoded.split(":", 2);
         if (username == null || password == null) {
             throw new Error("Invalid basic auth");

package/dist/{core/auth/BearerToken.js → esm/core/auth/BearerToken.mjs}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BearerToken = void 0;
 const BEARER_AUTH_HEADER_PREFIX = /^Bearer /i;
-exports.BearerToken = {
+export const BearerToken = {
     toAuthorizationHeader: (token) => {
         if (token == null) {
             return undefined;

package/dist/esm/core/auth/index.d.mts

@@ -0,0 +1,4 @@
+export { AuthProvider } from "./AuthProvider.mjs";
+export { type AuthRequest } from "./AuthRequest.mjs";
+export { BasicAuth } from "./BasicAuth.mjs";
+export { BearerToken } from "./BearerToken.mjs";

package/dist/esm/core/auth/index.mjs

@@ -0,0 +1,2 @@
+export { BasicAuth } from "./BasicAuth.mjs";
+export { BearerToken } from "./BearerToken.mjs";

package/dist/esm/core/base64.d.mts

@@ -0,0 +1,2 @@
+export declare function base64Encode(input: string): string;
+export declare function base64Decode(input: string): string;

package/dist/esm/core/base64.mjs

@@ -0,0 +1,22 @@
+function base64ToBytes(base64) {
+    const binString = atob(base64);
+    return Uint8Array.from(binString, (m) => m.codePointAt(0));
+}
+function bytesToBase64(bytes) {
+    const binString = String.fromCodePoint(...bytes);
+    return btoa(binString);
+}
+export function base64Encode(input) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(input, "utf8").toString("base64");
+    }
+    const bytes = new TextEncoder().encode(input);
+    return bytesToBase64(bytes);
+}
+export function base64Decode(input) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(input, "base64").toString("utf8");
+    }
+    const bytes = base64ToBytes(input);
+    return new TextDecoder().decode(bytes);
+}

package/dist/esm/core/exports.d.mts

@@ -0,0 +1 @@
+export * from "./file/exports.mjs";

package/dist/esm/core/exports.mjs

@@ -0,0 +1 @@
+export * from "./file/exports.mjs";

package/dist/{core/fetcher/APIResponse.d.ts → esm/core/fetcher/APIResponse.d.mts}

@@ -1,4 +1,4 @@
-import { RawResponse } from "./RawResponse";
+import { RawResponse } from "./RawResponse.mjs";
 /**
  * The response of an API call.
  * It is a successful response or a failed response.

package/dist/esm/core/fetcher/APIResponse.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/fetcher/BinaryResponse.d.mts

@@ -0,0 +1,20 @@
+import { ResponseWithBody } from "./ResponseWithBody.mjs";
+export type BinaryResponse = {
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bodyUsed) */
+    bodyUsed: boolean;
+    /**
+     * Returns a ReadableStream of the response body.
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/body)
+     */
+    stream: () => ReadableStream<Uint8Array>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/arrayBuffer) */
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/blob) */
+    blob: () => Promise<Blob>;
+    /**
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bytes)
+     * Some versions of the Fetch API may not support this method.
+     */
+    bytes?(): Promise<Uint8Array>;
+};
+export declare function getBinaryResponse(response: ResponseWithBody): BinaryResponse;

package/dist/esm/core/fetcher/BinaryResponse.mjs

@@ -0,0 +1,14 @@
+export function getBinaryResponse(response) {
+    const binaryResponse = {
+        get bodyUsed() {
+            return response.bodyUsed;
+        },
+        stream: () => response.body,
+        arrayBuffer: response.arrayBuffer.bind(response),
+        blob: response.blob.bind(response),
+    };
+    if ("bytes" in response && typeof response.bytes === "function") {
+        binaryResponse.bytes = response.bytes.bind(response);
+    }
+    return binaryResponse;
+}

package/{core/fetcher/Fetcher.d.ts → dist/esm/core/fetcher/Fetcher.d.mts}

@@ -1,19 +1,20 @@
-import { APIResponse } from "./APIResponse";
+import { APIResponse } from "./APIResponse.mjs";
+import { Supplier } from "./Supplier.mjs";
 export type FetchFunction = <R = unknown>(args: Fetcher.Args) => Promise<APIResponse<R, Fetcher.Error>>;
 export declare namespace Fetcher {
     interface Args {
         url: string;
         method: string;
         contentType?: string;
-        headers?: Record<string, string | undefined>;
-        queryParameters?: Record<string, string | string[] | object | object[] | null>;
+        headers?: Record<string, string | Supplier<string | null | undefined> | null | undefined>;
+        queryParameters?: Record<string, unknown>;
         body?: unknown;
         timeoutMs?: number;
         maxRetries?: number;
         withCredentials?: boolean;
         abortSignal?: AbortSignal;
         requestType?: "json" | "file" | "bytes";
-        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer";
+        responseType?: "json" | "blob" | "sse" | "streaming" | "text" | "arrayBuffer" | "binary-response";
         duplex?: "half";
     }
     type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;

package/dist/{core/fetcher/Fetcher.js → esm/core/fetcher/Fetcher.mjs}

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,47 +7,57 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetcher = void 0;
-exports.fetcherImpl = fetcherImpl;
-const json_1 = require("../json");
-const RawResponse_1 = require("./RawResponse");
-const createRequestUrl_1 = require("./createRequestUrl");
-const getFetchFn_1 = require("./getFetchFn");
-const getRequestBody_1 = require("./getRequestBody");
-const getResponseBody_1 = require("./getResponseBody");
-const makeRequest_1 = require("./makeRequest");
-const requestWithRetries_1 = require("./requestWithRetries");
-function fetcherImpl(args) {
+import { toJson } from "../json.mjs";
+import { createRequestUrl } from "./createRequestUrl.mjs";
+import { getErrorResponseBody } from "./getErrorResponseBody.mjs";
+import { getFetchFn } from "./getFetchFn.mjs";
+import { getRequestBody } from "./getRequestBody.mjs";
+import { getResponseBody } from "./getResponseBody.mjs";
+import { makeRequest } from "./makeRequest.mjs";
+import { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.mjs";
+import { requestWithRetries } from "./requestWithRetries.mjs";
+import { Supplier } from "./Supplier.mjs";
+function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
-        const headers = {};
+        const newHeaders = {};
         if (args.body !== undefined && args.contentType != null) {
-            headers["Content-Type"] = args.contentType;
+            newHeaders["Content-Type"] = args.contentType;
         }
-        if (args.headers != null) {
-            for (const [key, value] of Object.entries(args.headers)) {
-                if (value != null) {
-                    headers[key] = value;
-                }
+        if (args.headers == null) {
+            return newHeaders;
+        }
+        for (const [key, value] of Object.entries(args.headers)) {
+            const result = yield Supplier.get(value);
+            if (typeof result === "string") {
+                newHeaders[key] = result;
+                continue;
+            }
+            if (result == null) {
+                continue;
             }
+            newHeaders[key] = `${result}`;
         }
-        const url = (0, createRequestUrl_1.createRequestUrl)(args.url, args.queryParameters);
-        const requestBody = yield (0, getRequestBody_1.getRequestBody)({
+        return newHeaders;
+    });
+}
+export function fetcherImpl(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = createRequestUrl(args.url, args.queryParameters);
+        const requestBody = yield getRequestBody({
             body: args.body,
             type: args.requestType === "json" ? "json" : "other",
         });
-        const fetchFn = yield (0, getFetchFn_1.getFetchFn)();
+        const fetchFn = yield getFetchFn();
         try {
-            const response = yield (0, requestWithRetries_1.requestWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
-                return (0, makeRequest_1.makeRequest)(fetchFn, url, args.method, headers, requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
+            const response = yield requestWithRetries(() => __awaiter(this, void 0, void 0, function* () {
+                return makeRequest(fetchFn, url, args.method, yield getHeaders(args), requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
             }), args.maxRetries);
-            const responseBody = yield (0, getResponseBody_1.getResponseBody)(response, args.responseType);
             if (response.status >= 200 && response.status < 400) {
                 return {
                     ok: true,
-                    body: responseBody,
+                    body: (yield getResponseBody(response, args.responseType)),
                     headers: response.headers,
-                    rawResponse: (0, RawResponse_1.toRawResponse)(response),
+                    rawResponse: toRawResponse(response),
                 };
             }
             else {
@@ -57,9 +66,9 @@ function fetcherImpl(args) {
                     error: {
                         reason: "status-code",
                         statusCode: response.status,
-                        body: responseBody,
+                        body: yield getErrorResponseBody(response),
                     },
-                    rawResponse: (0, RawResponse_1.toRawResponse)(response),
+                    rawResponse: toRawResponse(response),
                 };
             }
         }
@@ -71,7 +80,7 @@ function fetcherImpl(args) {
                         reason: "unknown",
                         errorMessage: "The user aborted a request",
                     },
-                    rawResponse: RawResponse_1.abortRawResponse,
+                    rawResponse: abortRawResponse,
                 };
             }
             else if (error instanceof Error && error.name === "AbortError") {
@@ -80,7 +89,7 @@ function fetcherImpl(args) {
                     error: {
                         reason: "timeout",
                     },
-                    rawResponse: RawResponse_1.abortRawResponse,
+                    rawResponse: abortRawResponse,
                 };
             }
             else if (error instanceof Error) {
@@ -90,18 +99,18 @@ function fetcherImpl(args) {
                         reason: "unknown",
                         errorMessage: error.message,
                     },
-                    rawResponse: RawResponse_1.unknownRawResponse,
+                    rawResponse: unknownRawResponse,
                 };
             }
             return {
                 ok: false,
                 error: {
                     reason: "unknown",
-                    errorMessage: (0, json_1.toJson)(error),
+                    errorMessage: toJson(error),
                 },
-                rawResponse: RawResponse_1.unknownRawResponse,
+                rawResponse: unknownRawResponse,
             };
         }
     });
 }
-exports.fetcher = fetcherImpl;
+export const fetcher = fetcherImpl;

package/dist/{core/fetcher/Headers.js → esm/core/fetcher/Headers.mjs}

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Headers = void 0;
 let Headers;
 if (typeof globalThis.Headers !== "undefined") {
-    exports.Headers = Headers = globalThis.Headers;
+    Headers = globalThis.Headers;
 }
 else {
-    exports.Headers = Headers = class Headers {
+    Headers = class Headers {
         constructor(init) {
             this.headers = new Map();
             if (init) {
@@ -82,3 +79,4 @@ else {
         }
     };
 }
+export { Headers };

package/{core/fetcher/HttpResponsePromise.d.ts → dist/esm/core/fetcher/HttpResponsePromise.d.mts}

@@ -1,4 +1,4 @@
-import { WithRawResponse } from "./RawResponse";
+import { WithRawResponse } from "./RawResponse.mjs";
 /**
  * A promise that returns the parsed response and lets you retrieve the raw response too.
  */

package/dist/{core/fetcher/HttpResponsePromise.js → esm/core/fetcher/HttpResponsePromise.mjs}

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,12 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpResponsePromise = void 0;
 /**
  * A promise that returns the parsed response and lets you retrieve the raw response too.
  */
-class HttpResponsePromise extends Promise {
+export class HttpResponsePromise extends Promise {
     constructor(promise) {
         // Initialize with a no-op to avoid premature parsing
         super((resolve) => {
@@ -100,4 +97,3 @@ class HttpResponsePromise extends Promise {
         });
     }
 }
-exports.HttpResponsePromise = HttpResponsePromise;

package/dist/{core/fetcher/RawResponse.js → esm/core/fetcher/RawResponse.mjs}

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unknownRawResponse = exports.abortRawResponse = void 0;
-exports.toRawResponse = toRawResponse;
-const Headers_1 = require("./Headers");
+import { Headers } from "./Headers.mjs";
 /**
  * A raw response indicating that the request was aborted.
  */
-exports.abortRawResponse = {
-    headers: new Headers_1.Headers(),
+export const abortRawResponse = {
+    headers: new Headers(),
     redirected: false,
     status: 499,
     statusText: "Client Closed Request",
@@ -17,8 +13,8 @@ exports.abortRawResponse = {
 /**
  * A raw response indicating an unknown error.
  */
-exports.unknownRawResponse = {
-    headers: new Headers_1.Headers(),
+export const unknownRawResponse = {
+    headers: new Headers(),
     redirected: false,
     status: 0,
     statusText: "Unknown Error",
@@ -32,7 +28,7 @@ exports.unknownRawResponse = {
  * @param response - The `RawResponse` object to convert.
  * @returns A `RawResponse` object containing the extracted properties of the input response.
  */
-function toRawResponse(response) {
+export function toRawResponse(response) {
     return {
         headers: response.headers,
         redirected: response.redirected,

package/dist/esm/core/fetcher/ResponseWithBody.d.mts

@@ -0,0 +1,4 @@
+export type ResponseWithBody = Response & {
+    body: ReadableStream<Uint8Array>;
+};
+export declare function isResponseWithBody(response: Response): response is ResponseWithBody;

package/dist/esm/core/fetcher/ResponseWithBody.mjs

@@ -0,0 +1,3 @@
+export function isResponseWithBody(response) {
+    return response.body != null;
+}

package/dist/{core/fetcher/Supplier.js → esm/core/fetcher/Supplier.mjs}

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,9 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Supplier = void 0;
-exports.Supplier = {
+export const Supplier = {
     get: (supplier) => __awaiter(void 0, void 0, void 0, function* () {
         if (typeof supplier === "function") {
             return supplier();

package/dist/esm/core/fetcher/createRequestUrl.d.mts

@@ -0,0 +1 @@
+export declare function createRequestUrl(baseUrl: string, queryParameters?: Record<string, unknown>): string;

package/dist/esm/core/fetcher/createRequestUrl.mjs

@@ -0,0 +1,5 @@
+import { toQueryString } from "../url/qs.mjs";
+export function createRequestUrl(baseUrl, queryParameters) {
+    const queryString = toQueryString(queryParameters, { arrayFormat: "repeat" });
+    return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+}

package/dist/esm/core/fetcher/getErrorResponseBody.d.mts

@@ -0,0 +1 @@
+export declare function getErrorResponseBody(response: Response): Promise<unknown>;

package/dist/esm/core/fetcher/getErrorResponseBody.mjs

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { fromJson } from "../json.mjs";
+import { getResponseBody } from "./getResponseBody.mjs";
+export function getErrorResponseBody(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        let contentType = (_a = response.headers.get("Content-Type")) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (contentType == null || contentType.length === 0) {
+            return getResponseBody(response);
+        }
+        if (contentType.indexOf(";") !== -1) {
+            contentType = (_c = (_b = contentType.split(";")[0]) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : "";
+        }
+        switch (contentType) {
+            case "application/hal+json":
+            case "application/json":
+            case "application/ld+json":
+            case "application/problem+json":
+            case "application/vnd.api+json":
+            case "text/json":
+                const text = yield response.text();
+                return text.length > 0 ? fromJson(text) : undefined;
+            default:
+                if (contentType.startsWith("application/vnd.") && contentType.endsWith("+json")) {
+                    const text = yield response.text();
+                    return text.length > 0 ? fromJson(text) : undefined;
+                }
+                // Fallback to plain text if content type is not recognized
+                // Even if no body is present, the response will be an empty string
+                return yield response.text();
+        }
+    });
+}

package/dist/esm/core/fetcher/getFetchFn.d.mts

@@ -0,0 +1 @@
+export declare function getFetchFn(): Promise<typeof fetch>;

package/dist/esm/core/fetcher/getFetchFn.mjs

@@ -0,0 +1,14 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export function getFetchFn() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return fetch;
+    });
+}

package/dist/{core/fetcher/getHeader.js → esm/core/fetcher/getHeader.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHeader = getHeader;
-function getHeader(headers, header) {
+export function getHeader(headers, header) {
     for (const [headerKey, headerValue] of Object.entries(headers)) {
         if (headerKey.toLowerCase() === header.toLowerCase()) {
             return headerValue;

package/dist/{core/fetcher/getRequestBody.js → esm/core/fetcher/getRequestBody.mjs}

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,13 +7,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRequestBody = getRequestBody;
-const json_1 = require("../json");
-function getRequestBody(_a) {
+import { toJson } from "../json.mjs";
+export function getRequestBody(_a) {
     return __awaiter(this, arguments, void 0, function* ({ body, type }) {
         if (type.includes("json")) {
-            return (0, json_1.toJson)(body);
+            return toJson(body);
         }
         else {
             return body;

package/dist/esm/core/fetcher/getResponseBody.mjs

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getBinaryResponse } from "./BinaryResponse.mjs";
+import { isResponseWithBody } from "./ResponseWithBody.mjs";
+import { fromJson } from "../json.mjs";
+export function getResponseBody(response, responseType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!isResponseWithBody(response)) {
+            return undefined;
+        }
+        switch (responseType) {
+            case "binary-response":
+                return getBinaryResponse(response);
+            case "blob":
+                return yield response.blob();
+            case "arrayBuffer":
+                return yield response.arrayBuffer();
+            case "sse":
+                return response.body;
+            case "streaming":
+                return response.body;
+            case "text":
+                return yield response.text();
+        }
+        // if responseType is "json" or not specified, try to parse as JSON
+        const text = yield response.text();
+        if (text.length > 0) {
+            try {
+                let responseBody = fromJson(text);
+                return responseBody;
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "non-json",
+                        statusCode: response.status,
+                        rawBody: text,
+                    },
+                };
+            }
+        }
+        return undefined;
+    });
+}

package/dist/esm/core/fetcher/index.d.mts

@@ -0,0 +1,9 @@
+export type { APIResponse } from "./APIResponse.mjs";
+export type { BinaryResponse } from "./BinaryResponse.mjs";
+export type { Fetcher, FetchFunction } from "./Fetcher.mjs";
+export { fetcher } from "./Fetcher.mjs";
+export { getHeader } from "./getHeader.mjs";
+export { HttpResponsePromise } from "./HttpResponsePromise.mjs";
+export type { RawResponse, WithRawResponse } from "./RawResponse.mjs";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.mjs";
+export { Supplier } from "./Supplier.mjs";

package/dist/esm/core/fetcher/index.mjs

@@ -0,0 +1,5 @@
+export { fetcher } from "./Fetcher.mjs";
+export { getHeader } from "./getHeader.mjs";
+export { HttpResponsePromise } from "./HttpResponsePromise.mjs";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.mjs";
+export { Supplier } from "./Supplier.mjs";

package/{core/fetcher/makeRequest.js → dist/esm/core/fetcher/makeRequest.mjs}

@@ -1,4 +1,3 @@
-"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,15 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeRequest = void 0;
-const signals_1 = require("./signals");
-const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => __awaiter(void 0, void 0, void 0, function* () {
+import { anySignal, getTimeoutSignal } from "./signals.mjs";
+export const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => __awaiter(void 0, void 0, void 0, function* () {
     const signals = [];
     // Add timeout signal
     let timeoutAbortId = undefined;
     if (timeoutMs != null) {
-        const { signal, abortId } = (0, signals_1.getTimeoutSignal)(timeoutMs);
+        const { signal, abortId } = getTimeoutSignal(timeoutMs);
         timeoutAbortId = abortId;
         signals.push(signal);
     }
@@ -24,7 +21,7 @@ const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abor
     if (abortSignal != null) {
         signals.push(abortSignal);
     }
-    let newSignals = (0, signals_1.anySignal)(signals);
+    let newSignals = anySignal(signals);
     const response = yield fetchFn(url, {
         method: method,
         headers,
@@ -39,4 +36,3 @@ const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abor
     }
     return response;
 });
-exports.makeRequest = makeRequest;