1import { i as buildProps, d4 as useTooltipTriggerProps, d5 as useTooltipContentProps, m as isBoolean, f as defineComponent, z as computed, v as useNamespace, A as ref, h as unref, B as addUnit, o as openBlock, J as createBlock, w as withCtx, c as createElementBlock, G as normalizeClass, t as toDisplayString, M as createCommentVNode, Z as renderSlot, d as createTextVNode, $ as mergeProps, a0 as ElTooltip, Q as _export_sfc, d6 as withInstallDirective, X as withInstall, by as commonjsGlobal, bz as getDefaultExportFromCjs } from "./entry.bb9e2e36.js"; 2import { d as dropdownProps } from "./dropdown.34b625b6.js"; 3const popoverProps = buildProps({ 4 trigger: useTooltipTriggerProps.trigger, 5 placement: dropdownProps.placement, 6 disabled: useTooltipTriggerProps.disabled, 7 visible: useTooltipContentProps.visible, 8 transition: useTooltipContentProps.transition, 9 popperOptions: dropdownProps.popperOptions, 10 tabindex: dropdownProps.tabindex, 11 content: useTooltipContentProps.content, 12 popperStyle: useTooltipContentProps.popperStyle, 13 popperClass: useTooltipContentProps.popperClass, 14 enterable: { 15 ...useTooltipContentProps.enterable, 16 default: true 17 }, 18 effect: { 19 ...useTooltipContentProps.effect, 20 default: "light" 21 }, 22 teleported: useTooltipContentProps.teleported, 23 title: String, 24 width: { 25 type: [String, Number], 26 default: 150 27 }, 28 offset: { 29 type: Number, 30 default: void 0 31 }, 32 showAfter: { 33 type: Number, 34 default: 0 35 }, 36 hideAfter: { 37 type: Number, 38 default: 200 39 }, 40 autoClose: { 41 type: Number, 42 default: 0 43 }, 44 showArrow: { 45 type: Boolean, 46 default: true 47 }, 48 persistent: { 49 type: Boolean, 50 default: true 51 }, 52 "onUpdate:visible": { 53 type: Function 54 } 55}); 56const popoverEmits = { 57 "update:visible": (value) => isBoolean(value), 58 "before-enter": () => true, 59 "before-leave": () => true, 60 "after-enter": () => true, 61 "after-leave": () => true 62}; 63const updateEventKeyRaw = `onUpdate:visible`; 64const __default__ = /* @__PURE__ */ defineComponent({ 65 name: "ElPopover" 66}); 67const _sfc_main = /* @__PURE__ */ defineComponent({ 68 ...__default__, 69 props: popoverProps, 70 emits: popoverEmits, 71 setup(__props, { expose, emit }) { 72 const props = __props; 73 const onUpdateVisible = computed(() => { 74 return props[updateEventKeyRaw]; 75 }); 76 const ns = useNamespace("popover"); 77 const tooltipRef = ref(); 78 const popperRef = computed(() => { 79 var _a; 80 return (_a = unref(tooltipRef)) == null ? void 0 : _a.popperRef; 81 }); 82 const style = computed(() => { 83 return [ 84 { 85 width: addUnit(props.width) 86 }, 87 props.popperStyle 88 ]; 89 }); 90 const kls = computed(() => { 91 return [ns.b(), props.popperClass, { [ns.m("plain")]: !!props.content }]; 92 }); 93 const gpuAcceleration = computed(() => { 94 return props.transition === `${ns.namespace.value}-fade-in-linear`; 95 }); 96 const hide = () => { 97 var _a; 98 (_a = tooltipRef.value) == null ? void 0 : _a.hide(); 99 }; 100 const beforeEnter = () => { 101 emit("before-enter"); 102 }; 103 const beforeLeave = () => { 104 emit("before-leave"); 105 }; 106 const afterEnter = () => { 107 emit("after-enter"); 108 }; 109 const afterLeave = () => { 110 emit("update:visible", false); 111 emit("after-leave"); 112 }; 113 expose({ 114 popperRef, 115 hide 116 }); 117 return (_ctx, _cache) => { 118 return openBlock(), createBlock(unref(ElTooltip), mergeProps({ 119 ref_key: "tooltipRef", 120 ref: tooltipRef 121 }, _ctx.$attrs, { 122 trigger: _ctx.trigger, 123 placement: _ctx.placement, 124 disabled: _ctx.disabled, 125 visible: _ctx.visible, 126 transition: _ctx.transition, 127 "popper-options": _ctx.popperOptions, 128 tabindex: _ctx.tabindex, 129 content: _ctx.content, 130 offset: _ctx.offset, 131 "show-after": _ctx.showAfter, 132 "hide-after": _ctx.hideAfter, 133 "auto-close": _ctx.autoClose, 134 "show-arrow": _ctx.showArrow, 135 "aria-label": _ctx.title, 136 effect: _ctx.effect, 137 enterable: _ctx.enterable, 138 "popper-class": unref(kls), 139 "popper-style": unref(style), 140 teleported: _ctx.teleported, 141 persistent: _ctx.persistent, 142 "gpu-acceleration": unref(gpuAcceleration), 143 "onUpdate:visible": unref(onUpdateVisible), 144 onBeforeShow: beforeEnter, 145 onBeforeHide: beforeLeave, 146 onShow: afterEnter, 147 onHide: afterLeave 148 }), { 149 content: withCtx(() => [ 150 _ctx.title ? (openBlock(), createElementBlock("div", { 151 key: 0, 152 class: normalizeClass(unref(ns).e("title")), 153 role: "title" 154 }, toDisplayString(_ctx.title), 3)) : createCommentVNode("v-if", true), 155 renderSlot(_ctx.$slots, "default", {}, () => [ 156 createTextVNode(toDisplayString(_ctx.content), 1) 157 ]) 158 ]), 159 default: withCtx(() => [ 160 _ctx.$slots.reference ? renderSlot(_ctx.$slots, "reference", { key: 0 }) : createCommentVNode("v-if", true) 161 ]), 162 _: 3 163 }, 16, ["trigger", "placement", "disabled", "visible", "transition", "popper-options", "tabindex", "content", "offset", "show-after", "hide-after", "auto-close", "show-arrow", "aria-label", "effect", "enterable", "popper-class", "popper-style", "teleported", "persistent", "gpu-acceleration", "onUpdate:visible"]); 164 }; 165 } 166}); 167var Popover = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popover/src/popover.vue"]]); 168const attachEvents = (el, binding) => { 169 const popperComponent = binding.arg || binding.value; 170 const popover = popperComponent == null ? void 0 : popperComponent.popperRef; 171 if (popover) { 172 popover.triggerRef = el; 173 } 174}; 175var PopoverDirective = { 176 mounted(el, binding) { 177 attachEvents(el, binding); 178 }, 179 updated(el, binding) { 180 attachEvents(el, binding); 181 } 182}; 183const VPopover = "popover"; 184const ElPopoverDirective = withInstallDirective(PopoverDirective, VPopover); 185const ElPopover = withInstall(Popover, { 186 directive: ElPopoverDirective 187}); 188var clipboard = { exports: {} }; 189/*! 190 * clipboard.js v2.0.11 191 * https://clipboardjs.com/ 192 * 193 * Licensed MIT © Zeno Rocha 194 */
vendor: 8,060 bytes, lines 195-355
195(function(module, exports) { 196 (function webpackUniversalModuleDefinition(root, factory) { 197 module.exports = factory(); 198 })(commonjsGlobal, function() { 199 return ( 200 /******/ 201 function() { 202 var __webpack_modules__ = { 203 /***/ 204 686: ( 205 /***/ 206 function(__unused_webpack_module, __webpack_exports__, __webpack_require__2) { 207 __webpack_require__2.d(__webpack_exports__, { 208 "default": function() { 209 return ( 210 /* binding */ 211 clipboard2 212 ); 213 } 214 }); 215 var tiny_emitter = __webpack_require__2(279); 216 var tiny_emitter_default = /* @__PURE__ */ __webpack_require__2.n(tiny_emitter); 217 var listen = __webpack_require__2(370); 218 var listen_default = /* @__PURE__ */ __webpack_require__2.n(listen); 219 var src_select = __webpack_require__2(817); 220 var select_default = /* @__PURE__ */ __webpack_require__2.n(src_select); 221 function command(type) { 222 try { 223 return document.execCommand(type); 224 } catch (err) { 225 return false; 226 } 227 } 228 var ClipboardActionCut = function ClipboardActionCut2(target) { 229 var selectedText = select_default()(target); 230 command("cut"); 231 return selectedText; 232 }; 233 var actions_cut = ClipboardActionCut; 234 function createFakeElement(value) { 235 var isRTL = document.documentElement.getAttribute("dir") === "rtl"; 236 var fakeElement = document.createElement("textarea"); 237 fakeElement.style.fontSize = "12pt"; 238 fakeElement.style.border = "0"; 239 fakeElement.style.padding = "0"; 240 fakeElement.style.margin = "0"; 241 fakeElement.style.position = "absolute"; 242 fakeElement.style[isRTL ? "right" : "left"] = "-9999px"; 243 var yPosition = window.pageYOffset || document.documentElement.scrollTop; 244 fakeElement.style.top = "".concat(yPosition, "px"); 245 fakeElement.setAttribute("readonly", ""); 246 fakeElement.value = value; 247 return fakeElement; 248 } 249 var fakeCopyAction = function fakeCopyAction2(value, options) { 250 var fakeElement = createFakeElement(value); 251 options.container.appendChild(fakeElement); 252 var selectedText = select_default()(fakeElement); 253 command("copy"); 254 fakeElement.remove(); 255 return selectedText; 256 }; 257 var ClipboardActionCopy = function ClipboardActionCopy2(target) { 258 var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : { 259 container: document.body 260 }; 261 var selectedText = ""; 262 if (typeof target === "string") { 263 selectedText = fakeCopyAction(target, options); 264 } else if (target instanceof HTMLInputElement && !["text", "search", "url", "tel", "password"].includes(target === null || target === void 0 ? void 0 : target.type)) { 265 selectedText = fakeCopyAction(target.value, options); 266 } else { 267 selectedText = select_default()(target); 268 command("copy"); 269 } 270 return selectedText; 271 }; 272 var actions_copy = ClipboardActionCopy; 273 function _typeof(obj) { 274 "@babel/helpers - typeof"; 275 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 276 _typeof = function _typeof2(obj2) { 277 return typeof obj2; 278 }; 279 } else { 280 _typeof = function _typeof2(obj2) { 281 return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; 282 }; 283 } 284 return _typeof(obj); 285 } 286 var ClipboardActionDefault = function ClipboardActionDefault2() { 287 var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; 288 var _options$action = options.action, action = _options$action === void 0 ? "copy" : _options$action, container = options.container, target = options.target, text = options.text; 289 if (action !== "copy" && action !== "cut") { 290 throw new Error('Invalid "action" value, use either "copy" or "cut"'); 291 } 292 if (target !== void 0) { 293 if (target && _typeof(target) === "object" && target.nodeType === 1) { 294 if (action === "copy" && target.hasAttribute("disabled")) { 295 throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute'); 296 } 297 if (action === "cut" && (target.hasAttribute("readonly") || target.hasAttribute("disabled"))) { 298 throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`); 299 } 300 } else { 301 throw new Error('Invalid "target" value, use a valid Element'); 302 } 303 } 304 if (text) { 305 return actions_copy(text, { 306 container 307 }); 308 } 309 if (target) { 310 return action === "cut" ? actions_cut(target) : actions_copy(target, { 311 container 312 }); 313 } 314 }; 315 var actions_default = ClipboardActionDefault; 316 function clipboard_typeof(obj) { 317 "@babel/helpers - typeof"; 318 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { 319 clipboard_typeof = function _typeof2(obj2) { 320 return typeof obj2; 321 }; 322 } else { 323 clipboard_typeof = function _typeof2(obj2) { 324 return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2; 325 }; 326 } 327 return clipboard_typeof(obj); 328 } 329 function _classCallCheck(instance, Constructor) { 330 if (!(instance instanceof Constructor)) { 331 throw new TypeError("Cannot call a class as a function"); 332 } 333 } 334 function _defineProperties(target, props) { 335 for (var i = 0; i < props.length; i++) { 336 var descriptor = props[i]; 337 descriptor.enumerable = descriptor.enumerable || false; 338 descriptor.configurable = true; 339 if ("value" in descriptor) 340 descriptor.writable = true; 341 Object.defineProperty(target, descriptor.key, descriptor); 342 } 343 } 344 function _createClass(Constructor, protoProps, staticProps) { 345 if (protoProps) 346 _defineProperties(Constructor.prototype, protoProps); 347 if (staticProps) 348 _defineProperties(Constructor, staticProps); 349 return Constructor; 350 } 351 function _inherits(subClass, superClass) { 352 if (typeof superClass !== "function" && superClass !== null) { 353 throw new TypeError("Super expression must either be null or a function"); 354 } 355 subClass.prototype = Object.create(superClass && superClass.prototype, { c
vendor: 5,217 bytes, lines 355-465
355onstructor: { value: subClass, writable: true, configurable: true } }); 356 if (superClass) 357 _setPrototypeOf(subClass, superClass); 358 } 359 function _setPrototypeOf(o, p) { 360 _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) { 361 o2.__proto__ = p2; 362 return o2; 363 }; 364 return _setPrototypeOf(o, p); 365 } 366 function _createSuper(Derived) { 367 var hasNativeReflectConstruct = _isNativeReflectConstruct(); 368 return function _createSuperInternal() { 369 var Super = _getPrototypeOf(Derived), result; 370 if (hasNativeReflectConstruct) { 371 var NewTarget = _getPrototypeOf(this).constructor; 372 result = Reflect.construct(Super, arguments, NewTarget); 373 } else { 374 result = Super.apply(this, arguments); 375 } 376 return _possibleConstructorReturn(this, result); 377 }; 378 } 379 function _possibleConstructorReturn(self, call) { 380 if (call && (clipboard_typeof(call) === "object" || typeof call === "function")) { 381 return call; 382 } 383 return _assertThisInitialized(self); 384 } 385 function _assertThisInitialized(self) { 386 if (self === void 0) { 387 throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 388 } 389 return self; 390 } 391 function _isNativeReflectConstruct() { 392 if (typeof Reflect === "undefined" || !Reflect.construct) 393 return false; 394 if (Reflect.construct.sham) 395 return false; 396 if (typeof Proxy === "function") 397 return true; 398 try { 399 Date.prototype.toString.call(Reflect.construct(Date, [], function() { 400 })); 401 return true; 402 } catch (e) { 403 return false; 404 } 405 } 406 function _getPrototypeOf(o) { 407 _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) { 408 return o2.__proto__ || Object.getPrototypeOf(o2); 409 }; 410 return _getPrototypeOf(o); 411 } 412 function getAttributeValue(suffix, element) { 413 var attribute = "data-clipboard-".concat(suffix); 414 if (!element.hasAttribute(attribute)) { 415 return; 416 } 417 return element.getAttribute(attribute); 418 } 419 var Clipboard2 = /* @__PURE__ */ function(_Emitter) { 420 _inherits(Clipboard3, _Emitter); 421 var _super = _createSuper(Clipboard3); 422 function Clipboard3(trigger, options) { 423 var _this; 424 _classCallCheck(this, Clipboard3); 425 _this = _super.call(this); 426 _this.resolveOptions(options); 427 _this.listenClick(trigger); 428 return _this; 429 } 430 _createClass(Clipboard3, [{ 431 key: "resolveOptions", 432 value: function resolveOptions() { 433 var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; 434 this.action = typeof options.action === "function" ? options.action : this.defaultAction; 435 this.target = typeof options.target === "function" ? options.target : this.defaultTarget; 436 this.text = typeof options.text === "function" ? options.text : this.defaultText; 437 this.container = clipboard_typeof(options.container) === "object" ? options.container : document.body; 438 } 439 /** 440 * Adds a click event listener to the passed trigger. 441 * @param {String|HTMLElement|HTMLCollection|NodeList} trigger 442 */ 443 }, { 444 key: "listenClick", 445 value: function listenClick(trigger) { 446 var _this2 = this; 447 this.listener = listen_default()(trigger, "click", function(e) { 448 return _this2.onClick(e); 449 }); 450 } 451 /** 452 * Defines a new `ClipboardAction` on each click event. 453 * @param {Event} e 454 */ 455 }, { 456 key: "onClick", 457 value: function onClick(e) { 458 var trigger = e.delegateTarget || e.currentTarget; 459 var action = this.action(trigger) || "copy"; 460 var text = actions_default({ 461 action, 462 container: this.container, 463 target: this.target(trigger), 464 text: this.text(trigger) 465 });
vendor: 15,494 bytes, lines 466-862
466 this.emit(text ? "success" : "error", { 467 action, 468 text, 469 trigger, 470 clearSelection: function clearSelection() { 471 if (trigger) { 472 trigger.focus(); 473 } 474 window.getSelection().removeAllRanges(); 475 } 476 }); 477 } 478 /** 479 * Default `action` lookup function. 480 * @param {Element} trigger 481 */ 482 }, { 483 key: "defaultAction", 484 value: function defaultAction(trigger) { 485 return getAttributeValue("action", trigger); 486 } 487 /** 488 * Default `target` lookup function. 489 * @param {Element} trigger 490 */ 491 }, { 492 key: "defaultTarget", 493 value: function defaultTarget(trigger) { 494 var selector = getAttributeValue("target", trigger); 495 if (selector) { 496 return document.querySelector(selector); 497 } 498 } 499 /** 500 * Allow fire programmatically a copy action 501 * @param {String|HTMLElement} target 502 * @param {Object} options 503 * @returns Text copied. 504 */ 505 }, { 506 key: "defaultText", 507 /** 508 * Default `text` lookup function. 509 * @param {Element} trigger 510 */ 511 value: function defaultText(trigger) { 512 return getAttributeValue("text", trigger); 513 } 514 /** 515 * Destroy lifecycle. 516 */ 517 }, { 518 key: "destroy", 519 value: function destroy() { 520 this.listener.destroy(); 521 } 522 }], [{ 523 key: "copy", 524 value: function copy(target) { 525 var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : { 526 container: document.body 527 }; 528 return actions_copy(target, options); 529 } 530 /** 531 * Allow fire programmatically a cut action 532 * @param {String|HTMLElement} target 533 * @returns Text cutted. 534 */ 535 }, { 536 key: "cut", 537 value: function cut(target) { 538 return actions_cut(target); 539 } 540 /** 541 * Returns the support of the given action, or all actions if no action is 542 * given. 543 * @param {String} [action] 544 */ 545 }, { 546 key: "isSupported", 547 value: function isSupported() { 548 var action = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ["copy", "cut"]; 549 var actions = typeof action === "string" ? [action] : action; 550 var support = !!document.queryCommandSupported; 551 actions.forEach(function(action2) { 552 support = support && !!document.queryCommandSupported(action2); 553 }); 554 return support; 555 } 556 }]); 557 return Clipboard3; 558 }(tiny_emitter_default()); 559 var clipboard2 = Clipboard2; 560 } 561 ), 562 /***/ 563 828: ( 564 /***/ 565 function(module2) { 566 var DOCUMENT_NODE_TYPE = 9; 567 if (typeof Element !== "undefined" && !Element.prototype.matches) { 568 var proto = Element.prototype; 569 proto.matches = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector; 570 } 571 function closest(element, selector) { 572 while (element && element.nodeType !== DOCUMENT_NODE_TYPE) { 573 if (typeof element.matches === "function" && element.matches(selector)) { 574 return element; 575 } 576 element = element.parentNode; 577 } 578 } 579 module2.exports = closest; 580 } 581 ), 582 /***/ 583 438: ( 584 /***/ 585 function(module2, __unused_webpack_exports, __webpack_require__2) { 586 var closest = __webpack_require__2(828); 587 function _delegate(element, selector, type, callback, useCapture) { 588 var listenerFn = listener.apply(this, arguments); 589 element.addEventListener(type, listenerFn, useCapture); 590 return { 591 destroy: function() { 592 element.removeEventListener(type, listenerFn, useCapture); 593 } 594 }; 595 } 596 function delegate(elements, selector, type, callback, useCapture) { 597 if (typeof elements.addEventListener === "function") { 598 return _delegate.apply(null, arguments); 599 } 600 if (typeof type === "function") { 601 return _delegate.bind(null, document).apply(null, arguments); 602 } 603 if (typeof elements === "string") { 604 elements = document.querySelectorAll(elements); 605 } 606 return Array.prototype.map.call(elements, function(element) { 607 return _delegate(element, selector, type, callback, useCapture); 608 }); 609 } 610 function listener(element, selector, type, callback) { 611 return function(e) { 612 e.delegateTarget = closest(e.target, selector); 613 if (e.delegateTarget) { 614 callback.call(element, e); 615 } 616 }; 617 } 618 module2.exports = delegate; 619 } 620 ), 621 /***/ 622 879: ( 623 /***/ 624 function(__unused_webpack_module, exports2) { 625 exports2.node = function(value) { 626 return value !== void 0 && value instanceof HTMLElement && value.nodeType === 1; 627 }; 628 exports2.nodeList = function(value) { 629 var type = Object.prototype.toString.call(value); 630 return value !== void 0 && (type === "[object NodeList]" || type === "[object HTMLCollection]") && "length" in value && (value.length === 0 || exports2.node(value[0])); 631 }; 632 exports2.string = function(value) { 633 return typeof value === "string" || value instanceof String; 634 }; 635 exports2.fn = function(value) { 636 var type = Object.prototype.toString.call(value); 637 return type === "[object Function]"; 638 }; 639 } 640 ), 641 /***/ 642 370: ( 643 /***/ 644 function(module2, __unused_webpack_exports, __webpack_require__2) { 645 var is = __webpack_require__2(879); 646 var delegate = __webpack_require__2(438); 647 function listen(target, type, callback) { 648 if (!target && !type && !callback) { 649 throw new Error("Missing required arguments"); 650 } 651 if (!is.string(type)) { 652 throw new TypeError("Second argument must be a String"); 653 } 654 if (!is.fn(callback)) { 655 throw new TypeError("Third argument must be a Function"); 656 } 657 if (is.node(target)) { 658 return listenNode(target, type, callback); 659 } else if (is.nodeList(target)) { 660 return listenNodeList(target, type, callback); 661 } else if (is.string(target)) { 662 return listenSelector(target, type, callback); 663 } else { 664 throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList"); 665 } 666 } 667 function listenNode(node, type, callback) { 668 node.addEventListener(type, callback); 669 return { 670 destroy: function() { 671 node.removeEventListener(type, callback); 672 } 673 }; 674 } 675 function listenNodeList(nodeList, type, callback) { 676 Array.prototype.forEach.call(nodeList, function(node) { 677 node.addEventListener(type, callback); 678 }); 679 return { 680 destroy: function() { 681 Array.prototype.forEach.call(nodeList, function(node) { 682 node.removeEventListener(type, callback); 683 }); 684 } 685 }; 686 } 687 function listenSelector(selector, type, callback) { 688 return delegate(document.body, selector, type, callback); 689 } 690 module2.exports = listen; 691 } 692 ), 693 /***/ 694 817: ( 695 /***/ 696 function(module2) { 697 function select(element) { 698 var selectedText; 699 if (element.nodeName === "SELECT") { 700 element.focus(); 701 selectedText = element.value; 702 } else if (element.nodeName === "INPUT" || element.nodeName === "TEXTAREA") { 703 var isReadOnly = element.hasAttribute("readonly"); 704 if (!isReadOnly) { 705 element.setAttribute("readonly", ""); 706 } 707 element.select(); 708 element.setSelectionRange(0, element.value.length); 709 if (!isReadOnly) { 710 element.removeAttribute("readonly"); 711 } 712 selectedText = element.value; 713 } else { 714 if (element.hasAttribute("contenteditable")) { 715 element.focus(); 716 } 717 var selection = window.getSelection(); 718 var range = document.createRange(); 719 range.selectNodeContents(element); 720 selection.removeAllRanges(); 721 selection.addRange(range); 722 selectedText = selection.toString(); 723 } 724 return selectedText; 725 } 726 module2.exports = select; 727 } 728 ), 729 /***/ 730 279: ( 731 /***/ 732 function(module2) { 733 function E() { 734 } 735 E.prototype = { 736 on: function(name, callback, ctx) { 737 var e = this.e || (this.e = {}); 738 (e[name] || (e[name] = [])).push({ 739 fn: callback, 740 ctx 741 }); 742 return this; 743 }, 744 once: function(name, callback, ctx) { 745 var self = this; 746 function listener() { 747 self.off(name, listener); 748 callback.apply(ctx, arguments); 749 } 750 listener._ = callback; 751 return this.on(name, listener, ctx); 752 }, 753 emit: function(name) { 754 var data = [].slice.call(arguments, 1); 755 var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); 756 var i = 0; 757 var len = evtArr.length; 758 for (i; i < len; i++) { 759 evtArr[i].fn.apply(evtArr[i].ctx, data); 760 } 761 return this; 762 }, 763 off: function(name, callback) { 764 var e = this.e || (this.e = {}); 765 var evts = e[name]; 766 var liveEvents = []; 767 if (evts && callback) { 768 for (var i = 0, len = evts.length; i < len; i++) { 769 if (evts[i].fn !== callback && evts[i].fn._ !== callback) 770 liveEvents.push(evts[i]); 771 } 772 } 773 liveEvents.length ? e[name] = liveEvents : delete e[name]; 774 return this; 775 } 776 }; 777 module2.exports = E; 778 module2.exports.TinyEmitter = E; 779 } 780 ) 781 /******/ 782 }; 783 var __webpack_module_cache__ = {}; 784 function __webpack_require__(moduleId) { 785 if (__webpack_module_cache__[moduleId]) { 786 return __webpack_module_cache__[moduleId].exports; 787 } 788 var module2 = __webpack_module_cache__[moduleId] = { 789 /******/ 790 // no module.id needed 791 /******/ 792 // no module.loaded needed 793 /******/ 794 exports: {} 795 /******/ 796 }; 797 __webpack_modules__[moduleId](module2, module2.exports, __webpack_require__); 798 return module2.exports; 799 } 800 !function() { 801 __webpack_require__.n = function(module2) { 802 var getter = module2 && module2.__esModule ? ( 803 /******/ 804 function() { 805 return module2["default"]; 806 } 807 ) : ( 808 /******/ 809 function() { 810 return module2; 811 } 812 ); 813 __webpack_require__.d(getter, { a: getter }); 814 return getter; 815 }; 816 }(); 817 !function() { 818 __webpack_require__.d = function(exports2, definition) { 819 for (var key in definition) { 820 if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports2, key)) { 821 Object.defineProperty(exports2, key, { enumerable: true, get: definition[key] }); 822 } 823 } 824 }; 825 }(); 826 !function() { 827 __webpack_require__.o = function(obj, prop) { 828 return Object.prototype.hasOwnProperty.call(obj, prop); 829 }; 830 }(); 831 return __webpack_require__(686); 832 }().default 833 ); 834 }); 835})(clipboard); 836var clipboardExports = clipboard.exports; 837const Clipboard = /* @__PURE__ */ getDefaultExportFromCjs(clipboardExports); 838class ManualClipboard extends Clipboard { 839 listenClick(target) { 840 if (!target) { 841 this.listener = { 842 destroy() { 843 } 844 }; 845 return; 846 } 847 super.listenClick(target); 848 } 849 doClipboard(text, action = "copy") { 850 if (this.clipboardAction) 851 this.clipboardAction = null; 852 this.action = () => action; 853 this.text = () => text; 854 this.target = () => void 0; 855 this.onClick({ currentTarget: void 0 }); 856 } 857 static quicklyClipboard(text, action = "copy") { 858 return new Promise((resolve, reject) => { 859 const instance = new ManualClipboard(); 860 const cb = (fn) => { 861 return (...args) => { 862 instance.destroy();
863 Reflect.apply(fn, null, args); 864 }; 865 }; 866 instance.on("success", cb(resolve)); 867 instance.on("error", cb(reject)); 868 instance.doClipboard(text, action); 869 }); 870 } 871} 872export { 873 ElPopover as E, 874 ManualClipboard as M 875};
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.