LearnNode/node-course/node_modules/eslint-plugin-vue/dist/rules/no-irregular-whitespace.js

"use strict";
const require_runtime = require("../_virtual/_rolldown/runtime.js");
const require_index = require("../utils/index.js");
//#region lib/rules/no-irregular-whitespace.js
/**
* @author Yosuke Ota
* @fileoverview Rule to disalow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
*/
var require_no_irregular_whitespace = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
	const utils = require_index.default;
	const ALL_IRREGULARS = /[\f\v\u{85}\u{FEFF}\u{A0}\u{1680}\u{180E}\u{2000}\u{2001}\u{2002}\u{2003}\u{2004}\u{2005}\u{2006}\u{2007}\u{2008}\u{2009}\u{200A}\u{200B}\u{202F}\u{205F}\u{3000}\u{2028}\u{2029}]/u;
	const IRREGULAR_WHITESPACE = /[\f\v\u{85}\u{FEFF}\u{A0}\u{1680}\u{180E}\u{2000}\u{2001}\u{2002}\u{2003}\u{2004}\u{2005}\u{2006}\u{2007}\u{2008}\u{2009}\u{200A}\u{200B}\u{202F}\u{205F}\u{3000}]+/gmu;
	const IRREGULAR_LINE_TERMINATORS = /[\u{2028}\u{2029}]/gmu;
	module.exports = {
		meta: {
			type: "problem",
			docs: {
				description: "disallow irregular whitespace in `.vue` files",
				categories: void 0,
				url: "https://eslint.vuejs.org/rules/no-irregular-whitespace.html",
				extensionSource: {
					url: "https://eslint.org/docs/rules/no-irregular-whitespace",
					name: "ESLint core"
				}
			},
			schema: [{
				type: "object",
				properties: {
					skipComments: { type: "boolean" },
					skipStrings: { type: "boolean" },
					skipTemplates: { type: "boolean" },
					skipRegExps: { type: "boolean" },
					skipHTMLAttributeValues: { type: "boolean" },
					skipHTMLTextContents: { type: "boolean" }
				},
				additionalProperties: false
			}],
			messages: { disallow: "Irregular whitespace not allowed." }
		},
		/**
		* @param {RuleContext} context - The rule context.
		* @returns {RuleListener} AST event handlers.
		*/
		create(context) {
			/** @type {{start: number, end: number}[]} */
			let errorIndices = [];
			const options = context.options[0] || {};
			const shouldSkipComments = !!options.skipComments;
			const shouldSkipStrings = options.skipStrings !== false;
			const shouldSkipRegExps = !!options.skipRegExps;
			const shouldSkipTemplates = !!options.skipTemplates;
			const shouldSkipHTMLAttributeValues = !!options.skipHTMLAttributeValues;
			const shouldSkipHTMLTextContents = !!options.skipHTMLTextContents;
			const sourceCode = context.sourceCode;
			/**
			* Removes errors that occur inside a string node
			* @param {ASTNode | Token} node to check for matching errors.
			* @returns {void}
			* @private
			*/
			function removeWhitespaceError(node) {
				const [startIndex, endIndex] = node.range;
				errorIndices = errorIndices.filter((error) => error.start < startIndex || endIndex <= error.start);
			}
			/**
			* Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
			* @param {Literal} node to check for matching errors.
			* @returns {void}
			* @private
			*/
			function removeInvalidNodeErrorsInLiteral(node) {
				const shouldCheckStrings = shouldSkipStrings && typeof node.value === "string";
				const shouldCheckRegExps = shouldSkipRegExps && Boolean(node.regex);
				if ((shouldCheckStrings || shouldCheckRegExps) && ALL_IRREGULARS.test(sourceCode.getText(node))) removeWhitespaceError(node);
			}
			/**
			* Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
			* @param {TemplateElement} node to check for matching errors.
			* @returns {void}
			* @private
			*/
			function removeInvalidNodeErrorsInTemplateLiteral(node) {
				if (ALL_IRREGULARS.test(node.value.raw)) removeWhitespaceError(node);
			}
			/**
			* Checks HTML attribute value nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
			* @param {VLiteral} node to check for matching errors.
			* @returns {void}
			* @private
			*/
			function removeInvalidNodeErrorsInHTMLAttributeValue(node) {
				if (ALL_IRREGULARS.test(sourceCode.getText(node))) removeWhitespaceError(node);
			}
			/**
			* Checks HTML text content nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
			* @param {VText} node to check for matching errors.
			* @returns {void}
			* @private
			*/
			function removeInvalidNodeErrorsInHTMLTextContent(node) {
				if (ALL_IRREGULARS.test(sourceCode.getText(node))) removeWhitespaceError(node);
			}
			/**
			* Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
			* @param {Comment | HTMLComment | HTMLBogusComment} node to check for matching errors.
			* @returns {void}
			* @private
			*/
			function removeInvalidNodeErrorsInComment(node) {
				if (ALL_IRREGULARS.test(node.value)) removeWhitespaceError(node);
			}
			/**
			* Checks the program source for irregular whitespaces and irregular line terminators
			* @returns {void}
			* @private
			*/
			function checkForIrregularWhitespace() {
				const source = sourceCode.getText();
				let match;
				while ((match = IRREGULAR_WHITESPACE.exec(source)) !== null) errorIndices.push({
					start: match.index,
					end: match.index + match[0].length
				});
				while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) errorIndices.push({
					start: match.index,
					end: match.index + match[0].length
				});
			}
			checkForIrregularWhitespace();
			if (errorIndices.length === 0) return {};
			const bodyVisitor = utils.defineTemplateBodyVisitor(context, {
				...shouldSkipHTMLAttributeValues ? { "VAttribute[directive=false] > VLiteral": removeInvalidNodeErrorsInHTMLAttributeValue } : {},
				...shouldSkipHTMLTextContents ? { VText: removeInvalidNodeErrorsInHTMLTextContent } : {},
				Literal: removeInvalidNodeErrorsInLiteral,
				...shouldSkipTemplates ? { TemplateElement: removeInvalidNodeErrorsInTemplateLiteral } : {}
			});
			return {
				...bodyVisitor,
				Literal: removeInvalidNodeErrorsInLiteral,
				...shouldSkipTemplates ? { TemplateElement: removeInvalidNodeErrorsInTemplateLiteral } : {},
				"Program:exit"(node) {
					if (bodyVisitor["Program:exit"]) bodyVisitor["Program:exit"](node);
					const templateBody = node.templateBody;
					if (shouldSkipComments) {
						for (const node of sourceCode.getAllComments()) removeInvalidNodeErrorsInComment(node);
						if (templateBody) for (const node of templateBody.comments) removeInvalidNodeErrorsInComment(node);
					}
					const [scriptStart, scriptEnd] = node.range;
					const [templateStart, templateEnd] = templateBody ? templateBody.range : [0, 0];
					errorIndices = errorIndices.filter((error) => scriptStart <= error.start && error.start < scriptEnd || templateStart <= error.start && error.start < templateEnd);
					for (const { start, end } of errorIndices) context.report({
						loc: {
							start: sourceCode.getLocFromIndex(start),
							end: sourceCode.getLocFromIndex(end)
						},
						messageId: "disallow"
					});
				}
			};
		}
	};
}));
//#endregion
Object.defineProperty(exports, "default", {
	enumerable: true,
	get: function() {
		return require_no_irregular_whitespace();
	}
});