@shapeshift-labs/frontier-lang-css 0.1.3 → 0.1.5

package/README.md

@@ -232,11 +232,11 @@ const merge = safeMergeCssSource({
 });
 ```
 
-`sourceMap.mappings` links emitted rule blocks back to Frontier Lang semantic node ids. `createCssSemanticMergeEvidence` records selectors, specificity, declarations, custom properties, cascade keys, CSS Modules exports, ICSS edges, source spans, stable hashes, and fail-closed proof gaps for cascade/render-sensitive CSS surfaces. `safeMergeCssSource` admits independent unscoped declaration edits by cascade key, and for `.module.css` files it classifies exported local classes, `composes`, and ICSS import/export records as explicit merge contracts.
+`sourceMap.mappings` links emitted rule blocks back to Frontier Lang semantic node ids. `createCssSemanticMergeEvidence` records selectors, specificity, declarations, custom properties, cascade keys, statement-form at-rules, CSS Modules exports, ICSS edges, scoped cascade graph proof hashes, source spans, stable hashes, and fail-closed proof gaps for cascade/render-sensitive CSS surfaces. `safeMergeCssSource` admits independent declaration edits by cascade key, including existing scoped `@media` / `@supports` / `@container` / `@layer` declarations when a scoped cascade graph proof hash is supplied, preserves unchanged statement-form at-rules such as `@layer reset, components;`, and for `.module.css` files it classifies exported local classes, `composes`, and ICSS import/export records as explicit merge contracts.
 
 ## Support Boundary
 
-- Ready evidence: style rules, selectors, specificity, declarations, custom properties, CSS Modules local exports, generated class-name map coverage, JS/TS use-site graph hashes, composition graph hashes, ICSS graph hashes, source spans, stable hashes.
-- Safe merge: independent unscoped declarations with non-overlapping cascade keys; explicit CSS Modules export additions/deletions when generated class-name and JS/TS use-site graph proof is supplied; composition edits when composition graph proof is supplied; ICSS edits when ICSS graph proof is supplied. Output is a canonical CSS render and not a byte/trivia-preserving claim.
-- Review-only gaps: incomplete generated class-name maps, unproved CSS Modules use-site graphs, unproved composition or ICSS graphs, shorthands without longhand expansion, scoped cascade under `@media` / `@supports` / `@container` / `@layer`, `@keyframes`, `@font-face`, `@page`, browser layout and render equivalence.
+- Ready evidence: style rules, selectors, specificity, declarations, custom properties, statement-form at-rules, CSS Modules local exports, generated class-name map coverage, JS/TS use-site graph hashes, composition graph hashes, ICSS graph hashes, scoped cascade graph hashes, source spans, stable hashes.
+- Safe merge: independent declarations with non-overlapping cascade keys; unchanged statement-form at-rules preserved in canonical output; existing scoped declaration edits when scoped cascade graph proof is supplied; explicit CSS Modules export additions/deletions when generated class-name and JS/TS use-site graph proof is supplied; composition edits when composition graph proof is supplied; ICSS edits when ICSS graph proof is supplied. Output is a canonical CSS render and not a byte/trivia-preserving claim.
+- Review-only gaps: incomplete generated class-name maps, unproved CSS Modules use-site graphs, unproved composition or ICSS graphs, shorthands without longhand expansion, statement-form at-rule order/condition changes, one-sided or structurally changed scoped cascade under `@media` / `@supports` / `@container` / `@layer`, `@keyframes`, `@font-face`, `@page`, browser layout and render equivalence.
 - Claims: `autoMergeClaim`, `semanticEquivalenceClaim`, `browserCascadeEquivalenceClaim`, and `browserRenderEquivalenceClaim` remain false.

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export interface CssProjectionOptions {
   readonly jsTsUseSiteGraphHash?: string;
   readonly cssModuleCompositionGraphHash?: string;
   readonly icssGraphHash?: string;
+  readonly scopedCascadeGraphHash?: string;
   readonly targetPath?: string;
   readonly semanticIndexId?: string;
   readonly sourceSpansBySemanticNodeId?: Readonly<Record<string, CssSourceSpan>>;
@@ -124,6 +125,8 @@ export interface CssSemanticRecord {
   readonly atRuleName?: string;
   readonly conditionText?: string;
   readonly scopeKey?: string;
+  readonly statementText?: string;
+  readonly scopedCascadeGraphHash?: string;
   readonly sourceSpan: CssSourceSpan;
   readonly sourceHash: string;
   readonly ruleHash?: string;
@@ -266,6 +269,7 @@ export interface CssSafeMergeInput {
   readonly jsTsUseSiteGraphHash?: string;
   readonly cssModuleCompositionGraphHash?: string;
   readonly icssGraphHash?: string;
+  readonly scopedCascadeGraphHash?: string;
   readonly baseGeneratedClassNameMap?: Readonly<Record<string, string>>;
   readonly workerGeneratedClassNameMap?: Readonly<Record<string, string>>;
   readonly headGeneratedClassNameMap?: Readonly<Record<string, string>>;
@@ -281,6 +285,9 @@ export interface CssSafeMergeInput {
   readonly baseIcssGraphHash?: string;
   readonly workerIcssGraphHash?: string;
   readonly headIcssGraphHash?: string;
+  readonly baseScopedCascadeGraphHash?: string;
+  readonly workerScopedCascadeGraphHash?: string;
+  readonly headScopedCascadeGraphHash?: string;
 }
 
 export declare function toCssAst(document: FrontierLangDocument, options?: CssProjectionOptions): CssAstStylesheet;

package/dist/index.js

@@ -59,7 +59,7 @@ export function emitCssWithSourceMap(document, options = {}) {
 export function parseCssSemanticSheet(sourceText, options = {}) {
   const lineStarts = computeLineStarts(sourceText);
   const sourceHash = options.sourceHash ?? hashSemanticValue({ kind: 'frontier.lang.css.source.v1', sourceText });
-  const records = parseCssBlocks(sourceText, 0, sourceText.length, [], lineStarts, sourceHash);
+  const records = parseCssBlocks(sourceText, 0, sourceText.length, [], lineStarts, sourceHash, options);
   const cssModules = createCssModuleEvidence(records, options, sourceHash);
   const proofGaps = [
     ...records.flatMap((record) => record.proofGaps ?? []),
@@ -112,8 +112,9 @@ export function safeMergeCssSource(input = {}) {
   return safeMergeCssSourceImpl(input, { parseCssSemanticSheet, hashSemanticValue });
 }
 
-function parseCssBlocks(sourceText, start, end, scopes, lineStarts, sourceHash) {
+function parseCssBlocks(sourceText, start, end, scopes, lineStarts, sourceHash, options) {
   const records = [];
+  const blockRanges = [];
   let index = start;
   while (index < end) {
     const open = sourceText.indexOf('{', index);
@@ -121,26 +122,28 @@ function parseCssBlocks(sourceText, start, end, scopes, lineStarts, sourceHash)
     const close = matchingBrace(sourceText, open, end);
     if (close < 0) break;
     const preludeStart = previousBoundary(sourceText, index, open);
+    blockRanges.push([preludeStart, close + 1]);
     const prelude = sourceText.slice(preludeStart, open).replace(/\/\*[\s\S]*?\*\//g, '').trim();
     const body = sourceText.slice(open + 1, close);
     if (prelude.startsWith('@')) {
-      const at = parseAtRule(prelude, preludeStart, close + 1, lineStarts, sourceHash, scopes);
+      const at = parseAtRule(prelude, preludeStart, close + 1, lineStarts, sourceHash, scopes, options);
       records.push(at);
-      if (ScopeAtRules.has(at.atRuleName)) records.push(...parseCssBlocks(sourceText, open + 1, close, [...scopes, at.scopeKey], lineStarts, sourceHash));
+      if (ScopeAtRules.has(at.atRuleName)) records.push(...parseCssBlocks(sourceText, open + 1, close, [...scopes, at.scopeKey], lineStarts, sourceHash, options));
     } else if (prelude) {
-      records.push(cssRuleRecord(prelude, body, preludeStart, close + 1, lineStarts, sourceHash, scopes));
+      records.push(cssRuleRecord(prelude, body, preludeStart, close + 1, lineStarts, sourceHash, scopes, options));
     }
     index = close + 1;
   }
-  return records;
+  records.push(...parseAtRuleStatements(sourceText, start, end, scopes, lineStarts, sourceHash, options, blockRanges));
+  return records.sort((left, right) => left.sourceSpan.startOffset - right.sourceSpan.startOffset);
 }
 
-function cssRuleRecord(prelude, body, start, end, lineStarts, sourceHash, scopes) {
+function cssRuleRecord(prelude, body, start, end, lineStarts, sourceHash, scopes, options) {
   const selectors = prelude.split(',').map((selector) => selector.trim()).filter(Boolean);
   const declarations = parseDeclarations(body);
   const proofGaps = [
     ...declarations.filter((declaration) => ShorthandProperties.has(declaration.property)).map((declaration) => proofGap('css-shorthand-expansion-unproved', `CSS shorthand ${declaration.property} needs longhand expansion evidence.`)),
-    ...scopes.length ? [proofGap('css-scoped-cascade-equivalence-unproved', 'Scoped cascade equivalence requires browser/style evidence.')] : []
+    ...scopes.length && !options.scopedCascadeGraphHash ? [proofGap('css-scoped-cascade-equivalence-unproved', 'Scoped cascade equivalence requires browser/style evidence.')] : []
   ];
   return compactRecord({
     kind: 'rule',
@@ -155,6 +158,7 @@ function cssRuleRecord(prelude, body, start, end, lineStarts, sourceHash, scopes
       declarationHash: hashSemanticValue({ kind: 'frontier.lang.css.declaration.v1', scopes, selectors, declaration })
     })),
     customProperties: declarations.filter((declaration) => declaration.property.startsWith('--')).map((declaration) => declaration.property),
+    scopedCascadeGraphHash: scopes.length ? options.scopedCascadeGraphHash : undefined,
     sourceSpan: sourceSpan(start, end, lineStarts),
     sourceHash,
     ruleHash: hashSemanticValue({ kind: 'frontier.lang.css.rule.v1', selectors, scopes, declarations }),
@@ -162,19 +166,20 @@ function cssRuleRecord(prelude, body, start, end, lineStarts, sourceHash, scopes
   });
 }
 
-function parseAtRule(prelude, start, end, lineStarts, sourceHash, scopes) {
+function parseAtRule(prelude, start, end, lineStarts, sourceHash, scopes, options) {
   const match = /^@([A-Za-z-]+)\s*([\s\S]*)$/.exec(prelude);
   const atRuleName = match?.[1]?.toLowerCase() ?? 'unknown';
   const conditionText = match?.[2]?.trim() ?? '';
   const proofGaps = [];
   if (RuntimeAtRules.has(atRuleName)) proofGaps.push(proofGap(`css-${atRuleName}-runtime-equivalence-unproved`, `CSS @${atRuleName} semantics require browser evidence.`));
-  if (ScopeAtRules.has(atRuleName)) proofGaps.push(proofGap(`css-${atRuleName}-cascade-scope-unproved`, `CSS @${atRuleName} scoped cascade requires condition evaluation evidence.`));
+  if (ScopeAtRules.has(atRuleName) && !options.scopedCascadeGraphHash) proofGaps.push(proofGap(`css-${atRuleName}-cascade-scope-unproved`, `CSS @${atRuleName} scoped cascade requires condition evaluation evidence.`));
   return compactRecord({
     kind: 'at-rule',
     atRuleName,
     conditionText,
     scopeKey: `@${atRuleName} ${conditionText}`.trim(),
     scopes,
+    scopedCascadeGraphHash: ScopeAtRules.has(atRuleName) ? options.scopedCascadeGraphHash : undefined,
     sourceSpan: sourceSpan(start, end, lineStarts),
     sourceHash,
     atRuleHash: hashSemanticValue({ kind: 'frontier.lang.css.atRule.v1', atRuleName, conditionText, scopes }),
@@ -182,6 +187,47 @@ function parseAtRule(prelude, start, end, lineStarts, sourceHash, scopes) {
   });
 }
 
+function parseAtRuleStatements(sourceText, start, end, scopes, lineStarts, sourceHash, options, blockRanges) {
+  const records = [];
+  let index = start;
+  while (index < end) {
+    const semicolon = sourceText.indexOf(';', index);
+    if (semicolon < 0 || semicolon >= end) break;
+    const range = blockRanges.find(([rangeStart, rangeEnd]) => semicolon >= rangeStart && semicolon < rangeEnd);
+    if (range) {
+      index = range[1];
+      continue;
+    }
+    const statementStart = previousBoundary(sourceText, index, semicolon);
+    const statementText = sourceText.slice(statementStart, semicolon + 1).replace(/\/\*[\s\S]*?\*\//g, '').trim();
+    if (statementText.startsWith('@') && !statementText.includes('{')) records.push(parseAtRuleStatement(statementText, statementStart, semicolon + 1, lineStarts, sourceHash, scopes, options));
+    index = semicolon + 1;
+  }
+  return records;
+}
+
+function parseAtRuleStatement(statementText, start, end, lineStarts, sourceHash, scopes, options) {
+  const body = statementText.replace(/;$/, '').trim();
+  const match = /^@([A-Za-z-]+)\s*([\s\S]*)$/.exec(body);
+  const atRuleName = match?.[1]?.toLowerCase() ?? 'unknown';
+  const conditionText = match?.[2]?.trim() ?? '';
+  const proofGaps = [];
+  if (atRuleName === 'layer') proofGaps.push(proofGap('css-layer-order-statement-unsupported', 'CSS @layer statement order requires cascade order evidence.'));
+  else proofGaps.push(proofGap(`css-${atRuleName}-statement-equivalence-unproved`, `CSS @${atRuleName} statement semantics require host evidence.`));
+  return compactRecord({
+    kind: 'at-rule-statement',
+    atRuleName,
+    conditionText,
+    statementText,
+    scopes,
+    scopedCascadeGraphHash: ScopeAtRules.has(atRuleName) ? options.scopedCascadeGraphHash : undefined,
+    sourceSpan: sourceSpan(start, end, lineStarts),
+    sourceHash,
+    atRuleHash: hashSemanticValue({ kind: 'frontier.lang.css.atRuleStatement.v1', atRuleName, conditionText, scopes, statementText }),
+    proofGaps
+  });
+}
+
 function parseDeclarations(body) {
   return body
     .replace(/\/\*[\s\S]*?\*\//g, '')
@@ -254,7 +300,7 @@ function positionAt(offset, lineStarts) {
 
 function sourceRef(node, extra = {}) { return { semanticNodeId: node.id, semanticNodeKind: node.kind, semanticNodeName: node.name, ...extra }; }
 function proofGap(code, summary) { return { code, status: 'not-claimed', summary, failClosed: true, semanticEquivalenceClaim: false }; }
-function hashableCssRecord(record) { return { kind: record.kind, selectors: record.selectors, specificity: record.specificity, scopes: record.scopes, atRuleName: record.atRuleName, conditionText: record.conditionText, declarations: record.declarations?.map((item) => ({ property: item.property, value: item.value, important: item.important })), proofGaps: record.proofGaps?.map((gap) => gap.code) }; }
+function hashableCssRecord(record) { return { kind: record.kind, selectors: record.selectors, specificity: record.specificity, scopes: record.scopes, atRuleName: record.atRuleName, conditionText: record.conditionText, statementText: record.statementText, declarations: record.declarations?.map((item) => ({ property: item.property, value: item.value, important: item.important })), proofGaps: record.proofGaps?.map((gap) => gap.code) }; }
 function computeLineStarts(text) { const starts = [0]; for (let index = 0; index < text.length; index += 1) if (text[index] === '\n') starts.push(index + 1); return starts; }
 function cssIdentifier(value) { return String(value ?? 'unknown').replace(/[^A-Za-z0-9_-]/g, '-').replace(/^-+/, '') || 'unknown'; }
 function cssString(value) { return String(value ?? '').replace(/\\/g, '\\\\').replace(/"/g, '\\"'); }

package/dist/semantic-merge-css-modules.js

@@ -8,7 +8,8 @@ function sheetOptions(input, side, sourcePath) {
     generatedClassNameMapHash: input[`${prefix}GeneratedClassNameMapHash`] ?? input.generatedClassNameMapHash,
     jsTsUseSiteGraphHash: input[`${prefix}JsTsUseSiteGraphHash`] ?? input.jsTsUseSiteGraphHash,
     cssModuleCompositionGraphHash: input[`${prefix}CssModuleCompositionGraphHash`] ?? input.cssModuleCompositionGraphHash,
-    icssGraphHash: input[`${prefix}IcssGraphHash`] ?? input.icssGraphHash
+    icssGraphHash: input[`${prefix}IcssGraphHash`] ?? input.icssGraphHash,
+    scopedCascadeGraphHash: input[`${prefix}ScopedCascadeGraphHash`] ?? input.scopedCascadeGraphHash
   };
 }
 
@@ -149,7 +150,7 @@ function unsupportedSourceShapeChanges(baseSheet, currentSheet, declarationChang
     if (changedDeclarationRuleKeys.has(before?.ruleKey) || changedDeclarationRuleKeys.has(after?.ruleKey)) return [];
     return [{
       side,
-      reasonCode: 'css-source-shape-unsupported',
+      reasonCode: sourceShapeChangeReason(before, after),
       shapeKey: key,
       before: sourceShapeDetails(before),
       after: sourceShapeDetails(after)
@@ -180,6 +181,19 @@ function sourceShapeIndex(sheet, hash) {
         atRuleName: record.atRuleName,
         conditionText: record.conditionText,
         representedByDeclarations: false,
+        unsupportedReasonCode: atRuleUnsupportedReasonCode(record),
+        hash: record.atRuleHash
+      });
+    }
+    if (record.kind === 'at-rule-statement') {
+      const shapeKey = `at-rule-statement:${[...(record.scopes ?? []), record.atRuleName, record.conditionText].join('::')}`;
+      result.set(shapeKey, {
+        kind: 'at-rule-statement',
+        atRuleName: record.atRuleName,
+        conditionText: record.conditionText,
+        statementText: record.statementText,
+        representedByDeclarations: false,
+        unsupportedReasonCode: atRuleStatementUnsupportedReasonCode(record),
         hash: record.atRuleHash
       });
     }
@@ -194,7 +208,15 @@ function conflict(id, sourcePath, code, reasonCode, details = {}) {
 
 function sameContractChange(left, right) { return (left.after?.hash ?? '') === (right.after?.hash ?? '') && left.kind === right.kind; }
 function contractChangeDetails(change) { return { kind: change.kind, contractKind: (change.after ?? change.before)?.contractKind, name: (change.after ?? change.before)?.name, hash: change.after?.hash }; }
-function sourceShapeDetails(shape) { return shape ? { kind: shape.kind, selectors: shape.selectors, atRuleName: shape.atRuleName, conditionText: shape.conditionText, representedByDeclarations: shape.representedByDeclarations } : undefined; }
+function sourceShapeDetails(shape) { return shape ? { kind: shape.kind, selectors: shape.selectors, atRuleName: shape.atRuleName, conditionText: shape.conditionText, statementText: shape.statementText, representedByDeclarations: shape.representedByDeclarations } : undefined; }
+function sourceShapeChangeReason(before, after) {
+  if (!before && after?.kind === 'at-rule') return 'css-atrule-new-scope-unsupported';
+  if (before?.kind === 'at-rule' || after?.kind === 'at-rule') return after?.unsupportedReasonCode ?? before?.unsupportedReasonCode ?? 'css-atrule-condition-edit-unsupported';
+  if (before?.kind === 'at-rule-statement' || after?.kind === 'at-rule-statement') return after?.unsupportedReasonCode ?? before?.unsupportedReasonCode ?? 'css-atrule-statement-unsupported';
+  return 'css-source-shape-unsupported';
+}
+function atRuleUnsupportedReasonCode(record) { return record.atRuleName === 'layer' ? 'css-layer-name-edit-unsupported' : 'css-atrule-condition-edit-unsupported'; }
+function atRuleStatementUnsupportedReasonCode(record) { return record.atRuleName === 'layer' ? 'css-layer-order-statement-unsupported' : 'css-atrule-statement-unsupported'; }
 function ruleIdentityKey(record) { return [...(record.scopes ?? []), record.selectors.join(',')].join('::'); }
 function unique(values) { return [...new Set(values.filter(Boolean))]; }
 function uniqueProofGaps(values) {

package/dist/semantic-merge.js

@@ -10,8 +10,6 @@ function safeMergeCssSource(input = {}, context = {}) {
   const head = input.headSourceText ?? base;
   if (typeof base !== 'string' || typeof worker !== 'string' || typeof head !== 'string') return blocked(id, sourcePath, 'css-source-text-missing');
   if (worker === head) return merged(id, sourcePath, worker, 'worker-head-identical', hash);
-  if (worker === base) return merged(id, sourcePath, head, 'worker-unchanged', hash);
-  if (head === base) return merged(id, sourcePath, worker, 'head-unchanged', hash);
   const sheets = {
     base: parseSheet(base, sheetOptions(input, 'base', sourcePath)),
     worker: parseSheet(worker, sheetOptions(input, 'worker', sourcePath)),
@@ -47,7 +45,17 @@ function safeMergeCssSource(input = {}, context = {}) {
 function declarationIndex(sheet) {
   const declarations = new Map();
   const order = [];
+  const statements = [];
   for (const record of sheet.records) {
+    if (record.kind === 'at-rule-statement') {
+      statements.push({
+        key: record.atRuleHash,
+        scopes: record.scopes ?? [],
+        statementText: record.statementText,
+        atRuleName: record.atRuleName,
+        conditionText: record.conditionText
+      });
+    }
     if (record.kind !== 'rule') continue;
     const ruleKey = ruleIdentityKey(record);
     for (const declaration of record.declarations ?? []) {
@@ -66,7 +74,7 @@ function declarationIndex(sheet) {
       order.push(entry.key);
     }
   }
-  return { declarations, order: unique(order) };
+  return { declarations, order: unique(order), statements };
 }
 
 function changedDeclarations(baseIndex, currentIndex, side) {
@@ -143,25 +151,55 @@ function applyDeclarationChanges(index, changes) {
       if (!order.includes(change.key)) order.push(change.key);
     }
   }
-  return { declarations, order: order.filter((key) => declarations.has(key)) };
+  return { declarations, order: order.filter((key) => declarations.has(key)), statements: index.statements ?? [] };
 }
 
 function renderDeclarationIndex(index) {
   const groups = new Map();
   for (const key of index.order) {
     const declaration = index.declarations.get(key);
-    if (!declaration || declaration.scopes.length) continue;
+    if (!declaration) continue;
     groups.set(declaration.ruleKey, [...(groups.get(declaration.ruleKey) ?? []), declaration]);
   }
   const chunks = [];
+  for (const statement of index.statements ?? []) renderAtRuleStatement(chunks, statement);
   for (const declarations of groups.values()) {
-    chunks.push(`${declarations[0].selectors.join(', ')} {`);
-    for (const declaration of declarations) chunks.push(`  ${declaration.property}: ${declaration.value};`);
-    chunks.push('}', '');
+    renderDeclarationGroup(chunks, declarations);
   }
   return `${chunks.join('\n').trimEnd()}\n`;
 }
 
+function renderAtRuleStatement(chunks, statement) {
+  let indent = 0;
+  for (const scope of statement.scopes ?? []) {
+    chunks.push(`${spaces(indent)}${scope} {`);
+    indent += 2;
+  }
+  chunks.push(`${spaces(indent)}${statement.statementText}`);
+  for (let index = (statement.scopes ?? []).length - 1; index >= 0; index -= 1) {
+    indent -= 2;
+    chunks.push(`${spaces(indent)}}`);
+  }
+  chunks.push('');
+}
+
+function renderDeclarationGroup(chunks, declarations) {
+  const first = declarations[0];
+  let indent = 0;
+  for (const scope of first.scopes) {
+    chunks.push(`${spaces(indent)}${scope} {`);
+    indent += 2;
+  }
+  chunks.push(`${spaces(indent)}${first.selectors.join(', ')} {`);
+  for (const declaration of declarations) chunks.push(`${spaces(indent + 2)}${declaration.property}: ${declaration.value};`);
+  chunks.push(`${spaces(indent)}}`);
+  for (let index = first.scopes.length - 1; index >= 0; index -= 1) {
+    indent -= 2;
+    chunks.push(`${spaces(indent)}}`);
+  }
+  chunks.push('');
+}
+
 function merged(id, sourcePath, sourceText, operation, hash, extra = {}) {
   return result(id, sourcePath, 'merged', {
     operation,
@@ -209,6 +247,7 @@ function proofGapsForDeclaration(record, declaration) {
   return (record.proofGaps ?? []).filter((gap) => gap.code !== 'css-shorthand-expansion-unproved' || gap.summary.includes(` ${declaration.property} `));
 }
 function unique(values) { return [...new Set(values.filter(Boolean))]; }
+function spaces(count) { return ' '.repeat(Math.max(0, count)); }
 
 function shorthandGroupForProperty(property) {
   if (ShorthandGroups.has(property)) return property;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-css",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CSS semantic merge evidence and projection adapter for Frontier Lang semantic source documents.",
   "type": "module",
   "main": "./dist/index.js",