ember-scoped-css 3.1.0 → 3.2.0

package/dist/cjs/all-DJjr6YEx.cjs

@@ -0,0 +1,1534 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_assert = require("node:assert");
+node_assert = __toESM(node_assert);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_module = require("node:module");
+node_module = __toESM(node_module);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let path = require("path");
+path = __toESM(path);
+let unplugin = require("unplugin");
+unplugin = __toESM(unplugin);
+let postcss = require("postcss");
+postcss = __toESM(postcss);
+let postcss_selector_parser = require("postcss-selector-parser");
+postcss_selector_parser = __toESM(postcss_selector_parser);
+let fs = require("fs");
+fs = __toESM(fs);
+let postcss_scss = require("postcss-scss");
+postcss_scss = __toESM(postcss_scss);
+let node_process = require("node:process");
+node_process = __toESM(node_process);
+let ember_template_recast = require("ember-template-recast");
+ember_template_recast = __toESM(ember_template_recast);
+
+//#region src/lib/path/const.js
+/**
+* Join will convert to whatever is appropriate fro the current platform
+*/
+const leadingSlashPath = {
+	embroiderDir: path.default.join("/node_modules/.embroider/"),
+	atEmbroider: path.default.join("/@embroider"),
+	componentsDir: path.default.join("/components/"),
+	templatesDir: path.default.join("/templates/"),
+	routesDir: path.default.join("/routes/"),
+	testem: path.default.join("/testem"),
+	src: path.default.join("/src/"),
+	app: path.default.join("/app/")
+};
+const barePath = { pnpmDir: path.default.join("node_modules/.pnpm") };
+
+//#endregion
+//#region src/lib/path/md5.js
+/**
+* Add integers, wrapping at 2^32.
+* This uses 16-bit operations internally to work around bugs in interpreters.
+*
+* @param {number} x First integer
+* @param {number} y Second integer
+* @returns {number} Sum
+*/
+function safeAdd(x, y) {
+	var lsw = (x & 65535) + (y & 65535);
+	return (x >> 16) + (y >> 16) + (lsw >> 16) << 16 | lsw & 65535;
+}
+/**
+* Bitwise rotate a 32-bit number to the left.
+*
+* @param {number} num 32-bit number
+* @param {number} cnt Rotation count
+* @returns {number} Rotated number
+*/
+function bitRotateLeft(num, cnt) {
+	return num << cnt | num >>> 32 - cnt;
+}
+/**
+* Basic operation the algorithm uses.
+*
+* @param {number} q q
+* @param {number} a a
+* @param {number} b b
+* @param {number} x x
+* @param {number} s s
+* @param {number} t t
+* @returns {number} Result
+*/
+function md5cmn(q, a, b, x, s, t) {
+	return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+}
+/**
+* Basic operation the algorithm uses.
+*
+* @param {number} a a
+* @param {number} b b
+* @param {number} c c
+* @param {number} d d
+* @param {number} x x
+* @param {number} s s
+* @param {number} t t
+* @returns {number} Result
+*/
+function md5ff(a, b, c, d, x, s, t) {
+	return md5cmn(b & c | ~b & d, a, b, x, s, t);
+}
+/**
+* Basic operation the algorithm uses.
+*
+* @param {number} a a
+* @param {number} b b
+* @param {number} c c
+* @param {number} d d
+* @param {number} x x
+* @param {number} s s
+* @param {number} t t
+* @returns {number} Result
+*/
+function md5gg(a, b, c, d, x, s, t) {
+	return md5cmn(b & d | c & ~d, a, b, x, s, t);
+}
+/**
+* Basic operation the algorithm uses.
+*
+* @param {number} a a
+* @param {number} b b
+* @param {number} c c
+* @param {number} d d
+* @param {number} x x
+* @param {number} s s
+* @param {number} t t
+* @returns {number} Result
+*/
+function md5hh(a, b, c, d, x, s, t) {
+	return md5cmn(b ^ c ^ d, a, b, x, s, t);
+}
+/**
+* Basic operation the algorithm uses.
+*
+* @param {number} a a
+* @param {number} b b
+* @param {number} c c
+* @param {number} d d
+* @param {number} x x
+* @param {number} s s
+* @param {number} t t
+* @returns {number} Result
+*/
+function md5ii(a, b, c, d, x, s, t) {
+	return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+/**
+* Calculate the MD5 of an array of little-endian words, and a bit length.
+*
+* @param {Array} x Array of little-endian words
+* @param {number} len Bit length
+* @returns {Array<number>} MD5 Array
+*/
+function binlMD5(x, len) {
+	x[len >> 5] |= 128 << len % 32;
+	x[(len + 64 >>> 9 << 4) + 14] = len;
+	var i;
+	var olda;
+	var oldb;
+	var oldc;
+	var oldd;
+	var a = 1732584193;
+	var b = -271733879;
+	var c = -1732584194;
+	var d = 271733878;
+	for (i = 0; i < x.length; i += 16) {
+		olda = a;
+		oldb = b;
+		oldc = c;
+		oldd = d;
+		a = md5ff(a, b, c, d, x[i], 7, -680876936);
+		d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+		c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+		b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+		a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+		d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+		c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+		b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+		a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+		d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+		c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+		b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+		a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+		d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+		c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+		b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+		a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+		d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+		c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+		b = md5gg(b, c, d, a, x[i], 20, -373897302);
+		a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+		d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+		c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+		b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+		a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+		d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+		c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+		b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+		a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+		d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+		c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+		b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+		a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+		d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+		c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+		b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+		a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+		d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+		c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+		b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+		a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+		d = md5hh(d, a, b, c, x[i], 11, -358537222);
+		c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+		b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+		a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+		d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+		c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+		b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+		a = md5ii(a, b, c, d, x[i], 6, -198630844);
+		d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+		c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+		b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+		a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+		d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+		c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+		b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+		a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+		d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+		c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+		b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+		a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+		d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+		c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+		b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+		a = safeAdd(a, olda);
+		b = safeAdd(b, oldb);
+		c = safeAdd(c, oldc);
+		d = safeAdd(d, oldd);
+	}
+	return [
+		a,
+		b,
+		c,
+		d
+	];
+}
+/**
+* Convert an array of little-endian words to a string
+*
+* @param {Array<number>} input MD5 Array
+* @returns {string} MD5 string
+*/
+function binl2rstr(input) {
+	var i;
+	var output = "";
+	var length32 = input.length * 32;
+	for (i = 0; i < length32; i += 8) output += String.fromCharCode(input[i >> 5] >>> i % 32 & 255);
+	return output;
+}
+/**
+* Convert a raw string to an array of little-endian words
+* Characters >255 have their high-byte silently ignored.
+*
+* @param {string} input Raw input string
+* @returns {Array<number>} Array of little-endian words
+*/
+function rstr2binl(input) {
+	var i;
+	var output = [];
+	output[(input.length >> 2) - 1] = void 0;
+	for (i = 0; i < output.length; i += 1) output[i] = 0;
+	var length8 = input.length * 8;
+	for (i = 0; i < length8; i += 8) output[i >> 5] |= (input.charCodeAt(i / 8) & 255) << i % 32;
+	return output;
+}
+/**
+* Calculate the MD5 of a raw string
+*
+* @param {string} s Input string
+* @returns {string} Raw MD5 string
+*/
+function rstrMD5(s) {
+	return binl2rstr(binlMD5(rstr2binl(s), s.length * 8));
+}
+/**
+* Calculates the HMAC-MD5 of a key and some data (raw strings)
+*
+* @param {string} key HMAC key
+* @param {string} data Raw input string
+* @returns {string} Raw MD5 string
+*/
+function rstrHMACMD5(key, data) {
+	var i;
+	var bkey = rstr2binl(key);
+	var ipad = [];
+	var opad = [];
+	var hash$2;
+	ipad[15] = opad[15] = void 0;
+	if (bkey.length > 16) bkey = binlMD5(bkey, key.length * 8);
+	for (i = 0; i < 16; i += 1) {
+		ipad[i] = bkey[i] ^ 909522486;
+		opad[i] = bkey[i] ^ 1549556828;
+	}
+	hash$2 = binlMD5(ipad.concat(rstr2binl(data)), 512 + data.length * 8);
+	return binl2rstr(binlMD5(opad.concat(hash$2), 640));
+}
+/**
+* Convert a raw string to a hex string
+*
+* @param {string} input Raw input string
+* @returns {string} Hex encoded string
+*/
+function rstr2hex(input) {
+	var hexTab = "0123456789abcdef";
+	var output = "";
+	var x;
+	var i;
+	for (i = 0; i < input.length; i += 1) {
+		x = input.charCodeAt(i);
+		output += hexTab.charAt(x >>> 4 & 15) + hexTab.charAt(x & 15);
+	}
+	return output;
+}
+/**
+* Encode a string as UTF-8
+*
+* @param {string} input Input string
+* @returns {string} UTF8 string
+*/
+function str2rstrUTF8(input) {
+	return unescape(encodeURIComponent(input));
+}
+/**
+* Encodes input string as raw MD5 string
+*
+* @param {string} s Input string
+* @returns {string} Raw MD5 string
+*/
+function rawMD5(s) {
+	return rstrMD5(str2rstrUTF8(s));
+}
+/**
+* Encodes input string as Hex encoded string
+*
+* @param {string} s Input string
+* @returns {string} Hex encoded string
+*/
+function hexMD5(s) {
+	return rstr2hex(rawMD5(s));
+}
+/**
+* Calculates the raw HMAC-MD5 for the given key and data
+*
+* @param {string} k HMAC key
+* @param {string} d Input string
+* @returns {string} Raw MD5 string
+*/
+function rawHMACMD5(k, d) {
+	return rstrHMACMD5(str2rstrUTF8(k), str2rstrUTF8(d));
+}
+/**
+* Calculates the Hex encoded HMAC-MD5 for the given key and data
+*
+* @param {string} k HMAC key
+* @param {string} d Input string
+* @returns {string} Raw MD5 string
+*/
+function hexHMACMD5(k, d) {
+	return rstr2hex(rawHMACMD5(k, d));
+}
+/**
+* Calculates MD5 value for a given string.
+* If a key is provided, calculates the HMAC-MD5 value.
+* Returns a Hex encoded string unless the raw argument is given.
+*
+* @param {string} string Input string
+* @param {string} [key] HMAC key
+* @param {boolean} [raw] Raw output switch
+* @returns {string} MD5 output
+*/
+function md5(string, key, raw) {
+	if (!key) {
+		if (!raw) return hexMD5(string);
+		return rawMD5(string);
+	}
+	if (!raw) return hexHMACMD5(key, string);
+	return rawHMACMD5(key, string);
+}
+
+//#endregion
+//#region src/lib/path/hash-from-module-path.js
+/**
+* The intent of this function is to generate the suffix/postfix for the
+* css classes, based on the module-scoped path name.
+*
+* for example,
+*    hash('my-app/components/foo')
+*  instead of
+*    hash('app/components/foo')
+*
+*  (unless your app name is 'app')
+*
+* @param {string} modulePath
+* @returns {string}
+*/
+function hash$1(modulePath) {
+	return "e" + md5(modulePath).substring(0, 8);
+}
+const hashFromModulePath$1 = hash$1;
+
+//#endregion
+//#region src/lib/path/utils.js
+/**
+*
+* @param {string} filePath
+* @returns {string}
+*/
+function hashFromModulePath(filePath) {
+	return hashFromModulePath$1(forcePosix(filePath));
+}
+/**
+* @param {string} filePath
+*/
+function forcePosix(filePath) {
+	const parsed = node_path.default.parse(filePath);
+	if (parsed.root === "") return filePath.replaceAll(node_path.default.win32.sep, node_path.default.posix.sep);
+	return filePath.replace(/* @__PURE__ */ new RegExp(`^${RegExp.escape(parsed.root)}`), node_path.default.posix.sep).replaceAll(node_path.default.win32.sep, node_path.default.posix.sep);
+}
+let here = require("url").pathToFileURL(__filename).href;
+let ourRequire = globalThis.require ? globalThis.require : here && (0, node_module.createRequire)(here);
+if (!ourRequire) ourRequire = require;
+const IRRELEVANT_PATHS = [barePath.pnpmDir, "__vite-"];
+const UNSUPPORTED_DIRECTORIES = new Set(["tests"]);
+const CWD = process.cwd();
+/**
+* Based on ember's component location conventions,
+* this function will provide a path for where we
+* expect the CSS to live.
+*
+* For co-located structure:
+*   - components/my-component.hbs
+*   - components/my-component.css
+*
+* For nested co-located structure
+*   - components/my-component/foo.hbs
+*   - components/my-component/foo.css
+*
+* For Pods routes structure
+*   - routes/my-route/template.{hbs,js}
+*   - routes/my-route/styles.css
+*
+* Deliberately not supported:
+*   - components w/ pods -- this is deprecated in 5.10
+*
+* @param {string} fileName - the hbs, js, gjs, gts or whatever co-located path.
+* @returns {string} - expected css path
+*/
+function cssPathFor(fileName) {
+	let cssPath = withoutExtension(fileName) + ".css";
+	if (isPod(fileName)) cssPath = fileName.replace(/template\.js$/, "styles.css").replace(/template\.gjs/, "styles.css").replace(/template\.gts/, "styles.css").replace(/template\.hbs/, "styles.css");
+	return cssPath;
+}
+/**
+* Note that components in the "pods" convention will
+* never be supported.
+*
+* @param {string} filePath
+*/
+function isPodTemplate(filePath) {
+	if (filePath.includes(leadingSlashPath.componentsDir)) return false;
+	return filePath.endsWith("template.js") || filePath.endsWith("template.hbs") || filePath.endsWith("template.gjs") || filePath.endsWith("template.gts");
+}
+/**
+* Note that components in the "pods" convention will
+* never be supported.
+*
+* Checks if a file ends with
+* - template.js
+* - template.hbs
+* - styles.css
+*
+* @param {string} filePath
+*/
+function isPod(filePath) {
+	if (filePath.includes(leadingSlashPath.componentsDir)) return false;
+	if (isPodTemplate(filePath)) return true;
+	return filePath.endsWith("styles.css");
+}
+/**
+*
+* @param {string} filePath
+* @returns the same path, but without the extension
+*/
+function withoutExtension(filePath) {
+	let parsed = node_path.default.parse(filePath);
+	return node_path.default.join(parsed.dir, parsed.name);
+}
+/**
+* Examples for fileName
+* - absolute on-disk path
+* - in webpack
+*   - URL-absolute path, starting with /
+*
+* @param {string} fileName
+* @param {{ additionalRoots?: string[]; cwd: string }} options
+* @returns
+*/
+function isRelevantFile(fileName, { additionalRoots, cwd }) {
+	if (fileName.startsWith(leadingSlashPath.testem)) return false;
+	if (fileName.startsWith("\0")) return false;
+	if (node_path.default.isAbsolute(fileName) === false) {
+		if (fileName.match(/^[a-zA-Z]/)) return false;
+	}
+	if (fileName.startsWith(leadingSlashPath.atEmbroider)) return false;
+	if (IRRELEVANT_PATHS.some((i) => fileName.includes(i))) return false;
+	(0, node_assert.default)(cwd, `cwd was not passed to isRelevantFile`);
+	let isInAdditionalRoot = additionalRoots?.some((root) => {
+		let relative = node_path.default.relative(node_path.default.resolve(cwd, root), fileName);
+		return relative !== ".." && !relative.startsWith(`..${node_path.default.sep}`) && !node_path.default.isAbsolute(relative);
+	});
+	let workspace = findWorkspacePath(fileName);
+	let ourWorkspace = findWorkspacePath(cwd);
+	if (workspace !== ourWorkspace && !isInAdditionalRoot) return false;
+	let isInWorkspaceAdditionalRoot = workspace === ourWorkspace && additionalRoots?.some((root) => {
+		if (node_path.default.isAbsolute(root)) return false;
+		let normalizedFileName = `${node_path.default.sep}${node_path.default.normalize(fileName)}${node_path.default.sep}`;
+		let normalizedRoot = `${node_path.default.sep}${node_path.default.normalize(root)}${node_path.default.sep}`;
+		return normalizedFileName.includes(normalizedRoot);
+	});
+	let [, ...parts] = fileName.replace(workspace, "").split(node_path.default.sep).filter(Boolean);
+	if (UNSUPPORTED_DIRECTORIES.has(parts[0])) return false;
+	/**
+	* Mostly pods support.
+	* folks need to opt in to pods (routes), because every pods app can be configured differently
+	*/
+	let roots = [
+		leadingSlashPath.componentsDir,
+		leadingSlashPath.templatesDir,
+		leadingSlashPath.routesDir
+	];
+	if (!isInAdditionalRoot && !isInWorkspaceAdditionalRoot && !roots.some((root) => fileName.includes(root))) return;
+	return true;
+}
+function packageScopedPathToModulePath(packageScopedPath) {
+	/**
+	* *By convention*, `src` is omitted from component paths.
+	* We can reflect the same behavior by replacing src/
+	* with an empty string.
+	*
+	* CSS isn't emitted as a co-located module, but
+	* to keep conventions consistent across languages,
+	* we can pretend it is.
+	*
+	* Any customization beyond removing `src` and `app` is potentially confusing.
+	* If we need further customizations, we'll want to match on `exports` in the
+	* corresponding package.json
+	*/
+	let packageRelative = packageScopedPath.replace(/* @__PURE__ */ new RegExp(`^${RegExp.escape(leadingSlashPath.src)}`), node_path.default.sep);
+	let parsed = node_path.default.parse(packageRelative);
+	if (isPod(packageRelative))
+ /**
+	* For pods, we chop off the whole file, and use the dir name as the "modulePath"
+	*/
+	return parsed.dir;
+	return node_path.default.join(parsed.dir, parsed.name);
+}
+/**
+* returns the app-module path of the source file
+*
+* This assumes normal ember app conventions
+*
+* which is `<package.json#name>/path-to-file`
+*/
+function appPath(sourcePath) {
+	let workspacePath = findWorkspacePath(sourcePath);
+	let name = moduleName(sourcePath);
+	/**
+	*  Under embroider builds, the spec-compliant version of the app
+	* has all the files under a folder which represents the package name,
+	* rather than "app".
+	*/
+	let packageRelative = sourcePath.replace(workspacePath, "");
+	/**
+	* But we also don't want 'app' -- which is present in the v1 addon pipeline
+	*/
+	packageRelative = packageRelative.replace(leadingSlashPath.app, node_path.default.sep);
+	packageRelative = node_path.default.normalize(packageRelative);
+	return `${name}${packageScopedPathToModulePath(packageRelative)}`;
+}
+/**
+* To avoid hitting the filesysetm, we'll store all found
+* project paths bere, so we can, in memory,
+* get the folder where a package.json exists, rather than
+* hit the file system every time.
+*/
+const SEEN = /* @__PURE__ */ new Set();
+function getSeen(sourcePath) {
+	if (SEEN.has(sourcePath)) return sourcePath;
+	let parts = sourcePath.split(node_path.default.sep);
+	for (let i = parts.length - 1; i > 1; i--) {
+		let toCheck = parts.slice(0, i).join(node_path.default.sep);
+		if (SEEN.has(toCheck)) return toCheck;
+	}
+}
+function findWorkspacePath(sourcePath, options) {
+	let cwd = options?.cwd ?? CWD;
+	if (sourcePath.endsWith(node_path.default.sep)) sourcePath = sourcePath.replace(/* @__PURE__ */ new RegExp(`${RegExp.escape(node_path.default.sep)}$`), "");
+	let seen = getSeen(sourcePath);
+	if (seen) return seen;
+	let candidatePath = node_path.default.join(sourcePath, "package.json");
+	if (node_fs.default.existsSync(candidatePath)) return sourcePath;
+	const packageJsonPath = findPackageJsonUp(sourcePath, { cwd });
+	if (!packageJsonPath) throw new Error(`Could not determine project for ${sourcePath}`);
+	const workspacePath = node_path.default.dirname(packageJsonPath);
+	SEEN.add(workspacePath);
+	return workspacePath;
+}
+function findPackageJsonUp(startPath, options) {
+	let cwd = options?.cwd ?? CWD;
+	let parts = startPath.split(node_path.default.sep);
+	for (let i = parts.length - 1; i > 1; i--) {
+		let toCheck = parts.slice(0, i).join(node_path.default.sep);
+		let packageJson = node_path.default.join(toCheck, "package.json");
+		if (node_fs.default.existsSync(packageJson)) return packageJson;
+		if (toCheck === cwd) break;
+	}
+	return null;
+}
+const MANIFEST_CACHE = /* @__PURE__ */ new Map();
+/**
+* Will return the package.json#name, or config/environment#moudlePrefix (if v1 app)
+*
+* @param {string} sourcePath
+*/
+function moduleName(sourcePath) {
+	return getManifest(findWorkspacePath(sourcePath)).name;
+}
+/**
+* @param {string} workspace
+*/
+function getManifest(workspace) {
+	let existing = MANIFEST_CACHE.get(workspace);
+	if (existing) return existing;
+	let content = node_fs.default.readFileSync(node_path.default.join(workspace, "package.json")).toString();
+	let json = JSON.parse(content);
+	MANIFEST_CACHE.set(workspace, json);
+	return json;
+}
+
+//#endregion
+//#region src/lib/renameClass.js
+/**
+* Splits a space-separated class list (the value of a `class` attribute or of
+* a `[class="..."]` selector) into its individual class names.
+*
+* @param {string} classList
+* @returns {string[]}
+*/
+function splitClassList(classList) {
+	return classList.split(/\s+/).filter(Boolean);
+}
+/**
+*
+* @param {string} className
+* @param {string} postfix
+* @param {Set<string>} [classesInCss]
+* @returns
+*/
+function renameClass(className, postfix, classesInCss) {
+	const renamedClasses = splitClassList(className).map((c) => {
+		if (!classesInCss || classesInCss.has(c)) {
+			if (c.endsWith(postfix)) return c;
+			return c + "_" + postfix;
+		}
+		return c;
+	}).join(" ");
+	return className.replace(className.trimStart().trimEnd(), renamedClasses);
+}
+
+//#endregion
+//#region src/build/babel-plugin.js
+function _isRelevantFile(state, cwd) {
+	let fileName = state.file.opts.filename;
+	let additionalRoots = state.opts?.additionalRoots;
+	return isRelevantFile(fileName, {
+		additionalRoots,
+		cwd
+	});
+}
+/**
+* @param {any} env - babel plugin env, env.types is most commonly used (esp in TS)
+* @param {object} options - the options for scoped-css -- this is also available in each visitor's state.opts
+* @param {string} workingDirectory
+*/
+const scopedCSS$1 = (config) => (env, options, workingDirectory) => {
+	options = {
+		...config,
+		...options
+	};
+	/**
+	* This babel plugin does two things:
+	* - removes the import of scopedClass, if it exists
+	*   - if scopedClass was imported, it is removed from any component's "scope bag"
+	*     (the scope bag being a low-level object used for passing what is "in scope" for a component)
+	*/
+	return { visitor: {
+		Program: { enter(path$8, state) {
+			if (!_isRelevantFile(state, workingDirectory)) {
+				state.canSkip = true;
+				return;
+			}
+			state.postfix = hashFromModulePath(appPath(state.filename));
+		} },
+		ImportDeclaration(path$8, state) {
+			if (state.canSkip) return;
+			if (path$8.node.source.value === "ember-scoped-css") {
+				let specifier = path$8.node.specifiers.find((x) => x.imported.name === "scopedClass");
+				if (specifier) state.file.opts.importedScopedClass = specifier.local.name;
+				if (specifier.local.name !== "scopedClass") throw new Error(`The scopedClass import is a psuedo-helper, and may not be renamed as it is removed at build time.`);
+				path$8.remove();
+			}
+		},
+		CallExpression(path$8, state) {
+			if (state.canSkip) return;
+			if (path$8.node.callee.type === "Identifier" && path$8.node.callee.name === state.file.opts?.importedScopedClass) {
+				if (path$8.node.arguments.length !== 1 || path$8.node.arguments[0].type !== "StringLiteral") throw new Error(`The scopedClass helper only accepts a single, non-dynamic, string literal argument.`);
+				const original = path$8.node.arguments[0].value;
+				const renamed = renameClass(original, state.postfix, new Set([original]));
+				const transformedString = env.types.stringLiteral(renamed);
+				path$8.replaceWith(transformedString);
+			}
+		},
+		ObjectProperty(path$8, state) {
+			if (!state.file.opts?.importedScopedClass) return;
+			if (path$8.node.value.type === "Identifier" && path$8.node.value.name === state.file.opts?.importedScopedClass) path$8.remove();
+		}
+	} };
+};
+
+//#endregion
+//#region src/lib/css/utils.js
+/**
+* @param {string} css
+* @return {string} hashed down version of the CSS for disambiguating
+*/
+function hash(css) {
+	return `css-${md5(css)}`;
+}
+/**
+* Attribute selectors are scoped with one of two strategies:
+*
+* - **renamed value**: class-targeting selectors whose value names real
+*   class(es) (`[class="foo"]`, `[class~="foo"]`) are scoped by renaming the
+*   value the same way `.foo` is renamed to `.foo_postfix`. The renamed token
+*   is unique per file, so nothing else is needed.
+* - **postfix class**: every other attribute selector keeps its discriminator
+*   and is scoped by the generated postfix class — appended to the selector
+*   in the CSS and added to matching elements in the template (the same
+*   strategy bare tag selectors use: `div` becomes `div.postfix`).
+*
+* This predicate decides between the two. It is shared by the CSS rewrite
+* (which renames the selector value) and by discovery in this file (which
+* registers the value's class names for template renaming) so both sides
+* always classify a selector the same way.
+*
+* @param {import('postcss-selector-parser').Attribute} node
+* @returns {boolean}
+*/
+function isRenamedClassAttribute(node) {
+	return node.attribute === "class" && (node.operator === "=" || node.operator === "~=") && Boolean(node.value);
+}
+function isInsideGlobal(node, func) {
+	const parent = node.parent;
+	if (!parent) return false;
+	if (parent.type === "pseudo" && parent.value === ":global") return true;
+	return isInsideGlobal(parent, func);
+}
+/**
+* @param {string} cssPath path to a CSS file
+*/
+function getCSSInfo(cssPath) {
+	if (!(0, fs.existsSync)(cssPath)) return null;
+	return getCSSContentInfo((0, fs.readFileSync)(cssPath, "utf8"));
+}
+/**
+* We use this function to check each class used in the template
+* to see if we need to leave it alone or transform it
+*
+* @param {string} css the CSS's contents
+* @param {string} [lang] optional language hint (e.g. 'scss', 'sass', 'less')
+* @return {{ classes: Set<string>, tags: Set<string>, attributes: Set<string>, css: string, id: string }}
+*/
+function getCSSContentInfo(css, lang) {
+	const classes = /* @__PURE__ */ new Set();
+	const tags = /* @__PURE__ */ new Set();
+	const attributes = /* @__PURE__ */ new Set();
+	const parseOptions = lang === "scss" || lang === "sass" ? { syntax: postcss_scss.default } : {};
+	const ast = postcss.default.parse(css, parseOptions);
+	const isScss = lang === "scss" || lang === "sass";
+	ast.walk((node) => {
+		if (node.type === "rule") collectSelectorInfo(isScss ? resolveNestedSassSelector(node) : node.selector, classes, tags, attributes);
+	});
+	return {
+		classes,
+		tags,
+		attributes,
+		css,
+		id: hash(css)
+	};
+}
+/**
+* Resolves a nested SCSS selector by substituting `&` with the fully-resolved
+* parent selector, recursively. This converts e.g. `&--modifier` (child of
+* `.block`) into `.block--modifier`, and handles arbitrary nesting depth so
+* that `&--modifier` inside `&--modifier` inside `.block` yields
+* `.block--modifier--modifier`.
+*
+* @param {import('postcss').Rule} node
+* @return {string}
+*/
+function resolveNestedSassSelector(node) {
+	const { selector } = node;
+	if (!selector.includes("&")) return selector;
+	const parent = node.parent;
+	if (!parent || parent.type !== "rule") return selector;
+	const resolvedParent = resolveNestedSassSelector(parent);
+	return selector.replace(/&/g, resolvedParent);
+}
+function collectSelectorInfo(sel, classes, tags, attributes) {
+	const transform = (sls) => {
+		sls.walk((selector) => {
+			if (isInsideGlobal(selector)) return;
+			if (selector.type === "class") classes.add(selector.value);
+			else if (selector.type === "tag") tags.add(selector.value);
+			else if (selector.type === "attribute") if (isRenamedClassAttribute(selector)) for (let token of splitClassList(selector.value)) classes.add(token);
+			else attributes.add(selector.attribute.toLowerCase());
+		});
+	};
+	(0, postcss_selector_parser.default)(transform).processSync(sel);
+}
+
+//#endregion
+//#region src/lib/css/rewrite.js
+const SEP$1 = "__";
+function isRule(node) {
+	return node.type === "rule";
+}
+function isDeclaration(node) {
+	return node.type === "decl";
+}
+/**
+* NOTE: "keyframes" is a singular definition, in that it's a block containing keyframes
+*       using `@keyframes {}` with only one thing on the inside doesn't make sense.
+*/
+function rewriteReferenceable(node, postfix) {
+	let originalName = node.params;
+	let postfixedName = node.params + SEP$1 + postfix;
+	node.params = postfixedName;
+	return {
+		originalName,
+		postfixedName
+	};
+}
+/**
+* Walk left and right from `node` within its compound selector (bounded by
+* combinators) to see if the postfix class has already been added. Used to add
+* the postfix class at most once per compound, e.g. `input[type="text"]`
+* becomes `input.postfix[type="text"]`, not `input.postfix[type="text"].postfix`.
+*/
+function compoundHasPostfixClass(node, postfix) {
+	const siblings = node.parent.nodes;
+	const index = siblings.indexOf(node);
+	for (let i = index; i >= 0; i--) {
+		if (siblings[i].type === "combinator") break;
+		if (siblings[i].type === "class" && siblings[i].value === postfix) return true;
+	}
+	for (let i = index + 1; i < siblings.length; i++) {
+		if (siblings[i].type === "combinator") break;
+		if (siblings[i].type === "class" && siblings[i].value === postfix) return true;
+	}
+	return false;
+}
+function addPostfixClass(node, postfix) {
+	if (compoundHasPostfixClass(node, postfix)) return;
+	node.parent.insertAfter(node, postcss_selector_parser.default.className({ value: postfix }));
+}
+function rewriteSelector(sel, postfix) {
+	const transform = (selectors) => {
+		const needsPostfixClass = [];
+		selectors.walk((selector) => {
+			if (isInsideGlobal(selector)) return;
+			if (selector.type === "psuedo") return;
+			if (isNthOfType(selector)) return;
+			if (selector.type === "class") selector.value += "_" + postfix;
+			else if (selector.type === "tag") needsPostfixClass.push(selector);
+			else if (selector.type === "attribute") if (isRenamedClassAttribute(selector)) {
+				selector.value = renameClass(selector.value, postfix);
+				if (!selector.quoteMark) selector.quoteMark = "\"";
+			} else needsPostfixClass.push(selector);
+		});
+		for (const node of needsPostfixClass) addPostfixClass(node, postfix);
+		selectors.walk((selector) => {
+			if (selector.type === "pseudo" && selector.value === ":global") selector.replaceWith(...selector.nodes);
+		});
+	};
+	return (0, postcss_selector_parser.default)(transform).processSync(sel);
+}
+function isNthOfType(node) {
+	if (!node) return false;
+	return node.parent?.value === ":nth-of-type" || isNthOfType(node.parent);
+}
+function isInsideKeyframes(node) {
+	const parent = node.parent;
+	if (!parent) return false;
+	if (parent.type === "atrule" && parent.name === "keyframes") return true;
+	return isInsideKeyframes(parent);
+}
+function rewriteCss(css, postfix, fileName, layerName) {
+	const ast = postcss.default.parse(css);
+	/**
+	* kind => originalName => postfixedName
+	* @type {{ [kind: string]: { [originalName: string]: string }}}
+	*/
+	const referenceables = {
+		keyframes: {},
+		"counter-style": {},
+		"position-try": {},
+		property: {}
+	};
+	const availableReferenceables = new Set(Object.keys(referenceables));
+	function isReferenceable(node) {
+		if (node.type !== "atrule") return;
+		return availableReferenceables.has(node.name);
+	}
+	function updateDirectReferences(node) {
+		if (!node.value) return;
+		for (let [, map] of Object.entries(referenceables)) if (map[node.value]) node.value = map[node.value];
+	}
+	function updateShorthandContents(node) {
+		if (node.prop === "animation") {
+			let match = node.value.split(" ").filter((x) => referenceables.keyframes[x]);
+			if (match.length) match.forEach((x) => {
+				let replacement = referenceables.keyframes[x];
+				if (!replacement) return;
+				node.value = node.value.replace(x, replacement);
+			});
+		}
+		for (let [lookFor, replaceWith] of Object.entries(referenceables.property)) {
+			let lookForVar = `var(${lookFor})`;
+			let replaceWithVar = `var(${replaceWith})`;
+			node.value = node.value.replace(lookForVar, replaceWithVar);
+		}
+	}
+	/**
+	* We have to do two passes:
+	* 1. postfix all the referenceable syntax
+	* 2. postfix as normal, but also checking values of CSS properties
+	*    that could match postfixed referenceables from step 1
+	*/
+	ast.walk((node) => {
+		/**
+		* @keyframes, @counter-style, etc
+		*/
+		if (isReferenceable(node)) {
+			let name = node.name;
+			let { originalName, postfixedName } = rewriteReferenceable(node, postfix);
+			referenceables[name][originalName] = postfixedName;
+			return;
+		}
+	});
+	ast.walk((node) => {
+		if (isDeclaration(node)) {
+			updateDirectReferences(node);
+			updateShorthandContents(node);
+			return;
+		}
+		if (isRule(node)) {
+			/**
+			* The inner-contents of a keyframe are percentages, rather than selectors
+			*/
+			if (isInsideKeyframes(node)) return;
+			node.selector = rewriteSelector(node.selector, postfix);
+			return;
+		}
+	});
+	const rewrittenCss = ast.toString();
+	return [
+		`/* ${fileName} */`,
+		layerName ? `@layer ${layerName} {` : "",
+		rewrittenCss.trimEnd(),
+		layerName ? `}` : ""
+	].filter(Boolean).join("\n") + "\n";
+}
+
+//#endregion
+//#region src/lib/request.js
+const KEY = "ember-scoped.css";
+const SEP = "___";
+const request = {
+	is: {
+		inline(request$1) {
+			return request$1.includes(KEY);
+		},
+		colocated(request$1) {
+			return request$1.includes(".css?scoped=");
+		}
+	},
+	inline: {
+		create(cssHash, postfix, cssContents, lang) {
+			let url = `./${postfix}${SEP}${cssHash}.${KEY}?css=${encodeURIComponent(cssContents)}`;
+			if (lang) url += `&lang=${encodeURIComponent(lang)}`;
+			return url;
+		},
+		decode(request$1) {
+			let [left, qps] = request$1.split("?");
+			left = left.slice(2).replace(`.${KEY}`, "");
+			let [postfix, hash$2] = left.split(SEP);
+			let search = new URLSearchParams(qps);
+			return {
+				hash: hash$2,
+				postfix,
+				css: search.get("css"),
+				from: search.get("from"),
+				lang: search.get("lang")
+			};
+		}
+	},
+	colocated: {
+		create(cssHash, postfix, filePath) {
+			return `./${node_path.default.basename(filePath)}?scoped=${postfix}&cssHash=${cssHash}`;
+		},
+		decode(request$1) {
+			const [fileName, qs] = request$1.split("?");
+			const search = new URLSearchParams(qs);
+			return {
+				fileName,
+				cssHash: search.get("cssHash"),
+				postfix: search.get("scoped")
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/build/unplugin-colocated.js
+const META$1 = "scoped-css:colocated";
+/** File extensions that Vite can preprocess via its CSS preprocessor pipeline */
+const PREPROCESSED_EXTENSIONS = new Set([
+	".scss",
+	".sass",
+	".less",
+	".styl",
+	".stylus"
+]);
+/**
+* Plugin for supporting colocated styles
+*
+* e.g.:
+*  src/components/my-component.js
+*  src/components/my-component.css
+*/
+function colocated(options = {}) {
+	const CWD$1 = process.cwd();
+	/** @type {import('vite').ResolvedConfig | undefined} */
+	let viteConfig;
+	/** @type {((code: string, filename: string, config: unknown) => Promise<{ code: string }>) | undefined} */
+	let preprocessCSS;
+	/**
+	*
+	* @param {string} id the request id / what was imported
+	* @param {string} filePath  path on disk
+	* @returns
+	*/
+	function buildResponse(id, filePath) {
+		const parsed = request.colocated.decode(id);
+		const relativeFilePath = node_path.default.relative(CWD$1, filePath);
+		return {
+			id: filePath,
+			meta: { [META$1]: {
+				postfix: parsed.postfix,
+				fileName: relativeFilePath,
+				fullPath: filePath
+			} }
+		};
+	}
+	return {
+		name: "ember-scoped-css:colocated",
+		resolveId(id, importer) {
+			if (request.is.colocated(id)) {
+				const parsed = request.colocated.decode(id);
+				return buildResponse(id, node_path.default.resolve(node_path.default.dirname(importer), node_path.default.basename(parsed.fileName)));
+			}
+		},
+		load(id) {
+			const meta = this.getModuleInfo(id)?.meta?.[META$1];
+			if (meta) {
+				this.addWatchFile(meta.fullPath);
+				return rewriteCss((0, node_fs.readFileSync)(meta.fullPath, "utf-8"), meta.postfix, meta.fileName, options.layerName);
+			}
+		},
+		vite: {
+			async configResolved(config) {
+				viteConfig = config;
+				try {
+					preprocessCSS = (await import((0, node_module.createRequire)(node_path.default.join(config.root, "package.json")).resolve("vite"))).preprocessCSS;
+				} catch {}
+			},
+			async load(id) {
+				if (request.is.colocated(id)) {
+					const parsed = request.colocated.decode(id);
+					let code = (0, node_fs.readFileSync)(parsed.fileName, "utf-8");
+					let relativeFilePath = node_path.default.relative(CWD$1, parsed.fileName);
+					const ext = node_path.default.extname(parsed.fileName).toLowerCase();
+					if (PREPROCESSED_EXTENSIONS.has(ext)) {
+						if (!viteConfig || !preprocessCSS) throw new Error(`[ember-scoped-css] Colocated CSS file with extension '${ext}' requires Vite. CSS preprocessing is only supported in Vite builds.`);
+						code = (await preprocessCSS(code, parsed.fileName, viteConfig)).code;
+					}
+					return rewriteCss(code, parsed.postfix, relativeFilePath, options.layerName);
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/build/unplugin-inline.js
+const META = "scoped-css:inline";
+/**
+* Plugin for supporting the styles from
+*
+* <template>
+*   <style>...</style>
+* </template>
+*
+* This plugin can't have HMR for CSS because changes to the CSS content alters the template content
+*/
+function inline(options = {}) {
+	const CWD$1 = process.cwd();
+	/** @type {import('vite').ResolvedConfig | undefined} */
+	let viteConfig;
+	/** @type {((code: string, filename: string, config: unknown) => Promise<{ code: string }>) | undefined} */
+	let preprocessCSS;
+	/**
+	* @param {string} id the request id / what was imported
+	*/
+	function buildResponse(id, filePath) {
+		const parsed = request.inline.decode(id);
+		const relativeFilePath = node_path.default.relative(CWD$1, filePath);
+		return {
+			id: filePath.split("?")[0],
+			meta: { [META]: {
+				rawCss: parsed.css,
+				postfix: parsed.postfix,
+				fileName: relativeFilePath,
+				lang: parsed.lang
+			} }
+		};
+	}
+	return {
+		name: "ember-scoped-css:inline",
+		resolveId(id, importer) {
+			if (request.is.inline(id)) {
+				const parsed = request.inline.decode(id);
+				return buildResponse(id, node_path.default.resolve(node_path.default.dirname(importer), `${node_path.default.basename(importer, node_path.default.extname(importer))}-${parsed.hash}.css`));
+			}
+		},
+		async load(id) {
+			const meta = this.getModuleInfo(id)?.meta?.[META];
+			if (meta) {
+				let rawCss = meta.rawCss;
+				if (meta.lang) {
+					if (!viteConfig || !preprocessCSS) throw new Error(`[ember-scoped-css] <style scoped lang="${meta.lang}"> requires Vite. CSS preprocessing via the 'lang' attribute is only supported in Vite builds.`);
+					const fakeFilename = `${meta.fileName}.${meta.lang}`;
+					rawCss = (await preprocessCSS(rawCss, fakeFilename, viteConfig)).code;
+				}
+				return rewriteCss(rawCss, meta.postfix, `<inline>/${meta.fileName}`, options.layerName);
+			}
+		},
+		vite: { async configResolved(config) {
+			viteConfig = config;
+			try {
+				preprocessCSS = (await import((0, node_module.createRequire)(node_path.default.join(config.root, "package.json")).resolve("vite"))).preprocessCSS;
+			} catch {}
+		} }
+	};
+}
+
+//#endregion
+//#region src/build/scoped-css-unplugin.js
+/**
+* The plugin that handles CSS requests for `<style>` elements and transforms
+* for existing files
+*
+* vite: CSS files are resolved by vite. We use their resolver to also get
+*       HMR. That is, for all non-physical CSS files, we extend vite by our
+*       resolver and also can enrich metadata to it (for better debugging)
+*/
+const unplugin$1 = (0, unplugin.createUnplugin)((options = {}) => {
+	return [colocated(options), inline(options)];
+});
+
+//#endregion
+//#region src/lib/path/template-transform-paths.js
+/**
+* template plugins do not hand us the correct file path.
+* additionally, we may not be able to rely on this data in the future,
+* so this functions acts as a means of normalizing _whatever_ we're given
+* in the future.
+*
+* @param {string} filename
+* @returns {string} the absolute path to the file
+*/
+function fixFilename(filename) {
+	let fileName = filename;
+	let workspace = findWorkspacePath(fileName);
+	/**
+	* ember-source 5.8:
+	* - the filename looks like an absolute path, but swapped out the 'app' part of the path
+	*   with the module name, so the file paths never exist on disk
+	*
+	* - in vite apps:
+	*   the 'app' part _may_ be `src`, so we also need to ensure that `src` is excluded as well
+	*/
+	let hasAppDir = fileName.includes(node_path.default.join(workspace, "app"));
+	let hasSrcDir = fileName.includes(node_path.default.join(workspace, "src"));
+	if (!(hasAppDir || hasSrcDir) && !fileName.includes(leadingSlashPath.embroiderDir)) {
+		let [maybeScope, ...rest] = fileName.replace(workspace, "").split(node_path.default.sep).filter(Boolean);
+		let parts = rest;
+		if (maybeScope.startsWith("@")) {
+			let [, ...rester] = rest;
+			parts = rester;
+		}
+		let relative = node_path.default.join(...parts);
+		return node_path.default.join(workspace, "app", relative);
+	}
+	if (!fileName.includes(workspace)) return fileName;
+	return fileName;
+}
+
+//#endregion
+//#region src/lib/rewriteHbs.js
+/**
+* Whether an element may carry an attribute that appears in a scoped
+* attribute selector. This includes component invocations: a component
+* receives the postfix class through its `...attributes` the same way it
+* receives the matched attribute, so `[type="text"]` scopes
+* `<Foo type="text">` just as it scopes `<input type="text">`.
+*
+* An element that spreads `...attributes` can receive any attribute from its
+* caller at runtime, so it counts as long as the CSS scopes by attribute at
+* all — the preserved attribute selector still decides which rules actually
+* apply.
+*
+* `attributes` comes from parsing the CSS, so it can only contain valid
+* attribute-selector names — `@args` can never be in it and needs no special
+* handling.
+*
+* Names in `attributes` are lowercased at discovery (CSS matches HTML
+* attribute names case-insensitively), so compare lowercased.
+*/
+function elementHasScopedAttribute(node, attributes) {
+	if (attributes.size === 0) return false;
+	return node.attributes.some((attr) => attr.name === "...attributes" || attributes.has(attr.name.toLowerCase()));
+}
+function templatePlugin({ classes, tags, attributes, postfix }) {
+	let stack = [];
+	let scopedClassCandidates = ["scoped-class", "scopedClass"];
+	function isScopedClass(str) {
+		if (!str) return false;
+		return scopedClassCandidates.some((candidate) => candidate === str);
+	}
+	return {
+		AttrNode(node) {
+			if (node.name === "class") {
+				if (node.value.type === "TextNode" && node.value.chars) {
+					const renamedClass = renameClass(node.value.chars, postfix, classes);
+					node.value.chars = renamedClass;
+				} else if (node.value.type === "ConcatStatement") {
+					for (let part of node.value.parts) if (part.type === "TextNode" && part.chars) part.chars = renameClass(part.chars, postfix, classes);
+					else if (part.type === "MustacheStatement") ember_template_recast.traverse(part, { StringLiteral(node$1) {
+						node$1.value = renameClass(node$1.value, postfix, classes);
+					} });
+				}
+			}
+		},
+		ElementNode(node) {
+			if (!(tags.has(node.tag) || elementHasScopedAttribute(node, attributes))) return;
+			const classAttr = node.attributes.find((attr) => attr.name === "class");
+			if (!classAttr) node.attributes.push(ember_template_recast.builders.attr("class", ember_template_recast.builders.text(postfix)));
+			else if (classAttr.value.type === "TextNode") classAttr.value.chars += " " + postfix;
+			else if (classAttr.value.type === "ConcatStatement") classAttr.value.parts.push(ember_template_recast.builders.text(" " + postfix));
+			else {
+				classAttr.value = ember_template_recast.builders.concat([classAttr.value, ember_template_recast.builders.text(" " + postfix)]);
+				classAttr.quoteType = "\"";
+			}
+		},
+		All: {
+			enter(node) {
+				stack.push(node);
+			},
+			exit() {
+				stack.pop();
+			}
+		},
+		MustacheStatement(node) {
+			let cssClass;
+			if (isScopedClass(getValue(node.path)) && node.params?.length === 1 && node.params[0].type === "StringLiteral") cssClass = node.params[0].value;
+			if (isScopedClass(getValue(node.path?.path)) && node.path?.params?.length === 1 && node.path?.params[0].type === "StringLiteral") cssClass = node.path.params[0].value;
+			if (cssClass) {
+				const textNode = ember_template_recast.builders.text(renameClass(cssClass, postfix));
+				const parent = stack[stack.length - 1];
+				if (parent?.type === "AttrNode") parent.quoteType = "\"";
+				return textNode;
+			}
+		},
+		SubExpression(node) {
+			if (isScopedClass(getValue(node.path)) && node.params?.length === 1 && node.params[0].type === "StringLiteral") {
+				const cssClass = node.params[0].value;
+				return ember_template_recast.builders.literal("StringLiteral", renameClass(cssClass, postfix));
+			}
+		}
+	};
+}
+function getValue(path$8) {
+	if (!path$8) return;
+	if ("value" in path$8) return path$8.value;
+	/**
+	* Deprecated in ember 5.9+
+	* (so we use the above for newer embers)
+	*/
+	return path$8.original;
+}
+
+//#endregion
+//#region src/build/template-plugin.js
+const noopPlugin = {
+	name: "ember-scoped-css:noop",
+	visitor: {}
+};
+/**
+* @returns {ASTPlugin}
+*/
+function createPlugin(config) {
+	/**
+	*
+	* @param {ASTPluginEnvironment} env
+	*/
+	return function scopedCss(env) {
+		let cwd = node_process.default.cwd();
+		if (!isRelevantFile(env.filename, {
+			additionalRoots: config.additionalRoots,
+			cwd
+		})) return noopPlugin;
+		let absolutePath = fixFilename(env.filename);
+		let postfix = hashFromModulePath(appPath(absolutePath));
+		/**
+		* The list of naked tag selectors found in the CSS
+		*
+		* @type {Set<string>}
+		*/
+		let scopedTags = /* @__PURE__ */ new Set();
+		/**
+		* The list of classes found in the CSS
+		*
+		* @type {Set<string>}
+		*/
+		let scopedClasses = /* @__PURE__ */ new Set();
+		/**
+		* The attribute names found in attribute selectors in the CSS, used to
+		* mark matching elements with the scope class.
+		*
+		* @type {Set<string>}
+		*/
+		let scopedAttributes = /* @__PURE__ */ new Set();
+		/**
+		* @param {{ tags: Set<string>; classes: Set<string>; attributes: Set<string> }} info
+		*/
+		function addInfo(info$1) {
+			for (let item of info$1.tags) scopedTags.add(item);
+			for (let item of info$1.classes) scopedClasses.add(item);
+			for (let item of info$1.attributes) scopedAttributes.add(item);
+		}
+		let cssPath = cssPathFor(absolutePath);
+		let info = getCSSInfo(cssPath);
+		let localCssPath = forcePosix(cssPath.replace(cwd + node_path.default.sep, ""));
+		/**
+		* This will be falsey if we don't have a co-located CSS file.
+		* We'll still want to check for embedded <style scoped> tags though.
+		*/
+		if (info) {
+			addInfo(info);
+			let cssRequest = request.colocated.create(info.id, postfix, localCssPath);
+			/**
+			* With this we don't need a JS plugin
+			*/
+			env.meta.jsutils.importForSideEffect(cssRequest);
+		}
+		let visitors = templatePlugin({
+			classes: scopedClasses,
+			tags: scopedTags,
+			attributes: scopedAttributes,
+			postfix
+		});
+		return {
+			name: "ember-scoped-css:template-plugin",
+			visitor: {
+				...visitors,
+				Template(node) {
+					/**
+					* We only allow a scoped <style> at the root
+					*/
+					let styleTag = node.body.find((n) => n.type === "ElementNode" && n.tag === "style");
+					if (hasScopedAttribute(styleTag)) {
+						let css = textContent(styleTag);
+						let lang = getLangAttribute(styleTag);
+						let info$1 = getCSSContentInfo(css, lang);
+						addInfo(info$1);
+						if (hasInlineAttributeWithoutLang(styleTag))
+ /**
+						* This will be handled in ElementNode traversal
+						*/
+						return;
+						if (lang)
+ /**
+						* For <style scoped inline lang="..."> we cannot preprocess at Babel-time
+						* (preprocessing is async and requires Vite's ResolvedConfig).
+						* Remove the tag and inject via virtual CSS module and warn user.
+						*/
+						console.warn(`[ember-scoped-css] <style scoped inline lang="${lang}"> is not supported (preprocessing is async and cannot run at Babel-time). Downgrading to non-inline: the style tag will be removed and injected as a virtual CSS module.`);
+						let cssRequest = request.inline.create(info$1.id, postfix, css, lang);
+						env.meta.jsutils.importForSideEffect(cssRequest);
+					}
+				},
+				AttrNode(...args) {
+					return visitors.AttrNode(...args);
+				},
+				ElementNode(node, walker) {
+					visitors.ElementNode(node, walker);
+					if (hasScopedAttribute(node)) {
+						if (walker.parent?.node.type !== "Template") throw new Error("<style scoped> tags must be at the root of the template, they cannot be nested");
+						if (hasInlineAttributeWithoutLang(node)) {
+							let scopedText = rewriteCss(textContent(node), postfix, localCssPath, config.layerName);
+							/**
+							* Traverse this and allow interpolation
+							*/
+							node.children = [env.syntax.builders.text(scopedText)];
+							return;
+						}
+						return null;
+					}
+					if (hasInlineAttributeWithoutLang(node)) throw new Error(`<style inline> is not valid. Please add the scoped attribute: <style scoped inline>`);
+				},
+				MustacheStatement(...args) {
+					return visitors.MustacheStatement(...args);
+				},
+				SubExpression(...args) {
+					return visitors.SubExpression(...args);
+				}
+			}
+		};
+	};
+}
+/**
+* Thanks, CardStack and @ef4 for this code.
+*/
+const SCOPED_ATTRIBUTE_NAME = "scoped";
+const INLINE_ATTRIBUTE_NAME = "inline";
+const LANG_ATTRIBUTE_NAME = "lang";
+function hasScopedAttribute(node) {
+	if (!node) return;
+	if (node.tag !== "style") return;
+	if (node.type !== "ElementNode") return;
+	return node.attributes.some((attribute) => attribute.name === SCOPED_ATTRIBUTE_NAME);
+}
+function hasInlineAttributeWithoutLang(node) {
+	if (!node) return;
+	if (node.tag !== "style") return;
+	if (node.type !== "ElementNode") return;
+	if (getLangAttribute(node)) return false;
+	return node.attributes.some((attribute) => attribute.name === INLINE_ATTRIBUTE_NAME);
+}
+/**
+* Returns the value of the `lang` attribute on a `<style>` node, or null if absent.
+*
+* @param {object} node
+* @returns {string | null}
+*/
+function getLangAttribute(node) {
+	if (!node) return null;
+	if (node.tag !== "style") return null;
+	if (node.type !== "ElementNode") return null;
+	const attr = node.attributes.find((attribute) => attribute.name === LANG_ATTRIBUTE_NAME);
+	if (!attr) return null;
+	const value = attr.value;
+	if (value?.type === "TextNode") return value.chars || null;
+	return null;
+}
+function textContent(node) {
+	return node.children.filter((c) => c.type === "TextNode").map((c) => c.chars).join("");
+}
+
+//#endregion
+//#region src/build/public-exports/all.js
+const scopedCSS = {
+	vite: unplugin$1.vite,
+	rollup: unplugin$1.rollup,
+	babel: scopedCSS$1,
+	template: createPlugin
+};
+
+//#endregion
+Object.defineProperty(exports, 'scopedCSS', {
+  enumerable: true,
+  get: function () {
+    return scopedCSS;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"all-DJjr6YEx.cjs","names":["hash","hash","hashFromModulePath","hashPosixModulePath","path","fsSync","scopedCSS","path","scssSyntax","SEP","parser","request","hash","path","META","CWD","path","CWD","path","unplugin","path","node","recast","path","process","info","path","unplugin","babel.scopedCSS","template.createPlugin"],"sources":["../../src/lib/path/const.js","../../src/lib/path/md5.js","../../src/lib/path/hash-from-module-path.js","../../src/lib/path/utils.js","../../src/lib/renameClass.js","../../src/build/babel-plugin.js","../../src/lib/css/utils.js","../../src/lib/css/rewrite.js","../../src/lib/request.js","../../src/build/unplugin-colocated.js","../../src/build/unplugin-inline.js","../../src/build/scoped-css-unplugin.js","../../src/lib/path/template-transform-paths.js","../../src/lib/rewriteHbs.js","../../src/build/template-plugin.js","../../src/build/public-exports/all.js"],"sourcesContent":["import path from 'path';\n\n/**\n * Join will convert to whatever is appropriate fro the current platform\n */\n\nexport const leadingSlashPath = {\n  embroiderDir: path.join('/node_modules/.embroider/'),\n  atEmbroider: path.join('/@embroider'),\n  componentsDir: path.join('/components/'),\n  templatesDir: path.join('/templates/'),\n  routesDir: path.join('/routes/'),\n  testem: path.join('/testem'),\n  src: path.join('/src/'),\n  app: path.join('/app/'),\n};\n\nexport const barePath = {\n  pnpmDir: path.join('node_modules/.pnpm'),\n};\n","/*\n * JavaScript MD5\n * https://github.com/blueimp/JavaScript-MD5\n *\n * Copyright 2011, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n *\n * Based on\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\n * Digest Algorithm, as defined in RFC 1321.\n * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for more info.\n *\n * Modifications:\n * - removed IIFE, exported md5 (this file is now ESM)\n */\n\n/**\n * Add integers, wrapping at 2^32.\n * This uses 16-bit operations internally to work around bugs in interpreters.\n *\n * @param {number} x First integer\n * @param {number} y Second integer\n * @returns {number} Sum\n */\nfunction safeAdd(x, y) {\n  var lsw = (x & 0xffff) + (y & 0xffff);\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n\n  return (msw << 16) | (lsw & 0xffff);\n}\n\n/**\n * Bitwise rotate a 32-bit number to the left.\n *\n * @param {number} num 32-bit number\n * @param {number} cnt Rotation count\n * @returns {number} Rotated number\n */\nfunction bitRotateLeft(num, cnt) {\n  return (num << cnt) | (num >>> (32 - cnt));\n}\n\n/**\n * Basic operation the algorithm uses.\n *\n * @param {number} q q\n * @param {number} a a\n * @param {number} b b\n * @param {number} x x\n * @param {number} s s\n * @param {number} t t\n * @returns {number} Result\n */\nfunction md5cmn(q, a, b, x, s, t) {\n  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);\n}\n\n/**\n * Basic operation the algorithm uses.\n *\n * @param {number} a a\n * @param {number} b b\n * @param {number} c c\n * @param {number} d d\n * @param {number} x x\n * @param {number} s s\n * @param {number} t t\n * @returns {number} Result\n */\nfunction md5ff(a, b, c, d, x, s, t) {\n  return md5cmn((b & c) | (~b & d), a, b, x, s, t);\n}\n\n/**\n * Basic operation the algorithm uses.\n *\n * @param {number} a a\n * @param {number} b b\n * @param {number} c c\n * @param {number} d d\n * @param {number} x x\n * @param {number} s s\n * @param {number} t t\n * @returns {number} Result\n */\nfunction md5gg(a, b, c, d, x, s, t) {\n  return md5cmn((b & d) | (c & ~d), a, b, x, s, t);\n}\n\n/**\n * Basic operation the algorithm uses.\n *\n * @param {number} a a\n * @param {number} b b\n * @param {number} c c\n * @param {number} d d\n * @param {number} x x\n * @param {number} s s\n * @param {number} t t\n * @returns {number} Result\n */\nfunction md5hh(a, b, c, d, x, s, t) {\n  return md5cmn(b ^ c ^ d, a, b, x, s, t);\n}\n\n/**\n * Basic operation the algorithm uses.\n *\n * @param {number} a a\n * @param {number} b b\n * @param {number} c c\n * @param {number} d d\n * @param {number} x x\n * @param {number} s s\n * @param {number} t t\n * @returns {number} Result\n */\nfunction md5ii(a, b, c, d, x, s, t) {\n  return md5cmn(c ^ (b | ~d), a, b, x, s, t);\n}\n\n/**\n * Calculate the MD5 of an array of little-endian words, and a bit length.\n *\n * @param {Array} x Array of little-endian words\n * @param {number} len Bit length\n * @returns {Array<number>} MD5 Array\n */\nfunction binlMD5(x, len) {\n  /* append padding */\n  x[len >> 5] |= 0x80 << len % 32;\n  x[(((len + 64) >>> 9) << 4) + 14] = len;\n\n  var i;\n  var olda;\n  var oldb;\n  var oldc;\n  var oldd;\n  var a = 1732584193;\n  var b = -271733879;\n  var c = -1732584194;\n  var d = 271733878;\n\n  for (i = 0; i < x.length; i += 16) {\n    olda = a;\n    oldb = b;\n    oldc = c;\n    oldd = d;\n\n    a = md5ff(a, b, c, d, x[i], 7, -680876936);\n    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);\n    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);\n    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);\n    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);\n    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);\n    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);\n    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);\n    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);\n    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);\n    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);\n    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);\n    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);\n    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);\n    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);\n    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);\n\n    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);\n    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);\n    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);\n    b = md5gg(b, c, d, a, x[i], 20, -373897302);\n    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);\n    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);\n    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);\n    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);\n    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);\n    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);\n    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);\n    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);\n    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);\n    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);\n    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);\n    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);\n\n    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);\n    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);\n    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);\n    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);\n    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);\n    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);\n    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);\n    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);\n    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);\n    d = md5hh(d, a, b, c, x[i], 11, -358537222);\n    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);\n    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);\n    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);\n    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);\n    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);\n    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);\n\n    a = md5ii(a, b, c, d, x[i], 6, -198630844);\n    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);\n    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);\n    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);\n    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);\n    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);\n    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);\n    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);\n    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);\n    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);\n    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);\n    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);\n    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);\n    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);\n    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);\n    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);\n\n    a = safeAdd(a, olda);\n    b = safeAdd(b, oldb);\n    c = safeAdd(c, oldc);\n    d = safeAdd(d, oldd);\n  }\n\n  return [a, b, c, d];\n}\n\n/**\n * Convert an array of little-endian words to a string\n *\n * @param {Array<number>} input MD5 Array\n * @returns {string} MD5 string\n */\nfunction binl2rstr(input) {\n  var i;\n  var output = '';\n  var length32 = input.length * 32;\n\n  for (i = 0; i < length32; i += 8) {\n    output += String.fromCharCode((input[i >> 5] >>> i % 32) & 0xff);\n  }\n\n  return output;\n}\n\n/**\n * Convert a raw string to an array of little-endian words\n * Characters >255 have their high-byte silently ignored.\n *\n * @param {string} input Raw input string\n * @returns {Array<number>} Array of little-endian words\n */\nfunction rstr2binl(input) {\n  var i;\n  var output = [];\n  output[(input.length >> 2) - 1] = undefined;\n\n  for (i = 0; i < output.length; i += 1) {\n    output[i] = 0;\n  }\n\n  var length8 = input.length * 8;\n\n  for (i = 0; i < length8; i += 8) {\n    output[i >> 5] |= (input.charCodeAt(i / 8) & 0xff) << i % 32;\n  }\n\n  return output;\n}\n\n/**\n * Calculate the MD5 of a raw string\n *\n * @param {string} s Input string\n * @returns {string} Raw MD5 string\n */\nfunction rstrMD5(s) {\n  return binl2rstr(binlMD5(rstr2binl(s), s.length * 8));\n}\n\n/**\n * Calculates the HMAC-MD5 of a key and some data (raw strings)\n *\n * @param {string} key HMAC key\n * @param {string} data Raw input string\n * @returns {string} Raw MD5 string\n */\nfunction rstrHMACMD5(key, data) {\n  var i;\n  var bkey = rstr2binl(key);\n  var ipad = [];\n  var opad = [];\n  var hash;\n  ipad[15] = opad[15] = undefined;\n\n  if (bkey.length > 16) {\n    bkey = binlMD5(bkey, key.length * 8);\n  }\n\n  for (i = 0; i < 16; i += 1) {\n    ipad[i] = bkey[i] ^ 0x36363636;\n    opad[i] = bkey[i] ^ 0x5c5c5c5c;\n  }\n\n  hash = binlMD5(ipad.concat(rstr2binl(data)), 512 + data.length * 8);\n\n  return binl2rstr(binlMD5(opad.concat(hash), 512 + 128));\n}\n\n/**\n * Convert a raw string to a hex string\n *\n * @param {string} input Raw input string\n * @returns {string} Hex encoded string\n */\nfunction rstr2hex(input) {\n  var hexTab = '0123456789abcdef';\n  var output = '';\n  var x;\n  var i;\n\n  for (i = 0; i < input.length; i += 1) {\n    x = input.charCodeAt(i);\n    output += hexTab.charAt((x >>> 4) & 0x0f) + hexTab.charAt(x & 0x0f);\n  }\n\n  return output;\n}\n\n/**\n * Encode a string as UTF-8\n *\n * @param {string} input Input string\n * @returns {string} UTF8 string\n */\nfunction str2rstrUTF8(input) {\n  return unescape(encodeURIComponent(input));\n}\n\n/**\n * Encodes input string as raw MD5 string\n *\n * @param {string} s Input string\n * @returns {string} Raw MD5 string\n */\nfunction rawMD5(s) {\n  return rstrMD5(str2rstrUTF8(s));\n}\n\n/**\n * Encodes input string as Hex encoded string\n *\n * @param {string} s Input string\n * @returns {string} Hex encoded string\n */\nfunction hexMD5(s) {\n  return rstr2hex(rawMD5(s));\n}\n\n/**\n * Calculates the raw HMAC-MD5 for the given key and data\n *\n * @param {string} k HMAC key\n * @param {string} d Input string\n * @returns {string} Raw MD5 string\n */\nfunction rawHMACMD5(k, d) {\n  return rstrHMACMD5(str2rstrUTF8(k), str2rstrUTF8(d));\n}\n\n/**\n * Calculates the Hex encoded HMAC-MD5 for the given key and data\n *\n * @param {string} k HMAC key\n * @param {string} d Input string\n * @returns {string} Raw MD5 string\n */\nfunction hexHMACMD5(k, d) {\n  return rstr2hex(rawHMACMD5(k, d));\n}\n\n/**\n * Calculates MD5 value for a given string.\n * If a key is provided, calculates the HMAC-MD5 value.\n * Returns a Hex encoded string unless the raw argument is given.\n *\n * @param {string} string Input string\n * @param {string} [key] HMAC key\n * @param {boolean} [raw] Raw output switch\n * @returns {string} MD5 output\n */\nexport function md5(string, key, raw) {\n  if (!key) {\n    if (!raw) {\n      return hexMD5(string);\n    }\n\n    return rawMD5(string);\n  }\n\n  if (!raw) {\n    return hexHMACMD5(key, string);\n  }\n\n  return rawHMACMD5(key, string);\n}\n","import { md5 } from './md5.js';\n\n/**\n * The intent of this function is to generate the suffix/postfix for the\n * css classes, based on the module-scoped path name.\n *\n * for example,\n *    hash('my-app/components/foo')\n *  instead of\n *    hash('app/components/foo')\n *\n *  (unless your app name is 'app')\n *\n * @param {string} modulePath\n * @returns {string}\n */\nexport function hash(modulePath) {\n  return 'e' + md5(modulePath).substring(0, 8);\n}\n\nif (import.meta.vitest) {\n  const { it, expect } = import.meta.vitest;\n\n  it('should return a string', function () {\n    const postfix = hash('foo.css');\n\n    expect(postfix).to.be.a('string');\n  });\n\n  it('should return a string starting with \"e\"', function () {\n    const postfix = hash('foo.css');\n\n    expect(postfix).to.match(/^e/);\n  });\n\n  it('should return a string of length 9', function () {\n    const postfix = hash('foo.css');\n\n    expect(postfix).to.have.lengthOf(9);\n  });\n}\n\nexport const hashFromModulePath = hash;\n","import assert from 'node:assert';\nimport fsSync, { existsSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\n\nimport { barePath, leadingSlashPath } from './const.js';\nimport { hashFromAbsolutePath } from './hash-from-absolute-path.js';\nimport { hashFromModulePath as hashPosixModulePath } from './hash-from-module-path.js';\n\nexport { hashFromAbsolutePath } from './hash-from-absolute-path.js';\n\n/**\n *\n * @param {string} filePath\n * @returns {string}\n */\nexport function hashFromModulePath(filePath) {\n  let posixPath = forcePosix(filePath);\n\n  return hashPosixModulePath(posixPath);\n}\n\n/**\n * @param {string} filePath\n */\nexport function forcePosix(filePath) {\n  const parsed = path.parse(filePath);\n\n  if (parsed.root === '') {\n    return filePath.replaceAll(path.win32.sep, path.posix.sep);\n  }\n\n  let rootless = filePath.replace(\n    new RegExp(`^${RegExp.escape(parsed.root)}`),\n    path.posix.sep,\n  );\n\n  return rootless.replaceAll(path.win32.sep, path.posix.sep);\n}\n\nconst COMPONENT_EXTENSIONS = ['.gts', '.gjs', '.ts', '.js', '.hbs'];\n\n// CJS / ESM?\nlet here = import.meta.url;\nlet ourRequire = globalThis.require\n  ? globalThis.require\n  : here && createRequire(here);\n\nif (!ourRequire) {\n  ourRequire = require;\n}\n\nconst IRRELEVANT_PATHS = [barePath.pnpmDir, '__vite-'];\nconst UNSUPPORTED_DIRECTORIES = new Set(['tests']);\n\nconst CWD = process.cwd();\n\n/**\n * Regardless of what the filePath format is,\n * this will try to return the correct postfix.\n *\n * @param {string} filePath\n * @returns\n */\nexport function hashFrom(filePath) {\n  if (path.isAbsolute(filePath)) {\n    return hashFromAbsolutePath(filePath);\n  }\n\n  return hashFromModulePath(filePath);\n}\n\n/**\n *\n */\nexport function cssHasAssociatedComponent(cssPath) {\n  return cssHasStandardFile(cssPath) || cssHasPodsFile(cssPath);\n}\n\nfunction cssHasStandardFile(id) {\n  /**\n   * Normally we don't need to check a JS path here, but when using\n   * embroider@3, we have a \"rewritten app\", which has all our source\n   * preprocessed a bit before scoped-css transformations.\n   *\n   * (In Vite, we operate more directly with the source)\n   */\n  for (let ext of COMPONENT_EXTENSIONS) {\n    let candidatePath = id.replace(/\\.css$/, ext);\n\n    if (existsSync(candidatePath)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction cssHasPodsFile(id) {\n  if (!id.endsWith('styles.css')) {\n    return;\n  }\n\n  /**\n   * Normally we don't need to check a JS path here, but when using\n   * embroider@3, we have a \"rewritten app\", which has all our source\n   * preprocessed a bit before scoped-css transformations.\n   *\n   * (In Vite, we operate more directly with the source)\n   */\n  for (let ext of COMPONENT_EXTENSIONS) {\n    let candidatePath = id.replace(/styles\\.css$/, `template${ext}`);\n\n    if (existsSync(candidatePath)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Based on ember's component location conventions,\n * this function will provide a path for where we\n * expect the CSS to live.\n *\n * For co-located structure:\n *   - components/my-component.hbs\n *   - components/my-component.css\n *\n * For nested co-located structure\n *   - components/my-component/foo.hbs\n *   - components/my-component/foo.css\n *\n * For Pods routes structure\n *   - routes/my-route/template.{hbs,js}\n *   - routes/my-route/styles.css\n *\n * Deliberately not supported:\n *   - components w/ pods -- this is deprecated in 5.10\n *\n * @param {string} fileName - the hbs, js, gjs, gts or whatever co-located path.\n * @returns {string} - expected css path\n */\nexport function cssPathFor(fileName) {\n  let withoutExt = withoutExtension(fileName);\n  let cssPath = withoutExt + '.css';\n\n  if (isPod(fileName)) {\n    cssPath = fileName\n      .replace(/template\\.js$/, 'styles.css')\n      .replace(/template\\.gjs/, 'styles.css')\n      .replace(/template\\.gts/, 'styles.css')\n      .replace(/template\\.hbs/, 'styles.css');\n  }\n\n  return cssPath;\n}\n\n/**\n * Note that components in the \"pods\" convention will\n * never be supported.\n *\n * @param {string} filePath\n */\nexport function isPodTemplate(filePath) {\n  if (filePath.includes(leadingSlashPath.componentsDir)) {\n    return false;\n  }\n\n  return (\n    filePath.endsWith('template.js') ||\n    filePath.endsWith('template.hbs') ||\n    filePath.endsWith('template.gjs') ||\n    filePath.endsWith('template.gts')\n  );\n}\n\n/**\n * Note that components in the \"pods\" convention will\n * never be supported.\n *\n * Checks if a file ends with\n * - template.js\n * - template.hbs\n * - styles.css\n *\n * @param {string} filePath\n */\nexport function isPod(filePath) {\n  if (filePath.includes(leadingSlashPath.componentsDir)) {\n    return false;\n  }\n\n  if (isPodTemplate(filePath)) {\n    return true;\n  }\n\n  return filePath.endsWith('styles.css');\n}\n\n/**\n *\n * @param {string} filePath\n * @returns the same path, but without the extension\n */\nexport function withoutExtension(filePath) {\n  let parsed = path.parse(filePath);\n\n  return path.join(parsed.dir, parsed.name);\n}\n\n/**\n * Examples for fileName\n * - absolute on-disk path\n * - in webpack\n *   - URL-absolute path, starting with /\n *\n * @param {string} fileName\n * @param {{ additionalRoots?: string[]; cwd: string }} options\n * @returns\n */\nexport function isRelevantFile(fileName, { additionalRoots, cwd }) {\n  // Fake file handled by testem server when it runs\n  if (fileName.startsWith(leadingSlashPath.testem)) return false;\n  // Private Virtual Modules\n  if (fileName.startsWith('\\0')) return false;\n\n  // These are not valid userland names (or are from libraries)\n  if (path.isAbsolute(fileName) === false) {\n    if (fileName.match(/^[a-zA-Z]/)) return false;\n  }\n\n  // External to us\n  if (fileName.startsWith(leadingSlashPath.atEmbroider)) return false;\n  if (IRRELEVANT_PATHS.some((i) => fileName.includes(i))) return false;\n\n  assert(cwd, `cwd was not passed to isRelevantFile`);\n\n  let isInAdditionalRoot = additionalRoots?.some((root) => {\n    let relative = path.relative(path.resolve(cwd, root), fileName);\n\n    return (\n      relative !== '..' &&\n      !relative.startsWith(`..${path.sep}`) &&\n      !path.isAbsolute(relative)\n    );\n  });\n\n  let workspace = findWorkspacePath(fileName);\n\n  let ourWorkspace = findWorkspacePath(cwd);\n\n  if (workspace !== ourWorkspace && !isInAdditionalRoot) {\n    return false;\n  }\n\n  let isInWorkspaceAdditionalRoot =\n    workspace === ourWorkspace &&\n    additionalRoots?.some((root) => {\n      if (path.isAbsolute(root)) return false;\n\n      let normalizedFileName = `${path.sep}${path.normalize(fileName)}${path.sep}`;\n      let normalizedRoot = `${path.sep}${path.normalize(root)}${path.sep}`;\n\n      return normalizedFileName.includes(normalizedRoot);\n    });\n\n  let local = fileName.replace(workspace, '');\n  let [, ...parts] = local.split(path.sep).filter(Boolean);\n\n  if (UNSUPPORTED_DIRECTORIES.has(parts[0])) {\n    return false;\n  }\n\n  /**\n   * Mostly pods support.\n   * folks need to opt in to pods (routes), because every pods app can be configured differently\n   */\n  let roots = [\n    leadingSlashPath.componentsDir,\n    leadingSlashPath.templatesDir,\n    leadingSlashPath.routesDir,\n  ];\n\n  if (\n    !isInAdditionalRoot &&\n    !isInWorkspaceAdditionalRoot &&\n    !roots.some((root) => fileName.includes(root))\n  ) {\n    return;\n  }\n\n  return true;\n}\n\nexport function packageScopedPathToModulePath(packageScopedPath) {\n  /**\n   * *By convention*, `src` is omitted from component paths.\n   * We can reflect the same behavior by replacing src/\n   * with an empty string.\n   *\n   * CSS isn't emitted as a co-located module, but\n   * to keep conventions consistent across languages,\n   * we can pretend it is.\n   *\n   * Any customization beyond removing `src` and `app` is potentially confusing.\n   * If we need further customizations, we'll want to match on `exports` in the\n   * corresponding package.json\n   */\n  let packageRelative = packageScopedPath.replace(\n    new RegExp(`^${RegExp.escape(leadingSlashPath.src)}`),\n    path.sep,\n  );\n\n  let parsed = path.parse(packageRelative);\n\n  if (isPod(packageRelative)) {\n    /**\n     * For pods, we chop off the whole file, and use the dir name as the \"modulePath\"\n     */\n    return parsed.dir;\n  }\n\n  /**\n   * If an extension is passed, remove it.\n   * When using packagers, folks are used to not having to specify extensions for files.\n   * Since we don't even emit css files co-located to each module,\n   * this helps us not convey a lie that a file may exist in at runtime.\n   *\n   * For example `<module-name>/components/button`.\n   * It doesn't matter what the extension is, because you can only have one css file\n   * for the button module anyway.\n   */\n  let localPackagerStylePath = path.join(parsed.dir, parsed.name);\n\n  return localPackagerStylePath;\n}\n\n/**\n * returns the app-module path of the source file\n *\n * This assumes normal ember app conventions\n *\n * which is `<package.json#name>/path-to-file`\n */\nexport function appPath(sourcePath) {\n  let workspacePath = findWorkspacePath(sourcePath);\n  let name = moduleName(sourcePath);\n\n  /**\n   *  Under embroider builds, the spec-compliant version of the app\n   * has all the files under a folder which represents the package name,\n   * rather than \"app\".\n   */\n  let packageRelative = sourcePath.replace(workspacePath, '');\n\n  /**\n   * But we also don't want 'app' -- which is present in the v1 addon pipeline\n   */\n  packageRelative = packageRelative.replace(leadingSlashPath.app, path.sep);\n\n  // Any of the above relpacements could accidentally give us an extra / (depending on our build environment)\n  packageRelative = path.normalize(packageRelative);\n\n  let localPackagerStylePath = packageScopedPathToModulePath(packageRelative);\n\n  return `${name}${localPackagerStylePath}`;\n}\n\n/**\n * To avoid hitting the filesysetm, we'll store all found\n * project paths bere, so we can, in memory,\n * get the folder where a package.json exists, rather than\n * hit the file system every time.\n */\nconst SEEN = new Set();\n\nfunction getSeen(sourcePath) {\n  if (SEEN.has(sourcePath)) return sourcePath;\n\n  let parts = sourcePath.split(path.sep);\n\n  for (let i = parts.length - 1; i > 1; i--) {\n    let toCheck = parts.slice(0, i).join(path.sep);\n\n    let seen = SEEN.has(toCheck);\n\n    if (seen) {\n      return toCheck;\n    }\n  }\n}\n\nexport function findWorkspacePath(sourcePath, options) {\n  let cwd = options?.cwd ?? CWD;\n\n  if (sourcePath.endsWith(path.sep)) {\n    sourcePath = sourcePath.replace(\n      new RegExp(`${RegExp.escape(path.sep)}$`),\n      '',\n    );\n  }\n\n  let seen = getSeen(sourcePath);\n\n  if (seen) {\n    return seen;\n  }\n\n  let candidatePath = path.join(sourcePath, 'package.json');\n\n  const isWorkspace = fsSync.existsSync(candidatePath);\n\n  if (isWorkspace) {\n    return sourcePath;\n  }\n\n  const packageJsonPath = findPackageJsonUp(sourcePath, { cwd });\n\n  if (!packageJsonPath) {\n    throw new Error(`Could not determine project for ${sourcePath}`);\n  }\n\n  const workspacePath = path.dirname(packageJsonPath);\n\n  SEEN.add(workspacePath);\n\n  return workspacePath;\n}\n\nfunction findPackageJsonUp(startPath, options) {\n  let cwd = options?.cwd ?? CWD;\n  let parts = startPath.split(path.sep);\n\n  for (let i = parts.length - 1; i > 1; i--) {\n    let toCheck = parts.slice(0, i).join(path.sep);\n\n    let packageJson = path.join(toCheck, 'package.json');\n    let exists = fsSync.existsSync(packageJson);\n\n    if (exists) {\n      return packageJson;\n    }\n\n    // Don't traverse all the way to the root of the file system.\n    if (toCheck === cwd) {\n      break;\n    }\n  }\n\n  return null;\n}\n\nconst MANIFEST_CACHE = new Map();\n\n/**\n * Will return the package.json#name, or config/environment#moudlePrefix (if v1 app)\n *\n * @param {string} sourcePath\n */\nexport function moduleName(sourcePath) {\n  const workspace = findWorkspacePath(sourcePath);\n  const manifest = getManifest(workspace);\n\n  return manifest.name;\n}\n\n/**\n * @param {string} workspace\n */\nfunction getManifest(workspace) {\n  let existing = MANIFEST_CACHE.get(workspace);\n\n  if (existing) {\n    return existing;\n  }\n\n  let buffer = fsSync.readFileSync(path.join(workspace, 'package.json'));\n  let content = buffer.toString();\n  let json = JSON.parse(content);\n\n  MANIFEST_CACHE.set(workspace, json);\n\n  return json;\n}\n","/**\n * Splits a space-separated class list (the value of a `class` attribute or of\n * a `[class=\"...\"]` selector) into its individual class names.\n *\n * @param {string} classList\n * @returns {string[]}\n */\nexport function splitClassList(classList) {\n  return classList.split(/\\s+/).filter(Boolean);\n}\n\n/**\n *\n * @param {string} className\n * @param {string} postfix\n * @param {Set<string>} [classesInCss]\n * @returns\n */\nexport function renameClass(className, postfix, classesInCss) {\n  const renamedClasses = splitClassList(className)\n    .map((c) => {\n      if (!classesInCss || classesInCss.has(c)) {\n        if (c.endsWith(postfix)) return c;\n\n        return c + '_' + postfix;\n      }\n\n      return c;\n    })\n    .join(' ');\n\n  const renamedWithPreservedSpaces = className.replace(\n    className.trimStart().trimEnd(),\n    renamedClasses,\n  );\n\n  return renamedWithPreservedSpaces;\n}\n","import {\n  appPath,\n  hashFromModulePath,\n  isRelevantFile,\n} from '../lib/path/utils.js';\nimport { renameClass } from '../lib/renameClass.js';\n\nfunction _isRelevantFile(state, cwd) {\n  let fileName = state.file.opts.filename;\n  let additionalRoots = state.opts?.additionalRoots;\n\n  return isRelevantFile(fileName, {\n    additionalRoots,\n    cwd,\n  });\n}\n\n/**\n * @param {any} env - babel plugin env, env.types is most commonly used (esp in TS)\n * @param {object} options - the options for scoped-css -- this is also available in each visitor's state.opts\n * @param {string} workingDirectory\n */\nexport const scopedCSS = (config) => (env, options, workingDirectory) => {\n  // not really a deep merge, but the idea is to use one or the other and not mix the configs\n  options = { ...config, ...options };\n\n  /**\n   * This babel plugin does two things:\n   * - removes the import of scopedClass, if it exists\n   *   - if scopedClass was imported, it is removed from any component's \"scope bag\"\n   *     (the scope bag being a low-level object used for passing what is \"in scope\" for a component)\n   */\n  return {\n    visitor: {\n      Program: {\n        enter(path, state) {\n          if (!_isRelevantFile(state, workingDirectory)) {\n            state.canSkip = true;\n\n            return;\n          }\n\n          let modulePath = appPath(state.filename);\n\n          state.postfix = hashFromModulePath(modulePath);\n        },\n      },\n      ImportDeclaration(path, state) {\n        if (state.canSkip) {\n          return;\n        }\n\n        if (path.node.source.value === 'ember-scoped-css') {\n          let specifier = path.node.specifiers.find(\n            (x) => x.imported.name === 'scopedClass',\n          );\n\n          if (specifier) {\n            state.file.opts.importedScopedClass = specifier.local.name;\n          }\n\n          if (specifier.local.name !== 'scopedClass') {\n            throw new Error(\n              `The scopedClass import is a psuedo-helper, and may not be renamed as it is removed at build time.`,\n            );\n          }\n\n          path.remove();\n        }\n      },\n      /**\n       * Rename usages in JS/TS/GJS/GTS\n       */\n      CallExpression(path, state) {\n        if (state.canSkip) {\n          return;\n        }\n\n        if (\n          path.node.callee.type === 'Identifier' &&\n          path.node.callee.name === state.file.opts?.importedScopedClass\n        ) {\n          if (\n            path.node.arguments.length !== 1 ||\n            path.node.arguments[0].type !== 'StringLiteral'\n          ) {\n            throw new Error(\n              `The scopedClass helper only accepts a single, non-dynamic, string literal argument.`,\n            );\n          }\n\n          const original = path.node.arguments[0].value;\n          const renamed = renameClass(\n            original,\n            state.postfix,\n            new Set([original]),\n          );\n          const transformedString = env.types.stringLiteral(renamed);\n\n          path.replaceWith(transformedString);\n        }\n      },\n      /**\n       * Only in strict mode, do we care about remoning the scope bag reference\n       */\n      ObjectProperty(path, state) {\n        if (!state.file.opts?.importedScopedClass) return;\n\n        if (\n          path.node.value.type === 'Identifier' &&\n          path.node.value.name === state.file.opts?.importedScopedClass\n        ) {\n          path.remove();\n        }\n      },\n    },\n  };\n};\n","import { existsSync, readFileSync } from 'fs';\nimport postcss from 'postcss';\nimport scssSyntax from 'postcss-scss';\nimport parser from 'postcss-selector-parser';\n\nimport { md5 } from '../path/md5.js';\nimport { splitClassList } from '../renameClass.js';\n\n/**\n * @param {string} css\n * @return {string} hashed down version of the CSS for disambiguating\n */\nexport function hash(css) {\n  return `css-${md5(css)}`;\n}\n\n/**\n * Attribute selectors are scoped with one of two strategies:\n *\n * - **renamed value**: class-targeting selectors whose value names real\n *   class(es) (`[class=\"foo\"]`, `[class~=\"foo\"]`) are scoped by renaming the\n *   value the same way `.foo` is renamed to `.foo_postfix`. The renamed token\n *   is unique per file, so nothing else is needed.\n * - **postfix class**: every other attribute selector keeps its discriminator\n *   and is scoped by the generated postfix class — appended to the selector\n *   in the CSS and added to matching elements in the template (the same\n *   strategy bare tag selectors use: `div` becomes `div.postfix`).\n *\n * This predicate decides between the two. It is shared by the CSS rewrite\n * (which renames the selector value) and by discovery in this file (which\n * registers the value's class names for template renaming) so both sides\n * always classify a selector the same way.\n *\n * @param {import('postcss-selector-parser').Attribute} node\n * @returns {boolean}\n */\nexport function isRenamedClassAttribute(node) {\n  return (\n    node.attribute === 'class' &&\n    (node.operator === '=' || node.operator === '~=') &&\n    Boolean(node.value)\n  );\n}\n\nexport function isInsideGlobal(node, func) {\n  const parent = node.parent;\n\n  if (!parent) return false;\n  if (parent.type === 'pseudo' && parent.value === ':global') return true;\n\n  return isInsideGlobal(parent, func);\n}\n\n/**\n * @param {string} cssPath path to a CSS file\n */\nexport function getCSSInfo(cssPath) {\n  if (!existsSync(cssPath)) {\n    return null;\n  }\n\n  let css = readFileSync(cssPath, 'utf8');\n\n  return getCSSContentInfo(css);\n}\n\n/**\n * We use this function to check each class used in the template\n * to see if we need to leave it alone or transform it\n *\n * @param {string} css the CSS's contents\n * @param {string} [lang] optional language hint (e.g. 'scss', 'sass', 'less')\n * @return {{ classes: Set<string>, tags: Set<string>, attributes: Set<string>, css: string, id: string }}\n */\nexport function getCSSContentInfo(css, lang) {\n  const classes = new Set();\n  const tags = new Set();\n  const attributes = new Set();\n\n  const parseOptions =\n    lang === 'scss' || lang === 'sass' ? { syntax: scssSyntax } : {};\n\n  const ast = postcss.parse(css, parseOptions);\n\n  const isScss = lang === 'scss' || lang === 'sass';\n\n  ast.walk((node) => {\n    if (node.type === 'rule') {\n      const selector = isScss ? resolveNestedSassSelector(node) : node.selector;\n\n      collectSelectorInfo(selector, classes, tags, attributes);\n    }\n  });\n\n  let id = hash(css);\n\n  return { classes, tags, attributes, css, id };\n}\n\n/**\n * Resolves a nested SCSS selector by substituting `&` with the fully-resolved\n * parent selector, recursively. This converts e.g. `&--modifier` (child of\n * `.block`) into `.block--modifier`, and handles arbitrary nesting depth so\n * that `&--modifier` inside `&--modifier` inside `.block` yields\n * `.block--modifier--modifier`.\n *\n * @param {import('postcss').Rule} node\n * @return {string}\n */\nfunction resolveNestedSassSelector(node) {\n  const { selector } = node;\n\n  if (!selector.includes('&')) {\n    return selector;\n  }\n\n  const parent = node.parent;\n\n  if (!parent || parent.type !== 'rule') {\n    // No parent rule — `&` has nothing to substitute, return as-is\n    return selector;\n  }\n\n  // Recursively resolve the parent first, then substitute into this selector\n  const resolvedParent = resolveNestedSassSelector(parent);\n\n  return selector.replace(/&/g, resolvedParent);\n}\n\nfunction collectSelectorInfo(sel, classes, tags, attributes) {\n  const transform = (sls) => {\n    sls.walk((selector) => {\n      if (isInsideGlobal(selector)) return;\n\n      if (selector.type === 'class') {\n        classes.add(selector.value);\n      } else if (selector.type === 'tag') {\n        tags.add(selector.value);\n      } else if (selector.type === 'attribute') {\n        if (isRenamedClassAttribute(selector)) {\n          // Register the value's class names so the template renames them.\n          //\n          // postcss-selector-parser exposes the attribute value only as an\n          // opaque string, so splitting `[class=\"foo bar\"]` into its\n          // space-separated class names is on us — `splitClassList` is the\n          // same tokenization `renameClass` applies.\n          for (let token of splitClassList(selector.value)) {\n            classes.add(token);\n          }\n        } else {\n          // Elements carrying this attribute get the postfix class. For\n          // class-target operators (^=, *=, $=, |=) and presence, the name\n          // is `class`.\n          //\n          // CSS matches HTML attribute names case-insensitively, so store the\n          // name lowercased and compare against lowercased template attribute\n          // names. (Coarser than SVG's case-sensitive matching, but the two\n          // sides always agree; worst case an element gets the postfix class\n          // it didn't strictly need.)\n          attributes.add(selector.attribute.toLowerCase());\n        }\n      }\n    });\n  };\n\n  parser(transform).processSync(sel);\n}\n\nif (import.meta.vitest) {\n  const { it, expect } = import.meta.vitest;\n\n  it('should return classes and tags that are not in :global', function () {\n    const css = '.baz :global(.foo) .bar div :global(p)  { color: red; }';\n    const { classes, tags } = getCSSContentInfo(css);\n\n    // classes should be baz and bar\n    expect(classes.size).to.equal(2);\n    expect([...classes]).to.have.members(['baz', 'bar']);\n    expect(tags.size).to.equal(1);\n    expect([...tags]).to.have.members(['div']);\n  });\n\n  it('collects attribute names for postfix-class scoping', function () {\n    const css = '[disabled] [data-x=\"y\"] { color: red; }';\n    const { attributes } = getCSSContentInfo(css);\n\n    expect(attributes).to.deep.equal(new Set(['disabled', 'data-x']));\n  });\n\n  it('treats =/~= class attribute values as renamed classes', function () {\n    const css = '[class=\"foo bar\"] [class~=\"baz\"] { color: red; }';\n    const { classes, attributes } = getCSSContentInfo(css);\n\n    expect(classes).to.deep.equal(new Set(['foo', 'bar', 'baz']));\n    expect(attributes).to.deep.equal(new Set());\n  });\n\n  it('treats other class attribute operators as postfix-class attributes', function () {\n    const css = '[class^=\"foo\"] [class*=\"bar\"] { color: red; }';\n    const { classes, attributes } = getCSSContentInfo(css);\n\n    expect(classes).to.deep.equal(new Set());\n    expect(attributes).to.deep.equal(new Set(['class']));\n  });\n\n  it('lowercases attribute names (CSS matches them case-insensitively)', function () {\n    const css = '[TYPE=\"submit\"] { color: red; }';\n    const { attributes } = getCSSContentInfo(css);\n\n    expect(attributes).to.deep.equal(new Set(['type']));\n  });\n\n  it('ignores attribute selectors inside :global', function () {\n    const css = ':global([data-x]) [data-y] { color: red; }';\n    const { attributes } = getCSSContentInfo(css);\n\n    expect(attributes).to.deep.equal(new Set(['data-y']));\n  });\n\n  it('should parse SCSS nesting syntax without crashing when lang=scss', function () {\n    const scss = `\n      $base-color: #c6538c;\n      $border-dark: rgba($base-color, 0.88);\n\n      .parent {\n        &:hover { color: $base-color; }\n        .child { border: 1px solid $border-dark; }\n        color: red;\n      }\n    `;\n    const { classes } = getCSSContentInfo(scss, 'scss');\n\n    expect([...classes]).toMatchInlineSnapshot(`\n      [\n        \"parent\",\n        \"child\",\n      ]\n    `);\n  });\n\n  it('should parse SCSS nesting syntax without crashing when lang=sass', function () {\n    const scss = `\n      $base-color: green;\n      .block {\n        &--modifier { color: $base-color; }\n      }\n    `;\n    const { classes } = getCSSContentInfo(scss, 'sass');\n\n    expect([...classes]).toMatchInlineSnapshot(`\n      [\n        \"block\",\n        \"block--modifier\",\n      ]\n    `);\n  });\n\n  it('should parse SCSS deeply nested BEM when lang=sass', function () {\n    const scss = `\n      $base-color: green;\n      .block {\n        &--modifier {\n          color: $base-color;\n          &--modifier {\n            color: $base-color;\n            &--modifier {\n              color: $base-color;\n            }\n          }\n        }\n      }\n    `;\n    const { classes } = getCSSContentInfo(scss, 'sass');\n\n    expect([...classes]).toMatchInlineSnapshot(`\n      [\n        \"block\",\n        \"block--modifier\",\n        \"block--modifier--modifier\",\n        \"block--modifier--modifier--modifier\",\n      ]\n    `);\n  });\n}\n","/**\n * Important docs:\n * - https://developer.mozilla.org/en-US/docs/Web/CSS/\n */\nimport postcss from 'postcss';\nimport parser from 'postcss-selector-parser';\n\nimport { renameClass } from '../renameClass.js';\nimport { isInsideGlobal, isRenamedClassAttribute } from './utils.js';\n\nconst SEP = '__';\n\nfunction isRule(node) {\n  return node.type === 'rule';\n}\n\nfunction isDeclaration(node) {\n  return node.type === 'decl';\n}\n\n/**\n * NOTE: \"keyframes\" is a singular definition, in that it's a block containing keyframes\n *       using `@keyframes {}` with only one thing on the inside doesn't make sense.\n */\nfunction rewriteReferenceable(node, postfix) {\n  let originalName = node.params;\n  let postfixedName = node.params + SEP + postfix;\n\n  node.params = postfixedName;\n\n  return {\n    originalName,\n    postfixedName,\n  };\n}\n\n/**\n * Walk left and right from `node` within its compound selector (bounded by\n * combinators) to see if the postfix class has already been added. Used to add\n * the postfix class at most once per compound, e.g. `input[type=\"text\"]`\n * becomes `input.postfix[type=\"text\"]`, not `input.postfix[type=\"text\"].postfix`.\n */\nfunction compoundHasPostfixClass(node, postfix) {\n  const siblings = node.parent.nodes;\n  const index = siblings.indexOf(node);\n\n  for (let i = index; i >= 0; i--) {\n    if (siblings[i].type === 'combinator') break;\n    if (siblings[i].type === 'class' && siblings[i].value === postfix)\n      return true;\n  }\n\n  for (let i = index + 1; i < siblings.length; i++) {\n    if (siblings[i].type === 'combinator') break;\n    if (siblings[i].type === 'class' && siblings[i].value === postfix)\n      return true;\n  }\n\n  return false;\n}\n\nfunction addPostfixClass(node, postfix) {\n  if (compoundHasPostfixClass(node, postfix)) return;\n\n  node.parent.insertAfter(node, parser.className({ value: postfix }));\n}\n\nfunction rewriteSelector(sel, postfix) {\n  const transform = (selectors) => {\n    // Nodes that need the postfix class added next to them. We collect them\n    // during the walk and insert the classes afterwards so the freshly-inserted\n    // classes are never themselves re-visited by the walk.\n    const needsPostfixClass = [];\n\n    selectors.walk((selector) => {\n      if (isInsideGlobal(selector)) return;\n\n      // We never want to touch psuedo selectors since we and the user doesn't own them.\n      if (selector.type === 'psuedo') return;\n\n      // :nth-of-type has special syntax where the values passed to nth-of-type()\n      // must either be exactly \"odd\", \"even\", or a simple formula\n      //\n      // https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-of-type\n      if (isNthOfType(selector)) return;\n\n      if (selector.type === 'class') {\n        selector.value += '_' + postfix;\n      } else if (selector.type === 'tag') {\n        needsPostfixClass.push(selector);\n      } else if (selector.type === 'attribute') {\n        if (isRenamedClassAttribute(selector)) {\n          // The renamed token (e.g. `foo_postfix`) is already unique per\n          // file, so no postfix class is needed.\n          selector.value = renameClass(selector.value, postfix);\n          if (!selector.quoteMark) selector.quoteMark = '\"';\n        } else {\n          // `[class|=\"foo\"]` and `[class$=\"foo\"]` cannot be reliably scoped\n          // with the postfix class (the postfix class defeats them). That is\n          // surfaced to authors by the\n          // `ember-scoped-css/no-unscopable-class-attribute-selectors`\n          // stylelint rule rather than a runtime warning.\n          needsPostfixClass.push(selector);\n        }\n      }\n    });\n\n    for (const node of needsPostfixClass) {\n      addPostfixClass(node, postfix);\n    }\n\n    // remove :global\n    selectors.walk((selector) => {\n      if (selector.type === 'pseudo' && selector.value === ':global') {\n        selector.replaceWith(...selector.nodes);\n      }\n    });\n  };\n  const transformed = parser(transform).processSync(sel);\n\n  return transformed;\n}\n\nfunction isNthOfType(node) {\n  if (!node) return false;\n\n  return node.parent?.value === ':nth-of-type' || isNthOfType(node.parent);\n}\n\nfunction isInsideKeyframes(node) {\n  const parent = node.parent;\n\n  if (!parent) return false;\n  if (parent.type === 'atrule' && parent.name === 'keyframes') return true;\n\n  return isInsideKeyframes(parent);\n}\n\nexport function rewriteCss(css, postfix, fileName, layerName) {\n  const ast = postcss.parse(css);\n  /**\n   * kind => originalName => postfixedName\n   * @type {{ [kind: string]: { [originalName: string]: string }}}\n   */\n  const referenceables = {\n    keyframes: {},\n    'counter-style': {},\n    'position-try': {},\n    property: {},\n  };\n\n  const availableReferenceables = new Set(Object.keys(referenceables));\n\n  function isReferenceable(node) {\n    if (node.type !== 'atrule') return;\n\n    return availableReferenceables.has(node.name);\n  }\n\n  function updateDirectReferences(node) {\n    if (!node.value) return;\n\n    for (let [, map] of Object.entries(referenceables)) {\n      if (map[node.value]) {\n        node.value = map[node.value];\n      }\n    }\n  }\n\n  function updateShorthandContents(node) {\n    if (node.prop === 'animation') {\n      let parts = node.value.split(' ');\n      let match = parts.filter((x) => referenceables.keyframes[x]);\n\n      if (match.length) {\n        match.forEach((x) => {\n          let replacement = referenceables.keyframes[x];\n\n          if (!replacement) return;\n\n          node.value = node.value.replace(x, replacement);\n        });\n      }\n    }\n\n    for (let [lookFor, replaceWith] of Object.entries(\n      referenceables.property,\n    )) {\n      let lookForVar = `var(${lookFor})`;\n      let replaceWithVar = `var(${replaceWith})`;\n\n      node.value = node.value.replace(lookForVar, replaceWithVar);\n    }\n  }\n\n  /**\n   * We have to do two passes:\n   * 1. postfix all the referenceable syntax\n   * 2. postfix as normal, but also checking values of CSS properties\n   *    that could match postfixed referenceables from step 1\n   */\n\n  // Step 1: find referenceables\n  ast.walk((node) => {\n    /**\n     * @keyframes, @counter-style, etc\n     */\n    if (isReferenceable(node)) {\n      let name = node.name;\n      let { originalName, postfixedName } = rewriteReferenceable(node, postfix);\n\n      referenceables[name][originalName] = postfixedName;\n\n      return;\n    }\n  });\n\n  // Step 2: postfix and update referenced referenceables\n  ast.walk((node) => {\n    if (isDeclaration(node)) {\n      updateDirectReferences(node);\n      updateShorthandContents(node);\n\n      return;\n    }\n\n    if (isRule(node)) {\n      /**\n       * The inner-contents of a keyframe are percentages, rather than selectors\n       */\n      if (isInsideKeyframes(node)) return;\n\n      node.selector = rewriteSelector(node.selector, postfix);\n\n      return;\n    }\n  });\n\n  const rewrittenCss = ast.toString();\n\n  return (\n    [\n      `/* ${fileName} */`,\n      layerName ? `@layer ${layerName} {` : '',\n      rewrittenCss.trimEnd(),\n      layerName ? `}` : '',\n    ]\n      .filter(Boolean)\n      .join('\\n') + '\\n'\n  );\n}\n","import path from 'node:path';\n\nconst KEY = 'ember-scoped.css';\nconst SEP = '___';\n\nexport const request = {\n  is: {\n    inline(request) {\n      return request.includes(KEY);\n    },\n    colocated(request) {\n      return request.includes('.css?scoped=');\n    },\n  },\n  inline: {\n    /**\n     * Makes request URL for embedding `<style>` as `<link>` into the `<head>`\n     *\n     * @param {string} cssHash the hash of the CSS contents\n     * @param {string} postfix the hash of the file that _includes_ the linked file\n     * @param {string} cssContents the contents of the CSS file\n     * @param {string} [lang] optional preprocessor language (e.g. 'scss', 'sass', 'less')\n     */\n    create(cssHash, postfix, cssContents, lang) {\n      let url = `./${postfix}${SEP}${cssHash}.${KEY}?css=${encodeURIComponent(cssContents)}`;\n\n      if (lang) {\n        url += `&lang=${encodeURIComponent(lang)}`;\n      }\n\n      return url;\n    },\n    decode(request) {\n      let [left, qps] = request.split('?');\n\n      left = left.slice(2).replace(`.${KEY}`, '');\n\n      let [postfix, hash] = left.split(SEP);\n\n      let search = new URLSearchParams(qps);\n\n      return {\n        hash,\n        postfix,\n        css: search.get('css'),\n        from: search.get('from'),\n        lang: search.get('lang'),\n      };\n    },\n  },\n  colocated: {\n    /**\n     * Makes request URL for embedding separate CSS File as `<link>` into the `<head>`\n     *\n     * @param {string} cssHash the hash of the CSS contents\n     * @param {string} postfix the hash of the file that _includes_ the linked file\n     * @param {string} filePath path to the separate CSS File\n     */\n    create(cssHash, postfix, filePath) {\n      return `./${path.basename(filePath)}?scoped=${postfix}&cssHash=${cssHash}`;\n    },\n    decode(request) {\n      const [fileName, qs] = request.split('?');\n      const search = new URLSearchParams(qs);\n\n      return {\n        fileName,\n        cssHash: search.get('cssHash'),\n        postfix: search.get('scoped'),\n      };\n    },\n  },\n};\n","import { readFileSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\n\nimport { rewriteCss } from '../lib/css/rewrite.js';\nimport { request } from '../lib/request.js';\n\nconst META = 'scoped-css:colocated';\n\n/** File extensions that Vite can preprocess via its CSS preprocessor pipeline */\nconst PREPROCESSED_EXTENSIONS = new Set([\n  '.scss',\n  '.sass',\n  '.less',\n  '.styl',\n  '.stylus',\n]);\n\n/**\n * Plugin for supporting colocated styles\n *\n * e.g.:\n *  src/components/my-component.js\n *  src/components/my-component.css\n */\nexport function colocated(options = {}) {\n  const CWD = process.cwd();\n\n  /** @type {import('vite').ResolvedConfig | undefined} */\n  let viteConfig;\n\n  /** @type {((code: string, filename: string, config: unknown) => Promise<{ code: string }>) | undefined} */\n  let preprocessCSS;\n\n  /**\n   *\n   * @param {string} id the request id / what was imported\n   * @param {string} filePath  path on disk\n   * @returns\n   */\n  function buildResponse(id, filePath) {\n    const parsed = request.colocated.decode(id);\n    const relativeFilePath = path.relative(CWD, filePath);\n\n    return {\n      id: filePath,\n      meta: {\n        [META]: {\n          postfix: parsed.postfix,\n          fileName: relativeFilePath,\n          fullPath: filePath,\n        },\n      },\n    };\n  }\n\n  return {\n    name: 'ember-scoped-css:colocated',\n    resolveId(id, importer) {\n      // handles: some-file.css?scoped=[postfix]\n      // this is only run in rollup, vite handles it differently\n      if (request.is.colocated(id)) {\n        const parsed = request.colocated.decode(id);\n\n        const filePath = path.resolve(\n          path.dirname(importer),\n          path.basename(parsed.fileName),\n        );\n\n        return buildResponse(id, filePath);\n      }\n    },\n    load(id) {\n      const meta = this.getModuleInfo(id)?.meta?.[META];\n\n      if (meta) {\n        this.addWatchFile(meta.fullPath);\n\n        let code = readFileSync(meta.fullPath, 'utf-8');\n\n        let css = rewriteCss(\n          code,\n          meta.postfix,\n          meta.fileName,\n          options.layerName,\n        );\n\n        return css;\n      }\n    },\n    vite: {\n      async configResolved(config) {\n        viteConfig = config;\n\n        // Resolve Vite's preprocessCSS from the app root to ensure we find\n        // the correct Vite installation (not a stale or missing one).\n        try {\n          const require = createRequire(path.join(config.root, 'package.json'));\n          const vitePath = require.resolve('vite');\n          const viteModule = await import(vitePath);\n\n          preprocessCSS = viteModule.preprocessCSS;\n        } catch {\n          // Vite may not be resolvable from the config root in some setups;\n          // preprocessor support for colocated .scss files will throw a clear\n          // error at load time if used.\n        }\n      },\n\n      /**\n       * There may not be meta for this request yet.\n       *\n       * @param {*} id\n       */\n      async load(id) {\n        if (request.is.colocated(id)) {\n          const parsed = request.colocated.decode(id);\n\n          let code = readFileSync(parsed.fileName, 'utf-8');\n          let relativeFilePath = path.relative(CWD, parsed.fileName);\n\n          const ext = path.extname(parsed.fileName).toLowerCase();\n\n          if (PREPROCESSED_EXTENSIONS.has(ext)) {\n            if (!viteConfig || !preprocessCSS) {\n              throw new Error(\n                `[ember-scoped-css] Colocated CSS file with extension '${ext}' requires Vite. ` +\n                  `CSS preprocessing is only supported in Vite builds.`,\n              );\n            }\n\n            const result = await preprocessCSS(\n              code,\n              parsed.fileName,\n              viteConfig,\n            );\n\n            code = result.code;\n          }\n\n          let css = rewriteCss(\n            code,\n            parsed.postfix,\n            relativeFilePath,\n            options.layerName,\n          );\n\n          return css;\n        }\n      },\n    },\n  };\n}\n","import { createRequire } from 'node:module';\nimport path from 'node:path';\n\nimport { rewriteCss } from '../lib/css/rewrite.js';\nimport { request } from '../lib/request.js';\n\nconst META = 'scoped-css:inline';\n\n/**\n * Plugin for supporting the styles from\n *\n * <template>\n *   <style>...</style>\n * </template>\n *\n * This plugin can't have HMR for CSS because changes to the CSS content alters the template content\n */\nexport function inline(options = {}) {\n  const CWD = process.cwd();\n\n  /** @type {import('vite').ResolvedConfig | undefined} */\n  let viteConfig;\n\n  /** @type {((code: string, filename: string, config: unknown) => Promise<{ code: string }>) | undefined} */\n  let preprocessCSS;\n\n  /**\n   * @param {string} id the request id / what was imported\n   */\n  function buildResponse(id, filePath) {\n    const parsed = request.inline.decode(id);\n\n    const relativeFilePath = path.relative(CWD, filePath);\n\n    return {\n      id: filePath.split('?')[0],\n      meta: {\n        [META]: {\n          rawCss: parsed.css,\n          postfix: parsed.postfix,\n          fileName: relativeFilePath,\n          lang: parsed.lang,\n        },\n      },\n    };\n  }\n\n  return {\n    name: 'ember-scoped-css:inline',\n    resolveId(id, importer) {\n      if (request.is.inline(id)) {\n        const parsed = request.inline.decode(id);\n\n        const filePath = path.resolve(\n          path.dirname(importer),\n          `${path.basename(importer, path.extname(importer))}-${parsed.hash}.css`,\n        );\n\n        return buildResponse(id, filePath);\n      }\n    },\n    async load(id) {\n      const meta = this.getModuleInfo(id)?.meta?.[META];\n\n      if (meta) {\n        let rawCss = meta.rawCss;\n\n        if (meta.lang) {\n          if (!viteConfig || !preprocessCSS) {\n            throw new Error(\n              `[ember-scoped-css] <style scoped lang=\"${meta.lang}\"> requires Vite. ` +\n                `CSS preprocessing via the 'lang' attribute is only supported in Vite builds.`,\n            );\n          }\n\n          const fakeFilename = `${meta.fileName}.${meta.lang}`;\n          const result = await preprocessCSS(rawCss, fakeFilename, viteConfig);\n\n          rawCss = result.code;\n        }\n\n        const css = rewriteCss(\n          rawCss,\n          meta.postfix,\n          `<inline>/${meta.fileName}`,\n          options.layerName,\n        );\n\n        return css;\n      }\n    },\n    vite: {\n      async configResolved(config) {\n        viteConfig = config;\n\n        // Resolve Vite's preprocessCSS from the app root to ensure we find\n        // the correct Vite installation (not a stale or missing one).\n        try {\n          const require = createRequire(path.join(config.root, 'package.json'));\n          const vitePath = require.resolve('vite');\n          const viteModule = await import(vitePath);\n\n          preprocessCSS = viteModule.preprocessCSS;\n        } catch {\n          // Vite may not be resolvable from the config root in some setups;\n          // lang= support will throw a clear error at load time if used.\n        }\n      },\n    },\n  };\n}\n","import { createUnplugin } from 'unplugin';\n\nimport { colocated } from './unplugin-colocated.js';\nimport { inline } from './unplugin-inline.js';\n\n/**\n * The plugin that handles CSS requests for `<style>` elements and transforms\n * for existing files\n *\n * vite: CSS files are resolved by vite. We use their resolver to also get\n *       HMR. That is, for all non-physical CSS files, we extend vite by our\n *       resolver and also can enrich metadata to it (for better debugging)\n */\nexport const unplugin = createUnplugin((options = {}) => {\n  return [colocated(options), inline(options)];\n});\n","import path from 'node:path';\n\nimport { leadingSlashPath } from './const.js';\nimport { findWorkspacePath } from './utils.js';\n\n/**\n * template plugins do not hand us the correct file path.\n * additionally, we may not be able to rely on this data in the future,\n * so this functions acts as a means of normalizing _whatever_ we're given\n * in the future.\n *\n * @param {string} filename\n * @returns {string} the absolute path to the file\n */\nexport function fixFilename(filename) {\n  let fileName = filename;\n  let workspace = findWorkspacePath(fileName);\n\n  /**\n   * ember-source 5.8:\n   * - the filename looks like an absolute path, but swapped out the 'app' part of the path\n   *   with the module name, so the file paths never exist on disk\n   *\n   * - in vite apps:\n   *   the 'app' part _may_ be `src`, so we also need to ensure that `src` is excluded as well\n   */\n  let hasAppDir = fileName.includes(path.join(workspace, 'app'));\n  let hasSrcDir = fileName.includes(path.join(workspace, 'src'));\n\n  if (\n    !(hasAppDir || hasSrcDir) &&\n    !fileName.includes(leadingSlashPath.embroiderDir)\n  ) {\n    let maybeModule = fileName.replace(workspace, '');\n    let [maybeScope, ...rest] = maybeModule.split(path.sep).filter(Boolean);\n    let parts = rest;\n\n    if (maybeScope.startsWith('@')) {\n      let [, ...rester] = rest;\n\n      parts = rester;\n    }\n\n    let relative = path.join(...parts);\n\n    /**\n     * We don't actually know if this file is an app.\n     * it could be an addon (v1 or v2)\n     *\n     * So here we log to see if we have unhandled situations.\n     */\n    let candidatePath = path.join(workspace, 'app', relative);\n\n    return candidatePath;\n  }\n\n  // TODO: why are we passed files to other projects?\n  if (!fileName.includes(workspace)) {\n    return fileName;\n  }\n\n  // Fallback to what the plugin system gives us.\n  // This may be wrong, and if wrong, reveals\n  // unhandled scenarios with the file names in the plugin infra\n  return fileName;\n}\n","import * as recast from 'ember-template-recast';\n\nimport { renameClass } from './renameClass.js';\n\n/**\n * Whether an element may carry an attribute that appears in a scoped\n * attribute selector. This includes component invocations: a component\n * receives the postfix class through its `...attributes` the same way it\n * receives the matched attribute, so `[type=\"text\"]` scopes\n * `<Foo type=\"text\">` just as it scopes `<input type=\"text\">`.\n *\n * An element that spreads `...attributes` can receive any attribute from its\n * caller at runtime, so it counts as long as the CSS scopes by attribute at\n * all — the preserved attribute selector still decides which rules actually\n * apply.\n *\n * `attributes` comes from parsing the CSS, so it can only contain valid\n * attribute-selector names — `@args` can never be in it and needs no special\n * handling.\n *\n * Names in `attributes` are lowercased at discovery (CSS matches HTML\n * attribute names case-insensitively), so compare lowercased.\n */\nfunction elementHasScopedAttribute(node, attributes) {\n  if (attributes.size === 0) return false;\n\n  return node.attributes.some(\n    (attr) =>\n      attr.name === '...attributes' || attributes.has(attr.name.toLowerCase()),\n  );\n}\n\nexport function templatePlugin({ classes, tags, attributes, postfix }) {\n  let stack = [];\n  // scoped-class is a global we allow in hbs\n  // scopedClass is importable, and we'll error if someone tries to rename it\n  let scopedClassCandidates = ['scoped-class', 'scopedClass'];\n\n  function isScopedClass(str) {\n    if (!str) return false;\n\n    return scopedClassCandidates.some((candidate) => candidate === str);\n  }\n\n  return {\n    AttrNode(node) {\n      if (node.name === 'class') {\n        if (node.value.type === 'TextNode' && node.value.chars) {\n          const renamedClass = renameClass(node.value.chars, postfix, classes);\n\n          node.value.chars = renamedClass;\n        } else if (node.value.type === 'ConcatStatement') {\n          for (let part of node.value.parts) {\n            if (part.type === 'TextNode' && part.chars) {\n              const renamedClass = renameClass(part.chars, postfix, classes);\n\n              part.chars = renamedClass;\n            } else if (part.type === 'MustacheStatement') {\n              recast.traverse(part, {\n                StringLiteral(node) {\n                  const renamedClass = renameClass(\n                    node.value,\n                    postfix,\n                    classes,\n                  );\n\n                  node.value = renamedClass;\n                },\n              });\n            }\n          }\n        }\n      }\n    },\n\n    ElementNode(node) {\n      // An element is in scope if its tag matches a tag selector, or if it\n      // carries an attribute named in a scoped attribute selector. We add the\n      // postfix class at most once regardless of how many things matched.\n      const shouldScope =\n        tags.has(node.tag) || elementHasScopedAttribute(node, attributes);\n\n      if (!shouldScope) return;\n\n      // check if class attribute already exists\n      const classAttr = node.attributes.find((attr) => attr.name === 'class');\n\n      if (!classAttr) {\n        // push class attribute\n        node.attributes.push(\n          recast.builders.attr('class', recast.builders.text(postfix)),\n        );\n      } else if (classAttr.value.type === 'TextNode') {\n        classAttr.value.chars += ' ' + postfix;\n      } else if (classAttr.value.type === 'ConcatStatement') {\n        // class=\"foo {{bar}}\"\n        classAttr.value.parts.push(recast.builders.text(' ' + postfix));\n      } else {\n        // class={{this.foo}} — wrap in a concat so we can append the text part\n        classAttr.value = recast.builders.concat([\n          classAttr.value,\n          recast.builders.text(' ' + postfix),\n        ]);\n        classAttr.quoteType = '\"';\n      }\n    },\n\n    All: {\n      enter(node) {\n        stack.push(node);\n      },\n      exit() {\n        stack.pop();\n      },\n    },\n\n    MustacheStatement(node) {\n      let cssClass;\n\n      if (\n        isScopedClass(getValue(node.path)) &&\n        node.params?.length === 1 &&\n        node.params[0].type === 'StringLiteral'\n      ) {\n        cssClass = node.params[0].value;\n      }\n\n      if (\n        isScopedClass(getValue(node.path?.path)) &&\n        node.path?.params?.length === 1 &&\n        node.path?.params[0].type === 'StringLiteral'\n      ) {\n        cssClass = node.path.params[0].value;\n      }\n\n      if (cssClass) {\n        const textNode = recast.builders.text(renameClass(cssClass, postfix));\n        const parent = stack[stack.length - 1];\n\n        if (parent?.type === 'AttrNode') {\n          parent.quoteType = '\"';\n        }\n\n        return textNode;\n      }\n    },\n\n    SubExpression(node) {\n      if (\n        isScopedClass(getValue(node.path)) &&\n        node.params?.length === 1 &&\n        node.params[0].type === 'StringLiteral'\n      ) {\n        const cssClass = node.params[0].value;\n        const textNode = recast.builders.literal(\n          'StringLiteral',\n          renameClass(cssClass, postfix),\n        );\n\n        return textNode;\n      }\n    },\n  };\n}\n\nfunction getValue(path) {\n  if (!path) return;\n\n  if ('value' in path) {\n    return path.value;\n  }\n\n  /**\n   * Deprecated in ember 5.9+\n   * (so we use the above for newer embers)\n   */\n  return path.original;\n}\n\nexport default function rewriteHbs(\n  hbs,\n  classes,\n  tags,\n  postfix,\n  attributes = new Set(),\n) {\n  let ast = recast.parse(hbs);\n\n  recast.traverse(ast, templatePlugin({ classes, tags, attributes, postfix }));\n\n  let result = recast.print(ast);\n\n  return result;\n}\n","/**\n * @typedef {import('@glimmer/syntax').ASTPlugin} ASTPlugin\n * @typedef {import('@glimmer/syntax').ASTPluginEnvironment} ASTPluginEnvironment\n *\n */\n\nimport path from 'node:path';\nimport process from 'node:process';\n\nimport { rewriteCss } from '../lib/css/rewrite.js';\nimport { getCSSContentInfo, getCSSInfo } from '../lib/css/utils.js';\nimport { fixFilename } from '../lib/path/template-transform-paths.js';\nimport {\n  appPath,\n  cssPathFor,\n  forcePosix,\n  hashFromModulePath,\n  isRelevantFile,\n} from '../lib/path/utils.js';\nimport { request } from '../lib/request.js';\nimport { templatePlugin } from '../lib/rewriteHbs.js';\n\nconst noopPlugin = {\n  name: 'ember-scoped-css:noop',\n  visitor: {},\n};\n\n/**\n * @returns {ASTPlugin}\n */\nexport function createPlugin(config) {\n  /**\n   *\n   * @param {ASTPluginEnvironment} env\n   */\n  return function scopedCss(env) {\n    let cwd = process.cwd();\n\n    let isRelevant = isRelevantFile(env.filename, {\n      additionalRoots: config.additionalRoots,\n      cwd,\n    });\n\n    if (!isRelevant) {\n      return noopPlugin;\n    }\n\n    let absolutePath = fixFilename(env.filename);\n    let modulePath = appPath(absolutePath);\n    let postfix = hashFromModulePath(modulePath);\n\n    /**\n     * The list of naked tag selectors found in the CSS\n     *\n     * @type {Set<string>}\n     */\n    let scopedTags = new Set();\n\n    /**\n     * The list of classes found in the CSS\n     *\n     * @type {Set<string>}\n     */\n    let scopedClasses = new Set();\n\n    /**\n     * The attribute names found in attribute selectors in the CSS, used to\n     * mark matching elements with the scope class.\n     *\n     * @type {Set<string>}\n     */\n    let scopedAttributes = new Set();\n\n    /**\n     * @param {{ tags: Set<string>; classes: Set<string>; attributes: Set<string> }} info\n     */\n    function addInfo(info) {\n      for (let item of info.tags) {\n        scopedTags.add(item);\n      }\n\n      for (let item of info.classes) {\n        scopedClasses.add(item);\n      }\n\n      for (let item of info.attributes) {\n        scopedAttributes.add(item);\n      }\n    }\n\n    let cssPath = cssPathFor(absolutePath);\n    let info = getCSSInfo(cssPath);\n    let localCssPath = forcePosix(cssPath.replace(cwd + path.sep, ''));\n\n    /**\n     * This will be falsey if we don't have a co-located CSS file.\n     * We'll still want to check for embedded <style scoped> tags though.\n     */\n    if (info) {\n      addInfo(info);\n\n      let cssRequest = request.colocated.create(info.id, postfix, localCssPath);\n\n      /**\n       * With this we don't need a JS plugin\n       */\n      env.meta.jsutils.importForSideEffect(cssRequest);\n    }\n\n    let visitors = templatePlugin({\n      classes: scopedClasses,\n      tags: scopedTags,\n      attributes: scopedAttributes,\n      postfix,\n    });\n\n    return {\n      name: 'ember-scoped-css:template-plugin',\n      visitor: {\n        // Stack Manager\n        ...visitors,\n\n        /**\n         * We have to eagerly get the <style scoped> contents, so we can pre-parse\n         * the tags and classes to then pass to the other visitors so that they can\n         * appropriately change matching classes / tags.\n         */\n        Template(node) {\n          /**\n           * We only allow a scoped <style> at the root\n           */\n          let styleTag = node.body.find(\n            (n) => n.type === 'ElementNode' && n.tag === 'style',\n          );\n\n          if (hasScopedAttribute(styleTag)) {\n            let css = textContent(styleTag);\n            let lang = getLangAttribute(styleTag);\n            let info = getCSSContentInfo(css, lang);\n\n            addInfo(info);\n\n            if (hasInlineAttributeWithoutLang(styleTag)) {\n              /**\n               * This will be handled in ElementNode traversal\n               */\n              return;\n            }\n\n            if (lang) {\n              /**\n               * For <style scoped inline lang=\"...\"> we cannot preprocess at Babel-time\n               * (preprocessing is async and requires Vite's ResolvedConfig).\n               * Remove the tag and inject via virtual CSS module and warn user.\n               */\n              console.warn(\n                `[ember-scoped-css] <style scoped inline lang=\"${lang}\"> is not supported ` +\n                  `(preprocessing is async and cannot run at Babel-time). ` +\n                  `Downgrading to non-inline: the style tag will be removed and injected as a virtual CSS module.`,\n              );\n            }\n\n            let cssRequest = request.inline.create(info.id, postfix, css, lang);\n\n            env.meta.jsutils.importForSideEffect(cssRequest);\n          }\n        },\n\n        // Visitors broken out like this so we can conditionally\n        // debug based on file path.\n        AttrNode(...args) {\n          return visitors.AttrNode(...args);\n        },\n        ElementNode(node, walker) {\n          // class attribute handling\n          visitors.ElementNode(node, walker);\n\n          if (hasScopedAttribute(node)) {\n            if (walker.parent?.node.type !== 'Template') {\n              throw new Error(\n                '<style scoped> tags must be at the root of the template, they cannot be nested',\n              );\n            }\n\n            if (hasInlineAttributeWithoutLang(node)) {\n              let text = textContent(node);\n              let scopedText = rewriteCss(\n                text,\n                postfix,\n                localCssPath,\n                config.layerName,\n              );\n\n              /**\n               * Traverse this and allow interpolation\n               */\n              node.children = [env.syntax.builders.text(scopedText)];\n\n              return;\n            }\n\n            // Returning null removes the node\n            return null;\n          }\n\n          if (hasInlineAttributeWithoutLang(node)) {\n            throw new Error(\n              `<style inline> is not valid. Please add the scoped attribute: <style scoped inline>`,\n            );\n          }\n        },\n        MustacheStatement(...args) {\n          return visitors.MustacheStatement(...args);\n        },\n        SubExpression(...args) {\n          return visitors.SubExpression(...args);\n        },\n      },\n    };\n  };\n}\n\n/**\n * Thanks, CardStack and @ef4 for this code.\n */\nconst SCOPED_ATTRIBUTE_NAME = 'scoped';\nconst INLINE_ATTRIBUTE_NAME = 'inline';\nconst LANG_ATTRIBUTE_NAME = 'lang';\n\nfunction hasScopedAttribute(node) {\n  if (!node) return;\n  if (node.tag !== 'style') return;\n  if (node.type !== 'ElementNode') return;\n\n  return node.attributes.some(\n    (attribute) => attribute.name === SCOPED_ATTRIBUTE_NAME,\n  );\n}\n\nfunction hasInlineAttributeWithoutLang(node) {\n  if (!node) return;\n  if (node.tag !== 'style') return;\n  if (node.type !== 'ElementNode') return;\n\n  if (getLangAttribute(node)) {\n    return false;\n  }\n\n  return node.attributes.some(\n    (attribute) => attribute.name === INLINE_ATTRIBUTE_NAME,\n  );\n}\n\n/**\n * Returns the value of the `lang` attribute on a `<style>` node, or null if absent.\n *\n * @param {object} node\n * @returns {string | null}\n */\nfunction getLangAttribute(node) {\n  if (!node) return null;\n  if (node.tag !== 'style') return null;\n  if (node.type !== 'ElementNode') return null;\n\n  const attr = node.attributes.find(\n    (attribute) => attribute.name === LANG_ATTRIBUTE_NAME,\n  );\n\n  if (!attr) return null;\n\n  // The attribute value is a TextNode child of the AttrNode's value\n  const value = attr.value;\n\n  if (value?.type === 'TextNode') return value.chars || null;\n\n  return null;\n}\n\nfunction textContent(node) {\n  let textChildren = node.children.filter((c) => c.type === 'TextNode');\n\n  return textChildren.map((c) => c.chars).join('');\n}\n","import * as babel from '../babel-plugin.js';\nimport { unplugin } from '../scoped-css-unplugin.js';\nimport * as template from '../template-plugin.js';\n\nexport const scopedCSS = {\n  vite: unplugin.vite,\n  rollup: unplugin.rollup,\n  babel: babel.scopedCSS,\n  template: template.createPlugin,\n};\n"],"mappings":"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"}