@citestyle/compiler 0.0.2

package/src/codegen.js

@@ -0,0 +1,992 @@
+/**
+ * CSL AST → JavaScript code generation.
+ *
+ * Transforms the parsed CSL AST into a JavaScript module string.
+ * The generated module exports: meta, bibliography(), citation().
+ */
+
+/**
+ * Generate JavaScript module source from a CSL AST + resolved locale.
+ *
+ * @param {object} ast - Parsed CSL style AST
+ * @param {object} locale - Resolved locale data
+ * @param {object} [options]
+ * @returns {string} JavaScript module source code
+ */
+export function generate(ast, locale, options = {}) {
+  const ctx = createCodegenContext(ast, locale)
+
+  const lines = []
+
+  // Header
+  lines.push(`// Generated by @citestyle/compiler — do not edit`)
+  lines.push(`// Source: ${ast.info?.title || 'Unknown CSL style'}`)
+  lines.push(`import { formatNames, formatDate, escapeHtml, stripFormatting, toHtml, titleCase, sentenceCase, capitalize, applyTextCase, stripNocaseSpans, ordinal, roman, pageRange } from '@citestyle/core'`)
+  lines.push('')
+
+  // Meta
+  lines.push(`export const meta = ${JSON.stringify(buildMeta(ast), null, 2)}`)
+  lines.push('')
+
+  // Locale terms (inlined)
+  lines.push(`const T = ${JSON.stringify(buildTermsObject(locale), null, 2)}`)
+  lines.push('')
+
+  // Month terms for date formatting
+  lines.push(`const MONTHS = ${JSON.stringify(locale.monthTerms || {})}`)
+  lines.push('')
+
+  // Inheritable name options
+  const globalNameOpts = resolveNameOptions(ast, null)
+  lines.push(`const NAME_OPTS = ${JSON.stringify(globalNameOpts)}`)
+  lines.push('')
+
+  // _nameConfig: runtime name option resolution (global → section → element)
+  lines.push(`function _nameConfig(ctx, el) {
+  const c = Object.assign({}, NAME_OPTS, ctx._secOpts || {}, el)
+  if (el.initialize === false || (ctx._secOpts || {}).initialize === false || NAME_OPTS.initialize === false) c.initialize = false
+  if (c.and === 'text') c.andTerm = T['and'] || 'and'
+  else if (c.and === 'symbol') c.andTerm = '&'
+  if (!c.etAlTerm) c.etAlTerm = T[el._etAlTerm || 'et-al'] || 'et al.'
+  if (ctx._disambig) c._disambig = ctx._disambig
+  return c
+}`)
+  lines.push('')
+
+  // Macros — name options resolved at runtime via _nameConfig
+  for (const [name, macro] of Object.entries(ast.macros)) {
+    lines.push(generateMacro(name, macro, ctx))
+    lines.push('')
+  }
+
+  // Bibliography
+  if (ast.bibliography) {
+    const bibNameOpts = resolveNameOptions(ast, ast.bibliography)
+    lines.push(`const BIB_NAME_OPTS = ${JSON.stringify(bibNameOpts)}`)
+    lines.push('')
+    lines.push(generateBibliography(ast.bibliography, ctx))
+    lines.push('')
+  }
+
+  // Citation
+  if (ast.citation) {
+    const citNameOpts = resolveNameOptions(ast, ast.citation)
+    lines.push(`const CIT_NAME_OPTS = ${JSON.stringify(citNameOpts)}`)
+    lines.push('')
+    lines.push(generateCitation(ast.citation, ctx))
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Create a codegen context for tracking state during generation.
+ */
+function createCodegenContext(ast, locale) {
+  let varCounter = 0
+  return {
+    ast,
+    locale,
+    freshVar(prefix = '_v') { return prefix + (varCounter++) },
+    macroNames: new Set(Object.keys(ast.macros)),
+    pageRangeFormat: ast.pageRangeFormat,
+  }
+}
+
+// ── Meta ─────────────────────────────────────────────────────────────────────
+
+function buildMeta(ast) {
+  const info = ast.info || {}
+  const id = info.id || ''
+  const shortId = id.replace(/^.*\//, '')
+
+  const meta = {
+    id: shortId,
+    title: info.title || '',
+    class: ast.class,
+    version: ast.version,
+    compiledWith: '@citestyle/compiler@0.1.0',
+  }
+
+  // Expose bibliography-level settings for registry use
+  if (ast.bibliography?.subsequentAuthorSubstitute != null) {
+    meta.subsequentAuthorSubstitute = ast.bibliography.subsequentAuthorSubstitute
+  }
+
+  // Expose citation disambiguation settings for registry use
+  if (ast.citation?.disambiguateAddYearSuffix) {
+    meta.disambiguateAddYearSuffix = true
+  }
+  if (ast.citation?.disambiguateAddNames) {
+    meta.disambiguateAddNames = true
+  }
+  if (ast.citation?.disambiguateAddGivenname) {
+    meta.disambiguateAddGivenname = true
+    meta.givennameDisambiguationRule = ast.citation.givennameDisambiguationRule || 'by-cite'
+  }
+
+  // Expose collapse mode for cite collapsing in registry
+  if (ast.citation?.collapseAttr) {
+    meta.collapse = ast.citation.collapseAttr
+  }
+
+  // Expose citation layout delimiter for collapsed output
+  if (ast.citation?.layout?.delimiter) {
+    meta.citationLayoutDelimiter = ast.citation.layout.delimiter
+  }
+
+  // Expose collapsing delimiters for author-date collapsing
+  if (ast.citation?.citeGroupDelimiter != null) {
+    meta.citeGroupDelimiter = ast.citation.citeGroupDelimiter
+  }
+  if (ast.citation?.yearSuffixDelimiter != null) {
+    meta.yearSuffixDelimiter = ast.citation.yearSuffixDelimiter
+  }
+  if (ast.citation?.afterCollapseDelimiter != null) {
+    meta.afterCollapseDelimiter = ast.citation.afterCollapseDelimiter
+  }
+
+  // Expose citation layout prefix/suffix for collapsing reconstruction
+  if (ast.citation?.layout?.prefix != null) {
+    meta.citationLayoutPrefix = ast.citation.layout.prefix
+  }
+  if (ast.citation?.layout?.suffix != null) {
+    meta.citationLayoutSuffix = ast.citation.layout.suffix
+  }
+
+  return meta
+}
+
+function buildTermsObject(locale) {
+  const terms = {}
+  // Only include terms that are likely used — keep it compact
+  for (const [key, val] of Object.entries(locale.terms)) {
+    if (key.includes(':gender')) continue // skip gender markers
+    terms[key] = val
+  }
+  return terms
+}
+
+// ── Name options resolution ──────────────────────────────────────────────────
+
+/**
+ * Resolve name options: merge global defaults → citation/bibliography level.
+ * These get further merged with per-names-element options at runtime.
+ */
+function resolveNameOptions(ast, sectionNode) {
+  const opts = {}
+  // Global inheritable options from <style>
+  if (ast.nameOptions) Object.assign(opts, ast.nameOptions)
+  // Section-level overrides
+  if (sectionNode?.nameOptions) Object.assign(opts, sectionNode.nameOptions)
+  return opts
+}
+
+// ── Macro generation ─────────────────────────────────────────────────────────
+
+function generateMacro(name, macro, ctx) {
+  const safeName = 'macro_' + name.replace(/[^a-zA-Z0-9_]/g, '_')
+  const body = generateChildren(macro.children, ctx, '  ')
+  return `function ${safeName}(item, ctx) {\n${body.code}\n  return ${body.expr}\n}`
+}
+
+// ── Bibliography generation ──────────────────────────────────────────────────
+
+function generateBibliography(bibNode, ctx) {
+  if (!bibNode.layout) return 'export function bibliography(item, ctx = {}) { return { text: "", html: "", parts: {}, links: {} } }'
+
+  const layout = bibNode.layout
+  const body = generateChildren(layout.children, ctx, '  ')
+  const delimiter = layout.delimiter ? JSON.stringify(layout.delimiter) : '""'
+  const secondFieldAlign = bibNode.secondFieldAlign
+
+  const sortCode = bibNode.sort ? generateSortFunction(bibNode.sort, ctx) : ''
+
+  // When second-field-align is set, the first layout element (typically citation-number)
+  // is separated from the rest by a space in text output
+  let joinCode
+  if (secondFieldAlign && body.parts.length > 1) {
+    joinCode = `  const _first = ${body.parts[0]}
+  const _rest = [${body.parts.slice(1).join(', ')}].filter(v => v !== '').join(${delimiter})
+  const _raw = (_first ? _first + (/\\s[\\uE000-\\uE007\\uE020-\\uE022]*$/.test(_first) ? '' : ' ') : '') + _rest`
+  } else {
+    joinCode = `  const _layout = [${body.parts.join(', ')}].filter(v => v !== '')
+  const _raw = _layout.join(${delimiter})`
+  }
+
+  return `export function bibliography(item, ctx = {}) {
+  ctx = { ...ctx, _secOpts: BIB_NAME_OPTS }
+${body.code}
+${joinCode}${layout.prefix ? ` + ${JSON.stringify(layout.prefix)}` : ''}${layout.suffix ? ` + ${JSON.stringify(layout.suffix)}` : ''}
+  const _norm = _normalizePunctuation(_raw)
+  const text = stripFormatting(_norm)
+  const html = '<div class="csl-entry">' + toHtml(_norm) + '</div>'
+  return {
+    text,
+    html,
+    parts: _extractParts(item),
+    links: _extractLinks(item),
+  }
+}
+
+function _extractParts(item) {
+  return {
+    authors: item.author || [],
+    year: item.issued?.['date-parts']?.[0]?.[0]?.toString() || '',
+    title: item.title || '',
+    container: item['container-title'] || '',
+    volume: item.volume?.toString() || '',
+    issue: item.issue?.toString() || '',
+    pages: item.page || '',
+    doi: item.DOI || '',
+    url: item.URL || '',
+  }
+}
+
+function _extractLinks(item) {
+  return {
+    doi: item.DOI ? 'https://doi.org/' + item.DOI : null,
+    url: item.URL || null,
+    pdf: item.extended?.pdf_url || null,
+  }
+}
+
+function _normalizePunctuation(str) {
+  if (!str) return ''
+  // F matches PUA tokens (formatting U+E000-E007 and semantic U+E020-E022) that may appear between dots
+  const F = '[\\uE000-\\uE007\\uE020-\\uE022]*'
+  return str
+    .replace(new RegExp('([.!?])(' + F + ')\\\\. ', 'g'), '$1$2 ')
+    .replace(new RegExp('\\\\.(' + F + ')\\\\.', 'g'), '.$1')
+    .replace(/ +/g, ' ')
+    .trim()
+}
+${sortCode}`
+}
+
+// ── Citation generation ──────────────────────────────────────────────────────
+
+function generateCitation(citNode, ctx) {
+  if (!citNode.layout) return 'export function citation(cites, ctx = {}) { return { text: "", html: "" } }'
+
+  const layout = citNode.layout
+  const body = generateChildren(layout.children, ctx, '    ')
+  const citeDelimiter = layout.delimiter ? JSON.stringify(layout.delimiter) : '"; "'
+  const isSuperscript = layout.verticalAlign === 'sup'
+
+  return `export function citation(cites, ctx = {}) {
+  const _outerCtx = { ...ctx, _secOpts: CIT_NAME_OPTS }
+  const rendered = cites.map(cite => {
+    let ctx = cite._disambig ? { ..._outerCtx, _disambig: cite._disambig } : _outerCtx
+    let item = cite.item || cite
+    if (cite.locator != null) { item = { ...item, locator: cite.locator, _locatorLabel: cite.label || 'page' } }
+${body.code}
+    return [${body.parts.join(', ')}].filter(v => v !== '').join('')
+  })
+  const _raw = ${layout.prefix ? JSON.stringify(layout.prefix) + ' + ' : ''}rendered.join(${citeDelimiter})${layout.suffix ? ' + ' + JSON.stringify(layout.suffix) : ''}
+  const text = stripFormatting(_raw)
+  const html = '<span class="csl-citation">${isSuperscript ? '<sup>' : ''}' + toHtml(_raw) + '${isSuperscript ? '</sup>' : ''}</span>'
+  return { text, html }
+}
+
+function _resolveTerm(key) {
+  const val = T[key]
+  if (val == null) return null
+  return typeof val === 'string' ? val : val.single || ''
+}`
+}
+
+// ── Sort generation ──────────────────────────────────────────────────────────
+
+function generateSortFunction(sort, ctx) {
+  if (!sort.keys.length) return ''
+
+  // Date variables that need special sort key extraction
+  const dateVars = new Set(['issued', 'accessed', 'event-date', 'original-date', 'submitted'])
+
+  const comparisons = sort.keys.map(key => {
+    const dir = key.sort === 'descending' ? -1 : 1
+    if (key.macro) {
+      const safeName = 'macro_' + key.macro.replace(/[^a-zA-Z0-9_]/g, '_')
+      return `  { fn: (item) => ${safeName}(item, {}), dir: ${dir} }`
+    }
+    if (key.variable) {
+      // Date variables: extract sortable string from date-parts
+      if (dateVars.has(key.variable)) {
+        return `  { fn: (item) => { const d = item[${JSON.stringify(key.variable)}]; if (!d || !d['date-parts'] || !d['date-parts'][0]) return ''; const p = d['date-parts'][0]; return String(p[0] || 0).padStart(4, '0') + String(p[1] || 0).padStart(2, '0') + String(p[2] || 0).padStart(2, '0') }, dir: ${dir} }`
+      }
+      return `  { fn: (item) => String(item[${JSON.stringify(key.variable)}] || ''), dir: ${dir} }`
+    }
+    return null
+  }).filter(Boolean)
+
+  return `
+export function bibliographySort(a, b) {
+  const keys = [
+${comparisons.join(',\n')}
+  ]
+  for (const k of keys) {
+    const va = k.fn(a)
+    const vb = k.fn(b)
+    const cmp = va < vb ? -1 : va > vb ? 1 : 0
+    if (cmp !== 0) return cmp * k.dir
+  }
+  return 0
+}`
+}
+
+// ── Children rendering ───────────────────────────────────────────────────────
+
+/**
+ * Generate code for an array of rendering elements.
+ *
+ * Returns { code: string (statements), parts: string[] (expressions), expr: string }
+ */
+function generateChildren(children, ctx, indent) {
+  const stmts = []
+  const parts = []
+
+  for (const child of children) {
+    const result = generateElement(child, ctx, indent)
+    if (result.code) stmts.push(result.code)
+    parts.push(result.expr)
+  }
+
+  return {
+    code: stmts.join('\n'),
+    parts,
+    expr: parts.length === 1
+      ? parts[0]
+      : `[${parts.join(', ')}].filter(v => v !== '').join('')`,
+  }
+}
+
+// ── Element generation ───────────────────────────────────────────────────────
+
+function generateElement(node, ctx, indent) {
+  switch (node.type) {
+    case 'text': return generateTextElement(node, ctx, indent)
+    case 'number': return generateNumberElement(node, ctx, indent)
+    case 'label': return generateLabelElement(node, ctx, indent)
+    case 'group': return generateGroupElement(node, ctx, indent)
+    case 'choose': return generateChooseElement(node, ctx, indent)
+    case 'names': return generateNamesElement(node, ctx, indent)
+    case 'date': return generateDateElement(node, ctx, indent)
+    default: return { code: '', expr: "''" }
+  }
+}
+
+// ── Text ─────────────────────────────────────────────────────────────────────
+
+function generateTextElement(node, ctx, indent) {
+  const v = ctx.freshVar()
+
+  let valueExpr
+
+  if (node.variable) {
+    // page-first: derive from page variable (extract first page from range)
+    if (node.variable === 'page-first') {
+      const pageAcc = variableAccessor('page')
+      valueExpr = `(${pageAcc} != null && ${pageAcc} !== '' ? stripNocaseSpans(String(${pageAcc})).split(/[-\u2013,\\s]/)[0] : '')`
+    } else if (node.variable === 'page' && ctx.pageRangeFormat) {
+      const accessor = variableAccessor(node.variable)
+      valueExpr = `(${accessor} != null && ${accessor} !== '' ? pageRange(stripNocaseSpans(String(${accessor})), ${JSON.stringify(ctx.pageRangeFormat)}) : '')`
+    } else {
+      const accessor = variableAccessor(node.variable)
+      valueExpr = `(${accessor} != null && ${accessor} !== '' ? String(${accessor}) : '')`
+    }
+  } else if (node.macro) {
+    const safeName = 'macro_' + node.macro.replace(/[^a-zA-Z0-9_]/g, '_')
+    valueExpr = `${safeName}(item, ctx)`
+  } else if (node.term) {
+    const termKey = node.form && node.form !== 'long'
+      ? JSON.stringify(node.term + ':' + node.form)
+      : JSON.stringify(node.term)
+    valueExpr = `(T[${termKey}] != null ? (typeof T[${termKey}] === 'string' ? T[${termKey}] : ${node.plural === 'true' ? `(T[${termKey}].multiple || T[${termKey}].single || '')` : `(T[${termKey}].single || '')`}) : '')`
+  } else if (node.value) {
+    valueExpr = JSON.stringify(node.value)
+  } else {
+    return { code: '', expr: "''" }
+  }
+
+  const code = `${indent}const ${v} = ${valueExpr}`
+  let expr = v
+
+  // Apply text-case (applyTextCase handles nocase span protection + stripping)
+  if (node.textCase) {
+    expr = applyTextCase(expr, node.textCase)
+  } else if (node.variable) {
+    // No text-case but variable may contain nocase spans — strip them
+    expr = `stripNocaseSpans(${expr})`
+  }
+  // Apply strip-periods
+  if (node.stripPeriods) expr = `${expr}.replace(/\\./g, '')`
+  // Apply formatting (for text output, formatting is mostly no-op; for HTML it wraps)
+  expr = applyFormatting(expr, node)
+  // Apply affixes
+  expr = applyAffixes(expr, node)
+  // Apply semantic class for variable-based text elements
+  if (node.variable) {
+    expr = wrapSemantic(expr, node.variable)
+  }
+
+  return { code, expr }
+}
+
+// ── Number ───────────────────────────────────────────────────────────────────
+
+function generateNumberElement(node, ctx, indent) {
+  const v = ctx.freshVar()
+  const accessor = variableAccessor(node.variable)
+  let code = `${indent}const ${v} = ${accessor} != null ? String(${accessor}) : ''`
+
+  let expr = v
+  if (node.form === 'ordinal') {
+    expr = `(${v} && !isNaN(Number(${v})) ? ordinal(Number(${v})) : ${v})`
+  } else if (node.form === 'long-ordinal') {
+    expr = `(${v} && !isNaN(Number(${v})) ? longOrdinal(Number(${v})) : ${v})`
+  } else if (node.form === 'roman') {
+    expr = `(${v} && !isNaN(Number(${v})) ? roman(Number(${v})) : ${v})`
+  }
+
+  expr = applyFormatting(expr, node)
+  expr = applyAffixes(expr, node)
+  expr = wrapSemantic(expr, node.variable)
+
+  return { code, expr }
+}
+
+// ── Label ────────────────────────────────────────────────────────────────────
+
+function generateLabelElement(node, ctx, indent) {
+  const v = ctx.freshVar()
+  const variable = node.variable
+
+  // Determine term key — locator is special: its term comes from the cite's label property at runtime
+  const isLocator = variable === 'locator'
+  const termName = variableToTermName(variable)
+  const formSuffix = node.form && node.form !== 'long' ? ':' + node.form : ''
+  const termKey = isLocator
+    ? `(item._locatorLabel || 'page') + ${JSON.stringify(formSuffix)}`
+    : JSON.stringify(termName + formSuffix)
+
+  const accessor = variableAccessor(variable)
+  // Labels should produce empty string when their variable is empty
+  const emptyCheck = `(${accessor} == null || ${accessor} === ''${
+    ['page', 'number-of-pages', 'number-of-volumes', 'volume', 'issue', 'edition', 'chapter-number', 'locator'].includes(variable)
+      ? '' : ` || (Array.isArray(${accessor}) && ${accessor}.length === 0)`
+  })`
+
+  let code
+  if (node.plural === 'always') {
+    code = `${indent}const ${v} = ${emptyCheck} ? '' : (T[${termKey}] != null ? (typeof T[${termKey}] === 'string' ? T[${termKey}] : T[${termKey}].multiple || T[${termKey}].single || '') : '')`
+  } else if (node.plural === 'never') {
+    code = `${indent}const ${v} = ${emptyCheck} ? '' : (T[${termKey}] != null ? (typeof T[${termKey}] === 'string' ? T[${termKey}] : T[${termKey}].single || '') : '')`
+  } else {
+    // contextual: determine plural from the variable's value
+    code = `${indent}const ${v} = (() => {
+${indent}  const _val = ${accessor}
+${indent}  if (_val == null || _val === '' || (Array.isArray(_val) && _val.length === 0)) return ''
+${indent}  const _term = T[${termKey}]
+${indent}  if (_term == null) return ''
+${indent}  if (typeof _term === 'string') return _term
+${indent}  const _isPlural = typeof _val === 'string' ? /[-,&]/.test(_val) || /\\d+\\s*[-\u2013]\\s*\\d+/.test(_val) : Array.isArray(_val) ? _val.length > 1 : Number(_val) !== 1
+${indent}  return _isPlural ? (_term.multiple || _term.single || '') : (_term.single || '')
+${indent}})()`
+  }
+
+  let expr = v
+  if (node.stripPeriods) expr = `${expr}.replace(/\\./g, '')`
+  expr = applyTextCase(expr, node.textCase)
+  expr = applyFormatting(expr, node)
+  expr = applyAffixes(expr, node)
+
+  return { code, expr }
+}
+
+// ── Group ────────────────────────────────────────────────────────────────────
+
+function generateGroupElement(node, ctx, indent) {
+  const delimiter = node.delimiter ? JSON.stringify(node.delimiter) : "''"
+  const g = ctx.freshVar('_g')
+  const partsVar = ctx.freshVar('_gp')
+
+  // Check if any children are choose elements (need flattening)
+  const hasChoose = node.children.some(c => c.type === 'choose')
+
+  if (hasChoose) {
+    // Use parts-array approach: choose branches push multiple items
+    return generateGroupWithFlattenedChoose(node, ctx, indent, delimiter, g, partsVar)
+  }
+
+  // Simple path: no choose children
+  const children = generateChildren(node.children, ctx, indent)
+
+  // Determine which children call variables (for group suppression)
+  // CSL spec: suppress group if all CALLED VARIABLES are empty
+  // We check the variables directly, not the rendered output
+  const calledVars = collectCalledVariables(node.children, ctx)
+
+  let code = children.code
+
+  if (calledVars.length > 0) {
+    const checks = calledVars.map(v => {
+      if (v.startsWith('__macro__')) {
+        // For macros, check the rendered output (we can't know which vars they use)
+        const safeName = 'macro_' + v.slice(9).replace(/[^a-zA-Z0-9_]/g, '_')
+        return `!${safeName}(item, ctx)`
+      }
+      const acc = variableAccessor(v)
+      // For name variables, also check array length
+      const nameVars = ['author', 'editor', 'translator', 'container-author',
+        'collection-editor', 'composer', 'director', 'illustrator',
+        'interviewer', 'recipient', 'reviewed-author']
+      const isNameVar = nameVars.includes(v)
+      return `(${acc} == null || ${acc} === ''${isNameVar ? ` || (Array.isArray(${acc}) && ${acc}.length === 0)` : ''})`
+    }).join(' && ')
+    code += `\n${indent}const ${g} = (${checks}) ? '' : [${children.parts.join(', ')}].filter(v => v !== '').join(${delimiter})`
+  } else {
+    code += `\n${indent}const ${g} = [${children.parts.join(', ')}].filter(v => v !== '').join(${delimiter})`
+  }
+
+  let expr = g
+  expr = applyFormatting(expr, node)
+  expr = applyAffixes(expr, node)
+
+  return { code, expr }
+}
+
+/**
+ * Generate a group where choose elements are flattened —
+ * branch children become individual group members.
+ */
+function generateGroupWithFlattenedChoose(node, ctx, indent, delimiter, g, partsVar) {
+  const lines = []
+  lines.push(`${indent}const ${partsVar} = []`)
+
+  for (const child of node.children) {
+    if (child.type === 'choose') {
+      // Flatten: each branch's children push individually to partsVar
+      for (let i = 0; i < child.conditions.length; i++) {
+        const cond = child.conditions[i]
+        const keyword = i === 0 ? 'if' : 'else if'
+        const test = generateConditionTest(cond, ctx)
+        lines.push(`${indent}${keyword} (${test}) {`)
+        for (const branchChild of cond.children) {
+          const result = generateElement(branchChild, ctx, indent + '  ')
+          if (result.code) lines.push(result.code)
+          lines.push(`${indent}  ${partsVar}.push(${result.expr})`)
+        }
+        lines.push(`${indent}}`)
+      }
+      if (child.else) {
+        lines.push(`${indent}else {`)
+        for (const branchChild of child.else.children) {
+          const result = generateElement(branchChild, ctx, indent + '  ')
+          if (result.code) lines.push(result.code)
+          lines.push(`${indent}  ${partsVar}.push(${result.expr})`)
+        }
+        lines.push(`${indent}}`)
+      }
+    } else {
+      const result = generateElement(child, ctx, indent)
+      if (result.code) lines.push(result.code)
+      lines.push(`${indent}${partsVar}.push(${result.expr})`)
+    }
+  }
+
+  lines.push(`${indent}const ${g} = ${partsVar}.filter(v => v !== '').join(${delimiter})`)
+
+  let expr = g
+  expr = applyFormatting(expr, node)
+  expr = applyAffixes(expr, node)
+
+  return { code: lines.join('\n'), expr }
+}
+
+// ── Choose ───────────────────────────────────────────────────────────────────
+
+function generateChooseElement(node, ctx, indent) {
+  const v = ctx.freshVar('_ch')
+  const lines = []
+
+  lines.push(`${indent}let ${v} = ''`)
+
+  for (let i = 0; i < node.conditions.length; i++) {
+    const cond = node.conditions[i]
+    const keyword = i === 0 ? 'if' : 'else if'
+    const test = generateConditionTest(cond, ctx)
+    const body = generateChildren(cond.children, ctx, indent + '  ')
+
+    lines.push(`${indent}${keyword} (${test}) {`)
+    if (body.code) lines.push(body.code)
+    lines.push(`${indent}  ${v} = ${body.expr}`)
+    lines.push(`${indent}}`)
+  }
+
+  if (node.else) {
+    const body = generateChildren(node.else.children, ctx, indent + '  ')
+    lines.push(`${indent}else {`)
+    if (body.code) lines.push(body.code)
+    lines.push(`${indent}  ${v} = ${body.expr}`)
+    lines.push(`${indent}}`)
+  }
+
+  return { code: lines.join('\n'), expr: v }
+}
+
+function generateConditionTest(cond, ctx) {
+  // Flatten all individual checks from all test attributes, then apply
+  // the match mode once. This avoids double-application of match="none"
+  // when a test attribute has multiple values (e.g., variable="page volume").
+  const allChecks = []
+
+  for (const t of cond.tests) {
+    if (t.test === 'type') {
+      for (const v of t.values) allChecks.push(`item.type === ${JSON.stringify(v)}`)
+    } else if (t.test === 'variable') {
+      for (const v of t.values) {
+        const acc = variableAccessor(v)
+        allChecks.push(`(${acc} != null && ${acc} !== '')`)
+      }
+    } else if (t.test === 'is-numeric') {
+      for (const v of t.values) {
+        const acc = variableAccessor(v)
+        allChecks.push(`(${acc} != null && /^\\s*\\d/.test(String(${acc})))`)
+      }
+    } else if (t.test === 'disambiguate') {
+      allChecks.push('ctx.disambiguate')
+    } else if (t.test === 'is-uncertain-date') {
+      for (const v of t.values) {
+        const acc = variableAccessor(v)
+        allChecks.push(`(${acc} && ${acc}.circa)`)
+      }
+    } else if (t.test === 'position') {
+      for (const v of t.values) allChecks.push(`ctx.position === ${JSON.stringify(v)}`)
+    } else if (t.test === 'locator') {
+      for (const v of t.values) allChecks.push(`ctx.locator === ${JSON.stringify(v)}`)
+    }
+  }
+
+  if (allChecks.length === 0) return 'true'
+  if (allChecks.length === 1) {
+    if (cond.match === 'none') return `!(${allChecks[0]})`
+    return allChecks[0]
+  }
+  if (cond.match === 'any') return '(' + allChecks.join(' || ') + ')'
+  if (cond.match === 'none') return allChecks.map(c => `!(${c})`).join(' && ')
+  return '(' + allChecks.join(' && ') + ')'
+}
+
+// ── Names ────────────────────────────────────────────────────────────────────
+
+function generateNamesElement(node, ctx, indent) {
+  const v = ctx.freshVar('_n')
+  const lines = []
+
+  // Build the element-level name options (resolved at runtime via _nameConfig)
+  const nameNode = node.nameNode || {}
+  const elementOpts = buildElementNameOpts(nameNode, ctx)
+
+  lines.push(`${indent}let ${v} = ''`)
+
+  // Try each variable in order (usually "author", or "author editor")
+  for (let i = 0; i < node.variables.length; i++) {
+    const variable = node.variables[i]
+    const accessor = variableAccessor(variable)
+    const isFirst = i === 0
+
+    if (isFirst) {
+      lines.push(`${indent}if (${accessor} && ${accessor}.length) {`)
+    } else {
+      lines.push(`${indent}else if (${accessor} && ${accessor}.length) {`)
+    }
+
+    lines.push(`${indent}  ${v} = formatNames(${accessor}, _nameConfig(ctx, ${JSON.stringify(elementOpts)}))`)
+
+    // Label after names (e.g., "(Ed.)" for editors)
+    if (node.labelNode && i > 0) {
+      const labelGen = generateLabelElement(
+        { ...node.labelNode, variable },
+        ctx, indent + '  '
+      )
+      if (labelGen.code) lines.push(labelGen.code)
+      lines.push(`${indent}  if (${v}) ${v} += ' ' + ${labelGen.expr}`)
+    }
+
+    // Semantic wrapping for this name variable
+    lines.push(`${indent}  if (${v}) ${v} = '\\uE020${variable}\\uE021' + ${v} + '\\uE022'`)
+
+    lines.push(`${indent}}`)
+  }
+
+  // Substitute fallback chain
+  if (node.substitute) {
+    lines.push(`${indent}if (!${v}) {`)
+    for (const sub of node.substitute.children) {
+      const subGen = generateElement(sub, ctx, indent + '  ')
+      if (subGen.code) lines.push(subGen.code)
+      lines.push(`${indent}  if (!${v}) ${v} = ${subGen.expr}`)
+    }
+    lines.push(`${indent}}`)
+  }
+
+  let expr = v
+  expr = applyFormatting(expr, node)
+  expr = applyAffixes(expr, node)
+
+  return { code: lines.join('\n'), expr }
+}
+
+/**
+ * Build element-level name options from a <name> node.
+ * Only includes properties explicitly set on the element.
+ * Runtime resolution via _nameConfig merges global → section → element.
+ */
+function buildElementNameOpts(nameNode, ctx) {
+  const opts = {}
+
+  if (nameNode.and != null) opts.and = nameNode.and
+  if (nameNode.delimiter != null) opts.delimiter = nameNode.delimiter
+  if (nameNode.delimiterPrecedesLast != null) opts.delimiterPrecedesLast = nameNode.delimiterPrecedesLast
+  if (nameNode.etAlMin != null) opts.etAlMin = nameNode.etAlMin
+  if (nameNode.etAlUseFirst != null) opts.etAlUseFirst = nameNode.etAlUseFirst
+  if (nameNode.etAlUseLast != null) opts.etAlUseLast = nameNode.etAlUseLast
+  if (nameNode.initialize === false) opts.initialize = false
+  if (nameNode.initializeWith != null) opts.initializeWith = nameNode.initializeWith
+  if (nameNode.nameAsSortOrder != null) opts.nameAsSortOrder = nameNode.nameAsSortOrder
+  if (nameNode.sortSeparator != null) opts.sortSeparator = nameNode.sortSeparator
+  if (nameNode.form && nameNode.form !== 'long') opts.form = nameNode.form
+  if (nameNode.delimiterPrecedesEtAl != null) opts.delimiterPrecedesEtAl = nameNode.delimiterPrecedesEtAl
+
+  // Name-part formatting (text-case, font formatting on family/given)
+  if (nameNode.nameParts && nameNode.nameParts.length > 0) {
+    opts.nameParts = nameNode.nameParts.map(np => {
+      const part = { name: np.name }
+      if (np.textCase) part.textCase = np.textCase
+      if (np.fontStyle) part.fontStyle = np.fontStyle
+      if (np.fontWeight) part.fontWeight = np.fontWeight
+      if (np.fontVariant) part.fontVariant = np.fontVariant
+      return part
+    })
+  }
+
+  // Store et-al term name for runtime resolution
+  const etAlNode = nameNode.etAlNode
+  if (etAlNode?.term && etAlNode.term !== 'et-al') opts._etAlTerm = etAlNode.term
+
+  return opts
+}
+
+// ── Date ─────────────────────────────────────────────────────────────────────
+
+function generateDateElement(node, ctx, indent) {
+  const v = ctx.freshVar('_d')
+  const variable = node.variable
+  const accessor = variableAccessor(variable)
+
+  // Build date config
+  let dateParts = node.dateParts
+
+  // If form is specified, use locale date format
+  if (node.form && (!dateParts || dateParts.length === 0)) {
+    const localeFormat = ctx.locale.dateFormats[node.form]
+    if (localeFormat) {
+      // Locale file uses 'parts', parser locale overrides use 'dateParts'
+      const formatParts = localeFormat.parts || localeFormat.dateParts || []
+      dateParts = formatParts.map(p => ({
+        ...p,
+        // Merge any date-part overrides from the style
+        ...(node.dateParts?.find(dp => dp.name === p.name) || {}),
+      }))
+    }
+  }
+
+  // Apply date-parts restriction (e.g., date-parts="year" → only year)
+  if (node.datePartsAttr && dateParts.length > 0) {
+    const allowed = new Set(node.datePartsAttr.split('-')) // "year-month" → {"year","month"}
+    dateParts = dateParts.filter(dp => allowed.has(dp.name))
+  }
+
+  const dateConfig = {
+    dateParts: (dateParts || []).map(dp => ({
+      name: dp.name,
+      form: dp.form,
+      prefix: dp.prefix || '',
+      suffix: dp.suffix || '',
+      rangeDelimiter: dp.rangeDelimiter,
+    })),
+    monthTerms: ctx.locale.monthTerms,
+    seasonTerms: ctx.locale.seasonTerms,
+  }
+
+  const code = `${indent}const ${v} = ${accessor} ? formatDate(${accessor}, ${JSON.stringify(dateConfig)}) : ''`
+
+  let expr = v
+  expr = applyFormatting(expr, node)
+  expr = applyAffixes(expr, node)
+  if (variable) {
+    expr = wrapSemantic(expr, variable)
+  }
+
+  return { code, expr }
+}
+
+// ── Formatting helpers ───────────────────────────────────────────────────────
+
+function applyTextCase(expr, textCase) {
+  if (!textCase) return expr
+  // Use the unified applyTextCase runtime function — handles nocase spans
+  return `applyTextCase(${expr}, ${JSON.stringify(textCase)})`
+}
+
+function applyFormatting(expr, node) {
+  // CSL rendering order: quotes → font formatting → display
+  if (node.quotes) {
+    expr = `(${expr} ? '\u201c' + ${expr} + '\u201d' : '')`
+  }
+  // Formatting tokens — PUA characters converted to HTML tags by toHtml()
+  if (node.fontStyle === 'italic') {
+    expr = `(${expr} ? '\\uE000' + ${expr} + '\\uE001' : '')`
+  }
+  if (node.fontWeight === 'bold') {
+    expr = `(${expr} ? '\\uE002' + ${expr} + '\\uE003' : '')`
+  }
+  if (node.fontVariant === 'small-caps') {
+    expr = `(${expr} ? '\\uE004' + ${expr} + '\\uE005' : '')`
+  }
+  if (node.textDecoration === 'underline') {
+    expr = `(${expr} ? '\\uE006' + ${expr} + '\\uE007' : '')`
+  }
+  return expr
+}
+
+function applyAffixes(expr, node) {
+  const prefix = node.prefix
+  const suffix = node.suffix
+  if (!prefix && !suffix) return expr
+
+  const parts = []
+  if (prefix) parts.push(JSON.stringify(prefix))
+  parts.push(expr)
+  if (suffix) parts.push(JSON.stringify(suffix))
+
+  if (parts.length === 1) return parts[0]
+  return `(${expr} ? ${parts.join(' + ')} : '')`
+}
+
+/**
+ * Wrap an expression in semantic span tokens for HTML CSS class output.
+ * Uses PUA tokens: \uE020 className \uE021 content \uE022
+ * toHtml() converts these to <span class="csl-className">content</span>
+ * stripFormatting() removes them for plain text.
+ */
+function wrapSemantic(expr, className) {
+  return `(${expr} ? '\\uE020${className}\\uE021' + ${expr} + '\\uE022' : '')`
+}
+
+// ── Utility ──────────────────────────────────────────────────────────────────
+
+/**
+ * Generate a JS property accessor for a CSL variable name.
+ * Handles hyphenated names like "container-title" → item['container-title']
+ */
+function variableAccessor(variable) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(variable)) {
+    return `item.${variable}`
+  }
+  return `item[${JSON.stringify(variable)}]`
+}
+
+/**
+ * Map variable name to its corresponding term name for labels.
+ */
+function variableToTermName(variable) {
+  // Most variables map directly to term names
+  // Exceptions:
+  const map = {
+    'page': 'page',
+    'volume': 'volume',
+    'issue': 'issue',
+    'chapter-number': 'chapter',
+    'edition': 'edition',
+    'number-of-pages': 'number-of-pages',
+    'number-of-volumes': 'number-of-volumes',
+  }
+  return map[variable] || variable
+}
+
+/**
+ * Collect all variable names called by an array of nodes.
+ * Used for group suppression: if all called variables are empty, suppress.
+ */
+function collectCalledVariables(nodes, ctx) {
+  const vars = new Set()
+  for (const node of nodes) {
+    collectVarsFromNode(node, vars, ctx)
+  }
+  return [...vars]
+}
+
+function collectVarsFromNode(node, vars, ctx) {
+  if (!node) return
+
+  switch (node.type) {
+    case 'text':
+      if (node.variable) vars.add(node.variable)
+      // For macros, conservatively treat as calling a variable
+      // (we can't easily resolve which vars the macro uses)
+      if (node.macro) vars.add('__macro__' + node.macro)
+      break
+    case 'number':
+    case 'date':
+      if (node.variable) vars.add(node.variable)
+      break
+    case 'label':
+      if (node.variable) vars.add(node.variable)
+      break
+    case 'names':
+      for (const v of (node.variables || [])) vars.add(v)
+      break
+    case 'group':
+      for (const child of (node.children || [])) collectVarsFromNode(child, vars, ctx)
+      break
+    case 'choose':
+      for (const cond of (node.conditions || [])) {
+        for (const child of (cond.children || [])) collectVarsFromNode(child, vars, ctx)
+      }
+      if (node.else) {
+        for (const child of (node.else.children || [])) collectVarsFromNode(child, vars, ctx)
+      }
+      break
+  }
+}
+
+/**
+ * Check if a rendering element calls a variable (for group suppression).
+ */
+function callsVariable(node, ctx) {
+  if (!node) return false
+
+  switch (node.type) {
+    case 'text':
+      if (node.variable) return true
+      if (node.macro) return true // Conservative: treat macros as calling variables
+      return false
+    case 'number':
+    case 'date':
+    case 'names':
+      return true
+    case 'label':
+      return !!node.variable
+    case 'group':
+      return node.children?.some(c => callsVariable(c, ctx)) || false
+    case 'choose':
+      // Conservative: if any branch calls a variable
+      return (node.conditions?.some(c => c.children?.some(ch => callsVariable(ch, ctx))) ||
+              node.else?.children?.some(c => callsVariable(c, ctx))) || false
+    default:
+      return false
+  }
+}