zyzz 0.0.28 → 0.0.30

package/src/compiler/internal/Expression.ts

@@ -1,218 +0,0 @@
-/**
- * Reads static template primitives and transparent TypeScript syntax without execution.
- * @module
- */
-import type * as Ast from '@oxc-project/types'
-import * as Binding from '../../internal/Binding.js'
-import * as Literal from '../../internal/Literal.js'
-import * as Token from '../../internal/Token.js'
-import * as Tree from 'css-tree'
-
-/** Checks color substitutions inside compound CSS values without widening direct reference domains. */
-export function acceptsColor(
-  expression: Token.Expression,
-  property: keyof Literal.Properties,
-): boolean {
-  const value = expression.parts
-    .map((part) => {
-      if (typeof part === 'string') return part
-      if (Binding.is(part) ? part.type === 'color' : part.group === 'color')
-        return 'rgb(1 2 3)'
-      return 'var(--zyzz-reference)'
-    })
-    .join('')
-    .replace(/(?: !custom)?(?: !important)?$/, '')
-
-  try {
-    return (
-      Tree.lexer.matchProperty(Literal.name(property), value).error === null
-    )
-  } catch {
-    return false
-  }
-}
-
-/** Validates explicit variable substitutions in compound values, including every conditional fallback. */
-export function acceptsVariables(
-  expression: Token.Expression,
-  property: keyof Literal.Properties,
-): boolean {
-  if (
-    !['filter', 'backdropFilter', 'boxShadow', 'textShadow'].includes(property)
-  )
-    return false
-  function values(value: Token.Value): readonly string[] {
-    if (Token.is(value)) return values(value.value)
-    if (typeof value === 'object') return Object.values(value).flatMap(values)
-    return [String(value)]
-  }
-  let candidates = ['']
-  for (const part of expression.parts) {
-    if (Binding.is(part)) return false
-    const alternatives = typeof part === 'string' ? [part] : values(part.value)
-    // Bound combinations of independent responsive variables before grammar checks.
-    if (candidates.length * alternatives.length > 256) return false
-    candidates = candidates.flatMap((prefix) =>
-      alternatives.map((value) => prefix + value),
-    )
-  }
-  try {
-    return candidates.every(
-      (value) =>
-        Tree.lexer.matchProperty(
-          Literal.name(property),
-          value.replace(/(?: !custom)?(?: !important)?$/, ''),
-        ).error === null,
-    )
-  } catch {
-    return false
-  }
-}
-
-/** Checks every identifier-token branch before its value becomes a CSS variable. */
-export function acceptsIdentifier(
-  reference: Token.Reference,
-  property: keyof Literal.Properties,
-): boolean {
-  function check(value: Token.Value): boolean {
-    if (Token.is(value)) return check(value.value)
-    if (typeof value === 'object') return Object.values(value).every(check)
-    try {
-      return (
-        Tree.lexer.matchProperty(Literal.name(property), String(value))
-          .error === null
-      )
-    } catch {
-      return false
-    }
-  }
-  return check(reference.value)
-}
-
-/** Folds cooked template text and literal primitive substitutions; unresolved syntax returns undefined. */
-export function template(
-  node: Ast.TemplateLiteral,
-  depth = 0,
-  resolve?: (
-    node: Ast.Node,
-    prefix: string,
-  ) => string | Token.Reference | Binding.Reference | undefined,
-  context = '',
-): string | Token.Expression | undefined {
-  if (depth >= 128) return undefined
-
-  const parts: (string | Token.Reference | Binding.Reference)[] = []
-
-  for (const [index, quasi] of node.quasis.entries()) {
-    if (quasi.value.cooked === null) return undefined
-
-    parts.push(quasi.value.cooked)
-
-    const expression = node.expressions[index]
-    if (!expression) continue
-
-    const value = unwrap(expression)
-    const prefix =
-      context +
-      parts
-        .map((part) =>
-          typeof part === 'string' ? part : 'var(--zyzz-expression)',
-        )
-        .join('')
-    const reference = resolve?.(expression, prefix) ?? resolve?.(value, prefix)
-
-    if (reference) {
-      if (
-        quoted(
-          parts
-            .filter((part): part is string => typeof part === 'string')
-            .join(''),
-        )
-      )
-        return undefined
-
-      // var() substitutions must remain whole CSS tokens.
-      if (
-        /[%a-zA-Z_\d.-]/.test(
-          node.quasis[index + 1]?.value.cooked?.[0] ?? '',
-        ) ||
-        /[\w.#@+\\-]$/.test(quasi.value.cooked)
-      )
-        return undefined
-
-      parts.push(reference)
-    } else if (value.type === 'Literal' && !('regex' in value)) {
-      if (typeof value.value === 'number' && !Number.isFinite(value.value))
-        return undefined
-
-      parts.push(String(value.value))
-    } else if (
-      value.type === 'UnaryExpression' &&
-      (value.operator === '-' || value.operator === '+') &&
-      value.argument.type === 'Literal' &&
-      typeof value.argument.value === 'number' &&
-      Number.isFinite(value.argument.value)
-    ) {
-      parts.push(
-        String(
-          value.operator === '-' ? -value.argument.value : value.argument.value,
-        ),
-      )
-    } else if (
-      value.type === 'UnaryExpression' &&
-      value.operator === '-' &&
-      value.argument.type === 'Literal' &&
-      typeof value.argument.value === 'bigint'
-    ) {
-      parts.push(String(-value.argument.value))
-    } else if (value.type === 'TemplateLiteral') {
-      const nested = template(value, depth + 1, resolve, prefix)
-      if (nested === undefined) return undefined
-
-      if (typeof nested === 'string') parts.push(nested)
-      else parts.push(...nested.parts)
-    } else return undefined
-  }
-
-  return parts.every((part) => typeof part === 'string')
-    ? parts.join('')
-    : Token.compose(parts)
-}
-
-/** Returns the expression beneath assertions without evaluating application code. */
-export function unwrap(node: Ast.Node): Ast.Node {
-  while (
-    node.type === 'TSAsExpression' ||
-    node.type === 'TSSatisfiesExpression' ||
-    node.type === 'TSNonNullExpression' ||
-    node.type === 'TSTypeAssertion'
-  )
-    node = node.expression
-
-  return node
-}
-
-function quoted(text: string): boolean {
-  let quote = ''
-
-  for (let index = 0; index < text.length; index++) {
-    const char = text[index]!
-
-    if (char === '\\') {
-      index++
-      continue
-    }
-
-    if (quote) {
-      if (char === quote) quote = ''
-    } else if (char === '"' || char === "'") quote = char
-    else if (char === '/' && text[index + 1] === '*') {
-      const end = text.indexOf('*/', index + 2)
-      if (end < 0) return true
-
-      index = end + 1
-    }
-  }
-
-  return !!quote
-}

package/src/compiler/internal/Functions.ts

@@ -1,206 +0,0 @@
-/** Checks CSS function arguments and defaults against native syntax definitions. @module */
-import * as FunctionSyntax from '../../internal/FunctionSyntax.js'
-import * as Lightning from 'lightningcss'
-import * as Tree from 'css-tree'
-
-/** Checks complete static values while leaving computed substitutions to CSS. */
-export function value(syntax: string, input: string): string | undefined {
-  const text = input.trim()
-  const body =
-    text.startsWith('{') && text.endsWith('}') ? text.slice(1, -1) : text
-  const parsed = Tree.parse(body, { context: 'value' })
-  let computed = false
-  Tree.walk(parsed, (node) => {
-    if (
-      node.type === 'Function' &&
-      /^(?:--|var$|env$|attr$)/i.test(Tree.ident.decode(node.name))
-    )
-      computed = true
-  })
-  const normalized = syntax.trim()
-  const definition = normalized.startsWith('type(')
-    ? normalized.slice(5, -1).trim()
-    : normalized
-  if (computed || definition === '*') return
-  const alternatives: string[] = []
-  let start = 0
-  Tree.tokenize(definition, (type, from, to) => {
-    if (type === Tree.tokenTypes.Delim && definition.slice(from, to) === '|') {
-      alternatives.push(definition.slice(start, from).trim())
-      start = to
-    }
-  })
-  alternatives.push(definition.slice(start).trim())
-  for (const alternative of alternatives) {
-    try {
-      if (alternative.startsWith('<')) {
-        if (alternative.startsWith('<string>')) {
-          if (Tree.lexer.match(alternative, body).error) continue
-        } else
-          Lightning.transform({
-            filename: 'argument.css',
-            code: new TextEncoder().encode(
-              `@property --argument{syntax:${JSON.stringify(alternative)};inherits:false;initial-value:${body};}`,
-            ),
-          })
-        return alternative
-      }
-      let multiplier = ''
-      let atom = alternative
-      Tree.tokenize(alternative, (type, from, to) => {
-        if (
-          type === Tree.tokenTypes.Delim &&
-          to === alternative.length &&
-          ['+', '#'].includes(alternative.slice(from, to))
-        ) {
-          multiplier = alternative.slice(from, to)
-          atom = alternative.slice(0, from)
-        }
-      })
-      const expected = Tree.ident.decode(atom)
-      const nodes = (parsed as Tree.Value).children.toArray()
-      let count = 0
-      let comma = false
-      let valid = true
-      for (const node of nodes) {
-        if (
-          node.type === 'Operator' &&
-          node.value === ',' &&
-          multiplier === '#' &&
-          count > 0 &&
-          !comma
-        ) {
-          comma = true
-          continue
-        }
-        if (
-          node.type !== 'Identifier' ||
-          Tree.ident.decode(node.name) !== expected ||
-          (count > 0 && (multiplier === '' || (multiplier === '#' && !comma)))
-        ) {
-          valid = false
-          break
-        }
-        count++
-        comma = false
-      }
-      if (valid && count > 0 && !comma) return alternative
-    } catch {
-      /* Another syntax alternative may accept this value. */
-    }
-  }
-  throw new Error('Invalid CSS function argument for its declared syntax.')
-}
-
-/** Validates packed function headers and body contexts before parser recovery. */
-export function validate(source: string): void {
-  Tree.walk(Tree.parse(source), {
-    visit: 'Atrule',
-    enter(rule) {
-      if (rule.name.toLowerCase() !== 'function') return
-      if (!rule.prelude || !rule.block)
-        throw new Error('CSS functions require parameters and a body.')
-      const prelude = Tree.generate(rule.prelude)
-      let opening = 0
-      let closing = -1
-      let depth = 0
-      const commas: number[] = []
-      Tree.tokenize(prelude, (type, start, end) => {
-        if (closing >= 0) return
-        if (
-          type === Tree.tokenTypes.Function ||
-          type === Tree.tokenTypes.LeftParenthesis
-        ) {
-          if (depth === 0) {
-            const name = Tree.ident.decode(prelude.slice(start, end - 1))
-            if (
-              start !== 0 ||
-              type !== Tree.tokenTypes.Function ||
-              !name.startsWith('--') ||
-              name.length <= 2
-            )
-              throw new Error('CSS function names require a dashed identifier.')
-            opening = end
-          }
-          depth++
-        } else if (type === Tree.tokenTypes.RightParenthesis) {
-          depth--
-          if (depth === 0) closing = start
-        } else if (type === Tree.tokenTypes.Comma && depth === 1)
-          commas.push(start)
-      })
-      if (closing < 0) throw new Error('Unclosed CSS function parameters.')
-      const names = new Set<string>()
-      let start = opening
-      for (const end of [...commas, closing]) {
-        const parameter = prelude.slice(start, end).trim()
-        start = end + 1
-        if (!parameter && end === closing && opening === closing) continue
-        let name = ''
-        let offset = 0
-        let colon = -1
-        let depth = 0
-        Tree.tokenize(parameter, (type, from, to) => {
-          if (from === 0 && type === Tree.tokenTypes.Ident) {
-            name = Tree.ident.decode(parameter.slice(from, to))
-            offset = to
-          }
-          if (
-            type === Tree.tokenTypes.Function ||
-            type === Tree.tokenTypes.LeftParenthesis
-          )
-            depth++
-          if (type === Tree.tokenTypes.RightParenthesis) depth--
-          if (type === Tree.tokenTypes.Colon && depth === 0 && colon < 0)
-            colon = from
-        })
-        if (!name.startsWith('--') || name.length <= 2 || names.has(name))
-          throw new Error(
-            'CSS function parameters require unique dashed names.',
-          )
-        names.add(name)
-        const syntax =
-          parameter.slice(offset, colon < 0 ? undefined : colon).trim() || '*'
-        if (!FunctionSyntax.accepts(syntax))
-          throw new Error('Invalid CSS function parameter syntax.')
-        if (colon >= 0) value(syntax, parameter.slice(colon + 1))
-      }
-      const returns = prelude.slice(closing + 1).trim()
-      if (
-        returns &&
-        (!returns.startsWith('returns ') ||
-          !FunctionSyntax.accepts(returns.slice(8)))
-      )
-        throw new Error('Invalid CSS function return syntax.')
-      function body(block: Tree.Block): void {
-        const declarations = Tree.parse(Tree.generate(block).slice(1, -1), {
-          context: 'declarationList',
-        }) as Tree.DeclarationList
-        declarations.children.forEach((node) => {
-          if (
-            node.type === 'Atrule' &&
-            ['media', 'supports', 'container'].includes(node.name) &&
-            node.block &&
-            node.prelude
-          ) {
-            if (
-              Tree.lexer.matchAtrulePrelude(
-                node.name,
-                Tree.generate(node.prelude),
-              ).error
-            )
-              throw new Error('Invalid CSS function condition.')
-            body(node.block)
-          } else if (
-            node.type === 'Declaration' &&
-            !node.important &&
-            (node.property === 'result' || node.property.startsWith('--'))
-          ) {
-            value('*', Tree.generate(node.value))
-          } else throw new Error('Invalid CSS function body context.')
-        })
-      }
-      body(rule.block)
-    },
-  })
-}

package/src/compiler/internal/Keyframes.ts

@@ -1,62 +0,0 @@
-/** Checks complete keyframe selectors, including named timeline ranges. @module */
-import * as Lightning from 'lightningcss'
-
-/** Rejects invalid ordinary offsets and importance in transported keyframes. */
-export function validate(source: string): void {
-  Lightning.transform({
-    filename: 'keyframes.css',
-    code: new TextEncoder().encode(source),
-    visitor: {
-      Rule(rule) {
-        if (rule.type !== 'keyframes') return
-        for (const frame of rule.value.keyframes) {
-          if (
-            frame.selectors.some(
-              (selector) =>
-                selector.type === 'percentage' &&
-                (selector.value < 0 || selector.value > 1),
-            )
-          )
-            throw new Error('Ordinary keyframe offsets must be within 0–100%.')
-          if (frame.declarations.importantDeclarations?.length)
-            throw new Error('Keyframes forbid important declarations.')
-        }
-      },
-    },
-  })
-}
-
-/** Named timeline percentages are unrestricted; ordinary offsets remain within 0–100%. */
-export function accepts(selector: string): boolean {
-  try {
-    let valid = false
-    Lightning.transform({
-      filename: 'keyframe.css',
-      code: new TextEncoder().encode(
-        `@keyframes zyzz {${selector}{opacity:0}}`,
-      ),
-      visitor: {
-        StyleSheet(sheet) {
-          const rule = sheet.rules[0]
-          if (
-            sheet.rules.length !== 1 ||
-            rule?.type !== 'keyframes' ||
-            rule.value.keyframes.length !== 1
-          )
-            return
-          const frame = rule.value.keyframes[0]!
-          valid =
-            frame.selectors.length > 0 &&
-            frame.selectors.every(
-              (selector) =>
-                selector.type !== 'percentage' ||
-                (selector.value >= 0 && selector.value <= 1),
-            )
-        },
-      },
-    })
-    return valid
-  } catch {
-    return false
-  }
-}

package/src/compiler/internal/Names.ts

@@ -1,48 +0,0 @@
-/** Derives emitted names from authored bindings rather than source locations. @module */
-import type * as Ast from '@oxc-project/types'
-import * as Walker from 'oxc-walker'
-import * as Identity from '../../internal/Identity.js'
-
-/** Collects readable declaration paths for calls in constants and namespaces. */
-export function collect(program: Ast.Program): ReadonlyMap<number, string> {
-  const names = new Map<number, string>()
-  const ancestors: Ast.Node[] = []
-
-  Walker.walk(program, {
-    enter(node) {
-      if (node.type === 'CallExpression') {
-        const parts: string[] = []
-        for (const ancestor of ancestors) {
-          if (
-            ancestor.type === 'TSModuleDeclaration' &&
-            ancestor.id.type === 'Identifier'
-          )
-            parts.push(ancestor.id.name)
-          if (
-            ancestor.type === 'VariableDeclarator' &&
-            ancestor.id.type === 'Identifier'
-          )
-            parts.push(ancestor.id.name)
-          if (ancestor.type === 'Property' && !ancestor.computed) {
-            if (ancestor.key.type === 'Identifier')
-              parts.push(ancestor.key.name)
-            else if (ancestor.key.type === 'Literal')
-              parts.push(String(ancestor.key.value))
-          }
-          if (ancestor.type === 'FunctionDeclaration' && ancestor.id)
-            parts.push(ancestor.id.name)
-        }
-        names.set(
-          node.start,
-          parts.length ? parts.map(Identity.name).join('-') : 'style',
-        )
-      }
-      ancestors.push(node)
-    },
-    leave() {
-      ancestors.pop()
-    },
-  })
-
-  return names
-}