@reckona/mreact-compiler 0.0.96 → 0.0.98

package/src/oxc-component-detection.ts

@@ -34,6 +34,44 @@ export function collectOxcPlainComponentNames(program: unknown): string[] {
   });
 }
 
+export function collectOxcLocalJsxReturnFunctionNames(program: unknown): Set<string> {
+  const names = new Set<string>();
+
+  for (const statement of readArray(readObject(program).body)) {
+    const object = readObject(statement);
+
+    if (object.type === "FunctionDeclaration" && hasOxcFunctionLikeJsxReturn(object)) {
+      const id = readObject(object.id);
+      if (typeof id.name === "string") {
+        names.add(id.name);
+      }
+      continue;
+    }
+
+    if (object.type !== "VariableDeclaration") {
+      continue;
+    }
+
+    for (const declarator of readArray(object.declarations)) {
+      const declaratorObject = readObject(declarator);
+      const id = readObject(declaratorObject.id);
+      const initializer = unwrapOxcComponentFunctionLikeInitializer(
+        readObject(declaratorObject.init),
+      );
+
+      if (
+        typeof id.name === "string" &&
+        initializer !== undefined &&
+        hasOxcFunctionLikeJsxReturn(initializer)
+      ) {
+        names.add(id.name);
+      }
+    }
+  }
+
+  return names;
+}
+
 export function collectOxcExportedComponents(program: unknown): string[] {
   const body = readArray(readObject(program).body);
   const components: string[] = [];
@@ -133,8 +171,15 @@ export function isOxcExportedJsxComponent(statement: unknown): boolean {
   );
 }
 
-export function isOxcJsxComponentStatement(statement: unknown): boolean {
-  return isOxcExportedJsxComponent(statement) || readOxcPlainComponent(statement) !== undefined;
+export function isOxcJsxComponentStatement(
+  statement: unknown,
+  localJsxReturnFunctionNames: ReadonlySet<string> = new Set(),
+): boolean {
+  return (
+    isOxcExportedJsxComponent(statement) ||
+    isOxcExportedFunctionReturningLocalJsxHelper(statement, localJsxReturnFunctionNames) ||
+    readOxcPlainComponent(statement) !== undefined
+  );
 }
 
 export function isOxcExportedFunctionLike(statement: unknown): boolean {
@@ -159,6 +204,7 @@ export function isOxcExportedFunctionLike(statement: unknown): boolean {
 export function isOxcUnsupportedExportedFunction(
   statement: unknown,
   options?: AnalyzeModuleOptions,
+  localJsxReturnFunctionNames: ReadonlySet<string> = new Set(),
 ): boolean {
   if (options?.compatReactNodeReturn === true) {
     return false;
@@ -178,10 +224,29 @@ export function isOxcUnsupportedExportedFunction(
     typeof id.name === "string" &&
     /^[A-Z]/.test(id.name) &&
     !hasComponentReturn(declaration.body) &&
+    !hasLocalJsxHelperCallReturn(declaration.body, localJsxReturnFunctionNames) &&
     !hasOnlyNullReturns(declaration.body)
   );
 }
 
+function isOxcExportedFunctionReturningLocalJsxHelper(
+  statement: unknown,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  const object = readObject(statement);
+
+  if (object.type !== "ExportNamedDeclaration") {
+    return false;
+  }
+
+  const declaration = readObject(object.declaration);
+
+  return (
+    declaration.type === "FunctionDeclaration" &&
+    hasLocalJsxHelperCallReturn(declaration.body, localJsxReturnFunctionNames)
+  );
+}
+
 export function readOxcVariableComponentDeclaration(
   declaration: Record<string, unknown>,
 ): { name: string; initializer: Record<string, unknown> } | undefined {
@@ -305,6 +370,45 @@ export function hasComponentCallReturn(body: unknown): boolean {
   });
 }
 
+export function hasLocalJsxHelperCallReturn(
+  body: unknown,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  if (localJsxReturnFunctionNames.size === 0) {
+    return false;
+  }
+
+  return readArray(readObject(body).body).some((statement) => {
+    const object = readObject(statement);
+
+    if (object.type === "ReturnStatement") {
+      return isOxcLocalJsxHelperCallExpression(
+        unwrapOxcParentheses(readObject(object.argument)),
+        localJsxReturnFunctionNames,
+      );
+    }
+
+    return hasNestedLocalJsxHelperCallReturn(object, localJsxReturnFunctionNames);
+  });
+}
+
+export function isOxcLocalJsxHelperCallExpression(
+  expression: Record<string, unknown>,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  if (expression.type !== "CallExpression") {
+    return false;
+  }
+
+  const callee = unwrapOxcParentheses(readObject(expression.callee));
+
+  return (
+    callee.type === "Identifier" &&
+    typeof callee.name === "string" &&
+    localJsxReturnFunctionNames.has(callee.name)
+  );
+}
+
 function hasNestedJsxReturn(statement: Record<string, unknown>): boolean {
   if (statement.type === "SwitchStatement") {
     return readArray(statement.cases).some((switchCase) =>
@@ -359,6 +463,45 @@ function hasNestedComponentCallReturn(statement: Record<string, unknown>): boole
   return false;
 }
 
+function hasNestedLocalJsxHelperCallReturn(
+  statement: Record<string, unknown>,
+  localJsxReturnFunctionNames: ReadonlySet<string>,
+): boolean {
+  if (statement.type === "SwitchStatement") {
+    return readArray(statement.cases).some((switchCase) =>
+      readArray(readObject(switchCase).consequent).some((child) => {
+        const object = readObject(child);
+        return (
+          object.type === "ReturnStatement" &&
+          isOxcLocalJsxHelperCallExpression(
+            unwrapOxcParentheses(readObject(object.argument)),
+            localJsxReturnFunctionNames,
+          )
+        );
+      }),
+    );
+  }
+
+  if (statement.type === "IfStatement") {
+    return (
+      hasLocalJsxHelperCallReturn(
+        { body: [statement.consequent] },
+        localJsxReturnFunctionNames,
+      ) ||
+      hasLocalJsxHelperCallReturn(
+        { body: [statement.alternate] },
+        localJsxReturnFunctionNames,
+      )
+    );
+  }
+
+  if (statement.type === "BlockStatement") {
+    return hasLocalJsxHelperCallReturn(statement, localJsxReturnFunctionNames);
+  }
+
+  return false;
+}
+
 function collectReturnArguments(statement: Record<string, unknown>): Record<string, unknown>[] {
   if (statement.type === "ReturnStatement") {
     return [readObject(statement.argument)];

package/src/oxc-component-props.ts

@@ -16,6 +16,7 @@ import type { Diagnostic } from "./types.js";
 export type AnalyzeOxcJsxNodeCallback = (
   node: Record<string, unknown>,
   bodyStatementJsx?: OxcBodyStatementJsxMode,
+  shadowNames?: readonly string[],
 ) => JsxNodeIr;
 
 export function analyzeOxcComponentProp(
@@ -159,7 +160,7 @@ export function analyzeOxcArrowJsxRenderer(
   if (body.type === "JSXElement" || body.type === "JSXFragment") {
     return {
       valueName,
-      children: [analyzeJsxNode(body, bodyStatementJsx)],
+      children: [analyzeJsxNode(body, bodyStatementJsx, [valueName])],
     };
   }
 

package/src/oxc-component-references.ts

@@ -1,13 +1,20 @@
 import type { ClientReferenceIr, JsxNodeIr } from "./ir.js";
 import { readArray, readObject } from "./oxc-node-utils.js";
 
-const routerEntryCompatRuntimeExports = new Set(["Link"]);
-const routerLinkCompatRuntimeExports = new Set(["Link"]);
+const routerEntryCompatRuntimeExports = new Set<string>();
+const routerLinkCompatRuntimeExports = new Set<string>();
+const unknownCompatReference: ClientReferenceIr = { moduleId: "", exportName: "default" };
 
 interface ClientReferenceAliasState {
+  allowAmbiguousAliases: boolean;
   references: Map<string, ClientReferenceIr>;
   stringConstants: Map<string, string>;
   objectMembers: Map<string, Map<string, ClientReferenceIr>>;
+  objectMemberKeys: Map<string, Set<string>>;
+  dynamicObjectMembers: Map<string, ClientReferenceIr[]>;
+  dynamicObjectNestedMembers: Map<string, Map<string, ClientReferenceIr[]>>;
+  globModuleMaps: Set<string>;
+  objectEntryValueBindings: Map<string, string>;
 }
 
 export function collectOxcClientBoundaryImportComponents(
@@ -117,6 +124,7 @@ export function collectOxcCompatRuntimeImportComponents(
     }
   }
 
+  collectOxcClientReferenceAliases(program, names, { allowAmbiguousAliases: true });
   return names;
 }
 
@@ -321,11 +329,18 @@ function readOxcClassComponentName(
 function collectOxcClientReferenceAliases(
   node: unknown,
   references: Map<string, ClientReferenceIr>,
+  options: { allowAmbiguousAliases?: boolean } = {},
 ): void {
   const state: ClientReferenceAliasState = {
+    allowAmbiguousAliases: options.allowAmbiguousAliases === true,
     references,
     stringConstants: new Map(),
     objectMembers: new Map(),
+    objectMemberKeys: new Map(),
+    dynamicObjectMembers: new Map(),
+    dynamicObjectNestedMembers: new Map(),
+    globModuleMaps: new Set(),
+    objectEntryValueBindings: new Map(),
   };
 
   collectOxcClientReferenceAliasesFromNode(node, state);
@@ -371,6 +386,11 @@ function collectOxcClientReferenceAliasesFromNode(
     collectOxcObjectAssignClientReferenceAliases(object, state);
   }
 
+  if (object.type === "ForOfStatement") {
+    collectOxcForOfClientReferenceAliases(object, state);
+    return;
+  }
+
   for (const [key, value] of Object.entries(object)) {
     if (key === "type" || key === "start" || key === "end" || key === "loc") {
       continue;
@@ -404,6 +424,10 @@ function collectOxcVariableClientReferenceAlias(
     }
   }
 
+  if (isImportMetaGlobEagerCall(init)) {
+    state.globModuleMaps.add(aliasName);
+  }
+
   collectOxcObjectLiteralClientReferenceAliases(aliasName, init, state);
 
   const reference = expressionClientReference(init, state);
@@ -428,7 +452,16 @@ function collectOxcObjectLiteralClientReferenceAliases(
     }
 
     const keyName = propertyName(readOptionalObject(property.key), property.computed === true, state);
-    const reference = expressionClientReference(readOptionalObject(property.value), state);
+    const value = readOptionalObject(property.value);
+    if (keyName !== undefined) {
+      addObjectMemberKey(state, objectName, keyName);
+    }
+
+    if (keyName !== undefined && value?.type === "ObjectExpression") {
+      collectOxcObjectLiteralClientReferenceAliases(`${objectName}.${keyName}`, value, state);
+    }
+
+    const reference = expressionClientReference(value, state);
     if (keyName !== undefined && reference !== undefined) {
       setObjectMemberReference(state, objectName, keyName, reference);
     }
@@ -448,11 +481,50 @@ function collectOxcAssignmentClientReferenceAlias(
     return;
   }
 
-  const objectName = expressionObjectName(readOptionalObject(left.object));
+  const objectName = expressionObjectName(readOptionalObject(left.object), state);
   const memberName = propertyName(readOptionalObject(left.property), left.computed === true, state);
   const reference = expressionClientReference(readOptionalObject(node.right), state);
-  if (objectName !== undefined && memberName !== undefined && reference !== undefined) {
-    setObjectMemberReference(state, objectName, memberName, reference);
+  if (objectName !== undefined && memberName !== undefined) {
+    addObjectMemberKey(state, objectName, memberName);
+    if (reference !== undefined) {
+      setObjectMemberReference(state, objectName, memberName, reference);
+    }
+  }
+
+  if (objectName !== undefined && memberName === undefined) {
+    if (reference !== undefined) {
+      addDynamicObjectMemberReference(state, objectName, reference);
+    }
+
+    collectDynamicObjectNestedMemberReferences(objectName, readOptionalObject(node.right), state);
+  }
+}
+
+function collectOxcForOfClientReferenceAliases(
+  node: Record<string, unknown>,
+  state: ClientReferenceAliasState,
+): void {
+  const sourceName = objectEntriesSourceName(readOptionalObject(node.right), state);
+  const valueName = forOfObjectEntriesValueBindingName(readOptionalObject(node.left));
+
+  if (sourceName === undefined || valueName === undefined) {
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "type" || key === "start" || key === "end" || key === "loc") {
+        continue;
+      }
+
+      collectOxcClientReferenceAliasesFromNode(value, state);
+    }
+    return;
+  }
+
+  const previous = state.objectEntryValueBindings.get(valueName);
+  state.objectEntryValueBindings.set(valueName, sourceName);
+  collectOxcClientReferenceAliasesFromNode(node.body, state);
+  if (previous === undefined) {
+    state.objectEntryValueBindings.delete(valueName);
+  } else {
+    state.objectEntryValueBindings.set(valueName, previous);
   }
 }
 
@@ -465,7 +537,7 @@ function collectOxcObjectAssignClientReferenceAliases(
   }
 
   const args = readArray(node.arguments).map(readOptionalObject);
-  const target = expressionObjectName(args[0]);
+  const target = expressionObjectName(args[0], state);
   if (target === undefined) {
     return;
   }
@@ -488,7 +560,7 @@ function expressionClientReference(
   }
 
   if (node.type === "MemberExpression") {
-    const objectName = expressionObjectName(readOptionalObject(node.object));
+    const objectName = expressionObjectName(readOptionalObject(node.object), state);
     const memberName = propertyName(readOptionalObject(node.property), node.computed === true, state);
     const objectReference =
       objectName === undefined ? undefined : state.references.get(objectName);
@@ -498,10 +570,39 @@ function expressionClientReference(
       if (objectMember !== undefined) {
         return objectMember;
       }
+
+      const dynamicObjectReference = selectClientReference(
+        dynamicObjectMemberReferences(state, objectName),
+        state.allowAmbiguousAliases,
+      );
+      if (dynamicObjectReference !== undefined) {
+        return dynamicObjectReference;
+      }
+
+      const objectEntryReference = objectEntryMemberReference(objectName, memberName, state);
+      if (objectEntryReference !== undefined) {
+        return objectEntryReference;
+      }
     }
 
     if (objectName !== undefined && memberName === undefined) {
-      return uniqueClientReference(Array.from(state.objectMembers.get(objectName)?.values() ?? []));
+      return selectClientReference(
+        [...objectMemberReferences(state, objectName), ...dynamicObjectMemberReferences(state, objectName)],
+        state.allowAmbiguousAliases,
+      );
+    }
+
+    if (objectName === undefined && memberName !== undefined) {
+      const references = [
+        ...expressionObjectNameCandidates(readOptionalObject(node.object), state)
+          .map((candidate) => state.objectMembers.get(candidate)?.get(memberName)),
+        ...expressionDynamicObjectNestedMemberReferences(
+          readOptionalObject(node.object),
+          memberName,
+          state,
+        ),
+      ];
+      return selectClientReference(references, state.allowAmbiguousAliases);
     }
 
     if (objectReference?.exportName === "*" && memberName !== undefined) {
@@ -532,8 +633,74 @@ function expressionClientReference(
   return undefined;
 }
 
-function expressionObjectName(node: Record<string, unknown> | undefined): string | undefined {
-  return node?.type === "Identifier" && typeof node.name === "string" ? node.name : undefined;
+function objectEntryMemberReference(
+  objectName: string,
+  memberName: string,
+  state: ClientReferenceAliasState,
+): ClientReferenceIr | undefined {
+  const sourceName = state.objectEntryValueBindings.get(objectName);
+  if (sourceName === undefined) {
+    return undefined;
+  }
+
+  if (state.allowAmbiguousAliases && state.globModuleMaps.has(sourceName) && memberName === "default") {
+    return unknownCompatReference;
+  }
+
+  const references = Array.from(state.objectMemberKeys.get(sourceName) ?? [])
+    .map((key) => state.objectMembers.get(`${sourceName}.${key}`)?.get(memberName));
+  return selectClientReference(references, state.allowAmbiguousAliases);
+}
+
+function expressionObjectNameCandidates(
+  node: Record<string, unknown> | undefined,
+  state: ClientReferenceAliasState,
+): string[] {
+  const exactName = expressionObjectName(node, state);
+  if (exactName !== undefined) {
+    return [exactName];
+  }
+
+  if (node?.type !== "MemberExpression") {
+    return [];
+  }
+
+  const objectName = expressionObjectName(readOptionalObject(node.object), state);
+  const memberName = propertyName(readOptionalObject(node.property), node.computed === true, state);
+
+  if (objectName !== undefined && memberName === undefined) {
+    return Array.from(state.objectMemberKeys.get(objectName) ?? []).map(
+      (key) => `${objectName}.${key}`,
+    );
+  }
+
+  if (memberName === undefined) {
+    return [];
+  }
+
+  return expressionObjectNameCandidates(readOptionalObject(node.object), state).map(
+    (candidate) => `${candidate}.${memberName}`,
+  );
+}
+
+function expressionObjectName(
+  node: Record<string, unknown> | undefined,
+  state: ClientReferenceAliasState,
+): string | undefined {
+  if (node?.type === "Identifier" && typeof node.name === "string") {
+    return node.name;
+  }
+
+  if (node?.type === "MemberExpression") {
+    const objectName = expressionObjectName(readOptionalObject(node.object), state);
+    const memberName = propertyName(readOptionalObject(node.property), node.computed === true, state);
+
+    return objectName !== undefined && memberName !== undefined
+      ? `${objectName}.${memberName}`
+      : undefined;
+  }
+
+  return undefined;
 }
 
 function propertyName(
@@ -596,6 +763,63 @@ function setObjectMemberReference(
   const members = state.objectMembers.get(objectName) ?? new Map<string, ClientReferenceIr>();
   members.set(memberName, reference);
   state.objectMembers.set(objectName, members);
+  addObjectMemberKey(state, objectName, memberName);
+}
+
+function addDynamicObjectMemberReference(
+  state: ClientReferenceAliasState,
+  objectName: string,
+  reference: ClientReferenceIr,
+): void {
+  const references = state.dynamicObjectMembers.get(objectName) ?? [];
+  references.push(reference);
+  state.dynamicObjectMembers.set(objectName, references);
+}
+
+function collectDynamicObjectNestedMemberReferences(
+  objectName: string,
+  node: Record<string, unknown> | undefined,
+  state: ClientReferenceAliasState,
+): void {
+  if (node?.type !== "ObjectExpression") {
+    return;
+  }
+
+  for (const propertyValue of readArray(node.properties)) {
+    const property = readOptionalObject(propertyValue);
+    if (property?.type !== "Property") {
+      continue;
+    }
+
+    const keyName = propertyName(readOptionalObject(property.key), property.computed === true, state);
+    const reference = expressionClientReference(readOptionalObject(property.value), state);
+    if (keyName !== undefined && reference !== undefined) {
+      addDynamicObjectNestedMemberReference(state, objectName, keyName, reference);
+    }
+  }
+}
+
+function addDynamicObjectNestedMemberReference(
+  state: ClientReferenceAliasState,
+  objectName: string,
+  memberName: string,
+  reference: ClientReferenceIr,
+): void {
+  const members = state.dynamicObjectNestedMembers.get(objectName) ?? new Map<string, ClientReferenceIr[]>();
+  const references = members.get(memberName) ?? [];
+  references.push(reference);
+  members.set(memberName, references);
+  state.dynamicObjectNestedMembers.set(objectName, members);
+}
+
+function addObjectMemberKey(
+  state: ClientReferenceAliasState,
+  objectName: string,
+  memberName: string,
+): void {
+  const keys = state.objectMemberKeys.get(objectName) ?? new Set<string>();
+  keys.add(memberName);
+  state.objectMemberKeys.set(objectName, keys);
 }
 
 function isObjectAssignCall(node: Record<string, unknown>): boolean {
@@ -610,6 +834,56 @@ function isObjectAssignCall(node: Record<string, unknown>): boolean {
     property?.type === "Identifier" && property.name === "assign";
 }
 
+function isObjectEntriesCall(node: Record<string, unknown> | undefined): boolean {
+  const callee = readOptionalObject(node?.callee);
+  if (callee?.type !== "MemberExpression" || callee.computed === true) {
+    return false;
+  }
+
+  const object = readOptionalObject(callee.object);
+  const property = readOptionalObject(callee.property);
+  return object?.type === "Identifier" && object.name === "Object" &&
+    property?.type === "Identifier" && property.name === "entries";
+}
+
+function isImportMetaGlobEagerCall(node: Record<string, unknown> | undefined): boolean {
+  const callee = readOptionalObject(node?.callee);
+  if (node?.type !== "CallExpression" || callee?.type !== "MemberExpression") {
+    return false;
+  }
+
+  const property = readOptionalObject(callee.property);
+  if (callee.computed === true || property?.type !== "Identifier" || property.name !== "glob") {
+    return false;
+  }
+
+  const metaProperty = readOptionalObject(callee.object);
+  const meta = readOptionalObject(metaProperty?.meta);
+  const metaName = meta?.type === "Identifier" ? meta.name : undefined;
+  const propertyName = readOptionalObject(metaProperty?.property);
+  const importMetaPropertyName = propertyName?.type === "Identifier" ? propertyName.name : undefined;
+  if (metaProperty?.type !== "MetaProperty" || metaName !== "import" || importMetaPropertyName !== "meta") {
+    return false;
+  }
+
+  const options = readOptionalObject(readArray(node.arguments)[1]);
+  if (options?.type !== "ObjectExpression") {
+    return false;
+  }
+
+  return readArray(options.properties).some((propertyValue) => {
+    const property = readOptionalObject(propertyValue);
+    const key = readOptionalObject(property?.key);
+    const value = readOptionalObject(property?.value);
+    return property?.type === "Property" &&
+      property.computed !== true &&
+      key?.type === "Identifier" &&
+      key.name === "eager" &&
+      value?.type === "Literal" &&
+      value.value === true;
+  });
+}
+
 function uniqueClientReference(
   values: readonly (ClientReferenceIr | undefined)[],
 ): ClientReferenceIr | undefined {
@@ -631,6 +905,87 @@ function uniqueClientReference(
     : undefined;
 }
 
+function selectClientReference(
+  values: readonly (ClientReferenceIr | undefined)[],
+  allowAmbiguousAliases: boolean,
+): ClientReferenceIr | undefined {
+  if (!allowAmbiguousAliases) {
+    return uniqueClientReference(values);
+  }
+
+  if (values.length === 0 || values.some((value) => value === undefined)) {
+    return undefined;
+  }
+
+  return values[0];
+}
+
+function objectMemberReferences(
+  state: ClientReferenceAliasState,
+  objectName: string,
+): Array<ClientReferenceIr | undefined> {
+  const keys = Array.from(state.objectMemberKeys.get(objectName) ?? []);
+  return keys.map((key) => state.objectMembers.get(objectName)?.get(key));
+}
+
+function dynamicObjectMemberReferences(
+  state: ClientReferenceAliasState,
+  objectName: string,
+): Array<ClientReferenceIr | undefined> {
+  return state.dynamicObjectMembers.get(objectName) ?? [];
+}
+
+function expressionDynamicObjectNestedMemberReferences(
+  node: Record<string, unknown> | undefined,
+  memberName: string,
+  state: ClientReferenceAliasState,
+): Array<ClientReferenceIr | undefined> {
+  if (node?.type !== "MemberExpression") {
+    return [];
+  }
+
+  const objectName = expressionObjectName(readOptionalObject(node.object), state);
+  const property = propertyName(readOptionalObject(node.property), node.computed === true, state);
+  if (objectName === undefined || property !== undefined) {
+    return [];
+  }
+
+  return state.dynamicObjectNestedMembers.get(objectName)?.get(memberName) ?? [];
+}
+
+function objectEntriesSourceName(
+  node: Record<string, unknown> | undefined,
+  state: ClientReferenceAliasState,
+): string | undefined {
+  if (!isObjectEntriesCall(node)) {
+    return undefined;
+  }
+
+  const args = readArray(node?.arguments).map(readOptionalObject);
+  return expressionObjectName(args[0], state);
+}
+
+function forOfObjectEntriesValueBindingName(
+  node: Record<string, unknown> | undefined,
+): string | undefined {
+  const declaration =
+    node?.type === "VariableDeclaration"
+      ? readOptionalObject(readArray(node.declarations)[0])
+      : undefined;
+  const pattern = declaration?.type === "VariableDeclarator"
+    ? readOptionalObject(declaration.id)
+    : node;
+
+  if (pattern?.type !== "ArrayPattern") {
+    return undefined;
+  }
+
+  const valueElement = readOptionalObject(readArray(pattern.elements)[1]);
+  return valueElement?.type === "Identifier" && typeof valueElement.name === "string"
+    ? valueElement.name
+    : undefined;
+}
+
 function uniqueString(values: readonly (string | undefined)[]): string | undefined {
   const unique = new Set(values.filter((value): value is string => value !== undefined));
   return unique.size === 1 ? Array.from(unique)[0] : undefined;