@reforma/project-tokens 0.0.1

package/dist/mutation/token-operations.d.ts

@@ -0,0 +1,31 @@
+import { TokenMutationLayout } from './layout.js';
+import type { DtcgTokenType } from '../authoring.js';
+import type { TokenCompilation, TokenCompilationOptions } from '../compilation/compiler.js';
+import type { TokenMutation } from './types.js';
+export declare class TokenOperations {
+    private readonly options;
+    private readonly compilation;
+    private readonly layout;
+    constructor(options: Omit<TokenCompilationOptions, 'documents'>, compilation: TokenCompilation, layout: TokenMutationLayout);
+    rename(mutation: Extract<TokenMutation, {
+        kind: 'token.rename' | 'group.rename';
+    }>, sourcePath: string[]): void;
+    duplicate(path: string[], destination: string[]): void;
+    createGroup(path: string[], type?: DtcgTokenType): void;
+    deleteGroup(mutation: Extract<TokenMutation, {
+        kind: 'group.delete';
+    }>, path: string[]): void;
+    deleteToken(tokenPath: string, path: string[]): void;
+    private materializeTokenReferences;
+    edit(mutation: Extract<TokenMutation, {
+        kind: 'token.create' | 'token.reset' | 'token.update';
+    }>, path: string[]): Promise<boolean>;
+    private createToken;
+    private resetToken;
+    private updateToken;
+    private assertScopeDestination;
+    private assertTokenParents;
+    private assertGroupPath;
+}
+export declare function validateTokenPath(path: string): string[];
+//# sourceMappingURL=token-operations.d.ts.map

package/dist/mutation/token-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-operations.d.ts","sourceRoot":"","sources":["../../src/mutation/token-operations.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAIlD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAC5F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,eAAe;IAEpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAH3B,YACqB,OAAO,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,CAAC,EACnD,WAAW,EAAE,gBAAgB,EAC7B,MAAM,EAAE,mBAAmB,EAC5C;IAEJ,MAAM,CACF,QAAQ,EAAE,OAAO,CAAC,aAAa,EAAE;QAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAAA;KAAE,CAAC,EAC3E,UAAU,EAAE,MAAM,EAAE,QAsBvB;IAED,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,QAoB9C;IAED,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,aAAa,QAqB/C;IAED,WAAW,CACP,QAAQ,EAAE,OAAO,CAAC,aAAa,EAAE;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,CAAC,EAC1D,IAAI,EAAE,MAAM,EAAE,QAkDjB;IAED,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QA0C5C;IAED,OAAO,CAAC,0BAA0B;IAoG5B,IAAI,CACN,QAAQ,EAAE,OAAO,CAAC,aAAa,EAAE;QAC7B,IAAI,EAAE,cAAc,GAAG,aAAa,GAAG,cAAc,CAAC;KACzD,CAAC,EACF,IAAI,EAAE,MAAM,EAAE,oBA+DjB;IAED,OAAO,CAAC,WAAW;IA2BnB,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,WAAW;IAyBnB,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,eAAe;CAQ1B;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,YAgB7C"}

package/dist/mutation/token-operations.js

@@ -0,0 +1,309 @@
+import { relative, resolve, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { isDtcgTokenType } from '../compilation/scope-validation.js';
+import { decodeJsonPointer, encodeJsonPointer } from '../json-pointer.js';
+import { TokenReferenceRenamer } from './reference-renamer.js';
+import { TokenMutationError } from './types.js';
+export class TokenOperations {
+    options;
+    compilation;
+    layout;
+    constructor(options, compilation, layout) {
+        this.options = options;
+        this.compilation = compilation;
+        this.layout = layout;
+    }
+    rename(mutation, sourcePath) {
+        const destinationPath = validateTokenPath(mutation.to);
+        if (mutation.kind === 'token.rename' && destinationPath.at(-1) === '$root' && sourcePath.at(-1) !== '$root') {
+            throw new TokenMutationError('INVALID_PATH', 'Choose a non-reserved variable name.');
+        }
+        if (mutation.kind === 'group.rename'
+            && (sourcePath.includes('$root') || destinationPath.includes('$root'))) {
+            throw new TokenMutationError('INVALID_PATH', '$root is a token, not a group.');
+        }
+        new TokenReferenceRenamer(this.options, this.compilation, this.layout.documents, this.layout.modeFiles).rename(mutation, sourcePath, destinationPath);
+    }
+    duplicate(path, destination) {
+        this.assertScopeDestination(path);
+        this.assertScopeDestination(destination);
+        if (destination.includes('$root') || path.slice(0, -1).join('.') !== destination.slice(0, -1).join('.')) {
+            throw new TokenMutationError('INVALID_PATH', 'Duplicate a variable under a new sibling name.');
+        }
+        const { documents, modeFiles, profile } = this.layout;
+        const source = documents.read(profile.baseFile, path);
+        if (!source || !Object.hasOwn(source, '$value')) {
+            throw new TokenMutationError('TOKEN_NOT_FOUND', 'Choose a variable defined in the base source.');
+        }
+        for (const file of new Set(modeFiles.values())) {
+            if (documents.read(file, destination) !== undefined) {
+                throw new TokenMutationError('PATH_EXISTS', 'Token or group already exists.');
+            }
+        }
+        for (const file of new Set(modeFiles.values())) {
+            const definition = documents.read(file, path);
+            if (definition !== undefined)
+                documents.edit(file, destination, definition);
+        }
+    }
+    createGroup(path, type) {
+        this.assertGroupPath(path);
+        if (type !== undefined) {
+            if (path.length !== 1 || !isDtcgTokenType(type)) {
+                throw new TokenMutationError('INVALID_SCOPE', 'Create a top-level scope with a standard DTCG type.');
+            }
+        }
+        else {
+            this.assertScopeDestination(path);
+        }
+        if ([...this.layout.modeFiles.values()].some(file => (this.layout.documents.read(file, path) !== undefined))) {
+            throw new TokenMutationError('PATH_EXISTS', 'Token or group already exists.');
+        }
+        this.layout.documents.edit(this.layout.profile.baseFile, path, type ? { $type: type } : {});
+    }
+    deleteGroup(mutation, path) {
+        this.assertGroupPath(path);
+        const { documents, modeFiles } = this.layout;
+        const files = [...modeFiles.values()].filter(file => (documents.read(file, path) !== undefined));
+        if (files.length === 0) {
+            throw new TokenMutationError('GROUP_NOT_FOUND', 'Group does not exist.');
+        }
+        const affectedTokens = [
+            ...new Set(this.compilation.permutations
+                .flatMap(permutation => permutation.tokens)
+                .filter(token => token.path.startsWith(`${mutation.path}.`))
+                .map(token => token.path)),
+        ].sort();
+        const confirmedTokens = mutation.tokens
+            ? [...new Set(mutation.tokens)].sort()
+            : null;
+        if (confirmedTokens && JSON.stringify(confirmedTokens) !== JSON.stringify(affectedTokens)) {
+            throw new TokenMutationError('REVISION_CONFLICT', 'The confirmed group token inventory changed.');
+        }
+        for (const file of files) {
+            const group = documents.read(file, path);
+            const hasChildren = Object.keys(group).some(key => (!key.startsWith('$') || key === '$root'));
+            const mustBeEmpty = !mutation.tokens && hasChildren;
+            if ('$value' in group || '$extends' in group || mustBeEmpty) {
+                throw new TokenMutationError('GROUP_NOT_EMPTY', 'Only empty groups can be deleted.');
+            }
+            documents.edit(file, path, undefined);
+        }
+    }
+    deleteToken(tokenPath, path) {
+        const tokens = this.compilation.permutations.flatMap(permutation => (permutation.tokens.filter(token => token.path === tokenPath)));
+        if (tokens.length === 0) {
+            throw new TokenMutationError('TOKEN_NOT_FOUND', 'Token does not exist.');
+        }
+        const sourceFiles = [...this.layout.modeFiles.values()];
+        const expectedPointer = encodeJsonPointer(path);
+        const ambiguousSource = tokens.some(token => (token.source.pointer !== expectedPointer
+            || !sourceFiles.includes(token.source.file)));
+        if (ambiguousSource) {
+            this.layout.throwAmbiguous();
+        }
+        const defaultToken = this.compilation.permutations.find(permutation => (permutation.input.mode === this.layout.profile.defaultMode))?.tokens.find(token => token.path === tokenPath);
+        if (!defaultToken) {
+            throw new TokenMutationError('TOKEN_NOT_FOUND', 'Token does not exist in the default mode.');
+        }
+        this.materializeTokenReferences(tokenPath, path, defaultToken.value, sourceFiles);
+        for (const file of this.layout.modeFiles.values()) {
+            if (this.layout.documents.read(file, path) !== undefined) {
+                this.layout.documents.edit(file, path, undefined);
+            }
+        }
+    }
+    materializeTokenReferences(tokenPath, path, value, sourceFiles) {
+        const { documents } = this.layout;
+        for (const file of documents.files) {
+            if (file === documents.entryFile)
+                continue;
+            const resolveReference = (reference) => {
+                const url = new URL(reference, pathToFileURL(resolve(this.options.workspaceRoot, file)));
+                const target = new URL(url);
+                target.hash = '';
+                const targetFile = relative(resolve(this.options.workspaceRoot), fileURLToPath(target)).split(sep).join('/');
+                const isInternal = reference.startsWith('#');
+                if ((isInternal && !sourceFiles.includes(file))
+                    || (!isInternal && !sourceFiles.includes(targetFile))) {
+                    return undefined;
+                }
+                const fragment = decodeURIComponent(url.hash.slice(1));
+                if (!fragment.startsWith('/'))
+                    return undefined;
+                const referencePath = decodeJsonPointer(fragment);
+                if (!path.every((part, index) => referencePath[index] === part)) {
+                    return undefined;
+                }
+                const componentPath = referencePath.slice(path.length);
+                if (componentPath[0] === '$value')
+                    componentPath.shift();
+                else if (componentPath.length > 0)
+                    return undefined;
+                let resolved = value;
+                for (const part of componentPath) {
+                    if (!resolved || typeof resolved !== 'object' || !Object.hasOwn(resolved, part)) {
+                        return undefined;
+                    }
+                    resolved = resolved[part];
+                }
+                return structuredClone(resolved);
+            };
+            const visitValue = (node, nodePath) => {
+                if (node === `{${tokenPath}}`) {
+                    documents.edit(file, nodePath, structuredClone(value));
+                    return;
+                }
+                if (!node || typeof node !== 'object')
+                    return;
+                if ('$ref' in node && typeof node.$ref === 'string') {
+                    const resolved = resolveReference(node.$ref);
+                    if (resolved !== undefined) {
+                        documents.edit(file, nodePath, resolved);
+                        return;
+                    }
+                }
+                for (const [key, child] of Object.entries(node)) {
+                    if (key === '$extensions')
+                        continue;
+                    visitValue(child, [...nodePath, Array.isArray(node) ? Number(key) : key]);
+                }
+            };
+            const visitGroups = (node, nodePath = []) => {
+                if (!node || typeof node !== 'object')
+                    return;
+                if ('$value' in node) {
+                    const reference = '$ref' in node && typeof node.$ref === 'string'
+                        ? resolveReference(node.$ref)
+                        : undefined;
+                    if (reference !== undefined) {
+                        const definition = { ...node, $value: reference };
+                        delete definition.$ref;
+                        documents.edit(file, nodePath, definition);
+                        return;
+                    }
+                    visitValue(node.$value, [...nodePath, '$value']);
+                    return;
+                }
+                for (const [key, child] of Object.entries(node)) {
+                    if (!key.startsWith('$') || key === '$root') {
+                        visitGroups(child, [...nodePath, key]);
+                    }
+                }
+            };
+            visitGroups(documents.parse(file));
+        }
+    }
+    async edit(mutation, path) {
+        this.assertScopeDestination(path);
+        if (mutation.kind === 'token.create' && mutation.mode !== this.layout.profile.defaultMode) {
+            throw new TokenMutationError('INVALID_MUTATION', 'Create tokens in the base mode; other modes override existing tokens.');
+        }
+        if (mutation.kind === 'token.create' && path.includes('$root')) {
+            throw new TokenMutationError('INVALID_PATH', 'Choose a non-reserved variable name.');
+        }
+        if (mutation.kind === 'token.update' && Object.hasOwn(mutation.properties, '$type')) {
+            throw new TokenMutationError('INVALID_MUTATION', 'Token type belongs to its scope and cannot be edited.');
+        }
+        const selected = this.compilation.permutations.find(permutation => (permutation.input.mode === mutation.mode));
+        if (!selected) {
+            throw new TokenMutationError('MODE_NOT_FOUND', 'Mode does not exist.');
+        }
+        const token = selected.tokens.find(candidate => candidate.path === mutation.path);
+        if (mutation.kind === 'token.reset'
+            && token
+            && !this.layout.modeFiles.has(mutation.mode)) {
+            return false;
+        }
+        const file = await this.layout.ensureModeFile(mutation.mode);
+        this.assertTokenParents(file, path);
+        if (mutation.kind === 'token.create') {
+            this.createToken(file, path, token, mutation.token);
+            return true;
+        }
+        if (!token) {
+            throw new TokenMutationError('TOKEN_NOT_FOUND', 'Token does not exist.');
+        }
+        const sourceFiles = [...this.layout.modeFiles.values()];
+        const sourceOwned = token.source.pointer === encodeJsonPointer(path)
+            && sourceFiles.includes(token.source.file);
+        if (!sourceOwned) {
+            this.layout.throwAmbiguous();
+        }
+        if (mutation.kind === 'token.reset') {
+            this.resetToken(file, path, mutation.mode);
+            return true;
+        }
+        this.updateToken(file, path, token.source.file, mutation.properties);
+        return true;
+    }
+    createToken(file, path, existing, definition) {
+        if (existing || this.layout.documents.read(file, path) !== undefined) {
+            throw new TokenMutationError('PATH_EXISTS', 'Token or group already exists.');
+        }
+        if (!Object.hasOwn(definition, '$value')) {
+            throw new TokenMutationError('INVALID_MUTATION', 'A token must have a value.');
+        }
+        if (Object.hasOwn(definition, '$type')) {
+            throw new TokenMutationError('INVALID_MUTATION', 'Tokens inherit their scope type; omit $type.');
+        }
+        this.layout.documents.edit(file, path, definition);
+    }
+    resetToken(file, path, mode) {
+        if (mode === this.layout.mode.default) {
+            throw new TokenMutationError('DEFAULT_RESET', 'The base value cannot be reset.');
+        }
+        if (this.layout.documents.read(file, path) !== undefined) {
+            this.layout.documents.edit(file, path, undefined);
+        }
+    }
+    updateToken(file, path, sourceFile, properties) {
+        const { documents } = this.layout;
+        if (file !== sourceFile) {
+            documents.edit(file, path, {
+                ...documents.read(sourceFile, path),
+            });
+        }
+        if (properties.$value !== undefined) {
+            documents.edit(file, [...path, '$ref'], undefined);
+        }
+        for (const [key, value] of Object.entries(properties)) {
+            if (value !== undefined) {
+                documents.edit(file, [...path, key], value);
+            }
+        }
+    }
+    assertScopeDestination(path) {
+        const scope = this.layout.documents.read(this.layout.profile.baseFile, path.slice(0, 1));
+        if (path.length < 2 || !scope || '$value' in scope || !isDtcgTokenType(scope.$type)) {
+            throw new TokenMutationError('INVALID_SCOPE', 'Choose an existing typed scope as the destination.');
+        }
+        this.assertTokenParents(this.layout.profile.baseFile, path);
+        if (!this.layout.documents.read(this.layout.profile.baseFile, path.slice(0, -1))) {
+            throw new TokenMutationError('INVALID_SCOPE', 'The destination group no longer exists.');
+        }
+    }
+    assertTokenParents(file, path) {
+        for (let index = 1; index < path.length; index++) {
+            const parent = this.layout.documents.read(file, path.slice(0, index));
+            if (parent && ('$value' in parent || '$extends' in parent)) {
+                this.layout.throwAmbiguous();
+            }
+        }
+    }
+    assertGroupPath(path) {
+        if (path.includes('$root')) {
+            throw new TokenMutationError('INVALID_PATH', '$root is a token, not a group.');
+        }
+    }
+}
+export function validateTokenPath(path) {
+    const parts = path.split('.');
+    const invalid = parts.some((part, index) => (!part.trim() || part !== part.trim()
+        || /[{}]/.test(part)
+        || part.startsWith('$') && !(part === '$root' && index === parts.length - 1)));
+    if (invalid) {
+        throw new TokenMutationError('INVALID_PATH', 'Expected a canonical token path.');
+    }
+    return parts;
+}

package/dist/mutation/types.d.ts

@@ -0,0 +1,78 @@
+import type { DtcgTokenType } from '../authoring.js';
+import type { TokenCompilation } from '../compilation/compiler.js';
+export type TokenMutation = {
+    kind: 'token.update';
+    path: string;
+    mode: string;
+    properties: {
+        $value?: unknown;
+        $description?: string;
+        $deprecated?: boolean | string;
+    };
+} | {
+    kind: 'token.create';
+    path: string;
+    mode: string;
+    token: Record<string, unknown> & {
+        $value: unknown;
+        $type?: never;
+    };
+} | {
+    kind: 'token.duplicate';
+    path: string;
+    to: string;
+} | {
+    kind: 'token.delete';
+    path: string;
+} | {
+    kind: 'token.reset';
+    path: string;
+    mode: string;
+} | {
+    kind: 'token.rename';
+    path: string;
+    to: string;
+} | {
+    kind: 'group.rename';
+    path: string;
+    to: string;
+} | {
+    kind: 'mode.create';
+    mode: string;
+} | {
+    kind: 'mode.rename';
+    mode: string;
+    to: string;
+} | {
+    kind: 'mode.reset';
+    mode: string;
+} | {
+    kind: 'mode.default';
+    mode: string;
+} | {
+    kind: 'mode.delete';
+    mode: string;
+    replacement?: string;
+} | {
+    kind: 'scope.create';
+    path: string;
+    type: DtcgTokenType;
+} | {
+    kind: 'group.create';
+    path: string;
+} | {
+    kind: 'group.delete';
+    path: string;
+    tokens?: string[];
+};
+export interface TokenFileChange {
+    path: string;
+    before: string | null;
+    after: string;
+}
+export declare class TokenMutationError extends Error {
+    code: string;
+    compilation?: TokenCompilation | undefined;
+    constructor(code: string, message: string, compilation?: TokenCompilation | undefined);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/mutation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/mutation/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,MAAM,MAAM,aAAa,GAAG;IACxB,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACR,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;KAClC,CAAC;CACL,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC;CACvE,GAAG;IACA,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACd,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CAChB,GAAG;IACA,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CAChB,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACd,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACd,GAAG;IACA,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CAChB,GAAG;IACA,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACd,GAAG;IACA,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CAChB,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CAChB,GAAG;IACA,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACvB,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CAChB,GAAG;IACA,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAE9B,IAAI,EAAE,MAAM;IAEZ,WAAW,CAAC,EAAE,gBAAgB;IAHzC,YACW,IAAI,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACR,WAAW,CAAC,EAAE,gBAAgB,YAAA,EAGxC;CACJ"}

package/dist/mutation/types.js

@@ -0,0 +1,9 @@
+export class TokenMutationError extends Error {
+    code;
+    compilation;
+    constructor(code, message, compilation) {
+        super(message);
+        this.code = code;
+        this.compilation = compilation;
+    }
+}

package/dist/mutation/validation.d.ts

@@ -0,0 +1,4 @@
+import { type TokenMutation } from './types.js';
+import type { TokenCompilation } from '../compilation/compiler.js';
+export declare function validateMutationResult(previous: TokenCompilation, next: TokenCompilation, mutation: TokenMutation): void;
+//# sourceMappingURL=validation.d.ts.map

package/dist/mutation/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/mutation/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAEpE,OAAO,KAAK,EAAgB,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEjF,wBAAgB,sBAAsB,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,aAAa,QAY1B"}

package/dist/mutation/validation.js

@@ -0,0 +1,48 @@
+import { TokenMutationError } from './types.js';
+export function validateMutationResult(previous, next, mutation) {
+    switch (mutation.kind) {
+        case 'token.rename':
+        case 'group.rename':
+            validateRename(previous, next, mutation);
+            break;
+        case 'mode.default':
+        case 'mode.delete':
+            validateModeValues(previous, next);
+            break;
+    }
+}
+function validateRename(previous, next, mutation) {
+    for (const nextPermutation of next.permutations) {
+        const previousPermutation = previous.permutations.find(candidate => (candidate.input.mode === nextPermutation.input.mode));
+        const before = comparableRenameTokens(previousPermutation.tokens, mutation, true);
+        const after = comparableRenameTokens(nextPermutation.tokens, mutation, false);
+        if (before !== after) {
+            throw new TokenMutationError('AMBIGUOUS_SOURCE', 'This refactor would change effective values. Edit this layout in JSON.');
+        }
+    }
+}
+function comparableRenameTokens(tokens, mutation, rename) {
+    const values = tokens.map(token => {
+        const renamed = rename && (token.path === mutation.path
+            || mutation.kind === 'group.rename' && token.path.startsWith(`${mutation.path}.`));
+        const path = renamed
+            ? mutation.to + token.path.slice(mutation.path.length)
+            : token.path;
+        return [path, token.type, token.value, token.deprecated];
+    });
+    values.sort((left, right) => String(left[0]).localeCompare(String(right[0])));
+    return JSON.stringify(values);
+}
+function validateModeValues(previous, next) {
+    for (const nextPermutation of next.permutations) {
+        const previousPermutation = previous.permutations.find(candidate => (candidate.input.mode === nextPermutation.input.mode));
+        const before = comparableModeTokens(previousPermutation.tokens);
+        const after = comparableModeTokens(nextPermutation.tokens);
+        if (before !== after) {
+            throw new TokenMutationError('AMBIGUOUS_SOURCE', 'This source layout cannot be rebased without changing effective mode values. Edit it in JSON.');
+        }
+    }
+}
+function comparableModeTokens(tokens) {
+    return JSON.stringify(tokens.map(token => [token.path, token.type, token.css]));
+}

package/dist/source/composer.d.ts

@@ -0,0 +1,17 @@
+import { TokenSourceDocuments } from './documents.js';
+import type { SourceItem } from './values.js';
+export declare class TokenSourceComposer {
+    private readonly documents;
+    constructor(documents: TokenSourceDocuments);
+    compose(entry: URL, items: SourceItem[], input: Record<string, string>): Promise<any>;
+    private annotate;
+    private annotateToken;
+    private rebaseValueReferences;
+    private compilerSource;
+    private expandGroups;
+    private resolveValuePointers;
+    private resolveValuePointer;
+    private validateAliases;
+    private expandArrayAliases;
+}
+//# sourceMappingURL=composer.d.ts.map

package/dist/source/composer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composer.d.ts","sourceRoot":"","sources":["../../src/source/composer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAMtD,OAAO,KAAK,EAER,UAAU,EAEb,MAAM,aAAa,CAAC;AAErB,qBAAa,mBAAmB;IAChB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,oBAAoB,EAAI;IAE1D,OAAO,CACT,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,UAAU,EAAE,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,gBAmBhC;IAED,OAAO,CAAC,QAAQ;IA2DhB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,qBAAqB;IAgB7B,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,YAAY;YA6EN,oBAAoB;YA4BpB,mBAAmB;IAmDjC,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,kBAAkB;CA2C7B"}