@master/css-tooling 0.0.0-site.1793659883.g69c9aebcf628

package/dist/scanner/options/index.js

@@ -0,0 +1,57 @@
+// src/scanner/options/index.ts
+const defaultExclude = Object.freeze([
+	"**/*.css",
+	"**/*.d.ts",
+	"**/*.test.*",
+	"**/*test.{js,cjs,ts}",
+	"**/*README.md",
+	"**/dist/**",
+	"**/out/**",
+	"**/public/**",
+	"**/.git/**",
+	"**/.hg/**",
+	"**/.svn/**",
+	"**/.cache/**",
+	"**/.vite/**",
+	"**/.turbo/**",
+	"**/.parcel-cache/**",
+	"**/.nx/cache/**",
+	"**/.astro/**",
+	"**/.next/**",
+	"**/.nuxt/**",
+	"**/.svelte-kit/**",
+	"**/.vitepress/cache/**",
+	"**/.vitepress/dist/**",
+	"**/.docusaurus/**",
+	"**/.output/**",
+	"**/.vercel/**",
+	"**/.netlify/**",
+	"**/.wrangler/**",
+	"**/.serverless/**",
+	"**/.yarn/**",
+	"**/.pnpm-store/**",
+	"**/.npm/**",
+	"**/.bun/**",
+	"**/node_modules/webpack*/**",
+	"**/node_modules/events/**",
+	"**/node_modules/html-entities/**",
+	"**/node_modules/ansi-html-community/**",
+	"**/node_modules/util/**",
+	"**/node_modules/react/**",
+	"**/node_modules/react-dom/**",
+	"**/node_modules/vue/**",
+	"**/node_modules/next/**",
+	"**/node_modules/astro/**",
+	"**/node_modules/svelte/**",
+	"**/node_modules/svelte-hmr/**",
+	"**/node_modules/@swc/**",
+	"**/node_modules/@sveltejs/**",
+	"**/node_modules/@angular/**"
+]);
+const defaultScannerOptions = Object.freeze({
+	verbose: 1,
+	exclude: defaultExclude,
+	safelist: Object.freeze([]),
+	blocklist: Object.freeze([])
+});
+export { defaultScannerOptions };

package/dist/scanner/source-policy.d.ts

@@ -0,0 +1,15 @@
+interface SourcePolicyOptions {
+  readonly exclude?: readonly string[];
+  readonly outputDirectories?: readonly string[];
+}
+/** Shared Node input boundary. No global Git configuration or ignore file is read. */
+declare class SourcePolicy {
+  readonly projectDir: string;
+  readonly options: SourcePolicyOptions;
+  readonly dependencies: Set<string>;
+  readonly root: string;
+  private readonly cache;
+  constructor(projectDir: string, options?: SourcePolicyOptions);
+  accepts(source: string, explicit?: boolean): boolean;
+}
+export { SourcePolicy, SourcePolicyOptions };

package/dist/scanner/source-policy.js

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, extname, isAbsolute, relative, resolve, sep } from "node:path";
+import ignore from "ignore";
+import { minimatch } from "minimatch";
+// src/scanner/source-policy.ts
+const automaticExcludes = [
+	"**/node_modules/**",
+	"**/*.d.ts",
+	"**/*.d.mts",
+	"**/*.d.cts",
+	"**/dist/**",
+	"**/out/**",
+	"**/.cache/**",
+	"**/.next/**",
+	"**/.nuxt/**",
+	"**/.output/**",
+	"**/.svelte-kit/**"
+];
+const binaryExtensions = /* @__PURE__ */ new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".avif",
+	".ico",
+	".bmp",
+	".woff",
+	".woff2",
+	".ttf",
+	".otf",
+	".eot",
+	".pdf",
+	".zip",
+	".gz",
+	".br",
+	".wasm",
+	".mp3",
+	".mp4",
+	".webm",
+	".mov"
+]);
+const neverInputs = [
+	"**/.git/**",
+	"**/.hg/**",
+	"**/.svn/**",
+	"**/.master/**"
+];
+const posix = (value) => value.split(sep).join("/");
+const inside = (root, file) => {
+	const path = relative(root, file);
+	return !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
+};
+function isWorkspace(directory) {
+	if (existsSync(resolve(directory, "pnpm-workspace.yaml"))) return true;
+	try {
+		const { workspaces } = JSON.parse(readFileSync(resolve(directory, "package.json"), "utf8"));
+		return Array.isArray(workspaces) || Array.isArray(workspaces?.packages);
+	} catch {
+		return false;
+	}
+}
+/** Shared Node input boundary. No global Git configuration or ignore file is read. */
+var SourcePolicy = class {
+	projectDir;
+	options;
+	dependencies = /* @__PURE__ */ new Set();
+	root;
+	cache = /* @__PURE__ */ new Map();
+	constructor(projectDir, options = {}) {
+		this.projectDir = projectDir;
+		this.options = options;
+		this.root = resolve(projectDir);
+		for (let directory = resolve(projectDir);; directory = dirname(directory)) {
+			if (existsSync(resolve(directory, ".git")) || isWorkspace(directory)) this.root = directory;
+			if (dirname(directory) === directory) break;
+		}
+	}
+	accepts(source, explicit = false) {
+		const file = resolve(this.projectDir, source.split("?")[0]);
+		if (binaryExtensions.has(extname(file).toLowerCase())) return false;
+		const path = posix(file);
+		const matches = (pattern) => minimatch(path, pattern, { dot: true }) || minimatch(posix(relative(this.projectDir, file)), pattern, { dot: true });
+		if (neverInputs.some(matches) || this.options.outputDirectories?.some((directory) => inside(resolve(this.projectDir, directory), file))) return false;
+		if (this.options.exclude?.some(matches)) return false;
+		if (explicit) return true;
+		if (automaticExcludes.some(matches)) return false;
+		const directories = [];
+		for (let directory = dirname(file); inside(this.root, directory); directory = dirname(directory)) {
+			directories.unshift(directory);
+			if (directory === this.root) break;
+		}
+		const rules = [];
+		const ignored = (target, directory) => {
+			let result = false;
+			for (const rule of rules) {
+				const name = posix(relative(rule.directory, target)) + (directory ? "/" : "");
+				const match = rule.matcher.test(name);
+				if (match.ignored) result = true;
+				if (match.unignored) result = false;
+			}
+			return result;
+		};
+		for (const directory of directories) {
+			if (directory !== this.root && ignored(directory, true)) return false;
+			const filename = resolve(directory, ".gitignore");
+			this.dependencies.add(filename);
+			try {
+				const stat = statSync(filename);
+				const identity = `${stat.mtimeMs}:${stat.size}:${stat.ino}`;
+				let cached = this.cache.get(filename);
+				if (cached?.identity !== identity) {
+					cached = {
+						identity,
+						matcher: ignore().add(readFileSync(filename, "utf8"))
+					};
+					this.cache.set(filename, cached);
+				}
+				rules.push({
+					directory,
+					matcher: cached.matcher
+				});
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+				this.cache.delete(filename);
+			}
+		}
+		return !ignored(file, false);
+	}
+};
+export { SourcePolicy };

package/dist/source/adapters/optional-peer.d.ts

@@ -0,0 +1,5 @@
+type OptionalPeerImporter = (specifier: string) => Promise<unknown>;
+declare function loadOptionalPeer<T>(specifier: string, label: string): Promise<T | undefined>;
+declare function setOptionalPeerImporterForTest(nextImporter: OptionalPeerImporter): void;
+declare function resetOptionalPeerStateForTest(): void;
+export { loadOptionalPeer, resetOptionalPeerStateForTest, setOptionalPeerImporterForTest };

package/dist/source/adapters/optional-peer.js

@@ -0,0 +1,29 @@
+// src/source/adapters/optional-peer.ts
+const defaultImporter = (specifier) => import(specifier);
+const peerPromises = /* @__PURE__ */ new Map();
+const warnedPeers = /* @__PURE__ */ new Set();
+let importer = defaultImporter;
+async function loadOptionalPeer(specifier, label) {
+	let peerPromise = peerPromises.get(specifier);
+	if (!peerPromise) {
+		peerPromise = importer(specifier).catch((error) => {
+			if (!warnedPeers.has(specifier)) {
+				warnedPeers.add(specifier);
+				const message = error instanceof Error ? ` ${error.message}` : "";
+				console.warn(`[@master/css-tooling/source] Optional ${label} parser "${specifier}" could not be loaded; falling back to text extraction.${message}`);
+			}
+		});
+		peerPromises.set(specifier, peerPromise);
+	}
+	return await peerPromise;
+}
+function setOptionalPeerImporterForTest(nextImporter) {
+	importer = nextImporter;
+	peerPromises.clear();
+}
+function resetOptionalPeerStateForTest() {
+	importer = defaultImporter;
+	peerPromises.clear();
+	warnedPeers.clear();
+}
+export { loadOptionalPeer, resetOptionalPeerStateForTest, setOptionalPeerImporterForTest };

package/dist/source/adapters/oxc.d.ts

@@ -0,0 +1,2 @@
+declare function extractOxcClasses(source: string, content: string): string[];
+export { extractOxcClasses };

package/dist/source/adapters/oxc.js

@@ -0,0 +1,6 @@
+import { extractOxcClassesNative } from "../native.js";
+// src/source/adapters/oxc.ts
+function extractOxcClasses(source, content) {
+	return extractOxcClassesNative(source, content);
+}
+export { extractOxcClasses };

package/dist/source/adapters/svelte.d.ts

@@ -0,0 +1,5 @@
+import { SourceAdapter } from "./types.js";
+declare const SVELTE_SOURCE_EXT: RegExp;
+declare function extractSvelteClasses(source: string, content: string): Promise<string[]>;
+declare function svelteAdapter(): SourceAdapter;
+export { SVELTE_SOURCE_EXT, extractSvelteClasses, svelteAdapter };

package/dist/source/adapters/svelte.js

@@ -0,0 +1,82 @@
+import { extractClassCandidatesNative } from "../native.js";
+import { extractOxcClasses } from "./oxc.js";
+import { loadOptionalPeer } from "./optional-peer.js";
+import { MasterCSSError } from "@master/css-schema";
+// src/source/adapters/svelte.ts
+const SVELTE_SOURCE_EXT = /\.svelte(?:\?|$)/;
+function isSvelteSource(source) {
+	return SVELTE_SOURCE_EXT.test(source) && !/[?&]type=style(?:&|$)/.test(source);
+}
+function addClassString(classes, value) {
+	if (!value) return;
+	for (const className of extractClassCandidatesNative(value)) if (className) classes.add(className);
+}
+function addOxc(classes, source, content) {
+	for (const className of extractOxcClasses(source, content)) if (className) classes.add(className);
+}
+function scriptExtension(content, script) {
+	if (script?.start == null || script.content?.start == null) return "js";
+	const openingTag = content.slice(script.start, script.content.start);
+	const match = /(?:^|\s)lang\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/iu.exec(openingTag);
+	const language = (match?.[1] ?? match?.[2] ?? match?.[3])?.toLowerCase();
+	return language === "ts" || language === "tsx" ? language : "js";
+}
+function visitMarkup(node, source, content, classes, extension) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node.attributes)) for (const attribute of node.attributes) {
+		if (attribute.type === "Class") {
+			addClassString(classes, attribute.name);
+			if (attribute.expression?.start != null && attribute.expression?.end != null) addOxc(classes, `${source}.${extension}`, content.slice(attribute.expression.start, attribute.expression.end));
+			continue;
+		}
+		if (attribute.type !== "Attribute" || attribute.name !== "class") continue;
+		for (const value of attribute.value || []) if (value.type === "Text") addClassString(classes, value.data ?? value.raw);
+		else if (value.start != null && value.end != null) addOxc(classes, `${source}.${extension}`, content.slice(value.start, value.end));
+	}
+	for (const child of node.children || []) visitMarkup(child, source, content, classes, extension);
+	for (const branch of [
+		node.else,
+		node.pending,
+		node.then,
+		node.catch
+	]) visitMarkup(branch, source, content, classes, extension);
+}
+async function loadSvelteCompiler() {
+	const specifier = ["svelte", "/compiler"].join("");
+	return await loadOptionalPeer(specifier, "Svelte");
+}
+async function extractSvelteClasses(source, content) {
+	if (!content.trim()) return [];
+	const compiler = await loadSvelteCompiler();
+	if (!compiler) throw new MasterCSSError({
+		code: "SOURCE_PARSE_ERROR",
+		domain: "tooling",
+		message: `Cannot parse ${source}: install the framework compiler or explicitly select kind: 'raw'.`
+	});
+	try {
+		const ast = compiler.parse(content);
+		const classes = /* @__PURE__ */ new Set();
+		const moduleExtension = scriptExtension(content, ast.module);
+		const instanceExtension = scriptExtension(content, ast.instance);
+		if (ast.module?.content) addOxc(classes, `${source}.${moduleExtension}`, content.slice(ast.module.content.start, ast.module.content.end));
+		if (ast.instance?.content) addOxc(classes, `${source}.${instanceExtension}`, content.slice(ast.instance.content.start, ast.instance.content.end));
+		visitMarkup(ast.html, source, content, classes, moduleExtension === "tsx" || instanceExtension === "tsx" ? "tsx" : moduleExtension === "ts" || instanceExtension === "ts" ? "ts" : "js");
+		return [...classes];
+	} catch (error) {
+		throw new MasterCSSError({
+			code: "SOURCE_PARSE_ERROR",
+			domain: "tooling",
+			message: `Cannot parse ${source}: ${String(error)}`
+		}, { cause: error });
+	}
+}
+function svelteAdapter() {
+	return {
+		name: "svelte",
+		test: isSvelteSource,
+		async extract({ source, content }) {
+			return await extractSvelteClasses(source, content);
+		}
+	};
+}
+export { SVELTE_SOURCE_EXT, extractSvelteClasses, svelteAdapter };

package/dist/source/adapters/types.d.ts

@@ -0,0 +1,11 @@
+interface SourceAdapterInput {
+  source: string;
+  content: string;
+}
+interface SourceAdapter {
+  name: string;
+  test: RegExp | ((source: string) => boolean);
+  extract(input: SourceAdapterInput): Promise<string[]>;
+}
+declare function matchesSourceAdapter(adapter: SourceAdapter, source: string): boolean;
+export { SourceAdapter, SourceAdapterInput, matchesSourceAdapter };

package/dist/source/adapters/types.js

@@ -0,0 +1,9 @@
+// src/source/adapters/types.ts
+function matchesSourceAdapter(adapter, source) {
+	if (typeof adapter.test === "function") return adapter.test(source);
+	adapter.test.lastIndex = 0;
+	const matched = adapter.test.test(source);
+	adapter.test.lastIndex = 0;
+	return matched;
+}
+export { matchesSourceAdapter };

package/dist/source/adapters/vue.d.ts

@@ -0,0 +1,5 @@
+import { SourceAdapter } from "./types.js";
+declare const VUE_SOURCE_EXT: RegExp;
+declare function extractVueClasses(source: string, content: string): Promise<string[]>;
+declare function vueAdapter(): SourceAdapter;
+export { VUE_SOURCE_EXT, extractVueClasses, vueAdapter };

package/dist/source/adapters/vue.js

@@ -0,0 +1,50 @@
+import { extractClassCandidatesNative } from "../native.js";
+import { extractOxcClasses } from "./oxc.js";
+import { loadOptionalPeer } from "./optional-peer.js";
+import { MasterCSSError } from "@master/css-schema";
+// src/source/adapters/vue.ts
+const VUE_SOURCE_EXT = /\.vue(?:\?|$)/;
+function isVueSource(source) {
+	return VUE_SOURCE_EXT.test(source) && !/[?&]type=style(?:&|$)/.test(source);
+}
+function add(classes, classNames) {
+	for (const className of classNames) if (className) classes.add(className);
+}
+async function loadVueCompiler() {
+	const specifier = ["vue", "/compiler-sfc"].join("");
+	return await loadOptionalPeer(specifier, "Vue SFC");
+}
+async function extractVueClasses(source, content) {
+	if (!content.trim()) return [];
+	const compiler = await loadVueCompiler();
+	if (!compiler) throw new MasterCSSError({
+		code: "SOURCE_PARSE_ERROR",
+		domain: "tooling",
+		message: `Cannot parse ${source}: install the framework compiler or explicitly select kind: 'raw'.`
+	});
+	try {
+		const classes = /* @__PURE__ */ new Set();
+		const { descriptor, errors } = compiler.parse(content, { filename: source });
+		if (errors.length) throw new Error(errors.map(String).join("; "));
+		if (descriptor.template?.content) add(classes, extractClassCandidatesNative(descriptor.template.content));
+		if (descriptor.script?.content) add(classes, extractOxcClasses(`${source}.${descriptor.script.lang || "js"}`, descriptor.script.content));
+		if (descriptor.scriptSetup?.content) add(classes, extractOxcClasses(`${source}.${descriptor.scriptSetup.lang || "js"}`, descriptor.scriptSetup.content));
+		return [...classes];
+	} catch (error) {
+		throw new MasterCSSError({
+			code: "SOURCE_PARSE_ERROR",
+			domain: "tooling",
+			message: `Cannot parse ${source}: ${String(error)}`
+		}, { cause: error });
+	}
+}
+function vueAdapter() {
+	return {
+		name: "vue",
+		test: isVueSource,
+		async extract({ source, content }) {
+			return await extractVueClasses(source, content);
+		}
+	};
+}
+export { VUE_SOURCE_EXT, extractVueClasses, vueAdapter };

package/dist/source/browser.d.ts

@@ -0,0 +1,7 @@
+import { SourceExtractor } from "./session.js";
+import { MasterCSSWasmBindingLoadOptions } from "@master/css-binding/tooling";
+type BrowserSourceExtractor = SourceExtractor & {
+  readonly binding: 'wasm';
+};
+declare function createSourceExtractor(options?: MasterCSSWasmBindingLoadOptions): Promise<BrowserSourceExtractor>;
+export { BrowserSourceExtractor, type MasterCSSWasmBindingLoadOptions, createSourceExtractor };

package/dist/source/browser.js

@@ -0,0 +1,11 @@
+import { bindSourceExtractor } from "./session.js";
+import { createToolingBinding } from "@master/css-binding/tooling";
+// src/source/browser.ts
+async function createSourceExtractor(options = {}) {
+	const tooling = await createToolingBinding({
+		binding: "wasm",
+		wasm: options
+	});
+	return bindSourceExtractor(tooling.binding, await tooling.createSourceSession());
+}
+export { createSourceExtractor };

package/dist/source/contracts.d.ts

@@ -0,0 +1,35 @@
+type MasterCSSSourceKind = 'auto' | 'raw' | 'oxc' | 'html' | 'astro' | 'markdown' | 'mdx';
+/** Decoded HTML attribute text and indivisible UTF-16 source spans. */
+interface MasterCSSDecodedHTMLAttribute {
+  readonly value: string;
+  readonly spans: readonly {
+    readonly range: {
+      readonly start: number;
+      readonly end: number;
+    };
+    readonly sourceRange: {
+      readonly start: number;
+      readonly end: number;
+    };
+  }[];
+}
+interface MasterCSSSourceExtractionInput {
+  readonly source: string;
+  readonly content: string;
+  readonly owner?: string;
+  readonly kind?: MasterCSSSourceKind;
+}
+interface MasterCSSSourceExtractionRequest {
+  readonly files: readonly MasterCSSSourceExtractionInput[];
+}
+interface MasterCSSExtractedSource {
+  readonly source: string;
+  readonly candidates: readonly string[];
+  readonly occurrences: readonly import('@master/css-binding/tooling').MasterCSSSourceOccurrence[];
+  readonly diagnostics: readonly import('@master/css-binding/tooling').MasterCSSDiagnostic[];
+}
+interface MasterCSSSourceExtraction {
+  readonly version: 2;
+  readonly files: readonly MasterCSSExtractedSource[];
+}
+export { MasterCSSDecodedHTMLAttribute, MasterCSSExtractedSource, MasterCSSSourceExtraction, MasterCSSSourceExtractionInput, MasterCSSSourceExtractionRequest, MasterCSSSourceKind };

package/dist/source/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/source/index.d.ts

@@ -0,0 +1,8 @@
+import { MasterCSSDecodedHTMLAttribute, MasterCSSExtractedSource, MasterCSSSourceExtraction, MasterCSSSourceExtractionInput, MasterCSSSourceExtractionRequest, MasterCSSSourceKind } from "./contracts.js";
+import { MasterCSSBinding } from "@master/css-binding";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function extractSource(request: MasterCSSSourceExtractionRequest, options: {
+  readonly manifest: MasterCSSManifest;
+  readonly binding?: MasterCSSBinding;
+}): Promise<MasterCSSSourceExtraction>;
+export { type MasterCSSDecodedHTMLAttribute, type MasterCSSExtractedSource, type MasterCSSSourceExtraction, type MasterCSSSourceExtractionInput, type MasterCSSSourceExtractionRequest, type MasterCSSSourceKind, extractSource };

package/dist/source/index.js

@@ -0,0 +1,11 @@
+import { createToolingSession } from "../tooling-session.js";
+// src/source/index.ts
+async function extractSource(request, options) {
+	const session = await createToolingSession(options);
+	try {
+		return session.extractSource(request);
+	} finally {
+		session.dispose();
+	}
+}
+export { extractSource };

package/dist/source/native.d.ts

@@ -0,0 +1,5 @@
+declare function extractClassCandidatesNative(content: string): string[];
+declare function extractOxcClassesNative(source: string, content: string): string[];
+declare function extractHTMLClassesNative(source: string, content: string): string[];
+declare function extractAstroClassesNative(source: string, content: string): string[];
+export { extractAstroClassesNative, extractClassCandidatesNative, extractHTMLClassesNative, extractOxcClassesNative };

package/dist/source/native.js

@@ -0,0 +1,53 @@
+import { createToolingBindingSync } from "@master/css-binding/tooling/node";
+import { MasterCSSError } from "@master/css-schema";
+// src/source/native.ts
+function binding() {
+	return createToolingBindingSync();
+}
+function extractClassCandidatesNative(content) {
+	return [...binding().extractClassCandidates(content)];
+}
+function extractOxcClassesNative(source, content) {
+	const session = binding().createSourceSession();
+	try {
+		const result = session.extract({ files: [{
+			source,
+			content,
+			kind: "oxc"
+		}] }).files[0];
+		if (result.diagnostics.length) {
+			const position = (offset) => {
+				const lines = content.slice(0, offset).split("\n");
+				return {
+					line: lines.length - 1,
+					character: lines.at(-1).length
+				};
+			};
+			throw new MasterCSSError({
+				code: "SOURCE_PARSE_ERROR",
+				domain: "tooling",
+				message: result.diagnostics[0].message,
+				diagnostics: result.diagnostics.map((diagnostic) => ({
+					...diagnostic,
+					version: 2,
+					domain: "tooling",
+					severity: diagnostic.severity === "info" ? "information" : diagnostic.severity,
+					range: diagnostic.range ? {
+						start: position(diagnostic.range.start),
+						end: position(diagnostic.range.end)
+					} : void 0
+				}))
+			});
+		}
+		return [...result.candidates];
+	} finally {
+		session.dispose();
+	}
+}
+function extractHTMLClassesNative(source, content) {
+	return [...binding().extractHTMLClasses(source, content)];
+}
+function extractAstroClassesNative(source, content) {
+	return [...binding().extractAstroClasses(source, content)];
+}
+export { extractAstroClassesNative, extractClassCandidatesNative, extractHTMLClassesNative, extractOxcClassesNative };

package/dist/source/node.d.ts

@@ -0,0 +1,7 @@
+import { MasterCSSSourceExtraction, MasterCSSSourceExtractionRequest } from "./contracts.js";
+import "./index.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function extractSourceSync(request: MasterCSSSourceExtractionRequest, options: {
+  readonly manifest: MasterCSSManifest;
+}): MasterCSSSourceExtraction;
+export { extractSourceSync };

package/dist/source/node.js

@@ -0,0 +1,11 @@
+import { createToolingSessionSync } from "../node.js";
+// src/source/node.ts
+function extractSourceSync(request, options) {
+	const session = createToolingSessionSync(options);
+	try {
+		return session.extractSource(request);
+	} finally {
+		session.dispose();
+	}
+}
+export { extractSourceSync };

package/dist/source/session.d.ts

@@ -0,0 +1,25 @@
+import { MasterCSSSourceBatch, MasterCSSSourceBatchRequest, MasterCSSSourceExtractorKind } from "@master/css-binding/tooling";
+type SourceBatchRequest = MasterCSSSourceBatchRequest;
+type SourceExtractorKind = MasterCSSSourceExtractorKind;
+interface SourceExtractor {
+  readonly binding: 'native' | 'wasm';
+  extract(request: SourceBatchRequest): MasterCSSSourceBatch;
+  extractClassCandidates(content: string): string[];
+  extractOxcClasses(source: string, content: string): string[];
+  extractHTMLClasses(source: string, content: string): string[];
+  extractAstroClasses(source: string, content: string): string[];
+  dispose(): void;
+}
+declare class SourceExtractorError extends Error {
+  readonly code: 'NATIVE_UNAVAILABLE' | 'SOURCE_BATCH_VERSION_MISMATCH';
+  constructor(code: 'NATIVE_UNAVAILABLE' | 'SOURCE_BATCH_VERSION_MISMATCH', message: string);
+}
+interface BindingSourceSession {
+  extract(request: unknown): unknown;
+  dispose(): void;
+}
+declare function bindSourceExtractor(binding: SourceExtractor['binding'], session: BindingSourceSession): SourceExtractor;
+declare function createSourceExtractor(options?: {
+  readonly binding?: 'auto' | 'native' | 'wasm';
+}): Promise<SourceExtractor>;
+export { SourceBatchRequest, SourceExtractor, SourceExtractorError, SourceExtractorKind, bindSourceExtractor, createSourceExtractor };

package/dist/source/session.js

@@ -0,0 +1,37 @@
+import { MASTER_CSS_SOURCE_BATCH_VERSION, createToolingBinding } from "@master/css-binding/tooling";
+// src/source/session.ts
+var SourceExtractorError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "SourceExtractorError";
+	}
+};
+function parse(value) {
+	const result = value;
+	if (result.version !== MASTER_CSS_SOURCE_BATCH_VERSION) throw new SourceExtractorError("SOURCE_BATCH_VERSION_MISMATCH", `Expected Master CSS source batch version ${MASTER_CSS_SOURCE_BATCH_VERSION}, received ${String(result.version)}.`);
+	return result;
+}
+function bindSourceExtractor(binding, session) {
+	const extract = (request) => parse(session.extract(request));
+	const candidates = (source, content, kind) => extract({ files: [{
+		source,
+		content,
+		kind
+	}] }).files[0]?.candidates ?? [];
+	return {
+		binding,
+		extract,
+		extractClassCandidates: (content) => candidates("", content, "raw"),
+		extractOxcClasses: (source, content) => candidates(source, content, "oxc"),
+		extractHTMLClasses: (source, content) => candidates(source, content, "html"),
+		extractAstroClasses: (source, content) => candidates(source, content, "astro"),
+		dispose: () => session.dispose()
+	};
+}
+async function createSourceExtractor(options = {}) {
+	const tooling = await createToolingBinding({ binding: options.binding });
+	return bindSourceExtractor(tooling.binding, await tooling.createSourceSession());
+}
+export { SourceExtractorError, bindSourceExtractor, createSourceExtractor };