@parcel/utils 2.0.0-nightly.1274 → 2.0.0-nightly.1277

package/lib/index.js

@@ -1170,7 +1170,7 @@ var $5MQDC = parcelRequire("5MQDC");
    * Tokenize input until we reach end-of-string
    */ while(!eos()){
         value = advance();
-        if (value === "\0") continue;
+        if (value === "\x00") continue;
         /**
      * Escaped characters
      */ if (value === "\\") {
@@ -1856,19 +1856,19 @@ parcelRequire.register("1Sf6D", function(module, exports) {
 /* eslint-disable no-new-wrappers, no-eval, camelcase, operator-linebreak */ module.exports = makeParserClass((parcelRequire("8E52p")));
 module.exports.makeParserClass = makeParserClass;
 class TomlError extends Error {
-    constructor(msg){
-        super(msg);
+    constructor(msg11){
+        super(msg11);
         this.name = "TomlError";
         /* istanbul ignore next */ if (Error.captureStackTrace) Error.captureStackTrace(this, TomlError);
         this.fromTOML = true;
         this.wrapped = null;
     }
 }
-TomlError.wrap = (err)=>{
-    const terr = new TomlError(err.message);
-    terr.code = err.code;
-    terr.wrapped = err;
-    return terr;
+TomlError.wrap = (err11)=>{
+    const terr11 = new TomlError(err11.message);
+    terr11.code = err11.code;
+    terr11.wrapped = err11;
+    return terr11;
 };
 module.exports.TomlError = TomlError;
 
@@ -1936,23 +1936,23 @@ const escapes = {
     [CHAR_QUOT]: '"',
     [CHAR_BSOL]: "\\"
 };
-function isDigit(cp) {
-    return cp >= CHAR_0 && cp <= CHAR_9;
+function isDigit(cp11) {
+    return cp11 >= CHAR_0 && cp11 <= CHAR_9;
 }
-function isHexit(cp) {
-    return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
+function isHexit(cp11) {
+    return cp11 >= CHAR_A && cp11 <= CHAR_F || cp11 >= CHAR_a && cp11 <= CHAR_f || cp11 >= CHAR_0 && cp11 <= CHAR_9;
 }
-function isBit(cp) {
-    return cp === CHAR_1 || cp === CHAR_0;
+function isBit(cp11) {
+    return cp11 === CHAR_1 || cp11 === CHAR_0;
 }
-function isOctit(cp) {
-    return cp >= CHAR_0 && cp <= CHAR_7;
+function isOctit(cp11) {
+    return cp11 >= CHAR_0 && cp11 <= CHAR_7;
 }
-function isAlphaNumQuoteHyphen(cp) {
-    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+function isAlphaNumQuoteHyphen(cp11) {
+    return cp11 >= CHAR_A && cp11 <= CHAR_Z || cp11 >= CHAR_a && cp11 <= CHAR_z || cp11 >= CHAR_0 && cp11 <= CHAR_9 || cp11 === CHAR_APOS || cp11 === CHAR_QUOT || cp11 === CHAR_LOWBAR || cp11 === CHAR_HYPHEN;
 }
-function isAlphaNumHyphen(cp) {
-    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+function isAlphaNumHyphen(cp11) {
+    return cp11 >= CHAR_A && cp11 <= CHAR_Z || cp11 >= CHAR_a && cp11 <= CHAR_z || cp11 >= CHAR_0 && cp11 <= CHAR_9 || cp11 === CHAR_LOWBAR || cp11 === CHAR_HYPHEN;
 }
 const _type = Symbol("type");
 const _declared = Symbol("declared");
@@ -1964,9 +1964,9 @@ const descriptor = {
     writable: true,
     value: undefined
 };
-function hasKey(obj, key) {
-    if (hasOwnProperty.call(obj, key)) return true;
-    if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
+function hasKey(obj11, key11) {
+    if (hasOwnProperty.call(obj11, key11)) return true;
+    if (key11 === "__proto__") defineProperty(obj11, "__proto__", descriptor);
     return false;
 }
 const INLINE_TABLE = Symbol("inline-table");
@@ -1977,9 +1977,9 @@ function InlineTable() {
         }
     });
 }
-function isInlineTable(obj) {
-    if (obj === null || typeof obj !== "object") return false;
-    return obj[_type] === INLINE_TABLE;
+function isInlineTable(obj11) {
+    if (obj11 === null || typeof obj11 !== "object") return false;
+    return obj11[_type] === INLINE_TABLE;
 }
 const TABLE = Symbol("table");
 function Table() {
@@ -1993,25 +1993,25 @@ function Table() {
         }
     });
 }
-function isTable(obj) {
-    if (obj === null || typeof obj !== "object") return false;
-    return obj[_type] === TABLE;
+function isTable(obj11) {
+    if (obj11 === null || typeof obj11 !== "object") return false;
+    return obj11[_type] === TABLE;
 }
 const _contentType = Symbol("content-type");
 const INLINE_LIST = Symbol("inline-list");
-function InlineList(type) {
+function InlineList(type11) {
     return Object.defineProperties([], {
         [_type]: {
             value: INLINE_LIST
         },
         [_contentType]: {
-            value: type
+            value: type11
         }
     });
 }
-function isInlineList(obj) {
-    if (obj === null || typeof obj !== "object") return false;
-    return obj[_type] === INLINE_LIST;
+function isInlineList(obj11) {
+    if (obj11 === null || typeof obj11 !== "object") return false;
+    return obj11[_type] === INLINE_LIST;
 }
 const LIST = Symbol("list");
 function List() {
@@ -2021,9 +2021,9 @@ function List() {
         }
     });
 }
-function isList(obj) {
-    if (obj === null || typeof obj !== "object") return false;
-    return obj[_type] === LIST;
+function isList(obj11) {
+    if (obj11 === null || typeof obj11 !== "object") return false;
+    return obj11[_type] === LIST;
 }
 // in an eval, to let bundlers not slurp in a util proxy
 let _custom;
@@ -2034,10 +2034,10 @@ try {
 /* eval require not available in transpiled bundle */ }
 /* istanbul ignore next */ const _inspect = _custom || "inspect";
 class BoxedBigInt {
-    constructor(value){
+    constructor(value11){
         try {
-            this.value = $parcel$global.BigInt.asIntN(64, value);
-        } catch (_) {
+            this.value = $parcel$global.BigInt.asIntN(64, value11);
+        } catch (_11) {
             /* istanbul ignore next */ this.value = null;
         }
         Object.defineProperty(this, _type, {
@@ -2058,12 +2058,12 @@ class BoxedBigInt {
     }
 }
 const INTEGER = Symbol("integer");
-function Integer(value) {
-    let num = Number(value);
+function Integer(value11) {
+    let num11 = Number(value11);
     // -0 is a float thing, not an int thing
-    if (Object.is(num, -0)) num = 0;
-    /* istanbul ignore else */ if ($parcel$global.BigInt && !Number.isSafeInteger(num)) return new BoxedBigInt(value);
-    else /* istanbul ignore next */ return Object.defineProperties(new Number(num), {
+    if (Object.is(num11, -0)) num11 = 0;
+    /* istanbul ignore else */ if ($parcel$global.BigInt && !Number.isSafeInteger(num11)) return new BoxedBigInt(value11);
+    else /* istanbul ignore next */ return Object.defineProperties(new Number(num11), {
         isNaN: {
             value: function() {
                 return isNaN(this);
@@ -2073,35 +2073,35 @@ function Integer(value) {
             value: INTEGER
         },
         [_inspect]: {
-            value: ()=>`[Integer: ${value}]`
+            value: ()=>`[Integer: ${value11}]`
         }
     });
 }
-function isInteger(obj) {
-    if (obj === null || typeof obj !== "object") return false;
-    return obj[_type] === INTEGER;
+function isInteger(obj11) {
+    if (obj11 === null || typeof obj11 !== "object") return false;
+    return obj11[_type] === INTEGER;
 }
 const FLOAT = Symbol("float");
-function Float(value) {
-    /* istanbul ignore next */ return Object.defineProperties(new Number(value), {
+function Float(value11) {
+    /* istanbul ignore next */ return Object.defineProperties(new Number(value11), {
         [_type]: {
             value: FLOAT
         },
         [_inspect]: {
-            value: ()=>`[Float: ${value}]`
+            value: ()=>`[Float: ${value11}]`
         }
     });
 }
-function isFloat(obj) {
-    if (obj === null || typeof obj !== "object") return false;
-    return obj[_type] === FLOAT;
+function isFloat(obj11) {
+    if (obj11 === null || typeof obj11 !== "object") return false;
+    return obj11[_type] === FLOAT;
 }
-function tomlType(value) {
-    const type = typeof value;
-    if (type === "object") {
-        /* istanbul ignore if */ if (value === null) return "null";
-        if (value instanceof Date) return "datetime";
-        /* istanbul ignore else */ if (_type in value) switch(value[_type]){
+function tomlType(value11) {
+    const type11 = typeof value11;
+    if (type11 === "object") {
+        /* istanbul ignore if */ if (value11 === null) return "null";
+        if (value11 instanceof Date) return "datetime";
+        /* istanbul ignore else */ if (_type in value11) switch(value11[_type]){
             case INLINE_TABLE:
                 return "inline-table";
             case INLINE_LIST:
@@ -2116,10 +2116,10 @@ function tomlType(value) {
                 return "integer";
         }
     }
-    return type;
+    return type11;
 }
-function makeParserClass(Parser) {
-    class TOMLParser extends Parser {
+function makeParserClass(Parser11) {
+    class TOMLParser11 extends Parser11 {
         constructor(){
             super();
             this.ctx = this.obj = Table();
@@ -2128,10 +2128,10 @@ function makeParserClass(Parser) {
             return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
         }
         atEndOfLine() {
-            return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
+            return this.char === Parser11.END || this.char === CTRL_J || this.char === CTRL_M;
         }
         parseStart() {
-            if (this.char === Parser.END) return null;
+            if (this.char === Parser11.END) return null;
             else if (this.char === CHAR_LSQB) return this.call(this.parseTableOrList);
             else if (this.char === CHAR_NUM) return this.call(this.parseComment);
             else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) return null;
@@ -2143,32 +2143,32 @@ function makeParserClass(Parser) {
         parseWhitespaceToEOL() {
             if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) return null;
             else if (this.char === CHAR_NUM) return this.goto(this.parseComment);
-            else if (this.char === Parser.END || this.char === CTRL_J) return this.return();
+            else if (this.char === Parser11.END || this.char === CTRL_J) return this.return();
             else throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
         }
         /* ASSIGNMENT: key = value */ parseAssignStatement() {
             return this.callNow(this.parseAssign, this.recordAssignStatement);
         }
-        recordAssignStatement(kv) {
-            let target = this.ctx;
-            let finalKey = kv.key.pop();
-            for (let kw of kv.key){
-                if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
-                target = target[kw] = target[kw] || Table();
+        recordAssignStatement(kv11) {
+            let target11 = this.ctx;
+            let finalKey11 = kv11.key.pop();
+            for (let kw11 of kv11.key){
+                if (hasKey(target11, kw11) && (!isTable(target11[kw11]) || target11[kw11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                target11 = target11[kw11] = target11[kw11] || Table();
             }
-            if (hasKey(target, finalKey)) throw this.error(new TomlError("Can't redefine existing key"));
+            if (hasKey(target11, finalKey11)) throw this.error(new TomlError("Can't redefine existing key"));
             // unbox our numbers
-            if (isInteger(kv.value) || isFloat(kv.value)) target[finalKey] = kv.value.valueOf();
-            else target[finalKey] = kv.value;
+            if (isInteger(kv11.value) || isFloat(kv11.value)) target11[finalKey11] = kv11.value.valueOf();
+            else target11[finalKey11] = kv11.value;
             return this.goto(this.parseWhitespaceToEOL);
         }
         /* ASSSIGNMENT expression, key = value possibly inside an inline table */ parseAssign() {
             return this.callNow(this.parseKeyword, this.recordAssignKeyword);
         }
-        recordAssignKeyword(key) {
-            if (this.state.resultTable) this.state.resultTable.push(key);
+        recordAssignKeyword(key11) {
+            if (this.state.resultTable) this.state.resultTable.push(key11);
             else this.state.resultTable = [
-                key
+                key11
             ];
             return this.goto(this.parseAssignKeywordPreDot);
         }
@@ -2187,15 +2187,15 @@ function makeParserClass(Parser) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseValue, this.recordAssignValue);
         }
-        recordAssignValue(value) {
+        recordAssignValue(value11) {
             return this.returnNow({
                 key: this.state.resultTable,
-                value: value
+                value: value11
             });
         }
         /* COMMENTS: #...eol */ parseComment() {
             do {
-                if (this.char === Parser.END || this.char === CTRL_J) return this.return();
+                if (this.char === Parser11.END || this.char === CTRL_J) return this.return();
             }while (this.nextChar());
         }
         /* TABLES AND LISTS, [foo] and [[foo]] */ parseTableOrList() {
@@ -2210,19 +2210,19 @@ function makeParserClass(Parser) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseKeyword, this.parseTableMore);
         }
-        parseTableMore(keyword) {
+        parseTableMore(keyword11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else if (this.char === CHAR_RSQB) {
-                if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                if (hasKey(this.ctx, keyword11) && (!isTable(this.ctx[keyword11]) || this.ctx[keyword11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
                 else {
-                    this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
+                    this.ctx = this.ctx[keyword11] = this.ctx[keyword11] || Table();
                     this.ctx[_declared] = true;
                 }
                 return this.next(this.parseWhitespaceToEOL);
             } else if (this.char === CHAR_PERIOD) {
-                if (!hasKey(this.ctx, keyword)) this.ctx = this.ctx[keyword] = Table();
-                else if (isTable(this.ctx[keyword])) this.ctx = this.ctx[keyword];
-                else if (isList(this.ctx[keyword])) this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+                if (!hasKey(this.ctx, keyword11)) this.ctx = this.ctx[keyword11] = Table();
+                else if (isTable(this.ctx[keyword11])) this.ctx = this.ctx[keyword11];
+                else if (isList(this.ctx[keyword11])) this.ctx = this.ctx[keyword11][this.ctx[keyword11].length - 1];
                 else throw this.error(new TomlError("Can't redefine existing key"));
                 return this.next(this.parseTableNext);
             } else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
@@ -2235,33 +2235,33 @@ function makeParserClass(Parser) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseKeyword, this.parseListMore);
         }
-        parseListMore(keyword) {
+        parseListMore(keyword11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else if (this.char === CHAR_RSQB) {
-                if (!hasKey(this.ctx, keyword)) this.ctx[keyword] = List();
-                if (isInlineList(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline array"));
-                else if (isList(this.ctx[keyword])) {
-                    const next = Table();
-                    this.ctx[keyword].push(next);
-                    this.ctx = next;
+                if (!hasKey(this.ctx, keyword11)) this.ctx[keyword11] = List();
+                if (isInlineList(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline array"));
+                else if (isList(this.ctx[keyword11])) {
+                    const next11 = Table();
+                    this.ctx[keyword11].push(next11);
+                    this.ctx = next11;
                 } else throw this.error(new TomlError("Can't redefine an existing key"));
                 return this.next(this.parseListEnd);
             } else if (this.char === CHAR_PERIOD) {
-                if (!hasKey(this.ctx, keyword)) this.ctx = this.ctx[keyword] = Table();
-                else if (isInlineList(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline array"));
-                else if (isInlineTable(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline table"));
-                else if (isList(this.ctx[keyword])) this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
-                else if (isTable(this.ctx[keyword])) this.ctx = this.ctx[keyword];
+                if (!hasKey(this.ctx, keyword11)) this.ctx = this.ctx[keyword11] = Table();
+                else if (isInlineList(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline array"));
+                else if (isInlineTable(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline table"));
+                else if (isList(this.ctx[keyword11])) this.ctx = this.ctx[keyword11][this.ctx[keyword11].length - 1];
+                else if (isTable(this.ctx[keyword11])) this.ctx = this.ctx[keyword11];
                 else throw this.error(new TomlError("Can't redefine an existing key"));
                 return this.next(this.parseListNext);
             } else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
         }
-        parseListEnd(keyword) {
+        parseListEnd(keyword11) {
             if (this.char === CHAR_RSQB) return this.next(this.parseWhitespaceToEOL);
             else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
         }
         /* VALUE string, number, boolean, inline list, inline object */ parseValue() {
-            if (this.char === Parser.END) throw this.error(new TomlError("Key without value"));
+            if (this.char === Parser11.END) throw this.error(new TomlError("Key without value"));
             else if (this.char === CHAR_QUOT) return this.next(this.parseDoubleString);
             if (this.char === CHAR_APOS) return this.next(this.parseSingleString);
             else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) return this.goto(this.parseNumberSign);
@@ -2273,8 +2273,8 @@ function makeParserClass(Parser) {
             else if (this.char === CHAR_LCUB) return this.call(this.parseInlineTable, this.recordValue);
             else throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
         }
-        recordValue(value) {
-            return this.returnNow(value);
+        recordValue(value11) {
+            return this.returnNow(value11);
         }
         parseInf() {
             if (this.char === CHAR_n) return this.next(this.parseInf2);
@@ -2301,7 +2301,7 @@ function makeParserClass(Parser) {
         }
         /* KEYS: barewords */ parseBareKey() {
             do {
-                if (this.char === Parser.END) throw this.error(new TomlError("Key ended without value"));
+                if (this.char === Parser11.END) throw this.error(new TomlError("Key ended without value"));
                 else if (isAlphaNumHyphen(this.char)) this.consume();
                 else if (this.state.buf.length === 0) throw this.error(new TomlError("Empty bare keys are not allowed"));
                 else return this.returnNow();
@@ -2331,7 +2331,7 @@ function makeParserClass(Parser) {
         parseLiteralMultiStringContent() {
             do {
                 if (this.char === CHAR_APOS) return this.next(this.parseLiteralMultiEnd);
-                else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated multi-line string"));
+                else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated multi-line string"));
                 else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) throw this.errorControlCharInString();
                 else this.consume();
             }while (this.nextChar());
@@ -2363,8 +2363,8 @@ function makeParserClass(Parser) {
                 else this.consume();
             }while (this.nextChar());
         }
-        recordEscapeReplacement(replacement) {
-            this.state.buf += replacement;
+        recordEscapeReplacement(replacement11) {
+            this.state.buf += replacement11;
             return this.goto(this.parseBasicString);
         }
         parseMultiStringMaybe() {
@@ -2380,19 +2380,19 @@ function makeParserClass(Parser) {
             do {
                 if (this.char === CHAR_BSOL) return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
                 else if (this.char === CHAR_QUOT) return this.next(this.parseMultiEnd);
-                else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated multi-line string"));
+                else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated multi-line string"));
                 else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) throw this.errorControlCharInString();
                 else this.consume();
             }while (this.nextChar());
         }
         errorControlCharInString() {
-            let displayCode = "\\u00";
-            if (this.char < 16) displayCode += "0";
-            displayCode += this.char.toString(16);
-            return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
+            let displayCode11 = "\\u00";
+            if (this.char < 16) displayCode11 += "0";
+            displayCode11 += this.char.toString(16);
+            return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode11} instead`));
         }
-        recordMultiEscapeReplacement(replacement) {
-            this.state.buf += replacement;
+        recordMultiEscapeReplacement(replacement11) {
+            this.state.buf += replacement11;
             return this.goto(this.parseMultiStringContent);
         }
         parseMultiEnd() {
@@ -2430,13 +2430,13 @@ function makeParserClass(Parser) {
             else if (this.char === CHAR_U) return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
             else throw this.error(new TomlError("Unknown escape character: " + this.char));
         }
-        parseUnicodeReturn(char) {
+        parseUnicodeReturn(char11) {
             try {
-                const codePoint = parseInt(char, 16);
-                if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
-                return this.returnNow(String.fromCodePoint(codePoint));
-            } catch (err) {
-                throw this.error(TomlError.wrap(err));
+                const codePoint11 = parseInt(char11, 16);
+                if (codePoint11 >= SURROGATE_FIRST && codePoint11 <= SURROGATE_LAST) throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+                return this.returnNow(String.fromCodePoint(codePoint11));
+            } catch (err11) {
+                throw this.error(TomlError.wrap(err11));
             }
         }
         parseSmallUnicode() {
@@ -2487,9 +2487,9 @@ function makeParserClass(Parser) {
                 this.consume();
                 return this.call(this.parseNoUnder, this.parseNumberFloat);
             } else {
-                const result = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result);
+                const result11 = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result11);
             }
         }
         parseNoUnder() {
@@ -2567,27 +2567,27 @@ function makeParserClass(Parser) {
             if (isHexit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result);
+                const result11 = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result11);
             }
         }
         parseIntegerOct() {
             if (isOctit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result);
+                const result11 = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result11);
             }
         }
         parseIntegerBin() {
             if (isBit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result);
+                const result11 = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result11);
             }
         }
         /* DATETIME */ parseDateTime() {
@@ -2776,20 +2776,20 @@ function makeParserClass(Parser) {
         }
         /* INLINE LISTS */ parseInlineList() {
             if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) return null;
-            else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_NUM) return this.call(this.parseComment);
             else if (this.char === CHAR_RSQB) return this.return(this.state.resultArr || InlineList());
             else return this.callNow(this.parseValue, this.recordInlineListValue);
         }
-        recordInlineListValue(value) {
+        recordInlineListValue(value11) {
             if (this.state.resultArr) {
-                const listType = this.state.resultArr[_contentType];
-                const valueType = tomlType(value);
-                if (listType !== valueType) throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
-            } else this.state.resultArr = InlineList(tomlType(value));
-            if (isFloat(value) || isInteger(value)) // unbox now that we've verified they're ok
-            this.state.resultArr.push(value.valueOf());
-            else this.state.resultArr.push(value);
+                const listType11 = this.state.resultArr[_contentType];
+                const valueType11 = tomlType(value11);
+                if (listType11 !== valueType11) throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType11} and ${valueType11}`));
+            } else this.state.resultArr = InlineList(tomlType(value11));
+            if (isFloat(value11) || isInteger(value11)) // unbox now that we've verified they're ok
+            this.state.resultArr.push(value11.valueOf());
+            else this.state.resultArr.push(value11);
             return this.goto(this.parseInlineListNext);
         }
         parseInlineListNext() {
@@ -2801,34 +2801,34 @@ function makeParserClass(Parser) {
         }
         /* INLINE TABLE */ parseInlineTable() {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
-            else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser11.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_RCUB) return this.return(this.state.resultTable || InlineTable());
             else {
                 if (!this.state.resultTable) this.state.resultTable = InlineTable();
                 return this.callNow(this.parseAssign, this.recordInlineTableValue);
             }
         }
-        recordInlineTableValue(kv) {
-            let target = this.state.resultTable;
-            let finalKey = kv.key.pop();
-            for (let kw of kv.key){
-                if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
-                target = target[kw] = target[kw] || Table();
+        recordInlineTableValue(kv11) {
+            let target11 = this.state.resultTable;
+            let finalKey11 = kv11.key.pop();
+            for (let kw11 of kv11.key){
+                if (hasKey(target11, kw11) && (!isTable(target11[kw11]) || target11[kw11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                target11 = target11[kw11] = target11[kw11] || Table();
             }
-            if (hasKey(target, finalKey)) throw this.error(new TomlError("Can't redefine existing key"));
-            if (isInteger(kv.value) || isFloat(kv.value)) target[finalKey] = kv.value.valueOf();
-            else target[finalKey] = kv.value;
+            if (hasKey(target11, finalKey11)) throw this.error(new TomlError("Can't redefine existing key"));
+            if (isInteger(kv11.value) || isFloat(kv11.value)) target11[finalKey11] = kv11.value.valueOf();
+            else target11[finalKey11] = kv11.value;
             return this.goto(this.parseInlineTableNext);
         }
         parseInlineTableNext() {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
-            else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser11.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_COMMA) return this.next(this.parseInlineTable);
             else if (this.char === CHAR_RCUB) return this.goto(this.parseInlineTable);
             else throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
         }
     }
-    return TOMLParser;
+    return TOMLParser11;
 }
 
 });
@@ -14671,7 +14671,7 @@ var $564ac6480d83471d$var$pkcs1 = $564ac6480d83471d$exports = $iGlOy.pkcs1 = $iG
     var lHash = md.digest();
     var PS = "";
     var PS_length = maxLength - message.length;
-    for(var i = 0; i < PS_length; i++)PS += "\0";
+    for(var i = 0; i < PS_length; i++)PS += "\x00";
     var DB = lHash.getBytes() + PS + "\x01" + message;
     if (!seed) seed = $iGlOy.random.getBytes(md.digestLength);
     else if (seed.length !== md.digestLength) {
@@ -14685,7 +14685,7 @@ var $564ac6480d83471d$var$pkcs1 = $564ac6480d83471d$exports = $iGlOy.pkcs1 = $iG
     var seedMask = $564ac6480d83471d$var$rsa_mgf1(maskedDB, md.digestLength, mgf1Md);
     var maskedSeed = $iGlOy.util.xorBytes(seed, seedMask, seed.length);
     // return encoded message
-    return "\0" + maskedSeed + maskedDB;
+    return "\x00" + maskedSeed + maskedDB;
 };
 /**
  * Decode the given RSAES-OAEP encoded message (EM) using key, with optional
@@ -14744,7 +14744,7 @@ var $564ac6480d83471d$var$pkcs1 = $564ac6480d83471d$exports = $iGlOy.pkcs1 = $iG
     var db = $iGlOy.util.xorBytes(maskedDB, dbMask, maskedDB.length);
     var lHashPrime = db.substring(0, md.digestLength);
     // constant time check that all values match what is expected
-    var error = y !== "\0";
+    var error = y !== "\x00";
     // constant time check lHash vs lHashPrime
     for(var i = 0; i < md.digestLength; ++i)error |= lHash.charAt(i) !== lHashPrime.charAt(i);
     // "constant time" find the 0x1 byte separating the padding (zeros) from the
@@ -26651,8 +26651,8 @@ var $33c8fc1a702f0359$var$_states = null;
             (lo >>> 29 | hi << 3) ^ // ROTR 61/(swap + ROTR 29)
             hi >>> 6) >>> 0; // SHR 6
             // low bits
-            t1_lo = ((hi << 13 | lo >>> 19) ^ (// ROTR 19
-            lo << 3 | hi >>> 29) ^ // ROTR 61/(swap + ROTR 29)
+            t1_lo = ((hi << 13 | lo >>> 19) ^ // ROTR 19
+            (lo << 3 | hi >>> 29) ^ // ROTR 61/(swap + ROTR 29)
             (hi << 26 | lo >>> 6)) >>> 0; // SHR 6
             // for word 15 words ago: ROTR 1(x) ^ ROTR 8(x) ^ SHR 7(x)
             w15 = w[i - 15];
@@ -26664,8 +26664,8 @@ var $33c8fc1a702f0359$var$_states = null;
             hi >>> 7) >>> 0; // SHR 7
             // low bits
             t2_lo = ((hi << 31 | lo >>> 1) ^ // ROTR 1
-            (hi << 24 | lo >>> 8) ^ (// ROTR 8
-            hi << 25 | lo >>> 7)) >>> 0; // SHR 7
+            (hi << 24 | lo >>> 8) ^ // ROTR 8
+            (hi << 25 | lo >>> 7)) >>> 0; // SHR 7
             // sum(t1, word 7 ago, t2, word 16 ago) modulo 2^64 (carry lo overflow)
             w7 = w[i - 7];
             w16 = w[i - 16];
@@ -26693,22 +26693,22 @@ var $33c8fc1a702f0359$var$_states = null;
         // round function
         for(i = 0; i < 80; ++i){
             // Sum1(e) = ROTR 14(e) ^ ROTR 18(e) ^ ROTR 41(e)
-            s1_hi = ((e_hi >>> 14 | e_lo << 18) ^ (// ROTR 14
-            e_hi >>> 18 | e_lo << 14) ^ (// ROTR 18
-            e_lo >>> 9 | e_hi << 23)) >>> 0; // ROTR 41/(swap + ROTR 9)
+            s1_hi = ((e_hi >>> 14 | e_lo << 18) ^ // ROTR 14
+            (e_hi >>> 18 | e_lo << 14) ^ // ROTR 18
+            (e_lo >>> 9 | e_hi << 23)) >>> 0; // ROTR 41/(swap + ROTR 9)
             s1_lo = ((e_hi << 18 | e_lo >>> 14) ^ // ROTR 14
-            (e_hi << 14 | e_lo >>> 18) ^ (// ROTR 18
-            e_lo << 23 | e_hi >>> 9)) >>> 0; // ROTR 41/(swap + ROTR 9)
+            (e_hi << 14 | e_lo >>> 18) ^ // ROTR 18
+            (e_lo << 23 | e_hi >>> 9)) >>> 0; // ROTR 41/(swap + ROTR 9)
             // Ch(e, f, g) (optimized the same way as SHA-1)
             ch_hi = (g_hi ^ e_hi & (f_hi ^ g_hi)) >>> 0;
             ch_lo = (g_lo ^ e_lo & (f_lo ^ g_lo)) >>> 0;
             // Sum0(a) = ROTR 28(a) ^ ROTR 34(a) ^ ROTR 39(a)
-            s0_hi = ((a_hi >>> 28 | a_lo << 4) ^ (// ROTR 28
-            a_lo >>> 2 | a_hi << 30) ^ // ROTR 34/(swap + ROTR 2)
+            s0_hi = ((a_hi >>> 28 | a_lo << 4) ^ // ROTR 28
+            (a_lo >>> 2 | a_hi << 30) ^ // ROTR 34/(swap + ROTR 2)
             (a_lo >>> 7 | a_hi << 25)) >>> 0; // ROTR 39/(swap + ROTR 7)
-            s0_lo = ((a_hi << 4 | a_lo >>> 28) ^ (// ROTR 28
-            a_lo << 30 | a_hi >>> 2) ^ (// ROTR 34/(swap + ROTR 2)
-            a_lo << 25 | a_hi >>> 7)) >>> 0; // ROTR 39/(swap + ROTR 7)
+            s0_lo = ((a_hi << 4 | a_lo >>> 28) ^ // ROTR 28
+            (a_lo << 30 | a_hi >>> 2) ^ // ROTR 34/(swap + ROTR 2)
+            (a_lo << 25 | a_hi >>> 7)) >>> 0; // ROTR 39/(swap + ROTR 7)
             // Maj(a, b, c) (optimized the same way as SHA-1)
             maj_hi = (a_hi & b_hi | c_hi & (a_hi ^ b_hi)) >>> 0;
             maj_lo = (a_lo & b_lo | c_lo & (a_lo ^ b_lo)) >>> 0;
@@ -29328,8 +29328,8 @@ var $85c6486b1bf8bee8$var$ssh = $85c6486b1bf8bee8$exports = $iGlOy.ssh = $iGlOy.
         padding.truncate(padding.length() - encLen + privbuffer.length());
         privbuffer.putBuffer(padding);
         var aeskey = $iGlOy.util.createBuffer();
-        aeskey.putBuffer($85c6486b1bf8bee8$var$_sha1("\0\0\0\0", passphrase));
-        aeskey.putBuffer($85c6486b1bf8bee8$var$_sha1("\0\0\0\x01", passphrase));
+        aeskey.putBuffer($85c6486b1bf8bee8$var$_sha1("\x00\x00\x00\x00", passphrase));
+        aeskey.putBuffer($85c6486b1bf8bee8$var$_sha1("\x00\x00\x00\x01", passphrase));
         // encrypt some bytes using CBC mode
         // key is 40 bytes, so truncate *by* 8 bytes
         var cipher = $iGlOy.aes.createEncryptionCipher(aeskey.truncate(8), "CBC");
@@ -35069,7 +35069,7 @@ function $5dc3ee1f90b35876$var$escape() {
         case "0":
             $5dc3ee1f90b35876$var$read();
             if ($5dc3ee1f90b35876$var$util.isDigit($5dc3ee1f90b35876$var$peek())) throw $5dc3ee1f90b35876$var$invalidChar($5dc3ee1f90b35876$var$read());
-            return "\0";
+            return "\x00";
         case "x":
             $5dc3ee1f90b35876$var$read();
             return $5dc3ee1f90b35876$var$hexEscape();
@@ -35289,7 +35289,7 @@ function $5dc3ee1f90b35876$var$formatChar(c) {
         "\r": "\\r",
         "	": "\\t",
         "\v": "\\v",
-        "\0": "\\0",
+        "\x00": "\\0",
         "\u2028": "\\u2028",
         "\u2029": "\\u2029"
     };
@@ -35377,7 +35377,7 @@ var $5dc3ee1f90b35876$var$stringify = function stringify(value, replacer, space)
             "\r": "\\r",
             "	": "\\t",
             "\v": "\\v",
-            "\0": "\\0",
+            "\x00": "\\0",
             "\u2028": "\\u2028",
             "\u2029": "\\u2029"
         };
@@ -35390,7 +35390,7 @@ var $5dc3ee1f90b35876$var$stringify = function stringify(value, replacer, space)
                     quotes[c]++;
                     product += c;
                     continue;
-                case "\0":
+                case "\x00":
                     if ($5dc3ee1f90b35876$var$util.isDigit(value[i + 1])) {
                         product += "\\x00";
                         continue;