initial commit

node_modules/unenv/runtime/node/http/_consts.cjs

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.maxHeaderSize = exports.STATUS_CODES = exports.METHODS = void 0;
+const METHODS = ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE", "MKACTIVITY", "MKCALENDAR", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PRI", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "REBIND", "REPORT", "SEARCH", "SOURCE", "SUBSCRIBE", "TRACE", "UNBIND", "UNLINK", "UNLOCK", "UNSUBSCRIBE"];
+exports.METHODS = METHODS;
+const STATUS_CODES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+exports.STATUS_CODES = STATUS_CODES;
+const maxHeaderSize = 16384;
+exports.maxHeaderSize = maxHeaderSize;

node_modules/unenv/runtime/node/http/_consts.d.ts

@@ -0,0 +1,67 @@
+export declare const METHODS: string[];
+export declare const STATUS_CODES: {
+    100: string;
+    101: string;
+    102: string;
+    103: string;
+    200: string;
+    201: string;
+    202: string;
+    203: string;
+    204: string;
+    205: string;
+    206: string;
+    207: string;
+    208: string;
+    226: string;
+    300: string;
+    301: string;
+    302: string;
+    303: string;
+    304: string;
+    305: string;
+    307: string;
+    308: string;
+    400: string;
+    401: string;
+    402: string;
+    403: string;
+    404: string;
+    405: string;
+    406: string;
+    407: string;
+    408: string;
+    409: string;
+    410: string;
+    411: string;
+    412: string;
+    413: string;
+    414: string;
+    415: string;
+    416: string;
+    417: string;
+    418: string;
+    421: string;
+    422: string;
+    423: string;
+    424: string;
+    425: string;
+    426: string;
+    428: string;
+    429: string;
+    431: string;
+    451: string;
+    500: string;
+    501: string;
+    502: string;
+    503: string;
+    504: string;
+    505: string;
+    506: string;
+    507: string;
+    508: string;
+    509: string;
+    510: string;
+    511: string;
+};
+export declare const maxHeaderSize = 16384;

node_modules/unenv/runtime/node/http/_consts.mjs

@@ -0,0 +1,103 @@
+export const METHODS = [
+  "ACL",
+  "BIND",
+  "CHECKOUT",
+  "CONNECT",
+  "COPY",
+  "DELETE",
+  "GET",
+  "HEAD",
+  "LINK",
+  "LOCK",
+  "M-SEARCH",
+  "MERGE",
+  "MKACTIVITY",
+  "MKCALENDAR",
+  "MKCOL",
+  "MOVE",
+  "NOTIFY",
+  "OPTIONS",
+  "PATCH",
+  "POST",
+  "PRI",
+  "PROPFIND",
+  "PROPPATCH",
+  "PURGE",
+  "PUT",
+  "REBIND",
+  "REPORT",
+  "SEARCH",
+  "SOURCE",
+  "SUBSCRIBE",
+  "TRACE",
+  "UNBIND",
+  "UNLINK",
+  "UNLOCK",
+  "UNSUBSCRIBE"
+];
+export const STATUS_CODES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+export const maxHeaderSize = 16384;

node_modules/unenv/runtime/node/http/_request.cjs

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IncomingMessage = void 0;
+
+var _socket = require("../net/socket.cjs");
+
+var _readable = require("../stream/readable.cjs");
+
+var _utils = require("../../_internal/utils.cjs");
+
+class IncomingMessage extends _readable.Readable {
+  constructor(socket) {
+    super();
+    this.aborted = false;
+    this.httpVersion = "1.1";
+    this.httpVersionMajor = 1;
+    this.httpVersionMinor = 1;
+    this.complete = true;
+    this.headers = {};
+    this.trailers = {};
+    this.method = "GET";
+    this.url = "/";
+    this.statusCode = 200;
+    this.statusMessage = "";
+    this.readable = false;
+    this.socket = this.connection = socket || new _socket.Socket();
+  }
+
+  get rawHeaders() {
+    return (0, _utils.rawHeaders)(this.headers);
+  }
+
+  get rawTrailers() {
+    return [];
+  }
+
+  setTimeout(_msecs, _callback) {
+    return this;
+  }
+
+}
+
+exports.IncomingMessage = IncomingMessage;

node_modules/unenv/runtime/node/http/_request.d.ts

@@ -0,0 +1,23 @@
+import type http from "node:http";
+import { Socket } from "../net/socket";
+import { Readable } from "../stream/readable";
+export declare class IncomingMessage extends Readable implements http.IncomingMessage {
+    aborted: boolean;
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    complete: boolean;
+    connection: Socket;
+    socket: Socket;
+    headers: http.IncomingHttpHeaders;
+    trailers: {};
+    method: string;
+    url: string;
+    statusCode: number;
+    statusMessage: string;
+    readable: boolean;
+    constructor(socket?: Socket);
+    get rawHeaders(): any[];
+    get rawTrailers(): any[];
+    setTimeout(_msecs: number, _callback?: () => void): this;
+}

node_modules/unenv/runtime/node/http/_request.mjs

@@ -0,0 +1,30 @@
+import { Socket } from "../net/socket.mjs";
+import { Readable } from "../stream/readable.mjs";
+import { rawHeaders } from "../../_internal/utils.mjs";
+export class IncomingMessage extends Readable {
+  constructor(socket) {
+    super();
+    this.aborted = false;
+    this.httpVersion = "1.1";
+    this.httpVersionMajor = 1;
+    this.httpVersionMinor = 1;
+    this.complete = true;
+    this.headers = {};
+    this.trailers = {};
+    this.method = "GET";
+    this.url = "/";
+    this.statusCode = 200;
+    this.statusMessage = "";
+    this.readable = false;
+    this.socket = this.connection = socket || new Socket();
+  }
+  get rawHeaders() {
+    return rawHeaders(this.headers);
+  }
+  get rawTrailers() {
+    return [];
+  }
+  setTimeout(_msecs, _callback) {
+    return this;
+  }
+}

node_modules/unenv/runtime/node/http/_response.cjs

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServerResponse = void 0;
+
+var _writable = require("../stream/writable.cjs");
+
+class ServerResponse extends _writable.Writable {
+  constructor(req) {
+    super();
+    this.statusCode = 200;
+    this.statusMessage = "";
+    this.upgrading = false;
+    this.chunkedEncoding = false;
+    this.shouldKeepAlive = false;
+    this.useChunkedEncodingByDefault = false;
+    this.sendDate = false;
+    this.finished = false;
+    this.headersSent = false;
+    this.connection = null;
+    this.socket = null;
+    this._headers = {};
+    this.req = req;
+  }
+
+  assignSocket(socket) {
+    socket._httpMessage = this;
+    this.socket = socket;
+    this.connection = socket;
+    this.emit("socket", socket);
+
+    this._flush();
+  }
+
+  _flush() {
+    this.flushHeaders();
+  }
+
+  detachSocket(_socket) {}
+
+  writeContinue(_callback) {}
+
+  writeHead(statusCode, arg1, arg2) {
+    if (statusCode) {
+      this.statusCode = statusCode;
+    }
+
+    if (typeof arg1 === "string") {
+      this.statusMessage = arg1;
+      arg1 = void 0;
+    }
+
+    const headers = arg2 || arg1;
+
+    if (headers) {
+      if (Array.isArray(headers)) {} else {
+        for (const key in headers) {
+          this.setHeader(key, headers[key]);
+        }
+      }
+    }
+
+    this.headersSent = true;
+    return this;
+  }
+
+  writeProcessing() {}
+
+  setTimeout(_msecs, _callback) {
+    return this;
+  }
+
+  setHeader(name, value) {
+    this._headers[name.toLowerCase()] = value + "";
+    return this;
+  }
+
+  getHeader(name) {
+    return this._headers[name.toLowerCase()];
+  }
+
+  getHeaders() {
+    return this._headers;
+  }
+
+  getHeaderNames() {
+    return Object.keys(this._headers);
+  }
+
+  hasHeader(name) {
+    return name.toLowerCase() in this._headers;
+  }
+
+  removeHeader(name) {
+    delete this._headers[name.toLowerCase()];
+  }
+
+  addTrailers(_headers) {}
+
+  flushHeaders() {}
+
+}
+
+exports.ServerResponse = ServerResponse;

node_modules/unenv/runtime/node/http/_response.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import type http from "node:http";
+import type { Socket } from "node:net";
+import { Callback, HeadersObject } from "../../_internal/types";
+import { Writable } from "../stream/writable";
+export declare class ServerResponse extends Writable implements http.ServerResponse {
+    statusCode: number;
+    statusMessage: string;
+    upgrading: boolean;
+    chunkedEncoding: boolean;
+    shouldKeepAlive: boolean;
+    useChunkedEncodingByDefault: boolean;
+    sendDate: boolean;
+    finished: boolean;
+    headersSent: boolean;
+    connection: Socket | null;
+    socket: Socket | null;
+    req: http.IncomingMessage;
+    _headers: HeadersObject;
+    constructor(req: http.IncomingMessage);
+    assignSocket(socket: Socket): void;
+    _flush(): void;
+    detachSocket(_socket: Socket): void;
+    writeContinue(_callback?: Callback): void;
+    writeHead(statusCode: number, arg1?: string | http.OutgoingHttpHeaders | http.OutgoingHttpHeader[], arg2?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[]): this;
+    writeProcessing(): void;
+    setTimeout(_msecs: number, _callback?: Callback): this;
+    setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
+    getHeader(name: string): number | string | string[] | undefined;
+    getHeaders(): http.OutgoingHttpHeaders;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    addTrailers(_headers: http.OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void;
+    flushHeaders(): void;
+}

node_modules/unenv/runtime/node/http/_response.mjs

@@ -0,0 +1,81 @@
+import { Writable } from "../stream/writable.mjs";
+export class ServerResponse extends Writable {
+  constructor(req) {
+    super();
+    this.statusCode = 200;
+    this.statusMessage = "";
+    this.upgrading = false;
+    this.chunkedEncoding = false;
+    this.shouldKeepAlive = false;
+    this.useChunkedEncodingByDefault = false;
+    this.sendDate = false;
+    this.finished = false;
+    this.headersSent = false;
+    this.connection = null;
+    this.socket = null;
+    this._headers = {};
+    this.req = req;
+  }
+  assignSocket(socket) {
+    socket._httpMessage = this;
+    this.socket = socket;
+    this.connection = socket;
+    this.emit("socket", socket);
+    this._flush();
+  }
+  _flush() {
+    this.flushHeaders();
+  }
+  detachSocket(_socket) {
+  }
+  writeContinue(_callback) {
+  }
+  writeHead(statusCode, arg1, arg2) {
+    if (statusCode) {
+      this.statusCode = statusCode;
+    }
+    if (typeof arg1 === "string") {
+      this.statusMessage = arg1;
+      arg1 = void 0;
+    }
+    const headers = arg2 || arg1;
+    if (headers) {
+      if (Array.isArray(headers)) {
+      } else {
+        for (const key in headers) {
+          this.setHeader(key, headers[key]);
+        }
+      }
+    }
+    this.headersSent = true;
+    return this;
+  }
+  writeProcessing() {
+  }
+  setTimeout(_msecs, _callback) {
+    return this;
+  }
+  setHeader(name, value) {
+    this._headers[name.toLowerCase()] = value + "";
+    return this;
+  }
+  getHeader(name) {
+    return this._headers[name.toLowerCase()];
+  }
+  getHeaders() {
+    return this._headers;
+  }
+  getHeaderNames() {
+    return Object.keys(this._headers);
+  }
+  hasHeader(name) {
+    return name.toLowerCase() in this._headers;
+  }
+  removeHeader(name) {
+    delete this._headers[name.toLowerCase()];
+  }
+  addTrailers(_headers) {
+  }
+  flushHeaders() {
+  }
+}

node_modules/unenv/runtime/node/http/index.cjs

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  createServer: true,
+  request: true,
+  get: true,
+  Server: true,
+  OutgoingMessage: true,
+  ClientRequest: true,
+  Agent: true,
+  globalAgent: true
+};
+exports.request = exports.globalAgent = exports.get = exports.default = exports.createServer = exports.Server = exports.OutgoingMessage = exports.ClientRequest = exports.Agent = void 0;
+
+var _utils = require("../../_internal/utils.cjs");
+
+var _proxy = _interopRequireDefault(require("../../mock/proxy.cjs"));
+
+var consts = _interopRequireWildcard(require("./_consts.cjs"));
+
+Object.keys(consts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === consts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return consts[key];
+    }
+  });
+});
+
+var _request = require("./_request.cjs");
+
+Object.keys(_request).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _request[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _request[key];
+    }
+  });
+});
+
+var _response = require("./_response.cjs");
+
+Object.keys(_response).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _response[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _response[key];
+    }
+  });
+});
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const createServer = (0, _utils.notImplemented)("http.createServer");
+exports.createServer = createServer;
+const request = (0, _utils.notImplemented)("http.request");
+exports.request = request;
+const get = (0, _utils.notImplemented)("http.get");
+exports.get = get;
+
+const Server = _proxy.default.__createMock__("http.Server");
+
+exports.Server = Server;
+
+const OutgoingMessage = _proxy.default.__createMock__("http.OutgoingMessage");
+
+exports.OutgoingMessage = OutgoingMessage;
+
+const ClientRequest = _proxy.default.__createMock__("http.ClientRequest");
+
+exports.ClientRequest = ClientRequest;
+
+const Agent = _proxy.default.__createMock__("http.Agent");
+
+exports.Agent = Agent;
+const globalAgent = new Agent();
+exports.globalAgent = globalAgent;
+var _default = { ...consts,
+  IncomingMessage: _request.IncomingMessage,
+  ServerResponse: _response.ServerResponse,
+  createServer,
+  request,
+  get,
+  Server,
+  OutgoingMessage,
+  ClientRequest,
+  Agent,
+  globalAgent
+};
+module.exports = _default;

node_modules/unenv/runtime/node/http/index.d.ts

@@ -0,0 +1,14 @@
+import http from "node:http";
+export * from "./_consts";
+export * from "./_request";
+export * from "./_response";
+export declare const createServer: typeof http.createServer;
+export declare const request: typeof http.request;
+export declare const get: typeof http.get;
+export declare const Server: typeof http.Server;
+export declare const OutgoingMessage: typeof http.OutgoingMessage;
+export declare const ClientRequest: typeof http.ClientRequest;
+export declare const Agent: typeof http.Agent;
+export declare const globalAgent: typeof http.globalAgent;
+declare const _default: any;
+export default _default;

node_modules/unenv/runtime/node/http/index.mjs

@@ -0,0 +1,29 @@
+import { notImplemented } from "../../_internal/utils.mjs";
+import mock from "../../mock/proxy.mjs";
+import * as consts from "./_consts.mjs";
+import { IncomingMessage } from "./_request.mjs";
+import { ServerResponse } from "./_response.mjs";
+export * from "./_consts.mjs";
+export * from "./_request.mjs";
+export * from "./_response.mjs";
+export const createServer = notImplemented("http.createServer");
+export const request = notImplemented("http.request");
+export const get = notImplemented("http.get");
+export const Server = mock.__createMock__("http.Server");
+export const OutgoingMessage = mock.__createMock__("http.OutgoingMessage");
+export const ClientRequest = mock.__createMock__("http.ClientRequest");
+export const Agent = mock.__createMock__("http.Agent");
+export const globalAgent = new Agent();
+export default {
+  ...consts,
+  IncomingMessage,
+  ServerResponse,
+  createServer,
+  request,
+  get,
+  Server,
+  OutgoingMessage,
+  ClientRequest,
+  Agent,
+  globalAgent
+};