@cloudflare/pages-shared 0.0.0-ship-js

package/dist/asset-server/handler.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQualityWeightedList = exports.generateHandler = exports.normaliseHeaders = exports.ANALYTICS_VERSION = exports.HEADERS_VERSION_V1 = exports.HEADERS_VERSION = exports.REDIRECTS_VERSION = exports.CACHE_CONTROL_BROWSER = exports.ASSET_PRESERVATION_CACHE = void 0;
+const responses_1 = require("./responses");
+const rulesEngine_1 = require("./rulesEngine");
+// Before serving a 404, we check the cache to see if we've served this asset recently
+// and if so, serve it from the cache instead of responding with a 404.
+// This gives a bit of a grace period between deployments for any clients browsing the old deployment.
+exports.ASSET_PRESERVATION_CACHE = "assetPreservationCache";
+const CACHE_CONTROL_PRESERVATION = "public, s-maxage=604800"; // 1 week
+exports.CACHE_CONTROL_BROWSER = "public, max-age=0, must-revalidate"; // have the browser check in with the server to make sure its local cache is valid before using it
+exports.REDIRECTS_VERSION = 1;
+exports.HEADERS_VERSION = 2;
+exports.HEADERS_VERSION_V1 = 1;
+exports.ANALYTICS_VERSION = 1;
+// In rolling this out, we're taking a conservative approach to only generate these Link headers from <link> elements that have these attributes.
+// We'll ignore any <link> elements that contain other attributes (e.g. `fetchpriority`, `crossorigin` or `data-please-dont-generate-a-header`).
+// We're not confident in browser support for all of these additional attributes, so we'll wait until we have that information before proceeding further.
+const ALLOWED_EARLY_HINT_LINK_ATTRIBUTES = ["rel", "as", "href"];
+// Takes metadata headers and "normalise" them
+// to the latest version
+function normaliseHeaders(headers) {
+    if (headers.version === exports.HEADERS_VERSION) {
+        return headers.rules;
+    }
+    else if (headers.version === exports.HEADERS_VERSION_V1) {
+        return Object.keys(headers.rules).reduce((acc, key) => {
+            acc[key] = {
+                set: headers.rules[key],
+            };
+            return acc;
+        }, {});
+    }
+    else {
+        return {};
+    }
+}
+exports.normaliseHeaders = normaliseHeaders;
+async function generateHandler({ request, metadata, xServerEnvHeader, logError, findAssetEntryForPath, getAssetKey, negotiateContent, fetchAsset, generateNotFoundResponse = async (notFoundRequest, notFoundFindAssetEntryForPath, notFoundServeAsset) => {
+    let assetEntry;
+    // No custom 404 page, so try serving as a single-page app
+    if ((assetEntry = await notFoundFindAssetEntryForPath("/index.html"))) {
+        return notFoundServeAsset(assetEntry, { preserve: false });
+    }
+    return new responses_1.NotFoundResponse();
+}, attachAdditionalHeaders = () => { }, caches, waitUntil, }) {
+    const url = new URL(request.url);
+    const { protocol, host, search } = url;
+    let { pathname } = url;
+    const earlyHintsCache = metadata.deploymentId
+        ? await caches?.open(`eh:${metadata.deploymentId}`)
+        : undefined;
+    const headerRules = metadata.headers
+        ? normaliseHeaders(metadata.headers)
+        : {};
+    const staticRules = metadata.redirects?.version === exports.REDIRECTS_VERSION
+        ? metadata.redirects.staticRules || {}
+        : {};
+    const staticRedirectsMatcher = () => {
+        const withHostMatch = staticRules[`https://${host}${pathname}`];
+        const withoutHostMatch = staticRules[pathname];
+        if (withHostMatch && withoutHostMatch) {
+            if (withHostMatch.lineNumber < withoutHostMatch.lineNumber) {
+                return withHostMatch;
+            }
+            else {
+                return withoutHostMatch;
+            }
+        }
+        return withHostMatch || withoutHostMatch;
+    };
+    const generateRedirectsMatcher = () => (0, rulesEngine_1.generateRulesMatcher)(metadata.redirects?.version === exports.REDIRECTS_VERSION
+        ? metadata.redirects.rules
+        : {}, ({ status, to }, replacements) => ({
+        status,
+        to: (0, rulesEngine_1.replacer)(to, replacements),
+    }));
+    let assetEntry;
+    async function generateResponse() {
+        const match = staticRedirectsMatcher() || generateRedirectsMatcher()({ request })[0];
+        if (match) {
+            const { status, to } = match;
+            const destination = new URL(to, request.url);
+            const location = destination.origin === new URL(request.url).origin
+                ? `${destination.pathname}${destination.search || search}${destination.hash}`
+                : `${destination.href}${destination.search ? "" : search}${destination.hash}`;
+            switch (status) {
+                case 301:
+                    return new responses_1.MovedPermanentlyResponse(location, undefined, {
+                        preventLeadingDoubleSlash: false,
+                    });
+                case 303:
+                    return new responses_1.SeeOtherResponse(location, undefined, {
+                        preventLeadingDoubleSlash: false,
+                    });
+                case 307:
+                    return new responses_1.TemporaryRedirectResponse(location, undefined, {
+                        preventLeadingDoubleSlash: false,
+                    });
+                case 308:
+                    return new responses_1.PermanentRedirectResponse(location, undefined, {
+                        preventLeadingDoubleSlash: false,
+                    });
+                case 302:
+                default:
+                    return new responses_1.FoundResponse(location, undefined, {
+                        preventLeadingDoubleSlash: false,
+                    });
+            }
+        }
+        if (!request.method.match(/^(get|head)$/i)) {
+            return new responses_1.MethodNotAllowedResponse();
+        }
+        try {
+            pathname = globalThis.decodeURIComponent(pathname);
+        }
+        catch (err) { }
+        if (pathname.endsWith("/")) {
+            if ((assetEntry = await findAssetEntryForPath(`${pathname}index.html`))) {
+                return serveAsset(assetEntry);
+            }
+            else if (pathname.endsWith("/index/")) {
+                return new responses_1.PermanentRedirectResponse(`/${pathname.slice(1, -"index/".length)}${search}`);
+            }
+            else if ((assetEntry = await findAssetEntryForPath(`${pathname.replace(/\/$/, ".html")}`))) {
+                return new responses_1.PermanentRedirectResponse(`/${pathname.slice(1, -1)}${search}`);
+            }
+            else {
+                return notFound();
+            }
+        }
+        if ((assetEntry = await findAssetEntryForPath(pathname))) {
+            if (pathname.endsWith(".html")) {
+                const extensionlessPath = pathname.slice(0, -".html".length);
+                // Don't redirect to an extensionless URL if another asset exists there
+                // or if pathname is /.html
+                // FIXME: this doesn't handle files in directories ie: /foobar/.html
+                if (extensionlessPath.endsWith("/index")) {
+                    return new responses_1.PermanentRedirectResponse(`${extensionlessPath.replace(/\/index$/, "/")}${search}`);
+                }
+                else if ((await findAssetEntryForPath(extensionlessPath)) ||
+                    extensionlessPath === "/") {
+                    return serveAsset(assetEntry);
+                }
+                else {
+                    return new responses_1.PermanentRedirectResponse(`${extensionlessPath}${search}`);
+                }
+            }
+            else {
+                return serveAsset(assetEntry);
+            }
+        }
+        else if (pathname.endsWith("/index")) {
+            return new responses_1.PermanentRedirectResponse(`/${pathname.slice(1, -"index".length)}${search}`);
+        }
+        else if ((assetEntry = await findAssetEntryForPath(`${pathname}.html`))) {
+            return serveAsset(assetEntry);
+        }
+        else if (hasFileExtension(pathname)) {
+            return notFound();
+        }
+        if ((assetEntry = await findAssetEntryForPath(`${pathname}/index.html`))) {
+            return new responses_1.PermanentRedirectResponse(`${pathname}/${search}`);
+        }
+        else {
+            return notFound();
+        }
+    }
+    async function attachHeaders(response) {
+        const existingHeaders = new Headers(response.headers);
+        const extraHeaders = new Headers({
+            "access-control-allow-origin": "*",
+            "referrer-policy": "strict-origin-when-cross-origin",
+            ...(existingHeaders.has("content-type")
+                ? { "x-content-type-options": "nosniff" }
+                : {}),
+        });
+        const headers = new Headers({
+            // But we intentionally override existing headers
+            ...Object.fromEntries(existingHeaders.entries()),
+            ...Object.fromEntries(extraHeaders.entries()),
+        });
+        if (earlyHintsCache) {
+            const preEarlyHintsHeaders = new Headers(headers);
+            // "Early Hints cache entries are keyed by request URI and ignore query strings."
+            // https://developers.cloudflare.com/cache/about/early-hints/
+            const earlyHintsCacheKey = `${protocol}//${host}${pathname}`;
+            const earlyHintsResponse = await earlyHintsCache.match(earlyHintsCacheKey);
+            if (earlyHintsResponse) {
+                const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
+                if (earlyHintsLinkHeader) {
+                    headers.set("Link", earlyHintsLinkHeader);
+                }
+            }
+            const clonedResponse = response.clone();
+            if (waitUntil) {
+                waitUntil((async () => {
+                    try {
+                        const links = [];
+                        const transformedResponse = new HTMLRewriter()
+                            .on("link[rel~=preconnect],link[rel~=preload]", {
+                            element(element) {
+                                for (const [attributeName] of element.attributes) {
+                                    if (!ALLOWED_EARLY_HINT_LINK_ATTRIBUTES.includes(attributeName.toLowerCase())) {
+                                        return;
+                                    }
+                                }
+                                const href = element.getAttribute("href") || undefined;
+                                const rel = element.getAttribute("rel") || undefined;
+                                const as = element.getAttribute("as") || undefined;
+                                if (href && !href.startsWith("data:") && rel) {
+                                    links.push({ href, rel, as });
+                                }
+                            },
+                        })
+                            .transform(clonedResponse);
+                        // Needed to actually execute the HTMLRewriter handlers
+                        await transformedResponse.text();
+                        links.forEach(({ href, rel, as }) => {
+                            let link = `<${href}>; rel="${rel}"`;
+                            if (as) {
+                                link += `; as=${as}`;
+                            }
+                            preEarlyHintsHeaders.append("Link", link);
+                        });
+                        const linkHeader = preEarlyHintsHeaders.get("Link");
+                        if (linkHeader) {
+                            await earlyHintsCache.put(earlyHintsCacheKey, new Response(null, { headers: { Link: linkHeader } }));
+                        }
+                    }
+                    catch (err) {
+                        // Nbd if we fail here in the deferred 'waitUntil' work. We're probably trying to parse a malformed page or something.
+                        // Totally fine to skip over any errors.
+                        // If we need to debug something, you can uncomment the following:
+                        // logError(err)
+                    }
+                })());
+            }
+        }
+        // Iterate through rules and find rules that match the path
+        const headersMatcher = (0, rulesEngine_1.generateRulesMatcher)(headerRules, ({ set = {}, unset = [] }, replacements) => {
+            const replacedSet = {};
+            Object.keys(set).forEach((key) => {
+                replacedSet[key] = (0, rulesEngine_1.replacer)(set[key], replacements);
+            });
+            return {
+                set: replacedSet,
+                unset,
+            };
+        });
+        const matches = headersMatcher({ request });
+        // This keeps track of every header that we've set from _headers
+        // because we want to combine user declared headers but overwrite
+        // existing and extra ones
+        const setMap = new Set();
+        // Apply every matched rule in order
+        matches.forEach(({ set = {}, unset = [] }) => {
+            unset.forEach((key) => {
+                headers.delete(key);
+            });
+            Object.keys(set).forEach((key) => {
+                if (setMap.has(key.toLowerCase())) {
+                    headers.append(key, set[key]);
+                }
+                else {
+                    headers.set(key, set[key]);
+                    setMap.add(key.toLowerCase());
+                }
+            });
+        });
+        // https://fetch.spec.whatwg.org/#null-body-status
+        return new Response([101, 204, 205, 304].includes(response.status) ? null : response.body, {
+            headers: headers,
+            status: response.status,
+            statusText: response.statusText,
+        });
+    }
+    return await attachHeaders(await generateResponse());
+    async function serveAsset(servingAssetEntry, options = { preserve: true }) {
+        let content;
+        try {
+            content = negotiateContent(request, servingAssetEntry);
+        }
+        catch (err) {
+            return new responses_1.NotAcceptableResponse();
+        }
+        const assetKey = getAssetKey(servingAssetEntry, content);
+        // https://support.cloudflare.com/hc/en-us/articles/218505467-Using-ETag-Headers-with-Cloudflare
+        // We sometimes remove etags unless they are wrapped in quotes
+        const etag = `"${assetKey}"`;
+        const weakEtag = `W/${etag}`;
+        const ifNoneMatch = request.headers.get("if-none-match");
+        // We sometimes downgrade strong etags to a weak ones, so we need to check for both
+        if (ifNoneMatch === weakEtag || ifNoneMatch === etag) {
+            return new responses_1.NotModifiedResponse();
+        }
+        try {
+            const asset = await fetchAsset(assetKey);
+            const headers = {
+                etag,
+                "content-type": asset.contentType,
+            };
+            let encodeBody = "automatic";
+            if (xServerEnvHeader) {
+                headers["x-server-env"] = xServerEnvHeader;
+            }
+            if (content.encoding) {
+                encodeBody = "manual";
+                headers["cache-control"] = "no-transform";
+                headers["content-encoding"] = content.encoding;
+            }
+            const response = new responses_1.OkResponse(request.method === "HEAD" ? null : asset.body, {
+                headers,
+                encodeBody,
+            });
+            if (isCacheable(request)) {
+                response.headers.append("cache-control", exports.CACHE_CONTROL_BROWSER);
+            }
+            attachAdditionalHeaders(response, content, servingAssetEntry, asset);
+            if (isPreview(new URL(request.url))) {
+                response.headers.set("x-robots-tag", "noindex");
+            }
+            if (options.preserve) {
+                // https://fetch.spec.whatwg.org/#null-body-status
+                const preservedResponse = new Response([101, 204, 205, 304].includes(response.status)
+                    ? null
+                    : response.clone().body, response);
+                preservedResponse.headers.set("cache-control", CACHE_CONTROL_PRESERVATION);
+                preservedResponse.headers.set("x-robots-tag", "noindex");
+                if (waitUntil && caches) {
+                    waitUntil(caches
+                        .open(exports.ASSET_PRESERVATION_CACHE)
+                        .then((assetPreservationCache) => assetPreservationCache.put(request.url, preservedResponse))
+                        .catch((err) => {
+                        logError(err);
+                    }));
+                }
+            }
+            if (asset.contentType.startsWith("text/html") &&
+                metadata.analytics?.version === exports.ANALYTICS_VERSION) {
+                return new HTMLRewriter()
+                    .on("body", {
+                    element(e) {
+                        e.append(`<!-- Cloudflare Pages Analytics --><script defer src='https://static.cloudflareinsights.com/beacon.min.js' data-cf-beacon='{"token": "${metadata.analytics?.token}"}'></script><!-- Cloudflare Pages Analytics -->`, { html: true });
+                    },
+                })
+                    .transform(response);
+            }
+            return response;
+        }
+        catch (err) {
+            logError(err);
+            return new responses_1.InternalServerErrorResponse(err);
+        }
+    }
+    async function notFound() {
+        if (caches) {
+            const assetPreservationCache = await caches.open(exports.ASSET_PRESERVATION_CACHE);
+            const preservedResponse = await assetPreservationCache.match(request.url);
+            if (preservedResponse) {
+                return preservedResponse;
+            }
+        }
+        // Traverse upwards from the current path looking for a custom 404 page
+        let cwd = pathname;
+        while (cwd) {
+            cwd = cwd.slice(0, cwd.lastIndexOf("/"));
+            if ((assetEntry = await findAssetEntryForPath(`${cwd}/404.html`))) {
+                let content;
+                try {
+                    content = negotiateContent(request, assetEntry);
+                }
+                catch (err) {
+                    return new responses_1.NotAcceptableResponse();
+                }
+                const assetKey = getAssetKey(assetEntry, content);
+                try {
+                    const { body, contentType } = await fetchAsset(assetKey);
+                    const response = new responses_1.NotFoundResponse(body);
+                    response.headers.set("content-type", contentType);
+                    return response;
+                }
+                catch (err) {
+                    logError(err);
+                    return new responses_1.InternalServerErrorResponse(err);
+                }
+            }
+        }
+        return await generateNotFoundResponse(request, findAssetEntryForPath, serveAsset);
+    }
+}
+exports.generateHandler = generateHandler;
+// Parses a list such as "deflate, gzip;q=1.0, *;q=0.5" into
+//   {deflate: 1, gzip: 1, *: 0.5}
+function parseQualityWeightedList(list = "") {
+    const items = {};
+    list
+        .replace(/\s/g, "")
+        .split(",")
+        .forEach((el) => {
+        const [item, weight] = el.split(";q=");
+        items[item] = weight ? parseFloat(weight) : 1;
+    });
+    return items;
+}
+exports.parseQualityWeightedList = parseQualityWeightedList;
+function isCacheable(request) {
+    return !request.headers.has("authorization") && !request.headers.has("range");
+}
+function hasFileExtension(path) {
+    return /\/.+\.[a-z0-9]+$/i.test(path);
+}
+// Parses a request URL hostname to determine if the request
+// is from a project served in "preview" mode.
+function isPreview(url) {
+    if (url.hostname.endsWith(".pages.dev")) {
+        return url.hostname.split(".").length > 3 ? true : false;
+    }
+    return false;
+}

package/dist/asset-server/metadata.d.ts

@@ -0,0 +1,52 @@
+export declare type MetadataStaticRedirectEntry = {
+    status: number;
+    to: string;
+    lineNumber: number;
+};
+export declare type MetadataRedirectEntry = {
+    status: number;
+    to: string;
+    lineNumber?: number;
+};
+export declare type MetadataStaticRedirects = {
+    [path: string]: MetadataStaticRedirectEntry;
+};
+export declare type MetadataRedirects = {
+    [path: string]: MetadataRedirectEntry;
+};
+export declare type MetadataHeadersEntries = Record<string, string>;
+export declare type MetadataHeadersRulesV1 = {
+    [path: string]: MetadataHeadersEntries;
+};
+export declare type MetadataHeadersV1 = {
+    version: number;
+    rules: MetadataHeadersRulesV1;
+};
+export declare type SetHeaders = MetadataHeadersEntries;
+export declare type UnsetHeaders = Array<string>;
+export declare type MetadataHeadersRulesV2 = {
+    [path: string]: MetadataHeaderEntry;
+};
+export declare type MetadataHeaderEntry = {
+    set?: SetHeaders;
+    unset?: UnsetHeaders;
+};
+export declare type MetadataHeadersV2 = {
+    version: number;
+    rules: MetadataHeadersRulesV2;
+};
+export declare type Metadata = {
+    redirects?: {
+        version: number;
+        staticRules?: MetadataStaticRedirects;
+        rules: MetadataRedirects;
+    };
+    headers?: MetadataHeadersV1 | MetadataHeadersV2;
+    analytics?: {
+        version: number;
+        token: string;
+    };
+    deploymentId?: string;
+    failOpen?: boolean;
+};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/asset-server/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../asset-server/metadata.ts"],"names":[],"mappings":"AAEA,oBAAY,2BAA2B,GAAG;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,oBAAY,qBAAqB,GAAG;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,oBAAY,uBAAuB,GAAG;IACrC,CAAC,IAAI,EAAE,MAAM,GAAG,2BAA2B,CAAC;CAC5C,CAAC;AAEF,oBAAY,iBAAiB,GAAG;IAC/B,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAAC;CACtC,CAAC;AAGF,oBAAY,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5D,oBAAY,sBAAsB,GAAG;IACpC,CAAC,IAAI,EAAE,MAAM,GAAG,sBAAsB,CAAC;CACvC,CAAC;AAEF,oBAAY,iBAAiB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,sBAAsB,CAAC;CAC9B,CAAC;AAGF,oBAAY,UAAU,GAAG,sBAAsB,CAAC;AAEhD,oBAAY,YAAY,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;AAEzC,oBAAY,sBAAsB,GAAG;IACpC,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAAC;CACpC,CAAC;AAEF,oBAAY,mBAAmB,GAAG;IACjC,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF,oBAAY,iBAAiB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,sBAAsB,CAAC;CAC9B,CAAC;AAEF,oBAAY,QAAQ,GAAG;IACtB,SAAS,CAAC,EAAE;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,uBAAuB,CAAC;QACtC,KAAK,EAAE,iBAAiB,CAAC;KACzB,CAAC;IACF,OAAO,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAAC;IAChD,SAAS,CAAC,EAAE;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACd,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC"}

package/dist/asset-server/metadata.js

@@ -0,0 +1,3 @@
+"use strict";
+// TODO: Use types from metadata-generator instead
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/asset-server/patchUrl.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=patchUrl.d.ts.map

package/dist/asset-server/patchUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patchUrl.d.ts","sourceRoot":"","sources":["../../asset-server/patchUrl.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,CAAC"}

package/dist/asset-server/patchUrl.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+globalThis.URL = (function (globalURL) {
+    PatchedURL.prototype = globalURL.prototype;
+    PatchedURL.createObjectURL = globalURL.createObjectURL;
+    PatchedURL.revokeObjectURL = globalURL.revokeObjectURL;
+    return PatchedURL;
+    function PatchedURL(input, base) {
+        const url = new globalURL(encodeURI(input), base);
+        return new Proxy(url, {
+            get(target, prop) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return globalThis.decodeURIComponent(target[prop]);
+            },
+        });
+    }
+})(URL);

package/dist/asset-server/responses.d.ts

@@ -0,0 +1,45 @@
+export declare function stripLeadingDoubleSlashes(location: string): string;
+export declare class OkResponse extends Response {
+    constructor(...[body, init]: ConstructorParameters<typeof Response>);
+}
+export declare class MovedPermanentlyResponse extends Response {
+    constructor(location: string, init?: ConstructorParameters<typeof Response>[1], { preventLeadingDoubleSlash, }?: {
+        preventLeadingDoubleSlash: boolean;
+    });
+}
+export declare class FoundResponse extends Response {
+    constructor(location: string, init?: ConstructorParameters<typeof Response>[1], { preventLeadingDoubleSlash, }?: {
+        preventLeadingDoubleSlash: boolean;
+    });
+}
+export declare class NotModifiedResponse extends Response {
+    constructor(...[_body, _init]: ConstructorParameters<typeof Response>);
+}
+export declare class PermanentRedirectResponse extends Response {
+    constructor(location: string, init?: ConstructorParameters<typeof Response>[1], { preventLeadingDoubleSlash, }?: {
+        preventLeadingDoubleSlash: boolean;
+    });
+}
+export declare class NotFoundResponse extends Response {
+    constructor(...[body, init]: ConstructorParameters<typeof Response>);
+}
+export declare class MethodNotAllowedResponse extends Response {
+    constructor(...[body, init]: ConstructorParameters<typeof Response>);
+}
+export declare class NotAcceptableResponse extends Response {
+    constructor(...[body, init]: ConstructorParameters<typeof Response>);
+}
+export declare class InternalServerErrorResponse extends Response {
+    constructor(err: Error, init?: ConstructorParameters<typeof Response>[1]);
+}
+export declare class SeeOtherResponse extends Response {
+    constructor(location: string, init?: ConstructorParameters<typeof Response>[1], { preventLeadingDoubleSlash, }?: {
+        preventLeadingDoubleSlash: boolean;
+    });
+}
+export declare class TemporaryRedirectResponse extends Response {
+    constructor(location: string, init?: ConstructorParameters<typeof Response>[1], { preventLeadingDoubleSlash, }?: {
+        preventLeadingDoubleSlash: boolean;
+    });
+}
+//# sourceMappingURL=responses.d.ts.map

package/dist/asset-server/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../asset-server/responses.ts"],"names":[],"mappings":"AAYA,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,UAEzD;AAED,qBAAa,UAAW,SAAQ,QAAQ;gBAC3B,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC;CAOnE;AAED,qBAAa,wBAAyB,SAAQ,QAAQ;gBAEpD,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,EAChD,EACC,yBAAgC,GAChC,GAAE;QAAE,yBAAyB,EAAE,OAAO,CAAA;KAEtC;CAcF;AAED,qBAAa,aAAc,SAAQ,QAAQ;gBAEzC,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,EAChD,EACC,yBAAgC,GAChC,GAAE;QAAE,yBAAyB,EAAE,OAAO,CAAA;KAEtC;CAcF;AAED,qBAAa,mBAAoB,SAAQ,QAAQ;gBACpC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC;CAMrE;AAED,qBAAa,yBAA0B,SAAQ,QAAQ;gBAErD,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,EAChD,EACC,yBAAgC,GAChC,GAAE;QAAE,yBAAyB,EAAE,OAAO,CAAA;KAEtC;CAcF;AAED,qBAAa,gBAAiB,SAAQ,QAAQ;gBACjC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC;CAOnE;AAED,qBAAa,wBAAyB,SAAQ,QAAQ;gBACzC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC;CAOnE;AAED,qBAAa,qBAAsB,SAAQ,QAAQ;gBACtC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC;CAOnE;AAED,qBAAa,2BAA4B,SAAQ,QAAQ;gBAC5C,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;CAaxE;AAED,qBAAa,gBAAiB,SAAQ,QAAQ;gBAE5C,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,EAChD,EACC,yBAAgC,GAChC,GAAE;QAAE,yBAAyB,EAAE,OAAO,CAAA;KAEtC;CAYF;AAED,qBAAa,yBAA0B,SAAQ,QAAQ;gBAErD,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,EAChD,EACC,yBAAgC,GAChC,GAAE;QAAE,yBAAyB,EAAE,OAAO,CAAA;KAEtC;CAYF"}