@parcel/utils 2.6.0 → 2.7.0

package/lib/index.js

@@ -137,7 +137,7 @@ const $304f14c7e435813f$var$isObject = (val)=>val && typeof val === "object" &&
     const opts = options || {};
     const posix = $5MQDC.isWindows(options);
     const regex = isState ? $304f14c7e435813f$var$picomatch.compileRe(glob, options) : $304f14c7e435813f$var$picomatch.makeRe(glob, options, false, true);
-    const state1 = regex.state;
+    const state = regex.state;
     delete regex.state;
     let isIgnored = ()=>false;
     if (opts.ignore) {
@@ -156,7 +156,7 @@ const $304f14c7e435813f$var$isObject = (val)=>val && typeof val === "object" &&
         });
         const result = {
             glob: glob,
-            state: state1,
+            state: state,
             regex: regex,
             posix: posix,
             input: input,
@@ -177,7 +177,7 @@ const $304f14c7e435813f$var$isObject = (val)=>val && typeof val === "object" &&
         if (typeof opts.onMatch === "function") opts.onMatch(result);
         return returnObject ? result : true;
     };
-    if (returnState) matcher.state = state1;
+    if (returnState) matcher.state = state;
     return matcher;
 };
 /**
@@ -665,10 +665,10 @@ const $1e0430853cfb927a$var$depth = (token)=>{
             prevIndex = i;
         }
         if (prevIndex && prevIndex + 1 < input.length) {
-            const value = input.slice(prevIndex + 1);
-            parts.push(value);
+            const value1 = input.slice(prevIndex + 1);
+            parts.push(value1);
             if (opts.tokens) {
-                tokens[tokens.length - 1].value = value;
+                tokens[tokens.length - 1].value = value1;
                 $1e0430853cfb927a$var$depth(tokens[tokens.length - 1]);
                 state.maxDepth += tokens[tokens.length - 1].depth;
             }
@@ -968,21 +968,21 @@ var $5MQDC = parcelRequire("5MQDC");
  */ const $fd5d6f248e5b4a63$var$parse = (input, options)=>{
     if (typeof input !== "string") throw new TypeError("Expected a string");
     input = $fd5d6f248e5b4a63$var$REPLACEMENTS[input] || input;
-    const opts1 = {
+    const opts = {
         ...options
     };
-    const max = typeof opts1.maxLength === "number" ? Math.min($fd5d6f248e5b4a63$var$MAX_LENGTH, opts1.maxLength) : $fd5d6f248e5b4a63$var$MAX_LENGTH;
+    const max = typeof opts.maxLength === "number" ? Math.min($fd5d6f248e5b4a63$var$MAX_LENGTH, opts.maxLength) : $fd5d6f248e5b4a63$var$MAX_LENGTH;
     let len = input.length;
     if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
     const bos = {
         type: "bos",
         value: "",
-        output: opts1.prepend || ""
+        output: opts.prepend || ""
     };
     const tokens = [
         bos
     ];
-    const capture = opts1.capture ? "" : "?:";
+    const capture = opts.capture ? "" : "?:";
     const win32 = $5MQDC.isWindows(options);
     // create constants based on platform, for windows or posix
     const PLATFORM_CHARS = $7XmS6.globChars(win32);
@@ -991,17 +991,17 @@ var $5MQDC = parcelRequire("5MQDC");
     const globstar = (opts)=>{
         return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
     };
-    const nodot = opts1.dot ? "" : NO_DOT;
-    const qmarkNoDot = opts1.dot ? QMARK : QMARK_NO_DOT;
-    let star = opts1.bash === true ? globstar(opts1) : STAR;
-    if (opts1.capture) star = `(${star})`;
+    const nodot = opts.dot ? "" : NO_DOT;
+    const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+    let star = opts.bash === true ? globstar(opts) : STAR;
+    if (opts.capture) star = `(${star})`;
     // minimatch options support
-    if (typeof opts1.noext === "boolean") opts1.noextglob = opts1.noext;
+    if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
     const state = {
         input: input,
         index: -1,
         start: 0,
-        dot: opts1.dot === true,
+        dot: opts.dot === true,
         consumed: "",
         output: "",
         prefix: "",
@@ -1020,7 +1020,7 @@ var $5MQDC = parcelRequire("5MQDC");
     const braces = [];
     const stack = [];
     let prev = bos;
-    let value1;
+    let value;
     /**
    * Tokenizing helpers
    */ const eos = ()=>state.index === len - 1;
@@ -1093,7 +1093,7 @@ var $5MQDC = parcelRequire("5MQDC");
         token.prev = prev;
         token.parens = state.parens;
         token.output = state.output;
-        const output = (opts1.capture ? "(" : "") + token.open;
+        const output = (opts.capture ? "(" : "") + token.open;
         increment("parens");
         push({
             type: type,
@@ -1109,11 +1109,11 @@ var $5MQDC = parcelRequire("5MQDC");
         extglobs.push(token);
     };
     const extglobClose = (token)=>{
-        let output = token.close + (opts1.capture ? ")" : "");
+        let output = token.close + (opts.capture ? ")" : "");
         let rest;
         if (token.type === "negate") {
             let extglobStar = star;
-            if (token.inner && token.inner.length > 1 && token.inner.includes("/")) extglobStar = globstar(opts1);
+            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.prev.type === "bos") state.negatedExtglob = true;
@@ -1121,14 +1121,14 @@ var $5MQDC = parcelRequire("5MQDC");
         push({
             type: "paren",
             extglob: true,
-            value: value1,
+            value: value,
             output: output
         });
         decrement("parens");
     };
     /**
    * Fast paths
-   */ if (opts1.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+   */ if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
         let backslashes = false;
         let output = input.replace($fd5d6f248e5b4a63$var$REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index)=>{
             if (first === "\\") {
@@ -1148,12 +1148,12 @@ var $5MQDC = parcelRequire("5MQDC");
             return esc ? m : `\\${m}`;
         });
         if (backslashes === true) {
-            if (opts1.unescape === true) output = output.replace(/\\/g, "");
+            if (opts.unescape === true) output = output.replace(/\\/g, "");
             else output = output.replace(/\\+/g, (m)=>{
                 return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
             });
         }
-        if (output === input && opts1.contains === true) {
+        if (output === input && opts.contains === true) {
             state.output = input;
             return state;
         }
@@ -1163,19 +1163,19 @@ var $5MQDC = parcelRequire("5MQDC");
     /**
    * Tokenize input until we reach end-of-string
    */ while(!eos()){
-        value1 = advance();
-        if (value1 === "\0") continue;
+        value = advance();
+        if (value === "\0") continue;
         /**
      * Escaped characters
-     */ if (value1 === "\\") {
+     */ if (value === "\\") {
             const next = peek();
-            if (next === "/" && opts1.bash !== true) continue;
+            if (next === "/" && opts.bash !== true) continue;
             if (next === "." || next === ";") continue;
             if (!next) {
-                value1 += "\\";
+                value += "\\";
                 push({
                     type: "text",
-                    value: value1
+                    value: value
                 });
                 continue;
             }
@@ -1185,14 +1185,14 @@ var $5MQDC = parcelRequire("5MQDC");
             if (match && match[0].length > 2) {
                 slashes = match[0].length;
                 state.index += slashes;
-                if (slashes % 2 !== 0) value1 += "\\";
+                if (slashes % 2 !== 0) value += "\\";
             }
-            if (opts1.unescape === true) value1 = advance();
-            else value1 += advance();
+            if (opts.unescape === true) value = advance();
+            else value += advance();
             if (state.brackets === 0) {
                 push({
                     type: "text",
-                    value: value1
+                    value: value
                 });
                 continue;
             }
@@ -1200,8 +1200,8 @@ var $5MQDC = parcelRequire("5MQDC");
         /**
      * If we're inside a regex character class, continue
      * until we reach the closing bracket.
-     */ if (state.brackets > 0 && (value1 !== "]" || prev.value === "[" || prev.value === "[^")) {
-            if (opts1.posix !== false && value1 === ":") {
+     */ if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+            if (opts.posix !== false && value === ":") {
                 const inner = prev.value.slice(1);
                 if (inner.includes("[")) {
                     prev.posix = true;
@@ -1220,48 +1220,48 @@ var $5MQDC = parcelRequire("5MQDC");
                     }
                 }
             }
-            if (value1 === "[" && peek() !== ":" || value1 === "-" && peek() === "]") value1 = `\\${value1}`;
-            if (value1 === "]" && (prev.value === "[" || prev.value === "[^")) value1 = `\\${value1}`;
-            if (opts1.posix === true && value1 === "!" && prev.value === "[") value1 = "^";
-            prev.value += value1;
+            if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
+            if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
+            if (opts.posix === true && value === "!" && prev.value === "[") value = "^";
+            prev.value += value;
             append({
-                value: value1
+                value: value
             });
             continue;
         }
         /**
      * If we're inside a quoted string, continue
      * until we reach the closing double quote.
-     */ if (state.quotes === 1 && value1 !== '"') {
-            value1 = $5MQDC.escapeRegex(value1);
-            prev.value += value1;
+     */ if (state.quotes === 1 && value !== '"') {
+            value = $5MQDC.escapeRegex(value);
+            prev.value += value;
             append({
-                value: value1
+                value: value
             });
             continue;
         }
         /**
      * Double quotes
-     */ if (value1 === '"') {
+     */ if (value === '"') {
             state.quotes = state.quotes === 1 ? 0 : 1;
-            if (opts1.keepQuotes === true) push({
+            if (opts.keepQuotes === true) push({
                 type: "text",
-                value: value1
+                value: value
             });
             continue;
         }
         /**
      * Parentheses
-     */ if (value1 === "(") {
+     */ if (value === "(") {
             increment("parens");
             push({
                 type: "paren",
-                value: value1
+                value: value
             });
             continue;
         }
-        if (value1 === ")") {
-            if (state.parens === 0 && opts1.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("opening", "("));
+        if (value === ")") {
+            if (state.parens === 0 && opts.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("opening", "("));
             const extglob = extglobs[extglobs.length - 1];
             if (extglob && state.parens === extglob.parens + 1) {
                 extglobClose(extglobs.pop());
@@ -1269,7 +1269,7 @@ var $5MQDC = parcelRequire("5MQDC");
             }
             push({
                 type: "paren",
-                value: value1,
+                value: value,
                 output: state.parens ? ")" : "\\)"
             });
             decrement("parens");
@@ -1277,50 +1277,50 @@ var $5MQDC = parcelRequire("5MQDC");
         }
         /**
      * Square brackets
-     */ if (value1 === "[") {
-            if (opts1.nobracket === true || !remaining().includes("]")) {
-                if (opts1.nobracket !== true && opts1.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", "]"));
-                value1 = `\\${value1}`;
+     */ if (value === "[") {
+            if (opts.nobracket === true || !remaining().includes("]")) {
+                if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", "]"));
+                value = `\\${value}`;
             } else increment("brackets");
             push({
                 type: "bracket",
-                value: value1
+                value: value
             });
             continue;
         }
-        if (value1 === "]") {
-            if (opts1.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+        if (value === "]") {
+            if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
                 push({
                     type: "text",
-                    value: value1,
-                    output: `\\${value1}`
+                    value: value,
+                    output: `\\${value}`
                 });
                 continue;
             }
             if (state.brackets === 0) {
-                if (opts1.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("opening", "["));
+                if (opts.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("opening", "["));
                 push({
                     type: "text",
-                    value: value1,
-                    output: `\\${value1}`
+                    value: value,
+                    output: `\\${value}`
                 });
                 continue;
             }
             decrement("brackets");
             const prevValue = prev.value.slice(1);
-            if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value1 = `/${value1}`;
-            prev.value += value1;
+            if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
+            prev.value += value;
             append({
-                value: value1
+                value: value
             });
             // when literal brackets are explicitly disabled
             // assume we should match with a regex character class
-            if (opts1.literalBrackets === false || $5MQDC.hasRegexChars(prevValue)) continue;
+            if (opts.literalBrackets === false || $5MQDC.hasRegexChars(prevValue)) continue;
             const escaped = $5MQDC.escapeRegex(prev.value);
             state.output = state.output.slice(0, -prev.value.length);
             // when literal brackets are explicitly enabled
             // assume we should escape the brackets to match literal characters
-            if (opts1.literalBrackets === true) {
+            if (opts.literalBrackets === true) {
                 state.output += escaped;
                 prev.value = escaped;
                 continue;
@@ -1332,11 +1332,11 @@ var $5MQDC = parcelRequire("5MQDC");
         }
         /**
      * Braces
-     */ if (value1 === "{" && opts1.nobrace !== true) {
+     */ if (value === "{" && opts.nobrace !== true) {
             increment("braces");
             const open = {
                 type: "brace",
-                value: value1,
+                value: value,
                 output: "(",
                 outputIndex: state.output.length,
                 tokensIndex: state.tokens.length
@@ -1345,17 +1345,17 @@ var $5MQDC = parcelRequire("5MQDC");
             push(open);
             continue;
         }
-        if (value1 === "}") {
+        if (value === "}") {
             const brace = braces[braces.length - 1];
-            if (opts1.nobrace === true || !brace) {
+            if (opts.nobrace === true || !brace) {
                 push({
                     type: "text",
-                    value: value1,
-                    output: value1
+                    value: value,
+                    output: value
                 });
                 continue;
             }
-            let output = ")";
+            let output1 = ")";
             if (brace.dots === true) {
                 const arr = tokens.slice();
                 const range = [];
@@ -1364,21 +1364,21 @@ var $5MQDC = parcelRequire("5MQDC");
                     if (arr[i].type === "brace") break;
                     if (arr[i].type !== "dots") range.unshift(arr[i].value);
                 }
-                output = $fd5d6f248e5b4a63$var$expandRange(range, opts1);
+                output1 = $fd5d6f248e5b4a63$var$expandRange(range, opts);
                 state.backtrack = true;
             }
             if (brace.comma !== true && brace.dots !== true) {
                 const out = state.output.slice(0, brace.outputIndex);
                 const toks = state.tokens.slice(brace.tokensIndex);
                 brace.value = brace.output = "\\{";
-                value1 = output = "\\}";
+                value = output1 = "\\}";
                 state.output = out;
                 for (const t of toks)state.output += t.output || t.value;
             }
             push({
                 type: "brace",
-                value: value1,
-                output: output
+                value: value,
+                output: output1
             });
             decrement("braces");
             braces.pop();
@@ -1386,33 +1386,33 @@ var $5MQDC = parcelRequire("5MQDC");
         }
         /**
      * Pipes
-     */ if (value1 === "|") {
+     */ if (value === "|") {
             if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
             push({
                 type: "text",
-                value: value1
+                value: value
             });
             continue;
         }
         /**
      * Commas
-     */ if (value1 === ",") {
-            let output = value1;
-            const brace = braces[braces.length - 1];
-            if (brace && stack[stack.length - 1] === "braces") {
-                brace.comma = true;
-                output = "|";
+     */ if (value === ",") {
+            let output2 = value;
+            const brace1 = braces[braces.length - 1];
+            if (brace1 && stack[stack.length - 1] === "braces") {
+                brace1.comma = true;
+                output2 = "|";
             }
             push({
                 type: "comma",
-                value: value1,
-                output: output
+                value: value,
+                output: output2
             });
             continue;
         }
         /**
      * Slashes
-     */ if (value1 === "/") {
+     */ if (value === "/") {
             // if the beginning of the glob is "./", advance the start
             // to the current index, and don't add the "./" characters
             // to the state. This greatly simplifies lookbehinds when
@@ -1427,98 +1427,98 @@ var $5MQDC = parcelRequire("5MQDC");
             }
             push({
                 type: "slash",
-                value: value1,
+                value: value,
                 output: SLASH_LITERAL
             });
             continue;
         }
         /**
      * Dots
-     */ if (value1 === ".") {
+     */ if (value === ".") {
             if (state.braces > 0 && prev.type === "dot") {
                 if (prev.value === ".") prev.output = DOT_LITERAL;
-                const brace = braces[braces.length - 1];
+                const brace2 = braces[braces.length - 1];
                 prev.type = "dots";
-                prev.output += value1;
-                prev.value += value1;
-                brace.dots = true;
+                prev.output += value;
+                prev.value += value;
+                brace2.dots = true;
                 continue;
             }
             if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
                 push({
                     type: "text",
-                    value: value1,
+                    value: value,
                     output: DOT_LITERAL
                 });
                 continue;
             }
             push({
                 type: "dot",
-                value: value1,
+                value: value,
                 output: DOT_LITERAL
             });
             continue;
         }
         /**
      * Question marks
-     */ if (value1 === "?") {
+     */ if (value === "?") {
             const isGroup = prev && prev.value === "(";
-            if (!isGroup && opts1.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-                extglobOpen("qmark", value1);
+            if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+                extglobOpen("qmark", value);
                 continue;
             }
             if (prev && prev.type === "paren") {
-                const next = peek();
-                let output = value1;
-                if (next === "<" && !$5MQDC.supportsLookbehinds()) throw new Error("Node.js v10 or higher is required for regex lookbehinds");
-                if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value1}`;
+                const next1 = peek();
+                let output3 = value;
+                if (next1 === "<" && !$5MQDC.supportsLookbehinds()) throw new Error("Node.js v10 or higher is required for regex lookbehinds");
+                if (prev.value === "(" && !/[!=<:]/.test(next1) || next1 === "<" && !/<([!=]|\w+>)/.test(remaining())) output3 = `\\${value}`;
                 push({
                     type: "text",
-                    value: value1,
-                    output: output
+                    value: value,
+                    output: output3
                 });
                 continue;
             }
-            if (opts1.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+            if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
                 push({
                     type: "qmark",
-                    value: value1,
+                    value: value,
                     output: QMARK_NO_DOT
                 });
                 continue;
             }
             push({
                 type: "qmark",
-                value: value1,
+                value: value,
                 output: QMARK
             });
             continue;
         }
         /**
      * Exclamation
-     */ if (value1 === "!") {
-            if (opts1.noextglob !== true && peek() === "(") {
+     */ if (value === "!") {
+            if (opts.noextglob !== true && peek() === "(") {
                 if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
-                    extglobOpen("negate", value1);
+                    extglobOpen("negate", value);
                     continue;
                 }
             }
-            if (opts1.nonegate !== true && state.index === 0) {
+            if (opts.nonegate !== true && state.index === 0) {
                 negate();
                 continue;
             }
         }
         /**
      * Plus
-     */ if (value1 === "+") {
-            if (opts1.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-                extglobOpen("plus", value1);
+     */ if (value === "+") {
+            if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+                extglobOpen("plus", value);
                 continue;
             }
-            if (prev && prev.value === "(" || opts1.regex === false) {
+            if (prev && prev.value === "(" || opts.regex === false) {
                 push({
                     type: "plus",
-                    value: value1,
+                    value: value,
                     output: PLUS_LITERAL
                 });
                 continue;
@@ -1526,7 +1526,7 @@ var $5MQDC = parcelRequire("5MQDC");
             if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
                 push({
                     type: "plus",
-                    value: value1
+                    value: value
                 });
                 continue;
             }
@@ -1538,34 +1538,34 @@ var $5MQDC = parcelRequire("5MQDC");
         }
         /**
      * Plain text
-     */ if (value1 === "@") {
-            if (opts1.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+     */ if (value === "@") {
+            if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
                 push({
                     type: "at",
                     extglob: true,
-                    value: value1,
+                    value: value,
                     output: ""
                 });
                 continue;
             }
             push({
                 type: "text",
-                value: value1
+                value: value
             });
             continue;
         }
         /**
      * Plain text
-     */ if (value1 !== "*") {
-            if (value1 === "$" || value1 === "^") value1 = `\\${value1}`;
-            const match = $fd5d6f248e5b4a63$var$REGEX_NON_SPECIAL_CHARS.exec(remaining());
-            if (match) {
-                value1 += match[0];
-                state.index += match[0].length;
+     */ if (value !== "*") {
+            if (value === "$" || value === "^") value = `\\${value}`;
+            const match1 = $fd5d6f248e5b4a63$var$REGEX_NON_SPECIAL_CHARS.exec(remaining());
+            if (match1) {
+                value += match1[0];
+                state.index += match1[0].length;
             }
             push({
                 type: "text",
-                value: value1
+                value: value
             });
             continue;
         }
@@ -1574,31 +1574,31 @@ var $5MQDC = parcelRequire("5MQDC");
      */ if (prev && (prev.type === "globstar" || prev.star === true)) {
             prev.type = "star";
             prev.star = true;
-            prev.value += value1;
+            prev.value += value;
             prev.output = star;
             state.backtrack = true;
             state.globstar = true;
-            consume(value1);
+            consume(value);
             continue;
         }
-        let rest = remaining();
-        if (opts1.noextglob !== true && /^\([^?]/.test(rest)) {
-            extglobOpen("star", value1);
+        let rest1 = remaining();
+        if (opts.noextglob !== true && /^\([^?]/.test(rest1)) {
+            extglobOpen("star", value);
             continue;
         }
         if (prev.type === "star") {
-            if (opts1.noglobstar === true) {
-                consume(value1);
+            if (opts.noglobstar === true) {
+                consume(value);
                 continue;
             }
             const prior = prev.prev;
             const before = prior.prev;
             const isStart = prior.type === "slash" || prior.type === "bos";
             const afterStar = before && (before.type === "star" || before.type === "globstar");
-            if (opts1.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+            if (opts.bash === true && (!isStart || rest1[0] && rest1[0] !== "/")) {
                 push({
                     type: "star",
-                    value: value1,
+                    value: value,
                     output: ""
                 });
                 continue;
@@ -1608,48 +1608,48 @@ var $5MQDC = parcelRequire("5MQDC");
             if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
                 push({
                     type: "star",
-                    value: value1,
+                    value: value,
                     output: ""
                 });
                 continue;
             }
             // strip consecutive `/**/`
-            while(rest.slice(0, 3) === "/**"){
+            while(rest1.slice(0, 3) === "/**"){
                 const after = input[state.index + 4];
                 if (after && after !== "/") break;
-                rest = rest.slice(3);
+                rest1 = rest1.slice(3);
                 consume("/**", 3);
             }
             if (prior.type === "bos" && eos()) {
                 prev.type = "globstar";
-                prev.value += value1;
-                prev.output = globstar(opts1);
+                prev.value += value;
+                prev.output = globstar(opts);
                 state.output = prev.output;
                 state.globstar = true;
-                consume(value1);
+                consume(value);
                 continue;
             }
             if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
                 state.output = state.output.slice(0, -(prior.output + prev.output).length);
                 prior.output = `(?:${prior.output}`;
                 prev.type = "globstar";
-                prev.output = globstar(opts1) + (opts1.strictSlashes ? ")" : "|$)");
-                prev.value += value1;
+                prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+                prev.value += value;
                 state.globstar = true;
                 state.output += prior.output + prev.output;
-                consume(value1);
+                consume(value);
                 continue;
             }
-            if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
-                const end = rest[1] !== void 0 ? "|$" : "";
+            if (prior.type === "slash" && prior.prev.type !== "bos" && rest1[0] === "/") {
+                const end = rest1[1] !== void 0 ? "|$" : "";
                 state.output = state.output.slice(0, -(prior.output + prev.output).length);
                 prior.output = `(?:${prior.output}`;
                 prev.type = "globstar";
-                prev.output = `${globstar(opts1)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
-                prev.value += value1;
+                prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+                prev.value += value;
                 state.output += prior.output + prev.output;
                 state.globstar = true;
-                consume(value1 + advance());
+                consume(value + advance());
                 push({
                     type: "slash",
                     value: "/",
@@ -1657,13 +1657,13 @@ var $5MQDC = parcelRequire("5MQDC");
                 });
                 continue;
             }
-            if (prior.type === "bos" && rest[0] === "/") {
+            if (prior.type === "bos" && rest1[0] === "/") {
                 prev.type = "globstar";
-                prev.value += value1;
-                prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts1)}${SLASH_LITERAL})`;
+                prev.value += value;
+                prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
                 state.output = prev.output;
                 state.globstar = true;
-                consume(value1 + advance());
+                consume(value + advance());
                 push({
                     type: "slash",
                     value: "/",
@@ -1675,27 +1675,27 @@ var $5MQDC = parcelRequire("5MQDC");
             state.output = state.output.slice(0, -prev.output.length);
             // reset previous token to globstar
             prev.type = "globstar";
-            prev.output = globstar(opts1);
-            prev.value += value1;
+            prev.output = globstar(opts);
+            prev.value += value;
             // reset output with globstar
             state.output += prev.output;
             state.globstar = true;
-            consume(value1);
+            consume(value);
             continue;
         }
         const token = {
             type: "star",
-            value: value1,
+            value: value,
             output: star
         };
-        if (opts1.bash === true) {
+        if (opts.bash === true) {
             token.output = ".*?";
             if (prev.type === "bos" || prev.type === "slash") token.output = nodot + token.output;
             push(token);
             continue;
         }
-        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts1.regex === true) {
-            token.output = value1;
+        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+            token.output = value;
             push(token);
             continue;
         }
@@ -1703,7 +1703,7 @@ var $5MQDC = parcelRequire("5MQDC");
             if (prev.type === "dot") {
                 state.output += NO_DOT_SLASH;
                 prev.output += NO_DOT_SLASH;
-            } else if (opts1.dot === true) {
+            } else if (opts.dot === true) {
                 state.output += NO_DOTS_SLASH;
                 prev.output += NO_DOTS_SLASH;
             } else {
@@ -1718,21 +1718,21 @@ var $5MQDC = parcelRequire("5MQDC");
         push(token);
     }
     while(state.brackets > 0){
-        if (opts1.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", "]"));
+        if (opts.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", "]"));
         state.output = $5MQDC.escapeLast(state.output, "[");
         decrement("brackets");
     }
     while(state.parens > 0){
-        if (opts1.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", ")"));
+        if (opts.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", ")"));
         state.output = $5MQDC.escapeLast(state.output, "(");
         decrement("parens");
     }
     while(state.braces > 0){
-        if (opts1.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", "}"));
+        if (opts.strictBrackets === true) throw new SyntaxError($fd5d6f248e5b4a63$var$syntaxError("closing", "}"));
         state.output = $5MQDC.escapeLast(state.output, "{");
         decrement("braces");
     }
-    if (opts1.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
+    if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
         type: "maybe_slash",
         value: "",
         output: `${SLASH_LITERAL}?`
@@ -1740,9 +1740,9 @@ var $5MQDC = parcelRequire("5MQDC");
     // rebuild the output if we had to backtrack at any point
     if (state.backtrack === true) {
         state.output = "";
-        for (const token of state.tokens){
-            state.output += token.output != null ? token.output : token.value;
-            if (token.suffix) state.output += token.suffix;
+        for (const token1 of state.tokens){
+            state.output += token1.output != null ? token1.output : token1.value;
+            if (token1.suffix) state.output += token1.suffix;
         }
     }
     return state;
@@ -1752,25 +1752,25 @@ var $5MQDC = parcelRequire("5MQDC");
  * This can significantly speed up processing and has very little downside
  * impact when none of the fast paths match.
  */ $fd5d6f248e5b4a63$var$parse.fastpaths = (input, options)=>{
-    const opts2 = {
+    const opts = {
         ...options
     };
-    const max = typeof opts2.maxLength === "number" ? Math.min($fd5d6f248e5b4a63$var$MAX_LENGTH, opts2.maxLength) : $fd5d6f248e5b4a63$var$MAX_LENGTH;
+    const max = typeof opts.maxLength === "number" ? Math.min($fd5d6f248e5b4a63$var$MAX_LENGTH, opts.maxLength) : $fd5d6f248e5b4a63$var$MAX_LENGTH;
     const len = input.length;
     if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
     input = $fd5d6f248e5b4a63$var$REPLACEMENTS[input] || input;
     const win32 = $5MQDC.isWindows(options);
     // create constants based on platform, for windows or posix
     const { DOT_LITERAL: DOT_LITERAL , SLASH_LITERAL: SLASH_LITERAL , ONE_CHAR: ONE_CHAR , DOTS_SLASH: DOTS_SLASH , NO_DOT: NO_DOT , NO_DOTS: NO_DOTS , NO_DOTS_SLASH: NO_DOTS_SLASH , STAR: STAR , START_ANCHOR: START_ANCHOR  } = $7XmS6.globChars(win32);
-    const nodot = opts2.dot ? NO_DOTS : NO_DOT;
-    const slashDot = opts2.dot ? NO_DOTS_SLASH : NO_DOT;
-    const capture = opts2.capture ? "" : "?:";
+    const nodot = opts.dot ? NO_DOTS : NO_DOT;
+    const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+    const capture = opts.capture ? "" : "?:";
     const state = {
         negated: false,
         prefix: ""
     };
-    let star = opts2.bash === true ? ".*?" : STAR;
-    if (opts2.capture) star = `(${star})`;
+    let star = opts.bash === true ? ".*?" : STAR;
+    if (opts.capture) star = `(${star})`;
     const globstar = (opts)=>{
         if (opts.noglobstar === true) return star;
         return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
@@ -1786,13 +1786,13 @@ var $5MQDC = parcelRequire("5MQDC");
             case "*/*":
                 return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
             case "**":
-                return nodot + globstar(opts2);
+                return nodot + globstar(opts);
             case "**/*":
-                return `(?:${nodot}${globstar(opts2)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
             case "**/*.*":
-                return `(?:${nodot}${globstar(opts2)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
             case "**/.*":
-                return `(?:${nodot}${globstar(opts2)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
             default:
                 {
                     const match = /^(.*?)\.(\w+)$/.exec(str);
@@ -1804,9 +1804,9 @@ var $5MQDC = parcelRequire("5MQDC");
         }
     };
     const output = $5MQDC.removePrefix(input, state);
-    let source1 = create(output);
-    if (source1 && opts2.strictSlashes !== true) source1 += `${SLASH_LITERAL}?`;
-    return source1;
+    let source = create(output);
+    if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL}?`;
+    return source;
 };
 module.exports = $fd5d6f248e5b4a63$var$parse;
 
@@ -3071,11 +3071,11 @@ var $1Sf6D = parcelRequire("1Sf6D");
 var $ciuZ9 = parcelRequire("ciuZ9");
 function $6e1ae4ed5b62d1d9$var$parseAsync(str, opts) {
     if (!opts) opts = {};
-    const index1 = 0;
-    const blocksize1 = opts.blocksize || 40960;
+    const index = 0;
+    const blocksize = opts.blocksize || 40960;
     const parser = new $1Sf6D();
     return new Promise((resolve, reject)=>{
-        setImmediate(parseAsyncNext, index1, blocksize1, resolve, reject);
+        setImmediate(parseAsyncNext, index, blocksize, resolve, reject);
     });
     function parseAsyncNext(index, blocksize, resolve, reject) {
         if (index >= str.length) {
@@ -3088,8 +3088,8 @@ function $6e1ae4ed5b62d1d9$var$parseAsync(str, opts) {
         try {
             parser.parse(str.slice(index, index + blocksize));
             setImmediate(parseAsyncNext, index + blocksize, blocksize, resolve, reject);
-        } catch (err) {
-            reject($ciuZ9(err, str));
+        } catch (err1) {
+            reject($ciuZ9(err1, str));
         }
     }
 }
@@ -3271,8 +3271,8 @@ function $17af713ce388fcb8$var$numpad(num, str) {
 function $17af713ce388fcb8$var$escapeString(str) {
     return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r")/* eslint-disable no-control-regex */ .replace(/([\u0000-\u001f\u007f])/, (c)=>"\\u" + $17af713ce388fcb8$var$numpad(4, c.codePointAt(0).toString(16)));
 /* eslint-enable no-control-regex */ }
-function $17af713ce388fcb8$var$stringifyMultilineString(str1) {
-    let escaped = str1.split(/\n/).map((str)=>{
+function $17af713ce388fcb8$var$stringifyMultilineString(str) {
+    let escaped = str.split(/\n/).map((str)=>{
         return $17af713ce388fcb8$var$escapeString(str).replace(/"(?="")/g, '\\"');
     }).join("\n");
     if (escaped.slice(-1) === '"') escaped += "\\\n";
@@ -3429,6 +3429,7 @@ $parcel$export(module.exports, "unique", () => $9631335a11debdd4$export$7a5d5c15
 $parcel$export(module.exports, "objectSortedEntries", () => $9631335a11debdd4$export$61559eb31990eff6);
 $parcel$export(module.exports, "objectSortedEntriesDeep", () => $9631335a11debdd4$export$1a9b883158ac407c);
 $parcel$export(module.exports, "setDifference", () => $9631335a11debdd4$export$8bd517cc5b3722f7);
+$parcel$export(module.exports, "setEqual", () => $9631335a11debdd4$export$dd7d5a65a6b6780f);
 $parcel$export(module.exports, "setIntersect", () => $9631335a11debdd4$export$9404cfefeb010e68);
 $parcel$export(module.exports, "setUnion", () => $9631335a11debdd4$export$667066422fa0af46);
 $parcel$export(module.exports, "resolveConfig", () => $10671d0be444e08b$export$7eca4ea16d4c8343);
@@ -3437,6 +3438,7 @@ $parcel$export(module.exports, "loadConfig", () => $10671d0be444e08b$export$c1a4
 $parcel$export(module.exports, "DefaultMap", () => $5783bf7916ff59db$export$674cd7dcb504ac5c);
 $parcel$export(module.exports, "DefaultWeakMap", () => $5783bf7916ff59db$export$4924f7ffab2ae440);
 $parcel$export(module.exports, "makeDeferredWithPromise", () => $75952a43539cb60f$export$93f345b3f0dd27e7);
+$parcel$export(module.exports, "getProgressMessage", () => $01f892dcf45b57a7$export$d28945a2f2ba5e30);
 $parcel$export(module.exports, "isGlob", () => $e8d0e504a4244d84$export$f3a2344a73dbdd42);
 $parcel$export(module.exports, "isGlobMatch", () => $e8d0e504a4244d84$export$16e6d319a883f04e);
 $parcel$export(module.exports, "globSync", () => $e8d0e504a4244d84$export$42275ba87174c828);
@@ -3533,8 +3535,8 @@ async function $15d4bc8b6fca8c7e$var$getSourcemapSizes(filePath, fs, projectRoot
     }
 }
 async function $15d4bc8b6fca8c7e$var$createBundleStats(bundle, fs, projectRoot) {
-    let filePath1 = bundle.filePath;
-    let sourcemapSizes = await $15d4bc8b6fca8c7e$var$getSourcemapSizes(filePath1, fs, projectRoot);
+    let filePath = bundle.filePath;
+    let sourcemapSizes = await $15d4bc8b6fca8c7e$var$getSourcemapSizes(filePath, fs, projectRoot);
     let assets = new Map();
     bundle.traverseAssets((asset)=>{
         let filePath = (0, ($parcel$interopDefault($8C1kk$path))).normalize(asset.filePath);
@@ -5801,26 +5803,26 @@ $4143f576ffbec226$var$util.text = {
  * @param options the options to use:
  *          update true to force an update (not use the cached value).
  * @param callback(err, max) called once the operation completes.
- */ $4143f576ffbec226$var$util.estimateCores = function(options, callback1) {
+ */ $4143f576ffbec226$var$util.estimateCores = function(options, callback) {
     if (typeof options === "function") {
-        callback1 = options;
+        callback = options;
         options = {};
     }
     options = options || {};
-    if ("cores" in $4143f576ffbec226$var$util && !options.update) return callback1(null, $4143f576ffbec226$var$util.cores);
+    if ("cores" in $4143f576ffbec226$var$util && !options.update) return callback(null, $4143f576ffbec226$var$util.cores);
     if (typeof navigator !== "undefined" && "hardwareConcurrency" in navigator && navigator.hardwareConcurrency > 0) {
         $4143f576ffbec226$var$util.cores = navigator.hardwareConcurrency;
-        return callback1(null, $4143f576ffbec226$var$util.cores);
+        return callback(null, $4143f576ffbec226$var$util.cores);
     }
     if (typeof Worker === "undefined") {
         // workers not available
         $4143f576ffbec226$var$util.cores = 1;
-        return callback1(null, $4143f576ffbec226$var$util.cores);
+        return callback(null, $4143f576ffbec226$var$util.cores);
     }
     if (typeof Blob === "undefined") {
         // can't estimate, default to 2
         $4143f576ffbec226$var$util.cores = 2;
-        return callback1(null, $4143f576ffbec226$var$util.cores);
+        return callback(null, $4143f576ffbec226$var$util.cores);
     }
     // create worker concurrency estimation code as blob
     var blobUrl = URL.createObjectURL(new Blob([
@@ -5846,12 +5848,12 @@ $4143f576ffbec226$var$util.text = {
     function sample(max, samples, numWorkers) {
         if (samples === 0) {
             // get overlap average
-            var avg1 = Math.floor(max.reduce(function(avg, x) {
+            var avg = Math.floor(max.reduce(function(avg, x) {
                 return avg + x;
             }, 0) / max.length);
-            $4143f576ffbec226$var$util.cores = Math.max(1, avg1);
+            $4143f576ffbec226$var$util.cores = Math.max(1, avg);
             URL.revokeObjectURL(blobUrl);
-            return callback1(null, $4143f576ffbec226$var$util.cores);
+            return callback(null, $4143f576ffbec226$var$util.cores);
         }
         map(numWorkers, function(err, results) {
             max.push(reduce(numWorkers, results));
@@ -5861,7 +5863,7 @@ $4143f576ffbec226$var$util.text = {
     function map(numWorkers, callback) {
         var workers = [];
         var results = [];
-        for(var i1 = 0; i1 < numWorkers; ++i1){
+        for(var i = 0; i < numWorkers; ++i){
             var worker = new Worker(blobUrl);
             worker.addEventListener("message", function(e) {
                 results.push(e.data);
@@ -5872,7 +5874,7 @@ $4143f576ffbec226$var$util.text = {
             });
             workers.push(worker);
         }
-        for(var i1 = 0; i1 < numWorkers; ++i1)workers[i1].postMessage(i1);
+        for(var i = 0; i < numWorkers; ++i)workers[i].postMessage(i);
     }
     function reduce(numWorkers, results) {
         // find overlapping time windows
@@ -7729,13 +7731,13 @@ var $ca9d5cba0afae339$var$imix; // inverse mix-columns table
  *          mode the cipher mode to use (default: 'CBC').
  *
  * @return the cipher.
- */ function $ca9d5cba0afae339$var$_createCipher(options1) {
-    options1 = options1 || {};
-    var mode = (options1.mode || "CBC").toUpperCase();
+ */ function $ca9d5cba0afae339$var$_createCipher(options) {
+    options = options || {};
+    var mode = (options.mode || "CBC").toUpperCase();
     var algorithm = "AES-" + mode;
     var cipher;
-    if (options1.decrypt) cipher = $iGlOy.cipher.createDecipher(algorithm, options1.key);
-    else cipher = $iGlOy.cipher.createCipher(algorithm, options1.key);
+    if (options.decrypt) cipher = $iGlOy.cipher.createDecipher(algorithm, options.key);
+    else cipher = $iGlOy.cipher.createCipher(algorithm, options.key);
     // backwards compatible start API
     var start = cipher.start;
     cipher.start = function(iv, options) {
@@ -7803,6 +7805,10 @@ $10862ec0f65326f9$var$_IN("1.3.14.3.2.29", "sha1WithRSASignature");
 $10862ec0f65326f9$var$_IN("2.16.840.1.101.3.4.2.1", "sha256");
 $10862ec0f65326f9$var$_IN("2.16.840.1.101.3.4.2.2", "sha384");
 $10862ec0f65326f9$var$_IN("2.16.840.1.101.3.4.2.3", "sha512");
+$10862ec0f65326f9$var$_IN("2.16.840.1.101.3.4.2.4", "sha224");
+$10862ec0f65326f9$var$_IN("2.16.840.1.101.3.4.2.5", "sha512-224");
+$10862ec0f65326f9$var$_IN("2.16.840.1.101.3.4.2.6", "sha512-256");
+$10862ec0f65326f9$var$_IN("1.2.840.113549.2.2", "md2");
 $10862ec0f65326f9$var$_IN("1.2.840.113549.2.5", "md5");
 // pkcs#7 content types
 $10862ec0f65326f9$var$_IN("1.2.840.113549.1.7.1", "data");
@@ -8128,6 +8134,8 @@ $10862ec0f65326f9$var$_IN("1.3.6.1.5.5.7.3.8", "timeStamping");
  * @param [options] object with options or boolean strict flag
  *          [strict] true to be strict when checking value lengths, false to
  *            allow truncated values (default: true).
+ *          [parseAllBytes] true to ensure all bytes are parsed
+ *            (default: true)
  *          [decodeBitStrings] true to attempt to decode the content of
  *            BIT STRINGs (not OCTET STRINGs) using strict mode. Note that
  *            without schema support to understand the data context this can
@@ -8135,21 +8143,34 @@ $10862ec0f65326f9$var$_IN("1.3.6.1.5.5.7.3.8", "timeStamping");
  *            flag will be deprecated or removed as soon as schema support is
  *            available. (default: true)
  *
+ * @throws Will throw an error for various malformed input conditions.
+ *
  * @return the parsed asn1 object.
  */ $579f29a8775d6845$var$asn1.fromDer = function(bytes, options) {
     if (options === undefined) options = {
         strict: true,
+        parseAllBytes: true,
         decodeBitStrings: true
     };
     if (typeof options === "boolean") options = {
         strict: options,
+        parseAllBytes: true,
         decodeBitStrings: true
     };
     if (!("strict" in options)) options.strict = true;
+    if (!("parseAllBytes" in options)) options.parseAllBytes = true;
     if (!("decodeBitStrings" in options)) options.decodeBitStrings = true;
     // wrap in buffer if needed
     if (typeof bytes === "string") bytes = $iGlOy.util.createBuffer(bytes);
-    return $579f29a8775d6845$var$_fromDer(bytes, bytes.length(), 0, options);
+    var byteCount = bytes.length();
+    var value = $579f29a8775d6845$var$_fromDer(bytes, bytes.length(), 0, options);
+    if (options.parseAllBytes && bytes.length() !== 0) {
+        var error = new Error("Unparsed DER bytes remain after ASN.1 parsing.");
+        error.byteCount = byteCount;
+        error.remaining = bytes.length();
+        throw error;
+    }
+    return value;
 };
 /**
  * Internal function to parse an asn1 object from a byte buffer in DER format.
@@ -8245,7 +8266,6 @@ $10862ec0f65326f9$var$_IN("1.3.6.1.5.5.7.3.8", "timeStamping");
             start = bytes.length();
             var subOptions = {
                 // enforce strict mode to avoid parsing ASN.1 from plain data
-                verbose: options.verbose,
                 strict: true,
                 decodeBitStrings: true
             };
@@ -8281,7 +8301,10 @@ $10862ec0f65326f9$var$_IN("1.3.6.1.5.5.7.3.8", "timeStamping");
                 value += String.fromCharCode(bytes.getInt16());
                 remaining -= 2;
             }
-        } else value = bytes.getBytes(length);
+        } else {
+            value = bytes.getBytes(length);
+            remaining -= length;
+        }
     }
     // add BIT STRING contents if available
     var asn1Options = bitStringContents === undefined ? null : {
@@ -8853,7 +8876,12 @@ var $579f29a8775d6845$var$_nonLatinRegex = /[^\\u0000-\\u00ff]/;
         } else if (obj.type === $579f29a8775d6845$var$asn1.Type.OCTETSTRING) {
             if (!$579f29a8775d6845$var$_nonLatinRegex.test(obj.value)) rval += "(" + obj.value + ") ";
             rval += "0x" + $iGlOy.util.bytesToHex(obj.value);
-        } else if (obj.type === $579f29a8775d6845$var$asn1.Type.UTF8) rval += $iGlOy.util.decodeUtf8(obj.value);
+        } else if (obj.type === $579f29a8775d6845$var$asn1.Type.UTF8) try {
+            rval += $iGlOy.util.decodeUtf8(obj.value);
+        } catch (e) {
+            if (e.message === "URI malformed") rval += "0x" + $iGlOy.util.bytesToHex(obj.value) + " (malformed UTF8)";
+            else throw e;
+        }
         else if (obj.type === $579f29a8775d6845$var$asn1.Type.PRINTABLESTRING || obj.type === $579f29a8775d6845$var$asn1.Type.IA5String) rval += obj.value;
         else if ($579f29a8775d6845$var$_nonLatinRegex.test(obj.value)) rval += "0x" + $iGlOy.util.bytesToHex(obj.value);
         else if (obj.value.length === 0) rval += "[null]";
@@ -10648,13 +10676,13 @@ var $ff4c3bd9116e15cc$var$spfunction8 = [
  *          mode the cipher mode to use (default: 'CBC').
  *
  * @return the cipher.
- */ function $ff4c3bd9116e15cc$var$_createCipher(options1) {
-    options1 = options1 || {};
-    var mode = (options1.mode || "CBC").toUpperCase();
+ */ function $ff4c3bd9116e15cc$var$_createCipher(options) {
+    options = options || {};
+    var mode = (options.mode || "CBC").toUpperCase();
     var algorithm = "DES-" + mode;
     var cipher;
-    if (options1.decrypt) cipher = $iGlOy.cipher.createDecipher(algorithm, options1.key);
-    else cipher = $iGlOy.cipher.createCipher(algorithm, options1.key);
+    if (options.decrypt) cipher = $iGlOy.cipher.createDecipher(algorithm, options.key);
+    else cipher = $iGlOy.cipher.createCipher(algorithm, options.key);
     // backwards compatible start API
     var start = cipher.start;
     cipher.start = function(iv, options) {
@@ -10734,9 +10762,9 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript) $7436abf0cf29a7b7
     var hLen = md.digestLength;
     /* 1. If dkLen > (2^32 - 1) * hLen, output "derived key too long" and
     stop. */ if (dkLen > 0xFFFFFFFF * hLen) {
-        var err1 = new Error("Derived key is too long.");
-        if (callback) return callback(err1);
-        throw err1;
+        var err = new Error("Derived key is too long.");
+        if (callback) return callback(err);
+        throw err;
     }
     /* 2. Let len be the number of hLen-octet blocks in the derived key,
     rounding up, and let r be the number of octets in the last
@@ -11187,9 +11215,9 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript && !process.versio
         keyBytes: ""
     };
     // create 32 entropy pools (each is a message digest)
-    var md1 = plugin.md;
+    var md = plugin.md;
     var pools = new Array(32);
-    for(var i1 = 0; i1 < 32; ++i1)pools[i1] = md1.create();
+    for(var i = 0; i < 32; ++i)pools[i] = md.create();
     ctx.pools = pools;
     // entropy pools are written to cyclically, starting at index 0
     ctx.pool = 0;
@@ -11345,9 +11373,9 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript && !process.versio
         // use window.crypto.getRandomValues strong source of entropy if available
         var getRandomValues = null;
         var globalScope = $iGlOy.util.globalScope;
-        var _crypto1 = globalScope.crypto || globalScope.msCrypto;
-        if (_crypto1 && _crypto1.getRandomValues) getRandomValues = function(arr) {
-            return _crypto1.getRandomValues(arr);
+        var _crypto = globalScope.crypto || globalScope.msCrypto;
+        if (_crypto && _crypto.getRandomValues) getRandomValues = function(arr) {
+            return _crypto.getRandomValues(arr);
         };
         var b = $iGlOy.util.createBuffer();
         if (getRandomValues) while(b.length() < needed){
@@ -11459,7 +11487,7 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript && !process.versio
         };
         else {
             // main thread sends random bytes upon request
-            var listener1 = function(e) {
+            var listener = function(e) {
                 var data = e.data;
                 if (data.forge && data.forge.prng) ctx.seedFile(data.forge.prng.needed, function(err, bytes) {
                     worker.postMessage({
@@ -11473,7 +11501,7 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript && !process.versio
                 });
             };
             // TODO: do we need to remove the event listener when the worker dies?
-            worker.addEventListener("message", listener1);
+            worker.addEventListener("message", listener);
         }
     };
     return ctx;
@@ -11487,7 +11515,7 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript && !process.versio
         $b9b57fce3e6d85ef$exports = $iGlOy.random;
         return;
     }
-    (function(jQuery) {
+    (function(jQuery1) {
         // the default prng plugin, uses AES-128
         var prng_aes = {};
         var _prng_aes_output = new Array(4);
@@ -11576,8 +11604,8 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript && !process.versio
             // add some entropy from navigator object
             if (typeof navigator !== "undefined") {
                 var _navBytes = "";
-                for(var key1 in navigator)try {
-                    if (typeof navigator[key1] == "string") _navBytes += navigator[key1];
+                for(var key in navigator)try {
+                    if (typeof navigator[key] == "string") _navBytes += navigator[key];
                 } catch (e) {
                 /* Some navigator keys might not be accessible, e.g. the geolocation
           attribute throws an exception if touched in Mozilla chrome://
@@ -11589,22 +11617,22 @@ if ($iGlOy.util.isNodejs && !$iGlOy.options.usePureJavaScript && !process.versio
                 _navBytes = null;
             }
             // add mouse and keyboard collectors if jquery is available
-            if (jQuery) {
+            if (jQuery1) {
                 // set up mouse entropy capture
-                jQuery().mousemove(function(e) {
+                jQuery1().mousemove(function(e) {
                     // add mouse coords
                     _ctx.collectInt(e.clientX, 16);
                     _ctx.collectInt(e.clientY, 16);
                 });
                 // set up keyboard entropy capture
-                jQuery().keypress(function(e) {
+                jQuery1().keypress(function(e) {
                     _ctx.collectInt(e.charCode, 8);
                 });
             }
         }
         /* Random API */ if (!$iGlOy.random) $iGlOy.random = _ctx;
         else // extend forge.random with _ctx
-        for(var key1 in _ctx)$iGlOy.random[key1] = _ctx[key1];
+        for(var key in _ctx)$iGlOy.random[key] = _ctx[key];
         // expose spawn PRNG
         $iGlOy.random.createInstance = spawnPrng;
         $b9b57fce3e6d85ef$exports = $iGlOy.random;
@@ -14171,11 +14199,11 @@ var $iGlOy = parcelRequire("iGlOy");
             // asynchronous which may actually be slower
             // start workers immediately
             var workers = [];
-            for(var i1 = 0; i1 < numWorkers; ++i1)// FIXME: fix path or use blob URLs
-            workers[i1] = new Worker(workerScript);
+            for(var i = 0; i < numWorkers; ++i)// FIXME: fix path or use blob URLs
+            workers[i] = new Worker(workerScript);
             var running = numWorkers;
             // listen for requests from workers and assign ranges to find prime
-            for(var i1 = 0; i1 < numWorkers; ++i1)workers[i1].addEventListener("message", workerMessage);
+            for(var i = 0; i < numWorkers; ++i)workers[i].addEventListener("message", workerMessage);
             /* Note: The distribution of random numbers is unknown. Therefore, each
     web worker is continuously allocated a range of numbers to check for a
     random number until one is found.
@@ -14474,6 +14502,45 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
         }
     ]
 };
+// validator for a DigestInfo structure
+var $8ab3548bea1beb81$var$digestInfoValidator = {
+    name: "DigestInfo",
+    tagClass: $8ab3548bea1beb81$var$asn1.Class.UNIVERSAL,
+    type: $8ab3548bea1beb81$var$asn1.Type.SEQUENCE,
+    constructed: true,
+    value: [
+        {
+            name: "DigestInfo.DigestAlgorithm",
+            tagClass: $8ab3548bea1beb81$var$asn1.Class.UNIVERSAL,
+            type: $8ab3548bea1beb81$var$asn1.Type.SEQUENCE,
+            constructed: true,
+            value: [
+                {
+                    name: "DigestInfo.DigestAlgorithm.algorithmIdentifier",
+                    tagClass: $8ab3548bea1beb81$var$asn1.Class.UNIVERSAL,
+                    type: $8ab3548bea1beb81$var$asn1.Type.OID,
+                    constructed: false,
+                    capture: "algorithmIdentifier"
+                },
+                {
+                    // NULL paramters
+                    name: "DigestInfo.DigestAlgorithm.parameters",
+                    tagClass: $8ab3548bea1beb81$var$asn1.Class.UNIVERSAL,
+                    type: $8ab3548bea1beb81$var$asn1.Type.NULL,
+                    constructed: false
+                }
+            ]
+        },
+        {
+            // digest
+            name: "DigestInfo.digest",
+            tagClass: $8ab3548bea1beb81$var$asn1.Class.UNIVERSAL,
+            type: $8ab3548bea1beb81$var$asn1.Type.OCTETSTRING,
+            constructed: false,
+            capture: "digest"
+        }
+    ]
+};
 /**
  * Wrap digest in DigestInfo object.
  *
@@ -14942,7 +15009,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
  * @param [callback(err, keypair)] called once the operation completes.
  *
  * @return an object with privateKey and publicKey properties.
- */ $8ab3548bea1beb81$var$pki.rsa.generateKeyPair = function(bits, e1, options, callback) {
+ */ $8ab3548bea1beb81$var$pki.rsa.generateKeyPair = function(bits, e, options, callback) {
     // (bits), (options), (callback)
     if (arguments.length === 1) {
         if (typeof bits === "object") {
@@ -14955,42 +15022,42 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
     } else if (arguments.length === 2) {
         // (bits, e), (bits, options), (bits, callback), (options, callback)
         if (typeof bits === "number") {
-            if (typeof e1 === "function") {
-                callback = e1;
-                e1 = undefined;
-            } else if (typeof e1 !== "number") {
-                options = e1;
-                e1 = undefined;
+            if (typeof e === "function") {
+                callback = e;
+                e = undefined;
+            } else if (typeof e !== "number") {
+                options = e;
+                e = undefined;
             }
         } else {
             options = bits;
-            callback = e1;
+            callback = e;
             bits = undefined;
-            e1 = undefined;
+            e = undefined;
         }
     } else if (arguments.length === 3) {
         // (bits, e, options), (bits, e, callback), (bits, options, callback)
-        if (typeof e1 === "number") {
+        if (typeof e === "number") {
             if (typeof options === "function") {
                 callback = options;
                 options = undefined;
             }
         } else {
             callback = options;
-            options = e1;
-            e1 = undefined;
+            options = e;
+            e = undefined;
         }
     }
     options = options || {};
     if (bits === undefined) bits = options.bits || 2048;
-    if (e1 === undefined) e1 = options.e || 0x10001;
+    if (e === undefined) e = options.e || 0x10001;
     // use native code if permitted, available, and parameters are acceptable
-    if (!$iGlOy.options.usePureJavaScript && !options.prng && bits >= 256 && bits <= 16384 && (e1 === 0x10001 || e1 === 3)) {
+    if (!$iGlOy.options.usePureJavaScript && !options.prng && bits >= 256 && bits <= 16384 && (e === 0x10001 || e === 3)) {
         if (callback) {
             // try native async
             if ($8ab3548bea1beb81$var$_detectNodeCrypto("generateKeyPair")) return $8ab3548bea1beb81$var$_crypto.generateKeyPair("rsa", {
                 modulusLength: bits,
-                publicExponent: e1,
+                publicExponent: e,
                 publicKeyEncoding: {
                     type: "spki",
                     format: "pem"
@@ -15010,7 +15077,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
             return $8ab3548bea1beb81$var$util.globalScope.crypto.subtle.generateKey({
                 name: "RSASSA-PKCS1-v1_5",
                 modulusLength: bits,
-                publicExponent: $8ab3548bea1beb81$var$_intToUint8Array(e1),
+                publicExponent: $8ab3548bea1beb81$var$_intToUint8Array(e),
                 hash: {
                     name: "SHA-256"
                 }
@@ -15035,7 +15102,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
                 var genOp = $8ab3548bea1beb81$var$util.globalScope.msCrypto.subtle.generateKey({
                     name: "RSASSA-PKCS1-v1_5",
                     modulusLength: bits,
-                    publicExponent: $8ab3548bea1beb81$var$_intToUint8Array(e1),
+                    publicExponent: $8ab3548bea1beb81$var$_intToUint8Array(e),
                     hash: {
                         name: "SHA-256"
                     }
@@ -15043,8 +15110,8 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
                     "sign",
                     "verify"
                 ]);
-                genOp.oncomplete = function(e2) {
-                    var pair = e2.target.result;
+                genOp.oncomplete = function(e) {
+                    var pair = e.target.result;
                     var exportOp = $8ab3548bea1beb81$var$util.globalScope.msCrypto.subtle.exportKey("pkcs8", pair.privateKey);
                     exportOp.oncomplete = function(e) {
                         var pkcs8 = e.target.result;
@@ -15067,7 +15134,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
         if ($8ab3548bea1beb81$var$_detectNodeCrypto("generateKeyPairSync")) {
             var keypair = $8ab3548bea1beb81$var$_crypto.generateKeyPairSync("rsa", {
                 modulusLength: bits,
-                publicExponent: e1,
+                publicExponent: e,
                 publicKeyEncoding: {
                     type: "spki",
                     format: "pem"
@@ -15084,7 +15151,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
         }
     }
     // use JavaScript implementation
-    var state = $8ab3548bea1beb81$var$pki.rsa.createKeyPairGenerationState(bits, e1, options);
+    var state = $8ab3548bea1beb81$var$pki.rsa.createKeyPairGenerationState(bits, e, options);
     if (!callback) {
         $8ab3548bea1beb81$var$pki.rsa.stepKeyPairGenerationState(state, 0);
         return state.keys;
@@ -15098,10 +15165,10 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
  * @param e the exponent.
  *
  * @return the public key.
- */ $8ab3548bea1beb81$var$pki.setRsaPublicKey = $8ab3548bea1beb81$var$pki.rsa.setPublicKey = function(n, e3) {
-    var key1 = {
+ */ $8ab3548bea1beb81$var$pki.setRsaPublicKey = $8ab3548bea1beb81$var$pki.rsa.setPublicKey = function(n, e) {
+    var key = {
         n: n,
-        e: e3
+        e: e
     };
     /**
    * Encrypts the given data with this public key. Newer applications
@@ -15119,7 +15186,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
    * @param schemeOptions any scheme-specific options.
    *
    * @return the encrypted byte string.
-   */ key1.encrypt = function(data, scheme, schemeOptions) {
+   */ key.encrypt = function(data, scheme, schemeOptions) {
         if (typeof scheme === "string") scheme = scheme.toUpperCase();
         else if (scheme === undefined) scheme = "RSAES-PKCS1-V1_5";
         if (scheme === "RSAES-PKCS1-V1_5") scheme = {
@@ -15144,8 +15211,8 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
         };
         else if (typeof scheme === "string") throw new Error('Unsupported encryption scheme: "' + scheme + '".');
         // do scheme-based encoding then rsa encryption
-        var e4 = scheme.encode(data, key1, true);
-        return $8ab3548bea1beb81$var$pki.rsa.encrypt(e4, key1, true);
+        var e = scheme.encode(data, key, true);
+        return $8ab3548bea1beb81$var$pki.rsa.encrypt(e, key, true);
     };
     /**
    * Verifies the given signature against the given digest.
@@ -15175,33 +15242,60 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
    *          a Forge PSS object for RSASSA-PSS,
    *          'NONE' or null for none, DigestInfo will not be expected, but
    *            PKCS#1 v1.5 padding will still be used.
+   * @param options optional verify options
+   *          _parseAllDigestBytes testing flag to control parsing of all
+   *            digest bytes. Unsupported and not for general usage.
+   *            (default: true)
    *
    * @return true if the signature was verified, false if not.
-   */ key1.verify = function(digest1, signature, scheme) {
+   */ key.verify = function(digest, signature, scheme, options) {
         if (typeof scheme === "string") scheme = scheme.toUpperCase();
         else if (scheme === undefined) scheme = "RSASSA-PKCS1-V1_5";
+        if (options === undefined) options = {
+            _parseAllDigestBytes: true
+        };
+        if (!("_parseAllDigestBytes" in options)) options._parseAllDigestBytes = true;
         if (scheme === "RSASSA-PKCS1-V1_5") scheme = {
             verify: function(digest, d) {
                 // remove padding
-                d = $8ab3548bea1beb81$var$_decodePkcs1_v1_5(d, key1, true);
+                d = $8ab3548bea1beb81$var$_decodePkcs1_v1_5(d, key, true);
                 // d is ASN.1 BER-encoded DigestInfo
-                var obj = $8ab3548bea1beb81$var$asn1.fromDer(d);
+                var obj = $8ab3548bea1beb81$var$asn1.fromDer(d, {
+                    parseAllBytes: options._parseAllDigestBytes
+                });
+                // validate DigestInfo
+                var capture = {};
+                var errors = [];
+                if (!$8ab3548bea1beb81$var$asn1.validate(obj, $8ab3548bea1beb81$var$digestInfoValidator, capture, errors)) {
+                    var error = new Error("ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 DigestInfo value.");
+                    error.errors = errors;
+                    throw error;
+                }
+                // check hash algorithm identifier
+                // see PKCS1-v1-5DigestAlgorithms in RFC 8017
+                // FIXME: add support to vaidator for strict value choices
+                var oid = $8ab3548bea1beb81$var$asn1.derToOid(capture.algorithmIdentifier);
+                if (!(oid === $iGlOy.oids.md2 || oid === $iGlOy.oids.md5 || oid === $iGlOy.oids.sha1 || oid === $iGlOy.oids.sha224 || oid === $iGlOy.oids.sha256 || oid === $iGlOy.oids.sha384 || oid === $iGlOy.oids.sha512 || oid === $iGlOy.oids["sha512-224"] || oid === $iGlOy.oids["sha512-256"])) {
+                    var error = new Error("Unknown RSASSA-PKCS1-v1_5 DigestAlgorithm identifier.");
+                    error.oid = oid;
+                    throw error;
+                }
                 // compare the given digest to the decrypted one
-                return digest === obj.value[1].value;
+                return digest === capture.digest;
             }
         };
         else if (scheme === "NONE" || scheme === "NULL" || scheme === null) scheme = {
             verify: function(digest, d) {
                 // remove padding
-                d = $8ab3548bea1beb81$var$_decodePkcs1_v1_5(d, key1, true);
+                d = $8ab3548bea1beb81$var$_decodePkcs1_v1_5(d, key, true);
                 return digest === d;
             }
         };
         // do rsa decryption w/o any decoding, then verify -- which does decoding
-        var d1 = $8ab3548bea1beb81$var$pki.rsa.decrypt(signature, key1, true, false);
-        return scheme.verify(digest1, d1, key1.n.bitLength());
+        var d = $8ab3548bea1beb81$var$pki.rsa.decrypt(signature, key, true, false);
+        return scheme.verify(digest, d, key.n.bitLength());
     };
-    return key1;
+    return key;
 };
 /**
  * Sets an RSA private key from BigIntegers modulus, exponent, primes,
@@ -15217,11 +15311,11 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
  * @param qInv ((inverse of q) mod p)
  *
  * @return the private key.
- */ $8ab3548bea1beb81$var$pki.setRsaPrivateKey = $8ab3548bea1beb81$var$pki.rsa.setPrivateKey = function(n, e, d2, p, q, dP, dQ, qInv) {
-    var key2 = {
+ */ $8ab3548bea1beb81$var$pki.setRsaPrivateKey = $8ab3548bea1beb81$var$pki.rsa.setPrivateKey = function(n, e, d, p, q, dP, dQ, qInv) {
+    var key = {
         n: n,
         e: e,
-        d: d2,
+        d: d,
         p: p,
         q: q,
         dP: dP,
@@ -15240,11 +15334,11 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
    * @param schemeOptions any scheme-specific options.
    *
    * @return the decrypted byte string.
-   */ key2.decrypt = function(data, scheme, schemeOptions) {
+   */ key.decrypt = function(data, scheme, schemeOptions) {
         if (typeof scheme === "string") scheme = scheme.toUpperCase();
         else if (scheme === undefined) scheme = "RSAES-PKCS1-V1_5";
         // do rsa decryption w/o any decoding
-        var d3 = $8ab3548bea1beb81$var$pki.rsa.decrypt(data, key2, false, false);
+        var d = $8ab3548bea1beb81$var$pki.rsa.decrypt(data, key, false, false);
         if (scheme === "RSAES-PKCS1-V1_5") scheme = {
             decode: $8ab3548bea1beb81$var$_decodePkcs1_v1_5
         };
@@ -15265,7 +15359,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
         };
         else throw new Error('Unsupported encryption scheme: "' + scheme + '".');
         // decode according to scheme
-        return scheme.decode(d3, key2, false);
+        return scheme.decode(d, key, false);
     };
     /**
    * Signs the given digest, producing a signature.
@@ -15285,7 +15379,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
    *            PKCS#1 v1.5 padding will still be used.
    *
    * @return the signature as a byte string.
-   */ key2.sign = function(md, scheme) {
+   */ key.sign = function(md, scheme) {
         /* Note: The internal implementation of RSA operations is being
       transitioned away from a PKCS#1 v1.5 hard-coded scheme. Some legacy
       code like the use of an encoding block identifier 'bt' will eventually
@@ -15306,10 +15400,10 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
             bt = 0x01;
         }
         // encode and then encrypt
-        var d = scheme.encode(md, key2.n.bitLength());
-        return $8ab3548bea1beb81$var$pki.rsa.encrypt(d, key2, bt);
+        var d = scheme.encode(md, key.n.bitLength());
+        return $8ab3548bea1beb81$var$pki.rsa.encrypt(d, key, bt);
     };
-    return key2;
+    return key;
 };
 /**
  * Wraps an RSAPrivateKey ASN.1 object in an ASN.1 PrivateKeyInfo object.
@@ -15596,9 +15690,9 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
  *            numbers for each web worker to check per work assignment,
  *            (default: 100).
  * @param callback(err, keypair) called once the operation completes.
- */ function $8ab3548bea1beb81$var$_generateKeyPair(state, options, callback1) {
+ */ function $8ab3548bea1beb81$var$_generateKeyPair(state, options, callback) {
     if (typeof options === "function") {
-        callback1 = options;
+        callback = options;
         options = {};
     }
     options = options || {};
@@ -15617,7 +15711,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
     function generate() {
         // find p and then q (done in series to simplify)
         getPrime(state.pBits, function(err, num) {
-            if (err) return callback1(err);
+            if (err) return callback(err);
             state.p = num;
             if (state.q !== null) return finish(err, state.q);
             getPrime(state.qBits, finish);
@@ -15627,7 +15721,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
         $iGlOy.prime.generateProbablePrime(bits, opts, callback);
     }
     function finish(err, num) {
-        if (err) return callback1(err);
+        if (err) return callback(err);
         // set q
         state.q = num;
         // ensure p is larger than q (swap them if not)
@@ -15673,7 +15767,7 @@ var $8ab3548bea1beb81$var$publicKeyValidator = $iGlOy.pki.rsa.publicKeyValidator
             privateKey: $8ab3548bea1beb81$var$pki.rsa.setPrivateKey(state.n, state.e, d, state.p, state.q, d.mod(state.p1), d.mod(state.q1), state.q.modInverse(state.p)),
             publicKey: $8ab3548bea1beb81$var$pki.rsa.setPublicKey(state.n, state.e)
         };
-        callback1(null, state.keys);
+        callback(null, state.keys);
     }
 }
 /**
@@ -16539,10 +16633,10 @@ var $4ead143e6089ae29$var$pkcs12PbeParamsValidator = {
     }
     // get PRF message digest
     var md = $4ead143e6089ae29$var$prfOidToMessageDigest(capture.prfOid);
-    var key1 = $4ead143e6089ae29$var$pki.pbe.generatePkcs12Key(password, salt, 1, count, dkLen, md);
+    var key = $4ead143e6089ae29$var$pki.pbe.generatePkcs12Key(password, salt, 1, count, dkLen, md);
     md.start();
-    var iv1 = $4ead143e6089ae29$var$pki.pbe.generatePkcs12Key(password, salt, 2, count, dIvLen, md);
-    return cipherFn(key1, iv1);
+    var iv = $4ead143e6089ae29$var$pki.pbe.generatePkcs12Key(password, salt, 2, count, dIvLen, md);
+    return cipherFn(key, iv);
 };
 /**
  * OpenSSL's legacy key derivation function.
@@ -19446,9 +19540,9 @@ var $f71d929f259208f7$var$jan_1_2050 = new Date("2050-01-01T00:00:00Z");
     }
     // auto-add passed in certs
     if (certs) // parse PEM-formatted certificates as necessary
-    for(var i1 = 0; i1 < certs.length; ++i1){
-        var cert1 = certs[i1];
-        caStore.addCertificate(cert1);
+    for(var i = 0; i < certs.length; ++i){
+        var cert = certs[i];
+        caStore.addCertificate(cert);
     }
     return caStore;
 };
@@ -20631,11 +20725,11 @@ var $71c5302ef2ea3950$var$asn1 = $iGlOy.asn1;
  * @param maxline the maximum characters per line, defaults to 64.
  *
  * @return the PEM-formatted private key.
- */ $71c5302ef2ea3950$var$pki.privateKeyInfoToPem = function(pki1, maxline) {
+ */ $71c5302ef2ea3950$var$pki.privateKeyInfoToPem = function(pki, maxline) {
     // convert to DER, then PEM-encode
     var msg = {
         type: "PRIVATE KEY",
-        body: $71c5302ef2ea3950$var$asn1.toDer(pki1).getBytes()
+        body: $71c5302ef2ea3950$var$asn1.toDer(pki).getBytes()
     };
     return $iGlOy.pem.encode(msg, {
         maxline: maxline
@@ -20761,7 +20855,7 @@ var $71c5302ef2ea3950$var$asn1 = $iGlOy.asn1;
  * @param record the record.
  *
  * @return the sha-1 hash (20 bytes) for the given record.
- */ var $e55982d45da68b81$var$hmac_sha1 = function(key1, seqNum, record) {
+ */ var $e55982d45da68b81$var$hmac_sha1 = function(key, seqNum, record) {
     /* MAC is computed like so:
   HMAC_hash(
     key, seqNum +
@@ -20770,7 +20864,7 @@ var $71c5302ef2ea3950$var$asn1 = $iGlOy.asn1;
       TLSCompressed.length +
       TLSCompressed.fragment)
   */ var hmac = $iGlOy.hmac.create();
-    hmac.start("SHA1", key1);
+    hmac.start("SHA1", key);
     var b = $iGlOy.util.createBuffer();
     b.putInt32(seqNum[0]);
     b.putInt32(seqNum[1]);
@@ -21073,8 +21167,8 @@ $e55982d45da68b81$var$tls.Alert.Description = {
  * @return the matching supported cipher suite or null.
  */ $e55982d45da68b81$var$tls.getCipherSuite = function(twoBytes) {
     var rval = null;
-    for(var key2 in $e55982d45da68b81$var$tls.CipherSuites){
-        var cs = $e55982d45da68b81$var$tls.CipherSuites[key2];
+    for(var key in $e55982d45da68b81$var$tls.CipherSuites){
+        var cs = $e55982d45da68b81$var$tls.CipherSuites[key];
         if (cs.id[0] === twoBytes.charCodeAt(0) && cs.id[1] === twoBytes.charCodeAt(1)) {
             rval = cs;
             break;
@@ -21796,9 +21890,9 @@ $e55982d45da68b81$var$tls.Alert.Description = {
  * @param c the connection.
  * @param record the record.
  * @param length the length of the handshake message.
- */ $e55982d45da68b81$var$tls.handleServerHelloDone = function(c1, record, length) {
+ */ $e55982d45da68b81$var$tls.handleServerHelloDone = function(c, record, length) {
     // len must be 0 bytes
-    if (length > 0) return c1.error(c1, {
+    if (length > 0) return c.error(c, {
         message: "Invalid ServerHelloDone message. Invalid length.",
         send: true,
         alert: {
@@ -21806,7 +21900,7 @@ $e55982d45da68b81$var$tls.Alert.Description = {
             description: $e55982d45da68b81$var$tls.Alert.Description.record_overflow
         }
     });
-    if (c1.serverCertificate === null) {
+    if (c.serverCertificate === null) {
         // no server certificate was provided
         var error = {
             message: "No server certificate provided. Not enough security.",
@@ -21818,7 +21912,7 @@ $e55982d45da68b81$var$tls.Alert.Description = {
         };
         // call application callback
         var depth = 0;
-        var ret = c1.verify(c1, error.alert.description, depth, []);
+        var ret = c.verify(c, error.alert.description, depth, []);
         if (ret !== true) {
             // check for custom alert info
             if (ret || ret === 0) {
@@ -21830,25 +21924,25 @@ $e55982d45da68b81$var$tls.Alert.Description = {
                 error.alert.description = ret;
             }
             // send error
-            return c1.error(c1, error);
+            return c.error(c, error);
         }
     }
     // create client certificate message if requested
-    if (c1.session.certificateRequest !== null) {
-        record = $e55982d45da68b81$var$tls.createRecord(c1, {
+    if (c.session.certificateRequest !== null) {
+        record = $e55982d45da68b81$var$tls.createRecord(c, {
             type: $e55982d45da68b81$var$tls.ContentType.handshake,
-            data: $e55982d45da68b81$var$tls.createCertificate(c1)
+            data: $e55982d45da68b81$var$tls.createCertificate(c)
         });
-        $e55982d45da68b81$var$tls.queue(c1, record);
+        $e55982d45da68b81$var$tls.queue(c, record);
     }
     // create client key exchange message
-    record = $e55982d45da68b81$var$tls.createRecord(c1, {
+    record = $e55982d45da68b81$var$tls.createRecord(c, {
         type: $e55982d45da68b81$var$tls.ContentType.handshake,
-        data: $e55982d45da68b81$var$tls.createClientKeyExchange(c1)
+        data: $e55982d45da68b81$var$tls.createClientKeyExchange(c)
     });
-    $e55982d45da68b81$var$tls.queue(c1, record);
+    $e55982d45da68b81$var$tls.queue(c, record);
     // expect no messages until the following callback has been called
-    c1.expect = $e55982d45da68b81$var$SER;
+    c.expect = $e55982d45da68b81$var$SER;
     // create callback to handle client signature (for client-certs)
     var callback = function(c, signature) {
         if (c.session.certificateRequest !== null && c.session.clientCertificate !== null) // create certificate verify message
@@ -21879,9 +21973,9 @@ $e55982d45da68b81$var$tls.Alert.Description = {
     };
     // if there is no certificate request or no client certificate, do
     // callback immediately
-    if (c1.session.certificateRequest === null || c1.session.clientCertificate === null) return callback(c1, null);
+    if (c.session.certificateRequest === null || c.session.clientCertificate === null) return callback(c, null);
     // otherwise get the client signature
-    $e55982d45da68b81$var$tls.getClientSignature(c1, callback);
+    $e55982d45da68b81$var$tls.getClientSignature(c, callback);
 };
 /**
  * Called when a ChangeCipherSpec record is received.
@@ -22992,8 +23086,8 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
  * @param c the connection.
  *
  * @return the new initialized TLS connection state.
- */ $e55982d45da68b81$var$tls.createConnectionState = function(c2) {
-    var client = c2.entity === $e55982d45da68b81$var$tls.ConnectionEnd.client;
+ */ $e55982d45da68b81$var$tls.createConnectionState = function(c) {
+    var client = c.entity === $e55982d45da68b81$var$tls.ConnectionEnd.client;
     var createMode = function() {
         var mode = {
             // two 32-bit numbers, first is most significant
@@ -23073,15 +23167,15 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
         return !c.fail;
     };
     // handle security parameters
-    if (c2.session) {
-        var sp = c2.session.sp;
-        c2.session.cipherSuite.initSecurityParameters(sp);
+    if (c.session) {
+        var sp = c.session.sp;
+        c.session.cipherSuite.initSecurityParameters(sp);
         // generate keys
-        sp.keys = $e55982d45da68b81$var$tls.generateKeys(c2, sp);
+        sp.keys = $e55982d45da68b81$var$tls.generateKeys(c, sp);
         state.read.macKey = client ? sp.keys.server_write_MAC_key : sp.keys.client_write_MAC_key;
         state.write.macKey = client ? sp.keys.client_write_MAC_key : sp.keys.server_write_MAC_key;
         // cipher suite setup
-        c2.session.cipherSuite.initConnectionState(state, c2, sp);
+        c.session.cipherSuite.initConnectionState(state, c, sp);
         // compression setup
         switch(sp.compression_algorithm){
             case $e55982d45da68b81$var$tls.CompressionMethod.none:
@@ -23476,8 +23570,8 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
     var sp = c.session.sp;
     sp.pre_master_secret = b.getBytes();
     // RSA-encrypt the pre-master secret
-    var key3 = c.session.serverCertificate.publicKey;
-    b = key3.encrypt(sp.pre_master_secret);
+    var key = c.session.serverCertificate.publicKey;
+    b = key.encrypt(sp.pre_master_secret);
     /* Note: The encrypted pre-master secret will be stored in a
     public-key-encrypted opaque vector that has the length prefixed using
     2 bytes, so include those 2 bytes in the handshake message length. This
@@ -23517,14 +23611,14 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
  *
  * @param c the connection.
  * @param callback the callback to call once the signed data is ready.
- */ $e55982d45da68b81$var$tls.getClientSignature = function(c3, callback1) {
+ */ $e55982d45da68b81$var$tls.getClientSignature = function(c, callback) {
     // generate data to RSA encrypt
-    var b1 = $iGlOy.util.createBuffer();
-    b1.putBuffer(c3.session.md5.digest());
-    b1.putBuffer(c3.session.sha1.digest());
-    b1 = b1.getBytes();
+    var b = $iGlOy.util.createBuffer();
+    b.putBuffer(c.session.md5.digest());
+    b.putBuffer(c.session.sha1.digest());
+    b = b.getBytes();
     // create default signing function as necessary
-    c3.getSignature = c3.getSignature || function(c, b, callback) {
+    c.getSignature = c.getSignature || function(c, b, callback) {
         // do rsa encryption, call callback
         var privateKey = null;
         if (c.getPrivateKey) try {
@@ -23553,7 +23647,7 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
         callback(c, b);
     };
     // get client signature
-    c3.getSignature(c3, b1, callback1);
+    c.getSignature(c, b, callback);
 };
 /**
  * Creates a CertificateVerify message.
@@ -23644,8 +23738,8 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
     certTypes.putByte(0x01);
     // add distinguished names from CA store
     var cAs = $iGlOy.util.createBuffer();
-    for(var key4 in c.caStore.certs){
-        var cert = c.caStore.certs[key4];
+    for(var key in c.caStore.certs){
+        var cert = c.caStore.certs[key];
         var dn = $iGlOy.pki.distinguishedNameToAsn1(cert.subject);
         var byteBuffer = $iGlOy.asn1.toDer(dn);
         cAs.putInt16(byteBuffer.length());
@@ -23924,12 +24018,12 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
  *          authority at the end.
  *
  * @return true if successful, false if not.
- */ $e55982d45da68b81$var$tls.verifyCertificateChain = function(c, chain1) {
+ */ $e55982d45da68b81$var$tls.verifyCertificateChain = function(c, chain) {
     try {
         // Make a copy of c.verifyOptions so that we can modify options.verify
         // without modifying c.verifyOptions.
         var options = {};
-        for(var key5 in c.verifyOptions)options[key5] = c.verifyOptions[key5];
+        for(var key in c.verifyOptions)options[key] = c.verifyOptions[key];
         options.verify = function(vfd, depth, chain) {
             // convert pki.certificateError to tls alert description
             var desc = $e55982d45da68b81$var$_certErrorToAlertDesc(vfd);
@@ -23954,7 +24048,7 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
             return ret;
         };
         // verify chain
-        $iGlOy.pki.verifyCertificateChain(c.caStore, chain1, options);
+        $iGlOy.pki.verifyCertificateChain(c.caStore, chain, options);
     } catch (ex) {
         // build tls error if not already customized
         var err = ex;
@@ -23993,21 +24087,21 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
         rval.capacity = Math.max(capacity || 100, 1);
         rval.order = [];
         // store order for sessions, delete session overflow
-        for(var key6 in cache)if (rval.order.length <= capacity) rval.order.push(key6);
-        else delete cache[key6];
+        for(var key in cache)if (rval.order.length <= capacity) rval.order.push(key);
+        else delete cache[key];
         // get a session from a session ID (or get any session)
         rval.getSession = function(sessionId) {
             var session = null;
-            var key7 = null;
+            var key = null;
             // if session ID provided, use it
-            if (sessionId) key7 = $iGlOy.util.bytesToHex(sessionId);
+            if (sessionId) key = $iGlOy.util.bytesToHex(sessionId);
             else if (rval.order.length > 0) // get first session from cache
-            key7 = rval.order[0];
-            if (key7 !== null && key7 in rval.cache) {
+            key = rval.order[0];
+            if (key !== null && key in rval.cache) {
                 // get cached session and remove from cache
-                session = rval.cache[key7];
-                delete rval.cache[key7];
-                for(var i in rval.order)if (rval.order[i] === key7) {
+                session = rval.cache[key];
+                delete rval.cache[key];
+                for(var i in rval.order)if (rval.order[i] === key) {
                     rval.order.splice(i, 1);
                     break;
                 }
@@ -24018,13 +24112,13 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
         rval.setSession = function(sessionId, session) {
             // remove session from cache if at capacity
             if (rval.order.length === rval.capacity) {
-                var key8 = rval.order.shift();
-                delete rval.cache[key8];
+                var key = rval.order.shift();
+                delete rval.cache[key];
             }
             // add session to cache
-            var key8 = $iGlOy.util.bytesToHex(sessionId);
-            rval.order.push(key8);
-            rval.cache[key8] = session;
+            var key = $iGlOy.util.bytesToHex(sessionId);
+            rval.order.push(key);
+            rval.cache[key] = session;
         };
     }
     return rval;
@@ -24049,14 +24143,14 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
     var cipherSuites = options.cipherSuites || null;
     if (cipherSuites === null) {
         cipherSuites = [];
-        for(var key9 in $e55982d45da68b81$var$tls.CipherSuites)cipherSuites.push($e55982d45da68b81$var$tls.CipherSuites[key9]);
+        for(var key in $e55982d45da68b81$var$tls.CipherSuites)cipherSuites.push($e55982d45da68b81$var$tls.CipherSuites[key]);
     }
     // set default entity
     var entity = options.server || false ? $e55982d45da68b81$var$tls.ConnectionEnd.server : $e55982d45da68b81$var$tls.ConnectionEnd.client;
     // create session cache if requested
     var sessionCache = options.sessionCache ? $e55982d45da68b81$var$tls.createSessionCache(options.sessionCache) : null;
     // create TLS connection
-    var c4 = {
+    var c = {
         version: {
             major: $e55982d45da68b81$var$tls.Version.major,
             minor: $e55982d45da68b81$var$tls.Version.minor
@@ -24107,33 +24201,33 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
    * Resets a closed TLS connection for reuse. Called in c.close().
    *
    * @param clearFail true to clear the fail flag (default: true).
-   */ c4.reset = function(clearFail) {
-        c4.version = {
+   */ c.reset = function(clearFail) {
+        c.version = {
             major: $e55982d45da68b81$var$tls.Version.major,
             minor: $e55982d45da68b81$var$tls.Version.minor
         };
-        c4.record = null;
-        c4.session = null;
-        c4.peerCertificate = null;
-        c4.state = {
+        c.record = null;
+        c.session = null;
+        c.peerCertificate = null;
+        c.state = {
             pending: null,
             current: null
         };
-        c4.expect = c4.entity === $e55982d45da68b81$var$tls.ConnectionEnd.client ? $e55982d45da68b81$var$SHE : $e55982d45da68b81$var$CHE;
-        c4.fragmented = null;
-        c4.records = [];
-        c4.open = false;
-        c4.handshakes = 0;
-        c4.handshaking = false;
-        c4.isConnected = false;
-        c4.fail = !(clearFail || typeof clearFail === "undefined");
-        c4.input.clear();
-        c4.tlsData.clear();
-        c4.data.clear();
-        c4.state.current = $e55982d45da68b81$var$tls.createConnectionState(c4);
+        c.expect = c.entity === $e55982d45da68b81$var$tls.ConnectionEnd.client ? $e55982d45da68b81$var$SHE : $e55982d45da68b81$var$CHE;
+        c.fragmented = null;
+        c.records = [];
+        c.open = false;
+        c.handshakes = 0;
+        c.handshaking = false;
+        c.isConnected = false;
+        c.fail = !(clearFail || typeof clearFail === "undefined");
+        c.input.clear();
+        c.tlsData.clear();
+        c.data.clear();
+        c.state.current = $e55982d45da68b81$var$tls.createConnectionState(c);
     };
     // do initial reset of connection
-    c4.reset();
+    c.reset();
     /**
    * Updates the current TLS engine state based on the given record.
    *
@@ -24244,39 +24338,39 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
    * This method should only be called if the connection is in client mode.
    *
    * @param sessionId the session ID to use, null to start a new one.
-   */ c4.handshake = function(sessionId) {
+   */ c.handshake = function(sessionId) {
         // error to call this in non-client mode
-        if (c4.entity !== $e55982d45da68b81$var$tls.ConnectionEnd.client) // not fatal error
-        c4.error(c4, {
+        if (c.entity !== $e55982d45da68b81$var$tls.ConnectionEnd.client) // not fatal error
+        c.error(c, {
             message: "Cannot initiate handshake as a server.",
             fatal: false
         });
-        else if (c4.handshaking) // handshake is already in progress, fail but not fatal error
-        c4.error(c4, {
+        else if (c.handshaking) // handshake is already in progress, fail but not fatal error
+        c.error(c, {
             message: "Handshake already in progress.",
             fatal: false
         });
         else {
             // clear fail flag on reuse
-            if (c4.fail && !c4.open && c4.handshakes === 0) c4.fail = false;
+            if (c.fail && !c.open && c.handshakes === 0) c.fail = false;
             // now handshaking
-            c4.handshaking = true;
+            c.handshaking = true;
             // default to blank (new session)
             sessionId = sessionId || "";
             // if a session ID was specified, try to find it in the cache
             var session = null;
             if (sessionId.length > 0) {
-                if (c4.sessionCache) session = c4.sessionCache.getSession(sessionId);
+                if (c.sessionCache) session = c.sessionCache.getSession(sessionId);
                 // matching session not found in cache, clear session ID
                 if (session === null) sessionId = "";
             }
             // no session given, grab a session from the cache, if available
-            if (sessionId.length === 0 && c4.sessionCache) {
-                session = c4.sessionCache.getSession();
+            if (sessionId.length === 0 && c.sessionCache) {
+                session = c.sessionCache.getSession();
                 if (session !== null) sessionId = session.id;
             }
             // set up session
-            c4.session = {
+            c.session = {
                 id: sessionId,
                 version: null,
                 cipherSuite: null,
@@ -24291,19 +24385,19 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
             // use existing session information
             if (session) {
                 // only update version on connection, session version not yet set
-                c4.version = session.version;
-                c4.session.sp = session.sp;
+                c.version = session.version;
+                c.session.sp = session.sp;
             }
             // generate new client random
-            c4.session.sp.client_random = $e55982d45da68b81$var$tls.createRandom().getBytes();
+            c.session.sp.client_random = $e55982d45da68b81$var$tls.createRandom().getBytes();
             // connection now open
-            c4.open = true;
+            c.open = true;
             // send hello
-            $e55982d45da68b81$var$tls.queue(c4, $e55982d45da68b81$var$tls.createRecord(c4, {
+            $e55982d45da68b81$var$tls.queue(c, $e55982d45da68b81$var$tls.createRecord(c, {
                 type: $e55982d45da68b81$var$tls.ContentType.handshake,
-                data: $e55982d45da68b81$var$tls.createClientHello(c4)
+                data: $e55982d45da68b81$var$tls.createClientHello(c)
             }));
-            $e55982d45da68b81$var$tls.flush(c4);
+            $e55982d45da68b81$var$tls.flush(c);
         }
     };
     /**
@@ -24314,21 +24408,21 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
    *
    * @return 0 if the data could be processed, otherwise the number of bytes
    *         required for data to be processed.
-   */ c4.process = function(data) {
+   */ c.process = function(data) {
         var rval = 0;
         // buffer input data
-        if (data) c4.input.putBytes(data);
+        if (data) c.input.putBytes(data);
         // process next record if no failure, process will be called after
         // each record is handled (since handling can be asynchronous)
-        if (!c4.fail) {
+        if (!c.fail) {
             // reset record if ready and now empty
-            if (c4.record !== null && c4.record.ready && c4.record.fragment.isEmpty()) c4.record = null;
+            if (c.record !== null && c.record.ready && c.record.fragment.isEmpty()) c.record = null;
             // if there is no pending record, try to read record header
-            if (c4.record === null) rval = _readRecordHeader(c4);
+            if (c.record === null) rval = _readRecordHeader(c);
             // read the next record (if record not yet ready)
-            if (!c4.fail && c4.record !== null && !c4.record.ready) rval = _readRecord(c4);
+            if (!c.fail && c.record !== null && !c.record.ready) rval = _readRecord(c);
             // record ready to be handled, update engine state
-            if (!c4.fail && c4.record !== null && c4.record.ready) _update(c4, c4.record);
+            if (!c.fail && c.record !== null && c.record.ready) _update(c, c.record);
         }
         return rval;
     };
@@ -24342,12 +24436,12 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
    *          of util.encodeUtf8(str).
    *
    * @return true on success, false on failure.
-   */ c4.prepare = function(data) {
-        $e55982d45da68b81$var$tls.queue(c4, $e55982d45da68b81$var$tls.createRecord(c4, {
+   */ c.prepare = function(data) {
+        $e55982d45da68b81$var$tls.queue(c, $e55982d45da68b81$var$tls.createRecord(c, {
             type: $e55982d45da68b81$var$tls.ContentType.application_data,
             data: $iGlOy.util.createBuffer(data)
         }));
-        return $e55982d45da68b81$var$tls.flush(c4);
+        return $e55982d45da68b81$var$tls.flush(c);
     };
     /**
    * Requests that a heartbeat request be packaged into a TLS record for
@@ -24363,53 +24457,53 @@ $e55982d45da68b81$var$hsTable[$e55982d45da68b81$var$tls.ConnectionEnd.server] =
    *          actual payload length.
    *
    * @return true on success, false on failure.
-   */ c4.prepareHeartbeatRequest = function(payload, payloadLength) {
+   */ c.prepareHeartbeatRequest = function(payload, payloadLength) {
         if (payload instanceof $iGlOy.util.ByteBuffer) payload = payload.bytes();
         if (typeof payloadLength === "undefined") payloadLength = payload.length;
-        c4.expectedHeartbeatPayload = payload;
-        $e55982d45da68b81$var$tls.queue(c4, $e55982d45da68b81$var$tls.createRecord(c4, {
+        c.expectedHeartbeatPayload = payload;
+        $e55982d45da68b81$var$tls.queue(c, $e55982d45da68b81$var$tls.createRecord(c, {
             type: $e55982d45da68b81$var$tls.ContentType.heartbeat,
             data: $e55982d45da68b81$var$tls.createHeartbeat($e55982d45da68b81$var$tls.HeartbeatMessageType.heartbeat_request, payload, payloadLength)
         }));
-        return $e55982d45da68b81$var$tls.flush(c4);
+        return $e55982d45da68b81$var$tls.flush(c);
     };
     /**
    * Closes the connection (sends a close_notify alert).
    *
    * @param clearFail true to clear the fail flag (default: true).
-   */ c4.close = function(clearFail) {
+   */ c.close = function(clearFail) {
         // save session if connection didn't fail
-        if (!c4.fail && c4.sessionCache && c4.session) {
+        if (!c.fail && c.sessionCache && c.session) {
             // only need to preserve session ID, version, and security params
             var session = {
-                id: c4.session.id,
-                version: c4.session.version,
-                sp: c4.session.sp
+                id: c.session.id,
+                version: c.session.version,
+                sp: c.session.sp
             };
             session.sp.keys = null;
-            c4.sessionCache.setSession(session.id, session);
+            c.sessionCache.setSession(session.id, session);
         }
-        if (c4.open) {
+        if (c.open) {
             // connection no longer open, clear input
-            c4.open = false;
-            c4.input.clear();
+            c.open = false;
+            c.input.clear();
             // if connected or handshaking, send an alert
-            if (c4.isConnected || c4.handshaking) {
-                c4.isConnected = c4.handshaking = false;
+            if (c.isConnected || c.handshaking) {
+                c.isConnected = c.handshaking = false;
                 // send close_notify alert
-                $e55982d45da68b81$var$tls.queue(c4, $e55982d45da68b81$var$tls.createAlert(c4, {
+                $e55982d45da68b81$var$tls.queue(c, $e55982d45da68b81$var$tls.createAlert(c, {
                     level: $e55982d45da68b81$var$tls.Alert.Level.warning,
                     description: $e55982d45da68b81$var$tls.Alert.Description.close_notify
                 }));
-                $e55982d45da68b81$var$tls.flush(c4);
+                $e55982d45da68b81$var$tls.flush(c);
             }
             // call handler
-            c4.closed(c4);
+            c.closed(c);
         }
         // reset TLS connection, do not clear fail flag
-        c4.reset(clearFail);
+        c.reset(clearFail);
     };
-    return c4;
+    return c;
 };
 /* TLS API */ $e55982d45da68b81$exports = $iGlOy.tls = $iGlOy.tls || {};
 // expose non-functions
@@ -26873,15 +26967,15 @@ for(var $4b898e145571f67c$var$i = 0; $4b898e145571f67c$var$i < $iGlOy.log.levels
  * @param message message object
  */ $iGlOy.log.logMessage = function(message) {
     var messageLevelIndex = $4b898e145571f67c$var$sLevelInfo[message.level].index;
-    for(var i1 = 0; i1 < $4b898e145571f67c$var$sLoggers.length; ++i1){
-        var logger1 = $4b898e145571f67c$var$sLoggers[i1];
-        if (logger1.flags & $iGlOy.log.NO_LEVEL_CHECK) logger1.f(message);
+    for(var i = 0; i < $4b898e145571f67c$var$sLoggers.length; ++i){
+        var logger = $4b898e145571f67c$var$sLoggers[i];
+        if (logger.flags & $iGlOy.log.NO_LEVEL_CHECK) logger.f(message);
         else {
             // get logger level
-            var loggerLevelIndex = $4b898e145571f67c$var$sLevelInfo[logger1.level].index;
+            var loggerLevelIndex = $4b898e145571f67c$var$sLevelInfo[logger.level].index;
             // check level
             if (messageLevelIndex <= loggerLevelIndex) // message critical enough, call logger
-            logger1.f(logger1, message);
+            logger.f(logger, message);
         }
     }
 };
@@ -26967,12 +27061,12 @@ for(var $4b898e145571f67c$var$i = 0; $4b898e145571f67c$var$i < $4b898e145571f67c
  *
  * @return a logger object.
  */ $iGlOy.log.makeLogger = function(logFunction) {
-    var logger2 = {
+    var logger = {
         flags: 0,
         f: logFunction
     };
-    $iGlOy.log.setLevel(logger2, "none");
-    return logger2;
+    $iGlOy.log.setLevel(logger, "none");
+    return logger;
 };
 /**
  * Sets the current log level on a logger.
@@ -26981,13 +27075,13 @@ for(var $4b898e145571f67c$var$i = 0; $4b898e145571f67c$var$i < $4b898e145571f67c
  * @param level the new maximum log level as a string.
  *
  * @return true if set, false if not.
- */ $iGlOy.log.setLevel = function(logger3, level) {
+ */ $iGlOy.log.setLevel = function(logger, level) {
     var rval = false;
-    if (logger3 && !(logger3.flags & $iGlOy.log.LEVEL_LOCKED)) for(var i2 = 0; i2 < $iGlOy.log.levels.length; ++i2){
-        var aValidLevel = $iGlOy.log.levels[i2];
+    if (logger && !(logger.flags & $iGlOy.log.LEVEL_LOCKED)) for(var i = 0; i < $iGlOy.log.levels.length; ++i){
+        var aValidLevel = $iGlOy.log.levels[i];
         if (level == aValidLevel) {
             // set level
-            logger3.level = level;
+            logger.level = level;
             rval = true;
             break;
         }
@@ -26999,16 +27093,16 @@ for(var $4b898e145571f67c$var$i = 0; $4b898e145571f67c$var$i < $4b898e145571f67c
  *
  * @param logger the target logger.
  * @param lock boolean lock value, default to true.
- */ $iGlOy.log.lock = function(logger4, lock1) {
-    if (typeof lock1 === "undefined" || lock1) logger4.flags |= $iGlOy.log.LEVEL_LOCKED;
-    else logger4.flags &= ~$iGlOy.log.LEVEL_LOCKED;
+ */ $iGlOy.log.lock = function(logger, lock) {
+    if (typeof lock === "undefined" || lock) logger.flags |= $iGlOy.log.LEVEL_LOCKED;
+    else logger.flags &= ~$iGlOy.log.LEVEL_LOCKED;
 };
 /**
  * Adds a logger.
  *
  * @param logger the logger object.
- */ $iGlOy.log.addLogger = function(logger5) {
-    $4b898e145571f67c$var$sLoggers.push(logger5);
+ */ $iGlOy.log.addLogger = function(logger) {
+    $4b898e145571f67c$var$sLoggers.push(logger);
 };
 // setup the console logger if possible, else create fake console.log
 if (typeof console !== "undefined" && "log" in console) {
@@ -28633,7 +28727,7 @@ $d0a07df29ef1b0fa$export$a287f47fed4544b8 = (num)=>{
     if (typeof num === "string" && num.trim() !== "") return Number.isInteger(Number(num));
     return false;
 };
-$d0a07df29ef1b0fa$export$71aa6c912b956294 = (node1, type)=>node1.nodes.find((node)=>node.type === type);
+$d0a07df29ef1b0fa$export$71aa6c912b956294 = (node, type)=>node.nodes.find((node)=>node.type === type);
 $d0a07df29ef1b0fa$export$fbadac39f36b1e16 = (min, max, step = 1, limit)=>{
     if (limit === false) return false;
     if (!$d0a07df29ef1b0fa$export$a287f47fed4544b8(min) || !$d0a07df29ef1b0fa$export$a287f47fed4544b8(max)) return false;
@@ -28858,20 +28952,20 @@ function $07628d57aabb0c0b$var$splitToPatterns(min, max, tok, options) {
     let start = min;
     let prev;
     for(let i = 0; i < ranges.length; i++){
-        let max = ranges[i];
-        let obj = $07628d57aabb0c0b$var$rangeToPattern(String(start), String(max), options);
+        let max1 = ranges[i];
+        let obj = $07628d57aabb0c0b$var$rangeToPattern(String(start), String(max1), options);
         let zeros = "";
         if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
             if (prev.count.length > 1) prev.count.pop();
             prev.count.push(obj.count[0]);
             prev.string = prev.pattern + $07628d57aabb0c0b$var$toQuantifier(prev.count);
-            start = max + 1;
+            start = max1 + 1;
             continue;
         }
-        if (tok.isPadded) zeros = $07628d57aabb0c0b$var$padZeros(max, tok, options);
+        if (tok.isPadded) zeros = $07628d57aabb0c0b$var$padZeros(max1, tok, options);
         obj.string = zeros + obj.pattern + $07628d57aabb0c0b$var$toQuantifier(obj.count);
         tokens.push(obj);
-        start = max + 1;
+        start = max1 + 1;
         prev = obj;
     }
     return tokens;
@@ -29425,18 +29519,18 @@ var $88c0a7901dd4a8c2$require$CHAR_ZERO_WIDTH_NOBREAK_SPACE = $f1bb1ac16e435177$
      * Quotes: '|"|`
      */ if (value === $88c0a7901dd4a8c2$require$CHAR_DOUBLE_QUOTE || value === $88c0a7901dd4a8c2$require$CHAR_SINGLE_QUOTE || value === $88c0a7901dd4a8c2$require$CHAR_BACKTICK) {
             let open = value;
-            let next;
+            let next1;
             if (options.keepQuotes !== true) value = "";
-            while(index < length && (next = advance())){
-                if (next === $88c0a7901dd4a8c2$require$CHAR_BACKSLASH) {
-                    value += next + advance();
+            while(index < length && (next1 = advance())){
+                if (next1 === $88c0a7901dd4a8c2$require$CHAR_BACKSLASH) {
+                    value += next1 + advance();
                     continue;
                 }
-                if (next === open) {
-                    if (options.keepQuotes === true) value += next;
+                if (next1 === open) {
+                    if (options.keepQuotes === true) value += next1;
                     break;
                 }
-                value += next;
+                value += next1;
             }
             push({
                 type: "text",
@@ -29493,9 +29587,9 @@ var $88c0a7901dd4a8c2$require$CHAR_ZERO_WIDTH_NOBREAK_SPACE = $f1bb1ac16e435177$
      */ if (value === $88c0a7901dd4a8c2$require$CHAR_COMMA && depth > 0) {
             if (block.ranges > 0) {
                 block.ranges = 0;
-                let open = block.nodes.shift();
+                let open1 = block.nodes.shift();
                 block.nodes = [
-                    open,
+                    open1,
                     {
                         type: "text",
                         value: $156a1a36db86ccbd$exports(block)
@@ -29569,9 +29663,9 @@ var $88c0a7901dd4a8c2$require$CHAR_ZERO_WIDTH_NOBREAK_SPACE = $f1bb1ac16e435177$
             });
             // get the location of the block on parent.nodes (block's siblings)
             let parent = stack[stack.length - 1];
-            let index = parent.nodes.indexOf(block);
+            let index1 = parent.nodes.indexOf(block);
             // replace the (invalid) block with it's nodes
-            parent.nodes.splice(index, 1, ...block.nodes);
+            parent.nodes.splice(index1, 1, ...block.nodes);
         }
     }while (stack.length > 0);
     push({
@@ -31733,13 +31827,13 @@ function $b57e78be4f7a2622$var$FastGlob(source, options) {
 }
 // https://github.com/typescript-eslint/typescript-eslint/issues/60
 // eslint-disable-next-line no-redeclare
-(function(FastGlob1) {
+(function(FastGlob) {
     function sync(source, options) {
         $b57e78be4f7a2622$var$assertPatternsInput(source);
         const works = $b57e78be4f7a2622$var$getWorks(source, $449ae2813b11b2d5$exports.default, options);
         return $1b5b082adfcf5f99$exports.array.flatten(works);
     }
-    FastGlob1.sync = sync;
+    FastGlob.sync = sync;
     function stream(source, options) {
         $b57e78be4f7a2622$var$assertPatternsInput(source);
         const works = $b57e78be4f7a2622$var$getWorks(source, $434410c8b70ca432$exports.default, options);
@@ -31749,25 +31843,25 @@ function $b57e78be4f7a2622$var$FastGlob(source, options) {
          * This affects performance (+25%). I don't see best solution right now.
          */ return $1b5b082adfcf5f99$exports.stream.merge(works);
     }
-    FastGlob1.stream = stream;
+    FastGlob.stream = stream;
     function generateTasks(source, options) {
         $b57e78be4f7a2622$var$assertPatternsInput(source);
         const patterns = [].concat(source);
         const settings = new $1d7e3dfd05c8321e$exports.default(options);
         return $d436392a45e5b9b4$exports.generate(patterns, settings);
     }
-    FastGlob1.generateTasks = generateTasks;
+    FastGlob.generateTasks = generateTasks;
     function isDynamicPattern(source, options) {
         $b57e78be4f7a2622$var$assertPatternsInput(source);
         const settings = new $1d7e3dfd05c8321e$exports.default(options);
         return $1b5b082adfcf5f99$exports.pattern.isDynamicPattern(source, settings);
     }
-    FastGlob1.isDynamicPattern = isDynamicPattern;
+    FastGlob.isDynamicPattern = isDynamicPattern;
     function escapePath(source) {
         $b57e78be4f7a2622$var$assertPatternsInput(source);
         return $1b5b082adfcf5f99$exports.path.escape(source);
     }
-    FastGlob1.escapePath = escapePath;
+    FastGlob.escapePath = escapePath;
 })($b57e78be4f7a2622$var$FastGlob || ($b57e78be4f7a2622$var$FastGlob = {}));
 function $b57e78be4f7a2622$var$getWorks(source, _Provider, options) {
     const patterns = [].concat(source);
@@ -31810,14 +31904,14 @@ function $3dff16cfd200ff25$export$7413eea5ad243d4(from, to, leadingDotSlash = tr
 function $e8d0e504a4244d84$export$f3a2344a73dbdd42(p) {
     return (0, (/*@__PURE__*/$parcel$interopDefault($5aee5a8e09e874bf$exports)))((0, $3dff16cfd200ff25$export$16778b798ae8e49d)(p));
 }
-function $e8d0e504a4244d84$export$16e6d319a883f04e(filePath, glob1, opts) {
-    glob1 = Array.isArray(glob1) ? glob1.map((0, $3dff16cfd200ff25$export$16778b798ae8e49d)) : (0, $3dff16cfd200ff25$export$16778b798ae8e49d)(glob1);
-    return (0, $fec3b4fc54d3756a$exports.isMatch)(filePath, glob1, opts);
+function $e8d0e504a4244d84$export$16e6d319a883f04e(filePath, glob, opts) {
+    glob = Array.isArray(glob) ? glob.map((0, $3dff16cfd200ff25$export$16778b798ae8e49d)) : (0, $3dff16cfd200ff25$export$16778b798ae8e49d)(glob);
+    return (0, $fec3b4fc54d3756a$exports.isMatch)(filePath, glob, opts);
 }
-function $e8d0e504a4244d84$export$c0436a5422df81e4(glob2, opts) {
-    return (0, $fec3b4fc54d3756a$exports.makeRe)(glob2, opts);
+function $e8d0e504a4244d84$export$c0436a5422df81e4(glob, opts) {
+    return (0, $fec3b4fc54d3756a$exports.makeRe)(glob, opts);
 }
-function $e8d0e504a4244d84$export$42275ba87174c828(p1, fs, options) {
+function $e8d0e504a4244d84$export$42275ba87174c828(p, fs, options) {
     // $FlowFixMe
     options = {
         ...options,
@@ -31835,9 +31929,9 @@ function $e8d0e504a4244d84$export$42275ba87174c828(p1, fs, options) {
             }
         }
     }; // $FlowFixMe
-    return (0, (/*@__PURE__*/$parcel$interopDefault($b57e78be4f7a2622$exports))).sync((0, $3dff16cfd200ff25$export$16778b798ae8e49d)(p1), options);
+    return (0, (/*@__PURE__*/$parcel$interopDefault($b57e78be4f7a2622$exports))).sync((0, $3dff16cfd200ff25$export$16778b798ae8e49d)(p), options);
 }
-function $e8d0e504a4244d84$export$442f1a04865e4790(p2, fs, options) {
+function $e8d0e504a4244d84$export$442f1a04865e4790(p, fs, options) {
     // $FlowFixMe
     options = {
         ...options,
@@ -31871,7 +31965,7 @@ function $e8d0e504a4244d84$export$442f1a04865e4790(p2, fs, options) {
             }
         }
     }; // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
-    return (0, (/*@__PURE__*/$parcel$interopDefault($b57e78be4f7a2622$exports)))((0, $3dff16cfd200ff25$export$16778b798ae8e49d)(p2), options);
+    return (0, (/*@__PURE__*/$parcel$interopDefault($b57e78be4f7a2622$exports)))((0, $3dff16cfd200ff25$export$16778b798ae8e49d)(p), options);
 }
 
 
@@ -32201,8 +32295,8 @@ function $007fe08032bb1964$var$supportsHyperlink(stream) {
     if ("VTE_VERSION" in env) {
         // 0.50.0 was supposed to support hyperlinks, but throws a segfault
         if (env.VTE_VERSION === "0.50.0") return false;
-        const version = $007fe08032bb1964$var$parseVersion(env.VTE_VERSION);
-        return version.major > 0 || version.minor >= 50;
+        const version1 = $007fe08032bb1964$var$parseVersion(env.VTE_VERSION);
+        return version1.major > 0 || version1.minor >= 50;
     }
     return false;
 }
@@ -32420,46 +32514,46 @@ const $f48e6c7a66080865$var$myers_x = (b, a)=>{
         while(k--)$f48e6c7a66080865$var$peq[a.charCodeAt(k)] = 0;
         for(k = start; k < start + vlen; k++)$f48e6c7a66080865$var$peq[b.charCodeAt(k)] |= 1 << k;
         score = m;
-        for(let i = 0; i < n; i++){
-            const eq = $f48e6c7a66080865$var$peq[a.charCodeAt(i)];
-            const pb = phc[i / 32 | 0] >>> i % 32 & 1;
-            const mb = mhc[i / 32 | 0] >>> i % 32 & 1;
+        for(let i1 = 0; i1 < n; i1++){
+            const eq = $f48e6c7a66080865$var$peq[a.charCodeAt(i1)];
+            const pb = phc[i1 / 32 | 0] >>> i1 % 32 & 1;
+            const mb = mhc[i1 / 32 | 0] >>> i1 % 32 & 1;
             const xv = eq | mv;
             const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
             let ph = mv | ~(xh | pv);
             let mh = pv & xh;
-            if (ph >>> 31 ^ pb) phc[i / 32 | 0] ^= 1 << i % 32;
-            if (mh >>> 31 ^ mb) mhc[i / 32 | 0] ^= 1 << i % 32;
+            if (ph >>> 31 ^ pb) phc[i1 / 32 | 0] ^= 1 << i1 % 32;
+            if (mh >>> 31 ^ mb) mhc[i1 / 32 | 0] ^= 1 << i1 % 32;
             ph = ph << 1 | pb;
             mh = mh << 1 | mb;
             pv = mh | ~(xv | ph);
             mv = ph & xv;
         }
     }
-    let mv = 0;
-    let pv = -1;
-    const start = j * 32;
-    const vlen = Math.min(32, m - start);
-    let k = n;
-    while(k--)$f48e6c7a66080865$var$peq[a.charCodeAt(k)] = 0;
-    for(k = start; k < start + vlen; k++)$f48e6c7a66080865$var$peq[b.charCodeAt(k)] |= 1 << k;
+    let mv1 = 0;
+    let pv1 = -1;
+    const start1 = j * 32;
+    const vlen1 = Math.min(32, m - start1);
+    let k1 = n;
+    while(k1--)$f48e6c7a66080865$var$peq[a.charCodeAt(k1)] = 0;
+    for(k1 = start1; k1 < start1 + vlen1; k1++)$f48e6c7a66080865$var$peq[b.charCodeAt(k1)] |= 1 << k1;
     score = m;
-    for(let i1 = 0; i1 < n; i1++){
-        const eq = $f48e6c7a66080865$var$peq[a.charCodeAt(i1)];
-        const pb = phc[i1 / 32 | 0] >>> i1 % 32 & 1;
-        const mb = mhc[i1 / 32 | 0] >>> i1 % 32 & 1;
-        const xv = eq | mv;
-        const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
-        let ph = mv | ~(xh | pv);
-        let mh = pv & xh;
-        score += ph >>> m % 32 - 1 & 1;
-        score -= mh >>> m % 32 - 1 & 1;
-        if (ph >>> 31 ^ pb) phc[i1 / 32 | 0] ^= 1 << i1 % 32;
-        if (mh >>> 31 ^ mb) mhc[i1 / 32 | 0] ^= 1 << i1 % 32;
-        ph = ph << 1 | pb;
-        mh = mh << 1 | mb;
-        pv = mh | ~(xv | ph);
-        mv = ph & xv;
+    for(let i2 = 0; i2 < n; i2++){
+        const eq1 = $f48e6c7a66080865$var$peq[a.charCodeAt(i2)];
+        const pb1 = phc[i2 / 32 | 0] >>> i2 % 32 & 1;
+        const mb1 = mhc[i2 / 32 | 0] >>> i2 % 32 & 1;
+        const xv1 = eq1 | mv1;
+        const xh1 = ((eq1 | mb1) & pv1) + pv1 ^ pv1 | eq1 | mb1;
+        let ph1 = mv1 | ~(xh1 | pv1);
+        let mh1 = pv1 & xh1;
+        score += ph1 >>> m % 32 - 1 & 1;
+        score -= mh1 >>> m % 32 - 1 & 1;
+        if (ph1 >>> 31 ^ pb1) phc[i2 / 32 | 0] ^= 1 << i2 % 32;
+        if (mh1 >>> 31 ^ mb1) mhc[i2 / 32 | 0] ^= 1 << i2 % 32;
+        ph1 = ph1 << 1 | pb1;
+        mh1 = mh1 << 1 | mb1;
+        pv1 = mh1 | ~(xv1 | ph1);
+        mv1 = ph1 & xv1;
     }
     return score;
 };
@@ -32544,14 +32638,14 @@ function $4ca1027d34905147$var$validateSchema(schema, data) {
                 case "number":
                     {
                         // $FlowFixMe type was already checked
-                        let value = dataNode;
+                        let value1 = dataNode;
                         if (schemaNode.enum) {
-                            if (!schemaNode.enum.includes(value)) return {
+                            if (!schemaNode.enum.includes(value1)) return {
                                 type: "enum",
                                 dataType: "value",
                                 dataPath: dataPath,
                                 expectedValues: schemaNode.enum,
-                                actualValue: value,
+                                actualValue: value1,
                                 ancestors: schemaAncestors
                             };
                         }
@@ -32559,13 +32653,13 @@ function $4ca1027d34905147$var$validateSchema(schema, data) {
                     }
                 case "object":
                     {
-                        let results = [];
+                        let results1 = [];
                         let invalidProps;
                         if (schemaNode.__forbiddenProperties) {
                             // $FlowFixMe type was already checked
                             let keys = Object.keys(dataNode);
                             invalidProps = schemaNode.__forbiddenProperties.filter((val)=>keys.includes(val));
-                            results.push(...invalidProps.map((k)=>({
+                            results1.push(...invalidProps.map((k)=>({
                                     type: "forbidden-prop",
                                     dataPath: dataPath + "/" + (0, $8C1kk$parceldiagnostic.encodeJSONKeyComponent)(k),
                                     dataType: "key",
@@ -32577,15 +32671,15 @@ function $4ca1027d34905147$var$validateSchema(schema, data) {
                         }
                         if (schemaNode.required) {
                             // $FlowFixMe type was already checked
-                            let keys = Object.keys(dataNode);
-                            let missingKeys = schemaNode.required.filter((val)=>!keys.includes(val));
-                            results.push(...missingKeys.map((k)=>({
+                            let keys1 = Object.keys(dataNode);
+                            let missingKeys = schemaNode.required.filter((val)=>!keys1.includes(val));
+                            results1.push(...missingKeys.map((k)=>({
                                     type: "missing-prop",
                                     dataPath: dataPath,
                                     dataType: "value",
                                     prop: k,
                                     expectedProps: schemaNode.required,
-                                    actualProps: keys,
+                                    actualProps: keys1,
                                     ancestors: schemaAncestors
                                 })));
                         }
@@ -32594,13 +32688,13 @@ function $4ca1027d34905147$var$validateSchema(schema, data) {
                             for(let k in dataNode){
                                 if (invalidProps && invalidProps.includes(k)) continue;
                                 else if (k in schemaNode.properties) {
-                                    let result = walk([
+                                    let result1 = walk([
                                         schemaNode.properties[k]
                                     ].concat(schemaAncestors), dataNode[k], dataPath + "/" + (0, $8C1kk$parceldiagnostic.encodeJSONKeyComponent)(k));
-                                    if (result) results.push(result);
+                                    if (result1) results1.push(result1);
                                 } else {
                                     if (typeof additionalProperties === "boolean") {
-                                        if (!additionalProperties) results.push({
+                                        if (!additionalProperties) results1.push({
                                             type: "enum",
                                             dataType: "key",
                                             dataPath: dataPath + "/" + (0, $8C1kk$parceldiagnostic.encodeJSONKeyComponent)(k),
@@ -32610,15 +32704,15 @@ function $4ca1027d34905147$var$validateSchema(schema, data) {
                                             prettyType: schemaNode.__type
                                         });
                                     } else {
-                                        let result = walk([
+                                        let result2 = walk([
                                             additionalProperties
                                         ].concat(schemaAncestors), dataNode[k], dataPath + "/" + (0, $8C1kk$parceldiagnostic.encodeJSONKeyComponent)(k));
-                                        if (result) results.push(result);
+                                        if (result2) results1.push(result2);
                                     }
                                 }
                             }
                         }
-                        if (results.length) return results.reduce((acc, v)=>acc.concat(v), []);
+                        if (results1.length) return results1.reduce((acc, v)=>acc.concat(v), []);
                         break;
                     }
                 case "boolean":
@@ -32637,23 +32731,23 @@ function $4ca1027d34905147$var$validateSchema(schema, data) {
             };
             if (schemaNode.oneOf || schemaNode.allOf) {
                 let list = schemaNode.oneOf || schemaNode.allOf;
-                let results = [];
+                let results2 = [];
                 for (let f of list){
-                    let result = walk([
+                    let result3 = walk([
                         f
                     ].concat(schemaAncestors), dataNode, dataPath);
-                    if (result) results.push(result);
+                    if (result3) results2.push(result3);
                 }
-                if (schemaNode.oneOf ? results.length == schemaNode.oneOf.length : results.length > 0) {
+                if (schemaNode.oneOf ? results2.length == schemaNode.oneOf.length : results2.length > 0) {
                     // return the result with more values / longer key
-                    results.sort((a, b)=>Array.isArray(a) || Array.isArray(b) ? Array.isArray(a) && !Array.isArray(b) ? -1 : !Array.isArray(a) && Array.isArray(b) ? 1 : Array.isArray(a) && Array.isArray(b) ? b.length - a.length : 0 : b.dataPath.length - a.dataPath.length);
-                    return results[0];
+                    results2.sort((a, b)=>Array.isArray(a) || Array.isArray(b) ? Array.isArray(a) && !Array.isArray(b) ? -1 : !Array.isArray(a) && Array.isArray(b) ? 1 : Array.isArray(a) && Array.isArray(b) ? b.length - a.length : 0 : b.dataPath.length - a.dataPath.length);
+                    return results2[0];
                 }
             } else if (schemaNode.not) {
-                let result = walk([
+                let result4 = walk([
                     schemaNode.not
                 ].concat(schemaAncestors), dataNode, dataPath);
-                if (!result || result.length == 0) return {
+                if (!result4 || result4.length == 0) return {
                     type: "other",
                     dataPath: dataPath,
                     dataType: null,
@@ -32665,11 +32759,11 @@ function $4ca1027d34905147$var$validateSchema(schema, data) {
         }
         return undefined;
     }
-    let result1 = walk([
+    let result = walk([
         schema
     ], data, "");
-    return Array.isArray(result1) ? result1 : result1 ? [
-        result1
+    return Array.isArray(result) ? result : result ? [
+        result
     ] : [];
 }
 var $4ca1027d34905147$export$2e2bcd8739ae039 = $4ca1027d34905147$var$validateSchema;
@@ -32681,7 +32775,7 @@ function $4ca1027d34905147$export$2115c2c0a84eef61(expectedValues, actualValue)
     result.sort(([, a], [, b])=>a - b);
     return result.map(([v])=>v);
 }
-$4ca1027d34905147$var$validateSchema.diagnostic = function(schema, data, origin, message1) {
+$4ca1027d34905147$var$validateSchema.diagnostic = function(schema, data, origin, message) {
     if ("source" in data && "data" in data && typeof data.source !== "string" && !data) throw new Error("At least one of data.source and data.data must be defined!");
     var _data;
     let object = data.map ? data.map.data : (_data = data.data) !== null && _data !== void 0 ? _data : JSON.parse(data.source);
@@ -32698,17 +32792,17 @@ $4ca1027d34905147$var$validateSchema.diagnostic = function(schema, data, origin,
                 else message = "Unexpected value";
             } else if (e.type === "forbidden-prop") {
                 let { prop: prop , expectedProps: expectedProps , actualProps: actualProps  } = e;
-                let likely = $4ca1027d34905147$export$2115c2c0a84eef61(expectedProps, prop).filter((v)=>!actualProps.includes(v));
-                if (likely.length > 0) message = `Did you mean ${likely.map((v)=>JSON.stringify(v)).join(", ")}?`;
+                let likely1 = $4ca1027d34905147$export$2115c2c0a84eef61(expectedProps, prop).filter((v)=>!actualProps.includes(v));
+                if (likely1.length > 0) message = `Did you mean ${likely1.map((v)=>JSON.stringify(v)).join(", ")}?`;
                 else message = "Unexpected property";
             } else if (e.type === "missing-prop") {
-                let { prop: prop , actualProps: actualProps  } = e;
-                let likely = $4ca1027d34905147$export$2115c2c0a84eef61(actualProps, prop);
-                if (likely.length > 0) {
-                    message = `Did you mean ${JSON.stringify(prop)}?`;
-                    e.dataPath += "/" + likely[0];
+                let { prop: prop1 , actualProps: actualProps1  } = e;
+                let likely2 = $4ca1027d34905147$export$2115c2c0a84eef61(actualProps1, prop1);
+                if (likely2.length > 0) {
+                    message = `Did you mean ${JSON.stringify(prop1)}?`;
+                    e.dataPath += "/" + likely2[0];
                     e.dataType = "key";
-                } else message = `Missing property ${prop}`;
+                } else message = `Missing property ${prop1}`;
             } else if (e.type === "type") {
                 if (e.prettyType != null) message = `Expected ${e.prettyType}`;
                 else message = `Expected type ${e.expectedTypes.join(", ")}`;
@@ -32744,7 +32838,7 @@ $4ca1027d34905147$var$validateSchema.diagnostic = function(schema, data, origin,
         ];
         throw new (0, ($parcel$interopDefault($8C1kk$parceldiagnostic)))({
             diagnostic: {
-                message: message1,
+                message: message,
                 origin: origin,
                 codeFrames: codeFrames
             }
@@ -32833,7 +32927,7 @@ function $e499d3e618e93ebd$export$2e2bcd8739ae039(fn, delay) {
 var $618f8c1de80a427f$exports = {};
 "use strict";
 
-var $618f8c1de80a427f$var$__dirname1 = $8C1kk$path.resolve(__dirname, "../../../../node_modules/open");
+var $618f8c1de80a427f$var$$parcel$__dirname = $8C1kk$path.resolve(__dirname, "../../../../node_modules/open");
 
 var $618f8c1de80a427f$require$promisify = $8C1kk$util.promisify;
 
@@ -32888,13 +32982,13 @@ else $544c5203b18a57d8$exports = $544c5203b18a57d8$var$isWsl();
 const $618f8c1de80a427f$var$pAccess = $618f8c1de80a427f$require$promisify($8C1kk$fs.access);
 const $618f8c1de80a427f$var$pExecFile = $618f8c1de80a427f$require$promisify($8C1kk$child_process.execFile);
 // Path to included `xdg-open`.
-const $618f8c1de80a427f$var$localXdgOpenPath = $8C1kk$path.join($618f8c1de80a427f$var$__dirname1, "xdg-open");
+const $618f8c1de80a427f$var$localXdgOpenPath = $8C1kk$path.join($618f8c1de80a427f$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 $618f8c1de80a427f$var$wslToWindowsPath = async (path1)=>{
+const $618f8c1de80a427f$var$wslToWindowsPath = async (path)=>{
     const { stdout: stdout  } = await $618f8c1de80a427f$var$pExecFile("wslpath", [
         "-w",
-        path1
+        path
     ]);
     return stdout.trim();
 };
@@ -32955,7 +33049,7 @@ $618f8c1de80a427f$exports = async (target, options)=>{
         if (options.app) command = options.app;
         else {
             // When bundled by Webpack, there's no actual package file path and no local `xdg-open`.
-            const isBundled = !$618f8c1de80a427f$var$__dirname1 || $618f8c1de80a427f$var$__dirname1 === "/";
+            const isBundled = !$618f8c1de80a427f$var$$parcel$__dirname || $618f8c1de80a427f$var$$parcel$__dirname === "/";
             // Check if local `xdg-open` exists and is executable.
             let exeLocalXdgOpen = false;
             try {
@@ -33093,9 +33187,9 @@ var $284aeb9e515b63c0$var$clone = function() {
  * @param `includeNonEnumerable` - set to true if the non-enumerable properties
  *    should be cloned as well. Non-enumerable properties on the prototype
  *    chain will be ignored. (optional - false by default)
-*/ function clone1(parent1, circular, depth1, prototype, includeNonEnumerable) {
+*/ function clone(parent, circular, depth, prototype, includeNonEnumerable) {
         if (typeof circular === "object") {
-            depth1 = circular.depth;
+            depth = circular.depth;
             prototype = circular.prototype;
             includeNonEnumerable = circular.includeNonEnumerable;
             circular = circular.circular;
@@ -33106,7 +33200,7 @@ var $284aeb9e515b63c0$var$clone = function() {
         var allChildren = [];
         var useBuffer = typeof Buffer != "undefined";
         if (typeof circular == "undefined") circular = true;
-        if (typeof depth1 == "undefined") depth1 = Infinity;
+        if (typeof depth == "undefined") depth = Infinity;
         // recurse this function so we don't reset allParents and allChildren
         function _clone(parent, depth) {
             // cloning null always returns null
@@ -33124,11 +33218,11 @@ var $284aeb9e515b63c0$var$clone = function() {
                     reject(_clone(err, depth - 1));
                 });
             });
-            else if (clone1.__isArray(parent)) child = [];
-            else if (clone1.__isRegExp(parent)) {
+            else if (clone.__isArray(parent)) child = [];
+            else if (clone.__isRegExp(parent)) {
                 child = new RegExp(parent.source, __getRegExpFlags(parent));
                 if (parent.lastIndex) child.lastIndex = parent.lastIndex;
-            } else if (clone1.__isDate(parent)) child = new Date(parent.getTime());
+            } else if (clone.__isDate(parent)) child = new Date(parent.getTime());
             else if (useBuffer && Buffer.isBuffer(parent)) {
                 if (Buffer.allocUnsafe) // Node.js >= 4.5.0
                 child = Buffer.allocUnsafe(parent.length);
@@ -33193,7 +33287,7 @@ var $284aeb9e515b63c0$var$clone = function() {
             }
             return child;
         }
-        return _clone(parent1, depth1);
+        return _clone(parent, depth);
     }
     /**
  * Simple flat clone using prototype, accepts only objects, usefull for property
@@ -33201,7 +33295,7 @@ var $284aeb9e515b63c0$var$clone = function() {
  *
  * USE WITH CAUTION! This may not behave as you wish if you do not know how this
  * works.
- */ clone1.clonePrototype = function clonePrototype(parent) {
+ */ clone.clonePrototype = function clonePrototype(parent) {
         if (parent === null) return null;
         var c = function() {};
         c.prototype = parent;
@@ -33211,19 +33305,19 @@ var $284aeb9e515b63c0$var$clone = function() {
     function __objToStr(o) {
         return Object.prototype.toString.call(o);
     }
-    clone1.__objToStr = __objToStr;
+    clone.__objToStr = __objToStr;
     function __isDate(o) {
         return typeof o === "object" && __objToStr(o) === "[object Date]";
     }
-    clone1.__isDate = __isDate;
+    clone.__isDate = __isDate;
     function __isArray(o) {
         return typeof o === "object" && __objToStr(o) === "[object Array]";
     }
-    clone1.__isArray = __isArray;
+    clone.__isArray = __isArray;
     function __isRegExp(o) {
         return typeof o === "object" && __objToStr(o) === "[object RegExp]";
     }
-    clone1.__isRegExp = __isRegExp;
+    clone.__isRegExp = __isRegExp;
     function __getRegExpFlags(re) {
         var flags = "";
         if (re.global) flags += "g";
@@ -33231,8 +33325,8 @@ var $284aeb9e515b63c0$var$clone = function() {
         if (re.multiline) flags += "m";
         return flags;
     }
-    clone1.__getRegExpFlags = __getRegExpFlags;
-    return clone1;
+    clone.__getRegExpFlags = __getRegExpFlags;
+    return clone;
 }();
 if ($284aeb9e515b63c0$exports) $284aeb9e515b63c0$exports = $284aeb9e515b63c0$var$clone;
 
@@ -33247,20 +33341,20 @@ var $5dc3ee1f90b35876$var$unicode = {
     ID_Continue: $5dc3ee1f90b35876$var$ID_Continue
 };
 var $5dc3ee1f90b35876$var$util = {
-    isSpaceSeparator (c1) {
-        return typeof c1 === "string" && $5dc3ee1f90b35876$var$unicode.Space_Separator.test(c1);
+    isSpaceSeparator (c) {
+        return typeof c === "string" && $5dc3ee1f90b35876$var$unicode.Space_Separator.test(c);
     },
-    isIdStartChar (c2) {
-        return typeof c2 === "string" && (c2 >= "a" && c2 <= "z" || c2 >= "A" && c2 <= "Z" || c2 === "$" || c2 === "_" || $5dc3ee1f90b35876$var$unicode.ID_Start.test(c2));
+    isIdStartChar (c) {
+        return typeof c === "string" && (c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "$" || c === "_" || $5dc3ee1f90b35876$var$unicode.ID_Start.test(c));
     },
-    isIdContinueChar (c3) {
-        return typeof c3 === "string" && (c3 >= "a" && c3 <= "z" || c3 >= "A" && c3 <= "Z" || c3 >= "0" && c3 <= "9" || c3 === "$" || c3 === "_" || c3 === "\u200C" || c3 === "\u200D" || $5dc3ee1f90b35876$var$unicode.ID_Continue.test(c3));
+    isIdContinueChar (c) {
+        return typeof c === "string" && (c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "$" || c === "_" || c === "‌" || c === "‍" || $5dc3ee1f90b35876$var$unicode.ID_Continue.test(c));
     },
-    isDigit (c4) {
-        return typeof c4 === "string" && /[0-9]/.test(c4);
+    isDigit (c) {
+        return typeof c === "string" && /[0-9]/.test(c);
     },
-    isHexDigit (c5) {
-        return typeof c5 === "string" && /[0-9A-Fa-f]/.test(c5);
+    isHexDigit (c) {
+        return typeof c === "string" && /[0-9A-Fa-f]/.test(c);
     }
 };
 let $5dc3ee1f90b35876$var$source;
@@ -33297,10 +33391,10 @@ var $5dc3ee1f90b35876$var$parse = function parse(text, reviver) {
 };
 function $5dc3ee1f90b35876$var$internalize(holder, name, reviver) {
     const value = holder[name];
-    if (value != null && typeof value === "object") for(const key1 in value){
-        const replacement = $5dc3ee1f90b35876$var$internalize(value, key1, reviver);
-        if (replacement === undefined) delete value[key1];
-        else value[key1] = replacement;
+    if (value != null && typeof value === "object") for(const key in value){
+        const replacement = $5dc3ee1f90b35876$var$internalize(value, key, reviver);
+        if (replacement === undefined) delete value[key];
+        else value[key] = replacement;
     }
     return reviver.call(holder, name, value);
 }
@@ -33320,22 +33414,22 @@ function $5dc3ee1f90b35876$var$lex() {
         // if (!lexStates[lexState]) {
         //     throw invalidLexState(lexState)
         // }
-        const token1 = $5dc3ee1f90b35876$var$lexStates[$5dc3ee1f90b35876$var$lexState]();
-        if (token1) return token1;
+        const token = $5dc3ee1f90b35876$var$lexStates[$5dc3ee1f90b35876$var$lexState]();
+        if (token) return token;
     }
 }
 function $5dc3ee1f90b35876$var$peek() {
     if ($5dc3ee1f90b35876$var$source[$5dc3ee1f90b35876$var$pos]) return String.fromCodePoint($5dc3ee1f90b35876$var$source.codePointAt($5dc3ee1f90b35876$var$pos));
 }
 function $5dc3ee1f90b35876$var$read() {
-    const c6 = $5dc3ee1f90b35876$var$peek();
-    if (c6 === "\n") {
+    const c = $5dc3ee1f90b35876$var$peek();
+    if (c === "\n") {
         $5dc3ee1f90b35876$var$line++;
         $5dc3ee1f90b35876$var$column = 0;
-    } else if (c6) $5dc3ee1f90b35876$var$column += c6.length;
+    } else if (c) $5dc3ee1f90b35876$var$column += c.length;
     else $5dc3ee1f90b35876$var$column++;
-    if (c6) $5dc3ee1f90b35876$var$pos += c6.length;
-    return c6;
+    if (c) $5dc3ee1f90b35876$var$pos += c.length;
+    return c;
 }
 const $5dc3ee1f90b35876$var$lexStates = {
     default () {
@@ -33502,8 +33596,8 @@ const $5dc3ee1f90b35876$var$lexStates = {
         switch($5dc3ee1f90b35876$var$c){
             case "$":
             case "_":
-            case "\u200C":
-            case "\u200D":
+            case "‌":
+            case "‍":
                 $5dc3ee1f90b35876$var$buffer += $5dc3ee1f90b35876$var$read();
                 return;
             case "\\":
@@ -33524,8 +33618,8 @@ const $5dc3ee1f90b35876$var$lexStates = {
         switch(u){
             case "$":
             case "_":
-            case "\u200C":
-            case "\u200D":
+            case "‌":
+            case "‍":
                 break;
             default:
                 if (!$5dc3ee1f90b35876$var$util.isIdContinueChar(u)) throw $5dc3ee1f90b35876$var$invalidIdentifier();
@@ -33797,15 +33891,15 @@ function $5dc3ee1f90b35876$var$newToken(type, value) {
     };
 }
 function $5dc3ee1f90b35876$var$literal(s) {
-    for (const c7 of s){
+    for (const c of s){
         const p = $5dc3ee1f90b35876$var$peek();
-        if (p !== c7) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
+        if (p !== c) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
         $5dc3ee1f90b35876$var$read();
     }
 }
 function $5dc3ee1f90b35876$var$escape() {
-    const c8 = $5dc3ee1f90b35876$var$peek();
-    switch(c8){
+    const c = $5dc3ee1f90b35876$var$peek();
+    switch(c){
         case "b":
             $5dc3ee1f90b35876$var$read();
             return "\b";
@@ -33859,24 +33953,24 @@ function $5dc3ee1f90b35876$var$escape() {
     return $5dc3ee1f90b35876$var$read();
 }
 function $5dc3ee1f90b35876$var$hexEscape() {
-    let buffer1 = "";
-    let c9 = $5dc3ee1f90b35876$var$peek();
-    if (!$5dc3ee1f90b35876$var$util.isHexDigit(c9)) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
-    buffer1 += $5dc3ee1f90b35876$var$read();
-    c9 = $5dc3ee1f90b35876$var$peek();
-    if (!$5dc3ee1f90b35876$var$util.isHexDigit(c9)) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
-    buffer1 += $5dc3ee1f90b35876$var$read();
-    return String.fromCodePoint(parseInt(buffer1, 16));
+    let buffer = "";
+    let c = $5dc3ee1f90b35876$var$peek();
+    if (!$5dc3ee1f90b35876$var$util.isHexDigit(c)) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
+    buffer += $5dc3ee1f90b35876$var$read();
+    c = $5dc3ee1f90b35876$var$peek();
+    if (!$5dc3ee1f90b35876$var$util.isHexDigit(c)) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
+    buffer += $5dc3ee1f90b35876$var$read();
+    return String.fromCodePoint(parseInt(buffer, 16));
 }
 function $5dc3ee1f90b35876$var$unicodeEscape() {
-    let buffer2 = "";
+    let buffer = "";
     let count = 4;
     while(count-- > 0){
-        const c10 = $5dc3ee1f90b35876$var$peek();
-        if (!$5dc3ee1f90b35876$var$util.isHexDigit(c10)) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
-        buffer2 += $5dc3ee1f90b35876$var$read();
+        const c = $5dc3ee1f90b35876$var$peek();
+        if (!$5dc3ee1f90b35876$var$util.isHexDigit(c)) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
+        buffer += $5dc3ee1f90b35876$var$read();
     }
-    return String.fromCodePoint(parseInt(buffer2, 16));
+    return String.fromCodePoint(parseInt(buffer, 16));
 }
 const $5dc3ee1f90b35876$var$parseStates = {
     start () {
@@ -34014,9 +34108,9 @@ function $5dc3ee1f90b35876$var$pop() {
 // function invalidLexState (state) {
 //     return new Error(`JSON5: invalid lex state '${state}'`)
 // }
-function $5dc3ee1f90b35876$var$invalidChar(c11) {
-    if (c11 === undefined) return $5dc3ee1f90b35876$var$syntaxError(`JSON5: invalid end of input at ${$5dc3ee1f90b35876$var$line}:${$5dc3ee1f90b35876$var$column}`);
-    return $5dc3ee1f90b35876$var$syntaxError(`JSON5: invalid character '${$5dc3ee1f90b35876$var$formatChar(c11)}' at ${$5dc3ee1f90b35876$var$line}:${$5dc3ee1f90b35876$var$column}`);
+function $5dc3ee1f90b35876$var$invalidChar(c) {
+    if (c === undefined) return $5dc3ee1f90b35876$var$syntaxError(`JSON5: invalid end of input at ${$5dc3ee1f90b35876$var$line}:${$5dc3ee1f90b35876$var$column}`);
+    return $5dc3ee1f90b35876$var$syntaxError(`JSON5: invalid character '${$5dc3ee1f90b35876$var$formatChar(c)}' at ${$5dc3ee1f90b35876$var$line}:${$5dc3ee1f90b35876$var$column}`);
 }
 function $5dc3ee1f90b35876$var$invalidEOF() {
     return $5dc3ee1f90b35876$var$syntaxError(`JSON5: invalid end of input at ${$5dc3ee1f90b35876$var$line}:${$5dc3ee1f90b35876$var$column}`);
@@ -34033,10 +34127,10 @@ function $5dc3ee1f90b35876$var$invalidIdentifier() {
     $5dc3ee1f90b35876$var$column -= 5;
     return $5dc3ee1f90b35876$var$syntaxError(`JSON5: invalid identifier character at ${$5dc3ee1f90b35876$var$line}:${$5dc3ee1f90b35876$var$column}`);
 }
-function $5dc3ee1f90b35876$var$separatorChar(c12) {
-    console.warn(`JSON5: '${$5dc3ee1f90b35876$var$formatChar(c12)}' in strings is not valid ECMAScript; consider escaping`);
+function $5dc3ee1f90b35876$var$separatorChar(c) {
+    console.warn(`JSON5: '${$5dc3ee1f90b35876$var$formatChar(c)}' in strings is not valid ECMAScript; consider escaping`);
 }
-function $5dc3ee1f90b35876$var$formatChar(c13) {
+function $5dc3ee1f90b35876$var$formatChar(c) {
     const replacements = {
         "'": "\\'",
         '"': '\\"',
@@ -34051,12 +34145,12 @@ function $5dc3ee1f90b35876$var$formatChar(c13) {
         "\u2028": "\\u2028",
         "\u2029": "\\u2029"
     };
-    if (replacements[c13]) return replacements[c13];
-    if (c13 < " ") {
-        const hexString = c13.charCodeAt(0).toString(16);
+    if (replacements[c]) return replacements[c];
+    if (c < " ") {
+        const hexString = c.charCodeAt(0).toString(16);
         return "\\x" + ("00" + hexString).substring(hexString.length);
     }
-    return c13;
+    return c;
 }
 function $5dc3ee1f90b35876$var$syntaxError(message) {
     const err = new SyntaxError(message);
@@ -34064,8 +34158,8 @@ function $5dc3ee1f90b35876$var$syntaxError(message) {
     err.columnNumber = $5dc3ee1f90b35876$var$column;
     return err;
 }
-var $5dc3ee1f90b35876$var$stringify = function stringify(value1, replacer, space) {
-    const stack1 = [];
+var $5dc3ee1f90b35876$var$stringify = function stringify(value, replacer, space) {
+    const stack = [];
     let indent = "";
     let propertyList;
     let replacerFunc;
@@ -34095,19 +34189,19 @@ var $5dc3ee1f90b35876$var$stringify = function stringify(value1, replacer, space
         }
     } else if (typeof space === "string") gap = space.substr(0, 10);
     return serializeProperty("", {
-        "": value1
+        "": value
     });
-    function serializeProperty(key2, holder) {
-        let value = holder[key2];
+    function serializeProperty(key, holder) {
+        let value = holder[key];
         if (value != null) {
             if (typeof value.toJSON5 === "function") {
-                value = value.toJSON5(key2);
+                value = value.toJSON5(key);
             } else if (typeof value.toJSON === "function") {
-                value = value.toJSON(key2);
+                value = value.toJSON(key);
             }
         }
         if (replacerFunc) {
-            value = replacerFunc.call(holder, key2, value);
+            value = replacerFunc.call(holder, key, value);
         }
         if (value instanceof Number) {
             value = Number(value);
@@ -34156,12 +34250,12 @@ var $5dc3ee1f90b35876$var$stringify = function stringify(value1, replacer, space
         };
         let product = "";
         for(let i = 0; i < value.length; i++){
-            const c14 = value[i];
-            switch(c14){
+            const c = value[i];
+            switch(c){
                 case "'":
                 case '"':
-                    quotes[c14]++;
-                    product += c14;
+                    quotes[c]++;
+                    product += c;
                     continue;
                 case "\0":
                     if ($5dc3ee1f90b35876$var$util.isDigit(value[i + 1])) {
@@ -34169,34 +34263,34 @@ var $5dc3ee1f90b35876$var$stringify = function stringify(value1, replacer, space
                         continue;
                     }
             }
-            if (replacements[c14]) {
-                product += replacements[c14];
+            if (replacements[c]) {
+                product += replacements[c];
                 continue;
             }
-            if (c14 < " ") {
-                let hexString = c14.charCodeAt(0).toString(16);
+            if (c < " ") {
+                let hexString = c.charCodeAt(0).toString(16);
                 product += "\\x" + ("00" + hexString).substring(hexString.length);
                 continue;
             }
-            product += c14;
+            product += c;
         }
         const quoteChar = quote || Object.keys(quotes).reduce((a, b)=>quotes[a] < quotes[b] ? a : b);
         product = product.replace(new RegExp(quoteChar, "g"), replacements[quoteChar]);
         return quoteChar + product + quoteChar;
     }
     function serializeObject(value) {
-        if (stack1.indexOf(value) >= 0) {
+        if (stack.indexOf(value) >= 0) {
             throw TypeError("Converting circular structure to JSON5");
         }
-        stack1.push(value);
+        stack.push(value);
         let stepback = indent;
         indent = indent + gap;
         let keys = propertyList || Object.keys(value);
         let partial = [];
-        for (const key3 of keys){
-            const propertyString = serializeProperty(key3, value);
+        for (const key of keys){
+            const propertyString = serializeProperty(key, value);
             if (propertyString !== undefined) {
-                let member = serializeKey(key3) + ":";
+                let member = serializeKey(key) + ":";
                 if (gap !== "") {
                     member += " ";
                 }
@@ -34218,30 +34312,30 @@ var $5dc3ee1f90b35876$var$stringify = function stringify(value1, replacer, space
                 final = "{\n" + indent + properties + ",\n" + stepback + "}";
             }
         }
-        stack1.pop();
+        stack.pop();
         indent = stepback;
         return final;
     }
-    function serializeKey(key4) {
-        if (key4.length === 0) {
-            return quoteString(key4, true);
+    function serializeKey(key) {
+        if (key.length === 0) {
+            return quoteString(key, true);
         }
-        const firstChar = String.fromCodePoint(key4.codePointAt(0));
+        const firstChar = String.fromCodePoint(key.codePointAt(0));
         if (!$5dc3ee1f90b35876$var$util.isIdStartChar(firstChar)) {
-            return quoteString(key4, true);
+            return quoteString(key, true);
         }
-        for(let i = firstChar.length; i < key4.length; i++){
-            if (!$5dc3ee1f90b35876$var$util.isIdContinueChar(String.fromCodePoint(key4.codePointAt(i)))) {
-                return quoteString(key4, true);
+        for(let i = firstChar.length; i < key.length; i++){
+            if (!$5dc3ee1f90b35876$var$util.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))) {
+                return quoteString(key, true);
             }
         }
-        return key4;
+        return key;
     }
     function serializeArray(value) {
-        if (stack1.indexOf(value) >= 0) {
+        if (stack.indexOf(value) >= 0) {
             throw TypeError("Converting circular structure to JSON5");
         }
-        stack1.push(value);
+        stack.push(value);
         let stepback = indent;
         indent = indent + gap;
         let partial = [];
@@ -34258,11 +34352,11 @@ var $5dc3ee1f90b35876$var$stringify = function stringify(value1, replacer, space
                 final = "[" + properties + "]";
             } else {
                 let separator = ",\n" + indent;
-                let properties = partial.join(separator);
-                final = "[\n" + indent + properties + ",\n" + stepback + "]";
+                let properties1 = partial.join(separator);
+                final = "[\n" + indent + properties1 + ",\n" + stepback + "]";
             }
         }
-        stack1.pop();
+        stack.pop();
         indent = stepback;
         return final;
     }
@@ -34827,7 +34921,7 @@ async function $10671d0be444e08b$export$c1a4367d4847eb06(fs, filepath, filenames
         if (cachedOutput) return cachedOutput;
         try {
             let extname = (0, ($parcel$interopDefault($8C1kk$path))).extname(configFile).slice(1);
-            if (extname === "js") {
+            if (extname === "js" || extname === "cjs") {
                 let output = {
                     // $FlowFixMe
                     config: (0, (/*@__PURE__*/$parcel$interopDefault($284aeb9e515b63c0$exports)))(require(configFile)),
@@ -34845,9 +34939,9 @@ async function $10671d0be444e08b$export$c1a4367d4847eb06(fs, filepath, filenames
             if (parse === false) config = configContent;
             else {
                 var ref1;
-                let parse = (ref1 = opts === null || opts === void 0 ? void 0 : opts.parser) !== null && ref1 !== void 0 ? ref1 : $10671d0be444e08b$var$getParser(extname);
+                let parse1 = (ref1 = opts === null || opts === void 0 ? void 0 : opts.parser) !== null && ref1 !== void 0 ? ref1 : $10671d0be444e08b$var$getParser(extname);
                 try {
-                    config = parse(configContent);
+                    config = parse1(configContent);
                 } catch (e) {
                     if (extname !== "" && extname !== "json") throw e;
                     let pos = {
@@ -34876,7 +34970,7 @@ async function $10671d0be444e08b$export$c1a4367d4847eb06(fs, filepath, filenames
                     });
                 }
             }
-            let output = {
+            let output1 = {
                 config: config,
                 files: [
                     {
@@ -34884,8 +34978,8 @@ async function $10671d0be444e08b$export$c1a4367d4847eb06(fs, filepath, filenames
                     }
                 ]
             };
-            $10671d0be444e08b$var$configCache.set(String(parse) + configFile, output);
-            return output;
+            $10671d0be444e08b$var$configCache.set(String(parse) + configFile, output1);
+            return output1;
         } catch (err) {
             if (err.code === "MODULE_NOT_FOUND" || err.code === "ENOENT") return null;
             throw err;
@@ -35024,6 +35118,13 @@ function $9631335a11debdd4$export$667066422fa0af46(a, b) {
         ...b
     ]);
 }
+function $9631335a11debdd4$export$dd7d5a65a6b6780f(a, b) {
+    if (a.size != b.size) return false;
+    for (let entry of a){
+        if (!b.has(entry)) return false;
+    }
+    return true;
+}
 
 
 
@@ -35061,6 +35162,22 @@ class $5783bf7916ff59db$export$4924f7ffab2ae440 extends WeakMap {
 
 
 
+function $01f892dcf45b57a7$export$d28945a2f2ba5e30(event) {
+    switch(event.phase){
+        case "transforming":
+            return `Building ${(0, ($parcel$interopDefault($8C1kk$path))).basename(event.filePath)}...`;
+        case "bundling":
+            return "Bundling...";
+        case "packaging":
+            return `Packaging ${event.bundle.displayName}...`;
+        case "optimizing":
+            return `Optimizing ${event.bundle.displayName}...`;
+    }
+    return null;
+}
+
+
+
 
 
 function $4b14026b40817fca$export$8a9ede1a78d6a1fe(stream) {
@@ -35117,10 +35234,10 @@ async function $0e887a49fdd81cad$export$3b1983e9896f988b(options) {
             key: key
         }, options.listener);
     } else {
-        let { cert: cert , key: key  } = await (0, $186980c178984fd2$export$2e2bcd8739ae039)(options.inputFS, options.https);
+        let { cert: cert1 , key: key1  } = await (0, $186980c178984fd2$export$2e2bcd8739ae039)(options.inputFS, options.https);
         server = (0, ($parcel$interopDefault($8C1kk$https))).createServer({
-            cert: cert,
-            key: key
+            cert: cert1,
+            key: key1
         }, options.listener);
     } // HTTPServer#close only stops accepting new connections, and does not close existing ones.
     // Before closing, destroy any active connections through their sockets. Additionally, remove sockets when they close:
@@ -35203,8 +35320,8 @@ async function $bc66accb63b05e9a$export$f074a8f9bef628fd({ bundle: bundle , bund
         let inlineType = (0, (/*@__PURE__*/$parcel$interopDefault($812806c6461f2963$exports)))(entryBundle.getMainEntry()).meta.inlineType;
         if (inlineType == null || inlineType === "string") {
             var ref;
-            var ref2;
-            let placeholder = (ref2 = (ref = dependency.meta) === null || ref === void 0 ? void 0 : ref.placeholder) !== null && ref2 !== void 0 ? ref2 : dependency.id;
+            var ref1;
+            let placeholder = (ref1 = (ref = dependency.meta) === null || ref === void 0 ? void 0 : ref.placeholder) !== null && ref1 !== void 0 ? ref1 : dependency.id;
             (0, ($parcel$interopDefault($8C1kk$assert)))(typeof placeholder === "string");
             replacements.set(placeholder, getInlineReplacement(dependency, inlineType, packagedContents));
         }
@@ -35228,8 +35345,8 @@ function $bc66accb63b05e9a$export$a22ef0cbdf8abc95({ dependency: dependency , fr
         pathname: (0, (/*@__PURE__*/$parcel$interopDefault($812806c6461f2963$exports)))(toBundle.name),
         hash: orig.hash
     }));
-    var ref3;
-    let placeholder = (ref3 = (ref = dependency.meta) === null || ref === void 0 ? void 0 : ref.placeholder) !== null && ref3 !== void 0 ? ref3 : dependency.id;
+    var ref1;
+    let placeholder = (ref1 = (ref = dependency.meta) === null || ref === void 0 ? void 0 : ref.placeholder) !== null && ref1 !== void 0 ? ref1 : dependency.id;
     (0, ($parcel$interopDefault($8C1kk$assert)))(typeof placeholder === "string");
     return {
         from: placeholder,