watermark-js-plus 1.6.0 → 1.6.2

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

@@ -0,0 +1,66 @@
+import { __require as requireFunctionBindContext } from './function-bind-context.js';
+import { __require as requireFunctionCall } from './function-call.js';
+import { __require as requireToObject } from './to-object.js';
+import { __require as requireCallWithSafeIterationClosing } from './call-with-safe-iteration-closing.js';
+import { __require as requireIsArrayIteratorMethod } from './is-array-iterator-method.js';
+import { __require as requireIsConstructor } from './is-constructor.js';
+import { __require as requireLengthOfArrayLike } from './length-of-array-like.js';
+import { __require as requireCreateProperty } from './create-property.js';
+import { __require as requireGetIterator } from './get-iterator.js';
+import { __require as requireGetIteratorMethod } from './get-iterator-method.js';
+
+var arrayFrom;
+var hasRequiredArrayFrom;
+
+function requireArrayFrom () {
+	if (hasRequiredArrayFrom) return arrayFrom;
+	hasRequiredArrayFrom = 1;
+	var bind = requireFunctionBindContext();
+	var call = requireFunctionCall();
+	var toObject = requireToObject();
+	var callWithSafeIterationClosing = requireCallWithSafeIterationClosing();
+	var isArrayIteratorMethod = requireIsArrayIteratorMethod();
+	var isConstructor = requireIsConstructor();
+	var lengthOfArrayLike = requireLengthOfArrayLike();
+	var createProperty = requireCreateProperty();
+	var getIterator = requireGetIterator();
+	var getIteratorMethod = requireGetIteratorMethod();
+
+	var $Array = Array;
+
+	// `Array.from` method implementation
+	// https://tc39.es/ecma262/#sec-array.from
+	arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+	  var O = toObject(arrayLike);
+	  var IS_CONSTRUCTOR = isConstructor(this);
+	  var argumentsLength = arguments.length;
+	  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
+	  var mapping = mapfn !== undefined;
+	  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
+	  var iteratorMethod = getIteratorMethod(O);
+	  var index = 0;
+	  var length, result, step, iterator, next, value;
+	  // if the target is not iterable or it's an array with the default iterator - use a simple case
+	  if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {
+	    result = IS_CONSTRUCTOR ? new this() : [];
+	    iterator = getIterator(O, iteratorMethod);
+	    next = iterator.next;
+	    for (;!(step = call(next, iterator)).done; index++) {
+	      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
+	      createProperty(result, index, value);
+	    }
+	  } else {
+	    length = lengthOfArrayLike(O);
+	    result = IS_CONSTRUCTOR ? new this(length) : $Array(length);
+	    for (;length > index; index++) {
+	      value = mapping ? mapfn(O[index], index) : O[index];
+	      createProperty(result, index, value);
+	    }
+	  }
+	  result.length = index;
+	  return result;
+	};
+	return arrayFrom;
+}
+
+export { requireArrayFrom as __require };

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

@@ -0,0 +1,47 @@
+import { __require as requireToIndexedObject } from './to-indexed-object.js';
+import { __require as requireToAbsoluteIndex } from './to-absolute-index.js';
+import { __require as requireLengthOfArrayLike } from './length-of-array-like.js';
+
+var arrayIncludes;
+var hasRequiredArrayIncludes;
+
+function requireArrayIncludes () {
+	if (hasRequiredArrayIncludes) return arrayIncludes;
+	hasRequiredArrayIncludes = 1;
+	var toIndexedObject = requireToIndexedObject();
+	var toAbsoluteIndex = requireToAbsoluteIndex();
+	var lengthOfArrayLike = requireLengthOfArrayLike();
+
+	// `Array.prototype.{ indexOf, includes }` methods implementation
+	var createMethod = function (IS_INCLUDES) {
+	  return function ($this, el, fromIndex) {
+	    var O = toIndexedObject($this);
+	    var length = lengthOfArrayLike(O);
+	    if (length === 0) return !IS_INCLUDES && -1;
+	    var index = toAbsoluteIndex(fromIndex, length);
+	    var value;
+	    // Array#includes uses SameValueZero equality algorithm
+	    // eslint-disable-next-line no-self-compare -- NaN check
+	    if (IS_INCLUDES && el !== el) while (length > index) {
+	      value = O[index++];
+	      // eslint-disable-next-line no-self-compare -- NaN check
+	      if (value !== value) return true;
+	    // Array#indexOf ignores holes, Array#includes - not
+	    } else for (;length > index; index++) {
+	      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+	    } return !IS_INCLUDES && -1;
+	  };
+	};
+
+	arrayIncludes = {
+	  // `Array.prototype.includes` method
+	  // https://tc39.es/ecma262/#sec-array.prototype.includes
+	  includes: createMethod(true),
+	  // `Array.prototype.indexOf` method
+	  // https://tc39.es/ecma262/#sec-array.prototype.indexof
+	  indexOf: createMethod(false)
+	};
+	return arrayIncludes;
+}
+
+export { requireArrayIncludes as __require };

package/dist/ie/es/node_modules/core-js/internals/array-slice.js

@@ -0,0 +1,15 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+
+var arraySlice;
+var hasRequiredArraySlice;
+
+function requireArraySlice () {
+	if (hasRequiredArraySlice) return arraySlice;
+	hasRequiredArraySlice = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	arraySlice = uncurryThis([].slice);
+	return arraySlice;
+}
+
+export { requireArraySlice as __require };

package/dist/ie/es/node_modules/core-js/internals/call-with-safe-iteration-closing.js

@@ -0,0 +1,24 @@
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireIteratorClose } from './iterator-close.js';
+
+var callWithSafeIterationClosing;
+var hasRequiredCallWithSafeIterationClosing;
+
+function requireCallWithSafeIterationClosing () {
+	if (hasRequiredCallWithSafeIterationClosing) return callWithSafeIterationClosing;
+	hasRequiredCallWithSafeIterationClosing = 1;
+	var anObject = requireAnObject();
+	var iteratorClose = requireIteratorClose();
+
+	// call something on iterator step with safe closing on error
+	callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) {
+	  try {
+	    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+	  } catch (error) {
+	    iteratorClose(iterator, 'throw', error);
+	  }
+	};
+	return callWithSafeIterationClosing;
+}
+
+export { requireCallWithSafeIterationClosing as __require };

package/dist/ie/es/node_modules/core-js/internals/check-correctness-of-iteration.js

@@ -0,0 +1,52 @@
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var checkCorrectnessOfIteration;
+var hasRequiredCheckCorrectnessOfIteration;
+
+function requireCheckCorrectnessOfIteration () {
+	if (hasRequiredCheckCorrectnessOfIteration) return checkCorrectnessOfIteration;
+	hasRequiredCheckCorrectnessOfIteration = 1;
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var ITERATOR = wellKnownSymbol('iterator');
+	var SAFE_CLOSING = false;
+
+	try {
+	  var called = 0;
+	  var iteratorWithReturn = {
+	    next: function () {
+	      return { done: !!called++ };
+	    },
+	    'return': function () {
+	      SAFE_CLOSING = true;
+	    }
+	  };
+	  iteratorWithReturn[ITERATOR] = function () {
+	    return this;
+	  };
+	  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
+	  Array.from(iteratorWithReturn, function () { throw 2; });
+	} catch (error) { /* empty */ }
+
+	checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) {
+	  try {
+	    if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
+	  } catch (error) { return false; } // workaround of old WebKit + `eval` bug
+	  var ITERATION_SUPPORT = false;
+	  try {
+	    var object = {};
+	    object[ITERATOR] = function () {
+	      return {
+	        next: function () {
+	          return { done: ITERATION_SUPPORT = true };
+	        }
+	      };
+	    };
+	    exec(object);
+	  } catch (error) { /* empty */ }
+	  return ITERATION_SUPPORT;
+	};
+	return checkCorrectnessOfIteration;
+}
+
+export { requireCheckCorrectnessOfIteration as __require };

package/dist/ie/es/node_modules/core-js/internals/classof-raw.js

@@ -0,0 +1,20 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+
+var classofRaw;
+var hasRequiredClassofRaw;
+
+function requireClassofRaw () {
+	if (hasRequiredClassofRaw) return classofRaw;
+	hasRequiredClassofRaw = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	var toString = uncurryThis({}.toString);
+	var stringSlice = uncurryThis(''.slice);
+
+	classofRaw = function (it) {
+	  return stringSlice(toString(it), 8, -1);
+	};
+	return classofRaw;
+}
+
+export { requireClassofRaw as __require };

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

@@ -0,0 +1,44 @@
+import { __require as requireToStringTagSupport } from './to-string-tag-support.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireClassofRaw } from './classof-raw.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var classof;
+var hasRequiredClassof;
+
+function requireClassof () {
+	if (hasRequiredClassof) return classof;
+	hasRequiredClassof = 1;
+	var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
+	var isCallable = requireIsCallable();
+	var classofRaw = requireClassofRaw();
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+	var $Object = Object;
+
+	// ES3 wrong here
+	var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
+
+	// fallback for IE11 Script Access Denied error
+	var tryGet = function (it, key) {
+	  try {
+	    return it[key];
+	  } catch (error) { /* empty */ }
+	};
+
+	// getting tag from ES6+ `Object.prototype.toString`
+	classof = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+	  var O, tag, result;
+	  return it === undefined ? 'Undefined' : it === null ? 'Null'
+	    // @@toStringTag case
+	    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
+	    // builtinTag case
+	    : CORRECT_ARGUMENTS ? classofRaw(O)
+	    // ES3 arguments fallback
+	    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
+	};
+	return classof;
+}
+
+export { requireClassof as __require };

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

@@ -0,0 +1,31 @@
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+import { __require as requireOwnKeys } from './own-keys.js';
+import { __require as requireObjectGetOwnPropertyDescriptor } from './object-get-own-property-descriptor.js';
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+
+var copyConstructorProperties;
+var hasRequiredCopyConstructorProperties;
+
+function requireCopyConstructorProperties () {
+	if (hasRequiredCopyConstructorProperties) return copyConstructorProperties;
+	hasRequiredCopyConstructorProperties = 1;
+	var hasOwn = requireHasOwnProperty();
+	var ownKeys = requireOwnKeys();
+	var getOwnPropertyDescriptorModule = requireObjectGetOwnPropertyDescriptor();
+	var definePropertyModule = requireObjectDefineProperty();
+
+	copyConstructorProperties = function (target, source, exceptions) {
+	  var keys = ownKeys(source);
+	  var defineProperty = definePropertyModule.f;
+	  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+	  for (var i = 0; i < keys.length; i++) {
+	    var key = keys[i];
+	    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+	      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+	    }
+	  }
+	};
+	return copyConstructorProperties;
+}
+
+export { requireCopyConstructorProperties as __require };

package/dist/ie/es/node_modules/core-js/internals/create-non-enumerable-property.js

@@ -0,0 +1,24 @@
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+import { __require as requireCreatePropertyDescriptor } from './create-property-descriptor.js';
+
+var createNonEnumerableProperty;
+var hasRequiredCreateNonEnumerableProperty;
+
+function requireCreateNonEnumerableProperty () {
+	if (hasRequiredCreateNonEnumerableProperty) return createNonEnumerableProperty;
+	hasRequiredCreateNonEnumerableProperty = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var definePropertyModule = requireObjectDefineProperty();
+	var createPropertyDescriptor = requireCreatePropertyDescriptor();
+
+	createNonEnumerableProperty = DESCRIPTORS ? function (object, key, value) {
+	  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+	} : function (object, key, value) {
+	  object[key] = value;
+	  return object;
+	};
+	return createNonEnumerableProperty;
+}
+
+export { requireCreateNonEnumerableProperty as __require };

package/dist/ie/es/node_modules/core-js/internals/create-property-descriptor.js

@@ -0,0 +1,18 @@
+var createPropertyDescriptor;
+var hasRequiredCreatePropertyDescriptor;
+
+function requireCreatePropertyDescriptor () {
+	if (hasRequiredCreatePropertyDescriptor) return createPropertyDescriptor;
+	hasRequiredCreatePropertyDescriptor = 1;
+	createPropertyDescriptor = function (bitmap, value) {
+	  return {
+	    enumerable: !(bitmap & 1),
+	    configurable: !(bitmap & 2),
+	    writable: !(bitmap & 4),
+	    value: value
+	  };
+	};
+	return createPropertyDescriptor;
+}
+
+export { requireCreatePropertyDescriptor as __require };

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

@@ -0,0 +1,22 @@
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+import { __require as requireCreatePropertyDescriptor } from './create-property-descriptor.js';
+
+var createProperty;
+var hasRequiredCreateProperty;
+
+function requireCreateProperty () {
+	if (hasRequiredCreateProperty) return createProperty;
+	hasRequiredCreateProperty = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var definePropertyModule = requireObjectDefineProperty();
+	var createPropertyDescriptor = requireCreatePropertyDescriptor();
+
+	createProperty = function (object, key, value) {
+	  if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
+	  else object[key] = value;
+	};
+	return createProperty;
+}
+
+export { requireCreateProperty as __require };

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

@@ -0,0 +1,21 @@
+import { __require as requireMakeBuiltIn } from './make-built-in.js';
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+
+var defineBuiltInAccessor;
+var hasRequiredDefineBuiltInAccessor;
+
+function requireDefineBuiltInAccessor () {
+	if (hasRequiredDefineBuiltInAccessor) return defineBuiltInAccessor;
+	hasRequiredDefineBuiltInAccessor = 1;
+	var makeBuiltIn = requireMakeBuiltIn();
+	var defineProperty = requireObjectDefineProperty();
+
+	defineBuiltInAccessor = function (target, name, descriptor) {
+	  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
+	  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
+	  return defineProperty.f(target, name, descriptor);
+	};
+	return defineBuiltInAccessor;
+}
+
+export { requireDefineBuiltInAccessor as __require };

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

@@ -0,0 +1,42 @@
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireObjectDefineProperty } from './object-define-property.js';
+import { __require as requireMakeBuiltIn } from './make-built-in.js';
+import { __require as requireDefineGlobalProperty } from './define-global-property.js';
+
+var defineBuiltIn;
+var hasRequiredDefineBuiltIn;
+
+function requireDefineBuiltIn () {
+	if (hasRequiredDefineBuiltIn) return defineBuiltIn;
+	hasRequiredDefineBuiltIn = 1;
+	var isCallable = requireIsCallable();
+	var definePropertyModule = requireObjectDefineProperty();
+	var makeBuiltIn = requireMakeBuiltIn();
+	var defineGlobalProperty = requireDefineGlobalProperty();
+
+	defineBuiltIn = function (O, key, value, options) {
+	  if (!options) options = {};
+	  var simple = options.enumerable;
+	  var name = options.name !== undefined ? options.name : key;
+	  if (isCallable(value)) makeBuiltIn(value, name, options);
+	  if (options.global) {
+	    if (simple) O[key] = value;
+	    else defineGlobalProperty(key, value);
+	  } else {
+	    try {
+	      if (!options.unsafe) delete O[key];
+	      else if (O[key]) simple = true;
+	    } catch (error) { /* empty */ }
+	    if (simple) O[key] = value;
+	    else definePropertyModule.f(O, key, {
+	      value: value,
+	      enumerable: false,
+	      configurable: !options.nonConfigurable,
+	      writable: !options.nonWritable
+	    });
+	  } return O;
+	};
+	return defineBuiltIn;
+}
+
+export { requireDefineBuiltIn as __require };

package/dist/ie/es/node_modules/core-js/internals/define-global-property.js

@@ -0,0 +1,24 @@
+import { __require as requireGlobalThis } from './global-this.js';
+
+var defineGlobalProperty;
+var hasRequiredDefineGlobalProperty;
+
+function requireDefineGlobalProperty () {
+	if (hasRequiredDefineGlobalProperty) return defineGlobalProperty;
+	hasRequiredDefineGlobalProperty = 1;
+	var globalThis = requireGlobalThis();
+
+	// eslint-disable-next-line es/no-object-defineproperty -- safe
+	var defineProperty = Object.defineProperty;
+
+	defineGlobalProperty = function (key, value) {
+	  try {
+	    defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
+	  } catch (error) {
+	    globalThis[key] = value;
+	  } return value;
+	};
+	return defineGlobalProperty;
+}
+
+export { requireDefineGlobalProperty as __require };

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

@@ -0,0 +1,19 @@
+import { __require as requireFails } from './fails.js';
+
+var descriptors;
+var hasRequiredDescriptors;
+
+function requireDescriptors () {
+	if (hasRequiredDescriptors) return descriptors;
+	hasRequiredDescriptors = 1;
+	var fails = requireFails();
+
+	// Detect IE8's incomplete defineProperty implementation
+	descriptors = !fails(function () {
+	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+	  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
+	});
+	return descriptors;
+}
+
+export { requireDescriptors as __require };

package/dist/ie/es/node_modules/core-js/internals/document-create-element.js

@@ -0,0 +1,23 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireIsObject } from './is-object.js';
+
+var documentCreateElement;
+var hasRequiredDocumentCreateElement;
+
+function requireDocumentCreateElement () {
+	if (hasRequiredDocumentCreateElement) return documentCreateElement;
+	hasRequiredDocumentCreateElement = 1;
+	var globalThis = requireGlobalThis();
+	var isObject = requireIsObject();
+
+	var document = globalThis.document;
+	// typeof document.createElement is 'object' in old IE
+	var EXISTS = isObject(document) && isObject(document.createElement);
+
+	documentCreateElement = function (it) {
+	  return EXISTS ? document.createElement(it) : {};
+	};
+	return documentCreateElement;
+}
+
+export { requireDocumentCreateElement as __require };

package/dist/ie/es/node_modules/core-js/internals/enum-bug-keys.js

@@ -0,0 +1,20 @@
+var enumBugKeys;
+var hasRequiredEnumBugKeys;
+
+function requireEnumBugKeys () {
+	if (hasRequiredEnumBugKeys) return enumBugKeys;
+	hasRequiredEnumBugKeys = 1;
+	// IE8- don't enum bug keys
+	enumBugKeys = [
+	  'constructor',
+	  'hasOwnProperty',
+	  'isPrototypeOf',
+	  'propertyIsEnumerable',
+	  'toLocaleString',
+	  'toString',
+	  'valueOf'
+	];
+	return enumBugKeys;
+}
+
+export { requireEnumBugKeys as __require };

package/dist/ie/es/node_modules/core-js/internals/environment-is-ios-pebble.js

@@ -0,0 +1,15 @@
+import { __require as requireEnvironmentUserAgent } from './environment-user-agent.js';
+
+var environmentIsIosPebble;
+var hasRequiredEnvironmentIsIosPebble;
+
+function requireEnvironmentIsIosPebble () {
+	if (hasRequiredEnvironmentIsIosPebble) return environmentIsIosPebble;
+	hasRequiredEnvironmentIsIosPebble = 1;
+	var userAgent = requireEnvironmentUserAgent();
+
+	environmentIsIosPebble = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';
+	return environmentIsIosPebble;
+}
+
+export { requireEnvironmentIsIosPebble as __require };

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

@@ -0,0 +1,16 @@
+import { __require as requireEnvironmentUserAgent } from './environment-user-agent.js';
+
+var environmentIsIos;
+var hasRequiredEnvironmentIsIos;
+
+function requireEnvironmentIsIos () {
+	if (hasRequiredEnvironmentIsIos) return environmentIsIos;
+	hasRequiredEnvironmentIsIos = 1;
+	var userAgent = requireEnvironmentUserAgent();
+
+	// eslint-disable-next-line redos/no-vulnerable -- safe
+	environmentIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
+	return environmentIsIos;
+}
+
+export { requireEnvironmentIsIos as __require };

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

@@ -0,0 +1,15 @@
+import { __require as requireEnvironment } from './environment.js';
+
+var environmentIsNode;
+var hasRequiredEnvironmentIsNode;
+
+function requireEnvironmentIsNode () {
+	if (hasRequiredEnvironmentIsNode) return environmentIsNode;
+	hasRequiredEnvironmentIsNode = 1;
+	var ENVIRONMENT = requireEnvironment();
+
+	environmentIsNode = ENVIRONMENT === 'NODE';
+	return environmentIsNode;
+}
+
+export { requireEnvironmentIsNode as __require };

package/dist/ie/es/node_modules/core-js/internals/environment-is-webos-webkit.js

@@ -0,0 +1,15 @@
+import { __require as requireEnvironmentUserAgent } from './environment-user-agent.js';
+
+var environmentIsWebosWebkit;
+var hasRequiredEnvironmentIsWebosWebkit;
+
+function requireEnvironmentIsWebosWebkit () {
+	if (hasRequiredEnvironmentIsWebosWebkit) return environmentIsWebosWebkit;
+	hasRequiredEnvironmentIsWebosWebkit = 1;
+	var userAgent = requireEnvironmentUserAgent();
+
+	environmentIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
+	return environmentIsWebosWebkit;
+}
+
+export { requireEnvironmentIsWebosWebkit as __require };

package/dist/ie/es/node_modules/core-js/internals/environment-user-agent.js

@@ -0,0 +1,18 @@
+import { __require as requireGlobalThis } from './global-this.js';
+
+var environmentUserAgent;
+var hasRequiredEnvironmentUserAgent;
+
+function requireEnvironmentUserAgent () {
+	if (hasRequiredEnvironmentUserAgent) return environmentUserAgent;
+	hasRequiredEnvironmentUserAgent = 1;
+	var globalThis = requireGlobalThis();
+
+	var navigator = globalThis.navigator;
+	var userAgent = navigator && navigator.userAgent;
+
+	environmentUserAgent = userAgent ? String(userAgent) : '';
+	return environmentUserAgent;
+}
+
+export { requireEnvironmentUserAgent as __require };

package/dist/ie/es/node_modules/core-js/internals/environment-v8-version.js

@@ -0,0 +1,40 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireEnvironmentUserAgent } from './environment-user-agent.js';
+
+var environmentV8Version;
+var hasRequiredEnvironmentV8Version;
+
+function requireEnvironmentV8Version () {
+	if (hasRequiredEnvironmentV8Version) return environmentV8Version;
+	hasRequiredEnvironmentV8Version = 1;
+	var globalThis = requireGlobalThis();
+	var userAgent = requireEnvironmentUserAgent();
+
+	var process = globalThis.process;
+	var Deno = globalThis.Deno;
+	var versions = process && process.versions || Deno && Deno.version;
+	var v8 = versions && versions.v8;
+	var match, version;
+
+	if (v8) {
+	  match = v8.split('.');
+	  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+	  // but their correct versions are not interesting for us
+	  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+	}
+
+	// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+	// so check `userAgent` even if `.v8` exists, but 0
+	if (!version && userAgent) {
+	  match = userAgent.match(/Edge\/(\d+)/);
+	  if (!match || match[1] >= 74) {
+	    match = userAgent.match(/Chrome\/(\d+)/);
+	    if (match) version = +match[1];
+	  }
+	}
+
+	environmentV8Version = version;
+	return environmentV8Version;
+}
+
+export { requireEnvironmentV8Version as __require };