@putout/babel 1.2.0 → 1.2.2

package/bundle/babel.cjs

@@ -101,22 +101,22 @@ function isIdentifierName(name) {
   return !isFirst;
 }
 
-const reservedWords$1 = {
+const reservedWords$2 = {
   keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
   strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
   strictBind: ["eval", "arguments"]
 };
-const keywords$2 = new Set(reservedWords$1.keyword);
-const reservedWordsStrictSet$1 = new Set(reservedWords$1.strict);
-new Set(reservedWords$1.strictBind);
-function isReservedWord$1(word, inModule) {
+const keywords$3 = new Set(reservedWords$2.keyword);
+const reservedWordsStrictSet$2 = new Set(reservedWords$2.strict);
+new Set(reservedWords$2.strictBind);
+function isReservedWord$2(word, inModule) {
   return inModule && word === "await" || word === "enum";
 }
-function isStrictReservedWord$1(word, inModule) {
-  return isReservedWord$1(word, inModule) || reservedWordsStrictSet$1.has(word);
+function isStrictReservedWord$2(word, inModule) {
+  return isReservedWord$2(word, inModule) || reservedWordsStrictSet$2.has(word);
 }
-function isKeyword$1(word) {
-  return keywords$2.has(word);
+function isKeyword$2(word) {
+  return keywords$3.has(word);
 }
 
 var _isDigit$1 = function isDigit(code) {
@@ -2947,7 +2947,7 @@ function is$1(type, node, opts) {
 function isValidIdentifier(name, reserved = true) {
   if (typeof name !== "string") return false;
   if (reserved) {
-    if (isKeyword$1(name) || isStrictReservedWord$1(name, true)) {
+    if (isKeyword$2(name) || isStrictReservedWord$2(name, true)) {
       return false;
     }
   }
@@ -3610,7 +3610,7 @@ defineType$4("Identifier", {
         meta: node
       })) return;
     }
-    if ((isKeyword$1(node.name) || isReservedWord$1(node.name, false)) && node.name !== "this") {
+    if ((isKeyword$2(node.name) || isReservedWord$2(node.name, false)) && node.name !== "this") {
       throw new TypeError(`"${node.name}" is not a valid identifier`);
     }
   }
@@ -12633,28 +12633,28 @@ function isIdentifierChar(code) {
   }
   return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
 }
-const reservedWords = {
+const reservedWords$1 = {
   keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
   strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
   strictBind: ["eval", "arguments"]
 };
-const keywords = new Set(reservedWords.keyword);
-const reservedWordsStrictSet = new Set(reservedWords.strict);
-const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
-function isReservedWord(word, inModule) {
+const keywords$2 = new Set(reservedWords$1.keyword);
+const reservedWordsStrictSet$1 = new Set(reservedWords$1.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords$1.strictBind);
+function isReservedWord$1(word, inModule) {
   return inModule && word === "await" || word === "enum";
 }
-function isStrictReservedWord(word, inModule) {
-  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+function isStrictReservedWord$1(word, inModule) {
+  return isReservedWord$1(word, inModule) || reservedWordsStrictSet$1.has(word);
 }
 function isStrictBindOnlyReservedWord(word) {
   return reservedWordsStrictBindSet.has(word);
 }
 function isStrictBindReservedWord(word, inModule) {
-  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+  return isStrictReservedWord$1(word, inModule) || isStrictBindOnlyReservedWord(word);
 }
-function isKeyword(word) {
-  return keywords.has(word);
+function isKeyword$1(word) {
+  return keywords$2.has(word);
 }
 function isIteratorStart(current, next, next2) {
   return current === 64 && next === 64 && isIdentifierStart(next2);
@@ -23299,14 +23299,14 @@ class ExpressionParser extends LValParser {
     if (!canBeReservedWord(word)) {
       return;
     }
-    if (checkKeywords && isKeyword(word)) {
+    if (checkKeywords && isKeyword$1(word)) {
       this.raise(Errors.UnexpectedKeyword, {
         at: startLoc,
         keyword: word
       });
       return;
     }
-    const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
+    const reservedTest = !this.state.strict ? isReservedWord$1 : isBinding ? isStrictBindReservedWord : isStrictReservedWord$1;
     if (reservedTest(word, this.inModule)) {
       this.raise(Errors.UnexpectedReservedWord, {
         at: startLoc,
@@ -25975,15 +25975,33 @@ var jsTokens_1 = function*(input, {jsx = false} = {}) {
 
 var jsTokens = /*@__PURE__*/getDefaultExportFromCjs(jsTokens_1);
 
-const ANSI_BACKGROUND_OFFSET = 10;
+const reservedWords = {
+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+new Set(reservedWords.strictBind);
+function isReservedWord(word, inModule) {
+  return inModule && word === "await" || word === "enum";
+}
+function isStrictReservedWord(word, inModule) {
+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+function isKeyword(word) {
+  return keywords.has(word);
+}
 
-const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+const ANSI_BACKGROUND_OFFSET$1 = 10;
 
-const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+const wrapAnsi16$1 = (offset = 0) => code => `\u001B[${code + offset}m`;
 
-const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+const wrapAnsi256$1 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
 
-const styles$1 = {
+const wrapAnsi16m$1 = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+const styles$3 = {
 	modifier: {
 		reset: [0, 0],
 		// 21 isn't widely supported and 22 does the same thing
@@ -26042,49 +26060,49 @@ const styles$1 = {
 	},
 };
 
-Object.keys(styles$1.modifier);
-const foregroundColorNames = Object.keys(styles$1.color);
-const backgroundColorNames = Object.keys(styles$1.bgColor);
-[...foregroundColorNames, ...backgroundColorNames];
+Object.keys(styles$3.modifier);
+const foregroundColorNames$1 = Object.keys(styles$3.color);
+const backgroundColorNames$1 = Object.keys(styles$3.bgColor);
+[...foregroundColorNames$1, ...backgroundColorNames$1];
 
-function assembleStyles() {
+function assembleStyles$1() {
 	const codes = new Map();
 
-	for (const [groupName, group] of Object.entries(styles$1)) {
+	for (const [groupName, group] of Object.entries(styles$3)) {
 		for (const [styleName, style] of Object.entries(group)) {
-			styles$1[styleName] = {
+			styles$3[styleName] = {
 				open: `\u001B[${style[0]}m`,
 				close: `\u001B[${style[1]}m`,
 			};
 
-			group[styleName] = styles$1[styleName];
+			group[styleName] = styles$3[styleName];
 
 			codes.set(style[0], style[1]);
 		}
 
-		Object.defineProperty(styles$1, groupName, {
+		Object.defineProperty(styles$3, groupName, {
 			value: group,
 			enumerable: false,
 		});
 	}
 
-	Object.defineProperty(styles$1, 'codes', {
+	Object.defineProperty(styles$3, 'codes', {
 		value: codes,
 		enumerable: false,
 	});
 
-	styles$1.color.close = '\u001B[39m';
-	styles$1.bgColor.close = '\u001B[49m';
+	styles$3.color.close = '\u001B[39m';
+	styles$3.bgColor.close = '\u001B[49m';
 
-	styles$1.color.ansi = wrapAnsi16();
-	styles$1.color.ansi256 = wrapAnsi256();
-	styles$1.color.ansi16m = wrapAnsi16m();
-	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	styles$3.color.ansi = wrapAnsi16$1();
+	styles$3.color.ansi256 = wrapAnsi256$1();
+	styles$3.color.ansi16m = wrapAnsi16m$1();
+	styles$3.bgColor.ansi = wrapAnsi16$1(ANSI_BACKGROUND_OFFSET$1);
+	styles$3.bgColor.ansi256 = wrapAnsi256$1(ANSI_BACKGROUND_OFFSET$1);
+	styles$3.bgColor.ansi16m = wrapAnsi16m$1(ANSI_BACKGROUND_OFFSET$1);
 
 	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
-	Object.defineProperties(styles$1, {
+	Object.defineProperties(styles$3, {
 		rgbToAnsi256: {
 			value(red, green, blue) {
 				// We use the extended greyscale palette here, with the exception of
@@ -26134,7 +26152,7 @@ function assembleStyles() {
 			enumerable: false,
 		},
 		hexToAnsi256: {
-			value: hex => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			value: hex => styles$3.rgbToAnsi256(...styles$3.hexToRgb(hex)),
 			enumerable: false,
 		},
 		ansi256ToAnsi: {
@@ -26183,51 +26201,51 @@ function assembleStyles() {
 			enumerable: false,
 		},
 		rgbToAnsi: {
-			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			value: (red, green, blue) => styles$3.ansi256ToAnsi(styles$3.rgbToAnsi256(red, green, blue)),
 			enumerable: false,
 		},
 		hexToAnsi: {
-			value: hex => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			value: hex => styles$3.ansi256ToAnsi(styles$3.hexToAnsi256(hex)),
 			enumerable: false,
 		},
 	});
 
-	return styles$1;
+	return styles$3;
 }
 
-const ansiStyles = assembleStyles();
+const ansiStyles$1 = assembleStyles$1();
 
 /* eslint-env browser */
 
-const level = (() => {
-	if (navigator.userAgentData) {
+const level$1 = (() => {
+	if (globalThis?.navigator?.userAgentData) {
 		const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium');
 		if (brand && brand.version > 93) {
 			return 3;
 		}
 	}
 
-	if (/\b(Chrome|Chromium)\//.test(navigator.userAgent)) {
+	if (/\b(Chrome|Chromium)\//.test(globalThis?.navigator?.userAgent)) {
 		return 1;
 	}
 
 	return 0;
 })();
 
-const colorSupport = level !== 0 && {
-	level,
+const colorSupport$1 = level$1 !== 0 && {
+	level: level$1,
 	hasBasic: true,
-	has256: level >= 2,
-	has16m: level >= 3,
+	has256: level$1 >= 2,
+	has16m: level$1 >= 3,
 };
 
-const supportsColor = {
-	stdout: colorSupport,
-	stderr: colorSupport,
+const supportsColor$1 = {
+	stdout: colorSupport$1,
+	stderr: colorSupport$1,
 };
 
 // TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
-function stringReplaceAll(string, substring, replacer) {
+function stringReplaceAll$1(string, substring, replacer) {
 	let index = string.indexOf(substring);
 	if (index === -1) {
 		return string;
@@ -26246,7 +26264,7 @@ function stringReplaceAll(string, substring, replacer) {
 	return returnValue;
 }
 
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+function stringEncaseCRLFWithFirstIndex$1(string, prefix, postfix, index) {
 	let endIndex = 0;
 	let returnValue = '';
 	do {
@@ -26260,131 +26278,131 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
 	return returnValue;
 }
 
-const {stdout: stdoutColor, stderr: stderrColor} = supportsColor;
+const {stdout: stdoutColor$1, stderr: stderrColor$1} = supportsColor$1;
 
-const GENERATOR = Symbol('GENERATOR');
-const STYLER = Symbol('STYLER');
-const IS_EMPTY = Symbol('IS_EMPTY');
+const GENERATOR$1 = Symbol('GENERATOR');
+const STYLER$1 = Symbol('STYLER');
+const IS_EMPTY$1 = Symbol('IS_EMPTY');
 
 // `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = [
+const levelMapping$1 = [
 	'ansi',
 	'ansi',
 	'ansi256',
 	'ansi16m',
 ];
 
-const styles = Object.create(null);
+const styles$2 = Object.create(null);
 
-const applyOptions = (object, options = {}) => {
+const applyOptions$1 = (object, options = {}) => {
 	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
 		throw new Error('The `level` option should be an integer from 0 to 3');
 	}
 
 	// Detect level if not set manually
-	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	const colorLevel = stdoutColor$1 ? stdoutColor$1.level : 0;
 	object.level = options.level === undefined ? colorLevel : options.level;
 };
 
-class Chalk {
+let Chalk$1 = class Chalk {
 	constructor(options) {
 		// eslint-disable-next-line no-constructor-return
-		return chalkFactory(options);
+		return chalkFactory$1(options);
 	}
-}
+};
 
-const chalkFactory = options => {
+const chalkFactory$1 = options => {
 	const chalk = (...strings) => strings.join(' ');
-	applyOptions(chalk, options);
+	applyOptions$1(chalk, options);
 
-	Object.setPrototypeOf(chalk, createChalk.prototype);
+	Object.setPrototypeOf(chalk, createChalk$1.prototype);
 
 	return chalk;
 };
 
-function createChalk(options) {
-	return chalkFactory(options);
+function createChalk$1(options) {
+	return chalkFactory$1(options);
 }
 
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+Object.setPrototypeOf(createChalk$1.prototype, Function.prototype);
 
-for (const [styleName, style] of Object.entries(ansiStyles)) {
-	styles[styleName] = {
+for (const [styleName, style] of Object.entries(ansiStyles$1)) {
+	styles$2[styleName] = {
 		get() {
-			const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+			const builder = createBuilder$1(this, createStyler$1(style.open, style.close, this[STYLER$1]), this[IS_EMPTY$1]);
 			Object.defineProperty(this, styleName, {value: builder});
 			return builder;
 		},
 	};
 }
 
-styles.visible = {
+styles$2.visible = {
 	get() {
-		const builder = createBuilder(this, this[STYLER], true);
+		const builder = createBuilder$1(this, this[STYLER$1], true);
 		Object.defineProperty(this, 'visible', {value: builder});
 		return builder;
 	},
 };
 
-const getModelAnsi = (model, level, type, ...arguments_) => {
+const getModelAnsi$1 = (model, level, type, ...arguments_) => {
 	if (model === 'rgb') {
 		if (level === 'ansi16m') {
-			return ansiStyles[type].ansi16m(...arguments_);
+			return ansiStyles$1[type].ansi16m(...arguments_);
 		}
 
 		if (level === 'ansi256') {
-			return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+			return ansiStyles$1[type].ansi256(ansiStyles$1.rgbToAnsi256(...arguments_));
 		}
 
-		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+		return ansiStyles$1[type].ansi(ansiStyles$1.rgbToAnsi(...arguments_));
 	}
 
 	if (model === 'hex') {
-		return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));
+		return getModelAnsi$1('rgb', level, type, ...ansiStyles$1.hexToRgb(...arguments_));
 	}
 
-	return ansiStyles[type][model](...arguments_);
+	return ansiStyles$1[type][model](...arguments_);
 };
 
-const usedModels = ['rgb', 'hex', 'ansi256'];
+const usedModels$1 = ['rgb', 'hex', 'ansi256'];
 
-for (const model of usedModels) {
-	styles[model] = {
+for (const model of usedModels$1) {
+	styles$2[model] = {
 		get() {
 			const {level} = this;
 			return function (...arguments_) {
-				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);
-				return createBuilder(this, styler, this[IS_EMPTY]);
+				const styler = createStyler$1(getModelAnsi$1(model, levelMapping$1[level], 'color', ...arguments_), ansiStyles$1.color.close, this[STYLER$1]);
+				return createBuilder$1(this, styler, this[IS_EMPTY$1]);
 			};
 		},
 	};
 
 	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
-	styles[bgModel] = {
+	styles$2[bgModel] = {
 		get() {
 			const {level} = this;
 			return function (...arguments_) {
-				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
-				return createBuilder(this, styler, this[IS_EMPTY]);
+				const styler = createStyler$1(getModelAnsi$1(model, levelMapping$1[level], 'bgColor', ...arguments_), ansiStyles$1.bgColor.close, this[STYLER$1]);
+				return createBuilder$1(this, styler, this[IS_EMPTY$1]);
 			};
 		},
 	};
 }
 
-const proto = Object.defineProperties(() => {}, {
-	...styles,
+const proto$1 = Object.defineProperties(() => {}, {
+	...styles$2,
 	level: {
 		enumerable: true,
 		get() {
-			return this[GENERATOR].level;
+			return this[GENERATOR$1].level;
 		},
 		set(level) {
-			this[GENERATOR].level = level;
+			this[GENERATOR$1].level = level;
 		},
 	},
 });
 
-const createStyler = (open, close, parent) => {
+const createStyler$1 = (open, close, parent) => {
 	let openAll;
 	let closeAll;
 	if (parent === undefined) {
@@ -26404,28 +26422,28 @@ const createStyler = (open, close, parent) => {
 	};
 };
 
-const createBuilder = (self, _styler, _isEmpty) => {
+const createBuilder$1 = (self, _styler, _isEmpty) => {
 	// Single argument is hot path, implicit coercion is faster than anything
 	// eslint-disable-next-line no-implicit-coercion
-	const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+	const builder = (...arguments_) => applyStyle$1(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
 
 	// We alter the prototype because we must return a function, but there is
 	// no way to create a function with a different prototype
-	Object.setPrototypeOf(builder, proto);
+	Object.setPrototypeOf(builder, proto$1);
 
-	builder[GENERATOR] = self;
-	builder[STYLER] = _styler;
-	builder[IS_EMPTY] = _isEmpty;
+	builder[GENERATOR$1] = self;
+	builder[STYLER$1] = _styler;
+	builder[IS_EMPTY$1] = _isEmpty;
 
 	return builder;
 };
 
-const applyStyle = (self, string) => {
+const applyStyle$1 = (self, string) => {
 	if (self.level <= 0 || !string) {
-		return self[IS_EMPTY] ? '' : string;
+		return self[IS_EMPTY$1] ? '' : string;
 	}
 
-	let styler = self[STYLER];
+	let styler = self[STYLER$1];
 
 	if (styler === undefined) {
 		return string;
@@ -26437,7 +26455,7 @@ const applyStyle = (self, string) => {
 			// Replace any instances already present with a re-opening code
 			// otherwise only the part of the string until said closing code
 			// will be colored, and the rest will simply be 'plain'.
-			string = stringReplaceAll(string, styler.close, styler.open);
+			string = stringReplaceAll$1(string, styler.close, styler.open);
 
 			styler = styler.parent;
 		}
@@ -26448,18 +26466,18 @@ const applyStyle = (self, string) => {
 	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
 	const lfIndex = string.indexOf('\n');
 	if (lfIndex !== -1) {
-		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+		string = stringEncaseCRLFWithFirstIndex$1(string, closeAll, openAll, lfIndex);
 	}
 
 	return openAll + string + closeAll;
 };
 
-Object.defineProperties(createChalk.prototype, styles);
+Object.defineProperties(createChalk$1.prototype, styles$2);
 
-const chalk = createChalk();
-createChalk({level: stderrColor ? stderrColor.level : 0});
+const chalk$2 = createChalk$1();
+createChalk$1({level: stderrColor$1 ? stderrColor$1.level : 0});
 
-var chalk$1 = chalk;
+var chalk$3 = chalk$2;
 
 const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
 function getDefs$1(chalk) {
@@ -26481,7 +26499,7 @@ let tokenize;
 {
   const getTokenType = function (token) {
     if (token.type === "IdentifierName") {
-      if (isKeyword$1(token.value) || isStrictReservedWord$1(token.value, true) || sometimesKeywords.has(token.value)) {
+      if (isKeyword(token.value) || isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) {
         return "keyword";
       }
       if (token.value[0] !== token.value[0].toLowerCase()) {
@@ -26582,17 +26600,17 @@ function highlightTokens(defs, text) {
   return highlighted;
 }
 function shouldHighlight(options) {
-  return chalk$1.level > 0 || options.forceColor;
+  return chalk$3.level > 0 || options.forceColor;
 }
 let chalkWithForcedColor$1 = undefined;
 function getChalk$1(forceColor) {
   if (forceColor) {
-    chalkWithForcedColor$1 ??= new Chalk({
+    chalkWithForcedColor$1 ??= new Chalk$1({
       level: 1
     });
     return chalkWithForcedColor$1;
   }
-  return chalk$1;
+  return chalk$3;
 }
 function highlight(code, options = {}) {
   if (code !== "" && shouldHighlight(options)) {
@@ -26603,6 +26621,492 @@ function highlight(code, options = {}) {
   }
 }
 
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`;
+
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		// 21 isn't widely supported and 22 does the same thing
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29],
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+
+		// Bright color
+		blackBright: [90, 39],
+		gray: [90, 39], // Alias of `blackBright`
+		grey: [90, 39], // Alias of `blackBright`
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39],
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+
+		// Bright color
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49], // Alias of `bgBlackBright`
+		bgGrey: [100, 49], // Alias of `bgBlackBright`
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49],
+	},
+};
+
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+
+function assembleStyles() {
+	const codes = new Map();
+
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`,
+			};
+
+			group[styleName] = styles$1[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false,
+		});
+	}
+
+	Object.defineProperty(styles$1, 'codes', {
+		value: codes,
+		enumerable: false,
+	});
+
+	styles$1.color.close = '\u001B[39m';
+	styles$1.bgColor.close = '\u001B[49m';
+
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				// We use the extended greyscale palette here, with the exception of
+				// black and white. normal palette only has 4 greyscale shades.
+				if (red === green && green === blue) {
+					if (red < 8) {
+						return 16;
+					}
+
+					if (red > 248) {
+						return 231;
+					}
+
+					return Math.round(((red - 8) / 247) * 24) + 232;
+				}
+
+				return 16
+					+ (36 * Math.round(red / 255 * 5))
+					+ (6 * Math.round(green / 255 * 5))
+					+ Math.round(blue / 255 * 5);
+			},
+			enumerable: false,
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) {
+					return [0, 0, 0];
+				}
+
+				let [colorString] = matches;
+
+				if (colorString.length === 3) {
+					colorString = [...colorString].map(character => character + character).join('');
+				}
+
+				const integer = Number.parseInt(colorString, 16);
+
+				return [
+					/* eslint-disable no-bitwise */
+					(integer >> 16) & 0xFF,
+					(integer >> 8) & 0xFF,
+					integer & 0xFF,
+					/* eslint-enable no-bitwise */
+				];
+			},
+			enumerable: false,
+		},
+		hexToAnsi256: {
+			value: hex => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false,
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) {
+					return 30 + code;
+				}
+
+				if (code < 16) {
+					return 90 + (code - 8);
+				}
+
+				let red;
+				let green;
+				let blue;
+
+				if (code >= 232) {
+					red = (((code - 232) * 10) + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+
+					const remainder = code % 36;
+
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = (remainder % 6) / 5;
+				}
+
+				const value = Math.max(red, green, blue) * 2;
+
+				if (value === 0) {
+					return 30;
+				}
+
+				// eslint-disable-next-line no-bitwise
+				let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+
+				if (value === 2) {
+					result += 60;
+				}
+
+				return result;
+			},
+			enumerable: false,
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false,
+		},
+		hexToAnsi: {
+			value: hex => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false,
+		},
+	});
+
+	return styles$1;
+}
+
+const ansiStyles = assembleStyles();
+
+/* eslint-env browser */
+
+const level = (() => {
+	if (globalThis?.navigator?.userAgentData) {
+		const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium');
+		if (brand && brand.version > 93) {
+			return 3;
+		}
+	}
+
+	if (/\b(Chrome|Chromium)\//.test(globalThis?.navigator?.userAgent)) {
+		return 1;
+	}
+
+	return 0;
+})();
+
+const colorSupport = level !== 0 && {
+	level,
+	hasBasic: true,
+	has256: level >= 2,
+	has16m: level >= 3,
+};
+
+const supportsColor = {
+	stdout: colorSupport,
+	stderr: colorSupport,
+};
+
+// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+const {stdout: stdoutColor, stderr: stderrColor} = supportsColor;
+
+const GENERATOR = Symbol('GENERATOR');
+const STYLER = Symbol('STYLER');
+const IS_EMPTY = Symbol('IS_EMPTY');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m',
+];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+		throw new Error('The `level` option should be an integer from 0 to 3');
+	}
+
+	// Detect level if not set manually
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+class Chalk {
+	constructor(options) {
+		// eslint-disable-next-line no-constructor-return
+		return chalkFactory(options);
+	}
+}
+
+const chalkFactory = options => {
+	const chalk = (...strings) => strings.join(' ');
+	applyOptions(chalk, options);
+
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+
+	return chalk;
+};
+
+function createChalk(options) {
+	return chalkFactory(options);
+}
+
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+	styles[styleName] = {
+		get() {
+			const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+			Object.defineProperty(this, styleName, {value: builder});
+			return builder;
+		},
+	};
+}
+
+styles.visible = {
+	get() {
+		const builder = createBuilder(this, this[STYLER], true);
+		Object.defineProperty(this, 'visible', {value: builder});
+		return builder;
+	},
+};
+
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === 'rgb') {
+		if (level === 'ansi16m') {
+			return ansiStyles[type].ansi16m(...arguments_);
+		}
+
+		if (level === 'ansi256') {
+			return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		}
+
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+
+	if (model === 'hex') {
+		return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));
+	}
+
+	return ansiStyles[type][model](...arguments_);
+};
+
+const usedModels = ['rgb', 'hex', 'ansi256'];
+
+for (const model of usedModels) {
+	styles[model] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+}
+
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		},
+	},
+});
+
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === undefined) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent,
+	};
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+	// Single argument is hot path, implicit coercion is faster than anything
+	// eslint-disable-next-line no-implicit-coercion
+	const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+
+	// We alter the prototype because we must return a function, but there is
+	// no way to create a function with a different prototype
+	Object.setPrototypeOf(builder, proto);
+
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+
+	return builder;
+};
+
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) {
+		return self[IS_EMPTY] ? '' : string;
+	}
+
+	let styler = self[STYLER];
+
+	if (styler === undefined) {
+		return string;
+	}
+
+	const {openAll, closeAll} = styler;
+	if (string.includes('\u001B')) {
+		while (styler !== undefined) {
+			// Replace any instances already present with a re-opening code
+			// otherwise only the part of the string until said closing code
+			// will be colored, and the rest will simply be 'plain'.
+			string = stringReplaceAll(string, styler.close, styler.open);
+
+			styler = styler.parent;
+		}
+	}
+
+	// We can move both next actions out of loop, because remaining actions in loop won't have
+	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+	const lfIndex = string.indexOf('\n');
+	if (lfIndex !== -1) {
+		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	}
+
+	return openAll + string + closeAll;
+};
+
+Object.defineProperties(createChalk.prototype, styles);
+
+const chalk = createChalk();
+createChalk({level: stderrColor ? stderrColor.level : 0});
+
+var chalk$1 = chalk;
+
 let chalkWithForcedColor = undefined;
 function getChalk(forceColor) {
   if (forceColor) {
@@ -33995,7 +34499,7 @@ var common = setup$1;
 		}
 
 		// Internet Explorer and Edge do not support colors.
-		if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+		if (typeof navigator !== 'undefined' && globalThis?.navigator?.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
 			return false;
 		}
 
@@ -34006,9 +34510,9 @@ var common = setup$1;
 			(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
 			// Is firefox >= v31?
 			// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-			(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+			(typeof navigator !== 'undefined' && globalThis?.navigator?.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
 			// Double check webkit in userAgent just in case we are in a worker
-			(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+			(typeof navigator !== 'undefined' && globalThis?.navigator?.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
 	}
 
 	/**