watermark-js-plus 1.6.0 → 1.6.2

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

@@ -0,0 +1,34 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireEnvironmentUserAgent } from './environment-user-agent.js';
+import { __require as requireClassofRaw } from './classof-raw.js';
+
+var environment;
+var hasRequiredEnvironment;
+
+function requireEnvironment () {
+	if (hasRequiredEnvironment) return environment;
+	hasRequiredEnvironment = 1;
+	/* global Bun, Deno -- detection */
+	var globalThis = requireGlobalThis();
+	var userAgent = requireEnvironmentUserAgent();
+	var classof = requireClassofRaw();
+
+	var userAgentStartsWith = function (string) {
+	  return userAgent.slice(0, string.length) === string;
+	};
+
+	environment = (function () {
+	  if (userAgentStartsWith('Bun/')) return 'BUN';
+	  if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE';
+	  if (userAgentStartsWith('Deno/')) return 'DENO';
+	  if (userAgentStartsWith('Node.js/')) return 'NODE';
+	  if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN';
+	  if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO';
+	  if (classof(globalThis.process) === 'process') return 'NODE';
+	  if (globalThis.window && globalThis.document) return 'BROWSER';
+	  return 'REST';
+	})();
+	return environment;
+}
+
+export { requireEnvironment as __require };

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

@@ -0,0 +1,72 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireObjectGetOwnPropertyDescriptor } from './object-get-own-property-descriptor.js';
+import { __require as requireCreateNonEnumerableProperty } from './create-non-enumerable-property.js';
+import { __require as requireDefineBuiltIn } from './define-built-in.js';
+import { __require as requireDefineGlobalProperty } from './define-global-property.js';
+import { __require as requireCopyConstructorProperties } from './copy-constructor-properties.js';
+import { __require as requireIsForced } from './is-forced.js';
+
+var _export;
+var hasRequired_export;
+
+function require_export () {
+	if (hasRequired_export) return _export;
+	hasRequired_export = 1;
+	var globalThis = requireGlobalThis();
+	var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
+	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+	var defineBuiltIn = requireDefineBuiltIn();
+	var defineGlobalProperty = requireDefineGlobalProperty();
+	var copyConstructorProperties = requireCopyConstructorProperties();
+	var isForced = requireIsForced();
+
+	/*
+	  options.target         - name of the target object
+	  options.global         - target is the global object
+	  options.stat           - export as static methods of target
+	  options.proto          - export as prototype methods of target
+	  options.real           - real prototype method for the `pure` version
+	  options.forced         - export even if the native feature is available
+	  options.bind           - bind methods to the target, required for the `pure` version
+	  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
+	  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
+	  options.sham           - add a flag to not completely full polyfills
+	  options.enumerable     - export as enumerable property
+	  options.dontCallGetSet - prevent calling a getter on target
+	  options.name           - the .name of the function if it does not match the key
+	*/
+	_export = function (options, source) {
+	  var TARGET = options.target;
+	  var GLOBAL = options.global;
+	  var STATIC = options.stat;
+	  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+	  if (GLOBAL) {
+	    target = globalThis;
+	  } else if (STATIC) {
+	    target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
+	  } else {
+	    target = globalThis[TARGET] && globalThis[TARGET].prototype;
+	  }
+	  if (target) for (key in source) {
+	    sourceProperty = source[key];
+	    if (options.dontCallGetSet) {
+	      descriptor = getOwnPropertyDescriptor(target, key);
+	      targetProperty = descriptor && descriptor.value;
+	    } else targetProperty = target[key];
+	    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+	    // contained in target
+	    if (!FORCED && targetProperty !== undefined) {
+	      if (typeof sourceProperty == typeof targetProperty) continue;
+	      copyConstructorProperties(sourceProperty, targetProperty);
+	    }
+	    // add a flag to not completely full polyfills
+	    if (options.sham || (targetProperty && targetProperty.sham)) {
+	      createNonEnumerableProperty(sourceProperty, 'sham', true);
+	    }
+	    defineBuiltIn(target, key, sourceProperty, options);
+	  }
+	};
+	return _export;
+}
+
+export { require_export as __require };

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

@@ -0,0 +1,17 @@
+var fails;
+var hasRequiredFails;
+
+function requireFails () {
+	if (hasRequiredFails) return fails;
+	hasRequiredFails = 1;
+	fails = function (exec) {
+	  try {
+	    return !!exec();
+	  } catch (error) {
+	    return true;
+	  }
+	};
+	return fails;
+}
+
+export { requireFails as __require };

package/dist/ie/es/node_modules/core-js/internals/function-apply.js

@@ -0,0 +1,22 @@
+import { __require as requireFunctionBindNative } from './function-bind-native.js';
+
+var functionApply;
+var hasRequiredFunctionApply;
+
+function requireFunctionApply () {
+	if (hasRequiredFunctionApply) return functionApply;
+	hasRequiredFunctionApply = 1;
+	var NATIVE_BIND = requireFunctionBindNative();
+
+	var FunctionPrototype = Function.prototype;
+	var apply = FunctionPrototype.apply;
+	var call = FunctionPrototype.call;
+
+	// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
+	functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
+	  return call.apply(apply, arguments);
+	});
+	return functionApply;
+}
+
+export { requireFunctionApply as __require };

package/dist/ie/es/node_modules/core-js/internals/function-bind-context.js

@@ -0,0 +1,27 @@
+import { __require as requireFunctionUncurryThisClause } from './function-uncurry-this-clause.js';
+import { __require as requireACallable } from './a-callable.js';
+import { __require as requireFunctionBindNative } from './function-bind-native.js';
+
+var functionBindContext;
+var hasRequiredFunctionBindContext;
+
+function requireFunctionBindContext () {
+	if (hasRequiredFunctionBindContext) return functionBindContext;
+	hasRequiredFunctionBindContext = 1;
+	var uncurryThis = requireFunctionUncurryThisClause();
+	var aCallable = requireACallable();
+	var NATIVE_BIND = requireFunctionBindNative();
+
+	var bind = uncurryThis(uncurryThis.bind);
+
+	// optional / simple context binding
+	functionBindContext = function (fn, that) {
+	  aCallable(fn);
+	  return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
+	    return fn.apply(that, arguments);
+	  };
+	};
+	return functionBindContext;
+}
+
+export { requireFunctionBindContext as __require };

package/dist/ie/es/node_modules/core-js/internals/function-bind-native.js

@@ -0,0 +1,20 @@
+import { __require as requireFails } from './fails.js';
+
+var functionBindNative;
+var hasRequiredFunctionBindNative;
+
+function requireFunctionBindNative () {
+	if (hasRequiredFunctionBindNative) return functionBindNative;
+	hasRequiredFunctionBindNative = 1;
+	var fails = requireFails();
+
+	functionBindNative = !fails(function () {
+	  // eslint-disable-next-line es/no-function-prototype-bind -- safe
+	  var test = (function () { /* empty */ }).bind();
+	  // eslint-disable-next-line no-prototype-builtins -- safe
+	  return typeof test != 'function' || test.hasOwnProperty('prototype');
+	});
+	return functionBindNative;
+}
+
+export { requireFunctionBindNative as __require };

package/dist/ie/es/node_modules/core-js/internals/function-call.js

@@ -0,0 +1,19 @@
+import { __require as requireFunctionBindNative } from './function-bind-native.js';
+
+var functionCall;
+var hasRequiredFunctionCall;
+
+function requireFunctionCall () {
+	if (hasRequiredFunctionCall) return functionCall;
+	hasRequiredFunctionCall = 1;
+	var NATIVE_BIND = requireFunctionBindNative();
+
+	var call = Function.prototype.call;
+	// eslint-disable-next-line es/no-function-prototype-bind -- safe
+	functionCall = NATIVE_BIND ? call.bind(call) : function () {
+	  return call.apply(call, arguments);
+	};
+	return functionCall;
+}
+
+export { requireFunctionCall as __require };

package/dist/ie/es/node_modules/core-js/internals/function-name.js

@@ -0,0 +1,30 @@
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireHasOwnProperty } from './has-own-property.js';
+
+var functionName;
+var hasRequiredFunctionName;
+
+function requireFunctionName () {
+	if (hasRequiredFunctionName) return functionName;
+	hasRequiredFunctionName = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var hasOwn = requireHasOwnProperty();
+
+	var FunctionPrototype = Function.prototype;
+	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+
+	var EXISTS = hasOwn(FunctionPrototype, 'name');
+	// additional protection from minified / mangled / dropped function names
+	var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+	var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
+
+	functionName = {
+	  EXISTS: EXISTS,
+	  PROPER: PROPER,
+	  CONFIGURABLE: CONFIGURABLE
+	};
+	return functionName;
+}
+
+export { requireFunctionName as __require };

package/dist/ie/es/node_modules/core-js/internals/function-uncurry-this-accessor.js

@@ -0,0 +1,22 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireACallable } from './a-callable.js';
+
+var functionUncurryThisAccessor;
+var hasRequiredFunctionUncurryThisAccessor;
+
+function requireFunctionUncurryThisAccessor () {
+	if (hasRequiredFunctionUncurryThisAccessor) return functionUncurryThisAccessor;
+	hasRequiredFunctionUncurryThisAccessor = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var aCallable = requireACallable();
+
+	functionUncurryThisAccessor = function (object, key, method) {
+	  try {
+	    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+	    return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
+	  } catch (error) { /* empty */ }
+	};
+	return functionUncurryThisAccessor;
+}
+
+export { requireFunctionUncurryThisAccessor as __require };

package/dist/ie/es/node_modules/core-js/internals/function-uncurry-this-clause.js

@@ -0,0 +1,22 @@
+import { __require as requireClassofRaw } from './classof-raw.js';
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+
+var functionUncurryThisClause;
+var hasRequiredFunctionUncurryThisClause;
+
+function requireFunctionUncurryThisClause () {
+	if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
+	hasRequiredFunctionUncurryThisClause = 1;
+	var classofRaw = requireClassofRaw();
+	var uncurryThis = requireFunctionUncurryThis();
+
+	functionUncurryThisClause = function (fn) {
+	  // Nashorn bug:
+	  //   https://github.com/zloirock/core-js/issues/1128
+	  //   https://github.com/zloirock/core-js/issues/1130
+	  if (classofRaw(fn) === 'Function') return uncurryThis(fn);
+	};
+	return functionUncurryThisClause;
+}
+
+export { requireFunctionUncurryThisClause as __require };

package/dist/ie/es/node_modules/core-js/internals/function-uncurry-this.js

@@ -0,0 +1,24 @@
+import { __require as requireFunctionBindNative } from './function-bind-native.js';
+
+var functionUncurryThis;
+var hasRequiredFunctionUncurryThis;
+
+function requireFunctionUncurryThis () {
+	if (hasRequiredFunctionUncurryThis) return functionUncurryThis;
+	hasRequiredFunctionUncurryThis = 1;
+	var NATIVE_BIND = requireFunctionBindNative();
+
+	var FunctionPrototype = Function.prototype;
+	var call = FunctionPrototype.call;
+	// eslint-disable-next-line es/no-function-prototype-bind -- safe
+	var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+
+	functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
+	  return function () {
+	    return call.apply(fn, arguments);
+	  };
+	};
+	return functionUncurryThis;
+}
+
+export { requireFunctionUncurryThis as __require };

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

@@ -0,0 +1,23 @@
+import { __require as requireGlobalThis } from './global-this.js';
+import { __require as requireIsCallable } from './is-callable.js';
+
+var getBuiltIn;
+var hasRequiredGetBuiltIn;
+
+function requireGetBuiltIn () {
+	if (hasRequiredGetBuiltIn) return getBuiltIn;
+	hasRequiredGetBuiltIn = 1;
+	var globalThis = requireGlobalThis();
+	var isCallable = requireIsCallable();
+
+	var aFunction = function (argument) {
+	  return isCallable(argument) ? argument : undefined;
+	};
+
+	getBuiltIn = function (namespace, method) {
+	  return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
+	};
+	return getBuiltIn;
+}
+
+export { requireGetBuiltIn as __require };

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

@@ -0,0 +1,29 @@
+import { __require as requireClassof } from './classof.js';
+import { __require as requireGetMethod } from './get-method.js';
+import { __require as requireIsNullOrUndefined } from './is-null-or-undefined.js';
+import { __require as requireIterators } from './iterators.js';
+import { __require as requireWellKnownSymbol } from './well-known-symbol.js';
+
+var getIteratorMethod;
+var hasRequiredGetIteratorMethod;
+
+function requireGetIteratorMethod () {
+	if (hasRequiredGetIteratorMethod) return getIteratorMethod;
+	hasRequiredGetIteratorMethod = 1;
+	var classof = requireClassof();
+	var getMethod = requireGetMethod();
+	var isNullOrUndefined = requireIsNullOrUndefined();
+	var Iterators = requireIterators();
+	var wellKnownSymbol = requireWellKnownSymbol();
+
+	var ITERATOR = wellKnownSymbol('iterator');
+
+	getIteratorMethod = function (it) {
+	  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
+	    || getMethod(it, '@@iterator')
+	    || Iterators[classof(it)];
+	};
+	return getIteratorMethod;
+}
+
+export { requireGetIteratorMethod as __require };

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

@@ -0,0 +1,29 @@
+import { __require as requireFunctionCall } from './function-call.js';
+import { __require as requireACallable } from './a-callable.js';
+import { __require as requireAnObject } from './an-object.js';
+import { __require as requireTryToString } from './try-to-string.js';
+import { __require as requireGetIteratorMethod } from './get-iterator-method.js';
+
+var getIterator;
+var hasRequiredGetIterator;
+
+function requireGetIterator () {
+	if (hasRequiredGetIterator) return getIterator;
+	hasRequiredGetIterator = 1;
+	var call = requireFunctionCall();
+	var aCallable = requireACallable();
+	var anObject = requireAnObject();
+	var tryToString = requireTryToString();
+	var getIteratorMethod = requireGetIteratorMethod();
+
+	var $TypeError = TypeError;
+
+	getIterator = function (argument, usingIterator) {
+	  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+	  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+	  throw new $TypeError(tryToString(argument) + ' is not iterable');
+	};
+	return getIterator;
+}
+
+export { requireGetIterator as __require };

package/dist/ie/es/node_modules/core-js/internals/get-method.js

@@ -0,0 +1,22 @@
+import { __require as requireACallable } from './a-callable.js';
+import { __require as requireIsNullOrUndefined } from './is-null-or-undefined.js';
+
+var getMethod;
+var hasRequiredGetMethod;
+
+function requireGetMethod () {
+	if (hasRequiredGetMethod) return getMethod;
+	hasRequiredGetMethod = 1;
+	var aCallable = requireACallable();
+	var isNullOrUndefined = requireIsNullOrUndefined();
+
+	// `GetMethod` abstract operation
+	// https://tc39.es/ecma262/#sec-getmethod
+	getMethod = function (V, P) {
+	  var func = V[P];
+	  return isNullOrUndefined(func) ? undefined : aCallable(func);
+	};
+	return getMethod;
+}
+
+export { requireGetMethod as __require };

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

@@ -0,0 +1,27 @@
+import { commonjsGlobal } from '../../../_virtual/_commonjsHelpers.js';
+
+var globalThis_1;
+var hasRequiredGlobalThis;
+
+function requireGlobalThis () {
+	if (hasRequiredGlobalThis) return globalThis_1;
+	hasRequiredGlobalThis = 1;
+	var check = function (it) {
+	  return it && it.Math === Math && it;
+	};
+
+	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+	globalThis_1 =
+	  // eslint-disable-next-line es/no-global-this -- safe
+	  check(typeof globalThis == 'object' && globalThis) ||
+	  check(typeof window == 'object' && window) ||
+	  // eslint-disable-next-line no-restricted-globals -- safe
+	  check(typeof self == 'object' && self) ||
+	  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+	  check(typeof globalThis_1 == 'object' && globalThis_1) ||
+	  // eslint-disable-next-line no-new-func -- fallback
+	  (function () { return this; })() || Function('return this')();
+	return globalThis_1;
+}
+
+export { requireGlobalThis as __require };

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

@@ -0,0 +1,24 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireToObject } from './to-object.js';
+
+var hasOwnProperty_1;
+var hasRequiredHasOwnProperty;
+
+function requireHasOwnProperty () {
+	if (hasRequiredHasOwnProperty) return hasOwnProperty_1;
+	hasRequiredHasOwnProperty = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var toObject = requireToObject();
+
+	var hasOwnProperty = uncurryThis({}.hasOwnProperty);
+
+	// `HasOwnProperty` abstract operation
+	// https://tc39.es/ecma262/#sec-hasownproperty
+	// eslint-disable-next-line es/no-object-hasown -- safe
+	hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+	  return hasOwnProperty(toObject(it), key);
+	};
+	return hasOwnProperty_1;
+}
+
+export { requireHasOwnProperty as __require };

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

@@ -0,0 +1,11 @@
+var hiddenKeys;
+var hasRequiredHiddenKeys;
+
+function requireHiddenKeys () {
+	if (hasRequiredHiddenKeys) return hiddenKeys;
+	hasRequiredHiddenKeys = 1;
+	hiddenKeys = {};
+	return hiddenKeys;
+}
+
+export { requireHiddenKeys as __require };

package/dist/ie/es/node_modules/core-js/internals/host-report-errors.js

@@ -0,0 +1,16 @@
+var hostReportErrors;
+var hasRequiredHostReportErrors;
+
+function requireHostReportErrors () {
+	if (hasRequiredHostReportErrors) return hostReportErrors;
+	hasRequiredHostReportErrors = 1;
+	hostReportErrors = function (a, b) {
+	  try {
+	    // eslint-disable-next-line no-console -- safe
+	    arguments.length === 1 ? (void 0) : (void 0);
+	  } catch (error) { /* empty */ }
+	};
+	return hostReportErrors;
+}
+
+export { requireHostReportErrors as __require };

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

@@ -0,0 +1,15 @@
+import { __require as requireGetBuiltIn } from './get-built-in.js';
+
+var html;
+var hasRequiredHtml;
+
+function requireHtml () {
+	if (hasRequiredHtml) return html;
+	hasRequiredHtml = 1;
+	var getBuiltIn = requireGetBuiltIn();
+
+	html = getBuiltIn('document', 'documentElement');
+	return html;
+}
+
+export { requireHtml as __require };

package/dist/ie/es/node_modules/core-js/internals/ie8-dom-define.js

@@ -0,0 +1,25 @@
+import { __require as requireDescriptors } from './descriptors.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireDocumentCreateElement } from './document-create-element.js';
+
+var ie8DomDefine;
+var hasRequiredIe8DomDefine;
+
+function requireIe8DomDefine () {
+	if (hasRequiredIe8DomDefine) return ie8DomDefine;
+	hasRequiredIe8DomDefine = 1;
+	var DESCRIPTORS = requireDescriptors();
+	var fails = requireFails();
+	var createElement = requireDocumentCreateElement();
+
+	// Thanks to IE8 for its funny defineProperty
+	ie8DomDefine = !DESCRIPTORS && !fails(function () {
+	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+	  return Object.defineProperty(createElement('div'), 'a', {
+	    get: function () { return 7; }
+	  }).a !== 7;
+	});
+	return ie8DomDefine;
+}
+
+export { requireIe8DomDefine as __require };

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

@@ -0,0 +1,29 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireFails } from './fails.js';
+import { __require as requireClassofRaw } from './classof-raw.js';
+
+var indexedObject;
+var hasRequiredIndexedObject;
+
+function requireIndexedObject () {
+	if (hasRequiredIndexedObject) return indexedObject;
+	hasRequiredIndexedObject = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var fails = requireFails();
+	var classof = requireClassofRaw();
+
+	var $Object = Object;
+	var split = uncurryThis(''.split);
+
+	// fallback for non-array-like ES3 and non-enumerable old V8 strings
+	indexedObject = fails(function () {
+	  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+	  // eslint-disable-next-line no-prototype-builtins -- safe
+	  return !$Object('z').propertyIsEnumerable(0);
+	}) ? function (it) {
+	  return classof(it) === 'String' ? split(it, '') : $Object(it);
+	} : $Object;
+	return indexedObject;
+}
+
+export { requireIndexedObject as __require };

package/dist/ie/es/node_modules/core-js/internals/inspect-source.js

@@ -0,0 +1,28 @@
+import { __require as requireFunctionUncurryThis } from './function-uncurry-this.js';
+import { __require as requireIsCallable } from './is-callable.js';
+import { __require as requireSharedStore } from './shared-store.js';
+
+var inspectSource;
+var hasRequiredInspectSource;
+
+function requireInspectSource () {
+	if (hasRequiredInspectSource) return inspectSource;
+	hasRequiredInspectSource = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var isCallable = requireIsCallable();
+	var store = requireSharedStore();
+
+	var functionToString = uncurryThis(Function.toString);
+
+	// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+	if (!isCallable(store.inspectSource)) {
+	  store.inspectSource = function (it) {
+	    return functionToString(it);
+	  };
+	}
+
+	inspectSource = store.inspectSource;
+	return inspectSource;
+}
+
+export { requireInspectSource as __require };