game_dig 0.0.1 → 0.2.0

data/lib/game_dig/node/node_modules/http2-wrapper/source/proxies/h1-over-h2.js

@@ -0,0 +1,90 @@
+'use strict';
+const tls = require('tls');
+const http = require('http');
+const https = require('https');
+const JSStreamSocket = require('../utils/js-stream-socket.js');
+const {globalAgent} = require('../agent.js');
+const UnexpectedStatusCodeError = require('./unexpected-status-code-error.js');
+const initialize = require('./initialize.js');
+const getAuthorizationHeaders = require('./get-auth-headers.js');
+
+const createConnection = (self, options, callback) => {
+	(async () => {
+		try {
+			const {proxyOptions} = self;
+			const {url, headers, raw} = proxyOptions;
+
+			const stream = await globalAgent.request(url, proxyOptions, {
+				...getAuthorizationHeaders(self),
+				...headers,
+				':method': 'CONNECT',
+				':authority': `${options.host}:${options.port}`
+			});
+
+			stream.once('error', callback);
+			stream.once('response', headers => {
+				const statusCode = headers[':status'];
+
+				if (statusCode !== 200) {
+					callback(new UnexpectedStatusCodeError(statusCode, ''));
+					return;
+				}
+
+				const encrypted = self instanceof https.Agent;
+
+				if (raw && encrypted) {
+					options.socket = stream;
+					const secureStream = tls.connect(options);
+
+					secureStream.once('close', () => {
+						stream.destroy();
+					});
+
+					callback(null, secureStream);
+					return;
+				}
+
+				const socket = new JSStreamSocket(stream);
+				socket.encrypted = false;
+				socket._handle.getpeername = out => {
+					out.family = undefined;
+					out.address = undefined;
+					out.port = undefined;
+				};
+
+				callback(null, socket);
+			});
+		} catch (error) {
+			callback(error);
+		}
+	})();
+};
+
+class HttpOverHttp2 extends http.Agent {
+	constructor(options) {
+		super(options);
+
+		initialize(this, options.proxyOptions);
+	}
+
+	createConnection(options, callback) {
+		createConnection(this, options, callback);
+	}
+}
+
+class HttpsOverHttp2 extends https.Agent {
+	constructor(options) {
+		super(options);
+
+		initialize(this, options.proxyOptions);
+	}
+
+	createConnection(options, callback) {
+		createConnection(this, options, callback);
+	}
+}
+
+module.exports = {
+	HttpOverHttp2,
+	HttpsOverHttp2
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/proxies/h2-over-h1.js

@@ -0,0 +1,48 @@
+'use strict';
+const http = require('http');
+const https = require('https');
+const Http2OverHttpX = require('./h2-over-hx.js');
+const getAuthorizationHeaders = require('./get-auth-headers.js');
+
+const getStream = request => new Promise((resolve, reject) => {
+	const onConnect = (response, socket, head) => {
+		socket.unshift(head);
+
+		request.off('error', reject);
+		resolve([socket, response.statusCode, response.statusMessage]);
+	};
+
+	request.once('error', reject);
+	request.once('connect', onConnect);
+});
+
+class Http2OverHttp extends Http2OverHttpX {
+	async _getProxyStream(authority) {
+		const {proxyOptions} = this;
+		const {url, headers} = this.proxyOptions;
+
+		const network = url.protocol === 'https:' ? https : http;
+
+		// `new URL('https://localhost/httpbin.org:443')` results in
+		// a `/httpbin.org:443` path, which has an invalid leading slash.
+		const request = network.request({
+			...proxyOptions,
+			hostname: url.hostname,
+			port: url.port,
+			path: authority,
+			headers: {
+				...getAuthorizationHeaders(this),
+				...headers,
+				host: authority
+			},
+			method: 'CONNECT'
+		}).end();
+
+		return getStream(request);
+	}
+}
+
+module.exports = {
+	Http2OverHttp,
+	Http2OverHttps: Http2OverHttp
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/proxies/h2-over-h2.js

@@ -0,0 +1,32 @@
+'use strict';
+const {globalAgent} = require('../agent.js');
+const Http2OverHttpX = require('./h2-over-hx.js');
+const getAuthorizationHeaders = require('./get-auth-headers.js');
+
+const getStatusCode = stream => new Promise((resolve, reject) => {
+	stream.once('error', reject);
+	stream.once('response', headers => {
+		stream.off('error', reject);
+		resolve(headers[':status']);
+	});
+});
+
+class Http2OverHttp2 extends Http2OverHttpX {
+	async _getProxyStream(authority) {
+		const {proxyOptions} = this;
+
+		const headers = {
+			...getAuthorizationHeaders(this),
+			...proxyOptions.headers,
+			':method': 'CONNECT',
+			':authority': authority
+		};
+
+		const stream = await globalAgent.request(proxyOptions.url, proxyOptions, headers);
+		const statusCode = await getStatusCode(stream);
+
+		return [stream, statusCode, ''];
+	}
+}
+
+module.exports = Http2OverHttp2;

data/lib/game_dig/node/node_modules/http2-wrapper/source/proxies/h2-over-hx.js

@@ -0,0 +1,40 @@
+'use strict';
+const {Agent} = require('../agent.js');
+const JSStreamSocket = require('../utils/js-stream-socket.js');
+const UnexpectedStatusCodeError = require('./unexpected-status-code-error.js');
+const initialize = require('./initialize.js');
+
+class Http2OverHttpX extends Agent {
+	constructor(options) {
+		super(options);
+
+		initialize(this, options.proxyOptions);
+	}
+
+	async createConnection(origin, options) {
+		const authority = `${origin.hostname}:${origin.port || 443}`;
+
+		const [stream, statusCode, statusMessage] = await this._getProxyStream(authority);
+		if (statusCode !== 200) {
+			throw new UnexpectedStatusCodeError(statusCode, statusMessage);
+		}
+
+		if (this.proxyOptions.raw) {
+			options.socket = stream;
+		} else {
+			const socket = new JSStreamSocket(stream);
+			socket.encrypted = false;
+			socket._handle.getpeername = out => {
+				out.family = undefined;
+				out.address = undefined;
+				out.port = undefined;
+			};
+
+			return socket;
+		}
+
+		return super.createConnection(origin, options);
+	}
+}
+
+module.exports = Http2OverHttpX;

data/lib/game_dig/node/node_modules/http2-wrapper/source/proxies/initialize.js

@@ -0,0 +1,21 @@
+'use strict';
+// See https://github.com/facebook/jest/issues/2549
+// eslint-disable-next-line node/prefer-global/url
+const {URL} = require('url');
+const checkType = require('../utils/check-type.js');
+
+module.exports = (self, proxyOptions) => {
+	checkType('proxyOptions', proxyOptions, ['object']);
+	checkType('proxyOptions.headers', proxyOptions.headers, ['object', 'undefined']);
+	checkType('proxyOptions.raw', proxyOptions.raw, ['boolean', 'undefined']);
+	checkType('proxyOptions.url', proxyOptions.url, [URL, 'string']);
+
+	const url = new URL(proxyOptions.url);
+
+	self.proxyOptions = {
+		raw: true,
+		...proxyOptions,
+		headers: {...proxyOptions.headers},
+		url
+	};
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/proxies/unexpected-status-code-error.js

@@ -0,0 +1,11 @@
+'use strict';
+
+class UnexpectedStatusCodeError extends Error {
+	constructor(statusCode, statusMessage = '') {
+		super(`The proxy server rejected the request with status code ${statusCode} (${statusMessage || 'empty status message'})`);
+		this.statusCode = statusCode;
+		this.statusMessage = statusMessage;
+	}
+}
+
+module.exports = UnexpectedStatusCodeError;

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/calculate-server-name.js

@@ -0,0 +1,29 @@
+'use strict';
+const {isIP} = require('net');
+const assert = require('assert');
+
+const getHost = host => {
+	if (host[0] === '[') {
+		const idx = host.indexOf(']');
+
+		assert(idx !== -1);
+		return host.slice(1, idx);
+	}
+
+	const idx = host.indexOf(':');
+	if (idx === -1) {
+		return host;
+	}
+
+	return host.slice(0, idx);
+};
+
+module.exports = host => {
+	const servername = getHost(host);
+
+	if (isIP(servername)) {
+		return '';
+	}
+
+	return servername;
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/check-type.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const checkType = (name, value, types) => {
+	const valid = types.some(type => {
+		const typeofType = typeof type;
+		if (typeofType === 'string') {
+			return typeof value === type;
+		}
+
+		return value instanceof type;
+	});
+
+	if (!valid) {
+		const names = types.map(type => typeof type === 'string' ? type : type.name);
+
+		throw new TypeError(`Expected '${name}' to be a type of ${names.join(' or ')}, got ${typeof value}`);
+	}
+};
+
+module.exports = checkType;

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/delay-async-destroy.js

@@ -0,0 +1,33 @@
+'use strict';
+
+module.exports = stream => {
+	if (stream.listenerCount('error') !== 0) {
+		return stream;
+	}
+
+	stream.__destroy = stream._destroy;
+	stream._destroy = (...args) => {
+		const callback = args.pop();
+
+		stream.__destroy(...args, async error => {
+			await Promise.resolve();
+			callback(error);
+		});
+	};
+
+	const onError = error => {
+		// eslint-disable-next-line promise/prefer-await-to-then
+		Promise.resolve().then(() => {
+			stream.emit('error', error);
+		});
+	};
+
+	stream.once('error', onError);
+
+	// eslint-disable-next-line promise/prefer-await-to-then
+	Promise.resolve().then(() => {
+		stream.off('error', onError);
+	});
+
+	return stream;
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/errors.js

@@ -0,0 +1,51 @@
+'use strict';
+/* istanbul ignore file: https://github.com/nodejs/node/blob/master/lib/internal/errors.js */
+
+const makeError = (Base, key, getMessage) => {
+	module.exports[key] = class NodeError extends Base {
+		constructor(...args) {
+			super(typeof getMessage === 'string' ? getMessage : getMessage(args));
+			this.name = `${super.name} [${key}]`;
+			this.code = key;
+		}
+	};
+};
+
+makeError(TypeError, 'ERR_INVALID_ARG_TYPE', args => {
+	const type = args[0].includes('.') ? 'property' : 'argument';
+
+	let valid = args[1];
+	const isManyTypes = Array.isArray(valid);
+
+	if (isManyTypes) {
+		valid = `${valid.slice(0, -1).join(', ')} or ${valid.slice(-1)}`;
+	}
+
+	return `The "${args[0]}" ${type} must be ${isManyTypes ? 'one of' : 'of'} type ${valid}. Received ${typeof args[2]}`;
+});
+
+makeError(TypeError, 'ERR_INVALID_PROTOCOL', args =>
+	`Protocol "${args[0]}" not supported. Expected "${args[1]}"`
+);
+
+makeError(Error, 'ERR_HTTP_HEADERS_SENT', args =>
+	`Cannot ${args[0]} headers after they are sent to the client`
+);
+
+makeError(TypeError, 'ERR_INVALID_HTTP_TOKEN', args =>
+	`${args[0]} must be a valid HTTP token [${args[1]}]`
+);
+
+makeError(TypeError, 'ERR_HTTP_INVALID_HEADER_VALUE', args =>
+	`Invalid value "${args[0]} for header "${args[1]}"`
+);
+
+makeError(TypeError, 'ERR_INVALID_CHAR', args =>
+	`Invalid character in ${args[0]} [${args[1]}]`
+);
+
+makeError(
+	Error,
+	'ERR_HTTP2_NO_SOCKET_MANIPULATION',
+	'HTTP/2 sockets should not be directly manipulated (e.g. read and written)'
+);

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/is-request-pseudo-header.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = header => {
+	switch (header) {
+		case ':method':
+		case ':scheme':
+		case ':authority':
+		case ':path':
+			return true;
+		default:
+			return false;
+	}
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/js-stream-socket.js

@@ -0,0 +1,8 @@
+'use strict';
+const stream = require('stream');
+const tls = require('tls');
+
+// Really awesome hack.
+const JSStreamSocket = (new tls.TLSSocket(new stream.PassThrough()))._handle._parentWrap.constructor;
+
+module.exports = JSStreamSocket;

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/proxy-events.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = (from, to, events) => {
+	for (const event of events) {
+		from.on(event, (...args) => to.emit(event, ...args));
+	}
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/proxy-socket-handler.js

@@ -0,0 +1,102 @@
+'use strict';
+const {ERR_HTTP2_NO_SOCKET_MANIPULATION} = require('./errors.js');
+
+/* istanbul ignore file */
+/* https://github.com/nodejs/node/blob/6eec858f34a40ffa489c1ec54bb24da72a28c781/lib/internal/http2/compat.js#L195-L272 */
+
+const proxySocketHandler = {
+	has(stream, property) {
+		// Replaced [kSocket] with .socket
+		const reference = stream.session === undefined ? stream : stream.session.socket;
+		return (property in stream) || (property in reference);
+	},
+
+	get(stream, property) {
+		switch (property) {
+			case 'on':
+			case 'once':
+			case 'end':
+			case 'emit':
+			case 'destroy':
+				return stream[property].bind(stream);
+			case 'writable':
+			case 'destroyed':
+				return stream[property];
+			case 'readable':
+				if (stream.destroyed) {
+					return false;
+				}
+
+				return stream.readable;
+			case 'setTimeout': {
+				const {session} = stream;
+				if (session !== undefined) {
+					return session.setTimeout.bind(session);
+				}
+
+				return stream.setTimeout.bind(stream);
+			}
+
+			case 'write':
+			case 'read':
+			case 'pause':
+			case 'resume':
+				throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
+			default: {
+				// Replaced [kSocket] with .socket
+				const reference = stream.session === undefined ? stream : stream.session.socket;
+				const value = reference[property];
+
+				return typeof value === 'function' ? value.bind(reference) : value;
+			}
+		}
+	},
+
+	getPrototypeOf(stream) {
+		if (stream.session !== undefined) {
+			// Replaced [kSocket] with .socket
+			return Reflect.getPrototypeOf(stream.session.socket);
+		}
+
+		return Reflect.getPrototypeOf(stream);
+	},
+
+	set(stream, property, value) {
+		switch (property) {
+			case 'writable':
+			case 'readable':
+			case 'destroyed':
+			case 'on':
+			case 'once':
+			case 'end':
+			case 'emit':
+			case 'destroy':
+				stream[property] = value;
+				return true;
+			case 'setTimeout': {
+				const {session} = stream;
+				if (session === undefined) {
+					stream.setTimeout = value;
+				} else {
+					session.setTimeout = value;
+				}
+
+				return true;
+			}
+
+			case 'write':
+			case 'read':
+			case 'pause':
+			case 'resume':
+				throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
+			default: {
+				// Replaced [kSocket] with .socket
+				const reference = stream.session === undefined ? stream : stream.session.socket;
+				reference[property] = value;
+				return true;
+			}
+		}
+	}
+};
+
+module.exports = proxySocketHandler;

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/validate-header-name.js

@@ -0,0 +1,11 @@
+'use strict';
+const {ERR_INVALID_HTTP_TOKEN} = require('./errors.js');
+const isRequestPseudoHeader = require('./is-request-pseudo-header.js');
+
+const isValidHttpToken = /^[\^`\-\w!#$%&*+.|~]+$/;
+
+module.exports = name => {
+	if (typeof name !== 'string' || (!isValidHttpToken.test(name) && !isRequestPseudoHeader(name))) {
+		throw new ERR_INVALID_HTTP_TOKEN('Header name', name);
+	}
+};

data/lib/game_dig/node/node_modules/http2-wrapper/source/utils/validate-header-value.js

@@ -0,0 +1,17 @@
+'use strict';
+const {
+	ERR_HTTP_INVALID_HEADER_VALUE,
+	ERR_INVALID_CHAR
+} = require('./errors.js');
+
+const isInvalidHeaderValue = /[^\t\u0020-\u007E\u0080-\u00FF]/;
+
+module.exports = (name, value) => {
+	if (typeof value === 'undefined') {
+		throw new ERR_HTTP_INVALID_HEADER_VALUE(value, name);
+	}
+
+	if (isInvalidHeaderValue.test(value)) {
+		throw new ERR_INVALID_CHAR('header content', name);
+	}
+};