game_dig 0.0.1 → 0.2.0

data/lib/game_dig/node/node_modules/barse/test/integration.js

@@ -0,0 +1,37 @@
+var parse = require('..');
+var test = require('tape');
+
+test('integration', function (t) {
+  var parser = parse()
+    .readUInt8('string length')
+    .string('string', 'string length')
+    .readUInt8('field count')
+    .loop('fields', 'field count', function (loop) {
+      loop.readUInt8('some');
+      loop.readUInt8('numbers');
+    })
+
+  parser.on('data', function (data) {
+    t.deepEqual(data, {
+      "string length" : 3,
+      "string" : "foo",
+      "field count" : 2,
+      "fields" : [
+        { "some" : 13, "numbers" : 37 },
+        { "some" : 73, "numbers" : 31 }
+      ]
+    });
+    t.end();
+  });
+
+  var buf = new Buffer(9);
+  buf.writeUInt8(3, 0); // string length
+  buf.write('foo', 1); // string
+  buf.writeUInt8(2, 4); // field count
+  buf.writeUInt8(13, 5); // fields[0].some
+  buf.writeUInt8(37, 6); // fields[0].numbers
+  buf.writeUInt8(73, 7); // fields[1].some
+  buf.writeUInt8(31, 8); // fields[1].numbers
+
+  parser.write(buf);
+});

data/lib/game_dig/node/node_modules/barse/test/loop.js

@@ -0,0 +1,36 @@
+var test = require('tape');
+var parse = require('..');
+
+test('basic loop', function (t) {
+  var parser = parse()
+    .loop('numbers', 3, function (loop) {
+      loop.readUInt8('one');
+      loop.readUInt8('two');
+    });
+
+  parser.on('data', function (data) {
+    t.deepEqual(data.numbers, [
+      { one : 1, two : 1 },
+      { one : 2, two : 2 },
+      { one : 3, two : 3 },
+    ]);
+    t.end();
+  });
+
+  var buf;
+  
+  buf = new Buffer(2);
+  buf.writeUInt8(1, 0);
+  buf.writeUInt8(1, 1);
+  parser.write(buf);
+  
+  buf = new Buffer(2);
+  buf.writeUInt8(2, 0);
+  buf.writeUInt8(2, 1);
+  parser.write(buf);
+  
+  buf = new Buffer(2);
+  buf.writeUInt8(3, 0);
+  buf.writeUInt8(3, 1);
+  parser.write(buf);
+});

data/lib/game_dig/node/node_modules/barse/test/next.js

@@ -0,0 +1,34 @@
+var parse = require('..');
+var test = require('tape');
+
+test('next', function (t) {
+  var parser = parse()
+    .next('foo', 3, function (chunk, offset) {
+      return chunk.toString('utf8', offset, offset + 3);
+    })
+    .next('bar', 3, function (chunk, offset) {
+      return chunk.toString('utf8', offset, offset + 3);
+    })
+
+  var i = 0;
+  parser.on('data', function (data) {
+    if (i === 0) {
+      t.deepEqual(data, { foo : 'foo', bar : 'bar' });
+    } else if (i === 1) {
+      t.deepEqual(data, { foo : 'oof', bar : 'rab' });
+    } else {
+      t.deepEqual(data, { foo : 'fff', bar : 'uuu' });
+      t.end();
+    }
+    i++;
+  });
+
+  parser.write(new Buffer('foobar'));
+
+  parser.write(new Buffer('oof'));
+  parser.write(new Buffer('rab'));
+
+  parser.write(new Buffer('ff'));
+  parser.write(new Buffer('fu'));
+  parser.write(new Buffer('uu'));
+});

data/lib/game_dig/node/node_modules/barse/test/scope.js

@@ -0,0 +1,18 @@
+var test = require('tape');
+var parse = require('..');
+
+test('scope', function (t) {
+  var parser = parse()
+    .readUInt8('length')
+    .next('body', 'length', function (chunk, offset) {
+      return chunk.toString('utf8', offset, offset + this.length);
+    });
+
+  parser.on('data', function (data) {
+    t.deepEquals(data, { length : 3, body : 'foo' });
+    t.end();
+  });
+
+  var length = new Buffer(1); length.writeUInt8(3, 0); parser.write(length);
+  parser.write('foo', 1);
+});

data/lib/game_dig/node/node_modules/barse/test/string.js

@@ -0,0 +1,33 @@
+var test = require('tape');
+var parse = require('..');
+
+test('variable string lengths', function (t) {
+  var parser = parse()
+    .readUInt8('length')
+    .string('str', 'length')
+    .string('str2', 'length')
+
+  var i = 0;
+  parser.on('data', function (data) {
+    if (i === 0) {
+      t.deepEqual(data, { length : 3, str : 'foo',  str2 : 'bar'  });
+    } else {
+      t.deepEqual(data, { length : 4, str : 'abcd', str2 : 'efgh' });
+      t.end();
+    }
+    i++;
+  });
+
+  var buf = new Buffer(7);
+  buf.writeUInt8(3, 0);
+  buf.write('foo', 1);
+  buf.write('bar', 4);
+
+  var buf2 = new Buffer(9);
+  buf2.writeUInt8(4, 0);
+  buf2.write('abcd', 1);
+  buf2.write('efgh', 5);
+
+  parser.write(buf);
+  parser.write(buf2);
+});

data/lib/game_dig/node/node_modules/barse/test/vars.js

@@ -0,0 +1,20 @@
+var test = require('tape');
+var parse = require('..');
+
+test('vars', function (t) {
+  var parser = parse()
+    .readUInt8('length')
+    .string('str', 'length')
+    .string('str2', 'length')
+
+  parser.on('data', function (data) {
+    t.deepEqual(data, { length : 3, str : 'foo', str2 : 'bar' });
+    t.end();
+  });
+
+  var buf = new Buffer(7);
+  buf.writeUInt8(3, 0);
+  buf.write('foo', 1);
+  buf.write('bar', 4);
+  parser.write(buf);
+});

data/lib/game_dig/node/node_modules/cacheable-lookup/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Szymon Marczak
+
+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.

data/lib/game_dig/node/node_modules/cacheable-lookup/README.md

@@ -0,0 +1,245 @@
+# cacheable-lookup
+
+> A cacheable [`dns.lookup(…)`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) that respects TTL :tada:
+
+[![Node CI](https://github.com/szmarczak/cacheable-lookup/workflows/Node%20CI/badge.svg)](https://github.com/szmarczak/cacheable-lookup/actions)
+[![codecov](https://codecov.io/gh/szmarczak/cacheable-lookup/branch/master/graph/badge.svg)](https://codecov.io/gh/szmarczak/cacheable-lookup)
+[![npm](https://img.shields.io/npm/dm/cacheable-lookup.svg)](https://www.npmjs.com/package/cacheable-lookup)
+[![install size](https://packagephobia.now.sh/badge?p=cacheable-lookup)](https://packagephobia.now.sh/result?p=cacheable-lookup)
+
+Making lots of HTTP requests? You can save some time by caching DNS lookups :zap:
+
+## Usage
+
+### Using the `lookup` option
+
+```js
+import http from 'node:http';
+import CacheableLookup from 'cacheable-lookup';
+
+const cacheable = new CacheableLookup();
+
+http.get('http://example.com', {lookup: cacheable.lookup}, response => {
+	// Handle the response here
+});
+```
+
+### Attaching CacheableLookup to an Agent
+
+```js
+import http from 'node:http';
+import https from 'node:https';
+import CacheableLookup from 'cacheable-lookup';
+
+const cacheable = new CacheableLookup();
+
+cacheable.install(http.globalAgent);
+cacheable.install(https.globalAgent);
+
+http.get('http://example.com', response => {
+	// Handle the response here
+});
+```
+
+## API
+
+### new CacheableLookup(options)
+
+Returns a new instance of `CacheableLookup`.
+
+#### options
+
+Type: `object`\
+Default: `{}`
+
+Options used to cache the DNS lookups.
+
+##### cache
+
+Type: `Map` | [`Keyv`](https://github.com/lukechilds/keyv/)\
+Default: `new Map()`
+
+Custom cache instance. If `undefined`, it will create a new one.
+
+**Note**: If you decide to use Keyv instead of the native implementation, the performance will drop by 10x. Memory leaks may occur as it doesn't provide any way to remove all the deprecated values at once.
+
+**Tip**: [`QuickLRU`](https://github.com/sindresorhus/quick-lru) is fully compatible with the Map API, you can use it to limit the amount of cached entries. Example:
+
+```js
+import http from 'node:http';
+import CacheableLookup from 'cacheable-lookup';
+import QuickLRU from 'quick-lru';
+
+const cacheable = new CacheableLookup({
+	cache: new QuickLRU({maxSize: 1000})
+});
+
+http.get('http://example.com', {lookup: cacheable.lookup}, response => {
+	// Handle the response here
+});
+```
+
+##### options.maxTtl
+
+Type: `number`\
+Default: `Infinity`
+
+The maximum lifetime of the entries received from the specifed DNS server (TTL in seconds).
+
+If set to `0`, it will make a new DNS query each time.
+
+**Pro Tip**: This shouldn't be lower than your DNS server response time in order to prevent bottlenecks. For example, if you use Cloudflare, this value should be greater than `0.01`.
+
+##### options.fallbackDuration
+
+Type: `number`\
+Default: `3600` (1 hour)
+
+When the DNS server responds with `ENOTFOUND` or `ENODATA` and the OS reports that the entry is available, it will use `dns.lookup(...)` directly for the requested hostnames for the specified amount of time (in seconds).
+
+**Note**: You should avoid setting this to `0` unless the provided DNS servers' database is limited to few domains.
+
+##### options.errorTtl
+
+Type: `number`\
+Default: `0.15`
+
+The time how long it needs to remember queries that threw `ENOTFOUND` or `ENODATA` (TTL in seconds).
+
+**Note**: This option is independent, `options.maxTtl` does not affect this.
+
+**Pro Tip**: This shouldn't be lower than your DNS server response time in order to prevent bottlenecks. For example, if you use Cloudflare, this value should be greater than `0.01`.
+
+##### options.resolver
+
+Type: `dns.Resolver | dns.promises.Resolver`\
+Default: [`new dns.promises.Resolver()`](https://nodejs.org/api/dns.html#dns_class_dns_resolver)
+
+An instance of [DNS Resolver](https://nodejs.org/api/dns.html#dns_class_dns_resolver) used to make DNS queries.
+
+##### options.lookup
+
+Type: `Function`\
+Default: [`dns.lookup`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback)
+
+The fallback function to use when the DNS server responds with `ENOTFOUND` or `ENODATA`.
+
+If you don't query internal hostnames (such as `localhost`, `database.local` etc.), it is strongly recommended to set this to `false`.
+
+### Entry object
+
+Type: `object`
+
+#### address
+
+Type: `string`
+
+The IP address (can be an IPv4 or IPv6 address).
+
+#### family
+
+Type: `number`
+
+The IP family (`4` or `6`).
+
+##### expires
+
+Type: `number`
+
+**Note**: This is not present when falling back to `dns.lookup(...)`!
+
+The timestamp (`Date.now() + ttl * 1000`) when the entry expires.
+
+#### ttl
+
+**Note**: This is not present when falling back to `dns.lookup(...)`!
+
+The time in seconds for its lifetime.
+
+#### source
+
+**Note**: This is not present when falling back to `dns.lookup(...)`!
+
+Whether this entry was loaded from the cache or came from a query (`cache` or `query`)
+
+### Entry object (callback-style)
+
+When `options.all` is `false`, then `callback(error, address, family, expires, ttl)` is called.\
+When `options.all` is `true`, then `callback(error, entries)` is called.
+
+### CacheableLookup instance
+
+#### servers
+
+Type: `Array`
+
+The DNS servers used to make queries. Can be overridden - doing so will clear the cache.
+
+#### [lookup(hostname, options, callback)](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback)
+
+#### lookupAsync(hostname, options)
+
+The asynchronous version of `dns.lookup(…)`.
+
+Returns an [entry object](#entry-object).\
+If `options.all` is true, returns an array of entry objects.
+
+##### hostname
+
+Type: `string`
+
+##### options
+
+Type: `object`
+
+The same as the [`dns.lookup(…)`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) options.
+
+#### query(hostname)
+
+An asynchronous function which returns cached DNS lookup entries.\
+This is the base for `lookupAsync(hostname, options)` and `lookup(hostname, options, callback)`.
+
+**Note**: This function has no options.
+
+Returns an array of objects with `address`, `family`, `ttl` and `expires` properties.
+
+#### queryAndCache(hostname)
+
+An asynchronous function which makes two DNS queries: A and AAAA. The result is cached.\
+This is used by `query(hostname)` if no entry in the database is present.
+
+Returns an array of objects with `address`, `family`, `ttl` and `expires` properties.
+
+#### updateInterfaceInfo()
+
+Updates interface info. For example, you need to run this when you plug or unplug your WiFi driver.
+
+**Note:** Running `updateInterfaceInfo()` will trigger `clear()` only on network interface removal.
+
+#### clear(hostname?)
+
+Clears the cache for the given hostname. If the hostname argument is not present, the entire cache will be emptied.
+
+## High performance
+
+Performed on:
+- Query: `example.com`
+- CPU: i7-7700k
+- CPU governor: performance
+
+```
+CacheableLookup#lookupAsync                x 2,896,251 ops/sec ±1.07% (85 runs sampled)
+CacheableLookup#lookupAsync.all            x 2,842,664 ops/sec ±1.11% (88 runs sampled)
+CacheableLookup#lookupAsync.all.ADDRCONFIG x 2,598,283 ops/sec ±1.21% (88 runs sampled)
+CacheableLookup#lookup                     x 2,565,913 ops/sec ±1.56% (85 runs sampled)
+CacheableLookup#lookup.all                 x 2,609,039 ops/sec ±1.01% (86 runs sampled)
+CacheableLookup#lookup.all.ADDRCONFIG      x 2,416,242 ops/sec ±0.89% (85 runs sampled)
+dns#lookup                                 x 7,272     ops/sec ±0.36% (86 runs sampled)
+dns#lookup.all                             x 7,249     ops/sec ±0.40% (86 runs sampled)
+dns#lookup.all.ADDRCONFIG                  x 5,693     ops/sec ±0.28% (85 runs sampled)
+Fastest is CacheableLookup#lookupAsync.all
+```
+
+## Related
+
+- [cacheable-request](https://github.com/lukechilds/cacheable-request) - Wrap native HTTP requests with RFC compliant cache support

data/lib/game_dig/node/node_modules/cacheable-lookup/index.d.ts

@@ -0,0 +1,144 @@
+import {Resolver, promises as dnsPromises, lookup} from 'dns';
+import {Agent} from 'http';
+
+type AsyncResolver = dnsPromises.Resolver;
+
+export type IPFamily = 4 | 6;
+export type EntrySource = 'query' | 'cache';
+
+type TPromise<T> = T | Promise<T>;
+
+export interface CacheInstance {
+	set(hostname: string, entries: EntryObject[], ttl: number): TPromise<void | boolean | this>;
+	get(hostname: string): TPromise<EntryObject[] | undefined>;
+	delete(hostname: string): TPromise<boolean>;
+	clear(): TPromise<void>;
+}
+
+export interface Options {
+	/**
+	 * Custom cache instance. If `undefined`, it will create a new one.
+	 * @default undefined
+	 */
+	cache?: CacheInstance;
+	/**
+	 * Limits the cache time (TTL). If set to `0`, it will make a new DNS query each time.
+	 * @default Infinity
+	 */
+	maxTtl?: number;
+	/**
+	 * DNS Resolver used to make DNS queries.
+	 * @default new dns.promises.Resolver()
+	 */
+	resolver?: Resolver | AsyncResolver;
+	/**
+	 * When the DNS server responds with `ENOTFOUND` or `ENODATA` and the OS reports that the entry is available,
+	 * it will use `dns.lookup(...)` directly for the requested hostnames for the specified amount of time (in seconds).
+	 *
+	 * If you don't query internal hostnames (such as `localhost`, `database.local` etc.),
+	 * it is strongly recommended to set this value to `0`.
+	 * @default 3600
+	 */
+	fallbackDuration?: number;
+	/**
+	 * The time how long it needs to remember failed queries (TTL in seconds).
+	 *
+	 * **Note**: This option is independent, `options.maxTtl` does not affect this.
+	 * @default 0.15
+	 */
+	errorTtl?: number;
+	/**
+	 * The fallback function to use when the DNS server responds with `ENOTFOUND` or `ENODATA`.
+	 *
+	 * **Note**: This has no effect if the `fallbackDuration` option is less than `1`.
+	 * @default dns.lookup
+	 */
+	lookup?: typeof lookup | false;
+}
+
+export interface EntryObject {
+	/**
+	 * The IP address (can be an IPv4 or IPv5 address).
+	 */
+	readonly address: string;
+	/**
+	 * The IP family.
+	 */
+	readonly family: IPFamily;
+	/**
+	 * The original TTL.
+	 */
+	readonly ttl?: number;
+	/**
+	 * The expiration timestamp.
+	 */
+	readonly expires?: number;
+	/**
+	 * Whether this entry comes from the cache or a query
+	 */
+	readonly source?: EntrySource;
+}
+
+export interface LookupOptions {
+	/**
+	 * One or more supported getaddrinfo flags. Multiple flags may be passed by bitwise ORing their values.
+	 */
+	hints?: number;
+	/**
+	 * The record family. Must be `4` or `6`. IPv4 and IPv6 addresses are both returned by default.
+	 */
+	family?: IPFamily;
+	/**
+	 * When `true`, the callback returns all resolved addresses in an array. Otherwise, returns a single address.
+	 * @default false
+	 */
+	all?: boolean;
+}
+
+export default class CacheableLookup {
+	constructor(options?: Options);
+	/**
+	 * The DNS servers used to make queries. Can be overridden - doing so will clear the cache.
+	 */
+	servers: string[];
+	/**
+	 * @see https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback
+	 */
+	lookup(hostname: string, family: IPFamily, callback: (error: NodeJS.ErrnoException | null, address: string, family: IPFamily) => void): void;
+	lookup(hostname: string, callback: (error: NodeJS.ErrnoException | null, address: string, family: IPFamily) => void): void;
+	lookup(hostname: string, options: LookupOptions & {all: true}, callback: (error: NodeJS.ErrnoException | null, result: ReadonlyArray<EntryObject>) => void): void;
+	lookup(hostname: string, options: LookupOptions, callback: (error: NodeJS.ErrnoException | null, address: string, family: IPFamily) => void): void;
+	/**
+	 * The asynchronous version of `dns.lookup(…)`.
+	 */
+	lookupAsync(hostname: string, options: LookupOptions & {all: true}): Promise<ReadonlyArray<EntryObject>>;
+	lookupAsync(hostname: string, options: LookupOptions): Promise<EntryObject>;
+	lookupAsync(hostname: string): Promise<EntryObject>;
+	lookupAsync(hostname: string, family: IPFamily): Promise<EntryObject>;
+	/**
+	 * An asynchronous function which returns cached DNS lookup entries. This is the base for `lookupAsync(hostname, options)` and `lookup(hostname, options, callback)`.
+	 */
+	query(hostname: string): Promise<ReadonlyArray<EntryObject>>;
+	/**
+	 * An asynchronous function which makes a new DNS lookup query and updates the database. This is used by `query(hostname, family)` if no entry in the database is present. Returns an array of objects with `address`, `family`, `ttl` and `expires` properties.
+	 */
+	queryAndCache(hostname: string): Promise<ReadonlyArray<EntryObject>>;
+	/**
+	 * Attaches itself to an Agent instance.
+	 */
+	install(agent: Agent): void;
+	/**
+	 * Removes itself from an Agent instance.
+	 */
+	uninstall(agent: Agent): void;
+	/**
+	 * Updates interface info. For example, you need to run this when you plug or unplug your WiFi driver.
+	 *
+	 * **Note:** Running `updateInterfaceInfo()` will trigger `clear()` only on network interface removal.
+	 */
+	updateInterfaceInfo(): void;
+	/**
+	 * Clears the cache for the given hostname. If the hostname argument is not present, the entire cache will be emptied.
+	 */
+	clear(hostname?: string): void;
+}

data/lib/game_dig/node/node_modules/cacheable-lookup/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "cacheable-lookup",
+  "version": "7.0.0",
+  "description": "A cacheable dns.lookup(…) that respects TTL",
+  "engines": {
+    "node": ">=14.16"
+  },
+  "files": [
+    "source",
+    "index.d.ts"
+  ],
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./source/index.js"
+  },
+  "scripts": {
+    "//test": "xo && nyc --reporter=lcovonly --reporter=text ava && tsd",
+    "test": "tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/szmarczak/cacheable-lookup.git"
+  },
+  "keywords": [
+    "dns",
+    "lookup",
+    "cacheable",
+    "ttl"
+  ],
+  "author": "Szymon Marczak",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/szmarczak/cacheable-lookup/issues"
+  },
+  "homepage": "https://github.com/szmarczak/cacheable-lookup#readme",
+  "devDependencies": {
+    "@types/keyv": "^3.1.1",
+    "ava": "^4.3.3",
+    "benchmark": "^2.1.4",
+    "coveralls": "^3.0.9",
+    "keyv": "^4.0.0",
+    "nyc": "^15.0.0",
+    "quibble": "^0.6.14",
+    "quick-lru": "^5.1.0",
+    "tsd": "^0.11.0",
+    "xo": "^0.25.3"
+  },
+  "ava": {
+    "nodeArguments": [
+      "--loader=quibble"
+    ]
+  },
+  "xo": {
+    "rules": {
+      "unicorn/import-index": "off",
+      "import/extensions": "off",
+      "import/no-useless-path-segments": "off"
+    }
+  }
+}