@swc/core 1.2.107 → 1.2.108

package/crates/swc_ecma_transforms_base/src/helpers/_decorate.js

@@ -0,0 +1,420 @@
+function _decorate(decorators, factory, superClass) {
+  var r = factory(function initialize(O) {
+    _initializeInstanceElements(O, decorated.elements);
+  }, superClass);
+
+  var decorated = _decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);
+
+  _initializeClassElements(r.F, decorated.elements);
+
+  return _runClassFinishers(r.F, decorated.finishers);
+}
+
+function _createElementDescriptor(def) {
+  var key = _toPropertyKey(def.key);
+  var descriptor;
+
+  if (def.kind === "method") {
+    descriptor = {
+      value: def.value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    };
+    Object.defineProperty(def.value, "name", {
+      value: _typeof(key) === "symbol" ? "" : key,
+      configurable: true
+    });
+  } 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 = {
+    kind: def.kind === "field" ? "field" : "method",
+    key: key,
+    placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype",
+    descriptor: descriptor
+  };
+  if (def.decorators) element.decorators = def.decorators;
+  if (def.kind === "field") element.initializer = def.value;
+  return element;
+}
+
+function _coalesceGetterSetter(element, other) {
+  if (element.descriptor.get !== undefined) {
+    other.descriptor.get = element.descriptor.get;
+  } else {
+    other.descriptor.set = element.descriptor.set;
+  }
+}
+
+function _coalesceClassElements(elements) {
+  var newElements = [];
+
+  var isSameElement = function isSameElement(other) {
+    return other.kind === "method" && other.key === element.key && other.placement === element.placement;
+  };
+
+  for (var i = 0; i < elements.length; i++) {
+    var element = elements[i];
+    var other;
+
+    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) {
+  return element.decorators && element.decorators.length;
+}
+
+function _isDataDescriptor(desc) {
+  return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);
+}
+
+function _initializeClassElements(F, elements) {
+  var proto = F.prototype;
+  ["method", "field"].forEach(function (kind) {
+    elements.forEach(function (element) {
+      var placement = element.placement;
+
+      if (element.kind === kind && (placement === "static" || placement === "prototype")) {
+        var receiver = placement === "static" ? F : proto;
+
+        _defineClassElement(receiver, element);
+      }
+    });
+  });
+}
+
+function _initializeInstanceElements(O, elements) {
+  ["method", "field"].forEach(function (kind) {
+    elements.forEach(function (element) {
+      if (element.kind === kind && element.placement === "own") {
+        _defineClassElement(O, element);
+      }
+    });
+  });
+}
+
+function _defineClassElement(receiver, element) {
+  var descriptor = 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);
+}
+
+function _decorateClass(elements, decorators) {
+  var newElements = [];
+  var finishers = [];
+  var placements = {
+    static: [],
+    prototype: [],
+    own: []
+  };
+  elements.forEach(function (element) {
+    _addElementPlacement(element, placements);
+  });
+  elements.forEach(function (element) {
+    if (!_hasDecorators(element)) return newElements.push(element);
+
+    var elementFinishersExtras = _decorateElement(element, placements);
+
+    newElements.push(elementFinishersExtras.element);
+    newElements.push.apply(newElements, elementFinishersExtras.extras);
+    finishers.push.apply(finishers, elementFinishersExtras.finishers);
+  });
+
+  if (!decorators) {
+    return {
+      elements: newElements,
+      finishers: finishers
+    };
+  }
+
+  var result = _decorateConstructor(newElements, decorators);
+
+  finishers.push.apply(finishers, result.finishers);
+  result.finishers = finishers;
+  return result;
+}
+
+function _addElementPlacement(element, placements, silent) {
+  var keys = placements[element.placement];
+
+  if (!silent && keys.indexOf(element.key) !== -1) {
+    throw new TypeError("Duplicated element (" + element.key + ")");
+  }
+
+  keys.push(element.key);
+}
+
+function _decorateElement(element, placements) {
+  var extras = [];
+  var finishers = [];
+
+  for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
+    var keys = placements[element.placement];
+    keys.splice(keys.indexOf(element.key), 1);
+
+    var elementObject = _fromElementDescriptor(element);
+
+    var elementFinisherExtras = _toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
+
+    element = elementFinisherExtras.element;
+
+    _addElementPlacement(element, placements);
+
+    if (elementFinisherExtras.finisher) {
+      finishers.push(elementFinisherExtras.finisher);
+    }
+
+    var newExtras = elementFinisherExtras.extras;
+
+    if (newExtras) {
+      for (var j = 0; j < newExtras.length; j++) {
+        _addElementPlacement(newExtras[j], placements);
+      }
+
+      extras.push.apply(extras, newExtras);
+    }
+  }
+
+  return {
+    element: element,
+    finishers: finishers,
+    extras: extras
+  };
+}
+
+function _decorateConstructor(elements, decorators) {
+  var finishers = [];
+
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var obj = _fromClassDescriptor(elements);
+
+    var elementsAndFinisher = _toClassDescriptor((0, decorators[i])(obj) || 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: elements,
+    finishers: finishers
+  };
+}
+
+function _fromElementDescriptor(element) {
+  var obj = {
+    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;
+}
+
+function _toElementDescriptors(elementObjects) {
+  if (elementObjects === undefined) return;
+  return _toArray(elementObjects).map(function (elementObject) {
+    var element = _toElementDescriptor(elementObject);
+
+    _disallowProperty(elementObject, "finisher", "An element descriptor");
+
+    _disallowProperty(elementObject, "extras", "An element descriptor");
+
+    return element;
+  });
+}
+
+function _toElementDescriptor(elementObject) {
+  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 = elementObject.descriptor;
+
+  _disallowProperty(elementObject, "elements", "An element descriptor");
+
+  var element = {
+    kind: kind,
+    key: key,
+    placement: placement,
+    descriptor: Object.assign({}, descriptor)
+  };
+
+  if (kind !== "field") {
+    _disallowProperty(elementObject, "initializer", "A method descriptor");
+  } else {
+    _disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
+
+    _disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
+
+    _disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
+
+    element.initializer = elementObject.initializer;
+  }
+
+  return element;
+}
+
+function _toElementFinisherExtras(elementObject) {
+  var element = _toElementDescriptor(elementObject);
+
+  var finisher = _optionalCallableProperty(elementObject, "finisher");
+
+  var extras = _toElementDescriptors(elementObject.extras);
+
+  return {
+    element: element,
+    finisher: finisher,
+    extras: extras
+  };
+}
+
+function _fromClassDescriptor(elements) {
+  var obj = {
+    kind: "class",
+    elements: elements.map(_fromElementDescriptor)
+  };
+  var desc = {
+    value: "Descriptor",
+    configurable: true
+  };
+  Object.defineProperty(obj, Symbol.toStringTag, desc);
+  return obj;
+}
+
+function _toClassDescriptor(obj) {
+  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 + '"');
+  }
+
+  _disallowProperty(obj, "key", "A class descriptor");
+
+  _disallowProperty(obj, "placement", "A class descriptor");
+
+  _disallowProperty(obj, "descriptor", "A class descriptor");
+
+  _disallowProperty(obj, "initializer", "A class descriptor");
+
+  _disallowProperty(obj, "extras", "A class descriptor");
+
+  var finisher = _optionalCallableProperty(obj, "finisher");
+
+  var elements = _toElementDescriptors(obj.elements);
+
+  return {
+    elements: elements,
+    finisher: finisher
+  };
+}
+
+function _disallowProperty(obj, name, objectType) {
+  if (obj[name] !== undefined) {
+    throw new TypeError(objectType + " can't have a ." + name + " property.");
+  }
+}
+
+function _optionalCallableProperty(obj, name) {
+  var value = obj[name];
+
+  if (value !== undefined && typeof value !== "function") {
+    throw new TypeError("Expected '" + name + "' to be a function");
+  }
+
+  return value;
+}
+
+function _runClassFinishers(constructor, finishers) {
+  for (var i = 0; i < finishers.length; i++) {
+    var newConstructor = (0, finishers[i])(constructor);
+
+    if (newConstructor !== undefined) {
+      if (typeof newConstructor !== "function") {
+        throw new TypeError("Finishers must return a constructor.");
+      }
+
+      constructor = newConstructor;
+    }
+  }
+
+  return constructor;
+}

package/crates/swc_ecma_transforms_base/src/helpers/_defaults.js

@@ -0,0 +1,14 @@
+function _defaults(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/crates/swc_ecma_transforms_base/src/helpers/_define_enumerable_properties.js

@@ -0,0 +1,22 @@
+function _defineEnumerableProperties(obj, descs) {
+  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);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    var objectSymbols = Object.getOwnPropertySymbols(descs);
+
+    for (var i = 0; i < objectSymbols.length; i++) {
+      var sym = objectSymbols[i];
+      var desc = descs[sym];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, sym, desc);
+    }
+  }
+
+  return obj;
+}

package/crates/swc_ecma_transforms_base/src/helpers/_define_property.js

@@ -0,0 +1,14 @@
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}

package/crates/swc_ecma_transforms_base/src/helpers/_extends.js

@@ -0,0 +1,17 @@
+function _extends() {
+  _extends = Object.assign || 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);
+}

package/crates/swc_ecma_transforms_base/src/helpers/_get.js

@@ -0,0 +1,19 @@
+function _get(target, property, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.get) {
+    _get = Reflect.get;
+  } else {
+    _get = function _get(target, property, receiver) {
+      var base = _superPropBase(target, property);
+      if (!base) return;
+      var desc = Object.getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        return desc.get.call(receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get(target, property, receiver || target);
+}

package/crates/swc_ecma_transforms_base/src/helpers/_get_prototype_of.js

@@ -0,0 +1,6 @@
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}

package/crates/swc_ecma_transforms_base/src/helpers/_inherits.js

@@ -0,0 +1,14 @@
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}

package/crates/swc_ecma_transforms_base/src/helpers/_inherits_loose.js

@@ -0,0 +1,5 @@
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  subClass.__proto__ = superClass;
+}

package/crates/swc_ecma_transforms_base/src/helpers/_initializer_define_property.js

@@ -0,0 +1,9 @@
+function _initializerDefineProperty(target, property, descriptor, context) {
+  if (!descriptor) return;
+  Object.defineProperty(target, property, {
+    enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable,
+    writable: descriptor.writable,
+    value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+  });
+}

package/crates/swc_ecma_transforms_base/src/helpers/_initializer_warning_helper.js

@@ -0,0 +1,3 @@
+function _initializerWarningHelper(descriptor, context) {
+  throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and set to use loose mode. ' + 'To use proposal-class-properties in spec mode with decorators, wait for ' + 'the next major version of decorators in stage 2.');
+}

package/crates/swc_ecma_transforms_base/src/helpers/_instanceof.js

@@ -0,0 +1,7 @@
+function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}

package/crates/swc_ecma_transforms_base/src/helpers/_interop_require_default.js

@@ -0,0 +1,5 @@
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}

package/crates/swc_ecma_transforms_base/src/helpers/_interop_require_wildcard.js

@@ -0,0 +1,24 @@
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
+
+          if (desc.get || desc.set) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+    }
+
+    newObj.default = obj;
+    return newObj;
+  }
+}

package/crates/swc_ecma_transforms_base/src/helpers/_is_native_function.js

@@ -0,0 +1,3 @@
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}

package/crates/swc_ecma_transforms_base/src/helpers/_is_native_reflect_construct.js

@@ -0,0 +1,11 @@
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () { }));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}

package/crates/swc_ecma_transforms_base/src/helpers/_iterable_to_array.js

@@ -0,0 +1,3 @@
+function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}

package/crates/swc_ecma_transforms_base/src/helpers/_iterable_to_array_limit.js

@@ -0,0 +1,25 @@
+function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}

package/crates/swc_ecma_transforms_base/src/helpers/_iterable_to_array_limit_loose.js

@@ -0,0 +1,11 @@
+function _iterableToArrayLimitLoose(arr, i) {
+  var _arr = [];
+
+  for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+    _arr.push(_step.value);
+
+    if (i && _arr.length === i) break;
+  }
+
+  return _arr;
+}