game_dig 0.1.0 → 0.2.0

data/lib/game_dig/node/node_modules/normalize-url/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "normalize-url",
+	"version": "8.1.0",
+	"description": "Normalize a URL",
+	"license": "MIT",
+	"repository": "sindresorhus/normalize-url",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"type": "module",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=14.16"
+	},
+	"scripts": {
+		"//test": "xo && c8 ava && tsd",
+		"test": "c8 ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"normalize",
+		"url",
+		"uri",
+		"address",
+		"string",
+		"normalization",
+		"normalisation",
+		"query",
+		"querystring",
+		"simplify",
+		"strip",
+		"trim",
+		"canonical"
+	],
+	"devDependencies": {
+		"ava": "^5.0.1",
+		"c8": "^7.12.0",
+		"tsd": "^0.24.1",
+		"xo": "^0.52.4"
+	},
+	"c8": {
+		"reporter": [
+			"text",
+			"lcov"
+		]
+	}
+}

data/lib/game_dig/node/node_modules/normalize-url/readme.md

@@ -0,0 +1,347 @@
+# normalize-url [![Coverage Status](https://codecov.io/gh/sindresorhus/normalize-url/branch/main/graph/badge.svg)](https://codecov.io/gh/sindresorhus/normalize-url)
+
+> [Normalize](https://en.wikipedia.org/wiki/URL_normalization) a URL
+
+Useful when you need to display, store, deduplicate, sort, compare, etc, URLs.
+
+**Note:** This package does **not** do URL sanitization. [Garbage in, garbage out.](https://en.wikipedia.org/wiki/Garbage_in,_garbage_out) If you use this in a server context and accept URLs as user input, it's up to you to protect against invalid URLs, [path traversal attacks](https://owasp.org/www-community/attacks/Path_Traversal), etc.
+
+## Install
+
+```sh
+npm install normalize-url
+```
+
+## Usage
+
+```js
+import normalizeUrl from 'normalize-url';
+
+normalizeUrl('sindresorhus.com');
+//=> 'http://sindresorhus.com'
+
+normalizeUrl('//www.sindresorhus.com:80/../baz?b=bar&a=foo');
+//=> 'http://sindresorhus.com/baz?a=foo&b=bar'
+```
+
+## API
+
+### normalizeUrl(url, options?)
+
+URLs with custom protocols are not normalized and just passed through by default. Supported protocols are: `https`, `http`, `file`, and `data`.
+
+Human-friendly URLs with basic auth (for example, `user:password@sindresorhus.com`) are not handled because basic auth conflicts with custom protocols. [Basic auth URLs are also deprecated.](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication#access_using_credentials_in_the_url)
+
+#### url
+
+Type: `string`
+
+URL to normalize, including [data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs).
+
+#### options
+
+Type: `object`
+
+##### defaultProtocol
+
+Type: `string`\
+Default: `'http'`\
+Values: `'https' | 'http'`
+
+##### normalizeProtocol
+
+Type: `boolean`\
+Default: `true`
+
+Prepend `defaultProtocol` to the URL if it's protocol-relative.
+
+```js
+normalizeUrl('//sindresorhus.com');
+//=> 'http://sindresorhus.com'
+
+normalizeUrl('//sindresorhus.com', {normalizeProtocol: false});
+//=> '//sindresorhus.com'
+```
+
+##### forceHttp
+
+Type: `boolean`\
+Default: `false`
+
+Normalize HTTPS to HTTP.
+
+```js
+normalizeUrl('https://sindresorhus.com');
+//=> 'https://sindresorhus.com'
+
+normalizeUrl('https://sindresorhus.com', {forceHttp: true});
+//=> 'http://sindresorhus.com'
+```
+
+##### forceHttps
+
+Type: `boolean`\
+Default: `false`
+
+Normalize HTTP to HTTPS.
+
+```js
+normalizeUrl('http://sindresorhus.com');
+//=> 'http://sindresorhus.com'
+
+normalizeUrl('http://sindresorhus.com', {forceHttps: true});
+//=> 'https://sindresorhus.com'
+```
+
+This option cannot be used with the `forceHttp` option at the same time.
+
+##### stripAuthentication
+
+Type: `boolean`\
+Default: `true`
+
+Strip the [authentication](https://en.wikipedia.org/wiki/Basic_access_authentication) part of the URL.
+
+```js
+normalizeUrl('https://user:password@sindresorhus.com');
+//=> 'https://sindresorhus.com'
+
+normalizeUrl('https://user:password@sindresorhus.com', {stripAuthentication: false});
+//=> 'https://user:password@sindresorhus.com'
+```
+
+##### stripHash
+
+Type: `boolean`\
+Default: `false`
+
+Strip the hash part of the URL.
+
+```js
+normalizeUrl('sindresorhus.com/about.html#contact');
+//=> 'http://sindresorhus.com/about.html#contact'
+
+normalizeUrl('sindresorhus.com/about.html#contact', {stripHash: true});
+//=> 'http://sindresorhus.com/about.html'
+```
+
+##### stripProtocol
+
+Type: `boolean`\
+Default: `false`
+
+Remove the protocol from the URL: `http://sindresorhus.com` → `sindresorhus.com`.
+
+It will only remove `https://` and `http://` protocols.
+
+```js
+normalizeUrl('https://sindresorhus.com');
+//=> 'https://sindresorhus.com'
+
+normalizeUrl('https://sindresorhus.com', {stripProtocol: true});
+//=> 'sindresorhus.com'
+```
+
+##### stripTextFragment
+
+Type: `boolean`\
+Default: `true`
+
+Strip the [text fragment](https://web.dev/text-fragments/) part of the URL.
+
+**Note:** The text fragment will always be removed if the `stripHash` option is set to `true`, as the hash contains the text fragment.
+
+```js
+normalizeUrl('http://sindresorhus.com/about.html#:~:text=hello');
+//=> 'http://sindresorhus.com/about.html#'
+
+normalizeUrl('http://sindresorhus.com/about.html#section:~:text=hello');
+//=> 'http://sindresorhus.com/about.html#section'
+
+normalizeUrl('http://sindresorhus.com/about.html#:~:text=hello', {stripTextFragment: false});
+//=> 'http://sindresorhus.com/about.html#:~:text=hello'
+
+normalizeUrl('http://sindresorhus.com/about.html#section:~:text=hello', {stripTextFragment: false});
+//=> 'http://sindresorhus.com/about.html#section:~:text=hello'
+```
+
+##### stripWWW
+
+Type: `boolean`\
+Default: `true`
+
+Remove `www.` from the URL.
+
+```js
+normalizeUrl('http://www.sindresorhus.com');
+//=> 'http://sindresorhus.com'
+
+normalizeUrl('http://www.sindresorhus.com', {stripWWW: false});
+//=> 'http://www.sindresorhus.com'
+```
+
+##### removeQueryParameters
+
+Type: `Array<RegExp | string> | boolean`\
+Default: `[/^utm_\w+/i]`
+
+Remove query parameters that matches any of the provided strings or regexes.
+
+```js
+normalizeUrl('www.sindresorhus.com?foo=bar&ref=test_ref', {
+	removeQueryParameters: ['ref']
+});
+//=> 'http://sindresorhus.com/?foo=bar'
+```
+
+If a boolean is provided, `true` will remove all the query parameters.
+
+```js
+normalizeUrl('www.sindresorhus.com?foo=bar', {
+	removeQueryParameters: true
+});
+//=> 'http://sindresorhus.com'
+```
+
+`false` will not remove any query parameter.
+
+```js
+normalizeUrl('www.sindresorhus.com?foo=bar&utm_medium=test&ref=test_ref', {
+	removeQueryParameters: false
+});
+//=> 'http://www.sindresorhus.com/?foo=bar&ref=test_ref&utm_medium=test'
+```
+
+##### keepQueryParameters
+
+Type: `Array<RegExp | string>`\
+Default: `undefined`
+
+Keeps only query parameters that matches any of the provided strings or regexes.
+
+**Note:** It overrides the `removeQueryParameters` option.
+
+```js
+normalizeUrl('https://sindresorhus.com?foo=bar&ref=unicorn', {
+	keepQueryParameters: ['ref']
+});
+//=> 'https://sindresorhus.com/?ref=unicorn'
+```
+
+##### removeTrailingSlash
+
+Type: `boolean`\
+Default: `true`
+
+Remove trailing slash.
+
+**Note:** Trailing slash is always removed if the URL doesn't have a pathname unless the `removeSingleSlash` option is set to `false`.
+
+```js
+normalizeUrl('http://sindresorhus.com/redirect/');
+//=> 'http://sindresorhus.com/redirect'
+
+normalizeUrl('http://sindresorhus.com/redirect/', {removeTrailingSlash: false});
+//=> 'http://sindresorhus.com/redirect/'
+
+normalizeUrl('http://sindresorhus.com/', {removeTrailingSlash: false});
+//=> 'http://sindresorhus.com'
+```
+
+##### removeSingleSlash
+
+Type: `boolean`\
+Default: `true`
+
+Remove a sole `/` pathname in the output. This option is independent of `removeTrailingSlash`.
+
+```js
+normalizeUrl('https://sindresorhus.com/');
+//=> 'https://sindresorhus.com'
+
+normalizeUrl('https://sindresorhus.com/', {removeSingleSlash: false});
+//=> 'https://sindresorhus.com/'
+```
+
+##### removeDirectoryIndex
+
+Type: `boolean | Array<RegExp | string>`\
+Default: `false`
+
+Removes the default directory index file from path that matches any of the provided strings or regexes. When `true`, the regex `/^index\.[a-z]+$/` is used.
+
+```js
+normalizeUrl('www.sindresorhus.com/foo/default.php', {
+	removeDirectoryIndex: [/^default\.[a-z]+$/]
+});
+//=> 'http://sindresorhus.com/foo'
+```
+
+##### removeExplicitPort
+
+Type: `boolean`\
+Default: `false`
+
+Removes an explicit port number from the URL.
+
+Port 443 is always removed from HTTPS URLs and 80 is always removed from HTTP URLs regardless of this option.
+
+```js
+normalizeUrl('sindresorhus.com:123', {
+	removeExplicitPort: true
+});
+//=> 'http://sindresorhus.com'
+```
+
+##### sortQueryParameters
+
+Type: `boolean`\
+Default: `true`
+
+Sorts the query parameters alphabetically by key.
+
+```js
+normalizeUrl('www.sindresorhus.com?b=two&a=one&c=three', {
+	sortQueryParameters: false
+});
+//=> 'http://sindresorhus.com/?b=two&a=one&c=three'
+```
+
+##### removePath
+
+Type: `boolean`\
+Default: `false`
+
+Removes the entire URL path, leaving only the domain.
+
+```js
+normalizeUrl('https://example.com/path/to/page', {
+	removePath: true
+});
+//=> 'https://example.com'
+```
+
+##### transformPath
+
+Type: `Function`\
+Default: `false`
+
+Custom function to transform the URL path components. The function receives an array of non-empty path components and should return a modified array.
+
+```js
+// Keep only the first path component
+normalizeUrl('https://example.com/api/v1/users', {
+	transformPath: (pathComponents) => pathComponents.slice(0, 1)
+});
+//=> 'https://example.com/api'
+
+// Remove specific components
+normalizeUrl('https://example.com/admin/users', {
+	transformPath: (pathComponents) => pathComponents.filter(c => c !== 'admin')
+});
+//=> 'https://example.com/users'
+```
+
+## Related
+
+- [compare-urls](https://github.com/sindresorhus/compare-urls) - Compare URLs by first normalizing them

data/lib/game_dig/node/node_modules/p-cancelable/index.d.ts

@@ -0,0 +1,168 @@
+/**
+The rejection reason when `.cancel()` is called.
+
+It includes a `.isCanceled` property for convenience.
+*/
+export class CancelError extends Error {
+	readonly name: 'CancelError';
+	readonly isCanceled: true;
+
+	constructor(reason?: string);
+}
+
+/**
+Accepts a function that is called when the promise is canceled.
+
+You're not required to call this function. You can call this function multiple times to add multiple cancel handlers.
+*/
+export interface OnCancelFunction {
+	shouldReject: boolean;
+	(cancelHandler: () => void): void;
+}
+
+export default class PCancelable<ValueType> extends Promise<ValueType> {
+	/**
+	Whether the promise is canceled.
+	*/
+	readonly isCanceled: boolean;
+
+	/**
+	Cancel the promise and optionally provide a reason.
+
+	The cancellation is synchronous. Calling it after the promise has settled or multiple times does nothing.
+
+	@param reason - The cancellation reason to reject the promise with.
+	*/
+	cancel: (reason?: string) => void;
+
+	/**
+	Create a promise that can be canceled.
+
+	Can be constructed in the same was as a [`Promise` constructor](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise), but with an appended `onCancel` parameter in `executor`. `PCancelable` is a subclass of `Promise`.
+
+	Cancelling will reject the promise with `CancelError`. To avoid that, set `onCancel.shouldReject` to `false`.
+
+	@example
+	```
+	import PCancelable from 'p-cancelable';
+
+	const cancelablePromise = new PCancelable((resolve, reject, onCancel) => {
+		const job = new Job();
+
+		onCancel.shouldReject = false;
+		onCancel(() => {
+			job.stop();
+		});
+
+		job.on('finish', resolve);
+	});
+
+	cancelablePromise.cancel(); // Doesn't throw an error
+	```
+	*/
+	constructor(
+		executor: (
+			resolve: (value?: ValueType | PromiseLike<ValueType>) => void,
+			reject: (reason?: unknown) => void,
+			onCancel: OnCancelFunction
+		) => void
+	);
+
+	/**
+	Convenience method to make your promise-returning or async function cancelable.
+
+	@param fn - A promise-returning function. The function you specify will have `onCancel` appended to its parameters.
+
+	@example
+	```
+	import PCancelable from 'p-cancelable';
+
+	const fn = PCancelable.fn((input, onCancel) => {
+		const job = new Job();
+
+		onCancel(() => {
+			job.cleanup();
+		});
+
+		return job.start(); //=> Promise
+	});
+
+	const cancelablePromise = fn('input'); //=> PCancelable
+
+	// …
+
+	cancelablePromise.cancel();
+	```
+	*/
+	static fn<ReturnType>(
+		userFn: (onCancel: OnCancelFunction) => PromiseLike<ReturnType>
+	): () => PCancelable<ReturnType>;
+	static fn<Agument1Type, ReturnType>(
+		userFn: (
+			argument1: Agument1Type,
+			onCancel: OnCancelFunction
+		) => PromiseLike<ReturnType>
+	): (argument1: Agument1Type) => PCancelable<ReturnType>;
+	static fn<Agument1Type, Agument2Type, ReturnType>(
+		userFn: (
+			argument1: Agument1Type,
+			argument2: Agument2Type,
+			onCancel: OnCancelFunction
+		) => PromiseLike<ReturnType>
+	): (
+		argument1: Agument1Type,
+		argument2: Agument2Type
+	) => PCancelable<ReturnType>;
+	static fn<Agument1Type, Agument2Type, Agument3Type, ReturnType>(
+		userFn: (
+			argument1: Agument1Type,
+			argument2: Agument2Type,
+			argument3: Agument3Type,
+			onCancel: OnCancelFunction
+		) => PromiseLike<ReturnType>
+	): (
+		argument1: Agument1Type,
+		argument2: Agument2Type,
+		argument3: Agument3Type
+	) => PCancelable<ReturnType>;
+	static fn<Agument1Type, Agument2Type, Agument3Type, Agument4Type, ReturnType>(
+		userFn: (
+			argument1: Agument1Type,
+			argument2: Agument2Type,
+			argument3: Agument3Type,
+			argument4: Agument4Type,
+			onCancel: OnCancelFunction
+		) => PromiseLike<ReturnType>
+	): (
+		argument1: Agument1Type,
+		argument2: Agument2Type,
+		argument3: Agument3Type,
+		argument4: Agument4Type
+	) => PCancelable<ReturnType>;
+	static fn<
+		Agument1Type,
+		Agument2Type,
+		Agument3Type,
+		Agument4Type,
+		Agument5Type,
+		ReturnType
+	>(
+		userFn: (
+			argument1: Agument1Type,
+			argument2: Agument2Type,
+			argument3: Agument3Type,
+			argument4: Agument4Type,
+			argument5: Agument5Type,
+			onCancel: OnCancelFunction
+		) => PromiseLike<ReturnType>
+	): (
+		argument1: Agument1Type,
+		argument2: Agument2Type,
+		argument3: Agument3Type,
+		argument4: Agument4Type,
+		argument5: Agument5Type
+	) => PCancelable<ReturnType>;
+	static fn<ReturnType>(
+		userFn: (...arguments: unknown[]) => PromiseLike<ReturnType>
+	): (...arguments: unknown[]) => PCancelable<ReturnType>;
+}

data/lib/game_dig/node/node_modules/p-cancelable/index.js

@@ -0,0 +1,110 @@
+export class CancelError extends Error {
+	constructor(reason) {
+		super(reason || 'Promise was canceled');
+		this.name = 'CancelError';
+	}
+
+	get isCanceled() {
+		return true;
+	}
+}
+
+// TODO: Use private class fields when ESLint 8 is out.
+
+export default class PCancelable {
+	static fn(userFunction) {
+		return (...arguments_) => {
+			return new PCancelable((resolve, reject, onCancel) => {
+				arguments_.push(onCancel);
+				// eslint-disable-next-line promise/prefer-await-to-then
+				userFunction(...arguments_).then(resolve, reject);
+			});
+		};
+	}
+
+	constructor(executor) {
+		this._cancelHandlers = [];
+		this._isPending = true;
+		this._isCanceled = false;
+		this._rejectOnCancel = true;
+
+		this._promise = new Promise((resolve, reject) => {
+			this._reject = reject;
+
+			const onResolve = value => {
+				if (!this._isCanceled || !onCancel.shouldReject) {
+					this._isPending = false;
+					resolve(value);
+				}
+			};
+
+			const onReject = error => {
+				this._isPending = false;
+				reject(error);
+			};
+
+			const onCancel = handler => {
+				if (!this._isPending) {
+					throw new Error('The `onCancel` handler was attached after the promise settled.');
+				}
+
+				this._cancelHandlers.push(handler);
+			};
+
+			Object.defineProperties(onCancel, {
+				shouldReject: {
+					get: () => this._rejectOnCancel,
+					set: boolean => {
+						this._rejectOnCancel = boolean;
+					}
+				}
+			});
+
+			executor(onResolve, onReject, onCancel);
+		});
+	}
+
+	then(onFulfilled, onRejected) {
+		// eslint-disable-next-line promise/prefer-await-to-then
+		return this._promise.then(onFulfilled, onRejected);
+	}
+
+	catch(onRejected) {
+		// eslint-disable-next-line promise/prefer-await-to-then
+		return this._promise.catch(onRejected);
+	}
+
+	finally(onFinally) {
+		// eslint-disable-next-line promise/prefer-await-to-then
+		return this._promise.finally(onFinally);
+	}
+
+	cancel(reason) {
+		if (!this._isPending || this._isCanceled) {
+			return;
+		}
+
+		this._isCanceled = true;
+
+		if (this._cancelHandlers.length > 0) {
+			try {
+				for (const handler of this._cancelHandlers) {
+					handler();
+				}
+			} catch (error) {
+				this._reject(error);
+				return;
+			}
+		}
+
+		if (this._rejectOnCancel) {
+			this._reject(new CancelError(reason));
+		}
+	}
+
+	get isCanceled() {
+		return this._isCanceled;
+	}
+}
+
+Object.setPrototypeOf(PCancelable.prototype, Promise.prototype);

data/lib/game_dig/node/node_modules/p-cancelable/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.