@jsenv/core 27.0.0-alpha.0 → 27.0.0-alpha.11

package/src/omega/core_plugins/babel/babel_helper/client/classPrivateFieldLooseBase/classPrivateFieldLooseBase.js

@@ -1,6 +0,0 @@
-export default function (receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance")
-  }
-  return receiver
-}

package/src/omega/core_plugins/babel/babel_helper/client/classPrivateFieldLooseKey/classPrivateFieldLooseKey.js

@@ -1,5 +0,0 @@
-var id = 0
-export default function (name) {
-  // eslint-disable-next-line prefer-template
-  return "__private_" + id++ + "_" + name
-}

package/src/omega/core_plugins/babel/babel_helper/client/classPrivateFieldSet/classPrivateFieldSet.js

@@ -1,8 +0,0 @@
-import classApplyDescriptorSet from "../classApplyDescriptorSet/classApplyDescriptorSet.js"
-import classExtractFieldDescriptor from "../classExtractFieldDescriptor/classExtractFieldDescriptor.js"
-
-export default function (receiver, privateMap, value) {
-  var descriptor = classExtractFieldDescriptor(receiver, privateMap, "set")
-  classApplyDescriptorSet(receiver, descriptor, value)
-  return value
-}

package/src/omega/core_plugins/babel/babel_helper/client/classPrivateMethodGet/classPrivateMethodGet.js

@@ -1,6 +0,0 @@
-export default function _classPrivateMethodGet(receiver, privateSet, fn) {
-  if (!privateSet.has(receiver)) {
-    throw new TypeError("attempted to get private field on non-instance")
-  }
-  return fn
-}

package/src/omega/core_plugins/babel/babel_helper/client/classPrivateMethodSet/classPrivateMethodSet.js

@@ -1,3 +0,0 @@
-export default function _classStaticPrivateMethodSet() {
-  throw new TypeError("attempted to set read only static private field")
-}

package/src/omega/core_plugins/babel/babel_helper/client/classStaticPrivateFieldSpecGet/classStaticPrivateFieldSpecGet.js

@@ -1,9 +0,0 @@
-import classApplyDescriptorGet from "../classApplyDescriptorGet/classApplyDescriptorGet.js"
-import classCheckPrivateStaticAccess from "../classCheckPrivateStaticAccess/classCheckPrivateStaticAccess.js"
-import classCheckPrivateStaticFieldDescriptor from "../classCheckPrivateStaticFieldDescriptor/classCheckPrivateStaticFieldDescriptor.js"
-
-export default function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
-  classCheckPrivateStaticAccess(receiver, classConstructor)
-  classCheckPrivateStaticFieldDescriptor(descriptor, "get")
-  return classApplyDescriptorGet(receiver, descriptor)
-}

package/src/omega/core_plugins/babel/babel_helper/client/classStaticPrivateFieldSpecSet/classStaticPrivateFieldSpecSet.js

@@ -1,15 +0,0 @@
-import classApplyDescriptorSet from "../classApplyDescriptorSet/classApplyDescriptorSet.js"
-import classCheckPrivateStaticAccess from "../classCheckPrivateStaticAccess/classCheckPrivateStaticAccess.js"
-import classCheckPrivateStaticFieldDescriptor from "../classCheckPrivateStaticFieldDescriptor/classCheckPrivateStaticFieldDescriptor.js"
-
-export default function _classStaticPrivateFieldSpecSet(
-  receiver,
-  classConstructor,
-  descriptor,
-  value,
-) {
-  classCheckPrivateStaticAccess(receiver, classConstructor)
-  classCheckPrivateStaticFieldDescriptor(descriptor, "set")
-  classApplyDescriptorSet(receiver, descriptor, value)
-  return value
-}

package/src/omega/core_plugins/babel/babel_helper/client/classStaticPrivateMethodGet/classStaticPrivateMethodGet.js

@@ -1,6 +0,0 @@
-import classCheckPrivateStaticAccess from "../classCheckPrivateStaticAccess/classCheckPrivateStaticAccess.js"
-
-export default function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
-  classCheckPrivateStaticAccess(receiver, classConstructor)
-  return method
-}

package/src/omega/core_plugins/babel/babel_helper/client/classStaticPrivateMethodSet/classStaticPrivateMethodSet.js

@@ -1,3 +0,0 @@
-export default function _classStaticPrivateMethodSet() {
-  throw new TypeError("attempted to set read only static private field")
-}

package/src/omega/core_plugins/babel/babel_helper/client/construct/construct.js

@@ -1,16 +0,0 @@
-import setPrototypeOf from "../setPrototypeOf/setPrototypeOf.js"
-import isNativeReflectConstruct from "../isNativeReflectConstruct/isNativeReflectConstruct.js"
-
-// NOTE: If Parent !== Class, the correct __proto__ is set *after*
-// calling the constructor.
-function reflectConstruct(Parent, args, Class) {
-  var a = [null]
-  // eslint-disable-next-line prefer-spread
-  a.push.apply(a, args)
-  var Constructor = Function.bind.apply(Parent, a)
-  var instance = new Constructor()
-  if (Class) setPrototypeOf(instance, Class.prototype)
-  return instance
-}
-
-export default isNativeReflectConstruct() ? Reflect.construct : reflectConstruct

package/src/omega/core_plugins/babel/babel_helper/client/createClass/createClass.js

@@ -1,15 +0,0 @@
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-export default function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", { writable: false });
-  return Constructor;
-}

package/src/omega/core_plugins/babel/babel_helper/client/createForOfIteratorHelper/createForOfIteratorHelper.js

@@ -1,60 +0,0 @@
-/* eslint-disable eqeqeq, no-eq-null */
-import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js"
-
-// s: start (create the iterator)
-// n: next
-// e: error (called whenever something throws)
-// f: finish (always called at the end)
-export default function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = (typeof Symbol !== "undefined" && o[Symbol.iterator]) || o["@@iterator"]
-  if (!it) {
-    // Fallback for engines without symbol support
-    if (
-      Array.isArray(o) ||
-      (it = unsupportedIterableToArray(o)) ||
-      (allowArrayLike && o && typeof o.length === "number")
-    ) {
-      if (it) o = it
-      var i = 0
-      var F = function () {}
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return { done: true }
-          return { done: false, value: o[i++] }
-        },
-        e: function (e) {
-          throw e
-        },
-        f: F,
-      }
-    }
-    throw new TypeError(
-      "Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.",
-    )
-  }
-  var normalCompletion = true,
-    didErr = false,
-    err
-  return {
-    s: function () {
-      it = it.call(o)
-    },
-    n: function () {
-      var step = it.next()
-      normalCompletion = step.done
-      return step
-    },
-    e: function (e) {
-      didErr = true
-      err = e
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return()
-      } finally {
-        if (didErr) throw err
-      }
-    },
-  }
-}

package/src/omega/core_plugins/babel/babel_helper/client/createForOfIteratorHelperLoose/createForOfIteratorHelperLoose.js

@@ -1,23 +0,0 @@
-/* eslint-disable eqeqeq, no-eq-null */
-import unsupportedIterableToArray from "../unsupportedIterableToArray/unsupportedIterableToArray.js"
-
-export default function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-  var it = (typeof Symbol !== "undefined" && o[Symbol.iterator]) || o["@@iterator"]
-  if (it) return (it = it.call(o)).next.bind(it)
-  // Fallback for engines without symbol support
-  if (
-    Array.isArray(o) ||
-    (it = unsupportedIterableToArray(o)) ||
-    (allowArrayLike && o && typeof o.length === "number")
-  ) {
-    if (it) o = it
-    var i = 0
-    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.",
-  )
-}

package/src/omega/core_plugins/babel/babel_helper/client/createRawReactElement/createRawReactElement.js

@@ -1,50 +0,0 @@
-/* globals REACT_ELEMENT_TYPE */
-export default function _createRawReactElement(type, props, key, children) {
-  if (!REACT_ELEMENT_TYPE) {
-    // eslint-disable-next-line no-native-reassign
-    REACT_ELEMENT_TYPE =
-      (typeof Symbol === "function" &&
-        // "for" is a reserved keyword in ES3 so escaping it here for backward compatibility
-        Symbol["for"] &&
-        Symbol["for"]("react.element")) ||
-      0xeac7
-  }
-
-  var defaultProps = type && type.defaultProps
-  var childrenLength = arguments.length - 3
-
-  if (!props && childrenLength !== 0) {
-    // If we're going to assign props.children, we create a new object now
-    // to avoid mutating defaultProps.
-    props = { children: void 0 }
-  }
-
-  if (childrenLength === 1) {
-    props.children = children
-  } else if (childrenLength > 1) {
-    var childArray = new Array(childrenLength)
-    for (var i = 0; i < childrenLength; i++) {
-      childArray[i] = arguments[i + 3]
-    }
-    props.children = childArray
-  }
-
-  if (props && defaultProps) {
-    for (var propName in defaultProps) {
-      if (props[propName] === void 0) {
-        props[propName] = defaultProps[propName]
-      }
-    }
-  } else if (!props) {
-    props = defaultProps || {}
-  }
-
-  return {
-    $$typeof: REACT_ELEMENT_TYPE,
-    type: type,
-    key: key === undefined ? null : "" + key,
-    ref: null,
-    props: props,
-    _owner: null,
-  }
-}

package/src/omega/core_plugins/babel/babel_helper/client/createSuper/createSuper.js

@@ -1,22 +0,0 @@
-import getPrototypeOf from "../getPrototypeOf/getPrototypeOf.js"
-import isNativeReflectConstruct from "../isNativeReflectConstruct/isNativeReflectConstruct.js"
-import possibleConstructorReturn from "../possibleConstructorReturn/possibleConstructorReturn.js"
-
-export default function _createSuper(Derived) {
-  var hasNativeReflectConstruct = isNativeReflectConstruct()
-
-  return function _createSuperInternal() {
-    var Super = getPrototypeOf(Derived)
-    var result
-    if (hasNativeReflectConstruct) {
-      // NOTE: This doesn't work if this.__proto__.constructor has been modified.
-      var NewTarget = getPrototypeOf(this).constructor
-      // eslint-disable-next-line prefer-rest-params
-      result = Reflect.construct(Super, arguments, NewTarget)
-    } else {
-      // eslint-disable-next-line prefer-rest-params
-      result = Super.apply(this, arguments)
-    }
-    return possibleConstructorReturn(this, result)
-  }
-}

package/src/omega/core_plugins/babel/babel_helper/client/decorate/decorate.js

@@ -1,403 +0,0 @@
-/* eslint-disable block-scoped-var */
-/* eslint-disable no-nested-ternary */
-/* eslint-disable no-negated-condition */
-/* eslint-disable consistent-return */
-/* eslint-disable prefer-spread */
-/* eslint-disable no-void */
-/* eslint-disable no-sequences */
-import toArray from "../toArray/toArray.js"
-import toPropertyKey from "../toPropertyKey/toPropertyKey.js"
-
-// ClassDefinitionEvaluation (Steps 26-*)
-export default function _decorate(
-  decorators /* : ClassDecorator[] */,
-  factory /* : ClassFactory */,
-  superClass /* : ?Class<*> */,
-  mixins /* : ?Array<Function> */,
-) /* : Class<*> */ {
-  var api = _getDecoratorsApi()
-  if (mixins) {
-    for (var i = 0; i < mixins.length; i++) {
-      api = mixins[i](api)
-    }
-  }
-  var r = factory(function initialize(O) {
-    api.initializeInstanceElements(O, decorated.elements)
-  }, superClass)
-  var decorated = api.decorateClass(
-    _coalesceClassElements(r.d.map(_createElementDescriptor)),
-    decorators,
-  )
-  api.initializeClassElements(r.F, decorated.elements)
-  return api.runClassFinishers(r.F, decorated.finishers)
-}
-
-var _getDecoratorsApi = function () {
-  var api = {
-    elementsDefinitionOrder: [["method"], ["field"]],
-    // InitializeInstanceElements
-    initializeInstanceElements(/* ::<C>*/ O /* : C */, elements /* : ElementDescriptor[] */) {
-      ;["method", "field"].forEach(function (kind) {
-        elements.forEach(function (element /* : ElementDescriptor */) {
-          if (element.kind === kind && element.placement === "own") {
-            this.defineClassElement(O, element)
-          }
-        }, this)
-      }, this)
-    },
-    // InitializeClassElements
-    initializeClassElements(/* ::<C>*/ F /* : Class<C> */, elements /* : ElementDescriptor[] */) {
-      var proto = F.prototype
-      ;["method", "field"].forEach(function (kind) {
-        elements.forEach(function (element /* : ElementDescriptor */) {
-          var placement = element.placement
-          if (element.kind === kind && (placement === "static" || placement === "prototype")) {
-            var receiver = placement === "static" ? F : proto
-            this.defineClassElement(receiver, element)
-          }
-        }, this)
-      }, this)
-    },
-    // DefineClassElement
-    defineClassElement(
-      /* ::<C>*/ receiver /* : C | Class<C> */,
-      element /* : ElementDescriptor */,
-    ) {
-      var descriptor /* : PropertyDescriptor */ = element.descriptor
-      if (element.kind === "field") {
-        var initializer = element.initializer
-        descriptor = {
-          enumerable: descriptor.enumerable,
-          writable: descriptor.writable,
-          configurable: descriptor.configurable,
-          value: initializer === void 0 ? void 0 : initializer.call(receiver),
-        }
-      }
-      Object.defineProperty(receiver, element.key, descriptor)
-    },
-    // DecorateClass
-    decorateClass(
-      elements /* : ElementDescriptor[] */,
-      decorators /* : ClassDecorator[] */,
-    ) /* : ElementsFinishers */ {
-      var newElements /* : ElementDescriptor[] */ = []
-      var finishers /* : ClassFinisher[] */ = []
-      var placements /* : Placements */ = {
-        static: [],
-        prototype: [],
-        own: [],
-      }
-      elements.forEach(function (element /* : ElementDescriptor */) {
-        this.addElementPlacement(element, placements)
-      }, this)
-      elements.forEach(function (element /* : ElementDescriptor */) {
-        if (!_hasDecorators(element)) return newElements.push(element)
-        var elementFinishersExtras /* : ElementFinishersExtras */ = this.decorateElement(
-          element,
-          placements,
-        )
-        newElements.push(elementFinishersExtras.element)
-        newElements.push.apply(newElements, elementFinishersExtras.extras)
-        finishers.push.apply(finishers, elementFinishersExtras.finishers)
-      }, this)
-      if (!decorators) {
-        return { elements: newElements, finishers }
-      }
-      var result /* : ElementsFinishers */ = this.decorateConstructor(newElements, decorators)
-      finishers.push.apply(finishers, result.finishers)
-      result.finishers = finishers
-      return result
-    },
-    // AddElementPlacement
-    addElementPlacement(
-      element /* : ElementDescriptor */,
-      placements /* : Placements */,
-      silent /* : boolean */,
-    ) {
-      var keys = placements[element.placement]
-      if (!silent && keys.indexOf(element.key) !== -1) {
-        throw new TypeError(`Duplicated element (${element.key})`)
-      }
-      keys.push(element.key)
-    },
-    // DecorateElement
-    decorateElement(
-      element /* : ElementDescriptor */,
-      placements /* : Placements */,
-    ) /* : ElementFinishersExtras */ {
-      var extras /* : ElementDescriptor[] */ = []
-      var finishers /* : ClassFinisher[] */ = []
-      for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
-        // (inlined) RemoveElementPlacement
-        var keys = placements[element.placement]
-        keys.splice(keys.indexOf(element.key), 1)
-        var elementObject /* : ElementObjectInput */ = this.fromElementDescriptor(element)
-        var elementFinisherExtras /* : ElementFinisherExtras */ = this.toElementFinisherExtras(
-          (0, decorators[i])(elementObject) /* : ElementObjectOutput */ || elementObject,
-        )
-        element = elementFinisherExtras.element
-        this.addElementPlacement(element, placements)
-        if (elementFinisherExtras.finisher) {
-          finishers.push(elementFinisherExtras.finisher)
-        }
-        var newExtras /* : ElementDescriptor[] | void */ = elementFinisherExtras.extras
-        if (newExtras) {
-          for (var j = 0; j < newExtras.length; j++) {
-            this.addElementPlacement(newExtras[j], placements)
-          }
-          extras.push.apply(extras, newExtras)
-        }
-      }
-      return { element, finishers, extras }
-    },
-    // DecorateConstructor
-    decorateConstructor(
-      elements /* : ElementDescriptor[] */,
-      decorators /* : ClassDecorator[] */,
-    ) /* : ElementsFinishers */ {
-      var finishers /* : ClassFinisher[] */ = []
-      for (var i = decorators.length - 1; i >= 0; i--) {
-        var obj /* : ClassObject */ = this.fromClassDescriptor(elements)
-        var elementsAndFinisher /* : ElementsFinisher */ = this.toClassDescriptor(
-          (0, decorators[i])(obj) /* : ClassObject */ || obj,
-        )
-        if (elementsAndFinisher.finisher !== undefined) {
-          finishers.push(elementsAndFinisher.finisher)
-        }
-        if (elementsAndFinisher.elements !== undefined) {
-          elements = elementsAndFinisher.elements
-          for (var j = 0; j < elements.length - 1; j++) {
-            for (var k = j + 1; k < elements.length; k++) {
-              if (
-                elements[j].key === elements[k].key &&
-                elements[j].placement === elements[k].placement
-              ) {
-                throw new TypeError(`Duplicated element (${elements[j].key})`)
-              }
-            }
-          }
-        }
-      }
-      return { elements, finishers }
-    },
-    // FromElementDescriptor
-    fromElementDescriptor(element /* : ElementDescriptor */) /* : ElementObject */ {
-      var obj /* : ElementObject */ = {
-        kind: element.kind,
-        key: element.key,
-        placement: element.placement,
-        descriptor: element.descriptor,
-      }
-      var desc = {
-        value: "Descriptor",
-        configurable: true,
-      }
-      Object.defineProperty(obj, Symbol.toStringTag, desc)
-      if (element.kind === "field") obj.initializer = element.initializer
-      return obj
-    },
-    // ToElementDescriptors
-    toElementDescriptors(elementObjects /* : ElementObject[] */) /* : ElementDescriptor[] */ {
-      if (elementObjects === undefined) return
-      return toArray(elementObjects).map(function (elementObject) {
-        var element = this.toElementDescriptor(elementObject)
-        this.disallowProperty(elementObject, "finisher", "An element descriptor")
-        this.disallowProperty(elementObject, "extras", "An element descriptor")
-        return element
-      }, this)
-    },
-    // ToElementDescriptor
-    toElementDescriptor(elementObject /* : ElementObject */) /* : ElementDescriptor */ {
-      var kind = String(elementObject.kind)
-      if (kind !== "method" && kind !== "field") {
-        throw new TypeError(
-          `${
-            'An element descriptor\'s .kind property must be either "method" or' +
-            ' "field", but a decorator created an element descriptor with' +
-            ' .kind "'
-          }${kind}"`,
-        )
-      }
-      var key = toPropertyKey(elementObject.key)
-      var placement = String(elementObject.placement)
-      if (placement !== "static" && placement !== "prototype" && placement !== "own") {
-        throw new TypeError(
-          `${
-            'An element descriptor\'s .placement property must be one of "static",' +
-            ' "prototype" or "own", but a decorator created an element descriptor' +
-            ' with .placement "'
-          }${placement}"`,
-        )
-      }
-      var descriptor /* : PropertyDescriptor */ = elementObject.descriptor
-      this.disallowProperty(elementObject, "elements", "An element descriptor")
-      var element /* : ElementDescriptor */ = {
-        kind,
-        key,
-        placement,
-        descriptor: Object.assign({}, descriptor),
-      }
-      if (kind !== "field") {
-        this.disallowProperty(elementObject, "initializer", "A method descriptor")
-      } else {
-        this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor")
-        this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor")
-        this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor")
-        element.initializer = elementObject.initializer
-      }
-      return element
-    },
-    toElementFinisherExtras(elementObject /* : ElementObject */) /* : ElementFinisherExtras */ {
-      var element /* : ElementDescriptor */ = this.toElementDescriptor(elementObject)
-      var finisher /* : ClassFinisher */ = _optionalCallableProperty(elementObject, "finisher")
-      var extras /* : ElementDescriptors[] */ = this.toElementDescriptors(elementObject.extras)
-      return { element, finisher, extras }
-    },
-    // FromClassDescriptor
-    fromClassDescriptor(elements /* : ElementDescriptor[] */) /* : ClassObject */ {
-      var obj = {
-        kind: "class",
-        elements: elements.map(this.fromElementDescriptor, this),
-      }
-      var desc = { value: "Descriptor", configurable: true }
-      Object.defineProperty(obj, Symbol.toStringTag, desc)
-      return obj
-    },
-    // ToClassDescriptor
-    toClassDescriptor(obj /* : ClassObject */) /* : ElementsFinisher */ {
-      var kind = String(obj.kind)
-      if (kind !== "class") {
-        throw new TypeError(
-          `${
-            'A class descriptor\'s .kind property must be "class", but a decorator' +
-            ' created a class descriptor with .kind "'
-          }${kind}"`,
-        )
-      }
-      this.disallowProperty(obj, "key", "A class descriptor")
-      this.disallowProperty(obj, "placement", "A class descriptor")
-      this.disallowProperty(obj, "descriptor", "A class descriptor")
-      this.disallowProperty(obj, "initializer", "A class descriptor")
-      this.disallowProperty(obj, "extras", "A class descriptor")
-      var finisher = _optionalCallableProperty(obj, "finisher")
-      var elements = this.toElementDescriptors(obj.elements)
-      return { elements, finisher }
-    },
-    // RunClassFinishers
-    runClassFinishers(
-      constructor /* : Class<*> */,
-      finishers /* : ClassFinisher[] */,
-    ) /* : Class<*> */ {
-      for (var i = 0; i < finishers.length; i++) {
-        var newConstructor /* : ?Class<*> */ = (0, finishers[i])(constructor)
-        if (newConstructor !== undefined) {
-          // NOTE: This should check if IsConstructor(newConstructor) is false.
-          if (typeof newConstructor !== "function") {
-            throw new TypeError("Finishers must return a constructor.")
-          }
-          constructor = newConstructor
-        }
-      }
-      return constructor
-    },
-    disallowProperty(obj, name, objectType) {
-      if (obj[name] !== undefined) {
-        throw new TypeError(`${objectType} can't have a .${name} property.`)
-      }
-    },
-  }
-  _getDecoratorsApi = function () {
-    return api
-  }
-  return api
-}
-
-// ClassElementEvaluation
-function _createElementDescriptor(def /* : ElementDefinition */) /* : ElementDescriptor */ {
-  var key = toPropertyKey(def.key)
-  var descriptor /* : PropertyDescriptor */
-  if (def.kind === "method") {
-    descriptor = {
-      value: def.value,
-      writable: true,
-      configurable: true,
-      enumerable: false,
-    }
-  } else if (def.kind === "get") {
-    descriptor = { get: def.value, configurable: true, enumerable: false }
-  } else if (def.kind === "set") {
-    descriptor = { set: def.value, configurable: true, enumerable: false }
-  } else if (def.kind === "field") {
-    descriptor = { configurable: true, writable: true, enumerable: true }
-  }
-  var element /* : ElementDescriptor */ = {
-    kind: def.kind === "field" ? "field" : "method",
-    key,
-    placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype",
-    descriptor,
-  }
-  if (def.decorators) element.decorators = def.decorators
-  if (def.kind === "field") element.initializer = def.value
-  return element
-}
-// CoalesceGetterSetter
-function _coalesceGetterSetter(element /* : ElementDescriptor */, other /* : ElementDescriptor */) {
-  if (element.descriptor.get !== undefined) {
-    other.descriptor.get = element.descriptor.get
-  } else {
-    other.descriptor.set = element.descriptor.set
-  }
-}
-// CoalesceClassElements
-function _coalesceClassElements(elements /* : ElementDescriptor[] */) /* : ElementDescriptor[] */ {
-  var newElements /* : ElementDescriptor[] */ = []
-  var isSameElement = function (other /* : ElementDescriptor */) /* : boolean */ {
-    return (
-      other.kind === "method" && other.key === element.key && other.placement === element.placement
-    )
-  }
-  for (var i = 0; i < elements.length; i++) {
-    var element /* : ElementDescriptor */ = elements[i]
-    var other /* : ElementDescriptor */
-    if (element.kind === "method" && (other = newElements.find(isSameElement))) {
-      if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {
-        if (_hasDecorators(element) || _hasDecorators(other)) {
-          throw new ReferenceError(`Duplicated methods (${element.key}) can't be decorated.`)
-        }
-        other.descriptor = element.descriptor
-      } else {
-        if (_hasDecorators(element)) {
-          if (_hasDecorators(other)) {
-            throw new ReferenceError(
-              `${
-                "Decorators can't be placed on different accessors with for " +
-                "the same property ("
-              }${element.key}).`,
-            )
-          }
-          other.decorators = element.decorators
-        }
-        _coalesceGetterSetter(element, other)
-      }
-    } else {
-      newElements.push(element)
-    }
-  }
-  return newElements
-}
-function _hasDecorators(element /* : ElementDescriptor */) /* : boolean */ {
-  return element.decorators && element.decorators.length
-}
-function _isDataDescriptor(desc /* : PropertyDescriptor */) /* : boolean */ {
-  return desc !== undefined && !(desc.value === undefined && desc.writable === undefined)
-}
-function _optionalCallableProperty /* ::<T>*/(
-  obj /* : T */,
-  name /* : $Keys<T> */,
-) /* : ?Function */ {
-  var value = obj[name]
-  if (value !== undefined && typeof value !== "function") {
-    throw new TypeError(`Expected '${name}' to be a function`)
-  }
-  return value
-}