@jsenv/core 40.3.1 → 40.3.3

package/dist/babel_helpers/decorate/decorate.js

@@ -1,488 +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;
-}

package/dist/babel_helpers/defaults/defaults.js

@@ -1,11 +0,0 @@
-export default function (obj, defaults) {
-  var keys = Object.getOwnPropertyNames(defaults);
-  for (var i = 0; i < keys.length; i++) {
-    var key = keys[i];
-    var value = Object.getOwnPropertyDescriptor(defaults, key);
-    if (value && value.configurable && obj[key] === undefined) {
-      Object.defineProperty(obj, key, value);
-    }
-  }
-  return obj;
-}

package/dist/babel_helpers/defineAccessor/defineAccessor.js

@@ -1,6 +0,0 @@
-export default function _defineAccessor(type, obj, key, fn) {
-  var desc = { configurable: true, enumerable: true };
-  // type should be "get" or "set"
-  desc[type] = fn;
-  return Object.defineProperty(obj, key, desc);
-}

package/dist/babel_helpers/defineEnumerableProperties/defineEnumerableProperties.js

@@ -1,23 +0,0 @@
-export default function (obj, descs) {
-  // eslint-disable-next-line guard-for-in
-  for (var key in descs) {
-    var desc = descs[key];
-    desc.configurable = desc.enumerable = true;
-    if ("value" in desc) desc.writable = true;
-    Object.defineProperty(obj, key, desc);
-  }
-  // Symbols are not enumerated over by for-in loops. If native
-  // Symbols are available, fetch all of the descs object's own
-  // symbol properties and define them on our target object too.
-  if (Object.getOwnPropertySymbols) {
-    var objectSymbols = Object.getOwnPropertySymbols(descs);
-    for (var i = 0; i < objectSymbols.length; i++) {
-      var sym = objectSymbols[i];
-      var symbDesc = descs[sym];
-      symbDesc.configurable = symbDesc.enumerable = true;
-      if ("value" in symbDesc) symbDesc.writable = true;
-      Object.defineProperty(obj, sym, symbDesc);
-    }
-  }
-  return obj;
-}

package/dist/babel_helpers/defineProperty/defineProperty.js

@@ -1,21 +0,0 @@
-import toPropertyKey from "../toPropertyKey/toPropertyKey.js";
-
-export default (obj, key, value) => {
-  key = toPropertyKey(key);
-  // Shortcircuit the slow defineProperty path when possible.
-  // We are trying to avoid issues where setters defined on the
-  // prototype cause side effects under the fast path of simple
-  // assignment. By checking for existence of the property with
-  // the in operator, we can optimize most of this overhead away.
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true,
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-};

package/dist/babel_helpers/dispose/dispose.js

@@ -1,45 +0,0 @@
-/* @minVersion 7.22.0 */
-function dispose_SuppressedError(suppressed, error) {
-  if (typeof SuppressedError !== "undefined") {
-    // eslint-disable-next-line no-undef
-    dispose_SuppressedError = SuppressedError;
-  } else {
-    dispose_SuppressedError = function SuppressedError(suppressed, error) {
-      this.suppressed = suppressed;
-      this.error = error;
-      this.stack = new Error().stack;
-    };
-    dispose_SuppressedError.prototype = Object.create(Error.prototype, {
-      constructor: {
-        value: dispose_SuppressedError,
-        writable: true,
-        configurable: true,
-      },
-    });
-  }
-  return new dispose_SuppressedError(suppressed, error);
-}
-
-export default function _dispose(stack, error, hasError) {
-  function next() {
-    while (stack.length > 0) {
-      try {
-        var r = stack.pop();
-        var p = r.d.call(r.v);
-        if (r.a) return Promise.resolve(p).then(next, err);
-      } catch (e) {
-        return err(e);
-      }
-    }
-    if (hasError) throw error;
-  }
-
-  function err(e) {
-    error = hasError ? new dispose_SuppressedError(e, error) : e;
-    hasError = true;
-
-    return next();
-  }
-
-  return next();
-}

package/dist/babel_helpers/extends/extends.js

@@ -1,14 +0,0 @@
-function assign(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    // eslint-disable-next-line prefer-rest-params
-    var source = arguments[i];
-    for (var key in source) {
-      if (Object.prototype.hasOwnProperty.call(source, key)) {
-        target[key] = source[key];
-      }
-    }
-  }
-  return target;
-}
-
-export default Object.assign ? Object.assign.bind() : assign;

package/dist/babel_helpers/get/get.js

@@ -1,19 +0,0 @@
-import superPropBase from "../superPropBase/superPropBase.js";
-
-export default function _get() {
-  if (typeof Reflect !== "undefined" && Reflect.get) {
-    _get = Reflect.get.bind();
-  } else {
-    _get = function _get(target, property, receiver) {
-      var base = superPropBase(target, property);
-      if (!base) return;
-      var desc = Object.getOwnPropertyDescriptor(base, property);
-      if (desc.get) {
-        // STEP 3. If receiver is not present, then set receiver to target.
-        return desc.get.call(arguments.length < 3 ? target : receiver);
-      }
-      return desc.value;
-    };
-  }
-  return _get.apply(this, arguments);
-}

package/dist/babel_helpers/getPrototypeOf/getPrototypeOf.js

@@ -1,4 +0,0 @@
-export default Object.setPrototypeOf
-  ? Object.getPrototypeOf.bind()
-  : // eslint-disable-next-line no-proto
-    (o) => o.__proto__ || Object.getPrototypeOf(o);

package/dist/babel_helpers/identity/identity.js

@@ -1,3 +0,0 @@
-export default function _identity(x) {
-  return x;
-}

package/dist/babel_helpers/importDeferProxy/importDeferProxy.js

@@ -1,31 +0,0 @@
-/* @minVersion 7.23.0 */
-export default function _importDeferProxy(init) {
-  var ns = null;
-  var constValue = function (v) {
-    return function () {
-      return v;
-    };
-  };
-  var proxy = function (run) {
-    return function (arg1, arg2, arg3) {
-      if (ns === null) ns = init();
-      return run(ns, arg2, arg3);
-    };
-  };
-  return new Proxy(
-    {},
-    {
-      defineProperty: constValue(false),
-      deleteProperty: constValue(false),
-      get: proxy(Reflect.get),
-      getOwnPropertyDescriptor: proxy(Reflect.getOwnPropertyDescriptor),
-      getPrototypeOf: constValue(null),
-      isExtensible: constValue(false),
-      has: proxy(Reflect.has),
-      ownKeys: proxy(Reflect.ownKeys),
-      preventExtensions: constValue(true),
-      set: constValue(false),
-      setPrototypeOf: constValue(false),
-    },
-  );
-}