@esportsplus/typescript 0.8.3 → 0.8.5

package/node_modules/micromatch/index.js

@@ -0,0 +1,474 @@
+'use strict';
+
+const util = require('util');
+const braces = require('braces');
+const picomatch = require('picomatch');
+const utils = require('picomatch/lib/utils');
+
+const isEmptyString = v => v === '' || v === './';
+const hasBraces = v => {
+  const index = v.indexOf('{');
+  return index > -1 && v.indexOf('}', index) > -1;
+};
+
+/**
+ * Returns an array of strings that match one or more glob patterns.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm(list, patterns[, options]);
+ *
+ * console.log(mm(['a.js', 'a.txt'], ['*.js']));
+ * //=> [ 'a.js' ]
+ * ```
+ * @param {String|Array<string>} `list` List of strings to match.
+ * @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options)
+ * @return {Array} Returns an array of matches
+ * @summary false
+ * @api public
+ */
+
+const micromatch = (list, patterns, options) => {
+  patterns = [].concat(patterns);
+  list = [].concat(list);
+
+  let omit = new Set();
+  let keep = new Set();
+  let items = new Set();
+  let negatives = 0;
+
+  let onResult = state => {
+    items.add(state.output);
+    if (options && options.onResult) {
+      options.onResult(state);
+    }
+  };
+
+  for (let i = 0; i < patterns.length; i++) {
+    let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
+    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+    if (negated) negatives++;
+
+    for (let item of list) {
+      let matched = isMatch(item, true);
+
+      let match = negated ? !matched.isMatch : matched.isMatch;
+      if (!match) continue;
+
+      if (negated) {
+        omit.add(matched.output);
+      } else {
+        omit.delete(matched.output);
+        keep.add(matched.output);
+      }
+    }
+  }
+
+  let result = negatives === patterns.length ? [...items] : [...keep];
+  let matches = result.filter(item => !omit.has(item));
+
+  if (options && matches.length === 0) {
+    if (options.failglob === true) {
+      throw new Error(`No matches found for "${patterns.join(', ')}"`);
+    }
+
+    if (options.nonull === true || options.nullglob === true) {
+      return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns;
+    }
+  }
+
+  return matches;
+};
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch.match = micromatch;
+
+/**
+ * Returns a matcher function from the given glob `pattern` and `options`.
+ * The returned function takes a string to match as its only argument and returns
+ * true if the string is a match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matcher(pattern[, options]);
+ *
+ * const isMatch = mm.matcher('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @param {String} `pattern` Glob pattern
+ * @param {Object} `options`
+ * @return {Function} Returns a matcher function.
+ * @api public
+ */
+
+micromatch.matcher = (pattern, options) => picomatch(pattern, options);
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.isMatch(string, patterns[, options]);
+ *
+ * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(mm.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `[options]` See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch.any = micromatch.isMatch;
+
+/**
+ * Returns a list of strings that _**do not match any**_ of the given `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.not(list, patterns[, options]);
+ *
+ * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+ * //=> ['b.b', 'c.c']
+ * ```
+ * @param {Array} `list` Array of strings to match.
+ * @param {String|Array} `patterns` One or more glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of strings that **do not match** the given patterns.
+ * @api public
+ */
+
+micromatch.not = (list, patterns, options = {}) => {
+  patterns = [].concat(patterns).map(String);
+  let result = new Set();
+  let items = [];
+
+  let onResult = state => {
+    if (options.onResult) options.onResult(state);
+    items.push(state.output);
+  };
+
+  let matches = new Set(micromatch(list, patterns, { ...options, onResult }));
+
+  for (let item of items) {
+    if (!matches.has(item)) {
+      result.add(item);
+    }
+  }
+  return [...result];
+};
+
+/**
+ * Returns true if the given `string` contains the given pattern. Similar
+ * to [.isMatch](#isMatch) but the pattern can match any part of the string.
+ *
+ * ```js
+ * var mm = require('micromatch');
+ * // mm.contains(string, pattern[, options]);
+ *
+ * console.log(mm.contains('aa/bb/cc', '*b'));
+ * //=> true
+ * console.log(mm.contains('aa/bb/cc', '*d'));
+ * //=> false
+ * ```
+ * @param {String} `str` The string to match.
+ * @param {String|Array} `patterns` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any of the patterns matches any part of `str`.
+ * @api public
+ */
+
+micromatch.contains = (str, pattern, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+  }
+
+  if (Array.isArray(pattern)) {
+    return pattern.some(p => micromatch.contains(str, p, options));
+  }
+
+  if (typeof pattern === 'string') {
+    if (isEmptyString(str) || isEmptyString(pattern)) {
+      return false;
+    }
+
+    if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {
+      return true;
+    }
+  }
+
+  return micromatch.isMatch(str, pattern, { ...options, contains: true });
+};
+
+/**
+ * Filter the keys of the given object with the given `glob` pattern
+ * and `options`. Does not attempt to match nested keys. If you need this feature,
+ * use [glob-object][] instead.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matchKeys(object, patterns[, options]);
+ *
+ * const obj = { aa: 'a', ab: 'b', ac: 'c' };
+ * console.log(mm.matchKeys(obj, '*b'));
+ * //=> { ab: 'b' }
+ * ```
+ * @param {Object} `object` The object with keys to filter.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Object} Returns an object with only keys that match the given patterns.
+ * @api public
+ */
+
+micromatch.matchKeys = (obj, patterns, options) => {
+  if (!utils.isObject(obj)) {
+    throw new TypeError('Expected the first argument to be an object');
+  }
+  let keys = micromatch(Object.keys(obj), patterns, options);
+  let res = {};
+  for (let key of keys) res[key] = obj[key];
+  return res;
+};
+
+/**
+ * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.some(list, patterns[, options]);
+ *
+ * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // true
+ * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`
+ * @api public
+ */
+
+micromatch.some = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
+    if (items.some(item => isMatch(item))) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Returns true if every string in the given `list` matches
+ * any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.every(list, patterns[, options]);
+ *
+ * console.log(mm.every('foo.js', ['foo.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // false
+ * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`
+ * @api public
+ */
+
+micromatch.every = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
+    if (!items.every(item => isMatch(item))) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Returns true if **all** of the given `patterns` match
+ * the specified string.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.all(string, patterns[, options]);
+ *
+ * console.log(mm.all('foo.js', ['foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', '!foo.js']));
+ * // false
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+ * // true
+ * ```
+ * @param {String|Array} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch.all = (str, patterns, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+  }
+
+  return [].concat(patterns).every(p => picomatch(p, options)(str));
+};
+
+/**
+ * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.capture(pattern, string[, options]);
+ *
+ * console.log(mm.capture('test/*.js', 'test/foo.js'));
+ * //=> ['foo']
+ * console.log(mm.capture('test/*.js', 'foo/bar.css'));
+ * //=> null
+ * ```
+ * @param {String} `glob` Glob pattern to use for matching.
+ * @param {String} `input` String to match
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.
+ * @api public
+ */
+
+micromatch.capture = (glob, input, options) => {
+  let posix = utils.isWindows(options);
+  let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+
+  if (match) {
+    return match.slice(1).map(v => v === void 0 ? '' : v);
+  }
+};
+
+/**
+ * Create a regular expression from the given glob `pattern`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.makeRe(pattern[, options]);
+ *
+ * console.log(mm.makeRe('*.js'));
+ * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+ * ```
+ * @param {String} `pattern` A glob pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+micromatch.makeRe = (...args) => picomatch.makeRe(...args);
+
+/**
+ * Scan a glob pattern to separate the pattern into segments. Used
+ * by the [split](#split) method.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.scan(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+micromatch.scan = (...args) => picomatch.scan(...args);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.parse(pattern[, options]);
+ * ```
+ * @param {String} `glob`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as regex source string.
+ * @api public
+ */
+
+micromatch.parse = (patterns, options) => {
+  let res = [];
+  for (let pattern of [].concat(patterns || [])) {
+    for (let str of braces(String(pattern), options)) {
+      res.push(picomatch.parse(str, options));
+    }
+  }
+  return res;
+};
+
+/**
+ * Process the given brace `pattern`.
+ *
+ * ```js
+ * const { braces } = require('micromatch');
+ * console.log(braces('foo/{a,b,c}/bar'));
+ * //=> [ 'foo/(a|b|c)/bar' ]
+ *
+ * console.log(braces('foo/{a,b,c}/bar', { expand: true }));
+ * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
+ * ```
+ * @param {String} `pattern` String with brace pattern to process.
+ * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.
+ * @return {Array}
+ * @api public
+ */
+
+micromatch.braces = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  if ((options && options.nobrace === true) || !hasBraces(pattern)) {
+    return [pattern];
+  }
+  return braces(pattern, options);
+};
+
+/**
+ * Expand braces
+ */
+
+micromatch.braceExpand = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  return micromatch.braces(pattern, { ...options, expand: true });
+};
+
+/**
+ * Expose micromatch
+ */
+
+// exposed for tests
+micromatch.hasBraces = hasBraces;
+module.exports = micromatch;

package/node_modules/micromatch/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "micromatch",
+  "description": "Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.",
+  "version": "4.0.8",
+  "homepage": "https://github.com/micromatch/micromatch",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "contributors": [
+    "(https://github.com/DianeLooney)",
+    "Amila Welihinda (amilajack.com)",
+    "Bogdan Chadkin (https://github.com/TrySound)",
+    "Brian Woodward (https://twitter.com/doowb)",
+    "Devon Govett (http://badassjs.com)",
+    "Elan Shanker (https://github.com/es128)",
+    "Fabrício Matté (https://ultcombo.js.org)",
+    "Jon Schlinkert (http://twitter.com/jonschlinkert)",
+    "Martin Kolárik (https://kolarik.sk)",
+    "Olsten Larck (https://i.am.charlike.online)",
+    "Paul Miller (paulmillr.com)",
+    "Tom Byrer (https://github.com/tomByrer)",
+    "Tyler Akins (http://rumkin.com)",
+    "Peter Bright <drpizza@quiscalusmexicanus.org> (https://github.com/drpizza)",
+    "Kuba Juszczyk (https://github.com/ku8ar)"
+  ],
+  "repository": "micromatch/micromatch",
+  "bugs": {
+    "url": "https://github.com/micromatch/micromatch/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=8.6"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "braces": "^3.0.3",
+    "picomatch": "^2.3.1"
+  },
+  "devDependencies": {
+    "fill-range": "^7.0.1",
+    "gulp-format-md": "^2.0.0",
+    "minimatch": "^5.0.1",
+    "mocha": "^9.2.2",
+    "time-require": "github:jonschlinkert/time-require"
+  },
+  "keywords": [
+    "bash",
+    "bracket",
+    "character-class",
+    "expand",
+    "expansion",
+    "expression",
+    "extglob",
+    "extglobs",
+    "file",
+    "files",
+    "filter",
+    "find",
+    "glob",
+    "globbing",
+    "globs",
+    "globstar",
+    "lookahead",
+    "lookaround",
+    "lookbehind",
+    "match",
+    "matcher",
+    "matches",
+    "matching",
+    "micromatch",
+    "minimatch",
+    "multimatch",
+    "negate",
+    "negation",
+    "path",
+    "pattern",
+    "patterns",
+    "posix",
+    "regex",
+    "regexp",
+    "regular",
+    "shell",
+    "star",
+    "wildcard"
+  ],
+  "verb": {
+    "toc": "collapsible",
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "lint": {
+      "reflinks": true
+    },
+    "related": {
+      "list": [
+        "braces",
+        "expand-brackets",
+        "extglob",
+        "fill-range",
+        "nanomatch"
+      ]
+    },
+    "reflinks": [
+      "extglob",
+      "fill-range",
+      "glob-object",
+      "minimatch",
+      "multimatch"
+    ]
+  }
+}

package/node_modules/mylas/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Raoul de Heer
+
+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/mylas/README.md

@@ -0,0 +1,39 @@
+# Mylas 
+![npm](https://img.shields.io/npm/dt/mylas)
+![install size](https://badgen.net/packagephobia/install/mylas)
+![npm bundle size (scoped)](https://img.shields.io/bundlephobia/min/mylas)
+![npm bundle size (scoped)](https://img.shields.io/bundlephobia/minzip/mylas)
+![dependencie count](https://img.shields.io/badge/dependencies-0-brightgreen)
+![GitHub](https://img.shields.io/github/license/raouldeheer/Mylas)
+![npm (scoped)](https://img.shields.io/npm/v/mylas)
+![node-current (scoped)](https://img.shields.io/node/v/mylas)  
+Mylas is a npm package that makes the loading and storing of data from fs easy and reliable. And it supports multithreading, json with comments and loading buffers with multithreading. It can also find [node_modules](https://github.com/raouldeheer/Mylas/wiki/Dir#nodemodules) folders.   
+<img src="https://raw.githubusercontent.com/raouldeheer/Mylas/HEAD/.github/logo.png" width="600"> 
+
+## Installation
+Install Mylas from NPM
+```ts
+npm i mylas
+// Or
+yarn add mylas
+```
+
+## Getting started
+
+To get started have a look at our [wiki](https://github.com/raouldeheer/Mylas/wiki) 
+
+## Examples
+
+- [Json examples](https://github.com/raouldeheer/Mylas/wiki/Json)
+- [File examples](https://github.com/raouldeheer/Mylas/wiki/File)
+- [Buf examples](https://github.com/raouldeheer/Mylas/wiki/Buf)
+- [Dir examples](https://github.com/raouldeheer/Mylas/wiki/Dir)
+
+## Documentation
+All features are listed at the [wiki](https://github.com/raouldeheer/Mylas/wiki)   
+
+## Contributing
+We would love more contributors! To start contributing read our [Contributing page](https://github.com/raouldeheer/Mylas/blob/main/.github/CONTRIBUTING.md).  
+
+## Supported Versions
+Check for supported versions at the [security policy](https://github.com/raouldeheer/Mylas/security/policy).  

package/node_modules/mylas/build/chunk-3EDNT3AM.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _chunkM3H36CX2js = require('./chunk-M3H36CX2.js');var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);var R={load:async(e,r)=>{if(await _chunkM3H36CX2js.c.call(void 0, e)){let t=await _fs2.default.promises.readFile(e);return r==null||r(t),t}else throw new Error(`Can't read from ${e}`)},save:async(e,r,t)=>{if(await _chunkM3H36CX2js.c.call(void 0, e))await _fs2.default.promises.writeFile(e,r),t==null||t();else throw new Error(`Can't write to ${e}`)},loadW:async(e,r)=>{let t=await _chunkM3H36CX2js.d.call(void 0, {method:5,path:e});return r==null||r(Buffer.from(t)),Buffer.from(t)},saveW:async(e,r,t)=>{let o=new Uint8Array(new SharedArrayBuffer(r.byteLength));o.set(r),await _chunkM3H36CX2js.d.call(void 0, {method:6,path:e,data:o,callback:t})}},O= exports.a =R;var _path = require('path'); var _path2 = _interopRequireDefault(_path);var _os = require('os'); var _os2 = _interopRequireDefault(_os);function _(e){let r={cwd:process.cwd(),relative:!0,...typeof e=="string"?{cwd:e}:e},t=[],o=r.cwd,s,i=!1;do if(o.charAt(0)==="~"&&(o=B(o)),o.charAt(0)==="@"&&(o=_path2.default.join(E||(E=g?_path2.default.resolve(c||(c=C()),"node_modules"):_path2.default.resolve(c||(c=C()),"lib/node_modules")),o.slice(1))),s=b(o),s){let n=r.relative?_path2.default.relative(r.cwd,s):s;i=t.indexOf(n)>-1,i||(t.push(n),o=_path2.default.join(s,"../../"))}while(s&&!i);return t}function b(e){let r=_path2.default.resolve(e,"node_modules"),t=_fs2.default.existsSync(r)?_path2.default.resolve(r):null;if(t)return t;let o=_path2.default.dirname(e);return o===e?null:b(o)}var E,c;function C(){if(process.env.PREFIX)c=process.env.PREFIX;else if(c=A(_path2.default.resolve(_os2.default.homedir(),".npmrc")),!c){try{c=A(_path2.default.resolve(I(),"..","..","npmrc")),c&&(c=A(_path2.default.resolve(c,"etc","npmrc"))||c)}catch (e2){}c||(g?c=process.env.APPDATA?_path2.default.join(process.env.APPDATA,"npm"):_path2.default.dirname(process.execPath):(c=_path2.default.dirname(_path2.default.dirname(process.execPath)),process.env.DESTDIR&&(c=_path2.default.join(process.env.DESTDIR,c))))}return c?B(c):""}function A(e){var r;try{return(r=F(_fs2.default.readFileSync(e,"utf-8")))==null?void 0:r.prefix}catch (e3){return null}}function F(e){let r=Object.create(null),t=r,o=null;for(let i of e.split(/[\r\n]+/g)){if(!i||i.match(/^\s*[;#]/))continue;let n=i.match(/^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i);if(!n)continue;if(n[1]!==void 0){if(o=P(n[1]),o==="__proto__"){t=Object.create(null);continue}t=r[o]=r[o]||Object.create(null);continue}let u=P(n[2]||""),d=u.length>2&&u.slice(-2)==="[]",l=d?u.slice(0,-2):u;if(l==="__proto__")continue;let a=n[3]?P(n[4]||""):!0,x=a==="true"||a==="false"||a==="null"?JSON.parse(a):a;d&&(Object.hasOwnProperty.call(t,l)?Array.isArray(t[l])||(t[l]=[t[l]]):t[l]=[]),Array.isArray(t[l])?t[l].push(x):t[l]=x}let s=[];for(let i of Object.keys(r)){if(!Object.hasOwnProperty.call(r,i)||typeof r[i]!="object"||Array.isArray(r[i]))continue;let n=i.replace(/\1/g,"LITERAL\\1LITERAL").replace(/\\\./g,"
").split(/\./).map(a=>a.replace(/\1/g,"\\.").replace(/\2LITERAL\\1LITERAL\2/g,"
")),u=r,d=n.pop()||"",l=d.replace(/\\\./g,".");for(let a of n)a!=="__proto__"&&((!Object.hasOwnProperty.call(u,a)||typeof u[a]!="object")&&(u[a]=Object.create(null)),u=u[a]);u===r&&l===d||(u[l]=r[i],s.push(i))}return s.forEach(i=>delete r[i]),r}function P(e){e=e.trim();let r=e.charAt(0),t=e.charAt(e.length-1);if(r==='"'&&t==='"'||r==="'"&&t==="'"){e=r==="'"?e.substr(1,e.length-2):e;try{return JSON.parse(e)}catch (e4){}}else{let o=!1,s="";for(let i=0;i<e.length;i++){let n=e.charAt(i);if(o)"\\;#".indexOf(n)!==-1?s+=n:s+="\\"+n,o=!1;else{if(";#".indexOf(n)!==-1)break;n==="\\"?o=!0:s+=n}}return o&&(s+="\\"),s.trim()}return e}var B=e=>e.charAt(0)==="~"?e.charAt(1)==="+"?_path2.default.join(process.cwd(),e.slice(2)):_path2.default.join(_os2.default.homedir(),e.slice(1)):e,g=process.platform==="win32"||process.env.OSTYPE==="cygwin"||process.env.OSTYPE==="msys";function I(){let e=(process.env.PATH||"").split(g?";":":"),r=[""];g&&(e.unshift(process.cwd()),r=(process.env.PATHEXT||".EXE;.CMD;.BAT;.COM").split(";"));for(let t of e){let o=_path2.default.join(t.charAt(0)==='"'&&t.slice(-1)==='"'?t.slice(1,-1):t,"npm");for(let s of r)if(M(o+s))return _fs2.default.realpathSync(o+s)}throw new Error("Can't find npm file")}function M(e){try{return(g?r=>{let t=_fs2.default.statSync(r);if(!t.isSymbolicLink()&&!t.isFile())return!1;if(!process.env.PATHEXT)return!0;let o=process.env.PATHEXT.split(";");if(o.indexOf("")!==-1)return!0;for(let s of o){let i=s.toLowerCase();if(i&&r.substr(-i.length).toLowerCase()===i)return!0}return!1}:r=>{let{mode:t,gid:o,uid:s,isFile:i}=_fs2.default.statSync(r);return i()&&(t&1||t&2&&o===process.getgid()||t&4&&s===process.getuid()||t&6&&process.getuid()===0)})(e)}catch (e5){return!1}}var X={mkS:e=>{_chunkM3H36CX2js.b.call(void 0, e)&&_fs2.default.mkdirSync(e,{recursive:!0})},rmS:e=>{_chunkM3H36CX2js.b.call(void 0, e)&&(process.versions.node.startsWith("12")?_fs2.default.rmdirSync(e,{recursive:!0}):_fs2.default.rmSync(e,{recursive:!0,force:!0}))},checkS:e=>_fs2.default.existsSync(e),mk:async(e,r)=>{await _chunkM3H36CX2js.c.call(void 0, e)&&await _fs2.default.promises.mkdir(e,{recursive:!0}),r==null||r()},rm:async(e,r)=>{await _chunkM3H36CX2js.c.call(void 0, e)&&(process.versions.node.startsWith("12")?await _fs2.default.promises.rmdir(e,{recursive:!0}):await _fs2.default.promises.rm(e,{recursive:!0,force:!0})),r==null||r()},check:async(e,r)=>{let t=_fs2.default.existsSync(e);return r==null||r(t),t},nodeModules:e=>_(e)},L= exports.b =X;var W={json:_chunkM3H36CX2js.f,file:_chunkM3H36CX2js.e,dir:L,buf:O,..._chunkM3H36CX2js.e},se= exports.c =W;exports.a = O; exports.b = L; exports.c = se;

package/node_modules/mylas/build/chunk-M3H36CX2.js

@@ -0,0 +1,3 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var w=(t=>(t[t.loadFile=0]="loadFile",t[t.saveFile=1]="saveFile",t[t.loadJson=2]="loadJson",t[t.loadJsonComments=3]="loadJsonComments",t[t.saveJson=4]="saveJson",t[t.loadBuffer=5]="loadBuffer",t[t.saveBuffer=6]="saveBuffer",t))(w||{});var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);var _path = require('path');var v=e=>!!T(e),C= exports.c =async e=>!!T(e),T=e=>{let r=_path.parse.call(void 0, e).dir;return r==""||_fs.existsSync.call(void 0, r)||_fs.mkdirSync.call(void 0, r,{recursive:!0}),_fs.existsSync.call(void 0, r)};var _worker_threads = require('worker_threads');var S=({callback:e,...r})=>new Promise((o,s)=>{let i;new (0, _worker_threads.Worker)(_path.resolve.call(void 0, __dirname,"./worker.js")).once("message",n=>i=n).once("exit",n=>n==0?o(i):s(n)).once("error",n=>s(n)).once("messageerror",n=>s(n)).postMessage(r)}).then(o=>(e==null||e(o),o),o=>{throw new Error(o)}),m= exports.d =S;var h={loadS:e=>{if(v(e))return _fs2.default.readFileSync(e,"utf8");throw new Error(`Can't read from ${e}`)},saveS:(e,r)=>{if(v(e))_fs2.default.writeFileSync(e,r,"utf8");else throw new Error(`Can't write to ${e}`)},load:async(e,r)=>{if(await C(e)){let o=await _fs2.default.promises.readFile(e,"utf8");return r==null||r(o),o}else throw new Error(`Can't read from ${e}`)},save:async(e,r,o)=>{if(await C(e))await _fs2.default.promises.writeFile(e,r,"utf8"),o==null||o();else throw new Error(`Can't write to ${e}`)},loadW:(e,r)=>m({method:0,path:e,callback:r}),saveW:(e,r,o)=>m({method:1,path:e,data:r,callback:o})},a= exports.e =h;var J={loadS:(e,r=!1)=>JSON.parse(r?k(a.loadS(e)):a.loadS(e)),saveS:(e,r)=>a.saveS(e,JSON.stringify(r)),load:async(e,r,o=!1)=>{let s=JSON.parse(o?k(await a.load(e)):await a.load(e));return r==null||r(s),s},save:async(e,r,o)=>{await a.save(e,JSON.stringify(r)),o==null||o()},loadW:(e,r,o=!1)=>m({method:o?3:2,path:e,callback:r}),saveW:(e,r,o)=>m({method:4,path:e,data:r,callback:o})},U= exports.f =J;function k(e){let r=(t,l)=>{let f=0;for(;t[l]==="\\";)l--,f++;return!(f%2)},o=!1,s=!1,i=!1,n=0,u="";for(let t=0;t<e.length;t++){let l=e[t]||"",f=e[t+1]||"",g=!(i||s);if(g&&l==='"'&&r(e,t-1)&&(o=!o),o)continue;let c=l+f;if(g&&c==="//")u+=e.slice(n,t),n=t,s=!0,t++;else if(s&&c===`\r
+`){t++,s=!1,n=t;continue}else if(s&&l===`
+`)s=!1,n=t;else if(g&&c==="/*"){u+=e.slice(n,t),n=t,i=!0,t++;continue}else if(i&&c==="*/"){t++,i=!1,n=t+1;continue}}return(u+(i||s?"":e.slice(n))).replace(/,(?!\s*?[{["'\w])/g,"")}exports.a = w; exports.b = v; exports.c = C; exports.d = m; exports.e = a; exports.f = U;