@unocss/svelte-scoped 66.5.10 → 66.5.12

package/dist/preprocess-DHIfuYme.d.mts

@@ -0,0 +1,7 @@
+import { a as UnocssSveltePreprocessOptions, t as SvelteScopedContext } from "./types-lojsQv1_.mjs";
+import { PreprocessorGroup } from "svelte/types/compiler/preprocess";
+
+//#region src/_preprocess/index.d.ts
+declare function UnocssSveltePreprocess(options?: UnocssSveltePreprocessOptions, unoContextFromVite?: SvelteScopedContext, isViteBuild?: () => boolean): PreprocessorGroup;
+//#endregion
+export { UnocssSveltePreprocess as t };

package/dist/preprocess-smYe4zo2.mjs

@@ -0,0 +1,563 @@
+import process from "node:process";
+import { createRecoveryConfigLoader } from "@unocss/config";
+import { createGenerator, expandVariantGroup, regexScopePlaceholder, toArray, warnOnce } from "@unocss/core";
+import presetWind3 from "@unocss/preset-wind3";
+import MagicString from "magic-string";
+import * as acorn from "acorn";
+import { walk } from "zimmerframe";
+import { clone, generate, parse, walk as walk$1 } from "css-tree";
+
+//#region src/_preprocess/transformClasses/addGeneratedStyles.ts
+const actualStylesTagWithCapturedDirectivesRE = new RegExp(/(?<!<!--\s*)/.source + /<style([^>]*)>[\s\S]*?<\/style\s*>/.source, "g");
+const captureOpeningStyleTagWithAttributesRE = /(<style[^>]*>)/;
+function addGeneratedStylesIntoStyleBlock(code, styles) {
+	if (code.match(actualStylesTagWithCapturedDirectivesRE)) return code.replace(captureOpeningStyleTagWithAttributesRE, `$1${styles}`);
+	return `${code}\n<style>${styles}</style>`;
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/findClasses.ts
+const classesRE$1 = /class=(["'`])([\s\S]*?)\1/g;
+const classDirectivesRE = /class:(\S+?)="?\{/g;
+const classDirectivesShorthandRE = /class:([^=>\s/]+)[{>\s/]/g;
+const classClsxRE = /(?<prefix>class=\{\w*)[[{(]/g;
+function findClasses(code) {
+	const matchedClasses = [...code.matchAll(classesRE$1)];
+	const matchedClassDirectives = [...code.matchAll(classDirectivesRE)];
+	const matchedClassDirectivesShorthand = [...code.matchAll(classDirectivesShorthandRE)];
+	const matchedClassClsx = [...code.matchAll(classClsxRE)];
+	const classes = parseMatches(matchedClasses, "regular", 7);
+	const classDirectives = parseMatches(matchedClassDirectives, "directive", 6);
+	const classDirectivesShorthand = parseMatches(matchedClassDirectivesShorthand, "directiveShorthand", 6);
+	const classClsx = parseMatchesWithAcorn(matchedClassClsx, code);
+	return [
+		...classes,
+		...classDirectives,
+		...classDirectivesShorthand,
+		...classClsx
+	];
+}
+function parseMatches(matches, type, prefixLength) {
+	return matches.map((match) => {
+		const body = match[type === "regular" ? 2 : 1];
+		const start = match.index + prefixLength;
+		return {
+			body: body.trim(),
+			start,
+			end: start + body.length,
+			type
+		};
+	}).filter(hasBody);
+}
+function hasBody(foundClass) {
+	return foundClass.body;
+}
+function parseMatchesWithAcorn(matches, code) {
+	return matches.flatMap((match) => {
+		const start = match.index + match.groups.prefix.length;
+		const ast = acorn.parseExpressionAt(code, start, {
+			sourceType: "module",
+			ecmaVersion: 16,
+			locations: true
+		});
+		const classes = [];
+		function fromProperty(body, node, property) {
+			return {
+				body,
+				start: node.start,
+				end: node.end,
+				type: property.shorthand ? "clsxObjectShorthand" : "clsxObject"
+			};
+		}
+		function fromString(body, node) {
+			return {
+				body,
+				start: node.start + 1,
+				end: node.end - 1,
+				type: "regular"
+			};
+		}
+		walk(ast, { property: void 0 }, {
+			Property(node, { visit }) {
+				visit(node.key, { property: node });
+			},
+			Identifier(node, { state, next }) {
+				if (state.property) classes.push(fromProperty(node.name, node, state.property));
+				next();
+			},
+			Literal(node, { state, next }) {
+				if (typeof node.value === "string") {
+					const body = node.value;
+					if (state.property) classes.push(fromProperty(body, node, state.property));
+					else classes.push(fromString(body, node));
+				}
+				next();
+			},
+			TemplateLiteral(node, { state, next }) {
+				if (node.expressions.length === 0 && node.quasis.length === 1) {
+					const body = node.quasis[0].value.raw;
+					if (state.property) classes.push(fromProperty(body, node, state.property));
+					else classes.push(fromString(body, node));
+				}
+				next();
+			}
+		});
+		return classes;
+	}).filter(hasBody);
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/hash.ts
+function hash(str) {
+	let i;
+	let l;
+	let hval = 2166136261;
+	for (i = 0, l = str.length; i < l; i++) {
+		hval ^= str.charCodeAt(i);
+		hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
+	}
+	return `00000${(hval >>> 0).toString(36)}`.slice(-6);
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/generateClassName.ts
+function generateClassName(body, options, filename) {
+	const { classPrefix = "uno-", combine = true, hashFn = hash } = options;
+	if (combine) return `${classPrefix}${hashFn(body + filename)}`;
+	else return `_${body}_${hashFn(filename)}`;
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/isShortcut.ts
+function isShortcut(token, shortcuts) {
+	return shortcuts.some((s) => s[0] === token);
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/needsGenerated.ts
+async function needsGenerated(token, uno) {
+	if (uno.config.safelist.includes(token)) return false;
+	return !!await uno.parseToken(token);
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/sortClassesIntoCategories.ts
+async function sortClassesIntoCategories(body, options, uno, filename) {
+	const { combine = true } = options;
+	const rulesToGenerate = {};
+	const ignore = [];
+	const classes = body.trim().split(/\s+/);
+	const knownClassesToCombine = [];
+	for (const token of classes) {
+		if (!(isShortcut(token, uno.config.shortcuts) || await needsGenerated(token, uno))) {
+			ignore.push(token);
+			continue;
+		}
+		if (combine) knownClassesToCombine.push(token);
+		else {
+			const generatedClassName = generateClassName(token, options, filename);
+			rulesToGenerate[generatedClassName] = [token];
+		}
+	}
+	if (knownClassesToCombine.length) {
+		const generatedClassName = generateClassName(knownClassesToCombine.join(" "), options, filename);
+		rulesToGenerate[generatedClassName] = knownClassesToCombine;
+	}
+	return {
+		rulesToGenerate,
+		ignore
+	};
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/processExpressions.ts
+const expressionsRE = /\S*\{[^{}]+\}\S*/g;
+const classesRE = /(?<=\?\s*|:\s*)(["'`])([\s\S]*?)\1/g;
+async function processExpressions(body, options, uno, filename) {
+	const rulesToGenerate = {};
+	const updatedExpressions = [];
+	let restOfBody = body;
+	const expressions = [...body.matchAll(expressionsRE)];
+	for (let [expression] of expressions) {
+		restOfBody = restOfBody.replace(expression, "").trim();
+		const classes = [...expression.matchAll(classesRE)];
+		for (const [withQuotes, quoteMark, withoutQuotes] of classes) {
+			const { rulesToGenerate: rulesFromExpression, ignore } = await sortClassesIntoCategories(withoutQuotes, options, uno, filename);
+			Object.assign(rulesToGenerate, rulesFromExpression);
+			const updatedClasses = Object.keys(rulesFromExpression).concat(ignore).join(" ");
+			expression = expression.replace(withQuotes, quoteMark + updatedClasses + quoteMark);
+		}
+		updatedExpressions.push(expression);
+	}
+	return {
+		rulesToGenerate,
+		updatedExpressions,
+		restOfBody
+	};
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/processClassBody.ts
+async function processClassBody({ body, start, end }, options, uno, filename) {
+	const { rulesToGenerate: rulesFromExpressions, restOfBody, updatedExpressions } = await processExpressions(expandVariantGroup(body), options, uno, filename);
+	const { rulesToGenerate: rulesFromRegularClasses, ignore } = await sortClassesIntoCategories(restOfBody, options, uno, filename);
+	const rulesToGenerate = {
+		...rulesFromExpressions,
+		...rulesFromRegularClasses
+	};
+	if (!Object.keys(rulesToGenerate).length) return {};
+	return {
+		rulesToGenerate,
+		codeUpdate: {
+			content: Object.keys(rulesFromRegularClasses).concat(ignore).concat(updatedExpressions).join(" "),
+			start,
+			end
+		}
+	};
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/processDirective.ts
+async function processDirective({ body: token, start, end, type }, options, uno, filename) {
+	if (!(isShortcut(token, uno.config.shortcuts) || await needsGenerated(token, uno))) return;
+	const generatedClassName = generateClassName(token, options, filename);
+	const content = type === "directiveShorthand" ? `${generatedClassName}={${token}}` : generatedClassName;
+	return {
+		rulesToGenerate: { [generatedClassName]: [token] },
+		codeUpdate: {
+			content,
+			start,
+			end
+		}
+	};
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/processClsx.ts
+async function processClsx(cls, options, uno, filename) {
+	if (cls.type === "clsxObject") {
+		const { rulesToGenerate, codeUpdate } = await processClassBody({
+			...cls,
+			type: "regular"
+		}, options, uno, filename);
+		if (rulesToGenerate && codeUpdate) {
+			codeUpdate.content = `"${codeUpdate.content}"`;
+			return {
+				rulesToGenerate,
+				codeUpdate
+			};
+		}
+	} else if (cls.type === "clsxObjectShorthand") {
+		const { rulesToGenerate, codeUpdate } = await processDirective({
+			...cls,
+			type: "directive"
+		}, options, uno, filename) ?? {};
+		if (rulesToGenerate && codeUpdate) {
+			codeUpdate.content = `"${codeUpdate.content}": ${cls.body}`;
+			return {
+				rulesToGenerate,
+				codeUpdate
+			};
+		}
+	}
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/processClasses.ts
+async function processClasses(classes, options, uno, filename) {
+	const result = {
+		rulesToGenerate: {},
+		codeUpdates: []
+	};
+	for (const foundClass of classes) {
+		const { rulesToGenerate, codeUpdate } = await processClass(foundClass, options, uno, filename);
+		if (rulesToGenerate) Object.assign(result.rulesToGenerate, rulesToGenerate);
+		if (codeUpdate) result.codeUpdates.push(codeUpdate);
+	}
+	return result;
+}
+async function processClass(foundClass, options, uno, filename) {
+	if (foundClass.type === "regular") return await processClassBody(foundClass, options, uno, filename);
+	if (foundClass.type === "clsxObject" || foundClass.type === "clsxObjectShorthand") return await processClsx(foundClass, options, uno, filename) ?? {};
+	return await processDirective(foundClass, options, uno, filename) ?? {};
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/wrapGlobal.ts
+const EXTRACT_SELECTOR_RE = new RegExp(/(?<![\d(])/.source + /([[.][\s\S]+?)/.source + /(\{[\s\S]+?\})/.source, "g");
+function wrapSelectorsWithGlobal(css) {
+	return css.replace(EXTRACT_SELECTOR_RE, ":global($1)$2");
+}
+
+//#endregion
+//#region src/_preprocess/transformClasses/index.ts
+async function transformClasses({ content, filename, uno, options }) {
+	const classesToProcess = findClasses(content);
+	if (!classesToProcess.length) return;
+	const { rulesToGenerate, codeUpdates } = await processClasses(classesToProcess, options, uno, filename);
+	if (!Object.keys(rulesToGenerate).length) return;
+	const { map, code } = updateTemplateCodeIfNeeded(codeUpdates, content, filename);
+	return {
+		code: addGeneratedStylesIntoStyleBlock(code, await generateStyles(rulesToGenerate, uno)),
+		map
+	};
+}
+function updateTemplateCodeIfNeeded(codeUpdates, source, filename) {
+	if (!codeUpdates.length) return {
+		code: source,
+		map: void 0
+	};
+	const s = new MagicString(source);
+	for (const { start, end, content } of codeUpdates) s.overwrite(start, end, content);
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: true,
+			source: filename
+		})
+	};
+}
+const REMOVE_COMMENTS_TO_MAKE_GLOBAL_WRAPPING_EASY = true;
+async function generateStyles(rulesToGenerate, uno) {
+	const shortcutsForThisComponent = Object.entries(rulesToGenerate);
+	uno.config.shortcuts.push(...shortcutsForThisComponent);
+	const selectorsToGenerate = Object.keys(rulesToGenerate);
+	const { css } = await uno.generate(selectorsToGenerate, {
+		preflights: false,
+		safelist: false,
+		minify: REMOVE_COMMENTS_TO_MAKE_GLOBAL_WRAPPING_EASY
+	});
+	return wrapSelectorsWithGlobal(css);
+}
+
+//#endregion
+//#region src/_preprocess/transformApply/getUtils.ts
+async function getUtils(body, uno) {
+	return (await parseUtils(expandVariantGroup(body).split(/\s+/g).map((className) => className.trim().replace(/\\/, "")), uno)).sort(([aIndex], [bIndex]) => aIndex - bIndex).sort(([, , , aParent], [, , , bParent]) => (aParent ? uno.parentOrders.get(aParent) ?? 0 : 0) - (bParent ? uno.parentOrders.get(bParent) ?? 0 : 0)).reduce((acc, item) => {
+		const [, selector, body$1, parent] = item;
+		const sibling = acc.find(([, targetSelector, , targetParent]) => targetSelector === selector && targetParent === parent);
+		if (sibling) sibling[2] += body$1;
+		else acc.push([...item]);
+		return acc;
+	}, []);
+}
+async function parseUtils(classNames, uno) {
+	const foundUtils = [];
+	for (const token of classNames) {
+		const util = await uno.parseToken(token, "-");
+		if (util) foundUtils.push(util);
+		else warnOnce(`'${token}' not found. You have a typo or need to add a preset.`);
+	}
+	return foundUtils.flat();
+}
+
+//#endregion
+//#region src/_preprocess/transformApply/removeOuterQuotes.ts
+function removeOuterQuotes(input) {
+	if (!input) return "";
+	return /^(['"]).*\1$/.test(input) ? input.slice(1, -1) : input;
+}
+
+//#endregion
+//#region src/_preprocess/transformApply/writeUtilStyles.ts
+function writeUtilStyles([, selector, body, parent], s, node, childNode) {
+	if (!selector) return;
+	const selectorChanged = selector !== ".\\-";
+	if (!parent && !selectorChanged) return s.appendRight(childNode.loc.end.offset, body);
+	const originalSelector = generate(node.prelude);
+	if (parent && !selectorChanged) {
+		const css$1 = `${parent}{${originalSelector}{${body}}}`;
+		return s.appendLeft(node.loc.end.offset, css$1);
+	}
+	const rule = `${surroundAllButOriginalSelectorWithGlobal(originalSelector, generateUpdatedSelector(selector.replace(regexScopePlaceholder, " "), node.prelude))}{${body}}`;
+	const css = parent ? `${parent}{${rule}}` : rule;
+	s.appendLeft(node.loc.end.offset, css);
+}
+function generateUpdatedSelector(selector, _prelude) {
+	const selectorAST = parse(selector, { context: "selector" });
+	const prelude = clone(_prelude);
+	prelude.children.forEach((child) => {
+		const parentSelectorAst = clone(selectorAST);
+		parentSelectorAst.children.forEach((i) => {
+			if (i.type === "ClassSelector" && i.name === "\\-") Object.assign(i, clone(child));
+		});
+		Object.assign(child, parentSelectorAst);
+	});
+	return generate(prelude);
+}
+function surroundAllButOriginalSelectorWithGlobal(originalSelector, updatedSelector) {
+	const wrapWithGlobal = (str) => `:global(${str})`;
+	const originalSelectors = originalSelector.split(",").map((s) => s.trim());
+	const updatedSelectors = updatedSelector.split(",").map((s) => s.trim());
+	return originalSelectors.map((original, index) => {
+		const [prefix, suffix] = updatedSelectors[index].split(original).map((s) => s.trim());
+		const wrappedPrefix = prefix ? wrapWithGlobal(prefix) : "";
+		if (!suffix) return `${wrappedPrefix} ${original}`.trim();
+		const indexOfFirstCombinator = findFirstCombinatorIndex(suffix);
+		if (indexOfFirstCombinator === -1) return `${wrappedPrefix} ${original}${suffix}`.trim();
+		return `${wrappedPrefix} ${original}${suffix.substring(0, indexOfFirstCombinator).trim()} ${wrapWithGlobal(suffix.substring(indexOfFirstCombinator).trim())}`.trim();
+	}).join(", ");
+}
+function findFirstCombinatorIndex(input) {
+	for (const c of [
+		" ",
+		">",
+		"~",
+		"+"
+	]) {
+		const indexOfFirstCombinator = input.indexOf(c);
+		if (indexOfFirstCombinator !== -1) return indexOfFirstCombinator;
+	}
+	return -1;
+}
+
+//#endregion
+//#region src/_preprocess/transformApply/index.ts
+async function transformApply(ctx) {
+	const ast = parse(ctx.s.original, {
+		parseAtrulePrelude: false,
+		positions: true
+	});
+	if (ast.type !== "StyleSheet") return ctx.s;
+	const stack = [];
+	walk$1(ast, (node) => {
+		if (node.type === "Rule") stack.push(handleApply(ctx, node));
+	});
+	await Promise.all(stack);
+	return ctx.s;
+}
+/** transformerDirectives's handleApply function checks for style nesting (childNode.type === 'Raw') but we are not supporting it here as it is not valid syntax in Svelte style tags. If browser support becomes mainstream and Svelte updates in kind, we can support that. */
+async function handleApply(ctx, node) {
+	const parsePromises = node.block.children.map(async (childNode) => {
+		await parseApply(ctx, node, childNode);
+	});
+	await Promise.all(parsePromises);
+}
+async function parseApply({ s, uno, applyVariables }, node, childNode) {
+	const body = getChildNodeValue(childNode, applyVariables);
+	if (!body) return;
+	const utils = await getUtils(body, uno);
+	if (!utils.length) return;
+	let end = childNode.loc.end.offset;
+	if (s.slice(end, end + 1) === ";") end += 1;
+	s.remove(childNode.loc.start.offset, end);
+	for (const util of utils) writeUtilStyles(util, s, node, childNode);
+}
+function getChildNodeValue(childNode, applyVariables) {
+	if (childNode.type === "Atrule" && childNode.name === "apply" && childNode.prelude && childNode.prelude.type === "Raw") return childNode.prelude.value.trim();
+	if (childNode.type === "Declaration" && applyVariables.includes(childNode.property) && childNode.value.type === "Raw") return removeOuterQuotes(childNode.value.value.trim());
+}
+
+//#endregion
+//#region src/_preprocess/transformTheme.ts
+const themeRE = /theme\((.+?)\)/g;
+function transformTheme(s, theme) {
+	return s.replace(themeRE, (_, match) => {
+		return getThemeValue(match.slice(1, -1), theme);
+	});
+}
+function getThemeValue(rawArguments, theme) {
+	const keys = rawArguments.split(".");
+	let current = theme;
+	for (const key of keys) if (current[key] === void 0) throw new Error(`"${rawArguments}" is not found in your theme`);
+	else current = current[key];
+	return current;
+}
+
+//#endregion
+//#region src/_preprocess/transformStyle.ts
+const DEFAULT_APPLY_VARIABLES = ["--at-apply"];
+function checkForApply(content, _applyVariables) {
+	if (_applyVariables === false) return {
+		hasApply: false,
+		applyVariables: []
+	};
+	const applyVariables = toArray(_applyVariables || DEFAULT_APPLY_VARIABLES);
+	return {
+		hasApply: content.includes("@apply") || applyVariables.some((v) => content.includes(v)),
+		applyVariables
+	};
+}
+async function transformStyle({ content, uno, prepend, filename, applyVariables, transformThemeFn }) {
+	const s = new MagicString(content);
+	if (applyVariables?.length) await transformApply({
+		s,
+		uno,
+		applyVariables
+	});
+	if (transformThemeFn) transformTheme(s, uno.config.theme);
+	if (!s.hasChanged()) return;
+	if (prepend) s.prepend(prepend);
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: true,
+			source: filename || ""
+		})
+	};
+}
+
+//#endregion
+//#region src/_preprocess/index.ts
+function UnocssSveltePreprocess(options = {}, unoContextFromVite, isViteBuild) {
+	if (!options.classPrefix) options.classPrefix = "usp-";
+	let uno;
+	const makeGenerator = async () => {
+		if (unoContextFromVite) {
+			await unoContextFromVite.ready;
+			return unoContextFromVite.uno;
+		}
+		const defaults = { presets: [presetWind3()] };
+		return await createGenerator((await createRecoveryConfigLoader()(process.cwd(), options.configOrPath)).config, defaults);
+	};
+	return {
+		markup: async ({ content, filename }) => {
+			uno ??= await makeGenerator();
+			if (isViteBuild && options.combine === void 0) options.combine = isViteBuild();
+			return await transformClasses({
+				content,
+				filename: filename || "",
+				uno,
+				options
+			});
+		},
+		style: async ({ content, attributes, filename }) => {
+			const svelte3AddPreflights = attributes["uno:preflights"];
+			const svelte3AddSafelist = attributes["uno:safelist"];
+			const svelte4DeprecatedAddPreflights = attributes.uno && attributes.preflights;
+			const svelte4DeprecatedAddSafelist = attributes.uno && attributes.safelist;
+			let addPreflights = attributes["uno-preflights"] || svelte3AddPreflights || svelte4DeprecatedAddPreflights;
+			let addSafelist = attributes["uno-safelist"] || svelte3AddSafelist || svelte4DeprecatedAddSafelist;
+			if (unoContextFromVite && (addPreflights || addSafelist)) {
+				addPreflights = false;
+				addSafelist = false;
+				warnOnce("Notice for those transitioning to @unocss/svelte-scoped/vite: uno-preflights and uno-safelist are only for use in component libraries. Please see the documentation for how to add preflights and safelist into your head tag. If you are consuming a component library built by @unocss/svelte-scoped/preprocess, you can ignore this upgrade notice.");
+			}
+			const { hasApply, applyVariables } = checkForApply(content, options.applyVariables);
+			const hasThemeFn = options.transformThemeDirective === false ? false : !!content.match(themeRE);
+			if (!(addPreflights || addSafelist || hasApply || hasThemeFn)) return;
+			uno ??= await makeGenerator();
+			let preflightsSafelistCss = "";
+			if (addPreflights || addSafelist) {
+				const { css } = await uno.generate([], {
+					preflights: !!addPreflights,
+					safelist: !!addSafelist,
+					minify: true
+				});
+				preflightsSafelistCss = wrapSelectorsWithGlobal(css);
+			}
+			if (hasApply || hasThemeFn) return await transformStyle({
+				content,
+				uno,
+				filename,
+				prepend: preflightsSafelistCss,
+				applyVariables,
+				transformThemeFn: hasThemeFn
+			});
+			if (preflightsSafelistCss) return { code: preflightsSafelistCss + content };
+		}
+	};
+}
+
+//#endregion
+export { UnocssSveltePreprocess as t };

package/dist/preprocess.d.mts

@@ -1,9 +1,3 @@
-import { PreprocessorGroup } from 'svelte/types/compiler/preprocess';
-import { U as UnocssSveltePreprocessOptions, S as SvelteScopedContext } from './shared/svelte-scoped.BG2YMHlZ.mjs';
-export { a as TransformApplyOptions, T as TransformClassesOptions, b as TransformDirectivesOptions } from './shared/svelte-scoped.BG2YMHlZ.mjs';
-import '@unocss/config';
-import '@unocss/core';
-
-declare function UnocssSveltePreprocess(options?: UnocssSveltePreprocessOptions, unoContextFromVite?: SvelteScopedContext, isViteBuild?: () => boolean): PreprocessorGroup;
-
-export { SvelteScopedContext, UnocssSveltePreprocessOptions, UnocssSveltePreprocess as default };
+import { a as UnocssSveltePreprocessOptions, i as TransformDirectivesOptions, n as TransformApplyOptions, r as TransformClassesOptions, t as SvelteScopedContext } from "./types-lojsQv1_.mjs";
+import { t as UnocssSveltePreprocess } from "./preprocess-DHIfuYme.mjs";
+export { SvelteScopedContext, TransformApplyOptions, TransformClassesOptions, TransformDirectivesOptions, UnocssSveltePreprocessOptions, UnocssSveltePreprocess as default };

package/dist/preprocess.mjs

@@ -1,9 +1,4 @@
-export { U as default } from './shared/svelte-scoped.BF7qdJQ6.mjs';
-import 'node:process';
-import '@unocss/config';
-import '@unocss/core';
-import '@unocss/preset-wind3';
-import 'magic-string';
-import 'acorn';
-import 'zimmerframe';
-import 'css-tree';
+import { t as UnocssSveltePreprocess } from "./preprocess-smYe4zo2.mjs";
+import { a as UnocssSveltePreprocessOptions, i as TransformDirectivesOptions, n as TransformApplyOptions, r as TransformClassesOptions, t as SvelteScopedContext } from "./types-lojsQv1_.d.mts";
+
+export { SvelteScopedContext, TransformApplyOptions, TransformClassesOptions, TransformDirectivesOptions, UnocssSveltePreprocessOptions, UnocssSveltePreprocess as default };

package/dist/{shared/svelte-scoped.BG2YMHlZ.d.mts → types-lojsQv1_.d.mts}

@@ -1,31 +1,30 @@
-import { LoadConfigResult } from '@unocss/config';
-import { UserConfig, UnoGenerator } from '@unocss/core';
+import { LoadConfigResult } from "@unocss/config";
+import { UnoGenerator, UserConfig } from "@unocss/core";
 
+//#region src/_preprocess/types.d.ts
 interface UnocssSveltePreprocessOptions extends TransformClassesOptions, TransformApplyOptions, TransformDirectivesOptions {
   /**
    * UnoCSS config or path to config file. If not provided, will load unocss.config.ts/js. It's recommended to use the separate config file if you are having trouble with the UnoCSS extension in VSCode.
    */
-  configOrPath?: UserConfig | string
+  configOrPath?: UserConfig | string;
 }
-
 interface TransformClassesOptions {
   /**
    * Prefix for compiled class names. Distinct between `@unocss/svelte-scoped/vite` and `@unocss/svelte-scoped/preprocessor` to avoid bugs when using a component library built with `@unocss/svelte-scoped/preprocessor` in a project using `@unocss/svelte-scoped/vite`.
    * @default 'uno-' // `@unocss/svelte-scoped/vite`
    * @default 'usp-' // `@unocss/svelte-scoped/preprocessor`
    */
-  classPrefix?: string
+  classPrefix?: string;
   /**
    * Add hash and combine recognized tokens (optimal for production); set false in dev mode for easy dev tools toggling to allow for design adjustments in the browser
    * @default true
    */
-  combine?: boolean
+  combine?: boolean;
   /**
    * Used to generate hash for compiled class names
    */
-  hashFn?: (str: string) => string
+  hashFn?: (str: string) => string;
 }
-
 interface TransformApplyOptions {
   /**
    * Transform CSS custom properties (recommended for CSS syntax compatibility) or @apply directives.
@@ -34,9 +33,8 @@ interface TransformApplyOptions {
    *
    * @default ['--at-apply', '@apply']
    */
-  applyVariables?: string | string[] | false
+  applyVariables?: string | string[] | false;
 }
-
 interface TransformDirectivesOptions {
   /**
    * Transform the `theme()` directive (recommended for CSS syntax compatibility).
@@ -47,12 +45,11 @@ interface TransformDirectivesOptions {
    *
    * @default true
    */
-  transformThemeDirective?: boolean
+  transformThemeDirective?: boolean;
 }
-
 interface SvelteScopedContext {
-  uno: UnoGenerator
-  ready: Promise<LoadConfigResult<UserConfig>>
+  uno: UnoGenerator;
+  ready: Promise<LoadConfigResult<UserConfig>>;
 }
-
-export type { SvelteScopedContext as S, TransformClassesOptions as T, UnocssSveltePreprocessOptions as U, TransformApplyOptions as a, TransformDirectivesOptions as b };
+//#endregion
+export { UnocssSveltePreprocessOptions as a, TransformDirectivesOptions as i, TransformApplyOptions as n, TransformClassesOptions as r, SvelteScopedContext as t };