game_dig 0.1.0 → 0.2.0

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/createBoundary.js

@@ -0,0 +1,9 @@
+const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+export function createBoundary() {
+    let size = 16;
+    let res = "";
+    while (size--) {
+        res += alphabet[(Math.random() * alphabet.length) << 0];
+    }
+    return res;
+}

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/escapeName.js

@@ -0,0 +1,4 @@
+export const escapeName = (name) => String(name)
+    .replace(/\r/g, "%0D")
+    .replace(/\n/g, "%0A")
+    .replace(/"/g, "%22");

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/getStreamIterator.js

@@ -0,0 +1,21 @@
+import { isFunction } from "./isFunction.js";
+const isAsyncIterable = (value) => (isFunction(value[Symbol.asyncIterator]));
+async function* readStream(readable) {
+    const reader = readable.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        yield value;
+    }
+}
+export const getStreamIterator = (source) => {
+    if (isAsyncIterable(source)) {
+        return source;
+    }
+    if (isFunction(source.getReader)) {
+        return readStream(source);
+    }
+    throw new TypeError("Unsupported data source: Expected either ReadableStream or async iterable.");
+};

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/isFile.js

@@ -0,0 +1,8 @@
+import { isFunction } from "./isFunction.js";
+export const isFile = (value) => Boolean(value
+    && typeof value === "object"
+    && isFunction(value.constructor)
+    && value[Symbol.toStringTag] === "File"
+    && isFunction(value.stream)
+    && value.name != null);
+export const isFileLike = isFile;

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/isFormData.js

@@ -0,0 +1,8 @@
+import { isFunction } from "./isFunction.js";
+export const isFormData = (value) => Boolean(value
+    && isFunction(value.constructor)
+    && value[Symbol.toStringTag] === "FormData"
+    && isFunction(value.append)
+    && isFunction(value.getAll)
+    && isFunction(value.entries)
+    && isFunction(value[Symbol.iterator]));

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/isFunction.js

@@ -0,0 +1 @@
+export const isFunction = (value) => (typeof value === "function");

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/isPlainObject.js

@@ -0,0 +1,12 @@
+const getType = (value) => (Object.prototype.toString.call(value).slice(8, -1).toLowerCase());
+export function isPlainObject(value) {
+    if (getType(value) !== "object") {
+        return false;
+    }
+    const pp = Object.getPrototypeOf(value);
+    if (pp === null || pp === undefined) {
+        return true;
+    }
+    const Ctor = pp.constructor && pp.constructor.toString();
+    return Ctor === Object.toString();
+}

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/normalizeValue.js

@@ -0,0 +1,8 @@
+export const normalizeValue = (value) => String(value)
+    .replace(/\r|\n/g, (match, i, str) => {
+    if ((match === "\r" && str[i + 1] !== "\n")
+        || (match === "\n" && str[i - 1] !== "\r")) {
+        return "\r\n";
+    }
+    return match;
+});

data/lib/game_dig/node/node_modules/form-data-encoder/lib/util/proxyHeaders.js

@@ -0,0 +1,14 @@
+function getProperty(target, prop) {
+    if (typeof prop === "string") {
+        for (const [name, value] of Object.entries(target)) {
+            if (prop.toLowerCase() === name.toLowerCase()) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+export const proxyHeaders = (object) => new Proxy(object, {
+    get: (target, prop) => getProperty(target, prop),
+    has: (target, prop) => getProperty(target, prop) !== undefined
+});

data/lib/game_dig/node/node_modules/form-data-encoder/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021-present Nick K.
+
+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/form-data-encoder/package.json

@@ -0,0 +1,70 @@
+{
+  "type": "module",
+  "name": "form-data-encoder",
+  "version": "2.1.4",
+  "description": "Encode FormData content into the multipart/form-data format",
+  "repository": "octet-stream/form-data-encoder",
+  "sideEffects": false,
+  "engines": {
+    "node": ">= 14.17"
+  },
+  "keywords": [
+    "form-data",
+    "encoder",
+    "multipart",
+    "files-upload",
+    "async-iterator",
+    "spec-compatible",
+    "form"
+  ],
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "exports": {
+    "types": "./@type/index.d.ts",
+    "default": "./lib/index.js"
+  },
+  "types": "./@type/index.d.ts",
+  "scripts": {
+    "eslint": "eslint src/**/*.ts",
+    "staged": "lint-staged",
+    "coverage": "c8 npm test",
+    "ci": "c8 npm test && c8 report --reporter=json",
+    "build:types": "tsc --project tsconfig.d.ts.json",
+    "build": "tsc && npm run build:types",
+    "test": "ava --fail-fast",
+    "cleanup": "del-cli @type lib",
+    "prepare": "npm run cleanup && npm run build",
+    "_postinstall": "husky install",
+    "prepublishOnly": "pinst --disable",
+    "postpublish": "pinst --enable"
+  },
+  "author": "Nick K.",
+  "license": "MIT",
+  "devDependencies": {
+    "@octetstream/eslint-config": "6.2.2",
+    "@types/mime-types": "2.1.1",
+    "@types/node": "18.11.9",
+    "@types/sinon": "^10.0.13",
+    "@typescript-eslint/eslint-plugin": "5.44.0",
+    "@typescript-eslint/parser": "5.44.0",
+    "ava": "5.1.0",
+    "c8": "7.12.0",
+    "del-cli": "5.0.0",
+    "eslint": "8.28.0",
+    "eslint-config-airbnb-typescript": "17.0.0",
+    "eslint-import-resolver-typescript": "3.5.2",
+    "eslint-plugin-ava": "13.2.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jsx-a11y": "6.6.1",
+    "eslint-plugin-react": "7.31.11",
+    "formdata-node": "5.0.0",
+    "husky": "8.0.2",
+    "lint-staged": "13.0.3",
+    "pinst": "3.0.0",
+    "sinon": "^14.0.2",
+    "ts-node": "10.9.1",
+    "ttypescript": "1.5.13",
+    "typescript": "4.9.3",
+    "web-streams-polyfill": "4.0.0-beta.3"
+  }
+}

data/lib/game_dig/node/node_modules/form-data-encoder/readme.md

@@ -0,0 +1,368 @@
+# form-data-encoder
+
+Encode `FormData` content into the `multipart/form-data` format
+
+[![Code Coverage](https://codecov.io/github/octet-stream/form-data-encoder/coverage.svg?branch=master)](https://codecov.io/github/octet-stream/form-data-encoder?branch=master)
+[![CI](https://github.com/octet-stream/form-data-encoder/workflows/CI/badge.svg)](https://github.com/octet-stream/form-data-encoder/actions/workflows/ci.yml)
+[![ESLint](https://github.com/octet-stream/form-data-encoder/workflows/ESLint/badge.svg)](https://github.com/octet-stream/form-data-encoder/actions/workflows/eslint.yml)
+
+## Requirements
+
+- Node.js v14.17 or higher;
+- Runtime should support `TextEncoder`, `TextDecoder`, `WeakMap`, `WeakSet` and async generator functions;
+- For TypeScript users: tsc v4.3 or higher.
+
+## Installation
+
+You can install this package using npm:
+
+```sh
+npm install form-data-encoder
+```
+
+Or yarn:
+
+```sh
+yarn add form-data-encoder
+```
+
+Or pnpm:
+
+```sh
+pnpm add form-data-encoder
+```
+
+## Usage
+
+1. To start the encoding process, you need to create a new Encoder instance with the FormData you want to encode:
+
+```js
+import {Readable} from "stream"
+
+import {FormData, File} from "formdata-node"
+import {FormDataEncoder} from "form-data-encoder"
+
+import fetch from "node-fetch"
+
+const form = new FormData()
+
+form.set("greeting", "Hello, World!")
+form.set("file", new File(["On Soviet Moon landscape see binoculars through YOU"], "file.txt"))
+
+const encoder = new FormDataEncoder(form)
+
+const options = {
+  method: "post",
+
+  // Set request headers provided by the Encoder.
+  // The `headers` property has `Content-Type` and `Content-Length` headers.
+  headers: encoder.headers,
+
+  // Create a Readable stream from the Encoder.
+  // You can omit usage of `Readable.from` for HTTP clients whose support async iterables in request body.
+  // The Encoder will yield FormData content portions encoded into the multipart/form-data format as node-fetch consumes the stream.
+  body: Readable.from(encoder.encode()) // or just Readable.from(encoder)
+}
+
+const response = await fetch("https://httpbin.org/post", options)
+
+console.log(await response.json())
+```
+
+2. Encoder support different spec-compatible FormData implementations. Let's try it with [`formdata-polyfill`](https://github.com/jimmywarting/FormData):
+
+```js
+import {Readable} from "stream"
+
+import {FormDataEncoder} from "form-data-encoder"
+import {FormData} from "formdata-polyfill/esm-min.js"
+import {File} from "fetch-blob" // v3
+
+const form = new FormData()
+
+form.set("field", "Some value")
+form.set("file", new File(["File content goes here"], "file.txt"))
+
+const encoder = new FormDataEncoder(form)
+
+const options = {
+  method: "post",
+  headers: encoder.headers,
+  body: Readable.from(encoder)
+}
+
+await fetch("https://httpbin.org/post", options)
+```
+
+3. Because the Encoder is iterable (it has both Symbol.asyncIterator and Symbol.iterator methods), you can use it with different targets. Let's say you want to convert FormData content into `Blob`, for that you can write a function like this:
+
+```js
+import {Readable} from "stream"
+
+import {FormDataEncoder} from "form-data-encoder"
+
+import {FormData, File, Blob, fileFromPath} from "formdata-node"
+
+import fetch from "node-fetch"
+
+const form = new FormData()
+
+form.set("field", "Just a random string")
+form.set("file", new File(["Using files is class amazing"], "file.txt"))
+form.set("fileFromPath", await fileFromPath("path/to/a/file.txt"))
+
+// Note 1: When using with native Blob or fetch-blob@2 you might also need to generate boundary string for your FormDataEncoder instance
+// because Blob will lowercase value of the `type` option and default boundary generator produces a string with both lower and upper cased alphabetical characters. Math.random() should be enough to fix this:
+// const encoder = new FormDataEncoder(form, String(Math.random()))
+const encoder = new FormDataEncoder(form)
+
+const options = {
+  method: "post",
+
+  // Note 2: To use this approach with fetch-blob@2 you probably gonna need to convert the encoder parts output to an array first:
+  // new Blob([...encoder], {type: encoder.contentType})
+  body: new Blob(encoder, {type: encoder.contentType})
+}
+
+const response = await fetch("https://httpbin.org/post", options)
+
+console.log(await response.json())
+```
+
+4. Here's FormData to Blob conversion with async-iterator approach:
+
+```js
+import {FormData} from "formdata-polyfill/esm-min.js"
+import {blobFrom} from "fetch-blob/from.js"
+import {FormDataEncoder} from "form-data-encoder"
+
+import Blob from "fetch-blob"
+import fetch from "node-fetch"
+
+// This approach may require much more RAM compared to the previous one, but it works too.
+async function toBlob(form) {
+  const encoder = new Encoder(form)
+  const chunks = []
+
+  for await (const chunk of encoder) {
+    chunks.push(chunk)
+  }
+
+  return new Blob(chunks, {type: encoder.contentType})
+}
+
+const form = new FormData()
+
+form.set("name", "John Doe")
+form.set("avatar", await blobFrom("path/to/an/avatar.png"), "avatar.png")
+
+const options = {
+  method: "post",
+  body: await toBlob(form)
+}
+
+await fetch("https://httpbin.org/post", options)
+```
+
+5. Another way to convert FormData parts to blob using `form-data-encoder` is making a Blob-ish class:
+
+```js
+import {Readable} from "stream"
+
+import {FormDataEncoder} from "form-data-encoder"
+import {FormData} from "formdata-polyfill/esm-min.js"
+import {blobFrom} from "fetch-blob/from.js"
+
+import Blob from "fetch-blob"
+import fetch from "node-fetch"
+
+class BlobDataItem {
+  constructor(encoder) {
+    this.#encoder = encoder
+    this.#size = encoder.headers["Content-Length"]
+    this.#type = encoder.headers["Content-Type"]
+  }
+
+  get type() {
+    return this.#type
+  }
+
+  get size() {
+    return this.#size
+  }
+
+  stream() {
+    return Readable.from(this.#encoder)
+  }
+
+  get [Symbol.toStringTag]() {
+    return "Blob"
+  }
+}
+
+const form = new FormData()
+
+form.set("name", "John Doe")
+form.set("avatar", await blobFrom("path/to/an/avatar.png"), "avatar.png")
+
+const encoder = new FormDataEncoder(form)
+
+// Note that node-fetch@2 performs more strictness tests for Blob objects, so you may need to do extra steps before you set up request body (like, maybe you'll need to instaniate a Blob with BlobDataItem as one of its blobPart)
+const blob = new BlobDataItem(enocoder) // or new Blob([new BlobDataItem(enocoder)], {type: encoder.contentType})
+
+const options = {
+  method: "post",
+  body: blob
+}
+
+await fetch("https://httpbin.org/post", options)
+```
+
+6. In this example we will pull FormData content into the ReadableStream:
+
+```js
+ // This module is only necessary when you targeting Node.js or need web streams that implement Symbol.asyncIterator
+import {ReadableStream} from "web-streams-polyfill/ponyfill/es2018"
+
+import {FormDataEncoder} from "form-data-encoder"
+import {FormData} from "formdata-node"
+
+import fetch from "node-fetch"
+
+function toReadableStream(encoder) {
+  const iterator = encoder.encode()
+
+  return new ReadableStream({
+    async pull(controller) {
+      const {value, done} = await iterator.next()
+
+      if (done) {
+        return controller.close()
+      }
+
+      controller.enqueue(value)
+    }
+  })
+}
+
+const form = new FormData()
+
+form.set("field", "My hovercraft is full of eels")
+
+const encoder = new FormDataEncoder(form)
+
+const options = {
+  method: "post",
+  headers: encoder.headers,
+  body: toReadableStream(encoder)
+}
+
+// Note that this example requires `fetch` to support Symbol.asyncIterator, which node-fetch lacks of (but will support eventually)
+await fetch("https://httpbin.org/post", options)
+```
+
+7. Speaking of async iterables - if HTTP client supports them, you can use encoder like this:
+
+```js
+import {FormDataEncoder} from "form-data-encoder"
+import {FormData} from "formdata-node"
+
+import fetch from "node-fetch"
+
+const form = new FormData()
+
+form.set("field", "My hovercraft is full of eels")
+
+const encoder = new FormDataEncoder(form)
+
+const options = {
+  method: "post",
+  headers: encoder.headers,
+  body: encoder
+}
+
+await fetch("https://httpbin.org/post", options)
+```
+
+8. ...And for those client whose supporting form-data-encoder out of the box, the usage will be much, much more simpler:
+
+```js
+import {FormData} from "formdata-node" // Or any other spec-compatible implementation
+
+import fetch from "node-fetch"
+
+const form = new FormData()
+
+form.set("field", "My hovercraft is full of eels")
+
+const options = {
+  method: "post",
+  body: form
+}
+
+// Note that node-fetch does NOT support form-data-encoder
+await fetch("https://httpbin.org/post", options)
+```
+
+## API
+
+### `class FormDataEncoder`
+
+##### `constructor(form[, boundary, options]) -> {FormDataEncoder}`
+
+  - **{FormDataLike}** form - FormData object to encode. This object must be a spec-compatible FormData implementation.
+  - **{string}** [boundary] - An optional boundary string that will be used by the encoder. If there's no boundary string is present, FormDataEncoder will generate it automatically.
+  - **{object}** [options] - FormDataEncoder options.
+  - **{boolean}** [options.enableAdditionalHeaders = false] - When enabled, the encoder will emit additional per part headers, such as `Content-Length`. Please note that the web clients do not include these, so when enabled this option might cause an error if `multipart/form-data` does not consider additional headers.
+
+Creates a `multipart/form-data` encoder.
+
+#### Instance properties
+
+##### `boundary -> {string}`
+
+Returns boundary string.
+
+##### `contentType -> {string}`
+
+Returns Content-Type header.
+
+##### `contentLength -> {string}`
+
+Return Content-Length header.
+
+##### `headers -> {object}`
+
+Returns headers object with Content-Type and Content-Length header.
+
+#### Instance methods
+
+##### `values() -> {Generator<Uint8Array | FileLike, void, undefined>}`
+
+Creates an iterator allowing to go through form-data parts (with metadata).
+This method **will not** read the files.
+
+##### `encode() -> {AsyncGenerator<Uint8Array, void, undefined>}`
+
+Creates an async iterator allowing to perform the encoding by portions.
+This method **will** also read files.
+
+##### `[Symbol.iterator]() -> {Generator<Uint8Array | FileLike, void, undefined>}`
+
+An alias for `Encoder#values()` method.
+
+##### `[Symbol.asyncIterator]() -> {AsyncGenerator<Uint8Array, void, undefined>}`
+
+An alias for `Encoder#encode()` method.
+
+### `isFile(value) -> {boolean}`
+
+Check if a value is File-ish object.
+
+  - **{unknown}** value - a value to test
+
+### `isFormData(value) -> {boolean}`
+
+Check if a value is FormData-ish object.
+
+  - **{unknown}** value - a value to test