1import { au as isOn, av as eventName, r as ref, a9 as IN_BROWSER, l as useToggleScope, w as watch, o as onScopeDispose, aw as destructComputed, b as computed, ax as CircularBuffer, ad as convertToUnit, ay as clamp, F as nextTick, C as propsFactory, q as watchEffect, az as effectScope, aA as getCurrentInstance, k as inject, aB as templateRef, aC as matchesSelector, B as mergeProps, s as shallowRef, aD as useDisplay, v as onMounted, aE as reactive, a as toValue, aF as toRaw, aa as toRef, aG as readonly, ag as provide, h as genericComponent, j as useProxiedModel, p as provideTheme, a7 as useRtl, aH as useDimension, X as onBeforeUnmount, aI as standardEasing, y as useRender, A as createBaseVNode, z as createVNode, ab as withDirectives, aj as vShow, aJ as Teleport, Z as Fragment, D as omit, am as Transition, E as makeThemeProps, aK as makeDimensionProps, af as makeComponentProps } from "./index-BHBk8sZF.js"; 2import { B as Box, g as getTargetBox, a as getElementBox, b as getOverflow, n as nullifyTransforms, c as animate } from "./animation-K5qeGU_D.js"; 3import { p as parseAnchor, f as flipSide, b as flipAlign, c as flipCorner, g as getAxis } from "./rounded-CKBQHTI1.js"; 4import { d as deepEqual } from "./deepEqual-B9vqEPF8.js"; 5import { a as getScrollParents, h as hasScrollbar, g as getScrollParent } from "./getScrollParent-D4UQZrum.js"; 6import { a as useDelay, m as makeDelayProps, u as useScopeId, b as useFocusTrap, c as makeFocusTrapProps } from "./scopeId-D4j__SMb.js"; 7import { u as useBackgroundColor } from "./color-B5ZhD1Fv.js"; 8import { u as useLazy, m as makeLazyProps } from "./lazy-D5NXgZF5.js"; 9import { a as useRouter, b as useBackButton } from "./variant-BuJSkLPt.js"; 10import { M as MaybeTransition, m as makeTransitionProps } from "./transition-CS7Qo3dO.js"; 11const handlers = /* @__PURE__ */ new WeakMap(); 12function bindProps(el, props) { 13 Object.keys(props).forEach((k) => { 14 var _a; 15 if (isOn(k)) { 16 const name = eventName(k); 17 const handler = handlers.get(el); 18 if (props[k] == null) { 19 handler == null ? void 0 : handler.forEach((v) => { 20 const [n, fn] = v; 21 if (n === name) { 22 el.removeEventListener(name, fn); 23 handler.delete(v); 24 } 25 }); 26 } else if (!handler || !((_a = [...handler]) == null ? void 0 : _a.some((v) => v[0] === name && v[1] === props[k]))) { 27 el.addEventListener(name, props[k]); 28 const _handler = handler || /* @__PURE__ */ new Set(); 29 _handler.add([name, props[k]]); 30 if (!handlers.has(el)) handlers.set(el, _handler); 31 } 32 } else { 33 if (props[k] == null) { 34 el.removeAttribute(k); 35 } else { 36 el.setAttribute(k, props[k]); 37 } 38 } 39 }); 40} 41function unbindProps(el, props) { 42 Object.keys(props).forEach((k) => { 43 if (isOn(k)) { 44 const name = eventName(k); 45 const handler = handlers.get(el); 46 handler == null ? void 0 : handler.forEach((v) => { 47 const [n, fn] = v; 48 if (n === name) { 49 el.removeEventListener(name, fn); 50 handler.delete(v); 51 } 52 }); 53 } else { 54 el.removeAttribute(k); 55 } 56 }); 57} 58function attachedRoot(node) { 59 if (typeof node.getRootNode !== "function") { 60 while (node.parentNode) node = node.parentNode; 61 if (node !== document) return null; 62 return document; 63 } 64 const root = node.getRootNode(); 65 if (root !== document && root.getRootNode({ 66 composed: true 67 }) !== document) return null; 68 return root; 69} 70function isFixedPosition(el) { 71 while (el) { 72 if (window.getComputedStyle(el).position === "fixed") { 73 return true; 74 } 75 el = el.offsetParent; 76 } 77 return false; 78} 79function elementToViewport(point, offset) { 80 return { 81 x: point.x + offset.x, 82 y: point.y + offset.y 83 }; 84} 85function getOffset(a, b) { 86 return { 87 x: a.x - b.x, 88 y: a.y - b.y 89 }; 90} 91function anchorToPoint(anchor, box) { 92 if (anchor.side === "top" || anchor.side === "bottom") { 93 const { 94 side, 95 align 96 } = anchor; 97 const x = align === "left" ? 0 : align === "center" ? box.width / 2 : align === "right" ? box.width : align; 98 const y = side === "top" ? 0 : side === "bottom" ? box.height : side; 99 return elementToViewport({ 100 x, 101 y 102 }, box); 103 } else if (anchor.side === "left" || anchor.side === "right") { 104 const { 105 side, 106 align 107 } = anchor; 108 const x = side === "left" ? 0 : side === "right" ? box.width : side; 109 const y = align === "top" ? 0 : align === "center" ? box.height / 2 : align === "bottom" ? box.height : align; 110 return elementToViewport({ 111 x, 112 y 113 }, box); 114 } 115 return elementToViewport({ 116 x: box.width / 2, 117 y: box.height / 2 118 }, box); 119} 120const locationStrategies = { 121 static: staticLocationStrategy, 122 // specific viewport position, usually centered 123 connected: connectedLocationStrategy 124 // connected to a certain element 125}; 126const makeLocationStrategyProps = propsFactory({ 127 locationStrategy: { 128 type: [String, Function], 129 default: "static", 130 validator: (val) => typeof val === "function" || val in locationStrategies 131 }, 132 location: { 133 type: String, 134 default: "bottom" 135 }, 136 origin: { 137 type: String, 138 default: "auto" 139 }, 140 offset: [Number, String, Array], 141 stickToTarget: Boolean, 142 viewportMargin: { 143 type: [Number, String], 144 default: 12 145 } 146}, "VOverlay-location-strategies"); 147function useLocationStrategies(props, data) { 148 const contentStyles = ref({}); 149 const updateLocation = ref(); 150 if (IN_BROWSER) { 151 useToggleScope(() =>
151 !!(data.isActive.value && props.locationStrategy), (reset) => { 152 var _a, _b; 153 watch(() => props.locationStrategy, reset); 154 onScopeDispose(() => { 155 window.removeEventListener("resize", onResize); 156 visualViewport == null ? void 0 : visualViewport.removeEventListener("resize", onVisualResize); 157 visualViewport == null ? void 0 : visualViewport.removeEventListener("scroll", onVisualScroll); 158 updateLocation.value = void 0; 159 }); 160 window.addEventListener("resize", onResize, { 161 passive: true 162 }); 163 visualViewport == null ? void 0 : visualViewport.addEventListener("resize", onVisualResize, { 164 passive: true 165 }); 166 visualViewport == null ? void 0 : visualViewport.addEventListener("scroll", onVisualScroll, { 167 passive: true 168 }); 169 if (typeof props.locationStrategy === "function") { 170 updateLocation.value = (_a = props.locationStrategy(data, props, contentStyles)) == null ? void 0 : _a.updateLocation; 171 } else { 172 updateLocation.value = (_b = locationStrategies[props.locationStrategy](data, props, contentStyles)) == null ? void 0 : _b.updateLocation; 173 } 174 }); 175 } 176 function onResize(e) { 177 var _a; 178 (_a = updateLocation.value) == null ? void 0 : _a.call(updateLocation, e); 179 } 180 function onVisualResize(e) { 181 var _a; 182 (_a = updateLocation.value) == null ? void 0 : _a.call(updateLocation, e); 183 } 184 function onVisualScroll(e) { 185 var _a; 186 (_a = updateLocation.value) == null ? void 0 : _a.call(updateLocation, e); 187 } 188 return { 189 contentStyles, 190 updateLocation 191 }; 192} 193function staticLocationStrategy() { 194} 195function getIntrinsicSize(el, isRtl) { 196 const contentBox = nullifyTransforms(el); 197 if (isRtl) { 198 contentBox.x += parseFloat(el.style.right || 0); 199 } else { 200 contentBox.x -= parseFloat(el.style.left || 0); 201 } 202 contentBox.y -= parseFloat(el.style.top || 0); 203 return contentBox; 204} 205function connectedLocationStrategy(data, props, contentStyles) { 206 const activatorFixed = Array.isArray(data.target.value) || isFixedPosition(data.target.value); 207 if (activatorFixed) { 208 Object.assign(contentStyles.value, { 209 position: "fixed", 210 top: 0, 211 [data.isRtl.value ? "right" : "left"]: 0 212 }); 213 } 214 const { 215 preferredAnchor, 216 preferredOrigin 217 } = destructComputed(() => { 218 const parsedAnchor = parseAnchor(props.location, data.isRtl.value); 219 const parsedOrigin = props.origin === "overlap" ? parsedAnchor : props.origin === "auto" ? flipSide(parsedAnchor) : parseAnchor(props.origin, data.isRtl.value); 220 if (parsedAnchor.side === parsedOrigin.side && parsedAnchor.align === flipAlign(parsedOrigin).align) { 221 return { 222 preferredAnchor: flipCorner(parsedAnchor), 223 preferredOrigin: flipCorner(parsedOrigin) 224 }; 225 } else { 226 return { 227 preferredAnchor: parsedAnchor, 228 preferredOrigin: parsedOrigin 229 }; 230 } 231 }); 232 const [minWidth, minHeight, maxWidth, maxHeight] = ["minWidth", "minHeight", "maxWidth", "maxHeight"].map((key) => { 233 return computed(() => { 234 const val = parseFloat(props[key]); 235 return isNaN(val) ? Infinity : val; 236 }); 237 }); 238 const offset = computed(() => { 239 if (Array.isArray(props.offset)) { 240 return props.offset; 241 } 242 if (typeof props.offset === "string") { 243 const offset2 = props.offset.split(" ").map(parseFloat); 244 if (offset2.length < 2) offset2.push(0); 245 return offset2; 246 } 247 return typeof props.offset === "number" ? [props.offset, 0] : [0, 0]; 248 }); 249 let observe = false; 250 let lastFrame = -1; 251 const flipped = new CircularBuffer(4); 252 const observer = new ResizeObserver(() => { 253 if (!observe) return; 254 requestAnimationFrame((newTime) => { 255 if (newTime !== lastFrame) flipped.clear(); 256 requestAnimationFrame((newNewTime) => { 257 lastFrame = newNewTime; 258 }); 259 }); 260 if (flipped.isFull) { 261 const values = flipped.values(); 262 if (deepEqual(values.at(-1), values.at(-3)) && !deepEqual(values.at(-1), values.at(-2))) { 263 return; 264 } 265 } 266 const result = updateLocation(); 267 if (result) flipped.push(result.flipped); 268 }); 269 let targetBox = new Box({ 270 x: 0, 271 y: 0, 272 width: 0, 273 height: 0 274 }); 275 watch(data.target, (newTarget, oldTarget) => { 276 if (oldTarget && !Array.isArray(oldTarget)) observer.unobserve(oldTarget); 277 if (!Array.isArray(newTarget)) { 278 if (newTarget) observer.observe(newTarget); 279 } else if (!deepEqual(newTarget, oldTarget)) { 280 updateLocation(); 281 } 282 }, { 283 immediate: true 284 }); 285 watch(data.contentEl, (newContentEl, oldContentEl) => { 286 if (oldContentEl) observer.unobserve(oldContentEl); 287 if (newContentEl) observer.observe(newContentEl); 288 }, { 289 immediate: true 290 }); 291 onScopeDispose(() => { 292 observer.disconnect(); 293 }); 294 function updateLocation() { 295 observe = false;
vendor: 5,942 bytes, lines 296-465
296 requestAnimationFrame(() => observe = true); 297 if (!data.target.value || !data.contentEl.value) return; 298 if (Array.isArray(data.target.value) || data.target.value.offsetParent || data.target.value.getClientRects().length) { 299 targetBox = getTargetBox(data.target.value); 300 } 301 const contentBox = getIntrinsicSize(data.contentEl.value, data.isRtl.value); 302 const scrollParents = getScrollParents(data.contentEl.value); 303 const viewportMargin = Number(props.viewportMargin); 304 if (!scrollParents.length) { 305 scrollParents.push(document.documentElement); 306 if (!(data.contentEl.value.style.top && data.contentEl.value.style.left)) { 307 contentBox.x -= parseFloat(document.documentElement.style.getPropertyValue("--v-body-scroll-x") || 0); 308 contentBox.y -= parseFloat(document.documentElement.style.getPropertyValue("--v-body-scroll-y") || 0); 309 } 310 } 311 const viewport = scrollParents.reduce((box, el) => { 312 const scrollBox = getElementBox(el); 313 if (box) { 314 return new Box({ 315 x: Math.max(box.left, scrollBox.left), 316 y: Math.max(box.top, scrollBox.top), 317 width: Math.min(box.right, scrollBox.right) - Math.max(box.left, scrollBox.left), 318 height: Math.min(box.bottom, scrollBox.bottom) - Math.max(box.top, scrollBox.top) 319 }); 320 } 321 return scrollBox; 322 }, void 0); 323 if (props.stickToTarget) { 324 viewport.x += Math.min(viewportMargin, targetBox.x); 325 viewport.y += Math.min(viewportMargin, targetBox.y); 326 viewport.width = Math.max(viewport.width - viewportMargin * 2, targetBox.x + targetBox.width - viewportMargin); 327 viewport.height = Math.max(viewport.height - viewportMargin * 2, targetBox.y + targetBox.height - viewportMargin); 328 } else { 329 viewport.x += viewportMargin; 330 viewport.y += viewportMargin; 331 viewport.width -= viewportMargin * 2; 332 viewport.height -= viewportMargin * 2; 333 } 334 let placement = { 335 anchor: preferredAnchor.value, 336 origin: preferredOrigin.value 337 }; 338 function checkOverflow(_placement) { 339 const box = new Box(contentBox); 340 const targetPoint = anchorToPoint(_placement.anchor, targetBox); 341 const contentPoint = anchorToPoint(_placement.origin, box); 342 let { 343 x: x2, 344 y: y2 345 } = getOffset(targetPoint, contentPoint); 346 switch (_placement.anchor.side) { 347 case "top": 348 y2 -= offset.value[0]; 349 break; 350 case "bottom": 351 y2 += offset.value[0]; 352 break; 353 case "left": 354 x2 -= offset.value[0]; 355 break; 356 case "right": 357 x2 += offset.value[0]; 358 break; 359 } 360 switch (_placement.anchor.align) { 361 case "top": 362 y2 -= offset.value[1]; 363 break; 364 case "bottom": 365 y2 += offset.value[1]; 366 break; 367 case "left": 368 x2 -= offset.value[1]; 369 break; 370 case "right": 371 x2 += offset.value[1]; 372 break; 373 } 374 box.x += x2; 375 box.y += y2; 376 box.width = Math.min(box.width, maxWidth.value); 377 box.height = Math.min(box.height, maxHeight.value); 378 const overflows = getOverflow(box, viewport); 379 return { 380 overflows, 381 x: x2, 382 y: y2 383 }; 384 } 385 let x = 0; 386 let y = 0; 387 const available = { 388 x: 0, 389 y: 0 390 }; 391 const flipped2 = { 392 x: false, 393 y: false 394 }; 395 let resets = -1; 396 while (true) { 397 if (resets++ > 10) { 398 break; 399 } 400 const { 401 x: _x, 402 y: _y, 403 overflows 404 } = checkOverflow(placement); 405 x += _x; 406 y += _y; 407 contentBox.x += _x; 408 contentBox.y += _y; 409 { 410 const axis2 = getAxis(placement.anchor); 411 const hasOverflowX = overflows.x.before || overflows.x.after; 412 const hasOverflowY = overflows.y.before || overflows.y.after; 413 let reset = false; 414 ["x", "y"].forEach((key) => { 415 if (key === "x" && hasOverflowX && !flipped2.x || key === "y" && hasOverflowY && !flipped2.y) { 416 const newPlacement = { 417 anchor: { 418 ...placement.anchor 419 }, 420 origin: { 421 ...placement.origin 422 } 423 }; 424 const flip = key === "x" ? axis2 === "y" ? flipAlign : flipSide : axis2 === "y" ? flipSide : flipAlign; 425 newPlacement.anchor = flip(newPlacement.anchor); 426 newPlacement.origin = flip(newPlacement.origin); 427 const { 428 overflows: newOverflows 429 } = checkOverflow(newPlacement); 430 if (newOverflows[key].before <= overflows[key].before && newOverflows[key].after <= overflows[key].after || newOverflows[key].before + newOverflows[key].after < (overflows[key].before + overflows[key].after) / 2) { 431 placement = newPlacement; 432 reset = flipped2[key] = true; 433 } 434 } 435 }); 436 if (reset) continue; 437 } 438 if (overflows.x.before) { 439 x += overflows.x.before; 440 contentBox.x += overflows.x.before; 441 } 442 if (overflows.x.after) { 443 x -= overflows.x.after; 444 contentBox.x -= overflows.x.after; 445 } 446 if (overflows.y.before) { 447 y += overflows.y.before; 448 contentBox.y += overflows.y.before; 449 } 450 if (overflows.y.after) { 451 y -= overflows.y.after; 452 contentBox.y -= overflows.y.after; 453 } 454 { 455 const overflows2 = getOverflow(contentBox, viewport); 456 available.x = viewport.width - overflows2.x.before - overflows2.x.after; 457 available.y = viewport.height - overflows2.y.before - overflows2.y.after; 458 x += overflows2.x.before; 459 contentBox.x += overflows2.x.before; 460 y += overflows2.y.before; 461 contentBox.y += overflows2.y.before; 462 } 463 break; 464 } 465 const axis = getAxis(placement.anchor);
466 Object.assign(contentStyles.value, { 467 "--v-overlay-anchor-origin": `${placement.anchor.side} ${placement.anchor.align}`, 468 transformOrigin: `${placement.origin.side} ${placement.origin.align}`, 469 // transform: `translate(${pixelRound(x)}px, ${pixelRound(y)}px)`, 470 top: convertToUnit(pixelRound(y)), 471 left: data.isRtl.value ? void 0 : convertToUnit(pixelRound(x)), 472 right: data.isRtl.value ? convertToUnit(pixelRound(-x)) : void 0, 473 minWidth: convertToUnit(axis === "y" ? Math.min(minWidth.value, targetBox.width) : minWidth.value), 474 maxWidth: convertToUnit(pixelCeil(clamp(available.x, minWidth.value === Infinity ? 0 : minWidth.value, maxWidth.value))), 475 maxHeight: convertToUnit(pixelCeil(clamp(available.y, minHeight.value === Infinity ? 0 : minHeight.value, maxHeight.value))) 476 }); 477 return { 478 available, 479 contentBox, 480 flipped: flipped2 481 }; 482 } 483 watch(() => [preferredAnchor.value, preferredOrigin.value, props.offset, props.minWidth, props.minHeight, props.maxWidth, props.maxHeight], () => updateLocation()); 484 nextTick(() => { 485 const result = updateLocation(); 486 if (!result) return; 487 const { 488 available, 489 contentBox 490 } = result; 491 if (contentBox.height > available.y) { 492 requestAnimationFrame(() => { 493 updateLocation(); 494 requestAnimationFrame(() => { 495 updateLocation(); 496 }); 497 }); 498 } 499 }); 500 return { 501 updateLocation 502 }; 503} 504function pixelRound(val) { 505 return Math.round(val * devicePixelRatio) / devicePixelRatio; 506} 507function pixelCeil(val) { 508 return Math.ceil(val * devicePixelRatio) / devicePixelRatio; 509} 510let clean = true; 511const frames = []; 512function requestNewFrame(cb) { 513 if (!clean || frames.length) { 514 frames.push(cb); 515 run(); 516 } else { 517 clean = false; 518 cb(); 519 run(); 520 } 521} 522let raf = -1; 523function run() { 524 cancelAnimationFrame(raf); 525 raf = requestAnimationFrame(() => { 526 const frame = frames.shift(); 527 if (frame) frame(); 528 if (frames.length) run(); 529 else clean = true; 530 }); 531} 532const scrollStrategies = { 533 none: null, 534 close: closeScrollStrategy, 535 block: blockScrollStrategy, 536 reposition: repositionScrollStrategy 537}; 538const makeScrollStrategyProps = propsFactory({ 539 scrollStrategy: { 540 type: [String, Function], 541 default: "block", 542 validator: (val) => typeof val === "function" || val in scrollStrategies 543 } 544}, "VOverlay-scroll-strategies"); 545function useScrollStrategies(props, data) { 546 if (!IN_BROWSER) return; 547 let scope; 548 watchEffect(async () => { 549 scope == null ? void 0 : scope.stop(); 550 if (!(data.isActive.value && props.scrollStrategy)) return; 551 scope = effectScope(); 552 await new Promise((resolve) => setTimeout(resolve)); 553 scope.active && scope.run(() => { 554 var _a; 555 if (typeof props.scrollStrategy === "function") { 556 props.scrollStrategy(data, props, scope); 557 } else { 558 (_a = scrollStrategies[props.scrollStrategy]) == null ? void 0 : _a.call(scrollStrategies, data, props, scope); 559 } 560 }); 561 }); 562 onScopeDispose(() => { 563 scope == null ? void 0 : scope.stop(); 564 }); 565} 566function closeScrollStrategy(data) { 567 function onScroll(e) { 568 data.isActive.value = false; 569 } 570 bindScroll(getTargetEl(data.target.value, data.contentEl.value), onScroll); 571} 572function blockScrollStrategy(data, props) { 573 var _a; 574 const offsetParent = (_a = data.root.value) == null ? void 0 : _a.offsetParent; 575 const target = getTargetEl(data.target.value, data.contentEl.value); 576 const scrollElements = [.../* @__PURE__ */ new Set([...getScrollParents(target, props.contained ? offsetParent : void 0), ...getScrollParents(data.contentEl.value, props.contained ? offsetParent : void 0)])].filter((el) => !el.classList.contains("v-overlay-scroll-blocked")); 577 const scrollbarWidth = window.innerWidth - document.documentElement.offsetWidth; 578 const scrollableParent = ((el) => hasScrollbar(el) && el)(offsetParent || document.documentElement); 579 if (scrollableParent) { 580 data.root.value.classList.add("v-overlay--scroll-blocked"); 581 }
582 scrollElements.forEach((el, i) => { 583 el.style.setProperty("--v-body-scroll-x", convertToUnit(-el.scrollLeft)); 584 el.style.setProperty("--v-body-scroll-y", convertToUnit(-el.scrollTop)); 585 if (el !== document.documentElement) { 586 el.style.setProperty("--v-scrollbar-offset", convertToUnit(scrollbarWidth)); 587 } 588 el.classList.add("v-overlay-scroll-blocked"); 589 }); 590 onScopeDispose(() => { 591 scrollElements.forEach((el, i) => { 592 const x = parseFloat(el.style.getPropertyValue("--v-body-scroll-x")); 593 const y = parseFloat(el.style.getPropertyValue("--v-body-scroll-y")); 594 const scrollBehavior = el.style.scrollBehavior; 595 el.style.scrollBehavior = "auto"; 596 el.style.removeProperty("--v-body-scroll-x"); 597 el.style.removeProperty("--v-body-scroll-y"); 598 el.style.removeProperty("--v-scrollbar-offset"); 599 el.classList.remove("v-overlay-scroll-blocked"); 600 el.scrollLeft = -x; 601 el.scrollTop = -y; 602 el.style.scrollBehavior = scrollBehavior; 603 }); 604 if (scrollableParent) { 605 data.root.value.classList.remove("v-overlay--scroll-blocked"); 606 } 607 }); 608} 609function repositionScrollStrategy(data, props, scope) { 610 let slow = false; 611 let raf2 = -1; 612 let ric = -1; 613 function update(e) { 614 requestNewFrame(() => { 615 var _a, _b; 616 const start = performance.now(); 617 (_b = (_a = data.updateLocation).value) == null ? void 0 : _b.call(_a, e); 618 const time = performance.now() - start; 619 slow = time / (1e3 / 60) > 2; 620 }); 621 } 622 ric = (typeof requestIdleCallback === "undefined" ? (cb) => cb() : requestIdleCallback)(() => { 623 scope.run(() => { 624 bindScroll(getTargetEl(data.target.value, data.contentEl.value), (e) => { 625 if (slow) { 626 cancelAnimationFrame(raf2); 627 raf2 = requestAnimationFrame(() => { 628 raf2 = requestAnimationFrame(() => { 629 update(e); 630 }); 631 }); 632 } else { 633 update(e); 634 } 635 }); 636 }); 637 }); 638 onScopeDispose(() => { 639 typeof cancelIdleCallback !== "undefined" && cancelIdleCallback(ric); 640 cancelAnimationFrame(raf2); 641 }); 642} 643function getTargetEl(target, contentEl) { 644 return Array.isArray(target) ? document.elementsFromPoint(...target).find((el) => !(contentEl == null ? void 0 : contentEl.contains(el))) : target ?? contentEl; 645} 646function bindScroll(el, onScroll) { 647 const scrollElements = [document, ...getScrollParents(el)]; 648 scrollElements.forEach((el2) => { 649 el2.addEventListener("scroll", onScroll, { 650 passive: true 651 }); 652 }); 653 onScopeDispose(() => { 654 scrollElements.forEach((el2) => { 655 el2.removeEventListener("scroll", onScroll); 656 }); 657 }); 658} 659const VMenuSymbol = Symbol.for("vuetify:v-menu"); 660const makeActivatorProps = propsFactory({ 661 target: [String, Object], 662 activator: [String, Object], 663 activatorProps: { 664 type: Object, 665 default: () => ({}) 666 }, 667 openOnClick: { 668 type: Boolean, 669 default: void 0 670 }, 671 openOnHover: Boolean, 672 openOnFocus: { 673 type: Boolean, 674 default: void 0 675 }, 676 closeOnContentClick: Boolean, 677 ...makeDelayProps() 678}, "VOverlay-activator"); 679function useActivator(props, _ref) { 680 let { 681 isActive, 682 isTop, 683 contentEl 684 } = _ref; 685 const vm = getCurrentInstance("useActivator"); 686 const activatorEl = ref(); 687 let isHovered = false; 688 let isFocused = false; 689 let firstEnter = true; 690 const openOnFocus = computed(() => props.openOnFocus || props.openOnFocus == null && props.openOnHover); 691 const openOnClick = computed(() => props.openOnClick || props.openOnClick == null && !props.openOnHover && !openOnFocus.value); 692 const { 693 runOpenDelay, 694 runCloseDelay 695 } = useDelay(props, (value) => { 696 if (value === (props.openOnHover && isHovered || openOnFocus.value && isFocused) && !(props.openOnHover && isActive.value && !isTop.value)) { 697 if (isActive.value !== value) { 698 firstEnter = true; 699 } 700 isActive.value = value; 701 } 702 }); 703 const cursorTarget = ref(); 704 const availableEvents = { 705 onClick: (e) => { 706 e.stopPropagation(); 707 activatorEl.value = e.currentTarget || e.target; 708 if (!isActive.value) { 709 cursorTarget.value = [e.clientX, e.clientY]; 710 } 711 isActive.value = !isActive.value; 712 }, 713 onMouseenter: (e) => { 714 isHovered = true; 715 activatorEl.value = e.currentTarget || e.target; 716 runOpenDelay(); 717 }, 718 onMouseleave: (e) => { 719 isHovered = false;
720 runCloseDelay(); 721 }, 722 onFocus: (e) => { 723 if (matchesSelector(e.target, ":focus-visible") === false) return; 724 isFocused = true; 725 e.stopPropagation(); 726 activatorEl.value = e.currentTarget || e.target; 727 runOpenDelay(); 728 }, 729 onBlur: (e) => { 730 isFocused = false; 731 e.stopPropagation(); 732 runCloseDelay({ 733 minDelay: 1 734 }); 735 } 736 }; 737 const activatorEvents = computed(() => { 738 const events = {}; 739 if (openOnClick.value) { 740 events.onClick = availableEvents.onClick; 741 } 742 if (props.openOnHover) { 743 events.onMouseenter = availableEvents.onMouseenter; 744 events.onMouseleave = availableEvents.onMouseleave; 745 } 746 if (openOnFocus.value) { 747 events.onFocus = availableEvents.onFocus; 748 events.onBlur = availableEvents.onBlur; 749 } 750 return events; 751 }); 752 const contentEvents = computed(() => { 753 const events = {}; 754 if (props.openOnHover) { 755 events.onMouseenter = () => { 756 isHovered = true; 757 runOpenDelay(); 758 }; 759 events.onMouseleave = () => { 760 isHovered = false; 761 runCloseDelay(); 762 }; 763 } 764 if (openOnFocus.value) { 765 events.onFocusin = (e) => { 766 if (!e.target.matches(":focus-visible")) return; 767 isFocused = true; 768 runOpenDelay(); 769 }; 770 events.onFocusout = () => { 771 isFocused = false; 772 runCloseDelay({ 773 minDelay: 1 774 }); 775 }; 776 } 777 if (props.closeOnContentClick) { 778 const menu = inject(VMenuSymbol, null); 779 events.onClick = () => { 780 isActive.value = false; 781 menu == null ? void 0 : menu.closeParents(); 782 }; 783 } 784 return events; 785 }); 786 const scrimEvents = computed(() => { 787 const events = {}; 788 if (props.openOnHover) { 789 events.onMouseenter = () => { 790 if (firstEnter) { 791 isHovered = true; 792 firstEnter = false; 793 runOpenDelay(); 794 } 795 }; 796 events.onMouseleave = () => { 797 isHovered = false; 798 runCloseDelay(); 799 }; 800 } 801 return events; 802 }); 803 watch(isTop, (val) => { 804 var _a; 805 if (val && (props.openOnHover && !isHovered && (!openOnFocus.value || !isFocused) || openOnFocus.value && !isFocused && (!props.openOnHover || !isHovered)) && !((_a = contentEl.value) == null ? void 0 : _a.contains(document.activeElement))) { 806 isActive.value = false; 807 } 808 }); 809 watch(isActive, (val) => { 810 if (!val) { 811 setTimeout(() => { 812 cursorTarget.value = void 0; 813 }); 814 } 815 }, { 816 flush: "post" 817 }); 818 const activatorRef = templateRef(); 819 watchEffect(() => { 820 if (!activatorRef.value) return; 821 nextTick(() => { 822 activatorEl.value = activatorRef.el; 823 }); 824 }); 825 const targetRef = templateRef(); 826 const target = computed(() => { 827 if (props.target === "cursor" && cursorTarget.value) return cursorTarget.value; 828 if (targetRef.value) return targetRef.el; 829 return getTarget(props.target, vm) || activatorEl.value; 830 }); 831 const targetEl = computed(() => { 832 return Array.isArray(target.value) ? void 0 : target.value; 833 }); 834 let scope; 835 watch(() => !!props.activator, (val) => { 836 if (val && IN_BROWSER) { 837 scope = effectScope(); 838 scope.run(() => { 839 _useActivator(props, vm, { 840 activatorEl, 841 activatorEvents 842 }); 843 }); 844 } else if (scope) { 845 scope.stop(); 846 } 847 }, { 848 flush: "post", 849 immediate: true 850 }); 851 onScopeDispose(() => { 852 scope == null ? void 0 : scope.stop(); 853 }); 854 return { 855 activatorEl, 856 activatorRef, 857 target, 858 targetEl, 859 targetRef, 860 activatorEvents, 861 contentEvents, 862 scrimEvents 863 }; 864} 865function _useActivator(props, vm, _ref2) { 866 let { 867 activatorEl, 868 activatorEvents 869 } = _ref2; 870 watch(() => props.activator, (val, oldVal) => { 871 if (oldVal && val !== oldVal) { 872 const activator = getActivator(oldVal); 873 activator && unbindActivatorProps(activator); 874 } 875 if (val) { 876 nextTick(() => bindActivatorProps()); 877 } 878 }, { 879 immediate: true 880 }); 881 watch(() => props.activatorProps, () => { 882 bindActivatorProps(); 883 }); 884 onScopeDispose(() => { 885 unbindActivatorProps(); 886 }); 887 function bindActivatorProps() { 888 let el = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getActivator(); 889 let _props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : props.activatorProps; 890 if (!el) return; 891 bindProps(el, mergeProps(activatorEvents.value, _props)); 892 } 893 function unbindActivatorProps() { 894 let el = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getActivator(); 895 let _props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : props.activatorProps; 896 if (!el) return; 897 unbindProps(el, mergeProps(activatorEvents.value, _props)); 898 } 899 function getActivator() { 900 let selector = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : props.activator; 901 const activator = getTarget(selector, vm); 902 activatorEl.value = (activator == null ? void 0 : activator.nodeType) === N
902ode.ELEMENT_NODE ? activator : void 0; 903 return activatorEl.value; 904 } 905} 906function getTarget(selector, vm) { 907 var _a, _b; 908 if (!selector) return; 909 let target; 910 if (selector === "parent") { 911 let el = (_b = (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$el) == null ? void 0 : _b.parentNode; 912 while (el == null ? void 0 : el.hasAttribute("data-no-activator")) { 913 el = el.parentNode; 914 } 915 target = el; 916 } else if (typeof selector === "string") { 917 target = document.querySelector(selector); 918 } else if ("$el" in selector) { 919 target = selector.$el; 920 } else { 921 target = selector; 922 } 923 return target; 924} 925function useHydration() { 926 if (!IN_BROWSER) return shallowRef(false); 927 const { 928 ssr 929 } = useDisplay(); 930 if (ssr) { 931 const isMounted = shallowRef(false); 932 onMounted(() => { 933 isMounted.value = true; 934 }); 935 return isMounted; 936 } else { 937 return shallowRef(true); 938 } 939} 940const StackSymbol = Symbol.for("vuetify:stack"); 941const globalStack = reactive([]); 942function useStack(isActive, zIndex, disableGlobalStack) { 943 const vm = getCurrentInstance("useStack"); 944 const createStackEntry = !disableGlobalStack; 945 const parent = inject(StackSymbol, void 0); 946 const stack = reactive({ 947 activeChildren: /* @__PURE__ */ new Set() 948 }); 949 provide(StackSymbol, stack); 950 const _zIndex = shallowRef(Number(toValue(zIndex))); 951 useToggleScope(isActive, () => { 952 var _a; 953 const lastZIndex = (_a = globalStack.at(-1)) == null ? void 0 : _a[1]; 954 _zIndex.value = lastZIndex ? lastZIndex + 10 : Number(toValue(zIndex)); 955 if (createStackEntry) { 956 globalStack.push([vm.uid, _zIndex.value]); 957 } 958 parent == null ? void 0 : parent.activeChildren.add(vm.uid); 959 onScopeDispose(() => { 960 if (createStackEntry) { 961 const idx = toRaw(globalStack).findIndex((v) => v[0] === vm.uid); 962 globalStack.splice(idx, 1); 963 } 964 parent == null ? void 0 : parent.activeChildren.delete(vm.uid); 965 }); 966 }); 967 const globalTop = shallowRef(true); 968 if (createStackEntry) { 969 watchEffect(() => { 970 var _a; 971 const _isTop = ((_a = globalStack.at(-1)) == null ? void 0 : _a[0]) === vm.uid; 972 setTimeout(() => globalTop.value = _isTop); 973 }); 974 } 975 const localTop = toRef(() => !stack.activeChildren.size); 976 return { 977 globalTop: readonly(globalTop), 978 localTop, 979 stackStyles: toRef(() => ({ 980 zIndex: _zIndex.value 981 })) 982 }; 983} 984function useTeleport(target) { 985 const teleportTarget = computed(() => { 986 const _target = target(); 987 if (_target === true || !IN_BROWSER) return void 0; 988 const targetElement = _target === false ? document.body : typeof _target === "string" ? document.querySelector(_target) : _target; 989 if (targetElement == null) { 990 return void 0; 991 } 992 let container = [...targetElement.children].find((el) => el.matches(".v-overlay-container")); 993 if (!container) { 994 container = document.createElement("div"); 995 container.className = "v-overlay-container"; 996 targetElement.appendChild(container); 997 } 998 return container; 999 }); 1000 return { 1001 teleportTarget 1002 }; 1003} 1004function defaultConditional() { 1005 return true; 1006} 1007function checkEvent(e, el, binding) { 1008 if (!e || checkIsActive(e, binding) === false) return false; 1009 const root = attachedRoot(el); 1010 if (typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot && root.host === e.target) return false; 1011 const elements = (typeof binding.value === "object" && binding.value.include || (() => []))(); 1012 elements.push(el); 1013 return !elements.some((el2) => el2 == null ? void 0 : el2.contains(e.target)); 1014} 1015function checkIsActive(e, binding) { 1016 const isActive = typeof binding.value === "object" && binding.value.closeConditional || defaultConditional; 1017 return isActive(e); 1018} 1019function directive(e, el, binding) { 1020 const handler = typeof binding.value === "function" ? binding.value : binding.value.handler; 1021 e.shadowTarget = e.target; 1022 el._clickOutside.lastMousedownWasOutside && checkEvent(e, el, binding) && setTimeout(() => { 1023 checkIsActive(e, binding) && handler && handler(e); 1024 }, 0); 1025} 1026function handleShadow(el, callback) { 1027 const root = attachedRoot(el); 1028 callback(document); 1029 if (typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot) { 1030 callback(root); 1031 } 1032} 1033const ClickOutside = { 1034 // [data-app] may not be found 1035 // if using bind, inserted makes 1036 // sure that the root element is 1037 // available, iOS does not support 1038 // clicks on body 1039 mounted(el, binding) { 1040 const onClick = (e) => directive(e, el, binding); 1041 const onMousedown = (e) => { 1042 el._clickOutside.lastMousedownWasOutside = checkEvent(e, el, binding); 1043 }; 1044 handleShadow(el, (app) => { 1045 app.addEventListener("click", onClick, true); 1046 app.addEventListener("mousedown", onMousedown, true); 1047 }); 1048 if (!el._clickOutside) { 1049 el._clickOutside = { 1050 lastMousedownWasOutside: false 1051 }; 1052 } 1053 el._clickOutside[binding.instance.$.uid] = { 1054 onClick, 1055 onMousedown 1056 }; 1057 }, 1058 beforeUnmount(el, binding) { 1059 if (!el._clickOutside) return; 1060 handleShadow(el, (app) => { 1061 var _a; 1062 if (!app || !((_a = el._clickOutside) == null ? void 0 : _a[binding.instance.$.uid])) return; 1063 const { 1064 onClick, 1065 onMousedown 1066 } = el._clickOutside[binding.instance.$.uid]; 1067 app.removeEventListener("click", onClick, true); 1068 app.removeEventListener("mousedown", onMousedown, true); 1069 }); 1070 delete el._clickOutside[binding.instance.$.uid]; 1071 } 1072}; 1073function Scrim(props) { 1074 const { 1075 modelValue, 1076 color, 1077 ...rest 1078 } = props; 1079 return createVNode(Transition, { 1080 "name": "fade-transition", 1081 "appear": true 1082 }, { 1083 default: () => [props.modelValue && createBaseVNode("div", mergeProps({ 1084 "class": ["v-overlay__scrim", props.color.backgroundColorClasses.value], 1085 "style": props.color.backgroundColorStyles.value 1086 }, rest), null)] 1087 }); 1088} 1089const makeVOverlayProps = propsFactory({ 1090 absolute: Boolean, 1091 attach: [Boolean, String, Object], 1092 closeOnBack: { 1093 type: Boolean, 1094 default: true 1095 }, 1096 contained: Boolean,
1097 contentClass: null, 1098 contentProps: null, 1099 disabled: Boolean, 1100 opacity: [Number, String], 1101 noClickAnimation: Boolean, 1102 modelValue: Boolean, 1103 persistent: Boolean, 1104 scrim: { 1105 type: [Boolean, String], 1106 default: true 1107 }, 1108 zIndex: { 1109 type: [Number, String], 1110 default: 2e3 1111 }, 1112 ...makeActivatorProps(), 1113 ...makeComponentProps(), 1114 ...makeDimensionProps(), 1115 ...makeLazyProps(), 1116 ...makeLocationStrategyProps(), 1117 ...makeScrollStrategyProps(), 1118 ...makeFocusTrapProps(), 1119 ...makeThemeProps(), 1120 ...makeTransitionProps() 1121}, "VOverlay"); 1122const VOverlay = genericComponent()({ 1123 name: "VOverlay", 1124 directives: { 1125 vClickOutside: ClickOutside 1126 }, 1127 inheritAttrs: false, 1128 props: { 1129 _disableGlobalStack: Boolean, 1130 ...omit(makeVOverlayProps(), ["disableInitialFocus"]) 1131 }, 1132 emits: { 1133 "click:outside": (e) => true, 1134 "update:modelValue": (value) => true, 1135 keydown: (e) => true, 1136 afterEnter: () => true, 1137 afterLeave: () => true 1138 }, 1139 setup(props, _ref) { 1140 let { 1141 slots, 1142 attrs, 1143 emit 1144 } = _ref; 1145 const vm = getCurrentInstance("VOverlay"); 1146 const root = ref(); 1147 const scrimEl = ref(); 1148 const contentEl = ref(); 1149 const model = useProxiedModel(props, "modelValue"); 1150 const isActive = computed({ 1151 get: () => model.value, 1152 set: (v) => { 1153 if (!(v && props.disabled)) model.value = v; 1154 } 1155 }); 1156 const { 1157 themeClasses 1158 } = provideTheme(props); 1159 const { 1160 rtlClasses, 1161 isRtl 1162 } = useRtl(); 1163 const { 1164 hasContent, 1165 onAfterLeave: _onAfterLeave 1166 } = useLazy(props, isActive); 1167 const scrimColor = useBackgroundColor(() => { 1168 return typeof props.scrim === "string" ? props.scrim : null; 1169 }); 1170 const { 1171 globalTop, 1172 localTop, 1173 stackStyles 1174 } = useStack(isActive, () => props.zIndex, props._disableGlobalStack); 1175 const { 1176 activatorEl, 1177 activatorRef, 1178 target, 1179 targetEl, 1180 targetRef, 1181 activatorEvents, 1182 contentEvents, 1183 scrimEvents 1184 } = useActivator(props, { 1185 isActive, 1186 isTop: localTop, 1187 contentEl 1188 }); 1189 const { 1190 teleportTarget 1191 } = useTeleport(() => { 1192 var _a, _b, _c; 1193 const target2 = props.attach || props.contained; 1194 if (target2) return target2; 1195 const rootNode = ((_a = activatorEl == null ? void 0 : activatorEl.value) == null ? void 0 : _a.getRootNode()) || ((_c = (_b = vm.proxy) == null ? void 0 : _b.$el) == null ? void 0 : _c.getRootNode()); 1196 if (rootNode instanceof ShadowRoot) return rootNode; 1197 return false; 1198 }); 1199 const { 1200 dimensionStyles 1201 } = useDimension(props); 1202 const isMounted = useHydration(); 1203 const { 1204 scopeId 1205 } = useScopeId(); 1206 watch(() => props.disabled, (v) => { 1207 if (v) isActive.value = false; 1208 }); 1209 const { 1210 contentStyles, 1211 updateLocation 1212 } = useLocationStrategies(props, { 1213 isRtl, 1214 contentEl, 1215 target, 1216 isActive 1217 }); 1218 useScrollStrategies(props, { 1219 root, 1220 contentEl, 1221 targetEl, 1222 target, 1223 isActive, 1224 updateLocation 1225 }); 1226 function onClickOutside(e) { 1227 emit("click:outside", e); 1228 if (!props.persistent) isActive.value = false; 1229 else animateClick(); 1230 } 1231 function closeConditional(e) { 1232 return isActive.value && localTop.value && // If using scrim, only close if clicking on it rather than anything opened on top 1233 (!props.scrim || e.target === scrimEl.value || e instanceof MouseEvent && e.shadowTarget === scrimEl.value); 1234 } 1235 useFocusTrap(props, { 1236 isActive, 1237 localTop, 1238 contentEl, 1239 activatorEl 1240 }); 1241 IN_BROWSER && watch(isActive, (val) => { 1242 if (val) { 1243 window.addEventListener("keydown", onKeydown); 1244 } else { 1245 window.removeEventListener("keydown", onKeydown); 1246 } 1247 }, { 1248 immediate: true 1249 }); 1250 onBeforeUnmount(() => { 1251 if (!IN_BROWSER) return; 1252 window.removeEventListener("keydown", onKeydown); 1253 }); 1254 function onKeydown(e) { 1255 var _a, _b, _c; 1256 if (e.key === "Escape" && globalTop.value) { 1257 if (!((_a = contentEl.value) == null ? void 0 : _a.contains(document.activeElement))) { 1258 emit("keydown", e); 1259 } 1260 if (!props.persistent) { 1261 isActive.value = false;
1262 if ((_b = contentEl.value) == null ? void 0 : _b.contains(document.activeElement)) { 1263 (_c = activatorEl.value) == null ? void 0 : _c.focus(); 1264 } 1265 } else animateClick(); 1266 } 1267 } 1268 function onKeydownSelf(e) { 1269 if (e.key === "Escape" && !globalTop.value) return; 1270 emit("keydown", e); 1271 } 1272 const router = useRouter(); 1273 useToggleScope(() => props.closeOnBack, () => { 1274 useBackButton(router, () => { 1275 if (globalTop.value && isActive.value) { 1276 if (!props.persistent) isActive.value = false; 1277 else animateClick(); 1278 return false; 1279 } 1280 return void 0; 1281 }); 1282 }); 1283 const top = ref(); 1284 watch(() => isActive.value && (props.absolute || props.contained) && teleportTarget.value == null, (val) => { 1285 if (val) { 1286 const scrollParent = getScrollParent(root.value); 1287 if (scrollParent && scrollParent !== document.scrollingElement) { 1288 top.value = scrollParent.scrollTop; 1289 } 1290 } 1291 }); 1292 function animateClick() { 1293 if (props.noClickAnimation) return; 1294 contentEl.value && animate(contentEl.value, [{ 1295 transformOrigin: "center" 1296 }, { 1297 transform: "scale(1.03)" 1298 }, { 1299 transformOrigin: "center" 1300 }], { 1301 duration: 150, 1302 easing: standardEasing 1303 }); 1304 } 1305 function onAfterEnter() { 1306 emit("afterEnter"); 1307 } 1308 function onAfterLeave() { 1309 _onAfterLeave(); 1310 emit("afterLeave"); 1311 } 1312 useRender(() => { 1313 var _a; 1314 return createBaseVNode(Fragment, null, [(_a = slots.activator) == null ? void 0 : _a.call(slots, { 1315 isActive: isActive.value, 1316 targetRef, 1317 props: mergeProps({ 1318 ref: activatorRef 1319 }, activatorEvents.value, props.activatorProps) 1320 }), isMounted.value && hasContent.value && createVNode(Teleport, { 1321 "disabled": !teleportTarget.value, 1322 "to": teleportTarget.value 1323 }, { 1324 default: () => [createBaseVNode("div", mergeProps({ 1325 "class": ["v-overlay", { 1326 "v-overlay--absolute": props.absolute || props.contained, 1327 "v-overlay--active": isActive.value, 1328 "v-overlay--contained": props.contained 1329 }, themeClasses.value, rtlClasses.value, props.class], 1330 "style": [stackStyles.value, { 1331 "--v-overlay-opacity": props.opacity, 1332 top: convertToUnit(top.value) 1333 }, props.style], 1334 "ref": root, 1335 "onKeydown": onKeydownSelf 1336 }, scopeId, attrs), [createVNode(Scrim, mergeProps({ 1337 "color": scrimColor, 1338 "modelValue": isActive.value && !!props.scrim, 1339 "ref": scrimEl 1340 }, scrimEvents.value), null), createVNode(MaybeTransition, { 1341 "appear": true, 1342 "persisted": true, 1343 "transition": props.transition, 1344 "target": target.value, 1345 "onAfterEnter": onAfterEnter, 1346 "onAfterLeave": onAfterLeave 1347 }, { 1348 default: () => { 1349 var _a2; 1350 return [withDirectives(createBaseVNode("div", mergeProps({ 1351 "ref": contentEl, 1352 "class": ["v-overlay__content", props.contentClass], 1353 "style": [dimensionStyles.value, contentStyles.value] 1354 }, contentEvents.value, props.contentProps), [(_a2 = slots.default) == null ? void 0 : _a2.call(slots, { 1355 isActive 1356 })]), [[vShow, isActive.value], [ClickOutside, { 1357 handler: onClickOutside, 1358 closeConditional, 1359 include: () => [activatorEl.value] 1360 }]])]; 1361 } 1362 })])] 1363 })]); 1364 }); 1365 return { 1366 activatorEl, 1367 scrimEl, 1368 target, 1369 animateClick, 1370 contentEl, 1371 rootEl: root, 1372 globalTop, 1373 localTop, 1374 updateLocation 1375 }; 1376 } 1377}); 1378export { 1379 VOverlay as V, 1380 VMenuSymbol as a, 1381 makeVOverlayProps as m 1382};
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.