watermark-js-plus 1.6.0 → 1.6.2

package/dist/ie/es/node_modules/core-js/internals/to-primitive.js

@@ -0,0 +1,42 @@
+import { __require as requireFunctionCall } from './function-call.js';
+import { __require as requireIsObject } from './is-object.js';
+import { __require as requireIsSymbol } from './is-symbol.js';
+import { __require as requireGetMethod } from './get-method.js';
+import { __require as requireOrdinaryToPrimitive } from './ordinary-to-primitive.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var toPrimitive;
+var hasRequiredToPrimitive;
+
+function requireToPrimitive () {
+	if (hasRequiredToPrimitive) return toPrimitive;
+	hasRequiredToPrimitive = 1;
+	var call = requireFunctionCall();
+	var isObject = requireIsObject();
+	var isSymbol = requireIsSymbol();
+	var getMethod = requireGetMethod();
+	var ordinaryToPrimitive = requireOrdinaryToPrimitive();
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var $TypeError = TypeError;
+	var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+
+	// `ToPrimitive` abstract operation
+	// https://tc39.es/ecma262/#sec-toprimitive
+	toPrimitive = function (input, pref) {
+	  if (!isObject(input) || isSymbol(input)) return input;
+	  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+	  var result;
+	  if (exoticToPrim) {
+	    if (pref === undefined) pref = 'default';
+	    result = call(exoticToPrim, input, pref);
+	    if (!isObject(result) || isSymbol(result)) return result;
+	    throw new $TypeError("Can't convert object to primitive value");
+	  }
+	  if (pref === undefined) pref = 'number';
+	  return ordinaryToPrimitive(input, pref);
+	};
+	return toPrimitive;
+}
+
+export { requireToPrimitive as __require };

package/dist/ie/es/node_modules/core-js/internals/to-property-key.js

@@ -0,0 +1,22 @@
+import { __require as requireToPrimitive } from './to-primitive.js';
+import { __require as requireIsSymbol } from './is-symbol.js';
+
+var toPropertyKey;
+var hasRequiredToPropertyKey;
+
+function requireToPropertyKey () {
+	if (hasRequiredToPropertyKey) return toPropertyKey;
+	hasRequiredToPropertyKey = 1;
+	var toPrimitive = requireToPrimitive();
+	var isSymbol = requireIsSymbol();
+
+	// `ToPropertyKey` abstract operation
+	// https://tc39.es/ecma262/#sec-topropertykey
+	toPropertyKey = function (argument) {
+	  var key = toPrimitive(argument, 'string');
+	  return isSymbol(key) ? key : key + '';
+	};
+	return toPropertyKey;
+}
+
+export { requireToPropertyKey as __require };

package/dist/ie/es/node_modules/core-js/internals/to-string-tag-support.js

@@ -0,0 +1,20 @@
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var toStringTagSupport;
+var hasRequiredToStringTagSupport;
+
+function requireToStringTagSupport () {
+	if (hasRequiredToStringTagSupport) return toStringTagSupport;
+	hasRequiredToStringTagSupport = 1;
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+	var test = {};
+
+	test[TO_STRING_TAG] = 'z';
+
+	toStringTagSupport = String(test) === '[object z]';
+	return toStringTagSupport;
+}
+
+export { requireToStringTagSupport as __require };

package/dist/ie/es/node_modules/core-js/internals/try-to-string.js

@@ -0,0 +1,19 @@
+var tryToString;
+var hasRequiredTryToString;
+
+function requireTryToString () {
+	if (hasRequiredTryToString) return tryToString;
+	hasRequiredTryToString = 1;
+	var $String = String;
+
+	tryToString = function (argument) {
+	  try {
+	    return $String(argument);
+	  } catch (error) {
+	    return 'Object';
+	  }
+	};
+	return tryToString;
+}
+
+export { requireTryToString as __require };

package/dist/ie/es/node_modules/core-js/internals/uid.js

@@ -0,0 +1,21 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+
+var uid;
+var hasRequiredUid;
+
+function requireUid () {
+	if (hasRequiredUid) return uid;
+	hasRequiredUid = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	var id = 0;
+	var postfix = Math.random();
+	var toString = uncurryThis(1.0.toString);
+
+	uid = function (key) {
+	  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
+	};
+	return uid;
+}
+
+export { requireUid as __require };

package/dist/ie/es/node_modules/core-js/internals/use-symbol-as-uid.js

@@ -0,0 +1,18 @@
+import { __require as requireSymbolConstructorDetection } from './symbol-constructor-detection.js';
+
+var useSymbolAsUid;
+var hasRequiredUseSymbolAsUid;
+
+function requireUseSymbolAsUid () {
+	if (hasRequiredUseSymbolAsUid) return useSymbolAsUid;
+	hasRequiredUseSymbolAsUid = 1;
+	/* eslint-disable es/no-symbol -- required for testing */
+	var NATIVE_SYMBOL = requireSymbolConstructorDetection();
+
+	useSymbolAsUid = NATIVE_SYMBOL &&
+	  !Symbol.sham &&
+	  typeof Symbol.iterator == 'symbol';
+	return useSymbolAsUid;
+}
+
+export { requireUseSymbolAsUid as __require };

package/dist/ie/es/node_modules/core-js/internals/v8-prototype-define-bug.js

@@ -0,0 +1,25 @@
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireFails } from './fails.js';
+
+var v8PrototypeDefineBug;
+var hasRequiredV8PrototypeDefineBug;
+
+function requireV8PrototypeDefineBug () {
+	if (hasRequiredV8PrototypeDefineBug) return v8PrototypeDefineBug;
+	hasRequiredV8PrototypeDefineBug = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var fails = requireFails();
+
+	// V8 ~ Chrome 36-
+	// https://bugs.chromium.org/p/v8/issues/detail?id=3334
+	v8PrototypeDefineBug = DESCRIPTORS && fails(function () {
+	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+	  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
+	    value: 42,
+	    writable: false
+	  }).prototype !== 42;
+	});
+	return v8PrototypeDefineBug;
+}
+
+export { requireV8PrototypeDefineBug as __require };

package/dist/ie/es/node_modules/core-js/internals/validate-arguments-length.js

@@ -0,0 +1,16 @@
+var validateArgumentsLength;
+var hasRequiredValidateArgumentsLength;
+
+function requireValidateArgumentsLength () {
+	if (hasRequiredValidateArgumentsLength) return validateArgumentsLength;
+	hasRequiredValidateArgumentsLength = 1;
+	var $TypeError = TypeError;
+
+	validateArgumentsLength = function (passed, required) {
+	  if (passed < required) throw new $TypeError('Not enough arguments');
+	  return passed;
+	};
+	return validateArgumentsLength;
+}
+
+export { requireValidateArgumentsLength as __require };

package/dist/ie/es/node_modules/core-js/internals/weak-map-basic-detection.js

@@ -0,0 +1,19 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireIsCallable } from './is-callable.js';
+
+var weakMapBasicDetection;
+var hasRequiredWeakMapBasicDetection;
+
+function requireWeakMapBasicDetection () {
+	if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
+	hasRequiredWeakMapBasicDetection = 1;
+	var globalThis = requireGlobalThis();
+	var isCallable = requireIsCallable();
+
+	var WeakMap = globalThis.WeakMap;
+
+	weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
+	return weakMapBasicDetection;
+}
+
+export { requireWeakMapBasicDetection as __require };

package/dist/ie/es/node_modules/core-js/internals/well-known-symbol.js

@@ -0,0 +1,35 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireShared } from './shared.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireUid } from './uid.js';
+import { __require as requireSymbolConstructorDetection } from './symbol-constructor-detection.js';
+import { __require as requireUseSymbolAsUid } from './use-symbol-as-uid.js';
+
+var wellKnownSymbol;
+var hasRequiredWellKnownSymbol;
+
+function requireWellKnownSymbol () {
+	if (hasRequiredWellKnownSymbol) return wellKnownSymbol;
+	hasRequiredWellKnownSymbol = 1;
+	var globalThis = requireGlobalThis();
+	var shared = requireShared();
+	var hasOwn = requireHasOwnProperty();
+	var uid = requireUid();
+	var NATIVE_SYMBOL = requireSymbolConstructorDetection();
+	var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
+
+	var Symbol = globalThis.Symbol;
+	var WellKnownSymbolsStore = shared('wks');
+	var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
+
+	wellKnownSymbol = function (name) {
+	  if (!hasOwn(WellKnownSymbolsStore, name)) {
+	    WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
+	      ? Symbol[name]
+	      : createWellKnownSymbol('Symbol.' + name);
+	  } return WellKnownSymbolsStore[name];
+	};
+	return wellKnownSymbol;
+}
+
+export { requireWellKnownSymbol as __require };

package/dist/ie/es/node_modules/core-js/modules/es.array.fill.js

@@ -0,0 +1,26 @@
+import { __exports as es_array_fill } from '../../../_virtual/es.array.fill2.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireArrayFill } from '../internals/array-fill.js';
+import { __require as requireAddToUnscopables } from '../internals/add-to-unscopables.js';
+
+var hasRequiredEs_array_fill;
+
+function requireEs_array_fill () {
+	if (hasRequiredEs_array_fill) return es_array_fill;
+	hasRequiredEs_array_fill = 1;
+	var $ = require_export();
+	var fill = requireArrayFill();
+	var addToUnscopables = requireAddToUnscopables();
+
+	// `Array.prototype.fill` method
+	// https://tc39.es/ecma262/#sec-array.prototype.fill
+	$({ target: 'Array', proto: true }, {
+	  fill: fill
+	});
+
+	// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+	addToUnscopables('fill');
+	return es_array_fill;
+}
+
+export { requireEs_array_fill as __require };

package/dist/ie/es/node_modules/core-js/modules/es.array.from.js

@@ -0,0 +1,28 @@
+import { __exports as es_array_from } from '../../../_virtual/es.array.from2.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireArrayFrom } from '../internals/array-from.js';
+import { __require as requireCheckCorrectnessOfIteration } from '../internals/check-correctness-of-iteration.js';
+
+var hasRequiredEs_array_from;
+
+function requireEs_array_from () {
+	if (hasRequiredEs_array_from) return es_array_from;
+	hasRequiredEs_array_from = 1;
+	var $ = require_export();
+	var from = requireArrayFrom();
+	var checkCorrectnessOfIteration = requireCheckCorrectnessOfIteration();
+
+	var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
+	  // eslint-disable-next-line es/no-array-from -- required for testing
+	  Array.from(iterable);
+	});
+
+	// `Array.from` method
+	// https://tc39.es/ecma262/#sec-array.from
+	$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
+	  from: from
+	});
+	return es_array_from;
+}
+
+export { requireEs_array_from as __require };

package/dist/ie/es/node_modules/core-js/modules/es.array.includes.js

@@ -0,0 +1,36 @@
+import { __exports as es_array_includes } from '../../../_virtual/es.array.includes2.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireArrayIncludes } from '../internals/array-includes.js';
+import { __require as requireFails } from '../internals/fails.js';
+import { __require as requireAddToUnscopables } from '../internals/add-to-unscopables.js';
+
+var hasRequiredEs_array_includes;
+
+function requireEs_array_includes () {
+	if (hasRequiredEs_array_includes) return es_array_includes;
+	hasRequiredEs_array_includes = 1;
+	var $ = require_export();
+	var $includes = requireArrayIncludes().includes;
+	var fails = requireFails();
+	var addToUnscopables = requireAddToUnscopables();
+
+	// FF99+ bug
+	var BROKEN_ON_SPARSE = fails(function () {
+	  // eslint-disable-next-line es/no-array-prototype-includes -- detection
+	  return !Array(1).includes();
+	});
+
+	// `Array.prototype.includes` method
+	// https://tc39.es/ecma262/#sec-array.prototype.includes
+	$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
+	  includes: function includes(el /* , fromIndex = 0 */) {
+	    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
+	  }
+	});
+
+	// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+	addToUnscopables('includes');
+	return es_array_includes;
+}
+
+export { requireEs_array_includes as __require };

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

@@ -0,0 +1,56 @@
+import { __exports as es_promise_all } from '../../../_virtual/es.promise.all.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_all;
+
+function requireEs_promise_all () {
+	if (hasRequiredEs_promise_all) return es_promise_all;
+	hasRequiredEs_promise_all = 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.all` method
+	// https://tc39.es/ecma262/#sec-promise.all
+	$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
+	  all: function all(iterable) {
+	    var C = this;
+	    var capability = newPromiseCapabilityModule.f(C);
+	    var resolve = capability.resolve;
+	    var reject = capability.reject;
+	    var result = perform(function () {
+	      var $promiseResolve = aCallable(C.resolve);
+	      var values = [];
+	      var counter = 0;
+	      var remaining = 1;
+	      iterate(iterable, function (promise) {
+	        var index = counter++;
+	        var alreadyCalled = false;
+	        remaining++;
+	        call($promiseResolve, C, promise).then(function (value) {
+	          if (alreadyCalled) return;
+	          alreadyCalled = true;
+	          values[index] = value;
+	          --remaining || resolve(values);
+	        }, reject);
+	      });
+	      --remaining || resolve(values);
+	    });
+	    if (result.error) reject(result.value);
+	    return capability.promise;
+	  }
+	});
+	return es_promise_all;
+}
+
+export { requireEs_promise_all as __require };

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

@@ -0,0 +1,43 @@
+import { __exports as es_promise_catch } from '../../../_virtual/es.promise.catch.js';
+import { __require as require_export } from '../internals/export.js';
+import { __require as requireIsPure } from '../internals/is-pure.js';
+import { __require as requirePromiseConstructorDetection } from '../internals/promise-constructor-detection.js';
+import { __require as requirePromiseNativeConstructor } from '../internals/promise-native-constructor.js';
+import { __require as requireGetBuiltIn } from '../internals/get-built-in.js';
+import { __require as requireIsCallable } from '../internals/is-callable.js';
+import { __require as requireDefineBuiltIn } from '../internals/define-built-in.js';
+
+var hasRequiredEs_promise_catch;
+
+function requireEs_promise_catch () {
+	if (hasRequiredEs_promise_catch) return es_promise_catch;
+	hasRequiredEs_promise_catch = 1;
+	var $ = require_export();
+	var IS_PURE = requireIsPure();
+	var FORCED_PROMISE_CONSTRUCTOR = requirePromiseConstructorDetection().CONSTRUCTOR;
+	var NativePromiseConstructor = requirePromiseNativeConstructor();
+	var getBuiltIn = requireGetBuiltIn();
+	var isCallable = requireIsCallable();
+	var defineBuiltIn = requireDefineBuiltIn();
+
+	var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
+
+	// `Promise.prototype.catch` method
+	// https://tc39.es/ecma262/#sec-promise.prototype.catch
+	$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {
+	  'catch': function (onRejected) {
+	    return this.then(undefined, onRejected);
+	  }
+	});
+
+	// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
+	if (!IS_PURE && isCallable(NativePromiseConstructor)) {
+	  var method = getBuiltIn('Promise').prototype['catch'];
+	  if (NativePromisePrototype['catch'] !== method) {
+	    defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });
+	  }
+	}
+	return es_promise_catch;
+}
+
+export { requireEs_promise_catch as __require };