@master/css-schema 2.0.0-rc.88 → 3.0.0

package/dist/css-common.d.ts

@@ -1,4 +1,2 @@
-//#region src/css-common.d.ts
 type Vendors = 'webkit' | 'moz' | 'ms' | 'o';
-//#endregion
 export { Vendors };

package/dist/css-directives.d.ts

@@ -1,11 +1,8 @@
-import { MasterCSSManifestDefaultMode, MasterCSSManifestModeTrigger, MasterCSSManifestUtilityKind, MasterCSSManifestUtilityLayerName, MasterCSSManifestVariant } from "./manifest.js";
-//#region src/css-directives.d.ts
+import { MasterCSSKeyframeDefinition } from "./keyframes.js";
+import { MasterCSSMixinDefinition, MasterCSSMixinNode, MasterCSSMixinValue, MasterCSSUtilityDefinition } from "./mixin.js";
+import { MasterCSSThemeNode } from "./manifest.js";
 type CSSDirectiveVariableValue = number | string | false | (number | string)[];
 type CSSDirectiveDeclarations = Record<string, string>;
-type CSSDirectiveLayerName = MasterCSSManifestUtilityLayerName;
-type CSSDirectiveModeTrigger = MasterCSSManifestModeTrigger;
-type CSSDirectiveDefaultMode = MasterCSSManifestDefaultMode;
-type CSSDirectiveVariantDefinitions = Pick<MasterCSSManifestVariant, 'token' | 'branches'>[];
 interface CSSDirectiveSourceRange {
   start: number;
   end: number;
@@ -33,107 +30,106 @@ declare class CSSDirectiveError extends Error {
   constructor(code: string, message: string, source?: CSSDirectiveSourceReference, related?: CSSDirectiveRelatedInformation[]);
 }
 declare function createCSSDirectiveSourceReference(file: string | undefined, range: CSSDirectiveSourceRange, source?: string): CSSDirectiveSourceReference;
-interface CSSDirectiveVariableDefinition {
-  name?: string;
-  value: CSSDirectiveVariableValue;
-  mode?: string;
-  inline?: boolean;
-  static?: boolean;
-  namespace?: string;
-  key?: string;
-}
-type CSSDirectiveAnimationDefinitions = Record<string, Record<string, CSSDirectiveDeclarations>>;
-type CSSDirectiveAnimationOptions = Record<string, {
-  static?: boolean;
-}>;
-type CSSDirectiveConditionPathEntry = {
-  type: 'condition';
-  value: string;
-} | {
-  type: 'variant';
-  token: string;
-};
-interface CSSDirectiveUtilityRuleDefinition {
-  declarations: CSSDirectiveDeclarations;
-  conditions?: string[];
-  conditionPath?: CSSDirectiveConditionPathEntry[];
-  selector?: string;
-}
-interface CSSDirectiveUtilityPatternDefinition {
-  prefix: string;
-  values: string[];
-  valueMap?: Record<string, string>;
-}
-interface CSSDirectiveUtilityDynamicDefinition {
-  key: string;
-  variableAliasRefs?: string[];
-  kind?: MasterCSSManifestUtilityKind;
-  values?: string[];
-  arbitrary?: boolean;
-}
-interface CSSDirectiveUtilityDefinition {
+interface CSSCustomMediaDefinition {
   name: string;
-  type?: 'static' | 'pattern' | 'dynamic';
-  layer?: CSSDirectiveLayerName;
-  pattern?: CSSDirectiveUtilityPatternDefinition;
-  dynamic?: CSSDirectiveUtilityDynamicDefinition;
-  declarations?: CSSDirectiveDeclarations;
-  conditions?: string[];
-  conditionPath?: CSSDirectiveConditionPathEntry[];
-  rules?: CSSDirectiveUtilityRuleDefinition[];
+  query: string;
+  source?: CSSDirectiveSourceReference;
+}
+/** An `@custom-container` condition as written, before references expand. */
+interface CSSCustomContainerDefinition {
+  name: string;
+  query: string;
+  source?: CSSDirectiveSourceReference;
 }
 interface CSSDirectiveManifestInput {
-  variants?: CSSDirectiveVariantDefinitions;
-  variables?: CSSDirectiveVariableDefinition[];
-  utilities?: CSSDirectiveUtilityDefinition[];
-  rootSize?: number;
-  baseUnit?: number;
-  defaultMode?: CSSDirectiveDefaultMode;
-  scope?: string;
-  important?: boolean;
-  animations?: CSSDirectiveAnimationDefinitions;
-  animationOptions?: CSSDirectiveAnimationOptions;
-  modes?: string[];
-  modeTrigger?: CSSDirectiveModeTrigger;
+  keyframes?: MasterCSSKeyframeDefinition[];
+  keyframeSafelist?: string[];
+  animationVariables?: Record<string, string[]>;
+  theme?: MasterCSSThemeNode[];
+  customMedia?: CSSCustomMediaDefinition[];
+  customContainers?: CSSCustomContainerDefinition[];
+  mixins?: MasterCSSMixinDefinition[];
+  utilities?: MasterCSSUtilityDefinition[];
 }
 interface CSSDirectiveExtractionPolicy {
   include: string[];
   exclude: string[];
   safelist: string[];
+  safelistKeyframes: string[];
   blocklist: (string | RegExp)[];
   preserveNative: boolean;
+  pruneNative: boolean;
 }
 interface CSSDirectiveReference {
   source: string;
   file?: string;
 }
-interface CSSDirectiveStyleComposeDefinition {
-  type: 'compose';
+interface CSSOrderedDeclaration {
+  property: string;
+  value: string;
+  source?: CSSDirectiveSourceReference;
+}
+interface CSSDirectiveStyleNativeDefinition {
+  type: 'native';
   order: number;
-  className: string;
   selector: string;
+  declarations: CSSOrderedDeclaration[];
   source?: CSSDirectiveSourceReference;
-  directiveSource?: CSSDirectiveSourceReference;
   selectorSource?: CSSDirectiveSourceReference;
+  /** The enclosing conditional and layer preludes, outermost first. */
   conditions?: string[];
-  conditionPath?: CSSDirectiveConditionPathEntry[];
-  layer?: CSSDirectiveLayerName;
-  name?: string;
 }
-interface CSSDirectiveStyleNativeDefinition {
-  type: 'native';
+interface CSSDirectiveStyleApplyDefinition {
+  type: 'apply';
   order: number;
   selector: string;
-  declarations: CSSDirectiveDeclarations;
-  source?: CSSDirectiveSourceReference;
+  name: string;
+  arguments: MasterCSSMixinValue[];
+  contents?: MasterCSSMixinNode[];
   selectorSource?: CSSDirectiveSourceReference;
+  source?: CSSDirectiveSourceReference;
+  /** The enclosing conditional and layer preludes, outermost first. */
   conditions?: string[];
-  conditionPath?: CSSDirectiveConditionPathEntry[];
-  layer?: CSSDirectiveLayerName;
-  name?: string;
 }
-type CSSDirectiveStyleDefinition = CSSDirectiveStyleComposeDefinition | CSSDirectiveStyleNativeDefinition;
+type CSSDirectiveStyleDefinition = CSSDirectiveStyleApplyDefinition | CSSDirectiveStyleNativeDefinition;
+/** Generated UTF-16 offset and its original authoring-source anchor. */
+interface CSSOutputMapping {
+  generatedStart: number;
+  generatedEnd?: number;
+  source: CSSDirectiveSourceReference;
+}
+/** Rust output plan; pass it unchanged from parsing to directive lowering. */
+interface CSSNativeOutput {
+  css: string;
+  mappings: CSSOutputMapping[];
+  slots: {
+    start: number;
+    end: number;
+    marker: string;
+    definitions: CSSDirectiveStyleDefinition[];
+  }[];
+}
+interface CSSDefinitionSource {
+  kind: 'utility' | 'mixin';
+  name: string;
+  identity: string;
+  replacedBy?: CSSDirectiveSourceReference;
+  source: CSSDirectiveSourceReference;
+}
+interface CSSDirectiveNotice {
+  code: string;
+  message: string;
+  source?: CSSDirectiveSourceReference | null;
+}
 interface CSSDirectiveResult {
+  notices?: CSSDirectiveNotice[];
+  definitionSources?: CSSDefinitionSource[];
+  nativeOutput?: CSSNativeOutput;
+  outputMappings?: CSSOutputMapping[];
+  /** Serialized source map v3 for the final CSS, when produced by the stylesheet host. */
+  sourceMap?: string;
+  nativeMappings?: CSSOutputMapping[];
+  generatedMappings?: CSSOutputMapping[];
   manifestInput: CSSDirectiveManifestInput;
   extractionPolicy: CSSDirectiveExtractionPolicy;
   classNames: string[];
@@ -146,5 +142,4 @@ interface CSSDirectiveResult {
   references?: CSSDirectiveReference[];
   styleDefinitions?: CSSDirectiveStyleDefinition[];
 }
-//#endregion
-export { CSSDirectiveAnimationDefinitions, CSSDirectiveAnimationOptions, CSSDirectiveConditionPathEntry, CSSDirectiveDeclarations, CSSDirectiveDefaultMode, CSSDirectiveError, CSSDirectiveExtractionPolicy, CSSDirectiveLayerName, CSSDirectiveManifestInput, CSSDirectiveModeTrigger, CSSDirectiveReference, CSSDirectiveRelatedInformation, CSSDirectiveResult, CSSDirectiveSourceLocation, CSSDirectiveSourceRange, CSSDirectiveSourceReference, CSSDirectiveStyleComposeDefinition, CSSDirectiveStyleDefinition, CSSDirectiveStyleNativeDefinition, CSSDirectiveUtilityDefinition, CSSDirectiveUtilityDynamicDefinition, CSSDirectiveUtilityPatternDefinition, CSSDirectiveUtilityRuleDefinition, CSSDirectiveVariableDefinition, CSSDirectiveVariableValue, CSSDirectiveVariantDefinitions, createCSSDirectiveSourceReference };
+export { CSSCustomContainerDefinition, CSSCustomMediaDefinition, CSSDefinitionSource, CSSDirectiveDeclarations, CSSDirectiveError, CSSDirectiveExtractionPolicy, CSSDirectiveManifestInput, CSSDirectiveNotice, CSSDirectiveReference, CSSDirectiveRelatedInformation, CSSDirectiveResult, CSSDirectiveSourceLocation, CSSDirectiveSourceRange, CSSDirectiveSourceReference, CSSDirectiveStyleApplyDefinition, CSSDirectiveStyleDefinition, CSSDirectiveStyleNativeDefinition, CSSDirectiveVariableValue, CSSNativeOutput, CSSOrderedDeclaration, CSSOutputMapping, createCSSDirectiveSourceReference };

package/dist/css-directives.js

@@ -1,4 +1,4 @@
-//#region src/css-directives.ts
+// src/css-directives.ts
 var CSSDirectiveError = class extends Error {
 	code;
 	source;
@@ -33,5 +33,4 @@ function createCSSDirectiveSourceReference(file, range, source) {
 		} } : {}
 	};
 }
-//#endregion
 export { CSSDirectiveError, createCSSDirectiveSourceReference };

package/dist/css-syntax.d.ts

@@ -1,5 +1,4 @@
-import { MasterCSSManifestUtility, MasterCSSManifestUtilityLayerName, MasterCSSManifestVariableNumericValue } from "./manifest.js";
-//#region src/css-syntax.d.ts
+import { MasterCSSManifestUtilityLayerName, MasterCSSManifestVariableNumericValue } from "./manifest.js";
 type ValueComponent = StringValueComponent | NumberValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;
 interface StringValueComponent {
   text?: string;
@@ -39,20 +38,6 @@ interface SeparatorValueComponent {
   type: 'separator';
   value: string;
 }
-interface DefinedUtility {
-  id: string;
-  key?: string;
-  keys: string[];
-  matchers: {
-    key?: RegExp;
-    variable?: RegExp;
-    value?: RegExp;
-    arbitrary?: RegExp;
-  };
-  variables?: Map<string, Variable>;
-  order: number;
-  definition: MasterCSSManifestUtility;
-}
 type ExplicitUtilityLayerName = MasterCSSManifestUtilityLayerName;
 interface MediaFeatureComponent {
   type: string;
@@ -90,5 +75,4 @@ type Variable = VariableCommon & {
   value?: ResolvedVariableValue['value'];
   numeric?: MasterCSSManifestVariableNumericValue;
 };
-//#endregion
-export { DefinedUtility, ExplicitUtilityLayerName, FunctionValueComponent, MediaFeatureComponent, MediaQuery, NumberValueComponent, NumberVariable, ResolvedVariableValue, SeparatorValueComponent, StringValueComponent, StringVariable, ValueComponent, Variable, VariableValueComponent };
+export { ExplicitUtilityLayerName, FunctionValueComponent, MediaFeatureComponent, MediaQuery, NumberValueComponent, NumberVariable, ResolvedVariableValue, SeparatorValueComponent, StringValueComponent, StringVariable, ValueComponent, Variable, VariableValueComponent };

package/dist/diagnostics.d.ts

@@ -0,0 +1,41 @@
+declare const MASTER_CSS_DIAGNOSTIC_VERSION: 2;
+type MasterCSSDiagnosticDomain = 'binding' | 'compiler' | 'engine' | 'integration' | 'language' | 'project' | 'runtime' | 'server' | 'tooling';
+type MasterCSSDiagnosticSeverity = 'error' | 'warning' | 'information';
+interface MasterCSSDiagnosticPosition {
+  line: number;
+  character: number;
+}
+interface MasterCSSDiagnosticRange {
+  start: MasterCSSDiagnosticPosition;
+  end: MasterCSSDiagnosticPosition;
+}
+interface MasterCSSDiagnostic {
+  readonly version: typeof MASTER_CSS_DIAGNOSTIC_VERSION;
+  readonly code: string;
+  readonly domain: MasterCSSDiagnosticDomain;
+  readonly phase?: 'match' | 'css-syntax' | 'css-value' | 'browser-support' | 'compiler';
+  readonly severity: MasterCSSDiagnosticSeverity;
+  readonly message: string;
+  readonly source?: string;
+  readonly range?: MasterCSSDiagnosticRange;
+  readonly notes?: readonly string[];
+  readonly help?: string;
+}
+interface MasterCSSErrorPayload {
+  readonly code: string;
+  readonly domain: MasterCSSDiagnosticDomain;
+  readonly message: string;
+  readonly diagnostics?: readonly MasterCSSDiagnostic[];
+}
+interface MasterCSSErrorOptions extends ErrorOptions {
+  diagnostics?: readonly MasterCSSDiagnostic[];
+}
+declare class MasterCSSError extends Error {
+  readonly code: string;
+  readonly domain: MasterCSSDiagnosticDomain;
+  readonly diagnostics: readonly MasterCSSDiagnostic[];
+  readonly payload: MasterCSSErrorPayload;
+  constructor(payload: MasterCSSErrorPayload, options?: MasterCSSErrorOptions);
+  toJSON(): MasterCSSErrorPayload;
+}
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSDiagnostic, MasterCSSDiagnosticDomain, MasterCSSDiagnosticPosition, MasterCSSDiagnosticRange, MasterCSSDiagnosticSeverity, MasterCSSError, MasterCSSErrorOptions, MasterCSSErrorPayload };

package/dist/diagnostics.js

@@ -0,0 +1,35 @@
+// src/diagnostics.ts
+const MASTER_CSS_DIAGNOSTIC_VERSION = 2;
+function freezeDiagnostic(diagnostic) {
+	return Object.freeze({
+		...diagnostic,
+		...diagnostic.range ? { range: Object.freeze({
+			start: Object.freeze({ ...diagnostic.range.start }),
+			end: Object.freeze({ ...diagnostic.range.end })
+		}) } : {},
+		...diagnostic.notes ? { notes: Object.freeze([...diagnostic.notes]) } : {}
+	});
+}
+var MasterCSSError = class extends Error {
+	code;
+	domain;
+	diagnostics;
+	payload;
+	constructor(payload, options = {}) {
+		super(payload.message, options);
+		this.name = "MasterCSSError";
+		this.code = payload.code;
+		this.domain = payload.domain;
+		this.diagnostics = Object.freeze((options.diagnostics ?? payload.diagnostics ?? []).map(freezeDiagnostic));
+		this.payload = Object.freeze({
+			code: this.code,
+			domain: this.domain,
+			message: this.message,
+			...this.diagnostics.length ? { diagnostics: this.diagnostics } : {}
+		});
+	}
+	toJSON() {
+		return this.payload;
+	}
+};
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError };

package/dist/emitted-globals.d.ts

@@ -0,0 +1,7 @@
+/** Resource counts already emitted outside the current Rust engine session. */
+interface MasterCSSEmittedGlobals {
+  variables?: Record<string, number>;
+  /** Counts keyed by definition ID, rather than animation name. */
+  keyframes?: Record<string, number>;
+}
+export { MasterCSSEmittedGlobals };

package/dist/emitted-globals.js

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

package/dist/hydration-manifest.d.ts

@@ -1,35 +1,66 @@
 import { MasterCSSManifestUtilityLayerName } from "./manifest.js";
+import { MasterCSSEmittedGlobals } from "./emitted-globals.js";
 import { UtilityType } from "./utility-type.js";
-//#region src/hydration-manifest.d.ts
 declare const MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID = "master-css-hydration-manifest";
 declare const MASTER_CSS_HYDRATION_MANIFEST_ATTR = "data-master-css-hydration-manifest";
 declare const MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE = "/_master-css/hydration/";
 declare const MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME = "master-css-hydration";
-interface MasterCSSRulePriorityIR {
-  features?: [string, number, number][];
-  selector: number;
+interface MasterCSSConditionRange {
+  readonly domain: string;
+  readonly feature: string;
+  readonly unit: string;
+  readonly lower: {
+    readonly value: number;
+    readonly inclusive: boolean;
+  } | null;
+  readonly upper: {
+    readonly value: number;
+    readonly inclusive: boolean;
+  } | null;
 }
-interface MasterCSSGeneratedRuleNodeIR {
-  text: string;
+interface MasterCSSRulePriority {
+  /** Token values sort before raw values within the same cascade tier. */
+  readonly valuePriority?: -1 | 0;
+  /** Parsed declaration identity, independent of public aliases. */
+  readonly sortKey?: string;
+  readonly features: readonly MasterCSSConditionRange[];
+  readonly conditions?: readonly string[];
+  readonly selector: number;
 }
-interface MasterCSSGeneratedRuleIR {
-  className: string;
-  key: string;
-  layer: MasterCSSManifestUtilityLayerName;
-  type: UtilityType;
-  sortTier: number;
-  priority: MasterCSSRulePriorityIR;
-  text: string;
-  nodes?: MasterCSSGeneratedRuleNodeIR[];
-  selectorText?: string;
-  variableNames?: string[];
-  animationNames?: string[];
+interface MasterCSSHydrationRuleNode {
+  readonly text: string;
+}
+interface MasterCSSHydrationRule {
+  readonly className: string;
+  readonly key: string;
+  readonly layer: MasterCSSManifestUtilityLayerName;
+  readonly type: UtilityType;
+  readonly sortTier: number;
+  readonly priority: MasterCSSRulePriority;
+  readonly text: string;
+  readonly nodes?: readonly MasterCSSHydrationRuleNode[];
+  readonly selectorText?: string;
+  readonly variableNames?: readonly string[];
+  readonly keyframeNames?: readonly string[];
+  readonly retainAllKeyframes?: boolean;
 }
 interface MasterCSSHydrationManifest {
-  version: 1;
-  rules: MasterCSSGeneratedRuleIR[];
+  readonly version: 5;
+  readonly languageVersion: 18;
+  /**
+   * Every rendered class: those with rules in rule order, then those without, such as
+   * authored component classes, then classes manifest selectors reference without rules
+   * of their own, such as mode classes. The runtime treats them as covered by the
+   * pre-rendered CSS and replays them to verify it when the engine starts.
+   */
+  readonly classNames: readonly string[];
+  readonly resourceOrder: {
+    readonly variables: readonly string[];
+    readonly keyframes: readonly string[];
+  };
+  /** Resource counts the server render treated as emitted by the page's stylesheets. */
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
 }
 declare function serializeMasterCSSHydrationManifest(hydrationManifest: MasterCSSHydrationManifest): string;
 declare function createMasterCSSHydrationManifestScript(hydrationManifest: MasterCSSHydrationManifest): string;
-//#endregion
-export { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, MasterCSSGeneratedRuleIR, MasterCSSGeneratedRuleNodeIR, MasterCSSHydrationManifest, MasterCSSRulePriorityIR, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest };
+export { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, MasterCSSConditionRange, MasterCSSHydrationManifest, MasterCSSHydrationRule, MasterCSSHydrationRuleNode, MasterCSSRulePriority, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest };

package/dist/hydration-manifest.js

@@ -1,4 +1,4 @@
-//#region src/hydration-manifest.ts
+// src/hydration-manifest.ts
 const MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID = "master-css-hydration-manifest";
 const MASTER_CSS_HYDRATION_MANIFEST_ATTR = "data-master-css-hydration-manifest";
 const MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE = "/_master-css/hydration/";
@@ -9,5 +9,4 @@ function serializeMasterCSSHydrationManifest(hydrationManifest) {
 function createMasterCSSHydrationManifestScript(hydrationManifest) {
 	return `<script type="application/json" id="${MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID}">${serializeMasterCSSHydrationManifest(hydrationManifest)}<\/script>`;
 }
-//#endregion
 export { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest };

package/dist/index.d.ts

@@ -1,9 +1,4 @@
-export * from "./manifest.js";
-export * from "./manifest-json.js";
-export * from "./hydration-manifest.js";
-export * from "./css-directives.js";
-export * from "./css-syntax.js";
-export * from "./utility-type.js";
-export * from "./runtime-style.js";
-export * from "./native-css-shorthand.js";
-export * from "./css-common.js";
+import { MasterCSSManifest, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, normalizeMasterCSSManifest, serializeMasterCSSManifest } from "./manifest.js";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSDiagnostic, MasterCSSDiagnosticDomain, MasterCSSDiagnosticPosition, MasterCSSDiagnosticRange, MasterCSSDiagnosticSeverity, MasterCSSError, MasterCSSErrorOptions, MasterCSSErrorPayload } from "./diagnostics.js";
+import { MASTER_CSS_RENDERING_MODES, MasterCSSIntegrationOptions, MasterCSSIntegrationRuntimeOptions, MasterCSSRenderingMode, isMasterCSSRenderingMode } from "./integration.js";
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MASTER_CSS_RENDERING_MODES, type MasterCSSDiagnostic, type MasterCSSDiagnosticDomain, type MasterCSSDiagnosticPosition, type MasterCSSDiagnosticRange, type MasterCSSDiagnosticSeverity, MasterCSSError, type MasterCSSErrorOptions, type MasterCSSErrorPayload, type MasterCSSIntegrationOptions, type MasterCSSIntegrationRuntimeOptions, type MasterCSSManifest, type MasterCSSRenderingMode, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, isMasterCSSRenderingMode, normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/index.js

@@ -1,8 +1,5 @@
-import { CSSDirectiveError, createCSSDirectiveSourceReference } from "./css-directives.js";
-import { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest } from "./hydration-manifest.js";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError } from "./diagnostics.js";
+import { normalizeMasterCSSManifest, serializeMasterCSSManifest } from "./manifest-json.js";
 import { flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables } from "./manifest.js";
-import { normalizeMasterCSSManifestForJSON, stringifyMasterCSSManifestJSON } from "./manifest-json.js";
-import { UtilityType } from "./utility-type.js";
-import { MASTER_CSS_RUNTIME_STYLE_ID } from "./runtime-style.js";
-import { isNativeCSSShorthandProperty } from "./native-css-shorthand.js";
-export { CSSDirectiveError, MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, MASTER_CSS_RUNTIME_STYLE_ID, UtilityType, createCSSDirectiveSourceReference, createMasterCSSHydrationManifestScript, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, isNativeCSSShorthandProperty, normalizeMasterCSSManifestForJSON, serializeMasterCSSHydrationManifest, stringifyMasterCSSManifestJSON };
+import { MASTER_CSS_RENDERING_MODES, isMasterCSSRenderingMode } from "./integration.js";
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MASTER_CSS_RENDERING_MODES, MasterCSSError, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, isMasterCSSRenderingMode, normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/integration.d.ts

@@ -0,0 +1,14 @@
+declare const MASTER_CSS_RENDERING_MODES: readonly ['runtime', 'static', 'prerender', 'progressive'];
+type MasterCSSRenderingMode = typeof MASTER_CSS_RENDERING_MODES[number];
+interface MasterCSSIntegrationRuntimeOptions {
+  enabled?: boolean;
+  avoidFOUC?: boolean;
+}
+interface MasterCSSIntegrationOptions {
+  enabled?: boolean;
+  mode?: MasterCSSRenderingMode;
+  pruneNativeCSS?: boolean;
+  runtime?: boolean | MasterCSSIntegrationRuntimeOptions;
+}
+declare function isMasterCSSRenderingMode(value: unknown): value is MasterCSSRenderingMode;
+export { MASTER_CSS_RENDERING_MODES, MasterCSSIntegrationOptions, MasterCSSIntegrationRuntimeOptions, MasterCSSRenderingMode, isMasterCSSRenderingMode };

package/dist/integration.js

@@ -0,0 +1,11 @@
+// src/integration.ts
+const MASTER_CSS_RENDERING_MODES = [
+	"runtime",
+	"static",
+	"prerender",
+	"progressive"
+];
+function isMasterCSSRenderingMode(value) {
+	return MASTER_CSS_RENDERING_MODES.includes(value);
+}
+export { MASTER_CSS_RENDERING_MODES, isMasterCSSRenderingMode };

package/dist/keyframes.d.ts

@@ -0,0 +1,24 @@
+import { CSSDirectiveSourceReference } from "./css-directives.js";
+/**
+ * A native `@keyframes` rule of Master-compiled CSS. A `native` definition is
+ * delivered in place by its stylesheet or the host, and engines never emit it.
+ * Every other definition comes from a `@prune native` stylesheet and is emitted on
+ * demand, like a token, by the engine whose output references it.
+ */
+interface MasterCSSKeyframeDefinition {
+  id: string;
+  name: string;
+  text: string;
+  /** The enclosing conditional and layer rules an emitted definition is wrapped in. */
+  containers?: MasterCSSKeyframeContainer[];
+  native?: boolean;
+  /** `@safelist keyframes` emits the definition without a reference. */
+  safelisted?: boolean;
+  dependencies?: string[];
+  source?: CSSDirectiveSourceReference;
+}
+interface MasterCSSKeyframeContainer {
+  id: string;
+  prelude: string;
+}
+export { MasterCSSKeyframeContainer, MasterCSSKeyframeDefinition };

package/dist/keyframes.js

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

package/dist/manifest-json.d.ts

@@ -1,6 +1,4 @@
 import { MasterCSSManifest } from "./manifest.js";
-//#region src/manifest-json.d.ts
-declare function normalizeMasterCSSManifestForJSON(manifest: MasterCSSManifest): MasterCSSManifest;
-declare function stringifyMasterCSSManifestJSON(manifest: MasterCSSManifest): string;
-//#endregion
-export { normalizeMasterCSSManifestForJSON, stringifyMasterCSSManifestJSON };
+declare function normalizeMasterCSSManifest(manifest: MasterCSSManifest): MasterCSSManifest;
+declare function serializeMasterCSSManifest(manifest: MasterCSSManifest): string;
+export { normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/manifest-json.js

@@ -1,15 +1,7 @@
-//#region src/manifest-json.ts
+// src/manifest-json.ts
 function getVariableName(namespace, variable) {
 	return variable.name || (namespace ? `${namespace}${variable.key ? "-" + variable.key : ""}` : variable.key);
 }
-function normalizeTemplateDeclarations(declarations) {
-	const normalized = {};
-	for (const propertyName in declarations) {
-		const value = declarations[propertyName];
-		normalized[propertyName] = Array.isArray(value) ? value.map((part) => part === void 0 ? null : part) : value === void 0 ? null : value;
-	}
-	return normalized;
-}
 function normalizeVariablesForJSON(variables) {
 	if (!variables) return;
 	const normalized = {};
@@ -25,29 +17,13 @@ function normalizeVariablesForJSON(variables) {
 	}
 	return Object.keys(normalized).length ? normalized : void 0;
 }
-function normalizeUtilityForJSON(utility) {
-	const normalized = { ...utility };
-	if (normalized.name === normalized.id) delete normalized.name;
-	if (normalized.layer === "utilities") delete normalized.layer;
-	delete normalized.order;
-	if (normalized.emit.type !== "template") return normalized;
-	return {
-		...normalized,
-		emit: {
-			...normalized.emit,
-			declarations: normalizeTemplateDeclarations(normalized.emit.declarations)
-		}
-	};
-}
-function normalizeMasterCSSManifestForJSON(manifest) {
+function normalizeMasterCSSManifest(manifest) {
 	return {
 		...manifest,
-		...manifest.variables ? { variables: normalizeVariablesForJSON(manifest.variables) } : {},
-		...manifest.utilities?.length ? { utilities: manifest.utilities.map(normalizeUtilityForJSON) } : {}
+		...manifest.variables ? { variables: normalizeVariablesForJSON(manifest.variables) } : {}
 	};
 }
-function stringifyMasterCSSManifestJSON(manifest) {
-	return JSON.stringify(normalizeMasterCSSManifestForJSON(manifest));
+function serializeMasterCSSManifest(manifest) {
+	return JSON.stringify(normalizeMasterCSSManifest(manifest));
 }
-//#endregion
-export { normalizeMasterCSSManifestForJSON, stringifyMasterCSSManifestJSON };
+export { normalizeMasterCSSManifest, serializeMasterCSSManifest };