babel-plugin-polyfill-corejs3 0.10.4 → 0.11.0

package/lib/built-in-definitions.js

@@ -25,21 +25,22 @@ const ArrayNatureIteratorsWithTag = ["es.object.to-string", ...ArrayNatureIterat
 const CommonIteratorsWithTag = ["es.object.to-string", ...CommonIterators];
 const ErrorDependencies = ["es.error.cause", "es.error.to-string"];
 const SuppressedErrorDependencies = ["esnext.suppressed-error.constructor", ...ErrorDependencies];
-const TypedArrayDependencies = ["es.typed-array.at", "es.typed-array.copy-within", "es.typed-array.every", "es.typed-array.fill", "es.typed-array.filter", "es.typed-array.find", "es.typed-array.find-index", "es.typed-array.find-last", "es.typed-array.find-last-index", "es.typed-array.for-each", "es.typed-array.includes", "es.typed-array.index-of", "es.typed-array.iterator", "es.typed-array.join", "es.typed-array.last-index-of", "es.typed-array.map", "es.typed-array.reduce", "es.typed-array.reduce-right", "es.typed-array.reverse", "es.typed-array.set", "es.typed-array.slice", "es.typed-array.some", "es.typed-array.sort", "es.typed-array.subarray", "es.typed-array.to-locale-string", "es.typed-array.to-reversed", "es.typed-array.to-sorted", "es.typed-array.to-string", "es.typed-array.with", "es.object.to-string", "es.array.iterator", "es.array-buffer.slice", "es.data-view", "es.array-buffer.detached", "es.array-buffer.transfer", "es.array-buffer.transfer-to-fixed-length", "esnext.typed-array.filter-reject", "esnext.typed-array.group-by", "esnext.typed-array.to-spliced", "esnext.typed-array.unique-by"];
+const ArrayBufferDependencies = ["es.array-buffer.constructor", "es.array-buffer.slice", "es.data-view", "es.array-buffer.detached", "es.array-buffer.transfer", "es.array-buffer.transfer-to-fixed-length", "es.object.to-string"];
+const TypedArrayDependencies = ["es.typed-array.at", "es.typed-array.copy-within", "es.typed-array.every", "es.typed-array.fill", "es.typed-array.filter", "es.typed-array.find", "es.typed-array.find-index", "es.typed-array.find-last", "es.typed-array.find-last-index", "es.typed-array.for-each", "es.typed-array.includes", "es.typed-array.index-of", "es.typed-array.iterator", "es.typed-array.join", "es.typed-array.last-index-of", "es.typed-array.map", "es.typed-array.reduce", "es.typed-array.reduce-right", "es.typed-array.reverse", "es.typed-array.set", "es.typed-array.slice", "es.typed-array.some", "es.typed-array.sort", "es.typed-array.subarray", "es.typed-array.to-locale-string", "es.typed-array.to-reversed", "es.typed-array.to-sorted", "es.typed-array.to-string", "es.typed-array.with", "es.object.to-string", "es.array.iterator", "esnext.typed-array.filter-reject", "esnext.typed-array.group-by", "esnext.typed-array.to-spliced", "esnext.typed-array.unique-by", ...ArrayBufferDependencies];
 const PromiseDependencies = ["es.promise", "es.object.to-string"];
 exports.PromiseDependencies = PromiseDependencies;
 const PromiseDependenciesWithIterators = [...PromiseDependencies, ...CommonIterators];
 exports.PromiseDependenciesWithIterators = PromiseDependenciesWithIterators;
 const SymbolDependencies = ["es.symbol", "es.symbol.description", "es.object.to-string"];
-const MapDependencies = ["es.map", "esnext.map.delete-all", "esnext.map.emplace", "esnext.map.every", "esnext.map.filter", "esnext.map.find", "esnext.map.find-key", "esnext.map.includes", "esnext.map.key-of", "esnext.map.map-keys", "esnext.map.map-values", "esnext.map.merge", "esnext.map.reduce", "esnext.map.some", "esnext.map.update", ...CommonIteratorsWithTag];
-const SetDependencies = ["es.set", "esnext.set.add-all", "esnext.set.delete-all", "esnext.set.difference", "esnext.set.difference.v2", "esnext.set.every", "esnext.set.filter", "esnext.set.find", "esnext.set.intersection", "esnext.set.intersection.v2", "esnext.set.is-disjoint-from", "esnext.set.is-disjoint-from.v2", "esnext.set.is-subset-of", "esnext.set.is-subset-of.v2", "esnext.set.is-superset-of", "esnext.set.is-superset-of.v2", "esnext.set.join", "esnext.set.map", "esnext.set.reduce", "esnext.set.some", "esnext.set.symmetric-difference", "esnext.set.symmetric-difference.v2", "esnext.set.union", "esnext.set.union.v2", ...CommonIteratorsWithTag];
-const WeakMapDependencies = ["es.weak-map", "esnext.weak-map.delete-all", "esnext.weak-map.emplace", ...CommonIteratorsWithTag];
+const MapDependencies = ["es.map", "esnext.map.delete-all", "esnext.map.emplace", "esnext.map.every", "esnext.map.filter", "esnext.map.find", "esnext.map.find-key", "esnext.map.get-or-insert", "esnext.map.get-or-insert-computed", "esnext.map.includes", "esnext.map.key-of", "esnext.map.map-keys", "esnext.map.map-values", "esnext.map.merge", "esnext.map.reduce", "esnext.map.some", "esnext.map.update", ...CommonIteratorsWithTag];
+const SetDependencies = ["es.set", "es.set.difference.v2", "es.set.intersection.v2", "es.set.is-disjoint-from.v2", "es.set.is-subset-of.v2", "es.set.is-superset-of.v2", "es.set.symmetric-difference.v2", "es.set.union.v2", "esnext.set.add-all", "esnext.set.delete-all", "esnext.set.difference", "esnext.set.every", "esnext.set.filter", "esnext.set.find", "esnext.set.intersection", "esnext.set.is-disjoint-from", "esnext.set.is-subset-of", "esnext.set.is-superset-of", "esnext.set.join", "esnext.set.map", "esnext.set.reduce", "esnext.set.some", "esnext.set.symmetric-difference", "esnext.set.union", ...CommonIteratorsWithTag];
+const WeakMapDependencies = ["es.weak-map", "esnext.weak-map.delete-all", "esnext.weak-map.emplace", "esnext.weak-map.get-or-insert", "esnext.weak-map.get-or-insert-computed", ...CommonIteratorsWithTag];
 const WeakSetDependencies = ["es.weak-set", "esnext.weak-set.add-all", "esnext.weak-set.delete-all", ...CommonIteratorsWithTag];
 const DOMExceptionDependencies = ["web.dom-exception.constructor", "web.dom-exception.stack", "web.dom-exception.to-string-tag", "es.error.to-string"];
 const URLSearchParamsDependencies = ["web.url-search-params", "web.url-search-params.delete", "web.url-search-params.has", "web.url-search-params.size", ...CommonIteratorsWithTag];
 const AsyncIteratorDependencies = ["esnext.async-iterator.constructor", ...PromiseDependencies];
 const AsyncIteratorProblemMethods = ["esnext.async-iterator.every", "esnext.async-iterator.filter", "esnext.async-iterator.find", "esnext.async-iterator.flat-map", "esnext.async-iterator.for-each", "esnext.async-iterator.map", "esnext.async-iterator.reduce", "esnext.async-iterator.some"];
-const IteratorDependencies = ["esnext.iterator.constructor", "es.object.to-string"];
+const IteratorDependencies = ["es.iterator.constructor", "es.object.to-string"];
 const DecoratorMetadataDependencies = ["esnext.symbol.metadata", "esnext.function.metadata"];
 exports.DecoratorMetadataDependencies = DecoratorMetadataDependencies;
 const TypedArrayStaticMethods = base => ({
@@ -47,12 +48,12 @@ const TypedArrayStaticMethods = base => ({
   fromAsync: define(null, ["esnext.typed-array.from-async", base, ...PromiseDependenciesWithIterators, ...TypedArrayDependencies]),
   of: define(null, ["es.typed-array.of", base, ...TypedArrayDependencies])
 });
-const DataViewDependencies = ["es.data-view", "es.array-buffer.constructor", "es.array-buffer.slice", "es.array-buffer.detached", "es.array-buffer.transfer", "es.array-buffer.transfer-to-fixed-length", "es.object.to-string"];
+const DataViewDependencies = ["es.data-view", ...ArrayBufferDependencies];
 const BuiltIns = {
   AsyncDisposableStack: define("async-disposable-stack/index", ["esnext.async-disposable-stack.constructor", "es.object.to-string", "esnext.async-iterator.async-dispose", "esnext.iterator.dispose", ...PromiseDependencies, ...SuppressedErrorDependencies]),
   AsyncIterator: define("async-iterator/index", AsyncIteratorDependencies),
   AggregateError: define("aggregate-error", ["es.aggregate-error", ...ErrorDependencies, ...CommonIteratorsWithTag, "es.aggregate-error.cause"]),
-  ArrayBuffer: define(null, ["es.array-buffer.constructor", "es.array-buffer.slice", "es.data-view", "es.array-buffer.detached", "es.array-buffer.transfer", "es.array-buffer.transfer-to-fixed-length", "es.object.to-string"]),
+  ArrayBuffer: define(null, ArrayBufferDependencies),
   DataView: define(null, DataViewDependencies),
   Date: define(null, ["es.date.to-string"]),
   DOMException: define("dom-exception/index", DOMExceptionDependencies),
@@ -65,7 +66,7 @@ const BuiltIns = {
   Int16Array: typed("es.typed-array.int16-array"),
   Int32Array: typed("es.typed-array.int32-array"),
   Iterator: define("iterator/index", IteratorDependencies),
-  Uint8Array: typed("es.typed-array.uint8-array", "esnext.uint8-array.to-base64", "esnext.uint8-array.to-hex"),
+  Uint8Array: typed("es.typed-array.uint8-array", "esnext.uint8-array.set-from-base64", "esnext.uint8-array.set-from-hex", "esnext.uint8-array.to-base64", "esnext.uint8-array.to-hex"),
   Uint8ClampedArray: typed("es.typed-array.uint8-clamped-array"),
   Uint16Array: typed("es.typed-array.uint16-array"),
   Uint32Array: typed("es.typed-array.uint32-array"),
@@ -131,8 +132,9 @@ const StaticProperties = {
     isConstructor: define("function/is-constructor", ["esnext.function.is-constructor"])
   },
   Iterator: {
-    from: define("iterator/from", ["esnext.iterator.from", ...IteratorDependencies, ...CommonIterators]),
-    range: define("iterator/range", ["esnext.iterator.range", "es.object.to-string"])
+    concat: define("iterator/concat", ["esnext.iterator.concat", ...IteratorDependencies, ...CommonIterators]),
+    from: define("iterator/from", ["es.iterator.from", ...IteratorDependencies, ...CommonIterators]),
+    range: define("iterator/range", ["esnext.iterator.range", ...IteratorDependencies, "es.object.to-string"])
   },
   JSON: {
     isRawJSON: define("json/is-raw-json", ["esnext.json.is-raw-json"]),
@@ -169,15 +171,16 @@ const StaticProperties = {
     sign: define("math/sign", ["es.math.sign"]),
     signbit: define("math/signbit", ["esnext.math.signbit"]),
     sinh: define("math/sinh", ["es.math.sinh"]),
+    sumPrecise: define("math/sum-precise", ["esnext.math.sum-precise", "es.array.iterator"]),
     tanh: define("math/tanh", ["es.math.tanh"]),
     trunc: define("math/trunc", ["es.math.trunc"]),
     umulh: define("math/umulh", ["esnext.math.umulh"])
   },
   Map: {
-    from: define(null, ["esnext.map.from", ...MapDependencies]),
+    from: define("map/from", ["esnext.map.from", ...MapDependencies]),
     groupBy: define("map/group-by", ["es.map.group-by", ...MapDependencies]),
     keyBy: define("map/key-by", ["esnext.map.key-by", ...MapDependencies]),
-    of: define(null, ["esnext.map.of", ...MapDependencies])
+    of: define("map/of", ["esnext.map.of", ...MapDependencies])
   },
   Number: {
     EPSILON: define("number/epsilon", ["es.number.epsilon"]),
@@ -222,7 +225,7 @@ const StaticProperties = {
     allSettled: define("promise/all-settled", ["es.promise.all-settled", ...PromiseDependenciesWithIterators]),
     any: define("promise/any", ["es.promise.any", "es.aggregate-error", ...PromiseDependenciesWithIterators]),
     race: define(null, PromiseDependenciesWithIterators),
-    try: define("promise/try", ["esnext.promise.try", ...PromiseDependencies]),
+    try: define("promise/try", ["es.promise.try", ...PromiseDependencies]),
     withResolvers: define("promise/with-resolvers", ["es.promise.with-resolvers", ...PromiseDependencies])
   },
   Reflect: {
@@ -253,8 +256,8 @@ const StaticProperties = {
     escape: define("regexp/escape", ["esnext.regexp.escape"])
   },
   Set: {
-    from: define(null, ["esnext.set.from", ...SetDependencies]),
-    of: define(null, ["esnext.set.of", ...SetDependencies])
+    from: define("set/from", ["esnext.set.from", ...SetDependencies]),
+    of: define("set/of", ["esnext.set.of", ...SetDependencies])
   },
   String: {
     cooked: define("string/cooked", ["esnext.string.cooked"]),
@@ -265,6 +268,7 @@ const StaticProperties = {
   Symbol: {
     asyncDispose: define("symbol/async-dispose", ["esnext.symbol.async-dispose", "esnext.async-iterator.async-dispose"]),
     asyncIterator: define("symbol/async-iterator", ["es.symbol.async-iterator"]),
+    customMatcher: define("symbol/custom-matcher", ["esnext.symbol.custom-matcher"]),
     dispose: define("symbol/dispose", ["esnext.symbol.dispose", "esnext.iterator.dispose"]),
     for: define("symbol/for", [], "es.symbol"),
     hasInstance: define("symbol/has-instance", ["es.symbol.has-instance", "es.function.has-instance"]),
@@ -291,15 +295,16 @@ const StaticProperties = {
     unscopables: define("symbol/unscopables", ["es.symbol.unscopables"])
   },
   URL: {
-    canParse: define("url/can-parse", ["web.url.can-parse", "web.url"])
+    canParse: define("url/can-parse", ["web.url.can-parse", "web.url"]),
+    parse: define("url/parse", ["web.url.parse", "web.url"])
   },
   WeakMap: {
-    from: define(null, ["esnext.weak-map.from", ...WeakMapDependencies]),
-    of: define(null, ["esnext.weak-map.of", ...WeakMapDependencies])
+    from: define("weak-map/from", ["esnext.weak-map.from", ...WeakMapDependencies]),
+    of: define("weak-map/of", ["esnext.weak-map.of", ...WeakMapDependencies])
   },
   WeakSet: {
-    from: define(null, ["esnext.weak-set.from", ...WeakSetDependencies]),
-    of: define(null, ["esnext.weak-set.of", ...WeakSetDependencies])
+    from: define("weak-set/from", ["esnext.weak-set.from", ...WeakSetDependencies]),
+    of: define("weak-set/of", ["esnext.weak-set.of", ...WeakSetDependencies])
   },
   Int8Array: TypedArrayStaticMethods("es.typed-array.int8-array"),
   Uint8Array: _extends({
@@ -321,7 +326,7 @@ const StaticProperties = {
 };
 exports.StaticProperties = StaticProperties;
 const InstanceProperties = {
-  asIndexedPairs: define("instance/asIndexedPairs", ["esnext.async-iterator.as-indexed-pairs", ...AsyncIteratorDependencies, "esnext.iterator.as-indexed-pairs", ...IteratorDependencies]),
+  asIndexedPairs: define(null, ["esnext.async-iterator.as-indexed-pairs", ...AsyncIteratorDependencies, "esnext.iterator.as-indexed-pairs", ...IteratorDependencies]),
   at: define("instance/at", [
   // TODO: We should introduce overloaded instance methods definition
   // Before that is implemented, the `esnext.string.at` must be the first
@@ -342,29 +347,39 @@ const InstanceProperties = {
   demethodize: define("instance/demethodize", ["esnext.function.demethodize"]),
   description: define(null, ["es.symbol", "es.symbol.description"]),
   dotAll: define(null, ["es.regexp.dot-all"]),
-  drop: define(null, ["esnext.async-iterator.drop", ...AsyncIteratorDependencies, "esnext.iterator.drop", ...IteratorDependencies]),
-  emplace: define("instance/emplace", ["esnext.map.emplace", "esnext.weak-map.emplace"]),
+  drop: define(null, ["es.iterator.drop", ...IteratorDependencies, "esnext.async-iterator.drop", ...AsyncIteratorDependencies]),
   endsWith: define("instance/ends-with", ["es.string.ends-with"]),
   entries: define("instance/entries", ArrayNatureIteratorsWithTag),
-  every: define("instance/every", ["es.array.every", "esnext.async-iterator.every",
+  every: define("instance/every", ["es.array.every", "es.iterator.every", ...IteratorDependencies
   // TODO: add async iterator dependencies when we support sub-dependencies
   // esnext.async-iterator.every depends on es.promise
   // but we don't want to pull es.promise when esnext.async-iterator is disabled
   //
+  // "esnext.async-iterator.every",
   // ...AsyncIteratorDependencies
-  "esnext.iterator.every", ...IteratorDependencies]),
+  ]),
+
   exec: define(null, ["es.regexp.exec"]),
   fill: define("instance/fill", ["es.array.fill"]),
-  filter: define("instance/filter", ["es.array.filter", "esnext.async-iterator.filter", "esnext.iterator.filter", ...IteratorDependencies]),
+  filter: define("instance/filter", ["es.array.filter", "es.iterator.filter", ...IteratorDependencies
+  // "esnext.async-iterator.filter",
+  ]),
+
   filterReject: define("instance/filterReject", ["esnext.array.filter-reject"]),
   finally: define(null, ["es.promise.finally", ...PromiseDependencies]),
-  find: define("instance/find", ["es.array.find", "esnext.async-iterator.find", "esnext.iterator.find", ...IteratorDependencies]),
+  find: define("instance/find", ["es.array.find", "es.iterator.find", ...IteratorDependencies
+  // "esnext.async-iterator.find",
+  ]),
+
   findIndex: define("instance/find-index", ["es.array.find-index"]),
   findLast: define("instance/find-last", ["es.array.find-last"]),
   findLastIndex: define("instance/find-last-index", ["es.array.find-last-index"]),
   fixed: define(null, ["es.string.fixed"]),
   flags: define("instance/flags", ["es.regexp.flags"]),
-  flatMap: define("instance/flat-map", ["es.array.flat-map", "es.array.unscopables.flat-map", "esnext.async-iterator.flat-map", "esnext.iterator.flat-map", ...IteratorDependencies]),
+  flatMap: define("instance/flat-map", ["es.array.flat-map", "es.array.unscopables.flat-map", "es.iterator.flat-map", ...IteratorDependencies
+  // "esnext.async-iterator.flat-map",
+  ]),
+
   flat: define("instance/flat", ["es.array.flat", "es.array.unscopables.flat"]),
   getFloat16: define(null, ["esnext.data-view.get-float16", ...DataViewDependencies]),
   getUint8Clamped: define(null, ["esnext.data-view.get-uint8-clamped", ...DataViewDependencies]),
@@ -375,7 +390,9 @@ const InstanceProperties = {
   groupToMap: define("instance/group-to-map", ["esnext.array.group-to-map", "es.map", "es.object.to-string"]),
   fontcolor: define(null, ["es.string.fontcolor"]),
   fontsize: define(null, ["es.string.fontsize"]),
-  forEach: define("instance/for-each", ["es.array.for-each", "esnext.async-iterator.for-each", "esnext.iterator.for-each", ...IteratorDependencies, "web.dom-collections.for-each"]),
+  forEach: define("instance/for-each", ["es.array.for-each", "es.iterator.for-each", ...IteratorDependencies,
+  // "esnext.async-iterator.for-each",
+  "web.dom-collections.for-each"]),
   includes: define("instance/includes", ["es.array.includes", "es.string.includes"]),
   indexed: define(null, ["esnext.async-iterator.indexed", ...AsyncIteratorDependencies, "esnext.iterator.indexed", ...IteratorDependencies]),
   indexOf: define("instance/index-of", ["es.array.index-of"]),
@@ -387,14 +404,20 @@ const InstanceProperties = {
   lastIndexOf: define("instance/last-index-of", ["es.array.last-index-of"]),
   lastItem: define(null, ["esnext.array.last-item"]),
   link: define(null, ["es.string.link"]),
-  map: define("instance/map", ["es.array.map", "esnext.async-iterator.map", "esnext.iterator.map"]),
+  map: define("instance/map", ["es.array.map", "es.iterator.map", ...IteratorDependencies
+  // "esnext.async-iterator.map",
+  ]),
+
   match: define(null, ["es.string.match", "es.regexp.exec"]),
   matchAll: define("instance/match-all", ["es.string.match-all", "es.regexp.exec"]),
   name: define(null, ["es.function.name"]),
   padEnd: define("instance/pad-end", ["es.string.pad-end"]),
   padStart: define("instance/pad-start", ["es.string.pad-start"]),
   push: define("instance/push", ["es.array.push"]),
-  reduce: define("instance/reduce", ["es.array.reduce", "esnext.async-iterator.reduce", "esnext.iterator.reduce", ...IteratorDependencies]),
+  reduce: define("instance/reduce", ["es.array.reduce", "es.iterator.reduce", ...IteratorDependencies
+  // "esnext.async-iterator.reduce",
+  ]),
+
   reduceRight: define("instance/reduce-right", ["es.array.reduce-right"]),
   repeat: define("instance/repeat", ["es.string.repeat"]),
   replace: define(null, ["es.string.replace", "es.regexp.exec"]),
@@ -406,7 +429,10 @@ const InstanceProperties = {
   setYear: define(null, ["es.date.set-year"]),
   slice: define("instance/slice", ["es.array.slice"]),
   small: define(null, ["es.string.small"]),
-  some: define("instance/some", ["es.array.some", "esnext.async-iterator.some", "esnext.iterator.some", ...IteratorDependencies]),
+  some: define("instance/some", ["es.array.some", "es.iterator.some", ...IteratorDependencies
+  // "esnext.async-iterator.some",
+  ]),
+
   sort: define("instance/sort", ["es.array.sort"]),
   splice: define("instance/splice", ["es.array.splice"]),
   split: define(null, ["es.string.split", "es.regexp.exec"]),
@@ -416,9 +442,9 @@ const InstanceProperties = {
   sub: define(null, ["es.string.sub"]),
   substr: define(null, ["es.string.substr"]),
   sup: define(null, ["es.string.sup"]),
-  take: define(null, ["esnext.async-iterator.take", ...AsyncIteratorDependencies, "esnext.iterator.take", ...IteratorDependencies]),
+  take: define(null, ["es.iterator.take", ...IteratorDependencies, "esnext.async-iterator.take", ...AsyncIteratorDependencies]),
   test: define(null, ["es.regexp.test", "es.regexp.exec"]),
-  toArray: define(null, ["esnext.async-iterator.to-array", ...AsyncIteratorDependencies, "esnext.iterator.to-array", ...IteratorDependencies]),
+  toArray: define(null, ["es.iterator.to-array", ...IteratorDependencies, "esnext.async-iterator.to-array", ...AsyncIteratorDependencies]),
   toAsync: define(null, ["esnext.iterator.to-async", ...IteratorDependencies, ...AsyncIteratorDependencies, ...AsyncIteratorProblemMethods]),
   toExponential: define(null, ["es.number.to-exponential"]),
   toFixed: define(null, ["es.number.to-fixed"]),

package/lib/index.js

@@ -16,7 +16,8 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 const {
-  types: t
+  types: t,
+  template: template
 } = _babel.default || _babel;
 const presetEnvCompat = "#__secret_key__@babel/preset-env__compatibility";
 const runtimeCompat = "#__secret_key__@babel/runtime__compatibility";
@@ -161,7 +162,9 @@ var _default = (0, _helperDefinePolyfillProvider.default)(function ({
       })) return;
       if (meta.kind === "property") {
         // We can't compile destructuring and updateExpression.
-        if (!path.isMemberExpression()) return;
+        if (!path.isMemberExpression() && !path.isOptionalMemberExpression()) {
+          return;
+        }
         if (!path.isReferenced()) return;
         if (path.parentPath.isUpdateExpression()) return;
         if (t.isSuper(path.node.object)) {
@@ -206,19 +209,52 @@ var _default = (0, _helperDefinePolyfillProvider.default)(function ({
         const id = maybeInjectPure(resolved.desc, resolved.name, utils,
         // @ts-expect-error
         meta.object);
-        if (id) path.replaceWith(id);
+        if (id) {
+          path.replaceWith(id);
+          let {
+            parentPath
+          } = path;
+          if (parentPath.isOptionalMemberExpression() || parentPath.isOptionalCallExpression()) {
+            do {
+              const parentAsNotOptional = parentPath;
+              parentAsNotOptional.type = parentAsNotOptional.node.type = parentPath.type === "OptionalMemberExpression" ? "MemberExpression" : "CallExpression";
+              delete parentAsNotOptional.node.optional;
+              ({
+                parentPath
+              } = parentPath);
+            } while ((parentPath.isOptionalMemberExpression() || parentPath.isOptionalCallExpression()) && !parentPath.node.optional);
+          }
+        }
       } else if (resolved.kind === "instance") {
         const id = maybeInjectPure(resolved.desc, `${resolved.name}InstanceProperty`, utils,
         // @ts-expect-error
         meta.object);
         if (!id) return;
         const {
-          node
+          node,
+          parent
         } = path;
-        if (t.isCallExpression(path.parent, {
-          callee: node
-        })) {
-          (0, _utils.callMethod)(path, id);
+        if (t.isOptionalCallExpression(parent) && parent.callee === node) {
+          const wasOptional = parent.optional;
+          parent.optional = !wasOptional;
+          if (!wasOptional) {
+            const check = (0, _utils.extractOptionalCheck)(path.scope, node);
+            const [thisArg, thisArg2] = (0, _utils.maybeMemoizeContext)(node, path.scope);
+            path.replaceWith(check(template.expression.ast`
+                  Function.call.bind(${id}(${thisArg}), ${thisArg2})
+                `));
+          } else if (t.isOptionalMemberExpression(node)) {
+            const check = (0, _utils.extractOptionalCheck)(path.scope, node);
+            (0, _utils.callMethod)(path, id, true, check);
+          } else {
+            (0, _utils.callMethod)(path, id, true);
+          }
+        } else if (t.isCallExpression(parent) && parent.callee === node) {
+          (0, _utils.callMethod)(path, id, false);
+        } else if (t.isOptionalMemberExpression(node)) {
+          const check = (0, _utils.extractOptionalCheck)(path.scope, node);
+          path.replaceWith(check(t.callExpression(id, [node.object])));
+          if (t.isOptionalMemberExpression(parent)) parent.optional = true;
         } else {
           path.replaceWith(t.callExpression(id, [node.object]));
         }

package/lib/shipped-proposals.js

@@ -3,5 +3,5 @@
 exports.__esModule = true;
 exports.default = void 0;
 // This file is automatically generated by scripts/build-corejs3-shipped-proposals.mjs
-var _default = new Set(["esnext.suppressed-error.constructor", "esnext.array.from-async", "esnext.array.group", "esnext.array.group-to-map", "esnext.iterator.constructor", "esnext.iterator.drop", "esnext.iterator.every", "esnext.iterator.filter", "esnext.iterator.find", "esnext.iterator.flat-map", "esnext.iterator.for-each", "esnext.iterator.from", "esnext.iterator.map", "esnext.iterator.reduce", "esnext.iterator.some", "esnext.iterator.take", "esnext.iterator.to-array", "esnext.json.is-raw-json", "esnext.json.parse", "esnext.json.raw-json", "esnext.set.difference.v2", "esnext.set.intersection.v2", "esnext.set.is-disjoint-from.v2", "esnext.set.is-subset-of.v2", "esnext.set.is-superset-of.v2", "esnext.set.symmetric-difference.v2", "esnext.set.union.v2", "esnext.symbol.async-dispose", "esnext.symbol.dispose", "esnext.symbol.metadata"]);
+var _default = new Set(["esnext.suppressed-error.constructor", "esnext.array.from-async", "esnext.array.group", "esnext.array.group-to-map", "esnext.data-view.get-float16", "esnext.data-view.set-float16", "esnext.json.is-raw-json", "esnext.json.parse", "esnext.json.raw-json", "esnext.math.f16round", "esnext.regexp.escape", "esnext.symbol.async-dispose", "esnext.symbol.dispose", "esnext.symbol.metadata", "esnext.uint8-array.from-base64", "esnext.uint8-array.from-hex", "esnext.uint8-array.set-from-base64", "esnext.uint8-array.set-from-hex", "esnext.uint8-array.to-base64", "esnext.uint8-array.to-hex"]);
 exports.default = _default;

package/lib/utils.js

@@ -5,7 +5,9 @@ exports.BABEL_RUNTIME = void 0;
 exports.callMethod = callMethod;
 exports.coreJSModule = coreJSModule;
 exports.coreJSPureHelper = coreJSPureHelper;
+exports.extractOptionalCheck = extractOptionalCheck;
 exports.isCoreJSSource = isCoreJSSource;
+exports.maybeMemoizeContext = maybeMemoizeContext;
 var _babel = _interopRequireWildcard(require("@babel/core"));
 var _entries = _interopRequireDefault(require("../core-js-compat/entries.js"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -16,20 +18,38 @@ const {
 } = _babel.default || _babel;
 const BABEL_RUNTIME = "@babel/runtime-corejs3";
 exports.BABEL_RUNTIME = BABEL_RUNTIME;
-function callMethod(path, id) {
+function callMethod(path, id, optionalCall, wrapCallee) {
+  const [context1, context2] = maybeMemoizeContext(path.node, path.scope);
+  let callee = t.callExpression(id, [context1]);
+  if (wrapCallee) callee = wrapCallee(callee);
+  const call = t.identifier("call");
+  path.replaceWith(optionalCall ? t.optionalMemberExpression(callee, call, false, true) : t.memberExpression(callee, call));
+  path.parentPath.unshiftContainer("arguments", context2);
+}
+function maybeMemoizeContext(node, scope) {
   const {
     object
-  } = path.node;
+  } = node;
   let context1, context2;
   if (t.isIdentifier(object)) {
-    context1 = object;
-    context2 = t.cloneNode(object);
+    context2 = object;
+    context1 = t.cloneNode(object);
   } else {
-    context1 = path.scope.generateDeclaredUidIdentifier("context");
-    context2 = t.assignmentExpression("=", t.cloneNode(context1), object);
+    context2 = scope.generateDeclaredUidIdentifier("context");
+    context1 = t.assignmentExpression("=", t.cloneNode(context2), object);
+  }
+  return [context1, context2];
+}
+function extractOptionalCheck(scope, node) {
+  let optionalNode = node;
+  while (!optionalNode.optional && t.isOptionalMemberExpression(optionalNode.object)) {
+    optionalNode = optionalNode.object;
   }
-  path.replaceWith(t.memberExpression(t.callExpression(id, [context2]), t.identifier("call")));
-  path.parentPath.unshiftContainer("arguments", context1);
+  optionalNode.optional = false;
+  const ctx = scope.generateDeclaredUidIdentifier("context");
+  const assign = t.assignmentExpression("=", ctx, optionalNode.object);
+  optionalNode.object = t.cloneNode(ctx);
+  return ifNotNullish => t.conditionalExpression(t.binaryExpression("==", assign, t.nullLiteral()), t.unaryExpression("void", t.numericLiteral(0)), ifNotNullish);
 }
 function isCoreJSSource(source) {
   if (typeof source === "string") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-polyfill-corejs3",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "description": "A Babel plugin to inject imports to core-js@3 polyfills",
   "repository": {
     "type": "git",
@@ -26,8 +26,8 @@
     "babel-plugin"
   ],
   "dependencies": {
-    "@babel/helper-define-polyfill-provider": "^0.6.1",
-    "core-js-compat": "^3.36.1"
+    "@babel/helper-define-polyfill-provider": "^0.6.3",
+    "core-js-compat": "^3.39.0"
   },
   "devDependencies": {
     "@babel/core": "^7.22.6",
@@ -39,11 +39,11 @@
     "@babel/plugin-transform-modules-commonjs": "^7.22.5",
     "@babel/plugin-transform-runtime": "^7.22.15",
     "@babel/plugin-transform-spread": "^7.22.5",
-    "core-js": "^3.36.1",
-    "core-js-pure": "^3.36.1"
+    "core-js": "^3.39.0",
+    "core-js-pure": "^3.39.0"
   },
   "peerDependencies": {
     "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
   },
-  "gitHead": "a5db9c31c5b5474b4018e6178bc40882fc3eb5bf"
+  "gitHead": "66340fb145086a826c496f008f67488367846c09"
 }