game_dig 0.0.1 → 0.2.0

data/lib/game_dig/node/node_modules/telnet-client/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "telnet-client",
+  "description": "A simple node.js telnet client",
+  "author": {
+    "name": "Mario Kozjak",
+    "email": "kozjakm1@gmail.com"
+  },
+  "version": "2.2.6",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "engine": "node >= 6.9.1",
+  "license": "MIT",
+  "scripts": {
+    "prepack": "tsc",
+    "test": "nyc --reporter=html mocha --timeout 3000 --require ts-node/register test/**/*.ts",
+    "lint": "eslint 'src/**/*.ts' 'test/**/*.ts'"
+  },
+  "dependencies": {
+    "net": "^1.0.2",
+    "stream": "^0.0.2"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.10",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^17.0.45",
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "chai": "^4.3.10",
+    "eslint": "^8.56.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-chai-friendly": "^0.7.2",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-standard": "^5.0.0",
+    "extend": "^3.0.2",
+    "form-data": "^4.0.4",
+    "mocha": "^11.1.0",
+    "nyc": "^15.1.0",
+    "telnet": "0.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.9.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "github:mkozjak/node-telnet-client.git"
+  },
+  "contributors": [
+    {
+      "name": "Petar Koretic",
+      "email": "petar.koretic@gmail.com"
+    },
+    {
+      "name": "stardast"
+    },
+    {
+      "name": "ChristopherHackett"
+    },
+    {
+      "name": "EyePulp"
+    },
+    {
+      "name": "HaykoKoryun"
+    },
+    {
+      "name": "silverwind"
+    },
+    {
+      "name": "Peter Halliday",
+      "email": "pghalliday@gmail.com"
+    },
+    {
+      "name": "kaYcee"
+    },
+    {
+      "name": "bryanculver"
+    },
+    {
+      "name": "fbertone"
+    },
+    {
+      "name": "Shastel"
+    },
+    {
+      "name": "barak-shirali"
+    },
+    {
+      "name": "HaykoKoryun"
+    },
+    {
+      "name": "Ivan Sieder",
+      "email": "ivan@sieder.xyz"
+    },
+    {
+      "name": "Kerry Shetline",
+      "email": "kerry@shetline.com"
+    }
+  ],
+  "funding": {
+    "type": "paypal",
+    "url": "https://paypal.me/kozjak"
+  }
+}

data/lib/game_dig/node/node_modules/util-deprecate/History.md

@@ -0,0 +1,16 @@
+
+1.0.2 / 2015-10-07
+==================
+
+  * use try/catch when checking `localStorage` (#3, @kumavis)
+
+1.0.1 / 2014-11-25
+==================
+
+  * browser: use `console.warn()` for deprecation calls
+  * browser: more jsdocs
+
+1.0.0 / 2014-04-30
+==================
+
+  * initial commit

data/lib/game_dig/node/node_modules/util-deprecate/LICENSE

@@ -0,0 +1,24 @@
+(The MIT License)
+
+Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
+
+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/util-deprecate/README.md

@@ -0,0 +1,53 @@
+util-deprecate
+==============
+### The Node.js `util.deprecate()` function with browser support
+
+In Node.js, this module simply re-exports the `util.deprecate()` function.
+
+In the web browser (i.e. via browserify), a browser-specific implementation
+of the `util.deprecate()` function is used.
+
+
+## API
+
+A `deprecate()` function is the only thing exposed by this module.
+
+``` javascript
+// setup:
+exports.foo = deprecate(foo, 'foo() is deprecated, use bar() instead');
+
+
+// users see:
+foo();
+// foo() is deprecated, use bar() instead
+foo();
+foo();
+```
+
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
+
+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/util-deprecate/browser.js

@@ -0,0 +1,67 @@
+
+/**
+ * Module exports.
+ */
+
+module.exports = deprecate;
+
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
+
+function deprecate (fn, msg) {
+  if (config('noDeprecation')) {
+    return fn;
+  }
+
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config('throwDeprecation')) {
+        throw new Error(msg);
+      } else if (config('traceDeprecation')) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+
+  return deprecated;
+}
+
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
+
+function config (name) {
+  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+  try {
+    if (!global.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = global.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === 'true';
+}

data/lib/game_dig/node/node_modules/util-deprecate/node.js

@@ -0,0 +1,6 @@
+
+/**
+ * For Node.js, simply re-export the core `util.deprecate` function.
+ */
+
+module.exports = require('util').deprecate;

data/lib/game_dig/node/node_modules/util-deprecate/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "util-deprecate",
+  "version": "1.0.2",
+  "description": "The Node.js `util.deprecate()` function with browser support",
+  "main": "node.js",
+  "browser": "browser.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/TooTallNate/util-deprecate.git"
+  },
+  "keywords": [
+    "util",
+    "deprecate",
+    "browserify",
+    "browser",
+    "node"
+  ],
+  "author": "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/TooTallNate/util-deprecate/issues"
+  },
+  "homepage": "https://github.com/TooTallNate/util-deprecate"
+}

data/lib/game_dig/node/node_modules/varint/README.md

@@ -0,0 +1,53 @@
+# varint
+
+encode whole numbers to an array of [protobuf-style varint bytes](https://developers.google.com/protocol-buffers/docs/encoding#varints) and also decode them.
+
+```javascript
+var varint = require('varint')
+
+var bytes = varint.encode(300) // === [0xAC, 0x02]
+varint.decode(bytes) // 300
+varint.decode.bytes // 2 (the last decode() call required 2 bytes)
+```
+
+## api
+
+### varint = require('varint')
+
+### varint.encode(num[, buffer=[], offset=0]) -> buffer
+
+Encodes `num` into `buffer` starting at `offset`. returns `buffer`, with the encoded varint written into it. If `buffer` is not provided, it will default to a new array.
+
+`varint.encode.bytes` will now be set to the number of bytes
+modified.
+
+### varint.decode(data[, offset=0]) -> number
+
+decodes `data`, which can be either a buffer or array of integers, from position `offset` or default 0 and returns the decoded original integer.
+
+Throws a `RangeError` when `data` does not represent a valid encoding.
+
+### varint.decode.bytes
+
+if you also require the length (number of bytes) that were required to decode the integer you can access it via `varint.decode.bytes`. this is an integer property that will tell you the number of bytes that the last .decode() call had to use to decode.
+
+### varint.encode.bytes
+
+similar to `decode.bytes` when encoding a number it can be useful to know how many bytes where written (especially if you pass an output array). you can access this via `varint.encode.bytes` which holds the number of bytes written in the last encode.
+
+
+### varint.encodingLength(num)
+
+returns the number of bytes this number will be encoded as, up to a maximum of 8.
+
+## usage notes
+
+If varint is passed a buffer that does not contain a valid end
+byte, then `decode` will throw `RangeError`, and `decode.bytes` 
+will be set to 0. If you are reading from a streaming source,
+it's okay to pass an incomplete buffer into `decode`, detect this
+case, and then concatenate the next buffer.
+
+# License
+
+MIT

data/lib/game_dig/node/node_modules/varint/bench.js

@@ -0,0 +1,57 @@
+var N = 1e7
+var M = 10
+/*
+  benchmark encoding and decoding N random integers.
+
+  A number is encoded into a buffer, (the buffer is reused so
+  that allocation does not affect the benchmark)
+
+  to test the effect on performance of invalid records
+  (i.e. too short, with the Most Significant Byte missing)
+  every M items, attempt to decode from a shorter slice of the buffer.
+  This will probably be produce an invalid result. We do not
+  need to write into that buffer - because it refurs to the same memory as
+  the full size buffer.
+
+  run with INVALID=1 to include N/M invalid decodes.
+
+  results:
+    with no invalid decodes, I get about 2428 decodes/ms
+    with invalid decodes:
+      old code that overruns buffer: 1122 decodes/ms
+      check length & return undefined: 2439 decodecs/ms
+      check length & return NaN: 2434 d/ms
+      check length & return -1: 2400 d/ms
+
+  conclusion, it doesn't make a significant difference whether
+  what is returned to show an invalid read,
+  but if you overrun the buffer the cost is considerable.
+
+  recomendation: return undefined
+*/
+
+var buffer = new Buffer(8)
+var _buffer = buffer.slice(0, 4)
+var varint = require('./')
+var l = N
+var invalid = 0
+
+includeInvalid = !!process.env.INVALID
+
+var start = Date.now()
+while (l--) {
+  var int = Math.floor(Math.random()*0x01fffffffffffff)
+  varint.encode(int, buffer, 0)
+  //console.log(int, varint.decode(buffer, 0))
+  //every 1000 varints, do one that will be too short,
+  //measure
+  if(includeInvalid && !(l%M)) {
+    if(undefined == varint.decode(_buffer, 0))
+      invalid ++
+  } else 
+  if(int !== varint.decode(buffer, 0))
+    throw new Error('decode was incorrect')
+}
+
+console.log('decode&encode/ms, invalidDecodes')
+console.log(N/(Date.now() - start) + ',', invalid)

data/lib/game_dig/node/node_modules/varint/decode.js

@@ -0,0 +1,29 @@
+module.exports = read
+
+var MSB = 0x80
+  , REST = 0x7F
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length
+
+  do {
+    if (counter >= l || shift > 49) {
+      read.bytes = 0
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++]
+    res += shift < 28
+      ? (b & REST) << shift
+      : (b & REST) * Math.pow(2, shift)
+    shift += 7
+  } while (b >= MSB)
+
+  read.bytes = counter - offset
+
+  return res
+}

data/lib/game_dig/node/node_modules/varint/encode.js

@@ -0,0 +1,30 @@
+module.exports = encode
+
+var MSB = 0x80
+  , REST = 0x7F
+  , MSBALL = ~REST
+  , INT = Math.pow(2, 31)
+
+function encode(num, out, offset) {
+  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+    encode.bytes = 0
+    throw new RangeError('Could not encode varint')
+  }
+  out = out || []
+  offset = offset || 0
+  var oldOffset = offset
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB
+    num /= 128
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB
+    num >>>= 7
+  }
+  out[offset] = num | 0
+  
+  encode.bytes = offset - oldOffset + 1
+  
+  return out
+}

data/lib/game_dig/node/node_modules/varint/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+    encode: require('./encode.js')
+  , decode: require('./decode.js')
+  , encodingLength: require('./length.js')
+}

data/lib/game_dig/node/node_modules/varint/length.js

@@ -0,0 +1,25 @@
+
+var N1 = Math.pow(2,  7)
+var N2 = Math.pow(2, 14)
+var N3 = Math.pow(2, 21)
+var N4 = Math.pow(2, 28)
+var N5 = Math.pow(2, 35)
+var N6 = Math.pow(2, 42)
+var N7 = Math.pow(2, 49)
+var N8 = Math.pow(2, 56)
+var N9 = Math.pow(2, 63)
+
+module.exports = function (value) {
+  return (
+    value < N1 ? 1
+  : value < N2 ? 2
+  : value < N3 ? 3
+  : value < N4 ? 4
+  : value < N5 ? 5
+  : value < N6 ? 6
+  : value < N7 ? 7
+  : value < N8 ? 8
+  : value < N9 ? 9
+  :              10
+  )
+}

data/lib/game_dig/node/node_modules/varint/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "varint",
+  "version": "6.0.0",
+  "description": "protobuf-style varint bytes - use msb to create integer values of varying sizes",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/chrisdickinson/varint.git"
+  },
+  "keywords": [
+    "varint",
+    "protobuf",
+    "encode",
+    "decode"
+  ],
+  "author": "Chris Dickinson <chris@neversaw.us>",
+  "license": "MIT",
+  "devDependencies": {
+    "tape": "~2.12.3"
+  }
+}

data/lib/game_dig/node/node_modules/varint/test.js

@@ -0,0 +1,156 @@
+var varint = require('./index')
+  , test = require('tape')
+  , decode = varint.decode
+  , encode = varint.encode
+  , encodingLength = varint.encodingLength
+
+test('fuzz test', function(assert) {
+  var expect
+    , encoded
+
+  for(var i = 0, len = 100; i < len; ++i) {
+    expect = randint(0x7FFFFFFF)
+    encoded = encode(expect)
+    var data = decode(encoded)
+    assert.equal(expect, data, 'fuzz test: ' + expect.toString())
+    assert.equal(decode.bytes, encoded.length)
+  }
+
+  assert.end()
+})
+
+test('test single byte works as expected', function(assert) {
+  var buf = new Uint8Array(2)
+  buf[0] = 172
+  buf[1] = 2
+  var data = decode(buf)
+  assert.equal(data, 300, 'should equal 300')
+  assert.equal(decode.bytes, 2)
+  assert.end()
+})
+
+test('test encode works as expected', function(assert) {
+  var out = []
+
+  assert.deepEqual(encode(300), [0xAC, 0x02])
+
+  assert.end()
+})
+
+test('test decode single bytes', function(assert) {
+  var expected = randint(parseInt('1111111', '2'))
+  var buf = new Uint8Array(1)
+  buf[0] = expected
+  var data = decode(buf)
+  assert.equal(data, expected)
+  assert.equal(decode.bytes, 1)
+  assert.end()
+})
+
+test('test decode multiple bytes with zero', function(assert) {
+  var expected = randint(parseInt('1111111', '2'))
+  var buf = new Uint8Array(2)
+  buf[0] = 128
+  buf[1] = expected
+  var data = decode(buf)
+  assert.equal(data, expected << 7)
+  assert.equal(decode.bytes, 2)
+  assert.end()
+})
+
+test('encode single byte', function(assert) {
+  var expected = randint(parseInt('1111111', '2'))
+  assert.deepEqual(encode(expected), [expected])
+  assert.equal(encode.bytes, 1)
+  assert.end()
+})
+
+test('encode multiple byte with zero first byte', function(assert) {
+  var expected = 0x0F00
+  assert.deepEqual(encode(expected), [0x80, 0x1E])
+  assert.equal(encode.bytes, 2)
+  assert.end()
+})
+
+test('big integers', function (assert) {
+
+  var bigs = []
+  for(var i = 32; i <= 53; i++) (function (i) {
+    bigs.push(Math.pow(2, i) - 1)
+  })(i)
+
+  bigs.forEach(function (n) {
+    var data = encode(n)
+    console.error(n, '->', data)
+    assert.equal(decode(data), n)
+    assert.notEqual(decode(data), n - 1)
+  })
+  assert.end()
+})
+
+test('fuzz test - big', function(assert) {
+  var expect
+    , encoded
+
+  var MAX_INTD = Number.MAX_SAFE_INTEGER
+  var MAX_INT = Math.pow(2, 31)
+
+  for(var i = 0, len = 100; i < len; ++i) {
+    expect = randint(MAX_INTD - MAX_INT) + MAX_INT
+    encoded = encode(expect)
+    var data = decode(encoded)
+    assert.equal(expect, data, 'fuzz test: ' + expect.toString())
+    assert.equal(decode.bytes, encoded.length)
+  }
+
+  assert.end()
+})
+
+test('encodingLength', function (assert) {
+
+  for(var i = 0; i <= 53; i++) {
+    var n = Math.pow(2, i) - 1
+    assert.equal(encode(n).length, encodingLength(n))
+  }
+
+  assert.end()
+})
+
+test('buffer too short', function (assert) {
+
+  var value = encode(9812938912312)
+  var buffer = encode(value)
+
+  var l = buffer.length
+  while(l--) {
+    try {
+      var val = decode(buffer.slice(0, l))
+    } catch (err) {
+      assert.equal(err.constructor, RangeError)
+      assert.equal(decode.bytes, 0)
+    }
+  }
+  assert.end()
+})
+
+test('buffer too long', function (assert) {
+
+  var buffer = Uint8Array.from(
+    Array.from({length: 150}, function () { return 0xff })
+      .concat(Array.from({length: 1}, function () { return 0x1 }))
+  )
+
+  try {
+    var val = decode(buffer)
+    encode(val)
+    assert.fail('expected an error received value instead: ' + val)
+  } catch (err) {
+    assert.equal(err.constructor, RangeError)
+    assert.equal(decode.bytes, 0)
+  }
+  assert.end()
+})
+
+function randint(range) {
+  return Math.floor(Math.random() * range)
+}

data/lib/game_dig/node/node_modules/xmlbuilder/.npmignore

@@ -0,0 +1,5 @@
+.travis.yml
+src
+test
+perf
+coverage