@parcel/utils 2.0.0-nightly.1439 → 2.0.0-nightly.1441

package/lib/index.js

@@ -1854,19 +1854,19 @@ parcelRegister("2nj4a", function(module, exports) {
 /* eslint-disable no-new-wrappers, no-eval, camelcase, operator-linebreak */ module.exports = makeParserClass((parcelRequire("ibqqh")));
 module.exports.makeParserClass = makeParserClass;
 class TomlError extends Error {
-    constructor(msg11){
-        super(msg11);
+    constructor(msg){
+        super(msg);
         this.name = "TomlError";
         /* istanbul ignore next */ if (Error.captureStackTrace) Error.captureStackTrace(this, TomlError);
         this.fromTOML = true;
         this.wrapped = null;
     }
 }
-TomlError.wrap = (err11)=>{
-    const terr11 = new TomlError(err11.message);
-    terr11.code = err11.code;
-    terr11.wrapped = err11;
-    return terr11;
+TomlError.wrap = (err)=>{
+    const terr = new TomlError(err.message);
+    terr.code = err.code;
+    terr.wrapped = err;
+    return terr;
 };
 module.exports.TomlError = TomlError;
 
@@ -1934,23 +1934,23 @@ const escapes = {
     [CHAR_QUOT]: '"',
     [CHAR_BSOL]: "\\"
 };
-function isDigit(cp11) {
-    return cp11 >= CHAR_0 && cp11 <= CHAR_9;
+function isDigit(cp) {
+    return cp >= CHAR_0 && cp <= CHAR_9;
 }
-function isHexit(cp11) {
-    return cp11 >= CHAR_A && cp11 <= CHAR_F || cp11 >= CHAR_a && cp11 <= CHAR_f || cp11 >= CHAR_0 && cp11 <= CHAR_9;
+function isHexit(cp) {
+    return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
 }
-function isBit(cp11) {
-    return cp11 === CHAR_1 || cp11 === CHAR_0;
+function isBit(cp) {
+    return cp === CHAR_1 || cp === CHAR_0;
 }
-function isOctit(cp11) {
-    return cp11 >= CHAR_0 && cp11 <= CHAR_7;
+function isOctit(cp) {
+    return cp >= CHAR_0 && cp <= CHAR_7;
 }
-function isAlphaNumQuoteHyphen(cp11) {
-    return cp11 >= CHAR_A && cp11 <= CHAR_Z || cp11 >= CHAR_a && cp11 <= CHAR_z || cp11 >= CHAR_0 && cp11 <= CHAR_9 || cp11 === CHAR_APOS || cp11 === CHAR_QUOT || cp11 === CHAR_LOWBAR || cp11 === CHAR_HYPHEN;
+function isAlphaNumQuoteHyphen(cp) {
+    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
 }
-function isAlphaNumHyphen(cp11) {
-    return cp11 >= CHAR_A && cp11 <= CHAR_Z || cp11 >= CHAR_a && cp11 <= CHAR_z || cp11 >= CHAR_0 && cp11 <= CHAR_9 || cp11 === CHAR_LOWBAR || cp11 === CHAR_HYPHEN;
+function isAlphaNumHyphen(cp) {
+    return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
 }
 const _type = Symbol("type");
 const _declared = Symbol("declared");
@@ -1962,9 +1962,9 @@ const descriptor = {
     writable: true,
     value: undefined
 };
-function hasKey(obj11, key11) {
-    if (hasOwnProperty.call(obj11, key11)) return true;
-    if (key11 === "__proto__") defineProperty(obj11, "__proto__", descriptor);
+function hasKey(obj, key) {
+    if (hasOwnProperty.call(obj, key)) return true;
+    if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
     return false;
 }
 const INLINE_TABLE = Symbol("inline-table");
@@ -1975,9 +1975,9 @@ function InlineTable() {
         }
     });
 }
-function isInlineTable(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === INLINE_TABLE;
+function isInlineTable(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === INLINE_TABLE;
 }
 const TABLE = Symbol("table");
 function Table() {
@@ -1991,25 +1991,25 @@ function Table() {
         }
     });
 }
-function isTable(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === TABLE;
+function isTable(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === TABLE;
 }
 const _contentType = Symbol("content-type");
 const INLINE_LIST = Symbol("inline-list");
-function InlineList(type11) {
+function InlineList(type) {
     return Object.defineProperties([], {
         [_type]: {
             value: INLINE_LIST
         },
         [_contentType]: {
-            value: type11
+            value: type
         }
     });
 }
-function isInlineList(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === INLINE_LIST;
+function isInlineList(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === INLINE_LIST;
 }
 const LIST = Symbol("list");
 function List() {
@@ -2019,9 +2019,9 @@ function List() {
         }
     });
 }
-function isList(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === LIST;
+function isList(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === LIST;
 }
 // in an eval, to let bundlers not slurp in a util proxy
 let _custom;
@@ -2032,10 +2032,10 @@ try {
 /* eval require not available in transpiled bundle */ }
 /* istanbul ignore next */ const _inspect = _custom || "inspect";
 class BoxedBigInt {
-    constructor(value11){
+    constructor(value){
         try {
-            this.value = $parcel$global.BigInt.asIntN(64, value11);
-        } catch (_11) {
+            this.value = $parcel$global.BigInt.asIntN(64, value);
+        } catch (_) {
             /* istanbul ignore next */ this.value = null;
         }
         Object.defineProperty(this, _type, {
@@ -2056,12 +2056,12 @@ class BoxedBigInt {
     }
 }
 const INTEGER = Symbol("integer");
-function Integer(value11) {
-    let num11 = Number(value11);
+function Integer(value) {
+    let num = Number(value);
     // -0 is a float thing, not an int thing
-    if (Object.is(num11, -0)) num11 = 0;
-    /* istanbul ignore else */ if ($parcel$global.BigInt && !Number.isSafeInteger(num11)) return new BoxedBigInt(value11);
-    else /* istanbul ignore next */ return Object.defineProperties(new Number(num11), {
+    if (Object.is(num, -0)) num = 0;
+    /* istanbul ignore else */ if ($parcel$global.BigInt && !Number.isSafeInteger(num)) return new BoxedBigInt(value);
+    else /* istanbul ignore next */ return Object.defineProperties(new Number(num), {
         isNaN: {
             value: function() {
                 return isNaN(this);
@@ -2071,35 +2071,35 @@ function Integer(value11) {
             value: INTEGER
         },
         [_inspect]: {
-            value: ()=>`[Integer: ${value11}]`
+            value: ()=>`[Integer: ${value}]`
         }
     });
 }
-function isInteger(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === INTEGER;
+function isInteger(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === INTEGER;
 }
 const FLOAT = Symbol("float");
-function Float(value11) {
-    /* istanbul ignore next */ return Object.defineProperties(new Number(value11), {
+function Float(value) {
+    /* istanbul ignore next */ return Object.defineProperties(new Number(value), {
         [_type]: {
             value: FLOAT
         },
         [_inspect]: {
-            value: ()=>`[Float: ${value11}]`
+            value: ()=>`[Float: ${value}]`
         }
     });
 }
-function isFloat(obj11) {
-    if (obj11 === null || typeof obj11 !== "object") return false;
-    return obj11[_type] === FLOAT;
+function isFloat(obj) {
+    if (obj === null || typeof obj !== "object") return false;
+    return obj[_type] === FLOAT;
 }
-function tomlType(value11) {
-    const type11 = typeof value11;
-    if (type11 === "object") {
-        /* istanbul ignore if */ if (value11 === null) return "null";
-        if (value11 instanceof Date) return "datetime";
-        /* istanbul ignore else */ if (_type in value11) switch(value11[_type]){
+function tomlType(value) {
+    const type = typeof value;
+    if (type === "object") {
+        /* istanbul ignore if */ if (value === null) return "null";
+        if (value instanceof Date) return "datetime";
+        /* istanbul ignore else */ if (_type in value) switch(value[_type]){
             case INLINE_TABLE:
                 return "inline-table";
             case INLINE_LIST:
@@ -2114,10 +2114,10 @@ function tomlType(value11) {
                 return "integer";
         }
     }
-    return type11;
+    return type;
 }
-function makeParserClass(Parser11) {
-    class TOMLParser11 extends Parser11 {
+function makeParserClass(Parser) {
+    class TOMLParser extends Parser {
         constructor(){
             super();
             this.ctx = this.obj = Table();
@@ -2126,10 +2126,10 @@ function makeParserClass(Parser11) {
             return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
         }
         atEndOfLine() {
-            return this.char === Parser11.END || this.char === CTRL_J || this.char === CTRL_M;
+            return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
         }
         parseStart() {
-            if (this.char === Parser11.END) return null;
+            if (this.char === Parser.END) return null;
             else if (this.char === CHAR_LSQB) return this.call(this.parseTableOrList);
             else if (this.char === CHAR_NUM) return this.call(this.parseComment);
             else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) return null;
@@ -2141,32 +2141,32 @@ function makeParserClass(Parser11) {
         parseWhitespaceToEOL() {
             if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) return null;
             else if (this.char === CHAR_NUM) return this.goto(this.parseComment);
-            else if (this.char === Parser11.END || this.char === CTRL_J) return this.return();
+            else if (this.char === Parser.END || this.char === CTRL_J) return this.return();
             else throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
         }
         /* ASSIGNMENT: key = value */ parseAssignStatement() {
             return this.callNow(this.parseAssign, this.recordAssignStatement);
         }
-        recordAssignStatement(kv11) {
-            let target11 = this.ctx;
-            let finalKey11 = kv11.key.pop();
-            for (let kw11 of kv11.key){
-                if (hasKey(target11, kw11) && (!isTable(target11[kw11]) || target11[kw11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
-                target11 = target11[kw11] = target11[kw11] || Table();
+        recordAssignStatement(kv) {
+            let target = this.ctx;
+            let finalKey = kv.key.pop();
+            for (let kw of kv.key){
+                if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                target = target[kw] = target[kw] || Table();
             }
-            if (hasKey(target11, finalKey11)) throw this.error(new TomlError("Can't redefine existing key"));
+            if (hasKey(target, finalKey)) throw this.error(new TomlError("Can't redefine existing key"));
             // unbox our numbers
-            if (isInteger(kv11.value) || isFloat(kv11.value)) target11[finalKey11] = kv11.value.valueOf();
-            else target11[finalKey11] = kv11.value;
+            if (isInteger(kv.value) || isFloat(kv.value)) target[finalKey] = kv.value.valueOf();
+            else target[finalKey] = kv.value;
             return this.goto(this.parseWhitespaceToEOL);
         }
         /* ASSSIGNMENT expression, key = value possibly inside an inline table */ parseAssign() {
             return this.callNow(this.parseKeyword, this.recordAssignKeyword);
         }
-        recordAssignKeyword(key11) {
-            if (this.state.resultTable) this.state.resultTable.push(key11);
+        recordAssignKeyword(key) {
+            if (this.state.resultTable) this.state.resultTable.push(key);
             else this.state.resultTable = [
-                key11
+                key
             ];
             return this.goto(this.parseAssignKeywordPreDot);
         }
@@ -2185,15 +2185,15 @@ function makeParserClass(Parser11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseValue, this.recordAssignValue);
         }
-        recordAssignValue(value11) {
+        recordAssignValue(value) {
             return this.returnNow({
                 key: this.state.resultTable,
-                value: value11
+                value: value
             });
         }
         /* COMMENTS: #...eol */ parseComment() {
             do {
-                if (this.char === Parser11.END || this.char === CTRL_J) return this.return();
+                if (this.char === Parser.END || this.char === CTRL_J) return this.return();
             }while (this.nextChar());
         }
         /* TABLES AND LISTS, [foo] and [[foo]] */ parseTableOrList() {
@@ -2208,19 +2208,19 @@ function makeParserClass(Parser11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseKeyword, this.parseTableMore);
         }
-        parseTableMore(keyword11) {
+        parseTableMore(keyword) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else if (this.char === CHAR_RSQB) {
-                if (hasKey(this.ctx, keyword11) && (!isTable(this.ctx[keyword11]) || this.ctx[keyword11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
                 else {
-                    this.ctx = this.ctx[keyword11] = this.ctx[keyword11] || Table();
+                    this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
                     this.ctx[_declared] = true;
                 }
                 return this.next(this.parseWhitespaceToEOL);
             } else if (this.char === CHAR_PERIOD) {
-                if (!hasKey(this.ctx, keyword11)) this.ctx = this.ctx[keyword11] = Table();
-                else if (isTable(this.ctx[keyword11])) this.ctx = this.ctx[keyword11];
-                else if (isList(this.ctx[keyword11])) this.ctx = this.ctx[keyword11][this.ctx[keyword11].length - 1];
+                if (!hasKey(this.ctx, keyword)) this.ctx = this.ctx[keyword] = Table();
+                else if (isTable(this.ctx[keyword])) this.ctx = this.ctx[keyword];
+                else if (isList(this.ctx[keyword])) this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
                 else throw this.error(new TomlError("Can't redefine existing key"));
                 return this.next(this.parseTableNext);
             } else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
@@ -2233,33 +2233,33 @@ function makeParserClass(Parser11) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else return this.callNow(this.parseKeyword, this.parseListMore);
         }
-        parseListMore(keyword11) {
+        parseListMore(keyword) {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
             else if (this.char === CHAR_RSQB) {
-                if (!hasKey(this.ctx, keyword11)) this.ctx[keyword11] = List();
-                if (isInlineList(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline array"));
-                else if (isList(this.ctx[keyword11])) {
-                    const next11 = Table();
-                    this.ctx[keyword11].push(next11);
-                    this.ctx = next11;
+                if (!hasKey(this.ctx, keyword)) this.ctx[keyword] = List();
+                if (isInlineList(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline array"));
+                else if (isList(this.ctx[keyword])) {
+                    const next = Table();
+                    this.ctx[keyword].push(next);
+                    this.ctx = next;
                 } else throw this.error(new TomlError("Can't redefine an existing key"));
                 return this.next(this.parseListEnd);
             } else if (this.char === CHAR_PERIOD) {
-                if (!hasKey(this.ctx, keyword11)) this.ctx = this.ctx[keyword11] = Table();
-                else if (isInlineList(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline array"));
-                else if (isInlineTable(this.ctx[keyword11])) throw this.error(new TomlError("Can't extend an inline table"));
-                else if (isList(this.ctx[keyword11])) this.ctx = this.ctx[keyword11][this.ctx[keyword11].length - 1];
-                else if (isTable(this.ctx[keyword11])) this.ctx = this.ctx[keyword11];
+                if (!hasKey(this.ctx, keyword)) this.ctx = this.ctx[keyword] = Table();
+                else if (isInlineList(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline array"));
+                else if (isInlineTable(this.ctx[keyword])) throw this.error(new TomlError("Can't extend an inline table"));
+                else if (isList(this.ctx[keyword])) this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+                else if (isTable(this.ctx[keyword])) this.ctx = this.ctx[keyword];
                 else throw this.error(new TomlError("Can't redefine an existing key"));
                 return this.next(this.parseListNext);
             } else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
         }
-        parseListEnd(keyword11) {
+        parseListEnd(keyword) {
             if (this.char === CHAR_RSQB) return this.next(this.parseWhitespaceToEOL);
             else throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
         }
         /* VALUE string, number, boolean, inline list, inline object */ parseValue() {
-            if (this.char === Parser11.END) throw this.error(new TomlError("Key without value"));
+            if (this.char === Parser.END) throw this.error(new TomlError("Key without value"));
             else if (this.char === CHAR_QUOT) return this.next(this.parseDoubleString);
             if (this.char === CHAR_APOS) return this.next(this.parseSingleString);
             else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) return this.goto(this.parseNumberSign);
@@ -2271,8 +2271,8 @@ function makeParserClass(Parser11) {
             else if (this.char === CHAR_LCUB) return this.call(this.parseInlineTable, this.recordValue);
             else throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
         }
-        recordValue(value11) {
-            return this.returnNow(value11);
+        recordValue(value) {
+            return this.returnNow(value);
         }
         parseInf() {
             if (this.char === CHAR_n) return this.next(this.parseInf2);
@@ -2299,7 +2299,7 @@ function makeParserClass(Parser11) {
         }
         /* KEYS: barewords */ parseBareKey() {
             do {
-                if (this.char === Parser11.END) throw this.error(new TomlError("Key ended without value"));
+                if (this.char === Parser.END) throw this.error(new TomlError("Key ended without value"));
                 else if (isAlphaNumHyphen(this.char)) this.consume();
                 else if (this.state.buf.length === 0) throw this.error(new TomlError("Empty bare keys are not allowed"));
                 else return this.returnNow();
@@ -2329,7 +2329,7 @@ function makeParserClass(Parser11) {
         parseLiteralMultiStringContent() {
             do {
                 if (this.char === CHAR_APOS) return this.next(this.parseLiteralMultiEnd);
-                else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated multi-line string"));
+                else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated multi-line string"));
                 else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) throw this.errorControlCharInString();
                 else this.consume();
             }while (this.nextChar());
@@ -2361,8 +2361,8 @@ function makeParserClass(Parser11) {
                 else this.consume();
             }while (this.nextChar());
         }
-        recordEscapeReplacement(replacement11) {
-            this.state.buf += replacement11;
+        recordEscapeReplacement(replacement) {
+            this.state.buf += replacement;
             return this.goto(this.parseBasicString);
         }
         parseMultiStringMaybe() {
@@ -2378,19 +2378,19 @@ function makeParserClass(Parser11) {
             do {
                 if (this.char === CHAR_BSOL) return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
                 else if (this.char === CHAR_QUOT) return this.next(this.parseMultiEnd);
-                else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated multi-line string"));
+                else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated multi-line string"));
                 else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) throw this.errorControlCharInString();
                 else this.consume();
             }while (this.nextChar());
         }
         errorControlCharInString() {
-            let displayCode11 = "\\u00";
-            if (this.char < 16) displayCode11 += "0";
-            displayCode11 += this.char.toString(16);
-            return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode11} instead`));
+            let displayCode = "\\u00";
+            if (this.char < 16) displayCode += "0";
+            displayCode += this.char.toString(16);
+            return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
         }
-        recordMultiEscapeReplacement(replacement11) {
-            this.state.buf += replacement11;
+        recordMultiEscapeReplacement(replacement) {
+            this.state.buf += replacement;
             return this.goto(this.parseMultiStringContent);
         }
         parseMultiEnd() {
@@ -2428,13 +2428,13 @@ function makeParserClass(Parser11) {
             else if (this.char === CHAR_U) return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
             else throw this.error(new TomlError("Unknown escape character: " + this.char));
         }
-        parseUnicodeReturn(char11) {
+        parseUnicodeReturn(char) {
             try {
-                const codePoint11 = parseInt(char11, 16);
-                if (codePoint11 >= SURROGATE_FIRST && codePoint11 <= SURROGATE_LAST) throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
-                return this.returnNow(String.fromCodePoint(codePoint11));
-            } catch (err11) {
-                throw this.error(TomlError.wrap(err11));
+                const codePoint = parseInt(char, 16);
+                if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+                return this.returnNow(String.fromCodePoint(codePoint));
+            } catch (err) {
+                throw this.error(TomlError.wrap(err));
             }
         }
         parseSmallUnicode() {
@@ -2485,9 +2485,9 @@ function makeParserClass(Parser11) {
                 this.consume();
                 return this.call(this.parseNoUnder, this.parseNumberFloat);
             } else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         parseNoUnder() {
@@ -2565,27 +2565,27 @@ function makeParserClass(Parser11) {
             if (isHexit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         parseIntegerOct() {
             if (isOctit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         parseIntegerBin() {
             if (isBit(this.char)) this.consume();
             else if (this.char === CHAR_LOWBAR) return this.call(this.parseNoUnder);
             else {
-                const result11 = Integer(this.state.buf);
-                /* istanbul ignore if */ if (result11.isNaN()) throw this.error(new TomlError("Invalid number"));
-                else return this.returnNow(result11);
+                const result = Integer(this.state.buf);
+                /* istanbul ignore if */ if (result.isNaN()) throw this.error(new TomlError("Invalid number"));
+                else return this.returnNow(result);
             }
         }
         /* DATETIME */ parseDateTime() {
@@ -2774,20 +2774,20 @@ function makeParserClass(Parser11) {
         }
         /* INLINE LISTS */ parseInlineList() {
             if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) return null;
-            else if (this.char === Parser11.END) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser.END) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_NUM) return this.call(this.parseComment);
             else if (this.char === CHAR_RSQB) return this.return(this.state.resultArr || InlineList());
             else return this.callNow(this.parseValue, this.recordInlineListValue);
         }
-        recordInlineListValue(value11) {
+        recordInlineListValue(value) {
             if (this.state.resultArr) {
-                const listType11 = this.state.resultArr[_contentType];
-                const valueType11 = tomlType(value11);
-                if (listType11 !== valueType11) throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType11} and ${valueType11}`));
-            } else this.state.resultArr = InlineList(tomlType(value11));
-            if (isFloat(value11) || isInteger(value11)) // unbox now that we've verified they're ok
-            this.state.resultArr.push(value11.valueOf());
-            else this.state.resultArr.push(value11);
+                const listType = this.state.resultArr[_contentType];
+                const valueType = tomlType(value);
+                if (listType !== valueType) throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
+            } else this.state.resultArr = InlineList(tomlType(value));
+            if (isFloat(value) || isInteger(value)) // unbox now that we've verified they're ok
+            this.state.resultArr.push(value.valueOf());
+            else this.state.resultArr.push(value);
             return this.goto(this.parseInlineListNext);
         }
         parseInlineListNext() {
@@ -2799,34 +2799,34 @@ function makeParserClass(Parser11) {
         }
         /* INLINE TABLE */ parseInlineTable() {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
-            else if (this.char === Parser11.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_RCUB) return this.return(this.state.resultTable || InlineTable());
             else {
                 if (!this.state.resultTable) this.state.resultTable = InlineTable();
                 return this.callNow(this.parseAssign, this.recordInlineTableValue);
             }
         }
-        recordInlineTableValue(kv11) {
-            let target11 = this.state.resultTable;
-            let finalKey11 = kv11.key.pop();
-            for (let kw11 of kv11.key){
-                if (hasKey(target11, kw11) && (!isTable(target11[kw11]) || target11[kw11][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
-                target11 = target11[kw11] = target11[kw11] || Table();
+        recordInlineTableValue(kv) {
+            let target = this.state.resultTable;
+            let finalKey = kv.key.pop();
+            for (let kw of kv.key){
+                if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) throw this.error(new TomlError("Can't redefine existing key"));
+                target = target[kw] = target[kw] || Table();
             }
-            if (hasKey(target11, finalKey11)) throw this.error(new TomlError("Can't redefine existing key"));
-            if (isInteger(kv11.value) || isFloat(kv11.value)) target11[finalKey11] = kv11.value.valueOf();
-            else target11[finalKey11] = kv11.value;
+            if (hasKey(target, finalKey)) throw this.error(new TomlError("Can't redefine existing key"));
+            if (isInteger(kv.value) || isFloat(kv.value)) target[finalKey] = kv.value.valueOf();
+            else target[finalKey] = kv.value;
             return this.goto(this.parseInlineTableNext);
         }
         parseInlineTableNext() {
             if (this.char === CHAR_SP || this.char === CTRL_I) return null;
-            else if (this.char === Parser11.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
+            else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) throw this.error(new TomlError("Unterminated inline array"));
             else if (this.char === CHAR_COMMA) return this.next(this.parseInlineTable);
             else if (this.char === CHAR_RCUB) return this.goto(this.parseInlineTable);
             else throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
         }
     }
-    return TOMLParser11;
+    return TOMLParser;
 }
 
 });