@esportsplus/typescript 0.7.1 → 0.8.1

package/node_modules/queue-lit/dist/queue-lit.module.js

@@ -0,0 +1,110 @@
+var id = 0;
+function _classPrivateFieldLooseKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+function _classPrivateFieldLooseBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+  return receiver;
+}
+
+let _Symbol$iterator;
+class Node {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Queue
+ * @implements Iterable<Value>
+ * @template Value
+ */
+var _head = /*#__PURE__*/_classPrivateFieldLooseKey("head");
+var _tail = /*#__PURE__*/_classPrivateFieldLooseKey("tail");
+var _size = /*#__PURE__*/_classPrivateFieldLooseKey("size");
+_Symbol$iterator = Symbol.iterator;
+class Queue {
+  constructor() {
+    Object.defineProperty(this, _head, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _tail, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _size, {
+      writable: true,
+      value: void 0
+    });
+    this.clear();
+  }
+
+  /**
+   * clear
+   * @returns {void}
+   */
+  clear() {
+    _classPrivateFieldLooseBase(this, _head)[_head] = undefined;
+    _classPrivateFieldLooseBase(this, _tail)[_tail] = undefined;
+    _classPrivateFieldLooseBase(this, _size)[_size] = 0;
+  }
+
+  /**
+   * push
+   * @param {Value} value
+   * @returns {number}
+   */
+  push(value) {
+    const node = new Node(value);
+    if (_classPrivateFieldLooseBase(this, _head)[_head]) {
+      _classPrivateFieldLooseBase(this, _tail)[_tail].next = node;
+      _classPrivateFieldLooseBase(this, _tail)[_tail] = node;
+    } else {
+      _classPrivateFieldLooseBase(this, _head)[_head] = node;
+      _classPrivateFieldLooseBase(this, _tail)[_tail] = node;
+    }
+    _classPrivateFieldLooseBase(this, _size)[_size]++;
+    return _classPrivateFieldLooseBase(this, _size)[_size];
+  }
+
+  /**
+   * pop
+   * @returns {Value | undefined}
+   */
+  pop() {
+    const current = _classPrivateFieldLooseBase(this, _head)[_head];
+    if (!current) {
+      return;
+    }
+    _classPrivateFieldLooseBase(this, _head)[_head] = _classPrivateFieldLooseBase(this, _head)[_head].next;
+    _classPrivateFieldLooseBase(this, _size)[_size]--;
+    return current.value;
+  }
+
+  /**
+   * size
+   * @returns {number}
+   */
+  get size() {
+    return _classPrivateFieldLooseBase(this, _size)[_size];
+  }
+
+  /**
+   * Iterator
+   * @returns {IterableIterator<Value>}
+   */
+  *[_Symbol$iterator]() {
+    let current = _classPrivateFieldLooseBase(this, _head)[_head];
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+}
+
+export { Queue };

package/node_modules/queue-lit/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "queue-lit",
+  "description": "queue-lit is a tiny queue data structure in case you `Array#push()` or `Array#shift()` on large arrays very often",
+  "version": "1.5.2",
+  "author": "Joel Voß <mail@joelvoss.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/joelvoss/queue-lit",
+  "bugs": {
+    "url": "https://github.com/joelvoss/queue-lit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/joelvoss/queue-lit.git"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "type": "module",
+  "source": "src/index.js",
+  "main": "dist/queue-lit.cjs",
+  "module": "dist/queue-lit.module.js",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/queue-lit.cjs",
+    "import": "./dist/queue-lit.modern.js"
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "./Taskfile.sh",
+    "test": "./Taskfile.sh test",
+    "prepublishOnly": "./Taskfile.sh build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@jvdx/core": "^3.6.0"
+  },
+  "prettier": "@jvdx/prettier-config",
+  "prettierIgnore": [
+    "tests/",
+    "dist/"
+  ],
+  "eslintConfig": {
+    "extends": "@jvdx/eslint-config"
+  },
+  "eslintIgnore": [
+    "tests/",
+    "dist/"
+  ]
+}

package/node_modules/queue-microtask/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) Feross Aboukhadijeh
+
+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.

package/node_modules/queue-microtask/README.md

@@ -0,0 +1,90 @@
+# queue-microtask [![ci][ci-image]][ci-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
+
+[ci-image]: https://img.shields.io/github/workflow/status/feross/queue-microtask/ci/master
+[ci-url]: https://github.com/feross/queue-microtask/actions
+[npm-image]: https://img.shields.io/npm/v/queue-microtask.svg
+[npm-url]: https://npmjs.org/package/queue-microtask
+[downloads-image]: https://img.shields.io/npm/dm/queue-microtask.svg
+[downloads-url]: https://npmjs.org/package/queue-microtask
+[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
+[standard-url]: https://standardjs.com
+
+### fast, tiny [`queueMicrotask`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/queueMicrotask) shim for modern engines
+
+- Use [`queueMicrotask`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/queueMicrotask) in all modern JS engines.
+- No dependencies. Less than 10 lines. No shims or complicated fallbacks.
+- Optimal performance in all modern environments
+  - Uses `queueMicrotask` in modern environments
+  - Fallback to `Promise.resolve().then(fn)` in Node.js 10 and earlier, and old browsers (same performance as `queueMicrotask`)
+
+## install
+
+```
+npm install queue-microtask
+```
+
+## usage
+
+```js
+const queueMicrotask = require('queue-microtask')
+
+queueMicrotask(() => { /* this will run soon */ })
+```
+
+## What is `queueMicrotask` and why would one use it?
+
+The `queueMicrotask` function is a WHATWG standard. It queues a microtask to be executed prior to control returning to the event loop.
+
+A microtask is a short function which will run after the current task has completed its work and when there is no other code waiting to be run before control of the execution context is returned to the event loop.
+
+The code `queueMicrotask(fn)` is equivalent to the code `Promise.resolve().then(fn)`. It is also very similar to [`process.nextTick(fn)`](https://nodejs.org/api/process.html#process_process_nexttick_callback_args) in Node.
+
+Using microtasks lets code run without interfering with any other, potentially higher priority, code that is pending, but before the JS engine regains control over the execution context.
+
+See the [spec](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#microtask-queuing) or [Node documentation](https://nodejs.org/api/globals.html#globals_queuemicrotask_callback) for more information.
+
+## Who is this package for?
+
+This package allows you to use `queueMicrotask` safely in all modern JS engines. Use it if you prioritize small JS bundle size over support for old browsers.
+
+If you just need to support Node 12 and later, use `queueMicrotask` directly. If you need to support all versions of Node, use this package.
+
+## Why not use `process.nextTick`?
+
+In Node, `queueMicrotask` and `process.nextTick` are [essentially equivalent](https://nodejs.org/api/globals.html#globals_queuemicrotask_callback), though there are [subtle differences](https://github.com/YuzuJS/setImmediate#macrotasks-and-microtasks) that don't matter in most situations.
+
+You can think of `queueMicrotask` as a standardized version of `process.nextTick` that works in the browser. No need to rely on your browser bundler to shim `process` for the browser environment.
+
+## Why not use `setTimeout(fn, 0)`?
+
+This approach is the most compatible, but it has problems. Modern browsers throttle timers severely, so `setTimeout(…, 0)` usually takes at least 4ms to run. Furthermore, the throttling gets even worse if the page is backgrounded. If you have many `setTimeout` calls, then this can severely limit the performance of your program.
+
+## Why not use a microtask library like [`immediate`](https://www.npmjs.com/package/immediate) or [`asap`](https://www.npmjs.com/package/asap)?
+
+These packages are great! However, if you prioritize small JS bundle size over optimal performance in old browsers then you may want to consider this package.
+
+This package (`queue-microtask`) is four times smaller than `immediate`, twice as small as `asap`, and twice as small as using `process.nextTick` and letting the browser bundler shim it automatically.
+
+Note: This package throws an exception in JS environments which lack `Promise` support -- which are usually very old browsers and Node.js versions.
+
+Since the `queueMicrotask` API is supported in Node.js, Chrome, Firefox, Safari, Opera, and Edge, **the vast majority of users will get optimal performance**. Any JS environment with `Promise`, which is almost all of them, also get optimal performance. If you need support for JS environments which lack `Promise` support, use one of the alternative packages.
+
+## What is a shim?
+
+> In computer programming, a shim is a library that transparently intercepts API calls and changes the arguments passed, handles the operation itself or redirects the operation elsewhere. – [Wikipedia](https://en.wikipedia.org/wiki/Shim_(computing))
+
+This package could also be described as a "ponyfill".
+
+> A ponyfill is almost the same as a polyfill, but not quite. Instead of patching functionality for older browsers, a ponyfill provides that functionality as a standalone module you can use. – [PonyFoo](https://ponyfoo.com/articles/polyfills-or-ponyfills)
+
+## API
+
+### `queueMicrotask(fn)`
+
+The `queueMicrotask()` method queues a microtask.
+
+The `fn` argument is a function to be executed after all pending tasks have completed but before yielding control to the browser's event loop.
+
+## license
+
+MIT. Copyright (c) [Feross Aboukhadijeh](https://feross.org).

package/node_modules/queue-microtask/index.d.ts

@@ -0,0 +1,2 @@
+declare const queueMicrotask: (cb: () => void) => void
+export = queueMicrotask

package/node_modules/queue-microtask/index.js

@@ -0,0 +1,9 @@
+/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+let promise
+
+module.exports = typeof queueMicrotask === 'function'
+  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : global)
+  // reuse resolved promise, and allocate it lazily
+  : cb => (promise || (promise = Promise.resolve()))
+    .then(cb)
+    .catch(err => setTimeout(() => { throw err }, 0))

package/node_modules/queue-microtask/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "queue-microtask",
+  "description": "fast, tiny `queueMicrotask` shim for modern engines",
+  "version": "1.2.3",
+  "author": {
+    "name": "Feross Aboukhadijeh",
+    "email": "feross@feross.org",
+    "url": "https://feross.org"
+  },
+  "bugs": {
+    "url": "https://github.com/feross/queue-microtask/issues"
+  },
+  "devDependencies": {
+    "standard": "*",
+    "tape": "^5.2.2"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/feross"
+    },
+    {
+      "type": "patreon",
+      "url": "https://www.patreon.com/feross"
+    },
+    {
+      "type": "consulting",
+      "url": "https://feross.org/support"
+    }
+  ],
+  "homepage": "https://github.com/feross/queue-microtask",
+  "keywords": [
+    "asap",
+    "immediate",
+    "micro task",
+    "microtask",
+    "nextTick",
+    "process.nextTick",
+    "queue micro task",
+    "queue microtask",
+    "queue-microtask",
+    "queueMicrotask",
+    "setImmediate",
+    "task"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/feross/queue-microtask.git"
+  },
+  "scripts": {
+    "test": "standard && tape test/*.js"
+  }
+}

package/node_modules/readdirp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.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.

package/node_modules/readdirp/README.md

@@ -0,0 +1,122 @@
+# readdirp [![Weekly downloads](https://img.shields.io/npm/dw/readdirp.svg)](https://github.com/paulmillr/readdirp)
+
+Recursive version of [fs.readdir](https://nodejs.org/api/fs.html#fs_fs_readdir_path_options_callback). Exposes a **stream API** and a **promise API**.
+
+
+```sh
+npm install readdirp
+```
+
+```javascript
+const readdirp = require('readdirp');
+
+// Use streams to achieve small RAM & CPU footprint.
+// 1) Streams example with for-await.
+for await (const entry of readdirp('.')) {
+  const {path} = entry;
+  console.log(`${JSON.stringify({path})}`);
+}
+
+// 2) Streams example, non for-await.
+// Print out all JS files along with their size within the current folder & subfolders.
+readdirp('.', {fileFilter: '*.js', alwaysStat: true})
+  .on('data', (entry) => {
+    const {path, stats: {size}} = entry;
+    console.log(`${JSON.stringify({path, size})}`);
+  })
+  // Optionally call stream.destroy() in `warn()` in order to abort and cause 'close' to be emitted
+  .on('warn', error => console.error('non-fatal error', error))
+  .on('error', error => console.error('fatal error', error))
+  .on('end', () => console.log('done'));
+
+// 3) Promise example. More RAM and CPU than streams / for-await.
+const files = await readdirp.promise('.');
+console.log(files.map(file => file.path));
+
+// Other options.
+readdirp('test', {
+  fileFilter: '*.js',
+  directoryFilter: ['!.git', '!*modules']
+  // directoryFilter: (di) => di.basename.length === 9
+  type: 'files_directories',
+  depth: 1
+});
+```
+
+For more examples, check out `examples` directory.
+
+## API
+
+`const stream = readdirp(root[, options])` — **Stream API**
+
+- Reads given root recursively and returns a `stream` of [entry infos](#entryinfo)
+- Optionally can be used like `for await (const entry of stream)` with node.js 10+ (`asyncIterator`).
+- `on('data', (entry) => {})` [entry info](#entryinfo) for every file / dir.
+- `on('warn', (error) => {})` non-fatal `Error` that prevents a file / dir from being processed. Example: inaccessible to the user.
+- `on('error', (error) => {})` fatal `Error` which also ends the stream. Example: illegal options where passed.
+- `on('end')` — we are done. Called when all entries were found and no more will be emitted.
+- `on('close')` — stream is destroyed via `stream.destroy()`.
+  Could be useful if you want to manually abort even on a non fatal error.
+  At that point the stream is no longer `readable` and no more entries, warning or errors are emitted
+- To learn more about streams, consult the very detailed [nodejs streams documentation](https://nodejs.org/api/stream.html)
+  or the [stream-handbook](https://github.com/substack/stream-handbook)
+
+`const entries = await readdirp.promise(root[, options])` — **Promise API**. Returns a list of [entry infos](#entryinfo).
+
+First argument is awalys `root`, path in which to start reading and recursing into subdirectories.
+
+### options
+
+- `fileFilter: ["*.js"]`: filter to include or exclude files. A `Function`, Glob string or Array of glob strings.
+    - **Function**: a function that takes an entry info as a parameter and returns true to include or false to exclude the entry
+    - **Glob string**: a string (e.g., `*.js`) which is matched using [picomatch](https://github.com/micromatch/picomatch), so go there for more
+        information. Globstars (`**`) are not supported since specifying a recursive pattern for an already recursive function doesn't make sense. Negated globs (as explained in the minimatch documentation) are allowed, e.g., `!*.txt` matches everything but text files.
+    - **Array of glob strings**: either need to be all inclusive or all exclusive (negated) patterns otherwise an error is thrown.
+        `['*.json', '*.js']` includes all JavaScript and Json files.
+        `['!.git', '!node_modules']` includes all directories except the '.git' and 'node_modules'.
+    - Directories that do not pass a filter will not be recursed into.
+- `directoryFilter: ['!.git']`: filter to include/exclude directories found and to recurse into. Directories that do not pass a filter will not be recursed into.
+- `depth: 5`: depth at which to stop recursing even if more subdirectories are found
+- `type: 'files'`: determines if data events on the stream should be emitted for `'files'` (default), `'directories'`, `'files_directories'`, or `'all'`. Setting to `'all'` will also include entries for other types of file descriptors like character devices, unix sockets and named pipes.
+- `alwaysStat: false`: always return `stats` property for every file. Default is `false`, readdirp will return `Dirent` entries. Setting it to `true` can double readdir execution time - use it only when you need file `size`, `mtime` etc. Cannot be enabled on node <10.10.0.
+- `lstat: false`: include symlink entries in the stream along with files. When `true`, `fs.lstat` would be used instead of `fs.stat`
+
+### `EntryInfo`
+
+Has the following properties:
+
+- `path: 'assets/javascripts/react.js'`: path to the file/directory (relative to given root)
+- `fullPath: '/Users/dev/projects/app/assets/javascripts/react.js'`: full path to the file/directory found
+- `basename: 'react.js'`: name of the file/directory
+- `dirent: fs.Dirent`: built-in [dir entry object](https://nodejs.org/api/fs.html#fs_class_fs_dirent) - only with `alwaysStat: false`
+- `stats: fs.Stats`: built in [stat object](https://nodejs.org/api/fs.html#fs_class_fs_stats) - only with `alwaysStat: true`
+
+## Changelog
+
+- 3.5 (Oct 13, 2020) disallows recursive directory-based symlinks.
+  Before, it could have entered infinite loop.
+- 3.4 (Mar 19, 2020) adds support for directory-based symlinks.
+- 3.3 (Dec 6, 2019) stabilizes RAM consumption and enables perf management with `highWaterMark` option. Fixes race conditions related to `for-await` looping.
+- 3.2 (Oct 14, 2019) improves performance by 250% and makes streams implementation more idiomatic.
+- 3.1 (Jul 7, 2019) brings `bigint` support to `stat` output on Windows. This is backwards-incompatible for some cases. Be careful. It you use it incorrectly, you'll see "TypeError: Cannot mix BigInt and other types, use explicit conversions".
+- 3.0 brings huge performance improvements and stream backpressure support.
+- Upgrading 2.x to 3.x:
+    - Signature changed from `readdirp(options)` to `readdirp(root, options)`
+    - Replaced callback API with promise API.
+    - Renamed `entryType` option to `type`
+    - Renamed `entryType: 'both'` to `'files_directories'`
+    - `EntryInfo`
+        - Renamed `stat` to `stats`
+            - Emitted only when `alwaysStat: true`
+            - `dirent` is emitted instead of `stats` by default with `alwaysStat: false`
+        - Renamed `name` to `basename`
+        - Removed `parentDir` and `fullParentDir` properties
+- Supported node.js versions:
+    - 3.x: node 8+
+    - 2.x: node 0.6+
+
+## License
+
+Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (<https://paulmillr.com>)
+
+MIT License, see [LICENSE](LICENSE) file.

package/node_modules/readdirp/index.d.ts

@@ -0,0 +1,43 @@
+// TypeScript Version: 3.2
+
+/// <reference types="node" lib="esnext" />
+
+import * as fs from 'fs';
+import { Readable } from 'stream';
+
+declare namespace readdir {
+  interface EntryInfo {
+    path: string;
+    fullPath: string;
+    basename: string;
+    stats?: fs.Stats;
+    dirent?: fs.Dirent;
+  }
+
+  interface ReaddirpOptions {
+    root?: string;
+    fileFilter?: string | string[] | ((entry: EntryInfo) => boolean);
+    directoryFilter?: string | string[] | ((entry: EntryInfo) => boolean);
+    type?: 'files' | 'directories' | 'files_directories' | 'all';
+    lstat?: boolean;
+    depth?: number;
+    alwaysStat?: boolean;
+  }
+
+  interface ReaddirpStream extends Readable, AsyncIterable<EntryInfo> {
+    read(): EntryInfo;
+    [Symbol.asyncIterator](): AsyncIterableIterator<EntryInfo>;
+  }
+
+  function promise(
+    root: string,
+    options?: ReaddirpOptions
+  ): Promise<EntryInfo[]>;
+}
+
+declare function readdir(
+  root: string,
+  options?: readdir.ReaddirpOptions
+): readdir.ReaddirpStream;
+
+export = readdir;