Something went wrong. Try again.
MIRROR: javascript for 🐜's, a tiny runtime with big ambitions ant.themackabu.dev
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194import * as http from 'node:http';import tls from 'node:tls';
const TLS_SERVER_OPTION_KEYS = [ 'ALPNProtocols', 'SNICallback', 'allowPartialChain', 'ca', 'cert', 'ciphers', 'clientCertEngine', 'crl', 'dhparam', 'ecdhCurve', 'honorCipherOrder', 'key', 'maxVersion', 'minVersion', 'passphrase', 'pfx', 'rejectUnauthorized', 'requestCert', 'secureOptions', 'secureContext', 'secureProtocol', 'sessionIdContext', 'sigalgs', 'ticketKeys'];
function createPlainObject() { return Object.create(null);}
function splitServerOptions(options) { const httpOptions = createPlainObject(); const tlsOptions = createPlainObject(); let hasTlsOptions = false;
if (!options || typeof options !== 'object') { return { httpOptions: undefined, tlsOptions: undefined, hasTlsOptions: false }; }
Object.keys(options).forEach(key => { if (TLS_SERVER_OPTION_KEYS.includes(key)) { tlsOptions[key] = options[key]; hasTlsOptions = true; return; }
httpOptions[key] = options[key]; });
return { httpOptions, tlsOptions: hasTlsOptions ? tlsOptions : undefined, hasTlsOptions };}
function normalizeCreateServerArgs(options, requestListener) { if (typeof options === 'function') { return { serverOptions: undefined, requestListener: options }; }
return { serverOptions: options, requestListener };}
function createInvalidProtocolError(protocol) { const error = new TypeError(`Protocol "${protocol}" not supported. Expected "https:"`); error.code = 'ERR_INVALID_PROTOCOL'; return error;}
function getProtocolFromInput(input) { if (typeof input === 'string') return new URL(input).protocol; if (!input || typeof input !== 'object') return undefined; if (typeof input.href === 'string') return new URL(String(input)).protocol; if (input.protocol === undefined || input.protocol === null) return undefined; return String(input.protocol);}
function assertHttpsProtocol(protocol) { if (protocol === undefined || protocol === null || protocol === '') return; if (String(protocol) !== 'https:') throw createInvalidProtocolError(String(protocol));}
function applyDefaultHttpsProtocol(input, options) { const optionProtocol = options && typeof options === 'object' ? options.protocol : undefined; assertHttpsProtocol(optionProtocol);
if (typeof input === 'string' || (input && typeof input === 'object' && typeof input.href === 'string')) { if (optionProtocol === undefined) assertHttpsProtocol(getProtocolFromInput(input)); return [input, options]; }
if (typeof input === 'function' || input === undefined || input === null) { return [{ protocol: 'https:' }, options]; }
assertHttpsProtocol(getProtocolFromInput(input)); return [{ ...input, protocol: input.protocol ?? 'https:' }, options];}
const HTTP_SERVER_METHODS = ['_attachSocket', '_drainSocket', 'closeAllConnections', 'closeIdleConnections', 'setTimeout'];
export class Server extends tls.Server { constructor(options, requestListener) { const normalized = normalizeCreateServerArgs(options, requestListener); const split = splitServerOptions(normalized.serverOptions);
super(split.tlsOptions); this.timeout = 0; this.headersTimeout = 60000; this.requestTimeout = 300000; this.keepAliveTimeout = 5000; this.maxHeadersCount = 2000; this._socketStates = new Set(); this._closing = false;
this.on('secureConnection', socket => { this.emit('connection', socket); this._attachSocket(socket); });
if (typeof normalized.requestListener === 'function') this.on('request', normalized.requestListener); }
listen(...args) { this._closing = false; return super.listen(...args); }
close(callback) { this._closing = true; this.closeIdleConnections(); return super.close(callback); }}
for (const name of HTTP_SERVER_METHODS) { Object.defineProperty(Server.prototype, name, { value: http.Server.prototype[name], writable: true, configurable: true });}
export class Agent extends http.Agent { constructor(options) { super(options); this.defaultPort = 443; this.protocol = 'https:'; this.maxCachedSessions = this.options.maxCachedSessions ?? 100; this._sessionCache = { map: Object.create(null), list: [] }; }}
export const globalAgent = new Agent();
export function createSecureContext(options) { return tls.createSecureContext(options);}
export function isSecureContext(value) { return tls.isSecureContext(value);}
export function setConfigPath(path) { return tls.setConfigPath(path);}
export function createServer(options, requestListener) { return new Server(options, requestListener);}
export function request(input, options, callback) { const [resolvedInput, resolvedOptions] = applyDefaultHttpsProtocol(input, options); return http.request(resolvedInput, resolvedOptions, callback);}
export function get(input, options, callback) { const [resolvedInput, resolvedOptions] = applyDefaultHttpsProtocol(input, options); return http.get(resolvedInput, resolvedOptions, callback);}
export { METHODS, STATUS_CODES } from 'ant:internal/http_metadata';