vue3-color-picker-gradient
Version:
vue3,颜色选择器,线性（纯色）、渐变选择器,支持角度、多点渐变
1,734 lines (1,477 loc) • 1.72 MB
JavaScript
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = "fb15");
/******/ })
/************************************************************************/
/******/ ({
/***/ "0108":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var vue = __webpack_require__("8bbf");
var core = __webpack_require__("2c28");
__webpack_require__("25af");
var aria = __webpack_require__("b576");
let registeredEscapeHandlers = [];
const useEscapeKeydown = (handler) => {
const cachedHandler = (e) => {
const event = e;
if (event.key === aria.EVENT_CODE.esc) {
registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event));
}
};
vue.onMounted(() => {
if (registeredEscapeHandlers.length === 0) {
document.addEventListener("keydown", cachedHandler);
}
if (core.isClient)
registeredEscapeHandlers.push(handler);
});
vue.onBeforeUnmount(() => {
registeredEscapeHandlers = registeredEscapeHandlers.filter((registeredHandler) => registeredHandler !== handler);
if (registeredEscapeHandlers.length === 0) {
if (core.isClient)
document.removeEventListener("keydown", cachedHandler);
}
});
};
exports.useEscapeKeydown = useEscapeKeydown;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "06cf":
/***/ (function(module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__("83ab");
var call = __webpack_require__("c65b");
var propertyIsEnumerableModule = __webpack_require__("d1e7");
var createPropertyDescriptor = __webpack_require__("5c6c");
var toIndexedObject = __webpack_require__("fc6a");
var toPropertyKey = __webpack_require__("a04b");
var hasOwn = __webpack_require__("1a2d");
var IE8_DOM_DEFINE = __webpack_require__("0cfb");
// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
// `Object.getOwnPropertyDescriptor` method
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
O = toIndexedObject(O);
P = toPropertyKey(P);
if (IE8_DOM_DEFINE) try {
return $getOwnPropertyDescriptor(O, P);
} catch (error) { /* empty */ }
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
};
/***/ }),
/***/ "07f2":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
__webpack_require__("876b");
var tooltip$1 = __webpack_require__("1489");
var tooltip = __webpack_require__("d07a");
var tokens = __webpack_require__("d65d");
var install = __webpack_require__("d53c");
const ElTooltip = install.withInstall(tooltip$1["default"]);
exports.useTooltipContentProps = tooltip.useTooltipContentProps;
exports.useTooltipProps = tooltip.useTooltipProps;
exports.useTooltipTriggerProps = tooltip.useTooltipTriggerProps;
exports.TOOLTIP_INJECTION_KEY = tokens.TOOLTIP_INJECTION_KEY;
exports.ElTooltip = ElTooltip;
exports["default"] = ElTooltip;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "07fa":
/***/ (function(module, exports, __webpack_require__) {
var toLength = __webpack_require__("50c4");
// `LengthOfArrayLike` abstract operation
// https://tc39.es/ecma262/#sec-lengthofarraylike
module.exports = function (obj) {
return toLength(obj.length);
};
/***/ }),
/***/ "09ac":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var shared = __webpack_require__("9ff4");
const useSameTarget = (handleClick) => {
if (!handleClick) {
return { onClick: shared.NOOP, onMousedown: shared.NOOP, onMouseup: shared.NOOP };
}
let mousedownTarget = false;
let mouseupTarget = false;
const onClick = (e) => {
if (mousedownTarget && mouseupTarget) {
handleClick(e);
}
mousedownTarget = mouseupTarget = false;
};
const onMousedown = (e) => {
mousedownTarget = e.target === e.currentTarget;
};
const onMouseup = (e) => {
mouseupTarget = e.target === e.currentTarget;
};
return { onClick, onMousedown, onMouseup };
};
exports.useSameTarget = useSameTarget;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "0a14":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var vue = __webpack_require__("8bbf");
var shared = __webpack_require__("9ff4");
__webpack_require__("6428");
var error = __webpack_require__("f41e");
const SCOPE = "utils/vue/vnode";
var PatchFlags = /* @__PURE__ */ ((PatchFlags2) => {
PatchFlags2[PatchFlags2["TEXT"] = 1] = "TEXT";
PatchFlags2[PatchFlags2["CLASS"] = 2] = "CLASS";
PatchFlags2[PatchFlags2["STYLE"] = 4] = "STYLE";
PatchFlags2[PatchFlags2["PROPS"] = 8] = "PROPS";
PatchFlags2[PatchFlags2["FULL_PROPS"] = 16] = "FULL_PROPS";
PatchFlags2[PatchFlags2["HYDRATE_EVENTS"] = 32] = "HYDRATE_EVENTS";
PatchFlags2[PatchFlags2["STABLE_FRAGMENT"] = 64] = "STABLE_FRAGMENT";
PatchFlags2[PatchFlags2["KEYED_FRAGMENT"] = 128] = "KEYED_FRAGMENT";
PatchFlags2[PatchFlags2["UNKEYED_FRAGMENT"] = 256] = "UNKEYED_FRAGMENT";
PatchFlags2[PatchFlags2["NEED_PATCH"] = 512] = "NEED_PATCH";
PatchFlags2[PatchFlags2["DYNAMIC_SLOTS"] = 1024] = "DYNAMIC_SLOTS";
PatchFlags2[PatchFlags2["HOISTED"] = -1] = "HOISTED";
PatchFlags2[PatchFlags2["BAIL"] = -2] = "BAIL";
return PatchFlags2;
})(PatchFlags || {});
function isFragment(node) {
return vue.isVNode(node) && node.type === vue.Fragment;
}
function isText(node) {
return vue.isVNode(node) && node.type === vue.Text;
}
function isComment(node) {
return vue.isVNode(node) && node.type === vue.Comment;
}
const TEMPLATE = "template";
function isTemplate(node) {
return vue.isVNode(node) && node.type === TEMPLATE;
}
function isValidElementNode(node) {
return vue.isVNode(node) && !isFragment(node) && !isComment(node);
}
function getChildren(node, depth) {
if (isComment(node))
return;
if (isFragment(node) || isTemplate(node)) {
return depth > 0 ? getFirstValidNode(node.children, depth - 1) : void 0;
}
return node;
}
const getFirstValidNode = (nodes, maxDepth = 3) => {
if (Array.isArray(nodes)) {
return getChildren(nodes[0], maxDepth);
} else {
return getChildren(nodes, maxDepth);
}
};
function renderIf(condition, ...args) {
return condition ? renderBlock(...args) : vue.createCommentVNode("v-if", true);
}
function renderBlock(...args) {
return vue.openBlock(), vue.createBlock(...args);
}
const getNormalizedProps = (node) => {
if (!vue.isVNode(node)) {
error.debugWarn(SCOPE, "[getNormalizedProps] must be a VNode");
return {};
}
const raw = node.props || {};
const type = (vue.isVNode(node.type) ? node.type.props : void 0) || {};
const props = {};
Object.keys(type).forEach((key) => {
if (shared.hasOwn(type[key], "default")) {
props[key] = type[key].default;
}
});
Object.keys(raw).forEach((key) => {
props[shared.camelize(key)] = raw[key];
});
return props;
};
const ensureOnlyChild = (children) => {
if (!shared.isArray(children) || children.length > 1) {
throw new Error("expect to receive a single Vue element child");
}
return children[0];
};
exports.PatchFlags = PatchFlags;
exports.ensureOnlyChild = ensureOnlyChild;
exports.getFirstValidNode = getFirstValidNode;
exports.getNormalizedProps = getNormalizedProps;
exports.isComment = isComment;
exports.isFragment = isFragment;
exports.isTemplate = isTemplate;
exports.isText = isText;
exports.isValidElementNode = isValidElementNode;
exports.renderBlock = renderBlock;
exports.renderIf = renderIf;
//# sourceMappingURL=vnode.js.map
/***/ }),
/***/ "0b99":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
//# sourceMappingURL=typescript.js.map
/***/ }),
/***/ "0c6b":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
__webpack_require__("25af");
var size = __webpack_require__("fd5e");
var date = __webpack_require__("8658");
const isValidComponentSize = (val) => ["", ...size.componentSizes].includes(val);
const isValidDatePickType = (val) => [...date.datePickTypes].includes(val);
exports.isValidComponentSize = isValidComponentSize;
exports.isValidDatePickType = isValidDatePickType;
//# sourceMappingURL=validator.js.map
/***/ }),
/***/ "0c6c":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var core = __webpack_require__("2c28");
const buildPopperOptions = (props, arrowProps) => {
const { placement, strategy, popperOptions } = props;
const options = {
placement,
strategy,
...popperOptions,
modifiers: genModifiers(props)
};
attachArrow(options, arrowProps);
deriveExtraModifiers(options, popperOptions == null ? void 0 : popperOptions.modifiers);
return options;
};
const unwrapMeasurableEl = ($el) => {
if (!core.isClient)
return;
return core.unrefElement($el);
};
function genModifiers(options) {
const { offset, gpuAcceleration, fallbackPlacements } = options;
return [
{
name: "offset",
options: {
offset: [0, offset != null ? offset : 12]
}
},
{
name: "preventOverflow",
options: {
padding: {
top: 2,
bottom: 2,
left: 5,
right: 5
}
}
},
{
name: "flip",
options: {
padding: 5,
fallbackPlacements: fallbackPlacements != null ? fallbackPlacements : []
}
},
{
name: "computeStyles",
options: {
gpuAcceleration,
adaptive: gpuAcceleration
}
}
];
}
function attachArrow(options, { arrowEl, arrowOffset }) {
options.modifiers.push({
name: "arrow",
options: {
element: arrowEl,
padding: arrowOffset != null ? arrowOffset : 5
}
});
}
function deriveExtraModifiers(options, modifiers) {
if (modifiers) {
options.modifiers = [...options.modifiers, ...modifiers != null ? modifiers : []];
}
}
exports.buildPopperOptions = buildPopperOptions;
exports.unwrapMeasurableEl = unwrapMeasurableEl;
//# sourceMappingURL=utils.js.map
/***/ }),
/***/ "0cb9":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var core = __webpack_require__("2c28");
__webpack_require__("a19d");
__webpack_require__("4477");
var objects = __webpack_require__("6428");
var error = __webpack_require__("f41e");
var shared = __webpack_require__("9ff4");
const SCOPE = "utils/dom/style";
const classNameToArray = (cls = "") => cls.split(" ").filter((item) => !!item.trim());
const hasClass = (el, cls) => {
if (!el || !cls)
return false;
if (cls.includes(" "))
throw new Error("className should not contain space.");
return el.classList.contains(cls);
};
const addClass = (el, cls) => {
if (!el || !cls.trim())
return;
el.classList.add(...classNameToArray(cls));
};
const removeClass = (el, cls) => {
if (!el || !cls.trim())
return;
el.classList.remove(...classNameToArray(cls));
};
const getStyle = (element, styleName) => {
var _a;
if (!core.isClient || !element || !styleName)
return "";
let key = shared.camelize(styleName);
if (key === "float")
key = "cssFloat";
try {
const style = element.style[key];
if (style)
return style;
const computed = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(element, "");
return computed ? computed[key] : "";
} catch (e) {
return element.style[key];
}
};
const setStyle = (element, styleName, value) => {
if (!element || !styleName)
return;
if (shared.isObject(styleName)) {
objects.entriesOf(styleName).forEach(([prop, value2]) => setStyle(element, prop, value2));
} else {
const key = shared.camelize(styleName);
element.style[key] = value;
}
};
const removeStyle = (element, style) => {
if (!element || !style)
return;
if (shared.isObject(style)) {
objects.keysOf(style).forEach((prop) => removeStyle(element, prop));
} else {
setStyle(element, style, "");
}
};
function addUnit(value, defaultUnit = "px") {
if (!value)
return "";
if (shared.isString(value)) {
return value;
} else if (core.isNumber(value)) {
return `${value}${defaultUnit}`;
}
error.debugWarn(SCOPE, "binding value must be a string or number");
}
exports.addClass = addClass;
exports.addUnit = addUnit;
exports.classNameToArray = classNameToArray;
exports.getStyle = getStyle;
exports.hasClass = hasClass;
exports.removeClass = removeClass;
exports.removeStyle = removeStyle;
exports.setStyle = setStyle;
//# sourceMappingURL=style.js.map
/***/ }),
/***/ "0cfb":
/***/ (function(module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__("83ab");
var fails = __webpack_require__("d039");
var createElement = __webpack_require__("cc12");
// Thanks to IE8 for its funny defineProperty
module.exports = !DESCRIPTORS && !fails(function () {
// eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
return Object.defineProperty(createElement('div'), 'a', {
get: function () { return 7; }
}).a != 7;
});
/***/ }),
/***/ "0d51":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAlphaValue = exports.validateColorStops = exports.validateMinMaxValues = void 0;
function validateMinMaxValues(min, max) {
if (min === max) {
throw new Error('The minimum value cannot be equal to the maximum value.');
}
else if (min > max) {
throw new Error('The minimum value must be less than the maximum value.');
}
}
exports.validateMinMaxValues = validateMinMaxValues;
function validateColorStops(colorStops) {
if (colorStops.length < 2) {
throw new Error('At least two colors must be provided.');
}
}
exports.validateColorStops = validateColorStops;
function validateAlphaValue(alpha) {
if (alpha < 0 || alpha > 1) {
throw new Error('The alpha value must be between 0 and 1.');
}
}
exports.validateAlphaValue = validateAlphaValue;
/***/ }),
/***/ "0d516":
/***/ (function(module, exports) {
var $String = String;
module.exports = function (argument) {
try {
return $String(argument);
} catch (error) {
return 'Object';
}
};
/***/ }),
/***/ "0ed7":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var vue = __webpack_require__("8bbf");
var lodashUnified = __webpack_require__("d095");
__webpack_require__("25af");
__webpack_require__("af2e");
var aria = __webpack_require__("b576");
var slider = __webpack_require__("8dc1");
var event = __webpack_require__("6296");
const { left, down, right, up, home, end, pageUp, pageDown } = aria.EVENT_CODE;
const useTooltip = (props, formatTooltip, showTooltip) => {
const tooltip = vue.ref();
const tooltipVisible = vue.ref(false);
const enableFormat = vue.computed(() => {
return formatTooltip.value instanceof Function;
});
const formatValue = vue.computed(() => {
return enableFormat.value && formatTooltip.value(props.modelValue) || props.modelValue;
});
const displayTooltip = lodashUnified.debounce(() => {
showTooltip.value && (tooltipVisible.value = true);
}, 50);
const hideTooltip = lodashUnified.debounce(() => {
showTooltip.value && (tooltipVisible.value = false);
}, 50);
return {
tooltip,
tooltipVisible,
formatValue,
displayTooltip,
hideTooltip
};
};
const useSliderButton = (props, initData, emit) => {
const {
disabled,
min,
max,
step,
showTooltip,
precision,
sliderSize,
formatTooltip,
emitChange,
resetSize,
updateDragging
} = vue.inject(slider.sliderContextKey);
const { tooltip, tooltipVisible, formatValue, displayTooltip, hideTooltip } = useTooltip(props, formatTooltip, showTooltip);
const button = vue.ref();
const currentPosition = vue.computed(() => {
return `${(props.modelValue - min.value) / (max.value - min.value) * 100}%`;
});
const wrapperStyle = vue.computed(() => {
return props.vertical ? { bottom: currentPosition.value } : { left: currentPosition.value };
});
const handleMouseEnter = () => {
initData.hovering = true;
displayTooltip();
};
const handleMouseLeave = () => {
initData.hovering = false;
if (!initData.dragging) {
hideTooltip();
}
};
const onButtonDown = (event) => {
if (disabled.value)
return;
event.preventDefault();
onDragStart(event);
window.addEventListener("mousemove", onDragging);
window.addEventListener("touchmove", onDragging);
window.addEventListener("mouseup", onDragEnd);
window.addEventListener("touchend", onDragEnd);
window.addEventListener("contextmenu", onDragEnd);
button.value.focus();
};
const incrementPosition = (amount) => {
if (disabled.value)
return;
initData.newPosition = Number.parseFloat(currentPosition.value) + amount / (max.value - min.value) * 100;
setPosition(initData.newPosition);
emitChange();
};
const onLeftKeyDown = () => {
incrementPosition(-step.value);
};
const onRightKeyDown = () => {
incrementPosition(step.value);
};
const onPageDownKeyDown = () => {
incrementPosition(-step.value * 4);
};
const onPageUpKeyDown = () => {
incrementPosition(step.value * 4);
};
const onHomeKeyDown = () => {
if (disabled.value)
return;
setPosition(0);
emitChange();
};
const onEndKeyDown = () => {
if (disabled.value)
return;
setPosition(100);
emitChange();
};
const onKeyDown = (event) => {
let isPreventDefault = true;
if ([left, down].includes(event.key)) {
onLeftKeyDown();
} else if ([right, up].includes(event.key)) {
onRightKeyDown();
} else if (event.key === home) {
onHomeKeyDown();
} else if (event.key === end) {
onEndKeyDown();
} else if (event.key === pageDown) {
onPageDownKeyDown();
} else if (event.key === pageUp) {
onPageUpKeyDown();
} else {
isPreventDefault = false;
}
isPreventDefault && event.preventDefault();
};
const getClientXY = (event) => {
let clientX;
let clientY;
if (event.type.startsWith("touch")) {
clientY = event.touches[0].clientY;
clientX = event.touches[0].clientX;
} else {
clientY = event.clientY;
clientX = event.clientX;
}
return {
clientX,
clientY
};
};
const onDragStart = (event) => {
initData.dragging = true;
initData.isClick = true;
const { clientX, clientY } = getClientXY(event);
if (props.vertical) {
initData.startY = clientY;
} else {
initData.startX = clientX;
}
initData.startPosition = Number.parseFloat(currentPosition.value);
initData.newPosition = initData.startPosition;
};
const onDragging = (event) => {
if (initData.dragging) {
initData.isClick = false;
displayTooltip();
resetSize();
let diff;
const { clientX, clientY } = getClientXY(event);
if (props.vertical) {
initData.currentY = clientY;
diff = (initData.startY - initData.currentY) / sliderSize.value * 100;
} else {
initData.currentX = clientX;
diff = (initData.currentX - initData.startX) / sliderSize.value * 100;
}
initData.newPosition = initData.startPosition + diff;
setPosition(initData.newPosition);
}
};
const onDragEnd = () => {
if (initData.dragging) {
setTimeout(() => {
initData.dragging = false;
if (!initData.hovering) {
hideTooltip();
}
if (!initData.isClick) {
setPosition(initData.newPosition);
emitChange();
}
}, 0);
window.removeEventListener("mousemove", onDragging);
window.removeEventListener("touchmove", onDragging);
window.removeEventListener("mouseup", onDragEnd);
window.removeEventListener("touchend", onDragEnd);
window.removeEventListener("contextmenu", onDragEnd);
}
};
const setPosition = async (newPosition) => {
if (newPosition === null || Number.isNaN(+newPosition))
return;
if (newPosition < 0) {
newPosition = 0;
} else if (newPosition > 100) {
newPosition = 100;
}
const lengthPerStep = 100 / ((max.value - min.value) / step.value);
const steps = Math.round(newPosition / lengthPerStep);
let value = steps * lengthPerStep * (max.value - min.value) * 0.01 + min.value;
value = Number.parseFloat(value.toFixed(precision.value));
emit(event.UPDATE_MODEL_EVENT, value);
if (!initData.dragging && props.modelValue !== initData.oldValue) {
initData.oldValue = props.modelValue;
}
await vue.nextTick();
initData.dragging && displayTooltip();
tooltip.value.updatePopper();
};
vue.watch(() => initData.dragging, (val) => {
updateDragging(val);
});
return {
button,
tooltip,
tooltipVisible,
showTooltip,
wrapperStyle,
formatValue,
handleMouseEnter,
handleMouseLeave,
onButtonDown,
onKeyDown,
setPosition
};
};
exports.useSliderButton = useSliderButton;
//# sourceMappingURL=use-slider-button.js.map
/***/ }),
/***/ "0f0e":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var vue = __webpack_require__("8bbf");
var index = __webpack_require__("ce4a");
const zIndex = vue.ref(0);
const useZIndex = () => {
const initialZIndex = index.useGlobalConfig("zIndex", 2e3);
const currentZIndex = vue.computed(() => initialZIndex.value + zIndex.value);
const nextZIndex = () => {
zIndex.value++;
return currentZIndex.value;
};
return {
initialZIndex,
currentZIndex,
nextZIndex
};
};
exports.useZIndex = useZIndex;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "0f17":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
const breadcrumbKey = Symbol("breadcrumbKey");
exports.breadcrumbKey = breadcrumbKey;
//# sourceMappingURL=breadcrumb.js.map
/***/ }),
/***/ "0f62":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
__webpack_require__("ccb9");
__webpack_require__("3286");
var runtime = __webpack_require__("a9b2");
exports.buildProp = runtime.buildProp;
exports.buildProps = runtime.buildProps;
exports.definePropType = runtime.definePropType;
exports.epPropKey = runtime.epPropKey;
exports.isEpProp = runtime.isEpProp;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "1227":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var focusTrap = __webpack_require__("e859");
var tokens = __webpack_require__("3dc1");
var utils = __webpack_require__("a5e4");
exports.ElFocusTrap = focusTrap["default"];
exports["default"] = focusTrap["default"];
exports.FOCUS_AFTER_RELEASED = tokens.FOCUS_AFTER_RELEASED;
exports.FOCUS_AFTER_TRAPPED = tokens.FOCUS_AFTER_TRAPPED;
exports.FOCUS_AFTER_TRAPPED_OPTS = tokens.FOCUS_AFTER_TRAPPED_OPTS;
exports.FOCUS_TRAP_INJECTION_KEY = tokens.FOCUS_TRAP_INJECTION_KEY;
exports.ON_RELEASE_FOCUS_EVT = tokens.ON_RELEASE_FOCUS_EVT;
exports.ON_TRAP_FOCUS_EVT = tokens.ON_TRAP_FOCUS_EVT;
exports.focusFirstDescendant = utils.focusFirstDescendant;
exports.focusableStack = utils.focusableStack;
exports.getEdges = utils.getEdges;
exports.getVisibleElement = utils.getVisibleElement;
exports.isHidden = utils.isHidden;
exports.obtainAllFocusableElements = utils.obtainAllFocusableElements;
exports.tryFocus = utils.tryFocus;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "128e":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var vue = __webpack_require__("8bbf");
var core = __webpack_require__("2c28");
var lodashUnified = __webpack_require__("d095");
var dom = __webpack_require__("e20a");
__webpack_require__("876b");
var runtime = __webpack_require__("a9b2");
var objects = __webpack_require__("6428");
const useFloatingProps = runtime.buildProps({});
const unrefReference = (elRef) => {
if (!core.isClient)
return;
if (!elRef)
return elRef;
const unrefEl = core.unrefElement(elRef);
if (unrefEl)
return unrefEl;
return vue.isRef(elRef) ? unrefEl : elRef;
};
const getPositionDataWithUnit = (record, key) => {
const value = record == null ? void 0 : record[key];
return lodashUnified.isNil(value) ? "" : `${value}px`;
};
const useFloating = ({
middleware,
placement,
strategy
}) => {
const referenceRef = vue.ref();
const contentRef = vue.ref();
const x = vue.ref();
const y = vue.ref();
const middlewareData = vue.ref({});
const states = {
x,
y,
placement,
strategy,
middlewareData
};
const update = async () => {
if (!core.isClient)
return;
const referenceEl = unrefReference(referenceRef);
const contentEl = core.unrefElement(contentRef);
if (!referenceEl || !contentEl)
return;
const data = await dom.computePosition(referenceEl, contentEl, {
placement: vue.unref(placement),
strategy: vue.unref(strategy),
middleware: vue.unref(middleware)
});
objects.keysOf(states).forEach((key) => {
states[key].value = data[key];
});
};
vue.onMounted(() => {
vue.watchEffect(() => {
update();
});
});
return {
...states,
update,
referenceRef,
contentRef
};
};
const arrowMiddleware = ({
arrowRef,
padding
}) => {
return {
name: "arrow",
options: {
element: arrowRef,
padding
},
fn(args) {
const arrowEl = vue.unref(arrowRef);
if (!arrowEl)
return {};
return dom.arrow({
element: arrowEl,
padding
}).fn(args);
}
};
};
exports.arrowMiddleware = arrowMiddleware;
exports.getPositionDataWithUnit = getPositionDataWithUnit;
exports.useFloating = useFloating;
exports.useFloatingProps = useFloatingProps;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "1290":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
__webpack_require__("25af");
var size = __webpack_require__("fd5e");
const getComponentSize = (size$1) => {
return size.componentSizeMap[size$1 || "default"];
};
exports.getComponentSize = getComponentSize;
//# sourceMappingURL=size.js.map
/***/ }),
/***/ "136a":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var core = __webpack_require__("2c28");
const isInContainer = (el, container) => {
if (!core.isClient || !el || !container)
return false;
const elRect = el.getBoundingClientRect();
let containerRect;
if (container instanceof Element) {
containerRect = container.getBoundingClientRect();
} else {
containerRect = {
top: 0,
right: window.innerWidth,
bottom: window.innerHeight,
left: 0
};
}
return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
};
const getOffsetTop = (el) => {
let offset = 0;
let parent = el;
while (parent) {
offset += parent.offsetTop;
parent = parent.offsetParent;
}
return offset;
};
const getOffsetTopDistance = (el, containerEl) => {
return Math.abs(getOffsetTop(el) - getOffsetTop(containerEl));
};
const getClientXY = (event) => {
let clientX;
let clientY;
if (event.type === "touchend") {
clientY = event.changedTouches[0].clientY;
clientX = event.changedTouches[0].clientX;
} else if (event.type.startsWith("touch")) {
clientY = event.touches[0].clientY;
clientX = event.touches[0].clientX;
} else {
clientY = event.clientY;
clientX = event.clientX;
}
return {
clientX,
clientY
};
};
exports.getClientXY = getClientXY;
exports.getOffsetTop = getOffsetTop;
exports.getOffsetTopDistance = getOffsetTopDistance;
exports.isInContainer = isInContainer;
//# sourceMappingURL=position.js.map
/***/ }),
/***/ "13d2":
/***/ (function(module, exports, __webpack_require__) {
var fails = __webpack_require__("d039");
var isCallable = __webpack_require__("1626");
var hasOwn = __webpack_require__("1a2d");
var DESCRIPTORS = __webpack_require__("83ab");
var CONFIGURABLE_FUNCTION_NAME = __webpack_require__("5e77").CONFIGURABLE;
var inspectSource = __webpack_require__("8925");
var InternalStateModule = __webpack_require__("69f3");
var enforceInternalState = InternalStateModule.enforce;
var getInternalState = InternalStateModule.get;
// eslint-disable-next-line es-x/no-object-defineproperty -- safe
var defineProperty = Object.defineProperty;
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
});
var TEMPLATE = String(String).split('String');
var makeBuiltIn = module.exports = function (value, name, options) {
if (String(name).slice(0, 7) === 'Symbol(') {
name = '[' + String(name).replace(/^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 = TEMPLATE.join(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(function toString() {
return isCallable(this) && getInternalState(this).source || inspectSource(this);
}, 'toString');
/***/ }),
/***/ "1489":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var vue = __webpack_require__("8bbf");
var index$1 = __webpack_require__("4045");
__webpack_require__("876b");
__webpack_require__("4f6e");
var content = __webpack_require__("260d");
var trigger = __webpack_require__("50b2");
var tooltip = __webpack_require__("d07a");
var tokens = __webpack_require__("d65d");
var pluginVue_exportHelper = __webpack_require__("cb7e");
var index = __webpack_require__("beb8");
var arrow = __webpack_require__("f124");
var popper = __webpack_require__("ff7f");
var arrow$1 = __webpack_require__("9ae7");
var index$2 = __webpack_require__("3056");
var types = __webpack_require__("a19d");
var error = __webpack_require__("f41e");
var core = __webpack_require__("2c28");
var index$3 = __webpack_require__("31ba");
var index$4 = __webpack_require__("88aa");
const { useModelToggleProps, useModelToggle, useModelToggleEmits } = index.createModelToggleComposable("visible");
const _sfc_main = vue.defineComponent({
name: "ElTooltip",
components: {
ElPopper: index$1.ElPopper,
ElPopperArrow: arrow["default"],
ElTooltipContent: content["default"],
ElTooltipTrigger: trigger["default"]
},
props: {
...popper.usePopperProps,
...useModelToggleProps,
...tooltip.useTooltipContentProps,
...tooltip.useTooltipTriggerProps,
...arrow$1.usePopperArrowProps,
...tooltip.useTooltipProps
},
emits: [
...useModelToggleEmits,
"before-show",
"before-hide",
"show",
"hide",
"open",
"close"
],
setup(props, { emit }) {
index$2.usePopperContainer();
const compatShowAfter = vue.computed(() => {
if (!types.isUndefined(props.openDelay)) {
error.debugWarn("ElTooltip", "open-delay is about to be deprecated in the next major version, please use `show-after` instead");
}
return props.openDelay || props.showAfter;
});
const compatShowArrow = vue.computed(() => {
if (!types.isUndefined(props.visibleArrow)) {
error.debugWarn("ElTooltip", "`visible-arrow` is about to be deprecated in the next major version, please use `show-arrow` instead");
}
return core.isBoolean(props.visibleArrow) ? props.visibleArrow : props.showArrow;
});
const id = index$3.useId();
const popperRef = vue.ref(null);
const contentRef = vue.ref(null);
const updatePopper = () => {
var _a;
const popperComponent = vue.unref(popperRef);
if (popperComponent) {
(_a = popperComponent.popperInstanceRef) == null ? void 0 : _a.update();
}
};
const open = vue.ref(false);
const toggleReason = vue.ref(void 0);
const { show, hide } = useModelToggle({
indicator: open,
toggleReason
});
const { onOpen, onClose } = index$4.useDelayedToggle({
showAfter: compatShowAfter,
hideAfter: vue.toRef(props, "hideAfter"),
open: show,
close: hide
});
const controlled = vue.computed(() => core.isBoolean(props.visible));
vue.provide(tokens.TOOLTIP_INJECTION_KEY, {
controlled,
id,
open: vue.readonly(open),
trigger: vue.toRef(props, "trigger"),
onOpen: (event) => {
onOpen(event);
},
onClose: (event) => {
onClose(event);
},
onToggle: (event) => {
if (vue.unref(open)) {
onClose(event);
} else {
onOpen(event);
}
},
onShow: () => {
emit("show", toggleReason.value);
},
onHide: () => {
emit("hide", toggleReason.value);
},
onBeforeShow: () => {
emit("before-show", toggleReason.value);
},
onBeforeHide: () => {
emit("before-hide", toggleReason.value);
},
updatePopper
});
vue.watch(() => props.disabled, (disabled) => {
if (disabled && open.value) {
open.value = false;
}
});
const isFocusInsideContent = () => {
var _a, _b;
const popperContent = (_b = (_a = contentRef.value) == null ? void 0 : _a.contentRef) == null ? void 0 : _b.popperContentRef;
return popperContent && popperContent.contains(document.activeElement);
};
vue.onDeactivated(() => open.value && hide());
return {
compatShowAfter,
compatShowArrow,
popperRef,
contentRef,
open,
hide,
isFocusInsideContent,
updatePopper,
onOpen,
onClose
};
}
});
const _hoisted_1 = ["innerHTML"];
const _hoisted_2 = { key: 1 };
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
const _component_el_tooltip_trigger = vue.resolveComponent("el-tooltip-trigger");
const _component_el_popper_arrow = vue.resolveComponent("el-popper-arrow");
const _component_el_tooltip_content = vue.resolveComponent("el-tooltip-content");
const _component_el_popper = vue.resolveComponent("el-popper");
return vue.openBlock(), vue.createBlock(_component_el_popper, {
ref: "popperRef",
role: _ctx.role
}, {
default: vue.withCtx(() => [
vue.createVNode(_component_el_tooltip_trigger, {
disabled: _ctx.disabled,
trigger: _ctx.trigger,
"trigger-keys": _ctx.triggerKeys,
"virtual-ref": _ctx.virtualRef,
"virtual-triggering": _ctx.virtualTriggering
}, {
default: vue.withCtx(() => [
_ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }) : vue.createCommentVNode("v-if", true)
]),
_: 3
}, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
vue.createVNode(_component_el_tooltip_content, {
ref: "contentRef",
"aria-label": _ctx.ariaLabel,
"boundaries-padding": _ctx.boundariesPadding,
content: _ctx.content,
disabled: _ctx.disabled,
effect: _ctx.effect,
enterable: _ctx.enterable,
"fallback-placements": _ctx.fallbackPlacements,
"hide-after": _ctx.hideAfter,
"gpu-acceleration": _ctx.gpuAcceleration,
offset: _ctx.offset,
persistent: _ctx.persistent,
"popper-class": _ctx.popperClass,
"popper-style": _ctx.popperStyle,
placement: _ctx.placement,
"popper-options": _ctx.popperOptions,
pure: _ctx.pure,
"raw-content": _ctx.rawContent,
"reference-el": _ctx.referenceEl,
"trigger-target-el": _ctx.triggerTargetEl,
"show-after": _ctx.compatShowAfter,
strategy: _ctx.strategy,
teleported: _ctx.teleported,
transition: _ctx.transition,
"virtual-triggering": _ctx.virtualTriggering,
"z-index": _ctx.zIndex,
"append-to": _ctx.appendTo
}, {
default: vue.withCtx(() => [
vue.renderSlot(_ctx.$slots, "content", {}, () => [
_ctx.rawContent ? (vue.openBlock(), vue.createElementBlock("span", {
key: 0,
innerHTML: _ctx.content
}, null, 8, _hoisted_1)) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_2, vue.toDisplayString(_ctx.content), 1))
]),
_ctx.compatShowArrow ? (vue.openBlock(), vue.createBlock(_component_el_popper_arrow, {
key: 0,
"arrow-offset": _ctx.arrowOffset
}, null, 8, ["arrow-offset"])) : vue.createCommentVNode("v-if", true)
]),
_: 3
}, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to"])
]),
_: 3
}, 8, ["role"]);
}
var Tooltip = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip/src/tooltip.vue"]]);
exports["default"] = Tooltip;
//# sourceMappingURL=tooltip2.js.map
/***/ }),
/***/ "1626":
/***/ (function(module, exports) {
// `IsCallable` abstract operation
// https://tc39.es/ecma262/#sec-iscallable
module.exports = function (argument) {
return typeof argument == 'function';
};
/***/ }),
/***/ "16df":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
const tabsRootContextKey = Symbol("tabsRootContextKey");
exports.tabsRootContextKey = tabsRootContextKey;
//# sourceMappingURL=tabs.js.map
/***/ }),
/***/ "16e0":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var core = __webpack_require__("2c28");
function useTimeout() {
let timeoutHandle;
const registerTimeout = (fn, delay) => {
cancelTimeout();
timeoutHandle = window.setTimeout(fn, delay);
};
const cancelTimeout = () => window.clearTimeout(timeoutHandle);
core.tryOnScopeDispose(() => cancelTimeout());
return {
registerTimeout,
cancelTimeout
};
}
exports.useTimeout = useTimeout;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "183e":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
__webpack_require__("876b");
var inputNumber$1 = __webpack_require__("9133");
var inputNumber = __webpack_require__("5176");
var install = __webpack_require__("d53c");
const ElInputNumber = install.withInstall(inputNumber$1["default"]);
exports.inputNumberEmits = inputNumber.inputNumberEmits;
exports.inputNumberProps = inputNumber.inputNumberProps;
exports.ElInputNumber = ElInputNumber;
exports["default"] = ElInputNumber;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ "1a2d":
/***/ (function(module, exports, __webpack_require__) {
var uncurryThis = __webpack_require__("e330");
var toObject = __webpack_require__("7b0b");
var hasOwnProperty = uncurryThis({}.hasOwnProperty);
// `HasOwnProperty` abstract operation
// https://tc39.es/ecma262/#sec-hasownproperty
// eslint-disable-next-line es-x/no-object-hasown -- safe
module.exports = Object.hasOwn || function hasOwn(it, key) {
return hasOwnProperty(toObject(it), key);
};
/***/ }),
/***/ "1a8c":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var core = __webpack_require__("2c28");
const globalNodes = [];
let target = !core.isClient ? void 0 : document.body;
function createGlobalNode(id) {
const el = document.createElement("div");
if (id !== void 0) {
el.setAttribute("id", id);
}
target.appendChild(el);
globalNodes.push(el);
return el;
}
function removeGlobalNode(el) {
globalNodes.splice(globalNodes.indexOf(el), 1);
el.remove();
}
function changeGlobalNodesTarget(el) {
if (el === target)
return;
target = el;
globalNodes.forEach((el2) => {
if (el2.contains(target) === false) {
target.appendChild(el2);
}
});
}
exports.changeGlobalNodesTarget = changeGlobalNodesTarget;
exports.createGlobalNode = createGlobalNode;
exports.removeGlobalNode = removeGlobalNode;
//# sourceMappingURL=global-node.js.map
/***/ }),
/***/ "1be4":
/***/ (function(module, exports, __webpack_require__) {
var getBuiltIn = __webpack_require__("d066");
module.exports = getBuiltIn('document', 'documentElement');
/***/ }),
/***/ "1d5b":
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', { value: true });
var vue = __webpack_require__("8bbf");
__webpack_require__("25af");
__webpack_require__("876b");
var event = __webpack_require__("6296");
var error = __webpack_require__("f41e");
const useWatch = (props, initData, minValue, maxValue, emit, elFormItem) => {
const _emit = (val) => {
emit(event.UPDATE_MODEL_EVENT, val);
emit(event.INPUT_EVENT, val);
};
const valueChanged = () => {
if (props.range) {
return ![minValue.value, maxValue.value].every((item, index) => item === initData.oldValue[index]);
} else {
return props.modelValue !== initData.oldValue;
}
};
const setValues = () => {
var _a, _b;
if (props.min > props.max) {
error.throwError("Slider", "min should not be greater than max.");
return;
}
const val = props.modelValue;
if (props.range && Array.isArray(val)) {
if (val[1] < props.min) {
_emit([props.min, props.min]);
} else if (val[0] > props.max) {
_emit([props.max, props.max]);
} else if (val[0] < props.min) {
_emit([props.min, val[1]]);
} else if (val[1] > props.max) {
_emit([val[0], props.max]);
} else {
initData.firstValue = val[0];
initData.secondValue = val[1];
if (valueChanged()) {
if (props.validateEvent) {
(_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => error.debugWarn(err));
}
initData.oldValue = val.slice();
}
}
} else if (!props.range && typeof val === "number" && !Number.isNaN(val)) {
if (val < props.min) {
_emit(props.min);
} else if (val > props.max) {
_emit(props.max);
} else {
initData.firstValue = val;
if (valueChanged()) {
if (props.validateEvent) {
(_b = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _b.call(elFormItem, "change").catch((err) => error.debugWarn(err));
}
initData.oldValue = val;
}
}
}
};
setValues();
vue.watch(() => initData.dragging, (val) => {
if (!val) {
setValues();
}
});
vue.watch(() => props.modelValue, (val, oldVal) => {
if (initData.dragging || Array.isArray(val) && Array.isArray(oldVal) && val.every((item, index) => item === oldVal[index]) && initData.firstValue === val[0] && initData.secondValue === val[1]) {
return;
}
setValues();
}, {
deep: true
});
vue.watch(() => [props.min, props.max], () => {
setValues();
});
};
exports.useWatch = useWatch;
//# sourceMappingURL=use-watch.js.map
/***/ }),
/***/ "1d80":
/***/ (function(module, exports) {
var $TypeError = TypeError;
// `RequireObjectCoercible` abstract operation
// https://tc39.es/ecma262/#sec-requireobjectcoercible
module.exports = function (it) {
if (it == undefined) throw $TypeError("Can't call method on " + it);
return it;
};
/***/ }),
/***/ "23cb":
/***/ (function(module, exports, __webpack_require__) {
var toIntegerOrInfinity = __webpack_require__("5926");
var max = Math.max;
var min = Math.min;
// Helper for a popular repeating case of the spec:
// Let integer be ? ToInteger(index).
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
module.exports = function (index, length) {
var integer = toIntegerOrInfinity(index);
return integer < 0 ? max(integer + length, 0) : min(integer, length);
};
/***/ }),
/***/ "23e7":
/***/ (function