@castlenine/vite-remove-attribute 1.0.1 → 2.0.0

package/dist/index.js

@@ -1,106 +1,534 @@
-const g = [
-  // Node modules
-  "node_modules",
-  // Git
-  ".git",
-  // IDE configurations
-  ".idea",
-  // JetBrains IDEs (e.g., WebStorm)
-  ".vscode",
-  // Visual Studio Code
-  // OS generated files
-  ".DS_Store",
-  // macOS
-  "Thumbs.db",
-  // Windows
-  // Environment variables
-  ".env",
-  ".env.*",
-  // .env.development, .env.production, etc.
-  // Logs
-  "logs",
-  "*.log",
-  // Svelte
-  "public",
-  // Svelte.js public folder
-  "build",
-  // Svelte.js build folder
-  // SvelteKit
-  ".svelte-kit",
-  // SvelteKit generates this folder
-  // Dist
-  "dist",
-  // Distribution folder
-  // Vue.js
-  ".nuxt",
-  // Nuxt.js generates this folder
-  // React.js
-  ".next",
-  // Next.js generates this folder
-  // Remix.js
-  ".remix",
-  // Remix.js cache
-  // Angular
-  "e2e",
-  // End-to-end tests in Angular
-  "angular.json",
-  // Angular CLI configuration
-  "browserslist",
-  // Browser compatibility list for Angular
-  ".cache"
-  // Cache files for various tools
+import { relative, sep } from "node:path";
+//#region src/sourcemap.ts
+var BASE64_CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var WORD_CHARACTER_REGEX = /\w/;
+/**
+* Encodes a single integer value as a base64 VLQ (Variable Length Quantity) string.
+*
+* @remarks
+* Base64 VLQ is the encoding format used for numbers in source map `mappings` fields.
+* This function encodes both positive and negative integers using bitwise operations,
+* setting the least significant bit for sign and using continuation bits for multi-digit numbers.
+*
+* @param value - The integer to encode. Can be positive, negative, or zero.
+*
+* @returns The VLQ Base64-encoded string representation.
+*
+* @see [Source Map V3 Spec](https://sourcemaps.info/spec.html)
+*/
+function encodeVlq(value) {
+	let vlq = value < 0 ? -value << 1 | 1 : value << 1;
+	let output = "";
+	do {
+		let digit = vlq & 31;
+		vlq >>>= 5;
+		if (vlq > 0) digit |= 32;
+		output += BASE64_CHARACTERS.charAt(digit);
+	} while (vlq > 0);
+	return output;
+}
+/**
+* Builds the `mappings` string one generated line at a time, encoding every segment as deltas from the previous one
+*/
+var MappingsWriter = class {
+	lines = [];
+	segments = [];
+	lastGeneratedColumn = 0;
+	lastOriginalLine = 0;
+	lastOriginalColumn = 0;
+	lastMappedColumn = -1;
+	addSegment(generatedColumn, originalLine, originalColumn) {
+		if (generatedColumn === this.lastMappedColumn) return;
+		this.segments.push(encodeVlq(generatedColumn - this.lastGeneratedColumn) + encodeVlq(0) + encodeVlq(originalLine - this.lastOriginalLine) + encodeVlq(originalColumn - this.lastOriginalColumn));
+		this.lastGeneratedColumn = generatedColumn;
+		this.lastOriginalLine = originalLine;
+		this.lastOriginalColumn = originalColumn;
+		this.lastMappedColumn = generatedColumn;
+	}
+	endLine() {
+		this.lines.push(this.segments.join(","));
+		this.segments = [];
+		this.lastGeneratedColumn = 0;
+		this.lastMappedColumn = -1;
+	}
+	toString() {
+		this.endLine();
+		return this.lines.join(";");
+	}
+};
+/**
+* Generates a source map for a given `source` string with the specified ranges removed.
+*
+* Emits a segment at the start of each generated line, at each position where the original text was cut, and at
+* every word boundary in between, allowing consumers to resolve any token to its original line and column.
+*
+* @param source - The original source code string.
+* @param ranges - Sorted, non-overlapping `[start, end)` character ranges to be removed.
+* @param file - The original file name or path. Used as the single source entry in the resulting source map.
+*
+* @returns The generated SourceMap object with correct mappings after range removal.
+*/
+function generateRemovalSourceMap(source, ranges, file) {
+	const WRITER = new MappingsWriter();
+	let generatedColumn = 0;
+	let originalLine = 0;
+	let originalColumn = 0;
+	let previousCharacter = "";
+	let cursor = 0;
+	/**
+	* Advances the original position from `from` to `to`, updating `originalLine` and `originalColumn`
+	* to correctly reflect skipping a removed range.
+	*
+	* @param from - Start index in the original source.
+	* @param to - End index in the original source.
+	*/
+	const ADVANCE_ORIGINAL = (from, to) => {
+		for (let index = from; index < to; index++) if (source.charAt(index) === "\n") {
+			originalLine++;
+			originalColumn = 0;
+		} else originalColumn++;
+	};
+	/**
+	* Emits source map segments for the kept region from `from` to `to`.
+	*
+	* @remarks
+	* A segment is written at every new line and at every word boundary change (as determined by
+	* `WORD_CHARACTER_REGEX`), so tools consuming the source map can resolve the original location of any token in
+	* the generated content. The `generatedColumn`, `originalLine` and `originalColumn` counters are advanced as the
+	* region is traversed, and `needsSegment` forces a segment right after a cut.
+	*
+	* @param from - Start index of the kept region.
+	* @param to - End index of the kept region.
+	*/
+	const WRITE_KEPT = (from, to) => {
+		let needsSegment = from < to;
+		for (let index = from; index < to; index++) {
+			const CHARACTER = source.charAt(index);
+			if (CHARACTER === "\n") {
+				WRITER.endLine();
+				generatedColumn = 0;
+				originalLine++;
+				originalColumn = 0;
+				needsSegment = true;
+			} else {
+				if (needsSegment || WORD_CHARACTER_REGEX.test(CHARACTER) !== WORD_CHARACTER_REGEX.test(previousCharacter)) {
+					WRITER.addSegment(generatedColumn, originalLine, originalColumn);
+					needsSegment = false;
+				}
+				generatedColumn++;
+				originalColumn++;
+			}
+			previousCharacter = CHARACTER;
+		}
+	};
+	for (const [START, END] of ranges) {
+		WRITE_KEPT(cursor, START);
+		ADVANCE_ORIGINAL(START, END);
+		cursor = END;
+	}
+	WRITE_KEPT(cursor, source.length);
+	return {
+		version: 3,
+		sources: [file],
+		sourcesContent: [source],
+		names: [],
+		mappings: WRITER.toString()
+	};
+}
+//#endregion
+//#region src/utilities.ts
+var DEFAULT_IGNORE_PATHS = [
+	"node_modules",
+	".git",
+	".idea",
+	".vscode",
+	".DS_Store",
+	"Thumbs.db",
+	".env",
+	".env.*",
+	"logs",
+	"*.log",
+	"public",
+	"build",
+	".svelte-kit",
+	"dist",
+	".nuxt",
+	".next",
+	".remix",
+	"e2e",
+	"angular.json",
+	"browserslist",
+	".cache"
 ];
-function a(e) {
-  return {
-    extensions: Array.isArray(e.extensions) ? e.extensions : [],
-    ignoreFolders: Array.isArray(e.ignoreFolders) ? e.ignoreFolders : [],
-    ignoreFiles: Array.isArray(e.ignoreFiles) ? e.ignoreFiles : [],
-    attributes: Array.isArray(e.attributes) ? e.attributes : []
-  };
-}
-function E(e) {
-  const n = [".", "./", "/", "/."], r = l(e.ignoreFolders || [], n).filter((s) => d(s)), t = l(e.ignoreFiles || [], n).filter((s) => c(s));
-  return r.concat(t);
-}
-function f(e) {
-  return !!e && typeof e == "string";
-}
-function o(e) {
-  return e.trim().startsWith("./") ? e.substring(2) : e.trim();
-}
-function u(e, n) {
-  return (n ?? g).some((r) => e.includes(r));
-}
-function l(e, n) {
-  return [...new Set(e.filter((r) => !n.includes(r) && f(r) && o(r).length).map(o))];
-}
-function c(e) {
-  var n;
-  const [r, ...t] = ((n = e.split("/").pop()) !== null && n !== void 0 ? n : "").split(".");
-  return e.length >= 3 && t.length >= 2 && r.length >= 3 && !r.includes("/");
-}
-function d(e) {
-  return !c(e) && /^[a-zA-Z0-9_.-/]*$/.test(e);
-}
-function A(e, n) {
-  return new RegExp(`\\.(${n.extensions.join("|")})$`, "i").test(e);
-}
-function I(e, n) {
-  return n.reduce((r, t) => {
-    const i = new RegExp(`(\\s(:|v-bind:)?${t}\\s*=\\s*(['"\`])((?:(?!\\3).)*)(\\3))|(\\s(:|v-bind:)?${t}(?=[\\s>]))`, "gi");
-    return r.replace(i, "");
-  }, e);
-}
-function _(e) {
-  const n = a(e), r = E(n);
-  return {
-    name: "remove-attributes",
-    enforce: "pre",
-    transform(t, i) {
-      return u(i) || u(i, r) || !A(i, n) ? t : I(t, n.attributes);
-    }
-  };
-}
-export {
-  _ as default
+var REGEX_SPECIAL_CHARACTERS_REGEX = /[.*+?^${}()|[\]\\]/g;
+var LEADING_RELATIVE_PREFIX_REGEX = /^(?:\.\/|\/)+/;
+var TRAILING_SLASHES_REGEX = /\/+$/;
+var LEADING_PARENT_SEGMENTS_REGEX = /^(?:\.\.\/)+/;
+var LEADING_DOTS_REGEX = /^\.+/;
+var TOKEN_REGEX_CACHE = /* @__PURE__ */ new Map();
+var EXTENSION_REGEX_CACHE = /* @__PURE__ */ new Map();
+function escapeRegExp(value) {
+	return value.replace(REGEX_SPECIAL_CHARACTERS_REGEX, "\\$&");
+}
+function getOptions(options) {
+	return {
+		extensions: Array.isArray(options.extensions) ? options.extensions : [],
+		attributes: Array.isArray(options.attributes) ? options.attributes : [],
+		ignoreFolders: Array.isArray(options.ignoreFolders) ? options.ignoreFolders : [],
+		ignoreFiles: Array.isArray(options.ignoreFiles) ? options.ignoreFiles : [],
+		ignoreDefaults: options.ignoreDefaults !== false
+	};
+}
+/**
+* Normalizes a user-supplied ignore token by trimming whitespace,
+* removing leading './' or '/', and stripping trailing '/' characters.
+*
+* @param path - The ignore token to normalize.
+*
+* @returns The normalized ignore token.
+*/
+function cleanIgnoredPath(path) {
+	return path.trim().replace(LEADING_RELATIVE_PREFIX_REGEX, "").replace(TRAILING_SLASHES_REGEX, "");
+}
+/**
+* Normalizes and de-duplicates ignore tokens by:
+* - Trimming whitespace from each path
+* - Removing leading './' or '/', and trailing '/' characters
+* - Dropping empty and root-only entries (such as `''`, `.`, `/`, and `./`)
+* - Removing duplicate entries in the result
+*
+* @param paths - An array of ignore path tokens to be cleaned and de-duplicated.
+*
+* @returns A new array containing unique, cleaned ignore tokens, with all empty or root-only entries omitted.
+*/
+function cleanIgnoredPaths(paths) {
+	const CLEANED = paths.filter((path) => typeof path === "string").map(cleanIgnoredPath).filter((path) => path !== "" && path !== ".");
+	return [...new Set(CLEANED)];
+}
+/**
+* Returns the combined and cleaned list of ignored paths based on the provided {@link ResolvedOptions}.
+*
+* @remarks
+* - Merges `ignoreFolders` and `ignoreFiles` into a single list.
+* - Cleans each entry using {@link cleanIgnoredPaths}.
+* - If `ignoreDefaults` is not explicitly set to `false`, the list also includes {@link DEFAULT_IGNORE_PATHS}.
+* - The resulting list is de-duplicated.
+*
+* @param options - The resolved options containing `ignoreFolders`, `ignoreFiles` and the `ignoreDefaults` flag.
+*
+* @returns An array of unique, cleaned ignore path tokens, including the built-in defaults unless
+*   {@link ResolvedOptions.ignoreDefaults} is `false`.
+*/
+function getIgnoredPaths(options) {
+	const CONFIGURED = cleanIgnoredPaths([...options.ignoreFolders, ...options.ignoreFiles]);
+	return options.ignoreDefaults ? [.../* @__PURE__ */ new Set([...CONFIGURED, ...DEFAULT_IGNORE_PATHS])] : CONFIGURED;
+}
+/**
+* Removes the `?query` suffix that Vite appends to module IDs.
+*
+* For example, given `/src/App.svelte?svelte&type=style&lang.css`, this function will return `/src/App.svelte`.
+*
+* @param id - The module ID which may include a `?query` suffix.
+*
+* @returns The module ID without any `?query` part.
+*/
+function stripQuery(id) {
+	const QUERY_INDEX = id.indexOf("?");
+	return QUERY_INDEX === -1 ? id : id.slice(0, QUERY_INDEX);
+}
+/**
+* Returns the path of a module ID relative to the Vite root directory, using POSIX separators.
+*
+* @param id - The module ID to be converted to a relative path.
+* @param root - The root directory to which the path will be made relative.
+*
+* @returns The relative path from the root to the module ID, using '/' as the separator.
+*/
+function toRelativePath(id, root) {
+	return relative(root, stripQuery(id)).split(sep).join("/");
+}
+/**
+* Returns a cached or newly-created regular expression to match a path segment token,
+* supporting `*` wildcards matching within a segment (but not across path separators).
+*
+* The regular expression is built so that `*` matches any sequence of characters except '/'.
+* The regex is cached for subsequent calls with the same token.
+*
+* @param token - The ignore token, possibly containing `*` wildcards.
+*
+* @returns The regular expression corresponding to the token, matching segment boundaries.
+*/
+function getTokenRegex(token) {
+	const CACHED = TOKEN_REGEX_CACHE.get(token);
+	if (CACHED) return CACHED;
+	const PATTERN = token.split("*").map(escapeRegExp).join("[^/]*");
+	const REGEX = new RegExp(`(?:^|/)${PATTERN}(?:/|$)`);
+	TOKEN_REGEX_CACHE.set(token, REGEX);
+	return REGEX;
+}
+/**
+* Checks if the given relative path matches any of the provided ignore tokens,
+* comparing on path-segment boundaries. Ignores leading parent directory segments.
+*
+* @remarks
+* This function ignores absolute IDs to avoid false positives from folder names that coincidentally
+* contain ignore tokens. For example, in environments like Cloudflare where a repo may be cloned
+* to a directory such as `/opt/buildhome/repo`, a token like `build` should not match simply
+* because it's part of the parent path. Only the path relative to the Vite root is considered.
+*
+* Leading `../` segments are stripped from the path so that modules resolved outside the root
+* (e.g. `../../.pnpm/x/node_modules/y/index.js`) still have the opportunity to match ignore tokens
+* like `node_modules` against their segments.
+*
+* @param relativePath - The path of the module relative to the Vite root.
+* @param tokens - The list of ignore tokens, possibly including `*` wildcards.
+*
+* @returns `true` if the relative path matches any ignore token; otherwise, `false`.
+*/
+function hasIgnorePath(relativePath, tokens) {
+	const PATH = relativePath.replace(LEADING_PARENT_SEGMENTS_REGEX, "");
+	return tokens.some((token) => getTokenRegex(token).test(PATH));
+}
+/**
+* Returns a regular expression that matches any of the provided file extensions at the end of a string.
+*
+* The extensions are matched case-insensitively and can be provided with or without leading dots.
+* The resulting regex is cached for subsequent calls with the same set of extensions.
+*
+* @param extensions - An array of file extension strings (with or without leading dots).
+*
+* @returns A RegExp instance matching any of the specified extensions as a file suffix.
+*/
+function getExtensionRegex(extensions) {
+	const KEY = extensions.join("|");
+	const CACHED = EXTENSION_REGEX_CACHE.get(KEY);
+	if (CACHED) return CACHED;
+	const PATTERN = extensions.map((extension) => escapeRegExp(extension.replace(LEADING_DOTS_REGEX, ""))).join("|");
+	const REGEX = new RegExp(`\\.(?:${PATTERN})$`, "i");
+	EXTENSION_REGEX_CACHE.set(KEY, REGEX);
+	return REGEX;
+}
+/**
+* Determines whether the provided module id (with query suffix stripped) ends with one of the specified extensions.
+*
+* @param id - The module identifier, possibly including a query suffix (e.g., `file.js?raw`).
+* @param extensions - An array of file extension strings (with or without leading dots).
+*
+* @returns `true` if the module id (excluding the query suffix) ends with one of the provided extensions;
+*   otherwise, `false`.
+*/
+function hasExtension(id, extensions) {
+	if (extensions.length === 0) return false;
+	return getExtensionRegex(extensions).test(stripQuery(id));
+}
+/**
+* Character-by-character scanner for an `={…}` expression: tracks nested braces, quoted strings, template literals
+* and their `${…}` placeholders, and reports when the opening brace is closed
+*/
+var ExpressionScanner = class {
+	frames = [{
+		kind: "expression",
+		depth: 1
+	}];
+	stringQuote = "";
+	isEscaped = false;
+	step(character, next) {
+		if (this.isEscaped) {
+			this.isEscaped = false;
+			return "continue";
+		}
+		if (character === "\\") {
+			this.isEscaped = true;
+			return "continue";
+		}
+		if (this.stringQuote !== "") {
+			if (character === this.stringQuote) this.stringQuote = "";
+			return "continue";
+		}
+		const FRAME = this.frames.at(-1);
+		if (!FRAME) return "continue";
+		return FRAME.kind === "template" ? this.stepTemplate(character, next) : this.stepExpression(FRAME, character);
+	}
+	stepTemplate(character, next) {
+		if (character === "`") this.frames.pop();
+		else if (character === "$" && next === "{") {
+			this.frames.push({
+				kind: "expression",
+				depth: 1
+			});
+			return "skip-next";
+		}
+		return "continue";
+	}
+	stepExpression(frame, character) {
+		if (character === "'" || character === "\"") this.stringQuote = character;
+		else if (character === "`") this.frames.push({ kind: "template" });
+		else if (character === "{") frame.depth++;
+		else if (character === "}") return this.closeBrace(frame);
+		return "continue";
+	}
+	closeBrace(frame) {
+		frame.depth--;
+		if (frame.depth > 0) return "continue";
+		if (this.frames.length === 1) return "closed";
+		this.frames.pop();
+		return "continue";
+	}
 };
+/**
+* Finds the closing brace for an `={…}` attribute value in a string of markup. Returns the index of the closing
+* brace, or `-1` if the braces are unbalanced or not found.
+*
+* @remarks
+* A regular expression cannot do this: the expression may hold a template literal whose `${…}` placeholders nest
+* further braces, and a brace inside a string is text rather than structure. The scanner tracks both.
+*
+* @param input - The input string containing the markup or code.
+* @param openingBraceIndex - The index of the opening `{` character to start scanning from.
+*
+* @returns The index of the corresponding closing `}` brace, or `-1` if unmatched.
+*
+* @example
+* ```ts
+* findExpressionEnd('foo={a + {b: `1${two}`}}', 4); // returns the index of the matching }
+* ```
+*/
+function findExpressionEnd(input, openingBraceIndex) {
+	const SCANNER = new ExpressionScanner();
+	for (let index = openingBraceIndex + 1; index < input.length; index++) {
+		const STEP = SCANNER.step(input.charAt(index), input.charAt(index + 1));
+		if (STEP === "closed") return index;
+		if (STEP === "skip-next") index++;
+	}
+	return -1;
+}
+/**
+* Finds all ranges (start and end indices) for a specific attribute in the given markup input.
+*
+* Handles quoted values, expression values (i.e., `={...}`), and bare attributes, including optional
+* `:` or `v-bind:` prefixes. The detection accounts for whitespace before the attribute, as well as attributes
+* written on their own line. If an attribute value is an expression (`={...}`), this function uses
+* {@link findExpressionEnd} to locate the closing brace, and gracefully skips unbalanced or invalid expressions.
+*
+* @remarks
+* The returned ranges are suitable for text replacements: all whitespace before the attribute is included
+* so that removing the attribute does not leave a dangling blank line or extra spaces.
+*
+* @param input - The input markup string to search for the attribute within.
+* @param attribute - The name of the attribute to locate (e.g., `"data-testid"`).
+*
+* @returns An array of `[start, end)` ranges (as type `Range`) for each found occurrence of the attribute.
+*/
+function findAttributeRangesFor(input, attribute) {
+	const NAME = escapeRegExp(attribute);
+	const PATTERN = new RegExp(`\\s+(?::|v-bind:)?${NAME}(?:\\s*=\\s*(?:(['"\`])(?:(?!\\1)[\\s\\S])*\\1|(\\{))|(?=[\\s/>]))`, "gi");
+	const RANGES = [];
+	let match = PATTERN.exec(input);
+	while (match !== null) {
+		const MATCH_END = match.index + match[0].length;
+		let attributeEnd = MATCH_END;
+		if (match[2] !== void 0) {
+			const CLOSING_BRACE_INDEX = findExpressionEnd(input, MATCH_END - 1);
+			if (CLOSING_BRACE_INDEX === -1) {
+				match = PATTERN.exec(input);
+				continue;
+			}
+			attributeEnd = CLOSING_BRACE_INDEX + 1;
+		}
+		RANGES.push([match.index, attributeEnd]);
+		PATTERN.lastIndex = attributeEnd;
+		match = PATTERN.exec(input);
+	}
+	return RANGES;
+}
+/**
+* Returns the merged ranges of every occurrence of the given attributes (in quoted, `={expression}`,
+* or bare form, with optional `:` or `v-bind:` prefix) within the markup string. The resulting
+* ranges are sorted by start index, and any touching or overlapping ranges are merged.
+*
+* All attributes are located in the same original input, so the returned ranges can be used
+* for sourcemap-aware or batch editing operations.
+*
+* @param input - The markup string to search for the attributes.
+* @param attributes - An array of attribute names to search for (e.g., `['data-testid', 'data-id']`).
+*
+* @returns An array of `Range` tuples, each representing [start, end) of a matched attribute occurrence,
+*          with adjacent and overlapping ranges merged.
+*/
+function findAttributeRanges(input, attributes) {
+	const RANGES = attributes.flatMap((attribute) => findAttributeRangesFor(input, attribute)).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+	const MERGED = [];
+	for (const [START, END] of RANGES) {
+		const LAST = MERGED.at(-1);
+		if (LAST && START <= LAST[1]) LAST[1] = Math.max(LAST[1], END);
+		else MERGED.push([START, END]);
+	}
+	return MERGED;
+}
+/**
+* Returns a copy of the input string with the specified ranges removed.
+*
+* The provided ranges must be sorted by start index and non-overlapping.
+* Each range is specified as a tuple [start, end), with `start` inclusive and `end` exclusive.
+* The function concatenates the segments of the input string outside of these ranges.
+*
+* @param input - The original string from which to remove segments.
+* @param ranges - An array of `[start, end)` index ranges (sorted, non-overlapping) to cut out from the input.
+*
+* @returns The resulting string after all specified ranges have been removed from the input.
+*/
+function removeRanges(input, ranges) {
+	if (ranges.length === 0) return input;
+	const SEGMENTS = [];
+	let lastEnd = 0;
+	for (const [START, END] of ranges) {
+		SEGMENTS.push(input.slice(lastEnd, START));
+		lastEnd = END;
+	}
+	SEGMENTS.push(input.slice(lastEnd));
+	return SEGMENTS.join("");
+}
+//#endregion
+//#region src/index.ts
+/**
+* Vite plugin to remove specified attributes from markup files.
+*
+* This plugin scans files with configured extensions and removes
+* attributes as defined in the option list. It also produces
+* accurate source maps to ensure the original line and column numbers
+* are preserved for consumers of the Vite build chain.
+*
+* Files can be ignored based on path token matching. Ignore patterns
+* are resolved relative to the Vite root.
+*
+* @param options - Plugin configuration including which attributes
+*   and file extensions to target, and optional ignore paths.
+*
+* @returns A Vite plugin object that removes attributes during
+*   transformation steps.
+*/
+function removeAttributesPlugin(options) {
+	const OPTIONS = getOptions(options);
+	const IGNORED_PATHS = getIgnoredPaths(OPTIONS);
+	let root = process.cwd();
+	return {
+		name: "remove-attributes",
+		enforce: "pre",
+		configResolved(config) {
+			root = config.root;
+		},
+		transform(code, id) {
+			if (id.startsWith("\0") || !hasExtension(id, OPTIONS.extensions) || hasIgnorePath(toRelativePath(id, root), IGNORED_PATHS)) return null;
+			const RANGES = findAttributeRanges(code, OPTIONS.attributes);
+			if (RANGES.length === 0) return null;
+			return {
+				code: removeRanges(code, RANGES),
+				map: generateRemovalSourceMap(code, RANGES, stripQuery(id))
+			};
+		}
+	};
+}
+//#endregion
+export { removeAttributesPlugin as default };
+
+//# sourceMappingURL=index.js.map