/**
* @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