Página no encontrada

/** * @package Freemius * @copyright Copyright (c) 2015, Freemius, Inc. * @license https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License Version 3 * @since 2.5.10 */ if ( ! defined( 'ABSPATH' ) ) { exit; } if ( ! function_exists( 'fs_html_get_allowed_kses_list' ) ) { /** * Get the allowed KSES list for sanitizing HTML output on the template files. * * @return array */ function fs_html_get_allowed_kses_list() { $common_attributes = array( 'id' => true, 'class' => true, 'style' => true, 'data-*' => true, ); return array( 'a' => array_merge( $common_attributes, array( 'href' => true, 'title' => true, 'target' => true, 'rel' => true, ) ), 'img' => array_merge( $common_attributes, array( 'src' => true, 'alt' => true, 'title' => true, 'width' => true, 'height' => true, ) ), 'br' => $common_attributes, 'em' => $common_attributes, 'small' => $common_attributes, 'strong' => $common_attributes, 'u' => $common_attributes, 'b' => $common_attributes, 'i' => $common_attributes, 'hr' => $common_attributes, 'span' => $common_attributes, 'p' => $common_attributes, 'div' => $common_attributes, 'ul' => $common_attributes, 'li' => $common_attributes, 'ol' => $common_attributes, 'h1' => $common_attributes, 'h2' => $common_attributes, 'h3' => $common_attributes, 'h4' => $common_attributes, 'h5' => $common_attributes, 'h6' => $common_attributes, 'button' => $common_attributes, 'sup' => $common_attributes, 'sub' => $common_attributes, 'nobr' => $common_attributes, ); } } if ( ! function_exists( 'fs_html_get_classname' ) ) { /** * Gets an HTML class attribute value. * * @param string|string[] $classes * * @return string */ function fs_html_get_classname( $classes ) { if ( is_array( $classes ) ) { $classes = implode( ' ', $classes ); } return esc_attr( $classes ); } } if ( ! function_exists( 'fs_html_get_attributes' ) ) { /** * Gets a properly escaped HTML attributes string from an associative array. * * @param array $attributes A key/value pair array of attributes. * * @return string */ function fs_html_get_attributes( $attributes ) { $attribute_string = ''; foreach ( $attributes as $key => $value ) { $attribute_string .= sprintf( ' %1$s="%2$s"', esc_attr( $key ), esc_attr( $value ) ); } return $attribute_string; } } if ( ! function_exists( 'fs_html_get_sanitized_html' ) ) { /** * Get sanitized HTML for template files. * * @param string $raw_html * * @return string * @since 2.5.10 */ function fs_html_get_sanitized_html( $raw_html ) { return wp_kses( $raw_html, fs_html_get_allowed_kses_list() ); } } @keyframes rotateInDownLeft{from{transform-origin:left bottom;transform:rotate3d(0,0,1,-45deg);opacity:0}to{transform-origin:left bottom;transform:none;opacity:1}}.rotateInDownLeft{animation-name:rotateInDownLeft}const config = { presets: [ [ '@automattic/jetpack-webpack-config/babel/preset', { pluginReplaceTextdomain: { textdomain: 'jetpack-idc' } }, ], ], }; module.exports = config; 'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); const index = require('./index-8acc3c89.js'); const index$1 = require('./index-fb76df07.js'); const pageAlign = require('./page-align-5a2ab493.js'); function getSide(placement) { return placement.split('-')[0]; } function getAlignment(placement) { return placement.split('-')[1]; } function getMainAxisFromPlacement(placement) { return ['top', 'bottom'].includes(getSide(placement)) ? 'x' : 'y'; } function getLengthFromAxis(axis) { return axis === 'y' ? 'height' : 'width'; } function computeCoordsFromPlacement(_ref, placement, rtl) { let { reference, floating } = _ref; const commonX = reference.x + reference.width / 2 - floating.width / 2; const commonY = reference.y + reference.height / 2 - floating.height / 2; const mainAxis = getMainAxisFromPlacement(placement); const length = getLengthFromAxis(mainAxis); const commonAlign = reference[length] / 2 - floating[length] / 2; const side = getSide(placement); const isVertical = mainAxis === 'x'; let coords; switch (side) { case 'top': coords = { x: commonX, y: reference.y - floating.height }; break; case 'bottom': coords = { x: commonX, y: reference.y + reference.height }; break; case 'right': coords = { x: reference.x + reference.width, y: commonY }; break; case 'left': coords = { x: reference.x - floating.width, y: commonY }; break; default: coords = { x: reference.x, y: reference.y }; } switch (getAlignment(placement)) { case 'start': coords[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1); break; case 'end': coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1); break; } return coords; } /** * Computes the `x` and `y` coordinates that will place the floating element * next to a reference element when it is given a certain positioning strategy. * * This export does not have any `platform` interface logic. You will need to * write one for the platform you are using Floating UI with. */ const computePosition$1 = async (reference, floating, config) => { const { placement = 'bottom', strategy = 'absolute', middleware = [], platform } = config; const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating)); let rects = await platform.getElementRects({ reference, floating, strategy }); let { x, y } = computeCoordsFromPlacement(rects, placement, rtl); let statefulPlacement = placement; let middlewareData = {}; let resetCount = 0; for (let i = 0; i < middleware.length; i++) { const { name, fn } = middleware[i]; const { x: nextX, y: nextY, data, reset } = await fn({ x, y, initialPlacement: placement, placement: statefulPlacement, strategy, middlewareData, rects, platform, elements: { reference, floating } }); x = nextX != null ? nextX : x; y = nextY != null ? nextY : y; middlewareData = { ...middlewareData, [name]: { ...middlewareData[name], ...data } }; if (reset && resetCount <= 50) { resetCount++; if (typeof reset === 'object') { if (reset.placement) { statefulPlacement = reset.placement; } if (reset.rects) { rects = reset.rects === true ? await platform.getElementRects({ reference, floating, strategy }) : reset.rects; } ({ x, y } = computeCoordsFromPlacement(rects, statefulPlacement, rtl)); } i = -1; continue; } } return { x, y, placement: statefulPlacement, strategy, middlewareData }; }; function expandPaddingObject(padding) { return { top: 0, right: 0, bottom: 0, left: 0, ...padding }; } function getSideObjectFromPadding(padding) { return typeof padding !== 'number' ? expandPaddingObject(padding) : { top: padding, right: padding, bottom: padding, left: padding }; } function rectToClientRect(rect) { return { ...rect, top: rect.y, left: rect.x, right: rect.x + rect.width, bottom: rect.y + rect.height }; } /** * Resolves with an object of overflow side offsets that determine how much the * element is overflowing a given clipping boundary. * - positive = overflowing the boundary by that number of pixels * - negative = how many pixels left before it will overflow * - 0 = lies flush with the boundary * @see https://floating-ui.com/docs/detectOverflow */ async function detectOverflow(middlewareArguments, options) { var _await$platform$isEle; if (options === void 0) { options = {}; } const { x, y, platform, rects, elements, strategy } = middlewareArguments; const { boundary = 'clippingAncestors', rootBoundary = 'viewport', elementContext = 'floating', altBoundary = false, padding = 0 } = options; const paddingObject = getSideObjectFromPadding(padding); const altContext = elementContext === 'floating' ? 'reference' : 'floating'; const element = elements[altBoundary ? altContext : elementContext]; const clippingClientRect = rectToClientRect(await platform.getClippingRect({ element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))), boundary, rootBoundary, strategy })); const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({ rect: elementContext === 'floating' ? { ...rects.floating, x, y } : rects.reference, offsetParent: await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating)), strategy }) : rects[elementContext]); return { top: clippingClientRect.top - elementClientRect.top + paddingObject.top, bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, left: clippingClientRect.left - elementClientRect.left + paddingObject.left, right: elementClientRect.right - clippingClientRect.right + paddingObject.right }; } const min$1 = Math.min; const max$1 = Math.max; function within(min$1$1, value, max$1$1) { return max$1(min$1$1, min$1(value, max$1$1)); } const hash$1 = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' }; function getOppositePlacement(placement) { return placement.replace(/left|right|bottom|top/g, matched => hash$1[matched]); } function getAlignmentSides(placement, rects, rtl) { if (rtl === void 0) { rtl = false; } const alignment = getAlignment(placement); const mainAxis = getMainAxisFromPlacement(placement); const length = getLengthFromAxis(mainAxis); let mainAlignmentSide = mainAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top'; if (rects.reference[length] > rects.floating[length]) { mainAlignmentSide = getOppositePlacement(mainAlignmentSide); } return { main: mainAlignmentSide, cross: getOppositePlacement(mainAlignmentSide) }; } const hash = { start: 'end', end: 'start' }; function getOppositeAlignmentPlacement(placement) { return placement.replace(/start|end/g, matched => hash[matched]); } function getExpandedPlacements(placement) { const oppositePlacement = getOppositePlacement(placement); return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)]; } /** * Changes the placement of the floating element to one that will fit if the * initially specified `placement` does not. * @see https://floating-ui.com/docs/flip */ const flip = function (options) { if (options === void 0) { options = {}; } return { name: 'flip', options, async fn(middlewareArguments) { var _middlewareData$flip; const { placement, middlewareData, rects, initialPlacement, platform, elements } = middlewareArguments; const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = true, fallbackPlacements: specifiedFallbackPlacements, fallbackStrategy = 'bestFit', flipAlignment = true, ...detectOverflowOptions } = options; const side = getSide(placement); const isBasePlacement = side === initialPlacement; const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement)); const placements = [initialPlacement, ...fallbackPlacements]; const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions); const overflows = []; let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || []; if (checkMainAxis) { overflows.push(overflow[side]); } if (checkCrossAxis) { const { main, cross } = getAlignmentSides(placement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))); overflows.push(overflow[main], overflow[cross]); } overflowsData = [...overflowsData, { placement, overflows }]; // One or more sides is overflowing if (!overflows.every(side => side <= 0)) { var _middlewareData$flip$, _middlewareData$flip2; const nextIndex = ((_middlewareData$flip$ = (_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) != null ? _middlewareData$flip$ : 0) + 1; const nextPlacement = placements[nextIndex]; if (nextPlacement) { // Try next placement and re-run the lifecycle return { data: { index: nextIndex, overflows: overflowsData }, reset: { placement: nextPlacement } }; } let resetPlacement = 'bottom'; switch (fallbackStrategy) { case 'bestFit': { var _overflowsData$map$so; const placement = (_overflowsData$map$so = overflowsData.map(d => [d, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement; if (placement) { resetPlacement = placement; } break; } case 'initialPlacement': resetPlacement = initialPlacement; break; } if (placement !== resetPlacement) { return { reset: { placement: resetPlacement } }; } } return {}; } }; }; async function convertValueToCoords(middlewareArguments, value) { const { placement, platform, elements } = middlewareArguments; const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)); const side = getSide(placement); const alignment = getAlignment(placement); const isVertical = getMainAxisFromPlacement(placement) === 'x'; const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1; const crossAxisMulti = rtl && isVertical ? -1 : 1; const rawValue = typeof value === 'function' ? value(middlewareArguments) : value; // eslint-disable-next-line prefer-const let { mainAxis, crossAxis, alignmentAxis } = typeof rawValue === 'number' ? { mainAxis: rawValue, crossAxis: 0, alignmentAxis: null } : { mainAxis: 0, crossAxis: 0, alignmentAxis: null, ...rawValue }; if (alignment && typeof alignmentAxis === 'number') { crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis; } return isVertical ? { x: crossAxis * crossAxisMulti, y: mainAxis * mainAxisMulti } : { x: mainAxis * mainAxisMulti, y: crossAxis * crossAxisMulti }; } /** * Displaces the floating element from its reference element. * @see https://floating-ui.com/docs/offset */ const offset = function (value) { if (value === void 0) { value = 0; } return { name: 'offset', options: value, async fn(middlewareArguments) { const { x, y } = middlewareArguments; const diffCoords = await convertValueToCoords(middlewareArguments, value); return { x: x + diffCoords.x, y: y + diffCoords.y, data: diffCoords }; } }; }; function getCrossAxis(axis) { return axis === 'x' ? 'y' : 'x'; } /** * Shifts the floating element in order to keep it in view when it will overflow * a clipping boundary. * @see https://floating-ui.com/docs/shift */ const shift = function (options) { if (options === void 0) { options = {}; } return { name: 'shift', options, async fn(middlewareArguments) { const { x, y, placement } = middlewareArguments; const { mainAxis: checkMainAxis = true, crossAxis: checkCrossAxis = false, limiter = { fn: _ref => { let { x, y } = _ref; return { x, y }; } }, ...detectOverflowOptions } = options; const coords = { x, y }; const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions); const mainAxis = getMainAxisFromPlacement(getSide(placement)); const crossAxis = getCrossAxis(mainAxis); let mainAxisCoord = coords[mainAxis]; let crossAxisCoord = coords[crossAxis]; if (checkMainAxis) { const minSide = mainAxis === 'y' ? 'top' : 'left'; const maxSide = mainAxis === 'y' ? 'bottom' : 'right'; const min = mainAxisCoord + overflow[minSide]; const max = mainAxisCoord - overflow[maxSide]; mainAxisCoord = within(min, mainAxisCoord, max); } if (checkCrossAxis) { const minSide = crossAxis === 'y' ? 'top' : 'left'; const maxSide = crossAxis === 'y' ? 'bottom' : 'right'; const min = crossAxisCoord + overflow[minSide]; const max = crossAxisCoord - overflow[maxSide]; crossAxisCoord = within(min, crossAxisCoord, max); } const limitedCoords = limiter.fn({ ...middlewareArguments, [mainAxis]: mainAxisCoord, [crossAxis]: crossAxisCoord }); return { ...limitedCoords, data: { x: limitedCoords.x - x, y: limitedCoords.y - y } }; } }; }; /** * Provides data to change the size of the floating element. For instance, * prevent it from overflowing its clipping boundary or match the width of the * reference element. * @see https://floating-ui.com/docs/size */ const size = function (options) { if (options === void 0) { options = {}; } return { name: 'size', options, async fn(middlewareArguments) { const { placement, rects, platform, elements } = middlewareArguments; const { apply, ...detectOverflowOptions } = options; const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions); const side = getSide(placement); const alignment = getAlignment(placement); let heightSide; let widthSide; if (side === 'top' || side === 'bottom') { heightSide = side; widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right'; } else { widthSide = side; heightSide = alignment === 'end' ? 'top' : 'bottom'; } const xMin = max$1(overflow.left, 0); const xMax = max$1(overflow.right, 0); const yMin = max$1(overflow.top, 0); const yMax = max$1(overflow.bottom, 0); const dimensions = { availableHeight: rects.floating.height - (['left', 'right'].includes(placement) ? 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$1(overflow.top, overflow.bottom)) : overflow[heightSide]), availableWidth: rects.floating.width - (['top', 'bottom'].includes(placement) ? 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$1(overflow.left, overflow.right)) : overflow[widthSide]) }; const prevDimensions = await platform.getDimensions(elements.floating); apply == null ? void 0 : apply({ ...middlewareArguments, ...dimensions }); const nextDimensions = await platform.getDimensions(elements.floating); if (prevDimensions.width !== nextDimensions.width || prevDimensions.height !== nextDimensions.height) { return { reset: { rects: true } }; } return {}; } }; }; function isWindow(value) { return value && value.document && value.location && value.alert && value.setInterval; } function getWindow(node) { if (node == null) { return window; } if (!isWindow(node)) { const ownerDocument = node.ownerDocument; return ownerDocument ? ownerDocument.defaultView || window : window; } return node; } function getComputedStyle$1(element) { return getWindow(element).getComputedStyle(element); } function getNodeName(node) { return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : ''; } function getUAString() { const uaData = navigator.userAgentData; if (uaData != null && uaData.brands) { return uaData.brands.map(item => item.brand + "/" + item.version).join(' '); } return navigator.userAgent; } function isHTMLElement(value) { return value instanceof getWindow(value).HTMLElement; } function isElement(value) { return value instanceof getWindow(value).Element; } function isNode(value) { return value instanceof getWindow(value).Node; } function isShadowRoot(node) { // Browsers without `ShadowRoot` support if (typeof ShadowRoot === 'undefined') { return false; } const OwnElement = getWindow(node).ShadowRoot; return node instanceof OwnElement || node instanceof ShadowRoot; } function isOverflowElement(element) { // Firefox wants us to check `-x` and `-y` variations as well const { overflow, overflowX, overflowY } = getComputedStyle$1(element); return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); } function isTableElement(element) { return ['table', 'td', 'th'].includes(getNodeName(element)); } function isContainingBlock(element) { // TODO: Try and use feature detection here instead const isFirefox = /firefox/i.test(getUAString()); const css = getComputedStyle$1(element); // This is non-exhaustive but covers the most common CSS properties that // create a containing block. // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block return css.transform !== 'none' || css.perspective !== 'none' || // @ts-ignore (TS 4.1 compat) css.contain === 'paint' || ['transform', 'perspective'].includes(css.willChange) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false); } function isLayoutViewport() { // Not Safari return !/^((?!chrome|android).)*safari/i.test(getUAString()); // Feature detection for this fails in various ways // • Always-visible scrollbar or not // • Width of , etc. // const vV = win.visualViewport; // return vV ? Math.abs(win.innerWidth / vV.scale - vV.width) < 0.5 : true; } const min = Math.min; const max = Math.max; const round = Math.round; function getBoundingClientRect(element, includeScale, isFixedStrategy) { var _win$visualViewport$o, _win$visualViewport, _win$visualViewport$o2, _win$visualViewport2; if (includeScale === void 0) { includeScale = false; } if (isFixedStrategy === void 0) { isFixedStrategy = false; } const clientRect = element.getBoundingClientRect(); let scaleX = 1; let scaleY = 1; if (includeScale && isHTMLElement(element)) { scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1; scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1; } const win = isElement(element) ? getWindow(element) : window; const addVisualOffsets = !isLayoutViewport() && isFixedStrategy; const x = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX; const y = (clientRect.top + (addVisualOffsets ? (_win$visualViewport$o2 = (_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) != null ? _win$visualViewport$o2 : 0 : 0)) / scaleY; const width = clientRect.width / scaleX; const height = clientRect.height / scaleY; return { width, height, top: y, right: x + width, bottom: y + height, left: x, x, y }; } function getDocumentElement(node) { return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement; } function getNodeScroll(element) { if (isElement(element)) { return { scrollLeft: element.scrollLeft, scrollTop: element.scrollTop }; } return { scrollLeft: element.pageXOffset, scrollTop: element.pageYOffset }; } function getWindowScrollBarX(element) { // If has a CSS width greater than the viewport, then this will be // incorrect for RTL. return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft; } function isScaled(element) { const rect = getBoundingClientRect(element); return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight; } function getRectRelativeToOffsetParent(element, offsetParent, strategy) { const isOffsetParentAnElement = isHTMLElement(offsetParent); const documentElement = getDocumentElement(offsetParent); const rect = getBoundingClientRect(element, // @ts-ignore - checked above (TS 4.1 compat) isOffsetParentAnElement && isScaled(offsetParent), strategy === 'fixed'); let scroll = { scrollLeft: 0, scrollTop: 0 }; const offsets = { x: 0, y: 0 }; if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') { if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) { scroll = getNodeScroll(offsetParent); } if (isHTMLElement(offsetParent)) { const offsetRect = getBoundingClientRect(offsetParent, true); offsets.x = offsetRect.x + offsetParent.clientLeft; offsets.y = offsetRect.y + offsetParent.clientTop; } else if (documentElement) { offsets.x = getWindowScrollBarX(documentElement); } } return { x: rect.left + scroll.scrollLeft - offsets.x, y: rect.top + scroll.scrollTop - offsets.y, width: rect.width, height: rect.height }; } function getParentNode(node) { if (getNodeName(node) === 'html') { return node; } return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle // @ts-ignore node.assignedSlot || // step into the shadow DOM of the parent of a slotted node node.parentNode || ( // DOM Element detected isShadowRoot(node) ? node.host : null) || // ShadowRoot detected getDocumentElement(node) // fallback ); } function getTrueOffsetParent(element) { if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') { return null; } return element.offsetParent; } function getContainingBlock(element) { let currentNode = getParentNode(element); if (isShadowRoot(currentNode)) { currentNode = currentNode.host; } while (isHTMLElement(currentNode) && !['html', 'body'].includes(getNodeName(currentNode))) { if (isContainingBlock(currentNode)) { return currentNode; } else { currentNode = currentNode.parentNode; } } return null; } // Gets the closest ancestor positioned element. Handles some edge cases, // such as table ancestors and cross browser bugs. function getOffsetParent(element) { const window = getWindow(element); let offsetParent = getTrueOffsetParent(element); while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') { offsetParent = getTrueOffsetParent(offsetParent); } if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) { return window; } return offsetParent || getContainingBlock(element) || window; } function getDimensions(element) { if (isHTMLElement(element)) { return { width: element.offsetWidth, height: element.offsetHeight }; } const rect = getBoundingClientRect(element); return { width: rect.width, height: rect.height }; } function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) { let { rect, offsetParent, strategy } = _ref; const isOffsetParentAnElement = isHTMLElement(offsetParent); const documentElement = getDocumentElement(offsetParent); if (offsetParent === documentElement) { return rect; } let scroll = { scrollLeft: 0, scrollTop: 0 }; const offsets = { x: 0, y: 0 }; if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') { if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) { scroll = getNodeScroll(offsetParent); } if (isHTMLElement(offsetParent)) { const offsetRect = getBoundingClientRect(offsetParent, true); offsets.x = offsetRect.x + offsetParent.clientLeft; offsets.y = offsetRect.y + offsetParent.clientTop; } // This doesn't appear to be need to be negated. // else if (documentElement) { // offsets.x = getWindowScrollBarX(documentElement); // } } return { ...rect, x: rect.x - scroll.scrollLeft + offsets.x, y: rect.y - scroll.scrollTop + offsets.y }; } function getViewportRect(element, strategy) { const win = getWindow(element); const html = getDocumentElement(element); const visualViewport = win.visualViewport; let width = html.clientWidth; let height = html.clientHeight; let x = 0; let y = 0; if (visualViewport) { width = visualViewport.width; height = visualViewport.height; const layoutViewport = isLayoutViewport(); if (layoutViewport || !layoutViewport && strategy === 'fixed') { x = visualViewport.offsetLeft; y = visualViewport.offsetTop; } } return { width, height, x, y }; } // of the `` and `` rect bounds if horizontally scrollable function getDocumentRect(element) { var _element$ownerDocumen; const html = getDocumentElement(element); const scroll = getNodeScroll(element); const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); let x = -scroll.scrollLeft + getWindowScrollBarX(element); const y = -scroll.scrollTop; if (getComputedStyle$1(body || html).direction === 'rtl') { x += max(html.clientWidth, body ? body.clientWidth : 0) - width; } return { width, height, x, y }; } function getNearestOverflowAncestor(node) { const parentNode = getParentNode(node); if (['html', 'body', '#document'].includes(getNodeName(parentNode))) { // @ts-ignore assume body is always available return node.ownerDocument.body; } if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) { return parentNode; } return getNearestOverflowAncestor(parentNode); } function getOverflowAncestors(node, list) { var _node$ownerDocument; if (list === void 0) { list = []; } const scrollableAncestor = getNearestOverflowAncestor(node); const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body); const win = getWindow(scrollableAncestor); const target = isBody ? [win].concat(win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []) : scrollableAncestor; const updatedList = list.concat(target); return isBody ? updatedList : // @ts-ignore: isBody tells us target will be an HTMLElement here updatedList.concat(getOverflowAncestors(target)); } function contains(parent, child) { const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method if (parent.contains(child)) { return true; } // then fallback to custom implementation with Shadow DOM support else if (rootNode && isShadowRoot(rootNode)) { let next = child; do { // use `===` replace node.isSameNode() if (next && parent === next) { return true; } // @ts-ignore: need a better way to handle this... next = next.parentNode || next.host; } while (next); } return false; } function getInnerBoundingClientRect(element, strategy) { const clientRect = getBoundingClientRect(element, false, strategy === 'fixed'); const top = clientRect.top + element.clientTop; const left = clientRect.left + element.clientLeft; return { top, left, x: left, y: top, right: left + element.clientWidth, bottom: top + element.clientHeight, width: element.clientWidth, height: element.clientHeight }; } function getClientRectFromClippingAncestor(element, clippingParent, strategy) { if (clippingParent === 'viewport') { return rectToClientRect(getViewportRect(element, strategy)); } if (isElement(clippingParent)) { return getInnerBoundingClientRect(clippingParent, strategy); } return rectToClientRect(getDocumentRect(getDocumentElement(element))); } // A "clipping ancestor" is an overflowable container with the characteristic of // clipping (or hiding) overflowing elements with a position different from // `initial` function getClippingAncestors(element) { const clippingAncestors = getOverflowAncestors(element); const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle$1(element).position); const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; if (!isElement(clipperElement)) { return []; } // @ts-ignore isElement check ensures we return Array return clippingAncestors.filter(clippingAncestors => isElement(clippingAncestors) && contains(clippingAncestors, clipperElement) && getNodeName(clippingAncestors) !== 'body'); } // Gets the maximum area that the element is visible in due to any number of // clipping ancestors function getClippingRect(_ref) { let { element, boundary, rootBoundary, strategy } = _ref; const mainClippingAncestors = boundary === 'clippingAncestors' ? getClippingAncestors(element) : [].concat(boundary); const clippingAncestors = [...mainClippingAncestors, rootBoundary]; const firstClippingAncestor = clippingAncestors[0]; const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => { const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy); accRect.top = max(rect.top, accRect.top); accRect.right = min(rect.right, accRect.right); accRect.bottom = min(rect.bottom, accRect.bottom); accRect.left = max(rect.left, accRect.left); return accRect; }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy)); return { width: clippingRect.right - clippingRect.left, height: clippingRect.bottom - clippingRect.top, x: clippingRect.left, y: clippingRect.top }; } const platform = { getClippingRect, convertOffsetParentRelativeRectToViewportRelativeRect, isElement, getDimensions, getOffsetParent, getDocumentElement, getElementRects: _ref => { let { reference, floating, strategy } = _ref; return { reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy), floating: { ...getDimensions(floating), x: 0, y: 0 } }; }, getClientRects: element => Array.from(element.getClientRects()), isRTL: element => getComputedStyle$1(element).direction === 'rtl' }; /** * Automatically updates the position of the floating element when necessary. * @see https://floating-ui.com/docs/autoUpdate */ function autoUpdate(reference, floating, update, options) { if (options === void 0) { options = {}; } const { ancestorScroll: _ancestorScroll = true, ancestorResize: _ancestorResize = true, elementResize = true, animationFrame = false } = options; const ancestorScroll = _ancestorScroll && !animationFrame; const ancestorResize = _ancestorResize && !animationFrame; const ancestors = ancestorScroll || ancestorResize ? [...(isElement(reference) ? getOverflowAncestors(reference) : []), ...getOverflowAncestors(floating)] : []; ancestors.forEach(ancestor => { ancestorScroll && ancestor.addEventListener('scroll', update, { passive: true }); ancestorResize && ancestor.addEventListener('resize', update); }); let observer = null; if (elementResize) { let initialUpdate = true; observer = new ResizeObserver(() => { if (!initialUpdate) { update(); } initialUpdate = false; }); isElement(reference) && !animationFrame && observer.observe(reference); observer.observe(floating); } let frameId; let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null; if (animationFrame) { frameLoop(); } function frameLoop() { const nextRefRect = getBoundingClientRect(reference); if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) { update(); } prevRefRect = nextRefRect; frameId = requestAnimationFrame(frameLoop); } update(); return () => { var _observer; ancestors.forEach(ancestor => { ancestorScroll && ancestor.removeEventListener('scroll', update); ancestorResize && ancestor.removeEventListener('resize', update); }); (_observer = observer) == null ? void 0 : _observer.disconnect(); observer = null; if (animationFrame) { cancelAnimationFrame(frameId); } }; } /** * Computes the `x` and `y` coordinates that will place the floating element * next to a reference element when it is given a certain CSS positioning * strategy. */ const computePosition = (reference, floating, options) => computePosition$1(reference, floating, { platform, ...options }); const dropdownCss = ":host{display:inline-block;--panel-height:75vh;--panel-width:11rem}.dropdown{position:relative}.dropdown.dropdown--open .dropdown__positioner{visibility:visible;opacity:1;transform:scale(1)}.dropdown__trigger{display:block;cursor:pointer;border-width:0;outline:none;background-color:unset}.dropdown--disabled,.dropdown--disabled .dropdown__trigger{cursor:not-allowed}.dropdown__positioner{position:absolute;right:0;width:100%;z-index:var(--sc-z-index-dropdown);opacity:0;visibility:hidden;transform:scale(0.9);min-width:var(--panel-width)}.dropdown__panel{transform-origin:top left;box-shadow:0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);max-height:var(--panel-height);font-family:var(--sc-font-sans);font-size:var(--sc-font-size-medium);font-weight:var(--sc-font-weight-normal);color:var(--color);background-color:var(--sc-panel-background-color);border:solid 1px var(--sc-panel-border-color);border-radius:var(--sc-border-radius-medium);box-shadow:var(--sc-shadow-large);overflow:auto;overscroll-behavior:none;transition:var(--sc-transition-fast) opacity, var(--sc-transition-fast) transform;z-index:5}"; const ScDropdownStyle0 = dropdownCss; let itemIndex = 0; let arrowFlag = ''; const ScDropdown = class { constructor(hostRef) { index.registerInstance(this, hostRef); this.scShow = index.createEvent(this, "scShow", 7); this.scHide = index.createEvent(this, "scHide", 7); this.clickEl = undefined; this.disabled = undefined; this.open = false; this.position = undefined; this.placement = 'bottom-start'; this.distance = 10; this.skidding = 0; this.hoist = false; this.closeOnSelect = true; this.isVisible = undefined; } handleOpenChange() { this.open ? this.show() : this.hide(); } handleOutsideClick(evt) { const path = evt.composedPath(); if (!path.some(item => { return item === this.el; })) { this.open = false; } } startPositioner() { this.stopPositioner(); this.updatePositioner(); this.positionerCleanup = autoUpdate(this.trigger, this.positioner, this.updatePositioner.bind(this)); } updatePositioner() { if (!this.open || !this.trigger || !this.positioner) { return; } computePosition(this.trigger, this.positioner, { placement: this.placement, middleware: [ offset({ mainAxis: this.distance, crossAxis: this.skidding }), flip(), shift(), size({ apply: ({ availableWidth: width, availableHeight: height }) => { // Ensure the panel stays within the viewport when we have lots of menu items Object.assign(this.panel.style, { maxWidth: `${width}px`, maxHeight: `${height}px`, }); }, padding: 8, }), ], strategy: this.hoist ? 'fixed' : 'absolute', }).then(({ x, y, placement }) => { this.positioner.setAttribute('data-placement', placement); Object.assign(this.positioner.style, { position: this.hoist ? 'fixed' : 'absolute', left: `${x}px`, top: `${y}px`, right: 'auto', }); }); } stopPositioner() { if (this.positionerCleanup) { this.positionerCleanup(); this.positionerCleanup = undefined; this.positioner.removeAttribute('data-placement'); } } show() { index$1.speak(wp.i18n.__('Menu Selection Dropdown opened. Press Up/Down arrow to toggle between menu items.', 'surecart'), 'assertive'); this.scShow.emit(); // Prevent subsequent calls to the method, whether manually or triggered by the `open` watcher if (this.isVisible) { return; } this.isVisible = true; this.open = true; this.startPositioner(); this.panel.focus(); } hide() { index$1.speak(wp.i18n.__('Menu Selection Dropdown closed.', 'surecart'), 'assertive'); this.scHide.emit(); // Prevent subsequent calls to the method, whether manually or triggered by the `open` watcher if (!this.isVisible) { return; } this.stopPositioner(); this.isVisible = false; this.open = false; const slotted = this.el.shadowRoot.querySelector('slot[name="trigger"]'); const trigger = slotted.assignedElements({ flatten: true })[0]; trigger.focus(); } handleClick(e) { if (this.closeOnSelect) { const path = e.composedPath(); if (path.some(item => { return item.classList && item.classList.contains('menu-item'); })) { this.open = false; } } } componentWillLoad() { document.addEventListener('mousedown', evt => this.handleOutsideClick(evt)); } /* Get the slotted menu */ getMenu() { let slotted = this.el.shadowRoot.querySelector('slot'); return slotted.assignedNodes().find(node => { return node.nodeName === 'sc-menu'; }); } getItems() { return [...this.el.querySelectorAll('sc-menu-item')]; } handleHide() { this.open = false; itemIndex = 0; this.trigger.focus(); } handleKeyDown(event) { const items = this.getItems(); // Tabbing out of the control closes it if (event.key === 'Tab') { if (this.open) { this.handleHide(); } return; } // Up/down opens the menu if (['ArrowDown', 'ArrowUp'].includes(event.key)) { event.preventDefault(); event.stopImmediatePropagation(); // Show the menu if it's not already open if (!this.open) { this.open = true; } // Focus on a menu item // Focus on a menu item if (event.key === 'ArrowDown') { if (arrowFlag == 'up') { itemIndex = itemIndex + 2; } if (itemIndex > items.length - 1) { itemIndex = 0; } items[itemIndex].setFocus(); arrowFlag = 'down'; itemIndex++; return; } if (event.key === 'ArrowUp') { if (arrowFlag == 'down') { itemIndex = itemIndex - 2; } if (itemIndex < 0) { itemIndex = items.length - 1; } items[itemIndex].setFocus(); arrowFlag = 'up'; itemIndex--; return; } } // Close select dropdown on Esc/Escape key if (event.key === 'Escape') { if (this.open) { this.handleHide(); } return; } // Open select dropdown with Enter if (event.key === 'Enter') { if (this.open) { this.handleHide(); } else { event.stopImmediatePropagation(); event.preventDefault(); this.open = true; } } // don't open the menu when a CTRL/Command key is pressed if (event.ctrlKey || event.metaKey) { return; } } render() { return (index.h("div", { key: '25b6d9a3052d38285fb4f8e8b57d121558c2383b', part: "base", class: { 'dropdown': true, 'dropdown--open': this.open, 'dropdown--disabled': this.disabled, } }, index.h("span", { key: 'd1ee260c989558e99307202dcef0436a423f3d14', part: "trigger", class: "dropdown__trigger", ref: el => (this.trigger = el), onClick: () => { if (this.disabled) return; if (this.open) { this.hide(); } else { setTimeout(() => { this.show(); }, 0); } }, "aria-expanded": this.open ? 'true' : 'false', "aria-haspopup": "true" }, index.h("slot", { key: '1f5d01914be97f17420e9225daa257b7e378f8f3', name: "trigger" })), index.h("div", { key: 'b6b6dfa1355f3c1ecc1e04dff4c780803ee51069', class: "dropdown__positioner", ref: el => (this.positioner = el) }, index.h("div", { key: '2cf4823ea0e1d0afa168c506ab190934bcfa5671', part: "panel", class: { 'dropdown__panel': true, 'position--top-left': this.position === 'top-left', 'position--top-right': this.position === 'top-right', 'position--bottom-left': this.position === 'bottom-left', 'position--bottom-right': this.position === 'bottom-right', }, "aria-orientation": "vertical", tabindex: "-1", onClick: e => this.handleClick(e), ref: el => (this.panel = el) }, index.h("slot", { key: 'c3bebc300852f5ed95b7639c5dd65b707cea1219' }))))); } get el() { return index.getElement(this); } static get watchers() { return { "open": ["handleOpenChange"] }; } }; ScDropdown.style = ScDropdownStyle0; const scMenuCss = ":host{display:block}.menu{padding:var(--sc-spacing-x-small) 0}.menu:focus{outline:none}::slotted(sc-input){margin-top:-var(--sc-spacing-x-small)}::slotted(sc-divider){--spacing:var(--sc-spacing-x-small)}"; const ScMenuStyle0 = scMenuCss; const ScMenu = class { constructor(hostRef) { index.registerInstance(this, hostRef); this.scSelect = index.createEvent(this, "scSelect", 7); this.items = []; this.ariaLabel = undefined; } /** TODO: Click test */ handleClick(event) { const target = event.target; const item = target.closest('sc-menu-item'); if (item && !item.disabled) { this.scSelect.emit({ item }); } } /** TODO: Keydown Test */ handleKeyDown(event) { // Make a selection when pressing enter if (event.key === 'Enter') { const item = this.getCurrentItem(); event.preventDefault(); if (item) { this.scSelect.emit({ item }); } index$1.speak(wp.i18n.sprintf(wp.i18n.__('Menu %s selected', 'surecart'), item.textContent), 'assertive'); } // Prevent scrolling when space is pressed if (event.key === ' ') { event.preventDefault(); } // Move the selection when pressing down or up if (['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) { const selectedItem = this.getCurrentItem(); let index = selectedItem ? this.items.indexOf(selectedItem) : 0; if (this.items.length) { event.preventDefault(); if (event.key === 'ArrowDown') { index++; } else if (event.key === 'ArrowUp') { index--; } else if (event.key === 'Home') { index = 0; } else if (event.key === 'End') { index = this.items.length - 1; } if (index < 0) index = 0; if (index > this.items.length - 1) index = this.items.length - 1; this.setCurrentItem(this.items[index]); return; } } } /** Get the active item */ getCurrentItem() { return this.items.find(i => i.getAttribute('tabindex') === '0'); } /** * @internal Sets the current menu item to the specified element. This sets `tabindex="0"` on the target element and * `tabindex="-1"` to all other items. This method must be called prior to setting focus on a menu item. */ async setCurrentItem(item) { const activeItem = item.disabled ? this.items[0] : item; // Update tab indexes this.items.forEach(i => { i.setAttribute('tabindex', i === activeItem ? '0' : '-1'); }); } /** Sync slotted items with internal state */ syncItems() { const slottedElements = this.el.shadowRoot.querySelector('slot').assignedElements({ flatten: true }); this.items = slottedElements.filter(node => { return node.nodeName === 'sc-menu-item'; }); } /** Handle items change in slot */ handleSlotChange() { this.syncItems(); } render() { return (index.h("div", { key: 'c7ccdc53df0781fdefffd1acd6a835df8fdb54fb', part: "base", class: "menu", tabindex: "0", onKeyDown: e => this.handleKeyDown(e) }, index.h("slot", { key: '07423e3f9886207a5a57c98b7faaf319767387ab', onSlotchange: () => this.handleSlotChange() }))); } get el() { return index.getElement(this); } }; ScMenu.style = ScMenuStyle0; const scMenuItemCss = ":host{display:block}.menu-item{position:relative;display:flex;align-items:stretch;font-family:var(--sc-font-sans);font-size:var(--sc-font-size-medium);font-weight:var(--sc-font-weight-normal);line-height:var(--sc-menu-item-line-height, var(--sc-line-height-normal));letter-spacing:var(--sc-letter-spacing-normal);text-align:left;color:var(--sc-menu-item-color, var(--sc-color-gray-700));padding:var(--sc-spacing-xx-small) var(--sc-spacing-x-large);transition:var(--sc-input-transition, var(--sc-transition-medium)) fill, var(--sc-input-transition, var(--sc-transition-medium)) background-color;user-select:none;white-space:var(--sc-menu-item-white-space, nowrap);cursor:pointer;text-decoration:none}.menu-item.menu-item--focused:not(.menu-item--disabled){outline:none;background-color:var(--sc-menu-item-background-focused, var(--sc-color-primary-500));color:var(--sc-color-white)}.menu-item.menu-item--disabled{outline:none;color:var(--sc-color-gray-400);cursor:not-allowed}.menu-item .menu-item__label{flex:1 1 auto}.menu-item .menu-item__prefix{flex:0 0 auto;display:flex;align-items:center}.menu-item .menu-item__prefix ::slotted(*){display:inline-flex;margin-right:var(--sc-spacing-small)}.menu-item .menu-item__suffix{flex:0 0 auto;display:flex;align-items:center}.menu-item .menu-item__suffix ::slotted(*){margin-left:var(--sc-spacing-x-small);text-align:right}.menu-item .menu-item__check{display:flex;position:absolute;left:0.5em;top:0.6em;visibility:hidden;align-items:center;font-size:inherit}.menu-item--checked .menu-item__check{visibility:visible}.menu-item--is-rtl.menu-item{text-align:right}.menu-item--is-rtl.menu-item .menu-item__check{left:auto;right:0.5em}"; const ScMenuItemStyle0 = scMenuItemCss; const ScMenuItem = class { constructor(hostRef) { index.registerInstance(this, hostRef); this.hasFocus = false; this.href = undefined; this.target = undefined; this.checked = false; this.value = ''; this.disabled = false; } /** Sets focus on the button. */ async setFocus(options) { this.menuItem.focus(options); } /** Removes focus from the button. */ async setBlur() { this.menuItem.blur(); } handleBlur() { this.hasFocus = false; } handleFocus() { this.hasFocus = true; } render() { const Tag = this.href ? 'a' : 'div'; return (index.h(Tag, { key: '092a23deb7d12067ffba0563eeaa7d59ffa19391', ref: el => (this.menuItem = el), part: "base", class: { 'menu-item': true, 'menu-item--checked': this.checked, 'menu-item--disabled': this.disabled, 'menu-item--focused': this.hasFocus, 'menu-item--is-rtl': pageAlign.isRtl(), }, href: this.href, role: "menuitem", "aria-disabled": this.disabled ? 'true' : 'false', "aria-checked": this.checked ? 'true' : 'false', tabindex: !this.disabled ? '0' : undefined, onFocus: () => this.handleFocus(), onBlur: () => this.handleBlur(), onMouseEnter: () => this.handleFocus(), onMouseLeave: () => this.handleBlur(), onKeyDown: e => { if (e.key === ' ' || e.key === 'Spacebar' || e.key === 'Enter') { this.menuItem.click(); } }, "aria-label": this.el.innerText, target: this.target }, index.h("span", { key: '589b7b05b179574ab44875fad2b4c67fead192c2', part: "checked-icon", class: "menu-item__check" }, index.h("svg", { key: '39bbab0a13b6d737d5db713d8bba1db5d32fe278', xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentColor", class: "bi bi-check", viewBox: "0 0 16 16" }, index.h("path", { key: '56ee6e7c595c10fb3e562fe6b0bfad1830d0401d', d: "M10.97 4.97a.75.75 0 0 1 1.07 1.05l-3.99 4.99a.75.75 0 0 1-1.08.02L4.324 8.384a.75.75 0 1 1 1.06-1.06l2.094 2.093 3.473-4.425a.267.267 0 0 1 .02-.022z" }))), index.h("span", { key: '4dc9f286f7af81ca977f983b82a524fd88a9d350', part: "prefix", class: "menu-item__prefix" }, index.h("slot", { key: '70bd6860b573de027a53010d7acf77defa67d943', name: "prefix" })), index.h("span", { key: '95b577e22a8f5b79b520082bf39a132fff7d05d5', part: "label", class: "menu-item__label" }, index.h("slot", { key: '656a92d3c75c06c95f110d1ec8aeabce7f2b10ee' })), index.h("span", { key: '606227e17934121ffce0ee912a402234351f01d1', part: "suffix", class: "menu-item__suffix" }, index.h("slot", { key: '1f6716ba1352af6ed2a2363f99dbabe1eaf27d73', name: "suffix" })))); } get el() { return index.getElement(this); } }; ScMenuItem.style = ScMenuItemStyle0; exports.sc_dropdown = ScDropdown; exports.sc_menu = ScMenu; exports.sc_menu_item = ScMenuItem; //# sourceMappingURL=sc-dropdown_3.cjs.entry.js.map Página no encontrada

Parece que el enlace que apuntaba aquí no sirve. ¿Quieres probar con una búsqueda?

¡COMPRA $1,200.00 PESOS Y TU ENVIO ES GRATIS! Descartar

× ¿Cómo puedo ayudarte?