@shapeshift-labs/frontier-lang-compiler 0.2.149 → 0.2.151

package/dist/internal/index-impl/projectSymbolGraphCompilerTypeReferenceTargetEquivalence.js

@@ -0,0 +1,99 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const TypeReferenceTargetProofKind = 'typescript-checker-public-api-type-reference-target-proof';
+
+const RequiredFields = [
+  field('typeReferenceName', 'Names', 'compiler-type-reference-target-names'),
+  field('targetSymbolName', 'SymbolNames', 'compiler-type-reference-target-symbol-names'),
+  field('targetFullyQualifiedName', 'FullyQualifiedNames', 'compiler-type-reference-target-fully-qualified-names'),
+  field('targetDeclarationSourcePath', 'DeclarationSourcePaths', 'compiler-type-reference-target-declaration-source-paths'),
+  field('targetDeclarationSpan', 'DeclarationSpans', 'compiler-type-reference-target-declaration-spans'),
+  field('targetDeclarationTextHash', 'DeclarationTextHashes', 'compiler-type-reference-target-declaration-text-hashes'),
+  field('targetSymbolIdentityHash', 'SymbolIdentityHashes', 'compiler-type-reference-target-symbol-identity-hashes'),
+  field('typeReferenceTargetProofHash', 'ProofHashes', 'compiler-type-reference-target-proof-hashes')
+];
+
+function typeReferenceTargetSetHash(value, counts) {
+  if (!counts.typeReferenceTargetCount || missingTypeReferenceTargetSignals(value, counts).length) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.typescript.compilerTypeReferenceTargetSetEquivalence.v1',
+    typeReferenceTargets: typeReferenceTargets(value).map(canonicalTypeReferenceTarget)
+  });
+}
+
+function typeReferenceTargetRequiredSignals(counts) {
+  return counts.typeReferenceTargetCount > 0
+    ? ['compiler-type-reference-target-count', ...RequiredFields.map((item) => item.signal)]
+    : [];
+}
+
+function missingTypeReferenceTargetSignals(value, counts) {
+  if (!counts.typeReferenceTargetCount) return [];
+  const targets = typeReferenceTargets(value);
+  const missing = [];
+  if (targets.length !== counts.typeReferenceTargetCount) missing.push('compiler-type-reference-target-count');
+  for (const item of RequiredFields) if (targets.some((target) => fieldMissing(target?.[item.key]))) missing.push(item.signal);
+  return uniqueStrings(missing);
+}
+
+function typeReferenceTargetCheckerEvidence(value, counts) {
+  if (!counts.typeReferenceTargetCount) return {};
+  const targets = typeReferenceTargets(value);
+  return compactRecord({
+    typeReferenceTargetCount: counts.typeReferenceTargetCount,
+    typeReferenceTargets: targets,
+    ...Object.fromEntries(RequiredFields.map((item) => [
+      `typeReferenceTarget${item.evidenceSuffix}`,
+      targets.map((target) => target[item.key]).filter((fieldValue) => fieldValue !== undefined && fieldValue !== null)
+    ]))
+  });
+}
+
+function typeReferenceTargetCheckerInvariant(counts) {
+  return counts.typeReferenceTargetCount > 0
+    ? 'type reference targets resolve to compiler symbols, declaration spans, and declaration source hashes'
+    : undefined;
+}
+
+function typeReferenceTargetProofLevel(counts) {
+  return counts.typeReferenceTargetCount > 0 ? 'type-reference-target-set' : undefined;
+}
+
+function typeReferenceTargetProofKind(counts) {
+  return counts.typeReferenceTargetCount > 0 ? TypeReferenceTargetProofKind : undefined;
+}
+
+function canonicalTypeReferenceTarget(target) {
+  return compactRecord({
+    kind: target.kind,
+    typeReferenceName: target.typeReferenceName,
+    targetSymbolName: target.targetSymbolName,
+    targetFullyQualifiedName: target.targetFullyQualifiedName,
+    targetDeclarationSourcePath: target.targetDeclarationSourcePath,
+    targetDeclarationSpan: target.targetDeclarationSpan,
+    targetDeclarationTextHash: target.targetDeclarationTextHash,
+    targetSymbolIdentityHash: target.targetSymbolIdentityHash,
+    typeReferenceTargetProofHash: target.typeReferenceTargetProofHash
+  });
+}
+
+function typeReferenceTargets(value) { return arrayValue(value.typeReferenceTargets); }
+function field(key, evidenceSuffix, signal) { return { key, evidenceSuffix, signal }; }
+function fieldMissing(value) {
+  if (Array.isArray(value)) return !value.length || value.some((item) => item === undefined || item === null);
+  return value === undefined || value === null;
+}
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  TypeReferenceTargetProofKind,
+  missingTypeReferenceTargetSignals,
+  typeReferenceTargetCheckerEvidence,
+  typeReferenceTargetCheckerInvariant,
+  typeReferenceTargetProofKind,
+  typeReferenceTargetProofLevel,
+  typeReferenceTargetRequiredSignals,
+  typeReferenceTargetSetHash
+};

package/dist/internal/index-impl/projectSymbolGraphCssModuleRecords.js

@@ -0,0 +1,264 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import {
+  compactRecord,
+  cssModuleSpecifierPath,
+  groupBy,
+  semanticSpanForHash,
+  sourceSpanForRange
+} from './projectSymbolGraphCssModuleUtils.js';
+
+function cssModuleImportBindingRecord(edge, index, documentsById, cssSourcesByPath) {
+  const cssSourcePath = edge.resolvedModulePath ?? cssModuleSpecifierPath(edge.moduleSpecifier);
+  const document = documentsById.get(edge.targetDocumentId);
+  const cssSource = cssSourcesByPath.get(cssSourcePath);
+  const cssModuleEvidence = cssSource?.cssModuleEvidence;
+  const cssModuleExportNames = cssModuleEvidenceExportNames(cssModuleEvidence);
+  const cssModuleHash = cssModuleEvidence?.moduleHash ?? hashSemanticValue({
+    kind: 'frontier.lang.cssModuleUnprovedSource.v1',
+    sourcePath: cssSourcePath,
+    sourceHash: document?.sourceHash ?? cssSource?.sourceHash
+  });
+  const signatureHash = hashSemanticValue({
+    kind: 'frontier.lang.cssModuleImportBinding.v1',
+    sourcePath: edge.sourcePath,
+    moduleSpecifier: edge.moduleSpecifier,
+    resolvedModulePath: edge.resolvedModulePath,
+    importKind: edge.importKind,
+    importedName: edge.importedName,
+    localName: edge.localName,
+    cssModuleSourcePath: cssSourcePath,
+    cssModuleSourceHash: document?.sourceHash ?? cssSource?.sourceHash,
+    cssModuleHash
+  });
+  return compactRecord({
+    id: `css_module_import_${idFragment(edge.id ?? `${edge.sourcePath}_${index}`)}`,
+    kind: 'css-module-import-binding',
+    sourcePath: edge.sourcePath,
+    sourceHash: edge.sourceHash,
+    sourceSpan: edge.sourceSpan,
+    importEdgeId: edge.id,
+    moduleSpecifier: edge.moduleSpecifier,
+    resolvedModulePath: edge.resolvedModulePath,
+    targetDocumentId: edge.targetDocumentId,
+    importKind: edge.importKind,
+    importedName: edge.importedName,
+    localName: edge.localName,
+    cssModuleSourcePath: cssSourcePath,
+    cssModuleSourceHash: document?.sourceHash ?? cssSource?.sourceHash,
+    cssModuleHash,
+    cssModuleEvidenceStatus: cssModuleEvidence ? 'supplied' : 'unproved',
+    cssModuleExportNames: cssModuleExportNames.length ? cssModuleExportNames : undefined,
+    cssModuleExportNamesHash: cssModuleExportNames.length ? hashSemanticValue(cssModuleExportNames) : undefined,
+    generatedClassNameMapHash: cssModuleEvidence?.generatedClassNameMapHash ?? cssModuleGeneratedClassNameMapHash(cssModuleEvidence),
+    jsTsUseSiteGraphHash: cssModuleEvidence?.jsTsUseSiteGraphHash,
+    cssModuleCompositionGraphHash: cssModuleEvidence?.cssModuleCompositionGraphHash,
+    icssGraphHash: cssModuleEvidence?.icssGraphHash,
+    bundlerTransformHash: cssSource?.bundlerTransformHash,
+    sourceMapProofHash: cssSource?.sourceMapProofHash,
+    signatureHash
+  });
+}
+
+function cssModuleUseSiteRecord(binding, input) {
+  const signatureHash = hashSemanticValue({
+    kind: 'frontier.lang.cssModuleUseSite.v1',
+    binding: binding.signatureHash,
+    useSiteKind: input.useSiteKind,
+    accessKind: input.accessKind,
+    exportName: input.exportName,
+    expressionText: input.expressionText,
+    sourceSpan: semanticSpanForHash(input.sourceSpan)
+  });
+  return compactRecord({
+    id: `css_module_use_${idFragment(binding.id)}_${idFragment(signatureHash)}`,
+    kind: 'css-module-use-site',
+    cssModuleImportBindingId: binding.id,
+    importEdgeId: binding.importEdgeId,
+    cssModuleSourcePath: binding.cssModuleSourcePath,
+    cssModuleHash: binding.cssModuleHash,
+    exportName: input.exportName,
+    cssModuleExportHash: cssModuleExportHash(binding, input.exportName),
+    useSiteKind: input.useSiteKind,
+    jsSourcePath: input.sourcePath,
+    jsSourceHash: input.sourceHash,
+    sourceSpan: input.sourceSpan,
+    accessKind: input.accessKind,
+    receiverLocalName: input.receiverLocalName,
+    localReferenceName: input.localReferenceName,
+    expressionText: input.expressionText,
+    jsxPropRecordId: input.jsxPropRecordId,
+    scopeReferenceRecordId: input.scopeReferenceRecordId,
+    conditionalRuntimePresence: input.conditionalRuntimePresence,
+    signatureHash
+  });
+}
+
+function cssModuleAccessBlocker(binding, sourceText, start, end, reasonCode, expressionText, extra = {}) {
+  return cssModuleBindingBlocker(binding, {
+    sourceSpan: sourceSpanForRange(sourceText, binding.sourcePath, binding.sourceHash, start, end),
+    expressionText,
+    reasonCode,
+    ...extra
+  });
+}
+
+function cssModulePropBlocker(binding, prop, reasonCode) {
+  return cssModuleBindingBlocker(binding, {
+    sourcePath: prop.sourcePath,
+    sourceHash: prop.sourceHash,
+    sourceSpan: prop.sourceSpan,
+    expressionText: prop.propValueExpressionText ?? prop.propValueText ?? prop.propValueDynamicText,
+    reasonCode,
+    jsxPropRecordId: prop.id
+  });
+}
+
+function cssModuleBindingBlocker(binding, input = {}) {
+  const sourcePath = input.sourcePath ?? binding.sourcePath;
+  const sourceHash = input.sourceHash ?? binding.sourceHash;
+  const reasonCode = input.reasonCode ?? 'css-module-import-resolution-unproved';
+  const expressionText = input.expressionText ?? binding.localName ?? binding.moduleSpecifier;
+  const blockerHash = hashSemanticValue({
+    kind: 'frontier.lang.cssModuleUseSiteBlocker.v1',
+    binding: binding.signatureHash,
+    reasonCode,
+    sourcePath,
+    sourceSpan: semanticSpanForHash(input.sourceSpan),
+    expressionText
+  });
+  return compactRecord({
+    id: `css_module_blocker_${idFragment(binding.id)}_${idFragment(blockerHash)}`,
+    kind: 'css-module-use-site-blocker',
+    sourcePath,
+    sourceHash,
+    sourceSpan: input.sourceSpan,
+    moduleSpecifier: binding.moduleSpecifier,
+    localName: binding.localName,
+    cssModuleImportBindingId: binding.id,
+    cssModuleSourcePath: binding.cssModuleSourcePath,
+    expressionText,
+    reasonCode,
+    writeOperation: input.writeOperation,
+    jsxPropRecordId: input.jsxPropRecordId,
+    failClosed: true,
+    semanticEquivalenceClaim: false,
+    signatureHash: blockerHash
+  });
+}
+
+function cssModuleTransformBlockers(binding) {
+  const blockers = [];
+  if (binding.cssModuleEvidenceStatus !== 'supplied') blockers.push(cssModuleBindingBlocker(binding, { reasonCode: 'css-module-import-resolution-unproved' }));
+  if (!binding.generatedClassNameMapHash) blockers.push(cssModuleBindingBlocker(binding, { reasonCode: 'css-module-generated-class-map-unproved' }));
+  if (!binding.bundlerTransformHash) blockers.push(cssModuleBindingBlocker(binding, { reasonCode: 'css-module-bundler-transform-identity-unproved' }));
+  if (!binding.sourceMapProofHash) blockers.push(cssModuleBindingBlocker(binding, { reasonCode: 'css-module-source-map-proof-unproved' }));
+  return blockers;
+}
+
+function cssModuleMissingExportBlockers(bindingsById, useSites) {
+  return useSites
+    .filter((site) => cssModuleExportNameMissing(bindingsById.get(site.cssModuleImportBindingId), site.exportName))
+    .map((site) => cssModuleBindingBlocker(bindingsById.get(site.cssModuleImportBindingId), {
+      sourcePath: site.jsSourcePath,
+      sourceHash: site.jsSourceHash,
+      sourceSpan: site.sourceSpan,
+      expressionText: site.expressionText,
+      reasonCode: 'css-module-export-name-unresolved'
+    }));
+}
+
+function cssModuleExportNameMissing(binding, exportName) {
+  if (!binding || !exportName || !Array.isArray(binding.cssModuleExportNames)) return false;
+  return !binding.cssModuleExportNames.includes(exportName);
+}
+
+function cssModuleUseSiteGraphRecords(importBindings, useSites, blockers) {
+  return [...groupBy(importBindings, (binding) => binding.cssModuleSourcePath).values()].map((bindings) => {
+    const cssModuleSourcePath = bindings[0]?.cssModuleSourcePath;
+    const bindingIds = new Set(bindings.map((binding) => binding.id));
+    const graphUseSites = useSites.filter((site) => bindingIds.has(site.cssModuleImportBindingId));
+    const graphBlockers = blockers.filter((blocker) => bindingIds.has(blocker.cssModuleImportBindingId));
+    return cssModuleUseSiteGraphRecord(cssModuleSourcePath, bindings, graphUseSites, graphBlockers);
+  });
+}
+
+function cssModuleUseSiteGraphRecord(cssModuleSourcePath, bindings, graphUseSites, graphBlockers) {
+  const graphHash = hashSemanticValue({
+    kind: 'frontier.lang.cssModuleUseSiteGraph.v1',
+    cssModuleSourcePath,
+    bindings: bindings.map((binding) => binding.signatureHash).sort(),
+    useSites: graphUseSites.map((site) => site.signatureHash).sort(),
+    blockers: graphBlockers.map((blocker) => blocker.signatureHash).sort()
+  });
+  return compactRecord({
+    kind: 'frontier.lang.cssModuleUseSiteGraph',
+    version: 1,
+    cssModuleSourcePath,
+    cssModuleHash: bindings[0]?.cssModuleHash,
+    cssModuleSourceHash: bindings[0]?.cssModuleSourceHash,
+    importBindingIds: bindings.map((binding) => binding.id),
+    useSiteIds: graphUseSites.map((site) => site.id),
+    blockerIds: graphBlockers.map((blocker) => blocker.id),
+    importBindingCount: bindings.length,
+    useSiteCount: graphUseSites.length,
+    blockerCount: graphBlockers.length,
+    generatedClassNameMapHash: bindings.find((binding) => binding.generatedClassNameMapHash)?.generatedClassNameMapHash,
+    cssModuleExportNamesHash: bindings.find((binding) => binding.cssModuleExportNamesHash)?.cssModuleExportNamesHash,
+    bundlerTransformHash: bindings.find((binding) => binding.bundlerTransformHash)?.bundlerTransformHash,
+    sourceMapProofHash: bindings.find((binding) => binding.sourceMapProofHash)?.sourceMapProofHash,
+    status: graphBlockers.length ? 'blocked' : 'ready',
+    graphHash,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function cssModuleExportHash(binding, exportName) {
+  if (!exportName || !Array.isArray(binding.cssModuleExportNames) || !binding.cssModuleExportNames.includes(exportName)) return undefined;
+  return hashSemanticValue({ kind: 'frontier.lang.cssModuleExport.v1', cssModuleHash: binding.cssModuleHash, exportName });
+}
+
+function cssModuleEvidenceExportNames(evidence) {
+  return uniqueSortedStrings([
+    ...arrayValue(evidence?.exportNames),
+    ...arrayValue(evidence?.localClassNames),
+    ...arrayValue(evidence?.classNames),
+    ...objectKeys(evidence?.exports),
+    ...objectKeys(evidence?.generatedClassNameMap),
+    ...objectKeys(evidence?.classMap)
+  ]);
+}
+
+function cssModuleGeneratedClassNameMapHash(evidence) {
+  const map = objectValue(evidence?.generatedClassNameMap) ?? objectValue(evidence?.classMap) ?? objectValue(evidence?.exports);
+  return map ? hashSemanticValue({ kind: 'frontier.lang.cssModuleGeneratedClassNameMap.v1', map }) : undefined;
+}
+
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function objectKeys(value) {
+  const object = objectValue(value);
+  return object ? Object.keys(object) : [];
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+
+function uniqueSortedStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))].sort();
+}
+
+export {
+  cssModuleAccessBlocker,
+  cssModuleBindingBlocker,
+  cssModuleImportBindingRecord,
+  cssModuleMissingExportBlockers,
+  cssModulePropBlocker,
+  cssModuleTransformBlockers,
+  cssModuleUseSiteGraphRecords,
+  cssModuleUseSiteRecord
+};

package/dist/internal/index-impl/projectSymbolGraphCssModuleScanners.js

@@ -0,0 +1,242 @@
+import { readStaticMemberLiteral } from './staticMemberLiteral.js';
+import {
+  bindingsForSourcePath,
+  escapeRegExp,
+  isIdentifierChar,
+  localKey,
+  sourceSpanForRange
+} from './projectSymbolGraphCssModuleUtils.js';
+import {
+  cssModuleAccessBlocker,
+  cssModulePropBlocker,
+  cssModuleUseSiteRecord
+} from './projectSymbolGraphCssModuleRecords.js';
+
+const IdentifierPattern = /^[A-Za-z_$][\w$]*$/;
+
+function cssModuleLexicalUseSites(importBindings, sourceTextsByPath) {
+  const useSites = [];
+  const blockers = [];
+  for (const binding of importBindings) {
+    if (!binding.localName) continue;
+    if (binding.importKind !== 'default' && binding.importKind !== 'namespace') continue;
+    const sourceText = sourceTextsByPath.get(binding.sourcePath);
+    if (typeof sourceText !== 'string') {
+      blockers.push(cssModuleAccessBlocker(binding, '', 0, 0, 'css-module-import-resolution-unproved'));
+      continue;
+    }
+    useSites.push(...cssModuleDestructuringUseSites(binding, sourceText, blockers));
+    useSites.push(...cssModuleMemberUseSites(binding, sourceText, blockers));
+  }
+  return { useSites, blockers };
+}
+
+function cssModuleMemberUseSites(binding, sourceText, blockers) {
+  const useSites = [];
+  for (const occurrence of identifierOccurrences(sourceText, binding.localName)) {
+    const access = cssModuleMemberAccess(sourceText, occurrence.end);
+    if (!access) continue;
+    if (access.status === 'blocked') {
+      blockers.push(cssModuleAccessBlocker(binding, sourceText, occurrence.start, access.end ?? occurrence.end, access.reasonCode, access.expressionText));
+      continue;
+    }
+    const writeOperation = memberWriteOperation(sourceText, occurrence.start, access.end);
+    if (writeOperation) {
+      blockers.push(cssModuleAccessBlocker(binding, sourceText, occurrence.start, access.end, 'css-module-member-write-unsupported', sourceText.slice(occurrence.start, access.end), { writeOperation }));
+      continue;
+    }
+    useSites.push(cssModuleUseSiteRecord(binding, {
+      useSiteKind: 'scope-member-read',
+      accessKind: access.accessKind,
+      exportName: access.memberName,
+      receiverLocalName: binding.localName,
+      expressionText: sourceText.slice(occurrence.start, access.end),
+      sourcePath: binding.sourcePath,
+      sourceHash: binding.sourceHash,
+      sourceSpan: sourceSpanForRange(sourceText, binding.sourcePath, binding.sourceHash, occurrence.start, access.end)
+    }));
+  }
+  return useSites;
+}
+
+function cssModuleDestructuringUseSites(binding, sourceText, blockers) {
+  const useSites = [];
+  const pattern = new RegExp(`\\b(?:const|let|var)\\s*\\{([\\s\\S]*?)\\}\\s*=\\s*${escapeRegExp(binding.localName)}\\b`, 'g');
+  for (const match of sourceText.matchAll(pattern)) {
+    const body = match[1] ?? '';
+    const bodyStart = match.index + match[0].indexOf(body);
+    for (const part of splitTopLevelComma(body, bodyStart)) {
+      const text = part.text.trim();
+      if (!text) continue;
+      if (text.startsWith('...')) {
+        blockers.push(cssModuleAccessBlocker(binding, sourceText, part.offset, part.offset + part.text.length, 'css-module-destructuring-rest-unsupported', part.text));
+        continue;
+      }
+      const property = destructuringProperty(text);
+      if (!property?.exportName) continue;
+      useSites.push(cssModuleUseSiteRecord(binding, {
+        useSiteKind: 'destructured-binding',
+        accessKind: 'destructure',
+        exportName: property.exportName,
+        receiverLocalName: binding.localName,
+        localReferenceName: property.localName,
+        expressionText: text,
+        sourcePath: binding.sourcePath,
+        sourceHash: binding.sourceHash,
+        sourceSpan: sourceSpanForRange(sourceText, binding.sourcePath, binding.sourceHash, part.offset, part.offset + part.text.length)
+      }));
+    }
+  }
+  return useSites;
+}
+
+function cssModuleJsxUseSites(bindingsByLocal, jsxPropRecords) {
+  const useSites = [];
+  const blockers = [];
+  for (const prop of jsxPropRecords ?? []) {
+    const root = prop.propValueReferenceRoot;
+    const sourceBindings = root ? bindingsByLocal.get(localKey(prop.sourcePath, root)) ?? [] : [];
+    useSites.push(...cssModuleJsxStaticUseSites(sourceBindings, prop));
+    const classNameBindings = bindingsForSourcePath(bindingsByLocal, prop.sourcePath);
+    if (prop.propName !== 'className' || !classNameBindings.length) continue;
+    blockers.push(...cssModuleJsxBlockers(classNameBindings, prop));
+  }
+  return { useSites, blockers };
+}
+
+function cssModuleJsxStaticUseSites(sourceBindings, prop) {
+  if (prop.propName !== 'className' || prop.propValueKind !== 'reference') return [];
+  const referencePath = prop.propValueReferencePath ?? [];
+  if (referencePath.length < 2) return [];
+  return sourceBindings.map((binding) => cssModuleUseSiteRecord(binding, {
+    useSiteKind: 'jsx-className',
+    accessKind: 'dot',
+    exportName: referencePath[1],
+    receiverLocalName: referencePath[0],
+    expressionText: prop.propValueExpressionText,
+    sourcePath: prop.sourcePath,
+    sourceHash: prop.sourceHash,
+    sourceSpan: prop.sourceSpan,
+    jsxPropRecordId: prop.id
+  }));
+}
+
+function cssModuleJsxBlockers(classNameBindings, prop) {
+  if (prop.propValueKind === 'string') {
+    return classNameBindings.map((binding) => cssModulePropBlocker(binding, prop, 'css-module-string-literal-classname-unproved'));
+  }
+  if (!prop.propValueDynamicBlockerReasonCode) return [];
+  const expressionText = prop.propValueExpressionText ?? prop.propValueDynamicText ?? '';
+  return classNameBindings
+    .filter((binding) => expressionText.includes(binding.localName))
+    .map((binding) => cssModulePropBlocker(binding, prop, jsxDynamicReason(prop.propValueDynamicBlockerReasonCode)));
+}
+
+function cssModuleMemberAccess(sourceText, receiverEnd) {
+  let index = receiverEnd;
+  while (index < sourceText.length && /\s/.test(sourceText[index])) index += 1;
+  if (sourceText[index] === '?' && sourceText[index + 1] === '.') index += 2;
+  else if (sourceText[index] === '.') index += 1;
+  else if (sourceText[index] === '[') return cssModuleComputedAccess(sourceText, index);
+  else return undefined;
+  while (index < sourceText.length && /\s/.test(sourceText[index])) index += 1;
+  const match = /^[A-Za-z_$][\w$]*/.exec(sourceText.slice(index));
+  return match ? { accessKind: 'dot', memberName: match[0], end: index + match[0].length } : undefined;
+}
+
+function cssModuleComputedAccess(sourceText, open) {
+  const close = findMatchingBracket(sourceText, open);
+  if (close === -1) return { status: 'blocked', reasonCode: 'css-module-dynamic-member-access-unproved', end: open + 1 };
+  let index = open + 1;
+  while (index < close && /\s/.test(sourceText[index])) index += 1;
+  const literal = readStaticMemberLiteral(sourceText, index, close);
+  if (!literal || !IdentifierPattern.test(literal.value)) {
+    return { status: 'blocked', reasonCode: 'css-module-dynamic-member-access-unproved', end: close + 1, expressionText: sourceText.slice(open, close + 1) };
+  }
+  return { accessKind: literal.literalKind === 'static-template-literal' ? 'static-template' : 'static-bracket', memberName: literal.value, end: close + 1 };
+}
+
+function memberWriteOperation(sourceText, start, end) {
+  if (hasPrefixUpdateOperator(sourceText, start)) return 'update';
+  let index = end;
+  while (index < sourceText.length && /\s/.test(sourceText[index])) index += 1;
+  if (sourceText.slice(index, index + 2) === '++' || sourceText.slice(index, index + 2) === '--') return 'update';
+  return assignmentOperatorAt(sourceText, index) ? 'assignment' : undefined;
+}
+
+function assignmentOperatorAt(code, index) {
+  for (const operator of ['>>>=', '**=', '<<=', '>>=', '&&=', '||=', '??=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '=']) {
+    if (!code.startsWith(operator, index)) continue;
+    if (operator === '=' && (code[index + 1] === '=' || code[index + 1] === '>')) return undefined;
+    return operator;
+  }
+  return undefined;
+}
+
+function hasPrefixUpdateOperator(code, tokenStart) {
+  let index = tokenStart - 1;
+  while (index >= 0 && /\s/.test(code[index])) index -= 1;
+  const operator = code.slice(index - 1, index + 1);
+  if (operator !== '++' && operator !== '--') return false;
+  let before = index - 2;
+  while (before >= 0 && /\s/.test(code[before])) before -= 1;
+  return before < 0 || !/[A-Za-z0-9_$)\]]/.test(code[before]);
+}
+
+function findMatchingBracket(sourceText, open) {
+  let depth = 0;
+  for (let index = open; index < sourceText.length; index += 1) {
+    if (sourceText[index] === '[') depth += 1;
+    else if (sourceText[index] === ']' && --depth === 0) return index;
+  }
+  return -1;
+}
+
+function destructuringProperty(text) {
+  const value = String(text ?? '').trim();
+  const [rawName, rawLocal] = value.split(':').map((part) => part.trim());
+  const exportName = rawName?.match(/^([A-Za-z_$][\w$]*)$/)?.[1];
+  const localName = (rawLocal ?? rawName)?.match(/^([A-Za-z_$][\w$]*)$/)?.[1];
+  return exportName ? { exportName, localName } : undefined;
+}
+
+function splitTopLevelComma(text, baseOffset) {
+  const parts = [];
+  let start = 0;
+  let brace = 0, bracket = 0, paren = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '{') brace += 1;
+    else if (char === '}') brace = Math.max(0, brace - 1);
+    else if (char === '[') bracket += 1;
+    else if (char === ']') bracket = Math.max(0, bracket - 1);
+    else if (char === '(') paren += 1;
+    else if (char === ')') paren = Math.max(0, paren - 1);
+    if (char === ',' && brace === 0 && bracket === 0 && paren === 0) {
+      parts.push({ text: text.slice(start, index), offset: baseOffset + start });
+      start = index + 1;
+    }
+  }
+  parts.push({ text: text.slice(start), offset: baseOffset + start });
+  return parts;
+}
+
+function identifierOccurrences(sourceText, name) {
+  const result = [];
+  const pattern = new RegExp(`\\b${escapeRegExp(name)}\\b`, 'g');
+  for (const match of sourceText.matchAll(pattern)) {
+    const start = match.index;
+    const end = start + name.length;
+    if (isIdentifierChar(sourceText[start - 1]) || isIdentifierChar(sourceText[end])) continue;
+    result.push({ start, end });
+  }
+  return result;
+}
+
+function jsxDynamicReason(reasonCode) {
+  if (reasonCode.includes('call')) return 'css-module-helper-call-unproved';
+  if (reasonCode.includes('computed')) return 'css-module-dynamic-member-access-unproved';
+  return 'css-module-helper-dynamic-argument-unsupported';
+}
+
+export { cssModuleJsxUseSites, cssModuleLexicalUseSites };