@parcel/utils 2.10.3 → 2.12.0

package/lib/index.js

@@ -1119,7 +1119,18 @@ var $9kveb = parcelRequire("9kveb");
             let extglobStar = star;
             if (token.inner && token.inner.length > 1 && token.inner.includes("/")) extglobStar = globstar(opts);
             if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
-            if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) output = token.close = `)${rest})${extglobStar})`;
+            if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+                // In this case, we need to parse the string and use it in the output of the original pattern.
+                // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+                //
+                // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+                const expression = $8b2f0c2eaecf2312$var$parse(rest, {
+                    ...options,
+                    fastpaths: false
+                }).output;
+                output = token.close = `)${expression})${extglobStar})`;
+            }
             if (token.prev.type === "bos") state.negatedExtglob = true;
         }
         push({
@@ -1168,7 +1179,7 @@ var $9kveb = parcelRequire("9kveb");
    * Tokenize input until we reach end-of-string
    */ while(!eos()){
         value = advance();
-        if (value === "\x00") continue;
+        if (value === "\0") continue;
         /**
      * Escaped characters
      */ if (value === "\\") {
@@ -1854,19 +1865,19 @@ parcelRegister("2nj4a", function(module, exports) {
 /* eslint-disable no-new-wrappers, no-eval, camelcase, operator-linebreak */ module.exports = makeParserClass((parcelRequire("ibqqh")));
 module.exports.makeParserClass = makeParserClass;
 class TomlError extends Error {
-    constructor(msg11){
-        super(msg11);
+    constructor(msg){
+        super(msg);
         this.name = "TomlError";
         /* istanbul ignore next */ if (Error.captureStackTrace) Error.captureStackTrace(this, TomlError);
         this.fromTOML = true;
         this.wrapped = null;
     }
 }
-TomlError.wrap = (err11)=>{
-    const terr11 = new TomlError(err11.message);
-    terr11.code = err11.code;
-    terr11.wrapped = err11;
-    return terr11;
+TomlError.wrap = (err)=>{
+    const terr = new TomlError(err.message);
+    terr.code = err.code;
+    terr.wrapped = err;
+    return terr;
 };
 module.exports.TomlError = TomlError;
 
@@ -1934,23 +1945,23 @@ const escapes = {
     [CHAR_QUOT]: '"',
     [CHAR_BSOL]: "\\"
 };
-function isDigit(cp11) {
-    return cp11 >= CHAR_0 && cp11 <= CHAR_9;
+function isDigit(cp) {
+    return cp >= CHAR_0 && cp <= CHAR_9;
 }
-function isHexit(cp11) {
-    return cp11 >= CHAR_A && cp11 <= CHAR_F || cp11 >= CHAR_a && cp11 <= CHAR_f || cp11 >= CHAR_0 && cp11 <= CHAR_9;
+function isHexit(cp) {
+    return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
 }
-function isBit(cp11) {
-    return cp11 === CHAR_1 || cp11 === CHAR_0;
+function isBit(cp) {
+    return cp === CHAR_1 || cp === CHAR_0;
 }
-function isOctit(cp11) {
-    return cp11 >= CHAR_0 && cp11 <= CHAR_7;
+function isOctit(cp) {
+    return cp >= CHAR_0 && cp <= CHAR_7;
 }
-function isAlphaNumQuoteHyphen(cp11) {
-    return cp11 >= CHAR_A && cp11 <= CHAR_Z || cp11 >= CHAR_a && cp11 <= CHAR_z || cp11 >= CHAR_0 && cp11 <= CHAR_9 || cp11 === CHAR_APOS || cp11 === CHAR_QUOT || cp11 === CHAR_LOWBAR || cp11 === CHAR_HYPHEN;
+function isAlphaNumQuoteHyphen(cp) {
+    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
 }
-function isAlphaNumHyphen(cp11) {
-    return cp11 >= CHAR_A && cp11 <= CHAR_Z || cp11 >= CHAR_a && cp11 <= CHAR_z || cp11 >= CHAR_0 && cp11 <= CHAR_9 || cp11 === CHAR_LOWBAR || cp11 === CHAR_HYPHEN;
+function isAlphaNumHyphen(cp) {
+    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
 }
 const _type = Symbol("type");
 const _declared = Symbol("declared");
@@ -1962,9 +1973,9 @@ const descriptor = {
     writable: true,
     value: undefined
 };
-function hasKey(obj11, key11) {
-    if (hasOwnProperty.call(obj11, key11)) return true;
-    if (key11 === "__proto__") defineProperty(obj11, "__proto__", descriptor);
+function hasKey(obj, key) {
+    if (hasOwnProperty.call(obj, key)) return true;
+    if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
     return false;
 }
 const INLINE_TABLE = Symbol("inline-table");
@@ -1975,9 +1986,9 @@ function InlineTable() {
         }
     });
 }
-function isInlineTable(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === INLINE_TABLE;
+function isInlineTable(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === INLINE_TABLE;
 }
 const TABLE = Symbol("table");
 function Table() {
@@ -1991,25 +2002,25 @@ function Table() {
         }
     });
 }
-function isTable(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === TABLE;
+function isTable(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === TABLE;
 }
 const _contentType = Symbol("content-type");
 const INLINE_LIST = Symbol("inline-list");
-function InlineList(type11) {
+function InlineList(type) {
     return Object.defineProperties([], {
         [_type]: {
             value: INLINE_LIST
         },
         [_contentType]: {
-            value: type11
+            value: type
         }
     });
 }
-function isInlineList(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === INLINE_LIST;
+function isInlineList(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === INLINE_LIST;
 }
 const LIST = Symbol("list");
 function List() {
@@ -2019,9 +2030,9 @@ function List() {
         }
     });
 }
-function isList(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === LIST;
+function isList(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === LIST;
 }
 // in an eval, to let bundlers not slurp in a util proxy
 let _custom;
@@ -2032,10 +2043,10 @@ try {
 /* eval require not available in transpiled bundle */ }
 /* istanbul ignore next */ const _inspect = _custom || "inspect";
 class BoxedBigInt {
-    constructor(value11){
+    constructor(value){
         try {
-            this.value = $parcel$global.BigInt.asIntN(64, value11);
-        } catch (_11) {
+            this.value = $parcel$global.BigInt.asIntN(64, value);
+        } catch (_) {
             /* istanbul ignore next */ this.value = null;
         }
         Object.defineProperty(this, _type, {
@@ -2056,12 +2067,12 @@ class BoxedBigInt {
     }
 }
 const INTEGER = Symbol("integer");
-function Integer(value11) {
-    let num11 = Number(value11);
+function Integer(value) {
+    let num = Number(value);
     // -0 is a float thing, not an int thing
-    if (Object.is(num11, -0)) num11 = 0;
-    /* istanbul ignore else */ if ($parcel$global.BigInt && !Number.isSafeInteger(num11)) return new BoxedBigInt(value11);
-    else /* istanbul ignore next */ return Object.defineProperties(new Number(num11), {
+    if (Object.is(num, -0)) num = 0;
+    /* istanbul ignore else */ if ($parcel$global.BigInt && !Number.isSafeInteger(num)) return new BoxedBigInt(value);
+    else /* istanbul ignore next */ return Object.defineProperties(new Number(num), {
         isNaN: {
             value: function() {
                 return isNaN(this);
@@ -2071,35 +2082,35 @@ function Integer(value11) {
             value: INTEGER
         },
         [_inspect]: {
-            value: ()=>`[Integer: ${value11}]`
+            value: ()=>`[Integer: ${value}]`
         }
     });
 }
-function isInteger(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === INTEGER;
+function isInteger(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === INTEGER;
 }
 const FLOAT = Symbol("float");
-function Float(value11) {
-    /* istanbul ignore next */ return Object.defineProperties(new Number(value11), {
+function Float(value) {
+    /* istanbul ignore next */ return Object.defineProperties(new Number(value), {
         [_type]: {
             value: FLOAT
         },
         [_inspect]: {
-            value: ()=>`[Float: ${value11}]`
+            value: ()=>`[Float: ${value}]`
         }
     });
 }
-function isFloat(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === FLOAT;
+function isFloat(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === FLOAT;
 }
-function tomlType(value11) {
-    const type11 = typeof value11;
-    if (type11 === "object") {
-        /* istanbul ignore if */ if (value11 === null) return "null";
-        if (value11 instanceof Date) return "datetime";
-        /* istanbul ignore else */ if (_type in value11) switch(value11[_type]){
+function tomlType(value) {
+    const type = typeof value;
+    if (type === "object") {
+        /* istanbul ignore if */ if (value === null) return "null";
+        if (value instanceof Date) return "datetime";
+        /* istanbul ignore else */ if (_type in value) switch(value[_type]){
             case INLINE_TABLE:
                 return "inline-table";
             case INLINE_LIST:
@@ -2114,10 +2125,10 @@ function tomlType(value11) {
                 return "integer";
         }
     }
-    return type11;
+    return type;
 }
-function makeParserClass(Parser11) {
-    class TOMLParser11 extends Parser11 {
+function makeParserClass(Parser) {
+    class TOMLParser extends Parser {
         constructor(){
             super();
             this.ctx = this.obj = Table();
@@ -2126,10 +2137,10 @@ function makeParserClass(Parser11) {
             return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
         }
         atEndOfLine() {
-            return this.char === Parser11.END || this.char === CTRL_J || this.char === CTRL_M;
+            return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
         }
         parseStart() {
-            if (this.char === Parser11.END) return null;
+            if (this.char === Parser.END) return null;
             else if (this.char === CHAR_LSQB) return this.call(this.parseTableOrList);
             else if (this.char === CHAR_NUM) return this.call(this.parseComment);
             else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) return null;
@@ -2141,32 +2152,32 @@ function makeParserClass(Parser11) {
         parseWhitespaceToEOL() {
             if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) return null;
             else if (this.char === CHAR_NUM) return this.goto(this.parseComment);
-            else if (this.char === Parser11.END || this.char === CTRL_J) return this.return();
+            else if (this.char === Parser.END || this.char === CTRL_J) return this.return();
             else throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
         }
         /* ASSIGNMENT: key = value */ parseAssignStatement() {
             return this.callNow(this.parseAssign, this.recordAssignStatement);
         }
-        recordAssignStatement(kv11) {
-            let target11 = this.ctx;
-            let finalKey11 = kv11.key.pop();
-            for (let kw11 of kv11.key){
-                if (hasKey(target11, kw11) && (!isTable(target11[kw11]) || target11[kw11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
-                target11 = target11[kw11] = target11[kw11] || Table();
+        recordAssignStatement(kv) {
+            let target = this.ctx;
+            let finalKey = kv.key.pop();
+            for (let kw of kv.key){
+                if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                target = target[kw] = target[kw] || Table();
             }
-            if (hasKey(target11, finalKey11)) throw this.error(new TomlError("Can't redefine existing key"));
+            if (hasKey(target, finalKey)) throw this.error(new TomlError("Can't redefine existing key"));
             // unbox our numbers
-            if (isInteger(kv11.value) || isFloat(kv11.value)) target11[finalKey11] = kv11.value.valueOf();
-            else target11[finalKey11] = kv11.value;
+            if (isInteger(kv.value) || isFloat(kv.value)) target[finalKey] = kv.value.valueOf();
+            else target[finalKey] = kv.value;
             return this.goto(this.parseWhitespaceToEOL);
         }
         /* ASSSIGNMENT expression, key = value possibly inside an inline table */ parseAssign() {
             return this.callNow(this.parseKeyword, this.recordAssignKeyword);
         }
-        recordAssignKeyword(key11) {
-            if (this.state.resultTable) this.state.resultTable.push(key11);
+        recordAssignKeyword(key) {
+            if (this.state.resultTable) this.state.resultTable.push(key);
             else this.state.resultTable = [
-                key11
+                key
             ];
             return this.goto(this.parseAssignKeywordPreDot);
         }
@@ -2185,15 +2196,15 @@ function makeParserClass(Parser11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseValue, this.recordAssignValue);
         }
-        recordAssignValue(value11) {
+        recordAssignValue(value) {
             return this.returnNow({
                 key: this.state.resultTable,
-                value: value11
+                value: value
             });
         }
         /* COMMENTS: #...eol */ parseComment() {
             do {
-                if (this.char === Parser11.END || this.char === CTRL_J) return this.return();
+                if (this.char === Parser.END || this.char === CTRL_J) return this.return();
             }while (this.nextChar());
         }
         /* TABLES AND LISTS, [foo] and [[foo]] */ parseTableOrList() {
@@ -2208,19 +2219,19 @@ function makeParserClass(Parser11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseKeyword, this.parseTableMore);
         }
-        parseTableMore(keyword11) {
+        parseTableMore(keyword) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else if (this.char === CHAR_RSQB) {
-                if (hasKey(this.ctx, keyword11) && (!isTable(this.ctx[keyword11]) || this.ctx[keyword11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
                 else {
-                    this.ctx = this.ctx[keyword11] = this.ctx[keyword11] || Table();
+                    this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
                     this.ctx[_declared] = true;
                 }
                 return this.next(this.parseWhitespaceToEOL);
             } else if (this.char === CHAR_PERIOD) {
-                if (!hasKey(this.ctx, keyword11)) this.ctx = this.ctx[keyword11] = Table();
-                else if (isTable(this.ctx[keyword11])) this.ctx = this.ctx[keyword11];
-                else if (isList(this.ctx[keyword11])) this.ctx = this.ctx[keyword11][this.ctx[keyword11].length - 1];
+                if (!hasKey(this.ctx, keyword)) this.ctx = this.ctx[keyword] = Table();
+                else if (isTable(this.ctx[keyword])) this.ctx = this.ctx[keyword];
+                else if (isList(this.ctx[keyword])) this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
                 else throw this.error(new TomlError("Can't redefine existing key"));
                 return this.next(this.parseTableNext);
             } else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
@@ -2233,33 +2244,33 @@ function makeParserClass(Parser11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseKeyword, this.parseListMore);
         }
-        parseListMore(keyword11) {
+        parseListMore(keyword) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else if (this.char === CHAR_RSQB) {
-                if (!hasKey(this.ctx, keyword11)) this.ctx[keyword11] = List();
-                if (isInlineList(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline array"));
-                else if (isList(this.ctx[keyword11])) {
-                    const next11 = Table();
-                    this.ctx[keyword11].push(next11);
-                    this.ctx = next11;
+                if (!hasKey(this.ctx, keyword)) this.ctx[keyword] = List();
+                if (isInlineList(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline array"));
+                else if (isList(this.ctx[keyword])) {
+                    const next = Table();
+                    this.ctx[keyword].push(next);
+                    this.ctx = next;
                 } else throw this.error(new TomlError("Can't redefine an existing key"));
                 return this.next(this.parseListEnd);
             } else if (this.char === CHAR_PERIOD) {
-                if (!hasKey(this.ctx, keyword11)) this.ctx = this.ctx[keyword11] = Table();
-                else if (isInlineList(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline array"));
-                else if (isInlineTable(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline table"));
-                else if (isList(this.ctx[keyword11])) this.ctx = this.ctx[keyword11][this.ctx[keyword11].length - 1];
-                else if (isTable(this.ctx[keyword11])) this.ctx = this.ctx[keyword11];
+                if (!hasKey(this.ctx, keyword)) this.ctx = this.ctx[keyword] = Table();
+                else if (isInlineList(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline array"));
+                else if (isInlineTable(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline table"));
+                else if (isList(this.ctx[keyword])) this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+                else if (isTable(this.ctx[keyword])) this.ctx = this.ctx[keyword];
                 else throw this.error(new TomlError("Can't redefine an existing key"));
                 return this.next(this.parseListNext);
             } else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
         }
-        parseListEnd(keyword11) {
+        parseListEnd(keyword) {
             if (this.char === CHAR_RSQB) return this.next(this.parseWhitespaceToEOL);
             else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
         }
         /* VALUE string, number, boolean, inline list, inline object */ parseValue() {
-            if (this.char === Parser11.END) throw this.error(new TomlError("Key without value"));
+            if (this.char === Parser.END) throw this.error(new TomlError("Key without value"));
             else if (this.char === CHAR_QUOT) return this.next(this.parseDoubleString);
             if (this.char === CHAR_APOS) return this.next(this.parseSingleString);
             else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) return this.goto(this.parseNumberSign);
@@ -2271,8 +2282,8 @@ function makeParserClass(Parser11) {
             else if (this.char === CHAR_LCUB) return this.call(this.parseInlineTable, this.recordValue);
             else throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
         }
-        recordValue(value11) {
-            return this.returnNow(value11);
+        recordValue(value) {
+            return this.returnNow(value);
         }
         parseInf() {
             if (this.char === CHAR_n) return this.next(this.parseInf2);
@@ -2299,7 +2310,7 @@ function makeParserClass(Parser11) {
         }
         /* KEYS: barewords */ parseBareKey() {
             do {
-                if (this.char === Parser11.END) throw this.error(new TomlError("Key ended without value"));
+                if (this.char === Parser.END) throw this.error(new TomlError("Key ended without value"));
                 else if (isAlphaNumHyphen(this.char)) this.consume();
                 else if (this.state.buf.length === 0) throw this.error(new TomlError("Empty bare keys are not allowed"));
                 else return this.returnNow();
@@ -2329,7 +2340,7 @@ function makeParserClass(Parser11) {
         parseLiteralMultiStringContent() {
             do {
                 if (this.char === CHAR_APOS) return this.next(this.parseLiteralMultiEnd);
-                else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated multi-line string"));
+                else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated multi-line string"));
                 else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) throw this.errorControlCharInString();
                 else this.consume();
             }while (this.nextChar());
@@ -2361,8 +2372,8 @@ function makeParserClass(Parser11) {
                 else this.consume();
             }while (this.nextChar());
         }
-        recordEscapeReplacement(replacement11) {
-            this.state.buf += replacement11;
+        recordEscapeReplacement(replacement) {
+            this.state.buf += replacement;
             return this.goto(this.parseBasicString);
         }
         parseMultiStringMaybe() {
@@ -2378,19 +2389,19 @@ function makeParserClass(Parser11) {
             do {
                 if (this.char === CHAR_BSOL) return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
                 else if (this.char === CHAR_QUOT) return this.next(this.parseMultiEnd);
-                else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated multi-line string"));
+                else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated multi-line string"));
                 else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) throw this.errorControlCharInString();
                 else this.consume();
             }while (this.nextChar());
         }
         errorControlCharInString() {
-            let displayCode11 = "\\u00";
-            if (this.char < 16) displayCode11 += "0";
-            displayCode11 += this.char.toString(16);
-            return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode11} instead`));
+            let displayCode = "\\u00";
+            if (this.char < 16) displayCode += "0";
+            displayCode += this.char.toString(16);
+            return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
         }
-        recordMultiEscapeReplacement(replacement11) {
-            this.state.buf += replacement11;
+        recordMultiEscapeReplacement(replacement) {
+            this.state.buf += replacement;
             return this.goto(this.parseMultiStringContent);
         }
         parseMultiEnd() {
@@ -2428,13 +2439,13 @@ function makeParserClass(Parser11) {
             else if (this.char === CHAR_U) return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
             else throw this.error(new TomlError("Unknown escape character: " + this.char));
         }
-        parseUnicodeReturn(char11) {
+        parseUnicodeReturn(char) {
             try {
-                const codePoint11 = parseInt(char11, 16);
-                if (codePoint11 >= SURROGATE_FIRST && codePoint11 <= SURROGATE_LAST) throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
-                return this.returnNow(String.fromCodePoint(codePoint11));
-            } catch (err11) {
-                throw this.error(TomlError.wrap(err11));
+                const codePoint = parseInt(char, 16);
+                if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+                return this.returnNow(String.fromCodePoint(codePoint));
+            } catch (err) {
+                throw this.error(TomlError.wrap(err));
             }
         }
         parseSmallUnicode() {
@@ -2485,9 +2496,9 @@ function makeParserClass(Parser11) {
                 this.consume();
                 return this.call(this.parseNoUnder, this.parseNumberFloat);
             } else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         parseNoUnder() {
@@ -2565,27 +2576,27 @@ function makeParserClass(Parser11) {
             if (isHexit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         parseIntegerOct() {
             if (isOctit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         parseIntegerBin() {
             if (isBit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         /* DATETIME */ parseDateTime() {
@@ -2774,20 +2785,20 @@ function makeParserClass(Parser11) {
         }
         /* INLINE LISTS */ parseInlineList() {
             if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) return null;
-            else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_NUM) return this.call(this.parseComment);
             else if (this.char === CHAR_RSQB) return this.return(this.state.resultArr || InlineList());
             else return this.callNow(this.parseValue, this.recordInlineListValue);
         }
-        recordInlineListValue(value11) {
+        recordInlineListValue(value) {
             if (this.state.resultArr) {
-                const listType11 = this.state.resultArr[_contentType];
-                const valueType11 = tomlType(value11);
-                if (listType11 !== valueType11) throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType11} and ${valueType11}`));
-            } else this.state.resultArr = InlineList(tomlType(value11));
-            if (isFloat(value11) || isInteger(value11)) // unbox now that we've verified they're ok
-            this.state.resultArr.push(value11.valueOf());
-            else this.state.resultArr.push(value11);
+                const listType = this.state.resultArr[_contentType];
+                const valueType = tomlType(value);
+                if (listType !== valueType) throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
+            } else this.state.resultArr = InlineList(tomlType(value));
+            if (isFloat(value) || isInteger(value)) // unbox now that we've verified they're ok
+            this.state.resultArr.push(value.valueOf());
+            else this.state.resultArr.push(value);
             return this.goto(this.parseInlineListNext);
         }
         parseInlineListNext() {
@@ -2799,34 +2810,34 @@ function makeParserClass(Parser11) {
         }
         /* INLINE TABLE */ parseInlineTable() {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
-            else if (this.char === Parser11.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_RCUB) return this.return(this.state.resultTable || InlineTable());
             else {
                 if (!this.state.resultTable) this.state.resultTable = InlineTable();
                 return this.callNow(this.parseAssign, this.recordInlineTableValue);
             }
         }
-        recordInlineTableValue(kv11) {
-            let target11 = this.state.resultTable;
-            let finalKey11 = kv11.key.pop();
-            for (let kw11 of kv11.key){
-                if (hasKey(target11, kw11) && (!isTable(target11[kw11]) || target11[kw11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
-                target11 = target11[kw11] = target11[kw11] || Table();
+        recordInlineTableValue(kv) {
+            let target = this.state.resultTable;
+            let finalKey = kv.key.pop();
+            for (let kw of kv.key){
+                if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                target = target[kw] = target[kw] || Table();
             }
-            if (hasKey(target11, finalKey11)) throw this.error(new TomlError("Can't redefine existing key"));
-            if (isInteger(kv11.value) || isFloat(kv11.value)) target11[finalKey11] = kv11.value.valueOf();
-            else target11[finalKey11] = kv11.value;
+            if (hasKey(target, finalKey)) throw this.error(new TomlError("Can't redefine existing key"));
+            if (isInteger(kv.value) || isFloat(kv.value)) target[finalKey] = kv.value.valueOf();
+            else target[finalKey] = kv.value;
             return this.goto(this.parseInlineTableNext);
         }
         parseInlineTableNext() {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
-            else if (this.char === Parser11.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_COMMA) return this.next(this.parseInlineTable);
             else if (this.char === CHAR_RCUB) return this.goto(this.parseInlineTable);
             else throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
         }
     }
-    return TOMLParser11;
+    return TOMLParser;
 }
 
 });
@@ -14672,7 +14683,7 @@ var $465b080b3357c6b8$var$pkcs1 = $465b080b3357c6b8$exports = $aX5SS.pkcs1 = $aX
     var lHash = md.digest();
     var PS = "";
     var PS_length = maxLength - message.length;
-    for(var i = 0; i < PS_length; i++)PS += "\x00";
+    for(var i = 0; i < PS_length; i++)PS += "\0";
     var DB = lHash.getBytes() + PS + "\x01" + message;
     if (!seed) seed = $aX5SS.random.getBytes(md.digestLength);
     else if (seed.length !== md.digestLength) {
@@ -14686,7 +14697,7 @@ var $465b080b3357c6b8$var$pkcs1 = $465b080b3357c6b8$exports = $aX5SS.pkcs1 = $aX
     var seedMask = $465b080b3357c6b8$var$rsa_mgf1(maskedDB, md.digestLength, mgf1Md);
     var maskedSeed = $aX5SS.util.xorBytes(seed, seedMask, seed.length);
     // return encoded message
-    return "\x00" + maskedSeed + maskedDB;
+    return "\0" + maskedSeed + maskedDB;
 };
 /**
  * Decode the given RSAES-OAEP encoded message (EM) using key, with optional
@@ -14745,7 +14756,7 @@ var $465b080b3357c6b8$var$pkcs1 = $465b080b3357c6b8$exports = $aX5SS.pkcs1 = $aX
     var db = $aX5SS.util.xorBytes(maskedDB, dbMask, maskedDB.length);
     var lHashPrime = db.substring(0, md.digestLength);
     // constant time check that all values match what is expected
-    var error = y !== "\x00";
+    var error = y !== "\0";
     // constant time check lHash vs lHashPrime
     for(var i = 0; i < md.digestLength; ++i)error |= lHash.charAt(i) !== lHashPrime.charAt(i);
     // "constant time" find the 0x1 byte separating the padding (zeros) from the
@@ -29329,8 +29340,8 @@ var $1bb7c2e3e32c99fc$var$ssh = $1bb7c2e3e32c99fc$exports = $aX5SS.ssh = $aX5SS.
         padding.truncate(padding.length() - encLen + privbuffer.length());
         privbuffer.putBuffer(padding);
         var aeskey = $aX5SS.util.createBuffer();
-        aeskey.putBuffer($1bb7c2e3e32c99fc$var$_sha1("\x00\x00\x00\x00", passphrase));
-        aeskey.putBuffer($1bb7c2e3e32c99fc$var$_sha1("\x00\x00\x00\x01", passphrase));
+        aeskey.putBuffer($1bb7c2e3e32c99fc$var$_sha1("\0\0\0\0", passphrase));
+        aeskey.putBuffer($1bb7c2e3e32c99fc$var$_sha1("\0\0\0\x01", passphrase));
         // encrypt some bytes using CBC mode
         // key is 40 bytes, so truncate *by* 8 bytes
         var cipher = $aX5SS.aes.createEncryptionCipher(aeskey.truncate(8), "CBC");
@@ -31136,11 +31147,11 @@ const $69e4bed225e2da9c$var$isEmptyString = (val)=>val === "" || val === "./";
         if (options.onResult) options.onResult(state);
         items.push(state.output);
     };
-    let matches = $69e4bed225e2da9c$var$micromatch(list, patterns, {
+    let matches = new Set($69e4bed225e2da9c$var$micromatch(list, patterns, {
         ...options,
         onResult: onResult
-    });
-    for (let item of items)if (!matches.includes(item)) result.add(item);
+    }));
+    for (let item of items)if (!matches.has(item)) result.add(item);
     return [
         ...result
     ];
@@ -31344,7 +31355,7 @@ const $69e4bed225e2da9c$var$isEmptyString = (val)=>val === "" || val === "./";
  *
  * ```js
  * const mm = require('micromatch');
- * const state = mm(pattern[, options]);
+ * const state = mm.parse(pattern[, options]);
  * ```
  * @param {String} `glob`
  * @param {Object} `options`
@@ -31781,6 +31792,7 @@ var $317df5a2d050a904$exports = {};
 Object.defineProperty($317df5a2d050a904$exports, "__esModule", {
     value: true
 });
+$317df5a2d050a904$exports.Settings = $317df5a2d050a904$exports.walkStream = $317df5a2d050a904$exports.walkSync = $317df5a2d050a904$exports.walk = void 0;
 var $5b03973b11b9b194$exports = {};
 "use strict";
 Object.defineProperty($5b03973b11b9b194$exports, "__esModule", {
@@ -31797,29 +31809,43 @@ var $e0d812f240931569$exports = {};
 Object.defineProperty($e0d812f240931569$exports, "__esModule", {
     value: true
 });
+$e0d812f240931569$exports.Settings = $e0d812f240931569$exports.scandirSync = $e0d812f240931569$exports.scandir = void 0;
 var $8c82b681478b71a0$exports = {};
 "use strict";
 Object.defineProperty($8c82b681478b71a0$exports, "__esModule", {
     value: true
 });
+$8c82b681478b71a0$exports.readdir = $8c82b681478b71a0$exports.readdirWithFileTypes = $8c82b681478b71a0$exports.read = void 0;
 var $48b7d65b50efb0b8$exports = {};
 "use strict";
 Object.defineProperty($48b7d65b50efb0b8$exports, "__esModule", {
     value: true
 });
+$48b7d65b50efb0b8$exports.statSync = $48b7d65b50efb0b8$exports.stat = $48b7d65b50efb0b8$exports.Settings = void 0;
 var $79e2bbccd27c60ef$exports = {};
 "use strict";
 Object.defineProperty($79e2bbccd27c60ef$exports, "__esModule", {
     value: true
 });
+$79e2bbccd27c60ef$exports.read = void 0;
 function $79e2bbccd27c60ef$var$read(path, settings, callback) {
     settings.fs.lstat(path, (lstatError, lstat)=>{
-        if (lstatError !== null) return $79e2bbccd27c60ef$var$callFailureCallback(callback, lstatError);
-        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) return $79e2bbccd27c60ef$var$callSuccessCallback(callback, lstat);
+        if (lstatError !== null) {
+            $79e2bbccd27c60ef$var$callFailureCallback(callback, lstatError);
+            return;
+        }
+        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+            $79e2bbccd27c60ef$var$callSuccessCallback(callback, lstat);
+            return;
+        }
         settings.fs.stat(path, (statError, stat)=>{
             if (statError !== null) {
-                if (settings.throwErrorOnBrokenSymbolicLink) return $79e2bbccd27c60ef$var$callFailureCallback(callback, statError);
-                return $79e2bbccd27c60ef$var$callSuccessCallback(callback, lstat);
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    $79e2bbccd27c60ef$var$callFailureCallback(callback, statError);
+                    return;
+                }
+                $79e2bbccd27c60ef$var$callSuccessCallback(callback, lstat);
+                return;
             }
             if (settings.markSymbolicLink) stat.isSymbolicLink = ()=>true;
             $79e2bbccd27c60ef$var$callSuccessCallback(callback, stat);
@@ -31840,6 +31866,7 @@ var $3454c7a954c13fc6$exports = {};
 Object.defineProperty($3454c7a954c13fc6$exports, "__esModule", {
     value: true
 });
+$3454c7a954c13fc6$exports.read = void 0;
 function $3454c7a954c13fc6$var$read(path, settings) {
     const lstat = settings.fs.lstatSync(path);
     if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) return lstat;
@@ -31865,6 +31892,7 @@ var $8b5ba49f0cfc39f7$exports = {};
 Object.defineProperty($8b5ba49f0cfc39f7$exports, "__esModule", {
     value: true
 });
+$8b5ba49f0cfc39f7$exports.createFileSystemAdapter = $8b5ba49f0cfc39f7$exports.FILE_SYSTEM_ADAPTER = void 0;
 
 $8b5ba49f0cfc39f7$exports.FILE_SYSTEM_ADAPTER = {
     lstat: $eJUMF$fs.lstat,
@@ -31888,7 +31916,7 @@ class $0beccc825807a5ff$var$Settings {
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
     }
     _getValue(option, value) {
-        return option === undefined ? value : option;
+        return option !== null && option !== void 0 ? option : value;
     }
 }
 $0beccc825807a5ff$exports.default = $0beccc825807a5ff$var$Settings;
@@ -31896,7 +31924,10 @@ $0beccc825807a5ff$exports.default = $0beccc825807a5ff$var$Settings;
 
 $48b7d65b50efb0b8$exports.Settings = $0beccc825807a5ff$exports.default;
 function $48b7d65b50efb0b8$var$stat(path, optionsOrSettingsOrCallback, callback) {
-    if (typeof optionsOrSettingsOrCallback === "function") return $79e2bbccd27c60ef$exports.read(path, $48b7d65b50efb0b8$var$getSettings(), optionsOrSettingsOrCallback);
+    if (typeof optionsOrSettingsOrCallback === "function") {
+        $79e2bbccd27c60ef$exports.read(path, $48b7d65b50efb0b8$var$getSettings(), optionsOrSettingsOrCallback);
+        return;
+    }
     $79e2bbccd27c60ef$exports.read(path, $48b7d65b50efb0b8$var$getSettings(optionsOrSettingsOrCallback), callback);
 }
 $48b7d65b50efb0b8$exports.stat = $48b7d65b50efb0b8$var$stat;
@@ -31959,16 +31990,7 @@ var $f4853698f1f81687$exports = {};
 Object.defineProperty($f4853698f1f81687$exports, "__esModule", {
     value: true
 });
-const $f4853698f1f81687$var$NODE_PROCESS_VERSION_PARTS = process.versions.node.split(".");
-const $f4853698f1f81687$var$MAJOR_VERSION = parseInt($f4853698f1f81687$var$NODE_PROCESS_VERSION_PARTS[0], 10);
-const $f4853698f1f81687$var$MINOR_VERSION = parseInt($f4853698f1f81687$var$NODE_PROCESS_VERSION_PARTS[1], 10);
-const $f4853698f1f81687$var$SUPPORTED_MAJOR_VERSION = 10;
-const $f4853698f1f81687$var$SUPPORTED_MINOR_VERSION = 10;
-const $f4853698f1f81687$var$IS_MATCHED_BY_MAJOR = $f4853698f1f81687$var$MAJOR_VERSION > $f4853698f1f81687$var$SUPPORTED_MAJOR_VERSION;
-const $f4853698f1f81687$var$IS_MATCHED_BY_MAJOR_AND_MINOR = $f4853698f1f81687$var$MAJOR_VERSION === $f4853698f1f81687$var$SUPPORTED_MAJOR_VERSION && $f4853698f1f81687$var$MINOR_VERSION >= $f4853698f1f81687$var$SUPPORTED_MINOR_VERSION;
-/**
- * IS `true` for Node.js 10.10 and greater.
- */ $f4853698f1f81687$exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = $f4853698f1f81687$var$IS_MATCHED_BY_MAJOR || $f4853698f1f81687$var$IS_MATCHED_BY_MAJOR_AND_MINOR;
+$f4853698f1f81687$exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = true;
 
 
 var $9793ec236c80d044$exports = {};
@@ -31976,11 +31998,13 @@ var $9793ec236c80d044$exports = {};
 Object.defineProperty($9793ec236c80d044$exports, "__esModule", {
     value: true
 });
+$9793ec236c80d044$exports.fs = void 0;
 var $388b7846d9ee0898$exports = {};
 "use strict";
 Object.defineProperty($388b7846d9ee0898$exports, "__esModule", {
     value: true
 });
+$388b7846d9ee0898$exports.createDirentFromStats = void 0;
 class $388b7846d9ee0898$var$DirentFromStats {
     constructor(name, stats){
         this.name = name;
@@ -32002,25 +32026,52 @@ $388b7846d9ee0898$exports.createDirentFromStats = $388b7846d9ee0898$var$createDi
 $9793ec236c80d044$exports.fs = $388b7846d9ee0898$exports;
 
 
+var $743d85a8d1333002$exports = {};
+"use strict";
+Object.defineProperty($743d85a8d1333002$exports, "__esModule", {
+    value: true
+});
+$743d85a8d1333002$exports.joinPathSegments = void 0;
+function $743d85a8d1333002$var$joinPathSegments(a, b, separator) {
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */ if (a.endsWith(separator)) return a + b;
+    return a + separator + b;
+}
+$743d85a8d1333002$exports.joinPathSegments = $743d85a8d1333002$var$joinPathSegments;
+
+
 function $8c82b681478b71a0$var$read(directory, settings, callback) {
-    if (!settings.stats && $f4853698f1f81687$exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES) return $8c82b681478b71a0$var$readdirWithFileTypes(directory, settings, callback);
-    return $8c82b681478b71a0$var$readdir(directory, settings, callback);
+    if (!settings.stats && $f4853698f1f81687$exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        $8c82b681478b71a0$var$readdirWithFileTypes(directory, settings, callback);
+        return;
+    }
+    $8c82b681478b71a0$var$readdir(directory, settings, callback);
 }
 $8c82b681478b71a0$exports.read = $8c82b681478b71a0$var$read;
 function $8c82b681478b71a0$var$readdirWithFileTypes(directory, settings, callback) {
     settings.fs.readdir(directory, {
         withFileTypes: true
     }, (readdirError, dirents)=>{
-        if (readdirError !== null) return $8c82b681478b71a0$var$callFailureCallback(callback, readdirError);
+        if (readdirError !== null) {
+            $8c82b681478b71a0$var$callFailureCallback(callback, readdirError);
+            return;
+        }
         const entries = dirents.map((dirent)=>({
                 dirent: dirent,
                 name: dirent.name,
-                path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`
+                path: $743d85a8d1333002$exports.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
             }));
-        if (!settings.followSymbolicLinks) return $8c82b681478b71a0$var$callSuccessCallback(callback, entries);
+        if (!settings.followSymbolicLinks) {
+            $8c82b681478b71a0$var$callSuccessCallback(callback, entries);
+            return;
+        }
         const tasks = entries.map((entry)=>$8c82b681478b71a0$var$makeRplTaskEntry(entry, settings));
         $811497678ff58323$exports(tasks, (rplError, rplEntries)=>{
-            if (rplError !== null) return $8c82b681478b71a0$var$callFailureCallback(callback, rplError);
+            if (rplError !== null) {
+                $8c82b681478b71a0$var$callFailureCallback(callback, rplError);
+                return;
+            }
             $8c82b681478b71a0$var$callSuccessCallback(callback, rplEntries);
         });
     });
@@ -32028,37 +32079,53 @@ function $8c82b681478b71a0$var$readdirWithFileTypes(directory, settings, callbac
 $8c82b681478b71a0$exports.readdirWithFileTypes = $8c82b681478b71a0$var$readdirWithFileTypes;
 function $8c82b681478b71a0$var$makeRplTaskEntry(entry, settings) {
     return (done)=>{
-        if (!entry.dirent.isSymbolicLink()) return done(null, entry);
+        if (!entry.dirent.isSymbolicLink()) {
+            done(null, entry);
+            return;
+        }
         settings.fs.stat(entry.path, (statError, stats)=>{
             if (statError !== null) {
-                if (settings.throwErrorOnBrokenSymbolicLink) return done(statError);
-                return done(null, entry);
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    done(statError);
+                    return;
+                }
+                done(null, entry);
+                return;
             }
             entry.dirent = $9793ec236c80d044$exports.fs.createDirentFromStats(entry.name, stats);
-            return done(null, entry);
+            done(null, entry);
         });
     };
 }
 function $8c82b681478b71a0$var$readdir(directory, settings, callback) {
     settings.fs.readdir(directory, (readdirError, names)=>{
-        if (readdirError !== null) return $8c82b681478b71a0$var$callFailureCallback(callback, readdirError);
-        const filepaths = names.map((name)=>`${directory}${settings.pathSegmentSeparator}${name}`);
-        const tasks = filepaths.map((filepath)=>{
-            return (done)=>$48b7d65b50efb0b8$exports.stat(filepath, settings.fsStatSettings, done);
+        if (readdirError !== null) {
+            $8c82b681478b71a0$var$callFailureCallback(callback, readdirError);
+            return;
+        }
+        const tasks = names.map((name)=>{
+            const path = $743d85a8d1333002$exports.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+            return (done)=>{
+                $48b7d65b50efb0b8$exports.stat(path, settings.fsStatSettings, (error, stats)=>{
+                    if (error !== null) {
+                        done(error);
+                        return;
+                    }
+                    const entry = {
+                        name: name,
+                        path: path,
+                        dirent: $9793ec236c80d044$exports.fs.createDirentFromStats(name, stats)
+                    };
+                    if (settings.stats) entry.stats = stats;
+                    done(null, entry);
+                });
+            };
         });
-        $811497678ff58323$exports(tasks, (rplError, results)=>{
-            if (rplError !== null) return $8c82b681478b71a0$var$callFailureCallback(callback, rplError);
-            const entries = [];
-            names.forEach((name, index)=>{
-                const stats = results[index];
-                const entry = {
-                    name: name,
-                    path: filepaths[index],
-                    dirent: $9793ec236c80d044$exports.fs.createDirentFromStats(name, stats)
-                };
-                if (settings.stats) entry.stats = stats;
-                entries.push(entry);
-            });
+        $811497678ff58323$exports(tasks, (rplError, entries)=>{
+            if (rplError !== null) {
+                $8c82b681478b71a0$var$callFailureCallback(callback, rplError);
+                return;
+            }
             $8c82b681478b71a0$var$callSuccessCallback(callback, entries);
         });
     });
@@ -32077,6 +32144,8 @@ var $e69266c637240849$exports = {};
 Object.defineProperty($e69266c637240849$exports, "__esModule", {
     value: true
 });
+$e69266c637240849$exports.readdir = $e69266c637240849$exports.readdirWithFileTypes = $e69266c637240849$exports.read = void 0;
+
 
 
 
@@ -32093,7 +32162,7 @@ function $e69266c637240849$var$readdirWithFileTypes(directory, settings) {
         const entry = {
             dirent: dirent,
             name: dirent.name,
-            path: `${directory}${settings.pathSegmentSeparator}${dirent.name}`
+            path: $743d85a8d1333002$exports.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
         };
         if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) try {
             const stats = settings.fs.statSync(entry.path);
@@ -32108,7 +32177,7 @@ $e69266c637240849$exports.readdirWithFileTypes = $e69266c637240849$var$readdirWi
 function $e69266c637240849$var$readdir(directory, settings) {
     const names = settings.fs.readdirSync(directory);
     return names.map((name)=>{
-        const entryPath = `${directory}${settings.pathSegmentSeparator}${name}`;
+        const entryPath = $743d85a8d1333002$exports.joinPathSegments(directory, name, settings.pathSegmentSeparator);
         const stats = $48b7d65b50efb0b8$exports.statSync(entryPath, settings.fsStatSettings);
         const entry = {
             name: name,
@@ -32134,6 +32203,7 @@ var $775521ec67a4fc64$exports = {};
 Object.defineProperty($775521ec67a4fc64$exports, "__esModule", {
     value: true
 });
+$775521ec67a4fc64$exports.createFileSystemAdapter = $775521ec67a4fc64$exports.FILE_SYSTEM_ADAPTER = void 0;
 
 $775521ec67a4fc64$exports.FILE_SYSTEM_ADAPTER = {
     lstat: $eJUMF$fs.lstat,
@@ -32165,7 +32235,7 @@ class $a5cd045e5a6748b0$var$Settings {
         });
     }
     _getValue(option, value) {
-        return option === undefined ? value : option;
+        return option !== null && option !== void 0 ? option : value;
     }
 }
 $a5cd045e5a6748b0$exports.default = $a5cd045e5a6748b0$var$Settings;
@@ -32173,7 +32243,10 @@ $a5cd045e5a6748b0$exports.default = $a5cd045e5a6748b0$var$Settings;
 
 $e0d812f240931569$exports.Settings = $a5cd045e5a6748b0$exports.default;
 function $e0d812f240931569$var$scandir(path, optionsOrSettingsOrCallback, callback) {
-    if (typeof optionsOrSettingsOrCallback === "function") return $8c82b681478b71a0$exports.read(path, $e0d812f240931569$var$getSettings(), optionsOrSettingsOrCallback);
+    if (typeof optionsOrSettingsOrCallback === "function") {
+        $8c82b681478b71a0$exports.read(path, $e0d812f240931569$var$getSettings(), optionsOrSettingsOrCallback);
+        return;
+    }
     $8c82b681478b71a0$exports.read(path, $e0d812f240931569$var$getSettings(optionsOrSettingsOrCallback), callback);
 }
 $e0d812f240931569$exports.scandir = $e0d812f240931569$var$scandir;
@@ -32359,6 +32432,7 @@ var $d842871c1b1b7421$exports = {};
 Object.defineProperty($d842871c1b1b7421$exports, "__esModule", {
     value: true
 });
+$d842871c1b1b7421$exports.joinPathSegments = $d842871c1b1b7421$exports.replacePathSegmentSeparator = $d842871c1b1b7421$exports.isAppliedFilter = $d842871c1b1b7421$exports.isFatalError = void 0;
 function $d842871c1b1b7421$var$isFatalError(settings, error) {
     if (settings.errorFilter === null) return true;
     return !settings.errorFilter(error);
@@ -32369,11 +32443,14 @@ function $d842871c1b1b7421$var$isAppliedFilter(filter, value) {
 }
 $d842871c1b1b7421$exports.isAppliedFilter = $d842871c1b1b7421$var$isAppliedFilter;
 function $d842871c1b1b7421$var$replacePathSegmentSeparator(filepath, separator) {
-    return filepath.split(/[\\/]/).join(separator);
+    return filepath.split(/[/\\]/).join(separator);
 }
 $d842871c1b1b7421$exports.replacePathSegmentSeparator = $d842871c1b1b7421$var$replacePathSegmentSeparator;
 function $d842871c1b1b7421$var$joinPathSegments(a, b, separator) {
     if (a === "") return b;
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */ if (a.endsWith(separator)) return a + b;
     return a + separator + b;
 }
 $d842871c1b1b7421$exports.joinPathSegments = $d842871c1b1b7421$var$joinPathSegments;
@@ -32416,6 +32493,9 @@ class $b02d22213ae11a8a$var$AsyncReader extends $4be968f0d018c0c1$exports.defaul
         });
         return this._emitter;
     }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
     destroy() {
         if (this._isDestroyed) throw new Error("The reader is already destroyed");
         this._isDestroyed = true;
@@ -32441,13 +32521,16 @@ class $b02d22213ae11a8a$var$AsyncReader extends $4be968f0d018c0c1$exports.defaul
     }
     _worker(item, done) {
         this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries)=>{
-            if (error !== null) return done(error, undefined);
+            if (error !== null) {
+                done(error, undefined);
+                return;
+            }
             for (const entry of entries)this._handleEntry(entry, item.base);
             done(null, undefined);
         });
     }
     _handleError(error) {
-        if (!$d842871c1b1b7421$exports.isFatalError(this._settings, error)) return;
+        if (this._isDestroyed || !$d842871c1b1b7421$exports.isFatalError(this._settings, error)) return;
         this._isFatalError = true;
         this._isDestroyed = true;
         this._emitter.emit("error", error);
@@ -32457,7 +32540,7 @@ class $b02d22213ae11a8a$var$AsyncReader extends $4be968f0d018c0c1$exports.defaul
         const fullpath = entry.path;
         if (base !== undefined) entry.path = $d842871c1b1b7421$exports.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
         if ($d842871c1b1b7421$exports.isAppliedFilter(this._settings.entryFilter, entry)) this._emitEntry(entry);
-        if (entry.dirent.isDirectory() && $d842871c1b1b7421$exports.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, entry.path);
+        if (entry.dirent.isDirectory() && $d842871c1b1b7421$exports.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
     }
     _emitEntry(entry) {
         this._emitter.emit("entry", entry);
@@ -32471,19 +32554,17 @@ class $5b03973b11b9b194$var$AsyncProvider {
         this._root = _root;
         this._settings = _settings;
         this._reader = new $b02d22213ae11a8a$exports.default(this._root, this._settings);
-        this._storage = new Set();
+        this._storage = [];
     }
     read(callback) {
         this._reader.onError((error)=>{
             $5b03973b11b9b194$var$callFailureCallback(callback, error);
         });
         this._reader.onEntry((entry)=>{
-            this._storage.add(entry);
+            this._storage.push(entry);
         });
         this._reader.onEnd(()=>{
-            $5b03973b11b9b194$var$callSuccessCallback(callback, [
-                ...this._storage
-            ]);
+            $5b03973b11b9b194$var$callSuccessCallback(callback, this._storage);
         });
         this._reader.read();
     }
@@ -32512,7 +32593,9 @@ class $327790ac3132dcf6$var$StreamProvider {
         this._stream = new $eJUMF$stream.Readable({
             objectMode: true,
             read: ()=>{},
-            destroy: this._reader.destroy.bind(this._reader)
+            destroy: ()=>{
+                if (!this._reader.isDestroyed) this._reader.destroy();
+            }
         });
     }
     read() {
@@ -32549,15 +32632,13 @@ class $c5f7cf7adb14757e$var$SyncReader extends $4be968f0d018c0c1$exports.default
     constructor(){
         super(...arguments);
         this._scandir = $e0d812f240931569$exports.scandirSync;
-        this._storage = new Set();
+        this._storage = [];
         this._queue = new Set();
     }
     read() {
         this._pushToQueue(this._root, this._settings.basePath);
         this._handleQueue();
-        return [
-            ...this._storage
-        ];
+        return this._storage;
     }
     _pushToQueue(directory, base) {
         this._queue.add({
@@ -32584,10 +32665,10 @@ class $c5f7cf7adb14757e$var$SyncReader extends $4be968f0d018c0c1$exports.default
         const fullpath = entry.path;
         if (base !== undefined) entry.path = $d842871c1b1b7421$exports.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
         if ($d842871c1b1b7421$exports.isAppliedFilter(this._settings.entryFilter, entry)) this._pushToStorage(entry);
-        if (entry.dirent.isDirectory() && $d842871c1b1b7421$exports.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, entry.path);
+        if (entry.dirent.isDirectory() && $d842871c1b1b7421$exports.isAppliedFilter(this._settings.deepFilter, entry)) this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
     }
     _pushToStorage(entry) {
-        this._storage.add(entry);
+        this._storage.push(entry);
     }
 }
 $c5f7cf7adb14757e$exports.default = $c5f7cf7adb14757e$var$SyncReader;
@@ -32617,7 +32698,7 @@ class $8d237ca08a544ff3$var$Settings {
     constructor(_options = {}){
         this._options = _options;
         this.basePath = this._getValue(this._options.basePath, undefined);
-        this.concurrency = this._getValue(this._options.concurrency, Infinity);
+        this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
         this.deepFilter = this._getValue(this._options.deepFilter, null);
         this.entryFilter = this._getValue(this._options.entryFilter, null);
         this.errorFilter = this._getValue(this._options.errorFilter, null);
@@ -32631,7 +32712,7 @@ class $8d237ca08a544ff3$var$Settings {
         });
     }
     _getValue(option, value) {
-        return option === undefined ? value : option;
+        return option !== null && option !== void 0 ? option : value;
     }
 }
 $8d237ca08a544ff3$exports.default = $8d237ca08a544ff3$var$Settings;
@@ -32639,7 +32720,10 @@ $8d237ca08a544ff3$exports.default = $8d237ca08a544ff3$var$Settings;
 
 $317df5a2d050a904$exports.Settings = $8d237ca08a544ff3$exports.default;
 function $317df5a2d050a904$var$walk(directory, optionsOrSettingsOrCallback, callback) {
-    if (typeof optionsOrSettingsOrCallback === "function") return new $5b03973b11b9b194$exports.default(directory, $317df5a2d050a904$var$getSettings()).read(optionsOrSettingsOrCallback);
+    if (typeof optionsOrSettingsOrCallback === "function") {
+        new $5b03973b11b9b194$exports.default(directory, $317df5a2d050a904$var$getSettings()).read(optionsOrSettingsOrCallback);
+        return;
+    }
     new $5b03973b11b9b194$exports.default(directory, $317df5a2d050a904$var$getSettings(optionsOrSettingsOrCallback)).read(callback);
 }
 $317df5a2d050a904$exports.walk = $317df5a2d050a904$var$walk;
@@ -33435,11 +33519,11 @@ const $3f4e287414e2d74a$var$isEmptyString = (val)=>val === "" || val === "./";
         if (options.onResult) options.onResult(state);
         items.push(state.output);
     };
-    let matches = $3f4e287414e2d74a$var$micromatch(list, patterns, {
+    let matches = new Set($3f4e287414e2d74a$var$micromatch(list, patterns, {
         ...options,
         onResult: onResult
-    });
-    for (let item of items)if (!matches.includes(item)) result.add(item);
+    }));
+    for (let item of items)if (!matches.has(item)) result.add(item);
     return [
         ...result
     ];
@@ -33643,7 +33727,7 @@ const $3f4e287414e2d74a$var$isEmptyString = (val)=>val === "" || val === "./";
  *
  * ```js
  * const mm = require('micromatch');
- * const state = mm(pattern[, options]);
+ * const state = mm.parse(pattern[, options]);
  * ```
  * @param {String} `glob`
  * @param {Object} `options`
@@ -34251,6 +34335,7 @@ class $31bd78e367586e0a$export$2e2bcd8739ae039 {
     _runPromise = null;
     _count = 0;
     _results = [];
+    _addSubscriptions = new Set();
     constructor(opts = {
         maxConcurrent: Infinity
     }){
@@ -34270,9 +34355,16 @@ class $31bd78e367586e0a$export$2e2bcd8739ae039 {
                     reject(err);
                     throw err;
                 }));
+            for (const addFn of this._addSubscriptions)addFn();
             if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) this._next();
         });
     }
+    subscribeToAdd(fn) {
+        this._addSubscriptions.add(fn);
+        return ()=>{
+            this._addSubscriptions.delete(fn);
+        };
+    }
     run() {
         if (this._runPromise != null) return this._runPromise;
         if (this._queue.length === 0) return Promise.resolve([]);
@@ -34844,73 +34936,84 @@ else $152536acc51e0ffd$exports = $152536acc51e0ffd$var$isWsl();
 
 
 const $de07249fe885e737$var$pAccess = $de07249fe885e737$require$promisify($eJUMF$fs.access);
-const $de07249fe885e737$var$pExecFile = $de07249fe885e737$require$promisify($eJUMF$child_process.execFile);
+const $de07249fe885e737$var$pReadFile = $de07249fe885e737$require$promisify($eJUMF$fs.readFile);
 // Path to included `xdg-open`.
 const $de07249fe885e737$var$localXdgOpenPath = $eJUMF$path.join($de07249fe885e737$var$$parcel$__dirname, "xdg-open");
-// Convert a path from WSL format to Windows format:
-// `/mnt/c/Program Files/Example/MyApp.exe` → `C:\Program Files\Example\MyApp.exe`
-const $de07249fe885e737$var$wslToWindowsPath = async (path)=>{
-    const { stdout: stdout } = await $de07249fe885e737$var$pExecFile("wslpath", [
-        "-w",
-        path
-    ]);
-    return stdout.trim();
-};
+/**
+Get the mount point for fixed drives in WSL.
+
+@inner
+@returns {string} The mount point.
+*/ const $de07249fe885e737$var$getWslDrivesMountPoint = (()=>{
+    // Default value for "root" param
+    // according to https://docs.microsoft.com/en-us/windows/wsl/wsl-config
+    const defaultMountPoint = "/mnt/";
+    let mountPoint;
+    return async function() {
+        if (mountPoint) // Return memoized mount point value
+        return mountPoint;
+        const configFilePath = "/etc/wsl.conf";
+        let isConfigFileExists = false;
+        try {
+            await $de07249fe885e737$var$pAccess(configFilePath, $eJUMF$fs.constants.F_OK);
+            isConfigFileExists = true;
+        } catch (_) {}
+        if (!isConfigFileExists) return defaultMountPoint;
+        const configContent = await $de07249fe885e737$var$pReadFile(configFilePath, {
+            encoding: "utf8"
+        });
+        const configMountPoint = /root\s*=\s*(.*)/g.exec(configContent);
+        if (!configMountPoint) return defaultMountPoint;
+        mountPoint = configMountPoint[1].trim();
+        mountPoint = mountPoint.endsWith("/") ? mountPoint : mountPoint + "/";
+        return mountPoint;
+    };
+})();
 $de07249fe885e737$exports = async (target, options)=>{
     if (typeof target !== "string") throw new TypeError("Expected a `target`");
     options = {
         wait: false,
         background: false,
-        url: false,
+        allowNonzeroExitCode: false,
         ...options
     };
     let command;
+    let { app: app } = options;
     let appArguments = [];
     const cliArguments = [];
     const childProcessOptions = {};
-    if (Array.isArray(options.app)) {
-        appArguments = options.app.slice(1);
-        options.app = options.app[0];
-    }
-    // Encodes the target as if it were an URL. Especially useful to get
-    // double-quotes through the “double-quotes on Windows caveat”, but it
-    // can be used on any platform.
-    if (options.url) {
-        target = encodeURI(target);
-        if ($152536acc51e0ffd$exports) target = target.replace(/&/g, "^&");
+    if (Array.isArray(app)) {
+        appArguments = app.slice(1);
+        app = app[0];
     }
     if (process.platform === "darwin") {
         command = "open";
         if (options.wait) cliArguments.push("--wait-apps");
         if (options.background) cliArguments.push("--background");
-        if (options.app) cliArguments.push("-a", options.app);
+        if (app) cliArguments.push("-a", app);
     } else if (process.platform === "win32" || $152536acc51e0ffd$exports && !$511188f033b8926c$exports()) {
-        command = "cmd" + ($152536acc51e0ffd$exports ? ".exe" : "");
-        cliArguments.push("/s", "/c", "start", '""', "/b");
-        if (!$152536acc51e0ffd$exports) {
-            // Always quoting target allows for URLs/paths to have spaces and unmarked characters, as `cmd.exe` will
-            // interpret them as plain text to be forwarded as one unique argument. Enabling `windowsVerbatimArguments`
-            // disables Node.js's default quotes and escapes handling (https://git.io/fjdem).
-            // References:
-            // - Issues #17, #44, #55, #77, #101, #115
-            // - Pull requests: #74, #98
-            //
-            // As a result, all double-quotes are stripped from the `target` and do not get to your desired destination.
-            target = `"${target}"`;
-            childProcessOptions.windowsVerbatimArguments = true;
-            if (options.app) options.app = `"${options.app}"`;
-        }
-        if (options.wait) cliArguments.push("/wait");
-        if (options.app) {
-            if ($152536acc51e0ffd$exports && options.app.startsWith("/mnt/")) {
-                const windowsPath = await $de07249fe885e737$var$wslToWindowsPath(options.app);
-                options.app = windowsPath;
-            }
-            cliArguments.push(options.app);
-        }
-        if (appArguments.length > 0) cliArguments.push(...appArguments);
+        const mountPoint = await $de07249fe885e737$var$getWslDrivesMountPoint();
+        command = $152536acc51e0ffd$exports ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process.env.SYSTEMROOT}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+        cliArguments.push("-NoProfile", "-NonInteractive", "\u2013ExecutionPolicy", "Bypass", "-EncodedCommand");
+        if (!$152536acc51e0ffd$exports) childProcessOptions.windowsVerbatimArguments = true;
+        const encodedArguments = [
+            "Start"
+        ];
+        if (options.wait) encodedArguments.push("-Wait");
+        if (app) {
+            // Double quote with double quotes to ensure the inner quotes are passed through.
+            // Inner quotes are delimited for PowerShell interpretation with backticks.
+            encodedArguments.push(`"\`"${app}\`""`, "-ArgumentList");
+            appArguments.unshift(target);
+        } else encodedArguments.push(`"${target}"`);
+        if (appArguments.length > 0) {
+            appArguments = appArguments.map((arg)=>`"\`"${arg}\`""`);
+            encodedArguments.push(appArguments.join(","));
+        }
+        // Using Base64-encoded command, accepted by PowerShell, to allow special characters.
+        target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
     } else {
-        if (options.app) command = options.app;
+        if (app) command = app;
         else {
             // When bundled by Webpack, there's no actual package file path and no local `xdg-open`.
             const isBundled = !$de07249fe885e737$var$$parcel$__dirname || $de07249fe885e737$var$$parcel$__dirname === "/";
@@ -34937,7 +35040,7 @@ $de07249fe885e737$exports = async (target, options)=>{
     if (options.wait) return new Promise((resolve, reject)=>{
         subprocess.once("error", reject);
         subprocess.once("close", (exitCode)=>{
-            if (exitCode > 0) {
+            if (options.allowNonzeroExitCode && exitCode > 0) {
                 reject(new Error(`Exited with code ${exitCode}`));
                 return;
             }
@@ -35804,7 +35907,7 @@ function $fc60114c9ddc0bb9$var$escape() {
         case "0":
             $fc60114c9ddc0bb9$var$read();
             if ($fc60114c9ddc0bb9$var$util.isDigit($fc60114c9ddc0bb9$var$peek())) throw $fc60114c9ddc0bb9$var$invalidChar($fc60114c9ddc0bb9$var$read());
-            return "\x00";
+            return "\0";
         case "x":
             $fc60114c9ddc0bb9$var$read();
             return $fc60114c9ddc0bb9$var$hexEscape();
@@ -36029,7 +36132,7 @@ function $fc60114c9ddc0bb9$var$formatChar(c) {
         "\r": "\\r",
         "	": "\\t",
         "\v": "\\v",
-        "\x00": "\\0",
+        "\0": "\\0",
         "\u2028": "\\u2028",
         "\u2029": "\\u2029"
     };
@@ -36117,7 +36220,7 @@ var $fc60114c9ddc0bb9$var$stringify = function stringify(value, replacer, space)
             "\r": "\\r",
             "	": "\\t",
             "\v": "\\v",
-            "\x00": "\\0",
+            "\0": "\\0",
             "\u2028": "\\u2028",
             "\u2029": "\\u2029"
         };
@@ -36130,7 +36233,7 @@ var $fc60114c9ddc0bb9$var$stringify = function stringify(value, replacer, space)
                     quotes[c]++;
                     product += c;
                     continue;
-                case "\x00":
+                case "\0":
                     if ($fc60114c9ddc0bb9$var$util.isDigit(value[i + 1])) {
                         product += "\\x00";
                         continue;