eslint-plugin-formatjs 6.4.3 → 6.4.5

package/index.js

@@ -1,62 +1,4609 @@
-import { name as blocklistElementRuleName, rule as blocklistElements } from "./rules/blocklist-elements.js";
-import { rule as enforceDefaultMessage, name as enforceDefaultMessageName } from "./rules/enforce-default-message.js";
-import { rule as enforceDescription, name as enforceDescriptionName } from "./rules/enforce-description.js";
-import { rule as enforceId, name as enforceIdName } from "./rules/enforce-id.js";
-import { rule as enforcePlaceholders, name as enforcePlaceholdersName } from "./rules/enforce-placeholders.js";
-import { rule as enforcePluralRules, name as enforcePluralRulesName } from "./rules/enforce-plural-rules.js";
-import { rule as noCamelCase, name as noCamelCaseName } from "./rules/no-camel-case.js";
-import { rule as noComplexSelectors, name as noComplexSelectorsName } from "./rules/no-complex-selectors.js";
-import { rule as noEmoji, name as noEmojiName } from "./rules/no-emoji.js";
-import { rule as noId, name as noIdName } from "./rules/no-id.js";
-import { rule as noInvalidICU, name as noInvalidICUName } from "./rules/no-invalid-icu.js";
-import { rule as noLiteralStringInJsx, name as noLiteralStringInJsxName } from "./rules/no-literal-string-in-jsx.js";
-import { rule as noMissingIcuPluralOnePlaceholders, name as noMissingIcuPluralOnePlaceholdersName } from "./rules/no-missing-icu-plural-one-placeholders.js";
-import { rule as noMultiplePlurals, name as noMultiplePluralsName } from "./rules/no-multiple-plurals.js";
-import { rule as noMultipleWhitespaces, name as noMultipleWhitespacesName } from "./rules/no-multiple-whitespaces.js";
-import { rule as noOffset, name as noOffsetName } from "./rules/no-offset.js";
-import { rule as noUselessMessage, name as noUselessMessageName } from "./rules/no-useless-message.js";
-import { rule as preferFormattedMessage, name as preferFormattedMessageName } from "./rules/prefer-formatted-message.js";
-import { rule as preferPoundInPlural, name as preferPoundInPluralName } from "./rules/prefer-pound-in-plural.js";
-import { rule as noLiteralStringInObject, name as noLiteralStringInObjectName } from "./rules/no-literal-string-in-object.js";
-import { rule as preferFullSentence, name as preferFullSentenceName } from "./rules/prefer-full-sentence.js";
-import * as packageJsonNs from "./package.json" with { type: "json" };
-const packageJson = packageJsonNs.default ?? packageJsonNs;
-const { name, version } = packageJson;
-// All rules
-const rules = {
-	[blocklistElementRuleName]: blocklistElements,
-	[enforceDefaultMessageName]: enforceDefaultMessage,
-	[enforceDescriptionName]: enforceDescription,
-	[enforceIdName]: enforceId,
-	[enforcePlaceholdersName]: enforcePlaceholders,
-	[enforcePluralRulesName]: enforcePluralRules,
-	[noCamelCaseName]: noCamelCase,
-	[noComplexSelectorsName]: noComplexSelectors,
-	[noEmojiName]: noEmoji,
-	[noIdName]: noId,
-	[noInvalidICUName]: noInvalidICU,
-	[noLiteralStringInJsxName]: noLiteralStringInJsx,
-	[noMultiplePluralsName]: noMultiplePlurals,
-	[noMultipleWhitespacesName]: noMultipleWhitespaces,
-	[noOffsetName]: noOffset,
-	[noUselessMessageName]: noUselessMessage,
-	[preferFormattedMessageName]: preferFormattedMessage,
-	[preferPoundInPluralName]: preferPoundInPlural,
-	[noMissingIcuPluralOnePlaceholdersName]: noMissingIcuPluralOnePlaceholders,
-	[noLiteralStringInObjectName]: noLiteralStringInObject,
-	[preferFullSentenceName]: preferFullSentence
-};
-// Base plugin
+import { TYPE, isArgumentElement, isDateElement, isLiteralElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, parse } from "@formatjs/icu-messageformat-parser";
+import { interpolateName } from "@formatjs/ts-transformer";
+import * as emojiPresentationRegex from "@unicode/unicode-17.0.0/Binary_Property/Emoji_Presentation/regex.js";
+import * as emojiPropertyRegex from "@unicode/unicode-17.0.0/Binary_Property/Emoji/regex.js";
+import * as picomatchNs from "picomatch";
+import MagicString from "magic-string";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/util.ts
+const FORMAT_FUNCTION_NAMES = new Set([
+	"$formatMessage",
+	"formatMessage",
+	"$t"
+]);
+const COMPONENT_NAMES = new Set(["FormattedMessage"]);
+const DECLARATION_FUNCTION_NAMES = new Set(["defineMessage"]);
+function getSettings({ settings }) {
+	return settings.formatjs ?? settings;
+}
+function isStringLiteral(node) {
+	return node.type === "Literal" && typeof node.value === "string";
+}
+function isTemplateLiteralWithoutVar(node) {
+	return node.type === "TemplateLiteral" && node.quasis.length === 1;
+}
+function staticallyEvaluateStringConcat(node) {
+	const right = node.right;
+	const left = node.left;
+	if (!isStringLiteral(right)) return ["", false];
+	if (isStringLiteral(left)) return [left.value + right.value, true];
+	if (node.left.type === "BinaryExpression") {
+		const [result, isStaticallyEvaluatable] = staticallyEvaluateStringConcat(node.left);
+		return [result + right.value, isStaticallyEvaluatable];
+	}
+	return ["", false];
+}
+function isIntlFormatMessageCall(node) {
+	if (node.type !== "CallExpression") return false;
+	if (node.arguments.length < 1 || node.arguments[0].type !== "ObjectExpression") return false;
+	if (node.callee.type === "MemberExpression") return (node.callee.object.type === "Identifier" && node.callee.object.name === "intl" || node.callee.object.type === "MemberExpression" && node.callee.object.property.type === "Identifier" && node.callee.object.property.name === "intl") && node.callee.property.type === "Identifier" && (node.callee.property.name === "formatMessage" || node.callee.property.name === "$t");
+	if (node.callee.type === "Identifier") return FORMAT_FUNCTION_NAMES.has(node.callee.name);
+	return false;
+}
+function isSingleMessageDescriptorDeclaration(node, functionNames) {
+	return node.type === "CallExpression" && node.callee.type === "Identifier" && functionNames.has(node.callee.name);
+}
+function isMultipleMessageDescriptorDeclaration(node) {
+	return node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "defineMessages";
+}
+function extractMessageDescriptor(node) {
+	if (!node || node.type !== "ObjectExpression") return;
+	const result = {
+		messageDescriptorNode: node,
+		message: {},
+		messageNode: void 0,
+		messagePropNode: void 0,
+		descriptionNode: void 0,
+		idValueNode: void 0
+	};
+	for (const prop of node.properties) {
+		if (prop.type !== "Property" || prop.key.type !== "Identifier") continue;
+		const propName = prop.key.name;
+		if (propName !== "id" && propName !== "defaultMessage" && propName !== "description") continue;
+		const valueNode = prop.value;
+		let value = void 0;
+		if (isStringLiteral(valueNode)) value = valueNode.value;
+		else if (isTemplateLiteralWithoutVar(valueNode)) value = valueNode.quasis[0].value.cooked ?? void 0;
+		else if (valueNode.type === "TaggedTemplateExpression") {
+			const { quasi } = valueNode;
+			if (!isTemplateLiteralWithoutVar(quasi)) throw new Error("Tagged template expression must be no substitution");
+			value = quasi.quasis[0].value.cooked ?? void 0;
+		} else if (valueNode.type === "BinaryExpression") {
+			const [result, isStatic] = staticallyEvaluateStringConcat(valueNode);
+			if (isStatic) value = result;
+		}
+		switch (propName) {
+			case "defaultMessage":
+				result.messagePropNode = prop;
+				result.messageNode = valueNode;
+				result.message.defaultMessage = value;
+				break;
+			case "description":
+				result.descriptionNode = valueNode;
+				result.message.description = value;
+				break;
+			case "id":
+				result.message.id = value;
+				result.idValueNode = valueNode;
+				result.idPropNode = prop;
+				break;
+		}
+	}
+	return result;
+}
+function extractMessageDescriptorFromJSXElement(node) {
+	if (!node || !node.attributes) return;
+	let values;
+	const result = {
+		messageDescriptorNode: node,
+		message: {},
+		messageNode: void 0,
+		messagePropNode: void 0,
+		descriptionNode: void 0,
+		idValueNode: void 0,
+		idPropNode: void 0
+	};
+	let hasSpreadAttribute = false;
+	for (const prop of node.attributes) {
+		if (prop.type === "JSXSpreadAttribute") hasSpreadAttribute = true;
+		if (prop.type !== "JSXAttribute" || prop.name.type !== "JSXIdentifier") continue;
+		const keyName = prop.name.name;
+		const isMessageProp = keyName === "id" || keyName === "defaultMessage" || keyName === "description";
+		let valueNode = prop.value;
+		let value = void 0;
+		if (valueNode && isMessageProp) {
+			if (isStringLiteral(valueNode)) value = valueNode.value;
+			else if (valueNode?.type === "JSXExpressionContainer") {
+				const { expression } = valueNode;
+				if (expression.type === "BinaryExpression") {
+					const [result, isStatic] = staticallyEvaluateStringConcat(expression);
+					if (isStatic) value = result;
+				} else if (isTemplateLiteralWithoutVar(expression)) value = expression.quasis[0].value.cooked ?? void 0;
+				else if (expression.type === "TaggedTemplateExpression") {
+					const { quasi } = expression;
+					if (!isTemplateLiteralWithoutVar(quasi)) throw new Error("Tagged template expression must be no substitution");
+					value = quasi.quasis[0].value.cooked ?? void 0;
+				}
+			}
+		}
+		switch (keyName) {
+			case "defaultMessage":
+				result.messagePropNode = prop;
+				result.messageNode = valueNode;
+				if (value) result.message.defaultMessage = value;
+				break;
+			case "description":
+				result.descriptionNode = valueNode;
+				if (value) result.message.description = value;
+				break;
+			case "id":
+				result.idValueNode = valueNode;
+				result.idPropNode = prop;
+				if (value) result.message.id = value;
+				break;
+			case "values":
+				if (valueNode?.type === "JSXExpressionContainer" && valueNode.expression.type === "ObjectExpression") values = valueNode.expression;
+				break;
+		}
+	}
+	if (!result.messagePropNode && !result.descriptionNode && !result.idPropNode && hasSpreadAttribute) return;
+	return [result, values];
+}
+function extractMessageDescriptors(node) {
+	if (!node || node.type !== "ObjectExpression" || !node.properties.length) return [];
+	const msgs = [];
+	for (const prop of node.properties) {
+		if (prop.type !== "Property") continue;
+		const msg = prop.value;
+		if (msg.type !== "ObjectExpression") continue;
+		const nodeInfo = extractMessageDescriptor(msg);
+		if (nodeInfo) msgs.push(nodeInfo);
+	}
+	return msgs;
+}
+function extractMessages(node, { additionalComponentNames, additionalFunctionNames, excludeMessageDeclCalls } = {}) {
+	const allFormatFunctionNames = Array.isArray(additionalFunctionNames) ? new Set([...Array.from(FORMAT_FUNCTION_NAMES), ...additionalFunctionNames]) : FORMAT_FUNCTION_NAMES;
+	const allComponentNames = Array.isArray(additionalComponentNames) ? new Set([...Array.from(COMPONENT_NAMES), ...additionalComponentNames]) : COMPONENT_NAMES;
+	if (node.type === "CallExpression") {
+		const args0 = node.arguments[0];
+		const args1 = node.arguments[1];
+		if (!args0 || args0.type === "SpreadElement") return [];
+		if (!excludeMessageDeclCalls && isSingleMessageDescriptorDeclaration(node, DECLARATION_FUNCTION_NAMES) || isIntlFormatMessageCall(node) || isSingleMessageDescriptorDeclaration(node, allFormatFunctionNames)) {
+			const msgDescriptorNodeInfo = extractMessageDescriptor(args0);
+			if (msgDescriptorNodeInfo && (!args1 || args1.type !== "SpreadElement")) return [[msgDescriptorNodeInfo, args1]];
+		} else if (!excludeMessageDeclCalls && isMultipleMessageDescriptorDeclaration(node)) return extractMessageDescriptors(args0).map((msg) => [msg, void 0]);
+	} else if (node.type === "JSXOpeningElement" && node.name && node.name.type === "JSXIdentifier" && allComponentNames.has(node.name.name)) {
+		const msgDescriptorNodeInfo = extractMessageDescriptorFromJSXElement(node);
+		if (msgDescriptorNodeInfo) return [msgDescriptorNodeInfo];
+	}
+	return [];
+}
+/**
+* Apply changes to the ICU message in code. The return value can be used in
+* `fixer.replaceText(messageNode, <return value>)`. If the return value is null,
+* it means that the patch cannot be applied.
+*/
+function patchMessage(messageNode, ast, patcher) {
+	if (messageNode.type === "Literal" && messageNode.value && typeof messageNode.value === "string") return "\"" + patcher(messageNode.value, ast).replace("\"", "\\\"") + "\"";
+	else if (messageNode.type === "TemplateLiteral" && messageNode.quasis.length === 1 && messageNode.expressions.length === 0) return "`" + patcher(messageNode.quasis[0].value.cooked, ast).replace(/\\/g, "\\\\").replace(/`/g, "\\`") + "`";
+	return null;
+}
+//#endregion
+//#region packages/eslint-plugin-formatjs/messages.ts
+const CORE_MESSAGES = { parseError: `Failed to parse message string {{error}}` };
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/blocklist-elements.ts
+const name$22 = "blocklist-elements";
+function getMessage(type) {
+	return {
+		messageId: "blocklist",
+		data: { type }
+	};
+}
+let Element = /* @__PURE__ */ function(Element) {
+	Element["literal"] = "literal";
+	Element["argument"] = "argument";
+	Element["number"] = "number";
+	Element["date"] = "date";
+	Element["time"] = "time";
+	Element["select"] = "select";
+	Element["selectordinal"] = "selectordinal";
+	Element["plural"] = "plural";
+	Element["tag"] = "tag";
+	return Element;
+}({});
+function verifyAst$7(blocklist, ast) {
+	const errors = [];
+	for (const el of ast) {
+		if (isLiteralElement(el) && blocklist.includes(Element.literal)) errors.push(getMessage(Element.literal));
+		if (isArgumentElement(el) && blocklist.includes(Element.argument)) errors.push(getMessage(Element.argument));
+		if (isNumberElement(el) && blocklist.includes(Element.number)) errors.push(getMessage(Element.number));
+		if (isDateElement(el) && blocklist.includes(Element.date)) errors.push(getMessage(Element.date));
+		if (isTimeElement(el) && blocklist.includes(Element.time)) errors.push(getMessage(Element.time));
+		if (isSelectElement(el) && blocklist.includes(Element.select)) errors.push(getMessage(Element.select));
+		if (isTagElement(el) && blocklist.includes(Element.tag)) errors.push(getMessage(Element.tag));
+		if (isPluralElement(el)) {
+			if (blocklist.includes(Element.plural)) errors.push(getMessage(Element.argument));
+			if (el.pluralType === "ordinal" && blocklist.includes(Element.selectordinal)) errors.push(getMessage(Element.selectordinal));
+		}
+		if (isSelectElement(el) || isPluralElement(el)) {
+			const { options } = el;
+			for (const selector of Object.keys(options)) verifyAst$7(blocklist, options[selector].value);
+		}
+	}
+	return errors;
+}
+function checkNode$17(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, settings);
+	if (!msgs.length) return;
+	const blocklist = context.options[0];
+	if (!Array.isArray(blocklist) || !blocklist.length) return;
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+			continue;
+		}
+		const errors = verifyAst$7(blocklist, ast);
+		for (const error of errors) context.report({
+			node: messageNode,
+			...error
+		});
+	}
+}
+const rule$20 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow specific elements in ICU message format",
+			url: "https://formatjs.github.io/docs/tooling/linter#blocklist-elements"
+		},
+		fixable: "code",
+		schema: [{
+			type: "array",
+			items: {
+				type: "string",
+				enum: Object.keys(Element)
+			}
+		}],
+		messages: {
+			...CORE_MESSAGES,
+			blocklist: `{{type}} element is blocklisted`
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$17(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$17(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/enforce-default-message.ts
+let Option$1 = /* @__PURE__ */ function(Option) {
+	Option["literal"] = "literal";
+	Option["anything"] = "anything";
+	return Option;
+}({});
+const name$21 = "enforce-default-message";
+function checkNode$16(context, node) {
+	const msgs = extractMessages(node, getSettings(context));
+	const { options: [type] } = context;
+	for (const [{ message: { defaultMessage }, messageNode, messageDescriptorNode }] of msgs) if (!defaultMessage) {
+		if (type === "literal" && messageNode) context.report({
+			node: messageNode,
+			messageId: "defaultMessageLiteral"
+		});
+		else if (!messageNode) context.report({
+			node: messageDescriptorNode,
+			messageId: "defaultMessage"
+		});
+	}
+}
+const rule$19 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce defaultMessage in message descriptor",
+			url: "https://formatjs.github.io/docs/tooling/linter#enforce-default-message"
+		},
+		fixable: "code",
+		schema: [{
+			type: "string",
+			enum: Object.keys(Option$1)
+		}],
+		messages: {
+			defaultMessageLiteral: `"defaultMessage" must be:
+- a string literal or
+- template literal without variable`,
+			defaultMessage: "`defaultMessage` has to be specified in message descriptor"
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$16(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$16(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/enforce-description.ts
+let Option = /* @__PURE__ */ function(Option) {
+	Option["literal"] = "literal";
+	Option["anything"] = "anything";
+	return Option;
+}({});
+function normalizeOptions(raw) {
+	if (typeof raw === "string") return {
+		mode: raw,
+		minLength: void 0
+	};
+	if (typeof raw === "object" && raw !== null) return {
+		mode: raw.mode,
+		minLength: raw.minLength
+	};
+	return {
+		mode: void 0,
+		minLength: void 0
+	};
+}
+function checkNode$15(context, node) {
+	const msgs = extractMessages(node, getSettings(context));
+	const { mode: type, minLength } = normalizeOptions(context.options[0]);
+	for (const [{ message: { description }, descriptionNode, messageDescriptorNode }] of msgs) if (!description) {
+		if (type === "literal" && descriptionNode) context.report({
+			node: descriptionNode,
+			messageId: "enforceDescriptionLiteral"
+		});
+		else if (!descriptionNode) context.report({
+			node: messageDescriptorNode,
+			messageId: "enforceDescription"
+		});
+	} else if (typeof minLength === "number" && typeof description === "string" && description.length < minLength) context.report({
+		node: descriptionNode ?? messageDescriptorNode,
+		messageId: "enforceDescriptionMinLength",
+		data: {
+			minLength: String(minLength),
+			length: String(description.length)
+		}
+	});
+}
+const name$20 = "enforce-description";
+const rule$18 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce description in message descriptor",
+			url: "https://formatjs.github.io/docs/tooling/linter#enforce-description"
+		},
+		fixable: "code",
+		schema: [{ oneOf: [{
+			type: "string",
+			enum: Object.keys(Option)
+		}, {
+			type: "object",
+			properties: {
+				mode: {
+					type: "string",
+					enum: Object.keys(Option)
+				},
+				minLength: {
+					type: "integer",
+					minimum: 1
+				}
+			},
+			additionalProperties: false,
+			minProperties: 1
+		}] }],
+		messages: {
+			enforceDescription: "`description` has to be specified in message descriptor",
+			enforceDescriptionLiteral: "`description` has to be a string literal (not function call or variable)",
+			enforceDescriptionMinLength: "`description` must be at least {{minLength}} characters long (currently {{length}})"
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$15(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$15(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/enforce-id.ts
+function checkNode$14(context, node, { idInterpolationPattern, idWhitelistRegexps, quoteStyle }) {
+	const msgs = extractMessages(node, getSettings(context));
+	for (const [{ message: { defaultMessage, description, id }, idPropNode, descriptionNode, messagePropNode, messageDescriptorNode }] of msgs) {
+		if (!idInterpolationPattern && !idPropNode) {
+			context.report({
+				node: messageDescriptorNode ?? node,
+				messageId: "enforceId"
+			});
+			return;
+		}
+		if (idInterpolationPattern) if (!defaultMessage) context.report({
+			node: messageDescriptorNode ?? node,
+			messageId: "enforceIdDefaultMessage"
+		});
+		else if (!description && descriptionNode) context.report({
+			node: messageDescriptorNode ?? node,
+			messageId: "enforceIdDescription"
+		});
+		else {
+			if (idWhitelistRegexps && id && idWhitelistRegexps.some((r) => r.test(id))) continue;
+			const correctId = interpolateName({ resourcePath: context.filename }, idInterpolationPattern, { content: description ? `${defaultMessage}#${description}` : defaultMessage });
+			if (id !== correctId) {
+				let messageId = "enforceIdMatching";
+				let messageData = {
+					idInterpolationPattern,
+					expected: correctId,
+					actual: id
+				};
+				if (idWhitelistRegexps) {
+					messageId = "enforceIdMatchingAllowlisted";
+					messageData = {
+						...messageData,
+						idWhitelist: idWhitelistRegexps.map((r) => `"${r.toString()}"`).join(", ")
+					};
+				}
+				const quote = quoteStyle === "double" ? "\"" : "'";
+				context.report({
+					node: idPropNode ?? messageDescriptorNode ?? node,
+					messageId,
+					data: messageData,
+					fix(fixer) {
+						if (idPropNode) {
+							if (idPropNode.type === "JSXAttribute") return fixer.replaceText(idPropNode, `id="${correctId}"`);
+							return fixer.replaceText(idPropNode, `id: ${quote}${correctId}${quote}`);
+						}
+						if (messagePropNode) {
+							if (messagePropNode.type === "JSXAttribute") return fixer.insertTextAfter(messagePropNode, ` id="${correctId}"`);
+							return fixer.insertTextAfter(messagePropNode, `, id: ${quote}${correctId}${quote}`);
+						}
+						return null;
+					}
+				});
+			}
+		}
+	}
+}
+const name$19 = "enforce-id";
+const rule$17 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce (generated) ID in message descriptor",
+			url: "https://formatjs.github.io/docs/tooling/linter#enforce-id"
+		},
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: {
+				idInterpolationPattern: {
+					type: "string",
+					description: "Pattern to verify ID against. Recommended value: [sha512:contenthash:base64:6]"
+				},
+				idWhitelist: {
+					type: "array",
+					description: "An array of strings with regular expressions. This array allows allowlist custom ids for messages. For example '`\\\\.`' allows any id which has dot; `'^payment_.*'` - allows any custom id which has prefix `payment_`. Be aware that any backslash \\ provided via string must be escaped with an additional backslash.",
+					items: { type: "string" }
+				},
+				quoteStyle: {
+					type: "string",
+					enum: ["single", "double"],
+					description: "Quote style for generated IDs. Defaults to single quotes."
+				}
+			},
+			required: ["idInterpolationPattern"],
+			additionalProperties: false
+		}],
+		messages: {
+			enforceId: `id must be specified`,
+			enforceIdDefaultMessage: `defaultMessage must be a string literal to calculate generated IDs`,
+			enforceIdDescription: `description must be a string literal to calculate generated IDs`,
+			enforceIdMatching: `"id" does not match with hash pattern {{idInterpolationPattern}}.
+Expected: {{expected}}
+Actual: {{actual}}`,
+			enforceIdMatchingAllowlisted: `"id" does not match with hash pattern {{idInterpolationPattern}} or allowlisted patterns {{idWhitelist}}.
+Expected: {{expected}}
+Actual: {{actual}}`
+		}
+	},
+	create(context) {
+		const tmp = context.options[0];
+		let opts = {
+			idInterpolationPattern: tmp?.idInterpolationPattern,
+			quoteStyle: tmp?.quoteStyle || "single"
+		};
+		if (Array.isArray(tmp?.idWhitelist)) {
+			const { idWhitelist } = tmp;
+			opts.idWhitelistRegexps = idWhitelist.map((str) => new RegExp(str, "i"));
+		}
+		const callExpressionVisitor = (node) => checkNode$14(context, node, opts);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$14(context, node, opts),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/enforce-placeholders.ts
+function collectPlaceholderNames(ast) {
+	const placeholderNames = /* @__PURE__ */ new Set();
+	_traverse(ast);
+	return placeholderNames;
+	function _traverse(ast) {
+		for (const element of ast) switch (element.type) {
+			case TYPE.literal:
+			case TYPE.pound: break;
+			case TYPE.tag:
+				placeholderNames.add(element.value);
+				_traverse(element.children);
+				break;
+			case TYPE.plural:
+			case TYPE.select:
+				placeholderNames.add(element.value);
+				for (const { value } of Object.values(element.options)) _traverse(value);
+				break;
+			default:
+				placeholderNames.add(element.value);
+				break;
+		}
+	}
+}
+function checkNode$13(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, {
+		excludeMessageDeclCalls: true,
+		...settings
+	});
+	const { options: [opt] } = context;
+	const ignoreList = new Set(opt?.ignoreList || []);
+	for (const [{ message: { defaultMessage }, messageNode }, values] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		if (values && values.type !== "ObjectExpression") continue;
+		if (values?.properties.find((prop) => prop.type === "SpreadElement")) continue;
+		const literalElementByLiteralKey = /* @__PURE__ */ new Map();
+		if (values) {
+			for (const prop of values.properties) if (prop.type === "Property" && !prop.computed) {
+				const name = prop.key.type === "Identifier" ? prop.key.name : String(prop.key.value);
+				literalElementByLiteralKey.set(name, prop);
+			}
+		}
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e instanceof Error ? e.message : String(e) }
+			});
+			continue;
+		}
+		const placeholderNames = collectPlaceholderNames(ast);
+		const missingPlaceholders = [];
+		placeholderNames.forEach((name) => {
+			if (!ignoreList.has(name) && !literalElementByLiteralKey.has(name)) missingPlaceholders.push(name);
+		});
+		if (missingPlaceholders.length > 0) context.report({
+			node: messageNode,
+			messageId: "missingValue",
+			data: { list: missingPlaceholders.join(", ") }
+		});
+		literalElementByLiteralKey.forEach((element, key) => {
+			if (!ignoreList.has(key) && !placeholderNames.has(key)) context.report({
+				node: element,
+				messageId: "unusedValue"
+			});
+		});
+	}
+}
+const name$18 = "enforce-placeholders";
+const rule$16 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce that all messages with placeholders have enough passed-in values",
+			url: "https://formatjs.github.io/docs/tooling/linter#enforce-placeholders"
+		},
+		schema: [{
+			type: "object",
+			properties: { ignoreList: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			additionalProperties: false
+		}],
+		messages: {
+			...CORE_MESSAGES,
+			missingValue: "Missing value(s) for the following placeholder(s): {{list}}.",
+			unusedValue: "Value not used by the message."
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$13(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$13(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/enforce-plural-rules.ts
+var LDML = /* @__PURE__ */ function(LDML) {
+	LDML["zero"] = "zero";
+	LDML["one"] = "one";
+	LDML["two"] = "two";
+	LDML["few"] = "few";
+	LDML["many"] = "many";
+	LDML["other"] = "other";
+	return LDML;
+}(LDML || {});
+function verifyAst$6(plConfig, ast) {
+	const errors = [];
+	for (const el of ast) if (isPluralElement(el)) {
+		const rules = Object.keys(plConfig);
+		for (const rule of rules) {
+			if (plConfig[rule] && !el.options[rule]) errors.push({
+				messageId: "missingPlural",
+				data: { rule }
+			});
+			if (!plConfig[rule] && el.options[rule]) errors.push({
+				messageId: "forbidden",
+				data: { rule }
+			});
+		}
+		const { options } = el;
+		for (const selector of Object.keys(options)) errors.push(...verifyAst$6(plConfig, options[selector].value));
+	}
+	return errors;
+}
+function checkNode$12(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, settings);
+	if (!msgs.length) return;
+	const plConfig = context.options[0];
+	if (!plConfig) return;
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+			continue;
+		}
+		const errors = verifyAst$6(plConfig, ast);
+		for (const error of errors) context.report({
+			node: messageNode,
+			...error
+		});
+	}
+}
+const name$17 = "enforce-plural-rules";
+const rule$15 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce plural rules to always specify certain categories like `one`/`other`",
+			url: "https://formatjs.github.io/docs/tooling/linter#enforce-plural-rules"
+		},
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: Object.keys(LDML).reduce((schema, k) => {
+				schema[k] = { type: "boolean" };
+				return schema;
+			}, {}),
+			additionalProperties: false
+		}],
+		messages: {
+			...CORE_MESSAGES,
+			missingPlural: `Missing plural rule "{{rule}}"`,
+			forbidden: `Plural rule "{{rule}}" is forbidden`
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$12(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$12(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-camel-case.ts
+const name$16 = "no-camel-case";
+const CAMEL_CASE_REGEX = /[A-Z]/;
+function verifyAst$5(ast) {
+	const errors = [];
+	for (const el of ast) {
+		if (isArgumentElement(el)) {
+			if (CAMEL_CASE_REGEX.test(el.value)) errors.push({
+				messageId: "camelcase",
+				data: {}
+			});
+			continue;
+		}
+		if (isPluralElement(el)) {
+			if (CAMEL_CASE_REGEX.test(el.value)) errors.push({
+				messageId: "camelcase",
+				data: {}
+			});
+			const { options } = el;
+			for (const selector of Object.keys(options)) errors.push(...verifyAst$5(options[selector].value));
+		}
+	}
+	return errors;
+}
+function checkNode$11(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, settings);
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+			continue;
+		}
+		const errors = verifyAst$5(ast);
+		for (const error of errors) context.report({
+			node: messageNode,
+			...error
+		});
+	}
+}
+const rule$14 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow camel case placeholders in message",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-camel-case"
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			...CORE_MESSAGES,
+			camelcase: "Camel case arguments are not allowed"
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$11(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$11(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-complex-selectors.ts
+function calculateComplexity(ast) {
+	const complexityByNode = /* @__PURE__ */ new Map();
+	return _calculate(ast, 0);
+	function _calculate(ast, index) {
+		const element = ast[index];
+		if (!element) return 1;
+		const cachedComplexity = complexityByNode.get(element);
+		if (cachedComplexity !== void 0) return cachedComplexity;
+		let complexity;
+		switch (element.type) {
+			case TYPE.plural:
+			case TYPE.select: {
+				let sumOfOptions = 0;
+				for (const { value } of Object.values(element.options)) sumOfOptions += _calculate(value, 0);
+				complexity = sumOfOptions * _calculate(ast, index + 1);
+				break;
+			}
+			case TYPE.tag:
+				complexity = _calculate(element.children, 0) * _calculate(ast, index + 1);
+				break;
+			default:
+				complexity = _calculate(ast, index + 1);
+				break;
+		}
+		complexityByNode.set(element, complexity);
+		return complexity;
+	}
+}
+function checkNode$10(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, settings);
+	if (!msgs.length) return;
+	const config = {
+		limit: 20,
+		...context.options[0]
+	};
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e instanceof Error ? e.message : String(e) }
+			});
+			return;
+		}
+		const complexity = calculateComplexity(ast);
+		if (complexity > config.limit) context.report({
+			node: messageNode,
+			messageId: "tooComplex",
+			data: {
+				complexity,
+				limit: config.limit
+			}
+		});
+	}
+}
+const name$15 = "no-complex-selectors";
+const rule$13 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: `Make sure a sentence is not too complex.
+Complexity is determined by how many strings are produced when we try to
+flatten the sentence given its selectors. For example:
+"I have {count, plural, one{a dog} other{many dogs}}"
+has the complexity of 2 because flattening the plural selector
+results in 2 sentences: "I have a dog" & "I have many dogs".
+Default complexity limit is 20
+(using Smartling as a reference: https://help.smartling.com/hc/en-us/articles/360008030994-ICU-MessageFormat)
+`,
+			url: "https://formatjs.github.io/docs/tooling/linter#no-complex-selectors"
+		},
+		schema: [{
+			type: "object",
+			properties: { limit: { type: "number" } },
+			additionalProperties: false
+		}],
+		fixable: "code",
+		messages: {
+			...CORE_MESSAGES,
+			tooComplex: `Message complexity is too high ({{complexity}} vs limit at {{limit}})`
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$10(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$10(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/emoji-data.generated.ts
+const EMOJI_VERSIONS = [
+	"0.0",
+	"0.6",
+	"0.7",
+	"1.0",
+	"2.0",
+	"3.0",
+	"4.0",
+	"5.0",
+	"11.0",
+	"12.0",
+	"13.0",
+	"14.0",
+	"15.0",
+	"16.0",
+	"17.0"
+];
+/**
+* Emoji codepoint ranges with their Unicode versions
+* Total ranges: 418
+*
+* To check if a codepoint belongs to a version, iterate through ranges
+* and check if codepoint >= start && codepoint <= end
+*/
+const EMOJI_RANGES = [
+	{
+		start: 35,
+		end: 35,
+		version: "0.0",
+		name: "hash sign"
+	},
+	{
+		start: 42,
+		end: 42,
+		version: "0.0",
+		name: "asterisk"
+	},
+	{
+		start: 48,
+		end: 57,
+		version: "0.0",
+		name: "digit zero..digit nine"
+	},
+	{
+		start: 127462,
+		end: 127487,
+		version: "0.0",
+		name: "regional indicator symbol letter a..regional indicator symbol letter z"
+	},
+	{
+		start: 169,
+		end: 169,
+		version: "0.6",
+		name: "copyright"
+	},
+	{
+		start: 174,
+		end: 174,
+		version: "0.6",
+		name: "registered"
+	},
+	{
+		start: 8252,
+		end: 8252,
+		version: "0.6",
+		name: "double exclamation mark"
+	},
+	{
+		start: 8265,
+		end: 8265,
+		version: "0.6",
+		name: "exclamation question mark"
+	},
+	{
+		start: 8482,
+		end: 8482,
+		version: "0.6",
+		name: "trade mark"
+	},
+	{
+		start: 8505,
+		end: 8505,
+		version: "0.6",
+		name: "information"
+	},
+	{
+		start: 8596,
+		end: 8601,
+		version: "0.6",
+		name: "left-right arrow..down-left arrow"
+	},
+	{
+		start: 8617,
+		end: 8618,
+		version: "0.6",
+		name: "right arrow curving left..left arrow curving right"
+	},
+	{
+		start: 8986,
+		end: 8987,
+		version: "0.6",
+		name: "watch..hourglass done"
+	},
+	{
+		start: 9193,
+		end: 9196,
+		version: "0.6",
+		name: "fast-forward button..fast down button"
+	},
+	{
+		start: 9200,
+		end: 9200,
+		version: "0.6",
+		name: "alarm clock"
+	},
+	{
+		start: 9203,
+		end: 9203,
+		version: "0.6",
+		name: "hourglass not done"
+	},
+	{
+		start: 9410,
+		end: 9410,
+		version: "0.6",
+		name: "circled M"
+	},
+	{
+		start: 9642,
+		end: 9643,
+		version: "0.6",
+		name: "black small square..white small square"
+	},
+	{
+		start: 9654,
+		end: 9654,
+		version: "0.6",
+		name: "play button"
+	},
+	{
+		start: 9664,
+		end: 9664,
+		version: "0.6",
+		name: "reverse button"
+	},
+	{
+		start: 9723,
+		end: 9726,
+		version: "0.6",
+		name: "white medium square..black medium-small square"
+	},
+	{
+		start: 9728,
+		end: 9729,
+		version: "0.6",
+		name: "sun..cloud"
+	},
+	{
+		start: 9742,
+		end: 9742,
+		version: "0.6",
+		name: "telephone"
+	},
+	{
+		start: 9745,
+		end: 9745,
+		version: "0.6",
+		name: "check box with check"
+	},
+	{
+		start: 9748,
+		end: 9749,
+		version: "0.6",
+		name: "umbrella with rain drops..hot beverage"
+	},
+	{
+		start: 9757,
+		end: 9757,
+		version: "0.6",
+		name: "index pointing up"
+	},
+	{
+		start: 9786,
+		end: 9786,
+		version: "0.6",
+		name: "smiling face"
+	},
+	{
+		start: 9800,
+		end: 9811,
+		version: "0.6",
+		name: "Aries..Pisces"
+	},
+	{
+		start: 9824,
+		end: 9824,
+		version: "0.6",
+		name: "spade suit"
+	},
+	{
+		start: 9827,
+		end: 9827,
+		version: "0.6",
+		name: "club suit"
+	},
+	{
+		start: 9829,
+		end: 9830,
+		version: "0.6",
+		name: "heart suit..diamond suit"
+	},
+	{
+		start: 9832,
+		end: 9832,
+		version: "0.6",
+		name: "hot springs"
+	},
+	{
+		start: 9851,
+		end: 9851,
+		version: "0.6",
+		name: "recycling symbol"
+	},
+	{
+		start: 9855,
+		end: 9855,
+		version: "0.6",
+		name: "wheelchair symbol"
+	},
+	{
+		start: 9875,
+		end: 9875,
+		version: "0.6",
+		name: "anchor"
+	},
+	{
+		start: 9888,
+		end: 9889,
+		version: "0.6",
+		name: "warning..high voltage"
+	},
+	{
+		start: 9898,
+		end: 9899,
+		version: "0.6",
+		name: "white circle..black circle"
+	},
+	{
+		start: 9917,
+		end: 9918,
+		version: "0.6",
+		name: "soccer ball..baseball"
+	},
+	{
+		start: 9924,
+		end: 9925,
+		version: "0.6",
+		name: "snowman without snow..sun behind cloud"
+	},
+	{
+		start: 9934,
+		end: 9934,
+		version: "0.6",
+		name: "Ophiuchus"
+	},
+	{
+		start: 9940,
+		end: 9940,
+		version: "0.6",
+		name: "no entry"
+	},
+	{
+		start: 9962,
+		end: 9962,
+		version: "0.6",
+		name: "church"
+	},
+	{
+		start: 9970,
+		end: 9971,
+		version: "0.6",
+		name: "fountain..flag in hole"
+	},
+	{
+		start: 9973,
+		end: 9973,
+		version: "0.6",
+		name: "sailboat"
+	},
+	{
+		start: 9978,
+		end: 9978,
+		version: "0.6",
+		name: "tent"
+	},
+	{
+		start: 9981,
+		end: 9981,
+		version: "0.6",
+		name: "fuel pump"
+	},
+	{
+		start: 9986,
+		end: 9986,
+		version: "0.6",
+		name: "scissors"
+	},
+	{
+		start: 9989,
+		end: 9989,
+		version: "0.6",
+		name: "check mark button"
+	},
+	{
+		start: 9992,
+		end: 9996,
+		version: "0.6",
+		name: "airplane..victory hand"
+	},
+	{
+		start: 9999,
+		end: 9999,
+		version: "0.6",
+		name: "pencil"
+	},
+	{
+		start: 10002,
+		end: 10002,
+		version: "0.6",
+		name: "black nib"
+	},
+	{
+		start: 10004,
+		end: 10004,
+		version: "0.6",
+		name: "check mark"
+	},
+	{
+		start: 10006,
+		end: 10006,
+		version: "0.6",
+		name: "multiply"
+	},
+	{
+		start: 10024,
+		end: 10024,
+		version: "0.6",
+		name: "sparkles"
+	},
+	{
+		start: 10035,
+		end: 10036,
+		version: "0.6",
+		name: "eight-spoked asterisk..eight-pointed star"
+	},
+	{
+		start: 10052,
+		end: 10052,
+		version: "0.6",
+		name: "snowflake"
+	},
+	{
+		start: 10055,
+		end: 10055,
+		version: "0.6",
+		name: "sparkle"
+	},
+	{
+		start: 10060,
+		end: 10060,
+		version: "0.6",
+		name: "cross mark"
+	},
+	{
+		start: 10062,
+		end: 10062,
+		version: "0.6",
+		name: "cross mark button"
+	},
+	{
+		start: 10067,
+		end: 10069,
+		version: "0.6",
+		name: "red question mark..white exclamation mark"
+	},
+	{
+		start: 10071,
+		end: 10071,
+		version: "0.6",
+		name: "red exclamation mark"
+	},
+	{
+		start: 10084,
+		end: 10084,
+		version: "0.6",
+		name: "red heart"
+	},
+	{
+		start: 10133,
+		end: 10135,
+		version: "0.6",
+		name: "plus..divide"
+	},
+	{
+		start: 10145,
+		end: 10145,
+		version: "0.6",
+		name: "right arrow"
+	},
+	{
+		start: 10160,
+		end: 10160,
+		version: "0.6",
+		name: "curly loop"
+	},
+	{
+		start: 10548,
+		end: 10549,
+		version: "0.6",
+		name: "right arrow curving up..right arrow curving down"
+	},
+	{
+		start: 11013,
+		end: 11015,
+		version: "0.6",
+		name: "left arrow..down arrow"
+	},
+	{
+		start: 11035,
+		end: 11036,
+		version: "0.6",
+		name: "black large square..white large square"
+	},
+	{
+		start: 11088,
+		end: 11088,
+		version: "0.6",
+		name: "star"
+	},
+	{
+		start: 11093,
+		end: 11093,
+		version: "0.6",
+		name: "hollow red circle"
+	},
+	{
+		start: 12336,
+		end: 12336,
+		version: "0.6",
+		name: "wavy dash"
+	},
+	{
+		start: 12349,
+		end: 12349,
+		version: "0.6",
+		name: "part alternation mark"
+	},
+	{
+		start: 12951,
+		end: 12951,
+		version: "0.6",
+		name: "Japanese “congratulations” button"
+	},
+	{
+		start: 12953,
+		end: 12953,
+		version: "0.6",
+		name: "Japanese “secret” button"
+	},
+	{
+		start: 126980,
+		end: 126980,
+		version: "0.6",
+		name: "mahjong red dragon"
+	},
+	{
+		start: 127183,
+		end: 127183,
+		version: "0.6",
+		name: "joker"
+	},
+	{
+		start: 127344,
+		end: 127345,
+		version: "0.6",
+		name: "A button (blood type)..B button (blood type)"
+	},
+	{
+		start: 127358,
+		end: 127359,
+		version: "0.6",
+		name: "O button (blood type)..P button"
+	},
+	{
+		start: 127374,
+		end: 127374,
+		version: "0.6",
+		name: "AB button (blood type)"
+	},
+	{
+		start: 127377,
+		end: 127386,
+		version: "0.6",
+		name: "CL button..VS button"
+	},
+	{
+		start: 127489,
+		end: 127490,
+		version: "0.6",
+		name: "Japanese “here” button..Japanese “service charge” button"
+	},
+	{
+		start: 127514,
+		end: 127514,
+		version: "0.6",
+		name: "Japanese “free of charge” button"
+	},
+	{
+		start: 127535,
+		end: 127535,
+		version: "0.6",
+		name: "Japanese “reserved” button"
+	},
+	{
+		start: 127538,
+		end: 127546,
+		version: "0.6",
+		name: "Japanese “prohibited” button..Japanese “open for business” button"
+	},
+	{
+		start: 127568,
+		end: 127569,
+		version: "0.6",
+		name: "Japanese “bargain” button..Japanese “acceptable” button"
+	},
+	{
+		start: 127744,
+		end: 127756,
+		version: "0.6",
+		name: "cyclone..milky way"
+	},
+	{
+		start: 127759,
+		end: 127759,
+		version: "0.6",
+		name: "globe showing Asia-Australia"
+	},
+	{
+		start: 127761,
+		end: 127761,
+		version: "0.6",
+		name: "new moon"
+	},
+	{
+		start: 127763,
+		end: 127765,
+		version: "0.6",
+		name: "first quarter moon..full moon"
+	},
+	{
+		start: 127769,
+		end: 127769,
+		version: "0.6",
+		name: "crescent moon"
+	},
+	{
+		start: 127771,
+		end: 127771,
+		version: "0.6",
+		name: "first quarter moon face"
+	},
+	{
+		start: 127775,
+		end: 127776,
+		version: "0.6",
+		name: "glowing star..shooting star"
+	},
+	{
+		start: 127792,
+		end: 127793,
+		version: "0.6",
+		name: "chestnut..seedling"
+	},
+	{
+		start: 127796,
+		end: 127797,
+		version: "0.6",
+		name: "palm tree..cactus"
+	},
+	{
+		start: 127799,
+		end: 127818,
+		version: "0.6",
+		name: "tulip..tangerine"
+	},
+	{
+		start: 127820,
+		end: 127823,
+		version: "0.6",
+		name: "banana..green apple"
+	},
+	{
+		start: 127825,
+		end: 127867,
+		version: "0.6",
+		name: "peach..clinking beer mugs"
+	},
+	{
+		start: 127872,
+		end: 127891,
+		version: "0.6",
+		name: "ribbon..graduation cap"
+	},
+	{
+		start: 127904,
+		end: 127940,
+		version: "0.6",
+		name: "carousel horse..person surfing"
+	},
+	{
+		start: 127942,
+		end: 127942,
+		version: "0.6",
+		name: "trophy"
+	},
+	{
+		start: 127944,
+		end: 127944,
+		version: "0.6",
+		name: "american football"
+	},
+	{
+		start: 127946,
+		end: 127946,
+		version: "0.6",
+		name: "person swimming"
+	},
+	{
+		start: 127968,
+		end: 127971,
+		version: "0.6",
+		name: "house..Japanese post office"
+	},
+	{
+		start: 127973,
+		end: 127984,
+		version: "0.6",
+		name: "hospital..castle"
+	},
+	{
+		start: 128012,
+		end: 128014,
+		version: "0.6",
+		name: "snail..horse"
+	},
+	{
+		start: 128017,
+		end: 128018,
+		version: "0.6",
+		name: "ewe..monkey"
+	},
+	{
+		start: 128020,
+		end: 128020,
+		version: "0.6",
+		name: "chicken"
+	},
+	{
+		start: 128023,
+		end: 128041,
+		version: "0.6",
+		name: "boar..poodle"
+	},
+	{
+		start: 128043,
+		end: 128062,
+		version: "0.6",
+		name: "two-hump camel..paw prints"
+	},
+	{
+		start: 128064,
+		end: 128064,
+		version: "0.6",
+		name: "eyes"
+	},
+	{
+		start: 128066,
+		end: 128100,
+		version: "0.6",
+		name: "ear..bust in silhouette"
+	},
+	{
+		start: 128102,
+		end: 128107,
+		version: "0.6",
+		name: "boy..woman and man holding hands"
+	},
+	{
+		start: 128110,
+		end: 128172,
+		version: "0.6",
+		name: "police officer..speech balloon"
+	},
+	{
+		start: 128174,
+		end: 128181,
+		version: "0.6",
+		name: "white flower..dollar banknote"
+	},
+	{
+		start: 128184,
+		end: 128235,
+		version: "0.6",
+		name: "money with wings..closed mailbox with raised flag"
+	},
+	{
+		start: 128238,
+		end: 128238,
+		version: "0.6",
+		name: "postbox"
+	},
+	{
+		start: 128240,
+		end: 128244,
+		version: "0.6",
+		name: "newspaper..mobile phone off"
+	},
+	{
+		start: 128246,
+		end: 128247,
+		version: "0.6",
+		name: "antenna bars..camera"
+	},
+	{
+		start: 128249,
+		end: 128252,
+		version: "0.6",
+		name: "video camera..videocassette"
+	},
+	{
+		start: 128259,
+		end: 128259,
+		version: "0.6",
+		name: "clockwise vertical arrows"
+	},
+	{
+		start: 128266,
+		end: 128276,
+		version: "0.6",
+		name: "speaker high volume..bell"
+	},
+	{
+		start: 128278,
+		end: 128299,
+		version: "0.6",
+		name: "bookmark..water pistol"
+	},
+	{
+		start: 128302,
+		end: 128317,
+		version: "0.6",
+		name: "crystal ball..downwards button"
+	},
+	{
+		start: 128336,
+		end: 128347,
+		version: "0.6",
+		name: "one o’clock..twelve o’clock"
+	},
+	{
+		start: 128507,
+		end: 128511,
+		version: "0.6",
+		name: "mount fuji..moai"
+	},
+	{
+		start: 128513,
+		end: 128518,
+		version: "0.6",
+		name: "beaming face with smiling eyes..grinning squinting face"
+	},
+	{
+		start: 128521,
+		end: 128525,
+		version: "0.6",
+		name: "winking face..smiling face with heart-eyes"
+	},
+	{
+		start: 128527,
+		end: 128527,
+		version: "0.6",
+		name: "smirking face"
+	},
+	{
+		start: 128530,
+		end: 128532,
+		version: "0.6",
+		name: "unamused face..pensive face"
+	},
+	{
+		start: 128534,
+		end: 128534,
+		version: "0.6",
+		name: "confounded face"
+	},
+	{
+		start: 128536,
+		end: 128536,
+		version: "0.6",
+		name: "face blowing a kiss"
+	},
+	{
+		start: 128538,
+		end: 128538,
+		version: "0.6",
+		name: "kissing face with closed eyes"
+	},
+	{
+		start: 128540,
+		end: 128542,
+		version: "0.6",
+		name: "winking face with tongue..disappointed face"
+	},
+	{
+		start: 128544,
+		end: 128549,
+		version: "0.6",
+		name: "angry face..sad but relieved face"
+	},
+	{
+		start: 128552,
+		end: 128555,
+		version: "0.6",
+		name: "fearful face..tired face"
+	},
+	{
+		start: 128557,
+		end: 128557,
+		version: "0.6",
+		name: "loudly crying face"
+	},
+	{
+		start: 128560,
+		end: 128563,
+		version: "0.6",
+		name: "anxious face with sweat..flushed face"
+	},
+	{
+		start: 128565,
+		end: 128565,
+		version: "0.6",
+		name: "face with crossed-out eyes"
+	},
+	{
+		start: 128567,
+		end: 128576,
+		version: "0.6",
+		name: "face with medical mask..weary cat"
+	},
+	{
+		start: 128581,
+		end: 128591,
+		version: "0.6",
+		name: "person gesturing NO..folded hands"
+	},
+	{
+		start: 128640,
+		end: 128640,
+		version: "0.6",
+		name: "rocket"
+	},
+	{
+		start: 128643,
+		end: 128645,
+		version: "0.6",
+		name: "railway car..bullet train"
+	},
+	{
+		start: 128647,
+		end: 128647,
+		version: "0.6",
+		name: "metro"
+	},
+	{
+		start: 128649,
+		end: 128649,
+		version: "0.6",
+		name: "station"
+	},
+	{
+		start: 128652,
+		end: 128652,
+		version: "0.6",
+		name: "bus"
+	},
+	{
+		start: 128655,
+		end: 128655,
+		version: "0.6",
+		name: "bus stop"
+	},
+	{
+		start: 128657,
+		end: 128659,
+		version: "0.6",
+		name: "ambulance..police car"
+	},
+	{
+		start: 128661,
+		end: 128661,
+		version: "0.6",
+		name: "taxi"
+	},
+	{
+		start: 128663,
+		end: 128663,
+		version: "0.6",
+		name: "automobile"
+	},
+	{
+		start: 128665,
+		end: 128666,
+		version: "0.6",
+		name: "sport utility vehicle..delivery truck"
+	},
+	{
+		start: 128674,
+		end: 128674,
+		version: "0.6",
+		name: "ship"
+	},
+	{
+		start: 128676,
+		end: 128677,
+		version: "0.6",
+		name: "speedboat..horizontal traffic light"
+	},
+	{
+		start: 128679,
+		end: 128685,
+		version: "0.6",
+		name: "construction..no smoking"
+	},
+	{
+		start: 128690,
+		end: 128690,
+		version: "0.6",
+		name: "bicycle"
+	},
+	{
+		start: 128694,
+		end: 128694,
+		version: "0.6",
+		name: "person walking"
+	},
+	{
+		start: 128697,
+		end: 128702,
+		version: "0.6",
+		name: "men’s room..water closet"
+	},
+	{
+		start: 128704,
+		end: 128704,
+		version: "0.6",
+		name: "person taking bath"
+	},
+	{
+		start: 9197,
+		end: 9198,
+		version: "0.7",
+		name: "next track button..last track button"
+	},
+	{
+		start: 9208,
+		end: 9210,
+		version: "0.7",
+		name: "pause button..record button"
+	},
+	{
+		start: 9730,
+		end: 9731,
+		version: "0.7",
+		name: "umbrella..snowman"
+	},
+	{
+		start: 9770,
+		end: 9770,
+		version: "0.7",
+		name: "star and crescent"
+	},
+	{
+		start: 9775,
+		end: 9775,
+		version: "0.7",
+		name: "yin yang"
+	},
+	{
+		start: 9784,
+		end: 9785,
+		version: "0.7",
+		name: "wheel of dharma..frowning face"
+	},
+	{
+		start: 9928,
+		end: 9928,
+		version: "0.7",
+		name: "cloud with lightning and rain"
+	},
+	{
+		start: 9935,
+		end: 9935,
+		version: "0.7",
+		name: "pick"
+	},
+	{
+		start: 9937,
+		end: 9937,
+		version: "0.7",
+		name: "rescue worker’s helmet"
+	},
+	{
+		start: 9939,
+		end: 9939,
+		version: "0.7",
+		name: "chains"
+	},
+	{
+		start: 9961,
+		end: 9961,
+		version: "0.7",
+		name: "shinto shrine"
+	},
+	{
+		start: 9968,
+		end: 9969,
+		version: "0.7",
+		name: "mountain..umbrella on ground"
+	},
+	{
+		start: 9972,
+		end: 9972,
+		version: "0.7",
+		name: "ferry"
+	},
+	{
+		start: 9975,
+		end: 9977,
+		version: "0.7",
+		name: "skier..person bouncing ball"
+	},
+	{
+		start: 9997,
+		end: 9997,
+		version: "0.7",
+		name: "writing hand"
+	},
+	{
+		start: 10013,
+		end: 10013,
+		version: "0.7",
+		name: "latin cross"
+	},
+	{
+		start: 10017,
+		end: 10017,
+		version: "0.7",
+		name: "star of David"
+	},
+	{
+		start: 127757,
+		end: 127758,
+		version: "0.7",
+		name: "globe showing Europe-Africa..globe showing Americas"
+	},
+	{
+		start: 127772,
+		end: 127772,
+		version: "0.7",
+		name: "last quarter moon face"
+	},
+	{
+		start: 127777,
+		end: 127777,
+		version: "0.7",
+		name: "thermometer"
+	},
+	{
+		start: 127780,
+		end: 127788,
+		version: "0.7",
+		name: "sun behind small cloud..wind face"
+	},
+	{
+		start: 127798,
+		end: 127798,
+		version: "0.7",
+		name: "hot pepper"
+	},
+	{
+		start: 127869,
+		end: 127869,
+		version: "0.7",
+		name: "fork and knife with plate"
+	},
+	{
+		start: 127894,
+		end: 127895,
+		version: "0.7",
+		name: "military medal..reminder ribbon"
+	},
+	{
+		start: 127897,
+		end: 127899,
+		version: "0.7",
+		name: "studio microphone..control knobs"
+	},
+	{
+		start: 127902,
+		end: 127903,
+		version: "0.7",
+		name: "film frames..admission tickets"
+	},
+	{
+		start: 127947,
+		end: 127950,
+		version: "0.7",
+		name: "person lifting weights..racing car"
+	},
+	{
+		start: 127956,
+		end: 127967,
+		version: "0.7",
+		name: "snow-capped mountain..stadium"
+	},
+	{
+		start: 127987,
+		end: 127987,
+		version: "0.7",
+		name: "white flag"
+	},
+	{
+		start: 127989,
+		end: 127989,
+		version: "0.7",
+		name: "rosette"
+	},
+	{
+		start: 127991,
+		end: 127991,
+		version: "0.7",
+		name: "label"
+	},
+	{
+		start: 128008,
+		end: 128008,
+		version: "0.7",
+		name: "cat"
+	},
+	{
+		start: 128021,
+		end: 128021,
+		version: "0.7",
+		name: "dog"
+	},
+	{
+		start: 128063,
+		end: 128063,
+		version: "0.7",
+		name: "chipmunk"
+	},
+	{
+		start: 128065,
+		end: 128065,
+		version: "0.7",
+		name: "eye"
+	},
+	{
+		start: 128236,
+		end: 128237,
+		version: "0.7",
+		name: "open mailbox with raised flag..open mailbox with lowered flag"
+	},
+	{
+		start: 128253,
+		end: 128253,
+		version: "0.7",
+		name: "film projector"
+	},
+	{
+		start: 128264,
+		end: 128264,
+		version: "0.7",
+		name: "speaker low volume"
+	},
+	{
+		start: 128329,
+		end: 128330,
+		version: "0.7",
+		name: "om..dove"
+	},
+	{
+		start: 128348,
+		end: 128359,
+		version: "0.7",
+		name: "one-thirty..twelve-thirty"
+	},
+	{
+		start: 128367,
+		end: 128368,
+		version: "0.7",
+		name: "candle..mantelpiece clock"
+	},
+	{
+		start: 128371,
+		end: 128377,
+		version: "0.7",
+		name: "hole..joystick"
+	},
+	{
+		start: 128391,
+		end: 128391,
+		version: "0.7",
+		name: "linked paperclips"
+	},
+	{
+		start: 128394,
+		end: 128397,
+		version: "0.7",
+		name: "pen..crayon"
+	},
+	{
+		start: 128400,
+		end: 128400,
+		version: "0.7",
+		name: "hand with fingers splayed"
+	},
+	{
+		start: 128421,
+		end: 128421,
+		version: "0.7",
+		name: "desktop computer"
+	},
+	{
+		start: 128424,
+		end: 128424,
+		version: "0.7",
+		name: "printer"
+	},
+	{
+		start: 128433,
+		end: 128434,
+		version: "0.7",
+		name: "computer mouse..trackball"
+	},
+	{
+		start: 128444,
+		end: 128444,
+		version: "0.7",
+		name: "framed picture"
+	},
+	{
+		start: 128450,
+		end: 128452,
+		version: "0.7",
+		name: "card index dividers..file cabinet"
+	},
+	{
+		start: 128465,
+		end: 128467,
+		version: "0.7",
+		name: "wastebasket..spiral calendar"
+	},
+	{
+		start: 128476,
+		end: 128478,
+		version: "0.7",
+		name: "clamp..rolled-up newspaper"
+	},
+	{
+		start: 128481,
+		end: 128481,
+		version: "0.7",
+		name: "dagger"
+	},
+	{
+		start: 128483,
+		end: 128483,
+		version: "0.7",
+		name: "speaking head"
+	},
+	{
+		start: 128495,
+		end: 128495,
+		version: "0.7",
+		name: "right anger bubble"
+	},
+	{
+		start: 128499,
+		end: 128499,
+		version: "0.7",
+		name: "ballot box with ballot"
+	},
+	{
+		start: 128506,
+		end: 128506,
+		version: "0.7",
+		name: "world map"
+	},
+	{
+		start: 128528,
+		end: 128528,
+		version: "0.7",
+		name: "neutral face"
+	},
+	{
+		start: 128653,
+		end: 128653,
+		version: "0.7",
+		name: "oncoming bus"
+	},
+	{
+		start: 128660,
+		end: 128660,
+		version: "0.7",
+		name: "oncoming police car"
+	},
+	{
+		start: 128664,
+		end: 128664,
+		version: "0.7",
+		name: "oncoming automobile"
+	},
+	{
+		start: 128715,
+		end: 128715,
+		version: "0.7",
+		name: "couch and lamp"
+	},
+	{
+		start: 128717,
+		end: 128719,
+		version: "0.7",
+		name: "shopping bags..bed"
+	},
+	{
+		start: 128736,
+		end: 128741,
+		version: "0.7",
+		name: "hammer and wrench..motor boat"
+	},
+	{
+		start: 128745,
+		end: 128745,
+		version: "0.7",
+		name: "small airplane"
+	},
+	{
+		start: 128752,
+		end: 128752,
+		version: "0.7",
+		name: "satellite"
+	},
+	{
+		start: 128755,
+		end: 128755,
+		version: "0.7",
+		name: "passenger ship"
+	},
+	{
+		start: 9e3,
+		end: 9e3,
+		version: "1.0",
+		name: "keyboard"
+	},
+	{
+		start: 9167,
+		end: 9167,
+		version: "1.0",
+		name: "eject button"
+	},
+	{
+		start: 9199,
+		end: 9199,
+		version: "1.0",
+		name: "play or pause button"
+	},
+	{
+		start: 9201,
+		end: 9202,
+		version: "1.0",
+		name: "stopwatch..timer clock"
+	},
+	{
+		start: 9732,
+		end: 9732,
+		version: "1.0",
+		name: "comet"
+	},
+	{
+		start: 9752,
+		end: 9752,
+		version: "1.0",
+		name: "shamrock"
+	},
+	{
+		start: 9760,
+		end: 9760,
+		version: "1.0",
+		name: "skull and crossbones"
+	},
+	{
+		start: 9762,
+		end: 9763,
+		version: "1.0",
+		name: "radioactive..biohazard"
+	},
+	{
+		start: 9766,
+		end: 9766,
+		version: "1.0",
+		name: "orthodox cross"
+	},
+	{
+		start: 9774,
+		end: 9774,
+		version: "1.0",
+		name: "peace symbol"
+	},
+	{
+		start: 9874,
+		end: 9874,
+		version: "1.0",
+		name: "hammer and pick"
+	},
+	{
+		start: 9876,
+		end: 9876,
+		version: "1.0",
+		name: "crossed swords"
+	},
+	{
+		start: 9878,
+		end: 9879,
+		version: "1.0",
+		name: "balance scale..alembic"
+	},
+	{
+		start: 9881,
+		end: 9881,
+		version: "1.0",
+		name: "gear"
+	},
+	{
+		start: 9883,
+		end: 9884,
+		version: "1.0",
+		name: "atom symbol..fleur-de-lis"
+	},
+	{
+		start: 9904,
+		end: 9905,
+		version: "1.0",
+		name: "coffin..funeral urn"
+	},
+	{
+		start: 10083,
+		end: 10083,
+		version: "1.0",
+		name: "heart exclamation"
+	},
+	{
+		start: 10175,
+		end: 10175,
+		version: "1.0",
+		name: "double curly loop"
+	},
+	{
+		start: 127760,
+		end: 127760,
+		version: "1.0",
+		name: "globe with meridians"
+	},
+	{
+		start: 127762,
+		end: 127762,
+		version: "1.0",
+		name: "waxing crescent moon"
+	},
+	{
+		start: 127766,
+		end: 127768,
+		version: "1.0",
+		name: "waning gibbous moon..waning crescent moon"
+	},
+	{
+		start: 127770,
+		end: 127770,
+		version: "1.0",
+		name: "new moon face"
+	},
+	{
+		start: 127773,
+		end: 127774,
+		version: "1.0",
+		name: "full moon face..sun with face"
+	},
+	{
+		start: 127789,
+		end: 127791,
+		version: "1.0",
+		name: "hot dog..burrito"
+	},
+	{
+		start: 127794,
+		end: 127795,
+		version: "1.0",
+		name: "evergreen tree..deciduous tree"
+	},
+	{
+		start: 127819,
+		end: 127819,
+		version: "1.0",
+		name: "lemon"
+	},
+	{
+		start: 127824,
+		end: 127824,
+		version: "1.0",
+		name: "pear"
+	},
+	{
+		start: 127868,
+		end: 127868,
+		version: "1.0",
+		name: "baby bottle"
+	},
+	{
+		start: 127870,
+		end: 127871,
+		version: "1.0",
+		name: "bottle with popping cork..popcorn"
+	},
+	{
+		start: 127941,
+		end: 127941,
+		version: "1.0",
+		name: "sports medal"
+	},
+	{
+		start: 127943,
+		end: 127943,
+		version: "1.0",
+		name: "horse racing"
+	},
+	{
+		start: 127945,
+		end: 127945,
+		version: "1.0",
+		name: "rugby football"
+	},
+	{
+		start: 127951,
+		end: 127955,
+		version: "1.0",
+		name: "cricket game..ping pong"
+	},
+	{
+		start: 127972,
+		end: 127972,
+		version: "1.0",
+		name: "post office"
+	},
+	{
+		start: 127988,
+		end: 127988,
+		version: "1.0",
+		name: "black flag"
+	},
+	{
+		start: 127992,
+		end: 128007,
+		version: "1.0",
+		name: "badminton..rabbit"
+	},
+	{
+		start: 128009,
+		end: 128011,
+		version: "1.0",
+		name: "dragon..whale"
+	},
+	{
+		start: 128015,
+		end: 128016,
+		version: "1.0",
+		name: "ram..goat"
+	},
+	{
+		start: 128019,
+		end: 128019,
+		version: "1.0",
+		name: "rooster"
+	},
+	{
+		start: 128022,
+		end: 128022,
+		version: "1.0",
+		name: "pig"
+	},
+	{
+		start: 128042,
+		end: 128042,
+		version: "1.0",
+		name: "camel"
+	},
+	{
+		start: 128101,
+		end: 128101,
+		version: "1.0",
+		name: "busts in silhouette"
+	},
+	{
+		start: 128108,
+		end: 128109,
+		version: "1.0",
+		name: "men holding hands..women holding hands"
+	},
+	{
+		start: 128173,
+		end: 128173,
+		version: "1.0",
+		name: "thought balloon"
+	},
+	{
+		start: 128182,
+		end: 128183,
+		version: "1.0",
+		name: "euro banknote..pound banknote"
+	},
+	{
+		start: 128239,
+		end: 128239,
+		version: "1.0",
+		name: "postal horn"
+	},
+	{
+		start: 128245,
+		end: 128245,
+		version: "1.0",
+		name: "no mobile phones"
+	},
+	{
+		start: 128248,
+		end: 128248,
+		version: "1.0",
+		name: "camera with flash"
+	},
+	{
+		start: 128255,
+		end: 128258,
+		version: "1.0",
+		name: "prayer beads..repeat single button"
+	},
+	{
+		start: 128260,
+		end: 128263,
+		version: "1.0",
+		name: "counterclockwise arrows button..muted speaker"
+	},
+	{
+		start: 128265,
+		end: 128265,
+		version: "1.0",
+		name: "speaker medium volume"
+	},
+	{
+		start: 128277,
+		end: 128277,
+		version: "1.0",
+		name: "bell with slash"
+	},
+	{
+		start: 128300,
+		end: 128301,
+		version: "1.0",
+		name: "microscope..telescope"
+	},
+	{
+		start: 128331,
+		end: 128334,
+		version: "1.0",
+		name: "kaaba..menorah"
+	},
+	{
+		start: 128405,
+		end: 128406,
+		version: "1.0",
+		name: "middle finger..vulcan salute"
+	},
+	{
+		start: 128512,
+		end: 128512,
+		version: "1.0",
+		name: "grinning face"
+	},
+	{
+		start: 128519,
+		end: 128520,
+		version: "1.0",
+		name: "smiling face with halo..smiling face with horns"
+	},
+	{
+		start: 128526,
+		end: 128526,
+		version: "1.0",
+		name: "smiling face with sunglasses"
+	},
+	{
+		start: 128529,
+		end: 128529,
+		version: "1.0",
+		name: "expressionless face"
+	},
+	{
+		start: 128533,
+		end: 128533,
+		version: "1.0",
+		name: "confused face"
+	},
+	{
+		start: 128535,
+		end: 128535,
+		version: "1.0",
+		name: "kissing face"
+	},
+	{
+		start: 128537,
+		end: 128537,
+		version: "1.0",
+		name: "kissing face with smiling eyes"
+	},
+	{
+		start: 128539,
+		end: 128539,
+		version: "1.0",
+		name: "face with tongue"
+	},
+	{
+		start: 128543,
+		end: 128543,
+		version: "1.0",
+		name: "worried face"
+	},
+	{
+		start: 128550,
+		end: 128551,
+		version: "1.0",
+		name: "frowning face with open mouth..anguished face"
+	},
+	{
+		start: 128556,
+		end: 128556,
+		version: "1.0",
+		name: "grimacing face"
+	},
+	{
+		start: 128558,
+		end: 128559,
+		version: "1.0",
+		name: "face with open mouth..hushed face"
+	},
+	{
+		start: 128564,
+		end: 128564,
+		version: "1.0",
+		name: "sleeping face"
+	},
+	{
+		start: 128566,
+		end: 128566,
+		version: "1.0",
+		name: "face without mouth"
+	},
+	{
+		start: 128577,
+		end: 128580,
+		version: "1.0",
+		name: "slightly frowning face..face with rolling eyes"
+	},
+	{
+		start: 128641,
+		end: 128642,
+		version: "1.0",
+		name: "helicopter..locomotive"
+	},
+	{
+		start: 128646,
+		end: 128646,
+		version: "1.0",
+		name: "train"
+	},
+	{
+		start: 128648,
+		end: 128648,
+		version: "1.0",
+		name: "light rail"
+	},
+	{
+		start: 128650,
+		end: 128651,
+		version: "1.0",
+		name: "tram..tram car"
+	},
+	{
+		start: 128654,
+		end: 128654,
+		version: "1.0",
+		name: "trolleybus"
+	},
+	{
+		start: 128656,
+		end: 128656,
+		version: "1.0",
+		name: "minibus"
+	},
+	{
+		start: 128662,
+		end: 128662,
+		version: "1.0",
+		name: "oncoming taxi"
+	},
+	{
+		start: 128667,
+		end: 128673,
+		version: "1.0",
+		name: "articulated lorry..aerial tramway"
+	},
+	{
+		start: 128675,
+		end: 128675,
+		version: "1.0",
+		name: "person rowing boat"
+	},
+	{
+		start: 128678,
+		end: 128678,
+		version: "1.0",
+		name: "vertical traffic light"
+	},
+	{
+		start: 128686,
+		end: 128689,
+		version: "1.0",
+		name: "litter in bin sign..non-potable water"
+	},
+	{
+		start: 128691,
+		end: 128693,
+		version: "1.0",
+		name: "no bicycles..person mountain biking"
+	},
+	{
+		start: 128695,
+		end: 128696,
+		version: "1.0",
+		name: "no pedestrians..children crossing"
+	},
+	{
+		start: 128703,
+		end: 128703,
+		version: "1.0",
+		name: "shower"
+	},
+	{
+		start: 128705,
+		end: 128709,
+		version: "1.0",
+		name: "bathtub..left luggage"
+	},
+	{
+		start: 128716,
+		end: 128716,
+		version: "1.0",
+		name: "person in bed"
+	},
+	{
+		start: 128720,
+		end: 128720,
+		version: "1.0",
+		name: "place of worship"
+	},
+	{
+		start: 128747,
+		end: 128748,
+		version: "1.0",
+		name: "airplane departure..airplane arrival"
+	},
+	{
+		start: 129296,
+		end: 129304,
+		version: "1.0",
+		name: "zipper-mouth face..sign of the horns"
+	},
+	{
+		start: 129408,
+		end: 129412,
+		version: "1.0",
+		name: "crab..unicorn"
+	},
+	{
+		start: 129472,
+		end: 129472,
+		version: "1.0",
+		name: "cheese wedge"
+	},
+	{
+		start: 128488,
+		end: 128488,
+		version: "2.0",
+		name: "left speech bubble"
+	},
+	{
+		start: 128378,
+		end: 128378,
+		version: "3.0",
+		name: "man dancing"
+	},
+	{
+		start: 128420,
+		end: 128420,
+		version: "3.0",
+		name: "black heart"
+	},
+	{
+		start: 128721,
+		end: 128722,
+		version: "3.0",
+		name: "stop sign..shopping cart"
+	},
+	{
+		start: 128756,
+		end: 128758,
+		version: "3.0",
+		name: "kick scooter..canoe"
+	},
+	{
+		start: 129305,
+		end: 129310,
+		version: "3.0",
+		name: "call me hand..crossed fingers"
+	},
+	{
+		start: 129312,
+		end: 129319,
+		version: "3.0",
+		name: "cowboy hat face..sneezing face"
+	},
+	{
+		start: 129328,
+		end: 129328,
+		version: "3.0",
+		name: "pregnant woman"
+	},
+	{
+		start: 129331,
+		end: 129338,
+		version: "3.0",
+		name: "selfie..person fencing"
+	},
+	{
+		start: 129340,
+		end: 129342,
+		version: "3.0",
+		name: "people wrestling..person playing handball"
+	},
+	{
+		start: 129344,
+		end: 129349,
+		version: "3.0",
+		name: "wilted flower..goal net"
+	},
+	{
+		start: 129351,
+		end: 129355,
+		version: "3.0",
+		name: "1st place medal..martial arts uniform"
+	},
+	{
+		start: 129360,
+		end: 129374,
+		version: "3.0",
+		name: "croissant..pancakes"
+	},
+	{
+		start: 129413,
+		end: 129425,
+		version: "3.0",
+		name: "eagle..squid"
+	},
+	{
+		start: 9792,
+		end: 9792,
+		version: "4.0",
+		name: "female sign"
+	},
+	{
+		start: 9794,
+		end: 9794,
+		version: "4.0",
+		name: "male sign"
+	},
+	{
+		start: 9877,
+		end: 9877,
+		version: "4.0",
+		name: "medical symbol"
+	},
+	{
+		start: 128759,
+		end: 128760,
+		version: "5.0",
+		name: "sled..flying saucer"
+	},
+	{
+		start: 129311,
+		end: 129311,
+		version: "5.0",
+		name: "love-you gesture"
+	},
+	{
+		start: 129320,
+		end: 129327,
+		version: "5.0",
+		name: "face with raised eyebrow..exploding head"
+	},
+	{
+		start: 129329,
+		end: 129330,
+		version: "5.0",
+		name: "breast-feeding..palms up together"
+	},
+	{
+		start: 129356,
+		end: 129356,
+		version: "5.0",
+		name: "curling stone"
+	},
+	{
+		start: 129375,
+		end: 129387,
+		version: "5.0",
+		name: "dumpling..canned food"
+	},
+	{
+		start: 129426,
+		end: 129431,
+		version: "5.0",
+		name: "giraffe..cricket"
+	},
+	{
+		start: 129488,
+		end: 129510,
+		version: "5.0",
+		name: "face with monocle..socks"
+	},
+	{
+		start: 9823,
+		end: 9823,
+		version: "11.0",
+		name: "chess pawn"
+	},
+	{
+		start: 9854,
+		end: 9854,
+		version: "11.0",
+		name: "infinity"
+	},
+	{
+		start: 128761,
+		end: 128761,
+		version: "11.0",
+		name: "skateboard"
+	},
+	{
+		start: 129357,
+		end: 129359,
+		version: "11.0",
+		name: "lacrosse..flying disc"
+	},
+	{
+		start: 129388,
+		end: 129392,
+		version: "11.0",
+		name: "leafy green..smiling face with hearts"
+	},
+	{
+		start: 129395,
+		end: 129398,
+		version: "11.0",
+		name: "partying face..cold face"
+	},
+	{
+		start: 129402,
+		end: 129402,
+		version: "11.0",
+		name: "pleading face"
+	},
+	{
+		start: 129404,
+		end: 129407,
+		version: "11.0",
+		name: "lab coat..flat shoe"
+	},
+	{
+		start: 129432,
+		end: 129442,
+		version: "11.0",
+		name: "kangaroo..swan"
+	},
+	{
+		start: 129456,
+		end: 129465,
+		version: "11.0",
+		name: "red hair..supervillain"
+	},
+	{
+		start: 129473,
+		end: 129474,
+		version: "11.0",
+		name: "cupcake..salt"
+	},
+	{
+		start: 129511,
+		end: 129535,
+		version: "11.0",
+		name: "red envelope..nazar amulet"
+	},
+	{
+		start: 128725,
+		end: 128725,
+		version: "12.0",
+		name: "hindu temple"
+	},
+	{
+		start: 128762,
+		end: 128762,
+		version: "12.0",
+		name: "auto rickshaw"
+	},
+	{
+		start: 128992,
+		end: 129003,
+		version: "12.0",
+		name: "orange circle..brown square"
+	},
+	{
+		start: 129293,
+		end: 129295,
+		version: "12.0",
+		name: "white heart..pinching hand"
+	},
+	{
+		start: 129343,
+		end: 129343,
+		version: "12.0",
+		name: "diving mask"
+	},
+	{
+		start: 129393,
+		end: 129393,
+		version: "12.0",
+		name: "yawning face"
+	},
+	{
+		start: 129403,
+		end: 129403,
+		version: "12.0",
+		name: "sari"
+	},
+	{
+		start: 129445,
+		end: 129450,
+		version: "12.0",
+		name: "sloth..oyster"
+	},
+	{
+		start: 129454,
+		end: 129455,
+		version: "12.0",
+		name: "guide dog..white cane"
+	},
+	{
+		start: 129466,
+		end: 129471,
+		version: "12.0",
+		name: "safety vest..mechanical leg"
+	},
+	{
+		start: 129475,
+		end: 129482,
+		version: "12.0",
+		name: "beverage box..ice"
+	},
+	{
+		start: 129485,
+		end: 129487,
+		version: "12.0",
+		name: "person standing..deaf person"
+	},
+	{
+		start: 129648,
+		end: 129651,
+		version: "12.0",
+		name: "ballet shoes..shorts"
+	},
+	{
+		start: 129656,
+		end: 129658,
+		version: "12.0",
+		name: "drop of blood..stethoscope"
+	},
+	{
+		start: 129664,
+		end: 129666,
+		version: "12.0",
+		name: "yo-yo..parachute"
+	},
+	{
+		start: 129680,
+		end: 129685,
+		version: "12.0",
+		name: "ringed planet..banjo"
+	},
+	{
+		start: 9895,
+		end: 9895,
+		version: "13.0",
+		name: "transgender symbol"
+	},
+	{
+		start: 128726,
+		end: 128727,
+		version: "13.0",
+		name: "hut..elevator"
+	},
+	{
+		start: 128763,
+		end: 128764,
+		version: "13.0",
+		name: "pickup truck..roller skate"
+	},
+	{
+		start: 129292,
+		end: 129292,
+		version: "13.0",
+		name: "pinched fingers"
+	},
+	{
+		start: 129394,
+		end: 129394,
+		version: "13.0",
+		name: "smiling face with tear"
+	},
+	{
+		start: 129399,
+		end: 129400,
+		version: "13.0",
+		name: "ninja..disguised face"
+	},
+	{
+		start: 129443,
+		end: 129444,
+		version: "13.0",
+		name: "mammoth..dodo"
+	},
+	{
+		start: 129451,
+		end: 129453,
+		version: "13.0",
+		name: "beaver..seal"
+	},
+	{
+		start: 129483,
+		end: 129483,
+		version: "13.0",
+		name: "bubble tea"
+	},
+	{
+		start: 129652,
+		end: 129652,
+		version: "13.0",
+		name: "thong sandal"
+	},
+	{
+		start: 129667,
+		end: 129670,
+		version: "13.0",
+		name: "boomerang..nesting dolls"
+	},
+	{
+		start: 129686,
+		end: 129704,
+		version: "13.0",
+		name: "military helmet..rock"
+	},
+	{
+		start: 129712,
+		end: 129718,
+		version: "13.0",
+		name: "fly..feather"
+	},
+	{
+		start: 129728,
+		end: 129730,
+		version: "13.0",
+		name: "anatomical heart..people hugging"
+	},
+	{
+		start: 129744,
+		end: 129750,
+		version: "13.0",
+		name: "blueberries..teapot"
+	},
+	{
+		start: 128733,
+		end: 128735,
+		version: "14.0",
+		name: "playground slide..ring buoy"
+	},
+	{
+		start: 129008,
+		end: 129008,
+		version: "14.0",
+		name: "heavy equals sign"
+	},
+	{
+		start: 129401,
+		end: 129401,
+		version: "14.0",
+		name: "face holding back tears"
+	},
+	{
+		start: 129484,
+		end: 129484,
+		version: "14.0",
+		name: "troll"
+	},
+	{
+		start: 129659,
+		end: 129660,
+		version: "14.0",
+		name: "x-ray..crutch"
+	},
+	{
+		start: 129705,
+		end: 129708,
+		version: "14.0",
+		name: "mirror ball..hamsa"
+	},
+	{
+		start: 129719,
+		end: 129722,
+		version: "14.0",
+		name: "lotus..nest with eggs"
+	},
+	{
+		start: 129731,
+		end: 129733,
+		version: "14.0",
+		name: "pregnant man..person with crown"
+	},
+	{
+		start: 129751,
+		end: 129753,
+		version: "14.0",
+		name: "pouring liquid..jar"
+	},
+	{
+		start: 129760,
+		end: 129767,
+		version: "14.0",
+		name: "melting face..bubbles"
+	},
+	{
+		start: 129776,
+		end: 129782,
+		version: "14.0",
+		name: "hand with index finger and thumb crossed..heart hands"
+	},
+	{
+		start: 128732,
+		end: 128732,
+		version: "15.0",
+		name: "wireless"
+	},
+	{
+		start: 129653,
+		end: 129655,
+		version: "15.0",
+		name: "light blue heart..pink heart"
+	},
+	{
+		start: 129671,
+		end: 129672,
+		version: "15.0",
+		name: "maracas..flute"
+	},
+	{
+		start: 129709,
+		end: 129711,
+		version: "15.0",
+		name: "folding hand fan..khanda"
+	},
+	{
+		start: 129723,
+		end: 129725,
+		version: "15.0",
+		name: "hyacinth..wing"
+	},
+	{
+		start: 129727,
+		end: 129727,
+		version: "15.0",
+		name: "goose"
+	},
+	{
+		start: 129742,
+		end: 129743,
+		version: "15.0",
+		name: "moose..donkey"
+	},
+	{
+		start: 129754,
+		end: 129755,
+		version: "15.0",
+		name: "ginger root..pea pod"
+	},
+	{
+		start: 129768,
+		end: 129768,
+		version: "15.0",
+		name: "shaking face"
+	},
+	{
+		start: 129783,
+		end: 129784,
+		version: "15.0",
+		name: "leftwards pushing hand..rightwards pushing hand"
+	},
+	{
+		start: 129673,
+		end: 129673,
+		version: "16.0",
+		name: "harp"
+	},
+	{
+		start: 129679,
+		end: 129679,
+		version: "16.0",
+		name: "shovel"
+	},
+	{
+		start: 129726,
+		end: 129726,
+		version: "16.0",
+		name: "leafless tree"
+	},
+	{
+		start: 129734,
+		end: 129734,
+		version: "16.0",
+		name: "fingerprint"
+	},
+	{
+		start: 129756,
+		end: 129756,
+		version: "16.0",
+		name: "root vegetable"
+	},
+	{
+		start: 129759,
+		end: 129759,
+		version: "16.0",
+		name: "splatter"
+	},
+	{
+		start: 129769,
+		end: 129769,
+		version: "16.0",
+		name: "face with bags under eyes"
+	},
+	{
+		start: 128728,
+		end: 128728,
+		version: "17.0",
+		name: "landslide"
+	},
+	{
+		start: 129674,
+		end: 129674,
+		version: "17.0",
+		name: "trombone"
+	},
+	{
+		start: 129678,
+		end: 129678,
+		version: "17.0",
+		name: "treasure chest"
+	},
+	{
+		start: 129736,
+		end: 129736,
+		version: "17.0",
+		name: "hairy creature"
+	},
+	{
+		start: 129741,
+		end: 129741,
+		version: "17.0",
+		name: "orca"
+	},
+	{
+		start: 129770,
+		end: 129770,
+		version: "17.0",
+		name: "distorted face"
+	},
+	{
+		start: 129775,
+		end: 129775,
+		version: "17.0",
+		name: "fight cloud"
+	}
+];
+//#endregion
+//#region packages/eslint-plugin-formatjs/emoji-utils.ts
+/**
+* Emoji detection utilities using Intl.Segmenter
+*/
+/**
+* Cached Intl.Segmenter instance for emoji extraction
+* Reused across all extractEmojis calls for better performance
+*/
+const graphemeSegmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+/**
+* Regex for detecting emoji using Unicode 17.0.0 Emoji_Presentation data
+* Generated from @unicode/unicode-17.0.0/Binary_Property/Emoji_Presentation
+* This avoids false positives from #, *, digits, and text symbols like ©
+*/
+const emojiPresentationRegexCompiled = emojiPresentationRegex.default ?? emojiPresentationRegex;
+/**
+* Regex for detecting emoji-capable characters using Unicode 17.0.0 Emoji property
+* This includes characters that can have emoji presentation (like ❤, ☀)
+*/
+const emojiPropertyRegexCompiled = emojiPropertyRegex.default ?? emojiPropertyRegex;
+/**
+* Check if a string contains any emoji
+* Uses Unicode 17.0.0 Emoji_Presentation data and variation selector (U+FE0F)
+* to properly detect emoji while avoiding false positives from characters like
+* #, *, digits 0-9, and text symbols like © which have \p{Emoji} but are not visual emoji
+*/
+function hasEmoji(text) {
+	if (emojiPresentationRegexCompiled.test(text)) return true;
+	if (text.includes("️")) {
+		const segments = graphemeSegmenter.segment(text);
+		for (const { segment } of segments) if (segment.includes("️")) {
+			const beforeVS = segment.replace(/\uFE0F/g, "");
+			if (emojiPropertyRegexCompiled.test(beforeVS)) return true;
+		}
+	}
+	return false;
+}
+/**
+* Extract all emoji from a string using Intl.Segmenter
+* Returns an array of emoji characters (including multi-codepoint sequences)
+*
+* Uses grapheme segmentation to properly handle:
+* - Emoji with skin tone modifiers (🙋🏻)
+* - ZWJ sequences (👨‍👩‍👧‍👦)
+* - Flag sequences (🇺🇸)
+* - Regional indicator sequences
+* - Any other complex emoji grapheme clusters
+*/
+function extractEmojis(text) {
+	const segments = graphemeSegmenter.segment(text);
+	const emojis = [];
+	for (const { segment } of segments) {
+		if (emojiPresentationRegexCompiled.test(segment)) {
+			emojis.push(segment);
+			continue;
+		}
+		if (segment.includes("️")) {
+			const beforeVS = segment.replace(/\uFE0F/g, "");
+			if (emojiPropertyRegexCompiled.test(beforeVS)) emojis.push(segment);
+		}
+	}
+	return emojis;
+}
+/**
+* Check if a version string is a valid emoji version
+*/
+function isValidEmojiVersion(version) {
+	return EMOJI_VERSIONS.includes(version);
+}
+/**
+* Get the Unicode version for a given emoji character
+* Returns undefined if the emoji is not found in our data
+*/
+function getEmojiVersion(emoji) {
+	const codepoint = emoji.codePointAt(0);
+	if (codepoint === void 0) return;
+	for (const range of EMOJI_RANGES) if (codepoint >= range.start && codepoint <= range.end) return range.version;
+}
+/**
+* Filter function for emoji versions
+* Returns a filter function that checks if an emoji is from version or below
+*/
+function filterEmojis(version) {
+	const maxVersion = parseVersion(version);
+	return (emoji) => {
+		const emojiVersion = getEmojiVersion(emoji);
+		if (!emojiVersion) return true;
+		return parseVersion(emojiVersion) <= maxVersion;
+	};
+}
+/**
+* Parse version string to comparable number
+* e.g., "12.0" -> 12.0, "13.1" -> 13.1
+*/
+function parseVersion(version) {
+	return parseFloat(version);
+}
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-emoji.ts
+const name$14 = "no-emoji";
+function checkNode$9(context, node) {
+	const msgs = extractMessages(node, getSettings(context));
+	let versionAbove;
+	const [emojiConfig] = context.options;
+	if (emojiConfig?.versionAbove && isValidEmojiVersion(emojiConfig.versionAbove)) versionAbove = emojiConfig.versionAbove;
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		if (hasEmoji(defaultMessage)) if (versionAbove) {
+			const filter = filterEmojis(versionAbove);
+			for (const emoji of extractEmojis(defaultMessage)) if (!filter(emoji)) context.report({
+				node: messageNode,
+				messageId: "notAllowedAboveVersion",
+				data: {
+					versionAbove,
+					emoji
+				}
+			});
+		} else context.report({
+			node: messageNode,
+			messageId: "notAllowed"
+		});
+	}
+}
+const rule$12 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow emojis in message",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-emoji"
+		},
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { versionAbove: {
+				type: "string",
+				enum: [
+					"0.6",
+					"0.7",
+					"1.0",
+					"2.0",
+					"3.0",
+					"4.0",
+					"5.0",
+					"11.0",
+					"12.0",
+					"13.0",
+					"14.0",
+					"15.0",
+					"16.0",
+					"17.0"
+				]
+			} },
+			additionalProperties: false
+		}],
+		messages: {
+			notAllowed: "Emojis are not allowed",
+			notAllowedAboveVersion: "Emojis above version {{versionAbove}} are not allowed - Emoji: {{emoji}}"
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$9(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$9(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-id.ts
+function isComment(token) {
+	return !!token && (token.type === "Block" || token.type === "Line");
+}
+const name$13 = "no-id";
+function checkNode$8(context, node) {
+	const msgs = extractMessages(node, getSettings(context));
+	for (const [{ idPropNode }] of msgs) if (idPropNode) context.report({
+		node: idPropNode,
+		messageId: "noId",
+		fix(fixer) {
+			const token = context.sourceCode.getTokenAfter(idPropNode);
+			const fixes = [fixer.remove(idPropNode)];
+			if (token && !isComment(token) && token?.value === ",") fixes.push(fixer.remove(token));
+			return fixes;
+		}
+	});
+}
+const rule$11 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Ban explicit ID from MessageDescriptor",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-id"
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noId: "Manual `id` are not allowed in message descriptor" }
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$8(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$8(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-invalid-icu.ts
+const name$12 = "no-invalid-icu";
+function checkNode$7(context, node) {
+	const settings = getSettings(context);
+	let msgs;
+	try {
+		msgs = extractMessages(node, settings);
+	} catch (e) {
+		context.report({
+			node,
+			messageId: "parseError",
+			data: { error: e.message }
+		});
+		return;
+	}
+	if (!msgs.length) return;
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		try {
+			parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+		}
+	}
+}
+const rule$10 = {
+	meta: {
+		type: "problem",
+		docs: { description: `Make sure ICU messages are formatted correctly with no bad select statements, plurals, etc.` },
+		fixable: "code",
+		schema: [],
+		messages: CORE_MESSAGES
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$7(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$7(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-literal-string-in-jsx.ts
+const picomatch = picomatchNs.default ?? picomatchNs;
+const propMatcherSchema = {
+	type: "array",
+	items: {
+		type: "array",
+		items: [{ type: "string" }, { type: "string" }]
+	}
+};
+const defaultPropIncludePattern = [
+	["*", "aria-{label,description,details,errormessage}"],
+	["[a-z]*([a-z0-9])", "(placeholder|title)"],
+	["img", "alt"]
+];
+const defaultPropExcludePattern = [];
+function stringifyJsxTagName(tagName) {
+	switch (tagName.type) {
+		case "JSXIdentifier": return tagName.name;
+		case "JSXMemberExpression": return `${stringifyJsxTagName(tagName.object)}.${tagName.property.name}`;
+		case "JSXNamespacedName": return `${tagName.namespace.name}:${tagName.name.name}`;
+	}
+}
+function compilePropMatcher(propMatcher) {
+	return propMatcher.map(([tagNamePattern, propNamePattern]) => {
+		return [picomatch.makeRe(tagNamePattern, { contains: false }), picomatch.makeRe(propNamePattern, { contains: false })];
+	});
+}
+const name$11 = "no-literal-string-in-jsx";
+const rule$9 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow untranslated literal strings without translation.",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-literal-string-in-jsx"
+		},
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { props: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					include: { ...propMatcherSchema },
+					exclude: { ...propMatcherSchema }
+				}
+			} }
+		}],
+		messages: { noLiteralStringInJsx: "Cannot have untranslated text in JSX" }
+	},
+	create(context) {
+		const userConfig = context.options[0] || {};
+		const propIncludePattern = compilePropMatcher([...defaultPropIncludePattern, ...userConfig.props?.include ?? []]);
+		const propExcludePattern = compilePropMatcher([...defaultPropExcludePattern, ...userConfig.props?.exclude ?? []]);
+		const lexicalJsxStack = [];
+		const shouldSkipCurrentJsxElement = () => {
+			const currentJsxNode = lexicalJsxStack[lexicalJsxStack.length - 1];
+			if (currentJsxNode.type === "JSXFragment") return false;
+			const nameString = stringifyJsxTagName(currentJsxNode.openingElement.name);
+			for (const [tagNamePattern, propNamePattern] of propExcludePattern) if (tagNamePattern.test(nameString) && propNamePattern.test("children")) return true;
+			return false;
+		};
+		const shouldSkipCurrentJsxAttribute = (node) => {
+			const currentJsxNode = lexicalJsxStack[lexicalJsxStack.length - 1];
+			if (currentJsxNode.type === "JSXFragment") return false;
+			const nameString = stringifyJsxTagName(currentJsxNode.openingElement.name);
+			const attributeName = typeof node.name.name === "string" ? node.name.name : node.name.name.name;
+			for (const [tagNamePattern, propNamePattern] of propExcludePattern) if (tagNamePattern.test(nameString) && propNamePattern.test(attributeName)) return true;
+			for (const [tagNamePattern, propNamePattern] of propIncludePattern) if (tagNamePattern.test(nameString) && propNamePattern.test(attributeName)) return false;
+			return true;
+		};
+		const checkJSXExpression = (node) => {
+			if (node.type === "Literal" && typeof node.value === "string" && node.value.length > 0 || node.type === "TemplateLiteral" && (node.quasis.length > 1 || node.quasis[0].value.raw.length > 0)) context.report({
+				node,
+				messageId: "noLiteralStringInJsx"
+			});
+			else if (node.type === "BinaryExpression" && node.operator === "+") {
+				checkJSXExpression(node.left);
+				checkJSXExpression(node.right);
+			} else if (node.type === "ConditionalExpression") {
+				checkJSXExpression(node.consequent);
+				checkJSXExpression(node.alternate);
+			} else if (node.type === "LogicalExpression") {
+				checkJSXExpression(node.left);
+				checkJSXExpression(node.right);
+			}
+		};
+		return {
+			JSXElement: (node) => {
+				lexicalJsxStack.push(node);
+			},
+			"JSXElement:exit": () => {
+				lexicalJsxStack.pop();
+			},
+			JSXFragment: (node) => {
+				lexicalJsxStack.push(node);
+			},
+			"JSXFragment:exit": () => {
+				lexicalJsxStack.pop();
+			},
+			JSXAttribute: (node) => {
+				if (shouldSkipCurrentJsxAttribute(node)) return;
+				if (!node.value) return;
+				if (node.value.type === "Literal" && typeof node.value.value === "string" && node.value.value.length > 0) context.report({
+					node,
+					messageId: "noLiteralStringInJsx"
+				});
+				else if (node.value.type === "JSXExpressionContainer" && node.value.expression.type !== "JSXEmptyExpression") checkJSXExpression(node.value.expression);
+			},
+			JSXText: (node) => {
+				if (!node.value.replace(/\s*/gm, "")) return;
+				if (shouldSkipCurrentJsxElement()) return;
+				context.report({
+					node,
+					messageId: "noLiteralStringInJsx"
+				});
+			},
+			"JSXElement > JSXExpressionContainer": (node) => {
+				if (shouldSkipCurrentJsxElement()) return;
+				if (node.expression.type !== "JSXEmptyExpression") checkJSXExpression(node.expression);
+			}
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-missing-icu-plural-one-placeholders.ts
+const name$10 = "no-missing-icu-plural-one-placeholders";
+function verifyAst$4(context, messageNode, ast) {
+	const patches = [];
+	_verifyAstAndReplace(ast);
+	if (patches.length > 0) {
+		const patchedMessage = patchMessage(messageNode, ast, (content) => {
+			return patches.reduce((magicString, patch) => {
+				switch (patch.type) {
+					case "prependLeft": return magicString.prependLeft(patch.index, patch.content);
+					case "remove": return magicString.remove(patch.start, patch.end);
+					case "update": return magicString.update(patch.start, patch.end, patch.content);
+				}
+			}, new MagicString(content)).toString();
+		});
+		context.report({
+			node: messageNode,
+			messageId: "noMissingIcuPluralOnePlaceholders",
+			fix: patchedMessage !== null ? (fixer) => fixer.replaceText(messageNode, patchedMessage) : null
+		});
+	}
+	function _verifyAstAndReplace(ast, root = true) {
+		for (const el of ast) if (isPluralElement(el) && el.options["one"]) _verifyAstAndReplace(el.options["one"].value, false);
+		else if (isSelectElement(el)) for (const { value } of Object.values(el.options)) _verifyAstAndReplace(value, root);
+		else if (isTagElement(el)) _verifyAstAndReplace(el.children, root);
+		else if (!root && isLiteralElement(el)) {
+			const match = el.value.match(/\b1\b/);
+			if (match && el.location) patches.push({
+				type: "update",
+				start: el.location.start.offset,
+				end: el.location.end.offset,
+				content: el.value.replace(match[0], "#")
+			});
+		}
+	}
+}
+function checkNode$6(context, node) {
+	const msgs = extractMessages(node);
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { captureLocation: true });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+			continue;
+		}
+		verifyAst$4(context, messageNode, ast);
+	}
+}
+const rule$8 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "We use `one {# item}` instead of `one {1 item}` in ICU messages as some locales use the `one` formatting for other similar numbers.",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-explicit-icu-plural"
+		},
+		fixable: "code",
+		messages: {
+			...CORE_MESSAGES,
+			noMissingIcuPluralOnePlaceholders: "Use `one {# item}` instead of `one {1 item}` in ICU messages."
+		},
+		schema: []
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$6(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$6(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-multiple-plurals.ts
+function verifyAst$3(ast, pluralCount = { count: 0 }) {
+	const errors = [];
+	for (const el of ast) if (isPluralElement(el)) {
+		pluralCount.count++;
+		if (pluralCount.count > 1) errors.push({
+			messageId: "noMultiplePlurals",
+			data: {}
+		});
+		const { options } = el;
+		for (const selector of Object.keys(options)) errors.push(...verifyAst$3(options[selector].value, pluralCount));
+	}
+	return errors;
+}
+function checkNode$5(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, settings);
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+			continue;
+		}
+		const errors = verifyAst$3(ast);
+		for (const error of errors) context.report({
+			node,
+			...error
+		});
+	}
+}
+const name$9 = "no-multiple-plurals";
+const rule$7 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow multiple plural rules in the same message",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-multiple-plurals"
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			...CORE_MESSAGES,
+			noMultiplePlurals: "Multiple plural rules in the same message"
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$5(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$5(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-multiple-whitespaces.ts
+function isAstValid(ast) {
+	for (const element of ast) switch (element.type) {
+		case TYPE.literal:
+			if (/\s{2,}/gm.test(element.value)) return false;
+			break;
+		case TYPE.argument:
+		case TYPE.date:
+		case TYPE.number:
+		case TYPE.pound:
+		case TYPE.time: break;
+		case TYPE.plural:
+		case TYPE.select:
+			for (const option of Object.values(element.options)) if (!isAstValid(option.value)) return false;
+			break;
+		case TYPE.tag: return isAstValid(element.children);
+	}
+	return true;
+}
+function trimMultiWhitespaces(message, ast) {
+	const literalElements = [];
+	const collectLiteralElements = (elements) => {
+		for (const element of elements) switch (element.type) {
+			case TYPE.literal:
+				literalElements.push(element);
+				break;
+			case TYPE.argument:
+			case TYPE.date:
+			case TYPE.number:
+			case TYPE.pound:
+			case TYPE.time: break;
+			case TYPE.plural:
+			case TYPE.select:
+				for (const option of Object.values(element.options)) collectLiteralElements(option.value);
+				break;
+			case TYPE.tag:
+				collectLiteralElements(element.children);
+				break;
+		}
+	};
+	collectLiteralElements(ast);
+	let trimmedFragments = [];
+	let currentOffset = 0;
+	for (const literal of literalElements) {
+		const { start, end } = literal.location;
+		const startOffset = start.offset;
+		const endOffset = end.offset;
+		trimmedFragments.push(message.slice(currentOffset, startOffset));
+		trimmedFragments.push(message.slice(startOffset, endOffset).replace(/\s{2,}/gm, " "));
+		currentOffset = endOffset;
+	}
+	trimmedFragments.push(message.slice(currentOffset));
+	return trimmedFragments.join("");
+}
+function checkNode$4(context, node) {
+	const msgs = extractMessages(node, getSettings(context));
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { captureLocation: true });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e instanceof Error ? e.message : String(e) }
+			});
+			return;
+		}
+		if (!isAstValid(ast)) {
+			const newMessage = patchMessage(messageNode, ast, trimMultiWhitespaces);
+			context.report({
+				node: messageNode,
+				messageId: "noMultipleWhitespaces",
+				fix: newMessage !== null ? (fixer) => fixer.replaceText(messageNode, newMessage) : null
+			});
+		}
+	}
+}
+const name$8 = "no-multiple-whitespaces";
+const rule$6 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Prevents usage of multiple consecutive whitespaces in message",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-multiple-whitespaces"
+		},
+		messages: {
+			...CORE_MESSAGES,
+			noMultipleWhitespaces: "Multiple consecutive whitespaces are not allowed"
+		},
+		fixable: "code",
+		schema: []
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$4(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$4(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-offset.ts
+function verifyAst$2(ast) {
+	const errors = [];
+	for (const el of ast) if (isPluralElement(el)) {
+		if (el.offset) errors.push({
+			messageId: "noOffset",
+			data: {}
+		});
+		const { options } = el;
+		for (const selector of Object.keys(options)) errors.push(...verifyAst$2(options[selector].value));
+	}
+	return errors;
+}
+function checkNode$3(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, settings);
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+			continue;
+		}
+		const errors = verifyAst$2(ast);
+		for (const error of errors) context.report({
+			node: messageNode,
+			...error
+		});
+	}
+}
+const name$7 = "no-offset";
+const rule$5 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow offset in plural rules",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-offset"
+		},
+		fixable: "code",
+		messages: {
+			...CORE_MESSAGES,
+			noOffset: "offset is not allowed"
+		},
+		schema: []
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$3(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$3(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-useless-message.ts
+function verifyAst$1(ast) {
+	if (ast.length !== 1) return;
+	switch (ast[0].type) {
+		case TYPE.argument: return "unnecessaryFormat";
+		case TYPE.number: return "unnecessaryFormatNumber";
+		case TYPE.date: return "unnecessaryFormatDate";
+		case TYPE.time: return "unnecessaryFormatTime";
+	}
+}
+function checkNode$2(context, node) {
+	const settings = getSettings(context);
+	const msgs = extractMessages(node, settings);
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { ignoreTag: settings.ignoreTag });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e.message }
+			});
+			continue;
+		}
+		const messageId = verifyAst$1(ast);
+		if (messageId) context.report({
+			node: messageNode,
+			messageId
+		});
+	}
+}
+const name$6 = "no-useless-message";
+const rule$4 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow unnecessary formatted message",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-useless-message"
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			...CORE_MESSAGES,
+			unnecessaryFormat: "Unnecessary formatted message.",
+			unnecessaryFormatNumber: "Unnecessary formatted message: just use FormattedNumber or intl.formatNumber.",
+			unnecessaryFormatDate: "Unnecessary formatted message: just use FormattedDate or intl.formatDate.",
+			unnecessaryFormatTime: "Unnecessary formatted message: just use FormattedTime or intl.formatTime."
+		}
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$2(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$2(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/prefer-formatted-message.ts
+const name$5 = "prefer-formatted-message";
+const rule$3 = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer `FormattedMessage` component over `intl.formatMessage` if applicable.",
+			url: "https://formatjs.github.io/docs/tooling/linter#prefer-formatted-message"
+		},
+		messages: { jsxChildren: "Prefer `FormattedMessage` over `intl.formatMessage` in the JSX children expression." },
+		schema: []
+	},
+	create(context) {
+		return { JSXElement: (node) => {
+			node.children.forEach((child) => {
+				if (child.type !== "JSXExpressionContainer" || !isIntlFormatMessageCall(child.expression)) return;
+				context.report({
+					node: child,
+					messageId: "jsxChildren"
+				});
+			});
+		} };
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/prefer-pound-in-plural.ts
+function verifyAst(context, messageNode, ast) {
+	const patches = [];
+	_verifyAst(ast);
+	if (patches.length > 0) {
+		const patchedMessage = patchMessage(messageNode, ast, (content) => {
+			return patches.reduce((magicString, patch) => {
+				switch (patch.type) {
+					case "prependLeft": return magicString.prependLeft(patch.index, patch.content);
+					case "remove": return magicString.remove(patch.start, patch.end);
+					case "update": return magicString.update(patch.start, patch.end, patch.content);
+				}
+			}, new MagicString(content)).toString();
+		});
+		context.report({
+			node: messageNode,
+			messageId: "preferPoundInPlurals",
+			fix: patchedMessage !== null ? (fixer) => fixer.replaceText(messageNode, patchedMessage) : null
+		});
+	}
+	function _verifyAst(ast) {
+		for (let i = 0; i < ast.length; i++) {
+			const current = ast[i];
+			switch (current.type) {
+				case TYPE.argument:
+				case TYPE.number: {
+					if (current.type === TYPE.number && current.style) break;
+					const next = ast[i + 1];
+					const nextNext = ast[i + 2];
+					if (next && nextNext && next.type === TYPE.literal && next.value === " " && nextNext.type === TYPE.plural && nextNext.value === current.value) _removeRangeAndPrependPluralClauses(current.location.start.offset, next.location.end.offset, nextNext, "# ");
+					else if (next && next.type === TYPE.plural && next.value === current.value) _removeRangeAndPrependPluralClauses(current.location.start.offset, current.location.end.offset, next, "#");
+					break;
+				}
+				case TYPE.plural: {
+					const name = current.value;
+					for (const { value } of Object.values(current.options)) _replacementArgumentWithPound(name, value);
+					break;
+				}
+				case TYPE.select:
+					for (const { value } of Object.values(current.options)) _verifyAst(value);
+					break;
+				case TYPE.tag:
+					_verifyAst(current.children);
+					break;
+				default: break;
+			}
+		}
+	}
+	function _replacementArgumentWithPound(name, ast) {
+		for (const element of ast) switch (element.type) {
+			case TYPE.argument:
+			case TYPE.number:
+				if (element.value === name && (element.type !== TYPE.number || !element.style)) patches.push({
+					type: "update",
+					start: element.location.start.offset,
+					end: element.location.end.offset,
+					content: "#"
+				});
+				break;
+			case TYPE.tag:
+				_replacementArgumentWithPound(name, element.children);
+				break;
+			case TYPE.select:
+				for (const { value } of Object.values(element.options)) _replacementArgumentWithPound(name, value);
+				break;
+			default: break;
+		}
+	}
+	function _removeRangeAndPrependPluralClauses(rangeToRemoveStart, rangeToRemoveEnd, pluralElement, prependText) {
+		patches.push({
+			type: "remove",
+			start: rangeToRemoveStart,
+			end: rangeToRemoveEnd
+		});
+		for (const { location } of Object.values(pluralElement.options)) patches.push({
+			type: "prependLeft",
+			index: location.start.offset + 1,
+			content: prependText
+		});
+	}
+}
+function checkNode$1(context, node) {
+	const msgs = extractMessages(node, getSettings(context));
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage, { captureLocation: true });
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e instanceof Error ? e.message : String(e) }
+			});
+			return;
+		}
+		verifyAst(context, messageNode, ast);
+	}
+}
+const name$4 = "prefer-pound-in-plural";
+const rule$2 = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer using # to reference the count in the plural argument.",
+			url: "https://formatjs.github.io/docs/tooling/linter#prefer-pound-in-plurals"
+		},
+		messages: {
+			...CORE_MESSAGES,
+			preferPoundInPlurals: "Prefer using # to reference the count in the plural argument instead of repeating the argument."
+		},
+		fixable: "code",
+		schema: []
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode$1(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode$1(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/no-literal-string-in-object.ts
+const name$3 = "no-literal-string-in-object";
+const rule$1 = {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce translation of specific object properties",
+			url: "https://formatjs.github.io/docs/tooling/linter#no-literal-string-in-object"
+		},
+		schema: [{
+			type: "object",
+			properties: { include: {
+				type: "array",
+				items: { type: "string" },
+				default: ["label"]
+			} },
+			additionalProperties: false
+		}],
+		messages: { untranslatedProperty: "Object property: `{{propertyKey}}` might contain an untranslated literal string" }
+	},
+	create(context) {
+		const propertyVisitor = (node) => {
+			checkProperty(context, node);
+		};
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ Property: propertyVisitor }, { Property: propertyVisitor });
+		return { Property: propertyVisitor };
+	}
+};
+function checkProperty(context, node) {
+	const config = {
+		include: ["label"],
+		...context.options[0]
+	};
+	const propertyKey = node.key.type === "Identifier" ? node.key.name : node.key.type === "Literal" && typeof node.key.value === "string" ? node.key.value : null;
+	if (!propertyKey || !config.include.includes(propertyKey)) return;
+	checkPropertyValue(context, node.value, propertyKey);
+}
+function checkPropertyValue(context, node, propertyKey) {
+	if (node.type === "Literal" && typeof node.value === "string" && node.value.length > 0 || node.type === "TemplateLiteral" && (node.quasis.length > 1 || node.quasis[0].value.raw.length > 0)) context.report({
+		node,
+		messageId: "untranslatedProperty",
+		data: { propertyKey }
+	});
+	else if (node.type === "BinaryExpression" && node.operator === "+") {
+		checkPropertyValue(context, node.left, propertyKey);
+		checkPropertyValue(context, node.right, propertyKey);
+	} else if (node.type === "ConditionalExpression") {
+		checkPropertyValue(context, node.consequent, propertyKey);
+		checkPropertyValue(context, node.alternate, propertyKey);
+	} else if (node.type === "LogicalExpression") {
+		checkPropertyValue(context, node.left, propertyKey);
+		checkPropertyValue(context, node.right, propertyKey);
+	}
+}
+//#endregion
+//#region packages/eslint-plugin-formatjs/rules/prefer-full-sentence.ts
+/**
+* Get the first boundary element, recursing into tags since
+* <b>hello</b> starts with the literal "hello".
+*/
+function getFirstBoundaryElement(ast) {
+	if (ast.length === 0) return null;
+	const first = ast[0];
+	if (first.type === TYPE.tag) return getFirstBoundaryElement(first.children);
+	return first;
+}
+/**
+* Get the last boundary element, recursing into tags.
+*/
+function getLastBoundaryElement(ast) {
+	if (ast.length === 0) return null;
+	const last = ast[ast.length - 1];
+	if (last.type === TYPE.tag) return getLastBoundaryElement(last.children);
+	return last;
+}
+function findWhitespaceIssues(ast) {
+	const issues = [];
+	const first = getFirstBoundaryElement(ast);
+	const last = getLastBoundaryElement(ast);
+	if (first === last && first?.type === TYPE.literal && ast.length === 1 && first.value.trim() === "") return issues;
+	if (first?.type === TYPE.literal && /^\s/.test(first.value)) issues.push("leadingWhitespace");
+	if (last?.type === TYPE.literal && /\s$/.test(last.value)) issues.push("trailingWhitespace");
+	for (const element of ast) switch (element.type) {
+		case TYPE.plural:
+		case TYPE.select:
+			for (const option of Object.values(element.options)) issues.push(...findWhitespaceIssues(option.value));
+			break;
+	}
+	return issues;
+}
+function checkNode(context, node) {
+	const msgs = extractMessages(node, getSettings(context));
+	for (const [{ message: { defaultMessage }, messageNode }] of msgs) {
+		if (!defaultMessage || !messageNode) continue;
+		let ast;
+		try {
+			ast = parse(defaultMessage);
+		} catch (e) {
+			context.report({
+				node: messageNode,
+				messageId: "parseError",
+				data: { error: e instanceof Error ? e.message : String(e) }
+			});
+			return;
+		}
+		const issues = findWhitespaceIssues(ast);
+		const seen = /* @__PURE__ */ new Set();
+		for (const issue of issues) {
+			if (seen.has(issue)) continue;
+			seen.add(issue);
+			context.report({
+				node: messageNode,
+				messageId: issue
+			});
+		}
+	}
+}
+const name$2 = "prefer-full-sentence";
+const rule = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Detects messages with leading/trailing whitespace, which suggests string concatenation instead of full sentences",
+			url: "https://formatjs.github.io/docs/tooling/linter#prefer-full-sentence"
+		},
+		messages: {
+			...CORE_MESSAGES,
+			leadingWhitespace: "Messages should be full sentences — leading whitespace suggests string concatenation",
+			trailingWhitespace: "Messages should be full sentences — trailing whitespace suggests string concatenation"
+		},
+		schema: []
+	},
+	create(context) {
+		const callExpressionVisitor = (node) => checkNode(context, node);
+		const parserServices = context.sourceCode.parserServices;
+		if (parserServices?.defineTemplateBodyVisitor) return parserServices.defineTemplateBodyVisitor({ CallExpression: callExpressionVisitor }, { CallExpression: callExpressionVisitor });
+		return {
+			JSXOpeningElement: (node) => checkNode(context, node),
+			CallExpression: callExpressionVisitor
+		};
+	}
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/package.json
+var package_exports = /* @__PURE__ */ __exportAll({
+	author: () => author,
+	bugs: () => bugs,
+	default: () => package_default,
+	dependencies: () => dependencies,
+	description: () => description,
+	exports: () => exports,
+	homepage: () => homepage,
+	keywords: () => keywords,
+	license: () => license,
+	main: () => main,
+	name: () => name$1,
+	peerDependencies: () => peerDependencies,
+	repository: () => repository,
+	type: () => type,
+	types: () => types,
+	version: () => version$1
+});
+var name$1 = "eslint-plugin-formatjs";
+var description = "ESLint plugin for formatjs";
+var version$1 = "6.4.5";
+var license = "MIT";
+var author = "Long Ho <holevietlong@gmail.com>";
+var type = "module";
+var types = "index.d.ts";
+var exports = {
+	".": "./index.js",
+	"./util": "./util.js"
+};
+var dependencies = {
+	"@formatjs/icu-messageformat-parser": "workspace:*",
+	"@formatjs/ts-transformer": "workspace:*",
+	"@types/picomatch": "^4.0.0",
+	"@unicode/unicode-17.0.0": "^1.6.16",
+	"magic-string": "^0.30.0",
+	"picomatch": "2 || 3 || 4"
+};
+var peerDependencies = { "eslint": "9 || 10" };
+var bugs = "https://github.com/formatjs/formatjs/issues";
+var homepage = "https://github.com/formatjs/formatjs#readme";
+var keywords = [
+	"eslint",
+	"eslintplugin",
+	"formatjs",
+	"i18n"
+];
+var main = "index.js";
+var repository = "formatjs/formatjs.git";
+var package_default = {
+	name: name$1,
+	description,
+	version: version$1,
+	license,
+	author,
+	type,
+	types,
+	exports,
+	dependencies,
+	peerDependencies,
+	bugs,
+	homepage,
+	keywords,
+	main,
+	repository
+};
+//#endregion
+//#region packages/eslint-plugin-formatjs/index.ts
+const { name, version } = package_default ?? package_exports;
 const plugin = {
 	meta: {
 		name,
 		version
 	},
-	rules,
+	rules: {
+		[name$22]: rule$20,
+		[name$21]: rule$19,
+		[name$20]: rule$18,
+		[name$19]: rule$17,
+		[name$18]: rule$16,
+		[name$17]: rule$15,
+		[name$16]: rule$14,
+		[name$15]: rule$13,
+		[name$14]: rule$12,
+		[name$13]: rule$11,
+		[name$12]: rule$10,
+		[name$11]: rule$9,
+		[name$9]: rule$7,
+		[name$8]: rule$6,
+		[name$7]: rule$5,
+		[name$6]: rule$4,
+		[name$5]: rule$3,
+		[name$4]: rule$2,
+		[name$10]: rule$8,
+		[name$3]: rule$1,
+		[name$2]: rule
+	},
 	configs: {}
 };
-// Configs
-const configs = {
+plugin.configs = {
 	strict: {
 		name: "formatjs/strict",
 		plugins: { formatjs: plugin },
@@ -107,5 +4654,7 @@ const configs = {
 		}
 	}
 };
-plugin.configs = configs;
-export default plugin;
+//#endregion
+export { plugin as default };
+
+//# sourceMappingURL=index.js.map