@pre.style/core 3.0.0-alpha.0 → 3.1.0-alpha.0

package/dist/compiler/compiler.js

@@ -1,9 +1,10 @@
 import { readFileSync } from 'node:fs';
-import { resolve as resolvePath, sep } from 'node:path';
+import { dirname, relative, resolve as resolvePath, sep } from 'node:path';
 import SweatMap from 'sweatmap';
-import { parseBlock, PreStyleError, valueOf } from './block.js';
+import { dropOverridden, parseBlock, PreStyleError, valueOf } from './block.js';
 import { print } from './print.js';
 import { lvhfaRank, withClass } from './selectors.js';
+import { MARKER_PREFIX, markerKey, parseStylesheet } from './stylesheet.js';
 const RANGES = {
     Digits: { start: '0030', end: '0039' },
     Uppercase: { start: '0041', end: '005A' },
@@ -45,6 +46,8 @@ export class Compiler {
     #prepend;
     #libraries;
     #blocks = new Map();
+    #stylesheets = new Map();
+    #root;
     // One name list for every class, and one for prefixes (the at-rules and
     // selector variant a class is under), which only the `cn` table uses.
     #names;
@@ -62,6 +65,7 @@ export class Compiler {
             prefixes: new SweatMap(NAME_OPTIONS),
         };
         const root = options.root ?? process.cwd();
+        this.#root = root;
         this.#prepend = readPrepend(root, options.prependFiles);
         this.#libraries = (options.libraries ?? [])
             .map((library) => {
@@ -84,13 +88,14 @@ export class Compiler {
     // block before `assignNames`.
     scan(block) {
         const parsed = this.#parse(block);
-        for (const atom of parsed.atoms) {
-            count(this.#counts.atoms, atomKey(atom));
-            const prefix = prefixKey(atom);
-            if (prefix !== '')
-                count(this.#counts.prefixes, prefix);
-        }
         this.#register(block, parsed);
+        this.#count(this.#resolveBlock(block, parsed, []));
+    }
+    // Pass 1 of naming for a stylesheet file: counts what each class uses.
+    scanStylesheet(sheet) {
+        const parsed = this.#parseSheet(sheet);
+        for (const name of parsed.classes.keys())
+            this.#count(this.#resolveClass(sheet.file, parsed, name, [], []));
     }
     // Pass 2 of naming: gives the most-used entries the shortest names. Ties
     // are broken by key, so names don't depend on the order files are read.
@@ -106,7 +111,38 @@ export class Compiler {
     classString(block) {
         const parsed = this.#parse(block);
         this.#register(block, parsed);
-        return parsed.atoms.map((atom) => this.#nameOf(this.#atoms.get(atomKey(atom)))).join(' ');
+        return this.#classString(this.#resolveBlock(block, parsed, []));
+    }
+    // The files a block's class string depends on, through `composes … from`.
+    dependencies(block) {
+        const dependencies = [];
+        this.#resolveBlock(block, this.#parse(block), dependencies);
+        return [...new Set(dependencies)];
+    }
+    // The classes a stylesheet file exports, without compiling or keeping
+    // anything, for tools that only need the names (such as the TypeScript
+    // content mapper).
+    classNames(sheet) {
+        const { prepend } = this.#library(sheet.file);
+        try {
+            const parsed = parseStylesheet(sheet.code, sheet.lang, sheet.file, relative(this.#root, sheet.file), { ...this.#parseOptions, prepend });
+            return [...parsed.classes.keys()];
+        }
+        catch (error) {
+            throw error instanceof PreStyleError ? locate(error, fileBlock(sheet.file)) : error;
+        }
+    }
+    // Each class of a stylesheet file, with its class string.
+    stylesheet(sheet) {
+        const parsed = this.#parseSheet(sheet);
+        const dependencies = [...parsed.dependencies];
+        const exports = [];
+        for (const name of parsed.classes.keys())
+            exports.push([
+                name,
+                this.#classString(this.#resolveClass(sheet.file, parsed, name, [], dependencies)),
+            ]);
+        return { exports, dependencies: [...new Set(dependencies)] };
     }
     css() {
         const sources = [];
@@ -124,7 +160,7 @@ export class Compiler {
             .filter((g) => g.global.hoist !== false)
             .toSorted((a, b) => a.global.hoist - b.global.hoist);
         const rest = globals.filter((g) => g.global.hoist === false);
-        const rules = [...hoisted, ...rest].map((g) => withLoc(g.global.rule, loc(g.source)));
+        const rules = [...hoisted, ...rest].map((g) => withLoc(g.global.key.includes(MARKER_KEY) ? this.#named(g.global.rule) : g.global.rule, loc(g.source)));
         rules.push(...this.#atomRules(loc));
         return print(rules, sources, this.#parseOptions.lightningcss, this.#options.sourceMap ?? false);
     }
@@ -141,12 +177,14 @@ export class Compiler {
         }
         return table;
     }
+    // A library's blocks and files get its prepended files instead of the
+    // app's.
+    #library(file) {
+        const library = file === undefined ? -1 : this.#libraries.findIndex(({ dir }) => file.startsWith(dir));
+        return { library, prepend: library === -1 ? this.#prepend : this.#libraries[library].prepend };
+    }
     #parse(block) {
-        // A library's blocks get its prepended files instead of the app's.
-        const library = block.file === undefined
-            ? -1
-            : this.#libraries.findIndex(({ dir }) => block.file.startsWith(dir));
-        const prepend = library === -1 ? this.#prepend : this.#libraries[library].prepend;
+        const { library, prepend } = this.#library(block.file);
         const cacheKey = `${library}\n${block.lang}\n${block.code}`;
         let parsed = this.#blocks.get(cacheKey);
         if (parsed === undefined) {
@@ -160,6 +198,136 @@ export class Compiler {
         }
         return parsed;
     }
+    // Parses a stylesheet file and registers its classes and global rules, so
+    // the output includes them once the file is used.
+    #parseSheet(sheet) {
+        const { library, prepend } = this.#library(sheet.file);
+        const cacheKey = `${library}\n${sheet.lang}\n${sheet.file}\n${sheet.code}`;
+        let parsed = this.#stylesheets.get(cacheKey);
+        if (parsed === undefined) {
+            try {
+                parsed = parseStylesheet(sheet.code, sheet.lang, sheet.file, relative(this.#root, sheet.file), {
+                    ...this.#parseOptions,
+                    prepend,
+                });
+            }
+            catch (error) {
+                throw error instanceof PreStyleError ? locate(error, fileBlock(sheet.file)) : error;
+            }
+            this.#stylesheets.set(cacheKey, parsed);
+        }
+        const block = fileBlock(sheet.file);
+        for (const target of parsed.classes.values())
+            this.#register(block, { atoms: target.atoms, globals: [], composes: [] });
+        this.#register(block, { atoms: [], globals: parsed.globals, composes: [] });
+        return parsed;
+    }
+    // Reads a file named by `composes … from`.
+    #readSheet(file) {
+        let code;
+        try {
+            code = readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            throw new PreStyleError(`Can't read ${file}, named by \`composes\`.`, null, { cause: error });
+        }
+        return this.#parseSheet({ code, lang: file.endsWith('.scss') ? 'scss' : 'css', file });
+    }
+    // A class's atoms and other names, after its `composes`. Composed atoms
+    // come first, so the class's own declarations replace the ones they
+    // conflict with, as in `cn`. `stack` holds the classes being resolved, to
+    // find cycles. Files composed from are added to `dependencies`.
+    #resolveClass(file, parsed, name, stack, dependencies) {
+        const target = parsed.classes.get(name);
+        if (target === undefined)
+            throw new PreStyleError(`${file} has no class \`${name}\` to compose.`, null);
+        const id = `${file}\0${name}`;
+        if (stack.includes(id))
+            throw new PreStyleError(`\`composes\` cycle: ${[...stack, id].map((entry) => entry.replace('\0', ' .')).join(' -> ')}.`, null);
+        const composed = this.#resolveComposes(file, parsed, target.composes, [...stack, id], dependencies);
+        if (target.marker)
+            composed.extras.push(markerKey(relative(this.#root, file), name));
+        return {
+            atoms: composed.atoms.length === 0
+                ? target.atoms
+                : dropOverridden([...composed.atoms, ...target.atoms]),
+            extras: composed.extras,
+        };
+    }
+    #resolveBlock(block, parsed, dependencies) {
+        if (parsed.composes.length === 0)
+            return { atoms: parsed.atoms, extras: [] };
+        for (const c of parsed.composes) {
+            if (c.from.type === 'local')
+                throw new PreStyleError('Blocks have no classes of their own to compose. Use `composes: a from "./file.css";` or `composes: a from global;`.', c.position);
+        }
+        const file = block.file ?? resolvePath(this.#root, 'block.css');
+        let composed;
+        try {
+            composed = this.#resolveComposes(file, null, parsed.composes, [], dependencies);
+        }
+        catch (error) {
+            throw error instanceof PreStyleError ? locate(error, block) : error;
+        }
+        return { atoms: dropOverridden([...composed.atoms, ...parsed.atoms]), extras: composed.extras };
+    }
+    #resolveComposes(file, parsed, composes, stack, dependencies) {
+        const atoms = [];
+        const extras = [];
+        for (const c of composes) {
+            if (c.from.type === 'global') {
+                extras.push(...c.names);
+                continue;
+            }
+            let from = file;
+            let sheet = parsed;
+            if (c.from.type === 'file') {
+                from = resolvePath(dirname(file), c.from.path);
+                dependencies.push(from);
+                sheet = this.#readSheet(from);
+                dependencies.push(...sheet.dependencies);
+            }
+            for (const name of c.names) {
+                const resolved = this.#resolveClass(from, sheet, name, stack, dependencies);
+                atoms.push(...resolved.atoms);
+                extras.push(...resolved.extras);
+            }
+        }
+        return { atoms, extras };
+    }
+    #count(resolved) {
+        for (const atom of resolved.atoms) {
+            count(this.#counts.atoms, atomKey(atom));
+            const prefix = prefixKey(atom);
+            if (prefix !== '')
+                count(this.#counts.prefixes, prefix);
+        }
+        for (const extra of resolved.extras)
+            if (extra.startsWith(MARKER_PREFIX))
+                count(this.#counts.atoms, extra);
+    }
+    #classString(resolved) {
+        const names = resolved.atoms.map((atom) => this.#nameOf(this.#atoms.get(atomKey(atom))));
+        for (const extra of resolved.extras)
+            names.push(extra.startsWith(MARKER_PREFIX) ? this.#names.atoms.set(extra) : extra);
+        return [...new Set(names)].join(' ');
+    }
+    // Replaces markers in selectors with their names.
+    #named(value) {
+        const visit = (node) => {
+            if (Array.isArray(node))
+                return node.map(visit);
+            if (node === null || typeof node !== 'object')
+                return node;
+            const record = node;
+            if (record.type === 'class' &&
+                typeof record.name === 'string' &&
+                record.name.startsWith(MARKER_PREFIX))
+                return { ...record, name: this.#names.atoms.set(record.name) };
+            return Object.fromEntries(Object.entries(record).map(([k, v]) => [k, visit(v)]));
+        };
+        return visit(value);
+    }
     #register(block, parsed) {
         for (const atom of parsed.atoms) {
             const key = atomKey(atom);
@@ -211,9 +379,11 @@ export class Compiler {
             const rules = sortAtoms(group.atoms).map((record) => {
                 const { atom, source } = record;
                 const className = this.#nameOf(record);
-                const selectors = atom.variant
+                let selectors = atom.variant
                     ? withClass(atom.variant.selectors, className)
                     : [[{ type: 'class', name: className }]];
+                if (atom.variant?.key.includes(MARKER_KEY))
+                    selectors = this.#named(selectors);
                 const declarations = atom.declaration.important
                     ? { importantDeclarations: [atom.declaration.value] }
                     : { declarations: [atom.declaration.value] };
@@ -233,6 +403,10 @@ export class Compiler {
         return emit(root);
     }
 }
+// Markers as they appear in JSON keys, which escape the `\0`.
+const MARKER_KEY = JSON.stringify(MARKER_PREFIX).slice(1, -1);
+// A stylesheet file, for positions and source maps.
+const fileBlock = (file) => ({ code: '', lang: 'css', file, line: 1, column: 1 });
 // Reads prepended files, relative to `dir`, once.
 function readPrepend(dir, files) {
     const read = (list = []) => list.map((file) => readFileSync(resolvePath(dir, file), 'utf8')).join('\n');

package/dist/compiler/config.d.ts

@@ -0,0 +1,15 @@
+import type { PrependFiles } from './compiler.ts';
+import type { LibraryConfig } from './libraries.ts';
+export interface PackageConfig {
+    include?: string | string[];
+    exclude?: string | string[];
+    prependFiles?: PrependFiles;
+    libraries?: Record<string, LibraryConfig | boolean>;
+    quirksMode?: boolean;
+}
+export declare function checkField(field: Record<string, unknown>, where: string, keys: Set<string>): string[];
+export declare function readConfig(root: string): {
+    dir: string;
+    config: PackageConfig;
+    warnings: string[];
+};

package/dist/compiler/config.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const KEYS = new Set(['include', 'exclude', 'prependFiles', 'libraries', 'quirksMode']);
+const isStrings = (value) => typeof value === 'string' ||
+    (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+const isPrependFiles = (value) => (Array.isArray(value) && isStrings(value)) ||
+    (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.entries(value).every(([lang, files]) => (lang === 'css' || lang === 'scss') && Array.isArray(files) && isStrings(files)));
+// Checks a `pre.style` field's shared keys, and returns warnings for keys
+// it doesn't know. `where` names the field in errors.
+export function checkField(field, where, keys) {
+    const fail = (key, expected) => {
+        throw new Error(`[pre.style] ${where}: \`${key}\` must be ${expected}.`);
+    };
+    if (field.include !== undefined && !isStrings(field.include))
+        fail('include', 'a glob or an array of globs');
+    if (field.exclude !== undefined && !isStrings(field.exclude))
+        fail('exclude', 'a glob or an array of globs');
+    if (field.prependFiles !== undefined && !isPrependFiles(field.prependFiles))
+        fail('prependFiles', 'an array of paths, or an object with `css` and `scss` arrays');
+    if (field.quirksMode !== undefined && typeof field.quirksMode !== 'boolean')
+        fail('quirksMode', '`true` or `false`');
+    if (field.libraries !== undefined &&
+        (field.libraries === null ||
+            typeof field.libraries !== 'object' ||
+            Array.isArray(field.libraries)))
+        fail('libraries', 'an object of package names');
+    return Object.keys(field)
+        .filter((key) => !keys.has(key))
+        .map((key) => `${where}: unknown key \`${key}\`.`);
+}
+// Reads the `pre.style` field from the package.json nearest `root`. `dir`
+// is the package's directory, which the field's paths are relative to.
+export function readConfig(root) {
+    for (let dir = root;; dir = dirname(dir)) {
+        const file = join(dir, 'package.json');
+        if (existsSync(file)) {
+            const field = JSON.parse(readFileSync(file, 'utf8'))['pre.style'];
+            if (field === undefined)
+                return { dir, config: {}, warnings: [] };
+            const where = `"pre.style" in ${file}`;
+            if (field === null || typeof field !== 'object' || Array.isArray(field))
+                throw new Error(`[pre.style] ${where} must be an object.`);
+            const warnings = checkField(field, where, KEYS);
+            return { dir, config: field, warnings };
+        }
+        if (dirname(dir) === dir)
+            return { dir: root, config: {}, warnings: [] };
+    }
+}

package/dist/compiler/index.d.ts

@@ -1,5 +1,10 @@
 export { Compiler, createCompiler } from './compiler.ts';
-export type { Block, CompilerOptions, Library, PrependFiles } from './compiler.ts';
+export type { Block, CompiledStylesheet, CompilerOptions, Library, PrependFiles, Stylesheet, } from './compiler.ts';
 export { PreStyleError } from './block.ts';
 export type { Lang, LightningOptions, Position } from './block.ts';
 export type { Printed } from './print.ts';
+export { checkField, readConfig } from './config.ts';
+export type { PackageConfig } from './config.ts';
+export { findLibraries } from './libraries.ts';
+export type { LibraryConfig, ResolvedLibrary } from './libraries.ts';
+export { isIdentifier } from './stylesheet.ts';

package/dist/compiler/index.js

@@ -1,2 +1,5 @@
 export { Compiler, createCompiler } from './compiler.js';
 export { PreStyleError } from './block.js';
+export { checkField, readConfig } from './config.js';
+export { findLibraries } from './libraries.js';
+export { isIdentifier } from './stylesheet.js';

package/dist/compiler/libraries.d.ts

@@ -0,0 +1,14 @@
+import type { PrependFiles } from './compiler.ts';
+export interface LibraryConfig {
+    include?: string | string[];
+    exclude?: string | string[];
+    prependFiles?: PrependFiles;
+}
+export interface ResolvedLibrary {
+    name: string;
+    dir: string;
+    include: string[];
+    exclude: string[];
+    prependFiles?: PrependFiles;
+}
+export declare function findLibraries(root: string, overrides?: Record<string, LibraryConfig | boolean>, warn?: (message: string) => void): ResolvedLibrary[];

package/dist/compiler/libraries.js

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { checkField } from './config.js';
+// Keys a library's field shares with the app's. `libraries` and
+// `quirksMode` only apply to the app.
+const SHARED_KEYS = new Set(['include', 'exclude', 'prependFiles']);
+const APP_KEYS = new Set(['libraries', 'quirksMode']);
+const DEFAULT_INCLUDE = ['**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts,astro}'];
+const readPackage = (dir) => JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+// Finds an installed package the way Node does, by looking in each
+// `node_modules` up from `from`.
+function findPackage(name, from) {
+    for (let dir = from;; dir = dirname(dir)) {
+        const candidate = join(dir, 'node_modules', name);
+        if (existsSync(join(candidate, 'package.json')))
+            return realpathSync(candidate);
+        if (dirname(dir) === dir)
+            return null;
+    }
+}
+// Finds the pre.style component libraries an app uses: its dependencies
+// with a `pre.style` field, and theirs, recursively. `overrides` adds
+// packages, changes their config, or (with `false`) leaves them out.
+// `warn` receives problems that don't stop the build.
+export function findLibraries(root, overrides = {}, warn = () => { }) {
+    const libraries = [];
+    const seen = new Set();
+    const visit = (name, from) => {
+        const dir = findPackage(name, from);
+        if (dir === null || seen.has(dir))
+            return;
+        seen.add(dir);
+        const pkg = readPackage(dir);
+        const config = Object.hasOwn(overrides, name) ? overrides[name] : pkg['pre.style'];
+        if (!config)
+            return;
+        if (config !== true) {
+            const where = Object.hasOwn(overrides, name)
+                ? `"libraries" entry for ${name}`
+                : `"pre.style" in ${join(dir, 'package.json')}`;
+            for (const key of Object.keys(config))
+                if (APP_KEYS.has(key))
+                    warn(`${where}: \`${key}\` only applies to the app, so it's ignored for a library.`);
+            for (const warning of checkField(config, where, new Set([...SHARED_KEYS, ...APP_KEYS])))
+                warn(warning);
+        }
+        const { include, exclude, prependFiles } = config === true ? {} : config;
+        libraries.push({
+            name,
+            dir,
+            include: include === undefined ? DEFAULT_INCLUDE : [include].flat(),
+            exclude: exclude === undefined ? [] : [exclude].flat(),
+            prependFiles,
+        });
+        // A library's peer dependencies are installed by the app, and found the
+        // same way from the library.
+        for (const dependency of Object.keys({
+            ...pkg.dependencies,
+            ...pkg.peerDependencies,
+            ...pkg.optionalDependencies,
+        })) {
+            visit(dependency, dir);
+        }
+    };
+    const app = existsSync(join(root, 'package.json')) ? readPackage(root) : {};
+    const names = Object.keys({
+        ...app.dependencies,
+        ...app.devDependencies,
+        ...app.optionalDependencies,
+        ...overrides,
+    });
+    for (const name of names)
+        visit(name, root);
+    return libraries;
+}

package/dist/compiler/mapper.d.ts

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

package/dist/compiler/mapper.js

@@ -0,0 +1,160 @@
+// The TypeScript content mapper (TypeScript 7.1 and later). `tsc` and the
+// editor run it as a separate process, through the `typescript.contentMapper`
+// field in package.json, and send it each `.css` and `.scss` file in the
+// program over JSON-RPC on stdio. It answers with a TypeScript view of the
+// file that declares one `string` export per class, so named imports from
+// stylesheet files are typed with their exact keys.
+//
+// Register it in tsconfig.json, and run `tsc --runExternalCode`:
+//
+//   "contentMappers": [{ "package": "@pre.style/core", "extensions": [".css", ".scss"] }]
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { PreStyleError } from './block.js';
+import { createCompiler } from './compiler.js';
+import { readConfig } from './config.js';
+import { findLibraries } from './libraries.js';
+import { isIdentifier } from './stylesheet.js';
+// Each open project's compiler, by its handle.
+const projects = new Map();
+// Diagnostic codes, for errors in a stylesheet file.
+const INVALID_STYLESHEET = 9001;
+const prependPaths = (dir, files) => (Array.isArray(files) ? files : [...(files?.css ?? []), ...(files?.scss ?? [])]).map((file) => resolve(dir, file));
+async function openProject(params) {
+    // The project's package.json, nearest its tsconfig.json.
+    const root = params.configFileName ? dirname(params.configFileName) : process.cwd();
+    const app = readConfig(root);
+    const libraries = findLibraries(app.dir, app.config.libraries);
+    const compiler = createCompiler({
+        root: app.dir,
+        prependFiles: app.config.prependFiles,
+        libraries: libraries.map(({ dir, prependFiles }) => ({ dir, prependFiles })),
+        quirksMode: app.config.quirksMode,
+        warn: () => { },
+    });
+    projects.set(params.projectHandle, compiler);
+    await compiler;
+    // Changes to these files change which classes files export.
+    const watchedFiles = [
+        join(app.dir, 'package.json'),
+        ...prependPaths(app.dir, app.config.prependFiles),
+        ...libraries.flatMap(({ dir, prependFiles }) => [
+            join(dir, 'package.json'),
+            ...prependPaths(dir, prependFiles),
+        ]),
+    ].filter((file) => existsSync(file));
+    const hash = createHash('sha256');
+    for (const file of watchedFiles)
+        hash.update(`${file}\0${readFileSync(file, 'utf8')}\0`);
+    return { configIdentity: hash.digest('hex'), watchedFiles };
+}
+// The offset of a line and column (line from 0, column from 1) in `text`.
+function offsetOf(text, line, column) {
+    let offset = 0;
+    for (let i = 0; i < line; i++) {
+        const next = text.indexOf('\n', offset);
+        if (next === -1)
+            break;
+        offset = next + 1;
+    }
+    return Math.min(text.length, offset + column - 1);
+}
+async function transform(params) {
+    const compiler = await projects.get(params.projectHandle);
+    if (compiler === undefined)
+        throw new Error(`Unknown project ${params.projectHandle}.`);
+    const { fileName, content } = params;
+    let names;
+    try {
+        names = compiler.classNames({
+            code: content,
+            lang: fileName.endsWith('.scss') ? 'scss' : 'css',
+            file: fileName,
+        });
+    }
+    catch (error) {
+        if (!(error instanceof PreStyleError))
+            throw error;
+        const position = error.position;
+        return {
+            text: 'export {};\n',
+            extension: '.ts',
+            diagnostics: [
+                {
+                    // The message without the file:line:col prefix, which the
+                    // diagnostic shows itself.
+                    messageText: error.message.replace(/^.*?:\d+:\d+: /, ''),
+                    start: position ? offsetOf(content, position.line, position.column) : 0,
+                    length: 0,
+                    code: INVALID_STYLESHEET,
+                },
+            ],
+        };
+    }
+    // One `string` export per class. Each name maps to where the class is
+    // first written in the file, so go-to-definition opens the stylesheet.
+    let text = '';
+    const mappings = [];
+    let local = 0;
+    for (const name of names) {
+        const written = new RegExp(`\\.${name.replace(/[^\w-]/g, '\\$&')}(?![\\w-])`).exec(content);
+        let start;
+        if (isIdentifier(name)) {
+            text += 'export declare const ';
+            start = text.length;
+            text += `${name}: string;\n`;
+        }
+        else {
+            const binding = `__pre_style_${local++}`;
+            text += `declare const ${binding}: string;\nexport { ${binding} as `;
+            start = text.length + 1;
+            text += `${JSON.stringify(name)} };\n`;
+        }
+        // Verbatim mapping: the same text in both, in UTF-16 code units.
+        if (written !== null)
+            mappings.push([start, name.length, written.index + 1, name.length, 0]);
+    }
+    return { text: text || 'export {};\n', extension: '.ts', mappings };
+}
+async function handle(request) {
+    switch (request.method) {
+        case 'initialize':
+            return { positionEncoding: 'utf-16', diagnosticSource: 'pre.style' };
+        case 'openProject':
+            return openProject(request.params);
+        case 'transform':
+            return transform(request.params);
+        case 'closeProject':
+            projects.delete(request.params.projectHandle);
+            return null;
+        default:
+            throw Object.assign(new Error(`Unknown method ${request.method}.`), { code: -32601 });
+    }
+}
+function send(message) {
+    const body = Buffer.from(JSON.stringify({ jsonrpc: '2.0', ...message }));
+    process.stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
+    process.stdout.write(body);
+}
+// Messages are framed like the Language Server Protocol's: a
+// `Content-Length` header, a blank line, then the JSON body.
+let buffer = Buffer.alloc(0);
+process.stdin.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    for (;;) {
+        const headerEnd = buffer.indexOf('\r\n\r\n');
+        if (headerEnd === -1)
+            return;
+        const length = Number(/Content-Length: *(\d+)/i.exec(buffer.subarray(0, headerEnd).toString())?.[1]);
+        const start = headerEnd + 4;
+        if (buffer.length < start + length)
+            return;
+        const request = JSON.parse(buffer.subarray(start, start + length).toString());
+        buffer = buffer.subarray(start + length);
+        // Notifications have no ID, and get no response.
+        if (request.id === undefined)
+            continue;
+        handle(request).then((result) => send({ id: request.id, result }), (error) => send({ id: request.id, error: { code: error.code ?? -32603, message: error.message } }));
+    }
+});

package/dist/compiler/stylesheet.d.ts

@@ -0,0 +1,15 @@
+import type { Atom, Compose, GlobalRule, Lang, ParseOptions } from './block.ts';
+export declare const MARKER_PREFIX = "\0pre.style-marker:";
+export declare const markerKey: (id: string, name: string) => string;
+export declare const isIdentifier: (name: string) => boolean;
+export interface StylesheetClass {
+    atoms: Atom[];
+    composes: Compose[];
+    marker: boolean;
+}
+export interface ParsedStylesheet {
+    classes: Map<string, StylesheetClass>;
+    globals: GlobalRule[];
+    dependencies: string[];
+}
+export declare function parseStylesheet(code: string, lang: Lang, file: string, id: string, options: ParseOptions): ParsedStylesheet;