@siteimprove/alfa-http 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,163 @@
+# @siteimprove/alfa-http
+
+## 0.89.3
+
+## 0.89.2
+
+### Patch Changes
+
+- **Changed:** Trying to fix a problem in generating provenance statements ([#1674](https://github.com/Siteimprove/alfa/pull/1674))
+
+## 0.89.1
+
+### Patch Changes
+
+- **Added:** Trying to publish Alfa packages on the npm registry ([#1673](https://github.com/Siteimprove/alfa/pull/1673))
+
+## 0.89.0
+
+## 0.88.0
+
+### Minor Changes
+
+- **Fixed:** The publish flow was updated to a new version. ([`a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2`](https://github.com/Siteimprove/alfa/commit/a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2))
+
+  Some 0.87.\* versions were generating uninstallable package. This should be fixed now.
+
+## 0.87.12
+
+## 0.87.11
+
+## 0.87.10
+
+## 0.87.7
+
+## 0.87.6
+
+## 0.87.5
+
+## 0.87.4
+
+## 0.87.3
+
+## 0.87.2
+
+## 0.87.1
+
+## 0.87.0
+
+## 0.86.2
+
+## 0.86.1
+
+## 0.86.0
+
+### Minor Changes
+
+- **Breaking:** TS resolution has been changed to `Node16`, target to `es2022`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+- **Breaking:** Alfa is now distributed as ESM rather than CJS modules; projects using it must be ESM or use dynamic `import()`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+  ⚠️ This is the last of a series of changes on the internal structure and build process of distributed packages that was started with v0.85.0.
+
+## 0.85.1
+
+## 0.85.0
+
+### Minor Changes
+
+- **Breaking:** The .js files are now built in the `dist` folder rather than in `src`. ([#1628](https://github.com/Siteimprove/alfa/pull/1628))
+
+  ⚠️ This is the first of a series of changes on the internal structure and build process of distributed packages. It is probably better to not use this version and wait until more of these internal changes have been done to jump directly to the final result. We are internally releasing these changes for validation purpose only.
+
+  This should not impact consumers, the `package.json` files should be set correctly to consume these files.
+
+## 0.84.0
+
+## 0.83.1
+
+## 0.83.0
+
+## 0.82.0
+
+### Minor Changes
+
+- **Added:** Serialization options are now accepted, and passed on, by `toJSON()` on these types. ([#1622](https://github.com/Siteimprove/alfa/pull/1622))
+
+- **Breaking:** Node 18 is no longer supported. ([#1618](https://github.com/Siteimprove/alfa/pull/1618))
+
+## 0.81.0
+
+### Patch Changes
+
+- **Added:** Each package now contains its internal dependency graph in its `docs` directory. ([#1610](https://github.com/Siteimprove/alfa/pull/1610))
+
+## 0.80.0
+
+## 0.79.1
+
+## 0.79.0
+
+## 0.78.2
+
+## 0.78.1
+
+## 0.78.0
+
+## 0.77.0
+
+## 0.76.0
+
+## 0.75.2
+
+## 0.75.1
+
+## 0.75.0
+
+## 0.74.0
+
+## 0.73.0
+
+## 0.72.0
+
+## 0.71.1
+
+## 0.71.0
+
+## 0.70.0
+
+## 0.69.0
+
+## 0.68.0
+
+## 0.67.0
+
+## 0.66.0
+
+## 0.65.1
+
+## 0.65.0
+
+### Minor Changes
+
+- **Removed:** Many pieces of code are no longer exported. These were mostly internal exports that are no longer used in other files and should not impact intended usage of the packages. ([#1437](https://github.com/Siteimprove/alfa/pull/1437))
+
+## 0.64.0
+
+## 0.63.3
+
+## 0.63.2
+
+## 0.63.1
+
+### Patch Changes
+
+- **Fixed:** Added missing dependencies ([#1418](https://github.com/Siteimprove/alfa/pull/1418))
+
+  Some internal dependencies were missing, causing build failure in projects that use PnP strategies.
+
+## 0.63.0
+
+## 0.62.2
+
+## 0.62.1

package/dist/body.d.ts

@@ -0,0 +1,27 @@
+import type * as earl from "@siteimprove/alfa-earl";
+/**
+ * {@link https://fetch.spec.whatwg.org/#body-mixin}
+ *
+ * @public
+ */
+export interface Body {
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-body-body}
+     */
+    readonly body: ArrayBuffer;
+}
+/**
+ * @public
+ */
+export declare namespace Body {
+    interface EARL extends earl.EARL {
+        "@context": {
+            cnt: "http://www.w3.org/2011/content#";
+        };
+        "@type": ["cnt:Content", "cnt:ContentAsText"];
+        "cnt:characterEncoding": "utf-8";
+        "cnt:chars": string;
+    }
+    function isBody(value: unknown): value is Body;
+}
+//# sourceMappingURL=body.d.ts.map

package/dist/body.js

@@ -0,0 +1,13 @@
+import { Refinement } from "@siteimprove/alfa-refinement";
+const { isObject } = Refinement;
+/**
+ * @public
+ */
+export var Body;
+(function (Body) {
+    function isBody(value) {
+        return isObject(value) && value.body instanceof ArrayBuffer;
+    }
+    Body.isBody = isBody;
+})(Body || (Body = {}));
+//# sourceMappingURL=body.js.map

package/dist/cookie.d.ts

@@ -0,0 +1,31 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import type { Serializable } from "@siteimprove/alfa-json";
+import type * as json from "@siteimprove/alfa-json";
+/**
+ * @public
+ */
+export declare class Cookie implements Equatable, Serializable<Cookie.JSON> {
+    static of(name: string, value: string): Cookie;
+    private readonly _name;
+    private readonly _value;
+    private constructor();
+    get name(): string;
+    get value(): string;
+    equals(value: Cookie): boolean;
+    equals(value: unknown): value is this;
+    toJSON(): Cookie.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Cookie {
+    interface JSON {
+        [key: string]: json.JSON;
+        name: string;
+        value: string;
+    }
+    function from(json: JSON): Cookie;
+    function isCookie(value: unknown): value is Cookie;
+}
+//# sourceMappingURL=cookie.d.ts.map

package/dist/cookie.js

@@ -0,0 +1,48 @@
+/**
+ * @public
+ */
+export class Cookie {
+    static of(name, value) {
+        return new Cookie(name, value);
+    }
+    _name;
+    _value;
+    constructor(name, value) {
+        this._name = name;
+        this._value = value;
+    }
+    get name() {
+        return this._name;
+    }
+    get value() {
+        return this._value;
+    }
+    equals(value) {
+        return (value instanceof Cookie &&
+            value._name === this._name &&
+            value._value === this._value);
+    }
+    toJSON() {
+        return {
+            name: this._name,
+            value: this._value,
+        };
+    }
+    toString() {
+        return `${this._name}=${this._value}`;
+    }
+}
+/**
+ * @public
+ */
+(function (Cookie) {
+    function from(json) {
+        return Cookie.of(json.name, json.value);
+    }
+    Cookie.from = from;
+    function isCookie(value) {
+        return value instanceof Cookie;
+    }
+    Cookie.isCookie = isCookie;
+})(Cookie || (Cookie = {}));
+//# sourceMappingURL=cookie.js.map

package/dist/cookies.d.ts

@@ -0,0 +1,37 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import type { Serializable } from "@siteimprove/alfa-json";
+import type { Option } from "@siteimprove/alfa-option";
+import { Cookie } from "./cookie.js";
+/**
+ * @public
+ */
+export declare class Cookies implements Iterable<Cookie>, Serializable<Cookies.JSON> {
+    /**
+     * @remarks
+     * If the iterable contains cookies with duplicate names, the last cookie with
+     * a given name will take precedence.
+     */
+    static of(cookies: Iterable<Cookie>): Cookies;
+    private static _empty;
+    static empty(): Cookies;
+    private readonly _cookies;
+    private constructor();
+    get(name: string): Option<Cookie>;
+    has(name: string): boolean;
+    add(cookie: Cookie): Cookies;
+    delete(name: string): Cookies;
+    [Symbol.iterator](): Iterator<Cookie>;
+    toArray(): Array<Cookie>;
+    toJSON(): Cookies.JSON;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Cookies {
+    interface JSON extends Array<Cookie.JSON> {
+    }
+    function from(json: JSON): Cookies;
+    function isCookies(value: unknown): value is Cookies;
+}
+//# sourceMappingURL=cookies.d.ts.map

package/dist/cookies.js

@@ -0,0 +1,64 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Map } from "@siteimprove/alfa-map";
+import { Cookie } from "./cookie.js";
+/**
+ * @public
+ */
+export class Cookies {
+    /**
+     * @remarks
+     * If the iterable contains cookies with duplicate names, the last cookie with
+     * a given name will take precedence.
+     */
+    static of(cookies) {
+        return new Cookies(Map.from(Iterable.map(cookies, (cookie) => [cookie.name, cookie])));
+    }
+    static _empty = new Cookies(Map.empty());
+    static empty() {
+        return this._empty;
+    }
+    _cookies;
+    constructor(cookies) {
+        this._cookies = cookies;
+    }
+    get(name) {
+        return this._cookies.get(name);
+    }
+    has(name) {
+        return this._cookies.has(name);
+    }
+    add(cookie) {
+        return new Cookies(this._cookies.set(cookie.name, cookie));
+    }
+    delete(name) {
+        return new Cookies(this._cookies.delete(name));
+    }
+    *[Symbol.iterator]() {
+        yield* this._cookies.values();
+    }
+    toArray() {
+        return [...this];
+    }
+    toJSON() {
+        return this.toArray().map((cookie) => cookie.toJSON());
+    }
+    toString() {
+        return this.toArray()
+            .map((cookie) => cookie.toString())
+            .join("; ");
+    }
+}
+/**
+ * @public
+ */
+(function (Cookies) {
+    function from(json) {
+        return Cookies.of(json.map((cookie) => Cookie.from(cookie)));
+    }
+    Cookies.from = from;
+    function isCookies(value) {
+        return value instanceof Cookies;
+    }
+    Cookies.isCookies = isCookies;
+})(Cookies || (Cookies = {}));
+//# sourceMappingURL=cookies.js.map

package/dist/header.d.ts

@@ -0,0 +1,40 @@
+import type { Equatable } from "@siteimprove/alfa-equatable";
+import type * as earl from "@siteimprove/alfa-earl";
+import type * as json from "@siteimprove/alfa-json";
+/**
+ * @public
+ */
+export declare class Header implements Equatable, json.Serializable<Header.JSON>, earl.Serializable<Header.EARL> {
+    static of(name: string, value: string): Header;
+    private readonly _name;
+    private readonly _value;
+    private constructor();
+    get name(): string;
+    get value(): string;
+    equals(value: Header): boolean;
+    equals(value: unknown): value is this;
+    toJSON(options?: json.Serializable.Options): Header.JSON;
+    toEARL(): Header.EARL;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Header {
+    interface JSON {
+        [key: string]: json.JSON;
+        name: string;
+        value: string;
+    }
+    interface EARL extends earl.EARL {
+        "@context": {
+            http: "http://www.w3.org/2011/http#";
+        };
+        "@type": "http:MessageHeader";
+        "http:fieldName": string;
+        "http:fieldValue": string;
+    }
+    function from(json: JSON): Header;
+    function isHeader(value: unknown): value is Header;
+}
+//# sourceMappingURL=header.d.ts.map

package/dist/header.js

@@ -0,0 +1,58 @@
+/**
+ * @public
+ */
+export class Header {
+    static of(name, value) {
+        return new Header(name, value);
+    }
+    _name;
+    _value;
+    constructor(name, value) {
+        this._name = name;
+        this._value = value;
+    }
+    get name() {
+        return this._name;
+    }
+    get value() {
+        return this._value;
+    }
+    equals(value) {
+        return (value instanceof Header &&
+            value._name === this._name &&
+            value._value === this._value);
+    }
+    toJSON(options) {
+        return {
+            name: this._name,
+            value: this._value,
+        };
+    }
+    toEARL() {
+        return {
+            "@context": {
+                http: "http://www.w3.org/2011/http#",
+            },
+            "@type": "http:MessageHeader",
+            "http:fieldName": this._name,
+            "http:fieldValue": this._value,
+        };
+    }
+    toString() {
+        return `${this._name}: ${this._value}`;
+    }
+}
+/**
+ * @public
+ */
+(function (Header) {
+    function from(json) {
+        return Header.of(json.name, json.value);
+    }
+    Header.from = from;
+    function isHeader(value) {
+        return value instanceof Header;
+    }
+    Header.isHeader = isHeader;
+})(Header || (Header = {}));
+//# sourceMappingURL=header.js.map

package/dist/headers.d.ts

@@ -0,0 +1,45 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import type { Option } from "@siteimprove/alfa-option";
+import type * as earl from "@siteimprove/alfa-earl";
+import type * as json from "@siteimprove/alfa-json";
+import { Header } from "./header.js";
+/**
+ * @public
+ */
+export declare class Headers implements Iterable<Header>, json.Serializable<Headers.JSON>, earl.Serializable<Headers.EARL> {
+    /**
+     * @remarks
+     * If the iterable contains headers with duplicate names, the last header with
+     * a given name will take precedence.
+     */
+    static of(headers: Iterable<Header>): Headers;
+    private static _empty;
+    static empty(): Headers;
+    private readonly _headers;
+    private constructor();
+    get(name: string): Option<Header>;
+    has(name: string): boolean;
+    add(header: Header): Headers;
+    delete(name: string): Headers;
+    [Symbol.iterator](): Iterator<Header>;
+    toArray(): Array<Header>;
+    toJSON(options?: json.Serializable.Options): Headers.JSON;
+    toEARL(): Headers.EARL;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Headers {
+    interface JSON extends Array<Header.JSON> {
+    }
+    interface EARL extends earl.EARL {
+        "@context": {
+            http: "http://www.w3.org/2011/http#";
+        };
+        "@list": Array<Header.EARL>;
+    }
+    function from(json: JSON): Headers;
+    function isHeaders(value: unknown): value is Headers;
+}
+//# sourceMappingURL=headers.d.ts.map

package/dist/headers.js

@@ -0,0 +1,72 @@
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Map } from "@siteimprove/alfa-map";
+import { Header } from "./header.js";
+/**
+ * @public
+ */
+export class Headers {
+    /**
+     * @remarks
+     * If the iterable contains headers with duplicate names, the last header with
+     * a given name will take precedence.
+     */
+    static of(headers) {
+        return new Headers(Map.from(Iterable.map(headers, (header) => [header.name, header])));
+    }
+    static _empty = new Headers(Map.empty());
+    static empty() {
+        return this._empty;
+    }
+    _headers;
+    constructor(headers) {
+        this._headers = headers;
+    }
+    get(name) {
+        return this._headers.get(name);
+    }
+    has(name) {
+        return this._headers.has(name);
+    }
+    add(header) {
+        return new Headers(this._headers.set(header.name, header));
+    }
+    delete(name) {
+        return new Headers(this._headers.delete(name));
+    }
+    *[Symbol.iterator]() {
+        yield* this._headers.values();
+    }
+    toArray() {
+        return [...this];
+    }
+    toJSON(options) {
+        return this.toArray().map((header) => header.toJSON(options));
+    }
+    toEARL() {
+        return {
+            "@context": {
+                http: "http://www.w3.org/2011/http#",
+            },
+            "@list": this.toArray().map((header) => header.toEARL()),
+        };
+    }
+    toString() {
+        return this.toArray()
+            .map((header) => header.toString())
+            .join("\n");
+    }
+}
+/**
+ * @public
+ */
+(function (Headers) {
+    function from(json) {
+        return Headers.of(json.map((header) => Header.from(header)));
+    }
+    Headers.from = from;
+    function isHeaders(value) {
+        return value instanceof Headers;
+    }
+    Headers.isHeaders = isHeaders;
+})(Headers || (Headers = {}));
+//# sourceMappingURL=headers.js.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./body.js";
+export * from "./cookie.js";
+export * from "./cookies.js";
+export * from "./header.js";
+export * from "./headers.js";
+export * from "./request.js";
+export * from "./response.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./body.js";
+export * from "./cookie.js";
+export * from "./cookies.js";
+export * from "./header.js";
+export * from "./headers.js";
+export * from "./request.js";
+export * from "./response.js";
+//# sourceMappingURL=index.js.map

package/dist/request.d.ts

@@ -0,0 +1,65 @@
+import { URL } from "@siteimprove/alfa-url";
+import type * as earl from "@siteimprove/alfa-earl";
+import type * as json from "@siteimprove/alfa-json";
+import type { Result } from "@siteimprove/alfa-result";
+import type { Body } from "./body.js";
+import { Headers } from "./headers.js";
+/**
+ * {@link https://fetch.spec.whatwg.org/#request-class}
+ *
+ * @public
+ */
+export declare class Request implements Body, json.Serializable<Request.JSON>, earl.Serializable<Request.EARL> {
+    static of(method: string, url: URL, headers?: Headers, body?: ArrayBuffer): Request;
+    private static _empty;
+    static empty(): Request;
+    private readonly _method;
+    private readonly _url;
+    private readonly _headers;
+    private readonly _body;
+    private constructor();
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-request-method}
+     */
+    get method(): string;
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-request-url}
+     */
+    get url(): URL;
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-request-headers}
+     */
+    get headers(): Headers;
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-body-body}
+     */
+    get body(): ArrayBuffer;
+    toJSON(options?: json.Serializable.Options): Request.JSON;
+    toEARL(): Request.EARL;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Request {
+    interface JSON {
+        [key: string]: json.JSON;
+        method: string;
+        url: string;
+        headers: Headers.JSON;
+        body: string;
+    }
+    interface EARL extends earl.EARL {
+        "@context": {
+            http: "http://www.w3.org/2011/http#";
+        };
+        "@type": ["http:Message", "http:Request"];
+        "http:methodName": string;
+        "http:requestURI": string;
+        "http:headers": Headers.EARL;
+        "http:body": Body.EARL;
+    }
+    function from(json: JSON): Result<Request, string>;
+    function isRequest(value: unknown): value is Request;
+}
+//# sourceMappingURL=request.d.ts.map

package/dist/request.js

@@ -0,0 +1,99 @@
+import { Decoder, Encoder } from "@siteimprove/alfa-encoding";
+import { URL } from "@siteimprove/alfa-url";
+import { Headers } from "./headers.js";
+/**
+ * {@link https://fetch.spec.whatwg.org/#request-class}
+ *
+ * @public
+ */
+export class Request {
+    static of(method, url, headers = Headers.empty(), body = new ArrayBuffer(0)) {
+        return new Request(method, url, headers, body);
+    }
+    static _empty = Request.of("GET", URL.blank());
+    static empty() {
+        return this._empty;
+    }
+    _method;
+    _url;
+    _headers;
+    _body;
+    constructor(method, url, headers, body) {
+        this._method = method;
+        this._url = url;
+        this._headers = headers;
+        this._body = body;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-request-method}
+     */
+    get method() {
+        return this._method;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-request-url}
+     */
+    get url() {
+        return this._url;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-request-headers}
+     */
+    get headers() {
+        return this._headers;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-body-body}
+     */
+    get body() {
+        return this._body;
+    }
+    toJSON(options) {
+        return {
+            method: this._method,
+            url: this._url.toString(),
+            headers: this._headers.toJSON(options),
+            body: Decoder.decode(new Uint8Array(this._body)),
+        };
+    }
+    toEARL() {
+        return {
+            "@context": {
+                http: "http://www.w3.org/2011/http#",
+            },
+            "@type": ["http:Message", "http:Request"],
+            "http:methodName": this._method,
+            "http:requestURI": this._url.toString(),
+            "http:headers": this._headers.toEARL(),
+            "http:body": {
+                "@context": {
+                    cnt: "http://www.w3.org/2011/content#",
+                },
+                "@type": ["cnt:Content", "cnt:ContentAsText"],
+                "cnt:characterEncoding": "utf-8",
+                "cnt:chars": Decoder.decode(new Uint8Array(this._body)),
+            },
+        };
+    }
+    toString() {
+        let request = `${this._method} ${this._url} HTTP/1.1`;
+        request += "\n" + this._headers.toString();
+        request += "\n";
+        request += Decoder.decode(new Uint8Array(this._body));
+        return request;
+    }
+}
+/**
+ * @public
+ */
+(function (Request) {
+    function from(json) {
+        return URL.parse(json.url).map((url) => Request.of(json.method, url, Headers.from(json.headers), Encoder.encode(json.body)));
+    }
+    Request.from = from;
+    function isRequest(value) {
+        return value instanceof Request;
+    }
+    Request.isRequest = isRequest;
+})(Request || (Request = {}));
+//# sourceMappingURL=request.js.map

package/dist/response.d.ts

@@ -0,0 +1,64 @@
+import { URL } from "@siteimprove/alfa-url";
+import type * as earl from "@siteimprove/alfa-earl";
+import type * as json from "@siteimprove/alfa-json";
+import type { Result } from "@siteimprove/alfa-result";
+import type { Body } from "./body.js";
+import { Headers } from "./headers.js";
+/**
+ * {@link https://fetch.spec.whatwg.org/#response-class}
+ *
+ * @public
+ */
+export declare class Response implements Body, json.Serializable<Response.JSON>, earl.Serializable<Response.EARL> {
+    static of(url: URL, status: number, headers?: Headers, body?: ArrayBuffer): Response;
+    private static _empty;
+    static empty(): Response;
+    private readonly _url;
+    private readonly _status;
+    private readonly _headers;
+    private readonly _body;
+    private constructor();
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-response-url}
+     */
+    get url(): URL;
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-response-status}
+     */
+    get status(): number;
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-response-headers}
+     */
+    get headers(): Headers;
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-body-body}
+     */
+    get body(): ArrayBuffer;
+    toJSON(options?: json.Serializable.Options): Response.JSON;
+    toEARL(): Response.EARL;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Response {
+    interface JSON {
+        [key: string]: json.JSON;
+        url: string;
+        status: number;
+        headers: Headers.JSON;
+        body: string;
+    }
+    interface EARL extends earl.EARL {
+        "@context": {
+            http: "http://www.w3.org/2011/http#";
+        };
+        "@type": ["http:Message", "http:Response"];
+        "http:statusCodeValue": number;
+        "http:headers": Headers.EARL;
+        "http:body": Body.EARL;
+    }
+    function from(json: JSON): Result<Response, string>;
+    function isResponse(value: unknown): value is Response;
+}
+//# sourceMappingURL=response.d.ts.map

package/dist/response.js

@@ -0,0 +1,98 @@
+import { Decoder, Encoder } from "@siteimprove/alfa-encoding";
+import { URL } from "@siteimprove/alfa-url";
+import { Headers } from "./headers.js";
+/**
+ * {@link https://fetch.spec.whatwg.org/#response-class}
+ *
+ * @public
+ */
+export class Response {
+    static of(url, status, headers = Headers.empty(), body = new ArrayBuffer(0)) {
+        return new Response(url, status, headers, body);
+    }
+    static _empty = Response.of(URL.blank(), 200);
+    static empty() {
+        return this._empty;
+    }
+    _url;
+    _status;
+    _headers;
+    _body;
+    constructor(url, status, headers, body) {
+        this._url = url;
+        this._status = status;
+        this._headers = headers;
+        this._body = body;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-response-url}
+     */
+    get url() {
+        return this._url;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-response-status}
+     */
+    get status() {
+        return this._status;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-response-headers}
+     */
+    get headers() {
+        return this._headers;
+    }
+    /**
+     * {@link https://fetch.spec.whatwg.org/#dom-body-body}
+     */
+    get body() {
+        return this._body;
+    }
+    toJSON(options) {
+        return {
+            url: this._url.toString(),
+            status: this._status,
+            headers: this._headers.toJSON(options),
+            body: Decoder.decode(new Uint8Array(this._body)),
+        };
+    }
+    toEARL() {
+        return {
+            "@context": {
+                http: "http://www.w3.org/2011/http#",
+            },
+            "@type": ["http:Message", "http:Response"],
+            "http:statusCodeValue": this._status,
+            "http:headers": this._headers.toEARL(),
+            "http:body": {
+                "@context": {
+                    cnt: "http://www.w3.org/2011/content#",
+                },
+                "@type": ["cnt:Content", "cnt:ContentAsText"],
+                "cnt:characterEncoding": "utf-8",
+                "cnt:chars": Decoder.decode(new Uint8Array(this._body)),
+            },
+        };
+    }
+    toString() {
+        let response = `HTTP/1.1 ${this._status}`;
+        response += "\n" + this._headers.toString();
+        response += "\n";
+        response += Decoder.decode(new Uint8Array(this._body));
+        return response;
+    }
+}
+/**
+ * @public
+ */
+(function (Response) {
+    function from(json) {
+        return URL.parse(json.url).map((url) => Response.of(url, json.status, Headers.from(json.headers), Encoder.encode(json.body)));
+    }
+    Response.from = from;
+    function isResponse(value) {
+        return value instanceof Response;
+    }
+    Response.isResponse = isResponse;
+})(Response || (Response = {}));
+//# sourceMappingURL=response.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-http",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "Types for modelling HTTP primitives",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-http"
+  },
+  "bugs": "https://github.com/siteimprove/alfa/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@siteimprove/alfa-earl": "^0.89.5",
+    "@siteimprove/alfa-encoding": "^0.89.5",
+    "@siteimprove/alfa-equatable": "^0.89.5",
+    "@siteimprove/alfa-iterable": "^0.89.5",
+    "@siteimprove/alfa-json": "^0.89.5",
+    "@siteimprove/alfa-map": "^0.89.5",
+    "@siteimprove/alfa-option": "^0.89.5",
+    "@siteimprove/alfa-refinement": "^0.89.5",
+    "@siteimprove/alfa-result": "^0.89.5",
+    "@siteimprove/alfa-url": "^0.89.5"
+  },
+  "devDependencies": {
+    "@siteimprove/alfa-test": "^0.89.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}