prettier 1.17.0 → 1.18.2

package/index.js

@@ -12,7 +12,7 @@ var thirdParty = require('./third-party');
 var thirdParty__default = thirdParty['default'];
 
 var name = "prettier";
-var version$1 = "1.17.0";
+var version$1 = "1.18.2";
 var description = "Prettier is an opinionated code formatter";
 var bin = {
   "prettier": "./bin/prettier.js"
@@ -29,8 +29,8 @@ var dependencies = {
   "@angular/compiler": "7.2.9",
   "@babel/code-frame": "7.0.0",
   "@babel/parser": "7.2.0",
-  "@glimmer/syntax": "0.30.3",
-  "@iarna/toml": "2.0.0",
+  "@glimmer/syntax": "0.38.4",
+  "@iarna/toml": "2.2.3",
   "@typescript-eslint/typescript-estree": "1.6.0",
   "angular-estree-parser": "1.1.5",
   "angular-html-parser": "1.2.0",
@@ -108,7 +108,7 @@ var devDependencies = {
   "jest-snapshot-serializer-raw": "1.1.0",
   "jest-watch-typeahead": "0.1.0",
   "mkdirp": "0.5.1",
-  "prettier": "1.16.4",
+  "prettier": "1.18.0",
   "prettylint": "1.0.0",
   "rimraf": "2.6.2",
   "rollup": "0.47.6",
@@ -176,10 +176,6 @@ var _package$1 = Object.freeze({
 	default: _package
 });
 
-var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-
-
 function unwrapExports (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -11566,7 +11562,7 @@ function printString(raw, options, isDirectiveLiteral) {
   // sure that we consistently output the minimum amount of escaped quotes.
 
 
-  return makeString(rawContent, enclosingQuote, !(options.parser === "css" || options.parser === "less" || options.parser === "scss" || options.parentParser === "html" || options.parentParser === "vue" || options.parentParser === "angular" || options.parentParser === "lwc"));
+  return makeString(rawContent, enclosingQuote, !(options.parser === "css" || options.parser === "less" || options.parser === "scss" || options.embeddedInHtml));
 }
 
 function makeString(rawContent, enclosingQuote, unescapeUnnecessaryEscapes) {
@@ -11622,6 +11618,53 @@ function getMaxContinuousCount(str, target) {
   }, 0);
 }
 
+function getMinNotPresentContinuousCount(str, target) {
+  var matches = str.match(new RegExp(`(${escapeStringRegexp(target)})+`, "g"));
+
+  if (matches === null) {
+    return 0;
+  }
+
+  var countPresent = new Map();
+  var max = 0;
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = matches[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var match = _step.value;
+      var count = match.length / target.length;
+      countPresent.set(count, true);
+
+      if (count > max) {
+        max = count;
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  for (var i = 1; i < max; i++) {
+    if (!countPresent.get(i)) {
+      return i;
+    }
+  }
+
+  return max + 1;
+}
+
 function getStringWidth$1(text) {
   if (!text) {
     return 0;
@@ -11712,13 +11755,13 @@ function isWithinParentArrayProperty(path$$1, propertyName) {
 
 function replaceEndOfLineWith(text, replacement) {
   var parts = [];
-  var _iteratorNormalCompletion = true;
-  var _didIteratorError = false;
-  var _iteratorError = undefined;
+  var _iteratorNormalCompletion2 = true;
+  var _didIteratorError2 = false;
+  var _iteratorError2 = undefined;
 
   try {
-    for (var _iterator = text.split("\n")[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-      var part = _step.value;
+    for (var _iterator2 = text.split("\n")[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var part = _step2.value;
 
       if (parts.length !== 0) {
         parts.push(replacement);
@@ -11727,16 +11770,16 @@ function replaceEndOfLineWith(text, replacement) {
       parts.push(part);
     }
   } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
   } finally {
     try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
       }
     } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
+      if (_didIteratorError2) {
+        throw _iteratorError2;
       }
     }
   }
@@ -11748,6 +11791,7 @@ var util$1 = {
   replaceEndOfLineWith,
   getStringWidth: getStringWidth$1,
   getMaxContinuousCount,
+  getMinNotPresentContinuousCount,
   getPrecedence,
   shouldFlatten,
   isBitwiseOperator,
@@ -12638,6 +12682,7 @@ var docUtils = {
   willBreak,
   isLineNext,
   traverseDoc,
+  findInDoc,
   mapDoc: mapDoc$1,
   propagateBreaks,
   removeLines,
@@ -13449,6 +13494,7 @@ function printSubtree(path$$1, print, options$$1, printAstToDoc) {
 function textToDoc(text, partialNextOptions, parentOptions, printAstToDoc) {
   var nextOptions = normalize$3(Object.assign({}, parentOptions, partialNextOptions, {
     parentParser: parentOptions.parser,
+    embeddedInHtml: !!(parentOptions.embeddedInHtml || parentOptions.parser === "html" || parentOptions.parser === "vue" || parentOptions.parser === "angular" || parentOptions.parser === "lwc"),
     originalText: text
   }), {
     passThrough: true
@@ -13516,7 +13562,7 @@ function printAstToDoc(ast, options) {
 
     var res;
 
-    if (printer.willPrintOwnComments && printer.willPrintOwnComments(path$$1)) {
+    if (printer.willPrintOwnComments && printer.willPrintOwnComments(path$$1, options)) {
       res = callPluginPrintFunction(path$$1, options, printGenerically, args);
     } else {
       // printComments will call the plugin print function and check for
@@ -13963,7 +14009,6 @@ function formatRange(text, opts) {
   var rangeResult = coreFormat(rangeString, Object.assign({}, opts, {
     rangeStart: 0,
     rangeEnd: Infinity,
-    printWidth: opts.printWidth - alignmentSize,
     // track the cursor offset only if it's within our range
     cursorOffset: opts.cursorOffset >= rangeStart && opts.cursorOffset < rangeEnd ? opts.cursorOffset - rangeStart : -1
   }), alignmentSize); // Since the range contracts to avoid trailing whitespace,
@@ -14753,7 +14798,7 @@ var lodash_uniqby = createCommonjsModule(function (module, exports) {
   typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
   /** Detect free variable `global` from Node.js. */
 
-  var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
   /** Detect free variable `self`. */
 
   var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
@@ -17206,7 +17251,7 @@ var REJECTED = 'rejected';
 
 var NOOP = function NOOP() {};
 
-var isNode = typeof commonjsGlobal !== 'undefined' && typeof commonjsGlobal.process !== 'undefined' && typeof commonjsGlobal.process.emit === 'function';
+var isNode = typeof global !== 'undefined' && typeof global.process !== 'undefined' && typeof global.process.emit === 'function';
 var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;
 var asyncQueue = [];
 var asyncTimer;
@@ -17354,12 +17399,12 @@ function publishRejection(promise) {
   publish(promise);
 
   if (!promise._handled && isNode) {
-    commonjsGlobal.process.emit('unhandledRejection', promise._data, promise);
+    global.process.emit('unhandledRejection', promise._data, promise);
   }
 }
 
 function notifyRejectionHandled(promise) {
-  commonjsGlobal.process.emit('rejectionHandled', promise);
+  global.process.emit('rejectionHandled', promise);
 }
 /**
  * @class
@@ -17538,7 +17583,7 @@ var arrayUniq = createCommonjsModule(function (module) {
     return ret === true;
   }
 
-  if ('Set' in commonjsGlobal) {
+  if ('Set' in global) {
     if (typeof Set.prototype.forEach === 'function' && doesForEachActuallyWork()) {
       module.exports = uniqSetWithForEach;
     } else {
@@ -20822,7 +20867,7 @@ var timers = true;
 var tls = true;
 var tty = true;
 var url = true;
-var util$4 = true;
+var util$3 = true;
 var v8 = ">= 1";
 var vm = true;
 var zlib = true;
@@ -20864,7 +20909,7 @@ var core$3 = {
   tls: tls,
   tty: tty,
   url: url,
-  util: util$4,
+  util: util$3,
   v8: v8,
   vm: vm,
   zlib: zlib
@@ -20908,7 +20953,7 @@ var core$4 = Object.freeze({
 	tls: tls,
 	tty: tty,
 	url: url,
-	util: util$4,
+	util: util$3,
 	v8: v8,
 	vm: vm,
 	zlib: zlib,
@@ -21681,7 +21726,7 @@ function handleCommentInEmptyParens(text, enclosingNode, comment, options) {
   // i.e. a function without any argument.
 
 
-  if (enclosingNode && ((enclosingNode.type === "FunctionDeclaration" || enclosingNode.type === "FunctionExpression" || enclosingNode.type === "ArrowFunctionExpression" && (enclosingNode.body.type !== "CallExpression" || enclosingNode.body.arguments.length === 0) || enclosingNode.type === "ClassMethod" || enclosingNode.type === "ObjectMethod") && enclosingNode.params.length === 0 || (enclosingNode.type === "CallExpression" || enclosingNode.type === "NewExpression") && enclosingNode.arguments.length === 0)) {
+  if (enclosingNode && ((enclosingNode.type === "FunctionDeclaration" || enclosingNode.type === "FunctionExpression" || enclosingNode.type === "ArrowFunctionExpression" || enclosingNode.type === "ClassMethod" || enclosingNode.type === "ObjectMethod") && enclosingNode.params.length === 0 || (enclosingNode.type === "CallExpression" || enclosingNode.type === "NewExpression") && enclosingNode.arguments.length === 0)) {
     addDanglingComment$2(enclosingNode, comment);
     return true;
   }
@@ -21911,9 +21956,7 @@ var _require$$1$utils = doc.utils;
 var mapDoc$3 = _require$$1$utils.mapDoc;
 var stripTrailingHardline$1 = _require$$1$utils.stripTrailingHardline;
 
-function embed(path$$1, print, textToDoc
-/*, options */
-) {
+function embed(path$$1, print, textToDoc, options) {
   var node = path$$1.getValue();
   var parent = path$$1.getParentNode();
   var parentParent = path$$1.getParentNode(1);
@@ -22019,12 +22062,10 @@ function embed(path$$1, print, textToDoc
           return concat$5(["`", indent$3(concat$5([hardline$4, join$3(hardline$4, parts)])), hardline$4, "`"]);
         }
 
-        if (isHtml(path$$1)) {
-          return printHtmlTemplateLiteral(path$$1, print, textToDoc, "html");
-        }
+        var htmlParser = isHtml(path$$1) ? "html" : isAngularComponentTemplate(path$$1) ? "angular" : undefined;
 
-        if (isAngularComponentTemplate(path$$1)) {
-          return printHtmlTemplateLiteral(path$$1, print, textToDoc, "angular");
+        if (htmlParser) {
+          return printHtmlTemplateLiteral(path$$1, print, textToDoc, htmlParser, options.embeddedInHtml);
         }
 
         break;
@@ -22064,6 +22105,10 @@ function getIndentation(str) {
   return firstMatchedIndent === null ? "" : firstMatchedIndent[1];
 }
 
+function uncook(cookedValue) {
+  return cookedValue.replace(/([\\`]|\$\{)/g, "\\$1");
+}
+
 function escapeTemplateCharacters(doc$$2, raw) {
   return mapDoc$3(doc$$2, function (currentDoc) {
     if (!currentDoc.parts) {
@@ -22073,7 +22118,7 @@ function escapeTemplateCharacters(doc$$2, raw) {
     var parts = [];
     currentDoc.parts.forEach(function (part) {
       if (typeof part === "string") {
-        parts.push(raw ? part.replace(/(\\*)`/g, "$1$1\\`") : part.replace(/([\\`]|\$\{)/g, "\\$1"));
+        parts.push(raw ? part.replace(/(\\*)`/g, "$1$1\\`") : uncook(part));
       } else {
         parts.push(part);
       }
@@ -22184,8 +22229,11 @@ function printGraphqlComments(lines) {
   return parts.length === 0 ? null : join$3(hardline$4, parts);
 }
 /**
- * Template literal in this context:
+ * Template literal in these contexts:
  * <style jsx>{`div{color:red}`}</style>
+ * css``
+ * css.global``
+ * css.resolve``
  */
 
 
@@ -22195,7 +22243,7 @@ function isStyledJsx(path$$1) {
   var parentParent = path$$1.getParentNode(1);
   return parentParent && node.quasis && parent.type === "JSXExpressionContainer" && parentParent.type === "JSXElement" && parentParent.openingElement.name.name === "style" && parentParent.openingElement.attributes.some(function (attribute) {
     return attribute.name.name === "jsx";
-  });
+  }) || parent && parent.type === "TaggedTemplateExpression" && parent.tag.type === "Identifier" && parent.tag.name === "css" || parent && parent.type === "TaggedTemplateExpression" && parent.tag.type === "MemberExpression" && parent.tag.object.name === "css" && (parent.tag.property.name === "global" || parent.tag.property.name === "resolve");
 }
 /**
  * Angular Components can have:
@@ -22263,9 +22311,9 @@ function isStyledComponents(path$$1) {
 
     case "CallExpression":
       return (// styled(Component)``
-        isStyledIdentifier(tag.callee) || tag.callee.type === "MemberExpression" && (tag.callee.object.type === "MemberExpression" && ( // styled.foo.attr({})``
-        isStyledIdentifier(tag.callee.object.object) || // Component.extend.attr({)``
-        isStyledExtend(tag.callee.object)) || // styled(Component).attr({})``
+        isStyledIdentifier(tag.callee) || tag.callee.type === "MemberExpression" && (tag.callee.object.type === "MemberExpression" && ( // styled.foo.attrs({})``
+        isStyledIdentifier(tag.callee.object.object) || // Component.extend.attrs({})``
+        isStyledExtend(tag.callee.object)) || // styled(Component).attrs({})``
         tag.callee.object.type === "CallExpression" && isStyledIdentifier(tag.callee.object.callee))
       );
 
@@ -22383,16 +22431,22 @@ function isHtml(path$$1) {
   }, function (node, name) {
     return node.type === "TaggedTemplateExpression" && node.tag.type === "Identifier" && node.tag.name === "html" && name === "quasi";
   }]);
-}
+} // The counter is needed to distinguish nested embeds.
+
 
-function printHtmlTemplateLiteral(path$$1, print, textToDoc, parser) {
+var htmlTemplateLiteralCounter = 0;
+
+function printHtmlTemplateLiteral(path$$1, print, textToDoc, parser, escapeClosingScriptTag) {
   var node = path$$1.getValue();
-  var placeholderPattern = "PRETTIER_HTML_PLACEHOLDER_(\\d+)_IN_JS";
-  var placeholders = node.expressions.map(function (_, i) {
-    return `PRETTIER_HTML_PLACEHOLDER_${i}_IN_JS`;
-  });
+  var counter = htmlTemplateLiteralCounter;
+  htmlTemplateLiteralCounter = htmlTemplateLiteralCounter + 1 >>> 0;
+
+  var composePlaceholder = function composePlaceholder(index) {
+    return `PRETTIER_HTML_PLACEHOLDER_${index}_${counter}_IN_JS`;
+  };
+
   var text = node.quasis.map(function (quasi, index, quasis) {
-    return index === quasis.length - 1 ? quasi.value.raw : quasi.value.raw + placeholders[index];
+    return index === quasis.length - 1 ? quasi.value.cooked : quasi.value.cooked + composePlaceholder(index);
   }).join("");
   var expressionDocs = path$$1.map(print, "expressions");
 
@@ -22400,13 +22454,11 @@ function printHtmlTemplateLiteral(path$$1, print, textToDoc, parser) {
     return "``";
   }
 
+  var placeholderRegex = RegExp(composePlaceholder("(\\d+)"), "g");
   var contentDoc = mapDoc$3(stripTrailingHardline$1(textToDoc(text, {
     parser
   })), function (doc$$2) {
-    var placeholderRegex = new RegExp(placeholderPattern, "g");
-    var hasPlaceholder = typeof doc$$2 === "string" && placeholderRegex.test(doc$$2);
-
-    if (!hasPlaceholder) {
+    if (typeof doc$$2 !== "string") {
       return doc$$2;
     }
 
@@ -22418,6 +22470,12 @@ function printHtmlTemplateLiteral(path$$1, print, textToDoc, parser) {
 
       if (i % 2 === 0) {
         if (component) {
+          component = uncook(component);
+
+          if (escapeClosingScriptTag) {
+            component = component.replace(/<\/(script)\b/gi, "<\\/$1");
+          }
+
           parts.push(component);
         }
 
@@ -22817,35 +22875,97 @@ function hasNode$1(node, fn) {
   });
 }
 
+function hasNakedLeftSide$2(node) {
+  return node.type === "AssignmentExpression" || node.type === "BinaryExpression" || node.type === "LogicalExpression" || node.type === "NGPipeExpression" || node.type === "ConditionalExpression" || node.type === "CallExpression" || node.type === "OptionalCallExpression" || node.type === "MemberExpression" || node.type === "OptionalMemberExpression" || node.type === "SequenceExpression" || node.type === "TaggedTemplateExpression" || node.type === "BindExpression" || node.type === "UpdateExpression" && !node.prefix || node.type === "TSAsExpression" || node.type === "TSNonNullExpression";
+}
+
+function getLeftSide$1(node) {
+  if (node.expressions) {
+    return node.expressions[0];
+  }
+
+  return node.left || node.test || node.callee || node.object || node.tag || node.argument || node.expression;
+}
+
+function getLeftSidePathName$2(path$$1, node) {
+  if (node.expressions) {
+    return ["expressions", 0];
+  }
+
+  if (node.left) {
+    return ["left"];
+  }
+
+  if (node.test) {
+    return ["test"];
+  }
+
+  if (node.object) {
+    return ["object"];
+  }
+
+  if (node.callee) {
+    return ["callee"];
+  }
+
+  if (node.tag) {
+    return ["tag"];
+  }
+
+  if (node.argument) {
+    return ["argument"];
+  }
+
+  if (node.expression) {
+    return ["expression"];
+  }
+
+  throw new Error("Unexpected node has no left side", node);
+}
+
 var utils$4 = {
+  getLeftSide: getLeftSide$1,
+  getLeftSidePathName: getLeftSidePathName$2,
+  hasNakedLeftSide: hasNakedLeftSide$2,
   hasNode: hasNode$1,
   hasFlowShorthandAnnotationComment: hasFlowShorthandAnnotationComment$2,
   hasFlowAnnotationComment: hasFlowAnnotationComment$1
 };
 
+var getLeftSidePathName$1 = utils$4.getLeftSidePathName;
+var hasNakedLeftSide$1 = utils$4.hasNakedLeftSide;
 var hasFlowShorthandAnnotationComment$1 = utils$4.hasFlowShorthandAnnotationComment;
 
-function hasClosureCompilerTypeCastComment(text, path$$1, locStart, locEnd) {
+function hasClosureCompilerTypeCastComment(text, path$$1) {
   // https://github.com/google/closure-compiler/wiki/Annotating-Types#type-casts
   // Syntax example: var x = /** @type {string} */ (fruit);
   var n = path$$1.getValue();
-  return util$1.getNextNonSpaceNonCommentCharacter(text, n, locEnd) === ")" && (hasTypeCastComment(n) || hasAncestorTypeCastComment(0)); // for sub-item: /** @type {array} */ (numberOrString).map(x => x);
+  return isParenthesized(n) && (hasTypeCastComment(n) || hasAncestorTypeCastComment(0)); // for sub-item: /** @type {array} */ (numberOrString).map(x => x);
 
   function hasAncestorTypeCastComment(index) {
     var ancestor = path$$1.getParentNode(index);
-    return ancestor && util$1.getNextNonSpaceNonCommentCharacter(text, ancestor, locEnd) !== ")" && /^[\s(]*$/.test(text.slice(locStart(ancestor), locStart(n))) ? hasTypeCastComment(ancestor) || hasAncestorTypeCastComment(index + 1) : false;
+    return ancestor && !isParenthesized(ancestor) ? hasTypeCastComment(ancestor) || hasAncestorTypeCastComment(index + 1) : false;
   }
 
   function hasTypeCastComment(node) {
     return node.comments && node.comments.some(function (comment) {
-      return comment.leading && comments$3.isBlockComment(comment) && isTypeCastComment(comment.value) && util$1.getNextNonSpaceNonCommentCharacter(text, comment, locEnd) === "(";
+      return comment.leading && comments$3.isBlockComment(comment) && isTypeCastComment(comment.value);
     });
   }
 
+  function isParenthesized(node) {
+    // Closure typecast comments only really make sense when _not_ using
+    // typescript or flow parsers, so we take advantage of the babel parser's
+    // parenthesized expressions.
+    return node.extra && node.extra.parenthesized;
+  }
+
   function isTypeCastComment(comment) {
-    var trimmed = comment.trim();
+    var cleaned = comment.trim().split("\n").map(function (line) {
+      return line.replace(/^[\s*]+/, "");
+    }).join(" ").trim();
 
-    if (!/^\*\s*@type\s*\{[^]+\}$/.test(trimmed)) {
+    if (!/^@type\s*\{[^]+\}$/.test(cleaned)) {
       return false;
     }
 
@@ -22856,7 +22976,7 @@ function hasClosureCompilerTypeCastComment(text, path$$1, locStart, locEnd) {
     var _iteratorError = undefined;
 
     try {
-      for (var _iterator = trimmed[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      for (var _iterator = cleaned[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
         var char = _step.value;
 
         if (char === "{") {
@@ -22924,7 +23044,7 @@ function needsParens(path$$1, options) {
   // parentheses.
 
 
-  if (hasClosureCompilerTypeCastComment(options.originalText, path$$1, options.locStart, options.locEnd)) {
+  if (hasClosureCompilerTypeCastComment(options.originalText, path$$1)) {
     return true;
   }
 
@@ -22937,6 +23057,15 @@ function needsParens(path$$1, options) {
 
 
   if (node.type === "Identifier") {
+    // ...unless those identifiers are embed placeholders. They might be substituted by complex
+    // expressions, so the parens around them should not be dropped. Example (JS-in-HTML-in-JS):
+    //     let tpl = html`<script> f((${expr}) / 2); </script>`;
+    // If the inner JS formatter removes the parens, the expression might change its meaning:
+    //     f((a + b) / 2)  vs  f(a + b / 2)
+    if (node.extra && node.extra.parenthesized && /^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/.test(node.name)) {
+      return true;
+    }
+
     return false;
   }
 
@@ -22948,6 +23077,13 @@ function needsParens(path$$1, options) {
 
   if ((parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.superClass === node && (node.type === "ArrowFunctionExpression" || node.type === "AssignmentExpression" || node.type === "AwaitExpression" || node.type === "BinaryExpression" || node.type === "ConditionalExpression" || node.type === "LogicalExpression" || node.type === "NewExpression" || node.type === "ObjectExpression" || node.type === "ParenthesizedExpression" || node.type === "SequenceExpression" || node.type === "TaggedTemplateExpression" || node.type === "UnaryExpression" || node.type === "UpdateExpression" || node.type === "YieldExpression")) {
     return true;
+  } // `export default function` or `export default class` can't be followed by
+  // anything after. So an expression like `export default (function(){}).toString()`
+  // needs to be followed by a parentheses
+
+
+  if (parent.type === "ExportDefaultDeclaration") {
+    return shouldWrapFunctionForExportDefault(path$$1, options);
   }
 
   if (parent.type === "Decorator" && parent.expression === node) {
@@ -22999,9 +23135,11 @@ function needsParens(path$$1, options) {
     case "CallExpression":
       {
         var firstParentNotMemberExpression = parent;
-        var i = 0;
+        var i = 0; // tagged templates are basically member expressions from a grammar perspective
+        // see https://tc39.github.io/ecma262/#prod-MemberExpression
+        // so are typescript's non-null assertions, though there's no grammar to point to
 
-        while (firstParentNotMemberExpression && firstParentNotMemberExpression.type === "MemberExpression") {
+        while (firstParentNotMemberExpression && (firstParentNotMemberExpression.type === "MemberExpression" && firstParentNotMemberExpression.object === path$$1.getParentNode(i - 1) || firstParentNotMemberExpression.type === "TaggedTemplateExpression" || firstParentNotMemberExpression.type === "TSNonNullExpression")) {
           firstParentNotMemberExpression = path$$1.getParentNode(++i);
         }
 
@@ -23105,6 +23243,7 @@ function needsParens(path$$1, options) {
         case "TSTypeAssertion":
         case "TaggedTemplateExpression":
         case "UnaryExpression":
+        case "JSXSpreadAttribute":
         case "SpreadElement":
         case "SpreadProperty":
         case "BindExpression":
@@ -23184,7 +23323,7 @@ function needsParens(path$$1, options) {
         } // Delegate to inner TSParenthesizedType
 
 
-        if (node.typeAnnotation.type === "TSParenthesizedType") {
+        if (node.typeAnnotation.type === "TSParenthesizedType" && parent.type !== "TSArrayType") {
           return false;
         }
 
@@ -23235,6 +23374,7 @@ function needsParens(path$$1, options) {
         case "TSAsExpression":
         case "TSNonNullExpression":
         case "BindExpression":
+        case "OptionalMemberExpression":
           return true;
 
         case "MemberExpression":
@@ -23357,9 +23497,6 @@ function needsParens(path$$1, options) {
           return true;
         // This is basically a kind of IIFE.
 
-        case "ExportDefaultDeclaration":
-          return true;
-
         default:
           return false;
       }
@@ -23394,9 +23531,6 @@ function needsParens(path$$1, options) {
 
     case "ClassExpression":
       switch (parent.type) {
-        case "ExportDefaultDeclaration":
-          return true;
-
         case "NewExpression":
           return name === "callee" && parent.callee === node;
 
@@ -23427,7 +23561,7 @@ function needsParens(path$$1, options) {
       return false;
 
     case "BindExpression":
-      if (parent.type === "BindExpression" && name === "callee" && parent.callee === node || parent.type === "MemberExpression") {
+      if (parent.type === "BindExpression" && name === "callee" && parent.callee === node || parent.type === "MemberExpression" && name === "object" && parent.object === node || parent.type === "NewExpression" && name === "callee" && parent.callee === node) {
         return true;
       }
 
@@ -23509,6 +23643,26 @@ function isFollowedByRightBracket(path$$1) {
   return false;
 }
 
+function shouldWrapFunctionForExportDefault(path$$1, options) {
+  var node = path$$1.getValue();
+  var parent = path$$1.getParentNode();
+
+  if (node.type === "FunctionExpression" || node.type === "ClassExpression") {
+    return parent.type === "ExportDefaultDeclaration" || // in some cases the function is already wrapped
+    // (e.g. `export default (function() {})();`)
+    // in this case we don't need to add extra parens
+    !needsParens(path$$1, options);
+  }
+
+  if (!hasNakedLeftSide$1(node) || parent.type !== "ExportDefaultDeclaration" && needsParens(path$$1, options)) {
+    return false;
+  }
+
+  return path$$1.call.apply(path$$1, [function (childPath) {
+    return shouldWrapFunctionForExportDefault(childPath, options);
+  }].concat(getLeftSidePathName$1(path$$1, node)));
+}
+
 var needsParens_1 = needsParens;
 
 var _require$$0$builders$1 = doc.builders;
@@ -23614,6 +23768,9 @@ var isIdentifierName = utils$2.keyword.isIdentifierNameES5;
 var insertPragma = pragma.insertPragma;
 var printHtmlBinding = htmlBinding.printHtmlBinding;
 var isVueEventBindingExpression = htmlBinding.isVueEventBindingExpression;
+var getLeftSide = utils$4.getLeftSide;
+var getLeftSidePathName = utils$4.getLeftSidePathName;
+var hasNakedLeftSide = utils$4.hasNakedLeftSide;
 var hasNode = utils$4.hasNode;
 var hasFlowAnnotationComment = utils$4.hasFlowAnnotationComment;
 var hasFlowShorthandAnnotationComment = utils$4.hasFlowShorthandAnnotationComment;
@@ -25188,85 +25345,23 @@ function printPathNoParens(path$$1, options, print, args) {
         var expressions = path$$1.map(print, "expressions");
 
         var _parentNode = path$$1.getParentNode();
-        /**
-         * describe.each`table`(name, fn)
-         * describe.only.each`table`(name, fn)
-         * describe.skip.each`table`(name, fn)
-         * test.each`table`(name, fn)
-         * test.only.each`table`(name, fn)
-         * test.skip.each`table`(name, fn)
-         *
-         * Ref: https://github.com/facebook/jest/pull/6102
-         */
-
-
-        var jestEachTriggerRegex = /^[xf]?(describe|it|test)$/;
 
-        if (_parentNode.type === "TaggedTemplateExpression" && _parentNode.quasi === n && _parentNode.tag.type === "MemberExpression" && _parentNode.tag.property.type === "Identifier" && _parentNode.tag.property.name === "each" && (_parentNode.tag.object.type === "Identifier" && jestEachTriggerRegex.test(_parentNode.tag.object.name) || _parentNode.tag.object.type === "MemberExpression" && _parentNode.tag.object.property.type === "Identifier" && (_parentNode.tag.object.property.name === "only" || _parentNode.tag.object.property.name === "skip") && _parentNode.tag.object.object.type === "Identifier" && jestEachTriggerRegex.test(_parentNode.tag.object.object.name))) {
-          /**
-           * a    | b    | expected
-           * ${1} | ${1} | ${2}
-           * ${1} | ${2} | ${3}
-           * ${2} | ${1} | ${3}
-           */
-          var headerNames = n.quasis[0].value.raw.trim().split(/\s*\|\s*/);
+        if (isJestEachTemplateLiteral(n, _parentNode)) {
+          var _printed2 = printJestEachTemplateLiteral(n, expressions, options);
 
-          if (headerNames.length > 1 || headerNames.some(function (headerName) {
-            return headerName.length !== 0;
-          })) {
-            var stringifiedExpressions = expressions.map(function (doc$$2) {
-              return "${" + printDocToString$2(doc$$2, Object.assign({}, options, {
-                printWidth: Infinity,
-                endOfLine: "lf"
-              })).formatted + "}";
-            });
-            var tableBody = [{
-              hasLineBreak: false,
-              cells: []
-            }];
-
-            for (var _i = 1; _i < n.quasis.length; _i++) {
-              var row = tableBody[tableBody.length - 1];
-              var correspondingExpression = stringifiedExpressions[_i - 1];
-              row.cells.push(correspondingExpression);
-
-              if (correspondingExpression.indexOf("\n") !== -1) {
-                row.hasLineBreak = true;
-              }
+          if (_printed2) {
+            return _printed2;
+          }
+        }
 
-              if (n.quasis[_i].value.raw.indexOf("\n") !== -1) {
-                tableBody.push({
-                  hasLineBreak: false,
-                  cells: []
-                });
-              }
-            }
+        var isSimple = isSimpleTemplateLiteral(n);
 
-            var maxColumnCount = tableBody.reduce(function (maxColumnCount, row) {
-              return Math.max(maxColumnCount, row.cells.length);
-            }, headerNames.length);
-            var maxColumnWidths = Array.from(new Array(maxColumnCount), function () {
-              return 0;
-            });
-            var table = [{
-              cells: headerNames
-            }].concat(tableBody.filter(function (row) {
-              return row.cells.length !== 0;
-            }));
-            table.filter(function (row) {
-              return !row.hasLineBreak;
-            }).forEach(function (row) {
-              row.cells.forEach(function (cell, index) {
-                maxColumnWidths[index] = Math.max(maxColumnWidths[index], getStringWidth$2(cell));
-              });
-            });
-            parts.push("`", indent$2(concat$4([hardline$3, join$2(hardline$3, table.map(function (row) {
-              return join$2(" | ", row.cells.map(function (cell, index) {
-                return row.hasLineBreak ? cell : cell + " ".repeat(maxColumnWidths[index] - getStringWidth$2(cell));
-              }));
-            }))])), hardline$3, "`");
-            return concat$4(parts);
-          }
+        if (isSimple) {
+          expressions = expressions.map(function (doc$$2) {
+            return printDocToString$2(doc$$2, Object.assign({}, options, {
+              printWidth: Infinity
+            })).formatted;
+          });
         }
 
         parts.push("`");
@@ -25289,13 +25384,17 @@ function printPathNoParens(path$$1, options, print, args) {
             var tabWidth = options.tabWidth;
             var quasi = childPath.getValue();
             var indentSize = getIndentSize$1(quasi.value.raw, tabWidth);
-            var _printed2 = expressions[i];
+            var _printed3 = expressions[i];
 
-            if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression") {
-              _printed2 = concat$4([indent$2(concat$4([softline$1, _printed2])), softline$1]);
+            if (!isSimple) {
+              // Breaks at the template element boundaries (${ and }) are preferred to breaking
+              // in the middle of a MemberExpression
+              if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression") {
+                _printed3 = concat$4([indent$2(concat$4([softline$1, _printed3])), softline$1]);
+              }
             }
 
-            var aligned = indentSize === 0 && quasi.value.raw.endsWith("\n") ? align$1(-Infinity, _printed2) : addAlignmentToDoc$2(_printed2, indentSize, tabWidth);
+            var aligned = indentSize === 0 && quasi.value.raw.endsWith("\n") ? align$1(-Infinity, _printed3) : addAlignmentToDoc$2(_printed3, indentSize, tabWidth);
             parts.push(group$1(concat$4(["${", aligned, lineSuffixBoundary$1, "}"])));
           }
         }, "quasis");
@@ -25342,8 +25441,7 @@ function printPathNoParens(path$$1, options, print, args) {
     case "TupleTypeAnnotation":
       {
         var typesField = n.type === "TSTupleType" ? "elementTypes" : "types";
-        return group$1(concat$4(["[", indent$2(concat$4([softline$1, printArrayItems(path$$1, options, typesField, print)])), // TypeScript doesn't support trailing commas in tuple types
-        n.type === "TSTupleType" ? "" : ifBreak$1(shouldPrintComma(options) ? "," : ""), comments.printDanglingComments(path$$1, options,
+        return group$1(concat$4(["[", indent$2(concat$4([softline$1, printArrayItems(path$$1, options, typesField, print)])), ifBreak$1(shouldPrintComma(options, "all") ? "," : ""), comments.printDanglingComments(path$$1, options,
         /* sameIndent */
         true), softline$1, "]"]));
       }
@@ -25511,22 +25609,22 @@ function printPathNoParens(path$$1, options, print, args) {
         var result = [];
         var wasIndented = false;
 
-        for (var _i2 = 0; _i2 < types.length; ++_i2) {
-          if (_i2 === 0) {
-            result.push(types[_i2]);
-          } else if (isObjectType(n.types[_i2 - 1]) && isObjectType(n.types[_i2])) {
+        for (var _i = 0; _i < types.length; ++_i) {
+          if (_i === 0) {
+            result.push(types[_i]);
+          } else if (isObjectType(n.types[_i - 1]) && isObjectType(n.types[_i])) {
             // If both are objects, don't indent
-            result.push(concat$4([" & ", wasIndented ? indent$2(types[_i2]) : types[_i2]]));
-          } else if (!isObjectType(n.types[_i2 - 1]) && !isObjectType(n.types[_i2])) {
+            result.push(concat$4([" & ", wasIndented ? indent$2(types[_i]) : types[_i]]));
+          } else if (!isObjectType(n.types[_i - 1]) && !isObjectType(n.types[_i])) {
             // If no object is involved, go to the next line if it breaks
-            result.push(indent$2(concat$4([" &", line$3, types[_i2]])));
+            result.push(indent$2(concat$4([" &", line$3, types[_i]])));
           } else {
             // If you go from object to non-object or vis-versa, then inline it
-            if (_i2 > 1) {
+            if (_i > 1) {
               wasIndented = true;
             }
 
-            result.push(" & ", _i2 > 1 ? indent$2(types[_i2]) : types[_i2]);
+            result.push(" & ", _i > 1 ? indent$2(types[_i]) : types[_i]);
           }
         }
 
@@ -25555,7 +25653,7 @@ function printPathNoParens(path$$1, options, print, args) {
         // // comment
         // | child2
 
-        var _printed3 = path$$1.map(function (typePath) {
+        var _printed4 = path$$1.map(function (typePath) {
           var printedType = typePath.call(print);
 
           if (!shouldHug) {
@@ -25568,11 +25666,11 @@ function printPathNoParens(path$$1, options, print, args) {
         }, "types");
 
         if (shouldHug) {
-          return join$2(" | ", _printed3);
+          return join$2(" | ", _printed4);
         }
 
         var shouldAddStartLine = shouldIndent && !hasLeadingOwnLineComment(options.originalText, n, options);
-        var code = concat$4([ifBreak$1(concat$4([shouldAddStartLine ? line$3 : "", "| "])), join$2(concat$4([line$3, "| "]), _printed3)]);
+        var code = concat$4([ifBreak$1(concat$4([shouldAddStartLine ? line$3 : "", "| "])), join$2(concat$4([line$3, "| "]), _printed4)]);
         var hasParens;
 
         if (n.type === "TSUnionType") {
@@ -25658,9 +25756,9 @@ function printPathNoParens(path$$1, options, print, args) {
           parts.push("declare ");
         }
 
-        var _printed4 = printAssignmentRight(n.id, n.right, path$$1.call(print, "right"), options);
+        var _printed5 = printAssignmentRight(n.id, n.right, path$$1.call(print, "right"), options);
 
-        parts.push("type ", path$$1.call(print, "id"), path$$1.call(print, "typeParameters"), " =", _printed4, semi);
+        parts.push("type ", path$$1.call(print, "id"), path$$1.call(print, "typeParameters"), " =", _printed5, semi);
         return group$1(concat$4(parts));
       }
 
@@ -25737,6 +25835,15 @@ function printPathNoParens(path$$1, options, print, args) {
 
         if (n["default"]) {
           parts.push(" = ", path$$1.call(print, "default"));
+        } // Keep comma if the file extension is .tsx and
+        // has one type parameter that isn't extend with any types.
+        // Because, otherwise formatted result will be invalid as tsx.
+
+
+        var _grandParent = path$$1.getNode(2);
+
+        if (_parent9.params && _parent9.params.length === 1 && options.filepath && /\.tsx$/i.test(options.filepath) && !n.constraint && _grandParent.type === "ArrowFunctionExpression") {
+          parts.push(",");
         }
 
         return concat$4(parts);
@@ -25951,9 +26058,15 @@ function printPathNoParens(path$$1, options, print, args) {
       return concat$4([n.operator, " ", path$$1.call(print, "typeAnnotation")]);
 
     case "TSMappedType":
-      return group$1(concat$4(["{", indent$2(concat$4([options.bracketSpacing ? line$3 : softline$1, n.readonly ? concat$4([getTypeScriptMappedTypeModifier(n.readonly, "readonly"), " "]) : "", printTypeScriptModifiers(path$$1, options, print), path$$1.call(print, "typeParameter"), n.optional ? getTypeScriptMappedTypeModifier(n.optional, "?") : "", ": ", path$$1.call(print, "typeAnnotation")])), comments.printDanglingComments(path$$1, options,
-      /* sameIndent */
-      true), options.bracketSpacing ? line$3 : softline$1, "}"]));
+      {
+        var _shouldBreak2 = hasNewlineInRange$1(options.originalText, options.locStart(n), options.locEnd(n));
+
+        return group$1(concat$4(["{", indent$2(concat$4([options.bracketSpacing ? line$3 : softline$1, n.readonly ? concat$4([getTypeScriptMappedTypeModifier(n.readonly, "readonly"), " "]) : "", printTypeScriptModifiers(path$$1, options, print), path$$1.call(print, "typeParameter"), n.optional ? getTypeScriptMappedTypeModifier(n.optional, "?") : "", ": ", path$$1.call(print, "typeAnnotation"), _shouldBreak2 && options.semi ? ";" : ""])), comments.printDanglingComments(path$$1, options,
+        /* sameIndent */
+        true), options.bracketSpacing ? line$3 : softline$1, "}"]), {
+          shouldBreak: _shouldBreak2
+        });
+      }
 
     case "TSMethodSignature":
       parts.push(n.accessibility ? concat$4([n.accessibility, " "]) : "", n.export ? "export " : "", n.static ? "static " : "", n.readonly ? "readonly " : "", n.computed ? "[" : "", path$$1.call(print, "key"), n.computed ? "]" : "", printOptionalToken(path$$1), printFunctionParams(path$$1, print, options,
@@ -26231,7 +26344,7 @@ function printPropertyKey(path$$1, options, print) {
 
   if (options.quoteProps === "consistent" && !needsQuoteProps.has(parent)) {
     var objectHasStringProp = (parent.properties || parent.body || parent.members).some(function (prop) {
-      return prop.key && prop.key.type !== "Identifier" && !isStringPropSafeToCoerceToIdentifier(prop, options);
+      return !prop.computed && prop.key && isStringLiteral(prop.key) && !isStringPropSafeToCoerceToIdentifier(prop, options);
     });
     needsQuoteProps.set(parent, objectHasStringProp);
   }
@@ -26246,7 +26359,7 @@ function printPropertyKey(path$$1, options, print) {
     }, "key");
   }
 
-  if (isStringPropSafeToCoerceToIdentifier(node, options) && (options.quoteProps === "as-needed" || options.quoteProps === "consistent" && !needsQuoteProps.get(parent))) {
+  if (!node.computed && isStringPropSafeToCoerceToIdentifier(node, options) && (options.quoteProps === "as-needed" || options.quoteProps === "consistent" && !needsQuoteProps.get(parent))) {
     // 'a' -> a
     return path$$1.call(function (keyPath) {
       return comments.printComments(keyPath, function () {
@@ -26301,7 +26414,18 @@ function printMethod(path$$1, options, print) {
 }
 
 function couldGroupArg(arg) {
-  return arg.type === "ObjectExpression" && (arg.properties.length > 0 || arg.comments) || arg.type === "ArrayExpression" && (arg.elements.length > 0 || arg.comments) || arg.type === "TSTypeAssertion" || arg.type === "TSAsExpression" || arg.type === "FunctionExpression" || arg.type === "ArrowFunctionExpression" && !arg.returnType && (arg.body.type === "BlockStatement" || arg.body.type === "ArrowFunctionExpression" || arg.body.type === "ObjectExpression" || arg.body.type === "ArrayExpression" || arg.body.type === "CallExpression" || arg.body.type === "OptionalCallExpression" || arg.body.type === "ConditionalExpression" || isJSXNode(arg.body));
+  return arg.type === "ObjectExpression" && (arg.properties.length > 0 || arg.comments) || arg.type === "ArrayExpression" && (arg.elements.length > 0 || arg.comments) || arg.type === "TSTypeAssertion" || arg.type === "TSAsExpression" || arg.type === "FunctionExpression" || arg.type === "ArrowFunctionExpression" && ( // we want to avoid breaking inside composite return types but not simple keywords
+  // https://github.com/prettier/prettier/issues/4070
+  // export class Thing implements OtherThing {
+  //   do: (type: Type) => Provider<Prop> = memoize(
+  //     (type: ObjectType): Provider<Opts> => {}
+  //   );
+  // }
+  // https://github.com/prettier/prettier/issues/6099
+  // app.get("/", (req, res): void => {
+  //   res.send("Hello World!");
+  // });
+  !arg.returnType || !arg.returnType.typeAnnotation || arg.returnType.typeAnnotation.type !== "TSTypeReference") && (arg.body.type === "BlockStatement" || arg.body.type === "ArrowFunctionExpression" || arg.body.type === "ObjectExpression" || arg.body.type === "ArrayExpression" || arg.body.type === "CallExpression" || arg.body.type === "OptionalCallExpression" || arg.body.type === "ConditionalExpression" || isJSXNode(arg.body));
 }
 
 function shouldGroupLastArg(args) {
@@ -26327,6 +26451,130 @@ function isSimpleFlowType(node) {
   return node && flowTypeAnnotations.indexOf(node.type) !== -1 && !(node.type === "GenericTypeAnnotation" && node.typeParameters);
 }
 
+function isJestEachTemplateLiteral(node, parentNode) {
+  /**
+   * describe.each`table`(name, fn)
+   * describe.only.each`table`(name, fn)
+   * describe.skip.each`table`(name, fn)
+   * test.each`table`(name, fn)
+   * test.only.each`table`(name, fn)
+   * test.skip.each`table`(name, fn)
+   *
+   * Ref: https://github.com/facebook/jest/pull/6102
+   */
+  var jestEachTriggerRegex = /^[xf]?(describe|it|test)$/;
+  return parentNode.type === "TaggedTemplateExpression" && parentNode.quasi === node && parentNode.tag.type === "MemberExpression" && parentNode.tag.property.type === "Identifier" && parentNode.tag.property.name === "each" && (parentNode.tag.object.type === "Identifier" && jestEachTriggerRegex.test(parentNode.tag.object.name) || parentNode.tag.object.type === "MemberExpression" && parentNode.tag.object.property.type === "Identifier" && (parentNode.tag.object.property.name === "only" || parentNode.tag.object.property.name === "skip") && parentNode.tag.object.object.type === "Identifier" && jestEachTriggerRegex.test(parentNode.tag.object.object.name));
+}
+
+function printJestEachTemplateLiteral(node, expressions, options) {
+  /**
+   * a    | b    | expected
+   * ${1} | ${1} | ${2}
+   * ${1} | ${2} | ${3}
+   * ${2} | ${1} | ${3}
+   */
+  var headerNames = node.quasis[0].value.raw.trim().split(/\s*\|\s*/);
+
+  if (headerNames.length > 1 || headerNames.some(function (headerName) {
+    return headerName.length !== 0;
+  })) {
+    var parts = [];
+    var stringifiedExpressions = expressions.map(function (doc$$2) {
+      return "${" + printDocToString$2(doc$$2, Object.assign({}, options, {
+        printWidth: Infinity,
+        endOfLine: "lf"
+      })).formatted + "}";
+    });
+    var tableBody = [{
+      hasLineBreak: false,
+      cells: []
+    }];
+
+    for (var i = 1; i < node.quasis.length; i++) {
+      var row = tableBody[tableBody.length - 1];
+      var correspondingExpression = stringifiedExpressions[i - 1];
+      row.cells.push(correspondingExpression);
+
+      if (correspondingExpression.indexOf("\n") !== -1) {
+        row.hasLineBreak = true;
+      }
+
+      if (node.quasis[i].value.raw.indexOf("\n") !== -1) {
+        tableBody.push({
+          hasLineBreak: false,
+          cells: []
+        });
+      }
+    }
+
+    var maxColumnCount = tableBody.reduce(function (maxColumnCount, row) {
+      return Math.max(maxColumnCount, row.cells.length);
+    }, headerNames.length);
+    var maxColumnWidths = Array.from(new Array(maxColumnCount), function () {
+      return 0;
+    });
+    var table = [{
+      cells: headerNames
+    }].concat(tableBody.filter(function (row) {
+      return row.cells.length !== 0;
+    }));
+    table.filter(function (row) {
+      return !row.hasLineBreak;
+    }).forEach(function (row) {
+      row.cells.forEach(function (cell, index) {
+        maxColumnWidths[index] = Math.max(maxColumnWidths[index], getStringWidth$2(cell));
+      });
+    });
+    parts.push("`", indent$2(concat$4([hardline$3, join$2(hardline$3, table.map(function (row) {
+      return join$2(" | ", row.cells.map(function (cell, index) {
+        return row.hasLineBreak ? cell : cell + " ".repeat(maxColumnWidths[index] - getStringWidth$2(cell));
+      }));
+    }))])), hardline$3, "`");
+    return concat$4(parts);
+  }
+}
+/** @param node {import("estree").TemplateLiteral} */
+
+
+function isSimpleTemplateLiteral(node) {
+  if (node.expressions.length === 0) {
+    return false;
+  }
+
+  return node.expressions.every(function (expr) {
+    // Disallow comments since printDocToString can't print them here
+    if (expr.comments) {
+      return false;
+    } // Allow `x` and `this`
+
+
+    if (expr.type === "Identifier" || expr.type === "ThisExpression") {
+      return true;
+    } // Allow `a.b.c`, `a.b[c]`, and `this.x.y`
+
+
+    if ((expr.type === "MemberExpression" || expr.type === "OptionalMemberExpression") && (expr.property.type === "Identifier" || expr.property.type === "Literal")) {
+      var ancestor = expr;
+
+      while (ancestor.type === "MemberExpression" || ancestor.type === "OptionalMemberExpression") {
+        ancestor = ancestor.object;
+
+        if (ancestor.comments) {
+          return false;
+        }
+      }
+
+      if (ancestor.type === "Identifier" || ancestor.type === "ThisExpression") {
+        return true;
+      }
+
+      return false;
+    }
+
+    return false;
+  });
+}
+
 var functionCompositionFunctionNames = new Set(["pipe", // RxJS, Ramda
 "pipeP", // Ramda
 "pipeK", // Ramda
@@ -27462,11 +27710,10 @@ function printJSXChildren(path$$1, options, print, jsxWhitespace, isFacebookTran
 
 
 function printJSXElement(path$$1, options, print) {
-  var n = path$$1.getValue(); // Turn <div></div> into <div />
+  var n = path$$1.getValue();
 
   if (n.type === "JSXElement" && isEmptyJSXElement(n)) {
-    n.openingElement.selfClosing = true;
-    return path$$1.call(print, "openingElement");
+    return concat$4([path$$1.call(print, "openingElement"), path$$1.call(print, "closingElement")]);
   }
 
   var openingLines = n.type === "JSXElement" ? path$$1.call(print, "openingElement") : path$$1.call(print, "openingFragment");
@@ -27708,7 +27955,7 @@ function printAssignmentRight(leftNode, rightNode, printedRight, options) {
   }
 
   var canBreak = isBinaryish(rightNode) && !shouldInlineLogicalExpression(rightNode) || rightNode.type === "ConditionalExpression" && isBinaryish(rightNode.test) && !shouldInlineLogicalExpression(rightNode.test) || rightNode.type === "StringLiteralTypeAnnotation" || rightNode.type === "ClassExpression" && rightNode.decorators && rightNode.decorators.length || (leftNode.type === "Identifier" || isStringLiteral(leftNode) || leftNode.type === "MemberExpression") && (isStringLiteral(rightNode) || isMemberExpressionChain(rightNode)) && // do not put values on a separate line from the key in json
-  options.parser !== "json" && options.parser !== "json5";
+  options.parser !== "json" && options.parser !== "json5" || rightNode.type === "SequenceExpression";
 
   if (canBreak) {
     return group$1(indent$2(concat$4([line$3, printedRight])));
@@ -27786,60 +28033,12 @@ function hasLeadingOwnLineComment(text, node, options) {
   return res;
 }
 
-function hasNakedLeftSide(node) {
-  return node.type === "AssignmentExpression" || node.type === "BinaryExpression" || node.type === "LogicalExpression" || node.type === "NGPipeExpression" || node.type === "ConditionalExpression" || node.type === "CallExpression" || node.type === "OptionalCallExpression" || node.type === "MemberExpression" || node.type === "OptionalMemberExpression" || node.type === "SequenceExpression" || node.type === "TaggedTemplateExpression" || node.type === "BindExpression" || node.type === "UpdateExpression" && !node.prefix || node.type === "TSNonNullExpression";
-}
-
 function isFlowAnnotationComment(text, typeAnnotation, options) {
   var start = options.locStart(typeAnnotation);
   var end = skipWhitespace$1(text, options.locEnd(typeAnnotation));
   return text.substr(start, 2) === "/*" && text.substr(end, 2) === "*/";
 }
 
-function getLeftSide(node) {
-  if (node.expressions) {
-    return node.expressions[0];
-  }
-
-  return node.left || node.test || node.callee || node.object || node.tag || node.argument || node.expression;
-}
-
-function getLeftSidePathName(path$$1, node) {
-  if (node.expressions) {
-    return ["expressions", 0];
-  }
-
-  if (node.left) {
-    return ["left"];
-  }
-
-  if (node.test) {
-    return ["test"];
-  }
-
-  if (node.object) {
-    return ["object"];
-  }
-
-  if (node.callee) {
-    return ["callee"];
-  }
-
-  if (node.tag) {
-    return ["tag"];
-  }
-
-  if (node.argument) {
-    return ["argument"];
-  }
-
-  if (node.expression) {
-    return ["expression"];
-  }
-
-  throw new Error("Unexpected node has no left side", node);
-}
-
 function exprNeedsASIProtection(path$$1, options) {
   var node = path$$1.getValue();
   var maybeASIProblem = needsParens_1(path$$1, options) || node.type === "ParenthesizedExpression" || node.type === "TypeCastExpression" || node.type === "ArrowFunctionExpression" && !shouldPrintParamsWithoutParens(path$$1, options) || node.type === "ArrayExpression" || node.type === "ArrayPattern" || node.type === "UnaryExpression" && node.prefix && (node.operator === "+" || node.operator === "-") || node.type === "TemplateLiteral" || node.type === "TemplateElement" || isJSXNode(node) || node.type === "BindExpression" && !node.object || node.type === "RegExpLiteral" || node.type === "Literal" && node.pattern || node.type === "Literal" && node.regex;
@@ -28082,7 +28281,7 @@ function isLiteral(node) {
 }
 
 function isStringPropSafeToCoerceToIdentifier(node, options) {
-  return isStringLiteral(node.key) && isIdentifierName(node.key.value) && !node.computed && options.parser !== "json" && !(options.parser === "typescript" && node.type === "ClassProperty");
+  return isStringLiteral(node.key) && isIdentifierName(node.key.value) && options.parser !== "json" && !(options.parser === "typescript" && node.type === "ClassProperty");
 }
 
 function isNumericLiteral(node) {
@@ -28168,7 +28367,9 @@ function isTheOnlyJSXElementInMarkdown(options, path$$1) {
   return parent.type === "Program" && parent.body.length == 1;
 }
 
-function willPrintOwnComments(path$$1) {
+function willPrintOwnComments(path$$1
+/*, options */
+) {
   var node = path$$1.getValue();
   var parent = path$$1.getParentNode();
   return (node && (isJSXNode(node) || hasFlowShorthandAnnotationComment(node) || parent && parent.type === "CallExpression" && (hasFlowAnnotationComment(node.leadingComments) || hasFlowAnnotationComment(node.trailingComments))) || parent && (parent.type === "JSXSpreadAttribute" || parent.type === "JSXSpreadChild" || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType" || (parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.superClass === node)) && !hasIgnoreComment$1(path$$1);
@@ -28727,7 +28928,7 @@ var json5$1 = Object.freeze({
 
 var require$$0$21 = ( javascript$1 && javascript ) || javascript$1;
 
-var require$$1$9 = ( jsx$1 && jsx ) || jsx$1;
+var require$$1$10 = ( jsx$1 && jsx ) || jsx$1;
 
 var require$$2$10 = ( typescript$1 && typescript ) || typescript$1;
 
@@ -28756,7 +28957,7 @@ var languages = [createLanguage(require$$0$21, {
     filenames: [],
     extensions: [".js.flow"]
   }
-}), createLanguage(require$$1$9, {
+}), createLanguage(require$$1$10, {
   override: {
     since: "0.0.0",
     parsers: ["babel", "flow"],
@@ -30124,7 +30325,7 @@ var scss$1 = Object.freeze({
 
 var require$$0$23 = ( css$3 && css$2 ) || css$3;
 
-var require$$1$10 = ( postcss$1 && postcss ) || postcss$1;
+var require$$1$11 = ( postcss$1 && postcss ) || postcss$1;
 
 var require$$2$11 = ( less$1 && less ) || less$1;
 
@@ -30136,7 +30337,7 @@ var languages$1 = [createLanguage(require$$0$23, {
     parsers: ["css"],
     vscodeLanguageIds: ["css"]
   }
-}), createLanguage(require$$1$10, {
+}), createLanguage(require$$1$11, {
   override: {
     since: "1.4.0",
     parsers: ["css"],
@@ -30203,33 +30404,21 @@ function print(path$$1, options, print) {
         var isGlimmerComponent = tagFirstChar.toUpperCase() === tagFirstChar || isLocal;
         var hasChildren = n.children.length > 0;
         var isVoid = isGlimmerComponent && !hasChildren || voidTags.indexOf(n.tag) !== -1;
-        var closeTag = isVoid ? concat$10([" />", softline$4]) : ">";
+        var closeTagForNoBreak = isVoid ? concat$10([" />", softline$4]) : ">";
+        var closeTagForBreak = isVoid ? "/>" : ">";
 
         var _getParams = function _getParams(path$$1, print) {
           return indent$6(concat$10([n.attributes.length ? line$6 : "", join$7(line$6, path$$1.map(print, "attributes")), n.modifiers.length ? line$6 : "", join$7(line$6, path$$1.map(print, "modifiers")), n.comments.length ? line$6 : "", join$7(line$6, path$$1.map(print, "comments"))]));
-        }; // The problem here is that I want to not break at all if the children
-        // would not break but I need to force an indent, so I use a hardline.
-
-        /**
-         * What happens now:
-         * <div>
-         *   Hello
-         * </div>
-         * ==>
-         * <div>Hello</div>
-         * This is due to me using hasChildren to decide to put the hardline in.
-         * I would rather use a {DOES THE WHOLE THING NEED TO BREAK}
-         */
-
+        };
 
-        return concat$10([group$10(concat$10(["<", n.tag, _getParams(path$$1, print), n.blockParams.length ? ` as |${n.blockParams.join(" ")}|` : "", ifBreak$3(softline$4, ""), closeTag])), group$10(concat$10([indent$6(join$7(softline$4, [""].concat(path$$1.map(print, "children")))), ifBreak$3(hasChildren ? hardline$8 : "", ""), !isVoid ? concat$10(["</", n.tag, ">"]) : ""]))]);
+        return concat$10([group$10(concat$10(["<", n.tag, _getParams(path$$1, print), n.blockParams.length ? ` as |${n.blockParams.join(" ")}|` : "", ifBreak$3(softline$4, ""), ifBreak$3(closeTagForBreak, closeTagForNoBreak)])), group$10(concat$10([indent$6(join$7(softline$4, [""].concat(path$$1.map(print, "children")))), ifBreak$3(hasChildren ? hardline$8 : "", ""), !isVoid ? concat$10(["</", n.tag, ">"]) : ""]))]);
       }
 
     case "BlockStatement":
       {
         var pp = path$$1.getParentNode(1);
-        var isElseIf = pp && pp.inverse && pp.inverse.body[0] === n && pp.inverse.body[0].path.parts[0] === "if";
-        var hasElseIf = n.inverse && n.inverse.body[0] && n.inverse.body[0].type === "BlockStatement" && n.inverse.body[0].path.parts[0] === "if";
+        var isElseIf = pp && pp.inverse && pp.inverse.body.length === 1 && pp.inverse.body[0] === n && pp.inverse.body[0].path.parts[0] === "if";
+        var hasElseIf = n.inverse && n.inverse.body.length === 1 && n.inverse.body[0].type === "BlockStatement" && n.inverse.body[0].path.parts[0] === "if";
         var indentElse = hasElseIf ? function (a) {
           return a;
         } : indent$6;
@@ -31538,9 +31727,9 @@ function genericPrint$4(path$$1, options, print) {
 
     case "inlineCode":
       {
-        var backtickCount = util$1.getMaxContinuousCount(node.value, "`");
+        var backtickCount = util$1.getMinNotPresentContinuousCount(node.value, "`");
 
-        var _style = backtickCount === 1 ? "``" : "`";
+        var _style = "`".repeat(backtickCount || 1);
 
         var gap = backtickCount ? " " : "";
         return concat$12([_style, gap, node.value, gap, _style]);
@@ -33617,7 +33806,7 @@ var parseSrcset = createCommonjsModule(function (module) {
       // Browser globals (root is window)
       root.parseSrcset = factory();
     }
-  })(commonjsGlobal, function () {
+  })(this, function () {
     // 1. Let input be the value passed to this algorithm.
     return function (input, options) {
       var logger = options && options.logger || console; // UTILITY FUNCTIONS
@@ -34067,7 +34256,7 @@ function embed$6(path$$1, print, textToDoc, options) {
         } // lit-html: html`<my-element obj=${obj}></my-element>`
 
 
-        if (/^PRETTIER_HTML_PLACEHOLDER_\d+_IN_JS$/.test(options.originalText.slice(node.valueSpan.start.offset, node.valueSpan.end.offset))) {
+        if (/^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/.test(options.originalText.slice(node.valueSpan.start.offset, node.valueSpan.end.offset))) {
           return concat$14([node.rawName, "=", node.value]);
         } // lwc: html`<my-element data-for={value}></my-elememt>`
 
@@ -34837,7 +35026,7 @@ var vue$1 = Object.freeze({
 
 var require$$0$31 = ( html$2 && html$1 ) || html$2;
 
-var require$$1$11 = ( vue$1 && vue ) || vue$1;
+var require$$1$12 = ( vue$1 && vue ) || vue$1;
 
 var languages$5 = [createLanguage(require$$0$31, {
   override: {
@@ -34867,7 +35056,7 @@ var languages$5 = [createLanguage(require$$0$31, {
     extensions: [],
     filenames: []
   }
-}), createLanguage(require$$1$11, {
+}), createLanguage(require$$1$12, {
   override: {
     since: "1.10.0",
     parsers: ["vue"],
@@ -39304,7 +39493,7 @@ var fnmatch = createCommonjsModule(function (module, exports) {
 var ini = createCommonjsModule(function (module, exports) {
   "use strict"; // Based on iniparser by shockie <https://npmjs.org/package/iniparser>
 
-  var __awaiter = commonjsGlobal && commonjsGlobal.__awaiter || function (thisArg, _arguments, P, generator) {
+  var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
       function fulfilled(value) {
         try {
@@ -39332,7 +39521,7 @@ var ini = createCommonjsModule(function (module, exports) {
     });
   };
 
-  var __generator = commonjsGlobal && commonjsGlobal.__generator || function (thisArg, body) {
+  var __generator = this && this.__generator || function (thisArg, body) {
     var _ = {
       label: 0,
       sent: function sent() {
@@ -39443,7 +39632,7 @@ var ini = createCommonjsModule(function (module, exports) {
     }
   };
 
-  var __importStar = commonjsGlobal && commonjsGlobal.__importStar || function (mod) {
+  var __importStar = this && this.__importStar || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
     if (mod != null) for (var k in mod) {
@@ -39622,7 +39811,7 @@ var require$$4$6 = ( _package$3 && _package$2 ) || _package$3;
 var src$2 = createCommonjsModule(function (module, exports) {
   "use strict";
 
-  var __awaiter = commonjsGlobal && commonjsGlobal.__awaiter || function (thisArg, _arguments, P, generator) {
+  var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
       function fulfilled(value) {
         try {
@@ -39650,7 +39839,7 @@ var src$2 = createCommonjsModule(function (module, exports) {
     });
   };
 
-  var __generator = commonjsGlobal && commonjsGlobal.__generator || function (thisArg, body) {
+  var __generator = this && this.__generator || function (thisArg, body) {
     var _ = {
       label: 0,
       sent: function sent() {
@@ -39761,7 +39950,7 @@ var src$2 = createCommonjsModule(function (module, exports) {
     }
   };
 
-  var __importStar = commonjsGlobal && commonjsGlobal.__importStar || function (mod) {
+  var __importStar = this && this.__importStar || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
     if (mod != null) for (var k in mod) {
@@ -39771,7 +39960,7 @@ var src$2 = createCommonjsModule(function (module, exports) {
     return result;
   };
 
-  var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function (mod) {
+  var __importDefault = this && this.__importDefault || function (mod) {
     return mod && mod.__esModule ? mod : {
       "default": mod
     };
@@ -40233,6 +40422,7 @@ function (_Error) {
     _classCallCheck(this, ParserError);
 
     _this = _possibleConstructorReturn(this, _getPrototypeOf(ParserError).call(this, '[ParserError] ' + msg, filename, linenumber));
+    _this.name = 'ParserError';
     _this.code = 'ParserError';
     if (Error.captureStackTrace) Error.captureStackTrace(_assertThisInitialized(_assertThisInitialized(_this)), ParserError);
     return _this;
@@ -40356,7 +40546,7 @@ function () {
     key: "return",
     value: function _return(value) {
       /* istanbul ignore next */
-      if (!this.stack.length) throw this.error(new ParserError('Stack underflow'));
+      if (this.stack.length === 0) throw this.error(new ParserError('Stack underflow'));
       if (value === undefined) value = this.state.buf;
       this.state = this.stack.pop();
       this.state.returned = value;
@@ -40472,7 +40662,7 @@ var createDatetimeFloat = createCommonjsModule(function (module) {
 var createDate = createCommonjsModule(function (module) {
   'use strict';
 
-  var DateTime = commonjsGlobal.Date;
+  var DateTime = global.Date;
 
   var Date =
   /*#__PURE__*/
@@ -40569,6 +40759,7 @@ var tomlParser = createCommonjsModule(function (module) {
       _classCallCheck(this, TomlError);
 
       _this = _possibleConstructorReturn(this, _getPrototypeOf(TomlError).call(this, msg));
+      _this.name = 'TomlError';
       /* istanbul ignore next */
 
       if (Error.captureStackTrace) Error.captureStackTrace(_assertThisInitialized(_assertThisInitialized(_this)), TomlError);
@@ -40637,13 +40828,13 @@ var tomlParser = createCommonjsModule(function (module) {
   var SURROGATE_FIRST = 0xD800;
   var SURROGATE_LAST = 0xDFFF;
   var escapes = {
-    [CHAR_b]: '\x08',
-    [CHAR_t]: '\x09',
-    [CHAR_n]: '\x0a',
-    [CHAR_f]: '\x0c',
-    [CHAR_r]: '\x0d',
-    [CHAR_QUOT]: '\x22',
-    [CHAR_BSOL]: '\x5c'
+    [CHAR_b]: '\u0008',
+    [CHAR_t]: '\u0009',
+    [CHAR_n]: '\u000A',
+    [CHAR_f]: '\u000C',
+    [CHAR_r]: '\u000D',
+    [CHAR_QUOT]: '\u0022',
+    [CHAR_BSOL]: '\u005C'
   };
 
   function isDigit(cp) {
@@ -40674,6 +40865,21 @@ var tomlParser = createCommonjsModule(function (module) {
 
   var _declared = Symbol('declared');
 
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var defineProperty = Object.defineProperty;
+  var descriptor = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: undefined
+  };
+
+  function hasKey(obj, key) {
+    if (hasOwnProperty.call(obj, key)) return true;
+    if (key === '__proto__') defineProperty(obj, '__proto__', descriptor);
+    return false;
+  }
+
   var INLINE_TABLE = Symbol('inline-table');
 
   function InlineTable() {
@@ -40744,10 +40950,18 @@ var tomlParser = createCommonjsModule(function (module) {
   } // in an eval, to let bundlers not slurp in a util proxy
 
 
-  var utilInspect = eval(`require('util').inspect`);
+  var _custom;
+
+  try {
+    var utilInspect = util.inspect;
+    _custom = utilInspect.custom;
+  } catch (_) {}
+  /* eval require not available in transpiled bundle */
+
   /* istanbul ignore next */
 
-  var _inspect = utilInspect && utilInspect.custom || 'inspect';
+
+  var _inspect = _custom || 'inspect';
 
   var BoxedBigInt =
   /*#__PURE__*/
@@ -40756,7 +40970,7 @@ var tomlParser = createCommonjsModule(function (module) {
       _classCallCheck(this, BoxedBigInt);
 
       try {
-        this.value = commonjsGlobal.BigInt(value);
+        this.value = global.BigInt.asIntN(64, value);
       } catch (_) {
         /* istanbul ignore next */
         this.value = null;
@@ -40804,7 +41018,7 @@ var tomlParser = createCommonjsModule(function (module) {
     if (Object.is(num, -0)) num = 0;
     /* istanbul ignore else */
 
-    if (commonjsGlobal.BigInt && !Number.isSafeInteger(num)) {
+    if (global.BigInt && !Number.isSafeInteger(num)) {
       return new BoxedBigInt(_value);
     } else {
       /* istanbul ignore next */
@@ -40971,7 +41185,7 @@ var tomlParser = createCommonjsModule(function (module) {
             for (var _iterator = kv.key[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
               var kw = _step.value;
 
-              if (kw in target && (!isTable(target[kw]) || target[kw][_declared])) {
+              if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
                 throw this.error(new TomlError("Can't redefine existing key"));
               }
 
@@ -40992,7 +41206,7 @@ var tomlParser = createCommonjsModule(function (module) {
             }
           }
 
-          if (finalKey in target) {
+          if (hasKey(target, finalKey)) {
             throw this.error(new TomlError("Can't redefine existing key"));
           } // unbox our numbers
 
@@ -41110,7 +41324,7 @@ var tomlParser = createCommonjsModule(function (module) {
           if (this.char === CHAR_SP || this.char === CTRL_I) {
             return null;
           } else if (this.char === CHAR_RSQB) {
-            if (keyword in this.ctx && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
+            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[keyword] = this.ctx[keyword] || Table();
@@ -41119,7 +41333,7 @@ var tomlParser = createCommonjsModule(function (module) {
 
             return this.next(this.parseWhitespaceToEOL);
           } else if (this.char === CHAR_PERIOD) {
-            if (!(keyword in this.ctx)) {
+            if (!hasKey(this.ctx, keyword)) {
               this.ctx = this.ctx[keyword] = Table();
             } else if (isTable(this.ctx[keyword])) {
               this.ctx = this.ctx[keyword];
@@ -41157,7 +41371,7 @@ var tomlParser = createCommonjsModule(function (module) {
           if (this.char === CHAR_SP || this.char === CTRL_I) {
             return null;
           } else if (this.char === CHAR_RSQB) {
-            if (!(keyword in this.ctx)) {
+            if (!hasKey(this.ctx, keyword)) {
               this.ctx[keyword] = List();
             }
 
@@ -41173,7 +41387,7 @@ var tomlParser = createCommonjsModule(function (module) {
 
             return this.next(this.parseListEnd);
           } else if (this.char === CHAR_PERIOD) {
-            if (!(keyword in this.ctx)) {
+            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"));
@@ -41553,8 +41767,8 @@ var tomlParser = createCommonjsModule(function (module) {
             }
 
             return this.returnNow(String.fromCodePoint(codePoint));
-          } catch (ex) {
-            throw this.error(TomlError.wrap(ex));
+          } catch (err) {
+            throw this.error(TomlError.wrap(err));
           }
         }
       }, {
@@ -41593,7 +41807,30 @@ var tomlParser = createCommonjsModule(function (module) {
           } else if (this.char === CHAR_n) {
             return this.next(this.parseNan);
           } else {
-            return this.callNow(this.parseNoUnder, this.parseNumberInteger);
+            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
+          }
+        }
+      }, {
+        key: "parseNumberIntegerStart",
+        value: function parseNumberIntegerStart() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberIntegerExponentOrDecimal);
+          } else {
+            return this.goto(this.parseNumberInteger);
+          }
+        }
+      }, {
+        key: "parseNumberIntegerExponentOrDecimal",
+        value: function parseNumberIntegerExponentOrDecimal() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
           }
         }
       }, {
@@ -41623,9 +41860,9 @@ var tomlParser = createCommonjsModule(function (module) {
       }, {
         key: "parseNoUnder",
         value: function parseNoUnder() {
-          if (this.char === CHAR_LOWBAR) {
-            throw this.error(new TomlError('Unexpected character, expected digit, exponent marker(e) or whitespace'));
-          } else if (this.atEndOfWord() || this.char === CHAR_E || this.char === CHAR_e) {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
+            throw this.error(new TomlError('Unexpected character, expected digit'));
+          } else if (this.atEndOfWord()) {
             throw this.error(new TomlError('Incomplete number'));
           }
 
@@ -42200,7 +42437,7 @@ var tomlParser = createCommonjsModule(function (module) {
             for (var _iterator2 = kv.key[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
               var kw = _step2.value;
 
-              if (kw in target && (!isTable(target[kw]) || target[kw][_declared])) {
+              if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
                 throw this.error(new TomlError("Can't redefine existing key"));
               }
 
@@ -42221,7 +42458,7 @@ var tomlParser = createCommonjsModule(function (module) {
             }
           }
 
-          if (finalKey in target) {
+          if (hasKey(target, finalKey)) {
             throw this.error(new TomlError("Can't redefine existing key"));
           }
 
@@ -42301,7 +42538,7 @@ function prettyError(err, buf) {
 var parseString_1 = parseString;
 
 function parseString(str) {
-  if (commonjsGlobal.Buffer && commonjsGlobal.Buffer.isBuffer(str)) {
+  if (global.Buffer && global.Buffer.isBuffer(str)) {
     str = str.toString('utf8');
   }
 
@@ -42310,8 +42547,8 @@ function parseString(str) {
   try {
     parser.parse(str);
     return parser.finish();
-  } catch (ex) {
-    throw parsePrettyError(ex, str);
+  } catch (err) {
+    throw parsePrettyError(err, str);
   }
 }
 
@@ -42489,7 +42726,8 @@ var resolveConfig_1 = createCommonjsModule(function (module) {
     var patternList = [].concat(patterns);
     var excludedPatternList = [].concat(excludedPatterns || []);
     var opts = {
-      matchBase: true
+      matchBase: true,
+      dot: true
     };
     return patternList.some(function (pattern) {
       return minimatch_1(filePath, pattern, opts);