FM / esm

/var/www/flurhymez/node_modules/@babel/runtime/helpers/esm/

/var/www/flurhymez/node_modules/@babel/runtime/helpers/esm

Name	Size	Mode	Actions
applyDecoratedDescriptor.js	800	0644	edit dl rm
arrayLikeToArray.js	212	0644	edit dl rm
arrayWithHoles.js	86	0644	edit dl rm
arrayWithoutHoles.js	161	0644	edit dl rm
assertThisInitialized.js	192	0644	edit dl rm
AsyncGenerator.js	2010	0644	edit dl rm
asyncGeneratorDelegate.js	1013	0644	edit dl rm
asyncIterator.js	1761	0644	edit dl rm
asyncToGenerator.js	787	0644	edit dl rm
awaitAsyncGenerator.js	129	0644	edit dl rm
AwaitValue.js	70	0644	edit dl rm
checkPrivateRedeclaration.js	209	0644	edit dl rm
classApplyDescriptorDestructureSet.js	458	0644	edit dl rm
classApplyDescriptorGet.js	172	0644	edit dl rm
classApplyDescriptorSet.js	302	0644	edit dl rm
classCallCheck.js	176	0644	edit dl rm
classCheckPrivateStaticAccess.js	199	0644	edit dl rm
classCheckPrivateStaticFieldDescriptor.js	225	0644	edit dl rm
classExtractFieldDescriptor.js	247	0644	edit dl rm
classNameTDZError.js	145	0644	edit dl rm
classPrivateFieldDestructureSet.js	392	0644	edit dl rm
classPrivateFieldGet.js	348	0644	edit dl rm
classPrivateFieldInitSpec.js	226	0644	edit dl rm
classPrivateFieldLooseBase.js	240	0644	edit dl rm
classPrivateFieldLooseKey.js	110	0644	edit dl rm
classPrivateFieldSet.js	371	0644	edit dl rm
classPrivateMethodGet.js	204	0644	edit dl rm
classPrivateMethodInitSpec.js	213	0644	edit dl rm
classPrivateMethodSet.js	115	0644	edit dl rm
classStaticPrivateFieldDestructureSet.js	563	0644	edit dl rm
classStaticPrivateFieldSpecGet.js	523	0644	edit dl rm
classStaticPrivateFieldSpecSet.js	546	0644	edit dl rm
classStaticPrivateMethodGet.js	250	0644	edit dl rm
classStaticPrivateMethodSet.js	132	0644	edit dl rm
construct.js	608	0644	edit dl rm
createClass.js	579	0644	edit dl rm
createForOfIteratorHelper.js	1399	0644	edit dl rm
createForOfIteratorHelperLoose.js	768	0644	edit dl rm
createSuper.js	682	0644	edit dl rm
decorate.js	13341	0644	edit dl rm
defaults.js	370	0644	edit dl rm
defineEnumerableProperties.js	649	0644	edit dl rm
defineProperty.js	269	0644	edit dl rm
extends.js	397	0644	edit dl rm
get.js	556	0644	edit dl rm
getPrototypeOf.js	230	0644	edit dl rm
inherits.js	490	0644	edit dl rm
inheritsLoose.js	259	0644	edit dl rm
initializerDefineProperty.js	369	0644	edit dl rm
initializerWarningHelper.js	232	0644	edit dl rm
instanceof.js	232	0644	edit dl rm
interopRequireDefault.js	120	0644	edit dl rm
interopRequireWildcard.js	1344	0644	edit dl rm
isNativeFunction.js	118	0644	edit dl rm
isNativeReflectConstruct.js	369	0644	edit dl rm
iterableToArray.js	175	0644	edit dl rm
iterableToArrayLimit.js	607	0644	edit dl rm
iterableToArrayLimitLoose.js	354	0644	edit dl rm
jsx.js	1110	0644	edit dl rm
maybeArrayLike.js	304	0644	edit dl rm
newArrowCheck.js	166	0644	edit dl rm
nonIterableRest.js	210	0644	edit dl rm
nonIterableSpread.js	207	0644	edit dl rm
objectDestructuringEmpty.js	130	0644	edit dl rm
objectSpread.js	615	0644	edit dl rm
objectSpread2.js	1069	0644	edit dl rm
objectWithoutProperties.js	635	0644	edit dl rm
objectWithoutPropertiesLoose.js	350	0644	edit dl rm
package.json	22	0644	edit dl rm
possibleConstructorReturn.js	436	0644	edit dl rm
readOnlyError.js	104	0644	edit dl rm
set.js	1240	0644	edit dl rm
setPrototypeOf.js	200	0644	edit dl rm
skipFirstGeneratorNext.js	153	0644	edit dl rm
slicedToArray.js	409	0644	edit dl rm
slicedToArrayLoose.js	429	0644	edit dl rm
superPropBase.js	269	0644	edit dl rm
taggedTemplateLiteral.js	225	0644	edit dl rm
taggedTemplateLiteralLoose.js	155	0644	edit dl rm
tdz.js	118	0644	edit dl rm
temporalRef.js	165	0644	edit dl rm
temporalUndefined.js	47	0644	edit dl rm
toArray.js	379	0644	edit dl rm
toConsumableArray.js	404	0644	edit dl rm
toPrimitive.js	473	0644	edit dl rm
toPropertyKey.js	240	0644	edit dl rm
typeof.js	433	0644	edit dl rm
unsupportedIterableToArray.js	495	0644	edit dl rm
wrapAsyncGenerator.js	187	0644	edit dl rm
wrapNativeSuper.js	1087	0644	edit dl rm
wrapRegExp.js	1822	0644	edit dl rm
writeOnlyError.js	106	0644	edit dl rm

Edit: /var/www/flurhymez/node_modules/@babel/runtime/helpers/esm/decorate.js (13341B)

import toArray from "./toArray.js";
import toPropertyKey from "./toPropertyKey.js";
export default function _decorate(decorators, factory, superClass, mixins) {
  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);
}

function _getDecoratorsApi() {
  _getDecoratorsApi = function _getDecoratorsApi() {
    return api;
  };

if (element.kind === kind && (placement === "static" || placement === "prototype")) {
            var receiver = placement === "static" ? F : proto;
            this.defineClassElement(receiver, element);
          }
        }, this);
      }, this);
    },
    defineClassElement: 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);
    },
    decorateClass: function decorateClass(elements, decorators) {
      var newElements = [];
      var finishers = [];
      var placements = {
        "static": [],
        prototype: [],
        own: []
      };
      elements.forEach(function (element) {
        this.addElementPlacement(element, placements);
      }, this);
      elements.forEach(function (element) {
        if (!_hasDecorators(element)) return newElements.push(element);
        var 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: finishers
        };
      }

var result = this.decorateConstructor(newElements, decorators);
      finishers.push.apply(finishers, result.finishers);
      result.finishers = finishers;
      return result;
    },
    addElementPlacement: 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);
    },
    decorateElement: 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 = this.fromElementDescriptor(element);
        var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
        element = elementFinisherExtras.element;
        this.addElementPlacement(element, placements);

if (elementFinisherExtras.finisher) {
          finishers.push(elementFinisherExtras.finisher);
        }

var newExtras = elementFinisherExtras.extras;

if (newExtras) {
          for (var j = 0; j < newExtras.length; j++) {
            this.addElementPlacement(newExtras[j], placements);
          }

extras.push.apply(extras, newExtras);
        }
      }

return {
        element: element,
        finishers: finishers,
        extras: extras
      };
    },
    decorateConstructor: function decorateConstructor(elements, decorators) {
      var finishers = [];

for (var i = decorators.length - 1; i >= 0; i--) {
        var obj = this.fromClassDescriptor(elements);
        var elementsAndFinisher = this.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
      };
    },
    fromElementDescriptor: 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;
    },
    toElementDescriptors: function toElementDescriptors(elementObjects) {
      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: 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;
      this.disallowProperty(elementObject, "elements", "An element descriptor");
      var element = {
        kind: kind,
        key: key,
        placement: 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: function toElementFinisherExtras(elementObject) {
      var element = this.toElementDescriptor(elementObject);

var finisher = _optionalCallableProperty(elementObject, "finisher");

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: elements,
        finisher: finisher
      };
    },
    runClassFinishers: 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;
    },
    disallowProperty: function disallowProperty(obj, name, objectType) {
      if (obj[name] !== undefined) {
        throw new TypeError(objectType + " can't have a ." + name + " property.");
      }
    }
  };
  return api;
}

function _createElementDescriptor(def) {
  var key = toPropertyKey(def.key);
  var descriptor;

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 = {
    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 _optionalCallableProperty(obj, name) {
  var value = obj[name];

if (value !== undefined && typeof value !== "function") {
    throw new TypeError("Expected '" + name + "' to be a function");
  }

return value;
}

cmd: