tezx 2.0.11 → 3.0.0

package/node/serveStatic.js

@@ -0,0 +1,52 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { extensionExtract, sanitizePathSplitBasePath, } from "../utils/low-level.js";
+import { TezXError } from "../core/error.js";
+export function serveStatic(...args) {
+    let route = "";
+    let dir;
+    let options = {};
+    switch (args.length) {
+        case 3:
+            [route, dir, options] = args;
+            break;
+        case 2:
+            if (typeof args[1] === "object") {
+                [dir, options] = args;
+            }
+            else {
+                [route, dir] = args;
+            }
+            break;
+        case 1:
+            [dir] = args;
+            break;
+        default:
+            throw new TezXError(`\x1b[1;31m404 Not Found\x1b[0m \x1b[1;32mInvalid arguments\x1b[0m`);
+    }
+    return {
+        files: getFiles(dir, route, options),
+        options,
+    };
+}
+export function getFiles(dir, basePath = "/", option = {}) {
+    const files = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...getFiles(fullPath, `${basePath}/${entry.name}`, option));
+        }
+        else {
+            const ext = extensionExtract(entry.name);
+            if (option?.extensions?.length && !option.extensions.includes(ext)) {
+                continue;
+            }
+            files.push({
+                fileSource: fullPath,
+                route: `/${sanitizePathSplitBasePath(basePath, entry.name).join("/")}`,
+            });
+        }
+    }
+    return files;
+}

package/node/toWebRequest.js

@@ -0,0 +1,22 @@
+import { Readable } from "node:stream";
+export function toWebRequest(req, method = "GET") {
+    const protocol = req.socket && req.socket.encrypted ? "https:" : "http:";
+    const upperMethod = method.length === 3
+        ? method === "get"
+            ? "GET"
+            : method === "put"
+                ? "PUT"
+                : method.toUpperCase()
+        : method.toUpperCase();
+    let host = req.headers.host || "localhost";
+    const hasBody = upperMethod !== "GET" && upperMethod !== "HEAD";
+    const abortController = new AbortController();
+    req?.once("close", () => abortController.abort());
+    return new Request(protocol + "//" + host + (req.url ?? "/"), {
+        method,
+        headers: req?.headers,
+        body: hasBody ? Readable.toWeb(req) : undefined,
+        signal: abortController.signal,
+        duplex: hasBody ? "half" : undefined,
+    });
+}

package/node/ws.d.ts

@@ -0,0 +1,56 @@
+import type { PerMessageDeflateOptions } from "ws";
+import { Middleware, WebSocketCallback, WebSocketOptions } from "../types/index.js";
+export type nodeWebSocketOptions = {
+    /**
+     * Enables per-message deflate compression. Can be a boolean or a detailed config. (Node.js only)
+     */
+    perMessageDeflate?: boolean | PerMessageDeflateOptions;
+    /**
+     * Maximum allowed message size in bytes. Default is 1MB if not provided. (Node.js only)
+     */
+    maxPayload?: number;
+};
+/**
+ * Creates a Node.js-specific WebSocket upgrade middleware.
+ *
+ * This middleware validates WebSocket upgrade headers and upgrades the HTTP connection
+ * to a WebSocket connection using the `ws` library. It binds event handlers
+ * (`open`, `message`, `close`, `error`, `ping`, `pong`) based on the provided callback.
+ *
+ * @template T - Context type extending object with `wsProtocol` property ("ws" or "wss").
+ * @template Path - Route path type (string).
+ *
+ * @param {WebSocketCallback} callback - Function that returns WebSocket event handlers.
+ * @param {WebSocketOptions} [options={}] - Options for WebSocket upgrade behavior.
+ * @param {(error: TezXError, ctx: T) => any} [options.onUpgradeError] - Custom error handler for upgrade failures.
+ * @param {number} [options.maxPayload=1048576] - Maximum allowed payload size (in bytes).
+ * @param {boolean} [options.perMessageDeflate=false] - Whether to enable per-message deflate.
+ *
+ * @returns {Middleware<T, Path>} Middleware function for handling WebSocket upgrade requests.
+ *
+ * @throws Will return a 401 response if WebSocket upgrade headers are invalid.
+ * @throws Will return a 500 response if Node.js HTTP server instance is missing in context arguments.
+ *
+ * @example
+ * ```ts
+ * import { upgradeWebSocket } from "./nodeWebSocket.js";
+ *
+ * const wsMiddleware = upgradeWebSocket(ctx => ({
+ *   open(ws) {
+ *     console.log("WebSocket connection opened");
+ *   },
+ *   message(ws, data) {
+ *     console.log("Received message:", data);
+ *   },
+ *   close(ws, event) {
+ *     console.log("Connection closed:", event.code, event.reason);
+ *   },
+ *   error(ws, err) {
+ *     console.error("WebSocket error:", err);
+ *   },
+ * }));
+ * ```
+ */
+export declare function upgradeWebSocket<T extends Record<string, any> & {
+    wsProtocol: "wss" | "ws";
+}, Path extends string = any>(callback: WebSocketCallback, options?: WebSocketOptions & nodeWebSocketOptions): Middleware<T, Path>;

package/node/ws.js

@@ -0,0 +1,46 @@
+import { TezXError } from "../core/error.js";
+export function upgradeWebSocket(callback, options = {}) {
+    const { onUpgradeError = (error, ctx) => {
+        ctx.setStatus = 401;
+        return ctx.text(error.message);
+    }, } = options;
+    return async (ctx, next) => {
+        const upgrade = ctx.req.header("upgrade")?.toLowerCase();
+        const connection = ctx.req.header("connection")?.toLowerCase();
+        const key = ctx.req.header("sec-websocket-key");
+        if (upgrade !== "websocket" || !connection?.includes("upgrade") || !key) {
+            if (next) {
+                ctx.body = { error: "401 Bad Request: Invalid WebSocket headers" };
+                return next();
+            }
+            ctx.setStatus = 401;
+            return onUpgradeError(new TezXError("401 Bad Request: Invalid WebSocket headers", 401), ctx);
+        }
+        ctx.wsProtocol = ctx.url?.startsWith("https") ? "wss" : "ws";
+        const server = ctx.args?.[2];
+        if (!server?.on) {
+            ctx.setStatus = 500;
+            return onUpgradeError(new TezXError("Node server instance missing for WebSocket", 426), ctx);
+        }
+        const { WebSocketServer } = await import("ws");
+        const wss = new WebSocketServer({
+            noServer: true,
+            maxPayload: options.maxPayload ?? 1048576,
+            perMessageDeflate: options.perMessageDeflate ?? false,
+        });
+        server.on("upgrade", (request, socket, head) => {
+            wss?.handleUpgrade(request, socket, head, (ws) => {
+                wss?.emit("connection", ws, request);
+                let event = callback(ctx);
+                event.open?.(ws);
+                ws.on("open", () => event.open?.(ws));
+                ws.on("message", (data) => event.message?.(ws, data));
+                ws.on("close", (code, reason) => event.close?.(ws, { code, reason }));
+                ws.on("error", (err) => event.error?.(ws, err));
+                ws.on("ping", (data) => event.ping?.(ws, data));
+                ws.on("pong", (data) => event.pong?.(ws, data));
+            });
+        });
+        return next();
+    };
+}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "tezx",
-  "version": "2.0.11",
+  "version": "3.0.0",
   "description": "TezX is a high-performance, lightweight JavaScript framework designed for speed, scalability, and flexibility. It enables efficient routing, middleware management, and static file serving with minimal configuration. Fully compatible with Node.js, Deno, and Bun.",
+  "type": "module",
   "main": "cjs/index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -19,60 +20,68 @@
     ".": {
       "import": "./index.js",
       "require": "./cjs/index.js",
-      "types": "./index.d.ts",
-      "default": "./index.js"
+      "types": "./index.d.ts"
     },
-    "./middleware": {
-      "import": "./middleware/index.js",
-      "require": "./cjs/middleware/index.js",
-      "types": "./middleware/index.d.ts",
-      "default": "./middleware/index.js"
+    "./bun": {
+      "import": "./bun/index.js",
+      "require": "./cjs/bun/index.js",
+      "types": "./bun/index.d.ts"
     },
     "./node": {
       "import": "./node/index.js",
       "require": "./cjs/node/index.js",
-      "types": "./node/index.d.ts",
-      "default": "./node/index.js"
-    },
-    "./bun": {
-      "import": "./bun/index.js",
-      "require": "./cjs/bun/index.js",
-      "types": "./bun/index.d.ts",
-      "default": "./bun/index.js"
+      "types": "./node/index.d.ts"
     },
     "./deno": {
       "import": "./deno/index.js",
       "require": "./cjs/deno/index.js",
-      "types": "./deno/index.d.ts",
-      "default": "./deno/index.js"
+      "types": "./deno/index.d.ts"
     },
     "./helper": {
       "import": "./helper/index.js",
       "require": "./cjs/helper/index.js",
-      "types": "./helper/index.d.ts",
-      "default": "./helper/index.js"
+      "types": "./helper/index.d.ts"
     },
-    "./ws": {
-      "import": "./ws/index.js",
-      "require": "./cjs/ws/index.js",
-      "types": "./ws/index.d.ts",
-      "default": "./ws/index.js"
+    "./jwt/node": {
+      "import": "./jwt/node.js",
+      "require": "./cjs/jwt/node.js",
+      "types": "./jwt/node.d.ts"
+    },
+    "./jwt/web": {
+      "import": "./jwt/web.js",
+      "require": "./cjs/jwt/web.js",
+      "types": "./jwt/web.d.ts"
+    },
+    "./registry": {
+      "import": "./registry/index.js",
+      "require": "./cjs/registry/index.js",
+      "types": "./registry/index.d.ts"
+    },
+    "./middleware": {
+      "import": "./middleware/index.js",
+      "require": "./cjs/middleware/index.js",
+      "types": "./middleware/index.d.ts"
+    },
+    "./middleware/*": {
+      "import": "./middleware/*.js",
+      "require": "./cjs/middleware/*.js",
+      "types": "./middleware/*.d.ts"
     }
   },
   "files": [
-    "adapter/",
     "bun/",
     "cjs/",
     "core/",
     "deno/",
     "helper/",
-    "node/",
+    "jwt/",
     "middleware/",
+    "node/",
+    "registry/",
     "types/",
     "utils/",
-    "ws/",
-    "index.js",
-    "index.d.ts"
+    "index.d.ts",
+    "index.js"
   ],
   "keywords": [
     "server",

package/registry/RadixRouter.d.ts

@@ -0,0 +1,40 @@
+import type { Callback, HTTPMethod, Middleware, RouteMatchResult, RouteRegistry } from "../types/index.js";
+/**
+ * Radix-based router implementation for efficient route matching.
+ * Supports static, dynamic, optional, and wildcard parameters.
+ */
+export declare class RadixRouter implements RouteRegistry {
+    private root;
+    name: string;
+    constructor();
+    /**
+     * Adds a new route to the radix tree.
+     *
+     * @param method - HTTP method (GET, POST, etc.)
+     * @param path - Route path, e.g., "/users/:id?"
+     * @param handlers - Array of handler functions or middleware
+     * @throws Error if conflicting parameter definitions are detected
+     */
+    addRoute(method: HTTPMethod, path: string, handlers: (Callback | Middleware)[]): void;
+    /**
+     * Searches for a route match based on HTTP method and URL path.
+     *
+     * @param method - HTTP method to match
+     * @param path - Request path
+     * @returns RouteMatchResult containing handlers, middlewares, and parameters
+     */
+    search(method: HTTPMethod, path: string): RouteMatchResult;
+    /**
+     * Recursively matches the route path segments.
+     *
+     * @private
+     */
+    private _match;
+    /**
+     * Parses a route pattern into structured segments.
+     *
+     * @param pattern - The route string (e.g., "/users/:id?")
+     * @returns Parsed segments containing type, value, paramName, and optionality
+     */
+    private parsePattern;
+}

package/registry/RadixRouter.js

@@ -0,0 +1,144 @@
+import { TezXError } from "../core/error.js";
+import { sanitizePathSplit } from "../helper/index.js";
+export class RadixRouter {
+    root = { children: {} };
+    name;
+    constructor() {
+        this.name = "RadixRouter";
+    }
+    addRoute(method, path, handlers) {
+        const segments = this.parsePattern(path);
+        let node = this.root;
+        for (let i = 0; i < segments.length; i++) {
+            const { type, value, paramName, isOptional } = segments[i];
+            if (type === "static") {
+                node = node.children[value] ??= { children: {} };
+            }
+            else if (type === "dynamic") {
+                if (!node.children[":"]) {
+                    node.children[":"] = { children: {}, paramName, isOptional };
+                }
+                else if (node.children[":"]?.paramName !== paramName ||
+                    node.children[":"]?.isOptional !== isOptional) {
+                    throw new TezXError(`Conflicting param definition for ${paramName}`);
+                }
+                node = node.children[":"];
+            }
+            else if (type === "wildcard") {
+                node = node.children["*"] ??= { children: {}, paramName };
+                break;
+            }
+        }
+        node.isEndpoint = true;
+        node.handlers ??= {};
+        node.handlers[method] ??= [];
+        node.handlers[method].push(...(handlers || []));
+    }
+    search(method, path) {
+        let params = {};
+        let middlewares = [];
+        const { success, node } = this._match(method, this.root, path?.split("/")?.filter(Boolean), 0, params, middlewares);
+        if (success && node) {
+            const handlers = node.handlers?.[method] ?? [];
+            return { method, params, handlers, middlewares };
+        }
+        return { method, params: {}, handlers: [], middlewares };
+    }
+    _match(method, node, segments, index, params, middlewares) {
+        if (node?.handlers?.ALL) {
+            const mw = node.handlers?.ALL;
+            for (let i = 0; i < mw.length; i++) {
+                middlewares.push(mw[i]);
+            }
+        }
+        if (index === segments.length) {
+            if (node.isEndpoint && node.handlers?.[method])
+                return { success: true, node };
+            const opt = node.children[":"];
+            if (opt?.isOptional) {
+                params[opt.paramName] = null;
+                return this._match(method, opt, segments, index, params, middlewares);
+            }
+            return { success: false, node: node };
+        }
+        const wc = node.children["*"];
+        const seg = segments[index];
+        if (node.children[seg]) {
+            const res = this._match(method, node.children[seg], segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
+                return res;
+            }
+        }
+        const dyn = node.children[":"];
+        if (dyn) {
+            params[dyn.paramName] = seg;
+            const res = this._match(method, dyn, segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
+                return res;
+            }
+            if (dyn.isOptional) {
+                params[dyn.paramName] = null;
+                const skip = this._match(method, dyn, segments, index, params, middlewares);
+                if (skip.success) {
+                    if (wc?.handlers?.ALL) {
+                        const mw = wc.handlers?.ALL;
+                        for (let i = 0; i < mw.length; i++) {
+                            middlewares.push(mw[i]);
+                        }
+                    }
+                    return skip;
+                }
+            }
+        }
+        if (wc) {
+            let wildcard = segments.slice(index).join("/");
+            if (wc?.handlers?.ALL) {
+                const mw = wc.handlers?.ALL;
+                for (let i = 0; i < mw.length; i++) {
+                    middlewares.push(mw[i]);
+                }
+            }
+            if (wildcard) {
+                params[wc.paramName] = wildcard;
+                return { node: wc, success: true };
+            }
+        }
+        return { success: false, node };
+    }
+    parsePattern(pattern) {
+        const segments = sanitizePathSplit(pattern);
+        const result = [];
+        for (const segment of segments) {
+            if (segment === "*") {
+                result.push({ type: "wildcard", paramName: "*" });
+                break;
+            }
+            else if (segment.startsWith("*")) {
+                const paramName = segment.slice(1) || "*";
+                result.push({ type: "wildcard", paramName });
+                break;
+            }
+            else if (segment.startsWith(":")) {
+                const isOptional = segment.endsWith("?");
+                const paramName = isOptional ? segment.slice(1, -1) : segment.slice(1);
+                result.push({ type: "dynamic", paramName, isOptional });
+            }
+            else {
+                result.push({ type: "static", value: segment });
+            }
+        }
+        return result;
+    }
+}

package/registry/index.d.ts

@@ -0,0 +1,2 @@
+export { HandlerType, RouteMatchResult, RouteRegistry, } from "../types/index.js";
+export * from "./RadixRouter.js";

package/registry/index.js

@@ -0,0 +1 @@
+export * from "./RadixRouter.js";

package/types/headers.d.ts

@@ -0,0 +1,2 @@
+export type RequestHeader = "A-IM" | "Accept" | "Accept-Additions" | "Accept-CH" | "Accept-Charset" | "Accept-Datetime" | "Accept-Encoding" | "Accept-Features" | "Accept-Language" | "Accept-Patch" | "Accept-Post" | "Accept-Ranges" | "Accept-Signature" | "Access-Control" | "Access-Control-Allow-Credentials" | "Access-Control-Allow-Headers" | "Access-Control-Allow-Methods" | "Access-Control-Allow-Origin" | "Access-Control-Expose-Headers" | "Access-Control-Max-Age" | "Access-Control-Request-Headers" | "Access-Control-Request-Method" | "Age" | "Allow" | "ALPN" | "Alt-Svc" | "Alt-Used" | "Alternates" | "AMP-Cache-Transform" | "Apply-To-Redirect-Ref" | "Authentication-Control" | "Authentication-Info" | "Authorization" | "Available-Dictionary" | "C-Ext" | "C-Man" | "C-Opt" | "C-PEP" | "C-PEP-Info" | "Cache-Control" | "Cache-Status" | "Cal-Managed-ID" | "CalDAV-Timezones" | "Capsule-Protocol" | "CDN-Cache-Control" | "CDN-Loop" | "Cert-Not-After" | "Cert-Not-Before" | "Clear-Site-Data" | "Client-Cert" | "Client-Cert-Chain" | "Close" | "CMCD-Object" | "CMCD-Request" | "CMCD-Session" | "CMCD-Status" | "CMSD-Dynamic" | "CMSD-Static" | "Concealed-Auth-Export" | "Configuration-Context" | "Connection" | "Content-Base" | "Content-Digest" | "Content-Disposition" | "Content-Encoding" | "Content-ID" | "Content-Language" | "Content-Length" | "Content-Location" | "Content-MD5" | "Content-Range" | "Content-Script-Type" | "Content-Security-Policy" | "Content-Security-Policy-Report-Only" | "Content-Style-Type" | "Content-Type" | "Content-Version" | "Cookie" | "Cookie2" | "Cross-Origin-Embedder-Policy" | "Cross-Origin-Embedder-Policy-Report-Only" | "Cross-Origin-Opener-Policy" | "Cross-Origin-Opener-Policy-Report-Only" | "Cross-Origin-Resource-Policy" | "CTA-Common-Access-Token" | "DASL" | "Date" | "DAV" | "Default-Style" | "Delta-Base" | "Deprecation" | "Depth" | "Derived-From" | "Destination" | "Differential-ID" | "Dictionary-ID" | "Digest" | "DPoP" | "DPoP-Nonce" | "Early-Data" | "EDIINT-Features" | "ETag" | "Expect" | "Expect-CT" | "Expires" | "Ext" | "Forwarded" | "From" | "GetProfile" | "Hobareg" | "Host" | "HTTP2-Settings" | "If" | "If-Match" | "If-Modified-Since" | "If-None-Match" | "If-Range" | "If-Schedule-Tag-Match" | "If-Unmodified-Since" | "IM" | "Include-Referred-Token-Binding-ID" | "Isolation" | "Keep-Alive" | "Label" | "Last-Event-ID" | "Last-Modified" | "Link" | "Link-Template" | "Location" | "Lock-Token" | "Man" | "Max-Forwards" | "Memento-Datetime" | "Meter" | "Method-Check" | "Method-Check-Expires" | "MIME-Version" | "Negotiate" | "NEL" | "OData-EntityId" | "OData-Isolation" | "OData-MaxVersion" | "OData-Version" | "Opt" | "Optional-WWW-Authenticate" | "Ordering-Type" | "Origin" | "Origin-Agent-Cluster" | "OSCORE" | "OSLC-Core-Version" | "Overwrite" | "P3P" | "PEP" | "PEP-Info" | "Permissions-Policy" | "PICS-Label" | "Ping-From" | "Ping-To" | "Position" | "Pragma" | "Prefer" | "Preference-Applied" | "Priority" | "ProfileObject" | "Protocol" | "Protocol-Info" | "Protocol-Query" | "Protocol-Request" | "Proxy-Authenticate" | "Proxy-Authentication-Info" | "Proxy-Authorization" | "Proxy-Features" | "Proxy-Instruction" | "Proxy-Status" | "Public" | "Public-Key-Pins" | "Public-Key-Pins-Report-Only" | "Range" | "Redirect-Ref" | "Referer" | "Referer-Root" | "Referrer-Policy" | "Refresh" | "Repeatability-Client-ID" | "Repeatability-First-Sent" | "Repeatability-Request-ID" | "Repeatability-Result" | "Replay-Nonce" | "Reporting-Endpoints" | "Repr-Digest" | "Retry-After" | "Safe" | "Schedule-Reply" | "Schedule-Tag" | "Sec-GPC" | "Sec-Purpose" | "Sec-Token-Binding" | "Sec-WebSocket-Accept" | "Sec-WebSocket-Extensions" | "Sec-WebSocket-Key" | "Sec-WebSocket-Protocol" | "Sec-WebSocket-Version" | "Security-Scheme" | "Server" | "Server-Timing" | "Set-Cookie" | "Set-Cookie2" | "SetProfile" | "Signature" | "Signature-Input" | "SLUG" | "SoapAction" | "Status-URI" | "Strict-Transport-Security" | "Sunset" | "Surrogate-Capability" | "Surrogate-Control" | "TCN" | "TE" | "Timeout" | "Timing-Allow-Origin" | "Topic" | "Traceparent" | "Tracestate" | "Trailer" | "Transfer-Encoding" | "TTL" | "Upgrade" | "Urgency" | "URI" | "Use-As-Dictionary" | "User-Agent" | "Variant-Vary" | "Vary" | "Via" | "Want-Content-Digest" | "Want-Digest" | "Want-Repr-Digest" | "Warning" | "WWW-Authenticate" | "X-Content-Type-Options" | "X-Frame-Options";
+export type ResponseHeader = "Access-Control-Allow-Credentials" | "Access-Control-Allow-Headers" | "Access-Control-Allow-Methods" | "Access-Control-Allow-Origin" | "Access-Control-Expose-Headers" | "Access-Control-Max-Age" | "Age" | "Allow" | "Cache-Control" | "Clear-Site-Data" | "Content-Disposition" | "Content-Encoding" | "Content-Language" | "Content-Length" | "Content-Location" | "Content-Range" | "Content-Security-Policy" | "Content-Security-Policy-Report-Only" | "Content-Type" | "Cookie" | "Cross-Origin-Embedder-Policy" | "Cross-Origin-Opener-Policy" | "Cross-Origin-Resource-Policy" | "Date" | "ETag" | "Expires" | "Last-Modified" | "Location" | "Permissions-Policy" | "Pragma" | "Retry-After" | "Save-Data" | "Sec-CH-Prefers-Color-Scheme" | "Sec-CH-Prefers-Reduced-Motion" | "Sec-CH-UA" | "Sec-CH-UA-Arch" | "Sec-CH-UA-Bitness" | "Sec-CH-UA-Form-Factor" | "Sec-CH-UA-Full-Version" | "Sec-CH-UA-Full-Version-List" | "Sec-CH-UA-Mobile" | "Sec-CH-UA-Model" | "Sec-CH-UA-Platform" | "Sec-CH-UA-Platform-Version" | "Sec-CH-UA-WoW64" | "Sec-Fetch-Dest" | "Sec-Fetch-Mode" | "Sec-Fetch-Site" | "Sec-Fetch-User" | "Sec-GPC" | "Server" | "Server-Timing" | "Service-Worker-Navigation-Preload" | "Set-Cookie" | "Strict-Transport-Security" | "Timing-Allow-Origin" | "Trailer" | "Transfer-Encoding" | "Upgrade" | "Vary" | "WWW-Authenticate" | "Warning" | "X-Content-Type-Options" | "X-DNS-Prefetch-Control" | "X-Frame-Options" | "X-Permitted-Cross-Domain-Policies" | "X-Powered-By" | "X-Robots-Tag" | "X-XSS-Protection";

package/types/headers.js

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