https.mjs
No OneTemporary
Actions

Size

4 KB

Referenced Files

None

Subscribers

None

https.mjs
View Options

	import * as http from 'node:http';
	import tls from 'ant:internal/tls';

	const kSecureContext = Symbol('ant.internal.https.secureContext');

	const TLS_CONTEXT_OPTION_KEYS = ['allowPartialChain', 'ca', 'cert', 'key'];

	const TLS_SERVER_OPTION_KEYS = [
	'ALPNProtocols',
	'SNICallback',
	'allowPartialChain',
	'ca',
	'cert',
	'ciphers',
	'clientCertEngine',
	'crl',
	'dhparam',
	'ecdhCurve',
	'honorCipherOrder',
	'key',
	'maxVersion',
	'minVersion',
	'passphrase',
	'pfx',
	'rejectUnauthorized',
	'requestCert',
	'secureOptions',
	'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 toContextOptions(options) {
	const contextOptions = createPlainObject();

	if (!options) return contextOptions;
	TLS_CONTEXT_OPTION_KEYS.forEach(key => {
	if (options[key] !== undefined) contextOptions[key] = options[key];
	});
	return contextOptions;
	}

	function maybeCreateSecureContext(options) {
	if (!options) return undefined;
	return tls.createContext(toContextOptions(options));
	}

	function normalizeCreateServerArgs(options, requestListener) {
	if (typeof options === 'function') {
	return {
	serverOptions: undefined,
	requestListener: options
	};
	}

	return {
	serverOptions: options,
	requestListener
	};
	}

	function clientNotImplemented() {
	throw new Error('node:https client transport is not implemented yet');
	}

	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];
	}

	// compatibility stub only
	export class Server extends http.Server {
	constructor(options, requestListener) {
	const normalized = normalizeCreateServerArgs(options, requestListener);
	const split = splitServerOptions(normalized.serverOptions);

	super(split.httpOptions, normalized.requestListener);
	this[kSecureContext] = split.hasTlsOptions ? maybeCreateSecureContext(split.tlsOptions) : undefined;
	}
	}

	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.createContext(options);
	}

	export function isSecureContext(value) {
	return tls.isContext(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';

File Metadata

Mime Type: application/javascript
Expires: Sat, May 2, 9:41 AM (2 d)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 544119
Default Alt Text: https.mjs (4 KB)

Event Timeline