[BUGFIX lts] Add missing Babel helpers.

Due to the way Ember itself is compiled, we have custom versions of the
`@babel/helpers` that we inline into the IIFE that contains Ember. This
is obviously pretty unideal (largely because it forces us to be
misaligned with Babel and therefore brittle to reasonable changes that
they make).

These helpers have been pretty stable for quite a while, but recently
Babel 7.9.0 introduced a couple of new helpers:

* `createSuper` allows subclassing from native classes, even when
  partially transpiled).
* `createForOfIteratorHelperLoose`

Versions of `ember-source` prior to 3.13 fully transpiled with the Babel
version in `emberjs/ember.js`s _own_ `yarn.lock` at publish time. The
build process was significantly changed in `[email protected]` so that
`ember-source` would behave just like a normal addon. This was a
**huge** improvement!! Unfortunately, those changes also made us
vulnerable to changes made to Babel (new helpers added).

We **must** resolve that issue (likely by removing these custom external
helpers in favor of using `includeExternalHelpers` from
`ember-cli-babel`), but in the meantime this commit adds the required
helpers which should fix the reported issue in supported Ember versions.

(cherry picked from commit a4a1206)

Author: Robert Jackson

packages/external-helpers/lib/external-helpers.js

@@ -1,6 +1,11 @@
+/* globals Reflect */
+
 import { DEBUG } from '@glimmer/env';
 
 const setPrototypeOf = Object.setPrototypeOf;
+const getPrototypeOf = Object.getPrototypeOf;
+
+const hasReflectConstruct = typeof Reflect === 'object' && typeof Reflect.construct === 'function';
 
 const nativeWrapperCache = new Map();
 
@@ -117,3 +122,74 @@ export function objectDestructuringEmpty(obj) {
     throw new TypeError('Cannot destructure undefined');
   }
 }
+
+/*
+  Differs from default implementation by checking for _any_ `Reflect.construct`
+  (the default implementation tries to ensure that `Reflect.construct` is truly
+  the native one).
+
+  Original source: https://github.com/babel/babel/blob/v7.9.2/packages/babel-helpers/src/helpers.js#L738-L757
+*/
+export function createSuper(Derived) {
+  return function() {
+    let Super = getPrototypeOf(Derived);
+    let result;
+
+    if (hasReflectConstruct) {
+      // NOTE: This doesn't work if this.__proto__.constructor has been modified.
+      let NewTarget = getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+
+    return possibleConstructorReturn(this, result);
+  };
+}
+
+/*
+  Does not differ from default implementation.
+*/
+function arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  let arr2 = new Array(len);
+  for (let i = 0; i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+
+/*
+  Does not differ from default implementation.
+*/
+function unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === 'string') return arrayLikeToArray(o, minLen);
+  let n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === 'Object' && o.constructor) n = o.constructor.name;
+  if (n === 'Map' || n === 'Set') return Array.from(n);
+  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return arrayLikeToArray(o, minLen);
+}
+
+/*
+  Does not differ from default implementation.
+*/
+export function createForOfIteratorHelperLoose(o) {
+  let i = 0;
+  if (typeof Symbol === 'undefined' || o[Symbol.iterator] == null) {
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (o = unsupportedIterableToArray(o)))
+      return function() {
+        if (i >= o.length) return { done: true };
+        return { done: false, value: o[i++] };
+      };
+    throw new TypeError(
+      'Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.'
+    );
+  }
+  i = o[Symbol.iterator]();
+  return i.next.bind(i);
+}