@tamagui/style-grammar 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/types/transition.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,YAAY,qBAAqB,WAAW;AAE5C,iBAAiB,oBAAoB;CACnC,MAAM;CACN;CACA;;AAGF,iBAAiB,uBAAuB;CACtC,MAAM;CACN;CACA,SAAS,SAAS;;AAGpB,YAAY,mBAAmB,sBAAsB;AAErD,iBAAiB,gBAAgB;CAC/B;CACA,QAAQ;CACR;CACA,UAAU;;AAGZ,iBAAiB,aAAa;CAC5B,MAAM;CACN,kBAAkB;CAClB,QAAQ;CACR,OAAO;CACP,SAAS,SAAS;;AAGpB,iBAAiB,mBAAmB;CAClC,MAAM;CACN,OAAO,YAAY,YAAY,WAAW,iBAAiB;;AAG7D,YAAY,mBAAmB,eAAe;AAE9C,iBAAiB,qBAAqB;CACpC,MACI,0BACA,6BACA,mCACA,gCACA;CACJ;CACA;CACA;;AAGF,YAAY,wBACR;CACE,IAAI;CACJ,OAAO;IAET;CACE,IAAI;CACJ,sBAAsB;;AAG5B,iBAAiB,oBAAoB;CACnC;CACA;CACA;CACA;CACA;;;;;;;;AAmPF,OAAO,iBAAS,gBACd,eACA,cAAa,sBACZ;;;;;AA2GH,OAAO,iBAAS,yBACd,OAAO,sBACN;AAyGH,OAAO,iBAAS,oBAAoB,OAAO",
+  "names": [],
+  "sources": [
+    "src/transition.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "export type TransitionBehavior = 'normal' | 'allow-discrete'\n\nexport interface CSSTransitionTiming {\n  type: 'css'\n  duration: string\n  timingFunction: string\n}\n\nexport interface PresetTransitionTiming {\n  type: 'preset'\n  name: string\n  config?: Readonly<Record<string, unknown>>\n}\n\nexport type TransitionTiming = CSSTransitionTiming | PresetTransitionTiming\n\nexport interface TransitionEntry {\n  property: string\n  timing: TransitionTiming\n  delay: string\n  behavior: TransitionBehavior\n}\n\nexport interface TransitionIR {\n  kind: 'transition'\n  entries: readonly TransitionEntry[]\n  enter?: TransitionEntry\n  exit?: TransitionEntry\n  config?: Readonly<Record<string, unknown>>\n}\n\nexport interface TransitionGlobalIR {\n  kind: 'global'\n  value: 'inherit' | 'initial' | 'revert' | 'revert-layer' | 'unset'\n}\n\nexport type ParsedTransition = TransitionIR | TransitionGlobalIR\n\nexport interface TransitionDiagnostic {\n  code:\n    | 'transition-empty-item'\n    | 'transition-invalid-token'\n    | 'transition-duplicate-component'\n    | 'transition-invalid-duration'\n    | 'transition-invalid-list'\n  message: string\n  item?: string\n  token?: string\n}\n\nexport type TransitionParseResult =\n  | {\n      ok: true\n      value: ParsedTransition\n    }\n  | {\n      ok: false\n      diagnostics: readonly TransitionDiagnostic[]\n    }\n\nexport interface TransitionLonghands {\n  transitionProperty?: string\n  transitionDuration?: string\n  transitionTimingFunction?: string\n  transitionDelay?: string\n  transitionBehavior?: string\n}\n\nconst globalValues = new Set(['inherit', 'initial', 'revert', 'revert-layer', 'unset'])\nconst timingKeywords = new Set([\n  'ease',\n  'linear',\n  'ease-in',\n  'ease-out',\n  'ease-in-out',\n  'step-start',\n  'step-end',\n])\nconst behaviorValues = new Set(['normal', 'allow-discrete'])\nconst reservedPresetNames = new Set([\n  ...globalValues,\n  ...timingKeywords,\n  ...behaviorValues,\n  'all',\n  'none',\n])\nconst noPresetNames: ReadonlySet<string> = new Set()\nconst identifierPattern = /^-?(?:[_a-zA-Z]|[^\\0-\\x7f])(?:[-_a-zA-Z0-9]|[^\\0-\\x7f])*$/\nconst timePattern = /^([+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+))(ms|s)$/\n\nfunction splitTopLevel(input: string, separator: ',' | ' '): string[] | null {\n  const values: string[] = []\n  let start = 0\n  let depth = 0\n  let quote = ''\n\n  for (let index = 0; index < input.length; index++) {\n    const character = input[index]\n    if (quote) {\n      if (character === '\\\\') index++\n      else if (character === quote) quote = ''\n      continue\n    }\n    if (character === '\"' || character === \"'\") {\n      quote = character\n      continue\n    }\n    if (character === '(') {\n      depth++\n      continue\n    }\n    if (character === ')') {\n      depth--\n      if (depth < 0) return null\n      continue\n    }\n    if (depth !== 0) continue\n\n    const matches = separator === ',' ? character === ',' : /\\s/.test(character)\n    if (!matches) continue\n\n    const value = input.slice(start, index).trim()\n    if (value) values.push(value)\n    else if (separator === ',') values.push('')\n    start = index + 1\n    if (separator === ' ') {\n      while (start < input.length && /\\s/.test(input[start])) start++\n      index = start - 1\n    }\n  }\n\n  if (depth !== 0 || quote) return null\n  values.push(input.slice(start).trim())\n  return values\n}\n\nfunction isTime(value: string): boolean {\n  return timePattern.test(value)\n}\n\nfunction isTimingFunction(value: string): boolean {\n  if (timingKeywords.has(value)) return true\n  if (/^cubic-bezier\\(\\s*[^)]+\\s*\\)$/.test(value)) {\n    const values = value.slice(value.indexOf('(') + 1, -1).split(',')\n    if (values.length !== 4) return false\n    const numbers: number[] = []\n    for (let index = 0; index < values.length; index++) {\n      const number = Number(values[index].trim())\n      if (!Number.isFinite(number)) return false\n      numbers.push(number)\n    }\n    return numbers[0] >= 0 && numbers[0] <= 1 && numbers[2] >= 0 && numbers[2] <= 1\n  }\n  if (/^steps\\(\\s*[^)]+\\s*\\)$/.test(value)) {\n    const parts = value.slice(value.indexOf('(') + 1, -1).split(',')\n    if (parts.length > 2) return false\n    const count = Number(parts[0].trim())\n    if (!Number.isInteger(count) || count <= 0) return false\n    const position = parts[1]?.trim()\n    if (\n      position !== undefined &&\n      !/^(jump-start|jump-end|jump-none|jump-both|start|end)$/.test(position)\n    ) {\n      return false\n    }\n    return position !== 'jump-none' || count > 1\n  }\n  if (/^linear\\(\\s*[^)]+\\s*\\)$/.test(value)) return true\n  return false\n}\n\nfunction parseSingleTransition(item: string): TransitionEntry | TransitionDiagnostic {\n  const tokens = splitTopLevel(item, ' ')\n  if (tokens === null || tokens.length === 0) {\n    return {\n      code: 'transition-invalid-token',\n      item,\n      message: `\"${item}\" is not a balanced CSS transition`,\n    }\n  }\n  for (let index = 0; index < tokens.length; index++) {\n    if (!tokens[index]) {\n      return {\n        code: 'transition-invalid-token',\n        item,\n        message: `\"${item}\" is not a balanced CSS transition`,\n      }\n    }\n  }\n\n  let property: string | undefined\n  let duration: string | undefined\n  let delay: string | undefined\n  let timingFunction: string | undefined\n  let behavior: TransitionBehavior | undefined\n\n  for (const token of tokens) {\n    if (globalValues.has(token)) {\n      return {\n        code: 'transition-invalid-list',\n        item,\n        token,\n        message: `CSS-wide value \"${token}\" must be the whole transition`,\n      }\n    }\n    if (isTime(token)) {\n      if (duration === undefined) {\n        if (Number(token.match(timePattern)?.[1]) < 0) {\n          return {\n            code: 'transition-invalid-duration',\n            item,\n            token,\n            message: `transition duration \"${token}\" cannot be negative`,\n          }\n        }\n        duration = token\n      } else if (delay === undefined) {\n        delay = token\n      } else {\n        return {\n          code: 'transition-duplicate-component',\n          item,\n          token,\n          message: `\"${item}\" has more than two time values`,\n        }\n      }\n      continue\n    }\n\n    if (isTimingFunction(token)) {\n      if (timingFunction !== undefined) {\n        return {\n          code: 'transition-duplicate-component',\n          item,\n          token,\n          message: `\"${item}\" has more than one timing function`,\n        }\n      }\n      timingFunction = token\n      continue\n    }\n\n    if (behaviorValues.has(token)) {\n      if (behavior !== undefined) {\n        return {\n          code: 'transition-duplicate-component',\n          item,\n          token,\n          message: `\"${item}\" has more than one transition behavior`,\n        }\n      }\n      behavior = token as TransitionBehavior\n      continue\n    }\n\n    if (identifierPattern.test(token) || /^--[-_a-zA-Z0-9]+$/.test(token)) {\n      if (property !== undefined) {\n        return {\n          code: 'transition-duplicate-component',\n          item,\n          token,\n          message: `\"${item}\" has more than one transition property`,\n        }\n      }\n      property = token\n      continue\n    }\n\n    return {\n      code: 'transition-invalid-token',\n      item,\n      token,\n      message: `\"${token}\" is not valid in a CSS transition`,\n    }\n  }\n\n  if (\n    property === 'none' &&\n    (duration !== undefined ||\n      delay !== undefined ||\n      timingFunction !== undefined ||\n      behavior !== undefined)\n  ) {\n    return {\n      code: 'transition-invalid-list',\n      item,\n      message: '\"none\" cannot be combined with other transition components',\n    }\n  }\n\n  return {\n    property: property ?? 'all',\n    timing: {\n      type: 'css',\n      duration: duration ?? '0s',\n      timingFunction: timingFunction ?? 'ease',\n    },\n    delay: delay ?? '0s',\n    behavior: behavior ?? 'normal',\n  }\n}\n\n/**\n * parses CSS transition shorthand or an exact configured preset name.\n *\n * duration-shaped values and css-reserved names always use css semantics.\n * preset matching is exact and never infers aliases.\n */\nexport function parseTransition(\n  input: string,\n  presetNames: ReadonlySet<string> = noPresetNames\n): TransitionParseResult {\n  const value = input.trim()\n  if (!value) {\n    return {\n      ok: false,\n      diagnostics: [\n        {\n          code: 'transition-empty-item',\n          message: 'transition cannot be empty',\n        },\n      ],\n    }\n  }\n\n  if (globalValues.has(value)) {\n    return {\n      ok: true,\n      value: {\n        kind: 'global',\n        value: value as TransitionGlobalIR['value'],\n      },\n    }\n  }\n\n  if (\n    identifierPattern.test(value) &&\n    !reservedPresetNames.has(value) &&\n    presetNames.has(value)\n  ) {\n    return {\n      ok: true,\n      value: {\n        kind: 'transition',\n        entries: [\n          {\n            property: 'all',\n            timing: { type: 'preset', name: value },\n            delay: '0s',\n            behavior: 'normal',\n          },\n        ],\n      },\n    }\n  }\n\n  const items = splitTopLevel(value, ',')\n  if (items === null) {\n    return {\n      ok: false,\n      diagnostics: [\n        {\n          code: 'transition-invalid-token',\n          item: value,\n          message: `\"${value}\" is not a balanced CSS transition`,\n        },\n      ],\n    }\n  }\n\n  const entries: TransitionEntry[] = []\n  const diagnostics: TransitionDiagnostic[] = []\n  for (const item of items) {\n    if (!item) {\n      diagnostics.push({\n        code: 'transition-empty-item',\n        message: 'transition lists cannot contain an empty item',\n      })\n      continue\n    }\n    const parsed = parseSingleTransition(item)\n    if ('code' in parsed) diagnostics.push(parsed)\n    else entries.push(parsed)\n  }\n\n  let hasNone = false\n  for (let index = 0; index < entries.length; index++) {\n    if (entries[index].property === 'none') {\n      hasNone = true\n      break\n    }\n  }\n  if (hasNone && entries.length > 1) {\n    diagnostics.push({\n      code: 'transition-invalid-list',\n      message: '\"none\" cannot be combined with other transition items',\n    })\n  }\n\n  return diagnostics.length\n    ? { ok: false, diagnostics }\n    : { ok: true, value: { kind: 'transition', entries } }\n}\n\nfunction parseLonghandList(value: string | undefined, fallback: string): string[] | null {\n  if (value === undefined) return [fallback]\n  const values = splitTopLevel(value, ',')\n  if (!values?.length) return null\n  for (let index = 0; index < values.length; index++) {\n    if (!values[index]) return null\n  }\n  return values\n}\n\n/**\n * lowers the five CSS transition longhands into the same IR as the shorthand.\n * css list repetition is based on transition-property, as in the browser.\n */\nexport function parseTransitionLonghands(\n  input: TransitionLonghands\n): TransitionParseResult {\n  const properties = parseLonghandList(input.transitionProperty, 'all')\n  const durations = parseLonghandList(input.transitionDuration, '0s')\n  const timings = parseLonghandList(input.transitionTimingFunction, 'ease')\n  const delays = parseLonghandList(input.transitionDelay, '0s')\n  const behaviors = parseLonghandList(input.transitionBehavior, 'normal')\n\n  if (!properties || !durations || !timings || !delays || !behaviors) {\n    return {\n      ok: false,\n      diagnostics: [\n        {\n          code: 'transition-invalid-list',\n          message: 'transition longhands must be non-empty comma-separated lists',\n        },\n      ],\n    }\n  }\n\n  const entries: TransitionEntry[] = []\n  const diagnostics: TransitionDiagnostic[] = []\n  for (let index = 0; index < properties.length; index++) {\n    const property = properties[index]\n    const duration = durations[index % durations.length]\n    const timingFunction = timings[index % timings.length]\n    const delay = delays[index % delays.length]\n    const behavior = behaviors[index % behaviors.length]\n\n    if (\n      globalValues.has(property) ||\n      globalValues.has(duration) ||\n      globalValues.has(timingFunction) ||\n      globalValues.has(delay) ||\n      globalValues.has(behavior)\n    ) {\n      diagnostics.push({\n        code: 'transition-invalid-list',\n        message:\n          'CSS-wide values cannot be mixed into transition longhand lists; use the transition shorthand global value',\n      })\n      break\n    }\n    if (!(identifierPattern.test(property) || /^--[-_a-zA-Z0-9]+$/.test(property))) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: property,\n        message: `\"${property}\" is not a transition property`,\n      })\n    }\n    if (!isTime(duration) || Number(duration.match(timePattern)?.[1]) < 0) {\n      diagnostics.push({\n        code: 'transition-invalid-duration',\n        token: duration,\n        message: `\"${duration}\" is not a non-negative transition duration`,\n      })\n    }\n    if (!isTimingFunction(timingFunction)) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: timingFunction,\n        message: `\"${timingFunction}\" is not a transition timing function`,\n      })\n    }\n    if (!isTime(delay)) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: delay,\n        message: `\"${delay}\" is not a transition delay`,\n      })\n    }\n    if (!behaviorValues.has(behavior)) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: behavior,\n        message: `\"${behavior}\" is not a transition behavior`,\n      })\n    }\n\n    entries.push({\n      property,\n      timing: { type: 'css', duration, timingFunction },\n      delay,\n      behavior: behavior as TransitionBehavior,\n    })\n  }\n\n  let hasNone = false\n  for (let index = 0; index < properties.length; index++) {\n    if (properties[index] === 'none') {\n      hasNone = true\n      break\n    }\n  }\n  if (hasNone && properties.length > 1) {\n    diagnostics.push({\n      code: 'transition-invalid-list',\n      message: '\"none\" cannot be combined with other transition properties',\n    })\n  }\n\n  return diagnostics.length\n    ? { ok: false, diagnostics }\n    : { ok: true, value: { kind: 'transition', entries } }\n}\n\nexport function serializeTransition(value: ParsedTransition): string | null {\n  if (value.kind === 'global') return value.value\n  if (value.enter || value.exit || value.config) return null\n  for (let index = 0; index < value.entries.length; index++) {\n    if (value.entries[index].timing.type === 'preset') return null\n  }\n\n  let serialized = ''\n  for (let index = 0; index < value.entries.length; index++) {\n    const entry = value.entries[index]\n    if (index) serialized += ', '\n    if (entry.timing.type !== 'css') return null\n    if (entry.property === 'none') {\n      if (\n        entry.timing.duration !== '0s' ||\n        entry.timing.timingFunction !== 'ease' ||\n        entry.delay !== '0s' ||\n        entry.behavior !== 'normal'\n      ) {\n        return null\n      }\n      serialized += 'none'\n      continue\n    }\n    serialized += `${entry.property} ${entry.timing.duration} ${entry.timing.timingFunction} ${entry.delay} ${entry.behavior}`\n  }\n  return serialized\n}\n"
+  ]
+}

package/types/transitionAlign.d.ts

@@ -0,0 +1,15 @@
+import { type TransitionParseResult } from "./transition";
+export type TransitionLonghandName = "transitionProperty" | "transitionDuration" | "transitionTimingFunction" | "transitionDelay" | "transitionBehavior";
+export interface TransitionContribution {
+	/** the authored prop, in authored order */
+	prop: "transition" | TransitionLonghandName;
+	value: string;
+}
+/**
+* Merges any mix of `transition` shorthand and longhand contributions, in
+* authored order, into one TransitionIR. Last-wins per longhand; the
+* shorthand resets all five.
+*/
+export declare function alignTransitionContributions(contributions: readonly TransitionContribution[], presetNames?: ReadonlySet<string>): TransitionParseResult;
+
+//# sourceMappingURL=transitionAlign.d.ts.map

package/types/transitionAlign.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AA0BA,cAMO,6BACA;AAEP,YAAY,yBACR,uBACA,uBACA,6BACA,oBACA;AAEJ,iBAAiB,uBAAuB;;CAEtC,MAAM,eAAe;CACrB;;;;;;;AAwBF,OAAO,iBAAS,6BACd,wBAAwB,0BACxB,cAAc,sBACb",
+  "names": [],
+  "sources": [
+    "src/transitionAlign.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// Phase 6 item 4: align transition shorthand and longhand behavior.\n//\n// Ruling (2026-07-31, design record \"Web-aligned transitions\"): transitions\n// follow the border-family precedent — last-wins per longhand in authored\n// order, the shorthand expands-and-resets — because the five transition\n// longhands are real independent CSS longhands whose composition CSS fully\n// defines. The merge SUBSTRATE is the five longhand LISTS, not the zipped\n// entries: `transition=\"opacity 200ms\"` followed by `transitionDelay=\"50ms\"`\n// must yield opacity/200ms/50ms, which only works when delay replaces the\n// delay list and the zip (property list drives, shorter lists cycle) happens\n// at the end. Zipping and validation have one owner: final assembly goes\n// through parseTransitionLonghands.\n//\n// The one preset exception, where the transform no-invented-composition rule\n// applies: a preset occupies the fused duration+timingFunction pair and is\n// not decomposable into CSS components, so a duration or timing-function\n// longhand AFTER a preset shorthand is a diagnostic naming the fix.\n// property/delay/behavior compose freely around a preset. A longhand after a\n// global-value shorthand (`transition=\"inherit\"`) is a diagnostic for the\n// same reason: the global is whole-value and per-longhand override of it is\n// not representable without pretending to decompose it.\n//\n// Conditional transition clauses (`transition=\"200ms hover:400ms\"`) are\n// EXPLICITLY DEFERRED, not unconsidered: the record does not promise them and\n// they would pull the program engine into the transition IR.\n\nimport {\n  parseTransition,\n  parseTransitionLonghands,\n  type PresetTransitionTiming,\n  type TransitionEntry,\n  type TransitionLonghands,\n  type TransitionParseResult,\n} from './transition'\n\nexport type TransitionLonghandName =\n  | 'transitionProperty'\n  | 'transitionDuration'\n  | 'transitionTimingFunction'\n  | 'transitionDelay'\n  | 'transitionBehavior'\n\nexport interface TransitionContribution {\n  /** the authored prop, in authored order */\n  prop: 'transition' | TransitionLonghandName\n  value: string\n}\n\ninterface MergeState {\n  global: string | null\n  preset: PresetTransitionTiming | null\n  /** each slot holds the LAST contribution's list text, or undefined = CSS default */\n  lists: Partial<Record<TransitionLonghandName, string>>\n}\n\nconst timingLonghands: ReadonlySet<TransitionLonghandName> = new Set([\n  'transitionDuration',\n  'transitionTimingFunction',\n])\n\nfunction listText(values: readonly string[]): string {\n  return values.join(', ')\n}\n\n/**\n * Merges any mix of `transition` shorthand and longhand contributions, in\n * authored order, into one TransitionIR. Last-wins per longhand; the\n * shorthand resets all five.\n */\nexport function alignTransitionContributions(\n  contributions: readonly TransitionContribution[],\n  presetNames?: ReadonlySet<string>\n): TransitionParseResult {\n  const state: MergeState = { global: null, preset: null, lists: {} }\n\n  for (const contribution of contributions) {\n    if (contribution.prop === 'transition') {\n      const parsed = parseTransition(contribution.value, presetNames)\n      if (!parsed.ok) return parsed\n\n      // a shorthand resets everything that came before it\n      state.global = null\n      state.preset = null\n      state.lists = {}\n\n      if (parsed.value.kind === 'global') {\n        state.global = parsed.value.value\n        continue\n      }\n      const entries = parsed.value.entries\n      const presetEntry = entries.find((entry) => entry.timing.type === 'preset')\n      if (presetEntry) {\n        state.preset = presetEntry.timing as PresetTransitionTiming\n        state.lists.transitionProperty = listText(entries.map((entry) => entry.property))\n        state.lists.transitionDelay = listText(entries.map((entry) => entry.delay))\n        state.lists.transitionBehavior = listText(entries.map((entry) => entry.behavior))\n        continue\n      }\n      state.lists.transitionProperty = listText(entries.map((entry) => entry.property))\n      state.lists.transitionDuration = listText(\n        entries.map((entry) => (entry.timing as { duration: string }).duration)\n      )\n      state.lists.transitionTimingFunction = listText(\n        entries.map(\n          (entry) => (entry.timing as { timingFunction: string }).timingFunction\n        )\n      )\n      state.lists.transitionDelay = listText(entries.map((entry) => entry.delay))\n      state.lists.transitionBehavior = listText(entries.map((entry) => entry.behavior))\n      continue\n    }\n\n    if (state.global) {\n      return {\n        ok: false,\n        diagnostics: [\n          {\n            code: 'transition-invalid-list',\n            token: contribution.prop,\n            message: `\"${contribution.prop}\" cannot override the CSS-wide transition \"${state.global}\" per longhand; restate the whole transition`,\n          },\n        ],\n      }\n    }\n    if (state.preset && timingLonghands.has(contribution.prop)) {\n      return {\n        ok: false,\n        diagnostics: [\n          {\n            code: 'transition-invalid-list',\n            token: contribution.prop,\n            message: `\"${contribution.prop}\" cannot partially override the \"${state.preset.name}\" preset — a preset's timing is not decomposable into CSS components; restate \\`transition\\` with CSS timing or change the preset`,\n          },\n        ],\n      }\n    }\n    state.lists[contribution.prop] = contribution.value\n  }\n\n  if (state.global) {\n    return {\n      ok: true,\n      value: { kind: 'global', value: state.global as any },\n    }\n  }\n\n  if (state.preset) {\n    // validate and zip the three CSS-shaped slots through the one owner, then\n    // transplant the preset timing onto every zipped entry\n    const zipped = parseTransitionLonghands({\n      transitionProperty: state.lists.transitionProperty,\n      transitionDelay: state.lists.transitionDelay,\n      transitionBehavior: state.lists.transitionBehavior,\n    })\n    if (!zipped.ok || zipped.value.kind !== 'transition') return zipped\n    const preset = state.preset\n    const entries: TransitionEntry[] = zipped.value.entries.map((entry) => ({\n      ...entry,\n      timing: preset,\n    }))\n    return { ok: true, value: { kind: 'transition', entries } }\n  }\n\n  return parseTransitionLonghands(state.lists as TransitionLonghands)\n}\n"
+  ]
+}

package/types/transitionLegacy.d.ts

@@ -0,0 +1,9 @@
+import type { TransitionParseResult } from "./transition";
+export type LegacyTransitionValue = string | Readonly<Record<string, unknown>> | readonly [string, Readonly<Record<string, unknown>>];
+/**
+* lowers the legacy array and per-property object forms into transition IR.
+* per-property presets and spring overrides remain explicit driver config.
+*/
+export declare function migrateLegacyTransition(input: LegacyTransitionValue, presetNames: ReadonlySet<string>): TransitionParseResult;
+
+//# sourceMappingURL=transitionLegacy.d.ts.map

package/types/transitionLegacy.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAIE,6BACK;AAGP,YAAY,iCAER,SAAS,6CACS,SAAS;;;;;AAmC/B,OAAO,iBAAS,wBACd,OAAO,uBACP,aAAa,sBACZ",
+  "names": [],
+  "sources": [
+    "src/transitionLegacy.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type {\n  TransitionDiagnostic,\n  TransitionEntry,\n  TransitionIR,\n  TransitionParseResult,\n} from './transition'\nimport { parseTransition } from './transition'\n\nexport type LegacyTransitionValue =\n  | string\n  | Readonly<Record<string, unknown>>\n  | readonly [string, Readonly<Record<string, unknown>>]\n\nconst legacyControlKeys = new Set([\n  'default',\n  'enter',\n  'exit',\n  'delay',\n  'stiffness',\n  'damping',\n  'mass',\n  'tension',\n  'friction',\n  'velocity',\n  'overshootClamping',\n  'duration',\n  'bounciness',\n  'speed',\n])\nconst springConfigKeys = new Set([\n  'stiffness',\n  'damping',\n  'mass',\n  'tension',\n  'friction',\n  'velocity',\n  'overshootClamping',\n  'duration',\n  'bounciness',\n  'speed',\n])\n\n/**\n * lowers the legacy array and per-property object forms into transition IR.\n * per-property presets and spring overrides remain explicit driver config.\n */\nexport function migrateLegacyTransition(\n  input: LegacyTransitionValue,\n  presetNames: ReadonlySet<string>\n): TransitionParseResult {\n  if (typeof input === 'string') return parseTransition(input, presetNames)\n\n  const inputIsTuple = Array.isArray(input)\n  const options = (\n    inputIsTuple\n      ? (input as readonly [string, Readonly<Record<string, unknown>>])[1]\n      : input\n  ) as Readonly<Record<string, unknown>>\n  const defaultValue = inputIsTuple\n    ? (input as readonly [string, Readonly<Record<string, unknown>>])[0]\n    : options.default\n  const diagnostics: TransitionDiagnostic[] = []\n\n  const delay =\n    options.delay === undefined\n      ? undefined\n      : typeof options.delay === 'number' && Number.isFinite(options.delay)\n        ? `${options.delay}ms`\n        : null\n\n  if (delay === null) {\n    diagnostics.push({\n      code: 'transition-invalid-token',\n      token: String(options.delay),\n      message: 'legacy transition delay must be a finite number of milliseconds',\n    })\n  }\n\n  const resolveTiming = (\n    rawValue: string,\n    field: string\n  ): TransitionEntry | undefined => {\n    const parsed = parseTransition(rawValue, presetNames)\n    if (!parsed.ok) {\n      for (let index = 0; index < parsed.diagnostics.length; index++) {\n        const diagnostic = parsed.diagnostics[index]\n        diagnostics.push({\n          ...diagnostic,\n          message: `legacy transition ${field}: ${diagnostic.message}`,\n        })\n      }\n      return\n    }\n    if (\n      parsed.value.kind !== 'transition' ||\n      parsed.value.entries.length !== 1 ||\n      parsed.value.entries[0].property !== 'all'\n    ) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: rawValue,\n        message: `legacy transition ${field} must be a preset or CSS timing value`,\n      })\n      return\n    }\n    return parsed.value.entries[0]\n  }\n\n  let defaultTransition: TransitionEntry | undefined\n  if (defaultValue !== undefined) {\n    if (typeof defaultValue === 'string') {\n      defaultTransition = resolveTiming(defaultValue, 'default')\n    } else {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: String(defaultValue),\n        message: 'legacy transition default must be a preset or CSS timing value',\n      })\n    }\n  }\n\n  const resolveLifecycle = (field: 'enter' | 'exit'): TransitionEntry | undefined => {\n    const rawValue = options[field]\n    if (rawValue === undefined) return\n    if (typeof rawValue === 'string') return resolveTiming(rawValue, field)\n    diagnostics.push({\n      code: 'transition-invalid-token',\n      token: String(rawValue),\n      message: `legacy transition ${field} must be a preset or CSS timing value`,\n    })\n    return\n  }\n  const enter = resolveLifecycle('enter')\n  const exit = resolveLifecycle('exit')\n\n  const config: Record<string, unknown> = {}\n  for (const key of springConfigKeys) {\n    if (options[key] !== undefined) config[key] = options[key]\n  }\n  const hasConfig = Object.keys(config).length > 0\n\n  const entries: TransitionEntry[] = []\n  if (defaultTransition) {\n    if (defaultTransition.timing.type === 'css' && hasConfig) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: String(defaultValue),\n        message: 'spring overrides cannot be applied to CSS transition timing',\n      })\n    }\n    entries.push({\n      ...defaultTransition,\n      delay: delay ?? defaultTransition.delay,\n      timing:\n        defaultTransition.timing.type === 'preset' && hasConfig\n          ? { ...defaultTransition.timing, config }\n          : defaultTransition.timing,\n    })\n  }\n\n  for (const [property, rawValue] of Object.entries(options)) {\n    if (legacyControlKeys.has(property)) continue\n\n    let transition: TransitionEntry | undefined\n    let propertyConfig: Readonly<Record<string, unknown>> | undefined\n    if (typeof rawValue === 'string') {\n      transition = resolveTiming(rawValue, property)\n      if (!transition) continue\n    } else if (rawValue && typeof rawValue === 'object' && !Array.isArray(rawValue)) {\n      propertyConfig = rawValue as Readonly<Record<string, unknown>>\n      if (propertyConfig.type === undefined) {\n        transition = defaultTransition\n      } else if (typeof propertyConfig.type === 'string') {\n        transition = resolveTiming(propertyConfig.type, property)\n        if (!transition) continue\n      } else {\n        diagnostics.push({\n          code: 'transition-invalid-token',\n          token: property,\n          message: `legacy transition property \"${property}\" has a non-string type`,\n        })\n        continue\n      }\n    } else {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: property,\n        message: `legacy transition property \"${property}\" needs a preset, CSS timing value, or default`,\n      })\n      continue\n    }\n\n    if (!transition) {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: property,\n        message: `legacy transition property \"${property}\" needs a preset, CSS timing value, or default`,\n      })\n      continue\n    }\n\n    const propertyOverrides = propertyConfig\n      ? Object.fromEntries(\n          Object.entries(propertyConfig).filter(([key]) => key !== 'type')\n        )\n      : undefined\n    const hasPropertyOverrides =\n      propertyOverrides !== undefined && Object.keys(propertyOverrides).length > 0\n    if (hasPropertyOverrides && transition.timing.type === 'css') {\n      diagnostics.push({\n        code: 'transition-invalid-token',\n        token: property,\n        message: `legacy transition property \"${property}\" cannot apply spring overrides to CSS timing`,\n      })\n      continue\n    }\n    entries.push({\n      ...transition,\n      property,\n      timing:\n        transition.timing.type === 'preset' && propertyOverrides && hasPropertyOverrides\n          ? { ...transition.timing, config: propertyOverrides }\n          : transition.timing,\n      delay: delay ?? transition.delay,\n    })\n  }\n\n  if (diagnostics.length) return { ok: false, diagnostics }\n  const value: TransitionIR = {\n    kind: 'transition',\n    entries,\n    ...(enter ? { enter: { ...enter, delay: delay ?? enter.delay } } : {}),\n    ...(exit ? { exit: { ...exit, delay: delay ?? exit.delay } } : {}),\n    ...(hasConfig ? { config } : {}),\n  }\n  return { ok: true, value }\n}\n"
+  ]
+}

package/types/transitionNative.d.ts

@@ -0,0 +1,41 @@
+import type { ParsedTransition } from "./transition";
+export type NativeTransitionPlatform = "android" | "ios";
+export interface NativeTransitionTarget {
+	platform: NativeTransitionPlatform;
+	reactNativeMinor: number;
+	androidApi?: number;
+}
+export interface NativeTransitionCapability {
+	properties: readonly string[];
+	minimumReactNativeMinor: number;
+	platforms: readonly NativeTransitionPlatform[];
+	interpolation: "continuous" | "discrete";
+	note: string;
+}
+export interface NativeTransitionDiagnostic {
+	code: "native-transition-css-global" | "native-transition-property" | "native-transition-timing" | "native-transition-delay" | "native-transition-behavior" | "native-transition-filter";
+	property?: string;
+	message: string;
+}
+export type NativeTransitionValidationResult = {
+	ok: true;
+} | {
+	ok: false;
+	diagnostics: readonly NativeTransitionDiagnostic[];
+};
+/**
+* rn animated capability changes relevant to the v3 rn >= 0.82 target.
+*
+* 0.84 added broad non-layout native-driver coverage. 0.85 added layout
+* properties through the shared Animated/Reanimated backend.
+*/
+export declare const nativeTransitionCapabilities: readonly NativeTransitionCapability[];
+/**
+* validates a normalized transition for a concrete native target.
+*
+* pass the resolved destination values when property support depends on the
+* value, as with filter functions.
+*/
+export declare function validateNativeTransition(transition: ParsedTransition, target: NativeTransitionTarget, transitionedValues?: Readonly<Record<string, string>>): NativeTransitionValidationResult;
+
+//# sourceMappingURL=transitionNative.d.ts.map

package/types/transitionNative.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cAAc,wBAAyC;AAEvD,YAAY,2BAA2B,YAAY;AAEnD,iBAAiB,uBAAuB;CACtC,UAAU;CACV;CACA;;AAGF,iBAAiB,2BAA2B;CAC1C;CACA;CACA,oBAAoB;CACpB,eAAe,eAAe;CAC9B;;AAGF,iBAAiB,2BAA2B;CAC1C,MACI,iCACA,+BACA,6BACA,4BACA,+BACA;CACJ;CACA;;AAGF,YAAY,mCACR;CAAE,IAAI;IACN;CAAE,IAAI;CAAO,sBAAsB;;;;;;;;AAWvC,OAAO,cAAM,uCAAuC;;;;;;;AAoRpD,OAAO,iBAAS,yBACd,YAAY,kBACZ,QAAQ,wBACR,qBAAoB,SAAS,0BAC5B",
+  "names": [],
+  "sources": [
+    "src/transitionNative.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type { ParsedTransition, TransitionEntry } from './transition'\n\nexport type NativeTransitionPlatform = 'android' | 'ios'\n\nexport interface NativeTransitionTarget {\n  platform: NativeTransitionPlatform\n  reactNativeMinor: number\n  androidApi?: number\n}\n\nexport interface NativeTransitionCapability {\n  properties: readonly string[]\n  minimumReactNativeMinor: number\n  platforms: readonly NativeTransitionPlatform[]\n  interpolation: 'continuous' | 'discrete'\n  note: string\n}\n\nexport interface NativeTransitionDiagnostic {\n  code:\n    | 'native-transition-css-global'\n    | 'native-transition-property'\n    | 'native-transition-timing'\n    | 'native-transition-delay'\n    | 'native-transition-behavior'\n    | 'native-transition-filter'\n  property?: string\n  message: string\n}\n\nexport type NativeTransitionValidationResult =\n  | { ok: true }\n  | { ok: false; diagnostics: readonly NativeTransitionDiagnostic[] }\n\nconst bothPlatforms: readonly NativeTransitionPlatform[] = ['android', 'ios']\nconst iosPlatform: readonly NativeTransitionPlatform[] = ['ios']\n\n/**\n * rn animated capability changes relevant to the v3 rn >= 0.82 target.\n *\n * 0.84 added broad non-layout native-driver coverage. 0.85 added layout\n * properties through the shared Animated/Reanimated backend.\n */\nexport const nativeTransitionCapabilities: readonly NativeTransitionCapability[] = [\n  {\n    properties: ['opacity', 'transform', 'x', 'y', 'rotate', 'scale', 'filter'],\n    minimumReactNativeMinor: 82,\n    platforms: bothPlatforms,\n    interpolation: 'continuous',\n    note: 'baseline native-driver properties; filter animation landed in RN 0.82',\n  },\n  {\n    properties: [\n      'backgroundColor',\n      'borderRadius',\n      'borderTopLeftRadius',\n      'borderTopRightRadius',\n      'borderBottomRightRadius',\n      'borderBottomLeftRadius',\n      'boxShadow',\n      'outlineColor',\n      'outlineOffset',\n      'outlineWidth',\n      'transformOrigin',\n      'zIndex',\n    ],\n    minimumReactNativeMinor: 84,\n    platforms: bothPlatforms,\n    interpolation: 'continuous',\n    note: 'continuous properties explicitly recorded for the RN 0.84 backend',\n  },\n  {\n    properties: [\n      'backfaceVisibility',\n      'isolation',\n      'mixBlendMode',\n      'outlineStyle',\n      'overflow',\n      'pointerEvents',\n      'position',\n    ],\n    minimumReactNativeMinor: 84,\n    platforms: bothPlatforms,\n    interpolation: 'discrete',\n    note: 'the RN 0.84 backend can set these values, but native has no CSS allow-discrete transition semantics',\n  },\n  {\n    properties: ['cursor'],\n    minimumReactNativeMinor: 84,\n    platforms: iosPlatform,\n    interpolation: 'discrete',\n    note: 'cursor is limited to auto and pointer on iOS 17 or newer',\n  },\n  {\n    // the capability survey verifies width as the representative RN 0.85\n    // layout animation. Keep the matrix conservative until the rest of the\n    // layout property set has matching source evidence.\n    properties: ['width'],\n    minimumReactNativeMinor: 85,\n    platforms: bothPlatforms,\n    interpolation: 'continuous',\n    note: 'layout animation explicitly verified for the RN 0.85 shared backend',\n  },\n]\n\nfunction capabilityFor(property: string): NativeTransitionCapability | undefined {\n  for (let index = 0; index < nativeTransitionCapabilities.length; index++) {\n    const capability = nativeTransitionCapabilities[index]\n    for (\n      let propertyIndex = 0;\n      propertyIndex < capability.properties.length;\n      propertyIndex++\n    ) {\n      if (capability.properties[propertyIndex] === property) return capability\n    }\n  }\n  return undefined\n}\n\nconst baseFilterFunctions: ReadonlySet<string> = new Set(['brightness', 'opacity'])\nconst expandedAndroidFilterFunctions: ReadonlySet<string> = new Set([\n  'blur',\n  'contrast',\n  'drop-shadow',\n  'grayscale',\n  'hue-rotate',\n  'saturate',\n])\nconst filterFunctionPattern = /([a-z-]+)\\s*\\(/g\n\nfunction appendDiagnostics(\n  target: NativeTransitionDiagnostic[],\n  source: readonly NativeTransitionDiagnostic[]\n): void {\n  for (let index = 0; index < source.length; index++) target.push(source[index])\n}\n\nfunction validateFilter(\n  value: string,\n  target: NativeTransitionTarget\n): NativeTransitionDiagnostic | undefined {\n  filterFunctionPattern.lastIndex = 0\n  for (\n    let match = filterFunctionPattern.exec(value);\n    match;\n    match = filterFunctionPattern.exec(value)\n  ) {\n    const name = match[1]\n    if (baseFilterFunctions.has(name)) continue\n\n    if (target.platform === 'ios') {\n      return {\n        code: 'native-transition-filter',\n        property: 'filter',\n        message: `filter function \"${name}()\" is not supported on iOS`,\n      }\n    }\n\n    if (!expandedAndroidFilterFunctions.has(name)) {\n      return {\n        code: 'native-transition-filter',\n        property: 'filter',\n        message: `filter function \"${name}()\" is not supported on Android`,\n      }\n    }\n    if (target.reactNativeMinor < 83) {\n      return {\n        code: 'native-transition-filter',\n        property: 'filter',\n        message: `filter function \"${name}()\" requires React Native 0.83 or newer`,\n      }\n    }\n    if ((target.androidApi ?? 0) < 31) {\n      return {\n        code: 'native-transition-filter',\n        property: 'filter',\n        message: 'expanded filter functions require Android API 31 or newer',\n      }\n    }\n  }\n  return undefined\n}\n\nfunction validateProperty(\n  property: string,\n  target: NativeTransitionTarget,\n  transitionedValues: Readonly<Record<string, string>>\n): NativeTransitionDiagnostic[] {\n  const diagnostics: NativeTransitionDiagnostic[] = []\n\n  if (property.startsWith('--')) {\n    diagnostics.push({\n      code: 'native-transition-property',\n      property,\n      message: 'CSS custom properties are not supported on native',\n    })\n    return diagnostics\n  }\n\n  const capability = capabilityFor(property)\n  if (!capability) {\n    diagnostics.push({\n      code: 'native-transition-property',\n      property,\n      message: `\"${property}\" transitions are not supported on native`,\n    })\n    return diagnostics\n  }\n  if (!capability.platforms.includes(target.platform)) {\n    diagnostics.push({\n      code: 'native-transition-property',\n      property,\n      message: `\"${property}\" transitions are not supported on ${target.platform}`,\n    })\n    return diagnostics\n  }\n  if (target.reactNativeMinor < capability.minimumReactNativeMinor) {\n    diagnostics.push({\n      code: 'native-transition-property',\n      property,\n      message: `\"${property}\" transitions require React Native 0.${capability.minimumReactNativeMinor} or newer`,\n    })\n    return diagnostics\n  }\n\n  if (capability.interpolation === 'discrete') {\n    diagnostics.push({\n      code: 'native-transition-property',\n      property,\n      message: `\"${property}\" is discrete and native has no allow-discrete transition semantics`,\n    })\n    return diagnostics\n  }\n\n  if (property === 'filter') {\n    const value = transitionedValues.filter\n    if (value === undefined) {\n      diagnostics.push({\n        code: 'native-transition-filter',\n        property,\n        message: 'filter transition validation requires the resolved destination value',\n      })\n      return diagnostics\n    }\n    const diagnostic = validateFilter(value, target)\n    if (diagnostic) diagnostics.push(diagnostic)\n  }\n  return diagnostics\n}\n\nfunction validateEntry(\n  entry: TransitionEntry,\n  target: NativeTransitionTarget,\n  transitionedValues: Readonly<Record<string, string>>\n): NativeTransitionDiagnostic[] {\n  const diagnostics: NativeTransitionDiagnostic[] = []\n\n  if (entry.property === 'none') return diagnostics\n\n  if (entry.behavior === 'allow-discrete') {\n    diagnostics.push({\n      code: 'native-transition-behavior',\n      property: entry.property,\n      message: 'allow-discrete transition behavior is not supported on native',\n    })\n  }\n\n  if (entry.timing.type === 'css') {\n    if (\n      /^(?:steps|linear)\\(/.test(entry.timing.timingFunction) ||\n      entry.timing.timingFunction === 'step-start' ||\n      entry.timing.timingFunction === 'step-end'\n    ) {\n      diagnostics.push({\n        code: 'native-transition-timing',\n        property: entry.property,\n        message: `timing function \"${entry.timing.timingFunction}\" is not supported on native`,\n      })\n    }\n  }\n  if (Number.parseFloat(entry.delay) < 0) {\n    diagnostics.push({\n      code: 'native-transition-delay',\n      property: entry.property,\n      message: `negative transition delay \"${entry.delay}\" is not supported on native`,\n    })\n  }\n\n  if (entry.property !== 'all') {\n    appendDiagnostics(\n      diagnostics,\n      validateProperty(entry.property, target, transitionedValues)\n    )\n    return diagnostics\n  }\n\n  let hasProperty = false\n  for (const property in transitionedValues) {\n    if (!Object.prototype.hasOwnProperty.call(transitionedValues, property)) continue\n    hasProperty = true\n    appendDiagnostics(diagnostics, validateProperty(property, target, transitionedValues))\n  }\n  if (!hasProperty) {\n    diagnostics.push({\n      code: 'native-transition-property',\n      property: 'all',\n      message:\n        '\"all\" transition validation requires the concrete changed native properties',\n    })\n  }\n  return diagnostics\n}\n\n/**\n * validates a normalized transition for a concrete native target.\n *\n * pass the resolved destination values when property support depends on the\n * value, as with filter functions.\n */\nexport function validateNativeTransition(\n  transition: ParsedTransition,\n  target: NativeTransitionTarget,\n  transitionedValues: Readonly<Record<string, string>> = {}\n): NativeTransitionValidationResult {\n  if (transition.kind === 'global') {\n    return {\n      ok: false,\n      diagnostics: [\n        {\n          code: 'native-transition-css-global',\n          message: `CSS-wide value \"${transition.value}\" is not supported on native`,\n        },\n      ],\n    }\n  }\n\n  const diagnostics: NativeTransitionDiagnostic[] = []\n  if (transition.enter) {\n    appendDiagnostics(\n      diagnostics,\n      validateEntry(transition.enter, target, transitionedValues)\n    )\n  }\n  if (transition.exit) {\n    appendDiagnostics(\n      diagnostics,\n      validateEntry(transition.exit, target, transitionedValues)\n    )\n  }\n  for (let index = 0; index < transition.entries.length; index++) {\n    appendDiagnostics(\n      diagnostics,\n      validateEntry(transition.entries[index], target, transitionedValues)\n    )\n  }\n  return diagnostics.length ? { ok: false, diagnostics } : { ok: true }\n}\n"
+  ]
+}

package/types/unitlessNumbers.d.ts

@@ -0,0 +1,3 @@
+export declare const unitlessNumberProperties: ReadonlySet<string>;
+
+//# sourceMappingURL=unitlessNumbers.d.ts.map

package/types/unitlessNumbers.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AA4DA,OAAO,cAAM,0BAA0B",
+  "names": [],
+  "sources": [
+    "src/unitlessNumbers.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "const unitlessNumberPropertyNames = [\n  'animationIterationCount',\n  'aspectRatio',\n  'borderImageOutset',\n  'borderImageSlice',\n  'borderImageWidth',\n  'boxFlex',\n  'boxFlexGroup',\n  'boxOrdinalGroup',\n  'columnCount',\n  'flex',\n  'flexGrow',\n  'flexOrder',\n  'flexPositive',\n  'flexShrink',\n  'flexNegative',\n  'fontWeight',\n  'gap',\n  'columnGap',\n  'rowGap',\n  'gridRow',\n  'gridRowEnd',\n  'gridRowGap',\n  'gridRowStart',\n  'gridColumn',\n  'gridColumnEnd',\n  'gridColumnGap',\n  'gridColumnStart',\n  'lineClamp',\n  'opacity',\n  'order',\n  'orphans',\n  'tabSize',\n  'widows',\n  'zIndex',\n  'zoom',\n  'fillOpacity',\n  'floodOpacity',\n  'stopOpacity',\n  'strokeDasharray',\n  'strokeDashoffset',\n  'strokeMiterlimit',\n  'strokeOpacity',\n  'strokeWidth',\n  'scale',\n  'scaleX',\n  'scaleY',\n  'scaleZ',\n  'shadowOpacity',\n] as const\n\n// Mirrored from react-native-web-internals/src/modules/unitlessNumbers/index.tsx;\n// this package cannot import across that runtime boundary.\nconst unitlessNumbers = new Set<string>(unitlessNumberPropertyNames)\nfor (const prefix of ['ms', 'Moz', 'O', 'Webkit']) {\n  for (const property of unitlessNumberPropertyNames) {\n    unitlessNumbers.add(prefix + property[0].toUpperCase() + property.slice(1))\n  }\n}\n\nexport const unitlessNumberProperties: ReadonlySet<string> = unitlessNumbers\n"
+  ]
+}

package/types/v6ThemeNames.d.ts

@@ -0,0 +1,7 @@
+type KebabCase<Name extends string> = Name extends `${infer First}${infer Rest}` ? First extends Lowercase<First> ? `${First}${KebabCase<Rest>}` : `-${Lowercase<First>}${KebabCase<Rest>}` : Name;
+declare const v6RenamedThemeNames: readonly ["accentBackground", "accentColor", "colorHover", "colorPress", "colorFocus", "backgroundHover", "backgroundPress", "backgroundFocus", "borderColor", "borderColorHover", "borderColorFocus", "borderColorPress", "outlineColor", "placeholderColor", "colorTransparent", "shadowColor"];
+export declare const v6ThemeNameReplacements: { readonly [Name in (typeof v6RenamedThemeNames)[number]] : KebabCase<Name> };
+export declare const v6RemovedThemeNames: readonly ["backgroundActive"];
+export {};
+
+//# sourceMappingURL=v6ThemeNames.d.ts.map

package/types/v6ThemeNames.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "KAAK,UAAU,uBAAuB,sBAAsB,cAAc,SACtE,cAAc,UAAU,YACnB,QAAQ,UAAU,cACjB,UAAU,SAAS,UAAU,UACnC;AAKJ,cAAM,+BACJ,oBACA,eACA,cACA,cACA,cACA,mBACA,mBACA,mBACA,eACA,oBACA,oBACA,oBACA,gBACA,oBACA,oBACA;AAGF,OAAO,cAAM,qCAQD,gBAAgB,gCAA+B,UAAU;AAGrE,OAAO,cAAM,+BAAuB",
+  "names": [],
+  "sources": [
+    "src/v6ThemeNames.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "type KebabCase<Name extends string> = Name extends `${infer First}${infer Rest}`\n  ? First extends Lowercase<First>\n    ? `${First}${KebabCase<Rest>}`\n    : `-${Lowercase<First>}${KebabCase<Rest>}`\n  : Name\n\n// style-grammar cannot import the theme package without reversing the dependency\n// graph. This tuple is the zero-dependency vocabulary; the config test compares it\n// exhaustively with every actual v5 theme key so a new camel-case built-in fails.\nconst v6RenamedThemeNames = [\n  'accentBackground',\n  'accentColor',\n  'colorHover',\n  'colorPress',\n  'colorFocus',\n  'backgroundHover',\n  'backgroundPress',\n  'backgroundFocus',\n  'borderColor',\n  'borderColorHover',\n  'borderColorFocus',\n  'borderColorPress',\n  'outlineColor',\n  'placeholderColor',\n  'colorTransparent',\n  'shadowColor',\n] as const\n\nexport const v6ThemeNameReplacements = Object.freeze(\n  Object.fromEntries(\n    v6RenamedThemeNames.map((name) => [\n      name,\n      name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`),\n    ])\n  )\n) as {\n  readonly [Name in (typeof v6RenamedThemeNames)[number]]: KebabCase<Name>\n}\n\nexport const v6RemovedThemeNames = ['backgroundActive'] as const\n"
+  ]
+}

package/types/valueParser.d.ts

@@ -0,0 +1,36 @@
+import type { ModifierRegistryView, ValueParseResult } from "./valueTypes";
+export interface ValueSourceSpan {
+	kind: "base" | "payload" | "modifier" | "word";
+	start: number;
+	end: number;
+}
+export interface ValueParseWithSourceSpans {
+	result: ValueParseResult;
+	spans: readonly ValueSourceSpan[];
+}
+/**
+* NOT A SAFETY CHECK. A successful parse says the value is well-formed FLAT
+* VALUE SYNTAX. It does not say the value is safe to interpolate into CSS.
+*
+* `scanFlatValue` tracks the same constructs CSS's tokenizer does (comments,
+* strings that a newline ends, `url()`, paren nesting), so a value whose
+* delimiters do not actually close is an error rather than silently trusted.
+* That covers the constructs a value can leave OPEN; it is not an injection
+* guard. `emitValue` and `getStyleObject` used to call a
+* `carriesTopLevelInjection` guard independently; it was removed by owner
+* decision, on the grounds that a style value is authored rather than user
+* input, and the web lowering emits payloads verbatim by contract.
+*
+* So the rule lives upstream of this file: never put a user-controlled string
+* in a style value. A payload carrying `;}` closes its own rule and everything
+* after it is a selector block the author never wrote. Do not gate emission on
+* `parseValue(...).ok` either; it answers a syntax question, not a safety one.
+*/
+export declare function parseValue(input: string, registry: ModifierRegistryView): ValueParseResult;
+/**
+* Parses through the runtime scanner while also retaining source boundaries for
+* editor tooling. The ordinary runtime path does not allocate these spans.
+*/
+export declare function parseValueWithSourceSpans(input: string, registry: ModifierRegistryView): ValueParseWithSourceSpans;
+
+//# sourceMappingURL=valueParser.d.ts.map

package/types/valueParser.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAoBA,cACE,sBAIA,wBACK;AAMP,iBAAiB,gBAAgB;CAC/B,MAAM,SAAS,YAAY,aAAa;CACxC;CACA;;AAGF,iBAAiB,0BAA0B;CACzC,QAAQ;CACR,gBAAgB;;;;;;;;;;;;;;;;;;;;AAqBlB,OAAO,iBAAS,WACd,eACA,UAAU,uBACT;;;;;AAQH,OAAO,iBAAS,0BACd,eACA,UAAU,uBACT",
+  "names": [],
+  "sources": [
+    "src/valueParser.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// The universal flat value parser.\n//\n//   value  := base? clause*\n//   clause := modifier (\":\" modifier)* \":\" payload\n//\n// See plans/dom-tailwind-flat-values.md — \"The universal value grammar\". The\n// parser only splits: `base` and every `payload` come back as trimmed raw CSS\n// component-value sequences with no interpretation and no token resolution.\n//\n// The split itself is `scanFlatValue`, the one lexer every implementation of\n// this grammar drives; this file is what that split MEANS, which is the part\n// the registry decides. Read `scanFlatValue.ts` for why a top-level colon,\n// brace or semicolon is structural and everything inside a string or a paren is\n// not.\n\nimport {\n  scanFlatValue,\n  type FlatScanErrorCode,\n  type FlatValueVisitor,\n} from './scanFlatValue'\nimport type {\n  ModifierRegistryView,\n  ParsedClause,\n  ValueParseError,\n  ValueParseErrorCode,\n  ValueParseResult,\n} from './valueTypes'\n\nconst CHAR_COLON = 58\n\nconst noClauses: readonly ParsedClause[] = Object.freeze([])\n\nexport interface ValueSourceSpan {\n  kind: 'base' | 'payload' | 'modifier' | 'word'\n  start: number\n  end: number\n}\n\nexport interface ValueParseWithSourceSpans {\n  result: ValueParseResult\n  spans: readonly ValueSourceSpan[]\n}\n\n/**\n * NOT A SAFETY CHECK. A successful parse says the value is well-formed FLAT\n * VALUE SYNTAX. It does not say the value is safe to interpolate into CSS.\n *\n * `scanFlatValue` tracks the same constructs CSS's tokenizer does (comments,\n * strings that a newline ends, `url()`, paren nesting), so a value whose\n * delimiters do not actually close is an error rather than silently trusted.\n * That covers the constructs a value can leave OPEN; it is not an injection\n * guard. `emitValue` and `getStyleObject` used to call a\n * `carriesTopLevelInjection` guard independently; it was removed by owner\n * decision, on the grounds that a style value is authored rather than user\n * input, and the web lowering emits payloads verbatim by contract.\n *\n * So the rule lives upstream of this file: never put a user-controlled string\n * in a style value. A payload carrying `;}` closes its own rule and everything\n * after it is a selector block the author never wrote. Do not gate emission on\n * `parseValue(...).ok` either; it answers a syntax question, not a safety one.\n */\nexport function parseValue(\n  input: string,\n  registry: ModifierRegistryView\n): ValueParseResult {\n  return parseValueInternal(input, registry)\n}\n\n/**\n * Parses through the runtime scanner while also retaining source boundaries for\n * editor tooling. The ordinary runtime path does not allocate these spans.\n */\nexport function parseValueWithSourceSpans(\n  input: string,\n  registry: ModifierRegistryView\n): ValueParseWithSourceSpans {\n  const spans: ValueSourceSpan[] = []\n  return {\n    result: parseValueInternal(input, registry, spans),\n    spans,\n  }\n}\n\nfunction scanErrorMessage(code: FlatScanErrorCode, input: string, index: number): string {\n  if (code === 'invalid-character') {\n    return `\"${input[index]}\" cannot appear in a value: it would end the declaration or rule`\n  }\n  if (code === 'unterminated-string') {\n    return `unterminated ${input[index]} string`\n  }\n  if (code === 'unterminated-comment') {\n    return 'unterminated \"/*\" comment: it would swallow the rules after this one'\n  }\n  if (code === 'stray-comment-close') {\n    return 'stray \"*/\": it would close a comment opened somewhere else'\n  }\n  return 'unterminated \"(\" in value'\n}\n\nfunction parseValueInternal(\n  input: string,\n  registry: ModifierRegistryView,\n  sourceSpans?: ValueSourceSpan[]\n): ValueParseResult {\n  let errors: ValueParseError[] | null = null\n  let base: string | null = null\n  let clauses: ParsedClause[] | null = null\n  // modifiers of the clause whose payload is currently being collected\n  let pending: string[] | null = null\n  // where the base, or the current payload, starts before trimming, which is\n  // what an empty payload has to point its diagnostic at\n  let segmentStart = 0\n\n  const addError = (\n    code: ValueParseErrorCode,\n    index: number,\n    message: string,\n    modifier?: string\n  ): void => {\n    ;(errors ||= []).push(\n      modifier === undefined\n        ? { code, index, message }\n        : { code, index, message, modifier }\n    )\n  }\n\n  const visitor: FlatValueVisitor = {\n    segment(start, end, isBase) {\n      sourceSpans?.push({ kind: isBase ? 'base' : 'payload', start, end })\n      if (isBase) {\n        base = start < end ? input.slice(start, end) : null\n        return\n      }\n      if (start >= end) {\n        addError(\n          'empty-payload',\n          segmentStart,\n          `the \"${pending!.join(':')}:\" clause has no value`\n        )\n        return\n      }\n      ;(clauses ||= []).push({ modifiers: pending!, payload: input.slice(start, end) })\n    },\n\n    // a clause word ended: everything before its last top-level colon is the\n    // modifier chain, everything after it begins the payload\n    chain(chainStart, chainEnd) {\n      const modifiers: string[] = []\n      let nameStart = chainStart\n      for (let index = chainStart; index <= chainEnd; index++) {\n        if (index !== chainEnd && input.charCodeAt(index) !== CHAR_COLON) continue\n        if (index === nameStart) {\n          addError('empty-modifier', index, 'a modifier chain has an empty segment')\n        } else {\n          const name = input.slice(nameStart, index)\n          sourceSpans?.push({ kind: 'modifier', start: nameStart, end: index })\n          if (registry.get(name) === undefined) {\n            addError(\n              'unregistered-modifier',\n              nameStart,\n              `\"${name}\" is not a registered modifier`,\n              name\n            )\n          }\n          modifiers.push(name)\n        }\n        nameStart = index + 1\n      }\n      pending = modifiers\n      segmentStart = chainEnd + 1\n      return true\n    },\n\n    error(code, index) {\n      addError(code, index, scanErrorMessage(code, input, index))\n    },\n  }\n\n  if (sourceSpans) {\n    // only the trailing bare word is a completion position the spans have no\n    // other name for: every earlier word is inside a base or a payload span\n    visitor.word = (start, end, isChain) => {\n      if (!isChain && end === input.length) {\n        sourceSpans.push({ kind: 'word', start, end })\n      }\n    }\n  }\n\n  scanFlatValue(input, visitor)\n\n  if (errors !== null) return { ok: false, errors }\n  return { ok: true, value: { base, clauses: clauses ?? noClauses } }\n}\n"
+  ]
+}

package/types/valueTypes.d.ts

@@ -0,0 +1,66 @@
+export type ModifierKind = "state" | "theme" | "media" | "platform" | "group" | "container";
+/** Maximum distinct non-platform conditions one emitted clause can encode. */
+export declare const grammarMaxNonPlatformDepth = 5;
+/**
+* What the parser needs to know about registered modifiers. Implementations
+* project the user config (media keys, root themes, platform names) plus the
+* built-in state vocabulary into this view. Parameterized modifiers
+* (`group-<name>-<state>`) are the implementation's concern — `get` receives
+* the full authored spelling.
+*/
+export interface ModifierRegistryView {
+	get(name: string): ModifierKind | undefined;
+	/**
+	* Config-derived modifier trie lookup for authoring one canonical chain.
+	* Implementations that only parse values may omit it; tooling refuses to
+	* invent a completion vocabulary when it is absent.
+	*/
+	next?(modifiers: readonly string[]): readonly string[];
+}
+/** one `modifiers ":" payload` clause, modifiers in authored order */
+export interface ParsedClause {
+	modifiers: readonly string[];
+	/** trimmed raw CSS component-value sequence; never empty */
+	payload: string;
+}
+export interface ParsedValue {
+	/** trimmed unconditional leading value, or null when the string starts with a clause */
+	base: string | null;
+	clauses: readonly ParsedClause[];
+}
+export type ValueParseErrorCode = "unregistered-modifier" | "empty-payload" | "empty-modifier" | "unterminated-string" | "unterminated-function" | "unterminated-comment" | "stray-comment-close" | "invalid-character";
+export interface ValueParseError {
+	code: ValueParseErrorCode;
+	/** character offset into the source string where the error was detected */
+	index: number;
+	message: string;
+	/** the offending modifier spelling, for unregistered-modifier */
+	modifier?: string;
+}
+export type ValueParseResult = {
+	ok: true;
+	value: ParsedValue;
+} | {
+	ok: false;
+	errors: readonly ValueParseError[];
+};
+/**
+* CSS-wide keywords and universal values that resolve as literal CSS even when
+* ident resolution is config-first. A token may never take one of these names;
+* config creation must reject it. Shared by the parser's ident resolution and
+* config-time validation.
+*/
+export declare const reservedCssIdents: ReadonlySet<string>;
+/**
+* One longhand's merged program: which CSS longhand, the parsed value that owns
+* it, and which authored prop contributed it (for diagnostics and devtools).
+*/
+export interface LonghandProgram {
+	/** camelCase longhand matching React Native / react style keys */
+	property: string;
+	value: ParsedValue;
+	/** the authored prop name that won this longhand */
+	sourceProp: string;
+}
+
+//# sourceMappingURL=valueTypes.d.ts.map

package/types/valueTypes.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAgCA,YAAY,eACR,UACA,UACA,UACA,aACA,UAEA;;AAGJ,OAAO,cAAM,6BAA6B;;;;;;;;AAS1C,iBAAiB,qBAAqB;CACpC,IAAI,eAAe;;;;;;CAMnB,MAAM;;;AAIR,iBAAiB,aAAa;CAC5B;;CAEA;;AAGF,iBAAiB,YAAY;;CAE3B;CACA,kBAAkB;;AAGpB,YAAY,sBACR,0BACA,kBACA,mBACA,wBACA,0BAMA,yBAEA,wBAMA;AAEJ,iBAAiB,gBAAgB;CAC/B,MAAM;;CAEN;CACA;;CAEA;;AAGF,YAAY,mBACR;CAAE,IAAI;CAAM,OAAO;IACnB;CAAE,IAAI;CAAO,iBAAiB;;;;;;;;AAQlC,OAAO,cAAM,mBAAmB;;;;;AAehC,iBAAiB,gBAAgB;;CAE/B;CACA,OAAO;;CAEP",
+  "names": [],
+  "sources": [
+    "src/valueTypes.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "// The shared IR for the universal flat value grammar.\n//\n// This file is the contract between the value parser, the per-longhand program\n// merge engine, the compiler, and every frontend (props, Tailwind classes,\n// styled skins). See plans/dom-tailwind-flat-values.md on main — \"The universal\n// value grammar\" and \"Programs and merging\" — for the full design. The rules\n// that matter are restated here so this file can be read standalone.\n//\n// Grammar:\n//\n//   value  := base? clause*\n//   clause := modifier (\":\" modifier)* \":\" payload\n//\n// - `base` and each `payload` are plain CSS component-value sequences. They are\n//   NOT interpreted here; the parser only splits, it never resolves.\n// - Clause detection is purely syntactic: a top-level colon (outside strings\n//   and outside any paren nesting, url() included) always starts a clause. A\n//   top-level colon is never valid inside a CSS component value, so this is\n//   unambiguous with zero configuration.\n// - The identifier chain before the colon must be entirely registered\n//   modifiers. An unregistered modifier is a hard parse error (`hver:` never\n//   silently becomes part of a value).\n// - An empty payload is a parse error. A clause with no preceding base is fine\n//   (`bg=\"hover:red\"`).\n//\n// Programs:\n//\n// - Every authored prop expands (via shorthand + family tables) to one or more\n//   CSS longhands. Each longhand accumulates one program in authored order.\n//   Contributions merge by base or normalized condition-set slot, so a later\n//   clause replaces only that slot and unrelated earlier clauses persist.\n\nexport type ModifierKind =\n  | 'state'\n  | 'theme'\n  | 'media'\n  | 'platform'\n  | 'group'\n  /** container queries: `@sm:` nearest container, `@sm/card:` named */\n  | 'container'\n\n/** Maximum distinct non-platform conditions one emitted clause can encode. */\nexport const grammarMaxNonPlatformDepth = 5\n\n/**\n * What the parser needs to know about registered modifiers. Implementations\n * project the user config (media keys, root themes, platform names) plus the\n * built-in state vocabulary into this view. Parameterized modifiers\n * (`group-<name>-<state>`) are the implementation's concern — `get` receives\n * the full authored spelling.\n */\nexport interface ModifierRegistryView {\n  get(name: string): ModifierKind | undefined\n  /**\n   * Config-derived modifier trie lookup for authoring one canonical chain.\n   * Implementations that only parse values may omit it; tooling refuses to\n   * invent a completion vocabulary when it is absent.\n   */\n  next?(modifiers: readonly string[]): readonly string[]\n}\n\n/** one `modifiers \":\" payload` clause, modifiers in authored order */\nexport interface ParsedClause {\n  modifiers: readonly string[]\n  /** trimmed raw CSS component-value sequence; never empty */\n  payload: string\n}\n\nexport interface ParsedValue {\n  /** trimmed unconditional leading value, or null when the string starts with a clause */\n  base: string | null\n  clauses: readonly ParsedClause[]\n}\n\nexport type ValueParseErrorCode =\n  | 'unregistered-modifier'\n  | 'empty-payload'\n  | 'empty-modifier'\n  | 'unterminated-string'\n  | 'unterminated-function'\n  /**\n   * an opened comment that never closes. `getAllRules()` joins rules into one\n   * blob for SSR, so an open comment blanks the rules after it until some later\n   * close delimiter turns them back on\n   */\n  | 'unterminated-comment'\n  /** a close delimiter with nothing open, which closes another rule's comment */\n  | 'stray-comment-close'\n  /**\n   * a top-level `{`, `}`, or `;` — never valid in a CSS component value, and\n   * rejecting them here is what makes rule/selector injection through a\n   * payload structurally impossible in the web lowering\n   */\n  | 'invalid-character'\n\nexport interface ValueParseError {\n  code: ValueParseErrorCode\n  /** character offset into the source string where the error was detected */\n  index: number\n  message: string\n  /** the offending modifier spelling, for unregistered-modifier */\n  modifier?: string\n}\n\nexport type ValueParseResult =\n  | { ok: true; value: ParsedValue }\n  | { ok: false; errors: readonly ValueParseError[] }\n\n/**\n * CSS-wide keywords and universal values that resolve as literal CSS even when\n * ident resolution is config-first. A token may never take one of these names;\n * config creation must reject it. Shared by the parser's ident resolution and\n * config-time validation.\n */\nexport const reservedCssIdents: ReadonlySet<string> = new Set([\n  'inherit',\n  'initial',\n  'unset',\n  'revert',\n  'none',\n  'auto',\n  'transparent',\n  'currentColor',\n])\n\n/**\n * One longhand's merged program: which CSS longhand, the parsed value that owns\n * it, and which authored prop contributed it (for diagnostics and devtools).\n */\nexport interface LonghandProgram {\n  /** camelCase longhand matching React Native / react style keys */\n  property: string\n  value: ParsedValue\n  /** the authored prop name that won this longhand */\n  sourceProp: string\n}\n"
+  ]
+}