Diffusion Ant (mir/inline-method) Code

ant/src/builtins/node/https.mjs
3fa05edd2fe3mir/inline-method

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';

Owner Packages

No Owners