webfuscator 0.9.4

package/src/obfuscator.ts

@@ -0,0 +1,271 @@
+import generate from '@babel/generator'
+import { parse } from '@babel/parser'
+import type { ParserOptions } from '@babel/parser'
+import type { File } from '@babel/types'
+
+import type { ObfuscatorOptions, TransformContext, TransformName } from 'src/options'
+import { dotToBracket } from 'src/preparation/dot-to-bracket'
+import { expandDestructuring } from 'src/preparation/expand-destructuring'
+import { expandTemplateLiterals } from 'src/preparation/expand-template-literals'
+import { rewriteClassFields } from 'src/preparation/rewrite-class-fields'
+import { splitSequenceExpressions } from 'src/preparation/split-sequence-expressions'
+import { splitVariableDeclarations } from 'src/preparation/split-variable-declarations'
+import { stringifyObjectKeys } from 'src/preparation/stringify-object-keys'
+import { wrapSingleStatements } from 'src/preparation/wrap-single-statements'
+import { argumentsToParameters } from 'src/transforms/arguments-to-parameters'
+import { arrowToFunction } from 'src/transforms/arrow-to-function'
+import { collapseSingleUseTemps } from 'src/transforms/collapse-single-use-temps'
+import { constLetToVar } from 'src/transforms/const-let-to-var'
+import { constToLet } from 'src/transforms/const-to-let'
+import { doWhileToWhile } from 'src/transforms/do-while-to-while'
+import { dropConsole } from 'src/transforms/drop-console'
+import { dropDebugger } from 'src/transforms/drop-debugger'
+import { expandBinaryAssignment } from 'src/transforms/expand-binary-assignment'
+import { expandLogicalAssignment } from 'src/transforms/expand-logical-assignment'
+import { extractObjectProperties } from 'src/transforms/extract-object-properties'
+import { foldBuiltinMethods } from 'src/transforms/fold-builtin-methods'
+import { foldConstants } from 'src/transforms/fold-constants'
+import { forToWhile } from 'src/transforms/for-to-while'
+import { functionDeclarationToExpression } from 'src/transforms/function-declaration-to-expression'
+import { inlineFunctions } from 'src/transforms/inline-functions'
+import { logicalToTernary } from 'src/transforms/logical-to-ternary'
+import { mangleProperties } from 'src/transforms/mangle-properties'
+import { nullishCoalescingToTernary } from 'src/transforms/nullish-coalescing-to-ternary'
+import { numbersToStrings } from 'src/transforms/numbers-to-strings'
+import { objectMethodToProperty } from 'src/transforms/object-method-to-property'
+import { optionalChainingToTernary } from 'src/transforms/optional-chaining-to-ternary'
+import { packDeclarationsIntoParameters } from 'src/transforms/pack-declarations-into-parameters'
+import { removeAnonymousFunctionNames } from 'src/transforms/remove-anonymous-function-names'
+import { removeUnreachableCode } from 'src/transforms/remove-unreachable-code'
+import { removeUnusedCode } from 'src/transforms/remove-unused-code'
+import { renameIdentifiers } from 'src/transforms/rename-identifiers'
+import { specialsToStrings } from 'src/transforms/specials-to-strings'
+import { switchToIf } from 'src/transforms/switch-to-if'
+import { ternaryToIf } from 'src/transforms/ternary-to-if'
+import { updateToAssignment } from 'src/transforms/update-to-assignment'
+import { yodifyConditions } from 'src/transforms/yodify-conditions'
+import type { StringGeneratorModeOption } from 'src/utils/string-generator'
+
+const parserOptions: ParserOptions = { sourceType: 'unambiguous' }
+
+const PRESERVED_COMMENT_RE = /^!|@(?:license|preserve)\b|^#\s*source(?:Mapping)?URL=/iu
+
+const DEFAULT_STRING_GENERATOR_MODE: StringGeneratorModeOption = 'mangled'
+const DEFAULT_SEED = 0
+
+// Real inputs settle in a handful of iterations. Hitting this cap signals an
+// algorithmic bug; never raise it as a workaround.
+const FIXED_POINT_ITERATION_CAP = 10
+
+type TransformFn = (ast: File, ctx: TransformContext) => boolean
+type Phase = readonly [name: string, fn: TransformFn]
+type ConfigurablePhase = readonly [name: TransformName, fn: TransformFn]
+
+// Mangling must see quoted access and class fields before preparation erases
+// those shapes. It is opt-in because outside code may use the same properties.
+const BEFORE_PREPARATION: readonly ConfigurablePhase[] = [['mangleProperties', mangleProperties]]
+
+// Shape-normalizing passes. Always run; never exposed in `options.transforms`.
+const PREPARATION: readonly Phase[] = [
+  ['rewriteClassFields', asBoolean(rewriteClassFields)],
+  ['expandDestructuring', asBoolean(expandDestructuring)],
+  ['wrapSingleStatements', asBoolean(wrapSingleStatements)],
+  ['splitSequenceExpressions', asBoolean(splitSequenceExpressions)],
+  ['splitVariableDeclarations', asBoolean(splitVariableDeclarations)],
+  ['expandTemplateLiterals', asBoolean(expandTemplateLiterals)],
+  ['stringifyObjectKeys', asBoolean(stringifyObjectKeys)],
+  ['dotToBracket', asBoolean(dotToBracket)],
+]
+
+// These one-shot passes prepare the fixed point. Lexical declarations become
+// foldable function-scoped bindings, except at script top level where `var`
+// would create a global property. `argumentsToParameters` precedes parameter
+// renaming. Method demotion precedes extraction because any surviving
+// `ObjectMethod` makes extraction refuse the whole literal.
+const PRE_LOOP: readonly ConfigurablePhase[] = [
+  ['dropDebugger', dropDebugger],
+  ['dropConsole', dropConsole],
+  ['constToLet', constToLet],
+  ['constLetToVar', constLetToVar],
+  ['argumentsToParameters', argumentsToParameters],
+  ['objectMethodToProperty', objectMethodToProperty],
+]
+
+// Folds, removals, extraction, and inlining expose work for one another. Stop
+// when a full round makes no change.
+const FIXED_POINT: readonly ConfigurablePhase[] = [
+  ['foldConstants', foldConstants],
+  ['foldBuiltinMethods', foldBuiltinMethods],
+  ['extractObjectProperties', extractObjectProperties],
+  ['inlineFunctions', inlineFunctions],
+  ['removeUnreachableCode', removeUnreachableCode],
+  ['removeUnusedCode', removeUnusedCode],
+  ['removeAnonymousFunctionNames', removeAnonymousFunctionNames],
+  ['collapseSingleUseTemps', collapseSingleUseTemps],
+]
+
+// Lowerings run from producer to consumer. Arrow capture lands before code can
+// move out of an arrow. Function declarations remain available to the inliner
+// until the fixed point ends. Loop passes converge on `while`. Updates become
+// compound assignments before binary assignment expansion. Logical assignment,
+// optional chaining, nullish coalescing, logical expressions, and ternaries then
+// lower in that order.
+const LOWERING: readonly ConfigurablePhase[] = [
+  ['arrowToFunction', arrowToFunction],
+  ['functionDeclarationToExpression', functionDeclarationToExpression],
+  ['switchToIf', switchToIf],
+  ['forToWhile', forToWhile],
+  ['doWhileToWhile', doWhileToWhile],
+  ['updateToAssignment', updateToAssignment],
+  ['expandBinaryAssignment', expandBinaryAssignment],
+  ['expandLogicalAssignment', expandLogicalAssignment],
+  ['optionalChainingToTernary', optionalChainingToTernary],
+  ['nullishCoalescingToTernary', nullishCoalescingToTernary],
+  ['logicalToTernary', logicalToTernary],
+  ['ternaryToIf', ternaryToIf],
+]
+
+// Yodification and folding need raw numeric literals. Special-value lowering
+// comes next, then number lowering also handles the `1` created for `Infinity`.
+const POST_PROCESS: readonly ConfigurablePhase[] = [
+  ['packDeclarationsIntoParameters', packDeclarationsIntoParameters],
+  ['yodifyConditions', yodifyConditions],
+  ['specialsToStrings', specialsToStrings],
+  ['numbersToStrings', numbersToStrings],
+]
+
+// Renaming runs last because later transforms depend on recognizable bindings.
+const RENAME: readonly ConfigurablePhase[] = [['renameIdentifiers', renameIdentifiers]]
+
+/** Parses, transforms, and prints JavaScript without mutating external state. */
+export function obfuscate(code: string, options: ObfuscatorOptions = {}): string {
+  const log = options.verbose ? makeLogger() : null
+  const baseCtx: TransformContext = {
+    seed: options.seed ?? DEFAULT_SEED,
+    stringGeneratorMode: options.stringGeneratorMode ?? DEFAULT_STRING_GENERATOR_MODE,
+  }
+  const ast = run(log, 'parse', () => parse(code, parserOptions))
+
+  for (const [name, fn] of BEFORE_PREPARATION) {
+    if (!isEnabled(name, options)) {
+      continue
+    }
+    run(log, name, () => fn(ast, ctxFor(name, options, baseCtx)))
+  }
+
+  for (const [name, fn] of PREPARATION) {
+    run(log, name, () => fn(ast, baseCtx))
+  }
+
+  for (const [name, fn] of PRE_LOOP) {
+    if (!isEnabled(name, options)) {
+      continue
+    }
+    run(log, name, () => fn(ast, ctxFor(name, options, baseCtx)))
+  }
+
+  runFixedPoint(ast, options, baseCtx, log)
+
+  for (const [name, fn] of LOWERING) {
+    if (!isEnabled(name, options)) {
+      continue
+    }
+    run(log, name, () => fn(ast, ctxFor(name, options, baseCtx)))
+  }
+
+  for (const [name, fn] of POST_PROCESS) {
+    if (!isEnabled(name, options)) {
+      continue
+    }
+    run(log, name, () => fn(ast, ctxFor(name, options, baseCtx)))
+  }
+
+  for (const [name, fn] of RENAME) {
+    if (!isEnabled(name, options)) {
+      continue
+    }
+    run(log, name, () => fn(ast, ctxFor(name, options, baseCtx)))
+  }
+
+  return run(log, 'generate', () => generate(ast, { shouldPrintComment }).code)
+}
+
+function isEnabled(name: TransformName, options: ObfuscatorOptions): boolean {
+  if (name === 'mangleProperties') {
+    return (
+      options.transforms?.mangleProperties !== undefined &&
+      options.transforms.mangleProperties !== false
+    )
+  }
+  return options.transforms?.[name] !== false
+}
+
+// Boolean entries inherit the base. An override replaces its string mode.
+function ctxFor(
+  name: TransformName,
+  options: ObfuscatorOptions,
+  base: TransformContext,
+): TransformContext {
+  const entry = options.transforms?.[name]
+  let context = base
+  if (entry && typeof entry === 'object' && entry.stringGeneratorMode !== undefined) {
+    context = { ...base, stringGeneratorMode: entry.stringGeneratorMode }
+  }
+  if (name === 'mangleProperties' && entry && typeof entry === 'object') {
+    return { ...context, mangleProperties: entry }
+  }
+  return context
+}
+
+function runFixedPoint(
+  ast: File,
+  options: ObfuscatorOptions,
+  ctx: TransformContext,
+  log: Logger | null,
+): void {
+  const enabled = FIXED_POINT.filter(([name]) => isEnabled(name, options))
+  if (enabled.length === 0) {
+    return
+  }
+
+  for (let iter = 0; iter < FIXED_POINT_ITERATION_CAP; iter++) {
+    let any = false
+    for (const [name, fn] of enabled) {
+      if (run(log, name, () => fn(ast, ctx))) {
+        any = true
+      }
+    }
+    if (!any) {
+      return
+    }
+  }
+}
+
+function asBoolean(fn: (ast: File) => unknown): TransformFn {
+  return (ast) => {
+    fn(ast)
+    return false
+  }
+}
+
+function shouldPrintComment(value: string): boolean {
+  return PRESERVED_COMMENT_RE.test(value)
+}
+
+type Logger = <T>(name: string, fn: () => T) => T
+
+function run<T>(log: Logger | null, name: string, fn: () => T): T {
+  return log ? log(name, fn) : fn()
+}
+
+function makeLogger(): Logger {
+  const t0 = performance.now()
+  const stamp = (): string => `[${(performance.now() - t0).toFixed(0).padStart(6)}ms]`
+  return (name, fn) => {
+    console.error(`${stamp()} > ${name}`)
+    const start = performance.now()
+    const result = fn()
+    console.error(`${stamp()} < ${name} (${(performance.now() - start).toFixed(1)}ms)`)
+    return result
+  }
+}

package/src/options.ts

@@ -0,0 +1,114 @@
+import type { StringGeneratorModeOption } from 'src/utils/string-generator'
+
+/**
+ * Exported transform entry points. Preparation passes are always enabled and
+ * do not appear here.
+ */
+export type TransformName =
+  | 'dropConsole'
+  | 'dropDebugger'
+  | 'constToLet'
+  | 'constLetToVar'
+  | 'argumentsToParameters'
+  | 'objectMethodToProperty'
+  | 'foldConstants'
+  | 'foldBuiltinMethods'
+  | 'extractObjectProperties'
+  | 'inlineFunctions'
+  | 'removeUnreachableCode'
+  | 'removeUnusedCode'
+  | 'removeAnonymousFunctionNames'
+  | 'collapseSingleUseTemps'
+  | 'arrowToFunction'
+  | 'functionDeclarationToExpression'
+  | 'switchToIf'
+  | 'forToWhile'
+  | 'doWhileToWhile'
+  | 'updateToAssignment'
+  | 'expandBinaryAssignment'
+  | 'expandLogicalAssignment'
+  | 'optionalChainingToTernary'
+  | 'nullishCoalescingToTernary'
+  | 'logicalToTernary'
+  | 'ternaryToIf'
+  | 'packDeclarationsIntoParameters'
+  | 'yodifyConditions'
+  | 'specialsToStrings'
+  | 'numbersToStrings'
+  | 'mangleProperties'
+  | 'renameIdentifiers'
+
+// An override enables the transform and replaces its string-generator mode.
+type TransformEntry = boolean | { stringGeneratorMode?: StringGeneratorModeOption }
+
+/** Maps a zero-based ordinal to a stable property name. */
+export type PropertyNameGenerator = (index: number) => string
+
+/** Terser-compatible property-mangling options using camel-case names. */
+export interface ManglePropertiesOptions {
+  /** Allow names of JavaScript and DOM builtins to be mangled. Default `false`. */
+  builtins?: boolean
+  /** Reuse and extend mappings across calls or separately transformed files. */
+  cache?: Map<string, string>
+  /** Keep the original name visible as `_$name$suffix_`. Default `false`. */
+  debug?: boolean | string
+  /**
+   * Preserve quoted occurrences. `true` also reserves their names globally;
+   * `'strict'` lets unquoted occurrences of the same name be mangled.
+   */
+  keepQuoted?: boolean | 'strict'
+  /** Custom property-name generator. It takes precedence over `stringGeneratorMode`. */
+  nameGenerator?: PropertyNameGenerator
+  /**
+   * Only names carrying `/*@__MANGLE_PROP__*\/` or `/*#__MANGLE_PROP__*\/` may
+   * be mangled. Default `false`.
+   */
+  onlyAnnotated?: boolean
+  /** Only names already present in `cache` may be mangled. Default `false`. */
+  onlyCache?: boolean
+  /** Only property names matching this expression may be mangled. */
+  regex?: RegExp | string
+  /** Property names that must not be mangled. */
+  reserved?: readonly string[]
+  /** Override the default string-generator mode for property names. */
+  stringGeneratorMode?: StringGeneratorModeOption
+  /** Mangle accesses rooted at undeclared identifiers. Default `false`. */
+  undeclared?: boolean
+}
+
+type SimpleTransform = Exclude<
+  TransformName,
+  'mangleProperties' | 'renameIdentifiers' | 'specialsToStrings'
+>
+
+type TransformsMap = Partial<Record<SimpleTransform, boolean>> & {
+  mangleProperties?: boolean | ManglePropertiesOptions
+  renameIdentifiers?: TransformEntry
+  specialsToStrings?: TransformEntry
+}
+
+export interface ObfuscatorOptions {
+  /** Logs each pipeline step and its elapsed milliseconds to stderr. */
+  verbose?: boolean
+  /**
+   * Per-transform toggles and string-generator overrides. `mangleProperties` is
+   * opt-in because property names can cross the program boundary. Other omitted
+   * transforms default to enabled.
+   */
+  transforms?: TransformsMap
+  /**
+   * Default mode for generated identifiers, labels, and string contents. An
+   * array mixes modes uniformly. Individual transforms may override it through
+   * `transforms.<name>.stringGeneratorMode`. Default `'mangled'`.
+   */
+  stringGeneratorMode?: StringGeneratorModeOption
+  /** Seed for any nondeterministic transform. Same seed, same output. Default `0`. */
+  seed?: number
+}
+
+// Resolved per-call defaults handed to every transform.
+export interface TransformContext {
+  mangleProperties?: ManglePropertiesOptions
+  seed: number
+  stringGeneratorMode: StringGeneratorModeOption
+}

package/src/preparation/dot-to-bracket.ts

@@ -0,0 +1,41 @@
+import traverse from '@babel/traverse'
+import * as t from '@babel/types'
+import type { File } from '@babel/types'
+
+/**
+ * Rewrites `obj.foo` as `obj["foo"]`. Skips already-computed access and
+ * private fields; private-name semantics aren't expressible as a string key.
+ *
+ * @example
+ * // ◀️ before
+ * user.name = obj.foo.bar;
+ * var v = maybe?.value;
+ *
+ * // ▶️ after
+ * user["name"] = obj["foo"]["bar"];
+ * var v = maybe?.["value"];
+ */
+export function dotToBracket(ast: File): void {
+  traverse(ast, visitor as Parameters<typeof traverse>[1])
+}
+
+const visitor = {
+  'MemberExpression|OptionalMemberExpression'(path: {
+    node: t.MemberExpression | t.OptionalMemberExpression
+  }) {
+    convert(path.node)
+  },
+} as const
+
+function convert(node: t.MemberExpression | t.OptionalMemberExpression): void {
+  if (node.computed) {
+    return
+  }
+  if (!t.isIdentifier(node.property)) {
+    return
+  }
+  // Babel 8 narrows members by `computed`, so both fields need widening.
+  const bracketed = node as t.MemberExpression | t.OptionalMemberExpression
+  bracketed.property = t.stringLiteral(node.property.name)
+  bracketed.computed = true
+}

package/src/preparation/expand-destructuring.ts

@@ -0,0 +1,211 @@
+import traverse from '@babel/traverse'
+import type { NodePath, Scope } from '@babel/traverse'
+import * as t from '@babel/types'
+import type { File } from '@babel/types'
+
+import { enclosingScopeHasDirectEval, isInsideWith } from 'src/utils/ast'
+
+type Kind = t.VariableDeclaration['kind']
+
+// Babel 8 omits `AssignmentPattern` from `LVal`, so list these targets directly.
+type BindingTarget = t.Identifier | t.ObjectPattern | t.ArrayPattern | t.AssignmentPattern
+
+/**
+ * Rewrites object destructuring declarations as individual property reads.
+ * Array patterns stay intact because indexed reads cannot reproduce the iterator
+ * protocol.
+ *
+ * The source, computed keys, and getters keep their original evaluation counts.
+ * Defaults compare against `void 0` because `undefined` can be shadowed.
+ *
+ * `with` and direct `eval` can expose synthesized names that Babel cannot see, so
+ * those scopes are skipped. A `RequireObjectCoercible` guard runs before any
+ * computed key, matching ObjectBindingPattern evaluation order.
+ *
+ * @example
+ * // ◀️ before
+ * const { a, b: renamed, c = 3 } = obj;
+ *
+ * // ▶️ after
+ * const _ref = obj;
+ * const a = _ref.a;
+ * const renamed = _ref.b;
+ * const _c = _ref.c;
+ * const c = _c === void 0 ? 3 : _c;
+ */
+export function expandDestructuring(ast: File): void {
+  traverse(ast, visitor)
+}
+
+const visitor = {
+  VariableDeclaration(path: NodePath<t.VariableDeclaration>) {
+    if (typeof path.listKey !== 'string') {
+      return
+    }
+    // Babel cannot prove a generated name hidden from `with` or direct `eval`.
+    if (isInsideWith(path) || enclosingScopeHasDirectEval(path)) {
+      return
+    }
+
+    const { kind } = path.node
+    const replacement: t.Statement[] = []
+    let changed = false
+
+    for (const declarator of path.node.declarations) {
+      const { id, init } = declarator
+
+      if (
+        !init ||
+        !t.isObjectPattern(id) ||
+        containsRestElement(id) ||
+        containsArrayPattern(id) ||
+        containsEmptyObjectPattern(id)
+      ) {
+        replacement.push(t.variableDeclaration(kind, [declarator]))
+        continue
+      }
+
+      let source: t.Expression = init
+      // Snapshot a mutable identifier before reading more than one property.
+      if (t.isIdentifier(source) && topLevelReadCount(id) > 1) {
+        const temp = path.scope.generateUidIdentifier('ref')
+        replacement.push(t.variableDeclaration(kind, [t.variableDeclarator(temp, source)]))
+        source = t.cloneNode(temp)
+      }
+
+      replacement.push(...expandPattern(kind, id, source, path.scope))
+      changed = true
+    }
+
+    if (changed) {
+      path.replaceWithMultiple(replacement)
+    }
+  },
+}
+
+function expandPattern(
+  kind: Kind,
+  target: BindingTarget,
+  source: t.Expression,
+  scope: Scope,
+): t.Statement[] {
+  if (t.isIdentifier(target)) {
+    return [t.variableDeclaration(kind, [t.variableDeclarator(target, source)])]
+  }
+
+  if (t.isAssignmentPattern(target)) {
+    const innerName =
+      t.isIdentifier(target.left) && t.isValidIdentifier(target.left.name)
+        ? scope.generateUid(target.left.name)
+        : scope.generateUid('default')
+    const innerId = t.identifier(innerName)
+    const decls: t.Statement[] = [
+      t.variableDeclaration(kind, [t.variableDeclarator(t.cloneNode(innerId), source)]),
+    ]
+    const defaulted = t.conditionalExpression(
+      // `void 0`, not the shadowable identifier `undefined`.
+      t.binaryExpression(
+        '===',
+        t.cloneNode(innerId),
+        t.unaryExpression('void', t.numericLiteral(0)),
+      ),
+      target.right,
+      t.cloneNode(innerId),
+    )
+    decls.push(...expandPattern(kind, target.left as BindingTarget, defaulted, scope))
+    return decls
+  }
+
+  if (t.isObjectPattern(target)) {
+    const decls: t.Statement[] = []
+    // Snapshot before repeated or nested property evaluation.
+    let src = source
+    if (!t.isIdentifier(src)) {
+      const temp = scope.generateUidIdentifier('ref')
+      decls.push(t.variableDeclaration(kind, [t.variableDeclarator(temp, src)]))
+      src = t.cloneNode(temp)
+    }
+    // `({} = src)` reproduces RequireObjectCoercible before computed keys run.
+    if (hasComputedKey(target)) {
+      decls.push(
+        t.expressionStatement(t.assignmentExpression('=', t.objectPattern([]), t.cloneNode(src))),
+      )
+    }
+    for (const prop of target.properties) {
+      if (t.isRestElement(prop)) {
+        continue
+      }
+      const { key } = prop
+      const useComputed = prop.computed || !t.isIdentifier(key)
+      const access = t.memberExpression(
+        t.cloneNode(src),
+        t.cloneNode(key) as t.Expression,
+        useComputed,
+      )
+      decls.push(...expandPattern(kind, prop.value as BindingTarget, access, scope))
+    }
+    return decls
+  }
+
+  return [t.variableDeclaration(kind, [t.variableDeclarator(target, source)])]
+}
+
+function topLevelReadCount(pattern: t.ObjectPattern): number {
+  return pattern.properties.filter((prop) => !t.isRestElement(prop)).length
+}
+
+function hasComputedKey(pattern: t.ObjectPattern): boolean {
+  return pattern.properties.some((prop) => t.isObjectProperty(prop) && prop.computed)
+}
+
+// An empty pattern still throws on nullish input, with no property read to carry
+// that check after expansion.
+function containsEmptyObjectPattern(pattern: BindingTarget): boolean {
+  if (t.isObjectPattern(pattern)) {
+    return (
+      pattern.properties.length === 0 ||
+      pattern.properties.some(
+        (prop) =>
+          t.isObjectProperty(prop) && containsEmptyObjectPattern(prop.value as BindingTarget),
+      )
+    )
+  }
+  if (t.isAssignmentPattern(pattern)) {
+    return containsEmptyObjectPattern(pattern.left as BindingTarget)
+  }
+  return false
+}
+
+function containsArrayPattern(pattern: BindingTarget): boolean {
+  if (t.isArrayPattern(pattern)) {
+    return true
+  }
+  if (t.isObjectPattern(pattern)) {
+    return pattern.properties.some(
+      (prop) => t.isObjectProperty(prop) && containsArrayPattern(prop.value as BindingTarget),
+    )
+  }
+  if (t.isAssignmentPattern(pattern)) {
+    return containsArrayPattern(pattern.left as BindingTarget)
+  }
+  return false
+}
+
+function containsRestElement(pattern: BindingTarget): boolean {
+  if (t.isObjectPattern(pattern)) {
+    return pattern.properties.some(
+      (prop) =>
+        t.isRestElement(prop) ||
+        (t.isObjectProperty(prop) && containsRestElement(prop.value as BindingTarget)),
+    )
+  }
+  if (t.isArrayPattern(pattern)) {
+    return pattern.elements.some(
+      (el) => el !== null && (t.isRestElement(el) || containsRestElement(el as BindingTarget)),
+    )
+  }
+  if (t.isAssignmentPattern(pattern)) {
+    return containsRestElement(pattern.left as BindingTarget)
+  }
+  return false
+}