How to use the @babel/core.types.arrayExpression function in @babel/core

if (forExport.length) {
    // Add wrapper function definition
    shaken.body.push(
      t.variableDeclaration('const', [
        t.variableDeclarator(t.identifier(wrapName), expWrapper),
      ])
    );
  }

  // Add export of all evaluated expressions
  shaken.body.push(
    t.expressionStatement(
      t.assignmentExpression(
        '=',
        t.memberExpression(t.identifier('module'), t.identifier('exports')),
        t.arrayExpression(forExport)
      )
    )
  );

  return [
    shaken,
    depsGraph.externalDeps.filter(({ local }) => alive.has(local)),
  ];
}

} else if (t.isTSBooleanKeyword(type)) {
    return createMember(t.identifier('bool'), propTypesImportedName);

    // symbol -> PropTypes.symbol
  } else if (t.isTSSymbolKeyword(type)) {
    return createMember(t.identifier('symbol'), propTypesImportedName);

    // object -> PropTypes.object
  } else if (t.isTSObjectKeyword(type)) {
    return createMember(t.identifier('object'), propTypesImportedName);

    // null -> PropTypes.oneOf([null])
  } else if (t.isTSNullKeyword(type)) {
    return createCall(
      t.identifier('oneOf'),
      [t.arrayExpression([t.nullLiteral()])],
      propTypesImportedName,
    );

    // 'foo' -> PropTypes.oneOf(['foo'])
  } else if (t.isTSLiteralType(type)) {
    return createCall(
      t.identifier('oneOf'),
      [t.arrayExpression([type.literal])],
      propTypesImportedName,
    );

    // enum Foo {} -> PropTypes.oneOf
  } else if (t.isTSEnumDeclaration(type)) {
    return createCall(
      t.identifier('oneOf'),
      [

    t.arrayExpression(quasis.map(({value}) => t.stringLiteral(value.raw))),
    ...(expressions.length ? [t.arrayExpression(expressions)] : []),

function push(_props, nodes) {
    if (!_props.length) return _props;
    nodes.push(t.arrayExpression(_props));
    return [];
  }

function takeDecorators({ node }) {
  let result;
  if (node.decorators && node.decorators.length > 0) {
    result = t.arrayExpression(
      node.decorators.map(decorator => decorator.expression),
    );
  }
  node.decorators = undefined;
  return result;
}

}

            headers.push(
              ...buildNamespaceInitStatements(meta, metadata, loose),
            );
          }

          ensureStatementsHoisted(headers);
          path.unshiftContainer("body", headers);

          injectWrapper(
            path,
            buildWrapper({
              MODULE_NAME: moduleName,

              AMD_ARGUMENTS: t.arrayExpression(amdArgs),
              IMPORT_NAMES: importNames,
            }),
          );
        },
      },

} else if (t.isLiteral(key)) {
          keys.push(t.stringLiteral(String(key.value)));
        } else {
          keys.push(t.cloneNode(key));
          allLiteral = false;
        }
      }

      let value;
      if (keys.length === 0) {
        value = t.callExpression(getExtendsHelper(this), [
          t.objectExpression([]),
          t.cloneNode(objRef),
        ]);
      } else {
        let keyExpression = t.arrayExpression(keys);

        if (!allLiteral) {
          keyExpression = t.callExpression(
            t.memberExpression(keyExpression, t.identifier("map")),
            [this.addHelper("toPropertyKey")],
          );
        }

        value = t.callExpression(
          this.addHelper(`objectWithoutProperties${loose ? "Loose" : ""}`),
          [t.cloneNode(objRef), keyExpression],
        );
      }

      this.nodes.push(this.buildVariableAssignment(spreadProp.argument, value));
    }

    t.arrayExpression(stages.map(stage => t.arrayExpression(stage))),
  ]