watermark-js-plus 1.6.0 → 1.6.2

package/dist/ie/es/node_modules/core-js/internals/internal-state.js

@@ -0,0 +1,89 @@
+import { __require as requireWeakMapBasicDetection } from './weak-map-basic-detection.js';
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireIsObject } from './is-object.js';
+import { __require as requireCreateNonEnumerableProperty } from './create-non-enumerable-property.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireSharedStore } from './shared-store.js';
+import { __require as requireSharedKey } from './shared-key.js';
+import { __require as requireHiddenKeys } from './hidden-keys.js';
+
+var internalState;
+var hasRequiredInternalState;
+
+function requireInternalState () {
+	if (hasRequiredInternalState) return internalState;
+	hasRequiredInternalState = 1;
+	var NATIVE_WEAK_MAP = requireWeakMapBasicDetection();
+	var globalThis = requireGlobalThis();
+	var isObject = requireIsObject();
+	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+	var hasOwn = requireHasOwnProperty();
+	var shared = requireSharedStore();
+	var sharedKey = requireSharedKey();
+	var hiddenKeys = requireHiddenKeys();
+
+	var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+	var TypeError = globalThis.TypeError;
+	var WeakMap = globalThis.WeakMap;
+	var set, get, has;
+
+	var enforce = function (it) {
+	  return has(it) ? get(it) : set(it, {});
+	};
+
+	var getterFor = function (TYPE) {
+	  return function (it) {
+	    var state;
+	    if (!isObject(it) || (state = get(it)).type !== TYPE) {
+	      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
+	    } return state;
+	  };
+	};
+
+	if (NATIVE_WEAK_MAP || shared.state) {
+	  var store = shared.state || (shared.state = new WeakMap());
+	  /* eslint-disable no-self-assign -- prototype methods protection */
+	  store.get = store.get;
+	  store.has = store.has;
+	  store.set = store.set;
+	  /* eslint-enable no-self-assign -- prototype methods protection */
+	  set = function (it, metadata) {
+	    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+	    metadata.facade = it;
+	    store.set(it, metadata);
+	    return metadata;
+	  };
+	  get = function (it) {
+	    return store.get(it) || {};
+	  };
+	  has = function (it) {
+	    return store.has(it);
+	  };
+	} else {
+	  var STATE = sharedKey('state');
+	  hiddenKeys[STATE] = true;
+	  set = function (it, metadata) {
+	    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+	    metadata.facade = it;
+	    createNonEnumerableProperty(it, STATE, metadata);
+	    return metadata;
+	  };
+	  get = function (it) {
+	    return hasOwn(it, STATE) ? it[STATE] : {};
+	  };
+	  has = function (it) {
+	    return hasOwn(it, STATE);
+	  };
+	}
+
+	internalState = {
+	  set: set,
+	  get: get,
+	  has: has,
+	  enforce: enforce,
+	  getterFor: getterFor
+	};
+	return internalState;
+}
+
+export { requireInternalState as __require };

package/dist/ie/es/node_modules/core-js/internals/is-array-iterator-method.js

@@ -0,0 +1,23 @@
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+import { __require as requireIterators } from './iterators.js';
+
+var isArrayIteratorMethod;
+var hasRequiredIsArrayIteratorMethod;
+
+function requireIsArrayIteratorMethod () {
+	if (hasRequiredIsArrayIteratorMethod) return isArrayIteratorMethod;
+	hasRequiredIsArrayIteratorMethod = 1;
+	var wellKnownSymbol = requireWellKnownSymbol();
+	var Iterators = requireIterators();
+
+	var ITERATOR = wellKnownSymbol('iterator');
+	var ArrayPrototype = Array.prototype;
+
+	// check on default Array iterator
+	isArrayIteratorMethod = function (it) {
+	  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+	};
+	return isArrayIteratorMethod;
+}
+
+export { requireIsArrayIteratorMethod as __require };

package/dist/ie/es/node_modules/core-js/internals/is-callable.js

@@ -0,0 +1,21 @@
+var isCallable;
+var hasRequiredIsCallable;
+
+function requireIsCallable () {
+	if (hasRequiredIsCallable) return isCallable;
+	hasRequiredIsCallable = 1;
+	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+	var documentAll = typeof document == 'object' && document.all;
+
+	// `IsCallable` abstract operation
+	// https://tc39.es/ecma262/#sec-iscallable
+	// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+	isCallable = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
+	  return typeof argument == 'function' || argument === documentAll;
+	} : function (argument) {
+	  return typeof argument == 'function';
+	};
+	return isCallable;
+}
+
+export { requireIsCallable as __require };

package/dist/ie/es/node_modules/core-js/internals/is-constructor.js

@@ -0,0 +1,68 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireClassof } from './classof.js';
+import { __require as requireGetBuiltIn } from './get-built-in.js';
+import { __require as requireInspectSource } from './inspect-source.js';
+
+var isConstructor;
+var hasRequiredIsConstructor;
+
+function requireIsConstructor () {
+	if (hasRequiredIsConstructor) return isConstructor;
+	hasRequiredIsConstructor = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var fails = requireFails();
+	var isCallable = requireIsCallable();
+	var classof = requireClassof();
+	var getBuiltIn = requireGetBuiltIn();
+	var inspectSource = requireInspectSource();
+
+	var noop = function () { /* empty */ };
+	var construct = getBuiltIn('Reflect', 'construct');
+	var constructorRegExp = /^\s*(?:class|function)\b/;
+	var exec = uncurryThis(constructorRegExp.exec);
+	var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
+
+	var isConstructorModern = function isConstructor(argument) {
+	  if (!isCallable(argument)) return false;
+	  try {
+	    construct(noop, [], argument);
+	    return true;
+	  } catch (error) {
+	    return false;
+	  }
+	};
+
+	var isConstructorLegacy = function isConstructor(argument) {
+	  if (!isCallable(argument)) return false;
+	  switch (classof(argument)) {
+	    case 'AsyncFunction':
+	    case 'GeneratorFunction':
+	    case 'AsyncGeneratorFunction': return false;
+	  }
+	  try {
+	    // we can't check .prototype since constructors produced by .bind haven't it
+	    // `Function#toString` throws on some built-it function in some legacy engines
+	    // (for example, `DOMQuad` and similar in FF41-)
+	    return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
+	  } catch (error) {
+	    return true;
+	  }
+	};
+
+	isConstructorLegacy.sham = true;
+
+	// `IsConstructor` abstract operation
+	// https://tc39.es/ecma262/#sec-isconstructor
+	isConstructor = !construct || fails(function () {
+	  var called;
+	  return isConstructorModern(isConstructorModern.call)
+	    || !isConstructorModern(Object)
+	    || !isConstructorModern(function () { called = true; })
+	    || called;
+	}) ? isConstructorLegacy : isConstructorModern;
+	return isConstructor;
+}
+
+export { requireIsConstructor as __require };

package/dist/ie/es/node_modules/core-js/internals/is-forced.js

@@ -0,0 +1,35 @@
+import { __require as requireFails } from './fails.js';
+import { __require as requireIsCallable } from './is-callable.js';
+
+var isForced_1;
+var hasRequiredIsForced;
+
+function requireIsForced () {
+	if (hasRequiredIsForced) return isForced_1;
+	hasRequiredIsForced = 1;
+	var fails = requireFails();
+	var isCallable = requireIsCallable();
+
+	var replacement = /#|\.prototype\./;
+
+	var isForced = function (feature, detection) {
+	  var value = data[normalize(feature)];
+	  return value === POLYFILL ? true
+	    : value === NATIVE ? false
+	    : isCallable(detection) ? fails(detection)
+	    : !!detection;
+	};
+
+	var normalize = isForced.normalize = function (string) {
+	  return String(string).replace(replacement, '.').toLowerCase();
+	};
+
+	var data = isForced.data = {};
+	var NATIVE = isForced.NATIVE = 'N';
+	var POLYFILL = isForced.POLYFILL = 'P';
+
+	isForced_1 = isForced;
+	return isForced_1;
+}
+
+export { requireIsForced as __require };

package/dist/ie/es/node_modules/core-js/internals/is-null-or-undefined.js

@@ -0,0 +1,15 @@
+var isNullOrUndefined;
+var hasRequiredIsNullOrUndefined;
+
+function requireIsNullOrUndefined () {
+	if (hasRequiredIsNullOrUndefined) return isNullOrUndefined;
+	hasRequiredIsNullOrUndefined = 1;
+	// we can't use just `it == null` since of `document.all` special case
+	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+	isNullOrUndefined = function (it) {
+	  return it === null || it === undefined;
+	};
+	return isNullOrUndefined;
+}
+
+export { requireIsNullOrUndefined as __require };

package/dist/ie/es/node_modules/core-js/internals/is-object.js

@@ -0,0 +1,17 @@
+import { __require as requireIsCallable } from './is-callable.js';
+
+var isObject;
+var hasRequiredIsObject;
+
+function requireIsObject () {
+	if (hasRequiredIsObject) return isObject;
+	hasRequiredIsObject = 1;
+	var isCallable = requireIsCallable();
+
+	isObject = function (it) {
+	  return typeof it == 'object' ? it !== null : isCallable(it);
+	};
+	return isObject;
+}
+
+export { requireIsObject as __require };

package/dist/ie/es/node_modules/core-js/internals/is-possible-prototype.js

@@ -0,0 +1,17 @@
+import { __require as requireIsObject } from './is-object.js';
+
+var isPossiblePrototype;
+var hasRequiredIsPossiblePrototype;
+
+function requireIsPossiblePrototype () {
+	if (hasRequiredIsPossiblePrototype) return isPossiblePrototype;
+	hasRequiredIsPossiblePrototype = 1;
+	var isObject = requireIsObject();
+
+	isPossiblePrototype = function (argument) {
+	  return isObject(argument) || argument === null;
+	};
+	return isPossiblePrototype;
+}
+
+export { requireIsPossiblePrototype as __require };

package/dist/ie/es/node_modules/core-js/internals/is-pure.js

@@ -0,0 +1,11 @@
+var isPure;
+var hasRequiredIsPure;
+
+function requireIsPure () {
+	if (hasRequiredIsPure) return isPure;
+	hasRequiredIsPure = 1;
+	isPure = false;
+	return isPure;
+}
+
+export { requireIsPure as __require };

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

@@ -0,0 +1,28 @@
+import { __require as requireGetBuiltIn } from './get-built-in.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireObjectIsPrototypeOf } from './object-is-prototype-of.js';
+import { __require as requireUseSymbolAsUid } from './use-symbol-as-uid.js';
+
+var isSymbol;
+var hasRequiredIsSymbol;
+
+function requireIsSymbol () {
+	if (hasRequiredIsSymbol) return isSymbol;
+	hasRequiredIsSymbol = 1;
+	var getBuiltIn = requireGetBuiltIn();
+	var isCallable = requireIsCallable();
+	var isPrototypeOf = requireObjectIsPrototypeOf();
+	var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
+
+	var $Object = Object;
+
+	isSymbol = USE_SYMBOL_AS_UID ? function (it) {
+	  return typeof it == 'symbol';
+	} : function (it) {
+	  var $Symbol = getBuiltIn('Symbol');
+	  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+	};
+	return isSymbol;
+}
+
+export { requireIsSymbol as __require };

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

@@ -0,0 +1,89 @@
+import { __require as requireFunctionBindContext } from './function-bind-context.js';
+import { __require as requireFunctionCall } from './function-call.js';
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireTryToString } from './try-to-string.js';
+import { __require as requireIsArrayIteratorMethod } from './is-array-iterator-method.js';
+import { __require as requireLengthOfArrayLike } from './length-of-array-like.js';
+import { __require as requireObjectIsPrototypeOf } from './object-is-prototype-of.js';
+import { __require as requireGetIterator } from './get-iterator.js';
+import { __require as requireGetIteratorMethod } from './get-iterator-method.js';
+import { __require as requireIteratorClose } from './iterator-close.js';
+
+var iterate;
+var hasRequiredIterate;
+
+function requireIterate () {
+	if (hasRequiredIterate) return iterate;
+	hasRequiredIterate = 1;
+	var bind = requireFunctionBindContext();
+	var call = requireFunctionCall();
+	var anObject = requireAnObject();
+	var tryToString = requireTryToString();
+	var isArrayIteratorMethod = requireIsArrayIteratorMethod();
+	var lengthOfArrayLike = requireLengthOfArrayLike();
+	var isPrototypeOf = requireObjectIsPrototypeOf();
+	var getIterator = requireGetIterator();
+	var getIteratorMethod = requireGetIteratorMethod();
+	var iteratorClose = requireIteratorClose();
+
+	var $TypeError = TypeError;
+
+	var Result = function (stopped, result) {
+	  this.stopped = stopped;
+	  this.result = result;
+	};
+
+	var ResultPrototype = Result.prototype;
+
+	iterate = function (iterable, unboundFunction, options) {
+	  var that = options && options.that;
+	  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+	  var IS_RECORD = !!(options && options.IS_RECORD);
+	  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+	  var INTERRUPTED = !!(options && options.INTERRUPTED);
+	  var fn = bind(unboundFunction, that);
+	  var iterator, iterFn, index, length, result, next, step;
+
+	  var stop = function (condition) {
+	    if (iterator) iteratorClose(iterator, 'normal', condition);
+	    return new Result(true, condition);
+	  };
+
+	  var callFn = function (value) {
+	    if (AS_ENTRIES) {
+	      anObject(value);
+	      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+	    } return INTERRUPTED ? fn(value, stop) : fn(value);
+	  };
+
+	  if (IS_RECORD) {
+	    iterator = iterable.iterator;
+	  } else if (IS_ITERATOR) {
+	    iterator = iterable;
+	  } else {
+	    iterFn = getIteratorMethod(iterable);
+	    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
+	    // optimisation for array iterators
+	    if (isArrayIteratorMethod(iterFn)) {
+	      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+	        result = callFn(iterable[index]);
+	        if (result && isPrototypeOf(ResultPrototype, result)) return result;
+	      } return new Result(false);
+	    }
+	    iterator = getIterator(iterable, iterFn);
+	  }
+
+	  next = IS_RECORD ? iterable.next : iterator.next;
+	  while (!(step = call(next, iterator)).done) {
+	    try {
+	      result = callFn(step.value);
+	    } catch (error) {
+	      iteratorClose(iterator, 'throw', error);
+	    }
+	    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+	  } return new Result(false);
+	};
+	return iterate;
+}
+
+export { requireIterate as __require };

package/dist/ie/es/node_modules/core-js/internals/iterator-close.js

@@ -0,0 +1,37 @@
+import { __require as requireFunctionCall } from './function-call.js';
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireGetMethod } from './get-method.js';
+
+var iteratorClose;
+var hasRequiredIteratorClose;
+
+function requireIteratorClose () {
+	if (hasRequiredIteratorClose) return iteratorClose;
+	hasRequiredIteratorClose = 1;
+	var call = requireFunctionCall();
+	var anObject = requireAnObject();
+	var getMethod = requireGetMethod();
+
+	iteratorClose = function (iterator, kind, value) {
+	  var innerResult, innerError;
+	  anObject(iterator);
+	  try {
+	    innerResult = getMethod(iterator, 'return');
+	    if (!innerResult) {
+	      if (kind === 'throw') throw value;
+	      return value;
+	    }
+	    innerResult = call(innerResult, iterator);
+	  } catch (error) {
+	    innerError = true;
+	    innerResult = error;
+	  }
+	  if (kind === 'throw') throw value;
+	  if (innerError) throw innerResult;
+	  anObject(innerResult);
+	  return value;
+	};
+	return iteratorClose;
+}
+
+export { requireIteratorClose as __require };

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

@@ -0,0 +1,11 @@
+var iterators;
+var hasRequiredIterators;
+
+function requireIterators () {
+	if (hasRequiredIterators) return iterators;
+	hasRequiredIterators = 1;
+	iterators = {};
+	return iterators;
+}
+
+export { requireIterators as __require };

package/dist/ie/es/node_modules/core-js/internals/length-of-array-like.js

@@ -0,0 +1,19 @@
+import { __require as requireToLength } from './to-length.js';
+
+var lengthOfArrayLike;
+var hasRequiredLengthOfArrayLike;
+
+function requireLengthOfArrayLike () {
+	if (hasRequiredLengthOfArrayLike) return lengthOfArrayLike;
+	hasRequiredLengthOfArrayLike = 1;
+	var toLength = requireToLength();
+
+	// `LengthOfArrayLike` abstract operation
+	// https://tc39.es/ecma262/#sec-lengthofarraylike
+	lengthOfArrayLike = function (obj) {
+	  return toLength(obj.length);
+	};
+	return lengthOfArrayLike;
+}
+
+export { requireLengthOfArrayLike as __require };

package/dist/ie/es/node_modules/core-js/internals/make-built-in.js

@@ -0,0 +1,73 @@
+import { __module as makeBuiltIn } from '../../../_virtual/make-built-in.js';
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireFunctionName } from './function-name.js';
+import { __require as requireInspectSource } from './inspect-source.js';
+import { __require as requireInternalState } from './internal-state.js';
+
+var hasRequiredMakeBuiltIn;
+
+function requireMakeBuiltIn () {
+	if (hasRequiredMakeBuiltIn) return makeBuiltIn.exports;
+	hasRequiredMakeBuiltIn = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var fails = requireFails();
+	var isCallable = requireIsCallable();
+	var hasOwn = requireHasOwnProperty();
+	var DESCRIPTORS = requireDescriptors();
+	var CONFIGURABLE_FUNCTION_NAME = requireFunctionName().CONFIGURABLE;
+	var inspectSource = requireInspectSource();
+	var InternalStateModule = requireInternalState();
+
+	var enforceInternalState = InternalStateModule.enforce;
+	var getInternalState = InternalStateModule.get;
+	var $String = String;
+	// eslint-disable-next-line es/no-object-defineproperty -- safe
+	var defineProperty = Object.defineProperty;
+	var stringSlice = uncurryThis(''.slice);
+	var replace = uncurryThis(''.replace);
+	var join = uncurryThis([].join);
+
+	var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
+	  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
+	});
+
+	var TEMPLATE = String(String).split('String');
+
+	var makeBuiltIn$1 = makeBuiltIn.exports = function (value, name, options) {
+	  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
+	    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
+	  }
+	  if (options && options.getter) name = 'get ' + name;
+	  if (options && options.setter) name = 'set ' + name;
+	  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+	    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
+	    else value.name = name;
+	  }
+	  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
+	    defineProperty(value, 'length', { value: options.arity });
+	  }
+	  try {
+	    if (options && hasOwn(options, 'constructor') && options.constructor) {
+	      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
+	    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
+	    } else if (value.prototype) value.prototype = undefined;
+	  } catch (error) { /* empty */ }
+	  var state = enforceInternalState(value);
+	  if (!hasOwn(state, 'source')) {
+	    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
+	  } return value;
+	};
+
+	// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+	// eslint-disable-next-line no-extend-native -- required
+	Function.prototype.toString = makeBuiltIn$1(function toString() {
+	  return isCallable(this) && getInternalState(this).source || inspectSource(this);
+	}, 'toString');
+	return makeBuiltIn.exports;
+}
+
+export { requireMakeBuiltIn as __require };

package/dist/ie/es/node_modules/core-js/internals/math-trunc.js

@@ -0,0 +1,20 @@
+var mathTrunc;
+var hasRequiredMathTrunc;
+
+function requireMathTrunc () {
+	if (hasRequiredMathTrunc) return mathTrunc;
+	hasRequiredMathTrunc = 1;
+	var ceil = Math.ceil;
+	var floor = Math.floor;
+
+	// `Math.trunc` method
+	// https://tc39.es/ecma262/#sec-math.trunc
+	// eslint-disable-next-line es/no-math-trunc -- safe
+	mathTrunc = Math.trunc || function trunc(x) {
+	  var n = +x;
+	  return (n > 0 ? floor : ceil)(n);
+	};
+	return mathTrunc;
+}
+
+export { requireMathTrunc as __require };