watermark-js-plus 1.6.0 → 1.6.2

package/dist/ie/es/node_modules/core-js/modules/es.promise.constructor.js

@@ -0,0 +1,323 @@
+import { __exports as es_promise_constructor } from '../../../_virtual/es.promise.constructor.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireIsPure } from '../internals/is-pure.js';
+import { __require as requireEnvironmentIsNode } from '../internals/environment-is-node.js';
+import { __require as requireGlobalThis } from '../internals/global-this.js';
+import { __require as requireFunctionCall } from '../internals/function-call.js';
+import { __require as requireDefineBuiltIn } from '../internals/define-built-in.js';
+import { __require as requireObjectSetPrototypeOf } from '../internals/object-set-prototype-of.js';
+import { __require as requireSetToStringTag } from '../internals/set-to-string-tag.js';
+import { __require as requireSetSpecies } from '../internals/set-species.js';
+import { __require as requireACallable } from '../internals/a-callable.js';
+import { __require as requireIsCallable } from '../internals/is-callable.js';
+import { __require as requireIsObject } from '../internals/is-object.js';
+import { __require as requireAnInstance } from '../internals/an-instance.js';
+import { __require as requireSpeciesConstructor } from '../internals/species-constructor.js';
+import { __require as requireTask } from '../internals/task.js';
+import { __require as requireMicrotask } from '../internals/microtask.js';
+import { __require as requireHostReportErrors } from '../internals/host-report-errors.js';
+import { __require as requirePerform } from '../internals/perform.js';
+import { __require as requireQueue } from '../internals/queue.js';
+import { __require as requireInternalState } from '../internals/internal-state.js';
+import { __require as requirePromiseNativeConstructor } from '../internals/promise-native-constructor.js';
+import { __require as requirePromiseConstructorDetection } from '../internals/promise-constructor-detection.js';
+import { __require as requireNewPromiseCapability } from '../internals/new-promise-capability.js';
+
+var hasRequiredEs_promise_constructor;
+
+function requireEs_promise_constructor () {
+	if (hasRequiredEs_promise_constructor) return es_promise_constructor;
+	hasRequiredEs_promise_constructor = 1;
+	var $ = require_export();
+	var IS_PURE = requireIsPure();
+	var IS_NODE = requireEnvironmentIsNode();
+	var globalThis = requireGlobalThis();
+	var call = requireFunctionCall();
+	var defineBuiltIn = requireDefineBuiltIn();
+	var setPrototypeOf = requireObjectSetPrototypeOf();
+	var setToStringTag = requireSetToStringTag();
+	var setSpecies = requireSetSpecies();
+	var aCallable = requireACallable();
+	var isCallable = requireIsCallable();
+	var isObject = requireIsObject();
+	var anInstance = requireAnInstance();
+	var speciesConstructor = requireSpeciesConstructor();
+	var task = requireTask().set;
+	var microtask = requireMicrotask();
+	var hostReportErrors = requireHostReportErrors();
+	var perform = requirePerform();
+	var Queue = requireQueue();
+	var InternalStateModule = requireInternalState();
+	var NativePromiseConstructor = requirePromiseNativeConstructor();
+	var PromiseConstructorDetection = requirePromiseConstructorDetection();
+	var newPromiseCapabilityModule = requireNewPromiseCapability();
+
+	var PROMISE = 'Promise';
+	var FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;
+	var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
+	var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
+	var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+	var setInternalState = InternalStateModule.set;
+	var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+	var PromiseConstructor = NativePromiseConstructor;
+	var PromisePrototype = NativePromisePrototype;
+	var TypeError = globalThis.TypeError;
+	var document = globalThis.document;
+	var process = globalThis.process;
+	var newPromiseCapability = newPromiseCapabilityModule.f;
+	var newGenericPromiseCapability = newPromiseCapability;
+
+	var DISPATCH_EVENT = !!(document && document.createEvent && globalThis.dispatchEvent);
+	var UNHANDLED_REJECTION = 'unhandledrejection';
+	var REJECTION_HANDLED = 'rejectionhandled';
+	var PENDING = 0;
+	var FULFILLED = 1;
+	var REJECTED = 2;
+	var HANDLED = 1;
+	var UNHANDLED = 2;
+
+	var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
+
+	// helpers
+	var isThenable = function (it) {
+	  var then;
+	  return isObject(it) && isCallable(then = it.then) ? then : false;
+	};
+
+	var callReaction = function (reaction, state) {
+	  var value = state.value;
+	  var ok = state.state === FULFILLED;
+	  var handler = ok ? reaction.ok : reaction.fail;
+	  var resolve = reaction.resolve;
+	  var reject = reaction.reject;
+	  var domain = reaction.domain;
+	  var result, then, exited;
+	  try {
+	    if (handler) {
+	      if (!ok) {
+	        if (state.rejection === UNHANDLED) onHandleUnhandled(state);
+	        state.rejection = HANDLED;
+	      }
+	      if (handler === true) result = value;
+	      else {
+	        if (domain) domain.enter();
+	        result = handler(value); // can throw
+	        if (domain) {
+	          domain.exit();
+	          exited = true;
+	        }
+	      }
+	      if (result === reaction.promise) {
+	        reject(new TypeError('Promise-chain cycle'));
+	      } else if (then = isThenable(result)) {
+	        call(then, result, resolve, reject);
+	      } else resolve(result);
+	    } else reject(value);
+	  } catch (error) {
+	    if (domain && !exited) domain.exit();
+	    reject(error);
+	  }
+	};
+
+	var notify = function (state, isReject) {
+	  if (state.notified) return;
+	  state.notified = true;
+	  microtask(function () {
+	    var reactions = state.reactions;
+	    var reaction;
+	    while (reaction = reactions.get()) {
+	      callReaction(reaction, state);
+	    }
+	    state.notified = false;
+	    if (isReject && !state.rejection) onUnhandled(state);
+	  });
+	};
+
+	var dispatchEvent = function (name, promise, reason) {
+	  var event, handler;
+	  if (DISPATCH_EVENT) {
+	    event = document.createEvent('Event');
+	    event.promise = promise;
+	    event.reason = reason;
+	    event.initEvent(name, false, true);
+	    globalThis.dispatchEvent(event);
+	  } else event = { promise: promise, reason: reason };
+	  if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = globalThis['on' + name])) handler(event);
+	  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
+	};
+
+	var onUnhandled = function (state) {
+	  call(task, globalThis, function () {
+	    var promise = state.facade;
+	    var value = state.value;
+	    var IS_UNHANDLED = isUnhandled(state);
+	    var result;
+	    if (IS_UNHANDLED) {
+	      result = perform(function () {
+	        if (IS_NODE) {
+	          process.emit('unhandledRejection', value, promise);
+	        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
+	      });
+	      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+	      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
+	      if (result.error) throw result.value;
+	    }
+	  });
+	};
+
+	var isUnhandled = function (state) {
+	  return state.rejection !== HANDLED && !state.parent;
+	};
+
+	var onHandleUnhandled = function (state) {
+	  call(task, globalThis, function () {
+	    var promise = state.facade;
+	    if (IS_NODE) {
+	      process.emit('rejectionHandled', promise);
+	    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
+	  });
+	};
+
+	var bind = function (fn, state, unwrap) {
+	  return function (value) {
+	    fn(state, value, unwrap);
+	  };
+	};
+
+	var internalReject = function (state, value, unwrap) {
+	  if (state.done) return;
+	  state.done = true;
+	  if (unwrap) state = unwrap;
+	  state.value = value;
+	  state.state = REJECTED;
+	  notify(state, true);
+	};
+
+	var internalResolve = function (state, value, unwrap) {
+	  if (state.done) return;
+	  state.done = true;
+	  if (unwrap) state = unwrap;
+	  try {
+	    if (state.facade === value) throw new TypeError("Promise can't be resolved itself");
+	    var then = isThenable(value);
+	    if (then) {
+	      microtask(function () {
+	        var wrapper = { done: false };
+	        try {
+	          call(then, value,
+	            bind(internalResolve, wrapper, state),
+	            bind(internalReject, wrapper, state)
+	          );
+	        } catch (error) {
+	          internalReject(wrapper, error, state);
+	        }
+	      });
+	    } else {
+	      state.value = value;
+	      state.state = FULFILLED;
+	      notify(state, false);
+	    }
+	  } catch (error) {
+	    internalReject({ done: false }, error, state);
+	  }
+	};
+
+	// constructor polyfill
+	if (FORCED_PROMISE_CONSTRUCTOR) {
+	  // 25.4.3.1 Promise(executor)
+	  PromiseConstructor = function Promise(executor) {
+	    anInstance(this, PromisePrototype);
+	    aCallable(executor);
+	    call(Internal, this);
+	    var state = getInternalPromiseState(this);
+	    try {
+	      executor(bind(internalResolve, state), bind(internalReject, state));
+	    } catch (error) {
+	      internalReject(state, error);
+	    }
+	  };
+
+	  PromisePrototype = PromiseConstructor.prototype;
+
+	  // eslint-disable-next-line no-unused-vars -- required for `.length`
+	  Internal = function Promise(executor) {
+	    setInternalState(this, {
+	      type: PROMISE,
+	      done: false,
+	      notified: false,
+	      parent: false,
+	      reactions: new Queue(),
+	      rejection: false,
+	      state: PENDING,
+	      value: null
+	    });
+	  };
+
+	  // `Promise.prototype.then` method
+	  // https://tc39.es/ecma262/#sec-promise.prototype.then
+	  Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
+	    var state = getInternalPromiseState(this);
+	    var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
+	    state.parent = true;
+	    reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;
+	    reaction.fail = isCallable(onRejected) && onRejected;
+	    reaction.domain = IS_NODE ? process.domain : undefined;
+	    if (state.state === PENDING) state.reactions.add(reaction);
+	    else microtask(function () {
+	      callReaction(reaction, state);
+	    });
+	    return reaction.promise;
+	  });
+
+	  OwnPromiseCapability = function () {
+	    var promise = new Internal();
+	    var state = getInternalPromiseState(promise);
+	    this.promise = promise;
+	    this.resolve = bind(internalResolve, state);
+	    this.reject = bind(internalReject, state);
+	  };
+
+	  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+	    return C === PromiseConstructor || C === PromiseWrapper
+	      ? new OwnPromiseCapability(C)
+	      : newGenericPromiseCapability(C);
+	  };
+
+	  if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {
+	    nativeThen = NativePromisePrototype.then;
+
+	    if (!NATIVE_PROMISE_SUBCLASSING) {
+	      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
+	      defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
+	        var that = this;
+	        return new PromiseConstructor(function (resolve, reject) {
+	          call(nativeThen, that, resolve, reject);
+	        }).then(onFulfilled, onRejected);
+	      // https://github.com/zloirock/core-js/issues/640
+	      }, { unsafe: true });
+	    }
+
+	    // make `.constructor === Promise` work for native promise-based APIs
+	    try {
+	      delete NativePromisePrototype.constructor;
+	    } catch (error) { /* empty */ }
+
+	    // make `instanceof Promise` work for native promise-based APIs
+	    if (setPrototypeOf) {
+	      setPrototypeOf(NativePromisePrototype, PromisePrototype);
+	    }
+	  }
+	}
+
+	// `Promise` constructor
+	// https://tc39.es/ecma262/#sec-promise-executor
+	$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+	  Promise: PromiseConstructor
+	});
+
+	setToStringTag(PromiseConstructor, PROMISE, false, true);
+	setSpecies(PROMISE);
+	return es_promise_constructor;
+}
+
+export { requireEs_promise_constructor as __require };

package/dist/ie/es/node_modules/core-js/modules/es.promise.js

@@ -0,0 +1,24 @@
+import { __exports as es_promise } from '../../../_virtual/es.promise2.js';
+import { __require as requireEs_promise_constructor } from './es.promise.constructor.js';
+import { __require as requireEs_promise_all } from './es.promise.all.js';
+import { __require as requireEs_promise_catch } from './es.promise.catch.js';
+import { __require as requireEs_promise_race } from './es.promise.race.js';
+import { __require as requireEs_promise_reject } from './es.promise.reject.js';
+import { __require as requireEs_promise_resolve } from './es.promise.resolve.js';
+
+var hasRequiredEs_promise;
+
+function requireEs_promise () {
+	if (hasRequiredEs_promise) return es_promise;
+	hasRequiredEs_promise = 1;
+	// TODO: Remove this module from `core-js@4` since it's split to modules listed below
+	requireEs_promise_constructor();
+	requireEs_promise_all();
+	requireEs_promise_catch();
+	requireEs_promise_race();
+	requireEs_promise_reject();
+	requireEs_promise_resolve();
+	return es_promise;
+}
+
+export { requireEs_promise as __require };

package/dist/ie/es/node_modules/core-js/modules/es.promise.race.js

@@ -0,0 +1,43 @@
+import { __exports as es_promise_race } from '../../../_virtual/es.promise.race.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireFunctionCall } from '../internals/function-call.js';
+import { __require as requireACallable } from '../internals/a-callable.js';
+import { __require as requireNewPromiseCapability } from '../internals/new-promise-capability.js';
+import { __require as requirePerform } from '../internals/perform.js';
+import { __require as requireIterate } from '../internals/iterate.js';
+import { __require as requirePromiseStaticsIncorrectIteration } from '../internals/promise-statics-incorrect-iteration.js';
+
+var hasRequiredEs_promise_race;
+
+function requireEs_promise_race () {
+	if (hasRequiredEs_promise_race) return es_promise_race;
+	hasRequiredEs_promise_race = 1;
+	var $ = require_export();
+	var call = requireFunctionCall();
+	var aCallable = requireACallable();
+	var newPromiseCapabilityModule = requireNewPromiseCapability();
+	var perform = requirePerform();
+	var iterate = requireIterate();
+	var PROMISE_STATICS_INCORRECT_ITERATION = requirePromiseStaticsIncorrectIteration();
+
+	// `Promise.race` method
+	// https://tc39.es/ecma262/#sec-promise.race
+	$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+	  race: function race(iterable) {
+	    var C = this;
+	    var capability = newPromiseCapabilityModule.f(C);
+	    var reject = capability.reject;
+	    var result = perform(function () {
+	      var $promiseResolve = aCallable(C.resolve);
+	      iterate(iterable, function (promise) {
+	        call($promiseResolve, C, promise).then(capability.resolve, reject);
+	      });
+	    });
+	    if (result.error) reject(result.value);
+	    return capability.promise;
+	  }
+	});
+	return es_promise_race;
+}
+
+export { requireEs_promise_race as __require };

package/dist/ie/es/node_modules/core-js/modules/es.promise.reject.js

@@ -0,0 +1,28 @@
+import { __exports as es_promise_reject } from '../../../_virtual/es.promise.reject.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireNewPromiseCapability } from '../internals/new-promise-capability.js';
+import { __require as requirePromiseConstructorDetection } from '../internals/promise-constructor-detection.js';
+
+var hasRequiredEs_promise_reject;
+
+function requireEs_promise_reject () {
+	if (hasRequiredEs_promise_reject) return es_promise_reject;
+	hasRequiredEs_promise_reject = 1;
+	var $ = require_export();
+	var newPromiseCapabilityModule = requireNewPromiseCapability();
+	var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+
+	// `Promise.reject` method
+	// https://tc39.es/ecma262/#sec-promise.reject
+	$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
+	  reject: function reject(r) {
+	    var capability = newPromiseCapabilityModule.f(this);
+	    var capabilityReject = capability.reject;
+	    capabilityReject(r);
+	    return capability.promise;
+	  }
+	});
+	return es_promise_reject;
+}
+
+export { requireEs_promise_reject as __require };

package/dist/ie/es/node_modules/core-js/modules/es.promise.resolve.js

@@ -0,0 +1,34 @@
+import { __exports as es_promise_resolve } from '../../../_virtual/es.promise.resolve.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireGetBuiltIn } from '../internals/get-built-in.js';
+import { __require as requireIsPure } from '../internals/is-pure.js';
+import { __require as requirePromiseNativeConstructor } from '../internals/promise-native-constructor.js';
+import { __require as requirePromiseConstructorDetection } from '../internals/promise-constructor-detection.js';
+import { __require as requirePromiseResolve } from '../internals/promise-resolve.js';
+
+var hasRequiredEs_promise_resolve;
+
+function requireEs_promise_resolve () {
+	if (hasRequiredEs_promise_resolve) return es_promise_resolve;
+	hasRequiredEs_promise_resolve = 1;
+	var $ = require_export();
+	var getBuiltIn = requireGetBuiltIn();
+	var IS_PURE = requireIsPure();
+	var NativePromiseConstructor = requirePromiseNativeConstructor();
+	var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+	var promiseResolve = requirePromiseResolve();
+
+	var PromiseConstructorWrapper = getBuiltIn('Promise');
+	var CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;
+
+	// `Promise.resolve` method
+	// https://tc39.es/ecma262/#sec-promise.resolve
+	$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {
+	  resolve: function resolve(x) {
+	    return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);
+	  }
+	});
+	return es_promise_resolve;
+}
+
+export { requireEs_promise_resolve as __require };

package/dist/ie/es/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,86 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __assign, __awaiter, __extends, __generator };