/******/ (() => { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ "./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js":
/*!***************************************************************************!*\
  !*** ./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js ***!
  \***************************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   BASE_TRANSITION: () => (/* binding */ BASE_TRANSITION),
/* harmony export */   BindingTypes: () => (/* binding */ BindingTypes),
/* harmony export */   CAMELIZE: () => (/* binding */ CAMELIZE),
/* harmony export */   CAPITALIZE: () => (/* binding */ CAPITALIZE),
/* harmony export */   CREATE_BLOCK: () => (/* binding */ CREATE_BLOCK),
/* harmony export */   CREATE_COMMENT: () => (/* binding */ CREATE_COMMENT),
/* harmony export */   CREATE_ELEMENT_BLOCK: () => (/* binding */ CREATE_ELEMENT_BLOCK),
/* harmony export */   CREATE_ELEMENT_VNODE: () => (/* binding */ CREATE_ELEMENT_VNODE),
/* harmony export */   CREATE_SLOTS: () => (/* binding */ CREATE_SLOTS),
/* harmony export */   CREATE_STATIC: () => (/* binding */ CREATE_STATIC),
/* harmony export */   CREATE_TEXT: () => (/* binding */ CREATE_TEXT),
/* harmony export */   CREATE_VNODE: () => (/* binding */ CREATE_VNODE),
/* harmony export */   CompilerDeprecationTypes: () => (/* binding */ CompilerDeprecationTypes),
/* harmony export */   ConstantTypes: () => (/* binding */ ConstantTypes),
/* harmony export */   ElementTypes: () => (/* binding */ ElementTypes),
/* harmony export */   ErrorCodes: () => (/* binding */ ErrorCodes),
/* harmony export */   FRAGMENT: () => (/* binding */ FRAGMENT),
/* harmony export */   GUARD_REACTIVE_PROPS: () => (/* binding */ GUARD_REACTIVE_PROPS),
/* harmony export */   IS_MEMO_SAME: () => (/* binding */ IS_MEMO_SAME),
/* harmony export */   IS_REF: () => (/* binding */ IS_REF),
/* harmony export */   KEEP_ALIVE: () => (/* binding */ KEEP_ALIVE),
/* harmony export */   MERGE_PROPS: () => (/* binding */ MERGE_PROPS),
/* harmony export */   NORMALIZE_CLASS: () => (/* binding */ NORMALIZE_CLASS),
/* harmony export */   NORMALIZE_PROPS: () => (/* binding */ NORMALIZE_PROPS),
/* harmony export */   NORMALIZE_STYLE: () => (/* binding */ NORMALIZE_STYLE),
/* harmony export */   Namespaces: () => (/* binding */ Namespaces),
/* harmony export */   NodeTypes: () => (/* binding */ NodeTypes),
/* harmony export */   OPEN_BLOCK: () => (/* binding */ OPEN_BLOCK),
/* harmony export */   POP_SCOPE_ID: () => (/* binding */ POP_SCOPE_ID),
/* harmony export */   PUSH_SCOPE_ID: () => (/* binding */ PUSH_SCOPE_ID),
/* harmony export */   RENDER_LIST: () => (/* binding */ RENDER_LIST),
/* harmony export */   RENDER_SLOT: () => (/* binding */ RENDER_SLOT),
/* harmony export */   RESOLVE_COMPONENT: () => (/* binding */ RESOLVE_COMPONENT),
/* harmony export */   RESOLVE_DIRECTIVE: () => (/* binding */ RESOLVE_DIRECTIVE),
/* harmony export */   RESOLVE_DYNAMIC_COMPONENT: () => (/* binding */ RESOLVE_DYNAMIC_COMPONENT),
/* harmony export */   RESOLVE_FILTER: () => (/* binding */ RESOLVE_FILTER),
/* harmony export */   SET_BLOCK_TRACKING: () => (/* binding */ SET_BLOCK_TRACKING),
/* harmony export */   SUSPENSE: () => (/* binding */ SUSPENSE),
/* harmony export */   TELEPORT: () => (/* binding */ TELEPORT),
/* harmony export */   TO_DISPLAY_STRING: () => (/* binding */ TO_DISPLAY_STRING),
/* harmony export */   TO_HANDLERS: () => (/* binding */ TO_HANDLERS),
/* harmony export */   TO_HANDLER_KEY: () => (/* binding */ TO_HANDLER_KEY),
/* harmony export */   TS_NODE_TYPES: () => (/* binding */ TS_NODE_TYPES),
/* harmony export */   UNREF: () => (/* binding */ UNREF),
/* harmony export */   WITH_CTX: () => (/* binding */ WITH_CTX),
/* harmony export */   WITH_DIRECTIVES: () => (/* binding */ WITH_DIRECTIVES),
/* harmony export */   WITH_MEMO: () => (/* binding */ WITH_MEMO),
/* harmony export */   advancePositionWithClone: () => (/* binding */ advancePositionWithClone),
/* harmony export */   advancePositionWithMutation: () => (/* binding */ advancePositionWithMutation),
/* harmony export */   assert: () => (/* binding */ assert),
/* harmony export */   baseCompile: () => (/* binding */ baseCompile),
/* harmony export */   baseParse: () => (/* binding */ baseParse),
/* harmony export */   buildDirectiveArgs: () => (/* binding */ buildDirectiveArgs),
/* harmony export */   buildProps: () => (/* binding */ buildProps),
/* harmony export */   buildSlots: () => (/* binding */ buildSlots),
/* harmony export */   checkCompatEnabled: () => (/* binding */ checkCompatEnabled),
/* harmony export */   convertToBlock: () => (/* binding */ convertToBlock),
/* harmony export */   createArrayExpression: () => (/* binding */ createArrayExpression),
/* harmony export */   createAssignmentExpression: () => (/* binding */ createAssignmentExpression),
/* harmony export */   createBlockStatement: () => (/* binding */ createBlockStatement),
/* harmony export */   createCacheExpression: () => (/* binding */ createCacheExpression),
/* harmony export */   createCallExpression: () => (/* binding */ createCallExpression),
/* harmony export */   createCompilerError: () => (/* binding */ createCompilerError),
/* harmony export */   createCompoundExpression: () => (/* binding */ createCompoundExpression),
/* harmony export */   createConditionalExpression: () => (/* binding */ createConditionalExpression),
/* harmony export */   createForLoopParams: () => (/* binding */ createForLoopParams),
/* harmony export */   createFunctionExpression: () => (/* binding */ createFunctionExpression),
/* harmony export */   createIfStatement: () => (/* binding */ createIfStatement),
/* harmony export */   createInterpolation: () => (/* binding */ createInterpolation),
/* harmony export */   createObjectExpression: () => (/* binding */ createObjectExpression),
/* harmony export */   createObjectProperty: () => (/* binding */ createObjectProperty),
/* harmony export */   createReturnStatement: () => (/* binding */ createReturnStatement),
/* harmony export */   createRoot: () => (/* binding */ createRoot),
/* harmony export */   createSequenceExpression: () => (/* binding */ createSequenceExpression),
/* harmony export */   createSimpleExpression: () => (/* binding */ createSimpleExpression),
/* harmony export */   createStructuralDirectiveTransform: () => (/* binding */ createStructuralDirectiveTransform),
/* harmony export */   createTemplateLiteral: () => (/* binding */ createTemplateLiteral),
/* harmony export */   createTransformContext: () => (/* binding */ createTransformContext),
/* harmony export */   createVNodeCall: () => (/* binding */ createVNodeCall),
/* harmony export */   errorMessages: () => (/* binding */ errorMessages),
/* harmony export */   extractIdentifiers: () => (/* binding */ extractIdentifiers),
/* harmony export */   findDir: () => (/* binding */ findDir),
/* harmony export */   findProp: () => (/* binding */ findProp),
/* harmony export */   forAliasRE: () => (/* binding */ forAliasRE),
/* harmony export */   generate: () => (/* binding */ generate),
/* harmony export */   generateCodeFrame: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_0__.generateCodeFrame),
/* harmony export */   getBaseTransformPreset: () => (/* binding */ getBaseTransformPreset),
/* harmony export */   getConstantType: () => (/* binding */ getConstantType),
/* harmony export */   getMemoedVNodeCall: () => (/* binding */ getMemoedVNodeCall),
/* harmony export */   getVNodeBlockHelper: () => (/* binding */ getVNodeBlockHelper),
/* harmony export */   getVNodeHelper: () => (/* binding */ getVNodeHelper),
/* harmony export */   hasDynamicKeyVBind: () => (/* binding */ hasDynamicKeyVBind),
/* harmony export */   hasScopeRef: () => (/* binding */ hasScopeRef),
/* harmony export */   helperNameMap: () => (/* binding */ helperNameMap),
/* harmony export */   injectProp: () => (/* binding */ injectProp),
/* harmony export */   isCoreComponent: () => (/* binding */ isCoreComponent),
/* harmony export */   isFnExpression: () => (/* binding */ isFnExpression),
/* harmony export */   isFnExpressionBrowser: () => (/* binding */ isFnExpressionBrowser),
/* harmony export */   isFnExpressionNode: () => (/* binding */ isFnExpressionNode),
/* harmony export */   isFunctionType: () => (/* binding */ isFunctionType),
/* harmony export */   isInDestructureAssignment: () => (/* binding */ isInDestructureAssignment),
/* harmony export */   isInNewExpression: () => (/* binding */ isInNewExpression),
/* harmony export */   isMemberExpression: () => (/* binding */ isMemberExpression),
/* harmony export */   isMemberExpressionBrowser: () => (/* binding */ isMemberExpressionBrowser),
/* harmony export */   isMemberExpressionNode: () => (/* binding */ isMemberExpressionNode),
/* harmony export */   isReferencedIdentifier: () => (/* binding */ isReferencedIdentifier),
/* harmony export */   isSimpleIdentifier: () => (/* binding */ isSimpleIdentifier),
/* harmony export */   isSlotOutlet: () => (/* binding */ isSlotOutlet),
/* harmony export */   isStaticArgOf: () => (/* binding */ isStaticArgOf),
/* harmony export */   isStaticExp: () => (/* binding */ isStaticExp),
/* harmony export */   isStaticProperty: () => (/* binding */ isStaticProperty),
/* harmony export */   isStaticPropertyKey: () => (/* binding */ isStaticPropertyKey),
/* harmony export */   isTemplateNode: () => (/* binding */ isTemplateNode),
/* harmony export */   isText: () => (/* binding */ isText$1),
/* harmony export */   isVSlot: () => (/* binding */ isVSlot),
/* harmony export */   locStub: () => (/* binding */ locStub),
/* harmony export */   noopDirectiveTransform: () => (/* binding */ noopDirectiveTransform),
/* harmony export */   processExpression: () => (/* binding */ processExpression),
/* harmony export */   processFor: () => (/* binding */ processFor),
/* harmony export */   processIf: () => (/* binding */ processIf),
/* harmony export */   processSlotOutlet: () => (/* binding */ processSlotOutlet),
/* harmony export */   registerRuntimeHelpers: () => (/* binding */ registerRuntimeHelpers),
/* harmony export */   resolveComponentType: () => (/* binding */ resolveComponentType),
/* harmony export */   stringifyExpression: () => (/* binding */ stringifyExpression),
/* harmony export */   toValidAssetId: () => (/* binding */ toValidAssetId),
/* harmony export */   trackSlotScopes: () => (/* binding */ trackSlotScopes),
/* harmony export */   trackVForSlotScopes: () => (/* binding */ trackVForSlotScopes),
/* harmony export */   transform: () => (/* binding */ transform),
/* harmony export */   transformBind: () => (/* binding */ transformBind),
/* harmony export */   transformElement: () => (/* binding */ transformElement),
/* harmony export */   transformExpression: () => (/* binding */ transformExpression),
/* harmony export */   transformModel: () => (/* binding */ transformModel),
/* harmony export */   transformOn: () => (/* binding */ transformOn),
/* harmony export */   traverseNode: () => (/* binding */ traverseNode),
/* harmony export */   unwrapTSNode: () => (/* binding */ unwrapTSNode),
/* harmony export */   walkBlockDeclarations: () => (/* binding */ walkBlockDeclarations),
/* harmony export */   walkFunctionParams: () => (/* binding */ walkFunctionParams),
/* harmony export */   walkIdentifiers: () => (/* binding */ walkIdentifiers),
/* harmony export */   warnDeprecation: () => (/* binding */ warnDeprecation)
/* harmony export */ });
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
/**
* @vue/compiler-core v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/



const FRAGMENT = Symbol( true ? `Fragment` : 0);
const TELEPORT = Symbol( true ? `Teleport` : 0);
const SUSPENSE = Symbol( true ? `Suspense` : 0);
const KEEP_ALIVE = Symbol( true ? `KeepAlive` : 0);
const BASE_TRANSITION = Symbol( true ? `BaseTransition` : 0);
const OPEN_BLOCK = Symbol( true ? `openBlock` : 0);
const CREATE_BLOCK = Symbol( true ? `createBlock` : 0);
const CREATE_ELEMENT_BLOCK = Symbol( true ? `createElementBlock` : 0);
const CREATE_VNODE = Symbol( true ? `createVNode` : 0);
const CREATE_ELEMENT_VNODE = Symbol( true ? `createElementVNode` : 0);
const CREATE_COMMENT = Symbol( true ? `createCommentVNode` : 0);
const CREATE_TEXT = Symbol( true ? `createTextVNode` : 0);
const CREATE_STATIC = Symbol( true ? `createStaticVNode` : 0);
const RESOLVE_COMPONENT = Symbol( true ? `resolveComponent` : 0);
const RESOLVE_DYNAMIC_COMPONENT = Symbol(
   true ? `resolveDynamicComponent` : 0
);
const RESOLVE_DIRECTIVE = Symbol( true ? `resolveDirective` : 0);
const RESOLVE_FILTER = Symbol( true ? `resolveFilter` : 0);
const WITH_DIRECTIVES = Symbol( true ? `withDirectives` : 0);
const RENDER_LIST = Symbol( true ? `renderList` : 0);
const RENDER_SLOT = Symbol( true ? `renderSlot` : 0);
const CREATE_SLOTS = Symbol( true ? `createSlots` : 0);
const TO_DISPLAY_STRING = Symbol( true ? `toDisplayString` : 0);
const MERGE_PROPS = Symbol( true ? `mergeProps` : 0);
const NORMALIZE_CLASS = Symbol( true ? `normalizeClass` : 0);
const NORMALIZE_STYLE = Symbol( true ? `normalizeStyle` : 0);
const NORMALIZE_PROPS = Symbol( true ? `normalizeProps` : 0);
const GUARD_REACTIVE_PROPS = Symbol( true ? `guardReactiveProps` : 0);
const TO_HANDLERS = Symbol( true ? `toHandlers` : 0);
const CAMELIZE = Symbol( true ? `camelize` : 0);
const CAPITALIZE = Symbol( true ? `capitalize` : 0);
const TO_HANDLER_KEY = Symbol( true ? `toHandlerKey` : 0);
const SET_BLOCK_TRACKING = Symbol( true ? `setBlockTracking` : 0);
const PUSH_SCOPE_ID = Symbol( true ? `pushScopeId` : 0);
const POP_SCOPE_ID = Symbol( true ? `popScopeId` : 0);
const WITH_CTX = Symbol( true ? `withCtx` : 0);
const UNREF = Symbol( true ? `unref` : 0);
const IS_REF = Symbol( true ? `isRef` : 0);
const WITH_MEMO = Symbol( true ? `withMemo` : 0);
const IS_MEMO_SAME = Symbol( true ? `isMemoSame` : 0);
const helperNameMap = {
  [FRAGMENT]: `Fragment`,
  [TELEPORT]: `Teleport`,
  [SUSPENSE]: `Suspense`,
  [KEEP_ALIVE]: `KeepAlive`,
  [BASE_TRANSITION]: `BaseTransition`,
  [OPEN_BLOCK]: `openBlock`,
  [CREATE_BLOCK]: `createBlock`,
  [CREATE_ELEMENT_BLOCK]: `createElementBlock`,
  [CREATE_VNODE]: `createVNode`,
  [CREATE_ELEMENT_VNODE]: `createElementVNode`,
  [CREATE_COMMENT]: `createCommentVNode`,
  [CREATE_TEXT]: `createTextVNode`,
  [CREATE_STATIC]: `createStaticVNode`,
  [RESOLVE_COMPONENT]: `resolveComponent`,
  [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
  [RESOLVE_DIRECTIVE]: `resolveDirective`,
  [RESOLVE_FILTER]: `resolveFilter`,
  [WITH_DIRECTIVES]: `withDirectives`,
  [RENDER_LIST]: `renderList`,
  [RENDER_SLOT]: `renderSlot`,
  [CREATE_SLOTS]: `createSlots`,
  [TO_DISPLAY_STRING]: `toDisplayString`,
  [MERGE_PROPS]: `mergeProps`,
  [NORMALIZE_CLASS]: `normalizeClass`,
  [NORMALIZE_STYLE]: `normalizeStyle`,
  [NORMALIZE_PROPS]: `normalizeProps`,
  [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
  [TO_HANDLERS]: `toHandlers`,
  [CAMELIZE]: `camelize`,
  [CAPITALIZE]: `capitalize`,
  [TO_HANDLER_KEY]: `toHandlerKey`,
  [SET_BLOCK_TRACKING]: `setBlockTracking`,
  [PUSH_SCOPE_ID]: `pushScopeId`,
  [POP_SCOPE_ID]: `popScopeId`,
  [WITH_CTX]: `withCtx`,
  [UNREF]: `unref`,
  [IS_REF]: `isRef`,
  [WITH_MEMO]: `withMemo`,
  [IS_MEMO_SAME]: `isMemoSame`
};
function registerRuntimeHelpers(helpers) {
  Object.getOwnPropertySymbols(helpers).forEach((s) => {
    helperNameMap[s] = helpers[s];
  });
}

const Namespaces = {
  "HTML": 0,
  "0": "HTML",
  "SVG": 1,
  "1": "SVG",
  "MATH_ML": 2,
  "2": "MATH_ML"
};
const NodeTypes = {
  "ROOT": 0,
  "0": "ROOT",
  "ELEMENT": 1,
  "1": "ELEMENT",
  "TEXT": 2,
  "2": "TEXT",
  "COMMENT": 3,
  "3": "COMMENT",
  "SIMPLE_EXPRESSION": 4,
  "4": "SIMPLE_EXPRESSION",
  "INTERPOLATION": 5,
  "5": "INTERPOLATION",
  "ATTRIBUTE": 6,
  "6": "ATTRIBUTE",
  "DIRECTIVE": 7,
  "7": "DIRECTIVE",
  "COMPOUND_EXPRESSION": 8,
  "8": "COMPOUND_EXPRESSION",
  "IF": 9,
  "9": "IF",
  "IF_BRANCH": 10,
  "10": "IF_BRANCH",
  "FOR": 11,
  "11": "FOR",
  "TEXT_CALL": 12,
  "12": "TEXT_CALL",
  "VNODE_CALL": 13,
  "13": "VNODE_CALL",
  "JS_CALL_EXPRESSION": 14,
  "14": "JS_CALL_EXPRESSION",
  "JS_OBJECT_EXPRESSION": 15,
  "15": "JS_OBJECT_EXPRESSION",
  "JS_PROPERTY": 16,
  "16": "JS_PROPERTY",
  "JS_ARRAY_EXPRESSION": 17,
  "17": "JS_ARRAY_EXPRESSION",
  "JS_FUNCTION_EXPRESSION": 18,
  "18": "JS_FUNCTION_EXPRESSION",
  "JS_CONDITIONAL_EXPRESSION": 19,
  "19": "JS_CONDITIONAL_EXPRESSION",
  "JS_CACHE_EXPRESSION": 20,
  "20": "JS_CACHE_EXPRESSION",
  "JS_BLOCK_STATEMENT": 21,
  "21": "JS_BLOCK_STATEMENT",
  "JS_TEMPLATE_LITERAL": 22,
  "22": "JS_TEMPLATE_LITERAL",
  "JS_IF_STATEMENT": 23,
  "23": "JS_IF_STATEMENT",
  "JS_ASSIGNMENT_EXPRESSION": 24,
  "24": "JS_ASSIGNMENT_EXPRESSION",
  "JS_SEQUENCE_EXPRESSION": 25,
  "25": "JS_SEQUENCE_EXPRESSION",
  "JS_RETURN_STATEMENT": 26,
  "26": "JS_RETURN_STATEMENT"
};
const ElementTypes = {
  "ELEMENT": 0,
  "0": "ELEMENT",
  "COMPONENT": 1,
  "1": "COMPONENT",
  "SLOT": 2,
  "2": "SLOT",
  "TEMPLATE": 3,
  "3": "TEMPLATE"
};
const ConstantTypes = {
  "NOT_CONSTANT": 0,
  "0": "NOT_CONSTANT",
  "CAN_SKIP_PATCH": 1,
  "1": "CAN_SKIP_PATCH",
  "CAN_HOIST": 2,
  "2": "CAN_HOIST",
  "CAN_STRINGIFY": 3,
  "3": "CAN_STRINGIFY"
};
const locStub = {
  start: { line: 1, column: 1, offset: 0 },
  end: { line: 1, column: 1, offset: 0 },
  source: ""
};
function createRoot(children, source = "") {
  return {
    type: 0,
    source,
    children,
    helpers: /* @__PURE__ */ new Set(),
    components: [],
    directives: [],
    hoists: [],
    imports: [],
    cached: 0,
    temps: 0,
    codegenNode: void 0,
    loc: locStub
  };
}
function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
  if (context) {
    if (isBlock) {
      context.helper(OPEN_BLOCK);
      context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
    } else {
      context.helper(getVNodeHelper(context.inSSR, isComponent));
    }
    if (directives) {
      context.helper(WITH_DIRECTIVES);
    }
  }
  return {
    type: 13,
    tag,
    props,
    children,
    patchFlag,
    dynamicProps,
    directives,
    isBlock,
    disableTracking,
    isComponent,
    loc
  };
}
function createArrayExpression(elements, loc = locStub) {
  return {
    type: 17,
    loc,
    elements
  };
}
function createObjectExpression(properties, loc = locStub) {
  return {
    type: 15,
    loc,
    properties
  };
}
function createObjectProperty(key, value) {
  return {
    type: 16,
    loc: locStub,
    key: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(key) ? createSimpleExpression(key, true) : key,
    value
  };
}
function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
  return {
    type: 4,
    loc,
    content,
    isStatic,
    constType: isStatic ? 3 : constType
  };
}
function createInterpolation(content, loc) {
  return {
    type: 5,
    loc,
    content: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(content) ? createSimpleExpression(content, false, loc) : content
  };
}
function createCompoundExpression(children, loc = locStub) {
  return {
    type: 8,
    loc,
    children
  };
}
function createCallExpression(callee, args = [], loc = locStub) {
  return {
    type: 14,
    loc,
    callee,
    arguments: args
  };
}
function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
  return {
    type: 18,
    params,
    returns,
    newline,
    isSlot,
    loc
  };
}
function createConditionalExpression(test, consequent, alternate, newline = true) {
  return {
    type: 19,
    test,
    consequent,
    alternate,
    newline,
    loc: locStub
  };
}
function createCacheExpression(index, value, isVOnce = false) {
  return {
    type: 20,
    index,
    value,
    isVOnce,
    loc: locStub
  };
}
function createBlockStatement(body) {
  return {
    type: 21,
    body,
    loc: locStub
  };
}
function createTemplateLiteral(elements) {
  return {
    type: 22,
    elements,
    loc: locStub
  };
}
function createIfStatement(test, consequent, alternate) {
  return {
    type: 23,
    test,
    consequent,
    alternate,
    loc: locStub
  };
}
function createAssignmentExpression(left, right) {
  return {
    type: 24,
    left,
    right,
    loc: locStub
  };
}
function createSequenceExpression(expressions) {
  return {
    type: 25,
    expressions,
    loc: locStub
  };
}
function createReturnStatement(returns) {
  return {
    type: 26,
    returns,
    loc: locStub
  };
}
function getVNodeHelper(ssr, isComponent) {
  return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
}
function getVNodeBlockHelper(ssr, isComponent) {
  return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
}
function convertToBlock(node, { helper, removeHelper, inSSR }) {
  if (!node.isBlock) {
    node.isBlock = true;
    removeHelper(getVNodeHelper(inSSR, node.isComponent));
    helper(OPEN_BLOCK);
    helper(getVNodeBlockHelper(inSSR, node.isComponent));
  }
}

const defaultDelimitersOpen = new Uint8Array([123, 123]);
const defaultDelimitersClose = new Uint8Array([125, 125]);
function isTagStartChar(c) {
  return c >= 97 && c <= 122 || c >= 65 && c <= 90;
}
function isWhitespace(c) {
  return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
}
function isEndOfTagSection(c) {
  return c === 47 || c === 62 || isWhitespace(c);
}
function toCharCodes(str) {
  const ret = new Uint8Array(str.length);
  for (let i = 0; i < str.length; i++) {
    ret[i] = str.charCodeAt(i);
  }
  return ret;
}
const Sequences = {
  Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
  // CDATA[
  CdataEnd: new Uint8Array([93, 93, 62]),
  // ]]>
  CommentEnd: new Uint8Array([45, 45, 62]),
  // `-->`
  ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
  // `<\/script`
  StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
  // `</style`
  TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
  // `</title`
  TextareaEnd: new Uint8Array([
    60,
    47,
    116,
    101,
    120,
    116,
    97,
    114,
    101,
    97
  ])
  // `</textarea
};
class Tokenizer {
  constructor(stack, cbs) {
    this.stack = stack;
    this.cbs = cbs;
    /** The current state the tokenizer is in. */
    this.state = 1;
    /** The read buffer. */
    this.buffer = "";
    /** The beginning of the section that is currently being read. */
    this.sectionStart = 0;
    /** The index within the buffer that we are currently looking at. */
    this.index = 0;
    /** The start of the last entity. */
    this.entityStart = 0;
    /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
    this.baseState = 1;
    /** For special parsing behavior inside of script and style tags. */
    this.inRCDATA = false;
    /** For disabling RCDATA tags handling */
    this.inXML = false;
    /** For disabling interpolation parsing in v-pre */
    this.inVPre = false;
    /** Record newline positions for fast line / column calculation */
    this.newlines = [];
    this.mode = 0;
    this.delimiterOpen = defaultDelimitersOpen;
    this.delimiterClose = defaultDelimitersClose;
    this.delimiterIndex = -1;
    this.currentSequence = void 0;
    this.sequenceIndex = 0;
  }
  get inSFCRoot() {
    return this.mode === 2 && this.stack.length === 0;
  }
  reset() {
    this.state = 1;
    this.mode = 0;
    this.buffer = "";
    this.sectionStart = 0;
    this.index = 0;
    this.baseState = 1;
    this.inRCDATA = false;
    this.currentSequence = void 0;
    this.newlines.length = 0;
    this.delimiterOpen = defaultDelimitersOpen;
    this.delimiterClose = defaultDelimitersClose;
  }
  /**
   * Generate Position object with line / column information using recorded
   * newline positions. We know the index is always going to be an already
   * processed index, so all the newlines up to this index should have been
   * recorded.
   */
  getPos(index) {
    let line = 1;
    let column = index + 1;
    for (let i = this.newlines.length - 1; i >= 0; i--) {
      const newlineIndex = this.newlines[i];
      if (index > newlineIndex) {
        line = i + 2;
        column = index - newlineIndex;
        break;
      }
    }
    return {
      column,
      line,
      offset: index
    };
  }
  peek() {
    return this.buffer.charCodeAt(this.index + 1);
  }
  stateText(c) {
    if (c === 60) {
      if (this.index > this.sectionStart) {
        this.cbs.ontext(this.sectionStart, this.index);
      }
      this.state = 5;
      this.sectionStart = this.index;
    } else if (!this.inVPre && c === this.delimiterOpen[0]) {
      this.state = 2;
      this.delimiterIndex = 0;
      this.stateInterpolationOpen(c);
    }
  }
  stateInterpolationOpen(c) {
    if (c === this.delimiterOpen[this.delimiterIndex]) {
      if (this.delimiterIndex === this.delimiterOpen.length - 1) {
        const start = this.index + 1 - this.delimiterOpen.length;
        if (start > this.sectionStart) {
          this.cbs.ontext(this.sectionStart, start);
        }
        this.state = 3;
        this.sectionStart = start;
      } else {
        this.delimiterIndex++;
      }
    } else if (this.inRCDATA) {
      this.state = 32;
      this.stateInRCDATA(c);
    } else {
      this.state = 1;
      this.stateText(c);
    }
  }
  stateInterpolation(c) {
    if (c === this.delimiterClose[0]) {
      this.state = 4;
      this.delimiterIndex = 0;
      this.stateInterpolationClose(c);
    }
  }
  stateInterpolationClose(c) {
    if (c === this.delimiterClose[this.delimiterIndex]) {
      if (this.delimiterIndex === this.delimiterClose.length - 1) {
        this.cbs.oninterpolation(this.sectionStart, this.index + 1);
        if (this.inRCDATA) {
          this.state = 32;
        } else {
          this.state = 1;
        }
        this.sectionStart = this.index + 1;
      } else {
        this.delimiterIndex++;
      }
    } else {
      this.state = 3;
      this.stateInterpolation(c);
    }
  }
  stateSpecialStartSequence(c) {
    const isEnd = this.sequenceIndex === this.currentSequence.length;
    const isMatch = isEnd ? (
      // If we are at the end of the sequence, make sure the tag name has ended
      isEndOfTagSection(c)
    ) : (
      // Otherwise, do a case-insensitive comparison
      (c | 32) === this.currentSequence[this.sequenceIndex]
    );
    if (!isMatch) {
      this.inRCDATA = false;
    } else if (!isEnd) {
      this.sequenceIndex++;
      return;
    }
    this.sequenceIndex = 0;
    this.state = 6;
    this.stateInTagName(c);
  }
  /** Look for an end tag. For <title> and <textarea>, also decode entities. */
  stateInRCDATA(c) {
    if (this.sequenceIndex === this.currentSequence.length) {
      if (c === 62 || isWhitespace(c)) {
        const endOfText = this.index - this.currentSequence.length;
        if (this.sectionStart < endOfText) {
          const actualIndex = this.index;
          this.index = endOfText;
          this.cbs.ontext(this.sectionStart, endOfText);
          this.index = actualIndex;
        }
        this.sectionStart = endOfText + 2;
        this.stateInClosingTagName(c);
        this.inRCDATA = false;
        return;
      }
      this.sequenceIndex = 0;
    }
    if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
      this.sequenceIndex += 1;
    } else if (this.sequenceIndex === 0) {
      if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
        if (c === this.delimiterOpen[0]) {
          this.state = 2;
          this.delimiterIndex = 0;
          this.stateInterpolationOpen(c);
        }
      } else if (this.fastForwardTo(60)) {
        this.sequenceIndex = 1;
      }
    } else {
      this.sequenceIndex = Number(c === 60);
    }
  }
  stateCDATASequence(c) {
    if (c === Sequences.Cdata[this.sequenceIndex]) {
      if (++this.sequenceIndex === Sequences.Cdata.length) {
        this.state = 28;
        this.currentSequence = Sequences.CdataEnd;
        this.sequenceIndex = 0;
        this.sectionStart = this.index + 1;
      }
    } else {
      this.sequenceIndex = 0;
      this.state = 23;
      this.stateInDeclaration(c);
    }
  }
  /**
   * When we wait for one specific character, we can speed things up
   * by skipping through the buffer until we find it.
   *
   * @returns Whether the character was found.
   */
  fastForwardTo(c) {
    while (++this.index < this.buffer.length) {
      const cc = this.buffer.charCodeAt(this.index);
      if (cc === 10) {
        this.newlines.push(this.index);
      }
      if (cc === c) {
        return true;
      }
    }
    this.index = this.buffer.length - 1;
    return false;
  }
  /**
   * Comments and CDATA end with `-->` and `]]>`.
   *
   * Their common qualities are:
   * - Their end sequences have a distinct character they start with.
   * - That character is then repeated, so we have to check multiple repeats.
   * - All characters but the start character of the sequence can be skipped.
   */
  stateInCommentLike(c) {
    if (c === this.currentSequence[this.sequenceIndex]) {
      if (++this.sequenceIndex === this.currentSequence.length) {
        if (this.currentSequence === Sequences.CdataEnd) {
          this.cbs.oncdata(this.sectionStart, this.index - 2);
        } else {
          this.cbs.oncomment(this.sectionStart, this.index - 2);
        }
        this.sequenceIndex = 0;
        this.sectionStart = this.index + 1;
        this.state = 1;
      }
    } else if (this.sequenceIndex === 0) {
      if (this.fastForwardTo(this.currentSequence[0])) {
        this.sequenceIndex = 1;
      }
    } else if (c !== this.currentSequence[this.sequenceIndex - 1]) {
      this.sequenceIndex = 0;
    }
  }
  startSpecial(sequence, offset) {
    this.enterRCDATA(sequence, offset);
    this.state = 31;
  }
  enterRCDATA(sequence, offset) {
    this.inRCDATA = true;
    this.currentSequence = sequence;
    this.sequenceIndex = offset;
  }
  stateBeforeTagName(c) {
    if (c === 33) {
      this.state = 22;
      this.sectionStart = this.index + 1;
    } else if (c === 63) {
      this.state = 24;
      this.sectionStart = this.index + 1;
    } else if (isTagStartChar(c)) {
      this.sectionStart = this.index;
      if (this.mode === 0) {
        this.state = 6;
      } else if (this.inSFCRoot) {
        this.state = 34;
      } else if (!this.inXML) {
        if (c === 116) {
          this.state = 30;
        } else {
          this.state = c === 115 ? 29 : 6;
        }
      } else {
        this.state = 6;
      }
    } else if (c === 47) {
      this.state = 8;
    } else {
      this.state = 1;
      this.stateText(c);
    }
  }
  stateInTagName(c) {
    if (isEndOfTagSection(c)) {
      this.handleTagName(c);
    }
  }
  stateInSFCRootTagName(c) {
    if (isEndOfTagSection(c)) {
      const tag = this.buffer.slice(this.sectionStart, this.index);
      if (tag !== "template") {
        this.enterRCDATA(toCharCodes(`</` + tag), 0);
      }
      this.handleTagName(c);
    }
  }
  handleTagName(c) {
    this.cbs.onopentagname(this.sectionStart, this.index);
    this.sectionStart = -1;
    this.state = 11;
    this.stateBeforeAttrName(c);
  }
  stateBeforeClosingTagName(c) {
    if (isWhitespace(c)) ; else if (c === 62) {
      if (true) {
        this.cbs.onerr(14, this.index);
      }
      this.state = 1;
      this.sectionStart = this.index + 1;
    } else {
      this.state = isTagStartChar(c) ? 9 : 27;
      this.sectionStart = this.index;
    }
  }
  stateInClosingTagName(c) {
    if (c === 62 || isWhitespace(c)) {
      this.cbs.onclosetag(this.sectionStart, this.index);
      this.sectionStart = -1;
      this.state = 10;
      this.stateAfterClosingTagName(c);
    }
  }
  stateAfterClosingTagName(c) {
    if (c === 62) {
      this.state = 1;
      this.sectionStart = this.index + 1;
    }
  }
  stateBeforeAttrName(c) {
    if (c === 62) {
      this.cbs.onopentagend(this.index);
      if (this.inRCDATA) {
        this.state = 32;
      } else {
        this.state = 1;
      }
      this.sectionStart = this.index + 1;
    } else if (c === 47) {
      this.state = 7;
      if (( true) && this.peek() !== 62) {
        this.cbs.onerr(22, this.index);
      }
    } else if (c === 60 && this.peek() === 47) {
      this.cbs.onopentagend(this.index);
      this.state = 5;
      this.sectionStart = this.index;
    } else if (!isWhitespace(c)) {
      if (( true) && c === 61) {
        this.cbs.onerr(
          19,
          this.index
        );
      }
      this.handleAttrStart(c);
    }
  }
  handleAttrStart(c) {
    if (c === 118 && this.peek() === 45) {
      this.state = 13;
      this.sectionStart = this.index;
    } else if (c === 46 || c === 58 || c === 64 || c === 35) {
      this.cbs.ondirname(this.index, this.index + 1);
      this.state = 14;
      this.sectionStart = this.index + 1;
    } else {
      this.state = 12;
      this.sectionStart = this.index;
    }
  }
  stateInSelfClosingTag(c) {
    if (c === 62) {
      this.cbs.onselfclosingtag(this.index);
      this.state = 1;
      this.sectionStart = this.index + 1;
      this.inRCDATA = false;
    } else if (!isWhitespace(c)) {
      this.state = 11;
      this.stateBeforeAttrName(c);
    }
  }
  stateInAttrName(c) {
    if (c === 61 || isEndOfTagSection(c)) {
      this.cbs.onattribname(this.sectionStart, this.index);
      this.handleAttrNameEnd(c);
    } else if (( true) && (c === 34 || c === 39 || c === 60)) {
      this.cbs.onerr(
        17,
        this.index
      );
    }
  }
  stateInDirName(c) {
    if (c === 61 || isEndOfTagSection(c)) {
      this.cbs.ondirname(this.sectionStart, this.index);
      this.handleAttrNameEnd(c);
    } else if (c === 58) {
      this.cbs.ondirname(this.sectionStart, this.index);
      this.state = 14;
      this.sectionStart = this.index + 1;
    } else if (c === 46) {
      this.cbs.ondirname(this.sectionStart, this.index);
      this.state = 16;
      this.sectionStart = this.index + 1;
    }
  }
  stateInDirArg(c) {
    if (c === 61 || isEndOfTagSection(c)) {
      this.cbs.ondirarg(this.sectionStart, this.index);
      this.handleAttrNameEnd(c);
    } else if (c === 91) {
      this.state = 15;
    } else if (c === 46) {
      this.cbs.ondirarg(this.sectionStart, this.index);
      this.state = 16;
      this.sectionStart = this.index + 1;
    }
  }
  stateInDynamicDirArg(c) {
    if (c === 93) {
      this.state = 14;
    } else if (c === 61 || isEndOfTagSection(c)) {
      this.cbs.ondirarg(this.sectionStart, this.index + 1);
      this.handleAttrNameEnd(c);
      if (true) {
        this.cbs.onerr(
          27,
          this.index
        );
      }
    }
  }
  stateInDirModifier(c) {
    if (c === 61 || isEndOfTagSection(c)) {
      this.cbs.ondirmodifier(this.sectionStart, this.index);
      this.handleAttrNameEnd(c);
    } else if (c === 46) {
      this.cbs.ondirmodifier(this.sectionStart, this.index);
      this.sectionStart = this.index + 1;
    }
  }
  handleAttrNameEnd(c) {
    this.sectionStart = this.index;
    this.state = 17;
    this.cbs.onattribnameend(this.index);
    this.stateAfterAttrName(c);
  }
  stateAfterAttrName(c) {
    if (c === 61) {
      this.state = 18;
    } else if (c === 47 || c === 62) {
      this.cbs.onattribend(0, this.sectionStart);
      this.sectionStart = -1;
      this.state = 11;
      this.stateBeforeAttrName(c);
    } else if (!isWhitespace(c)) {
      this.cbs.onattribend(0, this.sectionStart);
      this.handleAttrStart(c);
    }
  }
  stateBeforeAttrValue(c) {
    if (c === 34) {
      this.state = 19;
      this.sectionStart = this.index + 1;
    } else if (c === 39) {
      this.state = 20;
      this.sectionStart = this.index + 1;
    } else if (!isWhitespace(c)) {
      this.sectionStart = this.index;
      this.state = 21;
      this.stateInAttrValueNoQuotes(c);
    }
  }
  handleInAttrValue(c, quote) {
    if (c === quote || this.fastForwardTo(quote)) {
      this.cbs.onattribdata(this.sectionStart, this.index);
      this.sectionStart = -1;
      this.cbs.onattribend(
        quote === 34 ? 3 : 2,
        this.index + 1
      );
      this.state = 11;
    }
  }
  stateInAttrValueDoubleQuotes(c) {
    this.handleInAttrValue(c, 34);
  }
  stateInAttrValueSingleQuotes(c) {
    this.handleInAttrValue(c, 39);
  }
  stateInAttrValueNoQuotes(c) {
    if (isWhitespace(c) || c === 62) {
      this.cbs.onattribdata(this.sectionStart, this.index);
      this.sectionStart = -1;
      this.cbs.onattribend(1, this.index);
      this.state = 11;
      this.stateBeforeAttrName(c);
    } else if (( true) && c === 34 || c === 39 || c === 60 || c === 61 || c === 96) {
      this.cbs.onerr(
        18,
        this.index
      );
    } else ;
  }
  stateBeforeDeclaration(c) {
    if (c === 91) {
      this.state = 26;
      this.sequenceIndex = 0;
    } else {
      this.state = c === 45 ? 25 : 23;
    }
  }
  stateInDeclaration(c) {
    if (c === 62 || this.fastForwardTo(62)) {
      this.state = 1;
      this.sectionStart = this.index + 1;
    }
  }
  stateInProcessingInstruction(c) {
    if (c === 62 || this.fastForwardTo(62)) {
      this.cbs.onprocessinginstruction(this.sectionStart, this.index);
      this.state = 1;
      this.sectionStart = this.index + 1;
    }
  }
  stateBeforeComment(c) {
    if (c === 45) {
      this.state = 28;
      this.currentSequence = Sequences.CommentEnd;
      this.sequenceIndex = 2;
      this.sectionStart = this.index + 1;
    } else {
      this.state = 23;
    }
  }
  stateInSpecialComment(c) {
    if (c === 62 || this.fastForwardTo(62)) {
      this.cbs.oncomment(this.sectionStart, this.index);
      this.state = 1;
      this.sectionStart = this.index + 1;
    }
  }
  stateBeforeSpecialS(c) {
    if (c === Sequences.ScriptEnd[3]) {
      this.startSpecial(Sequences.ScriptEnd, 4);
    } else if (c === Sequences.StyleEnd[3]) {
      this.startSpecial(Sequences.StyleEnd, 4);
    } else {
      this.state = 6;
      this.stateInTagName(c);
    }
  }
  stateBeforeSpecialT(c) {
    if (c === Sequences.TitleEnd[3]) {
      this.startSpecial(Sequences.TitleEnd, 4);
    } else if (c === Sequences.TextareaEnd[3]) {
      this.startSpecial(Sequences.TextareaEnd, 4);
    } else {
      this.state = 6;
      this.stateInTagName(c);
    }
  }
  startEntity() {
  }
  stateInEntity() {
  }
  /**
   * Iterates through the buffer, calling the function corresponding to the current state.
   *
   * States that are more likely to be hit are higher up, as a performance improvement.
   */
  parse(input) {
    this.buffer = input;
    while (this.index < this.buffer.length) {
      const c = this.buffer.charCodeAt(this.index);
      if (c === 10) {
        this.newlines.push(this.index);
      }
      switch (this.state) {
        case 1: {
          this.stateText(c);
          break;
        }
        case 2: {
          this.stateInterpolationOpen(c);
          break;
        }
        case 3: {
          this.stateInterpolation(c);
          break;
        }
        case 4: {
          this.stateInterpolationClose(c);
          break;
        }
        case 31: {
          this.stateSpecialStartSequence(c);
          break;
        }
        case 32: {
          this.stateInRCDATA(c);
          break;
        }
        case 26: {
          this.stateCDATASequence(c);
          break;
        }
        case 19: {
          this.stateInAttrValueDoubleQuotes(c);
          break;
        }
        case 12: {
          this.stateInAttrName(c);
          break;
        }
        case 13: {
          this.stateInDirName(c);
          break;
        }
        case 14: {
          this.stateInDirArg(c);
          break;
        }
        case 15: {
          this.stateInDynamicDirArg(c);
          break;
        }
        case 16: {
          this.stateInDirModifier(c);
          break;
        }
        case 28: {
          this.stateInCommentLike(c);
          break;
        }
        case 27: {
          this.stateInSpecialComment(c);
          break;
        }
        case 11: {
          this.stateBeforeAttrName(c);
          break;
        }
        case 6: {
          this.stateInTagName(c);
          break;
        }
        case 34: {
          this.stateInSFCRootTagName(c);
          break;
        }
        case 9: {
          this.stateInClosingTagName(c);
          break;
        }
        case 5: {
          this.stateBeforeTagName(c);
          break;
        }
        case 17: {
          this.stateAfterAttrName(c);
          break;
        }
        case 20: {
          this.stateInAttrValueSingleQuotes(c);
          break;
        }
        case 18: {
          this.stateBeforeAttrValue(c);
          break;
        }
        case 8: {
          this.stateBeforeClosingTagName(c);
          break;
        }
        case 10: {
          this.stateAfterClosingTagName(c);
          break;
        }
        case 29: {
          this.stateBeforeSpecialS(c);
          break;
        }
        case 30: {
          this.stateBeforeSpecialT(c);
          break;
        }
        case 21: {
          this.stateInAttrValueNoQuotes(c);
          break;
        }
        case 7: {
          this.stateInSelfClosingTag(c);
          break;
        }
        case 23: {
          this.stateInDeclaration(c);
          break;
        }
        case 22: {
          this.stateBeforeDeclaration(c);
          break;
        }
        case 25: {
          this.stateBeforeComment(c);
          break;
        }
        case 24: {
          this.stateInProcessingInstruction(c);
          break;
        }
        case 33: {
          this.stateInEntity();
          break;
        }
      }
      this.index++;
    }
    this.cleanup();
    this.finish();
  }
  /**
   * Remove data that has already been consumed from the buffer.
   */
  cleanup() {
    if (this.sectionStart !== this.index) {
      if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
        this.cbs.ontext(this.sectionStart, this.index);
        this.sectionStart = this.index;
      } else if (this.state === 19 || this.state === 20 || this.state === 21) {
        this.cbs.onattribdata(this.sectionStart, this.index);
        this.sectionStart = this.index;
      }
    }
  }
  finish() {
    this.handleTrailingData();
    this.cbs.onend();
  }
  /** Handle any trailing data. */
  handleTrailingData() {
    const endIndex = this.buffer.length;
    if (this.sectionStart >= endIndex) {
      return;
    }
    if (this.state === 28) {
      if (this.currentSequence === Sequences.CdataEnd) {
        this.cbs.oncdata(this.sectionStart, endIndex);
      } else {
        this.cbs.oncomment(this.sectionStart, endIndex);
      }
    } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else {
      this.cbs.ontext(this.sectionStart, endIndex);
    }
  }
  emitCodePoint(cp, consumed) {
  }
}

const CompilerDeprecationTypes = {
  "COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
  "COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
  "COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
  "COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
  "COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
  "COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
  "COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
  "COMPILER_FILTERS": "COMPILER_FILTERS"
};
const deprecationData = {
  ["COMPILER_IS_ON_ELEMENT"]: {
    message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
    link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
  },
  ["COMPILER_V_BIND_SYNC"]: {
    message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
    link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
  },
  ["COMPILER_V_BIND_OBJECT_ORDER"]: {
    message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
    link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
  },
  ["COMPILER_V_ON_NATIVE"]: {
    message: `.native modifier for v-on has been removed as is no longer necessary.`,
    link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
  },
  ["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
    message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
    link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
  },
  ["COMPILER_NATIVE_TEMPLATE"]: {
    message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`
  },
  ["COMPILER_INLINE_TEMPLATE"]: {
    message: `"inline-template" has been removed in Vue 3.`,
    link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
  },
  ["COMPILER_FILTERS"]: {
    message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
    link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
  }
};
function getCompatValue(key, { compatConfig }) {
  const value = compatConfig && compatConfig[key];
  if (key === "MODE") {
    return value || 3;
  } else {
    return value;
  }
}
function isCompatEnabled(key, context) {
  const mode = getCompatValue("MODE", context);
  const value = getCompatValue(key, context);
  return mode === 3 ? value === true : value !== false;
}
function checkCompatEnabled(key, context, loc, ...args) {
  const enabled = isCompatEnabled(key, context);
  if ( true && enabled) {
    warnDeprecation(key, context, loc, ...args);
  }
  return enabled;
}
function warnDeprecation(key, context, loc, ...args) {
  const val = getCompatValue(key, context);
  if (val === "suppress-warning") {
    return;
  }
  const { message, link } = deprecationData[key];
  const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
  Details: ${link}` : ``}`;
  const err = new SyntaxError(msg);
  err.code = key;
  if (loc) err.loc = loc;
  context.onWarn(err);
}

function defaultOnError(error) {
  throw error;
}
function defaultOnWarn(msg) {
   true && console.warn(`[Vue warn] ${msg.message}`);
}
function createCompilerError(code, loc, messages, additionalMessage) {
  const msg =  true ? (messages || errorMessages)[code] + (additionalMessage || ``) : 0;
  const error = new SyntaxError(String(msg));
  error.code = code;
  error.loc = loc;
  return error;
}
const ErrorCodes = {
  "ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
  "0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
  "CDATA_IN_HTML_CONTENT": 1,
  "1": "CDATA_IN_HTML_CONTENT",
  "DUPLICATE_ATTRIBUTE": 2,
  "2": "DUPLICATE_ATTRIBUTE",
  "END_TAG_WITH_ATTRIBUTES": 3,
  "3": "END_TAG_WITH_ATTRIBUTES",
  "END_TAG_WITH_TRAILING_SOLIDUS": 4,
  "4": "END_TAG_WITH_TRAILING_SOLIDUS",
  "EOF_BEFORE_TAG_NAME": 5,
  "5": "EOF_BEFORE_TAG_NAME",
  "EOF_IN_CDATA": 6,
  "6": "EOF_IN_CDATA",
  "EOF_IN_COMMENT": 7,
  "7": "EOF_IN_COMMENT",
  "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
  "8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
  "EOF_IN_TAG": 9,
  "9": "EOF_IN_TAG",
  "INCORRECTLY_CLOSED_COMMENT": 10,
  "10": "INCORRECTLY_CLOSED_COMMENT",
  "INCORRECTLY_OPENED_COMMENT": 11,
  "11": "INCORRECTLY_OPENED_COMMENT",
  "INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
  "12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
  "MISSING_ATTRIBUTE_VALUE": 13,
  "13": "MISSING_ATTRIBUTE_VALUE",
  "MISSING_END_TAG_NAME": 14,
  "14": "MISSING_END_TAG_NAME",
  "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
  "15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
  "NESTED_COMMENT": 16,
  "16": "NESTED_COMMENT",
  "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
  "17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
  "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
  "18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
  "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
  "19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
  "UNEXPECTED_NULL_CHARACTER": 20,
  "20": "UNEXPECTED_NULL_CHARACTER",
  "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
  "21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
  "UNEXPECTED_SOLIDUS_IN_TAG": 22,
  "22": "UNEXPECTED_SOLIDUS_IN_TAG",
  "X_INVALID_END_TAG": 23,
  "23": "X_INVALID_END_TAG",
  "X_MISSING_END_TAG": 24,
  "24": "X_MISSING_END_TAG",
  "X_MISSING_INTERPOLATION_END": 25,
  "25": "X_MISSING_INTERPOLATION_END",
  "X_MISSING_DIRECTIVE_NAME": 26,
  "26": "X_MISSING_DIRECTIVE_NAME",
  "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
  "27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
  "X_V_IF_NO_EXPRESSION": 28,
  "28": "X_V_IF_NO_EXPRESSION",
  "X_V_IF_SAME_KEY": 29,
  "29": "X_V_IF_SAME_KEY",
  "X_V_ELSE_NO_ADJACENT_IF": 30,
  "30": "X_V_ELSE_NO_ADJACENT_IF",
  "X_V_FOR_NO_EXPRESSION": 31,
  "31": "X_V_FOR_NO_EXPRESSION",
  "X_V_FOR_MALFORMED_EXPRESSION": 32,
  "32": "X_V_FOR_MALFORMED_EXPRESSION",
  "X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
  "33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
  "X_V_BIND_NO_EXPRESSION": 34,
  "34": "X_V_BIND_NO_EXPRESSION",
  "X_V_ON_NO_EXPRESSION": 35,
  "35": "X_V_ON_NO_EXPRESSION",
  "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
  "36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
  "X_V_SLOT_MIXED_SLOT_USAGE": 37,
  "37": "X_V_SLOT_MIXED_SLOT_USAGE",
  "X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
  "38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
  "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
  "39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
  "X_V_SLOT_MISPLACED": 40,
  "40": "X_V_SLOT_MISPLACED",
  "X_V_MODEL_NO_EXPRESSION": 41,
  "41": "X_V_MODEL_NO_EXPRESSION",
  "X_V_MODEL_MALFORMED_EXPRESSION": 42,
  "42": "X_V_MODEL_MALFORMED_EXPRESSION",
  "X_V_MODEL_ON_SCOPE_VARIABLE": 43,
  "43": "X_V_MODEL_ON_SCOPE_VARIABLE",
  "X_V_MODEL_ON_PROPS": 44,
  "44": "X_V_MODEL_ON_PROPS",
  "X_INVALID_EXPRESSION": 45,
  "45": "X_INVALID_EXPRESSION",
  "X_KEEP_ALIVE_INVALID_CHILDREN": 46,
  "46": "X_KEEP_ALIVE_INVALID_CHILDREN",
  "X_PREFIX_ID_NOT_SUPPORTED": 47,
  "47": "X_PREFIX_ID_NOT_SUPPORTED",
  "X_MODULE_MODE_NOT_SUPPORTED": 48,
  "48": "X_MODULE_MODE_NOT_SUPPORTED",
  "X_CACHE_HANDLER_NOT_SUPPORTED": 49,
  "49": "X_CACHE_HANDLER_NOT_SUPPORTED",
  "X_SCOPE_ID_NOT_SUPPORTED": 50,
  "50": "X_SCOPE_ID_NOT_SUPPORTED",
  "X_VNODE_HOOKS": 51,
  "51": "X_VNODE_HOOKS",
  "X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52,
  "52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
  "__EXTEND_POINT__": 53,
  "53": "__EXTEND_POINT__"
};
const errorMessages = {
  // parse errors
  [0]: "Illegal comment.",
  [1]: "CDATA section is allowed only in XML context.",
  [2]: "Duplicate attribute.",
  [3]: "End tag cannot have attributes.",
  [4]: "Illegal '/' in tags.",
  [5]: "Unexpected EOF in tag.",
  [6]: "Unexpected EOF in CDATA section.",
  [7]: "Unexpected EOF in comment.",
  [8]: "Unexpected EOF in script.",
  [9]: "Unexpected EOF in tag.",
  [10]: "Incorrectly closed comment.",
  [11]: "Incorrectly opened comment.",
  [12]: "Illegal tag name. Use '&lt;' to print '<'.",
  [13]: "Attribute value was expected.",
  [14]: "End tag name was expected.",
  [15]: "Whitespace was expected.",
  [16]: "Unexpected '<!--' in comment.",
  [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
  [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
  [19]: "Attribute name cannot start with '='.",
  [21]: "'<?' is allowed only in XML context.",
  [20]: `Unexpected null character.`,
  [22]: "Illegal '/' in tags.",
  // Vue-specific parse errors
  [23]: "Invalid end tag.",
  [24]: "Element is missing end tag.",
  [25]: "Interpolation end sign was not found.",
  [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
  [26]: "Legal directive name was expected.",
  // transform errors
  [28]: `v-if/v-else-if is missing expression.`,
  [29]: `v-if/else branches must use unique keys.`,
  [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
  [31]: `v-for is missing expression.`,
  [32]: `v-for has invalid expression.`,
  [33]: `<template v-for> key should be placed on the <template> tag.`,
  [34]: `v-bind is missing expression.`,
  [52]: `v-bind with same-name shorthand only allows static argument.`,
  [35]: `v-on is missing expression.`,
  [36]: `Unexpected custom directive on <slot> outlet.`,
  [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
  [38]: `Duplicate slot names found. `,
  [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
  [40]: `v-slot can only be used on components or <template> tags.`,
  [41]: `v-model is missing expression.`,
  [42]: `v-model value must be a valid JavaScript member expression.`,
  [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
  [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
  [45]: `Error parsing JavaScript expression: `,
  [46]: `<KeepAlive> expects exactly one child component.`,
  [51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,
  // generic errors
  [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
  [48]: `ES module mode is not supported in this build of compiler.`,
  [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
  [50]: `"scopeId" option is only supported in module mode.`,
  // just to fulfill types
  [53]: ``
};

function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
  {
    return;
  }
}
function isReferencedIdentifier(id, parent, parentStack) {
  {
    return false;
  }
}
function isInDestructureAssignment(parent, parentStack) {
  if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
    let i = parentStack.length;
    while (i--) {
      const p = parentStack[i];
      if (p.type === "AssignmentExpression") {
        return true;
      } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
        break;
      }
    }
  }
  return false;
}
function isInNewExpression(parentStack) {
  let i = parentStack.length;
  while (i--) {
    const p = parentStack[i];
    if (p.type === "NewExpression") {
      return true;
    } else if (p.type !== "MemberExpression") {
      break;
    }
  }
  return false;
}
function walkFunctionParams(node, onIdent) {
  for (const p of node.params) {
    for (const id of extractIdentifiers(p)) {
      onIdent(id);
    }
  }
}
function walkBlockDeclarations(block, onIdent) {
  for (const stmt of block.body) {
    if (stmt.type === "VariableDeclaration") {
      if (stmt.declare) continue;
      for (const decl of stmt.declarations) {
        for (const id of extractIdentifiers(decl.id)) {
          onIdent(id);
        }
      }
    } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
      if (stmt.declare || !stmt.id) continue;
      onIdent(stmt.id);
    } else if (isForStatement(stmt)) {
      walkForStatement(stmt, true, onIdent);
    }
  }
}
function isForStatement(stmt) {
  return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
}
function walkForStatement(stmt, isVar, onIdent) {
  const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
  if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) {
    for (const decl of variable.declarations) {
      for (const id of extractIdentifiers(decl.id)) {
        onIdent(id);
      }
    }
  }
}
function extractIdentifiers(param, nodes = []) {
  switch (param.type) {
    case "Identifier":
      nodes.push(param);
      break;
    case "MemberExpression":
      let object = param;
      while (object.type === "MemberExpression") {
        object = object.object;
      }
      nodes.push(object);
      break;
    case "ObjectPattern":
      for (const prop of param.properties) {
        if (prop.type === "RestElement") {
          extractIdentifiers(prop.argument, nodes);
        } else {
          extractIdentifiers(prop.value, nodes);
        }
      }
      break;
    case "ArrayPattern":
      param.elements.forEach((element) => {
        if (element) extractIdentifiers(element, nodes);
      });
      break;
    case "RestElement":
      extractIdentifiers(param.argument, nodes);
      break;
    case "AssignmentPattern":
      extractIdentifiers(param.left, nodes);
      break;
  }
  return nodes;
}
const isFunctionType = (node) => {
  return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
};
const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
const TS_NODE_TYPES = [
  "TSAsExpression",
  // foo as number
  "TSTypeAssertion",
  // (<number>foo)
  "TSNonNullExpression",
  // foo!
  "TSInstantiationExpression",
  // foo<string>
  "TSSatisfiesExpression"
  // foo satisfies T
];
function unwrapTSNode(node) {
  if (TS_NODE_TYPES.includes(node.type)) {
    return unwrapTSNode(node.expression);
  } else {
    return node;
  }
}

const isStaticExp = (p) => p.type === 4 && p.isStatic;
function isCoreComponent(tag) {
  switch (tag) {
    case "Teleport":
    case "teleport":
      return TELEPORT;
    case "Suspense":
    case "suspense":
      return SUSPENSE;
    case "KeepAlive":
    case "keep-alive":
      return KEEP_ALIVE;
    case "BaseTransition":
    case "base-transition":
      return BASE_TRANSITION;
  }
}
const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
const isMemberExpressionBrowser = (exp) => {
  const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
  let state = 0 /* inMemberExp */;
  let stateStack = [];
  let currentOpenBracketCount = 0;
  let currentOpenParensCount = 0;
  let currentStringType = null;
  for (let i = 0; i < path.length; i++) {
    const char = path.charAt(i);
    switch (state) {
      case 0 /* inMemberExp */:
        if (char === "[") {
          stateStack.push(state);
          state = 1 /* inBrackets */;
          currentOpenBracketCount++;
        } else if (char === "(") {
          stateStack.push(state);
          state = 2 /* inParens */;
          currentOpenParensCount++;
        } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
          return false;
        }
        break;
      case 1 /* inBrackets */:
        if (char === `'` || char === `"` || char === "`") {
          stateStack.push(state);
          state = 3 /* inString */;
          currentStringType = char;
        } else if (char === `[`) {
          currentOpenBracketCount++;
        } else if (char === `]`) {
          if (!--currentOpenBracketCount) {
            state = stateStack.pop();
          }
        }
        break;
      case 2 /* inParens */:
        if (char === `'` || char === `"` || char === "`") {
          stateStack.push(state);
          state = 3 /* inString */;
          currentStringType = char;
        } else if (char === `(`) {
          currentOpenParensCount++;
        } else if (char === `)`) {
          if (i === path.length - 1) {
            return false;
          }
          if (!--currentOpenParensCount) {
            state = stateStack.pop();
          }
        }
        break;
      case 3 /* inString */:
        if (char === currentStringType) {
          state = stateStack.pop();
          currentStringType = null;
        }
        break;
    }
  }
  return !currentOpenBracketCount && !currentOpenParensCount;
};
const isMemberExpressionNode = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP ;
const isMemberExpression = isMemberExpressionBrowser ;
const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
const isFnExpressionNode = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP ;
const isFnExpression = isFnExpressionBrowser ;
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
  return advancePositionWithMutation(
    {
      offset: pos.offset,
      line: pos.line,
      column: pos.column
    },
    source,
    numberOfCharacters
  );
}
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
  let linesCount = 0;
  let lastNewLinePos = -1;
  for (let i = 0; i < numberOfCharacters; i++) {
    if (source.charCodeAt(i) === 10) {
      linesCount++;
      lastNewLinePos = i;
    }
  }
  pos.offset += numberOfCharacters;
  pos.line += linesCount;
  pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
  return pos;
}
function assert(condition, msg) {
  if (!condition) {
    throw new Error(msg || `unexpected compiler condition`);
  }
}
function findDir(node, name, allowEmpty = false) {
  for (let i = 0; i < node.props.length; i++) {
    const p = node.props[i];
    if (p.type === 7 && (allowEmpty || p.exp) && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(name) ? p.name === name : name.test(p.name))) {
      return p;
    }
  }
}
function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
  for (let i = 0; i < node.props.length; i++) {
    const p = node.props[i];
    if (p.type === 6) {
      if (dynamicOnly) continue;
      if (p.name === name && (p.value || allowEmpty)) {
        return p;
      }
    } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
      return p;
    }
  }
}
function isStaticArgOf(arg, name) {
  return !!(arg && isStaticExp(arg) && arg.content === name);
}
function hasDynamicKeyVBind(node) {
  return node.props.some(
    (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
    p.arg.type !== 4 || // v-bind:[_ctx.foo]
    !p.arg.isStatic)
    // v-bind:[foo]
  );
}
function isText$1(node) {
  return node.type === 5 || node.type === 2;
}
function isVSlot(p) {
  return p.type === 7 && p.name === "slot";
}
function isTemplateNode(node) {
  return node.type === 1 && node.tagType === 3;
}
function isSlotOutlet(node) {
  return node.type === 1 && node.tagType === 2;
}
const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
function getUnnormalizedProps(props, callPath = []) {
  if (props && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props) && props.type === 14) {
    const callee = props.callee;
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(callee) && propsHelperSet.has(callee)) {
      return getUnnormalizedProps(
        props.arguments[0],
        callPath.concat(props)
      );
    }
  }
  return [props, callPath];
}
function injectProp(node, prop, context) {
  let propsWithInjection;
  let props = node.type === 13 ? node.props : node.arguments[2];
  let callPath = [];
  let parentCall;
  if (props && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props) && props.type === 14) {
    const ret = getUnnormalizedProps(props);
    props = ret[0];
    callPath = ret[1];
    parentCall = callPath[callPath.length - 1];
  }
  if (props == null || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(props)) {
    propsWithInjection = createObjectExpression([prop]);
  } else if (props.type === 14) {
    const first = props.arguments[0];
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(first) && first.type === 15) {
      if (!hasProp(prop, first)) {
        first.properties.unshift(prop);
      }
    } else {
      if (props.callee === TO_HANDLERS) {
        propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
          createObjectExpression([prop]),
          props
        ]);
      } else {
        props.arguments.unshift(createObjectExpression([prop]));
      }
    }
    !propsWithInjection && (propsWithInjection = props);
  } else if (props.type === 15) {
    if (!hasProp(prop, props)) {
      props.properties.unshift(prop);
    }
    propsWithInjection = props;
  } else {
    propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
      createObjectExpression([prop]),
      props
    ]);
    if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
      parentCall = callPath[callPath.length - 2];
    }
  }
  if (node.type === 13) {
    if (parentCall) {
      parentCall.arguments[0] = propsWithInjection;
    } else {
      node.props = propsWithInjection;
    }
  } else {
    if (parentCall) {
      parentCall.arguments[0] = propsWithInjection;
    } else {
      node.arguments[2] = propsWithInjection;
    }
  }
}
function hasProp(prop, props) {
  let result = false;
  if (prop.key.type === 4) {
    const propKeyName = prop.key.content;
    result = props.properties.some(
      (p) => p.key.type === 4 && p.key.content === propKeyName
    );
  }
  return result;
}
function toValidAssetId(name, type) {
  return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
    return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
  })}`;
}
function hasScopeRef(node, ids) {
  if (!node || Object.keys(ids).length === 0) {
    return false;
  }
  switch (node.type) {
    case 1:
      for (let i = 0; i < node.props.length; i++) {
        const p = node.props[i];
        if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {
          return true;
        }
      }
      return node.children.some((c) => hasScopeRef(c, ids));
    case 11:
      if (hasScopeRef(node.source, ids)) {
        return true;
      }
      return node.children.some((c) => hasScopeRef(c, ids));
    case 9:
      return node.branches.some((b) => hasScopeRef(b, ids));
    case 10:
      if (hasScopeRef(node.condition, ids)) {
        return true;
      }
      return node.children.some((c) => hasScopeRef(c, ids));
    case 4:
      return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
    case 8:
      return node.children.some((c) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(c) && hasScopeRef(c, ids));
    case 5:
    case 12:
      return hasScopeRef(node.content, ids);
    case 2:
    case 3:
      return false;
    default:
      if (true) ;
      return false;
  }
}
function getMemoedVNodeCall(node) {
  if (node.type === 14 && node.callee === WITH_MEMO) {
    return node.arguments[1].returns;
  } else {
    return node;
  }
}
const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;

const defaultParserOptions = {
  parseMode: "base",
  ns: 0,
  delimiters: [`{{`, `}}`],
  getNamespace: () => 0,
  isVoidTag: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO,
  isPreTag: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO,
  isCustomElement: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NO,
  onError: defaultOnError,
  onWarn: defaultOnWarn,
  comments: !!("development" !== "production"),
  prefixIdentifiers: false
};
let currentOptions = defaultParserOptions;
let currentRoot = null;
let currentInput = "";
let currentOpenTag = null;
let currentProp = null;
let currentAttrValue = "";
let currentAttrStartIndex = -1;
let currentAttrEndIndex = -1;
let inPre = 0;
let inVPre = false;
let currentVPreBoundary = null;
const stack = [];
const tokenizer = new Tokenizer(stack, {
  onerr: emitError,
  ontext(start, end) {
    onText(getSlice(start, end), start, end);
  },
  ontextentity(char, start, end) {
    onText(char, start, end);
  },
  oninterpolation(start, end) {
    if (inVPre) {
      return onText(getSlice(start, end), start, end);
    }
    let innerStart = start + tokenizer.delimiterOpen.length;
    let innerEnd = end - tokenizer.delimiterClose.length;
    while (isWhitespace(currentInput.charCodeAt(innerStart))) {
      innerStart++;
    }
    while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {
      innerEnd--;
    }
    let exp = getSlice(innerStart, innerEnd);
    if (exp.includes("&")) {
      {
        exp = currentOptions.decodeEntities(exp, false);
      }
    }
    addNode({
      type: 5,
      content: createExp(exp, false, getLoc(innerStart, innerEnd)),
      loc: getLoc(start, end)
    });
  },
  onopentagname(start, end) {
    const name = getSlice(start, end);
    currentOpenTag = {
      type: 1,
      tag: name,
      ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
      tagType: 0,
      // will be refined on tag close
      props: [],
      children: [],
      loc: getLoc(start - 1, end),
      codegenNode: void 0
    };
  },
  onopentagend(end) {
    endOpenTag(end);
  },
  onclosetag(start, end) {
    const name = getSlice(start, end);
    if (!currentOptions.isVoidTag(name)) {
      let found = false;
      for (let i = 0; i < stack.length; i++) {
        const e = stack[i];
        if (e.tag.toLowerCase() === name.toLowerCase()) {
          found = true;
          if (i > 0) {
            emitError(24, stack[0].loc.start.offset);
          }
          for (let j = 0; j <= i; j++) {
            const el = stack.shift();
            onCloseTag(el, end, j < i);
          }
          break;
        }
      }
      if (!found) {
        emitError(23, backTrack(start, 60));
      }
    }
  },
  onselfclosingtag(end) {
    const name = currentOpenTag.tag;
    currentOpenTag.isSelfClosing = true;
    endOpenTag(end);
    if (stack[0] && stack[0].tag === name) {
      onCloseTag(stack.shift(), end);
    }
  },
  onattribname(start, end) {
    currentProp = {
      type: 6,
      name: getSlice(start, end),
      nameLoc: getLoc(start, end),
      value: void 0,
      loc: getLoc(start)
    };
  },
  ondirname(start, end) {
    const raw = getSlice(start, end);
    const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
    if (!inVPre && name === "") {
      emitError(26, start);
    }
    if (inVPre || name === "") {
      currentProp = {
        type: 6,
        name: raw,
        nameLoc: getLoc(start, end),
        value: void 0,
        loc: getLoc(start)
      };
    } else {
      currentProp = {
        type: 7,
        name,
        rawName: raw,
        exp: void 0,
        arg: void 0,
        modifiers: raw === "." ? ["prop"] : [],
        loc: getLoc(start)
      };
      if (name === "pre") {
        inVPre = tokenizer.inVPre = true;
        currentVPreBoundary = currentOpenTag;
        const props = currentOpenTag.props;
        for (let i = 0; i < props.length; i++) {
          if (props[i].type === 7) {
            props[i] = dirToAttr(props[i]);
          }
        }
      }
    }
  },
  ondirarg(start, end) {
    if (start === end) return;
    const arg = getSlice(start, end);
    if (inVPre) {
      currentProp.name += arg;
      setLocEnd(currentProp.nameLoc, end);
    } else {
      const isStatic = arg[0] !== `[`;
      currentProp.arg = createExp(
        isStatic ? arg : arg.slice(1, -1),
        isStatic,
        getLoc(start, end),
        isStatic ? 3 : 0
      );
    }
  },
  ondirmodifier(start, end) {
    const mod = getSlice(start, end);
    if (inVPre) {
      currentProp.name += "." + mod;
      setLocEnd(currentProp.nameLoc, end);
    } else if (currentProp.name === "slot") {
      const arg = currentProp.arg;
      if (arg) {
        arg.content += "." + mod;
        setLocEnd(arg.loc, end);
      }
    } else {
      currentProp.modifiers.push(mod);
    }
  },
  onattribdata(start, end) {
    currentAttrValue += getSlice(start, end);
    if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
    currentAttrEndIndex = end;
  },
  onattribentity(char, start, end) {
    currentAttrValue += char;
    if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
    currentAttrEndIndex = end;
  },
  onattribnameend(end) {
    const start = currentProp.loc.start.offset;
    const name = getSlice(start, end);
    if (currentProp.type === 7) {
      currentProp.rawName = name;
    }
    if (currentOpenTag.props.some(
      (p) => (p.type === 7 ? p.rawName : p.name) === name
    )) {
      emitError(2, start);
    }
  },
  onattribend(quote, end) {
    if (currentOpenTag && currentProp) {
      setLocEnd(currentProp.loc, end);
      if (quote !== 0) {
        if (currentAttrValue.includes("&")) {
          currentAttrValue = currentOptions.decodeEntities(
            currentAttrValue,
            true
          );
        }
        if (currentProp.type === 6) {
          if (currentProp.name === "class") {
            currentAttrValue = condense(currentAttrValue).trim();
          }
          if (quote === 1 && !currentAttrValue) {
            emitError(13, end);
          }
          currentProp.value = {
            type: 2,
            content: currentAttrValue,
            loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
          };
          if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") {
            tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
          }
        } else {
          let expParseMode = 0 /* Normal */;
          currentProp.exp = createExp(
            currentAttrValue,
            false,
            getLoc(currentAttrStartIndex, currentAttrEndIndex),
            0,
            expParseMode
          );
          if (currentProp.name === "for") {
            currentProp.forParseResult = parseForExpression(currentProp.exp);
          }
          let syncIndex = -1;
          if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.indexOf("sync")) > -1 && checkCompatEnabled(
            "COMPILER_V_BIND_SYNC",
            currentOptions,
            currentProp.loc,
            currentProp.rawName
          )) {
            currentProp.name = "model";
            currentProp.modifiers.splice(syncIndex, 1);
          }
        }
      }
      if (currentProp.type !== 7 || currentProp.name !== "pre") {
        currentOpenTag.props.push(currentProp);
      }
    }
    currentAttrValue = "";
    currentAttrStartIndex = currentAttrEndIndex = -1;
  },
  oncomment(start, end) {
    if (currentOptions.comments) {
      addNode({
        type: 3,
        content: getSlice(start, end),
        loc: getLoc(start - 4, end + 3)
      });
    }
  },
  onend() {
    const end = currentInput.length;
    if (( true) && tokenizer.state !== 1) {
      switch (tokenizer.state) {
        case 5:
        case 8:
          emitError(5, end);
          break;
        case 3:
        case 4:
          emitError(
            25,
            tokenizer.sectionStart
          );
          break;
        case 28:
          if (tokenizer.currentSequence === Sequences.CdataEnd) {
            emitError(6, end);
          } else {
            emitError(7, end);
          }
          break;
        case 6:
        case 7:
        case 9:
        case 11:
        case 12:
        case 13:
        case 14:
        case 15:
        case 16:
        case 17:
        case 18:
        case 19:
        case 20:
        case 21:
          emitError(9, end);
          break;
      }
    }
    for (let index = 0; index < stack.length; index++) {
      onCloseTag(stack[index], end - 1);
      emitError(24, stack[index].loc.start.offset);
    }
  },
  oncdata(start, end) {
    if (stack[0].ns !== 0) {
      onText(getSlice(start, end), start, end);
    } else {
      emitError(1, start - 9);
    }
  },
  onprocessinginstruction(start) {
    if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
      emitError(
        21,
        start - 1
      );
    }
  }
});
const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
const stripParensRE = /^\(|\)$/g;
function parseForExpression(input) {
  const loc = input.loc;
  const exp = input.content;
  const inMatch = exp.match(forAliasRE);
  if (!inMatch) return;
  const [, LHS, RHS] = inMatch;
  const createAliasExpression = (content, offset, asParam = false) => {
    const start = loc.start.offset + offset;
    const end = start + content.length;
    return createExp(
      content,
      false,
      getLoc(start, end),
      0,
      asParam ? 1 /* Params */ : 0 /* Normal */
    );
  };
  const result = {
    source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
    value: void 0,
    key: void 0,
    index: void 0,
    finalized: false
  };
  let valueContent = LHS.trim().replace(stripParensRE, "").trim();
  const trimmedOffset = LHS.indexOf(valueContent);
  const iteratorMatch = valueContent.match(forIteratorRE);
  if (iteratorMatch) {
    valueContent = valueContent.replace(forIteratorRE, "").trim();
    const keyContent = iteratorMatch[1].trim();
    let keyOffset;
    if (keyContent) {
      keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
      result.key = createAliasExpression(keyContent, keyOffset, true);
    }
    if (iteratorMatch[2]) {
      const indexContent = iteratorMatch[2].trim();
      if (indexContent) {
        result.index = createAliasExpression(
          indexContent,
          exp.indexOf(
            indexContent,
            result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
          ),
          true
        );
      }
    }
  }
  if (valueContent) {
    result.value = createAliasExpression(valueContent, trimmedOffset, true);
  }
  return result;
}
function getSlice(start, end) {
  return currentInput.slice(start, end);
}
function endOpenTag(end) {
  if (tokenizer.inSFCRoot) {
    currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
  }
  addNode(currentOpenTag);
  const { tag, ns } = currentOpenTag;
  if (ns === 0 && currentOptions.isPreTag(tag)) {
    inPre++;
  }
  if (currentOptions.isVoidTag(tag)) {
    onCloseTag(currentOpenTag, end);
  } else {
    stack.unshift(currentOpenTag);
    if (ns === 1 || ns === 2) {
      tokenizer.inXML = true;
    }
  }
  currentOpenTag = null;
}
function onText(content, start, end) {
  {
    const tag = stack[0] && stack[0].tag;
    if (tag !== "script" && tag !== "style" && content.includes("&")) {
      content = currentOptions.decodeEntities(content, false);
    }
  }
  const parent = stack[0] || currentRoot;
  const lastNode = parent.children[parent.children.length - 1];
  if (lastNode && lastNode.type === 2) {
    lastNode.content += content;
    setLocEnd(lastNode.loc, end);
  } else {
    parent.children.push({
      type: 2,
      content,
      loc: getLoc(start, end)
    });
  }
}
function onCloseTag(el, end, isImplied = false) {
  if (isImplied) {
    setLocEnd(el.loc, backTrack(end, 60));
  } else {
    setLocEnd(el.loc, lookAhead(end, 62) + 1);
  }
  if (tokenizer.inSFCRoot) {
    if (el.children.length) {
      el.innerLoc.end = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, el.children[el.children.length - 1].loc.end);
    } else {
      el.innerLoc.end = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, el.innerLoc.start);
    }
    el.innerLoc.source = getSlice(
      el.innerLoc.start.offset,
      el.innerLoc.end.offset
    );
  }
  const { tag, ns } = el;
  if (!inVPre) {
    if (tag === "slot") {
      el.tagType = 2;
    } else if (isFragmentTemplate(el)) {
      el.tagType = 3;
    } else if (isComponent(el)) {
      el.tagType = 1;
    }
  }
  if (!tokenizer.inRCDATA) {
    el.children = condenseWhitespace(el.children, el.tag);
  }
  if (ns === 0 && currentOptions.isPreTag(tag)) {
    inPre--;
  }
  if (currentVPreBoundary === el) {
    inVPre = tokenizer.inVPre = false;
    currentVPreBoundary = null;
  }
  if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
    tokenizer.inXML = false;
  }
  {
    const props = el.props;
    if ( true && isCompatEnabled(
      "COMPILER_V_IF_V_FOR_PRECEDENCE",
      currentOptions
    )) {
      let hasIf = false;
      let hasFor = false;
      for (let i = 0; i < props.length; i++) {
        const p = props[i];
        if (p.type === 7) {
          if (p.name === "if") {
            hasIf = true;
          } else if (p.name === "for") {
            hasFor = true;
          }
        }
        if (hasIf && hasFor) {
          warnDeprecation(
            "COMPILER_V_IF_V_FOR_PRECEDENCE",
            currentOptions,
            el.loc
          );
          break;
        }
      }
    }
    if (!tokenizer.inSFCRoot && isCompatEnabled(
      "COMPILER_NATIVE_TEMPLATE",
      currentOptions
    ) && el.tag === "template" && !isFragmentTemplate(el)) {
       true && warnDeprecation(
        "COMPILER_NATIVE_TEMPLATE",
        currentOptions,
        el.loc
      );
      const parent = stack[0] || currentRoot;
      const index = parent.children.indexOf(el);
      parent.children.splice(index, 1, ...el.children);
    }
    const inlineTemplateProp = props.find(
      (p) => p.type === 6 && p.name === "inline-template"
    );
    if (inlineTemplateProp && checkCompatEnabled(
      "COMPILER_INLINE_TEMPLATE",
      currentOptions,
      inlineTemplateProp.loc
    ) && el.children.length) {
      inlineTemplateProp.value = {
        type: 2,
        content: getSlice(
          el.children[0].loc.start.offset,
          el.children[el.children.length - 1].loc.end.offset
        ),
        loc: inlineTemplateProp.loc
      };
    }
  }
}
function lookAhead(index, c) {
  let i = index;
  while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
  return i;
}
function backTrack(index, c) {
  let i = index;
  while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
  return i;
}
const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]);
function isFragmentTemplate({ tag, props }) {
  if (tag === "template") {
    for (let i = 0; i < props.length; i++) {
      if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {
        return true;
      }
    }
  }
  return false;
}
function isComponent({ tag, props }) {
  if (currentOptions.isCustomElement(tag)) {
    return false;
  }
  if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {
    return true;
  }
  for (let i = 0; i < props.length; i++) {
    const p = props[i];
    if (p.type === 6) {
      if (p.name === "is" && p.value) {
        if (p.value.content.startsWith("vue:")) {
          return true;
        } else if (checkCompatEnabled(
          "COMPILER_IS_ON_ELEMENT",
          currentOptions,
          p.loc
        )) {
          return true;
        }
      }
    } else if (// :is on plain element - only treat as component in compat mode
    p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled(
      "COMPILER_IS_ON_ELEMENT",
      currentOptions,
      p.loc
    )) {
      return true;
    }
  }
  return false;
}
function isUpperCase(c) {
  return c > 64 && c < 91;
}
const windowsNewlineRE = /\r\n/g;
function condenseWhitespace(nodes, tag) {
  const shouldCondense = currentOptions.whitespace !== "preserve";
  let removedWhitespace = false;
  for (let i = 0; i < nodes.length; i++) {
    const node = nodes[i];
    if (node.type === 2) {
      if (!inPre) {
        if (isAllWhitespace(node.content)) {
          const prev = nodes[i - 1] && nodes[i - 1].type;
          const next = nodes[i + 1] && nodes[i + 1].type;
          if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
            removedWhitespace = true;
            nodes[i] = null;
          } else {
            node.content = " ";
          }
        } else if (shouldCondense) {
          node.content = condense(node.content);
        }
      } else {
        node.content = node.content.replace(windowsNewlineRE, "\n");
      }
    }
  }
  if (inPre && tag && currentOptions.isPreTag(tag)) {
    const first = nodes[0];
    if (first && first.type === 2) {
      first.content = first.content.replace(/^\r?\n/, "");
    }
  }
  return removedWhitespace ? nodes.filter(Boolean) : nodes;
}
function isAllWhitespace(str) {
  for (let i = 0; i < str.length; i++) {
    if (!isWhitespace(str.charCodeAt(i))) {
      return false;
    }
  }
  return true;
}
function hasNewlineChar(str) {
  for (let i = 0; i < str.length; i++) {
    const c = str.charCodeAt(i);
    if (c === 10 || c === 13) {
      return true;
    }
  }
  return false;
}
function condense(str) {
  let ret = "";
  let prevCharIsWhitespace = false;
  for (let i = 0; i < str.length; i++) {
    if (isWhitespace(str.charCodeAt(i))) {
      if (!prevCharIsWhitespace) {
        ret += " ";
        prevCharIsWhitespace = true;
      }
    } else {
      ret += str[i];
      prevCharIsWhitespace = false;
    }
  }
  return ret;
}
function addNode(node) {
  (stack[0] || currentRoot).children.push(node);
}
function getLoc(start, end) {
  return {
    start: tokenizer.getPos(start),
    // @ts-expect-error allow late attachment
    end: end == null ? end : tokenizer.getPos(end),
    // @ts-expect-error allow late attachment
    source: end == null ? end : getSlice(start, end)
  };
}
function setLocEnd(loc, end) {
  loc.end = tokenizer.getPos(end);
  loc.source = getSlice(loc.start.offset, end);
}
function dirToAttr(dir) {
  const attr = {
    type: 6,
    name: dir.rawName,
    nameLoc: getLoc(
      dir.loc.start.offset,
      dir.loc.start.offset + dir.rawName.length
    ),
    value: void 0,
    loc: dir.loc
  };
  if (dir.exp) {
    const loc = dir.exp.loc;
    if (loc.end.offset < dir.loc.end.offset) {
      loc.start.offset--;
      loc.start.column--;
      loc.end.offset++;
      loc.end.column++;
    }
    attr.value = {
      type: 2,
      content: dir.exp.content,
      loc
    };
  }
  return attr;
}
function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) {
  const exp = createSimpleExpression(content, isStatic, loc, constType);
  return exp;
}
function emitError(code, index, message) {
  currentOptions.onError(
    createCompilerError(code, getLoc(index, index), void 0, message)
  );
}
function reset() {
  tokenizer.reset();
  currentOpenTag = null;
  currentProp = null;
  currentAttrValue = "";
  currentAttrStartIndex = -1;
  currentAttrEndIndex = -1;
  stack.length = 0;
}
function baseParse(input, options) {
  reset();
  currentInput = input;
  currentOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, defaultParserOptions);
  if (options) {
    let key;
    for (key in options) {
      if (options[key] != null) {
        currentOptions[key] = options[key];
      }
    }
  }
  if (true) {
    if (!currentOptions.decodeEntities) {
      throw new Error(
        `[@vue/compiler-core] decodeEntities option is required in browser builds.`
      );
    }
  }
  tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
  tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
  const delimiters = options && options.delimiters;
  if (delimiters) {
    tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
    tokenizer.delimiterClose = toCharCodes(delimiters[1]);
  }
  const root = currentRoot = createRoot([], input);
  tokenizer.parse(currentInput);
  root.loc = getLoc(0, input.length);
  root.children = condenseWhitespace(root.children);
  currentRoot = null;
  return root;
}

function hoistStatic(root, context) {
  walk(
    root,
    context,
    // Root node is unfortunately non-hoistable due to potential parent
    // fallthrough attributes.
    isSingleElementRoot(root, root.children[0])
  );
}
function isSingleElementRoot(root, child) {
  const { children } = root;
  return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
}
function walk(node, context, doNotHoistNode = false) {
  const { children } = node;
  const originalCount = children.length;
  let hoistedCount = 0;
  for (let i = 0; i < children.length; i++) {
    const child = children[i];
    if (child.type === 1 && child.tagType === 0) {
      const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
      if (constantType > 0) {
        if (constantType >= 2) {
          child.codegenNode.patchFlag = -1;
          child.codegenNode = context.hoist(child.codegenNode);
          hoistedCount++;
          continue;
        }
      } else {
        const codegenNode = child.codegenNode;
        if (codegenNode.type === 13) {
          const flag = codegenNode.patchFlag;
          if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
            const props = getNodeProps(child);
            if (props) {
              codegenNode.props = context.hoist(props);
            }
          }
          if (codegenNode.dynamicProps) {
            codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
          }
        }
      }
    }
    if (child.type === 1) {
      const isComponent = child.tagType === 1;
      if (isComponent) {
        context.scopes.vSlot++;
      }
      walk(child, context);
      if (isComponent) {
        context.scopes.vSlot--;
      }
    } else if (child.type === 11) {
      walk(child, context, child.children.length === 1);
    } else if (child.type === 9) {
      for (let i2 = 0; i2 < child.branches.length; i2++) {
        walk(
          child.branches[i2],
          context,
          child.branches[i2].children.length === 1
        );
      }
    }
  }
  if (hoistedCount && context.transformHoist) {
    context.transformHoist(children, context, node);
  }
  if (hoistedCount && hoistedCount === originalCount && node.type === 1 && node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node.codegenNode.children)) {
    const hoisted = context.hoist(
      createArrayExpression(node.codegenNode.children)
    );
    if (context.hmr) {
      hoisted.content = `[...${hoisted.content}]`;
    }
    node.codegenNode.children = hoisted;
  }
}
function getConstantType(node, context) {
  const { constantCache } = context;
  switch (node.type) {
    case 1:
      if (node.tagType !== 0) {
        return 0;
      }
      const cached = constantCache.get(node);
      if (cached !== void 0) {
        return cached;
      }
      const codegenNode = node.codegenNode;
      if (codegenNode.type !== 13) {
        return 0;
      }
      if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") {
        return 0;
      }
      if (codegenNode.patchFlag === void 0) {
        let returnType2 = 3;
        const generatedPropsType = getGeneratedPropsConstantType(node, context);
        if (generatedPropsType === 0) {
          constantCache.set(node, 0);
          return 0;
        }
        if (generatedPropsType < returnType2) {
          returnType2 = generatedPropsType;
        }
        for (let i = 0; i < node.children.length; i++) {
          const childType = getConstantType(node.children[i], context);
          if (childType === 0) {
            constantCache.set(node, 0);
            return 0;
          }
          if (childType < returnType2) {
            returnType2 = childType;
          }
        }
        if (returnType2 > 1) {
          for (let i = 0; i < node.props.length; i++) {
            const p = node.props[i];
            if (p.type === 7 && p.name === "bind" && p.exp) {
              const expType = getConstantType(p.exp, context);
              if (expType === 0) {
                constantCache.set(node, 0);
                return 0;
              }
              if (expType < returnType2) {
                returnType2 = expType;
              }
            }
          }
        }
        if (codegenNode.isBlock) {
          for (let i = 0; i < node.props.length; i++) {
            const p = node.props[i];
            if (p.type === 7) {
              constantCache.set(node, 0);
              return 0;
            }
          }
          context.removeHelper(OPEN_BLOCK);
          context.removeHelper(
            getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)
          );
          codegenNode.isBlock = false;
          context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
        }
        constantCache.set(node, returnType2);
        return returnType2;
      } else {
        constantCache.set(node, 0);
        return 0;
      }
    case 2:
    case 3:
      return 3;
    case 9:
    case 11:
    case 10:
      return 0;
    case 5:
    case 12:
      return getConstantType(node.content, context);
    case 4:
      return node.constType;
    case 8:
      let returnType = 3;
      for (let i = 0; i < node.children.length; i++) {
        const child = node.children[i];
        if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(child)) {
          continue;
        }
        const childType = getConstantType(child, context);
        if (childType === 0) {
          return 0;
        } else if (childType < returnType) {
          returnType = childType;
        }
      }
      return returnType;
    default:
      if (true) ;
      return 0;
  }
}
const allowHoistedHelperSet = /* @__PURE__ */ new Set([
  NORMALIZE_CLASS,
  NORMALIZE_STYLE,
  NORMALIZE_PROPS,
  GUARD_REACTIVE_PROPS
]);
function getConstantTypeOfHelperCall(value, context) {
  if (value.type === 14 && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(value.callee) && allowHoistedHelperSet.has(value.callee)) {
    const arg = value.arguments[0];
    if (arg.type === 4) {
      return getConstantType(arg, context);
    } else if (arg.type === 14) {
      return getConstantTypeOfHelperCall(arg, context);
    }
  }
  return 0;
}
function getGeneratedPropsConstantType(node, context) {
  let returnType = 3;
  const props = getNodeProps(node);
  if (props && props.type === 15) {
    const { properties } = props;
    for (let i = 0; i < properties.length; i++) {
      const { key, value } = properties[i];
      const keyType = getConstantType(key, context);
      if (keyType === 0) {
        return keyType;
      }
      if (keyType < returnType) {
        returnType = keyType;
      }
      let valueType;
      if (value.type === 4) {
        valueType = getConstantType(value, context);
      } else if (value.type === 14) {
        valueType = getConstantTypeOfHelperCall(value, context);
      } else {
        valueType = 0;
      }
      if (valueType === 0) {
        return valueType;
      }
      if (valueType < returnType) {
        returnType = valueType;
      }
    }
  }
  return returnType;
}
function getNodeProps(node) {
  const codegenNode = node.codegenNode;
  if (codegenNode.type === 13) {
    return codegenNode.props;
  }
}

function createTransformContext(root, {
  filename = "",
  prefixIdentifiers = false,
  hoistStatic: hoistStatic2 = false,
  hmr = false,
  cacheHandlers = false,
  nodeTransforms = [],
  directiveTransforms = {},
  transformHoist = null,
  isBuiltInComponent = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP,
  isCustomElement = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP,
  expressionPlugins = [],
  scopeId = null,
  slotted = true,
  ssr = false,
  inSSR = false,
  ssrCssVars = ``,
  bindingMetadata = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.EMPTY_OBJ,
  inline = false,
  isTS = false,
  onError = defaultOnError,
  onWarn = defaultOnWarn,
  compatConfig
}) {
  const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
  const context = {
    // options
    filename,
    selfName: nameMatch && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(nameMatch[1])),
    prefixIdentifiers,
    hoistStatic: hoistStatic2,
    hmr,
    cacheHandlers,
    nodeTransforms,
    directiveTransforms,
    transformHoist,
    isBuiltInComponent,
    isCustomElement,
    expressionPlugins,
    scopeId,
    slotted,
    ssr,
    inSSR,
    ssrCssVars,
    bindingMetadata,
    inline,
    isTS,
    onError,
    onWarn,
    compatConfig,
    // state
    root,
    helpers: /* @__PURE__ */ new Map(),
    components: /* @__PURE__ */ new Set(),
    directives: /* @__PURE__ */ new Set(),
    hoists: [],
    imports: [],
    constantCache: /* @__PURE__ */ new WeakMap(),
    temps: 0,
    cached: 0,
    identifiers: /* @__PURE__ */ Object.create(null),
    scopes: {
      vFor: 0,
      vSlot: 0,
      vPre: 0,
      vOnce: 0
    },
    parent: null,
    grandParent: null,
    currentNode: root,
    childIndex: 0,
    inVOnce: false,
    // methods
    helper(name) {
      const count = context.helpers.get(name) || 0;
      context.helpers.set(name, count + 1);
      return name;
    },
    removeHelper(name) {
      const count = context.helpers.get(name);
      if (count) {
        const currentCount = count - 1;
        if (!currentCount) {
          context.helpers.delete(name);
        } else {
          context.helpers.set(name, currentCount);
        }
      }
    },
    helperString(name) {
      return `_${helperNameMap[context.helper(name)]}`;
    },
    replaceNode(node) {
      if (true) {
        if (!context.currentNode) {
          throw new Error(`Node being replaced is already removed.`);
        }
        if (!context.parent) {
          throw new Error(`Cannot replace root node.`);
        }
      }
      context.parent.children[context.childIndex] = context.currentNode = node;
    },
    removeNode(node) {
      if ( true && !context.parent) {
        throw new Error(`Cannot remove root node.`);
      }
      const list = context.parent.children;
      const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
      if ( true && removalIndex < 0) {
        throw new Error(`node being removed is not a child of current parent`);
      }
      if (!node || node === context.currentNode) {
        context.currentNode = null;
        context.onNodeRemoved();
      } else {
        if (context.childIndex > removalIndex) {
          context.childIndex--;
          context.onNodeRemoved();
        }
      }
      context.parent.children.splice(removalIndex, 1);
    },
    onNodeRemoved: _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP,
    addIdentifiers(exp) {
    },
    removeIdentifiers(exp) {
    },
    hoist(exp) {
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(exp)) exp = createSimpleExpression(exp);
      context.hoists.push(exp);
      const identifier = createSimpleExpression(
        `_hoisted_${context.hoists.length}`,
        false,
        exp.loc,
        2
      );
      identifier.hoisted = exp;
      return identifier;
    },
    cache(exp, isVNode = false) {
      return createCacheExpression(context.cached++, exp, isVNode);
    }
  };
  {
    context.filters = /* @__PURE__ */ new Set();
  }
  return context;
}
function transform(root, options) {
  const context = createTransformContext(root, options);
  traverseNode(root, context);
  if (options.hoistStatic) {
    hoistStatic(root, context);
  }
  if (!options.ssr) {
    createRootCodegen(root, context);
  }
  root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
  root.components = [...context.components];
  root.directives = [...context.directives];
  root.imports = context.imports;
  root.hoists = context.hoists;
  root.temps = context.temps;
  root.cached = context.cached;
  root.transformed = true;
  {
    root.filters = [...context.filters];
  }
}
function createRootCodegen(root, context) {
  const { helper } = context;
  const { children } = root;
  if (children.length === 1) {
    const child = children[0];
    if (isSingleElementRoot(root, child) && child.codegenNode) {
      const codegenNode = child.codegenNode;
      if (codegenNode.type === 13) {
        convertToBlock(codegenNode, context);
      }
      root.codegenNode = codegenNode;
    } else {
      root.codegenNode = child;
    }
  } else if (children.length > 1) {
    let patchFlag = 64;
    let patchFlagText = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[64];
    if ( true && children.filter((c) => c.type !== 3).length === 1) {
      patchFlag |= 2048;
      patchFlagText += `, ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[2048]}`;
    }
    root.codegenNode = createVNodeCall(
      context,
      helper(FRAGMENT),
      void 0,
      root.children,
      patchFlag,
      void 0,
      void 0,
      true,
      void 0,
      false
    );
  } else ;
}
function traverseChildren(parent, context) {
  let i = 0;
  const nodeRemoved = () => {
    i--;
  };
  for (; i < parent.children.length; i++) {
    const child = parent.children[i];
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child)) continue;
    context.grandParent = context.parent;
    context.parent = parent;
    context.childIndex = i;
    context.onNodeRemoved = nodeRemoved;
    traverseNode(child, context);
  }
}
function traverseNode(node, context) {
  context.currentNode = node;
  const { nodeTransforms } = context;
  const exitFns = [];
  for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
    const onExit = nodeTransforms[i2](node, context);
    if (onExit) {
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(onExit)) {
        exitFns.push(...onExit);
      } else {
        exitFns.push(onExit);
      }
    }
    if (!context.currentNode) {
      return;
    } else {
      node = context.currentNode;
    }
  }
  switch (node.type) {
    case 3:
      if (!context.ssr) {
        context.helper(CREATE_COMMENT);
      }
      break;
    case 5:
      if (!context.ssr) {
        context.helper(TO_DISPLAY_STRING);
      }
      break;
    case 9:
      for (let i2 = 0; i2 < node.branches.length; i2++) {
        traverseNode(node.branches[i2], context);
      }
      break;
    case 10:
    case 11:
    case 1:
    case 0:
      traverseChildren(node, context);
      break;
  }
  context.currentNode = node;
  let i = exitFns.length;
  while (i--) {
    exitFns[i]();
  }
}
function createStructuralDirectiveTransform(name, fn) {
  const matches = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(name) ? (n) => n === name : (n) => name.test(n);
  return (node, context) => {
    if (node.type === 1) {
      const { props } = node;
      if (node.tagType === 3 && props.some(isVSlot)) {
        return;
      }
      const exitFns = [];
      for (let i = 0; i < props.length; i++) {
        const prop = props[i];
        if (prop.type === 7 && matches(prop.name)) {
          props.splice(i, 1);
          i--;
          const onExit = fn(node, prop, context);
          if (onExit) exitFns.push(onExit);
        }
      }
      return exitFns;
    }
  };
}

const PURE_ANNOTATION = `/*#__PURE__*/`;
const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
function createCodegenContext(ast, {
  mode = "function",
  prefixIdentifiers = mode === "module",
  sourceMap = false,
  filename = `template.vue.html`,
  scopeId = null,
  optimizeImports = false,
  runtimeGlobalName = `Vue`,
  runtimeModuleName = `vue`,
  ssrRuntimeModuleName = "vue/server-renderer",
  ssr = false,
  isTS = false,
  inSSR = false
}) {
  const context = {
    mode,
    prefixIdentifiers,
    sourceMap,
    filename,
    scopeId,
    optimizeImports,
    runtimeGlobalName,
    runtimeModuleName,
    ssrRuntimeModuleName,
    ssr,
    isTS,
    inSSR,
    source: ast.source,
    code: ``,
    column: 1,
    line: 1,
    offset: 0,
    indentLevel: 0,
    pure: false,
    map: void 0,
    helper(key) {
      return `_${helperNameMap[key]}`;
    },
    push(code, newlineIndex = -2 /* None */, node) {
      context.code += code;
    },
    indent() {
      newline(++context.indentLevel);
    },
    deindent(withoutNewLine = false) {
      if (withoutNewLine) {
        --context.indentLevel;
      } else {
        newline(--context.indentLevel);
      }
    },
    newline() {
      newline(context.indentLevel);
    }
  };
  function newline(n) {
    context.push("\n" + `  `.repeat(n), 0 /* Start */);
  }
  return context;
}
function generate(ast, options = {}) {
  const context = createCodegenContext(ast, options);
  if (options.onContextCreated) options.onContextCreated(context);
  const {
    mode,
    push,
    prefixIdentifiers,
    indent,
    deindent,
    newline,
    scopeId,
    ssr
  } = context;
  const helpers = Array.from(ast.helpers);
  const hasHelpers = helpers.length > 0;
  const useWithBlock = !prefixIdentifiers && mode !== "module";
  const preambleContext = context;
  {
    genFunctionPreamble(ast, preambleContext);
  }
  const functionName = ssr ? `ssrRender` : `render`;
  const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
  const signature = args.join(", ");
  {
    push(`function ${functionName}(${signature}) {`);
  }
  indent();
  if (useWithBlock) {
    push(`with (_ctx) {`);
    indent();
    if (hasHelpers) {
      push(
        `const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
`,
        -1 /* End */
      );
      newline();
    }
  }
  if (ast.components.length) {
    genAssets(ast.components, "component", context);
    if (ast.directives.length || ast.temps > 0) {
      newline();
    }
  }
  if (ast.directives.length) {
    genAssets(ast.directives, "directive", context);
    if (ast.temps > 0) {
      newline();
    }
  }
  if (ast.filters && ast.filters.length) {
    newline();
    genAssets(ast.filters, "filter", context);
    newline();
  }
  if (ast.temps > 0) {
    push(`let `);
    for (let i = 0; i < ast.temps; i++) {
      push(`${i > 0 ? `, ` : ``}_temp${i}`);
    }
  }
  if (ast.components.length || ast.directives.length || ast.temps) {
    push(`
`, 0 /* Start */);
    newline();
  }
  if (!ssr) {
    push(`return `);
  }
  if (ast.codegenNode) {
    genNode(ast.codegenNode, context);
  } else {
    push(`null`);
  }
  if (useWithBlock) {
    deindent();
    push(`}`);
  }
  deindent();
  push(`}`);
  return {
    ast,
    code: context.code,
    preamble: ``,
    map: context.map ? context.map.toJSON() : void 0
  };
}
function genFunctionPreamble(ast, context) {
  const {
    ssr,
    prefixIdentifiers,
    push,
    newline,
    runtimeModuleName,
    runtimeGlobalName,
    ssrRuntimeModuleName
  } = context;
  const VueBinding = runtimeGlobalName;
  const helpers = Array.from(ast.helpers);
  if (helpers.length > 0) {
    {
      push(`const _Vue = ${VueBinding}
`, -1 /* End */);
      if (ast.hoists.length) {
        const staticHelpers = [
          CREATE_VNODE,
          CREATE_ELEMENT_VNODE,
          CREATE_COMMENT,
          CREATE_TEXT,
          CREATE_STATIC
        ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
        push(`const { ${staticHelpers} } = _Vue
`, -1 /* End */);
      }
    }
  }
  genHoists(ast.hoists, context);
  newline();
  push(`return `);
}
function genAssets(assets, type, { helper, push, newline, isTS }) {
  const resolver = helper(
    type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
  );
  for (let i = 0; i < assets.length; i++) {
    let id = assets[i];
    const maybeSelfReference = id.endsWith("__self");
    if (maybeSelfReference) {
      id = id.slice(0, -6);
    }
    push(
      `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`
    );
    if (i < assets.length - 1) {
      newline();
    }
  }
}
function genHoists(hoists, context) {
  if (!hoists.length) {
    return;
  }
  context.pure = true;
  const { push, newline, helper, scopeId, mode } = context;
  newline();
  for (let i = 0; i < hoists.length; i++) {
    const exp = hoists[i];
    if (exp) {
      push(
        `const _hoisted_${i + 1} = ${``}`
      );
      genNode(exp, context);
      newline();
    }
  }
  context.pure = false;
}
function isText(n) {
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
}
function genNodeListAsArray(nodes, context) {
  const multilines = nodes.length > 3 ||  true && nodes.some((n) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(n) || !isText(n));
  context.push(`[`);
  multilines && context.indent();
  genNodeList(nodes, context, multilines);
  multilines && context.deindent();
  context.push(`]`);
}
function genNodeList(nodes, context, multilines = false, comma = true) {
  const { push, newline } = context;
  for (let i = 0; i < nodes.length; i++) {
    const node = nodes[i];
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node)) {
      push(node, -3 /* Unknown */);
    } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(node)) {
      genNodeListAsArray(node, context);
    } else {
      genNode(node, context);
    }
    if (i < nodes.length - 1) {
      if (multilines) {
        comma && push(",");
        newline();
      } else {
        comma && push(", ");
      }
    }
  }
}
function genNode(node, context) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node)) {
    context.push(node, -3 /* Unknown */);
    return;
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(node)) {
    context.push(context.helper(node));
    return;
  }
  switch (node.type) {
    case 1:
    case 9:
    case 11:
       true && assert(
        node.codegenNode != null,
        `Codegen node is missing for element/if/for node. Apply appropriate transforms first.`
      );
      genNode(node.codegenNode, context);
      break;
    case 2:
      genText(node, context);
      break;
    case 4:
      genExpression(node, context);
      break;
    case 5:
      genInterpolation(node, context);
      break;
    case 12:
      genNode(node.codegenNode, context);
      break;
    case 8:
      genCompoundExpression(node, context);
      break;
    case 3:
      genComment(node, context);
      break;
    case 13:
      genVNodeCall(node, context);
      break;
    case 14:
      genCallExpression(node, context);
      break;
    case 15:
      genObjectExpression(node, context);
      break;
    case 17:
      genArrayExpression(node, context);
      break;
    case 18:
      genFunctionExpression(node, context);
      break;
    case 19:
      genConditionalExpression(node, context);
      break;
    case 20:
      genCacheExpression(node, context);
      break;
    case 21:
      genNodeList(node.body, context, true, false);
      break;
    case 22:
      break;
    case 23:
      break;
    case 24:
      break;
    case 25:
      break;
    case 26:
      break;
    case 10:
      break;
    default:
      if (true) {
        assert(false, `unhandled codegen node type: ${node.type}`);
        const exhaustiveCheck = node;
        return exhaustiveCheck;
      }
  }
}
function genText(node, context) {
  context.push(JSON.stringify(node.content), -3 /* Unknown */, node);
}
function genExpression(node, context) {
  const { content, isStatic } = node;
  context.push(
    isStatic ? JSON.stringify(content) : content,
    -3 /* Unknown */,
    node
  );
}
function genInterpolation(node, context) {
  const { push, helper, pure } = context;
  if (pure) push(PURE_ANNOTATION);
  push(`${helper(TO_DISPLAY_STRING)}(`);
  genNode(node.content, context);
  push(`)`);
}
function genCompoundExpression(node, context) {
  for (let i = 0; i < node.children.length; i++) {
    const child = node.children[i];
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(child)) {
      context.push(child, -3 /* Unknown */);
    } else {
      genNode(child, context);
    }
  }
}
function genExpressionAsPropertyKey(node, context) {
  const { push } = context;
  if (node.type === 8) {
    push(`[`);
    genCompoundExpression(node, context);
    push(`]`);
  } else if (node.isStatic) {
    const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
    push(text, -2 /* None */, node);
  } else {
    push(`[${node.content}]`, -3 /* Unknown */, node);
  }
}
function genComment(node, context) {
  const { push, helper, pure } = context;
  if (pure) {
    push(PURE_ANNOTATION);
  }
  push(
    `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`,
    -3 /* Unknown */,
    node
  );
}
function genVNodeCall(node, context) {
  const { push, helper, pure } = context;
  const {
    tag,
    props,
    children,
    patchFlag,
    dynamicProps,
    directives,
    isBlock,
    disableTracking,
    isComponent
  } = node;
  let patchFlagString;
  if (patchFlag) {
    if (true) {
      if (patchFlag < 0) {
        patchFlagString = patchFlag + ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[patchFlag]} */`;
      } else {
        const flagNames = Object.keys(_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => _vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[n]).join(`, `);
        patchFlagString = patchFlag + ` /* ${flagNames} */`;
      }
    } else {}
  }
  if (directives) {
    push(helper(WITH_DIRECTIVES) + `(`);
  }
  if (isBlock) {
    push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
  }
  if (pure) {
    push(PURE_ANNOTATION);
  }
  const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
  push(helper(callHelper) + `(`, -2 /* None */, node);
  genNodeList(
    genNullableArgs([tag, props, children, patchFlagString, dynamicProps]),
    context
  );
  push(`)`);
  if (isBlock) {
    push(`)`);
  }
  if (directives) {
    push(`, `);
    genNode(directives, context);
    push(`)`);
  }
}
function genNullableArgs(args) {
  let i = args.length;
  while (i--) {
    if (args[i] != null) break;
  }
  return args.slice(0, i + 1).map((arg) => arg || `null`);
}
function genCallExpression(node, context) {
  const { push, helper, pure } = context;
  const callee = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(node.callee) ? node.callee : helper(node.callee);
  if (pure) {
    push(PURE_ANNOTATION);
  }
  push(callee + `(`, -2 /* None */, node);
  genNodeList(node.arguments, context);
  push(`)`);
}
function genObjectExpression(node, context) {
  const { push, indent, deindent, newline } = context;
  const { properties } = node;
  if (!properties.length) {
    push(`{}`, -2 /* None */, node);
    return;
  }
  const multilines = properties.length > 1 ||  true && properties.some((p) => p.value.type !== 4);
  push(multilines ? `{` : `{ `);
  multilines && indent();
  for (let i = 0; i < properties.length; i++) {
    const { key, value } = properties[i];
    genExpressionAsPropertyKey(key, context);
    push(`: `);
    genNode(value, context);
    if (i < properties.length - 1) {
      push(`,`);
      newline();
    }
  }
  multilines && deindent();
  push(multilines ? `}` : ` }`);
}
function genArrayExpression(node, context) {
  genNodeListAsArray(node.elements, context);
}
function genFunctionExpression(node, context) {
  const { push, indent, deindent } = context;
  const { params, returns, body, newline, isSlot } = node;
  if (isSlot) {
    push(`_${helperNameMap[WITH_CTX]}(`);
  }
  push(`(`, -2 /* None */, node);
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(params)) {
    genNodeList(params, context);
  } else if (params) {
    genNode(params, context);
  }
  push(`) => `);
  if (newline || body) {
    push(`{`);
    indent();
  }
  if (returns) {
    if (newline) {
      push(`return `);
    }
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(returns)) {
      genNodeListAsArray(returns, context);
    } else {
      genNode(returns, context);
    }
  } else if (body) {
    genNode(body, context);
  }
  if (newline || body) {
    deindent();
    push(`}`);
  }
  if (isSlot) {
    if (node.isNonScopedSlot) {
      push(`, undefined, true`);
    }
    push(`)`);
  }
}
function genConditionalExpression(node, context) {
  const { test, consequent, alternate, newline: needNewline } = node;
  const { push, indent, deindent, newline } = context;
  if (test.type === 4) {
    const needsParens = !isSimpleIdentifier(test.content);
    needsParens && push(`(`);
    genExpression(test, context);
    needsParens && push(`)`);
  } else {
    push(`(`);
    genNode(test, context);
    push(`)`);
  }
  needNewline && indent();
  context.indentLevel++;
  needNewline || push(` `);
  push(`? `);
  genNode(consequent, context);
  context.indentLevel--;
  needNewline && newline();
  needNewline || push(` `);
  push(`: `);
  const isNested = alternate.type === 19;
  if (!isNested) {
    context.indentLevel++;
  }
  genNode(alternate, context);
  if (!isNested) {
    context.indentLevel--;
  }
  needNewline && deindent(
    true
    /* without newline */
  );
}
function genCacheExpression(node, context) {
  const { push, helper, indent, deindent, newline } = context;
  push(`_cache[${node.index}] || (`);
  if (node.isVOnce) {
    indent();
    push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
    newline();
    push(`(`);
  }
  push(`_cache[${node.index}] = `);
  genNode(node.value, context);
  if (node.isVOnce) {
    push(`).cacheIndex = ${node.index},`);
    newline();
    push(`${helper(SET_BLOCK_TRACKING)}(1),`);
    newline();
    push(`_cache[${node.index}]`);
    deindent();
  }
  push(`)`);
}

const prohibitedKeywordRE = new RegExp(
  "\\b" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b") + "\\b"
);
const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) {
  const exp = node.content;
  if (!exp.trim()) {
    return;
  }
  try {
    new Function(
      asRawStatements ? ` ${exp} ` : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`
    );
  } catch (e) {
    let message = e.message;
    const keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE);
    if (keywordMatch) {
      message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`;
    }
    context.onError(
      createCompilerError(
        45,
        node.loc,
        void 0,
        message
      )
    );
  }
}

const transformExpression = (node, context) => {
  if (node.type === 5) {
    node.content = processExpression(
      node.content,
      context
    );
  } else if (node.type === 1) {
    for (let i = 0; i < node.props.length; i++) {
      const dir = node.props[i];
      if (dir.type === 7 && dir.name !== "for") {
        const exp = dir.exp;
        const arg = dir.arg;
        if (exp && exp.type === 4 && !(dir.name === "on" && arg)) {
          dir.exp = processExpression(
            exp,
            context,
            // slot args must be processed as function params
            dir.name === "slot"
          );
        }
        if (arg && arg.type === 4 && !arg.isStatic) {
          dir.arg = processExpression(arg, context);
        }
      }
    }
  }
};
function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
  {
    if (true) {
      validateBrowserExpression(node, context, asParams, asRawStatements);
    }
    return node;
  }
}
function stringifyExpression(exp) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(exp)) {
    return exp;
  } else if (exp.type === 4) {
    return exp.content;
  } else {
    return exp.children.map(stringifyExpression).join("");
  }
}

const transformIf = createStructuralDirectiveTransform(
  /^(if|else|else-if)$/,
  (node, dir, context) => {
    return processIf(node, dir, context, (ifNode, branch, isRoot) => {
      const siblings = context.parent.children;
      let i = siblings.indexOf(ifNode);
      let key = 0;
      while (i-- >= 0) {
        const sibling = siblings[i];
        if (sibling && sibling.type === 9) {
          key += sibling.branches.length;
        }
      }
      return () => {
        if (isRoot) {
          ifNode.codegenNode = createCodegenNodeForBranch(
            branch,
            key,
            context
          );
        } else {
          const parentCondition = getParentCondition(ifNode.codegenNode);
          parentCondition.alternate = createCodegenNodeForBranch(
            branch,
            key + ifNode.branches.length - 1,
            context
          );
        }
      };
    });
  }
);
function processIf(node, dir, context, processCodegen) {
  if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
    const loc = dir.exp ? dir.exp.loc : node.loc;
    context.onError(
      createCompilerError(28, dir.loc)
    );
    dir.exp = createSimpleExpression(`true`, false, loc);
  }
  if ( true && dir.exp) {
    validateBrowserExpression(dir.exp, context);
  }
  if (dir.name === "if") {
    const branch = createIfBranch(node, dir);
    const ifNode = {
      type: 9,
      loc: node.loc,
      branches: [branch]
    };
    context.replaceNode(ifNode);
    if (processCodegen) {
      return processCodegen(ifNode, branch, true);
    }
  } else {
    const siblings = context.parent.children;
    const comments = [];
    let i = siblings.indexOf(node);
    while (i-- >= -1) {
      const sibling = siblings[i];
      if (sibling && sibling.type === 3) {
        context.removeNode(sibling);
         true && comments.unshift(sibling);
        continue;
      }
      if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
        context.removeNode(sibling);
        continue;
      }
      if (sibling && sibling.type === 9) {
        if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
          context.onError(
            createCompilerError(30, node.loc)
          );
        }
        context.removeNode();
        const branch = createIfBranch(node, dir);
        if ( true && comments.length && // #3619 ignore comments if the v-if is direct child of <transition>
        !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) {
          branch.children = [...comments, ...branch.children];
        }
        if (true) {
          const key = branch.userKey;
          if (key) {
            sibling.branches.forEach(({ userKey }) => {
              if (isSameKey(userKey, key)) {
                context.onError(
                  createCompilerError(
                    29,
                    branch.userKey.loc
                  )
                );
              }
            });
          }
        }
        sibling.branches.push(branch);
        const onExit = processCodegen && processCodegen(sibling, branch, false);
        traverseNode(branch, context);
        if (onExit) onExit();
        context.currentNode = null;
      } else {
        context.onError(
          createCompilerError(30, node.loc)
        );
      }
      break;
    }
  }
}
function createIfBranch(node, dir) {
  const isTemplateIf = node.tagType === 3;
  return {
    type: 10,
    loc: node.loc,
    condition: dir.name === "else" ? void 0 : dir.exp,
    children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
    userKey: findProp(node, `key`),
    isTemplateIf
  };
}
function createCodegenNodeForBranch(branch, keyIndex, context) {
  if (branch.condition) {
    return createConditionalExpression(
      branch.condition,
      createChildrenCodegenNode(branch, keyIndex, context),
      // make sure to pass in asBlock: true so that the comment node call
      // closes the current block.
      createCallExpression(context.helper(CREATE_COMMENT), [
         true ? '"v-if"' : 0,
        "true"
      ])
    );
  } else {
    return createChildrenCodegenNode(branch, keyIndex, context);
  }
}
function createChildrenCodegenNode(branch, keyIndex, context) {
  const { helper } = context;
  const keyProperty = createObjectProperty(
    `key`,
    createSimpleExpression(
      `${keyIndex}`,
      false,
      locStub,
      2
    )
  );
  const { children } = branch;
  const firstChild = children[0];
  const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
  if (needFragmentWrapper) {
    if (children.length === 1 && firstChild.type === 11) {
      const vnodeCall = firstChild.codegenNode;
      injectProp(vnodeCall, keyProperty, context);
      return vnodeCall;
    } else {
      let patchFlag = 64;
      let patchFlagText = _vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[64];
      if ( true && !branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) {
        patchFlag |= 2048;
        patchFlagText += `, ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[2048]}`;
      }
      return createVNodeCall(
        context,
        helper(FRAGMENT),
        createObjectExpression([keyProperty]),
        children,
        patchFlag,
        void 0,
        void 0,
        true,
        false,
        false,
        branch.loc
      );
    }
  } else {
    const ret = firstChild.codegenNode;
    const vnodeCall = getMemoedVNodeCall(ret);
    if (vnodeCall.type === 13) {
      convertToBlock(vnodeCall, context);
    }
    injectProp(vnodeCall, keyProperty, context);
    return ret;
  }
}
function isSameKey(a, b) {
  if (!a || a.type !== b.type) {
    return false;
  }
  if (a.type === 6) {
    if (a.value.content !== b.value.content) {
      return false;
    }
  } else {
    const exp = a.exp;
    const branchExp = b.exp;
    if (exp.type !== branchExp.type) {
      return false;
    }
    if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
      return false;
    }
  }
  return true;
}
function getParentCondition(node) {
  while (true) {
    if (node.type === 19) {
      if (node.alternate.type === 19) {
        node = node.alternate;
      } else {
        return node;
      }
    } else if (node.type === 20) {
      node = node.value;
    }
  }
}

const transformBind = (dir, _node, context) => {
  const { modifiers, loc } = dir;
  const arg = dir.arg;
  let { exp } = dir;
  if (exp && exp.type === 4 && !exp.content.trim()) {
    {
      exp = void 0;
    }
  }
  if (!exp) {
    if (arg.type !== 4 || !arg.isStatic) {
      context.onError(
        createCompilerError(
          52,
          arg.loc
        )
      );
      return {
        props: [
          createObjectProperty(arg, createSimpleExpression("", true, loc))
        ]
      };
    }
    transformBindShorthand(dir);
    exp = dir.exp;
  }
  if (arg.type !== 4) {
    arg.children.unshift(`(`);
    arg.children.push(`) || ""`);
  } else if (!arg.isStatic) {
    arg.content = `${arg.content} || ""`;
  }
  if (modifiers.includes("camel")) {
    if (arg.type === 4) {
      if (arg.isStatic) {
        arg.content = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(arg.content);
      } else {
        arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
      }
    } else {
      arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
      arg.children.push(`)`);
    }
  }
  if (!context.inSSR) {
    if (modifiers.includes("prop")) {
      injectPrefix(arg, ".");
    }
    if (modifiers.includes("attr")) {
      injectPrefix(arg, "^");
    }
  }
  return {
    props: [createObjectProperty(arg, exp)]
  };
};
const transformBindShorthand = (dir, context) => {
  const arg = dir.arg;
  const propName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(arg.content);
  dir.exp = createSimpleExpression(propName, false, arg.loc);
};
const injectPrefix = (arg, prefix) => {
  if (arg.type === 4) {
    if (arg.isStatic) {
      arg.content = prefix + arg.content;
    } else {
      arg.content = `\`${prefix}\${${arg.content}}\``;
    }
  } else {
    arg.children.unshift(`'${prefix}' + (`);
    arg.children.push(`)`);
  }
};

const transformFor = createStructuralDirectiveTransform(
  "for",
  (node, dir, context) => {
    const { helper, removeHelper } = context;
    return processFor(node, dir, context, (forNode) => {
      const renderExp = createCallExpression(helper(RENDER_LIST), [
        forNode.source
      ]);
      const isTemplate = isTemplateNode(node);
      const memo = findDir(node, "memo");
      const keyProp = findProp(node, `key`, false, true);
      if (keyProp && keyProp.type === 7 && !keyProp.exp) {
        transformBindShorthand(keyProp);
      }
      const keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
      const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
      const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
      const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
      forNode.codegenNode = createVNodeCall(
        context,
        helper(FRAGMENT),
        void 0,
        renderExp,
        fragmentFlag,
        void 0,
        void 0,
        true,
        !isStableFragment,
        false,
        node.loc
      );
      return () => {
        let childBlock;
        const { children } = forNode;
        if (( true) && isTemplate) {
          node.children.some((c) => {
            if (c.type === 1) {
              const key = findProp(c, "key");
              if (key) {
                context.onError(
                  createCompilerError(
                    33,
                    key.loc
                  )
                );
                return true;
              }
            }
          });
        }
        const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
        const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
        if (slotOutlet) {
          childBlock = slotOutlet.codegenNode;
          if (isTemplate && keyProperty) {
            injectProp(childBlock, keyProperty, context);
          }
        } else if (needFragmentWrapper) {
          childBlock = createVNodeCall(
            context,
            helper(FRAGMENT),
            keyProperty ? createObjectExpression([keyProperty]) : void 0,
            node.children,
            64,
            void 0,
            void 0,
            true,
            void 0,
            false
          );
        } else {
          childBlock = children[0].codegenNode;
          if (isTemplate && keyProperty) {
            injectProp(childBlock, keyProperty, context);
          }
          if (childBlock.isBlock !== !isStableFragment) {
            if (childBlock.isBlock) {
              removeHelper(OPEN_BLOCK);
              removeHelper(
                getVNodeBlockHelper(context.inSSR, childBlock.isComponent)
              );
            } else {
              removeHelper(
                getVNodeHelper(context.inSSR, childBlock.isComponent)
              );
            }
          }
          childBlock.isBlock = !isStableFragment;
          if (childBlock.isBlock) {
            helper(OPEN_BLOCK);
            helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
          } else {
            helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
          }
        }
        if (memo) {
          const loop = createFunctionExpression(
            createForLoopParams(forNode.parseResult, [
              createSimpleExpression(`_cached`)
            ])
          );
          loop.body = createBlockStatement([
            createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
            createCompoundExpression([
              `if (_cached`,
              ...keyExp ? [` && _cached.key === `, keyExp] : [],
              ` && ${context.helperString(
                IS_MEMO_SAME
              )}(_cached, _memo)) return _cached`
            ]),
            createCompoundExpression([`const _item = `, childBlock]),
            createSimpleExpression(`_item.memo = _memo`),
            createSimpleExpression(`return _item`)
          ]);
          renderExp.arguments.push(
            loop,
            createSimpleExpression(`_cache`),
            createSimpleExpression(String(context.cached++))
          );
        } else {
          renderExp.arguments.push(
            createFunctionExpression(
              createForLoopParams(forNode.parseResult),
              childBlock,
              true
            )
          );
        }
      };
    });
  }
);
function processFor(node, dir, context, processCodegen) {
  if (!dir.exp) {
    context.onError(
      createCompilerError(31, dir.loc)
    );
    return;
  }
  const parseResult = dir.forParseResult;
  if (!parseResult) {
    context.onError(
      createCompilerError(32, dir.loc)
    );
    return;
  }
  finalizeForParseResult(parseResult, context);
  const { addIdentifiers, removeIdentifiers, scopes } = context;
  const { source, value, key, index } = parseResult;
  const forNode = {
    type: 11,
    loc: dir.loc,
    source,
    valueAlias: value,
    keyAlias: key,
    objectIndexAlias: index,
    parseResult,
    children: isTemplateNode(node) ? node.children : [node]
  };
  context.replaceNode(forNode);
  scopes.vFor++;
  const onExit = processCodegen && processCodegen(forNode);
  return () => {
    scopes.vFor--;
    if (onExit) onExit();
  };
}
function finalizeForParseResult(result, context) {
  if (result.finalized) return;
  if (true) {
    validateBrowserExpression(result.source, context);
    if (result.key) {
      validateBrowserExpression(
        result.key,
        context,
        true
      );
    }
    if (result.index) {
      validateBrowserExpression(
        result.index,
        context,
        true
      );
    }
    if (result.value) {
      validateBrowserExpression(
        result.value,
        context,
        true
      );
    }
  }
  result.finalized = true;
}
function createForLoopParams({ value, key, index }, memoArgs = []) {
  return createParamsList([value, key, index, ...memoArgs]);
}
function createParamsList(args) {
  let i = args.length;
  while (i--) {
    if (args[i]) break;
  }
  return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
}

const defaultFallback = createSimpleExpression(`undefined`, false);
const trackSlotScopes = (node, context) => {
  if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
    const vSlot = findDir(node, "slot");
    if (vSlot) {
      vSlot.exp;
      context.scopes.vSlot++;
      return () => {
        context.scopes.vSlot--;
      };
    }
  }
};
const trackVForSlotScopes = (node, context) => {
  let vFor;
  if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
    const result = vFor.forParseResult;
    if (result) {
      finalizeForParseResult(result, context);
      const { value, key, index } = result;
      const { addIdentifiers, removeIdentifiers } = context;
      value && addIdentifiers(value);
      key && addIdentifiers(key);
      index && addIdentifiers(index);
      return () => {
        value && removeIdentifiers(value);
        key && removeIdentifiers(key);
        index && removeIdentifiers(index);
      };
    }
  }
};
const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(
  props,
  children,
  false,
  true,
  children.length ? children[0].loc : loc
);
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
  context.helper(WITH_CTX);
  const { children, loc } = node;
  const slotsProperties = [];
  const dynamicSlots = [];
  let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
  const onComponentSlot = findDir(node, "slot", true);
  if (onComponentSlot) {
    const { arg, exp } = onComponentSlot;
    if (arg && !isStaticExp(arg)) {
      hasDynamicSlots = true;
    }
    slotsProperties.push(
      createObjectProperty(
        arg || createSimpleExpression("default", true),
        buildSlotFn(exp, void 0, children, loc)
      )
    );
  }
  let hasTemplateSlots = false;
  let hasNamedDefaultSlot = false;
  const implicitDefaultChildren = [];
  const seenSlotNames = /* @__PURE__ */ new Set();
  let conditionalBranchIndex = 0;
  for (let i = 0; i < children.length; i++) {
    const slotElement = children[i];
    let slotDir;
    if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
      if (slotElement.type !== 3) {
        implicitDefaultChildren.push(slotElement);
      }
      continue;
    }
    if (onComponentSlot) {
      context.onError(
        createCompilerError(37, slotDir.loc)
      );
      break;
    }
    hasTemplateSlots = true;
    const { children: slotChildren, loc: slotLoc } = slotElement;
    const {
      arg: slotName = createSimpleExpression(`default`, true),
      exp: slotProps,
      loc: dirLoc
    } = slotDir;
    let staticSlotName;
    if (isStaticExp(slotName)) {
      staticSlotName = slotName ? slotName.content : `default`;
    } else {
      hasDynamicSlots = true;
    }
    const vFor = findDir(slotElement, "for");
    const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
    let vIf;
    let vElse;
    if (vIf = findDir(slotElement, "if")) {
      hasDynamicSlots = true;
      dynamicSlots.push(
        createConditionalExpression(
          vIf.exp,
          buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
          defaultFallback
        )
      );
    } else if (vElse = findDir(
      slotElement,
      /^else(-if)?$/,
      true
      /* allowEmpty */
    )) {
      let j = i;
      let prev;
      while (j--) {
        prev = children[j];
        if (prev.type !== 3) {
          break;
        }
      }
      if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) {
        let conditional = dynamicSlots[dynamicSlots.length - 1];
        while (conditional.alternate.type === 19) {
          conditional = conditional.alternate;
        }
        conditional.alternate = vElse.exp ? createConditionalExpression(
          vElse.exp,
          buildDynamicSlot(
            slotName,
            slotFunction,
            conditionalBranchIndex++
          ),
          defaultFallback
        ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
      } else {
        context.onError(
          createCompilerError(30, vElse.loc)
        );
      }
    } else if (vFor) {
      hasDynamicSlots = true;
      const parseResult = vFor.forParseResult;
      if (parseResult) {
        finalizeForParseResult(parseResult, context);
        dynamicSlots.push(
          createCallExpression(context.helper(RENDER_LIST), [
            parseResult.source,
            createFunctionExpression(
              createForLoopParams(parseResult),
              buildDynamicSlot(slotName, slotFunction),
              true
            )
          ])
        );
      } else {
        context.onError(
          createCompilerError(
            32,
            vFor.loc
          )
        );
      }
    } else {
      if (staticSlotName) {
        if (seenSlotNames.has(staticSlotName)) {
          context.onError(
            createCompilerError(
              38,
              dirLoc
            )
          );
          continue;
        }
        seenSlotNames.add(staticSlotName);
        if (staticSlotName === "default") {
          hasNamedDefaultSlot = true;
        }
      }
      slotsProperties.push(createObjectProperty(slotName, slotFunction));
    }
  }
  if (!onComponentSlot) {
    const buildDefaultSlotProperty = (props, children2) => {
      const fn = buildSlotFn(props, void 0, children2, loc);
      if (context.compatConfig) {
        fn.isNonScopedSlot = true;
      }
      return createObjectProperty(`default`, fn);
    };
    if (!hasTemplateSlots) {
      slotsProperties.push(buildDefaultSlotProperty(void 0, children));
    } else if (implicitDefaultChildren.length && // #3766
    // with whitespace: 'preserve', whitespaces between slots will end up in
    // implicitDefaultChildren. Ignore if all implicit children are whitespaces.
    implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
      if (hasNamedDefaultSlot) {
        context.onError(
          createCompilerError(
            39,
            implicitDefaultChildren[0].loc
          )
        );
      } else {
        slotsProperties.push(
          buildDefaultSlotProperty(void 0, implicitDefaultChildren)
        );
      }
    }
  }
  const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
  let slots = createObjectExpression(
    slotsProperties.concat(
      createObjectProperty(
        `_`,
        // 2 = compiled but dynamic = can skip normalization, but must run diff
        // 1 = compiled and static = can skip normalization AND diff as optimized
        createSimpleExpression(
          slotFlag + ( true ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.slotFlagsText[slotFlag]} */` : 0),
          false
        )
      )
    ),
    loc
  );
  if (dynamicSlots.length) {
    slots = createCallExpression(context.helper(CREATE_SLOTS), [
      slots,
      createArrayExpression(dynamicSlots)
    ]);
  }
  return {
    slots,
    hasDynamicSlots
  };
}
function buildDynamicSlot(name, fn, index) {
  const props = [
    createObjectProperty(`name`, name),
    createObjectProperty(`fn`, fn)
  ];
  if (index != null) {
    props.push(
      createObjectProperty(`key`, createSimpleExpression(String(index), true))
    );
  }
  return createObjectExpression(props);
}
function hasForwardedSlots(children) {
  for (let i = 0; i < children.length; i++) {
    const child = children[i];
    switch (child.type) {
      case 1:
        if (child.tagType === 2 || hasForwardedSlots(child.children)) {
          return true;
        }
        break;
      case 9:
        if (hasForwardedSlots(child.branches)) return true;
        break;
      case 10:
      case 11:
        if (hasForwardedSlots(child.children)) return true;
        break;
    }
  }
  return false;
}
function isNonWhitespaceContent(node) {
  if (node.type !== 2 && node.type !== 12)
    return true;
  return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
}

const directiveImportMap = /* @__PURE__ */ new WeakMap();
const transformElement = (node, context) => {
  return function postTransformElement() {
    node = context.currentNode;
    if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
      return;
    }
    const { tag, props } = node;
    const isComponent = node.tagType === 1;
    let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
    const isDynamicComponent = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
    let vnodeProps;
    let vnodeChildren;
    let patchFlag = 0;
    let vnodeDynamicProps;
    let dynamicPropNames;
    let vnodeDirectives;
    let shouldUseBlock = (
      // dynamic component may resolve to plain elements
      isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
      // updates inside get proper isSVG flag at runtime. (#639, #643)
      // This is technically web-specific, but splitting the logic out of core
      // leads to too much unnecessary complexity.
      (tag === "svg" || tag === "foreignObject" || tag === "math")
    );
    if (props.length > 0) {
      const propsBuildResult = buildProps(
        node,
        context,
        void 0,
        isComponent,
        isDynamicComponent
      );
      vnodeProps = propsBuildResult.props;
      patchFlag = propsBuildResult.patchFlag;
      dynamicPropNames = propsBuildResult.dynamicPropNames;
      const directives = propsBuildResult.directives;
      vnodeDirectives = directives && directives.length ? createArrayExpression(
        directives.map((dir) => buildDirectiveArgs(dir, context))
      ) : void 0;
      if (propsBuildResult.shouldUseBlock) {
        shouldUseBlock = true;
      }
    }
    if (node.children.length > 0) {
      if (vnodeTag === KEEP_ALIVE) {
        shouldUseBlock = true;
        patchFlag |= 1024;
        if ( true && node.children.length > 1) {
          context.onError(
            createCompilerError(46, {
              start: node.children[0].loc.start,
              end: node.children[node.children.length - 1].loc.end,
              source: ""
            })
          );
        }
      }
      const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling
      vnodeTag !== TELEPORT && // explained above.
      vnodeTag !== KEEP_ALIVE;
      if (shouldBuildAsSlots) {
        const { slots, hasDynamicSlots } = buildSlots(node, context);
        vnodeChildren = slots;
        if (hasDynamicSlots) {
          patchFlag |= 1024;
        }
      } else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
        const child = node.children[0];
        const type = child.type;
        const hasDynamicTextChild = type === 5 || type === 8;
        if (hasDynamicTextChild && getConstantType(child, context) === 0) {
          patchFlag |= 1;
        }
        if (hasDynamicTextChild || type === 2) {
          vnodeChildren = child;
        } else {
          vnodeChildren = node.children;
        }
      } else {
        vnodeChildren = node.children;
      }
    }
    if (dynamicPropNames && dynamicPropNames.length) {
      vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
    }
    node.codegenNode = createVNodeCall(
      context,
      vnodeTag,
      vnodeProps,
      vnodeChildren,
      patchFlag === 0 ? void 0 : patchFlag,
      vnodeDynamicProps,
      vnodeDirectives,
      !!shouldUseBlock,
      false,
      isComponent,
      node.loc
    );
  };
};
function resolveComponentType(node, context, ssr = false) {
  let { tag } = node;
  const isExplicitDynamic = isComponentTag(tag);
  const isProp = findProp(
    node,
    "is",
    false,
    true
    /* allow empty */
  );
  if (isProp) {
    if (isExplicitDynamic || isCompatEnabled(
      "COMPILER_IS_ON_ELEMENT",
      context
    )) {
      let exp;
      if (isProp.type === 6) {
        exp = isProp.value && createSimpleExpression(isProp.value.content, true);
      } else {
        exp = isProp.exp;
        if (!exp) {
          exp = createSimpleExpression(`is`, false, isProp.arg.loc);
        }
      }
      if (exp) {
        return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
          exp
        ]);
      }
    } else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
      tag = isProp.value.content.slice(4);
    }
  }
  const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
  if (builtIn) {
    if (!ssr) context.helper(builtIn);
    return builtIn;
  }
  context.helper(RESOLVE_COMPONENT);
  context.components.add(tag);
  return toValidAssetId(tag, `component`);
}
function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
  const { tag, loc: elementLoc, children } = node;
  let properties = [];
  const mergeArgs = [];
  const runtimeDirectives = [];
  const hasChildren = children.length > 0;
  let shouldUseBlock = false;
  let patchFlag = 0;
  let hasRef = false;
  let hasClassBinding = false;
  let hasStyleBinding = false;
  let hasHydrationEventBinding = false;
  let hasDynamicKeys = false;
  let hasVnodeHook = false;
  const dynamicPropNames = [];
  const pushMergeArg = (arg) => {
    if (properties.length) {
      mergeArgs.push(
        createObjectExpression(dedupeProperties(properties), elementLoc)
      );
      properties = [];
    }
    if (arg) mergeArgs.push(arg);
  };
  const pushRefVForMarker = () => {
    if (context.scopes.vFor > 0) {
      properties.push(
        createObjectProperty(
          createSimpleExpression("ref_for", true),
          createSimpleExpression("true")
        )
      );
    }
  };
  const analyzePatchFlag = ({ key, value }) => {
    if (isStaticExp(key)) {
      const name = key.content;
      const isEventHandler = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(name);
      if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click
      // dedicated fast path.
      name.toLowerCase() !== "onclick" && // omit v-model handlers
      name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks
      !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isReservedProp)(name)) {
        hasHydrationEventBinding = true;
      }
      if (isEventHandler && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isReservedProp)(name)) {
        hasVnodeHook = true;
      }
      if (isEventHandler && value.type === 14) {
        value = value.arguments[0];
      }
      if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
        return;
      }
      if (name === "ref") {
        hasRef = true;
      } else if (name === "class") {
        hasClassBinding = true;
      } else if (name === "style") {
        hasStyleBinding = true;
      } else if (name !== "key" && !dynamicPropNames.includes(name)) {
        dynamicPropNames.push(name);
      }
      if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
        dynamicPropNames.push(name);
      }
    } else {
      hasDynamicKeys = true;
    }
  };
  for (let i = 0; i < props.length; i++) {
    const prop = props[i];
    if (prop.type === 6) {
      const { loc, name, nameLoc, value } = prop;
      let isStatic = true;
      if (name === "ref") {
        hasRef = true;
        pushRefVForMarker();
      }
      if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled(
        "COMPILER_IS_ON_ELEMENT",
        context
      ))) {
        continue;
      }
      properties.push(
        createObjectProperty(
          createSimpleExpression(name, true, nameLoc),
          createSimpleExpression(
            value ? value.content : "",
            isStatic,
            value ? value.loc : loc
          )
        )
      );
    } else {
      const { name, arg, exp, loc, modifiers } = prop;
      const isVBind = name === "bind";
      const isVOn = name === "on";
      if (name === "slot") {
        if (!isComponent) {
          context.onError(
            createCompilerError(40, loc)
          );
        }
        continue;
      }
      if (name === "once" || name === "memo") {
        continue;
      }
      if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled(
        "COMPILER_IS_ON_ELEMENT",
        context
      ))) {
        continue;
      }
      if (isVOn && ssr) {
        continue;
      }
      if (
        // #938: elements with dynamic keys should be forced into blocks
        isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
        // before children
        isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
      ) {
        shouldUseBlock = true;
      }
      if (isVBind && isStaticArgOf(arg, "ref")) {
        pushRefVForMarker();
      }
      if (!arg && (isVBind || isVOn)) {
        hasDynamicKeys = true;
        if (exp) {
          if (isVBind) {
            pushRefVForMarker();
            pushMergeArg();
            {
              if (true) {
                const hasOverridableKeys = mergeArgs.some((arg2) => {
                  if (arg2.type === 15) {
                    return arg2.properties.some(({ key }) => {
                      if (key.type !== 4 || !key.isStatic) {
                        return true;
                      }
                      return key.content !== "class" && key.content !== "style" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(key.content);
                    });
                  } else {
                    return true;
                  }
                });
                if (hasOverridableKeys) {
                  checkCompatEnabled(
                    "COMPILER_V_BIND_OBJECT_ORDER",
                    context,
                    loc
                  );
                }
              }
              if (isCompatEnabled(
                "COMPILER_V_BIND_OBJECT_ORDER",
                context
              )) {
                mergeArgs.unshift(exp);
                continue;
              }
            }
            mergeArgs.push(exp);
          } else {
            pushMergeArg({
              type: 14,
              loc,
              callee: context.helper(TO_HANDLERS),
              arguments: isComponent ? [exp] : [exp, `true`]
            });
          }
        } else {
          context.onError(
            createCompilerError(
              isVBind ? 34 : 35,
              loc
            )
          );
        }
        continue;
      }
      if (isVBind && modifiers.includes("prop")) {
        patchFlag |= 32;
      }
      const directiveTransform = context.directiveTransforms[name];
      if (directiveTransform) {
        const { props: props2, needRuntime } = directiveTransform(prop, node, context);
        !ssr && props2.forEach(analyzePatchFlag);
        if (isVOn && arg && !isStaticExp(arg)) {
          pushMergeArg(createObjectExpression(props2, elementLoc));
        } else {
          properties.push(...props2);
        }
        if (needRuntime) {
          runtimeDirectives.push(prop);
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(needRuntime)) {
            directiveImportMap.set(prop, needRuntime);
          }
        }
      } else if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isBuiltInDirective)(name)) {
        runtimeDirectives.push(prop);
        if (hasChildren) {
          shouldUseBlock = true;
        }
      }
    }
  }
  let propsExpression = void 0;
  if (mergeArgs.length) {
    pushMergeArg();
    if (mergeArgs.length > 1) {
      propsExpression = createCallExpression(
        context.helper(MERGE_PROPS),
        mergeArgs,
        elementLoc
      );
    } else {
      propsExpression = mergeArgs[0];
    }
  } else if (properties.length) {
    propsExpression = createObjectExpression(
      dedupeProperties(properties),
      elementLoc
    );
  }
  if (hasDynamicKeys) {
    patchFlag |= 16;
  } else {
    if (hasClassBinding && !isComponent) {
      patchFlag |= 2;
    }
    if (hasStyleBinding && !isComponent) {
      patchFlag |= 4;
    }
    if (dynamicPropNames.length) {
      patchFlag |= 8;
    }
    if (hasHydrationEventBinding) {
      patchFlag |= 32;
    }
  }
  if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
    patchFlag |= 512;
  }
  if (!context.inSSR && propsExpression) {
    switch (propsExpression.type) {
      case 15:
        let classKeyIndex = -1;
        let styleKeyIndex = -1;
        let hasDynamicKey = false;
        for (let i = 0; i < propsExpression.properties.length; i++) {
          const key = propsExpression.properties[i].key;
          if (isStaticExp(key)) {
            if (key.content === "class") {
              classKeyIndex = i;
            } else if (key.content === "style") {
              styleKeyIndex = i;
            }
          } else if (!key.isHandlerKey) {
            hasDynamicKey = true;
          }
        }
        const classProp = propsExpression.properties[classKeyIndex];
        const styleProp = propsExpression.properties[styleKeyIndex];
        if (!hasDynamicKey) {
          if (classProp && !isStaticExp(classProp.value)) {
            classProp.value = createCallExpression(
              context.helper(NORMALIZE_CLASS),
              [classProp.value]
            );
          }
          if (styleProp && // the static style is compiled into an object,
          // so use `hasStyleBinding` to ensure that it is a dynamic style binding
          (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,
          // v-bind:style with static literal object
          styleProp.value.type === 17)) {
            styleProp.value = createCallExpression(
              context.helper(NORMALIZE_STYLE),
              [styleProp.value]
            );
          }
        } else {
          propsExpression = createCallExpression(
            context.helper(NORMALIZE_PROPS),
            [propsExpression]
          );
        }
        break;
      case 14:
        break;
      default:
        propsExpression = createCallExpression(
          context.helper(NORMALIZE_PROPS),
          [
            createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
              propsExpression
            ])
          ]
        );
        break;
    }
  }
  return {
    props: propsExpression,
    directives: runtimeDirectives,
    patchFlag,
    dynamicPropNames,
    shouldUseBlock
  };
}
function dedupeProperties(properties) {
  const knownProps = /* @__PURE__ */ new Map();
  const deduped = [];
  for (let i = 0; i < properties.length; i++) {
    const prop = properties[i];
    if (prop.key.type === 8 || !prop.key.isStatic) {
      deduped.push(prop);
      continue;
    }
    const name = prop.key.content;
    const existing = knownProps.get(name);
    if (existing) {
      if (name === "style" || name === "class" || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isOn)(name)) {
        mergeAsArray(existing, prop);
      }
    } else {
      knownProps.set(name, prop);
      deduped.push(prop);
    }
  }
  return deduped;
}
function mergeAsArray(existing, incoming) {
  if (existing.value.type === 17) {
    existing.value.elements.push(incoming.value);
  } else {
    existing.value = createArrayExpression(
      [existing.value, incoming.value],
      existing.loc
    );
  }
}
function buildDirectiveArgs(dir, context) {
  const dirArgs = [];
  const runtime = directiveImportMap.get(dir);
  if (runtime) {
    dirArgs.push(context.helperString(runtime));
  } else {
    {
      context.helper(RESOLVE_DIRECTIVE);
      context.directives.add(dir.name);
      dirArgs.push(toValidAssetId(dir.name, `directive`));
    }
  }
  const { loc } = dir;
  if (dir.exp) dirArgs.push(dir.exp);
  if (dir.arg) {
    if (!dir.exp) {
      dirArgs.push(`void 0`);
    }
    dirArgs.push(dir.arg);
  }
  if (Object.keys(dir.modifiers).length) {
    if (!dir.arg) {
      if (!dir.exp) {
        dirArgs.push(`void 0`);
      }
      dirArgs.push(`void 0`);
    }
    const trueExpression = createSimpleExpression(`true`, false, loc);
    dirArgs.push(
      createObjectExpression(
        dir.modifiers.map(
          (modifier) => createObjectProperty(modifier, trueExpression)
        ),
        loc
      )
    );
  }
  return createArrayExpression(dirArgs, dir.loc);
}
function stringifyDynamicPropNames(props) {
  let propsNamesString = `[`;
  for (let i = 0, l = props.length; i < l; i++) {
    propsNamesString += JSON.stringify(props[i]);
    if (i < l - 1) propsNamesString += ", ";
  }
  return propsNamesString + `]`;
}
function isComponentTag(tag) {
  return tag === "component" || tag === "Component";
}

const transformSlotOutlet = (node, context) => {
  if (isSlotOutlet(node)) {
    const { children, loc } = node;
    const { slotName, slotProps } = processSlotOutlet(node, context);
    const slotArgs = [
      context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
      slotName,
      "{}",
      "undefined",
      "true"
    ];
    let expectedLen = 2;
    if (slotProps) {
      slotArgs[2] = slotProps;
      expectedLen = 3;
    }
    if (children.length) {
      slotArgs[3] = createFunctionExpression([], children, false, false, loc);
      expectedLen = 4;
    }
    if (context.scopeId && !context.slotted) {
      expectedLen = 5;
    }
    slotArgs.splice(expectedLen);
    node.codegenNode = createCallExpression(
      context.helper(RENDER_SLOT),
      slotArgs,
      loc
    );
  }
};
function processSlotOutlet(node, context) {
  let slotName = `"default"`;
  let slotProps = void 0;
  const nonNameProps = [];
  for (let i = 0; i < node.props.length; i++) {
    const p = node.props[i];
    if (p.type === 6) {
      if (p.value) {
        if (p.name === "name") {
          slotName = JSON.stringify(p.value.content);
        } else {
          p.name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(p.name);
          nonNameProps.push(p);
        }
      }
    } else {
      if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
        if (p.exp) {
          slotName = p.exp;
        } else if (p.arg && p.arg.type === 4) {
          const name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(p.arg.content);
          slotName = p.exp = createSimpleExpression(name, false, p.arg.loc);
        }
      } else {
        if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
          p.arg.content = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(p.arg.content);
        }
        nonNameProps.push(p);
      }
    }
  }
  if (nonNameProps.length > 0) {
    const { props, directives } = buildProps(
      node,
      context,
      nonNameProps,
      false,
      false
    );
    slotProps = props;
    if (directives.length) {
      context.onError(
        createCompilerError(
          36,
          directives[0].loc
        )
      );
    }
  }
  return {
    slotName,
    slotProps
  };
}

const transformOn = (dir, node, context, augmentor) => {
  const { loc, modifiers, arg } = dir;
  if (!dir.exp && !modifiers.length) {
    context.onError(createCompilerError(35, loc));
  }
  let eventName;
  if (arg.type === 4) {
    if (arg.isStatic) {
      let rawName = arg.content;
      if ( true && rawName.startsWith("vnode")) {
        context.onError(createCompilerError(51, arg.loc));
      }
      if (rawName.startsWith("vue:")) {
        rawName = `vnode-${rawName.slice(4)}`;
      }
      const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? (
        // for non-element and vnode lifecycle event listeners, auto convert
        // it to camelCase. See issue #2249
        (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(rawName))
      ) : (
        // preserve case for plain element listeners that have uppercase
        // letters, as these may be custom elements' custom events
        `on:${rawName}`
      );
      eventName = createSimpleExpression(eventString, true, arg.loc);
    } else {
      eventName = createCompoundExpression([
        `${context.helperString(TO_HANDLER_KEY)}(`,
        arg,
        `)`
      ]);
    }
  } else {
    eventName = arg;
    eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
    eventName.children.push(`)`);
  }
  let exp = dir.exp;
  if (exp && !exp.content.trim()) {
    exp = void 0;
  }
  let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
  if (exp) {
    const isMemberExp = isMemberExpression(exp);
    const isInlineStatement = !(isMemberExp || isFnExpression(exp));
    const hasMultipleStatements = exp.content.includes(`;`);
    if (true) {
      validateBrowserExpression(
        exp,
        context,
        false,
        hasMultipleStatements
      );
    }
    if (isInlineStatement || shouldCache && isMemberExp) {
      exp = createCompoundExpression([
        `${isInlineStatement ? `$event` : `${``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
        exp,
        hasMultipleStatements ? `}` : `)`
      ]);
    }
  }
  let ret = {
    props: [
      createObjectProperty(
        eventName,
        exp || createSimpleExpression(`() => {}`, false, loc)
      )
    ]
  };
  if (augmentor) {
    ret = augmentor(ret);
  }
  if (shouldCache) {
    ret.props[0].value = context.cache(ret.props[0].value);
  }
  ret.props.forEach((p) => p.key.isHandlerKey = true);
  return ret;
};

const transformText = (node, context) => {
  if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
    return () => {
      const children = node.children;
      let currentContainer = void 0;
      let hasText = false;
      for (let i = 0; i < children.length; i++) {
        const child = children[i];
        if (isText$1(child)) {
          hasText = true;
          for (let j = i + 1; j < children.length; j++) {
            const next = children[j];
            if (isText$1(next)) {
              if (!currentContainer) {
                currentContainer = children[i] = createCompoundExpression(
                  [child],
                  child.loc
                );
              }
              currentContainer.children.push(` + `, next);
              children.splice(j, 1);
              j--;
            } else {
              currentContainer = void 0;
              break;
            }
          }
        }
      }
      if (!hasText || // if this is a plain element with a single text child, leave it
      // as-is since the runtime has dedicated fast path for this by directly
      // setting textContent of the element.
      // for component root it's always normalized anyway.
      children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
      // custom directives can potentially add DOM elements arbitrarily,
      // we need to avoid setting textContent of the element at runtime
      // to avoid accidentally overwriting the DOM elements added
      // by the user through custom directives.
      !node.props.find(
        (p) => p.type === 7 && !context.directiveTransforms[p.name]
      ) && // in compat mode, <template> tags with no special directives
      // will be rendered as a fragment so its children must be
      // converted into vnodes.
      !(node.tag === "template"))) {
        return;
      }
      for (let i = 0; i < children.length; i++) {
        const child = children[i];
        if (isText$1(child) || child.type === 8) {
          const callArgs = [];
          if (child.type !== 2 || child.content !== " ") {
            callArgs.push(child);
          }
          if (!context.ssr && getConstantType(child, context) === 0) {
            callArgs.push(
              1 + ( true ? ` /* ${_vue_shared__WEBPACK_IMPORTED_MODULE_0__.PatchFlagNames[1]} */` : 0)
            );
          }
          children[i] = {
            type: 12,
            content: child,
            loc: child.loc,
            codegenNode: createCallExpression(
              context.helper(CREATE_TEXT),
              callArgs
            )
          };
        }
      }
    };
  }
};

const seen$1 = /* @__PURE__ */ new WeakSet();
const transformOnce = (node, context) => {
  if (node.type === 1 && findDir(node, "once", true)) {
    if (seen$1.has(node) || context.inVOnce || context.inSSR) {
      return;
    }
    seen$1.add(node);
    context.inVOnce = true;
    context.helper(SET_BLOCK_TRACKING);
    return () => {
      context.inVOnce = false;
      const cur = context.currentNode;
      if (cur.codegenNode) {
        cur.codegenNode = context.cache(
          cur.codegenNode,
          true
          /* isVNode */
        );
      }
    };
  }
};

const transformModel = (dir, node, context) => {
  const { exp, arg } = dir;
  if (!exp) {
    context.onError(
      createCompilerError(41, dir.loc)
    );
    return createTransformProps();
  }
  const rawExp = exp.loc.source;
  const expString = exp.type === 4 ? exp.content : rawExp;
  const bindingType = context.bindingMetadata[rawExp];
  if (bindingType === "props" || bindingType === "props-aliased") {
    context.onError(createCompilerError(44, exp.loc));
    return createTransformProps();
  }
  const maybeRef = false;
  if (!expString.trim() || !isMemberExpression(exp) && !maybeRef) {
    context.onError(
      createCompilerError(42, exp.loc)
    );
    return createTransformProps();
  }
  const propName = arg ? arg : createSimpleExpression("modelValue", true);
  const eventName = arg ? isStaticExp(arg) ? `onUpdate:${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.camelize)(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
  let assignmentExp;
  const eventArg = context.isTS ? `($event: any)` : `$event`;
  {
    assignmentExp = createCompoundExpression([
      `${eventArg} => ((`,
      exp,
      `) = $event)`
    ]);
  }
  const props = [
    // modelValue: foo
    createObjectProperty(propName, dir.exp),
    // "onUpdate:modelValue": $event => (foo = $event)
    createObjectProperty(eventName, assignmentExp)
  ];
  if (dir.modifiers.length && node.tagType === 1) {
    const modifiers = dir.modifiers.map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
    const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
    props.push(
      createObjectProperty(
        modifiersKey,
        createSimpleExpression(
          `{ ${modifiers} }`,
          false,
          dir.loc,
          2
        )
      )
    );
  }
  return createTransformProps(props);
};
function createTransformProps(props = []) {
  return { props };
}

const validDivisionCharRE = /[\w).+\-_$\]]/;
const transformFilter = (node, context) => {
  if (!isCompatEnabled("COMPILER_FILTERS", context)) {
    return;
  }
  if (node.type === 5) {
    rewriteFilter(node.content, context);
  } else if (node.type === 1) {
    node.props.forEach((prop) => {
      if (prop.type === 7 && prop.name !== "for" && prop.exp) {
        rewriteFilter(prop.exp, context);
      }
    });
  }
};
function rewriteFilter(node, context) {
  if (node.type === 4) {
    parseFilter(node, context);
  } else {
    for (let i = 0; i < node.children.length; i++) {
      const child = node.children[i];
      if (typeof child !== "object") continue;
      if (child.type === 4) {
        parseFilter(child, context);
      } else if (child.type === 8) {
        rewriteFilter(node, context);
      } else if (child.type === 5) {
        rewriteFilter(child.content, context);
      }
    }
  }
}
function parseFilter(node, context) {
  const exp = node.content;
  let inSingle = false;
  let inDouble = false;
  let inTemplateString = false;
  let inRegex = false;
  let curly = 0;
  let square = 0;
  let paren = 0;
  let lastFilterIndex = 0;
  let c, prev, i, expression, filters = [];
  for (i = 0; i < exp.length; i++) {
    prev = c;
    c = exp.charCodeAt(i);
    if (inSingle) {
      if (c === 39 && prev !== 92) inSingle = false;
    } else if (inDouble) {
      if (c === 34 && prev !== 92) inDouble = false;
    } else if (inTemplateString) {
      if (c === 96 && prev !== 92) inTemplateString = false;
    } else if (inRegex) {
      if (c === 47 && prev !== 92) inRegex = false;
    } else if (c === 124 && // pipe
    exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
      if (expression === void 0) {
        lastFilterIndex = i + 1;
        expression = exp.slice(0, i).trim();
      } else {
        pushFilter();
      }
    } else {
      switch (c) {
        case 34:
          inDouble = true;
          break;
        case 39:
          inSingle = true;
          break;
        case 96:
          inTemplateString = true;
          break;
        case 40:
          paren++;
          break;
        case 41:
          paren--;
          break;
        case 91:
          square++;
          break;
        case 93:
          square--;
          break;
        case 123:
          curly++;
          break;
        case 125:
          curly--;
          break;
      }
      if (c === 47) {
        let j = i - 1;
        let p;
        for (; j >= 0; j--) {
          p = exp.charAt(j);
          if (p !== " ") break;
        }
        if (!p || !validDivisionCharRE.test(p)) {
          inRegex = true;
        }
      }
    }
  }
  if (expression === void 0) {
    expression = exp.slice(0, i).trim();
  } else if (lastFilterIndex !== 0) {
    pushFilter();
  }
  function pushFilter() {
    filters.push(exp.slice(lastFilterIndex, i).trim());
    lastFilterIndex = i + 1;
  }
  if (filters.length) {
     true && warnDeprecation(
      "COMPILER_FILTERS",
      context,
      node.loc
    );
    for (i = 0; i < filters.length; i++) {
      expression = wrapFilter(expression, filters[i], context);
    }
    node.content = expression;
    node.ast = void 0;
  }
}
function wrapFilter(exp, filter, context) {
  context.helper(RESOLVE_FILTER);
  const i = filter.indexOf("(");
  if (i < 0) {
    context.filters.add(filter);
    return `${toValidAssetId(filter, "filter")}(${exp})`;
  } else {
    const name = filter.slice(0, i);
    const args = filter.slice(i + 1);
    context.filters.add(name);
    return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
  }
}

const seen = /* @__PURE__ */ new WeakSet();
const transformMemo = (node, context) => {
  if (node.type === 1) {
    const dir = findDir(node, "memo");
    if (!dir || seen.has(node)) {
      return;
    }
    seen.add(node);
    return () => {
      const codegenNode = node.codegenNode || context.currentNode.codegenNode;
      if (codegenNode && codegenNode.type === 13) {
        if (node.tagType !== 1) {
          convertToBlock(codegenNode, context);
        }
        node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
          dir.exp,
          createFunctionExpression(void 0, codegenNode),
          `_cache`,
          String(context.cached++)
        ]);
      }
    };
  }
};

function getBaseTransformPreset(prefixIdentifiers) {
  return [
    [
      transformOnce,
      transformIf,
      transformMemo,
      transformFor,
      ...[transformFilter] ,
      ... true ? [transformExpression] : 0,
      transformSlotOutlet,
      transformElement,
      trackSlotScopes,
      transformText
    ],
    {
      on: transformOn,
      bind: transformBind,
      model: transformModel
    }
  ];
}
function baseCompile(source, options = {}) {
  const onError = options.onError || defaultOnError;
  const isModuleMode = options.mode === "module";
  {
    if (options.prefixIdentifiers === true) {
      onError(createCompilerError(47));
    } else if (isModuleMode) {
      onError(createCompilerError(48));
    }
  }
  const prefixIdentifiers = false;
  if (options.cacheHandlers) {
    onError(createCompilerError(49));
  }
  if (options.scopeId && !isModuleMode) {
    onError(createCompilerError(50));
  }
  const resolvedOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, options, {
    prefixIdentifiers
  });
  const ast = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isString)(source) ? baseParse(source, resolvedOptions) : source;
  const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
  transform(
    ast,
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({}, resolvedOptions, {
      nodeTransforms: [
        ...nodeTransforms,
        ...options.nodeTransforms || []
        // user transforms
      ],
      directiveTransforms: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)(
        {},
        directiveTransforms,
        options.directiveTransforms || {}
        // user transforms
      )
    })
  );
  return generate(ast, resolvedOptions);
}

const BindingTypes = {
  "DATA": "data",
  "PROPS": "props",
  "PROPS_ALIASED": "props-aliased",
  "SETUP_LET": "setup-let",
  "SETUP_CONST": "setup-const",
  "SETUP_REACTIVE_CONST": "setup-reactive-const",
  "SETUP_MAYBE_REF": "setup-maybe-ref",
  "SETUP_REF": "setup-ref",
  "OPTIONS": "options",
  "LITERAL_CONST": "literal-const"
};

const noopDirectiveTransform = () => ({ props: [] });




/***/ }),

/***/ "./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js":
/*!*************************************************************************!*\
  !*** ./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js ***!
  \*************************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   BASE_TRANSITION: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.BASE_TRANSITION),
/* harmony export */   BindingTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.BindingTypes),
/* harmony export */   CAMELIZE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CAMELIZE),
/* harmony export */   CAPITALIZE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CAPITALIZE),
/* harmony export */   CREATE_BLOCK: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_BLOCK),
/* harmony export */   CREATE_COMMENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_COMMENT),
/* harmony export */   CREATE_ELEMENT_BLOCK: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_ELEMENT_BLOCK),
/* harmony export */   CREATE_ELEMENT_VNODE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_ELEMENT_VNODE),
/* harmony export */   CREATE_SLOTS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_SLOTS),
/* harmony export */   CREATE_STATIC: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_STATIC),
/* harmony export */   CREATE_TEXT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_TEXT),
/* harmony export */   CREATE_VNODE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CREATE_VNODE),
/* harmony export */   CompilerDeprecationTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.CompilerDeprecationTypes),
/* harmony export */   ConstantTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.ConstantTypes),
/* harmony export */   DOMDirectiveTransforms: () => (/* binding */ DOMDirectiveTransforms),
/* harmony export */   DOMErrorCodes: () => (/* binding */ DOMErrorCodes),
/* harmony export */   DOMErrorMessages: () => (/* binding */ DOMErrorMessages),
/* harmony export */   DOMNodeTransforms: () => (/* binding */ DOMNodeTransforms),
/* harmony export */   ElementTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.ElementTypes),
/* harmony export */   ErrorCodes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes),
/* harmony export */   FRAGMENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.FRAGMENT),
/* harmony export */   GUARD_REACTIVE_PROPS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.GUARD_REACTIVE_PROPS),
/* harmony export */   IS_MEMO_SAME: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.IS_MEMO_SAME),
/* harmony export */   IS_REF: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.IS_REF),
/* harmony export */   KEEP_ALIVE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.KEEP_ALIVE),
/* harmony export */   MERGE_PROPS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.MERGE_PROPS),
/* harmony export */   NORMALIZE_CLASS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_CLASS),
/* harmony export */   NORMALIZE_PROPS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_PROPS),
/* harmony export */   NORMALIZE_STYLE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NORMALIZE_STYLE),
/* harmony export */   Namespaces: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.Namespaces),
/* harmony export */   NodeTypes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.NodeTypes),
/* harmony export */   OPEN_BLOCK: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.OPEN_BLOCK),
/* harmony export */   POP_SCOPE_ID: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.POP_SCOPE_ID),
/* harmony export */   PUSH_SCOPE_ID: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.PUSH_SCOPE_ID),
/* harmony export */   RENDER_LIST: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RENDER_LIST),
/* harmony export */   RENDER_SLOT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RENDER_SLOT),
/* harmony export */   RESOLVE_COMPONENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_COMPONENT),
/* harmony export */   RESOLVE_DIRECTIVE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_DIRECTIVE),
/* harmony export */   RESOLVE_DYNAMIC_COMPONENT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_DYNAMIC_COMPONENT),
/* harmony export */   RESOLVE_FILTER: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.RESOLVE_FILTER),
/* harmony export */   SET_BLOCK_TRACKING: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.SET_BLOCK_TRACKING),
/* harmony export */   SUSPENSE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.SUSPENSE),
/* harmony export */   TELEPORT: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TELEPORT),
/* harmony export */   TO_DISPLAY_STRING: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_DISPLAY_STRING),
/* harmony export */   TO_HANDLERS: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_HANDLERS),
/* harmony export */   TO_HANDLER_KEY: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_HANDLER_KEY),
/* harmony export */   TRANSITION: () => (/* binding */ TRANSITION),
/* harmony export */   TRANSITION_GROUP: () => (/* binding */ TRANSITION_GROUP),
/* harmony export */   TS_NODE_TYPES: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TS_NODE_TYPES),
/* harmony export */   UNREF: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.UNREF),
/* harmony export */   V_MODEL_CHECKBOX: () => (/* binding */ V_MODEL_CHECKBOX),
/* harmony export */   V_MODEL_DYNAMIC: () => (/* binding */ V_MODEL_DYNAMIC),
/* harmony export */   V_MODEL_RADIO: () => (/* binding */ V_MODEL_RADIO),
/* harmony export */   V_MODEL_SELECT: () => (/* binding */ V_MODEL_SELECT),
/* harmony export */   V_MODEL_TEXT: () => (/* binding */ V_MODEL_TEXT),
/* harmony export */   V_ON_WITH_KEYS: () => (/* binding */ V_ON_WITH_KEYS),
/* harmony export */   V_ON_WITH_MODIFIERS: () => (/* binding */ V_ON_WITH_MODIFIERS),
/* harmony export */   V_SHOW: () => (/* binding */ V_SHOW),
/* harmony export */   WITH_CTX: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_CTX),
/* harmony export */   WITH_DIRECTIVES: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_DIRECTIVES),
/* harmony export */   WITH_MEMO: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.WITH_MEMO),
/* harmony export */   advancePositionWithClone: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.advancePositionWithClone),
/* harmony export */   advancePositionWithMutation: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.advancePositionWithMutation),
/* harmony export */   assert: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.assert),
/* harmony export */   baseCompile: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseCompile),
/* harmony export */   baseParse: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseParse),
/* harmony export */   buildDirectiveArgs: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildDirectiveArgs),
/* harmony export */   buildProps: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildProps),
/* harmony export */   buildSlots: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.buildSlots),
/* harmony export */   checkCompatEnabled: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.checkCompatEnabled),
/* harmony export */   compile: () => (/* binding */ compile),
/* harmony export */   convertToBlock: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.convertToBlock),
/* harmony export */   createArrayExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createArrayExpression),
/* harmony export */   createAssignmentExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createAssignmentExpression),
/* harmony export */   createBlockStatement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createBlockStatement),
/* harmony export */   createCacheExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCacheExpression),
/* harmony export */   createCallExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression),
/* harmony export */   createCompilerError: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompilerError),
/* harmony export */   createCompoundExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression),
/* harmony export */   createConditionalExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createConditionalExpression),
/* harmony export */   createDOMCompilerError: () => (/* binding */ createDOMCompilerError),
/* harmony export */   createForLoopParams: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createForLoopParams),
/* harmony export */   createFunctionExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createFunctionExpression),
/* harmony export */   createIfStatement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createIfStatement),
/* harmony export */   createInterpolation: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createInterpolation),
/* harmony export */   createObjectExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectExpression),
/* harmony export */   createObjectProperty: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty),
/* harmony export */   createReturnStatement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createReturnStatement),
/* harmony export */   createRoot: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createRoot),
/* harmony export */   createSequenceExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSequenceExpression),
/* harmony export */   createSimpleExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression),
/* harmony export */   createStructuralDirectiveTransform: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createStructuralDirectiveTransform),
/* harmony export */   createTemplateLiteral: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createTemplateLiteral),
/* harmony export */   createTransformContext: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createTransformContext),
/* harmony export */   createVNodeCall: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createVNodeCall),
/* harmony export */   errorMessages: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.errorMessages),
/* harmony export */   extractIdentifiers: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.extractIdentifiers),
/* harmony export */   findDir: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findDir),
/* harmony export */   findProp: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findProp),
/* harmony export */   forAliasRE: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.forAliasRE),
/* harmony export */   generate: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.generate),
/* harmony export */   generateCodeFrame: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.generateCodeFrame),
/* harmony export */   getBaseTransformPreset: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getBaseTransformPreset),
/* harmony export */   getConstantType: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getConstantType),
/* harmony export */   getMemoedVNodeCall: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getMemoedVNodeCall),
/* harmony export */   getVNodeBlockHelper: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getVNodeBlockHelper),
/* harmony export */   getVNodeHelper: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getVNodeHelper),
/* harmony export */   hasDynamicKeyVBind: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasDynamicKeyVBind),
/* harmony export */   hasScopeRef: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasScopeRef),
/* harmony export */   helperNameMap: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.helperNameMap),
/* harmony export */   injectProp: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.injectProp),
/* harmony export */   isCoreComponent: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isCoreComponent),
/* harmony export */   isFnExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFnExpression),
/* harmony export */   isFnExpressionBrowser: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFnExpressionBrowser),
/* harmony export */   isFnExpressionNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFnExpressionNode),
/* harmony export */   isFunctionType: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isFunctionType),
/* harmony export */   isInDestructureAssignment: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isInDestructureAssignment),
/* harmony export */   isInNewExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isInNewExpression),
/* harmony export */   isMemberExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpression),
/* harmony export */   isMemberExpressionBrowser: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpressionBrowser),
/* harmony export */   isMemberExpressionNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isMemberExpressionNode),
/* harmony export */   isReferencedIdentifier: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isReferencedIdentifier),
/* harmony export */   isSimpleIdentifier: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isSimpleIdentifier),
/* harmony export */   isSlotOutlet: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isSlotOutlet),
/* harmony export */   isStaticArgOf: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticArgOf),
/* harmony export */   isStaticExp: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp),
/* harmony export */   isStaticProperty: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticProperty),
/* harmony export */   isStaticPropertyKey: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticPropertyKey),
/* harmony export */   isTemplateNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isTemplateNode),
/* harmony export */   isText: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isText),
/* harmony export */   isVSlot: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isVSlot),
/* harmony export */   locStub: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.locStub),
/* harmony export */   noopDirectiveTransform: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.noopDirectiveTransform),
/* harmony export */   parse: () => (/* binding */ parse),
/* harmony export */   parserOptions: () => (/* binding */ parserOptions),
/* harmony export */   processExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processExpression),
/* harmony export */   processFor: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processFor),
/* harmony export */   processIf: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processIf),
/* harmony export */   processSlotOutlet: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.processSlotOutlet),
/* harmony export */   registerRuntimeHelpers: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeHelpers),
/* harmony export */   resolveComponentType: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.resolveComponentType),
/* harmony export */   stringifyExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.stringifyExpression),
/* harmony export */   toValidAssetId: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.toValidAssetId),
/* harmony export */   trackSlotScopes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.trackSlotScopes),
/* harmony export */   trackVForSlotScopes: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.trackVForSlotScopes),
/* harmony export */   transform: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transform),
/* harmony export */   transformBind: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformBind),
/* harmony export */   transformElement: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformElement),
/* harmony export */   transformExpression: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformExpression),
/* harmony export */   transformModel: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformModel),
/* harmony export */   transformOn: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformOn),
/* harmony export */   transformStyle: () => (/* binding */ transformStyle),
/* harmony export */   traverseNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.traverseNode),
/* harmony export */   unwrapTSNode: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.unwrapTSNode),
/* harmony export */   walkBlockDeclarations: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkBlockDeclarations),
/* harmony export */   walkFunctionParams: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkFunctionParams),
/* harmony export */   walkIdentifiers: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.walkIdentifiers),
/* harmony export */   warnDeprecation: () => (/* reexport safe */ _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.warnDeprecation)
/* harmony export */ });
/* harmony import */ var _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/compiler-core */ "./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js");
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
/**
* @vue/compiler-dom v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/




const V_MODEL_RADIO = Symbol( true ? `vModelRadio` : 0);
const V_MODEL_CHECKBOX = Symbol( true ? `vModelCheckbox` : 0);
const V_MODEL_TEXT = Symbol( true ? `vModelText` : 0);
const V_MODEL_SELECT = Symbol( true ? `vModelSelect` : 0);
const V_MODEL_DYNAMIC = Symbol( true ? `vModelDynamic` : 0);
const V_ON_WITH_MODIFIERS = Symbol( true ? `vOnModifiersGuard` : 0);
const V_ON_WITH_KEYS = Symbol( true ? `vOnKeysGuard` : 0);
const V_SHOW = Symbol( true ? `vShow` : 0);
const TRANSITION = Symbol( true ? `Transition` : 0);
const TRANSITION_GROUP = Symbol( true ? `TransitionGroup` : 0);
(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeHelpers)({
  [V_MODEL_RADIO]: `vModelRadio`,
  [V_MODEL_CHECKBOX]: `vModelCheckbox`,
  [V_MODEL_TEXT]: `vModelText`,
  [V_MODEL_SELECT]: `vModelSelect`,
  [V_MODEL_DYNAMIC]: `vModelDynamic`,
  [V_ON_WITH_MODIFIERS]: `withModifiers`,
  [V_ON_WITH_KEYS]: `withKeys`,
  [V_SHOW]: `vShow`,
  [TRANSITION]: `Transition`,
  [TRANSITION_GROUP]: `TransitionGroup`
});

let decoder;
function decodeHtmlBrowser(raw, asAttr = false) {
  if (!decoder) {
    decoder = document.createElement("div");
  }
  if (asAttr) {
    decoder.innerHTML = `<div foo="${raw.replace(/"/g, "&quot;")}">`;
    return decoder.children[0].getAttribute("foo");
  } else {
    decoder.innerHTML = raw;
    return decoder.textContent;
  }
}

const parserOptions = {
  parseMode: "html",
  isVoidTag: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.isVoidTag,
  isNativeTag: (tag) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isHTMLTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSVGTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isMathMLTag)(tag),
  isPreTag: (tag) => tag === "pre",
  decodeEntities: decodeHtmlBrowser ,
  isBuiltInComponent: (tag) => {
    if (tag === "Transition" || tag === "transition") {
      return TRANSITION;
    } else if (tag === "TransitionGroup" || tag === "transition-group") {
      return TRANSITION_GROUP;
    }
  },
  // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
  getNamespace(tag, parent, rootNamespace) {
    let ns = parent ? parent.ns : rootNamespace;
    if (parent && ns === 2) {
      if (parent.tag === "annotation-xml") {
        if (tag === "svg") {
          return 1;
        }
        if (parent.props.some(
          (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
        )) {
          ns = 0;
        }
      } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
        ns = 0;
      }
    } else if (parent && ns === 1) {
      if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
        ns = 0;
      }
    }
    if (ns === 0) {
      if (tag === "svg") {
        return 1;
      }
      if (tag === "math") {
        return 2;
      }
    }
    return ns;
  }
};

const transformStyle = (node) => {
  if (node.type === 1) {
    node.props.forEach((p, i) => {
      if (p.type === 6 && p.name === "style" && p.value) {
        node.props[i] = {
          type: 7,
          name: `bind`,
          arg: (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`style`, true, p.loc),
          exp: parseInlineCSS(p.value.content, p.loc),
          modifiers: [],
          loc: p.loc
        };
      }
    });
  }
};
const parseInlineCSS = (cssText, loc) => {
  const normalized = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.parseStringStyle)(cssText);
  return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(
    JSON.stringify(normalized),
    false,
    loc,
    3
  );
};

function createDOMCompilerError(code, loc) {
  return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompilerError)(
    code,
    loc,
     true ? DOMErrorMessages : 0
  );
}
const DOMErrorCodes = {
  "X_V_HTML_NO_EXPRESSION": 53,
  "53": "X_V_HTML_NO_EXPRESSION",
  "X_V_HTML_WITH_CHILDREN": 54,
  "54": "X_V_HTML_WITH_CHILDREN",
  "X_V_TEXT_NO_EXPRESSION": 55,
  "55": "X_V_TEXT_NO_EXPRESSION",
  "X_V_TEXT_WITH_CHILDREN": 56,
  "56": "X_V_TEXT_WITH_CHILDREN",
  "X_V_MODEL_ON_INVALID_ELEMENT": 57,
  "57": "X_V_MODEL_ON_INVALID_ELEMENT",
  "X_V_MODEL_ARG_ON_ELEMENT": 58,
  "58": "X_V_MODEL_ARG_ON_ELEMENT",
  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
  "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
  "X_V_MODEL_UNNECESSARY_VALUE": 60,
  "60": "X_V_MODEL_UNNECESSARY_VALUE",
  "X_V_SHOW_NO_EXPRESSION": 61,
  "61": "X_V_SHOW_NO_EXPRESSION",
  "X_TRANSITION_INVALID_CHILDREN": 62,
  "62": "X_TRANSITION_INVALID_CHILDREN",
  "X_IGNORED_SIDE_EFFECT_TAG": 63,
  "63": "X_IGNORED_SIDE_EFFECT_TAG",
  "__EXTEND_POINT__": 64,
  "64": "__EXTEND_POINT__"
};
const DOMErrorMessages = {
  [53]: `v-html is missing expression.`,
  [54]: `v-html will override element children.`,
  [55]: `v-text is missing expression.`,
  [56]: `v-text will override element children.`,
  [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
  [58]: `v-model argument is not supported on plain elements.`,
  [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
  [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
  [61]: `v-show is missing expression.`,
  [62]: `<Transition> expects exactly one child element or component.`,
  [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
};

const transformVHtml = (dir, node, context) => {
  const { exp, loc } = dir;
  if (!exp) {
    context.onError(
      createDOMCompilerError(53, loc)
    );
  }
  if (node.children.length) {
    context.onError(
      createDOMCompilerError(54, loc)
    );
    node.children.length = 0;
  }
  return {
    props: [
      (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)(
        (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`innerHTML`, true, loc),
        exp || (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)("", true)
      )
    ]
  };
};

const transformVText = (dir, node, context) => {
  const { exp, loc } = dir;
  if (!exp) {
    context.onError(
      createDOMCompilerError(55, loc)
    );
  }
  if (node.children.length) {
    context.onError(
      createDOMCompilerError(56, loc)
    );
    node.children.length = 0;
  }
  return {
    props: [
      (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)(
        (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`textContent`, true),
        exp ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.getConstantType)(exp, context) > 0 ? exp : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(
          context.helperString(_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.TO_DISPLAY_STRING),
          [exp],
          loc
        ) : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)("", true)
      )
    ]
  };
};

const transformModel = (dir, node, context) => {
  const baseResult = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformModel)(dir, node, context);
  if (!baseResult.props.length || node.tagType === 1) {
    return baseResult;
  }
  if (dir.arg) {
    context.onError(
      createDOMCompilerError(
        58,
        dir.arg.loc
      )
    );
  }
  function checkDuplicatedValue() {
    const value = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findDir)(node, "bind");
    if (value && (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticArgOf)(value.arg, "value")) {
      context.onError(
        createDOMCompilerError(
          60,
          value.loc
        )
      );
    }
  }
  const { tag } = node;
  const isCustomElement = context.isCustomElement(tag);
  if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
    let directiveToUse = V_MODEL_TEXT;
    let isInvalidType = false;
    if (tag === "input" || isCustomElement) {
      const type = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.findProp)(node, `type`);
      if (type) {
        if (type.type === 7) {
          directiveToUse = V_MODEL_DYNAMIC;
        } else if (type.value) {
          switch (type.value.content) {
            case "radio":
              directiveToUse = V_MODEL_RADIO;
              break;
            case "checkbox":
              directiveToUse = V_MODEL_CHECKBOX;
              break;
            case "file":
              isInvalidType = true;
              context.onError(
                createDOMCompilerError(
                  59,
                  dir.loc
                )
              );
              break;
            default:
               true && checkDuplicatedValue();
              break;
          }
        }
      } else if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.hasDynamicKeyVBind)(node)) {
        directiveToUse = V_MODEL_DYNAMIC;
      } else {
         true && checkDuplicatedValue();
      }
    } else if (tag === "select") {
      directiveToUse = V_MODEL_SELECT;
    } else {
       true && checkDuplicatedValue();
    }
    if (!isInvalidType) {
      baseResult.needRuntime = context.helper(directiveToUse);
    }
  } else {
    context.onError(
      createDOMCompilerError(
        57,
        dir.loc
      )
    );
  }
  baseResult.props = baseResult.props.filter(
    (p) => !(p.key.type === 4 && p.key.content === "modelValue")
  );
  return baseResult;
};

const isEventOptionModifier = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(`passive,once,capture`);
const isNonKeyModifier = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(
  // event propagation management
  `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
);
const maybeKeyModifier = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)("left,right");
const isKeyboardEvent = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(
  `onkeyup,onkeydown,onkeypress`,
  true
);
const resolveModifiers = (key, modifiers, context, loc) => {
  const keyModifiers = [];
  const nonKeyModifiers = [];
  const eventOptionModifiers = [];
  for (let i = 0; i < modifiers.length; i++) {
    const modifier = modifiers[i];
    if (modifier === "native" && (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.checkCompatEnabled)(
      "COMPILER_V_ON_NATIVE",
      context,
      loc
    )) {
      eventOptionModifiers.push(modifier);
    } else if (isEventOptionModifier(modifier)) {
      eventOptionModifiers.push(modifier);
    } else {
      if (maybeKeyModifier(modifier)) {
        if ((0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key)) {
          if (isKeyboardEvent(key.content)) {
            keyModifiers.push(modifier);
          } else {
            nonKeyModifiers.push(modifier);
          }
        } else {
          keyModifiers.push(modifier);
          nonKeyModifiers.push(modifier);
        }
      } else {
        if (isNonKeyModifier(modifier)) {
          nonKeyModifiers.push(modifier);
        } else {
          keyModifiers.push(modifier);
        }
      }
    }
  }
  return {
    keyModifiers,
    nonKeyModifiers,
    eventOptionModifiers
  };
};
const transformClick = (key, event) => {
  const isStaticClick = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) && key.content.toLowerCase() === "onclick";
  return isStaticClick ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(event, true) : key.type !== 4 ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression)([
    `(`,
    key,
    `) === "onClick" ? "${event}" : (`,
    key,
    `)`
  ]) : key;
};
const transformOn = (dir, node, context) => {
  return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.transformOn)(dir, node, context, (baseResult) => {
    const { modifiers } = dir;
    if (!modifiers.length) return baseResult;
    let { key, value: handlerExp } = baseResult.props[0];
    const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
    if (nonKeyModifiers.includes("right")) {
      key = transformClick(key, `onContextmenu`);
    }
    if (nonKeyModifiers.includes("middle")) {
      key = transformClick(key, `onMouseup`);
    }
    if (nonKeyModifiers.length) {
      handlerExp = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(context.helper(V_ON_WITH_MODIFIERS), [
        handlerExp,
        JSON.stringify(nonKeyModifiers)
      ]);
    }
    if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
    (!(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) || isKeyboardEvent(key.content))) {
      handlerExp = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCallExpression)(context.helper(V_ON_WITH_KEYS), [
        handlerExp,
        JSON.stringify(keyModifiers)
      ]);
    }
    if (eventOptionModifiers.length) {
      const modifierPostfix = eventOptionModifiers.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize).join("");
      key = (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.isStaticExp)(key) ? (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createSimpleExpression)(`${key.content}${modifierPostfix}`, true) : (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createCompoundExpression)([`(`, key, `) + "${modifierPostfix}"`]);
    }
    return {
      props: [(0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.createObjectProperty)(key, handlerExp)]
    };
  });
};

const transformShow = (dir, node, context) => {
  const { exp, loc } = dir;
  if (!exp) {
    context.onError(
      createDOMCompilerError(61, loc)
    );
  }
  return {
    props: [],
    needRuntime: context.helper(V_SHOW)
  };
};

const transformTransition = (node, context) => {
  if (node.type === 1 && node.tagType === 1) {
    const component = context.isBuiltInComponent(node.tag);
    if (component === TRANSITION) {
      return () => {
        if (!node.children.length) {
          return;
        }
        if (hasMultipleChildren(node)) {
          context.onError(
            createDOMCompilerError(
              62,
              {
                start: node.children[0].loc.start,
                end: node.children[node.children.length - 1].loc.end,
                source: ""
              }
            )
          );
        }
        const child = node.children[0];
        if (child.type === 1) {
          for (const p of child.props) {
            if (p.type === 7 && p.name === "show") {
              node.props.push({
                type: 6,
                name: "persisted",
                nameLoc: node.loc,
                value: void 0,
                loc: node.loc
              });
            }
          }
        }
      };
    }
  }
};
function hasMultipleChildren(node) {
  const children = node.children = node.children.filter(
    (c) => c.type !== 3 && !(c.type === 2 && !c.content.trim())
  );
  const child = children[0];
  return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
}

const ignoreSideEffectTags = (node, context) => {
  if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
     true && context.onError(
      createDOMCompilerError(
        63,
        node.loc
      )
    );
    context.removeNode();
  }
};

const DOMNodeTransforms = [
  transformStyle,
  ... true ? [transformTransition] : 0
];
const DOMDirectiveTransforms = {
  cloak: _vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.noopDirectiveTransform,
  html: transformVHtml,
  text: transformVText,
  model: transformModel,
  // override compiler-core
  on: transformOn,
  // override compiler-core
  show: transformShow
};
function compile(src, options = {}) {
  return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseCompile)(
    src,
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, parserOptions, options, {
      nodeTransforms: [
        // ignore <script> and <tag>
        // this is not put inside DOMNodeTransforms because that list is used
        // by compiler-ssr to generate vnode fallback branches
        ignoreSideEffectTags,
        ...DOMNodeTransforms,
        ...options.nodeTransforms || []
      ],
      directiveTransforms: (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(
        {},
        DOMDirectiveTransforms,
        options.directiveTransforms || {}
      ),
      transformHoist: null 
    })
  );
}
function parse(template, options = {}) {
  return (0,_vue_compiler_core__WEBPACK_IMPORTED_MODULE_0__.baseParse)(template, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, parserOptions, options));
}




/***/ }),

/***/ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js":
/*!*********************************************************************!*\
  !*** ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js ***!
  \*********************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   EffectScope: () => (/* binding */ EffectScope),
/* harmony export */   ITERATE_KEY: () => (/* binding */ ITERATE_KEY),
/* harmony export */   ReactiveEffect: () => (/* binding */ ReactiveEffect),
/* harmony export */   ReactiveFlags: () => (/* binding */ ReactiveFlags),
/* harmony export */   TrackOpTypes: () => (/* binding */ TrackOpTypes),
/* harmony export */   TriggerOpTypes: () => (/* binding */ TriggerOpTypes),
/* harmony export */   computed: () => (/* binding */ computed),
/* harmony export */   customRef: () => (/* binding */ customRef),
/* harmony export */   deferredComputed: () => (/* binding */ deferredComputed),
/* harmony export */   effect: () => (/* binding */ effect),
/* harmony export */   effectScope: () => (/* binding */ effectScope),
/* harmony export */   enableTracking: () => (/* binding */ enableTracking),
/* harmony export */   getCurrentScope: () => (/* binding */ getCurrentScope),
/* harmony export */   isProxy: () => (/* binding */ isProxy),
/* harmony export */   isReactive: () => (/* binding */ isReactive),
/* harmony export */   isReadonly: () => (/* binding */ isReadonly),
/* harmony export */   isRef: () => (/* binding */ isRef),
/* harmony export */   isShallow: () => (/* binding */ isShallow),
/* harmony export */   markRaw: () => (/* binding */ markRaw),
/* harmony export */   onScopeDispose: () => (/* binding */ onScopeDispose),
/* harmony export */   pauseScheduling: () => (/* binding */ pauseScheduling),
/* harmony export */   pauseTracking: () => (/* binding */ pauseTracking),
/* harmony export */   proxyRefs: () => (/* binding */ proxyRefs),
/* harmony export */   reactive: () => (/* binding */ reactive),
/* harmony export */   readonly: () => (/* binding */ readonly),
/* harmony export */   ref: () => (/* binding */ ref),
/* harmony export */   resetScheduling: () => (/* binding */ resetScheduling),
/* harmony export */   resetTracking: () => (/* binding */ resetTracking),
/* harmony export */   shallowReactive: () => (/* binding */ shallowReactive),
/* harmony export */   shallowReadonly: () => (/* binding */ shallowReadonly),
/* harmony export */   shallowRef: () => (/* binding */ shallowRef),
/* harmony export */   stop: () => (/* binding */ stop),
/* harmony export */   toRaw: () => (/* binding */ toRaw),
/* harmony export */   toRef: () => (/* binding */ toRef),
/* harmony export */   toRefs: () => (/* binding */ toRefs),
/* harmony export */   toValue: () => (/* binding */ toValue),
/* harmony export */   track: () => (/* binding */ track),
/* harmony export */   trigger: () => (/* binding */ trigger),
/* harmony export */   triggerRef: () => (/* binding */ triggerRef),
/* harmony export */   unref: () => (/* binding */ unref)
/* harmony export */ });
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
/**
* @vue/reactivity v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/


function warn(msg, ...args) {
  console.warn(`[Vue warn] ${msg}`, ...args);
}

let activeEffectScope;
class EffectScope {
  constructor(detached = false) {
    this.detached = detached;
    /**
     * @internal
     */
    this._active = true;
    /**
     * @internal
     */
    this.effects = [];
    /**
     * @internal
     */
    this.cleanups = [];
    this.parent = activeEffectScope;
    if (!detached && activeEffectScope) {
      this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
        this
      ) - 1;
    }
  }
  get active() {
    return this._active;
  }
  run(fn) {
    if (this._active) {
      const currentEffectScope = activeEffectScope;
      try {
        activeEffectScope = this;
        return fn();
      } finally {
        activeEffectScope = currentEffectScope;
      }
    } else if (true) {
      warn(`cannot run an inactive effect scope.`);
    }
  }
  /**
   * This should only be called on non-detached scopes
   * @internal
   */
  on() {
    activeEffectScope = this;
  }
  /**
   * This should only be called on non-detached scopes
   * @internal
   */
  off() {
    activeEffectScope = this.parent;
  }
  stop(fromParent) {
    if (this._active) {
      let i, l;
      for (i = 0, l = this.effects.length; i < l; i++) {
        this.effects[i].stop();
      }
      for (i = 0, l = this.cleanups.length; i < l; i++) {
        this.cleanups[i]();
      }
      if (this.scopes) {
        for (i = 0, l = this.scopes.length; i < l; i++) {
          this.scopes[i].stop(true);
        }
      }
      if (!this.detached && this.parent && !fromParent) {
        const last = this.parent.scopes.pop();
        if (last && last !== this) {
          this.parent.scopes[this.index] = last;
          last.index = this.index;
        }
      }
      this.parent = void 0;
      this._active = false;
    }
  }
}
function effectScope(detached) {
  return new EffectScope(detached);
}
function recordEffectScope(effect, scope = activeEffectScope) {
  if (scope && scope.active) {
    scope.effects.push(effect);
  }
}
function getCurrentScope() {
  return activeEffectScope;
}
function onScopeDispose(fn) {
  if (activeEffectScope) {
    activeEffectScope.cleanups.push(fn);
  } else if (true) {
    warn(
      `onScopeDispose() is called when there is no active effect scope to be associated with.`
    );
  }
}

let activeEffect;
class ReactiveEffect {
  constructor(fn, trigger, scheduler, scope) {
    this.fn = fn;
    this.trigger = trigger;
    this.scheduler = scheduler;
    this.active = true;
    this.deps = [];
    /**
     * @internal
     */
    this._dirtyLevel = 4;
    /**
     * @internal
     */
    this._trackId = 0;
    /**
     * @internal
     */
    this._runnings = 0;
    /**
     * @internal
     */
    this._shouldSchedule = false;
    /**
     * @internal
     */
    this._depsLength = 0;
    recordEffectScope(this, scope);
  }
  get dirty() {
    if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
      this._dirtyLevel = 1;
      pauseTracking();
      for (let i = 0; i < this._depsLength; i++) {
        const dep = this.deps[i];
        if (dep.computed) {
          triggerComputed(dep.computed);
          if (this._dirtyLevel >= 4) {
            break;
          }
        }
      }
      if (this._dirtyLevel === 1) {
        this._dirtyLevel = 0;
      }
      resetTracking();
    }
    return this._dirtyLevel >= 4;
  }
  set dirty(v) {
    this._dirtyLevel = v ? 4 : 0;
  }
  run() {
    this._dirtyLevel = 0;
    if (!this.active) {
      return this.fn();
    }
    let lastShouldTrack = shouldTrack;
    let lastEffect = activeEffect;
    try {
      shouldTrack = true;
      activeEffect = this;
      this._runnings++;
      preCleanupEffect(this);
      return this.fn();
    } finally {
      postCleanupEffect(this);
      this._runnings--;
      activeEffect = lastEffect;
      shouldTrack = lastShouldTrack;
    }
  }
  stop() {
    if (this.active) {
      preCleanupEffect(this);
      postCleanupEffect(this);
      this.onStop && this.onStop();
      this.active = false;
    }
  }
}
function triggerComputed(computed) {
  return computed.value;
}
function preCleanupEffect(effect2) {
  effect2._trackId++;
  effect2._depsLength = 0;
}
function postCleanupEffect(effect2) {
  if (effect2.deps.length > effect2._depsLength) {
    for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
      cleanupDepEffect(effect2.deps[i], effect2);
    }
    effect2.deps.length = effect2._depsLength;
  }
}
function cleanupDepEffect(dep, effect2) {
  const trackId = dep.get(effect2);
  if (trackId !== void 0 && effect2._trackId !== trackId) {
    dep.delete(effect2);
    if (dep.size === 0) {
      dep.cleanup();
    }
  }
}
function effect(fn, options) {
  if (fn.effect instanceof ReactiveEffect) {
    fn = fn.effect.fn;
  }
  const _effect = new ReactiveEffect(fn, _vue_shared__WEBPACK_IMPORTED_MODULE_0__.NOOP, () => {
    if (_effect.dirty) {
      _effect.run();
    }
  });
  if (options) {
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)(_effect, options);
    if (options.scope) recordEffectScope(_effect, options.scope);
  }
  if (!options || !options.lazy) {
    _effect.run();
  }
  const runner = _effect.run.bind(_effect);
  runner.effect = _effect;
  return runner;
}
function stop(runner) {
  runner.effect.stop();
}
let shouldTrack = true;
let pauseScheduleStack = 0;
const trackStack = [];
function pauseTracking() {
  trackStack.push(shouldTrack);
  shouldTrack = false;
}
function enableTracking() {
  trackStack.push(shouldTrack);
  shouldTrack = true;
}
function resetTracking() {
  const last = trackStack.pop();
  shouldTrack = last === void 0 ? true : last;
}
function pauseScheduling() {
  pauseScheduleStack++;
}
function resetScheduling() {
  pauseScheduleStack--;
  while (!pauseScheduleStack && queueEffectSchedulers.length) {
    queueEffectSchedulers.shift()();
  }
}
function trackEffect(effect2, dep, debuggerEventExtraInfo) {
  var _a;
  if (dep.get(effect2) !== effect2._trackId) {
    dep.set(effect2, effect2._trackId);
    const oldDep = effect2.deps[effect2._depsLength];
    if (oldDep !== dep) {
      if (oldDep) {
        cleanupDepEffect(oldDep, effect2);
      }
      effect2.deps[effect2._depsLength++] = dep;
    } else {
      effect2._depsLength++;
    }
    if (true) {
      (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({ effect: effect2 }, debuggerEventExtraInfo));
    }
  }
}
const queueEffectSchedulers = [];
function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
  var _a;
  pauseScheduling();
  for (const effect2 of dep.keys()) {
    let tracking;
    if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
      effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);
      effect2._dirtyLevel = dirtyLevel;
    }
    if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
      if (true) {
        (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.extend)({ effect: effect2 }, debuggerEventExtraInfo));
      }
      effect2.trigger();
      if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {
        effect2._shouldSchedule = false;
        if (effect2.scheduler) {
          queueEffectSchedulers.push(effect2.scheduler);
        }
      }
    }
  }
  resetScheduling();
}

const createDep = (cleanup, computed) => {
  const dep = /* @__PURE__ */ new Map();
  dep.cleanup = cleanup;
  dep.computed = computed;
  return dep;
};

const targetMap = /* @__PURE__ */ new WeakMap();
const ITERATE_KEY = Symbol( true ? "iterate" : 0);
const MAP_KEY_ITERATE_KEY = Symbol( true ? "Map key iterate" : 0);
function track(target, type, key) {
  if (shouldTrack && activeEffect) {
    let depsMap = targetMap.get(target);
    if (!depsMap) {
      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
    }
    let dep = depsMap.get(key);
    if (!dep) {
      depsMap.set(key, dep = createDep(() => depsMap.delete(key)));
    }
    trackEffect(
      activeEffect,
      dep,
       true ? {
        target,
        type,
        key
      } : 0
    );
  }
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
  const depsMap = targetMap.get(target);
  if (!depsMap) {
    return;
  }
  let deps = [];
  if (type === "clear") {
    deps = [...depsMap.values()];
  } else if (key === "length" && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target)) {
    const newLength = Number(newValue);
    depsMap.forEach((dep, key2) => {
      if (key2 === "length" || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key2) && key2 >= newLength) {
        deps.push(dep);
      }
    });
  } else {
    if (key !== void 0) {
      deps.push(depsMap.get(key));
    }
    switch (type) {
      case "add":
        if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target)) {
          deps.push(depsMap.get(ITERATE_KEY));
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) {
            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
          }
        } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key)) {
          deps.push(depsMap.get("length"));
        }
        break;
      case "delete":
        if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target)) {
          deps.push(depsMap.get(ITERATE_KEY));
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) {
            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
          }
        }
        break;
      case "set":
        if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target)) {
          deps.push(depsMap.get(ITERATE_KEY));
        }
        break;
    }
  }
  pauseScheduling();
  for (const dep of deps) {
    if (dep) {
      triggerEffects(
        dep,
        4,
         true ? {
          target,
          type,
          key,
          newValue,
          oldValue,
          oldTarget
        } : 0
      );
    }
  }
  resetScheduling();
}
function getDepFromReactive(object, key) {
  const depsMap = targetMap.get(object);
  return depsMap && depsMap.get(key);
}

const isNonTrackableKeys = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.makeMap)(`__proto__,__v_isRef,__isVue`);
const builtInSymbols = new Set(
  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)
);
const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
function createArrayInstrumentations() {
  const instrumentations = {};
  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
    instrumentations[key] = function(...args) {
      const arr = toRaw(this);
      for (let i = 0, l = this.length; i < l; i++) {
        track(arr, "get", i + "");
      }
      const res = arr[key](...args);
      if (res === -1 || res === false) {
        return arr[key](...args.map(toRaw));
      } else {
        return res;
      }
    };
  });
  ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
    instrumentations[key] = function(...args) {
      pauseTracking();
      pauseScheduling();
      const res = toRaw(this)[key].apply(this, args);
      resetScheduling();
      resetTracking();
      return res;
    };
  });
  return instrumentations;
}
function hasOwnProperty(key) {
  if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key)) key = String(key);
  const obj = toRaw(this);
  track(obj, "has", key);
  return obj.hasOwnProperty(key);
}
class BaseReactiveHandler {
  constructor(_isReadonly = false, _isShallow = false) {
    this._isReadonly = _isReadonly;
    this._isShallow = _isShallow;
  }
  get(target, key, receiver) {
    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
    if (key === "__v_isReactive") {
      return !isReadonly2;
    } else if (key === "__v_isReadonly") {
      return isReadonly2;
    } else if (key === "__v_isShallow") {
      return isShallow2;
    } else if (key === "__v_raw") {
      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
      // this means the receiver is a user proxy of the reactive proxy
      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
        return target;
      }
      return;
    }
    const targetIsArray = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target);
    if (!isReadonly2) {
      if (targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(arrayInstrumentations, key)) {
        return Reflect.get(arrayInstrumentations, key, receiver);
      }
      if (key === "hasOwnProperty") {
        return hasOwnProperty;
      }
    }
    const res = Reflect.get(target, key, receiver);
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
      return res;
    }
    if (!isReadonly2) {
      track(target, "get", key);
    }
    if (isShallow2) {
      return res;
    }
    if (isRef(res)) {
      return targetIsArray && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key) ? res : res.value;
    }
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(res)) {
      return isReadonly2 ? readonly(res) : reactive(res);
    }
    return res;
  }
}
class MutableReactiveHandler extends BaseReactiveHandler {
  constructor(isShallow2 = false) {
    super(false, isShallow2);
  }
  set(target, key, value, receiver) {
    let oldValue = target[key];
    if (!this._isShallow) {
      const isOldValueReadonly = isReadonly(oldValue);
      if (!isShallow(value) && !isReadonly(value)) {
        oldValue = toRaw(oldValue);
        value = toRaw(value);
      }
      if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) && isRef(oldValue) && !isRef(value)) {
        if (isOldValueReadonly) {
          return false;
        } else {
          oldValue.value = value;
          return true;
        }
      }
    }
    const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isIntegerKey)(key) ? Number(key) < target.length : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(target, key);
    const result = Reflect.set(target, key, value, receiver);
    if (target === toRaw(receiver)) {
      if (!hadKey) {
        trigger(target, "add", key, value);
      } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(value, oldValue)) {
        trigger(target, "set", key, value, oldValue);
      }
    }
    return result;
  }
  deleteProperty(target, key) {
    const hadKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(target, key);
    const oldValue = target[key];
    const result = Reflect.deleteProperty(target, key);
    if (result && hadKey) {
      trigger(target, "delete", key, void 0, oldValue);
    }
    return result;
  }
  has(target, key) {
    const result = Reflect.has(target, key);
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isSymbol)(key) || !builtInSymbols.has(key)) {
      track(target, "has", key);
    }
    return result;
  }
  ownKeys(target) {
    track(
      target,
      "iterate",
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(target) ? "length" : ITERATE_KEY
    );
    return Reflect.ownKeys(target);
  }
}
class ReadonlyReactiveHandler extends BaseReactiveHandler {
  constructor(isShallow2 = false) {
    super(true, isShallow2);
  }
  set(target, key) {
    if (true) {
      warn(
        `Set operation on key "${String(key)}" failed: target is readonly.`,
        target
      );
    }
    return true;
  }
  deleteProperty(target, key) {
    if (true) {
      warn(
        `Delete operation on key "${String(key)}" failed: target is readonly.`,
        target
      );
    }
    return true;
  }
}
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
  true
);
const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);

const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get(target, key, isReadonly2 = false, isShallow2 = false) {
  target = target["__v_raw"];
  const rawTarget = toRaw(target);
  const rawKey = toRaw(key);
  if (!isReadonly2) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(key, rawKey)) {
      track(rawTarget, "get", key);
    }
    track(rawTarget, "get", rawKey);
  }
  const { has: has2 } = getProto(rawTarget);
  const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
  if (has2.call(rawTarget, key)) {
    return wrap(target.get(key));
  } else if (has2.call(rawTarget, rawKey)) {
    return wrap(target.get(rawKey));
  } else if (target !== rawTarget) {
    target.get(key);
  }
}
function has(key, isReadonly2 = false) {
  const target = this["__v_raw"];
  const rawTarget = toRaw(target);
  const rawKey = toRaw(key);
  if (!isReadonly2) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(key, rawKey)) {
      track(rawTarget, "has", key);
    }
    track(rawTarget, "has", rawKey);
  }
  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
}
function size(target, isReadonly2 = false) {
  target = target["__v_raw"];
  !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
  return Reflect.get(target, "size", target);
}
function add(value, _isShallow = false) {
  if (!_isShallow && !isShallow(value) && !isReadonly(value)) {
    value = toRaw(value);
  }
  const target = toRaw(this);
  const proto = getProto(target);
  const hadKey = proto.has.call(target, value);
  if (!hadKey) {
    target.add(value);
    trigger(target, "add", value, value);
  }
  return this;
}
function set(key, value, _isShallow = false) {
  if (!_isShallow && !isShallow(value) && !isReadonly(value)) {
    value = toRaw(value);
  }
  const target = toRaw(this);
  const { has: has2, get: get2 } = getProto(target);
  let hadKey = has2.call(target, key);
  if (!hadKey) {
    key = toRaw(key);
    hadKey = has2.call(target, key);
  } else if (true) {
    checkIdentityKeys(target, has2, key);
  }
  const oldValue = get2.call(target, key);
  target.set(key, value);
  if (!hadKey) {
    trigger(target, "add", key, value);
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(value, oldValue)) {
    trigger(target, "set", key, value, oldValue);
  }
  return this;
}
function deleteEntry(key) {
  const target = toRaw(this);
  const { has: has2, get: get2 } = getProto(target);
  let hadKey = has2.call(target, key);
  if (!hadKey) {
    key = toRaw(key);
    hadKey = has2.call(target, key);
  } else if (true) {
    checkIdentityKeys(target, has2, key);
  }
  const oldValue = get2 ? get2.call(target, key) : void 0;
  const result = target.delete(key);
  if (hadKey) {
    trigger(target, "delete", key, void 0, oldValue);
  }
  return result;
}
function clear() {
  const target = toRaw(this);
  const hadItems = target.size !== 0;
  const oldTarget =  true ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(target) ? new Map(target) : new Set(target) : 0;
  const result = target.clear();
  if (hadItems) {
    trigger(target, "clear", void 0, void 0, oldTarget);
  }
  return result;
}
function createForEach(isReadonly2, isShallow2) {
  return function forEach(callback, thisArg) {
    const observed = this;
    const target = observed["__v_raw"];
    const rawTarget = toRaw(target);
    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
    !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
    return target.forEach((value, key) => {
      return callback.call(thisArg, wrap(value), wrap(key), observed);
    });
  };
}
function createIterableMethod(method, isReadonly2, isShallow2) {
  return function(...args) {
    const target = this["__v_raw"];
    const rawTarget = toRaw(target);
    const targetIsMap = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isMap)(rawTarget);
    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
    const isKeyOnly = method === "keys" && targetIsMap;
    const innerIterator = target[method](...args);
    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
    !isReadonly2 && track(
      rawTarget,
      "iterate",
      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
    );
    return {
      // iterator protocol
      next() {
        const { value, done } = innerIterator.next();
        return done ? { value, done } : {
          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
          done
        };
      },
      // iterable protocol
      [Symbol.iterator]() {
        return this;
      }
    };
  };
}
function createReadonlyMethod(type) {
  return function(...args) {
    if (true) {
      const key = args[0] ? `on key "${args[0]}" ` : ``;
      warn(
        `${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.capitalize)(type)} operation ${key}failed: target is readonly.`,
        toRaw(this)
      );
    }
    return type === "delete" ? false : type === "clear" ? void 0 : this;
  };
}
function createInstrumentations() {
  const mutableInstrumentations2 = {
    get(key) {
      return get(this, key);
    },
    get size() {
      return size(this);
    },
    has,
    add,
    set,
    delete: deleteEntry,
    clear,
    forEach: createForEach(false, false)
  };
  const shallowInstrumentations2 = {
    get(key) {
      return get(this, key, false, true);
    },
    get size() {
      return size(this);
    },
    has,
    add(value) {
      return add.call(this, value, true);
    },
    set(key, value) {
      return set.call(this, key, value, true);
    },
    delete: deleteEntry,
    clear,
    forEach: createForEach(false, true)
  };
  const readonlyInstrumentations2 = {
    get(key) {
      return get(this, key, true);
    },
    get size() {
      return size(this, true);
    },
    has(key) {
      return has.call(this, key, true);
    },
    add: createReadonlyMethod("add"),
    set: createReadonlyMethod("set"),
    delete: createReadonlyMethod("delete"),
    clear: createReadonlyMethod("clear"),
    forEach: createForEach(true, false)
  };
  const shallowReadonlyInstrumentations2 = {
    get(key) {
      return get(this, key, true, true);
    },
    get size() {
      return size(this, true);
    },
    has(key) {
      return has.call(this, key, true);
    },
    add: createReadonlyMethod("add"),
    set: createReadonlyMethod("set"),
    delete: createReadonlyMethod("delete"),
    clear: createReadonlyMethod("clear"),
    forEach: createForEach(true, true)
  };
  const iteratorMethods = [
    "keys",
    "values",
    "entries",
    Symbol.iterator
  ];
  iteratorMethods.forEach((method) => {
    mutableInstrumentations2[method] = createIterableMethod(method, false, false);
    readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
    shallowInstrumentations2[method] = createIterableMethod(method, false, true);
    shallowReadonlyInstrumentations2[method] = createIterableMethod(
      method,
      true,
      true
    );
  });
  return [
    mutableInstrumentations2,
    readonlyInstrumentations2,
    shallowInstrumentations2,
    shallowReadonlyInstrumentations2
  ];
}
const [
  mutableInstrumentations,
  readonlyInstrumentations,
  shallowInstrumentations,
  shallowReadonlyInstrumentations
] = /* @__PURE__ */ createInstrumentations();
function createInstrumentationGetter(isReadonly2, shallow) {
  const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
  return (target, key, receiver) => {
    if (key === "__v_isReactive") {
      return !isReadonly2;
    } else if (key === "__v_isReadonly") {
      return isReadonly2;
    } else if (key === "__v_raw") {
      return target;
    }
    return Reflect.get(
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasOwn)(instrumentations, key) && key in target ? instrumentations : target,
      key,
      receiver
    );
  };
}
const mutableCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
};
const shallowReadonlyCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
};
function checkIdentityKeys(target, has2, key) {
  const rawKey = toRaw(key);
  if (rawKey !== key && has2.call(target, rawKey)) {
    const type = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toRawType)(target);
    warn(
      `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
    );
  }
}

const reactiveMap = /* @__PURE__ */ new WeakMap();
const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
const readonlyMap = /* @__PURE__ */ new WeakMap();
const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
function targetTypeMap(rawType) {
  switch (rawType) {
    case "Object":
    case "Array":
      return 1 /* COMMON */;
    case "Map":
    case "Set":
    case "WeakMap":
    case "WeakSet":
      return 2 /* COLLECTION */;
    default:
      return 0 /* INVALID */;
  }
}
function getTargetType(value) {
  return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.toRawType)(value));
}
function reactive(target) {
  if (isReadonly(target)) {
    return target;
  }
  return createReactiveObject(
    target,
    false,
    mutableHandlers,
    mutableCollectionHandlers,
    reactiveMap
  );
}
function shallowReactive(target) {
  return createReactiveObject(
    target,
    false,
    shallowReactiveHandlers,
    shallowCollectionHandlers,
    shallowReactiveMap
  );
}
function readonly(target) {
  return createReactiveObject(
    target,
    true,
    readonlyHandlers,
    readonlyCollectionHandlers,
    readonlyMap
  );
}
function shallowReadonly(target) {
  return createReactiveObject(
    target,
    true,
    shallowReadonlyHandlers,
    shallowReadonlyCollectionHandlers,
    shallowReadonlyMap
  );
}
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
  if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(target)) {
    if (true) {
      warn(
        `value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(
          target
        )}`
      );
    }
    return target;
  }
  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
    return target;
  }
  const existingProxy = proxyMap.get(target);
  if (existingProxy) {
    return existingProxy;
  }
  const targetType = getTargetType(target);
  if (targetType === 0 /* INVALID */) {
    return target;
  }
  const proxy = new Proxy(
    target,
    targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
  );
  proxyMap.set(target, proxy);
  return proxy;
}
function isReactive(value) {
  if (isReadonly(value)) {
    return isReactive(value["__v_raw"]);
  }
  return !!(value && value["__v_isReactive"]);
}
function isReadonly(value) {
  return !!(value && value["__v_isReadonly"]);
}
function isShallow(value) {
  return !!(value && value["__v_isShallow"]);
}
function isProxy(value) {
  return value ? !!value["__v_raw"] : false;
}
function toRaw(observed) {
  const raw = observed && observed["__v_raw"];
  return raw ? toRaw(raw) : observed;
}
function markRaw(value) {
  if (Object.isExtensible(value)) {
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.def)(value, "__v_skip", true);
  }
  return value;
}
const toReactive = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(value) ? reactive(value) : value;
const toReadonly = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(value) ? readonly(value) : value;

const COMPUTED_SIDE_EFFECT_WARN = `Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided.  Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free`;
class ComputedRefImpl {
  constructor(getter, _setter, isReadonly, isSSR) {
    this.getter = getter;
    this._setter = _setter;
    this.dep = void 0;
    this.__v_isRef = true;
    this["__v_isReadonly"] = false;
    this.effect = new ReactiveEffect(
      () => getter(this._value),
      () => triggerRefValue(
        this,
        this.effect._dirtyLevel === 2 ? 2 : 3
      )
    );
    this.effect.computed = this;
    this.effect.active = this._cacheable = !isSSR;
    this["__v_isReadonly"] = isReadonly;
  }
  get value() {
    const self = toRaw(this);
    if ((!self._cacheable || self.effect.dirty) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(self._value, self._value = self.effect.run())) {
      triggerRefValue(self, 4);
    }
    trackRefValue(self);
    if (self.effect._dirtyLevel >= 2) {
      if ( true && this._warnRecursive) {
        warn(COMPUTED_SIDE_EFFECT_WARN, `

getter: `, this.getter);
      }
      triggerRefValue(self, 2);
    }
    return self._value;
  }
  set value(newValue) {
    this._setter(newValue);
  }
  // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x
  get _dirty() {
    return this.effect.dirty;
  }
  set _dirty(v) {
    this.effect.dirty = v;
  }
  // #endregion
}
function computed(getterOrOptions, debugOptions, isSSR = false) {
  let getter;
  let setter;
  const onlyGetter = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(getterOrOptions);
  if (onlyGetter) {
    getter = getterOrOptions;
    setter =  true ? () => {
      warn("Write operation failed: computed value is readonly");
    } : 0;
  } else {
    getter = getterOrOptions.get;
    setter = getterOrOptions.set;
  }
  const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
  if ( true && debugOptions && !isSSR) {
    cRef.effect.onTrack = debugOptions.onTrack;
    cRef.effect.onTrigger = debugOptions.onTrigger;
  }
  return cRef;
}

function trackRefValue(ref2) {
  var _a;
  if (shouldTrack && activeEffect) {
    ref2 = toRaw(ref2);
    trackEffect(
      activeEffect,
      (_a = ref2.dep) != null ? _a : ref2.dep = createDep(
        () => ref2.dep = void 0,
        ref2 instanceof ComputedRefImpl ? ref2 : void 0
      ),
       true ? {
        target: ref2,
        type: "get",
        key: "value"
      } : 0
    );
  }
}
function triggerRefValue(ref2, dirtyLevel = 4, newVal, oldVal) {
  ref2 = toRaw(ref2);
  const dep = ref2.dep;
  if (dep) {
    triggerEffects(
      dep,
      dirtyLevel,
       true ? {
        target: ref2,
        type: "set",
        key: "value",
        newValue: newVal,
        oldValue: oldVal
      } : 0
    );
  }
}
function isRef(r) {
  return !!(r && r.__v_isRef === true);
}
function ref(value) {
  return createRef(value, false);
}
function shallowRef(value) {
  return createRef(value, true);
}
function createRef(rawValue, shallow) {
  if (isRef(rawValue)) {
    return rawValue;
  }
  return new RefImpl(rawValue, shallow);
}
class RefImpl {
  constructor(value, __v_isShallow) {
    this.__v_isShallow = __v_isShallow;
    this.dep = void 0;
    this.__v_isRef = true;
    this._rawValue = __v_isShallow ? value : toRaw(value);
    this._value = __v_isShallow ? value : toReactive(value);
  }
  get value() {
    trackRefValue(this);
    return this._value;
  }
  set value(newVal) {
    const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
    newVal = useDirectValue ? newVal : toRaw(newVal);
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.hasChanged)(newVal, this._rawValue)) {
      const oldVal = this._rawValue;
      this._rawValue = newVal;
      this._value = useDirectValue ? newVal : toReactive(newVal);
      triggerRefValue(this, 4, newVal, oldVal);
    }
  }
}
function triggerRef(ref2) {
  triggerRefValue(ref2, 4,  true ? ref2.value : 0);
}
function unref(ref2) {
  return isRef(ref2) ? ref2.value : ref2;
}
function toValue(source) {
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(source) ? source() : unref(source);
}
const shallowUnwrapHandlers = {
  get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
  set: (target, key, value, receiver) => {
    const oldValue = target[key];
    if (isRef(oldValue) && !isRef(value)) {
      oldValue.value = value;
      return true;
    } else {
      return Reflect.set(target, key, value, receiver);
    }
  }
};
function proxyRefs(objectWithRefs) {
  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
  constructor(factory) {
    this.dep = void 0;
    this.__v_isRef = true;
    const { get, set } = factory(
      () => trackRefValue(this),
      () => triggerRefValue(this)
    );
    this._get = get;
    this._set = set;
  }
  get value() {
    return this._get();
  }
  set value(newVal) {
    this._set(newVal);
  }
}
function customRef(factory) {
  return new CustomRefImpl(factory);
}
function toRefs(object) {
  if ( true && !isProxy(object)) {
    warn(`toRefs() expects a reactive object but received a plain one.`);
  }
  const ret = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isArray)(object) ? new Array(object.length) : {};
  for (const key in object) {
    ret[key] = propertyToRef(object, key);
  }
  return ret;
}
class ObjectRefImpl {
  constructor(_object, _key, _defaultValue) {
    this._object = _object;
    this._key = _key;
    this._defaultValue = _defaultValue;
    this.__v_isRef = true;
  }
  get value() {
    const val = this._object[this._key];
    return val === void 0 ? this._defaultValue : val;
  }
  set value(newVal) {
    this._object[this._key] = newVal;
  }
  get dep() {
    return getDepFromReactive(toRaw(this._object), this._key);
  }
}
class GetterRefImpl {
  constructor(_getter) {
    this._getter = _getter;
    this.__v_isRef = true;
    this.__v_isReadonly = true;
  }
  get value() {
    return this._getter();
  }
}
function toRef(source, key, defaultValue) {
  if (isRef(source)) {
    return source;
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isFunction)(source)) {
    return new GetterRefImpl(source);
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_0__.isObject)(source) && arguments.length > 1) {
    return propertyToRef(source, key, defaultValue);
  } else {
    return ref(source);
  }
}
function propertyToRef(source, key, defaultValue) {
  const val = source[key];
  return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
}

const deferredComputed = computed;

const TrackOpTypes = {
  "GET": "get",
  "HAS": "has",
  "ITERATE": "iterate"
};
const TriggerOpTypes = {
  "SET": "set",
  "ADD": "add",
  "DELETE": "delete",
  "CLEAR": "clear"
};
const ReactiveFlags = {
  "SKIP": "__v_skip",
  "IS_REACTIVE": "__v_isReactive",
  "IS_READONLY": "__v_isReadonly",
  "IS_SHALLOW": "__v_isShallow",
  "RAW": "__v_raw"
};




/***/ }),

/***/ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js":
/*!*************************************************************************!*\
  !*** ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js ***!
  \*************************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   BaseTransition: () => (/* binding */ BaseTransition),
/* harmony export */   BaseTransitionPropsValidators: () => (/* binding */ BaseTransitionPropsValidators),
/* harmony export */   Comment: () => (/* binding */ Comment),
/* harmony export */   DeprecationTypes: () => (/* binding */ DeprecationTypes),
/* harmony export */   EffectScope: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.EffectScope),
/* harmony export */   ErrorCodes: () => (/* binding */ ErrorCodes),
/* harmony export */   ErrorTypeStrings: () => (/* binding */ ErrorTypeStrings),
/* harmony export */   Fragment: () => (/* binding */ Fragment),
/* harmony export */   KeepAlive: () => (/* binding */ KeepAlive),
/* harmony export */   ReactiveEffect: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect),
/* harmony export */   Static: () => (/* binding */ Static),
/* harmony export */   Suspense: () => (/* binding */ Suspense),
/* harmony export */   Teleport: () => (/* binding */ Teleport),
/* harmony export */   Text: () => (/* binding */ Text),
/* harmony export */   TrackOpTypes: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.TrackOpTypes),
/* harmony export */   TriggerOpTypes: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.TriggerOpTypes),
/* harmony export */   assertNumber: () => (/* binding */ assertNumber),
/* harmony export */   callWithAsyncErrorHandling: () => (/* binding */ callWithAsyncErrorHandling),
/* harmony export */   callWithErrorHandling: () => (/* binding */ callWithErrorHandling),
/* harmony export */   camelize: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize),
/* harmony export */   capitalize: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize),
/* harmony export */   cloneVNode: () => (/* binding */ cloneVNode),
/* harmony export */   compatUtils: () => (/* binding */ compatUtils),
/* harmony export */   computed: () => (/* binding */ computed),
/* harmony export */   createBlock: () => (/* binding */ createBlock),
/* harmony export */   createCommentVNode: () => (/* binding */ createCommentVNode),
/* harmony export */   createElementBlock: () => (/* binding */ createElementBlock),
/* harmony export */   createElementVNode: () => (/* binding */ createBaseVNode),
/* harmony export */   createHydrationRenderer: () => (/* binding */ createHydrationRenderer),
/* harmony export */   createPropsRestProxy: () => (/* binding */ createPropsRestProxy),
/* harmony export */   createRenderer: () => (/* binding */ createRenderer),
/* harmony export */   createSlots: () => (/* binding */ createSlots),
/* harmony export */   createStaticVNode: () => (/* binding */ createStaticVNode),
/* harmony export */   createTextVNode: () => (/* binding */ createTextVNode),
/* harmony export */   createVNode: () => (/* binding */ createVNode),
/* harmony export */   customRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.customRef),
/* harmony export */   defineAsyncComponent: () => (/* binding */ defineAsyncComponent),
/* harmony export */   defineComponent: () => (/* binding */ defineComponent),
/* harmony export */   defineEmits: () => (/* binding */ defineEmits),
/* harmony export */   defineExpose: () => (/* binding */ defineExpose),
/* harmony export */   defineModel: () => (/* binding */ defineModel),
/* harmony export */   defineOptions: () => (/* binding */ defineOptions),
/* harmony export */   defineProps: () => (/* binding */ defineProps),
/* harmony export */   defineSlots: () => (/* binding */ defineSlots),
/* harmony export */   devtools: () => (/* binding */ devtools),
/* harmony export */   effect: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.effect),
/* harmony export */   effectScope: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.effectScope),
/* harmony export */   getCurrentInstance: () => (/* binding */ getCurrentInstance),
/* harmony export */   getCurrentScope: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope),
/* harmony export */   getTransitionRawChildren: () => (/* binding */ getTransitionRawChildren),
/* harmony export */   guardReactiveProps: () => (/* binding */ guardReactiveProps),
/* harmony export */   h: () => (/* binding */ h),
/* harmony export */   handleError: () => (/* binding */ handleError),
/* harmony export */   hasInjectionContext: () => (/* binding */ hasInjectionContext),
/* harmony export */   initCustomFormatter: () => (/* binding */ initCustomFormatter),
/* harmony export */   inject: () => (/* binding */ inject),
/* harmony export */   isMemoSame: () => (/* binding */ isMemoSame),
/* harmony export */   isProxy: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy),
/* harmony export */   isReactive: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive),
/* harmony export */   isReadonly: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly),
/* harmony export */   isRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef),
/* harmony export */   isRuntimeOnly: () => (/* binding */ isRuntimeOnly),
/* harmony export */   isShallow: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow),
/* harmony export */   isVNode: () => (/* binding */ isVNode),
/* harmony export */   markRaw: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.markRaw),
/* harmony export */   mergeDefaults: () => (/* binding */ mergeDefaults),
/* harmony export */   mergeModels: () => (/* binding */ mergeModels),
/* harmony export */   mergeProps: () => (/* binding */ mergeProps),
/* harmony export */   nextTick: () => (/* binding */ nextTick),
/* harmony export */   normalizeClass: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass),
/* harmony export */   normalizeProps: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeProps),
/* harmony export */   normalizeStyle: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle),
/* harmony export */   onActivated: () => (/* binding */ onActivated),
/* harmony export */   onBeforeMount: () => (/* binding */ onBeforeMount),
/* harmony export */   onBeforeUnmount: () => (/* binding */ onBeforeUnmount),
/* harmony export */   onBeforeUpdate: () => (/* binding */ onBeforeUpdate),
/* harmony export */   onDeactivated: () => (/* binding */ onDeactivated),
/* harmony export */   onErrorCaptured: () => (/* binding */ onErrorCaptured),
/* harmony export */   onMounted: () => (/* binding */ onMounted),
/* harmony export */   onRenderTracked: () => (/* binding */ onRenderTracked),
/* harmony export */   onRenderTriggered: () => (/* binding */ onRenderTriggered),
/* harmony export */   onScopeDispose: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose),
/* harmony export */   onServerPrefetch: () => (/* binding */ onServerPrefetch),
/* harmony export */   onUnmounted: () => (/* binding */ onUnmounted),
/* harmony export */   onUpdated: () => (/* binding */ onUpdated),
/* harmony export */   openBlock: () => (/* binding */ openBlock),
/* harmony export */   popScopeId: () => (/* binding */ popScopeId),
/* harmony export */   provide: () => (/* binding */ provide),
/* harmony export */   proxyRefs: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs),
/* harmony export */   pushScopeId: () => (/* binding */ pushScopeId),
/* harmony export */   queuePostFlushCb: () => (/* binding */ queuePostFlushCb),
/* harmony export */   reactive: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.reactive),
/* harmony export */   readonly: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.readonly),
/* harmony export */   ref: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref),
/* harmony export */   registerRuntimeCompiler: () => (/* binding */ registerRuntimeCompiler),
/* harmony export */   renderList: () => (/* binding */ renderList),
/* harmony export */   renderSlot: () => (/* binding */ renderSlot),
/* harmony export */   resolveComponent: () => (/* binding */ resolveComponent),
/* harmony export */   resolveDirective: () => (/* binding */ resolveDirective),
/* harmony export */   resolveDynamicComponent: () => (/* binding */ resolveDynamicComponent),
/* harmony export */   resolveFilter: () => (/* binding */ resolveFilter),
/* harmony export */   resolveTransitionHooks: () => (/* binding */ resolveTransitionHooks),
/* harmony export */   setBlockTracking: () => (/* binding */ setBlockTracking),
/* harmony export */   setDevtoolsHook: () => (/* binding */ setDevtoolsHook),
/* harmony export */   setTransitionHooks: () => (/* binding */ setTransitionHooks),
/* harmony export */   shallowReactive: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReactive),
/* harmony export */   shallowReadonly: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly),
/* harmony export */   shallowRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowRef),
/* harmony export */   ssrContextKey: () => (/* binding */ ssrContextKey),
/* harmony export */   ssrUtils: () => (/* binding */ ssrUtils),
/* harmony export */   stop: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.stop),
/* harmony export */   toDisplayString: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.toDisplayString),
/* harmony export */   toHandlerKey: () => (/* reexport safe */ _vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey),
/* harmony export */   toHandlers: () => (/* binding */ toHandlers),
/* harmony export */   toRaw: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw),
/* harmony export */   toRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRef),
/* harmony export */   toRefs: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRefs),
/* harmony export */   toValue: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toValue),
/* harmony export */   transformVNodeArgs: () => (/* binding */ transformVNodeArgs),
/* harmony export */   triggerRef: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.triggerRef),
/* harmony export */   unref: () => (/* reexport safe */ _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.unref),
/* harmony export */   useAttrs: () => (/* binding */ useAttrs),
/* harmony export */   useModel: () => (/* binding */ useModel),
/* harmony export */   useSSRContext: () => (/* binding */ useSSRContext),
/* harmony export */   useSlots: () => (/* binding */ useSlots),
/* harmony export */   useTransitionState: () => (/* binding */ useTransitionState),
/* harmony export */   version: () => (/* binding */ version),
/* harmony export */   warn: () => (/* binding */ warn),
/* harmony export */   watch: () => (/* binding */ watch),
/* harmony export */   watchEffect: () => (/* binding */ watchEffect),
/* harmony export */   watchPostEffect: () => (/* binding */ watchPostEffect),
/* harmony export */   watchSyncEffect: () => (/* binding */ watchSyncEffect),
/* harmony export */   withAsyncContext: () => (/* binding */ withAsyncContext),
/* harmony export */   withCtx: () => (/* binding */ withCtx),
/* harmony export */   withDefaults: () => (/* binding */ withDefaults),
/* harmony export */   withDirectives: () => (/* binding */ withDirectives),
/* harmony export */   withMemo: () => (/* binding */ withMemo),
/* harmony export */   withScopeId: () => (/* binding */ withScopeId)
/* harmony export */ });
/* harmony import */ var _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/reactivity */ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js");
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
/**
* @vue/runtime-core v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/





const stack = [];
function pushWarningContext(vnode) {
  stack.push(vnode);
}
function popWarningContext() {
  stack.pop();
}
let isWarning = false;
function warn$1(msg, ...args) {
  if (isWarning) return;
  isWarning = true;
  (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)();
  const instance = stack.length ? stack[stack.length - 1].component : null;
  const appWarnHandler = instance && instance.appContext.config.warnHandler;
  const trace = getComponentTrace();
  if (appWarnHandler) {
    callWithErrorHandling(
      appWarnHandler,
      instance,
      11,
      [
        // eslint-disable-next-line no-restricted-syntax
        msg + args.map((a) => {
          var _a, _b;
          return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
        }).join(""),
        instance && instance.proxy,
        trace.map(
          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
        ).join("\n"),
        trace
      ]
    );
  } else {
    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
    if (trace.length && // avoid spamming console during tests
    true) {
      warnArgs.push(`
`, ...formatTrace(trace));
    }
    console.warn(...warnArgs);
  }
  (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)();
  isWarning = false;
}
function getComponentTrace() {
  let currentVNode = stack[stack.length - 1];
  if (!currentVNode) {
    return [];
  }
  const normalizedStack = [];
  while (currentVNode) {
    const last = normalizedStack[0];
    if (last && last.vnode === currentVNode) {
      last.recurseCount++;
    } else {
      normalizedStack.push({
        vnode: currentVNode,
        recurseCount: 0
      });
    }
    const parentInstance = currentVNode.component && currentVNode.component.parent;
    currentVNode = parentInstance && parentInstance.vnode;
  }
  return normalizedStack;
}
function formatTrace(trace) {
  const logs = [];
  trace.forEach((entry, i) => {
    logs.push(...i === 0 ? [] : [`
`], ...formatTraceEntry(entry));
  });
  return logs;
}
function formatTraceEntry({ vnode, recurseCount }) {
  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
  const isRoot = vnode.component ? vnode.component.parent == null : false;
  const open = ` at <${formatComponentName(
    vnode.component,
    vnode.type,
    isRoot
  )}`;
  const close = `>` + postfix;
  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
}
function formatProps(props) {
  const res = [];
  const keys = Object.keys(props);
  keys.slice(0, 3).forEach((key) => {
    res.push(...formatProp(key, props[key]));
  });
  if (keys.length > 3) {
    res.push(` ...`);
  }
  return res;
}
function formatProp(key, value, raw) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(value)) {
    value = JSON.stringify(value);
    return raw ? value : [`${key}=${value}`];
  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
    return raw ? value : [`${key}=${value}`];
  } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(value)) {
    value = formatProp(key, (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(value.value), true);
    return raw ? value : [`${key}=Ref<`, value, `>`];
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) {
    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
  } else {
    value = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(value);
    return raw ? value : [`${key}=`, value];
  }
}
function assertNumber(val, type) {
  if (false) {}
  if (val === void 0) {
    return;
  } else if (typeof val !== "number") {
    warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
  } else if (isNaN(val)) {
    warn$1(`${type} is NaN - the duration expression might be incorrect.`);
  }
}

const ErrorCodes = {
  "SETUP_FUNCTION": 0,
  "0": "SETUP_FUNCTION",
  "RENDER_FUNCTION": 1,
  "1": "RENDER_FUNCTION",
  "WATCH_GETTER": 2,
  "2": "WATCH_GETTER",
  "WATCH_CALLBACK": 3,
  "3": "WATCH_CALLBACK",
  "WATCH_CLEANUP": 4,
  "4": "WATCH_CLEANUP",
  "NATIVE_EVENT_HANDLER": 5,
  "5": "NATIVE_EVENT_HANDLER",
  "COMPONENT_EVENT_HANDLER": 6,
  "6": "COMPONENT_EVENT_HANDLER",
  "VNODE_HOOK": 7,
  "7": "VNODE_HOOK",
  "DIRECTIVE_HOOK": 8,
  "8": "DIRECTIVE_HOOK",
  "TRANSITION_HOOK": 9,
  "9": "TRANSITION_HOOK",
  "APP_ERROR_HANDLER": 10,
  "10": "APP_ERROR_HANDLER",
  "APP_WARN_HANDLER": 11,
  "11": "APP_WARN_HANDLER",
  "FUNCTION_REF": 12,
  "12": "FUNCTION_REF",
  "ASYNC_COMPONENT_LOADER": 13,
  "13": "ASYNC_COMPONENT_LOADER",
  "SCHEDULER": 14,
  "14": "SCHEDULER",
  "COMPONENT_UPDATE": 15,
  "15": "COMPONENT_UPDATE"
};
const ErrorTypeStrings$1 = {
  ["sp"]: "serverPrefetch hook",
  ["bc"]: "beforeCreate hook",
  ["c"]: "created hook",
  ["bm"]: "beforeMount hook",
  ["m"]: "mounted hook",
  ["bu"]: "beforeUpdate hook",
  ["u"]: "updated",
  ["bum"]: "beforeUnmount hook",
  ["um"]: "unmounted hook",
  ["a"]: "activated hook",
  ["da"]: "deactivated hook",
  ["ec"]: "errorCaptured hook",
  ["rtc"]: "renderTracked hook",
  ["rtg"]: "renderTriggered hook",
  [0]: "setup function",
  [1]: "render function",
  [2]: "watcher getter",
  [3]: "watcher callback",
  [4]: "watcher cleanup function",
  [5]: "native event handler",
  [6]: "component event handler",
  [7]: "vnode hook",
  [8]: "directive hook",
  [9]: "transition hook",
  [10]: "app errorHandler",
  [11]: "app warnHandler",
  [12]: "ref function",
  [13]: "async component loader",
  [14]: "scheduler flush",
  [15]: "component update"
};
function callWithErrorHandling(fn, instance, type, args) {
  try {
    return args ? fn(...args) : fn();
  } catch (err) {
    handleError(err, instance, type);
  }
}
function callWithAsyncErrorHandling(fn, instance, type, args) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(fn)) {
    const res = callWithErrorHandling(fn, instance, type, args);
    if (res && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(res)) {
      res.catch((err) => {
        handleError(err, instance, type);
      });
    }
    return res;
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn)) {
    const values = [];
    for (let i = 0; i < fn.length; i++) {
      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
    }
    return values;
  } else if (true) {
    warn$1(
      `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`
    );
  }
}
function handleError(err, instance, type, throwInDev = true) {
  const contextVNode = instance ? instance.vnode : null;
  if (instance) {
    let cur = instance.parent;
    const exposedInstance = instance.proxy;
    const errorInfo =  true ? ErrorTypeStrings$1[type] : 0;
    while (cur) {
      const errorCapturedHooks = cur.ec;
      if (errorCapturedHooks) {
        for (let i = 0; i < errorCapturedHooks.length; i++) {
          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
            return;
          }
        }
      }
      cur = cur.parent;
    }
    const appErrorHandler = instance.appContext.config.errorHandler;
    if (appErrorHandler) {
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)();
      callWithErrorHandling(
        appErrorHandler,
        null,
        10,
        [err, exposedInstance, errorInfo]
      );
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)();
      return;
    }
  }
  logError(err, type, contextVNode, throwInDev);
}
function logError(err, type, contextVNode, throwInDev = true) {
  if (true) {
    const info = ErrorTypeStrings$1[type];
    if (contextVNode) {
      pushWarningContext(contextVNode);
    }
    warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
    if (contextVNode) {
      popWarningContext();
    }
    if (throwInDev) {
      throw err;
    } else {
      console.error(err);
    }
  } else {}
}

let isFlushing = false;
let isFlushPending = false;
const queue = [];
let flushIndex = 0;
const pendingPostFlushCbs = [];
let activePostFlushCbs = null;
let postFlushIndex = 0;
const resolvedPromise = /* @__PURE__ */ Promise.resolve();
let currentFlushPromise = null;
const RECURSION_LIMIT = 100;
function nextTick(fn) {
  const p = currentFlushPromise || resolvedPromise;
  return fn ? p.then(this ? fn.bind(this) : fn) : p;
}
function findInsertionIndex(id) {
  let start = flushIndex + 1;
  let end = queue.length;
  while (start < end) {
    const middle = start + end >>> 1;
    const middleJob = queue[middle];
    const middleJobId = getId(middleJob);
    if (middleJobId < id || middleJobId === id && middleJob.pre) {
      start = middle + 1;
    } else {
      end = middle;
    }
  }
  return start;
}
function queueJob(job) {
  if (!queue.length || !queue.includes(
    job,
    isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
  )) {
    if (job.id == null) {
      queue.push(job);
    } else {
      queue.splice(findInsertionIndex(job.id), 0, job);
    }
    queueFlush();
  }
}
function queueFlush() {
  if (!isFlushing && !isFlushPending) {
    isFlushPending = true;
    currentFlushPromise = resolvedPromise.then(flushJobs);
  }
}
function invalidateJob(job) {
  const i = queue.indexOf(job);
  if (i > flushIndex) {
    queue.splice(i, 1);
  }
}
function queuePostFlushCb(cb) {
  if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(cb)) {
    if (!activePostFlushCbs || !activePostFlushCbs.includes(
      cb,
      cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
    )) {
      pendingPostFlushCbs.push(cb);
    }
  } else {
    pendingPostFlushCbs.push(...cb);
  }
  queueFlush();
}
function flushPreFlushCbs(instance, seen, i = isFlushing ? flushIndex + 1 : 0) {
  if (true) {
    seen = seen || /* @__PURE__ */ new Map();
  }
  for (; i < queue.length; i++) {
    const cb = queue[i];
    if (cb && cb.pre) {
      if (instance && cb.id !== instance.uid) {
        continue;
      }
      if ( true && checkRecursiveUpdates(seen, cb)) {
        continue;
      }
      queue.splice(i, 1);
      i--;
      cb();
    }
  }
}
function flushPostFlushCbs(seen) {
  if (pendingPostFlushCbs.length) {
    const deduped = [...new Set(pendingPostFlushCbs)].sort(
      (a, b) => getId(a) - getId(b)
    );
    pendingPostFlushCbs.length = 0;
    if (activePostFlushCbs) {
      activePostFlushCbs.push(...deduped);
      return;
    }
    activePostFlushCbs = deduped;
    if (true) {
      seen = seen || /* @__PURE__ */ new Map();
    }
    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
      const cb = activePostFlushCbs[postFlushIndex];
      if ( true && checkRecursiveUpdates(seen, cb)) {
        continue;
      }
      if (cb.active !== false) cb();
    }
    activePostFlushCbs = null;
    postFlushIndex = 0;
  }
}
const getId = (job) => job.id == null ? Infinity : job.id;
const comparator = (a, b) => {
  const diff = getId(a) - getId(b);
  if (diff === 0) {
    if (a.pre && !b.pre) return -1;
    if (b.pre && !a.pre) return 1;
  }
  return diff;
};
function flushJobs(seen) {
  isFlushPending = false;
  isFlushing = true;
  if (true) {
    seen = seen || /* @__PURE__ */ new Map();
  }
  queue.sort(comparator);
  const check =  true ? (job) => checkRecursiveUpdates(seen, job) : 0;
  try {
    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
      const job = queue[flushIndex];
      if (job && job.active !== false) {
        if ( true && check(job)) {
          continue;
        }
        callWithErrorHandling(
          job,
          job.i,
          job.i ? 15 : 14
        );
      }
    }
  } finally {
    flushIndex = 0;
    queue.length = 0;
    flushPostFlushCbs(seen);
    isFlushing = false;
    currentFlushPromise = null;
    if (queue.length || pendingPostFlushCbs.length) {
      flushJobs(seen);
    }
  }
}
function checkRecursiveUpdates(seen, fn) {
  if (!seen.has(fn)) {
    seen.set(fn, 1);
  } else {
    const count = seen.get(fn);
    if (count > RECURSION_LIMIT) {
      const instance = fn.i;
      const componentName = instance && getComponentName(instance.type);
      handleError(
        `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
        null,
        10
      );
      return true;
    } else {
      seen.set(fn, count + 1);
    }
  }
}

let isHmrUpdating = false;
const hmrDirtyComponents = /* @__PURE__ */ new Map();
if (true) {
  (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().__VUE_HMR_RUNTIME__ = {
    createRecord: tryWrap(createRecord),
    rerender: tryWrap(rerender),
    reload: tryWrap(reload)
  };
}
const map = /* @__PURE__ */ new Map();
function registerHMR(instance) {
  const id = instance.type.__hmrId;
  let record = map.get(id);
  if (!record) {
    createRecord(id, instance.type);
    record = map.get(id);
  }
  record.instances.add(instance);
}
function unregisterHMR(instance) {
  map.get(instance.type.__hmrId).instances.delete(instance);
}
function createRecord(id, initialDef) {
  if (map.has(id)) {
    return false;
  }
  map.set(id, {
    initialDef: normalizeClassComponent(initialDef),
    instances: /* @__PURE__ */ new Set()
  });
  return true;
}
function normalizeClassComponent(component) {
  return isClassComponent(component) ? component.__vccOpts : component;
}
function rerender(id, newRender) {
  const record = map.get(id);
  if (!record) {
    return;
  }
  record.initialDef.render = newRender;
  [...record.instances].forEach((instance) => {
    if (newRender) {
      instance.render = newRender;
      normalizeClassComponent(instance.type).render = newRender;
    }
    instance.renderCache = [];
    isHmrUpdating = true;
    instance.effect.dirty = true;
    instance.update();
    isHmrUpdating = false;
  });
}
function reload(id, newComp) {
  const record = map.get(id);
  if (!record) return;
  newComp = normalizeClassComponent(newComp);
  updateComponentDef(record.initialDef, newComp);
  const instances = [...record.instances];
  for (let i = 0; i < instances.length; i++) {
    const instance = instances[i];
    const oldComp = normalizeClassComponent(instance.type);
    let dirtyInstances = hmrDirtyComponents.get(oldComp);
    if (!dirtyInstances) {
      if (oldComp !== record.initialDef) {
        updateComponentDef(oldComp, newComp);
      }
      hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
    }
    dirtyInstances.add(instance);
    instance.appContext.propsCache.delete(instance.type);
    instance.appContext.emitsCache.delete(instance.type);
    instance.appContext.optionsCache.delete(instance.type);
    if (instance.ceReload) {
      dirtyInstances.add(instance);
      instance.ceReload(newComp.styles);
      dirtyInstances.delete(instance);
    } else if (instance.parent) {
      instance.parent.effect.dirty = true;
      queueJob(() => {
        instance.parent.update();
        dirtyInstances.delete(instance);
      });
    } else if (instance.appContext.reload) {
      instance.appContext.reload();
    } else if (typeof window !== "undefined") {
      window.location.reload();
    } else {
      console.warn(
        "[HMR] Root or manually mounted instance modified. Full reload required."
      );
    }
  }
  queuePostFlushCb(() => {
    hmrDirtyComponents.clear();
  });
}
function updateComponentDef(oldComp, newComp) {
  (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(oldComp, newComp);
  for (const key in oldComp) {
    if (key !== "__file" && !(key in newComp)) {
      delete oldComp[key];
    }
  }
}
function tryWrap(fn) {
  return (id, arg) => {
    try {
      return fn(id, arg);
    } catch (e) {
      console.error(e);
      console.warn(
        `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
      );
    }
  };
}

let devtools$1;
let buffer = [];
let devtoolsNotInstalled = false;
function emit$1(event, ...args) {
  if (devtools$1) {
    devtools$1.emit(event, ...args);
  } else if (!devtoolsNotInstalled) {
    buffer.push({ event, args });
  }
}
function setDevtoolsHook$1(hook, target) {
  var _a, _b;
  devtools$1 = hook;
  if (devtools$1) {
    devtools$1.enabled = true;
    buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));
    buffer = [];
  } else if (
    // handle late devtools injection - only do this if we are in an actual
    // browser environment to avoid the timer handle stalling test runner exit
    // (#4815)
    typeof window !== "undefined" && // some envs mock window but not fully
    window.HTMLElement && // also exclude jsdom
    // eslint-disable-next-line no-restricted-syntax
    !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
  ) {
    const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
    replay.push((newHook) => {
      setDevtoolsHook$1(newHook, target);
    });
    setTimeout(() => {
      if (!devtools$1) {
        target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
        devtoolsNotInstalled = true;
        buffer = [];
      }
    }, 3e3);
  } else {
    devtoolsNotInstalled = true;
    buffer = [];
  }
}
function devtoolsInitApp(app, version) {
  emit$1("app:init" /* APP_INIT */, app, version, {
    Fragment,
    Text,
    Comment,
    Static
  });
}
function devtoolsUnmountApp(app) {
  emit$1("app:unmount" /* APP_UNMOUNT */, app);
}
const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
  "component:added" /* COMPONENT_ADDED */
);
const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
  "component:removed" /* COMPONENT_REMOVED */
);
const devtoolsComponentRemoved = (component) => {
  if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered
  !devtools$1.cleanupBuffer(component)) {
    _devtoolsComponentRemoved(component);
  }
};
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function createDevtoolsComponentHook(hook) {
  return (component) => {
    emit$1(
      hook,
      component.appContext.app,
      component.uid,
      component.parent ? component.parent.uid : void 0,
      component
    );
  };
}
const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
  "perf:start" /* PERFORMANCE_START */
);
const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
  "perf:end" /* PERFORMANCE_END */
);
function createDevtoolsPerformanceHook(hook) {
  return (component, type, time) => {
    emit$1(hook, component.appContext.app, component.uid, component, type, time);
  };
}
function devtoolsComponentEmit(component, event, params) {
  emit$1(
    "component:emit" /* COMPONENT_EMIT */,
    component.appContext.app,
    component,
    event,
    params
  );
}

let currentRenderingInstance = null;
let currentScopeId = null;
function setCurrentRenderingInstance(instance) {
  const prev = currentRenderingInstance;
  currentRenderingInstance = instance;
  currentScopeId = instance && instance.type.__scopeId || null;
  return prev;
}
function pushScopeId(id) {
  currentScopeId = id;
}
function popScopeId() {
  currentScopeId = null;
}
const withScopeId = (_id) => withCtx;
function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
  if (!ctx) return fn;
  if (fn._n) {
    return fn;
  }
  const renderFnWithContext = (...args) => {
    if (renderFnWithContext._d) {
      setBlockTracking(-1);
    }
    const prevInstance = setCurrentRenderingInstance(ctx);
    let res;
    try {
      res = fn(...args);
    } finally {
      setCurrentRenderingInstance(prevInstance);
      if (renderFnWithContext._d) {
        setBlockTracking(1);
      }
    }
    if (true) {
      devtoolsComponentUpdated(ctx);
    }
    return res;
  };
  renderFnWithContext._n = true;
  renderFnWithContext._c = true;
  renderFnWithContext._d = true;
  return renderFnWithContext;
}

function validateDirectiveName(name) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isBuiltInDirective)(name)) {
    warn$1("Do not use built-in directive ids as custom directive id: " + name);
  }
}
function withDirectives(vnode, directives) {
  if (currentRenderingInstance === null) {
     true && warn$1(`withDirectives can only be used inside render functions.`);
    return vnode;
  }
  const instance = getComponentPublicInstance(currentRenderingInstance);
  const bindings = vnode.dirs || (vnode.dirs = []);
  for (let i = 0; i < directives.length; i++) {
    let [dir, value, arg, modifiers = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ] = directives[i];
    if (dir) {
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(dir)) {
        dir = {
          mounted: dir,
          updated: dir
        };
      }
      if (dir.deep) {
        traverse(value);
      }
      bindings.push({
        dir,
        instance,
        value,
        oldValue: void 0,
        arg,
        modifiers
      });
    }
  }
  return vnode;
}
function invokeDirectiveHook(vnode, prevVNode, instance, name) {
  const bindings = vnode.dirs;
  const oldBindings = prevVNode && prevVNode.dirs;
  for (let i = 0; i < bindings.length; i++) {
    const binding = bindings[i];
    if (oldBindings) {
      binding.oldValue = oldBindings[i].value;
    }
    let hook = binding.dir[name];
    if (hook) {
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)();
      callWithAsyncErrorHandling(hook, instance, 8, [
        vnode.el,
        binding,
        vnode,
        prevVNode
      ]);
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)();
    }
  }
}

const leaveCbKey = Symbol("_leaveCb");
const enterCbKey = Symbol("_enterCb");
function useTransitionState() {
  const state = {
    isMounted: false,
    isLeaving: false,
    isUnmounting: false,
    leavingVNodes: /* @__PURE__ */ new Map()
  };
  onMounted(() => {
    state.isMounted = true;
  });
  onBeforeUnmount(() => {
    state.isUnmounting = true;
  });
  return state;
}
const TransitionHookValidator = [Function, Array];
const BaseTransitionPropsValidators = {
  mode: String,
  appear: Boolean,
  persisted: Boolean,
  // enter
  onBeforeEnter: TransitionHookValidator,
  onEnter: TransitionHookValidator,
  onAfterEnter: TransitionHookValidator,
  onEnterCancelled: TransitionHookValidator,
  // leave
  onBeforeLeave: TransitionHookValidator,
  onLeave: TransitionHookValidator,
  onAfterLeave: TransitionHookValidator,
  onLeaveCancelled: TransitionHookValidator,
  // appear
  onBeforeAppear: TransitionHookValidator,
  onAppear: TransitionHookValidator,
  onAfterAppear: TransitionHookValidator,
  onAppearCancelled: TransitionHookValidator
};
const recursiveGetSubtree = (instance) => {
  const subTree = instance.subTree;
  return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
};
const BaseTransitionImpl = {
  name: `BaseTransition`,
  props: BaseTransitionPropsValidators,
  setup(props, { slots }) {
    const instance = getCurrentInstance();
    const state = useTransitionState();
    return () => {
      const children = slots.default && getTransitionRawChildren(slots.default(), true);
      if (!children || !children.length) {
        return;
      }
      let child = children[0];
      if (children.length > 1) {
        let hasFound = false;
        for (const c of children) {
          if (c.type !== Comment) {
            if ( true && hasFound) {
              warn$1(
                "<transition> can only be used on a single element or component. Use <transition-group> for lists."
              );
              break;
            }
            child = c;
            hasFound = true;
            if (false) {}
          }
        }
      }
      const rawProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props);
      const { mode } = rawProps;
      if ( true && mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") {
        warn$1(`invalid <transition> mode: ${mode}`);
      }
      if (state.isLeaving) {
        return emptyPlaceholder(child);
      }
      const innerChild = getKeepAliveChild(child);
      if (!innerChild) {
        return emptyPlaceholder(child);
      }
      let enterHooks = resolveTransitionHooks(
        innerChild,
        rawProps,
        state,
        instance,
        // #11061, ensure enterHooks is fresh after clone
        (hooks) => enterHooks = hooks
      );
      setTransitionHooks(innerChild, enterHooks);
      const oldChild = instance.subTree;
      const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
      if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {
        const leavingHooks = resolveTransitionHooks(
          oldInnerChild,
          rawProps,
          state,
          instance
        );
        setTransitionHooks(oldInnerChild, leavingHooks);
        if (mode === "out-in" && innerChild.type !== Comment) {
          state.isLeaving = true;
          leavingHooks.afterLeave = () => {
            state.isLeaving = false;
            if (instance.update.active !== false) {
              instance.effect.dirty = true;
              instance.update();
            }
          };
          return emptyPlaceholder(child);
        } else if (mode === "in-out" && innerChild.type !== Comment) {
          leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
            const leavingVNodesCache = getLeavingNodesForType(
              state,
              oldInnerChild
            );
            leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
            el[leaveCbKey] = () => {
              earlyRemove();
              el[leaveCbKey] = void 0;
              delete enterHooks.delayedLeave;
            };
            enterHooks.delayedLeave = delayedLeave;
          };
        }
      }
      return child;
    };
  }
};
const BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
  const { leavingVNodes } = state;
  let leavingVNodesCache = leavingVNodes.get(vnode.type);
  if (!leavingVNodesCache) {
    leavingVNodesCache = /* @__PURE__ */ Object.create(null);
    leavingVNodes.set(vnode.type, leavingVNodesCache);
  }
  return leavingVNodesCache;
}
function resolveTransitionHooks(vnode, props, state, instance, postClone) {
  const {
    appear,
    mode,
    persisted = false,
    onBeforeEnter,
    onEnter,
    onAfterEnter,
    onEnterCancelled,
    onBeforeLeave,
    onLeave,
    onAfterLeave,
    onLeaveCancelled,
    onBeforeAppear,
    onAppear,
    onAfterAppear,
    onAppearCancelled
  } = props;
  const key = String(vnode.key);
  const leavingVNodesCache = getLeavingNodesForType(state, vnode);
  const callHook = (hook, args) => {
    hook && callWithAsyncErrorHandling(
      hook,
      instance,
      9,
      args
    );
  };
  const callAsyncHook = (hook, args) => {
    const done = args[1];
    callHook(hook, args);
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) {
      if (hook.every((hook2) => hook2.length <= 1)) done();
    } else if (hook.length <= 1) {
      done();
    }
  };
  const hooks = {
    mode,
    persisted,
    beforeEnter(el) {
      let hook = onBeforeEnter;
      if (!state.isMounted) {
        if (appear) {
          hook = onBeforeAppear || onBeforeEnter;
        } else {
          return;
        }
      }
      if (el[leaveCbKey]) {
        el[leaveCbKey](
          true
          /* cancelled */
        );
      }
      const leavingVNode = leavingVNodesCache[key];
      if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
        leavingVNode.el[leaveCbKey]();
      }
      callHook(hook, [el]);
    },
    enter(el) {
      let hook = onEnter;
      let afterHook = onAfterEnter;
      let cancelHook = onEnterCancelled;
      if (!state.isMounted) {
        if (appear) {
          hook = onAppear || onEnter;
          afterHook = onAfterAppear || onAfterEnter;
          cancelHook = onAppearCancelled || onEnterCancelled;
        } else {
          return;
        }
      }
      let called = false;
      const done = el[enterCbKey] = (cancelled) => {
        if (called) return;
        called = true;
        if (cancelled) {
          callHook(cancelHook, [el]);
        } else {
          callHook(afterHook, [el]);
        }
        if (hooks.delayedLeave) {
          hooks.delayedLeave();
        }
        el[enterCbKey] = void 0;
      };
      if (hook) {
        callAsyncHook(hook, [el, done]);
      } else {
        done();
      }
    },
    leave(el, remove) {
      const key2 = String(vnode.key);
      if (el[enterCbKey]) {
        el[enterCbKey](
          true
          /* cancelled */
        );
      }
      if (state.isUnmounting) {
        return remove();
      }
      callHook(onBeforeLeave, [el]);
      let called = false;
      const done = el[leaveCbKey] = (cancelled) => {
        if (called) return;
        called = true;
        remove();
        if (cancelled) {
          callHook(onLeaveCancelled, [el]);
        } else {
          callHook(onAfterLeave, [el]);
        }
        el[leaveCbKey] = void 0;
        if (leavingVNodesCache[key2] === vnode) {
          delete leavingVNodesCache[key2];
        }
      };
      leavingVNodesCache[key2] = vnode;
      if (onLeave) {
        callAsyncHook(onLeave, [el, done]);
      } else {
        done();
      }
    },
    clone(vnode2) {
      const hooks2 = resolveTransitionHooks(
        vnode2,
        props,
        state,
        instance,
        postClone
      );
      if (postClone) postClone(hooks2);
      return hooks2;
    }
  };
  return hooks;
}
function emptyPlaceholder(vnode) {
  if (isKeepAlive(vnode)) {
    vnode = cloneVNode(vnode);
    vnode.children = null;
    return vnode;
  }
}
function getKeepAliveChild(vnode) {
  if (!isKeepAlive(vnode)) {
    return vnode;
  }
  if ( true && vnode.component) {
    return vnode.component.subTree;
  }
  const { shapeFlag, children } = vnode;
  if (children) {
    if (shapeFlag & 16) {
      return children[0];
    }
    if (shapeFlag & 32 && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(children.default)) {
      return children.default();
    }
  }
}
function setTransitionHooks(vnode, hooks) {
  if (vnode.shapeFlag & 6 && vnode.component) {
    setTransitionHooks(vnode.component.subTree, hooks);
  } else if (vnode.shapeFlag & 128) {
    vnode.ssContent.transition = hooks.clone(vnode.ssContent);
    vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
  } else {
    vnode.transition = hooks;
  }
}
function getTransitionRawChildren(children, keepComment = false, parentKey) {
  let ret = [];
  let keyedFragmentCount = 0;
  for (let i = 0; i < children.length; i++) {
    let child = children[i];
    const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
    if (child.type === Fragment) {
      if (child.patchFlag & 128) keyedFragmentCount++;
      ret = ret.concat(
        getTransitionRawChildren(child.children, keepComment, key)
      );
    } else if (keepComment || child.type !== Comment) {
      ret.push(key != null ? cloneVNode(child, { key }) : child);
    }
  }
  if (keyedFragmentCount > 1) {
    for (let i = 0; i < ret.length; i++) {
      ret[i].patchFlag = -2;
    }
  }
  return ret;
}

/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineComponent(options, extraOptions) {
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(options) ? (
    // #8326: extend call and options.name access are considered side-effects
    // by Rollup, so we have to wrap it in a pure-annotated IIFE.
    /* @__PURE__ */ (() => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({ name: options.name }, extraOptions, { setup: options }))()
  ) : options;
}

const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineAsyncComponent(source) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(source)) {
    source = { loader: source };
  }
  const {
    loader,
    loadingComponent,
    errorComponent,
    delay = 200,
    timeout,
    // undefined = never times out
    suspensible = true,
    onError: userOnError
  } = source;
  let pendingRequest = null;
  let resolvedComp;
  let retries = 0;
  const retry = () => {
    retries++;
    pendingRequest = null;
    return load();
  };
  const load = () => {
    let thisRequest;
    return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
      err = err instanceof Error ? err : new Error(String(err));
      if (userOnError) {
        return new Promise((resolve, reject) => {
          const userRetry = () => resolve(retry());
          const userFail = () => reject(err);
          userOnError(err, userRetry, userFail, retries + 1);
        });
      } else {
        throw err;
      }
    }).then((comp) => {
      if (thisRequest !== pendingRequest && pendingRequest) {
        return pendingRequest;
      }
      if ( true && !comp) {
        warn$1(
          `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`
        );
      }
      if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
        comp = comp.default;
      }
      if ( true && comp && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) {
        throw new Error(`Invalid async component load result: ${comp}`);
      }
      resolvedComp = comp;
      return comp;
    }));
  };
  return defineComponent({
    name: "AsyncComponentWrapper",
    __asyncLoader: load,
    get __asyncResolved() {
      return resolvedComp;
    },
    setup() {
      const instance = currentInstance;
      if (resolvedComp) {
        return () => createInnerComp(resolvedComp, instance);
      }
      const onError = (err) => {
        pendingRequest = null;
        handleError(
          err,
          instance,
          13,
          !errorComponent
        );
      };
      if (suspensible && instance.suspense || isInSSRComponentSetup) {
        return load().then((comp) => {
          return () => createInnerComp(comp, instance);
        }).catch((err) => {
          onError(err);
          return () => errorComponent ? createVNode(errorComponent, {
            error: err
          }) : null;
        });
      }
      const loaded = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(false);
      const error = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)();
      const delayed = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)(!!delay);
      if (delay) {
        setTimeout(() => {
          delayed.value = false;
        }, delay);
      }
      if (timeout != null) {
        setTimeout(() => {
          if (!loaded.value && !error.value) {
            const err = new Error(
              `Async component timed out after ${timeout}ms.`
            );
            onError(err);
            error.value = err;
          }
        }, timeout);
      }
      load().then(() => {
        loaded.value = true;
        if (instance.parent && isKeepAlive(instance.parent.vnode)) {
          instance.parent.effect.dirty = true;
          queueJob(instance.parent.update);
        }
      }).catch((err) => {
        onError(err);
        error.value = err;
      });
      return () => {
        if (loaded.value && resolvedComp) {
          return createInnerComp(resolvedComp, instance);
        } else if (error.value && errorComponent) {
          return createVNode(errorComponent, {
            error: error.value
          });
        } else if (loadingComponent && !delayed.value) {
          return createVNode(loadingComponent);
        }
      };
    }
  });
}
function createInnerComp(comp, parent) {
  const { ref: ref2, props, children, ce } = parent.vnode;
  const vnode = createVNode(comp, props, children);
  vnode.ref = ref2;
  vnode.ce = ce;
  delete parent.vnode.ce;
  return vnode;
}

const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
const KeepAliveImpl = {
  name: `KeepAlive`,
  // Marker for special handling inside the renderer. We are not using a ===
  // check directly on KeepAlive in the renderer, because importing it directly
  // would prevent it from being tree-shaken.
  __isKeepAlive: true,
  props: {
    include: [String, RegExp, Array],
    exclude: [String, RegExp, Array],
    max: [String, Number]
  },
  setup(props, { slots }) {
    const instance = getCurrentInstance();
    const sharedContext = instance.ctx;
    if (!sharedContext.renderer) {
      return () => {
        const children = slots.default && slots.default();
        return children && children.length === 1 ? children[0] : children;
      };
    }
    const cache = /* @__PURE__ */ new Map();
    const keys = /* @__PURE__ */ new Set();
    let current = null;
    if (true) {
      instance.__v_cache = cache;
    }
    const parentSuspense = instance.suspense;
    const {
      renderer: {
        p: patch,
        m: move,
        um: _unmount,
        o: { createElement }
      }
    } = sharedContext;
    const storageContainer = createElement("div");
    sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
      const instance2 = vnode.component;
      move(vnode, container, anchor, 0, parentSuspense);
      patch(
        instance2.vnode,
        vnode,
        container,
        anchor,
        instance2,
        parentSuspense,
        namespace,
        vnode.slotScopeIds,
        optimized
      );
      queuePostRenderEffect(() => {
        instance2.isDeactivated = false;
        if (instance2.a) {
          (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance2.a);
        }
        const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
        if (vnodeHook) {
          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
        }
      }, parentSuspense);
      if (true) {
        devtoolsComponentAdded(instance2);
      }
    };
    sharedContext.deactivate = (vnode) => {
      const instance2 = vnode.component;
      invalidateMount(instance2.m);
      invalidateMount(instance2.a);
      move(vnode, storageContainer, null, 1, parentSuspense);
      queuePostRenderEffect(() => {
        if (instance2.da) {
          (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance2.da);
        }
        const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
        if (vnodeHook) {
          invokeVNodeHook(vnodeHook, instance2.parent, vnode);
        }
        instance2.isDeactivated = true;
      }, parentSuspense);
      if (true) {
        devtoolsComponentAdded(instance2);
      }
    };
    function unmount(vnode) {
      resetShapeFlag(vnode);
      _unmount(vnode, instance, parentSuspense, true);
    }
    function pruneCache(filter) {
      cache.forEach((vnode, key) => {
        const name = getComponentName(vnode.type);
        if (name && (!filter || !filter(name))) {
          pruneCacheEntry(key);
        }
      });
    }
    function pruneCacheEntry(key) {
      const cached = cache.get(key);
      if (cached && (!current || !isSameVNodeType(cached, current))) {
        unmount(cached);
      } else if (current) {
        resetShapeFlag(current);
      }
      cache.delete(key);
      keys.delete(key);
    }
    watch(
      () => [props.include, props.exclude],
      ([include, exclude]) => {
        include && pruneCache((name) => matches(include, name));
        exclude && pruneCache((name) => !matches(exclude, name));
      },
      // prune post-render after `current` has been updated
      { flush: "post", deep: true }
    );
    let pendingCacheKey = null;
    const cacheSubtree = () => {
      if (pendingCacheKey != null) {
        if (isSuspense(instance.subTree.type)) {
          queuePostRenderEffect(() => {
            cache.set(pendingCacheKey, getInnerChild(instance.subTree));
          }, instance.subTree.suspense);
        } else {
          cache.set(pendingCacheKey, getInnerChild(instance.subTree));
        }
      }
    };
    onMounted(cacheSubtree);
    onUpdated(cacheSubtree);
    onBeforeUnmount(() => {
      cache.forEach((cached) => {
        const { subTree, suspense } = instance;
        const vnode = getInnerChild(subTree);
        if (cached.type === vnode.type && cached.key === vnode.key) {
          resetShapeFlag(vnode);
          const da = vnode.component.da;
          da && queuePostRenderEffect(da, suspense);
          return;
        }
        unmount(cached);
      });
    });
    return () => {
      pendingCacheKey = null;
      if (!slots.default) {
        return null;
      }
      const children = slots.default();
      const rawVNode = children[0];
      if (children.length > 1) {
        if (true) {
          warn$1(`KeepAlive should contain exactly one component child.`);
        }
        current = null;
        return children;
      } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
        current = null;
        return rawVNode;
      }
      let vnode = getInnerChild(rawVNode);
      if (vnode.type === Comment) {
        current = null;
        return vnode;
      }
      const comp = vnode.type;
      const name = getComponentName(
        isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
      );
      const { include, exclude, max } = props;
      if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
        current = vnode;
        return rawVNode;
      }
      const key = vnode.key == null ? comp : vnode.key;
      const cachedVNode = cache.get(key);
      if (vnode.el) {
        vnode = cloneVNode(vnode);
        if (rawVNode.shapeFlag & 128) {
          rawVNode.ssContent = vnode;
        }
      }
      pendingCacheKey = key;
      if (cachedVNode) {
        vnode.el = cachedVNode.el;
        vnode.component = cachedVNode.component;
        if (vnode.transition) {
          setTransitionHooks(vnode, vnode.transition);
        }
        vnode.shapeFlag |= 512;
        keys.delete(key);
        keys.add(key);
      } else {
        keys.add(key);
        if (max && keys.size > parseInt(max, 10)) {
          pruneCacheEntry(keys.values().next().value);
        }
      }
      vnode.shapeFlag |= 256;
      current = vnode;
      return isSuspense(rawVNode.type) ? rawVNode : vnode;
    };
  }
};
const KeepAlive = KeepAliveImpl;
function matches(pattern, name) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(pattern)) {
    return pattern.some((p) => matches(p, name));
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(pattern)) {
    return pattern.split(",").includes(name);
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isRegExp)(pattern)) {
    return pattern.test(name);
  }
  return false;
}
function onActivated(hook, target) {
  registerKeepAliveHook(hook, "a", target);
}
function onDeactivated(hook, target) {
  registerKeepAliveHook(hook, "da", target);
}
function registerKeepAliveHook(hook, type, target = currentInstance) {
  const wrappedHook = hook.__wdc || (hook.__wdc = () => {
    let current = target;
    while (current) {
      if (current.isDeactivated) {
        return;
      }
      current = current.parent;
    }
    return hook();
  });
  injectHook(type, wrappedHook, target);
  if (target) {
    let current = target.parent;
    while (current && current.parent) {
      if (isKeepAlive(current.parent.vnode)) {
        injectToKeepAliveRoot(wrappedHook, type, target, current);
      }
      current = current.parent;
    }
  }
}
function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
  const injected = injectHook(
    type,
    hook,
    keepAliveRoot,
    true
    /* prepend */
  );
  onUnmounted(() => {
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(keepAliveRoot[type], injected);
  }, target);
}
function resetShapeFlag(vnode) {
  vnode.shapeFlag &= ~256;
  vnode.shapeFlag &= ~512;
}
function getInnerChild(vnode) {
  return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
}

function injectHook(type, hook, target = currentInstance, prepend = false) {
  if (target) {
    const hooks = target[type] || (target[type] = []);
    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)();
      const reset = setCurrentInstance(target);
      const res = callWithAsyncErrorHandling(hook, target, type, args);
      reset();
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)();
      return res;
    });
    if (prepend) {
      hooks.unshift(wrappedHook);
    } else {
      hooks.push(wrappedHook);
    }
    return wrappedHook;
  } else if (true) {
    const apiName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(ErrorTypeStrings$1[type].replace(/ hook$/, ""));
    warn$1(
      `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + (` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.` )
    );
  }
}
const createHook = (lifecycle) => (hook, target = currentInstance) => {
  if (!isInSSRComponentSetup || lifecycle === "sp") {
    injectHook(lifecycle, (...args) => hook(...args), target);
  }
};
const onBeforeMount = createHook("bm");
const onMounted = createHook("m");
const onBeforeUpdate = createHook("bu");
const onUpdated = createHook("u");
const onBeforeUnmount = createHook("bum");
const onUnmounted = createHook("um");
const onServerPrefetch = createHook("sp");
const onRenderTriggered = createHook(
  "rtg"
);
const onRenderTracked = createHook(
  "rtc"
);
function onErrorCaptured(hook, target = currentInstance) {
  injectHook("ec", hook, target);
}

const COMPONENTS = "components";
const DIRECTIVES = "directives";
function resolveComponent(name, maybeSelfReference) {
  return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
}
const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
function resolveDynamicComponent(component) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(component)) {
    return resolveAsset(COMPONENTS, component, false) || component;
  } else {
    return component || NULL_DYNAMIC_COMPONENT;
  }
}
function resolveDirective(name) {
  return resolveAsset(DIRECTIVES, name);
}
function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
  const instance = currentRenderingInstance || currentInstance;
  if (instance) {
    const Component = instance.type;
    if (type === COMPONENTS) {
      const selfName = getComponentName(
        Component,
        false
      );
      if (selfName && (selfName === name || selfName === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name) || selfName === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name)))) {
        return Component;
      }
    }
    const res = (
      // local registration
      // check instance[type] first which is resolved for options API
      resolve(instance[type] || Component[type], name) || // global registration
      resolve(instance.appContext[type], name)
    );
    if (!res && maybeSelfReference) {
      return Component;
    }
    if ( true && warnMissing && !res) {
      const extra = type === COMPONENTS ? `
If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
      warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
    }
    return res;
  } else if (true) {
    warn$1(
      `resolve${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)(type.slice(0, -1))} can only be used in render() or setup().`
    );
  }
}
function resolve(registry, name) {
  return registry && (registry[name] || registry[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name)] || registry[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name))]);
}

function renderList(source, renderItem, cache, index) {
  let ret;
  const cached = cache && cache[index];
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(source) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(source)) {
    ret = new Array(source.length);
    for (let i = 0, l = source.length; i < l; i++) {
      ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
    }
  } else if (typeof source === "number") {
    if ( true && !Number.isInteger(source)) {
      warn$1(`The v-for range expect an integer value but got ${source}.`);
    }
    ret = new Array(source);
    for (let i = 0; i < source; i++) {
      ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
    }
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(source)) {
    if (source[Symbol.iterator]) {
      ret = Array.from(
        source,
        (item, i) => renderItem(item, i, void 0, cached && cached[i])
      );
    } else {
      const keys = Object.keys(source);
      ret = new Array(keys.length);
      for (let i = 0, l = keys.length; i < l; i++) {
        const key = keys[i];
        ret[i] = renderItem(source[key], key, i, cached && cached[i]);
      }
    }
  } else {
    ret = [];
  }
  if (cache) {
    cache[index] = ret;
  }
  return ret;
}

function createSlots(slots, dynamicSlots) {
  for (let i = 0; i < dynamicSlots.length; i++) {
    const slot = dynamicSlots[i];
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(slot)) {
      for (let j = 0; j < slot.length; j++) {
        slots[slot[j].name] = slot[j].fn;
      }
    } else if (slot) {
      slots[slot.name] = slot.key ? (...args) => {
        const res = slot.fn(...args);
        if (res) res.key = slot.key;
        return res;
      } : slot.fn;
    }
  }
  return slots;
}

function renderSlot(slots, name, props = {}, fallback, noSlotted) {
  if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
    if (name !== "default") props.name = name;
    return createVNode("slot", props, fallback && fallback());
  }
  let slot = slots[name];
  if ( true && slot && slot.length > 1) {
    warn$1(
      `SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`
    );
    slot = () => [];
  }
  if (slot && slot._c) {
    slot._d = false;
  }
  openBlock();
  const validSlotContent = slot && ensureValidVNode(slot(props));
  const rendered = createBlock(
    Fragment,
    {
      key: (props.key || // slot content array of a dynamic conditional slot may have a branch
      // key attached in the `createSlots` helper, respect that
      validSlotContent && validSlotContent.key || `_${name}`) + // #7256 force differentiate fallback content from actual content
      (!validSlotContent && fallback ? "_fb" : "")
    },
    validSlotContent || (fallback ? fallback() : []),
    validSlotContent && slots._ === 1 ? 64 : -2
  );
  if (!noSlotted && rendered.scopeId) {
    rendered.slotScopeIds = [rendered.scopeId + "-s"];
  }
  if (slot && slot._c) {
    slot._d = true;
  }
  return rendered;
}
function ensureValidVNode(vnodes) {
  return vnodes.some((child) => {
    if (!isVNode(child)) return true;
    if (child.type === Comment) return false;
    if (child.type === Fragment && !ensureValidVNode(child.children))
      return false;
    return true;
  }) ? vnodes : null;
}

function toHandlers(obj, preserveCaseIfNecessary) {
  const ret = {};
  if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(obj)) {
    warn$1(`v-on with no argument expects an object value.`);
    return ret;
  }
  for (const key in obj) {
    ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(key)] = obj[key];
  }
  return ret;
}

const getPublicInstance = (i) => {
  if (!i) return null;
  if (isStatefulComponent(i)) return getComponentPublicInstance(i);
  return getPublicInstance(i.parent);
};
const publicPropertiesMap = (
  // Move PURE marker to new line to workaround compiler discarding it
  // due to type annotation
  /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(/* @__PURE__ */ Object.create(null), {
    $: (i) => i,
    $el: (i) => i.vnode.el,
    $data: (i) => i.data,
    $props: (i) =>  true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.props) : 0,
    $attrs: (i) =>  true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.attrs) : 0,
    $slots: (i) =>  true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.slots) : 0,
    $refs: (i) =>  true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(i.refs) : 0,
    $parent: (i) => getPublicInstance(i.parent),
    $root: (i) => getPublicInstance(i.root),
    $emit: (i) => i.emit,
    $options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type,
    $forceUpdate: (i) => i.f || (i.f = () => {
      i.effect.dirty = true;
      queueJob(i.update);
    }),
    $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
    $watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP
  })
);
const isReservedPrefix = (key) => key === "_" || key === "$";
const hasSetupBinding = (state, key) => state !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && !state.__isScriptSetup && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(state, key);
const PublicInstanceProxyHandlers = {
  get({ _: instance }, key) {
    if (key === "__v_skip") {
      return true;
    }
    const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
    if ( true && key === "__isVue") {
      return true;
    }
    let normalizedProps;
    if (key[0] !== "$") {
      const n = accessCache[key];
      if (n !== void 0) {
        switch (n) {
          case 1 /* SETUP */:
            return setupState[key];
          case 2 /* DATA */:
            return data[key];
          case 4 /* CONTEXT */:
            return ctx[key];
          case 3 /* PROPS */:
            return props[key];
        }
      } else if (hasSetupBinding(setupState, key)) {
        accessCache[key] = 1 /* SETUP */;
        return setupState[key];
      } else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) {
        accessCache[key] = 2 /* DATA */;
        return data[key];
      } else if (
        // only cache other properties when instance has declared (thus stable)
        // props
        (normalizedProps = instance.propsOptions[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(normalizedProps, key)
      ) {
        accessCache[key] = 3 /* PROPS */;
        return props[key];
      } else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key)) {
        accessCache[key] = 4 /* CONTEXT */;
        return ctx[key];
      } else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {
        accessCache[key] = 0 /* OTHER */;
      }
    }
    const publicGetter = publicPropertiesMap[key];
    let cssModule, globalProperties;
    if (publicGetter) {
      if (key === "$attrs") {
        (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance.attrs, "get", "");
         true && markAttrsAccessed();
      } else if ( true && key === "$slots") {
        (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance, "get", key);
      }
      return publicGetter(instance);
    } else if (
      // css module (injected by vue-loader)
      (cssModule = type.__cssModules) && (cssModule = cssModule[key])
    ) {
      return cssModule;
    } else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key)) {
      accessCache[key] = 4 /* CONTEXT */;
      return ctx[key];
    } else if (
      // global properties
      globalProperties = appContext.config.globalProperties, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(globalProperties, key)
    ) {
      {
        return globalProperties[key];
      }
    } else if ( true && currentRenderingInstance && (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading
    // to infinite warning loop
    key.indexOf("__v") !== 0)) {
      if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && isReservedPrefix(key[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) {
        warn$1(
          `Property ${JSON.stringify(
            key
          )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
        );
      } else if (instance === currentRenderingInstance) {
        warn$1(
          `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
        );
      }
    }
  },
  set({ _: instance }, key, value) {
    const { data, setupState, ctx } = instance;
    if (hasSetupBinding(setupState, key)) {
      setupState[key] = value;
      return true;
    } else if ( true && setupState.__isScriptSetup && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, key)) {
      warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
      return false;
    } else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key)) {
      data[key] = value;
      return true;
    } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(instance.props, key)) {
       true && warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
      return false;
    }
    if (key[0] === "$" && key.slice(1) in instance) {
       true && warn$1(
        `Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
      );
      return false;
    } else {
      if ( true && key in instance.appContext.config.globalProperties) {
        Object.defineProperty(ctx, key, {
          enumerable: true,
          configurable: true,
          value
        });
      } else {
        ctx[key] = value;
      }
    }
    return true;
  },
  has({
    _: { data, setupState, accessCache, ctx, appContext, propsOptions }
  }, key) {
    let normalizedProps;
    return !!accessCache[key] || data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(normalizedProps, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(ctx, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(publicPropertiesMap, key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(appContext.config.globalProperties, key);
  },
  defineProperty(target, key, descriptor) {
    if (descriptor.get != null) {
      target._.accessCache[key] = 0;
    } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(descriptor, "value")) {
      this.set(target, key, descriptor.value, null);
    }
    return Reflect.defineProperty(target, key, descriptor);
  }
};
if (true) {
  PublicInstanceProxyHandlers.ownKeys = (target) => {
    warn$1(
      `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`
    );
    return Reflect.ownKeys(target);
  };
}
const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(
  {},
  PublicInstanceProxyHandlers,
  {
    get(target, key) {
      if (key === Symbol.unscopables) {
        return;
      }
      return PublicInstanceProxyHandlers.get(target, key, target);
    },
    has(_, key) {
      const has = key[0] !== "_" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isGloballyAllowed)(key);
      if ( true && !has && PublicInstanceProxyHandlers.has(_, key)) {
        warn$1(
          `Property ${JSON.stringify(
            key
          )} should not start with _ which is a reserved prefix for Vue internals.`
        );
      }
      return has;
    }
  }
);
function createDevRenderContext(instance) {
  const target = {};
  Object.defineProperty(target, `_`, {
    configurable: true,
    enumerable: false,
    get: () => instance
  });
  Object.keys(publicPropertiesMap).forEach((key) => {
    Object.defineProperty(target, key, {
      configurable: true,
      enumerable: false,
      get: () => publicPropertiesMap[key](instance),
      // intercepted by the proxy so no need for implementation,
      // but needed to prevent set errors
      set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP
    });
  });
  return target;
}
function exposePropsOnRenderContext(instance) {
  const {
    ctx,
    propsOptions: [propsOptions]
  } = instance;
  if (propsOptions) {
    Object.keys(propsOptions).forEach((key) => {
      Object.defineProperty(ctx, key, {
        enumerable: true,
        configurable: true,
        get: () => instance.props[key],
        set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP
      });
    });
  }
}
function exposeSetupStateOnRenderContext(instance) {
  const { ctx, setupState } = instance;
  Object.keys((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(setupState)).forEach((key) => {
    if (!setupState.__isScriptSetup) {
      if (isReservedPrefix(key[0])) {
        warn$1(
          `setup() return property ${JSON.stringify(
            key
          )} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
        );
        return;
      }
      Object.defineProperty(ctx, key, {
        enumerable: true,
        configurable: true,
        get: () => setupState[key],
        set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP
      });
    }
  });
}

const warnRuntimeUsage = (method) => warn$1(
  `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
);
function defineProps() {
  if (true) {
    warnRuntimeUsage(`defineProps`);
  }
  return null;
}
function defineEmits() {
  if (true) {
    warnRuntimeUsage(`defineEmits`);
  }
  return null;
}
function defineExpose(exposed) {
  if (true) {
    warnRuntimeUsage(`defineExpose`);
  }
}
function defineOptions(options) {
  if (true) {
    warnRuntimeUsage(`defineOptions`);
  }
}
function defineSlots() {
  if (true) {
    warnRuntimeUsage(`defineSlots`);
  }
  return null;
}
function defineModel() {
  if (true) {
    warnRuntimeUsage("defineModel");
  }
}
function withDefaults(props, defaults) {
  if (true) {
    warnRuntimeUsage(`withDefaults`);
  }
  return null;
}
function useSlots() {
  return getContext().slots;
}
function useAttrs() {
  return getContext().attrs;
}
function getContext() {
  const i = getCurrentInstance();
  if ( true && !i) {
    warn$1(`useContext() called without active instance.`);
  }
  return i.setupContext || (i.setupContext = createSetupContext(i));
}
function normalizePropsOrEmits(props) {
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props) ? props.reduce(
    (normalized, p) => (normalized[p] = null, normalized),
    {}
  ) : props;
}
function mergeDefaults(raw, defaults) {
  const props = normalizePropsOrEmits(raw);
  for (const key in defaults) {
    if (key.startsWith("__skip")) continue;
    let opt = props[key];
    if (opt) {
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opt) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt)) {
        opt = props[key] = { type: opt, default: defaults[key] };
      } else {
        opt.default = defaults[key];
      }
    } else if (opt === null) {
      opt = props[key] = { default: defaults[key] };
    } else if (true) {
      warn$1(`props default key "${key}" has no corresponding declaration.`);
    }
    if (opt && defaults[`__skip_${key}`]) {
      opt.skipFactory = true;
    }
  }
  return props;
}
function mergeModels(a, b) {
  if (!a || !b) return a || b;
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(a) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(b)) return a.concat(b);
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
}
function createPropsRestProxy(props, excludedKeys) {
  const ret = {};
  for (const key in props) {
    if (!excludedKeys.includes(key)) {
      Object.defineProperty(ret, key, {
        enumerable: true,
        get: () => props[key]
      });
    }
  }
  return ret;
}
function withAsyncContext(getAwaitable) {
  const ctx = getCurrentInstance();
  if ( true && !ctx) {
    warn$1(
      `withAsyncContext called without active current instance. This is likely a bug.`
    );
  }
  let awaitable = getAwaitable();
  unsetCurrentInstance();
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(awaitable)) {
    awaitable = awaitable.catch((e) => {
      setCurrentInstance(ctx);
      throw e;
    });
  }
  return [awaitable, () => setCurrentInstance(ctx)];
}

function createDuplicateChecker() {
  const cache = /* @__PURE__ */ Object.create(null);
  return (type, key) => {
    if (cache[key]) {
      warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`);
    } else {
      cache[key] = type;
    }
  };
}
let shouldCacheAccess = true;
function applyOptions(instance) {
  const options = resolveMergedOptions(instance);
  const publicThis = instance.proxy;
  const ctx = instance.ctx;
  shouldCacheAccess = false;
  if (options.beforeCreate) {
    callHook(options.beforeCreate, instance, "bc");
  }
  const {
    // state
    data: dataOptions,
    computed: computedOptions,
    methods,
    watch: watchOptions,
    provide: provideOptions,
    inject: injectOptions,
    // lifecycle
    created,
    beforeMount,
    mounted,
    beforeUpdate,
    updated,
    activated,
    deactivated,
    beforeDestroy,
    beforeUnmount,
    destroyed,
    unmounted,
    render,
    renderTracked,
    renderTriggered,
    errorCaptured,
    serverPrefetch,
    // public API
    expose,
    inheritAttrs,
    // assets
    components,
    directives,
    filters
  } = options;
  const checkDuplicateProperties =  true ? createDuplicateChecker() : 0;
  if (true) {
    const [propsOptions] = instance.propsOptions;
    if (propsOptions) {
      for (const key in propsOptions) {
        checkDuplicateProperties("Props" /* PROPS */, key);
      }
    }
  }
  if (injectOptions) {
    resolveInjections(injectOptions, ctx, checkDuplicateProperties);
  }
  if (methods) {
    for (const key in methods) {
      const methodHandler = methods[key];
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(methodHandler)) {
        if (true) {
          Object.defineProperty(ctx, key, {
            value: methodHandler.bind(publicThis),
            configurable: true,
            enumerable: true,
            writable: true
          });
        } else {}
        if (true) {
          checkDuplicateProperties("Methods" /* METHODS */, key);
        }
      } else if (true) {
        warn$1(
          `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
        );
      }
    }
  }
  if (dataOptions) {
    if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(dataOptions)) {
      warn$1(
        `The data option must be a function. Plain object usage is no longer supported.`
      );
    }
    const data = dataOptions.call(publicThis, publicThis);
    if ( true && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(data)) {
      warn$1(
        `data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`
      );
    }
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(data)) {
       true && warn$1(`data() should return an object.`);
    } else {
      instance.data = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.reactive)(data);
      if (true) {
        for (const key in data) {
          checkDuplicateProperties("Data" /* DATA */, key);
          if (!isReservedPrefix(key[0])) {
            Object.defineProperty(ctx, key, {
              configurable: true,
              enumerable: true,
              get: () => data[key],
              set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP
            });
          }
        }
      }
    }
  }
  shouldCacheAccess = true;
  if (computedOptions) {
    for (const key in computedOptions) {
      const opt = computedOptions[key];
      const get = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) ? opt.bind(publicThis, publicThis) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt.get) ? opt.get.bind(publicThis, publicThis) : _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP;
      if ( true && get === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) {
        warn$1(`Computed property "${key}" has no getter.`);
      }
      const set = !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt.set) ? opt.set.bind(publicThis) :  true ? () => {
        warn$1(
          `Write operation failed: computed property "${key}" is readonly.`
        );
      } : 0;
      const c = computed({
        get,
        set
      });
      Object.defineProperty(ctx, key, {
        enumerable: true,
        configurable: true,
        get: () => c.value,
        set: (v) => c.value = v
      });
      if (true) {
        checkDuplicateProperties("Computed" /* COMPUTED */, key);
      }
    }
  }
  if (watchOptions) {
    for (const key in watchOptions) {
      createWatcher(watchOptions[key], ctx, publicThis, key);
    }
  }
  if (provideOptions) {
    const provides = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
    Reflect.ownKeys(provides).forEach((key) => {
      provide(key, provides[key]);
    });
  }
  if (created) {
    callHook(created, instance, "c");
  }
  function registerLifecycleHook(register, hook) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) {
      hook.forEach((_hook) => register(_hook.bind(publicThis)));
    } else if (hook) {
      register(hook.bind(publicThis));
    }
  }
  registerLifecycleHook(onBeforeMount, beforeMount);
  registerLifecycleHook(onMounted, mounted);
  registerLifecycleHook(onBeforeUpdate, beforeUpdate);
  registerLifecycleHook(onUpdated, updated);
  registerLifecycleHook(onActivated, activated);
  registerLifecycleHook(onDeactivated, deactivated);
  registerLifecycleHook(onErrorCaptured, errorCaptured);
  registerLifecycleHook(onRenderTracked, renderTracked);
  registerLifecycleHook(onRenderTriggered, renderTriggered);
  registerLifecycleHook(onBeforeUnmount, beforeUnmount);
  registerLifecycleHook(onUnmounted, unmounted);
  registerLifecycleHook(onServerPrefetch, serverPrefetch);
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(expose)) {
    if (expose.length) {
      const exposed = instance.exposed || (instance.exposed = {});
      expose.forEach((key) => {
        Object.defineProperty(exposed, key, {
          get: () => publicThis[key],
          set: (val) => publicThis[key] = val
        });
      });
    } else if (!instance.exposed) {
      instance.exposed = {};
    }
  }
  if (render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) {
    instance.render = render;
  }
  if (inheritAttrs != null) {
    instance.inheritAttrs = inheritAttrs;
  }
  if (components) instance.components = components;
  if (directives) instance.directives = directives;
}
function resolveInjections(injectOptions, ctx, checkDuplicateProperties = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(injectOptions)) {
    injectOptions = normalizeInject(injectOptions);
  }
  for (const key in injectOptions) {
    const opt = injectOptions[key];
    let injected;
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(opt)) {
      if ("default" in opt) {
        injected = inject(
          opt.from || key,
          opt.default,
          true
        );
      } else {
        injected = inject(opt.from || key);
      }
    } else {
      injected = inject(opt);
    }
    if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(injected)) {
      Object.defineProperty(ctx, key, {
        enumerable: true,
        configurable: true,
        get: () => injected.value,
        set: (v) => injected.value = v
      });
    } else {
      ctx[key] = injected;
    }
    if (true) {
      checkDuplicateProperties("Inject" /* INJECT */, key);
    }
  }
}
function callHook(hook, instance, type) {
  callWithAsyncErrorHandling(
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
    instance,
    type
  );
}
function createWatcher(raw, ctx, publicThis, key) {
  const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(raw)) {
    const handler = ctx[raw];
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(handler)) {
      watch(getter, handler);
    } else if (true) {
      warn$1(`Invalid watch handler specified by key "${raw}"`, handler);
    }
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(raw)) {
    watch(getter, raw.bind(publicThis));
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(raw)) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) {
      raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
    } else {
      const handler = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(handler)) {
        watch(getter, handler, raw);
      } else if (true) {
        warn$1(`Invalid watch handler specified by key "${raw.handler}"`, handler);
      }
    }
  } else if (true) {
    warn$1(`Invalid watch option: "${key}"`, raw);
  }
}
function resolveMergedOptions(instance) {
  const base = instance.type;
  const { mixins, extends: extendsOptions } = base;
  const {
    mixins: globalMixins,
    optionsCache: cache,
    config: { optionMergeStrategies }
  } = instance.appContext;
  const cached = cache.get(base);
  let resolved;
  if (cached) {
    resolved = cached;
  } else if (!globalMixins.length && !mixins && !extendsOptions) {
    {
      resolved = base;
    }
  } else {
    resolved = {};
    if (globalMixins.length) {
      globalMixins.forEach(
        (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
      );
    }
    mergeOptions(resolved, base, optionMergeStrategies);
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(base)) {
    cache.set(base, resolved);
  }
  return resolved;
}
function mergeOptions(to, from, strats, asMixin = false) {
  const { mixins, extends: extendsOptions } = from;
  if (extendsOptions) {
    mergeOptions(to, extendsOptions, strats, true);
  }
  if (mixins) {
    mixins.forEach(
      (m) => mergeOptions(to, m, strats, true)
    );
  }
  for (const key in from) {
    if (asMixin && key === "expose") {
       true && warn$1(
        `"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
      );
    } else {
      const strat = internalOptionMergeStrats[key] || strats && strats[key];
      to[key] = strat ? strat(to[key], from[key]) : from[key];
    }
  }
  return to;
}
const internalOptionMergeStrats = {
  data: mergeDataFn,
  props: mergeEmitsOrPropsOptions,
  emits: mergeEmitsOrPropsOptions,
  // objects
  methods: mergeObjectOptions,
  computed: mergeObjectOptions,
  // lifecycle
  beforeCreate: mergeAsArray,
  created: mergeAsArray,
  beforeMount: mergeAsArray,
  mounted: mergeAsArray,
  beforeUpdate: mergeAsArray,
  updated: mergeAsArray,
  beforeDestroy: mergeAsArray,
  beforeUnmount: mergeAsArray,
  destroyed: mergeAsArray,
  unmounted: mergeAsArray,
  activated: mergeAsArray,
  deactivated: mergeAsArray,
  errorCaptured: mergeAsArray,
  serverPrefetch: mergeAsArray,
  // assets
  components: mergeObjectOptions,
  directives: mergeObjectOptions,
  // watch
  watch: mergeWatchOptions,
  // provide / inject
  provide: mergeDataFn,
  inject: mergeInject
};
function mergeDataFn(to, from) {
  if (!from) {
    return to;
  }
  if (!to) {
    return from;
  }
  return function mergedDataFn() {
    return ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend))(
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(to) ? to.call(this, this) : to,
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(from) ? from.call(this, this) : from
    );
  };
}
function mergeInject(to, from) {
  return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
}
function normalizeInject(raw) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) {
    const res = {};
    for (let i = 0; i < raw.length; i++) {
      res[raw[i]] = raw[i];
    }
    return res;
  }
  return raw;
}
function mergeAsArray(to, from) {
  return to ? [...new Set([].concat(to, from))] : from;
}
function mergeObjectOptions(to, from) {
  return to ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(/* @__PURE__ */ Object.create(null), to, from) : from;
}
function mergeEmitsOrPropsOptions(to, from) {
  if (to) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(to) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(from)) {
      return [.../* @__PURE__ */ new Set([...to, ...from])];
    }
    return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(
      /* @__PURE__ */ Object.create(null),
      normalizePropsOrEmits(to),
      normalizePropsOrEmits(from != null ? from : {})
    );
  } else {
    return from;
  }
}
function mergeWatchOptions(to, from) {
  if (!to) return from;
  if (!from) return to;
  const merged = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(/* @__PURE__ */ Object.create(null), to);
  for (const key in from) {
    merged[key] = mergeAsArray(to[key], from[key]);
  }
  return merged;
}

function createAppContext() {
  return {
    app: null,
    config: {
      isNativeTag: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NO,
      performance: false,
      globalProperties: {},
      optionMergeStrategies: {},
      errorHandler: void 0,
      warnHandler: void 0,
      compilerOptions: {}
    },
    mixins: [],
    components: {},
    directives: {},
    provides: /* @__PURE__ */ Object.create(null),
    optionsCache: /* @__PURE__ */ new WeakMap(),
    propsCache: /* @__PURE__ */ new WeakMap(),
    emitsCache: /* @__PURE__ */ new WeakMap()
  };
}
let uid$1 = 0;
function createAppAPI(render, hydrate) {
  return function createApp(rootComponent, rootProps = null) {
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(rootComponent)) {
      rootComponent = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, rootComponent);
    }
    if (rootProps != null && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(rootProps)) {
       true && warn$1(`root props passed to app.mount() must be an object.`);
      rootProps = null;
    }
    const context = createAppContext();
    const installedPlugins = /* @__PURE__ */ new WeakSet();
    let isMounted = false;
    const app = context.app = {
      _uid: uid$1++,
      _component: rootComponent,
      _props: rootProps,
      _container: null,
      _context: context,
      _instance: null,
      version,
      get config() {
        return context.config;
      },
      set config(v) {
        if (true) {
          warn$1(
            `app.config cannot be replaced. Modify individual options instead.`
          );
        }
      },
      use(plugin, ...options) {
        if (installedPlugins.has(plugin)) {
           true && warn$1(`Plugin has already been applied to target app.`);
        } else if (plugin && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(plugin.install)) {
          installedPlugins.add(plugin);
          plugin.install(app, ...options);
        } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(plugin)) {
          installedPlugins.add(plugin);
          plugin(app, ...options);
        } else if (true) {
          warn$1(
            `A plugin must either be a function or an object with an "install" function.`
          );
        }
        return app;
      },
      mixin(mixin) {
        if (__VUE_OPTIONS_API__) {
          if (!context.mixins.includes(mixin)) {
            context.mixins.push(mixin);
          } else if (true) {
            warn$1(
              "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
            );
          }
        } else if (true) {
          warn$1("Mixins are only available in builds supporting Options API");
        }
        return app;
      },
      component(name, component) {
        if (true) {
          validateComponentName(name, context.config);
        }
        if (!component) {
          return context.components[name];
        }
        if ( true && context.components[name]) {
          warn$1(`Component "${name}" has already been registered in target app.`);
        }
        context.components[name] = component;
        return app;
      },
      directive(name, directive) {
        if (true) {
          validateDirectiveName(name);
        }
        if (!directive) {
          return context.directives[name];
        }
        if ( true && context.directives[name]) {
          warn$1(`Directive "${name}" has already been registered in target app.`);
        }
        context.directives[name] = directive;
        return app;
      },
      mount(rootContainer, isHydrate, namespace) {
        if (!isMounted) {
          if ( true && rootContainer.__vue_app__) {
            warn$1(
              `There is already an app instance mounted on the host container.
 If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
            );
          }
          const vnode = createVNode(rootComponent, rootProps);
          vnode.appContext = context;
          if (namespace === true) {
            namespace = "svg";
          } else if (namespace === false) {
            namespace = void 0;
          }
          if (true) {
            context.reload = () => {
              render(
                cloneVNode(vnode),
                rootContainer,
                namespace
              );
            };
          }
          if (isHydrate && hydrate) {
            hydrate(vnode, rootContainer);
          } else {
            render(vnode, rootContainer, namespace);
          }
          isMounted = true;
          app._container = rootContainer;
          rootContainer.__vue_app__ = app;
          if (true) {
            app._instance = vnode.component;
            devtoolsInitApp(app, version);
          }
          return getComponentPublicInstance(vnode.component);
        } else if (true) {
          warn$1(
            `App has already been mounted.
If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
          );
        }
      },
      unmount() {
        if (isMounted) {
          render(null, app._container);
          if (true) {
            app._instance = null;
            devtoolsUnmountApp(app);
          }
          delete app._container.__vue_app__;
        } else if (true) {
          warn$1(`Cannot unmount an app that is not mounted.`);
        }
      },
      provide(key, value) {
        if ( true && key in context.provides) {
          warn$1(
            `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
          );
        }
        context.provides[key] = value;
        return app;
      },
      runWithContext(fn) {
        const lastApp = currentApp;
        currentApp = app;
        try {
          return fn();
        } finally {
          currentApp = lastApp;
        }
      }
    };
    return app;
  };
}
let currentApp = null;

function provide(key, value) {
  if (!currentInstance) {
    if (true) {
      warn$1(`provide() can only be used inside setup().`);
    }
  } else {
    let provides = currentInstance.provides;
    const parentProvides = currentInstance.parent && currentInstance.parent.provides;
    if (parentProvides === provides) {
      provides = currentInstance.provides = Object.create(parentProvides);
    }
    provides[key] = value;
  }
}
function inject(key, defaultValue, treatDefaultAsFactory = false) {
  const instance = currentInstance || currentRenderingInstance;
  if (instance || currentApp) {
    const provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
    if (provides && key in provides) {
      return provides[key];
    } else if (arguments.length > 1) {
      return treatDefaultAsFactory && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
    } else if (true) {
      warn$1(`injection "${String(key)}" not found.`);
    }
  } else if (true) {
    warn$1(`inject() can only be used inside setup() or functional components.`);
  }
}
function hasInjectionContext() {
  return !!(currentInstance || currentRenderingInstance || currentApp);
}

const internalObjectProto = {};
const createInternalObject = () => Object.create(internalObjectProto);
const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;

function initProps(instance, rawProps, isStateful, isSSR = false) {
  const props = {};
  const attrs = createInternalObject();
  instance.propsDefaults = /* @__PURE__ */ Object.create(null);
  setFullProps(instance, rawProps, props, attrs);
  for (const key in instance.propsOptions[0]) {
    if (!(key in props)) {
      props[key] = void 0;
    }
  }
  if (true) {
    validateProps(rawProps || {}, props, instance);
  }
  if (isStateful) {
    instance.props = isSSR ? props : (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReactive)(props);
  } else {
    if (!instance.type.props) {
      instance.props = attrs;
    } else {
      instance.props = props;
    }
  }
  instance.attrs = attrs;
}
function isInHmrContext(instance) {
  while (instance) {
    if (instance.type.__hmrId) return true;
    instance = instance.parent;
  }
}
function updateProps(instance, rawProps, rawPrevProps, optimized) {
  const {
    props,
    attrs,
    vnode: { patchFlag }
  } = instance;
  const rawCurrentProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props);
  const [options] = instance.propsOptions;
  let hasAttrsChanged = false;
  if (
    // always force full diff in dev
    // - #1942 if hmr is enabled with sfc component
    // - vite#872 non-sfc component used by sfc component
    !( true && isInHmrContext(instance)) && (optimized || patchFlag > 0) && !(patchFlag & 16)
  ) {
    if (patchFlag & 8) {
      const propsToUpdate = instance.vnode.dynamicProps;
      for (let i = 0; i < propsToUpdate.length; i++) {
        let key = propsToUpdate[i];
        if (isEmitListener(instance.emitsOptions, key)) {
          continue;
        }
        const value = rawProps[key];
        if (options) {
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(attrs, key)) {
            if (value !== attrs[key]) {
              attrs[key] = value;
              hasAttrsChanged = true;
            }
          } else {
            const camelizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key);
            props[camelizedKey] = resolvePropValue(
              options,
              rawCurrentProps,
              camelizedKey,
              value,
              instance,
              false
            );
          }
        } else {
          if (value !== attrs[key]) {
            attrs[key] = value;
            hasAttrsChanged = true;
          }
        }
      }
    }
  } else {
    if (setFullProps(instance, rawProps, props, attrs)) {
      hasAttrsChanged = true;
    }
    let kebabKey;
    for (const key in rawCurrentProps) {
      if (!rawProps || // for camelCase
      !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && // it's possible the original props was passed in as kebab-case
      // and converted to camelCase (#955)
      ((kebabKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)) === key || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, kebabKey))) {
        if (options) {
          if (rawPrevProps && // for camelCase
          (rawPrevProps[key] !== void 0 || // for kebab-case
          rawPrevProps[kebabKey] !== void 0)) {
            props[key] = resolvePropValue(
              options,
              rawCurrentProps,
              key,
              void 0,
              instance,
              true
            );
          }
        } else {
          delete props[key];
        }
      }
    }
    if (attrs !== rawCurrentProps) {
      for (const key in attrs) {
        if (!rawProps || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && true) {
          delete attrs[key];
          hasAttrsChanged = true;
        }
      }
    }
  }
  if (hasAttrsChanged) {
    (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.trigger)(instance.attrs, "set", "");
  }
  if (true) {
    validateProps(rawProps || {}, props, instance);
  }
}
function setFullProps(instance, rawProps, props, attrs) {
  const [options, needCastKeys] = instance.propsOptions;
  let hasAttrsChanged = false;
  let rawCastValues;
  if (rawProps) {
    for (let key in rawProps) {
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) {
        continue;
      }
      const value = rawProps[key];
      let camelKey;
      if (options && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, camelKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key))) {
        if (!needCastKeys || !needCastKeys.includes(camelKey)) {
          props[camelKey] = value;
        } else {
          (rawCastValues || (rawCastValues = {}))[camelKey] = value;
        }
      } else if (!isEmitListener(instance.emitsOptions, key)) {
        if (!(key in attrs) || value !== attrs[key]) {
          attrs[key] = value;
          hasAttrsChanged = true;
        }
      }
    }
  }
  if (needCastKeys) {
    const rawCurrentProps = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props);
    const castValues = rawCastValues || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
    for (let i = 0; i < needCastKeys.length; i++) {
      const key = needCastKeys[i];
      props[key] = resolvePropValue(
        options,
        rawCurrentProps,
        key,
        castValues[key],
        instance,
        !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(castValues, key)
      );
    }
  }
  return hasAttrsChanged;
}
function resolvePropValue(options, props, key, value, instance, isAbsent) {
  const opt = options[key];
  if (opt != null) {
    const hasDefault = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(opt, "default");
    if (hasDefault && value === void 0) {
      const defaultValue = opt.default;
      if (opt.type !== Function && !opt.skipFactory && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(defaultValue)) {
        const { propsDefaults } = instance;
        if (key in propsDefaults) {
          value = propsDefaults[key];
        } else {
          const reset = setCurrentInstance(instance);
          value = propsDefaults[key] = defaultValue.call(
            null,
            props
          );
          reset();
        }
      } else {
        value = defaultValue;
      }
    }
    if (opt[0 /* shouldCast */]) {
      if (isAbsent && !hasDefault) {
        value = false;
      } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key))) {
        value = true;
      }
    }
  }
  return value;
}
const mixinPropsCache = /* @__PURE__ */ new WeakMap();
function normalizePropsOptions(comp, appContext, asMixin = false) {
  const cache = __VUE_OPTIONS_API__ && asMixin ? mixinPropsCache : appContext.propsCache;
  const cached = cache.get(comp);
  if (cached) {
    return cached;
  }
  const raw = comp.props;
  const normalized = {};
  const needCastKeys = [];
  let hasExtends = false;
  if (__VUE_OPTIONS_API__ && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) {
    const extendProps = (raw2) => {
      hasExtends = true;
      const [props, keys] = normalizePropsOptions(raw2, appContext, true);
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, props);
      if (keys) needCastKeys.push(...keys);
    };
    if (!asMixin && appContext.mixins.length) {
      appContext.mixins.forEach(extendProps);
    }
    if (comp.extends) {
      extendProps(comp.extends);
    }
    if (comp.mixins) {
      comp.mixins.forEach(extendProps);
    }
  }
  if (!raw && !hasExtends) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) {
      cache.set(comp, _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR);
    }
    return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR;
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) {
    for (let i = 0; i < raw.length; i++) {
      if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(raw[i])) {
        warn$1(`props must be strings when using array syntax.`, raw[i]);
      }
      const normalizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(raw[i]);
      if (validatePropName(normalizedKey)) {
        normalized[normalizedKey] = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
      }
    }
  } else if (raw) {
    if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(raw)) {
      warn$1(`invalid props options`, raw);
    }
    for (const key in raw) {
      const normalizedKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key);
      if (validatePropName(normalizedKey)) {
        const opt = raw[key];
        const prop = normalized[normalizedKey] = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opt) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(opt) ? { type: opt } : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, opt);
        const propType = prop.type;
        let shouldCast = false;
        let shouldCastTrue = true;
        if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(propType)) {
          for (let index = 0; index < propType.length; ++index) {
            const type = propType[index];
            const typeName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(type) && type.name;
            if (typeName === "Boolean") {
              shouldCast = true;
              break;
            } else if (typeName === "String") {
              shouldCastTrue = false;
            }
          }
        } else {
          shouldCast = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(propType) && propType.name === "Boolean";
        }
        prop[0 /* shouldCast */] = shouldCast;
        prop[1 /* shouldCastTrue */] = shouldCastTrue;
        if (shouldCast || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(prop, "default")) {
          needCastKeys.push(normalizedKey);
        }
      }
    }
  }
  const res = [normalized, needCastKeys];
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) {
    cache.set(comp, res);
  }
  return res;
}
function validatePropName(key) {
  if (key[0] !== "$" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) {
    return true;
  } else if (true) {
    warn$1(`Invalid prop name: "${key}" is a reserved property.`);
  }
  return false;
}
function getType(ctor) {
  if (ctor === null) {
    return "null";
  }
  if (typeof ctor === "function") {
    return ctor.name || "";
  } else if (typeof ctor === "object") {
    const name = ctor.constructor && ctor.constructor.name;
    return name || "";
  }
  return "";
}
function validateProps(rawProps, props, instance) {
  const resolvedValues = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(props);
  const options = instance.propsOptions[0];
  for (const key in options) {
    let opt = options[key];
    if (opt == null) continue;
    validateProp(
      key,
      resolvedValues[key],
      opt,
       true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(resolvedValues) : 0,
      !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, key) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(rawProps, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key))
    );
  }
}
function validateProp(name, value, prop, props, isAbsent) {
  const { type, required, validator, skipCheck } = prop;
  if (required && isAbsent) {
    warn$1('Missing required prop: "' + name + '"');
    return;
  }
  if (value == null && !required) {
    return;
  }
  if (type != null && type !== true && !skipCheck) {
    let isValid = false;
    const types = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(type) ? type : [type];
    const expectedTypes = [];
    for (let i = 0; i < types.length && !isValid; i++) {
      const { valid, expectedType } = assertType(value, types[i]);
      expectedTypes.push(expectedType || "");
      isValid = valid;
    }
    if (!isValid) {
      warn$1(getInvalidTypeMessage(name, value, expectedTypes));
      return;
    }
  }
  if (validator && !validator(value, props)) {
    warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
  }
}
const isSimpleType = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)(
  "String,Number,Boolean,Function,Symbol,BigInt"
);
function assertType(value, type) {
  let valid;
  const expectedType = getType(type);
  if (isSimpleType(expectedType)) {
    const t = typeof value;
    valid = t === expectedType.toLowerCase();
    if (!valid && t === "object") {
      valid = value instanceof type;
    }
  } else if (expectedType === "Object") {
    valid = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(value);
  } else if (expectedType === "Array") {
    valid = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value);
  } else if (expectedType === "null") {
    valid = value === null;
  } else {
    valid = value instanceof type;
  }
  return {
    valid,
    expectedType
  };
}
function getInvalidTypeMessage(name, value, expectedTypes) {
  if (expectedTypes.length === 0) {
    return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
  }
  let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize).join(" | ")}`;
  const expectedType = expectedTypes[0];
  const receivedType = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toRawType)(value);
  const expectedValue = styleValue(value, expectedType);
  const receivedValue = styleValue(value, receivedType);
  if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
    message += ` with value ${expectedValue}`;
  }
  message += `, got ${receivedType} `;
  if (isExplicable(receivedType)) {
    message += `with value ${receivedValue}.`;
  }
  return message;
}
function styleValue(value, type) {
  if (type === "String") {
    return `"${value}"`;
  } else if (type === "Number") {
    return `${Number(value)}`;
  } else {
    return `${value}`;
  }
}
function isExplicable(type) {
  const explicitTypes = ["string", "number", "boolean"];
  return explicitTypes.some((elem) => type.toLowerCase() === elem);
}
function isBoolean(...args) {
  return args.some((elem) => elem.toLowerCase() === "boolean");
}

const isInternalKey = (key) => key[0] === "_" || key === "$stable";
const normalizeSlotValue = (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
const normalizeSlot = (key, rawSlot, ctx) => {
  if (rawSlot._n) {
    return rawSlot;
  }
  const normalized = withCtx((...args) => {
    if ( true && currentInstance && (!ctx || ctx.root === currentInstance.root)) {
      warn$1(
        `Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`
      );
    }
    return normalizeSlotValue(rawSlot(...args));
  }, ctx);
  normalized._c = false;
  return normalized;
};
const normalizeObjectSlots = (rawSlots, slots, instance) => {
  const ctx = rawSlots._ctx;
  for (const key in rawSlots) {
    if (isInternalKey(key)) continue;
    const value = rawSlots[key];
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) {
      slots[key] = normalizeSlot(key, value, ctx);
    } else if (value != null) {
      if (true) {
        warn$1(
          `Non-function value encountered for slot "${key}". Prefer function slots for better performance.`
        );
      }
      const normalized = normalizeSlotValue(value);
      slots[key] = () => normalized;
    }
  }
};
const normalizeVNodeSlots = (instance, children) => {
  if ( true && !isKeepAlive(instance.vnode) && true) {
    warn$1(
      `Non-function value encountered for default slot. Prefer function slots for better performance.`
    );
  }
  const normalized = normalizeSlotValue(children);
  instance.slots.default = () => normalized;
};
const assignSlots = (slots, children, optimized) => {
  for (const key in children) {
    if (optimized || key !== "_") {
      slots[key] = children[key];
    }
  }
};
const initSlots = (instance, children, optimized) => {
  const slots = instance.slots = createInternalObject();
  if (instance.vnode.shapeFlag & 32) {
    const type = children._;
    if (type) {
      assignSlots(slots, children, optimized);
      if (optimized) {
        (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(slots, "_", type, true);
      }
    } else {
      normalizeObjectSlots(children, slots);
    }
  } else if (children) {
    normalizeVNodeSlots(instance, children);
  }
};
const updateSlots = (instance, children, optimized) => {
  const { vnode, slots } = instance;
  let needDeletionCheck = true;
  let deletionComparisonTarget = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
  if (vnode.shapeFlag & 32) {
    const type = children._;
    if (type) {
      if ( true && isHmrUpdating) {
        assignSlots(slots, children, optimized);
        (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.trigger)(instance, "set", "$slots");
      } else if (optimized && type === 1) {
        needDeletionCheck = false;
      } else {
        assignSlots(slots, children, optimized);
      }
    } else {
      needDeletionCheck = !children.$stable;
      normalizeObjectSlots(children, slots);
    }
    deletionComparisonTarget = children;
  } else if (children) {
    normalizeVNodeSlots(instance, children);
    deletionComparisonTarget = { default: 1 };
  }
  if (needDeletionCheck) {
    for (const key in slots) {
      if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
        delete slots[key];
      }
    }
  }
};

function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(rawRef)) {
    rawRef.forEach(
      (r, i) => setRef(
        r,
        oldRawRef && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(oldRawRef) ? oldRawRef[i] : oldRawRef),
        parentSuspense,
        vnode,
        isUnmount
      )
    );
    return;
  }
  if (isAsyncWrapper(vnode) && !isUnmount) {
    return;
  }
  const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
  const value = isUnmount ? null : refValue;
  const { i: owner, r: ref } = rawRef;
  if ( true && !owner) {
    warn$1(
      `Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`
    );
    return;
  }
  const oldRef = oldRawRef && oldRawRef.r;
  const refs = owner.refs === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ ? owner.refs = {} : owner.refs;
  const setupState = owner.setupState;
  if (oldRef != null && oldRef !== ref) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(oldRef)) {
      refs[oldRef] = null;
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, oldRef)) {
        setupState[oldRef] = null;
      }
    } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(oldRef)) {
      oldRef.value = null;
    }
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(ref)) {
    callWithErrorHandling(ref, owner, 12, [value, refs]);
  } else {
    const _isString = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(ref);
    const _isRef = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(ref);
    if (_isString || _isRef) {
      const doSet = () => {
        if (rawRef.f) {
          const existing = _isString ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
          if (isUnmount) {
            (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(existing, refValue);
          } else {
            if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing)) {
              if (_isString) {
                refs[ref] = [refValue];
                if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, ref)) {
                  setupState[ref] = refs[ref];
                }
              } else {
                ref.value = [refValue];
                if (rawRef.k) refs[rawRef.k] = ref.value;
              }
            } else if (!existing.includes(refValue)) {
              existing.push(refValue);
            }
          }
        } else if (_isString) {
          refs[ref] = value;
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(setupState, ref)) {
            setupState[ref] = value;
          }
        } else if (_isRef) {
          ref.value = value;
          if (rawRef.k) refs[rawRef.k] = value;
        } else if (true) {
          warn$1("Invalid template ref type:", ref, `(${typeof ref})`);
        }
      };
      if (value) {
        doSet.id = -1;
        queuePostRenderEffect(doSet, parentSuspense);
      } else {
        doSet();
      }
    } else if (true) {
      warn$1("Invalid template ref type:", ref, `(${typeof ref})`);
    }
  }
}

const TeleportEndKey = Symbol("_vte");
const isTeleport = (type) => type.__isTeleport;
const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
const resolveTarget = (props, select) => {
  const targetSelector = props && props.to;
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(targetSelector)) {
    if (!select) {
       true && warn$1(
        `Current renderer does not support string target for Teleports. (missing querySelector renderer option)`
      );
      return null;
    } else {
      const target = select(targetSelector);
      if ( true && !target && !isTeleportDisabled(props)) {
        warn$1(
          `Failed to locate Teleport target with selector "${targetSelector}". Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree.`
        );
      }
      return target;
    }
  } else {
    if ( true && !targetSelector && !isTeleportDisabled(props)) {
      warn$1(`Invalid Teleport target: ${targetSelector}`);
    }
    return targetSelector;
  }
};
const TeleportImpl = {
  name: "Teleport",
  __isTeleport: true,
  process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
    const {
      mc: mountChildren,
      pc: patchChildren,
      pbc: patchBlockChildren,
      o: { insert, querySelector, createText, createComment }
    } = internals;
    const disabled = isTeleportDisabled(n2.props);
    let { shapeFlag, children, dynamicChildren } = n2;
    if ( true && isHmrUpdating) {
      optimized = false;
      dynamicChildren = null;
    }
    if (n1 == null) {
      const placeholder = n2.el =  true ? createComment("teleport start") : 0;
      const mainAnchor = n2.anchor =  true ? createComment("teleport end") : 0;
      insert(placeholder, container, anchor);
      insert(mainAnchor, container, anchor);
      const target = n2.target = resolveTarget(n2.props, querySelector);
      const targetAnchor = prepareAnchor(target, n2, createText, insert);
      if (target) {
        if (namespace === "svg" || isTargetSVG(target)) {
          namespace = "svg";
        } else if (namespace === "mathml" || isTargetMathML(target)) {
          namespace = "mathml";
        }
      } else if ( true && !disabled) {
        warn$1("Invalid Teleport target on mount:", target, `(${typeof target})`);
      }
      const mount = (container2, anchor2) => {
        if (shapeFlag & 16) {
          mountChildren(
            children,
            container2,
            anchor2,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        }
      };
      if (disabled) {
        mount(container, mainAnchor);
      } else if (target) {
        mount(target, targetAnchor);
      }
    } else {
      n2.el = n1.el;
      n2.targetStart = n1.targetStart;
      const mainAnchor = n2.anchor = n1.anchor;
      const target = n2.target = n1.target;
      const targetAnchor = n2.targetAnchor = n1.targetAnchor;
      const wasDisabled = isTeleportDisabled(n1.props);
      const currentContainer = wasDisabled ? container : target;
      const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
      if (namespace === "svg" || isTargetSVG(target)) {
        namespace = "svg";
      } else if (namespace === "mathml" || isTargetMathML(target)) {
        namespace = "mathml";
      }
      if (dynamicChildren) {
        patchBlockChildren(
          n1.dynamicChildren,
          dynamicChildren,
          currentContainer,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds
        );
        traverseStaticChildren(n1, n2, true);
      } else if (!optimized) {
        patchChildren(
          n1,
          n2,
          currentContainer,
          currentAnchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          false
        );
      }
      if (disabled) {
        if (!wasDisabled) {
          moveTeleport(
            n2,
            container,
            mainAnchor,
            internals,
            1
          );
        } else {
          if (n2.props && n1.props && n2.props.to !== n1.props.to) {
            n2.props.to = n1.props.to;
          }
        }
      } else {
        if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
          const nextTarget = n2.target = resolveTarget(
            n2.props,
            querySelector
          );
          if (nextTarget) {
            moveTeleport(
              n2,
              nextTarget,
              null,
              internals,
              0
            );
          } else if (true) {
            warn$1(
              "Invalid Teleport target on update:",
              target,
              `(${typeof target})`
            );
          }
        } else if (wasDisabled) {
          moveTeleport(
            n2,
            target,
            targetAnchor,
            internals,
            1
          );
        }
      }
    }
    updateCssVars(n2);
  },
  remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
    const {
      shapeFlag,
      children,
      anchor,
      targetStart,
      targetAnchor,
      target,
      props
    } = vnode;
    if (target) {
      hostRemove(targetStart);
      hostRemove(targetAnchor);
    }
    doRemove && hostRemove(anchor);
    if (shapeFlag & 16) {
      const shouldRemove = doRemove || !isTeleportDisabled(props);
      for (let i = 0; i < children.length; i++) {
        const child = children[i];
        unmount(
          child,
          parentComponent,
          parentSuspense,
          shouldRemove,
          !!child.dynamicChildren
        );
      }
    }
  },
  move: moveTeleport,
  hydrate: hydrateTeleport
};
function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
  if (moveType === 0) {
    insert(vnode.targetAnchor, container, parentAnchor);
  }
  const { el, anchor, shapeFlag, children, props } = vnode;
  const isReorder = moveType === 2;
  if (isReorder) {
    insert(el, container, parentAnchor);
  }
  if (!isReorder || isTeleportDisabled(props)) {
    if (shapeFlag & 16) {
      for (let i = 0; i < children.length; i++) {
        move(
          children[i],
          container,
          parentAnchor,
          2
        );
      }
    }
  }
  if (isReorder) {
    insert(anchor, container, parentAnchor);
  }
}
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
  o: { nextSibling, parentNode, querySelector, insert, createText }
}, hydrateChildren) {
  const target = vnode.target = resolveTarget(
    vnode.props,
    querySelector
  );
  if (target) {
    const targetNode = target._lpa || target.firstChild;
    if (vnode.shapeFlag & 16) {
      if (isTeleportDisabled(vnode.props)) {
        vnode.anchor = hydrateChildren(
          nextSibling(node),
          vnode,
          parentNode(node),
          parentComponent,
          parentSuspense,
          slotScopeIds,
          optimized
        );
        vnode.targetStart = targetNode;
        vnode.targetAnchor = targetNode && nextSibling(targetNode);
      } else {
        vnode.anchor = nextSibling(node);
        let targetAnchor = targetNode;
        while (targetAnchor) {
          if (targetAnchor && targetAnchor.nodeType === 8) {
            if (targetAnchor.data === "teleport start anchor") {
              vnode.targetStart = targetAnchor;
            } else if (targetAnchor.data === "teleport anchor") {
              vnode.targetAnchor = targetAnchor;
              target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
              break;
            }
          }
          targetAnchor = nextSibling(targetAnchor);
        }
        if (!vnode.targetAnchor) {
          prepareAnchor(target, vnode, createText, insert);
        }
        hydrateChildren(
          targetNode && nextSibling(targetNode),
          vnode,
          target,
          parentComponent,
          parentSuspense,
          slotScopeIds,
          optimized
        );
      }
    }
    updateCssVars(vnode);
  }
  return vnode.anchor && nextSibling(vnode.anchor);
}
const Teleport = TeleportImpl;
function updateCssVars(vnode) {
  const ctx = vnode.ctx;
  if (ctx && ctx.ut) {
    let node = vnode.children[0].el;
    while (node && node !== vnode.targetAnchor) {
      if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
      node = node.nextSibling;
    }
    ctx.ut();
  }
}
function prepareAnchor(target, vnode, createText, insert) {
  const targetStart = vnode.targetStart = createText("");
  const targetAnchor = vnode.targetAnchor = createText("");
  targetStart[TeleportEndKey] = targetAnchor;
  if (target) {
    insert(targetStart, target);
    insert(targetAnchor, target);
  }
  return targetAnchor;
}

let hasLoggedMismatchError = false;
const logMismatchError = () => {
  if (hasLoggedMismatchError) {
    return;
  }
  console.error("Hydration completed but contains mismatches.");
  hasLoggedMismatchError = true;
};
const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
const getContainerType = (container) => {
  if (isSVGContainer(container)) return "svg";
  if (isMathMLContainer(container)) return "mathml";
  return void 0;
};
const isComment = (node) => node.nodeType === 8 /* COMMENT */;
function createHydrationFunctions(rendererInternals) {
  const {
    mt: mountComponent,
    p: patch,
    o: {
      patchProp,
      createText,
      nextSibling,
      parentNode,
      remove,
      insert,
      createComment
    }
  } = rendererInternals;
  const hydrate = (vnode, container) => {
    if (!container.hasChildNodes()) {
      ( true) && warn$1(
        `Attempting to hydrate existing markup but container is empty. Performing full mount instead.`
      );
      patch(null, vnode, container);
      flushPostFlushCbs();
      container._vnode = vnode;
      return;
    }
    hydrateNode(container.firstChild, vnode, null, null, null);
    flushPostFlushCbs();
    container._vnode = vnode;
  };
  const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
    optimized = optimized || !!vnode.dynamicChildren;
    const isFragmentStart = isComment(node) && node.data === "[";
    const onMismatch = () => handleMismatch(
      node,
      vnode,
      parentComponent,
      parentSuspense,
      slotScopeIds,
      isFragmentStart
    );
    const { type, ref, shapeFlag, patchFlag } = vnode;
    let domType = node.nodeType;
    vnode.el = node;
    if (true) {
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(node, "__vnode", vnode, true);
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(node, "__vueParentComponent", parentComponent, true);
    }
    if (patchFlag === -2) {
      optimized = false;
      vnode.dynamicChildren = null;
    }
    let nextNode = null;
    switch (type) {
      case Text:
        if (domType !== 3 /* TEXT */) {
          if (vnode.children === "") {
            insert(vnode.el = createText(""), parentNode(node), node);
            nextNode = node;
          } else {
            nextNode = onMismatch();
          }
        } else {
          if (node.data !== vnode.children) {
            ( true) && warn$1(
              `Hydration text mismatch in`,
              node.parentNode,
              `
  - rendered on server: ${JSON.stringify(
                node.data
              )}
  - expected on client: ${JSON.stringify(vnode.children)}`
            );
            logMismatchError();
            node.data = vnode.children;
          }
          nextNode = nextSibling(node);
        }
        break;
      case Comment:
        if (isTemplateNode(node)) {
          nextNode = nextSibling(node);
          replaceNode(
            vnode.el = node.content.firstChild,
            node,
            parentComponent
          );
        } else if (domType !== 8 /* COMMENT */ || isFragmentStart) {
          nextNode = onMismatch();
        } else {
          nextNode = nextSibling(node);
        }
        break;
      case Static:
        if (isFragmentStart) {
          node = nextSibling(node);
          domType = node.nodeType;
        }
        if (domType === 1 /* ELEMENT */ || domType === 3 /* TEXT */) {
          nextNode = node;
          const needToAdoptContent = !vnode.children.length;
          for (let i = 0; i < vnode.staticCount; i++) {
            if (needToAdoptContent)
              vnode.children += nextNode.nodeType === 1 /* ELEMENT */ ? nextNode.outerHTML : nextNode.data;
            if (i === vnode.staticCount - 1) {
              vnode.anchor = nextNode;
            }
            nextNode = nextSibling(nextNode);
          }
          return isFragmentStart ? nextSibling(nextNode) : nextNode;
        } else {
          onMismatch();
        }
        break;
      case Fragment:
        if (!isFragmentStart) {
          nextNode = onMismatch();
        } else {
          nextNode = hydrateFragment(
            node,
            vnode,
            parentComponent,
            parentSuspense,
            slotScopeIds,
            optimized
          );
        }
        break;
      default:
        if (shapeFlag & 1) {
          if ((domType !== 1 /* ELEMENT */ || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
            nextNode = onMismatch();
          } else {
            nextNode = hydrateElement(
              node,
              vnode,
              parentComponent,
              parentSuspense,
              slotScopeIds,
              optimized
            );
          }
        } else if (shapeFlag & 6) {
          vnode.slotScopeIds = slotScopeIds;
          const container = parentNode(node);
          if (isFragmentStart) {
            nextNode = locateClosingAnchor(node);
          } else if (isComment(node) && node.data === "teleport start") {
            nextNode = locateClosingAnchor(node, node.data, "teleport end");
          } else {
            nextNode = nextSibling(node);
          }
          mountComponent(
            vnode,
            container,
            null,
            parentComponent,
            parentSuspense,
            getContainerType(container),
            optimized
          );
          if (isAsyncWrapper(vnode)) {
            let subTree;
            if (isFragmentStart) {
              subTree = createVNode(Fragment);
              subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
            } else {
              subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
            }
            subTree.el = node;
            vnode.component.subTree = subTree;
          }
        } else if (shapeFlag & 64) {
          if (domType !== 8 /* COMMENT */) {
            nextNode = onMismatch();
          } else {
            nextNode = vnode.type.hydrate(
              node,
              vnode,
              parentComponent,
              parentSuspense,
              slotScopeIds,
              optimized,
              rendererInternals,
              hydrateChildren
            );
          }
        } else if (shapeFlag & 128) {
          nextNode = vnode.type.hydrate(
            node,
            vnode,
            parentComponent,
            parentSuspense,
            getContainerType(parentNode(node)),
            slotScopeIds,
            optimized,
            rendererInternals,
            hydrateNode
          );
        } else if (true) {
          warn$1("Invalid HostVNode type:", type, `(${typeof type})`);
        }
    }
    if (ref != null) {
      setRef(ref, null, parentSuspense, vnode);
    }
    return nextNode;
  };
  const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
    optimized = optimized || !!vnode.dynamicChildren;
    const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
    const forcePatch = type === "input" || type === "option";
    if (true) {
      if (dirs) {
        invokeDirectiveHook(vnode, null, parentComponent, "created");
      }
      let needCallTransitionHooks = false;
      if (isTemplateNode(el)) {
        needCallTransitionHooks = needTransition(parentSuspense, transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
        const content = el.content.firstChild;
        if (needCallTransitionHooks) {
          transition.beforeEnter(content);
        }
        replaceNode(content, el, parentComponent);
        vnode.el = el = content;
      }
      if (shapeFlag & 16 && // skip if element has innerHTML / textContent
      !(props && (props.innerHTML || props.textContent))) {
        let next = hydrateChildren(
          el.firstChild,
          vnode,
          el,
          parentComponent,
          parentSuspense,
          slotScopeIds,
          optimized
        );
        let hasWarned = false;
        while (next) {
          if (( true) && !hasWarned) {
            warn$1(
              `Hydration children mismatch on`,
              el,
              `
Server rendered element contains more child nodes than client vdom.`
            );
            hasWarned = true;
          }
          logMismatchError();
          const cur = next;
          next = next.nextSibling;
          remove(cur);
        }
      } else if (shapeFlag & 8) {
        if (el.textContent !== vnode.children) {
          ( true) && warn$1(
            `Hydration text content mismatch on`,
            el,
            `
  - rendered on server: ${el.textContent}
  - expected on client: ${vnode.children}`
          );
          logMismatchError();
          el.textContent = vnode.children;
        }
      }
      if (props) {
        if (true) {
          const isCustomElement = el.tagName.includes("-");
          for (const key in props) {
            if (( true) && // #11189 skip if this node has directives that have created hooks
            // as it could have mutated the DOM in any possible way
            !(dirs && dirs.some((d) => d.dir.created)) && propHasMismatch(el, key, props[key], vnode, parentComponent)) {
              logMismatchError();
            }
            if (forcePatch && (key.endsWith("value") || key === "indeterminate") || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key) || // force hydrate v-bind with .prop modifiers
            key[0] === "." || isCustomElement) {
              patchProp(el, key, null, props[key], void 0, parentComponent);
            }
          }
        } else {}
      }
      let vnodeHooks;
      if (vnodeHooks = props && props.onVnodeBeforeMount) {
        invokeVNodeHook(vnodeHooks, parentComponent, vnode);
      }
      if (dirs) {
        invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
      }
      if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
        queueEffectWithSuspense(() => {
          vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
          needCallTransitionHooks && transition.enter(el);
          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
        }, parentSuspense);
      }
    }
    return el.nextSibling;
  };
  const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
    optimized = optimized || !!parentVNode.dynamicChildren;
    const children = parentVNode.children;
    const l = children.length;
    let hasWarned = false;
    for (let i = 0; i < l; i++) {
      const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
      const isText = vnode.type === Text;
      if (node) {
        if (isText && !optimized) {
          let next = children[i + 1];
          if (next && (next = normalizeVNode(next)).type === Text) {
            insert(
              createText(
                node.data.slice(vnode.children.length)
              ),
              container,
              nextSibling(node)
            );
            node.data = vnode.children;
          }
        }
        node = hydrateNode(
          node,
          vnode,
          parentComponent,
          parentSuspense,
          slotScopeIds,
          optimized
        );
      } else if (isText && !vnode.children) {
        insert(vnode.el = createText(""), container);
      } else {
        if (( true) && !hasWarned) {
          warn$1(
            `Hydration children mismatch on`,
            container,
            `
Server rendered element contains fewer child nodes than client vdom.`
          );
          hasWarned = true;
        }
        logMismatchError();
        patch(
          null,
          vnode,
          container,
          null,
          parentComponent,
          parentSuspense,
          getContainerType(container),
          slotScopeIds
        );
      }
    }
    return node;
  };
  const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
    const { slotScopeIds: fragmentSlotScopeIds } = vnode;
    if (fragmentSlotScopeIds) {
      slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
    }
    const container = parentNode(node);
    const next = hydrateChildren(
      nextSibling(node),
      vnode,
      container,
      parentComponent,
      parentSuspense,
      slotScopeIds,
      optimized
    );
    if (next && isComment(next) && next.data === "]") {
      return nextSibling(vnode.anchor = next);
    } else {
      logMismatchError();
      insert(vnode.anchor = createComment(`]`), container, next);
      return next;
    }
  };
  const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
    ( true) && warn$1(
      `Hydration node mismatch:
- rendered on server:`,
      node,
      node.nodeType === 3 /* TEXT */ ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``,
      `
- expected on client:`,
      vnode.type
    );
    logMismatchError();
    vnode.el = null;
    if (isFragment) {
      const end = locateClosingAnchor(node);
      while (true) {
        const next2 = nextSibling(node);
        if (next2 && next2 !== end) {
          remove(next2);
        } else {
          break;
        }
      }
    }
    const next = nextSibling(node);
    const container = parentNode(node);
    remove(node);
    patch(
      null,
      vnode,
      container,
      next,
      parentComponent,
      parentSuspense,
      getContainerType(container),
      slotScopeIds
    );
    return next;
  };
  const locateClosingAnchor = (node, open = "[", close = "]") => {
    let match = 0;
    while (node) {
      node = nextSibling(node);
      if (node && isComment(node)) {
        if (node.data === open) match++;
        if (node.data === close) {
          if (match === 0) {
            return nextSibling(node);
          } else {
            match--;
          }
        }
      }
    }
    return node;
  };
  const replaceNode = (newNode, oldNode, parentComponent) => {
    const parentNode2 = oldNode.parentNode;
    if (parentNode2) {
      parentNode2.replaceChild(newNode, oldNode);
    }
    let parent = parentComponent;
    while (parent) {
      if (parent.vnode.el === oldNode) {
        parent.vnode.el = parent.subTree.el = newNode;
      }
      parent = parent.parent;
    }
  };
  const isTemplateNode = (node) => {
    return node.nodeType === 1 /* ELEMENT */ && node.tagName.toLowerCase() === "template";
  };
  return [hydrate, hydrateNode];
}
function propHasMismatch(el, key, clientValue, vnode, instance) {
  let mismatchType;
  let mismatchKey;
  let actual;
  let expected;
  if (key === "class") {
    actual = el.getAttribute("class");
    expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)(clientValue);
    if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) {
      mismatchType = mismatchKey = `class`;
    }
  } else if (key === "style") {
    actual = el.getAttribute("style") || "";
    expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(clientValue) ? clientValue : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.stringifyStyle)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)(clientValue));
    const actualMap = toStyleMap(actual);
    const expectedMap = toStyleMap(expected);
    if (vnode.dirs) {
      for (const { dir, value } of vnode.dirs) {
        if (dir.name === "show" && !value) {
          expectedMap.set("display", "none");
        }
      }
    }
    if (instance) {
      resolveCssVars(instance, vnode, expectedMap);
    }
    if (!isMapEqual(actualMap, expectedMap)) {
      mismatchType = mismatchKey = "style";
    }
  } else if (el instanceof SVGElement && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isKnownSvgAttr)(key) || el instanceof HTMLElement && ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isBooleanAttr)(key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isKnownHtmlAttr)(key))) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isBooleanAttr)(key)) {
      actual = el.hasAttribute(key);
      expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(clientValue);
    } else if (clientValue == null) {
      actual = el.hasAttribute(key);
      expected = false;
    } else {
      if (el.hasAttribute(key)) {
        actual = el.getAttribute(key);
      } else if (key === "value" && el.tagName === "TEXTAREA") {
        actual = el.value;
      } else {
        actual = false;
      }
      expected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isRenderableAttrValue)(clientValue) ? String(clientValue) : false;
    }
    if (actual !== expected) {
      mismatchType = `attribute`;
      mismatchKey = key;
    }
  }
  if (mismatchType) {
    const format = (v) => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`;
    const preSegment = `Hydration ${mismatchType} mismatch on`;
    const postSegment = `
  - rendered on server: ${format(actual)}
  - expected on client: ${format(expected)}
  Note: this mismatch is check-only. The DOM will not be rectified in production due to performance overhead.
  You should fix the source of the mismatch.`;
    {
      warn$1(preSegment, el, postSegment);
    }
    return true;
  }
  return false;
}
function toClassSet(str) {
  return new Set(str.trim().split(/\s+/));
}
function isSetEqual(a, b) {
  if (a.size !== b.size) {
    return false;
  }
  for (const s of a) {
    if (!b.has(s)) {
      return false;
    }
  }
  return true;
}
function toStyleMap(str) {
  const styleMap = /* @__PURE__ */ new Map();
  for (const item of str.split(";")) {
    let [key, value] = item.split(":");
    key = key.trim();
    value = value && value.trim();
    if (key && value) {
      styleMap.set(key, value);
    }
  }
  return styleMap;
}
function isMapEqual(a, b) {
  if (a.size !== b.size) {
    return false;
  }
  for (const [key, value] of a) {
    if (value !== b.get(key)) {
      return false;
    }
  }
  return true;
}
function resolveCssVars(instance, vnode, expectedMap) {
  const root = instance.subTree;
  if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) {
    const cssVars = instance.getCssVars();
    for (const key in cssVars) {
      expectedMap.set(`--${key}`, String(cssVars[key]));
    }
  }
  if (vnode === root && instance.parent) {
    resolveCssVars(instance.parent, instance.vnode, expectedMap);
  }
}

let supported;
let perf;
function startMeasure(instance, type) {
  if (instance.appContext.config.performance && isSupported()) {
    perf.mark(`vue-${type}-${instance.uid}`);
  }
  if (true) {
    devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
  }
}
function endMeasure(instance, type) {
  if (instance.appContext.config.performance && isSupported()) {
    const startTag = `vue-${type}-${instance.uid}`;
    const endTag = startTag + `:end`;
    perf.mark(endTag);
    perf.measure(
      `<${formatComponentName(instance, instance.type)}> ${type}`,
      startTag,
      endTag
    );
    perf.clearMarks(startTag);
    perf.clearMarks(endTag);
  }
  if (true) {
    devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
  }
}
function isSupported() {
  if (supported !== void 0) {
    return supported;
  }
  if (typeof window !== "undefined" && window.performance) {
    supported = true;
    perf = window.performance;
  } else {
    supported = false;
  }
  return supported;
}

function initFeatureFlags() {
  const needWarn = [];
  if (typeof __VUE_OPTIONS_API__ !== "boolean") {
     true && needWarn.push(`__VUE_OPTIONS_API__`);
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().__VUE_OPTIONS_API__ = true;
  }
  if (typeof __VUE_PROD_DEVTOOLS__ !== "boolean") {
     true && needWarn.push(`__VUE_PROD_DEVTOOLS__`);
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().__VUE_PROD_DEVTOOLS__ = false;
  }
  if (typeof __VUE_PROD_HYDRATION_MISMATCH_DETAILS__ !== "boolean") {
     true && needWarn.push(`__VUE_PROD_HYDRATION_MISMATCH_DETAILS__`);
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)().__VUE_PROD_HYDRATION_MISMATCH_DETAILS__ = false;
  }
  if ( true && needWarn.length) {
    const multi = needWarn.length > 1;
    console.warn(
      `Feature flag${multi ? `s` : ``} ${needWarn.join(", ")} ${multi ? `are` : `is`} not explicitly defined. You are running the esm-bundler build of Vue, which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle.

For more details, see https://link.vuejs.org/feature-flags.`
    );
  }
}

const queuePostRenderEffect = queueEffectWithSuspense ;
function createRenderer(options) {
  return baseCreateRenderer(options);
}
function createHydrationRenderer(options) {
  return baseCreateRenderer(options, createHydrationFunctions);
}
function baseCreateRenderer(options, createHydrationFns) {
  {
    initFeatureFlags();
  }
  const target = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)();
  target.__VUE__ = true;
  if (true) {
    setDevtoolsHook$1(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
  }
  const {
    insert: hostInsert,
    remove: hostRemove,
    patchProp: hostPatchProp,
    createElement: hostCreateElement,
    createText: hostCreateText,
    createComment: hostCreateComment,
    setText: hostSetText,
    setElementText: hostSetElementText,
    parentNode: hostParentNode,
    nextSibling: hostNextSibling,
    setScopeId: hostSetScopeId = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP,
    insertStaticContent: hostInsertStaticContent
  } = options;
  const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized =  true && isHmrUpdating ? false : !!n2.dynamicChildren) => {
    if (n1 === n2) {
      return;
    }
    if (n1 && !isSameVNodeType(n1, n2)) {
      anchor = getNextHostNode(n1);
      unmount(n1, parentComponent, parentSuspense, true);
      n1 = null;
    }
    if (n2.patchFlag === -2) {
      optimized = false;
      n2.dynamicChildren = null;
    }
    const { type, ref, shapeFlag } = n2;
    switch (type) {
      case Text:
        processText(n1, n2, container, anchor);
        break;
      case Comment:
        processCommentNode(n1, n2, container, anchor);
        break;
      case Static:
        if (n1 == null) {
          mountStaticNode(n2, container, anchor, namespace);
        } else if (true) {
          patchStaticNode(n1, n2, container, namespace);
        }
        break;
      case Fragment:
        processFragment(
          n1,
          n2,
          container,
          anchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
        break;
      default:
        if (shapeFlag & 1) {
          processElement(
            n1,
            n2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        } else if (shapeFlag & 6) {
          processComponent(
            n1,
            n2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        } else if (shapeFlag & 64) {
          type.process(
            n1,
            n2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized,
            internals
          );
        } else if (shapeFlag & 128) {
          type.process(
            n1,
            n2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized,
            internals
          );
        } else if (true) {
          warn$1("Invalid VNode type:", type, `(${typeof type})`);
        }
    }
    if (ref != null && parentComponent) {
      setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
    }
  };
  const processText = (n1, n2, container, anchor) => {
    if (n1 == null) {
      hostInsert(
        n2.el = hostCreateText(n2.children),
        container,
        anchor
      );
    } else {
      const el = n2.el = n1.el;
      if (n2.children !== n1.children) {
        hostSetText(el, n2.children);
      }
    }
  };
  const processCommentNode = (n1, n2, container, anchor) => {
    if (n1 == null) {
      hostInsert(
        n2.el = hostCreateComment(n2.children || ""),
        container,
        anchor
      );
    } else {
      n2.el = n1.el;
    }
  };
  const mountStaticNode = (n2, container, anchor, namespace) => {
    [n2.el, n2.anchor] = hostInsertStaticContent(
      n2.children,
      container,
      anchor,
      namespace,
      n2.el,
      n2.anchor
    );
  };
  const patchStaticNode = (n1, n2, container, namespace) => {
    if (n2.children !== n1.children) {
      const anchor = hostNextSibling(n1.anchor);
      removeStaticNode(n1);
      [n2.el, n2.anchor] = hostInsertStaticContent(
        n2.children,
        container,
        anchor,
        namespace
      );
    } else {
      n2.el = n1.el;
      n2.anchor = n1.anchor;
    }
  };
  const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
    let next;
    while (el && el !== anchor) {
      next = hostNextSibling(el);
      hostInsert(el, container, nextSibling);
      el = next;
    }
    hostInsert(anchor, container, nextSibling);
  };
  const removeStaticNode = ({ el, anchor }) => {
    let next;
    while (el && el !== anchor) {
      next = hostNextSibling(el);
      hostRemove(el);
      el = next;
    }
    hostRemove(anchor);
  };
  const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
    if (n2.type === "svg") {
      namespace = "svg";
    } else if (n2.type === "math") {
      namespace = "mathml";
    }
    if (n1 == null) {
      mountElement(
        n2,
        container,
        anchor,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        optimized
      );
    } else {
      patchElement(
        n1,
        n2,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        optimized
      );
    }
  };
  const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
    let el;
    let vnodeHook;
    const { props, shapeFlag, transition, dirs } = vnode;
    el = vnode.el = hostCreateElement(
      vnode.type,
      namespace,
      props && props.is,
      props
    );
    if (shapeFlag & 8) {
      hostSetElementText(el, vnode.children);
    } else if (shapeFlag & 16) {
      mountChildren(
        vnode.children,
        el,
        null,
        parentComponent,
        parentSuspense,
        resolveChildrenNamespace(vnode, namespace),
        slotScopeIds,
        optimized
      );
    }
    if (dirs) {
      invokeDirectiveHook(vnode, null, parentComponent, "created");
    }
    setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
    if (props) {
      for (const key in props) {
        if (key !== "value" && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) {
          hostPatchProp(el, key, null, props[key], namespace, parentComponent);
        }
      }
      if ("value" in props) {
        hostPatchProp(el, "value", null, props.value, namespace);
      }
      if (vnodeHook = props.onVnodeBeforeMount) {
        invokeVNodeHook(vnodeHook, parentComponent, vnode);
      }
    }
    if (true) {
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(el, "__vnode", vnode, true);
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.def)(el, "__vueParentComponent", parentComponent, true);
    }
    if (dirs) {
      invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
    }
    const needCallTransitionHooks = needTransition(parentSuspense, transition);
    if (needCallTransitionHooks) {
      transition.beforeEnter(el);
    }
    hostInsert(el, container, anchor);
    if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
      queuePostRenderEffect(() => {
        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
        needCallTransitionHooks && transition.enter(el);
        dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
      }, parentSuspense);
    }
  };
  const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
    if (scopeId) {
      hostSetScopeId(el, scopeId);
    }
    if (slotScopeIds) {
      for (let i = 0; i < slotScopeIds.length; i++) {
        hostSetScopeId(el, slotScopeIds[i]);
      }
    }
    if (parentComponent) {
      let subTree = parentComponent.subTree;
      if ( true && subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
        subTree = filterSingleRoot(subTree.children) || subTree;
      }
      if (vnode === subTree) {
        const parentVNode = parentComponent.vnode;
        setScopeId(
          el,
          parentVNode,
          parentVNode.scopeId,
          parentVNode.slotScopeIds,
          parentComponent.parent
        );
      }
    }
  };
  const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
    for (let i = start; i < children.length; i++) {
      const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
      patch(
        null,
        child,
        container,
        anchor,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        optimized
      );
    }
  };
  const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
    const el = n2.el = n1.el;
    if (true) {
      el.__vnode = n2;
    }
    let { patchFlag, dynamicChildren, dirs } = n2;
    patchFlag |= n1.patchFlag & 16;
    const oldProps = n1.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
    const newProps = n2.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
    let vnodeHook;
    parentComponent && toggleRecurse(parentComponent, false);
    if (vnodeHook = newProps.onVnodeBeforeUpdate) {
      invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
    }
    if (dirs) {
      invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
    }
    parentComponent && toggleRecurse(parentComponent, true);
    if ( true && isHmrUpdating) {
      patchFlag = 0;
      optimized = false;
      dynamicChildren = null;
    }
    if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) {
      hostSetElementText(el, "");
    }
    if (dynamicChildren) {
      patchBlockChildren(
        n1.dynamicChildren,
        dynamicChildren,
        el,
        parentComponent,
        parentSuspense,
        resolveChildrenNamespace(n2, namespace),
        slotScopeIds
      );
      if (true) {
        traverseStaticChildren(n1, n2);
      }
    } else if (!optimized) {
      patchChildren(
        n1,
        n2,
        el,
        null,
        parentComponent,
        parentSuspense,
        resolveChildrenNamespace(n2, namespace),
        slotScopeIds,
        false
      );
    }
    if (patchFlag > 0) {
      if (patchFlag & 16) {
        patchProps(el, oldProps, newProps, parentComponent, namespace);
      } else {
        if (patchFlag & 2) {
          if (oldProps.class !== newProps.class) {
            hostPatchProp(el, "class", null, newProps.class, namespace);
          }
        }
        if (patchFlag & 4) {
          hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
        }
        if (patchFlag & 8) {
          const propsToUpdate = n2.dynamicProps;
          for (let i = 0; i < propsToUpdate.length; i++) {
            const key = propsToUpdate[i];
            const prev = oldProps[key];
            const next = newProps[key];
            if (next !== prev || key === "value") {
              hostPatchProp(el, key, prev, next, namespace, parentComponent);
            }
          }
        }
      }
      if (patchFlag & 1) {
        if (n1.children !== n2.children) {
          hostSetElementText(el, n2.children);
        }
      }
    } else if (!optimized && dynamicChildren == null) {
      patchProps(el, oldProps, newProps, parentComponent, namespace);
    }
    if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
      queuePostRenderEffect(() => {
        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
        dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
      }, parentSuspense);
    }
  };
  const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
    for (let i = 0; i < newChildren.length; i++) {
      const oldVNode = oldChildren[i];
      const newVNode = newChildren[i];
      const container = (
        // oldVNode may be an errored async setup() component inside Suspense
        // which will not have a mounted element
        oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
        // of the Fragment itself so it can move its children.
        (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
        // which also requires the correct parent container
        !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
        oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
          // In other cases, the parent container is not actually used so we
          // just pass the block element here to avoid a DOM parentNode call.
          fallbackContainer
        )
      );
      patch(
        oldVNode,
        newVNode,
        container,
        null,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        true
      );
    }
  };
  const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
    if (oldProps !== newProps) {
      if (oldProps !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) {
        for (const key in oldProps) {
          if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key) && !(key in newProps)) {
            hostPatchProp(
              el,
              key,
              oldProps[key],
              null,
              namespace,
              parentComponent
            );
          }
        }
      }
      for (const key in newProps) {
        if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isReservedProp)(key)) continue;
        const next = newProps[key];
        const prev = oldProps[key];
        if (next !== prev && key !== "value") {
          hostPatchProp(el, key, prev, next, namespace, parentComponent);
        }
      }
      if ("value" in newProps) {
        hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
      }
    }
  };
  const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
    const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
    const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
    let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
    if ( true && // #5523 dev root fragment may inherit directives
    (isHmrUpdating || patchFlag & 2048)) {
      patchFlag = 0;
      optimized = false;
      dynamicChildren = null;
    }
    if (fragmentSlotScopeIds) {
      slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
    }
    if (n1 == null) {
      hostInsert(fragmentStartAnchor, container, anchor);
      hostInsert(fragmentEndAnchor, container, anchor);
      mountChildren(
        // #10007
        // such fragment like `<></>` will be compiled into
        // a fragment which doesn't have a children.
        // In this case fallback to an empty array
        n2.children || [],
        container,
        fragmentEndAnchor,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        optimized
      );
    } else {
      if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
      // of renderSlot() with no valid children
      n1.dynamicChildren) {
        patchBlockChildren(
          n1.dynamicChildren,
          dynamicChildren,
          container,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds
        );
        if (true) {
          traverseStaticChildren(n1, n2);
        } else {}
      } else {
        patchChildren(
          n1,
          n2,
          container,
          fragmentEndAnchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
      }
    }
  };
  const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
    n2.slotScopeIds = slotScopeIds;
    if (n1 == null) {
      if (n2.shapeFlag & 512) {
        parentComponent.ctx.activate(
          n2,
          container,
          anchor,
          namespace,
          optimized
        );
      } else {
        mountComponent(
          n2,
          container,
          anchor,
          parentComponent,
          parentSuspense,
          namespace,
          optimized
        );
      }
    } else {
      updateComponent(n1, n2, optimized);
    }
  };
  const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
    const instance = (initialVNode.component = createComponentInstance(
      initialVNode,
      parentComponent,
      parentSuspense
    ));
    if ( true && instance.type.__hmrId) {
      registerHMR(instance);
    }
    if (true) {
      pushWarningContext(initialVNode);
      startMeasure(instance, `mount`);
    }
    if (isKeepAlive(initialVNode)) {
      instance.ctx.renderer = internals;
    }
    {
      if (true) {
        startMeasure(instance, `init`);
      }
      setupComponent(instance, false, optimized);
      if (true) {
        endMeasure(instance, `init`);
      }
    }
    if (instance.asyncDep) {
      parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
      if (!initialVNode.el) {
        const placeholder = instance.subTree = createVNode(Comment);
        processCommentNode(null, placeholder, container, anchor);
      }
    } else {
      setupRenderEffect(
        instance,
        initialVNode,
        container,
        anchor,
        parentSuspense,
        namespace,
        optimized
      );
    }
    if (true) {
      popWarningContext();
      endMeasure(instance, `mount`);
    }
  };
  const updateComponent = (n1, n2, optimized) => {
    const instance = n2.component = n1.component;
    if (shouldUpdateComponent(n1, n2, optimized)) {
      if (instance.asyncDep && !instance.asyncResolved) {
        if (true) {
          pushWarningContext(n2);
        }
        updateComponentPreRender(instance, n2, optimized);
        if (true) {
          popWarningContext();
        }
        return;
      } else {
        instance.next = n2;
        invalidateJob(instance.update);
        instance.effect.dirty = true;
        instance.update();
      }
    } else {
      n2.el = n1.el;
      instance.vnode = n2;
    }
  };
  const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
    const componentUpdateFn = () => {
      if (!instance.isMounted) {
        let vnodeHook;
        const { el, props } = initialVNode;
        const { bm, m, parent } = instance;
        const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
        toggleRecurse(instance, false);
        if (bm) {
          (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bm);
        }
        if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
          invokeVNodeHook(vnodeHook, parent, initialVNode);
        }
        toggleRecurse(instance, true);
        if (el && hydrateNode) {
          const hydrateSubTree = () => {
            if (true) {
              startMeasure(instance, `render`);
            }
            instance.subTree = renderComponentRoot(instance);
            if (true) {
              endMeasure(instance, `render`);
            }
            if (true) {
              startMeasure(instance, `hydrate`);
            }
            hydrateNode(
              el,
              instance.subTree,
              instance,
              parentSuspense,
              null
            );
            if (true) {
              endMeasure(instance, `hydrate`);
            }
          };
          if (isAsyncWrapperVNode) {
            initialVNode.type.__asyncLoader().then(
              // note: we are moving the render call into an async callback,
              // which means it won't track dependencies - but it's ok because
              // a server-rendered async wrapper is already in resolved state
              // and it will never need to change.
              () => !instance.isUnmounted && hydrateSubTree()
            );
          } else {
            hydrateSubTree();
          }
        } else {
          if (true) {
            startMeasure(instance, `render`);
          }
          const subTree = instance.subTree = renderComponentRoot(instance);
          if (true) {
            endMeasure(instance, `render`);
          }
          if (true) {
            startMeasure(instance, `patch`);
          }
          patch(
            null,
            subTree,
            container,
            anchor,
            instance,
            parentSuspense,
            namespace
          );
          if (true) {
            endMeasure(instance, `patch`);
          }
          initialVNode.el = subTree.el;
        }
        if (m) {
          queuePostRenderEffect(m, parentSuspense);
        }
        if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
          const scopedInitialVNode = initialVNode;
          queuePostRenderEffect(
            () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
            parentSuspense
          );
        }
        if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
          instance.a && queuePostRenderEffect(instance.a, parentSuspense);
        }
        instance.isMounted = true;
        if (true) {
          devtoolsComponentAdded(instance);
        }
        initialVNode = container = anchor = null;
      } else {
        let { next, bu, u, parent, vnode } = instance;
        {
          const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
          if (nonHydratedAsyncRoot) {
            if (next) {
              next.el = vnode.el;
              updateComponentPreRender(instance, next, optimized);
            }
            nonHydratedAsyncRoot.asyncDep.then(() => {
              if (!instance.isUnmounted) {
                componentUpdateFn();
              }
            });
            return;
          }
        }
        let originNext = next;
        let vnodeHook;
        if (true) {
          pushWarningContext(next || instance.vnode);
        }
        toggleRecurse(instance, false);
        if (next) {
          next.el = vnode.el;
          updateComponentPreRender(instance, next, optimized);
        } else {
          next = vnode;
        }
        if (bu) {
          (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bu);
        }
        if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
          invokeVNodeHook(vnodeHook, parent, next, vnode);
        }
        toggleRecurse(instance, true);
        if (true) {
          startMeasure(instance, `render`);
        }
        const nextTree = renderComponentRoot(instance);
        if (true) {
          endMeasure(instance, `render`);
        }
        const prevTree = instance.subTree;
        instance.subTree = nextTree;
        if (true) {
          startMeasure(instance, `patch`);
        }
        patch(
          prevTree,
          nextTree,
          // parent may have changed if it's in a teleport
          hostParentNode(prevTree.el),
          // anchor may have changed if it's in a fragment
          getNextHostNode(prevTree),
          instance,
          parentSuspense,
          namespace
        );
        if (true) {
          endMeasure(instance, `patch`);
        }
        next.el = nextTree.el;
        if (originNext === null) {
          updateHOCHostEl(instance, nextTree.el);
        }
        if (u) {
          queuePostRenderEffect(u, parentSuspense);
        }
        if (vnodeHook = next.props && next.props.onVnodeUpdated) {
          queuePostRenderEffect(
            () => invokeVNodeHook(vnodeHook, parent, next, vnode),
            parentSuspense
          );
        }
        if (true) {
          devtoolsComponentUpdated(instance);
        }
        if (true) {
          popWarningContext();
        }
      }
    };
    const effect = instance.effect = new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect(
      componentUpdateFn,
      _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP,
      () => queueJob(update),
      instance.scope
      // track it in component's effect scope
    );
    const update = instance.update = () => {
      if (effect.dirty) {
        effect.run();
      }
    };
    update.i = instance;
    update.id = instance.uid;
    toggleRecurse(instance, true);
    if (true) {
      effect.onTrack = instance.rtc ? (e) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.rtc, e) : void 0;
      effect.onTrigger = instance.rtg ? (e) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(instance.rtg, e) : void 0;
    }
    update();
  };
  const updateComponentPreRender = (instance, nextVNode, optimized) => {
    nextVNode.component = instance;
    const prevProps = instance.vnode.props;
    instance.vnode = nextVNode;
    instance.next = null;
    updateProps(instance, nextVNode.props, prevProps, optimized);
    updateSlots(instance, nextVNode.children, optimized);
    (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)();
    flushPreFlushCbs(instance);
    (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)();
  };
  const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
    const c1 = n1 && n1.children;
    const prevShapeFlag = n1 ? n1.shapeFlag : 0;
    const c2 = n2.children;
    const { patchFlag, shapeFlag } = n2;
    if (patchFlag > 0) {
      if (patchFlag & 128) {
        patchKeyedChildren(
          c1,
          c2,
          container,
          anchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
        return;
      } else if (patchFlag & 256) {
        patchUnkeyedChildren(
          c1,
          c2,
          container,
          anchor,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
        return;
      }
    }
    if (shapeFlag & 8) {
      if (prevShapeFlag & 16) {
        unmountChildren(c1, parentComponent, parentSuspense);
      }
      if (c2 !== c1) {
        hostSetElementText(container, c2);
      }
    } else {
      if (prevShapeFlag & 16) {
        if (shapeFlag & 16) {
          patchKeyedChildren(
            c1,
            c2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        } else {
          unmountChildren(c1, parentComponent, parentSuspense, true);
        }
      } else {
        if (prevShapeFlag & 8) {
          hostSetElementText(container, "");
        }
        if (shapeFlag & 16) {
          mountChildren(
            c2,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        }
      }
    }
  };
  const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
    c1 = c1 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR;
    c2 = c2 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR;
    const oldLength = c1.length;
    const newLength = c2.length;
    const commonLength = Math.min(oldLength, newLength);
    let i;
    for (i = 0; i < commonLength; i++) {
      const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
      patch(
        c1[i],
        nextChild,
        container,
        null,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        optimized
      );
    }
    if (oldLength > newLength) {
      unmountChildren(
        c1,
        parentComponent,
        parentSuspense,
        true,
        false,
        commonLength
      );
    } else {
      mountChildren(
        c2,
        container,
        anchor,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        optimized,
        commonLength
      );
    }
  };
  const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
    let i = 0;
    const l2 = c2.length;
    let e1 = c1.length - 1;
    let e2 = l2 - 1;
    while (i <= e1 && i <= e2) {
      const n1 = c1[i];
      const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
      if (isSameVNodeType(n1, n2)) {
        patch(
          n1,
          n2,
          container,
          null,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
      } else {
        break;
      }
      i++;
    }
    while (i <= e1 && i <= e2) {
      const n1 = c1[e1];
      const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
      if (isSameVNodeType(n1, n2)) {
        patch(
          n1,
          n2,
          container,
          null,
          parentComponent,
          parentSuspense,
          namespace,
          slotScopeIds,
          optimized
        );
      } else {
        break;
      }
      e1--;
      e2--;
    }
    if (i > e1) {
      if (i <= e2) {
        const nextPos = e2 + 1;
        const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
        while (i <= e2) {
          patch(
            null,
            c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
          i++;
        }
      }
    } else if (i > e2) {
      while (i <= e1) {
        unmount(c1[i], parentComponent, parentSuspense, true);
        i++;
      }
    } else {
      const s1 = i;
      const s2 = i;
      const keyToNewIndexMap = /* @__PURE__ */ new Map();
      for (i = s2; i <= e2; i++) {
        const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
        if (nextChild.key != null) {
          if ( true && keyToNewIndexMap.has(nextChild.key)) {
            warn$1(
              `Duplicate keys found during update:`,
              JSON.stringify(nextChild.key),
              `Make sure keys are unique.`
            );
          }
          keyToNewIndexMap.set(nextChild.key, i);
        }
      }
      let j;
      let patched = 0;
      const toBePatched = e2 - s2 + 1;
      let moved = false;
      let maxNewIndexSoFar = 0;
      const newIndexToOldIndexMap = new Array(toBePatched);
      for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
      for (i = s1; i <= e1; i++) {
        const prevChild = c1[i];
        if (patched >= toBePatched) {
          unmount(prevChild, parentComponent, parentSuspense, true);
          continue;
        }
        let newIndex;
        if (prevChild.key != null) {
          newIndex = keyToNewIndexMap.get(prevChild.key);
        } else {
          for (j = s2; j <= e2; j++) {
            if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
              newIndex = j;
              break;
            }
          }
        }
        if (newIndex === void 0) {
          unmount(prevChild, parentComponent, parentSuspense, true);
        } else {
          newIndexToOldIndexMap[newIndex - s2] = i + 1;
          if (newIndex >= maxNewIndexSoFar) {
            maxNewIndexSoFar = newIndex;
          } else {
            moved = true;
          }
          patch(
            prevChild,
            c2[newIndex],
            container,
            null,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
          patched++;
        }
      }
      const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR;
      j = increasingNewIndexSequence.length - 1;
      for (i = toBePatched - 1; i >= 0; i--) {
        const nextIndex = s2 + i;
        const nextChild = c2[nextIndex];
        const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
        if (newIndexToOldIndexMap[i] === 0) {
          patch(
            null,
            nextChild,
            container,
            anchor,
            parentComponent,
            parentSuspense,
            namespace,
            slotScopeIds,
            optimized
          );
        } else if (moved) {
          if (j < 0 || i !== increasingNewIndexSequence[j]) {
            move(nextChild, container, anchor, 2);
          } else {
            j--;
          }
        }
      }
    }
  };
  const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
    const { el, type, transition, children, shapeFlag } = vnode;
    if (shapeFlag & 6) {
      move(vnode.component.subTree, container, anchor, moveType);
      return;
    }
    if (shapeFlag & 128) {
      vnode.suspense.move(container, anchor, moveType);
      return;
    }
    if (shapeFlag & 64) {
      type.move(vnode, container, anchor, internals);
      return;
    }
    if (type === Fragment) {
      hostInsert(el, container, anchor);
      for (let i = 0; i < children.length; i++) {
        move(children[i], container, anchor, moveType);
      }
      hostInsert(vnode.anchor, container, anchor);
      return;
    }
    if (type === Static) {
      moveStaticNode(vnode, container, anchor);
      return;
    }
    const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
    if (needTransition2) {
      if (moveType === 0) {
        transition.beforeEnter(el);
        hostInsert(el, container, anchor);
        queuePostRenderEffect(() => transition.enter(el), parentSuspense);
      } else {
        const { leave, delayLeave, afterLeave } = transition;
        const remove2 = () => hostInsert(el, container, anchor);
        const performLeave = () => {
          leave(el, () => {
            remove2();
            afterLeave && afterLeave();
          });
        };
        if (delayLeave) {
          delayLeave(el, remove2, performLeave);
        } else {
          performLeave();
        }
      }
    } else {
      hostInsert(el, container, anchor);
    }
  };
  const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
    const {
      type,
      props,
      ref,
      children,
      dynamicChildren,
      shapeFlag,
      patchFlag,
      dirs,
      cacheIndex
    } = vnode;
    if (patchFlag === -2) {
      optimized = false;
    }
    if (ref != null) {
      setRef(ref, null, parentSuspense, vnode, true);
    }
    if (cacheIndex != null) {
      parentComponent.renderCache[cacheIndex] = void 0;
    }
    if (shapeFlag & 256) {
      parentComponent.ctx.deactivate(vnode);
      return;
    }
    const shouldInvokeDirs = shapeFlag & 1 && dirs;
    const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
    let vnodeHook;
    if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
      invokeVNodeHook(vnodeHook, parentComponent, vnode);
    }
    if (shapeFlag & 6) {
      unmountComponent(vnode.component, parentSuspense, doRemove);
    } else {
      if (shapeFlag & 128) {
        vnode.suspense.unmount(parentSuspense, doRemove);
        return;
      }
      if (shouldInvokeDirs) {
        invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
      }
      if (shapeFlag & 64) {
        vnode.type.remove(
          vnode,
          parentComponent,
          parentSuspense,
          internals,
          doRemove
        );
      } else if (dynamicChildren && // #5154
      // when v-once is used inside a block, setBlockTracking(-1) marks the
      // parent block with hasOnce: true
      // so that it doesn't take the fast path during unmount - otherwise
      // components nested in v-once are never unmounted.
      !dynamicChildren.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments
      (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
        unmountChildren(
          dynamicChildren,
          parentComponent,
          parentSuspense,
          false,
          true
        );
      } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
        unmountChildren(children, parentComponent, parentSuspense);
      }
      if (doRemove) {
        remove(vnode);
      }
    }
    if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
      queuePostRenderEffect(() => {
        vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
        shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
      }, parentSuspense);
    }
  };
  const remove = (vnode) => {
    const { type, el, anchor, transition } = vnode;
    if (type === Fragment) {
      if ( true && vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) {
        vnode.children.forEach((child) => {
          if (child.type === Comment) {
            hostRemove(child.el);
          } else {
            remove(child);
          }
        });
      } else {
        removeFragment(el, anchor);
      }
      return;
    }
    if (type === Static) {
      removeStaticNode(vnode);
      return;
    }
    const performRemove = () => {
      hostRemove(el);
      if (transition && !transition.persisted && transition.afterLeave) {
        transition.afterLeave();
      }
    };
    if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
      const { leave, delayLeave } = transition;
      const performLeave = () => leave(el, performRemove);
      if (delayLeave) {
        delayLeave(vnode.el, performRemove, performLeave);
      } else {
        performLeave();
      }
    } else {
      performRemove();
    }
  };
  const removeFragment = (cur, end) => {
    let next;
    while (cur !== end) {
      next = hostNextSibling(cur);
      hostRemove(cur);
      cur = next;
    }
    hostRemove(end);
  };
  const unmountComponent = (instance, parentSuspense, doRemove) => {
    if ( true && instance.type.__hmrId) {
      unregisterHMR(instance);
    }
    const { bum, scope, update, subTree, um, m, a } = instance;
    invalidateMount(m);
    invalidateMount(a);
    if (bum) {
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(bum);
    }
    scope.stop();
    if (update) {
      update.active = false;
      unmount(subTree, instance, parentSuspense, doRemove);
    }
    if (um) {
      queuePostRenderEffect(um, parentSuspense);
    }
    queuePostRenderEffect(() => {
      instance.isUnmounted = true;
    }, parentSuspense);
    if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
      parentSuspense.deps--;
      if (parentSuspense.deps === 0) {
        parentSuspense.resolve();
      }
    }
    if (true) {
      devtoolsComponentRemoved(instance);
    }
  };
  const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
    for (let i = start; i < children.length; i++) {
      unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
    }
  };
  const getNextHostNode = (vnode) => {
    if (vnode.shapeFlag & 6) {
      return getNextHostNode(vnode.component.subTree);
    }
    if (vnode.shapeFlag & 128) {
      return vnode.suspense.next();
    }
    const el = hostNextSibling(vnode.anchor || vnode.el);
    const teleportEnd = el && el[TeleportEndKey];
    return teleportEnd ? hostNextSibling(teleportEnd) : el;
  };
  let isFlushing = false;
  const render = (vnode, container, namespace) => {
    if (vnode == null) {
      if (container._vnode) {
        unmount(container._vnode, null, null, true);
      }
    } else {
      patch(
        container._vnode || null,
        vnode,
        container,
        null,
        null,
        null,
        namespace
      );
    }
    container._vnode = vnode;
    if (!isFlushing) {
      isFlushing = true;
      flushPreFlushCbs();
      flushPostFlushCbs();
      isFlushing = false;
    }
  };
  const internals = {
    p: patch,
    um: unmount,
    m: move,
    r: remove,
    mt: mountComponent,
    mc: mountChildren,
    pc: patchChildren,
    pbc: patchBlockChildren,
    n: getNextHostNode,
    o: options
  };
  let hydrate;
  let hydrateNode;
  if (createHydrationFns) {
    [hydrate, hydrateNode] = createHydrationFns(
      internals
    );
  }
  return {
    render,
    hydrate,
    createApp: createAppAPI(render, hydrate)
  };
}
function resolveChildrenNamespace({ type, props }, currentNamespace) {
  return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
}
function toggleRecurse({ effect, update }, allowed) {
  effect.allowRecurse = update.allowRecurse = allowed;
}
function needTransition(parentSuspense, transition) {
  return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
}
function traverseStaticChildren(n1, n2, shallow = false) {
  const ch1 = n1.children;
  const ch2 = n2.children;
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ch1) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ch2)) {
    for (let i = 0; i < ch1.length; i++) {
      const c1 = ch1[i];
      let c2 = ch2[i];
      if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
        if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
          c2 = ch2[i] = cloneIfMounted(ch2[i]);
          c2.el = c1.el;
        }
        if (!shallow && c2.patchFlag !== -2)
          traverseStaticChildren(c1, c2);
      }
      if (c2.type === Text) {
        c2.el = c1.el;
      }
      if ( true && c2.type === Comment && !c2.el) {
        c2.el = c1.el;
      }
    }
  }
}
function getSequence(arr) {
  const p = arr.slice();
  const result = [0];
  let i, j, u, v, c;
  const len = arr.length;
  for (i = 0; i < len; i++) {
    const arrI = arr[i];
    if (arrI !== 0) {
      j = result[result.length - 1];
      if (arr[j] < arrI) {
        p[i] = j;
        result.push(i);
        continue;
      }
      u = 0;
      v = result.length - 1;
      while (u < v) {
        c = u + v >> 1;
        if (arr[result[c]] < arrI) {
          u = c + 1;
        } else {
          v = c;
        }
      }
      if (arrI < arr[result[u]]) {
        if (u > 0) {
          p[i] = result[u - 1];
        }
        result[u] = i;
      }
    }
  }
  u = result.length;
  v = result[u - 1];
  while (u-- > 0) {
    result[u] = v;
    v = p[v];
  }
  return result;
}
function locateNonHydratedAsyncRoot(instance) {
  const subComponent = instance.subTree.component;
  if (subComponent) {
    if (subComponent.asyncDep && !subComponent.asyncResolved) {
      return subComponent;
    } else {
      return locateNonHydratedAsyncRoot(subComponent);
    }
  }
}
function invalidateMount(hooks) {
  if (hooks) {
    for (let i = 0; i < hooks.length; i++) hooks[i].active = false;
  }
}

const ssrContextKey = Symbol.for("v-scx");
const useSSRContext = () => {
  {
    const ctx = inject(ssrContextKey);
    if (!ctx) {
       true && warn$1(
        `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
      );
    }
    return ctx;
  }
};

function watchEffect(effect, options) {
  return doWatch(effect, null, options);
}
function watchPostEffect(effect, options) {
  return doWatch(
    effect,
    null,
     true ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, options, { flush: "post" }) : 0
  );
}
function watchSyncEffect(effect, options) {
  return doWatch(
    effect,
    null,
     true ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, options, { flush: "sync" }) : 0
  );
}
const INITIAL_WATCHER_VALUE = {};
function watch(source, cb, options) {
  if ( true && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(cb)) {
    warn$1(
      `\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`
    );
  }
  return doWatch(source, cb, options);
}
function doWatch(source, cb, {
  immediate,
  deep,
  flush,
  once,
  onTrack,
  onTrigger
} = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) {
  if (cb && once) {
    const _cb = cb;
    cb = (...args) => {
      _cb(...args);
      unwatch();
    };
  }
  if ( true && deep !== void 0 && typeof deep === "number") {
    warn$1(
      `watch() "deep" option with number value will be used as watch depth in future versions. Please use a boolean instead to avoid potential breakage.`
    );
  }
  if ( true && !cb) {
    if (immediate !== void 0) {
      warn$1(
        `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
      );
    }
    if (deep !== void 0) {
      warn$1(
        `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
      );
    }
    if (once !== void 0) {
      warn$1(
        `watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
      );
    }
  }
  const warnInvalidSource = (s) => {
    warn$1(
      `Invalid watch source: `,
      s,
      `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
    );
  };
  const instance = currentInstance;
  const reactiveGetter = (source2) => deep === true ? source2 : (
    // for deep: false, only traverse root-level properties
    traverse(source2, deep === false ? 1 : void 0)
  );
  let getter;
  let forceTrigger = false;
  let isMultiSource = false;
  if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(source)) {
    getter = () => source.value;
    forceTrigger = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(source);
  } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(source)) {
    getter = () => reactiveGetter(source);
    forceTrigger = true;
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(source)) {
    isMultiSource = true;
    forceTrigger = source.some((s) => (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(s) || (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(s));
    getter = () => source.map((s) => {
      if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(s)) {
        return s.value;
      } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(s)) {
        return reactiveGetter(s);
      } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(s)) {
        return callWithErrorHandling(s, instance, 2);
      } else {
         true && warnInvalidSource(s);
      }
    });
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(source)) {
    if (cb) {
      getter = () => callWithErrorHandling(source, instance, 2);
    } else {
      getter = () => {
        if (cleanup) {
          cleanup();
        }
        return callWithAsyncErrorHandling(
          source,
          instance,
          3,
          [onCleanup]
        );
      };
    }
  } else {
    getter = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP;
     true && warnInvalidSource(source);
  }
  if (cb && deep) {
    const baseGetter = getter;
    getter = () => traverse(baseGetter());
  }
  let cleanup;
  let onCleanup = (fn) => {
    cleanup = effect.onStop = () => {
      callWithErrorHandling(fn, instance, 4);
      cleanup = effect.onStop = void 0;
    };
  };
  let ssrCleanup;
  if (isInSSRComponentSetup) {
    onCleanup = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP;
    if (!cb) {
      getter();
    } else if (immediate) {
      callWithAsyncErrorHandling(cb, instance, 3, [
        getter(),
        isMultiSource ? [] : void 0,
        onCleanup
      ]);
    }
    if (flush === "sync") {
      const ctx = useSSRContext();
      ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
    } else {
      return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP;
    }
  }
  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
  const job = () => {
    if (!effect.active || !effect.dirty) {
      return;
    }
    if (cb) {
      const newValue = effect.run();
      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(v, oldValue[i])) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(newValue, oldValue)) || false) {
        if (cleanup) {
          cleanup();
        }
        callWithAsyncErrorHandling(cb, instance, 3, [
          newValue,
          // pass undefined as the old value when it's changed for the first time
          oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
          onCleanup
        ]);
        oldValue = newValue;
      }
    } else {
      effect.run();
    }
  };
  job.allowRecurse = !!cb;
  let scheduler;
  if (flush === "sync") {
    scheduler = job;
  } else if (flush === "post") {
    scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
  } else {
    job.pre = true;
    if (instance) job.id = instance.uid;
    scheduler = () => queueJob(job);
  }
  const effect = new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect(getter, _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP, scheduler);
  const scope = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope)();
  const unwatch = () => {
    effect.stop();
    if (scope) {
      (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.remove)(scope.effects, effect);
    }
  };
  if (true) {
    effect.onTrack = onTrack;
    effect.onTrigger = onTrigger;
  }
  if (cb) {
    if (immediate) {
      job();
    } else {
      oldValue = effect.run();
    }
  } else if (flush === "post") {
    queuePostRenderEffect(
      effect.run.bind(effect),
      instance && instance.suspense
    );
  } else {
    effect.run();
  }
  if (ssrCleanup) ssrCleanup.push(unwatch);
  return unwatch;
}
function instanceWatch(source, value, options) {
  const publicThis = this.proxy;
  const getter = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
  let cb;
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) {
    cb = value;
  } else {
    cb = value.handler;
    options = value;
  }
  const reset = setCurrentInstance(this);
  const res = doWatch(getter, cb.bind(publicThis), options);
  reset();
  return res;
}
function createPathGetter(ctx, path) {
  const segments = path.split(".");
  return () => {
    let cur = ctx;
    for (let i = 0; i < segments.length && cur; i++) {
      cur = cur[segments[i]];
    }
    return cur;
  };
}
function traverse(value, depth = Infinity, seen) {
  if (depth <= 0 || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(value) || value["__v_skip"]) {
    return value;
  }
  seen = seen || /* @__PURE__ */ new Set();
  if (seen.has(value)) {
    return value;
  }
  seen.add(value);
  depth--;
  if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(value)) {
    traverse(value.value, depth, seen);
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) {
    for (let i = 0; i < value.length; i++) {
      traverse(value[i], depth, seen);
    }
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isMap)(value)) {
    value.forEach((v) => {
      traverse(v, depth, seen);
    });
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPlainObject)(value)) {
    for (const key in value) {
      traverse(value[key], depth, seen);
    }
    for (const key of Object.getOwnPropertySymbols(value)) {
      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
        traverse(value[key], depth, seen);
      }
    }
  }
  return value;
}

function useModel(props, name, options = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) {
  const i = getCurrentInstance();
  if ( true && !i) {
    warn$1(`useModel() called without active instance.`);
    return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)();
  }
  if ( true && !i.propsOptions[0][name]) {
    warn$1(`useModel() called with prop "${name}" which is not declared.`);
    return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.ref)();
  }
  const camelizedName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(name);
  const hyphenatedName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(name);
  const modifiers = getModelModifiers(props, name);
  const res = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.customRef)((track, trigger) => {
    let localValue;
    let prevSetValue = _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
    let prevEmittedValue;
    watchSyncEffect(() => {
      const propValue = props[name];
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(localValue, propValue)) {
        localValue = propValue;
        trigger();
      }
    });
    return {
      get() {
        track();
        return options.get ? options.get(localValue) : localValue;
      },
      set(value) {
        const emittedValue = options.set ? options.set(value) : value;
        if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(emittedValue, localValue) && !(prevSetValue !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(value, prevSetValue))) {
          return;
        }
        const rawProps = i.vnode.props;
        if (!(rawProps && // check if parent has passed v-model
        (name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps))) {
          localValue = value;
          trigger();
        }
        i.emit(`update:${name}`, emittedValue);
        if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(value, emittedValue) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(value, prevSetValue) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(emittedValue, prevEmittedValue)) {
          trigger();
        }
        prevSetValue = value;
        prevEmittedValue = emittedValue;
      }
    };
  });
  res[Symbol.iterator] = () => {
    let i2 = 0;
    return {
      next() {
        if (i2 < 2) {
          return { value: i2++ ? modifiers || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ : res, done: false };
        } else {
          return { done: true };
        }
      }
    };
  };
  return res;
}
const getModelModifiers = (props, modelName) => {
  return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(modelName)}Modifiers`] || props[`${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(modelName)}Modifiers`];
};

function emit(instance, event, ...rawArgs) {
  if (instance.isUnmounted) return;
  const props = instance.vnode.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
  if (true) {
    const {
      emitsOptions,
      propsOptions: [propsOptions]
    } = instance;
    if (emitsOptions) {
      if (!(event in emitsOptions) && true) {
        if (!propsOptions || !((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(event)) in propsOptions)) {
          warn$1(
            `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(event))}" prop.`
          );
        }
      } else {
        const validator = emitsOptions[event];
        if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(validator)) {
          const isValid = validator(...rawArgs);
          if (!isValid) {
            warn$1(
              `Invalid event arguments: event validation failed for event "${event}".`
            );
          }
        }
      }
    }
  }
  let args = rawArgs;
  const isModelListener = event.startsWith("update:");
  const modifiers = isModelListener && getModelModifiers(props, event.slice(7));
  if (modifiers) {
    if (modifiers.trim) {
      args = rawArgs.map((a) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(a) ? a.trim() : a);
    }
    if (modifiers.number) {
      args = rawArgs.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber);
    }
  }
  if (true) {
    devtoolsComponentEmit(instance, event, args);
  }
  if (true) {
    const lowerCaseEvent = event.toLowerCase();
    if (lowerCaseEvent !== event && props[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(lowerCaseEvent)]) {
      warn$1(
        `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
          instance,
          instance.type
        )} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(
          event
        )}" instead of "${event}".`
      );
    }
  }
  let handlerName;
  let handler = props[handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)(event)] || // also try camelCase event handler (#2249)
  props[handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(event))];
  if (!handler && isModelListener) {
    handler = props[handlerName = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toHandlerKey)((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event))];
  }
  if (handler) {
    callWithAsyncErrorHandling(
      handler,
      instance,
      6,
      args
    );
  }
  const onceHandler = props[handlerName + `Once`];
  if (onceHandler) {
    if (!instance.emitted) {
      instance.emitted = {};
    } else if (instance.emitted[handlerName]) {
      return;
    }
    instance.emitted[handlerName] = true;
    callWithAsyncErrorHandling(
      onceHandler,
      instance,
      6,
      args
    );
  }
}
function normalizeEmitsOptions(comp, appContext, asMixin = false) {
  const cache = appContext.emitsCache;
  const cached = cache.get(comp);
  if (cached !== void 0) {
    return cached;
  }
  const raw = comp.emits;
  let normalized = {};
  let hasExtends = false;
  if (__VUE_OPTIONS_API__ && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(comp)) {
    const extendEmits = (raw2) => {
      const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
      if (normalizedFromExtend) {
        hasExtends = true;
        (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, normalizedFromExtend);
      }
    };
    if (!asMixin && appContext.mixins.length) {
      appContext.mixins.forEach(extendEmits);
    }
    if (comp.extends) {
      extendEmits(comp.extends);
    }
    if (comp.mixins) {
      comp.mixins.forEach(extendEmits);
    }
  }
  if (!raw && !hasExtends) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) {
      cache.set(comp, null);
    }
    return null;
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(raw)) {
    raw.forEach((key) => normalized[key] = null);
  } else {
    (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(normalized, raw);
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(comp)) {
    cache.set(comp, normalized);
  }
  return normalized;
}
function isEmitListener(options, key) {
  if (!options || !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) {
    return false;
  }
  key = key.slice(2).replace(/Once$/, "");
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, key[0].toLowerCase() + key.slice(1)) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key)) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasOwn)(options, key);
}

let accessedAttrs = false;
function markAttrsAccessed() {
  accessedAttrs = true;
}
function renderComponentRoot(instance) {
  const {
    type: Component,
    vnode,
    proxy,
    withProxy,
    propsOptions: [propsOptions],
    slots,
    attrs,
    emit,
    render,
    renderCache,
    props,
    data,
    setupState,
    ctx,
    inheritAttrs
  } = instance;
  const prev = setCurrentRenderingInstance(instance);
  let result;
  let fallthroughAttrs;
  if (true) {
    accessedAttrs = false;
  }
  try {
    if (vnode.shapeFlag & 4) {
      const proxyToUse = withProxy || proxy;
      const thisProxy =  true && setupState.__isScriptSetup ? new Proxy(proxyToUse, {
        get(target, key, receiver) {
          warn$1(
            `Property '${String(
              key
            )}' was accessed via 'this'. Avoid using 'this' in templates.`
          );
          return Reflect.get(target, key, receiver);
        }
      }) : proxyToUse;
      result = normalizeVNode(
        render.call(
          thisProxy,
          proxyToUse,
          renderCache,
           true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(props) : 0,
          setupState,
          data,
          ctx
        )
      );
      fallthroughAttrs = attrs;
    } else {
      const render2 = Component;
      if ( true && attrs === props) {
        markAttrsAccessed();
      }
      result = normalizeVNode(
        render2.length > 1 ? render2(
           true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(props) : 0,
           true ? {
            get attrs() {
              markAttrsAccessed();
              return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(attrs);
            },
            slots,
            emit
          } : 0
        ) : render2(
           true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(props) : 0,
          null
        )
      );
      fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
    }
  } catch (err) {
    blockStack.length = 0;
    handleError(err, instance, 1);
    result = createVNode(Comment);
  }
  let root = result;
  let setRoot = void 0;
  if ( true && result.patchFlag > 0 && result.patchFlag & 2048) {
    [root, setRoot] = getChildRoot(result);
  }
  if (fallthroughAttrs && inheritAttrs !== false) {
    const keys = Object.keys(fallthroughAttrs);
    const { shapeFlag } = root;
    if (keys.length) {
      if (shapeFlag & (1 | 6)) {
        if (propsOptions && keys.some(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)) {
          fallthroughAttrs = filterModelListeners(
            fallthroughAttrs,
            propsOptions
          );
        }
        root = cloneVNode(root, fallthroughAttrs, false, true);
      } else if ( true && !accessedAttrs && root.type !== Comment) {
        const allAttrs = Object.keys(attrs);
        const eventAttrs = [];
        const extraAttrs = [];
        for (let i = 0, l = allAttrs.length; i < l; i++) {
          const key = allAttrs[i];
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) {
            if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key)) {
              eventAttrs.push(key[2].toLowerCase() + key.slice(3));
            }
          } else {
            extraAttrs.push(key);
          }
        }
        if (extraAttrs.length) {
          warn$1(
            `Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`
          );
        }
        if (eventAttrs.length) {
          warn$1(
            `Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`
          );
        }
      }
    }
  }
  if (vnode.dirs) {
    if ( true && !isElementRoot(root)) {
      warn$1(
        `Runtime directive used on component with non-element root node. The directives will not function as intended.`
      );
    }
    root = cloneVNode(root, null, false, true);
    root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
  }
  if (vnode.transition) {
    if ( true && !isElementRoot(root)) {
      warn$1(
        `Component inside <Transition> renders non-element root node that cannot be animated.`
      );
    }
    root.transition = vnode.transition;
  }
  if ( true && setRoot) {
    setRoot(root);
  } else {
    result = root;
  }
  setCurrentRenderingInstance(prev);
  return result;
}
const getChildRoot = (vnode) => {
  const rawChildren = vnode.children;
  const dynamicChildren = vnode.dynamicChildren;
  const childRoot = filterSingleRoot(rawChildren, false);
  if (!childRoot) {
    return [vnode, void 0];
  } else if ( true && childRoot.patchFlag > 0 && childRoot.patchFlag & 2048) {
    return getChildRoot(childRoot);
  }
  const index = rawChildren.indexOf(childRoot);
  const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
  const setRoot = (updatedRoot) => {
    rawChildren[index] = updatedRoot;
    if (dynamicChildren) {
      if (dynamicIndex > -1) {
        dynamicChildren[dynamicIndex] = updatedRoot;
      } else if (updatedRoot.patchFlag > 0) {
        vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
      }
    }
  };
  return [normalizeVNode(childRoot), setRoot];
};
function filterSingleRoot(children, recurse = true) {
  let singleRoot;
  for (let i = 0; i < children.length; i++) {
    const child = children[i];
    if (isVNode(child)) {
      if (child.type !== Comment || child.children === "v-if") {
        if (singleRoot) {
          return;
        } else {
          singleRoot = child;
          if ( true && recurse && singleRoot.patchFlag > 0 && singleRoot.patchFlag & 2048) {
            return filterSingleRoot(singleRoot.children);
          }
        }
      }
    } else {
      return;
    }
  }
  return singleRoot;
}
const getFunctionalFallthrough = (attrs) => {
  let res;
  for (const key in attrs) {
    if (key === "class" || key === "style" || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) {
      (res || (res = {}))[key] = attrs[key];
    }
  }
  return res;
};
const filterModelListeners = (attrs, props) => {
  const res = {};
  for (const key in attrs) {
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key) || !(key.slice(9) in props)) {
      res[key] = attrs[key];
    }
  }
  return res;
};
const isElementRoot = (vnode) => {
  return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
  const { props: prevProps, children: prevChildren, component } = prevVNode;
  const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
  const emits = component.emitsOptions;
  if ( true && (prevChildren || nextChildren) && isHmrUpdating) {
    return true;
  }
  if (nextVNode.dirs || nextVNode.transition) {
    return true;
  }
  if (optimized && patchFlag >= 0) {
    if (patchFlag & 1024) {
      return true;
    }
    if (patchFlag & 16) {
      if (!prevProps) {
        return !!nextProps;
      }
      return hasPropsChanged(prevProps, nextProps, emits);
    } else if (patchFlag & 8) {
      const dynamicProps = nextVNode.dynamicProps;
      for (let i = 0; i < dynamicProps.length; i++) {
        const key = dynamicProps[i];
        if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
          return true;
        }
      }
    }
  } else {
    if (prevChildren || nextChildren) {
      if (!nextChildren || !nextChildren.$stable) {
        return true;
      }
    }
    if (prevProps === nextProps) {
      return false;
    }
    if (!prevProps) {
      return !!nextProps;
    }
    if (!nextProps) {
      return true;
    }
    return hasPropsChanged(prevProps, nextProps, emits);
  }
  return false;
}
function hasPropsChanged(prevProps, nextProps, emitsOptions) {
  const nextKeys = Object.keys(nextProps);
  if (nextKeys.length !== Object.keys(prevProps).length) {
    return true;
  }
  for (let i = 0; i < nextKeys.length; i++) {
    const key = nextKeys[i];
    if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
      return true;
    }
  }
  return false;
}
function updateHOCHostEl({ vnode, parent }, el) {
  while (parent) {
    const root = parent.subTree;
    if (root.suspense && root.suspense.activeBranch === vnode) {
      root.el = vnode.el;
    }
    if (root === vnode) {
      (vnode = parent.vnode).el = el;
      parent = parent.parent;
    } else {
      break;
    }
  }
}

const isSuspense = (type) => type.__isSuspense;
let suspenseId = 0;
const SuspenseImpl = {
  name: "Suspense",
  // In order to make Suspense tree-shakable, we need to avoid importing it
  // directly in the renderer. The renderer checks for the __isSuspense flag
  // on a vnode's type and calls the `process` method, passing in renderer
  // internals.
  __isSuspense: true,
  process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
    if (n1 == null) {
      mountSuspense(
        n2,
        container,
        anchor,
        parentComponent,
        parentSuspense,
        namespace,
        slotScopeIds,
        optimized,
        rendererInternals
      );
    } else {
      if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) {
        n2.suspense = n1.suspense;
        n2.suspense.vnode = n2;
        n2.el = n1.el;
        return;
      }
      patchSuspense(
        n1,
        n2,
        container,
        anchor,
        parentComponent,
        namespace,
        slotScopeIds,
        optimized,
        rendererInternals
      );
    }
  },
  hydrate: hydrateSuspense,
  normalize: normalizeSuspenseChildren
};
const Suspense = SuspenseImpl ;
function triggerEvent(vnode, name) {
  const eventListener = vnode.props && vnode.props[name];
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(eventListener)) {
    eventListener();
  }
}
function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
  const {
    p: patch,
    o: { createElement }
  } = rendererInternals;
  const hiddenContainer = createElement("div");
  const suspense = vnode.suspense = createSuspenseBoundary(
    vnode,
    parentSuspense,
    parentComponent,
    container,
    hiddenContainer,
    anchor,
    namespace,
    slotScopeIds,
    optimized,
    rendererInternals
  );
  patch(
    null,
    suspense.pendingBranch = vnode.ssContent,
    hiddenContainer,
    null,
    parentComponent,
    suspense,
    namespace,
    slotScopeIds
  );
  if (suspense.deps > 0) {
    triggerEvent(vnode, "onPending");
    triggerEvent(vnode, "onFallback");
    patch(
      null,
      vnode.ssFallback,
      container,
      anchor,
      parentComponent,
      null,
      // fallback tree will not have suspense context
      namespace,
      slotScopeIds
    );
    setActiveBranch(suspense, vnode.ssFallback);
  } else {
    suspense.resolve(false, true);
  }
}
function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
  const suspense = n2.suspense = n1.suspense;
  suspense.vnode = n2;
  n2.el = n1.el;
  const newBranch = n2.ssContent;
  const newFallback = n2.ssFallback;
  const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
  if (pendingBranch) {
    suspense.pendingBranch = newBranch;
    if (isSameVNodeType(newBranch, pendingBranch)) {
      patch(
        pendingBranch,
        newBranch,
        suspense.hiddenContainer,
        null,
        parentComponent,
        suspense,
        namespace,
        slotScopeIds,
        optimized
      );
      if (suspense.deps <= 0) {
        suspense.resolve();
      } else if (isInFallback) {
        if (!isHydrating) {
          patch(
            activeBranch,
            newFallback,
            container,
            anchor,
            parentComponent,
            null,
            // fallback tree will not have suspense context
            namespace,
            slotScopeIds,
            optimized
          );
          setActiveBranch(suspense, newFallback);
        }
      }
    } else {
      suspense.pendingId = suspenseId++;
      if (isHydrating) {
        suspense.isHydrating = false;
        suspense.activeBranch = pendingBranch;
      } else {
        unmount(pendingBranch, parentComponent, suspense);
      }
      suspense.deps = 0;
      suspense.effects.length = 0;
      suspense.hiddenContainer = createElement("div");
      if (isInFallback) {
        patch(
          null,
          newBranch,
          suspense.hiddenContainer,
          null,
          parentComponent,
          suspense,
          namespace,
          slotScopeIds,
          optimized
        );
        if (suspense.deps <= 0) {
          suspense.resolve();
        } else {
          patch(
            activeBranch,
            newFallback,
            container,
            anchor,
            parentComponent,
            null,
            // fallback tree will not have suspense context
            namespace,
            slotScopeIds,
            optimized
          );
          setActiveBranch(suspense, newFallback);
        }
      } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
        patch(
          activeBranch,
          newBranch,
          container,
          anchor,
          parentComponent,
          suspense,
          namespace,
          slotScopeIds,
          optimized
        );
        suspense.resolve(true);
      } else {
        patch(
          null,
          newBranch,
          suspense.hiddenContainer,
          null,
          parentComponent,
          suspense,
          namespace,
          slotScopeIds,
          optimized
        );
        if (suspense.deps <= 0) {
          suspense.resolve();
        }
      }
    }
  } else {
    if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
      patch(
        activeBranch,
        newBranch,
        container,
        anchor,
        parentComponent,
        suspense,
        namespace,
        slotScopeIds,
        optimized
      );
      setActiveBranch(suspense, newBranch);
    } else {
      triggerEvent(n2, "onPending");
      suspense.pendingBranch = newBranch;
      if (newBranch.shapeFlag & 512) {
        suspense.pendingId = newBranch.component.suspenseId;
      } else {
        suspense.pendingId = suspenseId++;
      }
      patch(
        null,
        newBranch,
        suspense.hiddenContainer,
        null,
        parentComponent,
        suspense,
        namespace,
        slotScopeIds,
        optimized
      );
      if (suspense.deps <= 0) {
        suspense.resolve();
      } else {
        const { timeout, pendingId } = suspense;
        if (timeout > 0) {
          setTimeout(() => {
            if (suspense.pendingId === pendingId) {
              suspense.fallback(newFallback);
            }
          }, timeout);
        } else if (timeout === 0) {
          suspense.fallback(newFallback);
        }
      }
    }
  }
}
let hasWarned = false;
function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
  if ( true && !hasWarned) {
    hasWarned = true;
    console[console.info ? "info" : "log"](
      `<Suspense> is an experimental feature and its API will likely change.`
    );
  }
  const {
    p: patch,
    m: move,
    um: unmount,
    n: next,
    o: { parentNode, remove }
  } = rendererInternals;
  let parentSuspenseId;
  const isSuspensible = isVNodeSuspensible(vnode);
  if (isSuspensible) {
    if (parentSuspense && parentSuspense.pendingBranch) {
      parentSuspenseId = parentSuspense.pendingId;
      parentSuspense.deps++;
    }
  }
  const timeout = vnode.props ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(vnode.props.timeout) : void 0;
  if (true) {
    assertNumber(timeout, `Suspense timeout`);
  }
  const initialAnchor = anchor;
  const suspense = {
    vnode,
    parent: parentSuspense,
    parentComponent,
    namespace,
    container,
    hiddenContainer,
    deps: 0,
    pendingId: suspenseId++,
    timeout: typeof timeout === "number" ? timeout : -1,
    activeBranch: null,
    pendingBranch: null,
    isInFallback: !isHydrating,
    isHydrating,
    isUnmounted: false,
    effects: [],
    resolve(resume = false, sync = false) {
      if (true) {
        if (!resume && !suspense.pendingBranch) {
          throw new Error(
            `suspense.resolve() is called without a pending branch.`
          );
        }
        if (suspense.isUnmounted) {
          throw new Error(
            `suspense.resolve() is called on an already unmounted suspense boundary.`
          );
        }
      }
      const {
        vnode: vnode2,
        activeBranch,
        pendingBranch,
        pendingId,
        effects,
        parentComponent: parentComponent2,
        container: container2
      } = suspense;
      let delayEnter = false;
      if (suspense.isHydrating) {
        suspense.isHydrating = false;
      } else if (!resume) {
        delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
        if (delayEnter) {
          activeBranch.transition.afterLeave = () => {
            if (pendingId === suspense.pendingId) {
              move(
                pendingBranch,
                container2,
                anchor === initialAnchor ? next(activeBranch) : anchor,
                0
              );
              queuePostFlushCb(effects);
            }
          };
        }
        if (activeBranch) {
          if (parentNode(activeBranch.el) !== suspense.hiddenContainer) {
            anchor = next(activeBranch);
          }
          unmount(activeBranch, parentComponent2, suspense, true);
        }
        if (!delayEnter) {
          move(pendingBranch, container2, anchor, 0);
        }
      }
      setActiveBranch(suspense, pendingBranch);
      suspense.pendingBranch = null;
      suspense.isInFallback = false;
      let parent = suspense.parent;
      let hasUnresolvedAncestor = false;
      while (parent) {
        if (parent.pendingBranch) {
          parent.effects.push(...effects);
          hasUnresolvedAncestor = true;
          break;
        }
        parent = parent.parent;
      }
      if (!hasUnresolvedAncestor && !delayEnter) {
        queuePostFlushCb(effects);
      }
      suspense.effects = [];
      if (isSuspensible) {
        if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
          parentSuspense.deps--;
          if (parentSuspense.deps === 0 && !sync) {
            parentSuspense.resolve();
          }
        }
      }
      triggerEvent(vnode2, "onResolve");
    },
    fallback(fallbackVNode) {
      if (!suspense.pendingBranch) {
        return;
      }
      const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense;
      triggerEvent(vnode2, "onFallback");
      const anchor2 = next(activeBranch);
      const mountFallback = () => {
        if (!suspense.isInFallback) {
          return;
        }
        patch(
          null,
          fallbackVNode,
          container2,
          anchor2,
          parentComponent2,
          null,
          // fallback tree will not have suspense context
          namespace2,
          slotScopeIds,
          optimized
        );
        setActiveBranch(suspense, fallbackVNode);
      };
      const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
      if (delayEnter) {
        activeBranch.transition.afterLeave = mountFallback;
      }
      suspense.isInFallback = true;
      unmount(
        activeBranch,
        parentComponent2,
        null,
        // no suspense so unmount hooks fire now
        true
        // shouldRemove
      );
      if (!delayEnter) {
        mountFallback();
      }
    },
    move(container2, anchor2, type) {
      suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
      suspense.container = container2;
    },
    next() {
      return suspense.activeBranch && next(suspense.activeBranch);
    },
    registerDep(instance, setupRenderEffect, optimized2) {
      const isInPendingSuspense = !!suspense.pendingBranch;
      if (isInPendingSuspense) {
        suspense.deps++;
      }
      const hydratedEl = instance.vnode.el;
      instance.asyncDep.catch((err) => {
        handleError(err, instance, 0);
      }).then((asyncSetupResult) => {
        if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
          return;
        }
        instance.asyncResolved = true;
        const { vnode: vnode2 } = instance;
        if (true) {
          pushWarningContext(vnode2);
        }
        handleSetupResult(instance, asyncSetupResult, false);
        if (hydratedEl) {
          vnode2.el = hydratedEl;
        }
        const placeholder = !hydratedEl && instance.subTree.el;
        setupRenderEffect(
          instance,
          vnode2,
          // component may have been moved before resolve.
          // if this is not a hydration, instance.subTree will be the comment
          // placeholder.
          parentNode(hydratedEl || instance.subTree.el),
          // anchor will not be used if this is hydration, so only need to
          // consider the comment placeholder case.
          hydratedEl ? null : next(instance.subTree),
          suspense,
          namespace,
          optimized2
        );
        if (placeholder) {
          remove(placeholder);
        }
        updateHOCHostEl(instance, vnode2.el);
        if (true) {
          popWarningContext();
        }
        if (isInPendingSuspense && --suspense.deps === 0) {
          suspense.resolve();
        }
      });
    },
    unmount(parentSuspense2, doRemove) {
      suspense.isUnmounted = true;
      if (suspense.activeBranch) {
        unmount(
          suspense.activeBranch,
          parentComponent,
          parentSuspense2,
          doRemove
        );
      }
      if (suspense.pendingBranch) {
        unmount(
          suspense.pendingBranch,
          parentComponent,
          parentSuspense2,
          doRemove
        );
      }
    }
  };
  return suspense;
}
function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals, hydrateNode) {
  const suspense = vnode.suspense = createSuspenseBoundary(
    vnode,
    parentSuspense,
    parentComponent,
    node.parentNode,
    // eslint-disable-next-line no-restricted-globals
    document.createElement("div"),
    null,
    namespace,
    slotScopeIds,
    optimized,
    rendererInternals,
    true
  );
  const result = hydrateNode(
    node,
    suspense.pendingBranch = vnode.ssContent,
    parentComponent,
    suspense,
    slotScopeIds,
    optimized
  );
  if (suspense.deps === 0) {
    suspense.resolve(false, true);
  }
  return result;
}
function normalizeSuspenseChildren(vnode) {
  const { shapeFlag, children } = vnode;
  const isSlotChildren = shapeFlag & 32;
  vnode.ssContent = normalizeSuspenseSlot(
    isSlotChildren ? children.default : children
  );
  vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
}
function normalizeSuspenseSlot(s) {
  let block;
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(s)) {
    const trackBlock = isBlockTreeEnabled && s._c;
    if (trackBlock) {
      s._d = false;
      openBlock();
    }
    s = s();
    if (trackBlock) {
      s._d = true;
      block = currentBlock;
      closeBlock();
    }
  }
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(s)) {
    const singleChild = filterSingleRoot(s);
    if ( true && !singleChild && s.filter((child) => child !== NULL_DYNAMIC_COMPONENT).length > 0) {
      warn$1(`<Suspense> slots expect a single root node.`);
    }
    s = singleChild;
  }
  s = normalizeVNode(s);
  if (block && !s.dynamicChildren) {
    s.dynamicChildren = block.filter((c) => c !== s);
  }
  return s;
}
function queueEffectWithSuspense(fn, suspense) {
  if (suspense && suspense.pendingBranch) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn)) {
      suspense.effects.push(...fn);
    } else {
      suspense.effects.push(fn);
    }
  } else {
    queuePostFlushCb(fn);
  }
}
function setActiveBranch(suspense, branch) {
  suspense.activeBranch = branch;
  const { vnode, parentComponent } = suspense;
  let el = branch.el;
  while (!el && branch.component) {
    branch = branch.component.subTree;
    el = branch.el;
  }
  vnode.el = el;
  if (parentComponent && parentComponent.subTree === vnode) {
    parentComponent.vnode.el = el;
    updateHOCHostEl(parentComponent, el);
  }
}
function isVNodeSuspensible(vnode) {
  const suspensible = vnode.props && vnode.props.suspensible;
  return suspensible != null && suspensible !== false;
}

const Fragment = Symbol.for("v-fgt");
const Text = Symbol.for("v-txt");
const Comment = Symbol.for("v-cmt");
const Static = Symbol.for("v-stc");
const blockStack = [];
let currentBlock = null;
function openBlock(disableTracking = false) {
  blockStack.push(currentBlock = disableTracking ? null : []);
}
function closeBlock() {
  blockStack.pop();
  currentBlock = blockStack[blockStack.length - 1] || null;
}
let isBlockTreeEnabled = 1;
function setBlockTracking(value) {
  isBlockTreeEnabled += value;
  if (value < 0 && currentBlock) {
    currentBlock.hasOnce = true;
  }
}
function setupBlock(vnode) {
  vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_ARR : null;
  closeBlock();
  if (isBlockTreeEnabled > 0 && currentBlock) {
    currentBlock.push(vnode);
  }
  return vnode;
}
function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
  return setupBlock(
    createBaseVNode(
      type,
      props,
      children,
      patchFlag,
      dynamicProps,
      shapeFlag,
      true
    )
  );
}
function createBlock(type, props, children, patchFlag, dynamicProps) {
  return setupBlock(
    createVNode(
      type,
      props,
      children,
      patchFlag,
      dynamicProps,
      true
    )
  );
}
function isVNode(value) {
  return value ? value.__v_isVNode === true : false;
}
function isSameVNodeType(n1, n2) {
  if ( true && n2.shapeFlag & 6 && n1.component) {
    const dirtyInstances = hmrDirtyComponents.get(n2.type);
    if (dirtyInstances && dirtyInstances.has(n1.component)) {
      n1.shapeFlag &= ~256;
      n2.shapeFlag &= ~512;
      return false;
    }
  }
  return n1.type === n2.type && n1.key === n2.key;
}
let vnodeArgsTransformer;
function transformVNodeArgs(transformer) {
  vnodeArgsTransformer = transformer;
}
const createVNodeWithArgsTransform = (...args) => {
  return _createVNode(
    ...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : args
  );
};
const normalizeKey = ({ key }) => key != null ? key : null;
const normalizeRef = ({
  ref,
  ref_key,
  ref_for
}) => {
  if (typeof ref === "number") {
    ref = "" + ref;
  }
  return ref != null ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(ref) || (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(ref) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
};
function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
  const vnode = {
    __v_isVNode: true,
    __v_skip: true,
    type,
    props,
    key: props && normalizeKey(props),
    ref: props && normalizeRef(props),
    scopeId: currentScopeId,
    slotScopeIds: null,
    children,
    component: null,
    suspense: null,
    ssContent: null,
    ssFallback: null,
    dirs: null,
    transition: null,
    el: null,
    anchor: null,
    target: null,
    targetStart: null,
    targetAnchor: null,
    staticCount: 0,
    shapeFlag,
    patchFlag,
    dynamicProps,
    dynamicChildren: null,
    appContext: null,
    ctx: currentRenderingInstance
  };
  if (needFullChildrenNormalization) {
    normalizeChildren(vnode, children);
    if (shapeFlag & 128) {
      type.normalize(vnode);
    }
  } else if (children) {
    vnode.shapeFlag |= (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(children) ? 8 : 16;
  }
  if ( true && vnode.key !== vnode.key) {
    warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
  }
  if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
  !isBlockNode && // has current parent block
  currentBlock && // presence of a patch flag indicates this node needs patching on updates.
  // component nodes also should always be patched, because even if the
  // component doesn't need to update, it needs to persist the instance on to
  // the next vnode so that it can be properly unmounted later.
  (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
  // vnode should not be considered dynamic due to handler caching.
  vnode.patchFlag !== 32) {
    currentBlock.push(vnode);
  }
  return vnode;
}
const createVNode =  true ? createVNodeWithArgsTransform : 0;
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
  if (!type || type === NULL_DYNAMIC_COMPONENT) {
    if ( true && !type) {
      warn$1(`Invalid vnode type when creating vnode: ${type}.`);
    }
    type = Comment;
  }
  if (isVNode(type)) {
    const cloned = cloneVNode(
      type,
      props,
      true
      /* mergeRef: true */
    );
    if (children) {
      normalizeChildren(cloned, children);
    }
    if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
      if (cloned.shapeFlag & 6) {
        currentBlock[currentBlock.indexOf(type)] = cloned;
      } else {
        currentBlock.push(cloned);
      }
    }
    cloned.patchFlag = -2;
    return cloned;
  }
  if (isClassComponent(type)) {
    type = type.__vccOpts;
  }
  if (props) {
    props = guardReactiveProps(props);
    let { class: klass, style } = props;
    if (klass && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(klass)) {
      props.class = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)(klass);
    }
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(style)) {
      if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(style) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(style)) {
        style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, style);
      }
      props.style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)(style);
    }
  }
  const shapeFlag = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(type) ? 4 : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(type) ? 2 : 0;
  if ( true && shapeFlag & 4 && (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(type)) {
    type = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(type);
    warn$1(
      `Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
      `
Component that was made reactive: `,
      type
    );
  }
  return createBaseVNode(
    type,
    props,
    children,
    patchFlag,
    dynamicProps,
    shapeFlag,
    isBlockNode,
    true
  );
}
function guardReactiveProps(props) {
  if (!props) return null;
  return (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isProxy)(props) || isInternalObject(props) ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, props) : props;
}
function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
  const { props, ref, patchFlag, children, transition } = vnode;
  const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
  const cloned = {
    __v_isVNode: true,
    __v_skip: true,
    type: vnode.type,
    props: mergedProps,
    key: mergedProps && normalizeKey(mergedProps),
    ref: extraProps && extraProps.ref ? (
      // #2078 in the case of <component :is="vnode" ref="extra"/>
      // if the vnode itself already has a ref, cloneVNode will need to merge
      // the refs so the single vnode can be set on multiple refs
      mergeRef && ref ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
    ) : ref,
    scopeId: vnode.scopeId,
    slotScopeIds: vnode.slotScopeIds,
    children:  true && patchFlag === -1 && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(children) ? children.map(deepCloneVNode) : children,
    target: vnode.target,
    targetStart: vnode.targetStart,
    targetAnchor: vnode.targetAnchor,
    staticCount: vnode.staticCount,
    shapeFlag: vnode.shapeFlag,
    // if the vnode is cloned with extra props, we can no longer assume its
    // existing patch flag to be reliable and need to add the FULL_PROPS flag.
    // note: preserve flag for fragments since they use the flag for children
    // fast paths only.
    patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
    dynamicProps: vnode.dynamicProps,
    dynamicChildren: vnode.dynamicChildren,
    appContext: vnode.appContext,
    dirs: vnode.dirs,
    transition,
    // These should technically only be non-null on mounted VNodes. However,
    // they *should* be copied for kept-alive vnodes. So we just always copy
    // them since them being non-null during a mount doesn't affect the logic as
    // they will simply be overwritten.
    component: vnode.component,
    suspense: vnode.suspense,
    ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
    ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
    el: vnode.el,
    anchor: vnode.anchor,
    ctx: vnode.ctx,
    ce: vnode.ce
  };
  if (transition && cloneTransition) {
    setTransitionHooks(
      cloned,
      transition.clone(cloned)
    );
  }
  return cloned;
}
function deepCloneVNode(vnode) {
  const cloned = cloneVNode(vnode);
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(vnode.children)) {
    cloned.children = vnode.children.map(deepCloneVNode);
  }
  return cloned;
}
function createTextVNode(text = " ", flag = 0) {
  return createVNode(Text, null, text, flag);
}
function createStaticVNode(content, numberOfNodes) {
  const vnode = createVNode(Static, null, content);
  vnode.staticCount = numberOfNodes;
  return vnode;
}
function createCommentVNode(text = "", asBlock = false) {
  return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
}
function normalizeVNode(child) {
  if (child == null || typeof child === "boolean") {
    return createVNode(Comment);
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(child)) {
    return createVNode(
      Fragment,
      null,
      // #3666, avoid reference pollution when reusing vnode
      child.slice()
    );
  } else if (typeof child === "object") {
    return cloneIfMounted(child);
  } else {
    return createVNode(Text, null, String(child));
  }
}
function cloneIfMounted(child) {
  return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
}
function normalizeChildren(vnode, children) {
  let type = 0;
  const { shapeFlag } = vnode;
  if (children == null) {
    children = null;
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(children)) {
    type = 16;
  } else if (typeof children === "object") {
    if (shapeFlag & (1 | 64)) {
      const slot = children.default;
      if (slot) {
        slot._c && (slot._d = false);
        normalizeChildren(vnode, slot());
        slot._c && (slot._d = true);
      }
      return;
    } else {
      type = 32;
      const slotFlag = children._;
      if (!slotFlag && !isInternalObject(children)) {
        children._ctx = currentRenderingInstance;
      } else if (slotFlag === 3 && currentRenderingInstance) {
        if (currentRenderingInstance.slots._ === 1) {
          children._ = 1;
        } else {
          children._ = 2;
          vnode.patchFlag |= 1024;
        }
      }
    }
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(children)) {
    children = { default: children, _ctx: currentRenderingInstance };
    type = 32;
  } else {
    children = String(children);
    if (shapeFlag & 64) {
      type = 16;
      children = [createTextVNode(children)];
    } else {
      type = 8;
    }
  }
  vnode.children = children;
  vnode.shapeFlag |= type;
}
function mergeProps(...args) {
  const ret = {};
  for (let i = 0; i < args.length; i++) {
    const toMerge = args[i];
    for (const key in toMerge) {
      if (key === "class") {
        if (ret.class !== toMerge.class) {
          ret.class = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeClass)([ret.class, toMerge.class]);
        }
      } else if (key === "style") {
        ret.style = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.normalizeStyle)([ret.style, toMerge.style]);
      } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) {
        const existing = ret[key];
        const incoming = toMerge[key];
        if (incoming && existing !== incoming && !((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(existing) && existing.includes(incoming))) {
          ret[key] = existing ? [].concat(existing, incoming) : incoming;
        }
      } else if (key !== "") {
        ret[key] = toMerge[key];
      }
    }
  }
  return ret;
}
function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
  callWithAsyncErrorHandling(hook, instance, 7, [
    vnode,
    prevVNode
  ]);
}

const emptyAppContext = createAppContext();
let uid = 0;
function createComponentInstance(vnode, parent, suspense) {
  const type = vnode.type;
  const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
  const instance = {
    uid: uid++,
    vnode,
    type,
    parent,
    appContext,
    root: null,
    // to be immediately set
    next: null,
    subTree: null,
    // will be set synchronously right after creation
    effect: null,
    update: null,
    // will be set synchronously right after creation
    scope: new _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.EffectScope(
      true
      /* detached */
    ),
    render: null,
    proxy: null,
    exposed: null,
    exposeProxy: null,
    withProxy: null,
    provides: parent ? parent.provides : Object.create(appContext.provides),
    accessCache: null,
    renderCache: [],
    // local resolved assets
    components: null,
    directives: null,
    // resolved props and emits options
    propsOptions: normalizePropsOptions(type, appContext),
    emitsOptions: normalizeEmitsOptions(type, appContext),
    // emit
    emit: null,
    // to be set immediately
    emitted: null,
    // props default value
    propsDefaults: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    // inheritAttrs
    inheritAttrs: type.inheritAttrs,
    // state
    ctx: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    data: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    props: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    attrs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    slots: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    refs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    setupState: _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ,
    setupContext: null,
    // suspense related
    suspense,
    suspenseId: suspense ? suspense.pendingId : 0,
    asyncDep: null,
    asyncResolved: false,
    // lifecycle hooks
    // not using enums here because it results in computed properties
    isMounted: false,
    isUnmounted: false,
    isDeactivated: false,
    bc: null,
    c: null,
    bm: null,
    m: null,
    bu: null,
    u: null,
    um: null,
    bum: null,
    da: null,
    a: null,
    rtg: null,
    rtc: null,
    ec: null,
    sp: null
  };
  if (true) {
    instance.ctx = createDevRenderContext(instance);
  } else {}
  instance.root = parent ? parent.root : instance;
  instance.emit = emit.bind(null, instance);
  if (vnode.ce) {
    vnode.ce(instance);
  }
  return instance;
}
let currentInstance = null;
const getCurrentInstance = () => currentInstance || currentRenderingInstance;
let internalSetCurrentInstance;
let setInSSRSetupState;
{
  const g = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.getGlobalThis)();
  const registerGlobalSetter = (key, setter) => {
    let setters;
    if (!(setters = g[key])) setters = g[key] = [];
    setters.push(setter);
    return (v) => {
      if (setters.length > 1) setters.forEach((set) => set(v));
      else setters[0](v);
    };
  };
  internalSetCurrentInstance = registerGlobalSetter(
    `__VUE_INSTANCE_SETTERS__`,
    (v) => currentInstance = v
  );
  setInSSRSetupState = registerGlobalSetter(
    `__VUE_SSR_SETTERS__`,
    (v) => isInSSRComponentSetup = v
  );
}
const setCurrentInstance = (instance) => {
  const prev = currentInstance;
  internalSetCurrentInstance(instance);
  instance.scope.on();
  return () => {
    instance.scope.off();
    internalSetCurrentInstance(prev);
  };
};
const unsetCurrentInstance = () => {
  currentInstance && currentInstance.scope.off();
  internalSetCurrentInstance(null);
};
const isBuiltInTag = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.makeMap)("slot,component");
function validateComponentName(name, { isNativeTag }) {
  if (isBuiltInTag(name) || isNativeTag(name)) {
    warn$1(
      "Do not use built-in or reserved HTML elements as component id: " + name
    );
  }
}
function isStatefulComponent(instance) {
  return instance.vnode.shapeFlag & 4;
}
let isInSSRComponentSetup = false;
function setupComponent(instance, isSSR = false, optimized = false) {
  isSSR && setInSSRSetupState(isSSR);
  const { props, children } = instance.vnode;
  const isStateful = isStatefulComponent(instance);
  initProps(instance, props, isStateful, isSSR);
  initSlots(instance, children, optimized);
  const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
  isSSR && setInSSRSetupState(false);
  return setupResult;
}
function setupStatefulComponent(instance, isSSR) {
  var _a;
  const Component = instance.type;
  if (true) {
    if (Component.name) {
      validateComponentName(Component.name, instance.appContext.config);
    }
    if (Component.components) {
      const names = Object.keys(Component.components);
      for (let i = 0; i < names.length; i++) {
        validateComponentName(names[i], instance.appContext.config);
      }
    }
    if (Component.directives) {
      const names = Object.keys(Component.directives);
      for (let i = 0; i < names.length; i++) {
        validateDirectiveName(names[i]);
      }
    }
    if (Component.compilerOptions && isRuntimeOnly()) {
      warn$1(
        `"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.`
      );
    }
  }
  instance.accessCache = /* @__PURE__ */ Object.create(null);
  instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
  if (true) {
    exposePropsOnRenderContext(instance);
  }
  const { setup } = Component;
  if (setup) {
    const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
    const reset = setCurrentInstance(instance);
    (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)();
    const setupResult = callWithErrorHandling(
      setup,
      instance,
      0,
      [
         true ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly)(instance.props) : 0,
        setupContext
      ]
    );
    (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)();
    reset();
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isPromise)(setupResult)) {
      setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
      if (isSSR) {
        return setupResult.then((resolvedResult) => {
          handleSetupResult(instance, resolvedResult, isSSR);
        }).catch((e) => {
          handleError(e, instance, 0);
        });
      } else {
        instance.asyncDep = setupResult;
        if ( true && !instance.suspense) {
          const name = (_a = Component.name) != null ? _a : "Anonymous";
          warn$1(
            `Component <${name}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`
          );
        }
      }
    } else {
      handleSetupResult(instance, setupResult, isSSR);
    }
  } else {
    finishComponentSetup(instance, isSSR);
  }
}
function handleSetupResult(instance, setupResult, isSSR) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(setupResult)) {
    if (instance.type.__ssrInlineRender) {
      instance.ssrRender = setupResult;
    } else {
      instance.render = setupResult;
    }
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(setupResult)) {
    if ( true && isVNode(setupResult)) {
      warn$1(
        `setup() should not return VNodes directly - return a render function instead.`
      );
    }
    if (true) {
      instance.devtoolsRawSetupState = setupResult;
    }
    instance.setupState = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs)(setupResult);
    if (true) {
      exposeSetupStateOnRenderContext(instance);
    }
  } else if ( true && setupResult !== void 0) {
    warn$1(
      `setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`
    );
  }
  finishComponentSetup(instance, isSSR);
}
let compile;
let installWithProxy;
function registerRuntimeCompiler(_compile) {
  compile = _compile;
  installWithProxy = (i) => {
    if (i.render._rc) {
      i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
    }
  };
}
const isRuntimeOnly = () => !compile;
function finishComponentSetup(instance, isSSR, skipOptions) {
  const Component = instance.type;
  if (!instance.render) {
    if (!isSSR && compile && !Component.render) {
      const template = Component.template || resolveMergedOptions(instance).template;
      if (template) {
        if (true) {
          startMeasure(instance, `compile`);
        }
        const { isCustomElement, compilerOptions } = instance.appContext.config;
        const { delimiters, compilerOptions: componentCompilerOptions } = Component;
        const finalCompilerOptions = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(
          (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(
            {
              isCustomElement,
              delimiters
            },
            compilerOptions
          ),
          componentCompilerOptions
        );
        Component.render = compile(template, finalCompilerOptions);
        if (true) {
          endMeasure(instance, `compile`);
        }
      }
    }
    instance.render = Component.render || _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP;
    if (installWithProxy) {
      installWithProxy(instance);
    }
  }
  if (__VUE_OPTIONS_API__ && true) {
    const reset = setCurrentInstance(instance);
    (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.pauseTracking)();
    try {
      applyOptions(instance);
    } finally {
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.resetTracking)();
      reset();
    }
  }
  if ( true && !Component.render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP && !isSSR) {
    if (!compile && Component.template) {
      warn$1(
        `Component provided template option but runtime compilation is not supported in this build of Vue.` + (` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` )
      );
    } else {
      warn$1(`Component is missing template or render function: `, Component);
    }
  }
}
const attrsProxyHandlers =  true ? {
  get(target, key) {
    markAttrsAccessed();
    (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(target, "get", "");
    return target[key];
  },
  set() {
    warn$1(`setupContext.attrs is readonly.`);
    return false;
  },
  deleteProperty() {
    warn$1(`setupContext.attrs is readonly.`);
    return false;
  }
} : 0;
function getSlotsProxy(instance) {
  return new Proxy(instance.slots, {
    get(target, key) {
      (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.track)(instance, "get", "$slots");
      return target[key];
    }
  });
}
function createSetupContext(instance) {
  const expose = (exposed) => {
    if (true) {
      if (instance.exposed) {
        warn$1(`expose() should be called only once per setup().`);
      }
      if (exposed != null) {
        let exposedType = typeof exposed;
        if (exposedType === "object") {
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(exposed)) {
            exposedType = "array";
          } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(exposed)) {
            exposedType = "ref";
          }
        }
        if (exposedType !== "object") {
          warn$1(
            `expose() should be passed a plain object, received ${exposedType}.`
          );
        }
      }
    }
    instance.exposed = exposed || {};
  };
  if (true) {
    let attrsProxy;
    let slotsProxy;
    return Object.freeze({
      get attrs() {
        return attrsProxy || (attrsProxy = new Proxy(instance.attrs, attrsProxyHandlers));
      },
      get slots() {
        return slotsProxy || (slotsProxy = getSlotsProxy(instance));
      },
      get emit() {
        return (event, ...args) => instance.emit(event, ...args);
      },
      expose
    });
  } else {}
}
function getComponentPublicInstance(instance) {
  if (instance.exposed) {
    return instance.exposeProxy || (instance.exposeProxy = new Proxy((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.proxyRefs)((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.markRaw)(instance.exposed)), {
      get(target, key) {
        if (key in target) {
          return target[key];
        } else if (key in publicPropertiesMap) {
          return publicPropertiesMap[key](instance);
        }
      },
      has(target, key) {
        return key in target || key in publicPropertiesMap;
      }
    }));
  } else {
    return instance.proxy;
  }
}
const classifyRE = /(?:^|[-_])(\w)/g;
const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
function getComponentName(Component, includeInferred = true) {
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
}
function formatComponentName(instance, Component, isRoot = false) {
  let name = getComponentName(Component);
  if (!name && Component.__file) {
    const match = Component.__file.match(/([^/\\]+)\.\w+$/);
    if (match) {
      name = match[1];
    }
  }
  if (!name && instance && instance.parent) {
    const inferFromRegistry = (registry) => {
      for (const key in registry) {
        if (registry[key] === Component) {
          return key;
        }
      }
    };
    name = inferFromRegistry(
      instance.components || instance.parent.type.components
    ) || inferFromRegistry(instance.appContext.components);
  }
  return name ? classify(name) : isRoot ? `App` : `Anonymous`;
}
function isClassComponent(value) {
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value) && "__vccOpts" in value;
}

const computed = (getterOrOptions, debugOptions) => {
  const c = (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.computed)(getterOrOptions, debugOptions, isInSSRComponentSetup);
  if (true) {
    const i = getCurrentInstance();
    if (i && i.appContext.config.warnRecursiveComputed) {
      c._warnRecursive = true;
    }
  }
  return c;
};

function h(type, propsOrChildren, children) {
  const l = arguments.length;
  if (l === 2) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(propsOrChildren) && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(propsOrChildren)) {
      if (isVNode(propsOrChildren)) {
        return createVNode(type, null, [propsOrChildren]);
      }
      return createVNode(type, propsOrChildren);
    } else {
      return createVNode(type, null, propsOrChildren);
    }
  } else {
    if (l > 3) {
      children = Array.prototype.slice.call(arguments, 2);
    } else if (l === 3 && isVNode(children)) {
      children = [children];
    }
    return createVNode(type, propsOrChildren, children);
  }
}

function initCustomFormatter() {
  if ( false || typeof window === "undefined") {
    return;
  }
  const vueStyle = { style: "color:#3ba776" };
  const numberStyle = { style: "color:#1677ff" };
  const stringStyle = { style: "color:#f5222d" };
  const keywordStyle = { style: "color:#eb2f96" };
  const formatter = {
    __vue_custom_formatter: true,
    header(obj) {
      if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(obj)) {
        return null;
      }
      if (obj.__isVue) {
        return ["div", vueStyle, `VueInstance`];
      } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isRef)(obj)) {
        return [
          "div",
          {},
          ["span", vueStyle, genRefFlag(obj)],
          "<",
          formatValue(obj.value),
          `>`
        ];
      } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReactive)(obj)) {
        return [
          "div",
          {},
          ["span", vueStyle, (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(obj) ? "ShallowReactive" : "Reactive"],
          "<",
          formatValue(obj),
          `>${(0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly)(obj) ? ` (readonly)` : ``}`
        ];
      } else if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isReadonly)(obj)) {
        return [
          "div",
          {},
          ["span", vueStyle, (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(obj) ? "ShallowReadonly" : "Readonly"],
          "<",
          formatValue(obj),
          ">"
        ];
      }
      return null;
    },
    hasBody(obj) {
      return obj && obj.__isVue;
    },
    body(obj) {
      if (obj && obj.__isVue) {
        return [
          "div",
          {},
          ...formatInstance(obj.$)
        ];
      }
    }
  };
  function formatInstance(instance) {
    const blocks = [];
    if (instance.type.props && instance.props) {
      blocks.push(createInstanceBlock("props", (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(instance.props)));
    }
    if (instance.setupState !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) {
      blocks.push(createInstanceBlock("setup", instance.setupState));
    }
    if (instance.data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ) {
      blocks.push(createInstanceBlock("data", (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(instance.data)));
    }
    const computed = extractKeys(instance, "computed");
    if (computed) {
      blocks.push(createInstanceBlock("computed", computed));
    }
    const injected = extractKeys(instance, "inject");
    if (injected) {
      blocks.push(createInstanceBlock("injected", injected));
    }
    blocks.push([
      "div",
      {},
      [
        "span",
        {
          style: keywordStyle.style + ";opacity:0.66"
        },
        "$ (internal): "
      ],
      ["object", { object: instance }]
    ]);
    return blocks;
  }
  function createInstanceBlock(type, target) {
    target = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, target);
    if (!Object.keys(target).length) {
      return ["span", {}];
    }
    return [
      "div",
      { style: "line-height:1.25em;margin-bottom:0.6em" },
      [
        "div",
        {
          style: "color:#476582"
        },
        type
      ],
      [
        "div",
        {
          style: "padding-left:1.25em"
        },
        ...Object.keys(target).map((key) => {
          return [
            "div",
            {},
            ["span", keywordStyle, key + ": "],
            formatValue(target[key], false)
          ];
        })
      ]
    ];
  }
  function formatValue(v, asRaw = true) {
    if (typeof v === "number") {
      return ["span", numberStyle, v];
    } else if (typeof v === "string") {
      return ["span", stringStyle, JSON.stringify(v)];
    } else if (typeof v === "boolean") {
      return ["span", keywordStyle, v];
    } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(v)) {
      return ["object", { object: asRaw ? (0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.toRaw)(v) : v }];
    } else {
      return ["span", stringStyle, String(v)];
    }
  }
  function extractKeys(instance, type) {
    const Comp = instance.type;
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(Comp)) {
      return;
    }
    const extracted = {};
    for (const key in instance.ctx) {
      if (isKeyOfType(Comp, key, type)) {
        extracted[key] = instance.ctx[key];
      }
    }
    return extracted;
  }
  function isKeyOfType(Comp, key, type) {
    const opts = Comp[type];
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(opts) && opts.includes(key) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(opts) && key in opts) {
      return true;
    }
    if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
      return true;
    }
    if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
      return true;
    }
  }
  function genRefFlag(v) {
    if ((0,_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__.isShallow)(v)) {
      return `ShallowRef`;
    }
    if (v.effect) {
      return `ComputedRef`;
    }
    return `Ref`;
  }
  if (window.devtoolsFormatters) {
    window.devtoolsFormatters.push(formatter);
  } else {
    window.devtoolsFormatters = [formatter];
  }
}

function withMemo(memo, render, cache, index) {
  const cached = cache[index];
  if (cached && isMemoSame(cached, memo)) {
    return cached;
  }
  const ret = render();
  ret.memo = memo.slice();
  ret.cacheIndex = index;
  return cache[index] = ret;
}
function isMemoSame(cached, memo) {
  const prev = cached.memo;
  if (prev.length != memo.length) {
    return false;
  }
  for (let i = 0; i < prev.length; i++) {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hasChanged)(prev[i], memo[i])) {
      return false;
    }
  }
  if (isBlockTreeEnabled > 0 && currentBlock) {
    currentBlock.push(cached);
  }
  return true;
}

const version = "3.4.38";
const warn =  true ? warn$1 : 0;
const ErrorTypeStrings = ErrorTypeStrings$1 ;
const devtools =  true ? devtools$1 : 0;
const setDevtoolsHook =  true ? setDevtoolsHook$1 : 0;
const _ssrUtils = {
  createComponentInstance,
  setupComponent,
  renderComponentRoot,
  setCurrentRenderingInstance,
  isVNode: isVNode,
  normalizeVNode,
  getComponentPublicInstance,
  ensureValidVNode
};
const ssrUtils = _ssrUtils ;
const resolveFilter = null;
const compatUtils = null;
const DeprecationTypes = null;




/***/ }),

/***/ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js":
/*!***********************************************************************!*\
  !*** ./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js ***!
  \***********************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   BaseTransition: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransition),
/* harmony export */   BaseTransitionPropsValidators: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransitionPropsValidators),
/* harmony export */   Comment: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Comment),
/* harmony export */   DeprecationTypes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.DeprecationTypes),
/* harmony export */   EffectScope: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.EffectScope),
/* harmony export */   ErrorCodes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes),
/* harmony export */   ErrorTypeStrings: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ErrorTypeStrings),
/* harmony export */   Fragment: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment),
/* harmony export */   KeepAlive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.KeepAlive),
/* harmony export */   ReactiveEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect),
/* harmony export */   Static: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Static),
/* harmony export */   Suspense: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Suspense),
/* harmony export */   Teleport: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Teleport),
/* harmony export */   Text: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Text),
/* harmony export */   TrackOpTypes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.TrackOpTypes),
/* harmony export */   Transition: () => (/* binding */ Transition),
/* harmony export */   TransitionGroup: () => (/* binding */ TransitionGroup),
/* harmony export */   TriggerOpTypes: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.TriggerOpTypes),
/* harmony export */   VueElement: () => (/* binding */ VueElement),
/* harmony export */   assertNumber: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.assertNumber),
/* harmony export */   callWithAsyncErrorHandling: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling),
/* harmony export */   callWithErrorHandling: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling),
/* harmony export */   camelize: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.camelize),
/* harmony export */   capitalize: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.capitalize),
/* harmony export */   cloneVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.cloneVNode),
/* harmony export */   compatUtils: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.compatUtils),
/* harmony export */   computed: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.computed),
/* harmony export */   createApp: () => (/* binding */ createApp),
/* harmony export */   createBlock: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createBlock),
/* harmony export */   createCommentVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode),
/* harmony export */   createElementBlock: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createElementBlock),
/* harmony export */   createElementVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createElementVNode),
/* harmony export */   createHydrationRenderer: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer),
/* harmony export */   createPropsRestProxy: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy),
/* harmony export */   createRenderer: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createRenderer),
/* harmony export */   createSSRApp: () => (/* binding */ createSSRApp),
/* harmony export */   createSlots: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createSlots),
/* harmony export */   createStaticVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode),
/* harmony export */   createTextVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createTextVNode),
/* harmony export */   createVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode),
/* harmony export */   customRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.customRef),
/* harmony export */   defineAsyncComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent),
/* harmony export */   defineComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineComponent),
/* harmony export */   defineCustomElement: () => (/* binding */ defineCustomElement),
/* harmony export */   defineEmits: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineEmits),
/* harmony export */   defineExpose: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineExpose),
/* harmony export */   defineModel: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineModel),
/* harmony export */   defineOptions: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineOptions),
/* harmony export */   defineProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineProps),
/* harmony export */   defineSSRCustomElement: () => (/* binding */ defineSSRCustomElement),
/* harmony export */   defineSlots: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineSlots),
/* harmony export */   devtools: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.devtools),
/* harmony export */   effect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.effect),
/* harmony export */   effectScope: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.effectScope),
/* harmony export */   getCurrentInstance: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance),
/* harmony export */   getCurrentScope: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope),
/* harmony export */   getTransitionRawChildren: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren),
/* harmony export */   guardReactiveProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps),
/* harmony export */   h: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.h),
/* harmony export */   handleError: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.handleError),
/* harmony export */   hasInjectionContext: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext),
/* harmony export */   hydrate: () => (/* binding */ hydrate),
/* harmony export */   initCustomFormatter: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter),
/* harmony export */   initDirectivesForSSR: () => (/* binding */ initDirectivesForSSR),
/* harmony export */   inject: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.inject),
/* harmony export */   isMemoSame: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isMemoSame),
/* harmony export */   isProxy: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isProxy),
/* harmony export */   isReactive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isReactive),
/* harmony export */   isReadonly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isReadonly),
/* harmony export */   isRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRef),
/* harmony export */   isRuntimeOnly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly),
/* harmony export */   isShallow: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isShallow),
/* harmony export */   isVNode: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isVNode),
/* harmony export */   markRaw: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.markRaw),
/* harmony export */   mergeDefaults: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults),
/* harmony export */   mergeModels: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeModels),
/* harmony export */   mergeProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.mergeProps),
/* harmony export */   nextTick: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick),
/* harmony export */   normalizeClass: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeClass),
/* harmony export */   normalizeProps: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeProps),
/* harmony export */   normalizeStyle: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle),
/* harmony export */   onActivated: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onActivated),
/* harmony export */   onBeforeMount: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount),
/* harmony export */   onBeforeUnmount: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount),
/* harmony export */   onBeforeUpdate: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate),
/* harmony export */   onDeactivated: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onDeactivated),
/* harmony export */   onErrorCaptured: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured),
/* harmony export */   onMounted: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onMounted),
/* harmony export */   onRenderTracked: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked),
/* harmony export */   onRenderTriggered: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered),
/* harmony export */   onScopeDispose: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose),
/* harmony export */   onServerPrefetch: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch),
/* harmony export */   onUnmounted: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUnmounted),
/* harmony export */   onUpdated: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUpdated),
/* harmony export */   openBlock: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.openBlock),
/* harmony export */   popScopeId: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.popScopeId),
/* harmony export */   provide: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.provide),
/* harmony export */   proxyRefs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.proxyRefs),
/* harmony export */   pushScopeId: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.pushScopeId),
/* harmony export */   queuePostFlushCb: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb),
/* harmony export */   reactive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.reactive),
/* harmony export */   readonly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.readonly),
/* harmony export */   ref: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ref),
/* harmony export */   registerRuntimeCompiler: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler),
/* harmony export */   render: () => (/* binding */ render),
/* harmony export */   renderList: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.renderList),
/* harmony export */   renderSlot: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.renderSlot),
/* harmony export */   resolveComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveComponent),
/* harmony export */   resolveDirective: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveDirective),
/* harmony export */   resolveDynamicComponent: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent),
/* harmony export */   resolveFilter: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveFilter),
/* harmony export */   resolveTransitionHooks: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks),
/* harmony export */   setBlockTracking: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking),
/* harmony export */   setDevtoolsHook: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook),
/* harmony export */   setTransitionHooks: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks),
/* harmony export */   shallowReactive: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowReactive),
/* harmony export */   shallowReadonly: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly),
/* harmony export */   shallowRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.shallowRef),
/* harmony export */   ssrContextKey: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey),
/* harmony export */   ssrUtils: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.ssrUtils),
/* harmony export */   stop: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.stop),
/* harmony export */   toDisplayString: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toDisplayString),
/* harmony export */   toHandlerKey: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey),
/* harmony export */   toHandlers: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toHandlers),
/* harmony export */   toRaw: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRaw),
/* harmony export */   toRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRef),
/* harmony export */   toRefs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toRefs),
/* harmony export */   toValue: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.toValue),
/* harmony export */   transformVNodeArgs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs),
/* harmony export */   triggerRef: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.triggerRef),
/* harmony export */   unref: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.unref),
/* harmony export */   useAttrs: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useAttrs),
/* harmony export */   useCssModule: () => (/* binding */ useCssModule),
/* harmony export */   useCssVars: () => (/* binding */ useCssVars),
/* harmony export */   useModel: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useModel),
/* harmony export */   useSSRContext: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useSSRContext),
/* harmony export */   useSlots: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useSlots),
/* harmony export */   useTransitionState: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useTransitionState),
/* harmony export */   vModelCheckbox: () => (/* binding */ vModelCheckbox),
/* harmony export */   vModelDynamic: () => (/* binding */ vModelDynamic),
/* harmony export */   vModelRadio: () => (/* binding */ vModelRadio),
/* harmony export */   vModelSelect: () => (/* binding */ vModelSelect),
/* harmony export */   vModelText: () => (/* binding */ vModelText),
/* harmony export */   vShow: () => (/* binding */ vShow),
/* harmony export */   version: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.version),
/* harmony export */   warn: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn),
/* harmony export */   watch: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watch),
/* harmony export */   watchEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchEffect),
/* harmony export */   watchPostEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect),
/* harmony export */   watchSyncEffect: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect),
/* harmony export */   withAsyncContext: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext),
/* harmony export */   withCtx: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withCtx),
/* harmony export */   withDefaults: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withDefaults),
/* harmony export */   withDirectives: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withDirectives),
/* harmony export */   withKeys: () => (/* binding */ withKeys),
/* harmony export */   withMemo: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withMemo),
/* harmony export */   withModifiers: () => (/* binding */ withModifiers),
/* harmony export */   withScopeId: () => (/* reexport safe */ _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.withScopeId)
/* harmony export */ });
/* harmony import */ var _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/runtime-core */ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js");
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
/* harmony import */ var _vue_runtime_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @vue/runtime-core */ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js");
/**
* @vue/runtime-dom v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/




const svgNS = "http://www.w3.org/2000/svg";
const mathmlNS = "http://www.w3.org/1998/Math/MathML";
const doc = typeof document !== "undefined" ? document : null;
const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
const nodeOps = {
  insert: (child, parent, anchor) => {
    parent.insertBefore(child, anchor || null);
  },
  remove: (child) => {
    const parent = child.parentNode;
    if (parent) {
      parent.removeChild(child);
    }
  },
  createElement: (tag, namespace, is, props) => {
    const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
    if (tag === "select" && props && props.multiple != null) {
      el.setAttribute("multiple", props.multiple);
    }
    return el;
  },
  createText: (text) => doc.createTextNode(text),
  createComment: (text) => doc.createComment(text),
  setText: (node, text) => {
    node.nodeValue = text;
  },
  setElementText: (el, text) => {
    el.textContent = text;
  },
  parentNode: (node) => node.parentNode,
  nextSibling: (node) => node.nextSibling,
  querySelector: (selector) => doc.querySelector(selector),
  setScopeId(el, id) {
    el.setAttribute(id, "");
  },
  // __UNSAFE__
  // Reason: innerHTML.
  // Static content here can only come from compiled templates.
  // As long as the user only uses trusted templates, this is safe.
  insertStaticContent(content, parent, anchor, namespace, start, end) {
    const before = anchor ? anchor.previousSibling : parent.lastChild;
    if (start && (start === end || start.nextSibling)) {
      while (true) {
        parent.insertBefore(start.cloneNode(true), anchor);
        if (start === end || !(start = start.nextSibling)) break;
      }
    } else {
      templateContainer.innerHTML = namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content;
      const template = templateContainer.content;
      if (namespace === "svg" || namespace === "mathml") {
        const wrapper = template.firstChild;
        while (wrapper.firstChild) {
          template.appendChild(wrapper.firstChild);
        }
        template.removeChild(wrapper);
      }
      parent.insertBefore(template, anchor);
    }
    return [
      // first
      before ? before.nextSibling : parent.firstChild,
      // last
      anchor ? anchor.previousSibling : parent.lastChild
    ];
  }
};

const TRANSITION = "transition";
const ANIMATION = "animation";
const vtcKey = Symbol("_vtc");
const Transition = (props, { slots }) => (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.h)(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransition, resolveTransitionProps(props), slots);
Transition.displayName = "Transition";
const DOMTransitionPropsValidators = {
  name: String,
  type: String,
  css: {
    type: Boolean,
    default: true
  },
  duration: [String, Number, Object],
  enterFromClass: String,
  enterActiveClass: String,
  enterToClass: String,
  appearFromClass: String,
  appearActiveClass: String,
  appearToClass: String,
  leaveFromClass: String,
  leaveActiveClass: String,
  leaveToClass: String
};
const TransitionPropsValidators = Transition.props = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(
  {},
  _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.BaseTransitionPropsValidators,
  DOMTransitionPropsValidators
);
const callHook = (hook, args = []) => {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook)) {
    hook.forEach((h2) => h2(...args));
  } else if (hook) {
    hook(...args);
  }
};
const hasExplicitCallback = (hook) => {
  return hook ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
};
function resolveTransitionProps(rawProps) {
  const baseProps = {};
  for (const key in rawProps) {
    if (!(key in DOMTransitionPropsValidators)) {
      baseProps[key] = rawProps[key];
    }
  }
  if (rawProps.css === false) {
    return baseProps;
  }
  const {
    name = "v",
    type,
    duration,
    enterFromClass = `${name}-enter-from`,
    enterActiveClass = `${name}-enter-active`,
    enterToClass = `${name}-enter-to`,
    appearFromClass = enterFromClass,
    appearActiveClass = enterActiveClass,
    appearToClass = enterToClass,
    leaveFromClass = `${name}-leave-from`,
    leaveActiveClass = `${name}-leave-active`,
    leaveToClass = `${name}-leave-to`
  } = rawProps;
  const durations = normalizeDuration(duration);
  const enterDuration = durations && durations[0];
  const leaveDuration = durations && durations[1];
  const {
    onBeforeEnter,
    onEnter,
    onEnterCancelled,
    onLeave,
    onLeaveCancelled,
    onBeforeAppear = onBeforeEnter,
    onAppear = onEnter,
    onAppearCancelled = onEnterCancelled
  } = baseProps;
  const finishEnter = (el, isAppear, done) => {
    removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
    removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
    done && done();
  };
  const finishLeave = (el, done) => {
    el._isLeaving = false;
    removeTransitionClass(el, leaveFromClass);
    removeTransitionClass(el, leaveToClass);
    removeTransitionClass(el, leaveActiveClass);
    done && done();
  };
  const makeEnterHook = (isAppear) => {
    return (el, done) => {
      const hook = isAppear ? onAppear : onEnter;
      const resolve = () => finishEnter(el, isAppear, done);
      callHook(hook, [el, resolve]);
      nextFrame(() => {
        removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
        addTransitionClass(el, isAppear ? appearToClass : enterToClass);
        if (!hasExplicitCallback(hook)) {
          whenTransitionEnds(el, type, enterDuration, resolve);
        }
      });
    };
  };
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)(baseProps, {
    onBeforeEnter(el) {
      callHook(onBeforeEnter, [el]);
      addTransitionClass(el, enterFromClass);
      addTransitionClass(el, enterActiveClass);
    },
    onBeforeAppear(el) {
      callHook(onBeforeAppear, [el]);
      addTransitionClass(el, appearFromClass);
      addTransitionClass(el, appearActiveClass);
    },
    onEnter: makeEnterHook(false),
    onAppear: makeEnterHook(true),
    onLeave(el, done) {
      el._isLeaving = true;
      const resolve = () => finishLeave(el, done);
      addTransitionClass(el, leaveFromClass);
      addTransitionClass(el, leaveActiveClass);
      forceReflow();
      nextFrame(() => {
        if (!el._isLeaving) {
          return;
        }
        removeTransitionClass(el, leaveFromClass);
        addTransitionClass(el, leaveToClass);
        if (!hasExplicitCallback(onLeave)) {
          whenTransitionEnds(el, type, leaveDuration, resolve);
        }
      });
      callHook(onLeave, [el, resolve]);
    },
    onEnterCancelled(el) {
      finishEnter(el, false);
      callHook(onEnterCancelled, [el]);
    },
    onAppearCancelled(el) {
      finishEnter(el, true);
      callHook(onAppearCancelled, [el]);
    },
    onLeaveCancelled(el) {
      finishLeave(el);
      callHook(onLeaveCancelled, [el]);
    }
  });
}
function normalizeDuration(duration) {
  if (duration == null) {
    return null;
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isObject)(duration)) {
    return [NumberOf(duration.enter), NumberOf(duration.leave)];
  } else {
    const n = NumberOf(duration);
    return [n, n];
  }
}
function NumberOf(val) {
  const res = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(val);
  if (true) {
    (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.assertNumber)(res, "<transition> explicit duration");
  }
  return res;
}
function addTransitionClass(el, cls) {
  cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
  (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
}
function removeTransitionClass(el, cls) {
  cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
  const _vtc = el[vtcKey];
  if (_vtc) {
    _vtc.delete(cls);
    if (!_vtc.size) {
      el[vtcKey] = void 0;
    }
  }
}
function nextFrame(cb) {
  requestAnimationFrame(() => {
    requestAnimationFrame(cb);
  });
}
let endId = 0;
function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
  const id = el._endId = ++endId;
  const resolveIfNotStale = () => {
    if (id === el._endId) {
      resolve();
    }
  };
  if (explicitTimeout) {
    return setTimeout(resolveIfNotStale, explicitTimeout);
  }
  const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
  if (!type) {
    return resolve();
  }
  const endEvent = type + "end";
  let ended = 0;
  const end = () => {
    el.removeEventListener(endEvent, onEnd);
    resolveIfNotStale();
  };
  const onEnd = (e) => {
    if (e.target === el && ++ended >= propCount) {
      end();
    }
  };
  setTimeout(() => {
    if (ended < propCount) {
      end();
    }
  }, timeout + 1);
  el.addEventListener(endEvent, onEnd);
}
function getTransitionInfo(el, expectedType) {
  const styles = window.getComputedStyle(el);
  const getStyleProperties = (key) => (styles[key] || "").split(", ");
  const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
  const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
  const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
  const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
  const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
  const animationTimeout = getTimeout(animationDelays, animationDurations);
  let type = null;
  let timeout = 0;
  let propCount = 0;
  if (expectedType === TRANSITION) {
    if (transitionTimeout > 0) {
      type = TRANSITION;
      timeout = transitionTimeout;
      propCount = transitionDurations.length;
    }
  } else if (expectedType === ANIMATION) {
    if (animationTimeout > 0) {
      type = ANIMATION;
      timeout = animationTimeout;
      propCount = animationDurations.length;
    }
  } else {
    timeout = Math.max(transitionTimeout, animationTimeout);
    type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
    propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
  }
  const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
    getStyleProperties(`${TRANSITION}Property`).toString()
  );
  return {
    type,
    timeout,
    propCount,
    hasTransform
  };
}
function getTimeout(delays, durations) {
  while (delays.length < durations.length) {
    delays = delays.concat(delays);
  }
  return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
}
function toMs(s) {
  if (s === "auto") return 0;
  return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
}
function forceReflow() {
  return document.body.offsetHeight;
}

function patchClass(el, value, isSVG) {
  const transitionClasses = el[vtcKey];
  if (transitionClasses) {
    value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
  }
  if (value == null) {
    el.removeAttribute("class");
  } else if (isSVG) {
    el.setAttribute("class", value);
  } else {
    el.className = value;
  }
}

const vShowOriginalDisplay = Symbol("_vod");
const vShowHidden = Symbol("_vsh");
const vShow = {
  beforeMount(el, { value }, { transition }) {
    el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
    if (transition && value) {
      transition.beforeEnter(el);
    } else {
      setDisplay(el, value);
    }
  },
  mounted(el, { value }, { transition }) {
    if (transition && value) {
      transition.enter(el);
    }
  },
  updated(el, { value, oldValue }, { transition }) {
    if (!value === !oldValue) return;
    if (transition) {
      if (value) {
        transition.beforeEnter(el);
        setDisplay(el, true);
        transition.enter(el);
      } else {
        transition.leave(el, () => {
          setDisplay(el, false);
        });
      }
    } else {
      setDisplay(el, value);
    }
  },
  beforeUnmount(el, { value }) {
    setDisplay(el, value);
  }
};
if (true) {
  vShow.name = "show";
}
function setDisplay(el, value) {
  el.style.display = value ? el[vShowOriginalDisplay] : "none";
  el[vShowHidden] = !value;
}
function initVShowForSSR() {
  vShow.getSSRProps = ({ value }) => {
    if (!value) {
      return { style: { display: "none" } };
    }
  };
}

const CSS_VAR_TEXT = Symbol( true ? "CSS_VAR_TEXT" : 0);
function useCssVars(getter) {
  const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)();
  if (!instance) {
     true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`useCssVars is called without current active component instance.`);
    return;
  }
  const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
    Array.from(
      document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
    ).forEach((node) => setVarsOnNode(node, vars));
  };
  if (true) {
    instance.getCssVars = () => getter(instance.proxy);
  }
  const setVars = () => {
    const vars = getter(instance.proxy);
    setVarsOnVNode(instance.subTree, vars);
    updateTeleports(vars);
  };
  (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount)(() => {
    (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect)(setVars);
  });
  (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
    const ob = new MutationObserver(setVars);
    ob.observe(instance.subTree.el.parentNode, { childList: true });
    (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => ob.disconnect());
  });
}
function setVarsOnVNode(vnode, vars) {
  if (vnode.shapeFlag & 128) {
    const suspense = vnode.suspense;
    vnode = suspense.activeBranch;
    if (suspense.pendingBranch && !suspense.isHydrating) {
      suspense.effects.push(() => {
        setVarsOnVNode(suspense.activeBranch, vars);
      });
    }
  }
  while (vnode.component) {
    vnode = vnode.component.subTree;
  }
  if (vnode.shapeFlag & 1 && vnode.el) {
    setVarsOnNode(vnode.el, vars);
  } else if (vnode.type === _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment) {
    vnode.children.forEach((c) => setVarsOnVNode(c, vars));
  } else if (vnode.type === _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Static) {
    let { el, anchor } = vnode;
    while (el) {
      setVarsOnNode(el, vars);
      if (el === anchor) break;
      el = el.nextSibling;
    }
  }
}
function setVarsOnNode(el, vars) {
  if (el.nodeType === 1) {
    const style = el.style;
    let cssText = "";
    for (const key in vars) {
      style.setProperty(`--${key}`, vars[key]);
      cssText += `--${key}: ${vars[key]};`;
    }
    style[CSS_VAR_TEXT] = cssText;
  }
}

const displayRE = /(^|;)\s*display\s*:/;
function patchStyle(el, prev, next) {
  const style = el.style;
  const isCssString = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(next);
  let hasControlledDisplay = false;
  if (next && !isCssString) {
    if (prev) {
      if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(prev)) {
        for (const key in prev) {
          if (next[key] == null) {
            setStyle(style, key, "");
          }
        }
      } else {
        for (const prevStyle of prev.split(";")) {
          const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim();
          if (next[key] == null) {
            setStyle(style, key, "");
          }
        }
      }
    }
    for (const key in next) {
      if (key === "display") {
        hasControlledDisplay = true;
      }
      setStyle(style, key, next[key]);
    }
  } else {
    if (isCssString) {
      if (prev !== next) {
        const cssVarText = style[CSS_VAR_TEXT];
        if (cssVarText) {
          next += ";" + cssVarText;
        }
        style.cssText = next;
        hasControlledDisplay = displayRE.test(next);
      }
    } else if (prev) {
      el.removeAttribute("style");
    }
  }
  if (vShowOriginalDisplay in el) {
    el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
    if (el[vShowHidden]) {
      style.display = "none";
    }
  }
}
const semicolonRE = /[^\\];\s*$/;
const importantRE = /\s*!important$/;
function setStyle(style, name, val) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(val)) {
    val.forEach((v) => setStyle(style, name, v));
  } else {
    if (val == null) val = "";
    if (true) {
      if (semicolonRE.test(val)) {
        (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
          `Unexpected semicolon at the end of '${name}' style value: '${val}'`
        );
      }
    }
    if (name.startsWith("--")) {
      style.setProperty(name, val);
    } else {
      const prefixed = autoPrefix(style, name);
      if (importantRE.test(val)) {
        style.setProperty(
          (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(prefixed),
          val.replace(importantRE, ""),
          "important"
        );
      } else {
        style[prefixed] = val;
      }
    }
  }
}
const prefixes = ["Webkit", "Moz", "ms"];
const prefixCache = {};
function autoPrefix(style, rawName) {
  const cached = prefixCache[rawName];
  if (cached) {
    return cached;
  }
  let name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(rawName);
  if (name !== "filter" && name in style) {
    return prefixCache[rawName] = name;
  }
  name = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.capitalize)(name);
  for (let i = 0; i < prefixes.length; i++) {
    const prefixed = prefixes[i] + name;
    if (prefixed in style) {
      return prefixCache[rawName] = prefixed;
    }
  }
  return rawName;
}

const xlinkNS = "http://www.w3.org/1999/xlink";
function patchAttr(el, key, value, isSVG, instance, isBoolean = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSpecialBooleanAttr)(key)) {
  if (isSVG && key.startsWith("xlink:")) {
    if (value == null) {
      el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
    } else {
      el.setAttributeNS(xlinkNS, key, value);
    }
  } else {
    if (value == null || isBoolean && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(value)) {
      el.removeAttribute(key);
    } else {
      el.setAttribute(
        key,
        isBoolean ? "" : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSymbol)(value) ? String(value) : value
      );
    }
  }
}

function patchDOMProp(el, key, value, parentComponent) {
  if (key === "innerHTML" || key === "textContent") {
    if (value == null) return;
    el[key] = value;
    return;
  }
  const tag = el.tagName;
  if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
  !tag.includes("-")) {
    const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
    const newValue = value == null ? "" : String(value);
    if (oldValue !== newValue || !("_value" in el)) {
      el.value = newValue;
    }
    if (value == null) {
      el.removeAttribute(key);
    }
    el._value = value;
    return;
  }
  let needRemove = false;
  if (value === "" || value == null) {
    const type = typeof el[key];
    if (type === "boolean") {
      value = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.includeBooleanAttr)(value);
    } else if (value == null && type === "string") {
      value = "";
      needRemove = true;
    } else if (type === "number") {
      value = 0;
      needRemove = true;
    }
  }
  try {
    el[key] = value;
  } catch (e) {
    if ( true && !needRemove) {
      (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
        `Failed setting prop "${key}" on <${tag.toLowerCase()}>: value ${value} is invalid.`,
        e
      );
    }
  }
  needRemove && el.removeAttribute(key);
}

function addEventListener(el, event, handler, options) {
  el.addEventListener(event, handler, options);
}
function removeEventListener(el, event, handler, options) {
  el.removeEventListener(event, handler, options);
}
const veiKey = Symbol("_vei");
function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
  const invokers = el[veiKey] || (el[veiKey] = {});
  const existingInvoker = invokers[rawName];
  if (nextValue && existingInvoker) {
    existingInvoker.value =  true ? sanitizeEventValue(nextValue, rawName) : 0;
  } else {
    const [name, options] = parseName(rawName);
    if (nextValue) {
      const invoker = invokers[rawName] = createInvoker(
         true ? sanitizeEventValue(nextValue, rawName) : 0,
        instance
      );
      addEventListener(el, name, invoker, options);
    } else if (existingInvoker) {
      removeEventListener(el, name, existingInvoker, options);
      invokers[rawName] = void 0;
    }
  }
}
const optionsModifierRE = /(?:Once|Passive|Capture)$/;
function parseName(name) {
  let options;
  if (optionsModifierRE.test(name)) {
    options = {};
    let m;
    while (m = name.match(optionsModifierRE)) {
      name = name.slice(0, name.length - m[0].length);
      options[m[0].toLowerCase()] = true;
    }
  }
  const event = name[2] === ":" ? name.slice(3) : (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(name.slice(2));
  return [event, options];
}
let cachedNow = 0;
const p = /* @__PURE__ */ Promise.resolve();
const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
function createInvoker(initialValue, instance) {
  const invoker = (e) => {
    if (!e._vts) {
      e._vts = Date.now();
    } else if (e._vts <= invoker.attached) {
      return;
    }
    (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling)(
      patchStopImmediatePropagation(e, invoker.value),
      instance,
      5,
      [e]
    );
  };
  invoker.value = initialValue;
  invoker.attached = getNow();
  return invoker;
}
function sanitizeEventValue(value, propName) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) {
    return value;
  }
  (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
    `Wrong type passed as event handler to ${propName} - did you forget @ or : in front of your prop?
Expected function or array of functions, received type ${typeof value}.`
  );
  return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.NOOP;
}
function patchStopImmediatePropagation(e, value) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) {
    const originalStop = e.stopImmediatePropagation;
    e.stopImmediatePropagation = () => {
      originalStop.call(e);
      e._stopped = true;
    };
    return value.map(
      (fn) => (e2) => !e2._stopped && fn && fn(e2)
    );
  } else {
    return value;
  }
}

const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // lowercase letter
key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
  const isSVG = namespace === "svg";
  if (key === "class") {
    patchClass(el, nextValue, isSVG);
  } else if (key === "style") {
    patchStyle(el, prevValue, nextValue);
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isOn)(key)) {
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isModelListener)(key)) {
      patchEvent(el, key, prevValue, nextValue, parentComponent);
    }
  } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
    patchDOMProp(el, key, nextValue);
    if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) {
      patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
    }
  } else {
    if (key === "true-value") {
      el._trueValue = nextValue;
    } else if (key === "false-value") {
      el._falseValue = nextValue;
    }
    patchAttr(el, key, nextValue, isSVG);
  }
};
function shouldSetAsProp(el, key, value, isSVG) {
  if (isSVG) {
    if (key === "innerHTML" || key === "textContent") {
      return true;
    }
    if (key in el && isNativeOn(key) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(value)) {
      return true;
    }
    return false;
  }
  if (key === "spellcheck" || key === "draggable" || key === "translate") {
    return false;
  }
  if (key === "form") {
    return false;
  }
  if (key === "list" && el.tagName === "INPUT") {
    return false;
  }
  if (key === "type" && el.tagName === "TEXTAREA") {
    return false;
  }
  if (key === "width" || key === "height") {
    const tag = el.tagName;
    if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") {
      return false;
    }
  }
  if (isNativeOn(key) && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(value)) {
    return false;
  }
  return key in el;
}

/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineCustomElement(options, extraOptions, hydrate2) {
  const Comp = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.defineComponent)(options, extraOptions);
  class VueCustomElement extends VueElement {
    constructor(initialProps) {
      super(Comp, initialProps, hydrate2);
    }
  }
  VueCustomElement.def = Comp;
  return VueCustomElement;
}
/*! #__NO_SIDE_EFFECTS__ */
const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
  return /* @__PURE__ */ defineCustomElement(options, extraOptions, hydrate);
};
const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
};
class VueElement extends BaseClass {
  constructor(_def, _props = {}, hydrate2) {
    super();
    this._def = _def;
    this._props = _props;
    /**
     * @internal
     */
    this._instance = null;
    this._connected = false;
    this._resolved = false;
    this._numberProps = null;
    this._ob = null;
    if (this.shadowRoot && hydrate2) {
      hydrate2(this._createVNode(), this.shadowRoot);
    } else {
      if ( true && this.shadowRoot) {
        (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
          `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.`
        );
      }
      this.attachShadow({ mode: "open" });
      if (!this._def.__asyncLoader) {
        this._resolveProps(this._def);
      }
    }
  }
  connectedCallback() {
    this._connected = true;
    if (!this._instance) {
      if (this._resolved) {
        this._update();
      } else {
        this._resolveDef();
      }
    }
  }
  disconnectedCallback() {
    this._connected = false;
    (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
      if (!this._connected) {
        if (this._ob) {
          this._ob.disconnect();
          this._ob = null;
        }
        render(null, this.shadowRoot);
        this._instance = null;
      }
    });
  }
  /**
   * resolve inner component definition (handle possible async component)
   */
  _resolveDef() {
    this._resolved = true;
    for (let i = 0; i < this.attributes.length; i++) {
      this._setAttr(this.attributes[i].name);
    }
    this._ob = new MutationObserver((mutations) => {
      for (const m of mutations) {
        this._setAttr(m.attributeName);
      }
    });
    this._ob.observe(this, { attributes: true });
    const resolve = (def, isAsync = false) => {
      const { props, styles } = def;
      let numberProps;
      if (props && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props)) {
        for (const key in props) {
          const opt = props[key];
          if (opt === Number || opt && opt.type === Number) {
            if (key in this._props) {
              this._props[key] = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(this._props[key]);
            }
            (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key)] = true;
          }
        }
      }
      this._numberProps = numberProps;
      if (isAsync) {
        this._resolveProps(def);
      }
      this._applyStyles(styles);
      this._update();
    };
    const asyncDef = this._def.__asyncLoader;
    if (asyncDef) {
      asyncDef().then((def) => resolve(def, true));
    } else {
      resolve(this._def);
    }
  }
  _resolveProps(def) {
    const { props } = def;
    const declaredPropKeys = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(props) ? props : Object.keys(props || {});
    for (const key of Object.keys(this)) {
      if (key[0] !== "_" && declaredPropKeys.includes(key)) {
        this._setProp(key, this[key], true, false);
      }
    }
    for (const key of declaredPropKeys.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)) {
      Object.defineProperty(this, key, {
        get() {
          return this._getProp(key);
        },
        set(val) {
          this._setProp(key, val);
        }
      });
    }
  }
  _setAttr(key) {
    let value = this.hasAttribute(key) ? this.getAttribute(key) : void 0;
    const camelKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.camelize)(key);
    if (this._numberProps && this._numberProps[camelKey]) {
      value = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.toNumber)(value);
    }
    this._setProp(camelKey, value, false);
  }
  /**
   * @internal
   */
  _getProp(key) {
    return this._props[key];
  }
  /**
   * @internal
   */
  _setProp(key, val, shouldReflect = true, shouldUpdate = true) {
    if (val !== this._props[key]) {
      this._props[key] = val;
      if (shouldUpdate && this._instance) {
        this._update();
      }
      if (shouldReflect) {
        if (val === true) {
          this.setAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key), "");
        } else if (typeof val === "string" || typeof val === "number") {
          this.setAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key), val + "");
        } else if (!val) {
          this.removeAttribute((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(key));
        }
      }
    }
  }
  _update() {
    render(this._createVNode(), this.shadowRoot);
  }
  _createVNode() {
    const vnode = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode)(this._def, (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, this._props));
    if (!this._instance) {
      vnode.ce = (instance) => {
        this._instance = instance;
        instance.isCE = true;
        if (true) {
          instance.ceReload = (newStyles) => {
            if (this._styles) {
              this._styles.forEach((s) => this.shadowRoot.removeChild(s));
              this._styles.length = 0;
            }
            this._applyStyles(newStyles);
            this._instance = null;
            this._update();
          };
        }
        const dispatch = (event, args) => {
          this.dispatchEvent(
            new CustomEvent(event, {
              detail: args
            })
          );
        };
        instance.emit = (event, ...args) => {
          dispatch(event, args);
          if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event) !== event) {
            dispatch((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event), args);
          }
        };
        let parent = this;
        while (parent = parent && (parent.parentNode || parent.host)) {
          if (parent instanceof VueElement) {
            instance.parent = parent._instance;
            instance.provides = parent._instance.provides;
            break;
          }
        }
      };
    }
    return vnode;
  }
  _applyStyles(styles) {
    if (styles) {
      styles.forEach((css) => {
        const s = document.createElement("style");
        s.textContent = css;
        this.shadowRoot.appendChild(s);
        if (true) {
          (this._styles || (this._styles = [])).push(s);
        }
      });
    }
  }
}

function useCssModule(name = "$style") {
  {
    const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)();
    if (!instance) {
       true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`useCssModule must be called inside setup()`);
      return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
    }
    const modules = instance.type.__cssModules;
    if (!modules) {
       true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Current instance does not have CSS modules injected.`);
      return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
    }
    const mod = modules[name];
    if (!mod) {
       true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`Current instance does not have CSS module named "${name}".`);
      return _vue_shared__WEBPACK_IMPORTED_MODULE_1__.EMPTY_OBJ;
    }
    return mod;
  }
}

const positionMap = /* @__PURE__ */ new WeakMap();
const newPositionMap = /* @__PURE__ */ new WeakMap();
const moveCbKey = Symbol("_moveCb");
const enterCbKey = Symbol("_enterCb");
const TransitionGroupImpl = {
  name: "TransitionGroup",
  props: /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({}, TransitionPropsValidators, {
    tag: String,
    moveClass: String
  }),
  setup(props, { slots }) {
    const instance = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)();
    const state = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.useTransitionState)();
    let prevChildren;
    let children;
    (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.onUpdated)(() => {
      if (!prevChildren.length) {
        return;
      }
      const moveClass = props.moveClass || `${props.name || "v"}-move`;
      if (!hasCSSTransform(
        prevChildren[0].el,
        instance.vnode.el,
        moveClass
      )) {
        return;
      }
      prevChildren.forEach(callPendingCbs);
      prevChildren.forEach(recordPosition);
      const movedChildren = prevChildren.filter(applyTranslation);
      forceReflow();
      movedChildren.forEach((c) => {
        const el = c.el;
        const style = el.style;
        addTransitionClass(el, moveClass);
        style.transform = style.webkitTransform = style.transitionDuration = "";
        const cb = el[moveCbKey] = (e) => {
          if (e && e.target !== el) {
            return;
          }
          if (!e || /transform$/.test(e.propertyName)) {
            el.removeEventListener("transitionend", cb);
            el[moveCbKey] = null;
            removeTransitionClass(el, moveClass);
          }
        };
        el.addEventListener("transitionend", cb);
      });
    });
    return () => {
      const rawProps = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_2__.toRaw)(props);
      const cssTransitionProps = resolveTransitionProps(rawProps);
      let tag = rawProps.tag || _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.Fragment;
      prevChildren = [];
      if (children) {
        for (let i = 0; i < children.length; i++) {
          const child = children[i];
          if (child.el && child.el instanceof Element) {
            prevChildren.push(child);
            (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks)(
              child,
              (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks)(
                child,
                cssTransitionProps,
                state,
                instance
              )
            );
            positionMap.set(
              child,
              child.el.getBoundingClientRect()
            );
          }
        }
      }
      children = slots.default ? (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren)(slots.default()) : [];
      for (let i = 0; i < children.length; i++) {
        const child = children[i];
        if (child.key != null) {
          (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks)(
            child,
            (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks)(child, cssTransitionProps, state, instance)
          );
        } else if (true) {
          (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(`<TransitionGroup> children must be keyed.`);
        }
      }
      return (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createVNode)(tag, null, children);
    };
  }
};
const removeMode = (props) => delete props.mode;
/* @__PURE__ */ removeMode(TransitionGroupImpl.props);
const TransitionGroup = TransitionGroupImpl;
function callPendingCbs(c) {
  const el = c.el;
  if (el[moveCbKey]) {
    el[moveCbKey]();
  }
  if (el[enterCbKey]) {
    el[enterCbKey]();
  }
}
function recordPosition(c) {
  newPositionMap.set(c, c.el.getBoundingClientRect());
}
function applyTranslation(c) {
  const oldPos = positionMap.get(c);
  const newPos = newPositionMap.get(c);
  const dx = oldPos.left - newPos.left;
  const dy = oldPos.top - newPos.top;
  if (dx || dy) {
    const s = c.el.style;
    s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
    s.transitionDuration = "0s";
    return c;
  }
}
function hasCSSTransform(el, root, moveClass) {
  const clone = el.cloneNode();
  const _vtc = el[vtcKey];
  if (_vtc) {
    _vtc.forEach((cls) => {
      cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
    });
  }
  moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
  clone.style.display = "none";
  const container = root.nodeType === 1 ? root : root.parentNode;
  container.appendChild(clone);
  const { hasTransform } = getTransitionInfo(clone);
  container.removeChild(clone);
  return hasTransform;
}

const getModelAssigner = (vnode) => {
  const fn = vnode.props["onUpdate:modelValue"] || false;
  return (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(fn) ? (value) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.invokeArrayFns)(fn, value) : fn;
};
function onCompositionStart(e) {
  e.target.composing = true;
}
function onCompositionEnd(e) {
  const target = e.target;
  if (target.composing) {
    target.composing = false;
    target.dispatchEvent(new Event("input"));
  }
}
const assignKey = Symbol("_assign");
const vModelText = {
  created(el, { modifiers: { lazy, trim, number } }, vnode) {
    el[assignKey] = getModelAssigner(vnode);
    const castToNumber = number || vnode.props && vnode.props.type === "number";
    addEventListener(el, lazy ? "change" : "input", (e) => {
      if (e.target.composing) return;
      let domValue = el.value;
      if (trim) {
        domValue = domValue.trim();
      }
      if (castToNumber) {
        domValue = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber)(domValue);
      }
      el[assignKey](domValue);
    });
    if (trim) {
      addEventListener(el, "change", () => {
        el.value = el.value.trim();
      });
    }
    if (!lazy) {
      addEventListener(el, "compositionstart", onCompositionStart);
      addEventListener(el, "compositionend", onCompositionEnd);
      addEventListener(el, "change", onCompositionEnd);
    }
  },
  // set value on mounted so it's after min/max for type="range"
  mounted(el, { value }) {
    el.value = value == null ? "" : value;
  },
  beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
    el[assignKey] = getModelAssigner(vnode);
    if (el.composing) return;
    const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber)(el.value) : el.value;
    const newValue = value == null ? "" : value;
    if (elValue === newValue) {
      return;
    }
    if (document.activeElement === el && el.type !== "range") {
      if (lazy && value === oldValue) {
        return;
      }
      if (trim && el.value.trim() === newValue) {
        return;
      }
    }
    el.value = newValue;
  }
};
const vModelCheckbox = {
  // #4096 array checkboxes need to be deep traversed
  deep: true,
  created(el, _, vnode) {
    el[assignKey] = getModelAssigner(vnode);
    addEventListener(el, "change", () => {
      const modelValue = el._modelValue;
      const elementValue = getValue(el);
      const checked = el.checked;
      const assign = el[assignKey];
      if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(modelValue)) {
        const index = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(modelValue, elementValue);
        const found = index !== -1;
        if (checked && !found) {
          assign(modelValue.concat(elementValue));
        } else if (!checked && found) {
          const filtered = [...modelValue];
          filtered.splice(index, 1);
          assign(filtered);
        }
      } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(modelValue)) {
        const cloned = new Set(modelValue);
        if (checked) {
          cloned.add(elementValue);
        } else {
          cloned.delete(elementValue);
        }
        assign(cloned);
      } else {
        assign(getCheckboxValue(el, checked));
      }
    });
  },
  // set initial checked on mount to wait for true-value/false-value
  mounted: setChecked,
  beforeUpdate(el, binding, vnode) {
    el[assignKey] = getModelAssigner(vnode);
    setChecked(el, binding, vnode);
  }
};
function setChecked(el, { value, oldValue }, vnode) {
  el._modelValue = value;
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) {
    el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, vnode.props.value) > -1;
  } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) {
    el.checked = value.has(vnode.props.value);
  } else if (value !== oldValue) {
    el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, getCheckboxValue(el, true));
  }
}
const vModelRadio = {
  created(el, { value }, vnode) {
    el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, vnode.props.value);
    el[assignKey] = getModelAssigner(vnode);
    addEventListener(el, "change", () => {
      el[assignKey](getValue(el));
    });
  },
  beforeUpdate(el, { value, oldValue }, vnode) {
    el[assignKey] = getModelAssigner(vnode);
    if (value !== oldValue) {
      el.checked = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(value, vnode.props.value);
    }
  }
};
const vModelSelect = {
  // <select multiple> value need to be deep traversed
  deep: true,
  created(el, { value, modifiers: { number } }, vnode) {
    const isSetModel = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value);
    addEventListener(el, "change", () => {
      const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
        (o) => number ? (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseToNumber)(getValue(o)) : getValue(o)
      );
      el[assignKey](
        el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
      );
      el._assigning = true;
      (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        el._assigning = false;
      });
    });
    el[assignKey] = getModelAssigner(vnode);
  },
  // set value in mounted & updated because <select> relies on its children
  // <option>s.
  mounted(el, { value, modifiers: { number } }) {
    setSelected(el, value);
  },
  beforeUpdate(el, _binding, vnode) {
    el[assignKey] = getModelAssigner(vnode);
  },
  updated(el, { value, modifiers: { number } }) {
    if (!el._assigning) {
      setSelected(el, value);
    }
  }
};
function setSelected(el, value, number) {
  const isMultiple = el.multiple;
  const isArrayValue = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value);
  if (isMultiple && !isArrayValue && !(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) {
     true && (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
      `<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString.call(value).slice(8, -1)}.`
    );
    return;
  }
  for (let i = 0, l = el.options.length; i < l; i++) {
    const option = el.options[i];
    const optionValue = getValue(option);
    if (isMultiple) {
      if (isArrayValue) {
        const optionType = typeof optionValue;
        if (optionType === "string" || optionType === "number") {
          option.selected = value.some((v) => String(v) === String(optionValue));
        } else {
          option.selected = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, optionValue) > -1;
        }
      } else {
        option.selected = value.has(optionValue);
      }
    } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(getValue(option), value)) {
      if (el.selectedIndex !== i) el.selectedIndex = i;
      return;
    }
  }
  if (!isMultiple && el.selectedIndex !== -1) {
    el.selectedIndex = -1;
  }
}
function getValue(el) {
  return "_value" in el ? el._value : el.value;
}
function getCheckboxValue(el, checked) {
  const key = checked ? "_trueValue" : "_falseValue";
  return key in el ? el[key] : checked;
}
const vModelDynamic = {
  created(el, binding, vnode) {
    callModelHook(el, binding, vnode, null, "created");
  },
  mounted(el, binding, vnode) {
    callModelHook(el, binding, vnode, null, "mounted");
  },
  beforeUpdate(el, binding, vnode, prevVNode) {
    callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
  },
  updated(el, binding, vnode, prevVNode) {
    callModelHook(el, binding, vnode, prevVNode, "updated");
  }
};
function resolveDynamicModel(tagName, type) {
  switch (tagName) {
    case "SELECT":
      return vModelSelect;
    case "TEXTAREA":
      return vModelText;
    default:
      switch (type) {
        case "checkbox":
          return vModelCheckbox;
        case "radio":
          return vModelRadio;
        default:
          return vModelText;
      }
  }
}
function callModelHook(el, binding, vnode, prevVNode, hook) {
  const modelToUse = resolveDynamicModel(
    el.tagName,
    vnode.props && vnode.props.type
  );
  const fn = modelToUse[hook];
  fn && fn(el, binding, vnode, prevVNode);
}
function initVModelForSSR() {
  vModelText.getSSRProps = ({ value }) => ({ value });
  vModelRadio.getSSRProps = ({ value }, vnode) => {
    if (vnode.props && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseEqual)(vnode.props.value, value)) {
      return { checked: true };
    }
  };
  vModelCheckbox.getSSRProps = ({ value }, vnode) => {
    if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isArray)(value)) {
      if (vnode.props && (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.looseIndexOf)(value, vnode.props.value) > -1) {
        return { checked: true };
      }
    } else if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSet)(value)) {
      if (vnode.props && value.has(vnode.props.value)) {
        return { checked: true };
      }
    } else if (value) {
      return { checked: true };
    }
  };
  vModelDynamic.getSSRProps = (binding, vnode) => {
    if (typeof vnode.type !== "string") {
      return;
    }
    const modelToUse = resolveDynamicModel(
      // resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
      vnode.type.toUpperCase(),
      vnode.props && vnode.props.type
    );
    if (modelToUse.getSSRProps) {
      return modelToUse.getSSRProps(binding, vnode);
    }
  };
}

const systemModifiers = ["ctrl", "shift", "alt", "meta"];
const modifierGuards = {
  stop: (e) => e.stopPropagation(),
  prevent: (e) => e.preventDefault(),
  self: (e) => e.target !== e.currentTarget,
  ctrl: (e) => !e.ctrlKey,
  shift: (e) => !e.shiftKey,
  alt: (e) => !e.altKey,
  meta: (e) => !e.metaKey,
  left: (e) => "button" in e && e.button !== 0,
  middle: (e) => "button" in e && e.button !== 1,
  right: (e) => "button" in e && e.button !== 2,
  exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
};
const withModifiers = (fn, modifiers) => {
  const cache = fn._withMods || (fn._withMods = {});
  const cacheKey = modifiers.join(".");
  return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => {
    for (let i = 0; i < modifiers.length; i++) {
      const guard = modifierGuards[modifiers[i]];
      if (guard && guard(event, modifiers)) return;
    }
    return fn(event, ...args);
  });
};
const keyNames = {
  esc: "escape",
  space: " ",
  up: "arrow-up",
  left: "arrow-left",
  right: "arrow-right",
  down: "arrow-down",
  delete: "backspace"
};
const withKeys = (fn, modifiers) => {
  const cache = fn._withKeys || (fn._withKeys = {});
  const cacheKey = modifiers.join(".");
  return cache[cacheKey] || (cache[cacheKey] = (event) => {
    if (!("key" in event)) {
      return;
    }
    const eventKey = (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.hyphenate)(event.key);
    if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) {
      return fn(event);
    }
  });
};

const rendererOptions = /* @__PURE__ */ (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.extend)({ patchProp }, nodeOps);
let renderer;
let enabledHydration = false;
function ensureRenderer() {
  return renderer || (renderer = (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createRenderer)(rendererOptions));
}
function ensureHydrationRenderer() {
  renderer = enabledHydration ? renderer : (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer)(rendererOptions);
  enabledHydration = true;
  return renderer;
}
const render = (...args) => {
  ensureRenderer().render(...args);
};
const hydrate = (...args) => {
  ensureHydrationRenderer().hydrate(...args);
};
const createApp = (...args) => {
  const app = ensureRenderer().createApp(...args);
  if (true) {
    injectNativeTagCheck(app);
    injectCompilerOptionsCheck(app);
  }
  const { mount } = app;
  app.mount = (containerOrSelector) => {
    const container = normalizeContainer(containerOrSelector);
    if (!container) return;
    const component = app._component;
    if (!(0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isFunction)(component) && !component.render && !component.template) {
      component.template = container.innerHTML;
    }
    container.innerHTML = "";
    const proxy = mount(container, false, resolveRootNamespace(container));
    if (container instanceof Element) {
      container.removeAttribute("v-cloak");
      container.setAttribute("data-v-app", "");
    }
    return proxy;
  };
  return app;
};
const createSSRApp = (...args) => {
  const app = ensureHydrationRenderer().createApp(...args);
  if (true) {
    injectNativeTagCheck(app);
    injectCompilerOptionsCheck(app);
  }
  const { mount } = app;
  app.mount = (containerOrSelector) => {
    const container = normalizeContainer(containerOrSelector);
    if (container) {
      return mount(container, true, resolveRootNamespace(container));
    }
  };
  return app;
};
function resolveRootNamespace(container) {
  if (container instanceof SVGElement) {
    return "svg";
  }
  if (typeof MathMLElement === "function" && container instanceof MathMLElement) {
    return "mathml";
  }
}
function injectNativeTagCheck(app) {
  Object.defineProperty(app.config, "isNativeTag", {
    value: (tag) => (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isHTMLTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isSVGTag)(tag) || (0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isMathMLTag)(tag),
    writable: false
  });
}
function injectCompilerOptionsCheck(app) {
  if ((0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly)()) {
    const isCustomElement = app.config.isCustomElement;
    Object.defineProperty(app.config, "isCustomElement", {
      get() {
        return isCustomElement;
      },
      set() {
        (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
          `The \`isCustomElement\` config option is deprecated. Use \`compilerOptions.isCustomElement\` instead.`
        );
      }
    });
    const compilerOptions = app.config.compilerOptions;
    const msg = `The \`compilerOptions\` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, \`compilerOptions\` must be passed to \`@vue/compiler-dom\` in the build setup instead.
- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option.
- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader
- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`;
    Object.defineProperty(app.config, "compilerOptions", {
      get() {
        (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(msg);
        return compilerOptions;
      },
      set() {
        (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(msg);
      }
    });
  }
}
function normalizeContainer(container) {
  if ((0,_vue_shared__WEBPACK_IMPORTED_MODULE_1__.isString)(container)) {
    const res = document.querySelector(container);
    if ( true && !res) {
      (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
        `Failed to mount app: mount target selector "${container}" returned null.`
      );
    }
    return res;
  }
  if ( true && window.ShadowRoot && container instanceof window.ShadowRoot && container.mode === "closed") {
    (0,_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__.warn)(
      `mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs`
    );
  }
  return container;
}
let ssrDirectiveInitialized = false;
const initDirectivesForSSR = () => {
  if (!ssrDirectiveInitialized) {
    ssrDirectiveInitialized = true;
    initVModelForSSR();
    initVShowForSSR();
  }
} ;




/***/ }),

/***/ "./node_modules/@vue/shared/dist/shared.esm-bundler.js":
/*!*************************************************************!*\
  !*** ./node_modules/@vue/shared/dist/shared.esm-bundler.js ***!
  \*************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   EMPTY_ARR: () => (/* binding */ EMPTY_ARR),
/* harmony export */   EMPTY_OBJ: () => (/* binding */ EMPTY_OBJ),
/* harmony export */   NO: () => (/* binding */ NO),
/* harmony export */   NOOP: () => (/* binding */ NOOP),
/* harmony export */   PatchFlagNames: () => (/* binding */ PatchFlagNames),
/* harmony export */   PatchFlags: () => (/* binding */ PatchFlags),
/* harmony export */   ShapeFlags: () => (/* binding */ ShapeFlags),
/* harmony export */   SlotFlags: () => (/* binding */ SlotFlags),
/* harmony export */   camelize: () => (/* binding */ camelize),
/* harmony export */   capitalize: () => (/* binding */ capitalize),
/* harmony export */   def: () => (/* binding */ def),
/* harmony export */   escapeHtml: () => (/* binding */ escapeHtml),
/* harmony export */   escapeHtmlComment: () => (/* binding */ escapeHtmlComment),
/* harmony export */   extend: () => (/* binding */ extend),
/* harmony export */   genPropsAccessExp: () => (/* binding */ genPropsAccessExp),
/* harmony export */   generateCodeFrame: () => (/* binding */ generateCodeFrame),
/* harmony export */   getGlobalThis: () => (/* binding */ getGlobalThis),
/* harmony export */   hasChanged: () => (/* binding */ hasChanged),
/* harmony export */   hasOwn: () => (/* binding */ hasOwn),
/* harmony export */   hyphenate: () => (/* binding */ hyphenate),
/* harmony export */   includeBooleanAttr: () => (/* binding */ includeBooleanAttr),
/* harmony export */   invokeArrayFns: () => (/* binding */ invokeArrayFns),
/* harmony export */   isArray: () => (/* binding */ isArray),
/* harmony export */   isBooleanAttr: () => (/* binding */ isBooleanAttr),
/* harmony export */   isBuiltInDirective: () => (/* binding */ isBuiltInDirective),
/* harmony export */   isDate: () => (/* binding */ isDate),
/* harmony export */   isFunction: () => (/* binding */ isFunction),
/* harmony export */   isGloballyAllowed: () => (/* binding */ isGloballyAllowed),
/* harmony export */   isGloballyWhitelisted: () => (/* binding */ isGloballyWhitelisted),
/* harmony export */   isHTMLTag: () => (/* binding */ isHTMLTag),
/* harmony export */   isIntegerKey: () => (/* binding */ isIntegerKey),
/* harmony export */   isKnownHtmlAttr: () => (/* binding */ isKnownHtmlAttr),
/* harmony export */   isKnownSvgAttr: () => (/* binding */ isKnownSvgAttr),
/* harmony export */   isMap: () => (/* binding */ isMap),
/* harmony export */   isMathMLTag: () => (/* binding */ isMathMLTag),
/* harmony export */   isModelListener: () => (/* binding */ isModelListener),
/* harmony export */   isObject: () => (/* binding */ isObject),
/* harmony export */   isOn: () => (/* binding */ isOn),
/* harmony export */   isPlainObject: () => (/* binding */ isPlainObject),
/* harmony export */   isPromise: () => (/* binding */ isPromise),
/* harmony export */   isRegExp: () => (/* binding */ isRegExp),
/* harmony export */   isRenderableAttrValue: () => (/* binding */ isRenderableAttrValue),
/* harmony export */   isReservedProp: () => (/* binding */ isReservedProp),
/* harmony export */   isSSRSafeAttrName: () => (/* binding */ isSSRSafeAttrName),
/* harmony export */   isSVGTag: () => (/* binding */ isSVGTag),
/* harmony export */   isSet: () => (/* binding */ isSet),
/* harmony export */   isSpecialBooleanAttr: () => (/* binding */ isSpecialBooleanAttr),
/* harmony export */   isString: () => (/* binding */ isString),
/* harmony export */   isSymbol: () => (/* binding */ isSymbol),
/* harmony export */   isVoidTag: () => (/* binding */ isVoidTag),
/* harmony export */   looseEqual: () => (/* binding */ looseEqual),
/* harmony export */   looseIndexOf: () => (/* binding */ looseIndexOf),
/* harmony export */   looseToNumber: () => (/* binding */ looseToNumber),
/* harmony export */   makeMap: () => (/* binding */ makeMap),
/* harmony export */   normalizeClass: () => (/* binding */ normalizeClass),
/* harmony export */   normalizeProps: () => (/* binding */ normalizeProps),
/* harmony export */   normalizeStyle: () => (/* binding */ normalizeStyle),
/* harmony export */   objectToString: () => (/* binding */ objectToString),
/* harmony export */   parseStringStyle: () => (/* binding */ parseStringStyle),
/* harmony export */   propsToAttrMap: () => (/* binding */ propsToAttrMap),
/* harmony export */   remove: () => (/* binding */ remove),
/* harmony export */   slotFlagsText: () => (/* binding */ slotFlagsText),
/* harmony export */   stringifyStyle: () => (/* binding */ stringifyStyle),
/* harmony export */   toDisplayString: () => (/* binding */ toDisplayString),
/* harmony export */   toHandlerKey: () => (/* binding */ toHandlerKey),
/* harmony export */   toNumber: () => (/* binding */ toNumber),
/* harmony export */   toRawType: () => (/* binding */ toRawType),
/* harmony export */   toTypeString: () => (/* binding */ toTypeString)
/* harmony export */ });
/**
* @vue/shared v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function makeMap(str, expectsLowerCase) {
  const set = new Set(str.split(","));
  return expectsLowerCase ? (val) => set.has(val.toLowerCase()) : (val) => set.has(val);
}

const EMPTY_OBJ =  true ? Object.freeze({}) : 0;
const EMPTY_ARR =  true ? Object.freeze([]) : 0;
const NOOP = () => {
};
const NO = () => false;
const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
const isModelListener = (key) => key.startsWith("onUpdate:");
const extend = Object.assign;
const remove = (arr, el) => {
  const i = arr.indexOf(el);
  if (i > -1) {
    arr.splice(i, 1);
  }
};
const hasOwnProperty = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
const isArray = Array.isArray;
const isMap = (val) => toTypeString(val) === "[object Map]";
const isSet = (val) => toTypeString(val) === "[object Set]";
const isDate = (val) => toTypeString(val) === "[object Date]";
const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
const isFunction = (val) => typeof val === "function";
const isString = (val) => typeof val === "string";
const isSymbol = (val) => typeof val === "symbol";
const isObject = (val) => val !== null && typeof val === "object";
const isPromise = (val) => {
  return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
};
const objectToString = Object.prototype.toString;
const toTypeString = (value) => objectToString.call(value);
const toRawType = (value) => {
  return toTypeString(value).slice(8, -1);
};
const isPlainObject = (val) => toTypeString(val) === "[object Object]";
const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
const isReservedProp = /* @__PURE__ */ makeMap(
  // the leading comma is intentional so empty string "" is also included
  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
);
const isBuiltInDirective = /* @__PURE__ */ makeMap(
  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
);
const cacheStringFunction = (fn) => {
  const cache = /* @__PURE__ */ Object.create(null);
  return (str) => {
    const hit = cache[str];
    return hit || (cache[str] = fn(str));
  };
};
const camelizeRE = /-(\w)/g;
const camelize = cacheStringFunction((str) => {
  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
});
const hyphenateRE = /\B([A-Z])/g;
const hyphenate = cacheStringFunction(
  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
);
const capitalize = cacheStringFunction((str) => {
  return str.charAt(0).toUpperCase() + str.slice(1);
});
const toHandlerKey = cacheStringFunction((str) => {
  const s = str ? `on${capitalize(str)}` : ``;
  return s;
});
const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
const invokeArrayFns = (fns, ...arg) => {
  for (let i = 0; i < fns.length; i++) {
    fns[i](...arg);
  }
};
const def = (obj, key, value, writable = false) => {
  Object.defineProperty(obj, key, {
    configurable: true,
    enumerable: false,
    writable,
    value
  });
};
const looseToNumber = (val) => {
  const n = parseFloat(val);
  return isNaN(n) ? val : n;
};
const toNumber = (val) => {
  const n = isString(val) ? Number(val) : NaN;
  return isNaN(n) ? val : n;
};
let _globalThis;
const getGlobalThis = () => {
  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : {});
};
const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
function genPropsAccessExp(name) {
  return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
}

const PatchFlags = {
  "TEXT": 1,
  "1": "TEXT",
  "CLASS": 2,
  "2": "CLASS",
  "STYLE": 4,
  "4": "STYLE",
  "PROPS": 8,
  "8": "PROPS",
  "FULL_PROPS": 16,
  "16": "FULL_PROPS",
  "NEED_HYDRATION": 32,
  "32": "NEED_HYDRATION",
  "STABLE_FRAGMENT": 64,
  "64": "STABLE_FRAGMENT",
  "KEYED_FRAGMENT": 128,
  "128": "KEYED_FRAGMENT",
  "UNKEYED_FRAGMENT": 256,
  "256": "UNKEYED_FRAGMENT",
  "NEED_PATCH": 512,
  "512": "NEED_PATCH",
  "DYNAMIC_SLOTS": 1024,
  "1024": "DYNAMIC_SLOTS",
  "DEV_ROOT_FRAGMENT": 2048,
  "2048": "DEV_ROOT_FRAGMENT",
  "HOISTED": -1,
  "-1": "HOISTED",
  "BAIL": -2,
  "-2": "BAIL"
};
const PatchFlagNames = {
  [1]: `TEXT`,
  [2]: `CLASS`,
  [4]: `STYLE`,
  [8]: `PROPS`,
  [16]: `FULL_PROPS`,
  [32]: `NEED_HYDRATION`,
  [64]: `STABLE_FRAGMENT`,
  [128]: `KEYED_FRAGMENT`,
  [256]: `UNKEYED_FRAGMENT`,
  [512]: `NEED_PATCH`,
  [1024]: `DYNAMIC_SLOTS`,
  [2048]: `DEV_ROOT_FRAGMENT`,
  [-1]: `HOISTED`,
  [-2]: `BAIL`
};

const ShapeFlags = {
  "ELEMENT": 1,
  "1": "ELEMENT",
  "FUNCTIONAL_COMPONENT": 2,
  "2": "FUNCTIONAL_COMPONENT",
  "STATEFUL_COMPONENT": 4,
  "4": "STATEFUL_COMPONENT",
  "TEXT_CHILDREN": 8,
  "8": "TEXT_CHILDREN",
  "ARRAY_CHILDREN": 16,
  "16": "ARRAY_CHILDREN",
  "SLOTS_CHILDREN": 32,
  "32": "SLOTS_CHILDREN",
  "TELEPORT": 64,
  "64": "TELEPORT",
  "SUSPENSE": 128,
  "128": "SUSPENSE",
  "COMPONENT_SHOULD_KEEP_ALIVE": 256,
  "256": "COMPONENT_SHOULD_KEEP_ALIVE",
  "COMPONENT_KEPT_ALIVE": 512,
  "512": "COMPONENT_KEPT_ALIVE",
  "COMPONENT": 6,
  "6": "COMPONENT"
};

const SlotFlags = {
  "STABLE": 1,
  "1": "STABLE",
  "DYNAMIC": 2,
  "2": "DYNAMIC",
  "FORWARDED": 3,
  "3": "FORWARDED"
};
const slotFlagsText = {
  [1]: "STABLE",
  [2]: "DYNAMIC",
  [3]: "FORWARDED"
};

const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error";
const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
const isGloballyWhitelisted = isGloballyAllowed;

const range = 2;
function generateCodeFrame(source, start = 0, end = source.length) {
  start = Math.max(0, Math.min(start, source.length));
  end = Math.max(0, Math.min(end, source.length));
  if (start > end) return "";
  let lines = source.split(/(\r?\n)/);
  const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
  lines = lines.filter((_, idx) => idx % 2 === 0);
  let count = 0;
  const res = [];
  for (let i = 0; i < lines.length; i++) {
    count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
    if (count >= start) {
      for (let j = i - range; j <= i + range || end > count; j++) {
        if (j < 0 || j >= lines.length) continue;
        const line = j + 1;
        res.push(
          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
        );
        const lineLength = lines[j].length;
        const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
        if (j === i) {
          const pad = start - (count - (lineLength + newLineSeqLength));
          const length = Math.max(
            1,
            end > count ? lineLength - pad : end - start
          );
          res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
        } else if (j > i) {
          if (end > count) {
            const length = Math.max(Math.min(end - count, lineLength), 1);
            res.push(`   |  ` + "^".repeat(length));
          }
          count += lineLength + newLineSeqLength;
        }
      }
      break;
    }
  }
  return res.join("\n");
}

function normalizeStyle(value) {
  if (isArray(value)) {
    const res = {};
    for (let i = 0; i < value.length; i++) {
      const item = value[i];
      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
      if (normalized) {
        for (const key in normalized) {
          res[key] = normalized[key];
        }
      }
    }
    return res;
  } else if (isString(value) || isObject(value)) {
    return value;
  }
}
const listDelimiterRE = /;(?![^(]*\))/g;
const propertyDelimiterRE = /:([^]+)/;
const styleCommentRE = /\/\*[^]*?\*\//g;
function parseStringStyle(cssText) {
  const ret = {};
  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
    if (item) {
      const tmp = item.split(propertyDelimiterRE);
      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
    }
  });
  return ret;
}
function stringifyStyle(styles) {
  let ret = "";
  if (!styles || isString(styles)) {
    return ret;
  }
  for (const key in styles) {
    const value = styles[key];
    if (isString(value) || typeof value === "number") {
      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
      ret += `${normalizedKey}:${value};`;
    }
  }
  return ret;
}
function normalizeClass(value) {
  let res = "";
  if (isString(value)) {
    res = value;
  } else if (isArray(value)) {
    for (let i = 0; i < value.length; i++) {
      const normalized = normalizeClass(value[i]);
      if (normalized) {
        res += normalized + " ";
      }
    }
  } else if (isObject(value)) {
    for (const name in value) {
      if (value[name]) {
        res += name + " ";
      }
    }
  }
  return res.trim();
}
function normalizeProps(props) {
  if (!props) return null;
  let { class: klass, style } = props;
  if (klass && !isString(klass)) {
    props.class = normalizeClass(klass);
  }
  if (style) {
    props.style = normalizeStyle(style);
  }
  return props;
}

const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);

const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
const isBooleanAttr = /* @__PURE__ */ makeMap(
  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
);
function includeBooleanAttr(value) {
  return !!value || value === "";
}
const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
const attrValidationCache = {};
function isSSRSafeAttrName(name) {
  if (attrValidationCache.hasOwnProperty(name)) {
    return attrValidationCache[name];
  }
  const isUnsafe = unsafeAttrCharRE.test(name);
  if (isUnsafe) {
    console.error(`unsafe attribute name: ${name}`);
  }
  return attrValidationCache[name] = !isUnsafe;
}
const propsToAttrMap = {
  acceptCharset: "accept-charset",
  className: "class",
  htmlFor: "for",
  httpEquiv: "http-equiv"
};
const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
  `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
);
const isKnownSvgAttr = /* @__PURE__ */ makeMap(
  `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
);
function isRenderableAttrValue(value) {
  if (value == null) {
    return false;
  }
  const type = typeof value;
  return type === "string" || type === "number" || type === "boolean";
}

const escapeRE = /["'&<>]/;
function escapeHtml(string) {
  const str = "" + string;
  const match = escapeRE.exec(str);
  if (!match) {
    return str;
  }
  let html = "";
  let escaped;
  let index;
  let lastIndex = 0;
  for (index = match.index; index < str.length; index++) {
    switch (str.charCodeAt(index)) {
      case 34:
        escaped = "&quot;";
        break;
      case 38:
        escaped = "&amp;";
        break;
      case 39:
        escaped = "&#39;";
        break;
      case 60:
        escaped = "&lt;";
        break;
      case 62:
        escaped = "&gt;";
        break;
      default:
        continue;
    }
    if (lastIndex !== index) {
      html += str.slice(lastIndex, index);
    }
    lastIndex = index + 1;
    html += escaped;
  }
  return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
}
const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
function escapeHtmlComment(src) {
  return src.replace(commentStripRE, "");
}

function looseCompareArrays(a, b) {
  if (a.length !== b.length) return false;
  let equal = true;
  for (let i = 0; equal && i < a.length; i++) {
    equal = looseEqual(a[i], b[i]);
  }
  return equal;
}
function looseEqual(a, b) {
  if (a === b) return true;
  let aValidType = isDate(a);
  let bValidType = isDate(b);
  if (aValidType || bValidType) {
    return aValidType && bValidType ? a.getTime() === b.getTime() : false;
  }
  aValidType = isSymbol(a);
  bValidType = isSymbol(b);
  if (aValidType || bValidType) {
    return a === b;
  }
  aValidType = isArray(a);
  bValidType = isArray(b);
  if (aValidType || bValidType) {
    return aValidType && bValidType ? looseCompareArrays(a, b) : false;
  }
  aValidType = isObject(a);
  bValidType = isObject(b);
  if (aValidType || bValidType) {
    if (!aValidType || !bValidType) {
      return false;
    }
    const aKeysCount = Object.keys(a).length;
    const bKeysCount = Object.keys(b).length;
    if (aKeysCount !== bKeysCount) {
      return false;
    }
    for (const key in a) {
      const aHasKey = a.hasOwnProperty(key);
      const bHasKey = b.hasOwnProperty(key);
      if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
        return false;
      }
    }
  }
  return String(a) === String(b);
}
function looseIndexOf(arr, val) {
  return arr.findIndex((item) => looseEqual(item, val));
}

const isRef = (val) => {
  return !!(val && val.__v_isRef === true);
};
const toDisplayString = (val) => {
  return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
};
const replacer = (_key, val) => {
  if (isRef(val)) {
    return replacer(_key, val.value);
  } else if (isMap(val)) {
    return {
      [`Map(${val.size})`]: [...val.entries()].reduce(
        (entries, [key, val2], i) => {
          entries[stringifySymbol(key, i) + " =>"] = val2;
          return entries;
        },
        {}
      )
    };
  } else if (isSet(val)) {
    return {
      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
    };
  } else if (isSymbol(val)) {
    return stringifySymbol(val);
  } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
    return String(val);
  }
  return val;
};
const stringifySymbol = (v, i = "") => {
  var _a;
  return (
    // Symbol.description in es2019+ so we need to cast here to pass
    // the lib: es2016 check
    isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
  );
};




/***/ }),

/***/ "./node_modules/vue-loader/dist/exportHelper.js":
/*!******************************************************!*\
  !*** ./node_modules/vue-loader/dist/exportHelper.js ***!
  \******************************************************/
/***/ ((__unused_webpack_module, exports) => {


Object.defineProperty(exports, "__esModule", ({ value: true }));
// runtime helper for setting properties on components
// in a tree-shakable way
exports["default"] = (sfc, props) => {
    const target = sfc.__vccOpts || sfc;
    for (const [key, val] of props) {
        target[key] = val;
    }
    return target;
};


/***/ }),

/***/ "./node_modules/vue/dist/vue.cjs.js":
/*!******************************************!*\
  !*** ./node_modules/vue/dist/vue.cjs.js ***!
  \******************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

/**
* vue v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/


Object.defineProperty(exports, "__esModule", ({ value: true }));

var compilerDom = __webpack_require__(/*! @vue/compiler-dom */ "./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js");
var runtimeDom = __webpack_require__(/*! @vue/runtime-dom */ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js");
var shared = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");

function _interopNamespaceDefault(e) {
  var n = Object.create(null);
  if (e) {
    for (var k in e) {
      n[k] = e[k];
    }
  }
  n.default = e;
  return Object.freeze(n);
}

var runtimeDom__namespace = /*#__PURE__*/_interopNamespaceDefault(runtimeDom);

const compileCache = /* @__PURE__ */ new WeakMap();
function getCache(options) {
  let c = compileCache.get(options != null ? options : shared.EMPTY_OBJ);
  if (!c) {
    c = /* @__PURE__ */ Object.create(null);
    compileCache.set(options != null ? options : shared.EMPTY_OBJ, c);
  }
  return c;
}
function compileToFunction(template, options) {
  if (!shared.isString(template)) {
    if (template.nodeType) {
      template = template.innerHTML;
    } else {
      runtimeDom.warn(`invalid template option: `, template);
      return shared.NOOP;
    }
  }
  const key = template;
  const cache = getCache(options);
  const cached = cache[key];
  if (cached) {
    return cached;
  }
  if (template[0] === "#") {
    const el = document.querySelector(template);
    if (!el) {
      runtimeDom.warn(`Template element not found or is empty: ${template}`);
    }
    template = el ? el.innerHTML : ``;
  }
  const opts = shared.extend(
    {
      hoistStatic: true,
      onError: onError ,
      onWarn: (e) => onError(e, true) 
    },
    options
  );
  if (!opts.isCustomElement && typeof customElements !== "undefined") {
    opts.isCustomElement = (tag) => !!customElements.get(tag);
  }
  const { code } = compilerDom.compile(template, opts);
  function onError(err, asWarning = false) {
    const message = asWarning ? err.message : `Template compilation error: ${err.message}`;
    const codeFrame = err.loc && shared.generateCodeFrame(
      template,
      err.loc.start.offset,
      err.loc.end.offset
    );
    runtimeDom.warn(codeFrame ? `${message}
${codeFrame}` : message);
  }
  const render = new Function("Vue", code)(runtimeDom__namespace);
  render._rc = true;
  return cache[key] = render;
}
runtimeDom.registerRuntimeCompiler(compileToFunction);

exports.compile = compileToFunction;
Object.keys(runtimeDom).forEach(function (k) {
  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = runtimeDom[k];
});


/***/ }),

/***/ "./node_modules/vue/dist/vue.runtime.esm-bundler.js":
/*!**********************************************************!*\
  !*** ./node_modules/vue/dist/vue.runtime.esm-bundler.js ***!
  \**********************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   BaseTransition: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.BaseTransition),
/* harmony export */   BaseTransitionPropsValidators: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.BaseTransitionPropsValidators),
/* harmony export */   Comment: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Comment),
/* harmony export */   DeprecationTypes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.DeprecationTypes),
/* harmony export */   EffectScope: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.EffectScope),
/* harmony export */   ErrorCodes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ErrorCodes),
/* harmony export */   ErrorTypeStrings: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ErrorTypeStrings),
/* harmony export */   Fragment: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Fragment),
/* harmony export */   KeepAlive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.KeepAlive),
/* harmony export */   ReactiveEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ReactiveEffect),
/* harmony export */   Static: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Static),
/* harmony export */   Suspense: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Suspense),
/* harmony export */   Teleport: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Teleport),
/* harmony export */   Text: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Text),
/* harmony export */   TrackOpTypes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.TrackOpTypes),
/* harmony export */   Transition: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.Transition),
/* harmony export */   TransitionGroup: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.TransitionGroup),
/* harmony export */   TriggerOpTypes: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.TriggerOpTypes),
/* harmony export */   VueElement: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.VueElement),
/* harmony export */   assertNumber: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.assertNumber),
/* harmony export */   callWithAsyncErrorHandling: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.callWithAsyncErrorHandling),
/* harmony export */   callWithErrorHandling: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.callWithErrorHandling),
/* harmony export */   camelize: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.camelize),
/* harmony export */   capitalize: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.capitalize),
/* harmony export */   cloneVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.cloneVNode),
/* harmony export */   compatUtils: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.compatUtils),
/* harmony export */   compile: () => (/* binding */ compile),
/* harmony export */   computed: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.computed),
/* harmony export */   createApp: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createApp),
/* harmony export */   createBlock: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createBlock),
/* harmony export */   createCommentVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode),
/* harmony export */   createElementBlock: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createElementBlock),
/* harmony export */   createElementVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createElementVNode),
/* harmony export */   createHydrationRenderer: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createHydrationRenderer),
/* harmony export */   createPropsRestProxy: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createPropsRestProxy),
/* harmony export */   createRenderer: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createRenderer),
/* harmony export */   createSSRApp: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createSSRApp),
/* harmony export */   createSlots: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createSlots),
/* harmony export */   createStaticVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode),
/* harmony export */   createTextVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createTextVNode),
/* harmony export */   createVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.createVNode),
/* harmony export */   customRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.customRef),
/* harmony export */   defineAsyncComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineAsyncComponent),
/* harmony export */   defineComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineComponent),
/* harmony export */   defineCustomElement: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineCustomElement),
/* harmony export */   defineEmits: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineEmits),
/* harmony export */   defineExpose: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineExpose),
/* harmony export */   defineModel: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineModel),
/* harmony export */   defineOptions: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineOptions),
/* harmony export */   defineProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineProps),
/* harmony export */   defineSSRCustomElement: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineSSRCustomElement),
/* harmony export */   defineSlots: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.defineSlots),
/* harmony export */   devtools: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.devtools),
/* harmony export */   effect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.effect),
/* harmony export */   effectScope: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.effectScope),
/* harmony export */   getCurrentInstance: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance),
/* harmony export */   getCurrentScope: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope),
/* harmony export */   getTransitionRawChildren: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.getTransitionRawChildren),
/* harmony export */   guardReactiveProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.guardReactiveProps),
/* harmony export */   h: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.h),
/* harmony export */   handleError: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.handleError),
/* harmony export */   hasInjectionContext: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hasInjectionContext),
/* harmony export */   hydrate: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.hydrate),
/* harmony export */   initCustomFormatter: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.initCustomFormatter),
/* harmony export */   initDirectivesForSSR: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.initDirectivesForSSR),
/* harmony export */   inject: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.inject),
/* harmony export */   isMemoSame: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isMemoSame),
/* harmony export */   isProxy: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isProxy),
/* harmony export */   isReactive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isReactive),
/* harmony export */   isReadonly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isReadonly),
/* harmony export */   isRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isRef),
/* harmony export */   isRuntimeOnly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isRuntimeOnly),
/* harmony export */   isShallow: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isShallow),
/* harmony export */   isVNode: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.isVNode),
/* harmony export */   markRaw: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.markRaw),
/* harmony export */   mergeDefaults: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeDefaults),
/* harmony export */   mergeModels: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeModels),
/* harmony export */   mergeProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.mergeProps),
/* harmony export */   nextTick: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.nextTick),
/* harmony export */   normalizeClass: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeClass),
/* harmony export */   normalizeProps: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeProps),
/* harmony export */   normalizeStyle: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle),
/* harmony export */   onActivated: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onActivated),
/* harmony export */   onBeforeMount: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeMount),
/* harmony export */   onBeforeUnmount: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeUnmount),
/* harmony export */   onBeforeUpdate: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onBeforeUpdate),
/* harmony export */   onDeactivated: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onDeactivated),
/* harmony export */   onErrorCaptured: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onErrorCaptured),
/* harmony export */   onMounted: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onMounted),
/* harmony export */   onRenderTracked: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onRenderTracked),
/* harmony export */   onRenderTriggered: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onRenderTriggered),
/* harmony export */   onScopeDispose: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose),
/* harmony export */   onServerPrefetch: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onServerPrefetch),
/* harmony export */   onUnmounted: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onUnmounted),
/* harmony export */   onUpdated: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.onUpdated),
/* harmony export */   openBlock: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.openBlock),
/* harmony export */   popScopeId: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.popScopeId),
/* harmony export */   provide: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.provide),
/* harmony export */   proxyRefs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.proxyRefs),
/* harmony export */   pushScopeId: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.pushScopeId),
/* harmony export */   queuePostFlushCb: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.queuePostFlushCb),
/* harmony export */   reactive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.reactive),
/* harmony export */   readonly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.readonly),
/* harmony export */   ref: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ref),
/* harmony export */   registerRuntimeCompiler: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.registerRuntimeCompiler),
/* harmony export */   render: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.render),
/* harmony export */   renderList: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.renderList),
/* harmony export */   renderSlot: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.renderSlot),
/* harmony export */   resolveComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveComponent),
/* harmony export */   resolveDirective: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveDirective),
/* harmony export */   resolveDynamicComponent: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent),
/* harmony export */   resolveFilter: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveFilter),
/* harmony export */   resolveTransitionHooks: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.resolveTransitionHooks),
/* harmony export */   setBlockTracking: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setBlockTracking),
/* harmony export */   setDevtoolsHook: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setDevtoolsHook),
/* harmony export */   setTransitionHooks: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.setTransitionHooks),
/* harmony export */   shallowReactive: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowReactive),
/* harmony export */   shallowReadonly: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowReadonly),
/* harmony export */   shallowRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.shallowRef),
/* harmony export */   ssrContextKey: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ssrContextKey),
/* harmony export */   ssrUtils: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.ssrUtils),
/* harmony export */   stop: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.stop),
/* harmony export */   toDisplayString: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toDisplayString),
/* harmony export */   toHandlerKey: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toHandlerKey),
/* harmony export */   toHandlers: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toHandlers),
/* harmony export */   toRaw: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRaw),
/* harmony export */   toRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRef),
/* harmony export */   toRefs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toRefs),
/* harmony export */   toValue: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.toValue),
/* harmony export */   transformVNodeArgs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.transformVNodeArgs),
/* harmony export */   triggerRef: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.triggerRef),
/* harmony export */   unref: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.unref),
/* harmony export */   useAttrs: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useAttrs),
/* harmony export */   useCssModule: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useCssModule),
/* harmony export */   useCssVars: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useCssVars),
/* harmony export */   useModel: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useModel),
/* harmony export */   useSSRContext: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useSSRContext),
/* harmony export */   useSlots: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useSlots),
/* harmony export */   useTransitionState: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.useTransitionState),
/* harmony export */   vModelCheckbox: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelCheckbox),
/* harmony export */   vModelDynamic: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelDynamic),
/* harmony export */   vModelRadio: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelRadio),
/* harmony export */   vModelSelect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelSelect),
/* harmony export */   vModelText: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vModelText),
/* harmony export */   vShow: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.vShow),
/* harmony export */   version: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.version),
/* harmony export */   warn: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.warn),
/* harmony export */   watch: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watch),
/* harmony export */   watchEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchEffect),
/* harmony export */   watchPostEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchPostEffect),
/* harmony export */   watchSyncEffect: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.watchSyncEffect),
/* harmony export */   withAsyncContext: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withAsyncContext),
/* harmony export */   withCtx: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withCtx),
/* harmony export */   withDefaults: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withDefaults),
/* harmony export */   withDirectives: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withDirectives),
/* harmony export */   withKeys: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withKeys),
/* harmony export */   withMemo: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withMemo),
/* harmony export */   withModifiers: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withModifiers),
/* harmony export */   withScopeId: () => (/* reexport safe */ _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__.withScopeId)
/* harmony export */ });
/* harmony import */ var _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/runtime-dom */ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js");
/* harmony import */ var _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/runtime-dom */ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js");
/**
* vue v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/



function initDev() {
  {
    (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.initCustomFormatter)();
  }
}

if (true) {
  initDev();
}
const compile = () => {
  if (true) {
    (0,_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_1__.warn)(
      `Runtime compilation is not supported in this build of Vue.` + (` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` )
    );
  }
};




/***/ }),

/***/ "./node_modules/vue/index.js":
/*!***********************************!*\
  !*** ./node_modules/vue/index.js ***!
  \***********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {



if (false) {} else {
  module.exports = __webpack_require__(/*! ./dist/vue.cjs.js */ "./node_modules/vue/dist/vue.cjs.js")
}


/***/ }),

/***/ "./node_modules/ts-loader/index.js??clonedRuleSet-10!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./src/vue/GenericButton.vue?vue&type=script&setup=true&lang=ts":
/*!***********************************************************************************************************************************************************************************************!*\
  !*** ./node_modules/ts-loader/index.js??clonedRuleSet-10!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./src/vue/GenericButton.vue?vue&type=script&setup=true&lang=ts ***!
  \***********************************************************************************************************************************************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {


var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
var vue_1 = __webpack_require__(/*! vue */ "./node_modules/vue/index.js");
var vue_2 = __webpack_require__(/*! vue */ "./node_modules/vue/index.js");
exports["default"] = (0, vue_1.defineComponent)(__assign({
    name: "GenericButton"
}, { __name: 'GenericButton', setup: function (__props, _a) {
        var __expose = _a.expose;
        __expose();
        var dataset = (0, vue_2.inject)('dataset');
        var __returned__ = { dataset: dataset };
        Object.defineProperty(__returned__, '__isScriptSetup', { enumerable: false, value: true });
        return __returned__;
    } }));


/***/ }),

/***/ "./node_modules/ts-loader/index.js??clonedRuleSet-10!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./src/vue/GenericButton.vue?vue&type=template&id=683abf12&ts=true":
/*!************************************************************************************************************************************************************************************************************************************************************************!*\
  !*** ./node_modules/ts-loader/index.js??clonedRuleSet-10!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./src/vue/GenericButton.vue?vue&type=template&id=683abf12&ts=true ***!
  \************************************************************************************************************************************************************************************************************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {


Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.render = render;
var vue_1 = __webpack_require__(/*! vue */ "./node_modules/vue/index.js");
function render(_ctx, _cache, $props, $setup, $data, $options) {
    var _component_SdsLink = (0, vue_1.resolveComponent)("SdsLink");
    var _component_SdsButton = (0, vue_1.resolveComponent)("SdsButton");
    return ((0, vue_1.openBlock)(), (0, vue_1.createBlock)(_component_SdsButton, {
        kind: "primary",
        size: $setup.dataset['size'],
        class: (0, vue_1.normalizeClass)(["group rounded-none flex p-0", {
                'w-fit': $setup.dataset['fill'] === 'False',
                'ml-0 mr-auto': $setup.dataset['align'] === 'left',
                'mx-auto': $setup.dataset['align'] === 'center',
                'ml-auto mr-0': $setup.dataset['align'] === 'right',
                'bg-white border-2 border-cmu-blue hover:bg-cmu-blue': $setup.dataset['color'] === 'blue',
                'bg-white border-2 border-cmu-red-600 hover:bg-cmu-red-600': $setup.dataset['color'] === 'red',
                'bg-transparent border-2 border-cmu-white hover:bg-cmu-white': $setup.dataset['color'] === 'white',
            }])
    }, {
        default: (0, vue_1.withCtx)(function () { return [
            (0, vue_1.createVNode)(_component_SdsLink, {
                href: $setup.dataset['url'] === 'None' ? null : $setup.dataset['url'],
                target: $setup.dataset['newWindow'] === 'True' ? '_blank' : null,
                class: (0, vue_1.normalizeClass)(["w-full h-full no-underline text-lg", {
                        'px-8 2xl:px-16 py-8': $setup.dataset['size'] === 'lg',
                        'px-6 2xl:px-12 py-2': $setup.dataset['size'] === 'sm',
                        'text-cmu-blue group-hover:text-cmu-white': $setup.dataset['color'] === 'blue',
                        'text-cmu-gray-600 group-hover:text-cmu-white': $setup.dataset['color'] === 'gray',
                        'text-cmu-red-600 group-hover:text-cmu-white': $setup.dataset['color'] === 'red',
                        'text-cmu-white group-hover:text-cmu-gray-800': $setup.dataset['color'] === 'white',
                    }])
            }, {
                default: (0, vue_1.withCtx)(function () { return [
                    (0, vue_1.createTextVNode)((0, vue_1.toDisplayString)($setup.dataset['text']), 1 /* TEXT */)
                ]; }),
                _: 1 /* STABLE */
            }, 8 /* PROPS */, ["href", "target", "class"])
        ]; }),
        _: 1 /* STABLE */
    }, 8 /* PROPS */, ["size", "class"]));
}


/***/ }),

/***/ "./src/vue/GenericButton.vue":
/*!***********************************!*\
  !*** ./src/vue/GenericButton.vue ***!
  \***********************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _GenericButton_vue_vue_type_template_id_683abf12_ts_true__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./GenericButton.vue?vue&type=template&id=683abf12&ts=true */ "./src/vue/GenericButton.vue?vue&type=template&id=683abf12&ts=true");
/* harmony import */ var _GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./GenericButton.vue?vue&type=script&setup=true&lang=ts */ "./src/vue/GenericButton.vue?vue&type=script&setup=true&lang=ts");
/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_1__) if(__WEBPACK_IMPORT_KEY__ !== "default") __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_1__[__WEBPACK_IMPORT_KEY__]
/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
/* harmony import */ var _node_modules_vue_loader_dist_exportHelper_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../node_modules/vue-loader/dist/exportHelper.js */ "./node_modules/vue-loader/dist/exportHelper.js");




;
const __exports__ = /*#__PURE__*/(0,_node_modules_vue_loader_dist_exportHelper_js__WEBPACK_IMPORTED_MODULE_2__["default"])(_GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_1__["default"], [['render',_GenericButton_vue_vue_type_template_id_683abf12_ts_true__WEBPACK_IMPORTED_MODULE_0__.render],['__file',"src/vue/GenericButton.vue"]])
/* hot reload */
if (false) {}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (__exports__);

/***/ }),

/***/ "./src/vue/GenericButton.vue?vue&type=script&setup=true&lang=ts":
/*!**********************************************************************!*\
  !*** ./src/vue/GenericButton.vue?vue&type=script&setup=true&lang=ts ***!
  \**********************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (/* reexport default from dynamic */ _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_0___default.a)
/* harmony export */ });
/* harmony import */ var _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../../node_modules/ts-loader/index.js??clonedRuleSet-10!../../node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./GenericButton.vue?vue&type=script&setup=true&lang=ts */ "./node_modules/ts-loader/index.js??clonedRuleSet-10!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./src/vue/GenericButton.vue?vue&type=script&setup=true&lang=ts");
/* harmony import */ var _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_0__);
/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_0__) if(__WEBPACK_IMPORT_KEY__ !== "default") __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_script_setup_true_lang_ts__WEBPACK_IMPORTED_MODULE_0__[__WEBPACK_IMPORT_KEY__]
/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 

/***/ }),

/***/ "./src/vue/GenericButton.vue?vue&type=template&id=683abf12&ts=true":
/*!*************************************************************************!*\
  !*** ./src/vue/GenericButton.vue?vue&type=template&id=683abf12&ts=true ***!
  \*************************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   __esModule: () => (/* reexport safe */ _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_templateLoader_js_ruleSet_1_rules_3_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_template_id_683abf12_ts_true__WEBPACK_IMPORTED_MODULE_0__.__esModule),
/* harmony export */   render: () => (/* reexport safe */ _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_templateLoader_js_ruleSet_1_rules_3_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_template_id_683abf12_ts_true__WEBPACK_IMPORTED_MODULE_0__.render)
/* harmony export */ });
/* harmony import */ var _node_modules_ts_loader_index_js_clonedRuleSet_10_node_modules_vue_loader_dist_templateLoader_js_ruleSet_1_rules_3_node_modules_vue_loader_dist_index_js_ruleSet_1_rules_23_use_0_GenericButton_vue_vue_type_template_id_683abf12_ts_true__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! -!../../node_modules/ts-loader/index.js??clonedRuleSet-10!../../node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!../../node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./GenericButton.vue?vue&type=template&id=683abf12&ts=true */ "./node_modules/ts-loader/index.js??clonedRuleSet-10!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[23].use[0]!./src/vue/GenericButton.vue?vue&type=template&id=683abf12&ts=true");


/***/ }),

/***/ "./node_modules/@sds/components-vue3/dist/index.mjs":
/*!**********************************************************!*\
  !*** ./node_modules/@sds/components-vue3/dist/index.mjs ***!
  \**********************************************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   SdsActionButton: () => (/* binding */ ca),
/* harmony export */   SdsActionDropdown: () => (/* binding */ da),
/* harmony export */   SdsAvatar: () => (/* binding */ ua),
/* harmony export */   SdsBadge: () => (/* binding */ fa),
/* harmony export */   SdsButton: () => (/* binding */ Tt),
/* harmony export */   SdsCalendar: () => (/* binding */ qt),
/* harmony export */   SdsCheckboxGroup: () => (/* binding */ ha),
/* harmony export */   SdsClientOnly: () => (/* binding */ it),
/* harmony export */   SdsComboBox: () => (/* binding */ ya),
/* harmony export */   SdsDatapoint: () => (/* binding */ ma),
/* harmony export */   SdsDatepicker: () => (/* binding */ ga),
/* harmony export */   SdsDropdown: () => (/* binding */ va),
/* harmony export */   SdsDropdownDivider: () => (/* binding */ ba),
/* harmony export */   SdsDropdownHeader: () => (/* binding */ pa),
/* harmony export */   SdsDropdownItem: () => (/* binding */ wa),
/* harmony export */   SdsExpandCollapse: () => (/* binding */ xa),
/* harmony export */   SdsFileUploader: () => (/* binding */ ka),
/* harmony export */   SdsFilterByDropdown: () => (/* binding */ Ma),
/* harmony export */   SdsFloatingActionButton: () => (/* binding */ Ca),
/* harmony export */   SdsFloatingUi: () => (/* binding */ _e),
/* harmony export */   SdsFormGroup: () => (/* binding */ Sa),
/* harmony export */   SdsIndicator: () => (/* binding */ Yt),
/* harmony export */   SdsInput: () => (/* binding */ $a),
/* harmony export */   SdsLayoutApp: () => (/* binding */ La),
/* harmony export */   SdsLayoutAppSimple: () => (/* binding */ za),
/* harmony export */   SdsLayoutSeiExternal: () => (/* binding */ Da),
/* harmony export */   SdsLayoutSeiExternalFooter: () => (/* binding */ Kt),
/* harmony export */   SdsLayoutSeiExternalHeader: () => (/* binding */ Ut),
/* harmony export */   SdsLayoutSeiExternalHeaderContent: () => (/* binding */ At),
/* harmony export */   SdsLayoutSeiExternalMasthead: () => (/* binding */ Xt),
/* harmony export */   SdsLayoutSeiExternalNav: () => (/* binding */ _t),
/* harmony export */   SdsLayoutSeiExternalWordmark: () => (/* binding */ jt),
/* harmony export */   SdsLayoutStacked: () => (/* binding */ Ta),
/* harmony export */   SdsLink: () => (/* binding */ Bt),
/* harmony export */   SdsLoadingSkeleton: () => (/* binding */ Ba),
/* harmony export */   SdsLoadingSpinner: () => (/* binding */ Pa),
/* harmony export */   SdsMegaMenu: () => (/* binding */ Aa),
/* harmony export */   SdsMegaMenuItem: () => (/* binding */ Va),
/* harmony export */   SdsMobileMenu: () => (/* binding */ Oa),
/* harmony export */   SdsModal: () => (/* binding */ Ha),
/* harmony export */   SdsMultiselect: () => (/* binding */ Na),
/* harmony export */   SdsNavigationItem: () => (/* binding */ Ea),
/* harmony export */   SdsPaginator: () => (/* binding */ Ia),
/* harmony export */   SdsPanel: () => (/* binding */ Qt),
/* harmony export */   SdsPopover: () => (/* binding */ Ra),
/* harmony export */   SdsRadioGroup: () => (/* binding */ Fa),
/* harmony export */   SdsResizer: () => (/* binding */ Wa),
/* harmony export */   SdsScrollArea: () => (/* binding */ Gt),
/* harmony export */   SdsScrollspy: () => (/* binding */ qa),
/* harmony export */   SdsSection: () => (/* binding */ Ga),
/* harmony export */   SdsSeiWordmark: () => (/* binding */ Pt),
/* harmony export */   SdsSelect: () => (/* binding */ Ya),
/* harmony export */   SdsTable: () => (/* binding */ Ua),
/* harmony export */   SdsTabs: () => (/* binding */ ja),
/* harmony export */   SdsTextarea: () => (/* binding */ Ka),
/* harmony export */   SdsToast: () => (/* binding */ Zt),
/* harmony export */   SdsToaster: () => (/* binding */ _a),
/* harmony export */   SdsToggleSwitch: () => (/* binding */ Xa),
/* harmony export */   SdsTooltip: () => (/* binding */ vt),
/* harmony export */   SdsTopFiveChart: () => (/* binding */ Qa),
/* harmony export */   "default": () => (/* binding */ Lm)
/* harmony export */ });
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.runtime.esm-bundler.js");

const Ur = ["type", "disabled", "aria-disabled"], ca = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsActionButton",
  __name: "ActionButton",
  props: {
    /**
     * Determines the purpose and particular function of the component.
     */
    kind: { type: String, default: "ghost" },
    /**
     * Determines the color of the component.
     */
    variant: { type: String, default: "gray" },
    /**
     * Determines the HTML type attribute for the button.
     */
    type: { type: String, default: "button" },
    /**
     * Determines the size.
     */
    size: { type: String, default: "sm" },
    /**
     * Sets the active state of a button.
     */
    active: { type: Boolean, default: !1 },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines whether to use the block styling or not.
     */
    block: { type: Boolean, default: !1 }
  },
  emits: ["click"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.kind ? "action-btn" : ""), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.kind) {
        case "primary":
          return "action-btn-primary";
        case "secondary":
          return "action-btn-secondary";
        case "ghost":
          return "action-btn-ghost";
        default:
          return "";
      }
    }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.variant) {
        case "gray":
          return "action-btn-gray";
        case "red":
          return "action-btn-red";
        case "blue":
          return "action-btn-blue";
        default:
          return "";
      }
    }), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.size) {
        case "lg":
          return "action-btn-lg";
        case "sm":
          return "action-btn-sm";
        case "xs":
          return "action-btn-xs";
        default:
          return "";
      }
    }), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.disabled ? "disabled" : ""), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.active ? "active" : ""), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.block ? "action-btn-block" : ""), y = () => {
      n("click");
    };
    return (d, h) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
      "data-id": "sds-action-button",
      type: e.type,
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)]),
      disabled: e.disabled,
      "aria-disabled": e.disabled,
      onClick: y
    }, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(d.$slots, "default")
    ], 10, Ur));
  }
});
ca.install = (e) => {
  e.component(ca.name, ca);
};
function ln(e) {
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentScope)() ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.onScopeDispose)(e), !0) : !1;
}
function et(e) {
  return typeof e == "function" ? e() : (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(e);
}
const ir = typeof window < "u" && typeof document < "u";
typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
const Kr = (e) => e != null, _r = Object.prototype.toString, Xr = (e) => _r.call(e) === "[object Object]", Lt = () => {
}, Qr = /* @__PURE__ */ Zr();
function Zr() {
  var e, t;
  return ir && ((e = window?.navigator) == null ? void 0 : e.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((t = window?.navigator) == null ? void 0 : t.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window?.navigator.userAgent));
}
function Jr(e, t) {
  function a(...n) {
    return new Promise((r, s) => {
      Promise.resolve(e(() => t.apply(this, n), { fn: t, thisArg: this, args: n })).then(r).catch(s);
    });
  }
  return a;
}
const es = (e) => e();
function ts(e, t = {}) {
  let a, n, r = Lt;
  const s = (f) => {
    clearTimeout(f), r(), r = Lt;
  };
  return (f) => {
    const v = et(e), g = et(t.maxWait);
    return a && s(a), v <= 0 || g !== void 0 && g <= 0 ? (n && (s(n), n = null), Promise.resolve(f())) : new Promise((m, y) => {
      r = t.rejectOnCancel ? y : m, g && !n && (n = setTimeout(() => {
        a && s(a), n = null, m(f());
      }, g)), a = setTimeout(() => {
        n && s(n), n = null, m(f());
      }, v);
    });
  };
}
function as(e, t) {
  var a;
  if (typeof e == "number")
    return e + t;
  const n = ((a = e.match(/^-?\d+\.?\d*/)) == null ? void 0 : a[0]) || "", r = e.slice(n.length), s = Number.parseFloat(n) + t;
  return Number.isNaN(s) ? e : s + r;
}
function ns(e) {
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)();
}
function rs(e, t, a = {}) {
  const {
    eventFilter: n = es,
    ...r
  } = a;
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(
    e,
    Jr(
      n,
      t
    ),
    r
  );
}
function ss(e, t = !0, a) {
  ns() ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(e, a) : t ? e() : (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(e);
}
function ls(e, t, a = {}) {
  const {
    debounce: n = 0,
    maxWait: r = void 0,
    ...s
  } = a;
  return rs(
    e,
    t,
    {
      ...s,
      eventFilter: ts(n, { maxWait: r })
    }
  );
}
function je(e) {
  var t;
  const a = et(e);
  return (t = a?.$el) != null ? t : a;
}
const xt = ir ? window : void 0;
function zt(...e) {
  let t, a, n, r;
  if (typeof e[0] == "string" || Array.isArray(e[0]) ? ([a, n, r] = e, t = xt) : [t, a, n, r] = e, !t)
    return Lt;
  Array.isArray(a) || (a = [a]), Array.isArray(n) || (n = [n]);
  const s = [], u = () => {
    s.forEach((m) => m()), s.length = 0;
  }, f = (m, y, d, h) => (m.addEventListener(y, d, h), () => m.removeEventListener(y, d, h)), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(
    () => [je(t), et(r)],
    ([m, y]) => {
      if (u(), !m)
        return;
      const d = Xr(y) ? { ...y } : y;
      s.push(
        ...a.flatMap((h) => n.map((p) => f(m, h, p, d)))
      );
    },
    { immediate: !0, flush: "post" }
  ), g = () => {
    v(), u();
  };
  return ln(g), g;
}
let Wn = !1;
function on(e, t, a = {}) {
  const { window: n = xt, ignore: r = [], capture: s = !0, detectIframe: u = !1 } = a;
  if (!n)
    return Lt;
  Qr && !Wn && (Wn = !0, Array.from(n.document.body.children).forEach((d) => d.addEventListener("click", Lt)), n.document.documentElement.addEventListener("click", Lt));
  let f = !0;
  const v = (d) => r.some((h) => {
    if (typeof h == "string")
      return Array.from(n.document.querySelectorAll(h)).some((p) => p === d.target || d.composedPath().includes(p));
    {
      const p = je(h);
      return p && (d.target === p || d.composedPath().includes(p));
    }
  }), m = [
    zt(n, "click", (d) => {
      const h = je(e);
      if (!(!h || h === d.target || d.composedPath().includes(h))) {
        if (d.detail === 0 && (f = !v(d)), !f) {
          f = !0;
          return;
        }
        t(d);
      }
    }, { passive: !0, capture: s }),
    zt(n, "pointerdown", (d) => {
      const h = je(e);
      f = !v(d) && !!(h && !d.composedPath().includes(h));
    }, { passive: !0 }),
    u && zt(n, "blur", (d) => {
      setTimeout(() => {
        var h;
        const p = je(e);
        ((h = n.document.activeElement) == null ? void 0 : h.tagName) === "IFRAME" && !p?.contains(n.document.activeElement) && t(d);
      }, 0);
    })
  ].filter(Boolean);
  return () => m.forEach((d) => d());
}
function os(e) {
  return typeof e == "function" ? e : typeof e == "string" ? (t) => t.key === e : Array.isArray(e) ? (t) => e.includes(t.key) : () => !0;
}
function ea(...e) {
  let t, a, n = {};
  e.length === 3 ? (t = e[0], a = e[1], n = e[2]) : e.length === 2 ? typeof e[1] == "object" ? (t = !0, a = e[0], n = e[1]) : (t = e[0], a = e[1]) : (t = !0, a = e[0]);
  const {
    target: r = xt,
    eventName: s = "keydown",
    passive: u = !1,
    dedupe: f = !1
  } = n, v = os(t);
  return zt(r, s, (m) => {
    m.repeat && et(f) || v(m) && a(m);
  }, u);
}
function is() {
  const e = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), t = (0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)();
  return t && (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
    e.value = !0;
  }, t), e;
}
function Bn(e) {
  const t = is();
  return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (t.value, !!e()));
}
function cs(e, t, a = {}) {
  const { window: n = xt, ...r } = a;
  let s;
  const u = Bn(() => n && "MutationObserver" in n), f = () => {
    s && (s.disconnect(), s = void 0);
  }, v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
    const d = et(e), h = (Array.isArray(d) ? d : [d]).map(je).filter(Kr);
    return new Set(h);
  }), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(
    () => v.value,
    (d) => {
      f(), u.value && d.size && (s = new MutationObserver(t), d.forEach((h) => s.observe(h, r)));
    },
    { immediate: !0, flush: "post" }
  ), m = () => s?.takeRecords(), y = () => {
    f(), g();
  };
  return ln(y), {
    isSupported: u,
    stop: y,
    takeRecords: m
  };
}
function Rt(e, t = {}) {
  const { window: a = xt } = t, n = Bn(() => a && "matchMedia" in a && typeof a.matchMedia == "function");
  let r;
  const s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), u = (g) => {
    s.value = g.matches;
  }, f = () => {
    r && ("removeEventListener" in r ? r.removeEventListener("change", u) : r.removeListener(u));
  }, v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watchEffect)(() => {
    n.value && (f(), r = a.matchMedia(et(e)), "addEventListener" in r ? r.addEventListener("change", u) : r.addListener(u), s.value = r.matches);
  });
  return ln(() => {
    v(), f(), r = void 0;
  }), s;
}
const ds = {
  sm: 640,
  md: 768,
  lg: 1024,
  xl: 1280,
  "2xl": 1536
};
function us(e, t = {}) {
  function a(m, y) {
    let d = et(e[et(m)]);
    return y != null && (d = as(d, y)), typeof d == "number" && (d = `${d}px`), d;
  }
  const { window: n = xt, strategy: r = "min-width" } = t;
  function s(m) {
    return n ? n.matchMedia(m).matches : !1;
  }
  const u = (m) => Rt(() => `(min-width: ${a(m)})`, t), f = (m) => Rt(() => `(max-width: ${a(m)})`, t), v = Object.keys(e).reduce((m, y) => (Object.defineProperty(m, y, {
    get: () => r === "min-width" ? u(y) : f(y),
    enumerable: !0,
    configurable: !0
  }), m), {});
  function g() {
    const m = Object.keys(e).map((y) => [y, u(y)]);
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => m.filter(([, y]) => y.value).map(([y]) => y));
  }
  return Object.assign(v, {
    greaterOrEqual: u,
    smallerOrEqual: f,
    greater(m) {
      return Rt(() => `(min-width: ${a(m, 0.1)})`, t);
    },
    smaller(m) {
      return Rt(() => `(max-width: ${a(m, -0.1)})`, t);
    },
    between(m, y) {
      return Rt(() => `(min-width: ${a(m)}) and (max-width: ${a(y, -0.1)})`, t);
    },
    isGreater(m) {
      return s(`(min-width: ${a(m, 0.1)})`);
    },
    isGreaterOrEqual(m) {
      return s(`(min-width: ${a(m)})`);
    },
    isSmaller(m) {
      return s(`(max-width: ${a(m, -0.1)})`);
    },
    isSmallerOrEqual(m) {
      return s(`(max-width: ${a(m)})`);
    },
    isInBetween(m, y) {
      return s(`(min-width: ${a(m)}) and (max-width: ${a(y, -0.1)})`);
    },
    current: g,
    active() {
      const m = g();
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => m.value.length === 0 ? "" : m.value.at(-1));
    }
  });
}
function cr(e, t, a = {}) {
  const { window: n = xt, ...r } = a;
  let s;
  const u = Bn(() => n && "ResizeObserver" in n), f = () => {
    s && (s.disconnect(), s = void 0);
  }, v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Array.isArray(e) ? e.map((y) => je(y)) : [je(e)]), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(
    v,
    (y) => {
      if (f(), u.value && n) {
        s = new ResizeObserver(t);
        for (const d of y)
          d && s.observe(d, r);
      }
    },
    { immediate: !0, flush: "post" }
  ), m = () => {
    f(), g();
  };
  return ln(m), {
    isSupported: u,
    stop: m
  };
}
function mn(e, t = {}) {
  const {
    reset: a = !0,
    windowResize: n = !0,
    windowScroll: r = !0,
    immediate: s = !0
  } = t, u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0);
  function p() {
    const w = je(e);
    if (!w) {
      a && (u.value = 0, f.value = 0, v.value = 0, g.value = 0, m.value = 0, y.value = 0, d.value = 0, h.value = 0);
      return;
    }
    const b = w.getBoundingClientRect();
    u.value = b.height, f.value = b.bottom, v.value = b.left, g.value = b.right, m.value = b.top, y.value = b.width, d.value = b.x, h.value = b.y;
  }
  return cr(e, p), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(() => je(e), (w) => !w && p()), cs(e, p, {
    attributeFilter: ["style", "class"]
  }), r && zt("scroll", p, { capture: !0, passive: !0 }), n && zt("resize", p, { passive: !0 }), ss(() => {
    s && p();
  }), {
    height: u,
    bottom: f,
    left: v,
    right: g,
    top: m,
    width: y,
    x: d,
    y: h,
    update: p
  };
}
const fs = ["top", "right", "bottom", "left"], qn = ["start", "end"], Gn = /* @__PURE__ */ fs.reduce((e, t) => e.concat(t, t + "-" + qn[0], t + "-" + qn[1]), []), tt = Math.min, Ue = Math.max, Za = Math.round, ia = Math.floor, ct = (e) => ({
  x: e,
  y: e
}), hs = {
  left: "right",
  right: "left",
  bottom: "top",
  top: "bottom"
}, ys = {
  start: "end",
  end: "start"
};
function xn(e, t, a) {
  return Ue(e, tt(t, a));
}
function kt(e, t) {
  return typeof e == "function" ? e(t) : e;
}
function Ie(e) {
  return e.split("-")[0];
}
function Ke(e) {
  return e.split("-")[1];
}
function dr(e) {
  return e === "x" ? "y" : "x";
}
function Pn(e) {
  return e === "y" ? "height" : "width";
}
function pt(e) {
  return ["top", "bottom"].includes(Ie(e)) ? "y" : "x";
}
function An(e) {
  return dr(pt(e));
}
function ur(e, t, a) {
  a === void 0 && (a = !1);
  const n = Ke(e), r = An(e), s = Pn(r);
  let u = r === "x" ? n === (a ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
  return t.reference[s] > t.floating[s] && (u = en(u)), [u, en(u)];
}
function ms(e) {
  const t = en(e);
  return [Ja(e), t, Ja(t)];
}
function Ja(e) {
  return e.replace(/start|end/g, (t) => ys[t]);
}
function gs(e, t, a) {
  const n = ["left", "right"], r = ["right", "left"], s = ["top", "bottom"], u = ["bottom", "top"];
  switch (e) {
    case "top":
    case "bottom":
      return a ? t ? r : n : t ? n : r;
    case "left":
    case "right":
      return t ? s : u;
    default:
      return [];
  }
}
function vs(e, t, a, n) {
  const r = Ke(e);
  let s = gs(Ie(e), a === "start", n);
  return r && (s = s.map((u) => u + "-" + r), t && (s = s.concat(s.map(Ja)))), s;
}
function en(e) {
  return e.replace(/left|right|bottom|top/g, (t) => hs[t]);
}
function bs(e) {
  return {
    top: 0,
    right: 0,
    bottom: 0,
    left: 0,
    ...e
  };
}
function Vn(e) {
  return typeof e != "number" ? bs(e) : {
    top: e,
    right: e,
    bottom: e,
    left: e
  };
}
function Vt(e) {
  const {
    x: t,
    y: a,
    width: n,
    height: r
  } = e;
  return {
    width: n,
    height: r,
    top: a,
    left: t,
    right: t + n,
    bottom: a + r,
    x: t,
    y: a
  };
}
function Yn(e, t, a) {
  let {
    reference: n,
    floating: r
  } = e;
  const s = pt(t), u = An(t), f = Pn(u), v = Ie(t), g = s === "y", m = n.x + n.width / 2 - r.width / 2, y = n.y + n.height / 2 - r.height / 2, d = n[f] / 2 - r[f] / 2;
  let h;
  switch (v) {
    case "top":
      h = {
        x: m,
        y: n.y - r.height
      };
      break;
    case "bottom":
      h = {
        x: m,
        y: n.y + n.height
      };
      break;
    case "right":
      h = {
        x: n.x + n.width,
        y
      };
      break;
    case "left":
      h = {
        x: n.x - r.width,
        y
      };
      break;
    default:
      h = {
        x: n.x,
        y: n.y
      };
  }
  switch (Ke(t)) {
    case "start":
      h[u] -= d * (a && g ? -1 : 1);
      break;
    case "end":
      h[u] += d * (a && g ? -1 : 1);
      break;
  }
  return h;
}
const ps = async (e, t, a) => {
  const {
    placement: n = "bottom",
    strategy: r = "absolute",
    middleware: s = [],
    platform: u
  } = a, f = s.filter(Boolean), v = await (u.isRTL == null ? void 0 : u.isRTL(t));
  let g = await u.getElementRects({
    reference: e,
    floating: t,
    strategy: r
  }), {
    x: m,
    y
  } = Yn(g, n, v), d = n, h = {}, p = 0;
  for (let w = 0; w < f.length; w++) {
    const {
      name: b,
      fn: k
    } = f[w], {
      x: D,
      y: C,
      data: L,
      reset: B
    } = await k({
      x: m,
      y,
      initialPlacement: n,
      placement: d,
      strategy: r,
      middlewareData: h,
      rects: g,
      platform: u,
      elements: {
        reference: e,
        floating: t
      }
    });
    m = D ?? m, y = C ?? y, h = {
      ...h,
      [b]: {
        ...h[b],
        ...L
      }
    }, B && p <= 50 && (p++, typeof B == "object" && (B.placement && (d = B.placement), B.rects && (g = B.rects === !0 ? await u.getElementRects({
      reference: e,
      floating: t,
      strategy: r
    }) : B.rects), {
      x: m,
      y
    } = Yn(g, d, v)), w = -1);
  }
  return {
    x: m,
    y,
    placement: d,
    strategy: r,
    middlewareData: h
  };
};
async function On(e, t) {
  var a;
  t === void 0 && (t = {});
  const {
    x: n,
    y: r,
    platform: s,
    rects: u,
    elements: f,
    strategy: v
  } = e, {
    boundary: g = "clippingAncestors",
    rootBoundary: m = "viewport",
    elementContext: y = "floating",
    altBoundary: d = !1,
    padding: h = 0
  } = kt(t, e), p = Vn(h), b = f[d ? y === "floating" ? "reference" : "floating" : y], k = Vt(await s.getClippingRect({
    element: (a = await (s.isElement == null ? void 0 : s.isElement(b))) == null || a ? b : b.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(f.floating)),
    boundary: g,
    rootBoundary: m,
    strategy: v
  })), D = y === "floating" ? {
    x: n,
    y: r,
    width: u.floating.width,
    height: u.floating.height
  } : u.reference, C = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(f.floating)), L = await (s.isElement == null ? void 0 : s.isElement(C)) ? await (s.getScale == null ? void 0 : s.getScale(C)) || {
    x: 1,
    y: 1
  } : {
    x: 1,
    y: 1
  }, B = Vt(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
    elements: f,
    rect: D,
    offsetParent: C,
    strategy: v
  }) : D);
  return {
    top: (k.top - B.top + p.top) / L.y,
    bottom: (B.bottom - k.bottom + p.bottom) / L.y,
    left: (k.left - B.left + p.left) / L.x,
    right: (B.right - k.right + p.right) / L.x
  };
}
const ws = (e) => ({
  name: "arrow",
  options: e,
  async fn(t) {
    const {
      x: a,
      y: n,
      placement: r,
      rects: s,
      platform: u,
      elements: f,
      middlewareData: v
    } = t, {
      element: g,
      padding: m = 0
    } = kt(e, t) || {};
    if (g == null)
      return {};
    const y = Vn(m), d = {
      x: a,
      y: n
    }, h = An(r), p = Pn(h), w = await u.getDimensions(g), b = h === "y", k = b ? "top" : "left", D = b ? "bottom" : "right", C = b ? "clientHeight" : "clientWidth", L = s.reference[p] + s.reference[h] - d[h] - s.floating[p], B = d[h] - s.reference[h], A = await (u.getOffsetParent == null ? void 0 : u.getOffsetParent(g));
    let E = A ? A[C] : 0;
    (!E || !await (u.isElement == null ? void 0 : u.isElement(A))) && (E = f.floating[C] || s.floating[p]);
    const M = L / 2 - B / 2, H = E / 2 - w[p] / 2 - 1, P = tt(y[k], H), G = tt(y[D], H), oe = P, U = E - w[p] - G, K = E / 2 - w[p] / 2 + M, J = xn(oe, K, U), ie = !v.arrow && Ke(r) != null && K !== J && s.reference[p] / 2 - (K < oe ? P : G) - w[p] / 2 < 0, de = ie ? K < oe ? K - oe : K - U : 0;
    return {
      [h]: d[h] + de,
      data: {
        [h]: J,
        centerOffset: K - J - de,
        ...ie && {
          alignmentOffset: de
        }
      },
      reset: ie
    };
  }
});
function xs(e, t, a) {
  return (e ? [...a.filter((r) => Ke(r) === e), ...a.filter((r) => Ke(r) !== e)] : a.filter((r) => Ie(r) === r)).filter((r) => e ? Ke(r) === e || (t ? Ja(r) !== r : !1) : !0);
}
const ks = function(e) {
  return e === void 0 && (e = {}), {
    name: "autoPlacement",
    options: e,
    async fn(t) {
      var a, n, r;
      const {
        rects: s,
        middlewareData: u,
        placement: f,
        platform: v,
        elements: g
      } = t, {
        crossAxis: m = !1,
        alignment: y,
        allowedPlacements: d = Gn,
        autoAlignment: h = !0,
        ...p
      } = kt(e, t), w = y !== void 0 || d === Gn ? xs(y || null, h, d) : d, b = await On(t, p), k = ((a = u.autoPlacement) == null ? void 0 : a.index) || 0, D = w[k];
      if (D == null)
        return {};
      const C = ur(D, s, await (v.isRTL == null ? void 0 : v.isRTL(g.floating)));
      if (f !== D)
        return {
          reset: {
            placement: w[0]
          }
        };
      const L = [b[Ie(D)], b[C[0]], b[C[1]]], B = [...((n = u.autoPlacement) == null ? void 0 : n.overflows) || [], {
        placement: D,
        overflows: L
      }], A = w[k + 1];
      if (A)
        return {
          data: {
            index: k + 1,
            overflows: B
          },
          reset: {
            placement: A
          }
        };
      const E = B.map((P) => {
        const G = Ke(P.placement);
        return [P.placement, G && m ? (
          // Check along the mainAxis and main crossAxis side.
          P.overflows.slice(0, 2).reduce((oe, U) => oe + U, 0)
        ) : (
          // Check only the mainAxis.
          P.overflows[0]
        ), P.overflows];
      }).sort((P, G) => P[1] - G[1]), H = ((r = E.filter((P) => P[2].slice(
        0,
        // Aligned placements should not check their opposite crossAxis
        // side.
        Ke(P[0]) ? 2 : 3
      ).every((G) => G <= 0))[0]) == null ? void 0 : r[0]) || E[0][0];
      return H !== f ? {
        data: {
          index: k + 1,
          overflows: B
        },
        reset: {
          placement: H
        }
      } : {};
    }
  };
}, Ms = function(e) {
  return e === void 0 && (e = {}), {
    name: "flip",
    options: e,
    async fn(t) {
      var a, n;
      const {
        placement: r,
        middlewareData: s,
        rects: u,
        initialPlacement: f,
        platform: v,
        elements: g
      } = t, {
        mainAxis: m = !0,
        crossAxis: y = !0,
        fallbackPlacements: d,
        fallbackStrategy: h = "bestFit",
        fallbackAxisSideDirection: p = "none",
        flipAlignment: w = !0,
        ...b
      } = kt(e, t);
      if ((a = s.arrow) != null && a.alignmentOffset)
        return {};
      const k = Ie(r), D = pt(f), C = Ie(f) === f, L = await (v.isRTL == null ? void 0 : v.isRTL(g.floating)), B = d || (C || !w ? [en(f)] : ms(f)), A = p !== "none";
      !d && A && B.push(...vs(f, w, p, L));
      const E = [f, ...B], M = await On(t, b), H = [];
      let P = ((n = s.flip) == null ? void 0 : n.overflows) || [];
      if (m && H.push(M[k]), y) {
        const K = ur(r, u, L);
        H.push(M[K[0]], M[K[1]]);
      }
      if (P = [...P, {
        placement: r,
        overflows: H
      }], !H.every((K) => K <= 0)) {
        var G, oe;
        const K = (((G = s.flip) == null ? void 0 : G.index) || 0) + 1, J = E[K];
        if (J)
          return {
            data: {
              index: K,
              overflows: P
            },
            reset: {
              placement: J
            }
          };
        let ie = (oe = P.filter((de) => de.overflows[0] <= 0).sort((de, ke) => de.overflows[1] - ke.overflows[1])[0]) == null ? void 0 : oe.placement;
        if (!ie)
          switch (h) {
            case "bestFit": {
              var U;
              const de = (U = P.filter((ke) => {
                if (A) {
                  const me = pt(ke.placement);
                  return me === D || // Create a bias to the `y` side axis due to horizontal
                  // reading directions favoring greater width.
                  me === "y";
                }
                return !0;
              }).map((ke) => [ke.placement, ke.overflows.filter((me) => me > 0).reduce((me, Ve) => me + Ve, 0)]).sort((ke, me) => ke[1] - me[1])[0]) == null ? void 0 : U[0];
              de && (ie = de);
              break;
            }
            case "initialPlacement":
              ie = f;
              break;
          }
        if (r !== ie)
          return {
            reset: {
              placement: ie
            }
          };
      }
      return {};
    }
  };
};
function fr(e) {
  const t = tt(...e.map((s) => s.left)), a = tt(...e.map((s) => s.top)), n = Ue(...e.map((s) => s.right)), r = Ue(...e.map((s) => s.bottom));
  return {
    x: t,
    y: a,
    width: n - t,
    height: r - a
  };
}
function Cs(e) {
  const t = e.slice().sort((r, s) => r.y - s.y), a = [];
  let n = null;
  for (let r = 0; r < t.length; r++) {
    const s = t[r];
    !n || s.y - n.y > n.height / 2 ? a.push([s]) : a[a.length - 1].push(s), n = s;
  }
  return a.map((r) => Vt(fr(r)));
}
const Ss = function(e) {
  return e === void 0 && (e = {}), {
    name: "inline",
    options: e,
    async fn(t) {
      const {
        placement: a,
        elements: n,
        rects: r,
        platform: s,
        strategy: u
      } = t, {
        padding: f = 2,
        x: v,
        y: g
      } = kt(e, t), m = Array.from(await (s.getClientRects == null ? void 0 : s.getClientRects(n.reference)) || []), y = Cs(m), d = Vt(fr(m)), h = Vn(f);
      function p() {
        if (y.length === 2 && y[0].left > y[1].right && v != null && g != null)
          return y.find((b) => v > b.left - h.left && v < b.right + h.right && g > b.top - h.top && g < b.bottom + h.bottom) || d;
        if (y.length >= 2) {
          if (pt(a) === "y") {
            const P = y[0], G = y[y.length - 1], oe = Ie(a) === "top", U = P.top, K = G.bottom, J = oe ? P.left : G.left, ie = oe ? P.right : G.right, de = ie - J, ke = K - U;
            return {
              top: U,
              bottom: K,
              left: J,
              right: ie,
              width: de,
              height: ke,
              x: J,
              y: U
            };
          }
          const b = Ie(a) === "left", k = Ue(...y.map((P) => P.right)), D = tt(...y.map((P) => P.left)), C = y.filter((P) => b ? P.left === D : P.right === k), L = C[0].top, B = C[C.length - 1].bottom, A = D, E = k, M = E - A, H = B - L;
          return {
            top: L,
            bottom: B,
            left: A,
            right: E,
            width: M,
            height: H,
            x: A,
            y: L
          };
        }
        return d;
      }
      const w = await s.getElementRects({
        reference: {
          getBoundingClientRect: p
        },
        floating: n.floating,
        strategy: u
      });
      return r.reference.x !== w.reference.x || r.reference.y !== w.reference.y || r.reference.width !== w.reference.width || r.reference.height !== w.reference.height ? {
        reset: {
          rects: w
        }
      } : {};
    }
  };
};
async function $s(e, t) {
  const {
    placement: a,
    platform: n,
    elements: r
  } = e, s = await (n.isRTL == null ? void 0 : n.isRTL(r.floating)), u = Ie(a), f = Ke(a), v = pt(a) === "y", g = ["left", "top"].includes(u) ? -1 : 1, m = s && v ? -1 : 1, y = kt(t, e);
  let {
    mainAxis: d,
    crossAxis: h,
    alignmentAxis: p
  } = typeof y == "number" ? {
    mainAxis: y,
    crossAxis: 0,
    alignmentAxis: null
  } : {
    mainAxis: 0,
    crossAxis: 0,
    alignmentAxis: null,
    ...y
  };
  return f && typeof p == "number" && (h = f === "end" ? p * -1 : p), v ? {
    x: h * m,
    y: d * g
  } : {
    x: d * g,
    y: h * m
  };
}
const Ls = function(e) {
  return e === void 0 && (e = 0), {
    name: "offset",
    options: e,
    async fn(t) {
      var a, n;
      const {
        x: r,
        y: s,
        placement: u,
        middlewareData: f
      } = t, v = await $s(t, e);
      return u === ((a = f.offset) == null ? void 0 : a.placement) && (n = f.arrow) != null && n.alignmentOffset ? {} : {
        x: r + v.x,
        y: s + v.y,
        data: {
          ...v,
          placement: u
        }
      };
    }
  };
}, zs = function(e) {
  return e === void 0 && (e = {}), {
    name: "shift",
    options: e,
    async fn(t) {
      const {
        x: a,
        y: n,
        placement: r
      } = t, {
        mainAxis: s = !0,
        crossAxis: u = !1,
        limiter: f = {
          fn: (b) => {
            let {
              x: k,
              y: D
            } = b;
            return {
              x: k,
              y: D
            };
          }
        },
        ...v
      } = kt(e, t), g = {
        x: a,
        y: n
      }, m = await On(t, v), y = pt(Ie(r)), d = dr(y);
      let h = g[d], p = g[y];
      if (s) {
        const b = d === "y" ? "top" : "left", k = d === "y" ? "bottom" : "right", D = h + m[b], C = h - m[k];
        h = xn(D, h, C);
      }
      if (u) {
        const b = y === "y" ? "top" : "left", k = y === "y" ? "bottom" : "right", D = p + m[b], C = p - m[k];
        p = xn(D, p, C);
      }
      const w = f.fn({
        ...t,
        [d]: h,
        [y]: p
      });
      return {
        ...w,
        data: {
          x: w.x - a,
          y: w.y - n
        }
      };
    }
  };
};
function Et(e) {
  return hr(e) ? (e.nodeName || "").toLowerCase() : "#document";
}
function Pe(e) {
  var t;
  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
}
function at(e) {
  var t;
  return (t = (hr(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
}
function hr(e) {
  return e instanceof Node || e instanceof Pe(e).Node;
}
function Re(e) {
  return e instanceof Element || e instanceof Pe(e).Element;
}
function Xe(e) {
  return e instanceof HTMLElement || e instanceof Pe(e).HTMLElement;
}
function jn(e) {
  return typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof Pe(e).ShadowRoot;
}
function aa(e) {
  const {
    overflow: t,
    overflowX: a,
    overflowY: n,
    display: r
  } = Fe(e);
  return /auto|scroll|overlay|hidden|clip/.test(t + n + a) && !["inline", "contents"].includes(r);
}
function Ds(e) {
  return ["table", "td", "th"].includes(Et(e));
}
function cn(e) {
  return [":popover-open", ":modal"].some((t) => {
    try {
      return e.matches(t);
    } catch {
      return !1;
    }
  });
}
function Hn(e) {
  const t = Nn(), a = Re(e) ? Fe(e) : e;
  return a.transform !== "none" || a.perspective !== "none" || (a.containerType ? a.containerType !== "normal" : !1) || !t && (a.backdropFilter ? a.backdropFilter !== "none" : !1) || !t && (a.filter ? a.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((n) => (a.willChange || "").includes(n)) || ["paint", "layout", "strict", "content"].some((n) => (a.contain || "").includes(n));
}
function Ts(e) {
  let t = dt(e);
  for (; Xe(t) && !Ot(t); ) {
    if (Hn(t))
      return t;
    if (cn(t))
      return null;
    t = dt(t);
  }
  return null;
}
function Nn() {
  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
}
function Ot(e) {
  return ["html", "body", "#document"].includes(Et(e));
}
function Fe(e) {
  return Pe(e).getComputedStyle(e);
}
function dn(e) {
  return Re(e) ? {
    scrollLeft: e.scrollLeft,
    scrollTop: e.scrollTop
  } : {
    scrollLeft: e.scrollX,
    scrollTop: e.scrollY
  };
}
function dt(e) {
  if (Et(e) === "html")
    return e;
  const t = (
    // Step into the shadow DOM of the parent of a slotted node.
    e.assignedSlot || // DOM Element detected.
    e.parentNode || // ShadowRoot detected.
    jn(e) && e.host || // Fallback.
    at(e)
  );
  return jn(t) ? t.host : t;
}
function yr(e) {
  const t = dt(e);
  return Ot(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : Xe(t) && aa(t) ? t : yr(t);
}
function ta(e, t, a) {
  var n;
  t === void 0 && (t = []), a === void 0 && (a = !0);
  const r = yr(e), s = r === ((n = e.ownerDocument) == null ? void 0 : n.body), u = Pe(r);
  if (s) {
    const f = kn(u);
    return t.concat(u, u.visualViewport || [], aa(r) ? r : [], f && a ? ta(f) : []);
  }
  return t.concat(r, ta(r, [], a));
}
function kn(e) {
  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
}
function mr(e) {
  const t = Fe(e);
  let a = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
  const r = Xe(e), s = r ? e.offsetWidth : a, u = r ? e.offsetHeight : n, f = Za(a) !== s || Za(n) !== u;
  return f && (a = s, n = u), {
    width: a,
    height: n,
    $: f
  };
}
function En(e) {
  return Re(e) ? e : e.contextElement;
}
function Dt(e) {
  const t = En(e);
  if (!Xe(t))
    return ct(1);
  const a = t.getBoundingClientRect(), {
    width: n,
    height: r,
    $: s
  } = mr(t);
  let u = (s ? Za(a.width) : a.width) / n, f = (s ? Za(a.height) : a.height) / r;
  return (!u || !Number.isFinite(u)) && (u = 1), (!f || !Number.isFinite(f)) && (f = 1), {
    x: u,
    y: f
  };
}
const Bs = /* @__PURE__ */ ct(0);
function gr(e) {
  const t = Pe(e);
  return !Nn() || !t.visualViewport ? Bs : {
    x: t.visualViewport.offsetLeft,
    y: t.visualViewport.offsetTop
  };
}
function Ps(e, t, a) {
  return t === void 0 && (t = !1), !a || t && a !== Pe(e) ? !1 : t;
}
function wt(e, t, a, n) {
  t === void 0 && (t = !1), a === void 0 && (a = !1);
  const r = e.getBoundingClientRect(), s = En(e);
  let u = ct(1);
  t && (n ? Re(n) && (u = Dt(n)) : u = Dt(e));
  const f = Ps(s, a, n) ? gr(s) : ct(0);
  let v = (r.left + f.x) / u.x, g = (r.top + f.y) / u.y, m = r.width / u.x, y = r.height / u.y;
  if (s) {
    const d = Pe(s), h = n && Re(n) ? Pe(n) : n;
    let p = d, w = kn(p);
    for (; w && n && h !== p; ) {
      const b = Dt(w), k = w.getBoundingClientRect(), D = Fe(w), C = k.left + (w.clientLeft + parseFloat(D.paddingLeft)) * b.x, L = k.top + (w.clientTop + parseFloat(D.paddingTop)) * b.y;
      v *= b.x, g *= b.y, m *= b.x, y *= b.y, v += C, g += L, p = Pe(w), w = kn(p);
    }
  }
  return Vt({
    width: m,
    height: y,
    x: v,
    y: g
  });
}
function As(e) {
  let {
    elements: t,
    rect: a,
    offsetParent: n,
    strategy: r
  } = e;
  const s = r === "fixed", u = at(n), f = t ? cn(t.floating) : !1;
  if (n === u || f && s)
    return a;
  let v = {
    scrollLeft: 0,
    scrollTop: 0
  }, g = ct(1);
  const m = ct(0), y = Xe(n);
  if ((y || !y && !s) && ((Et(n) !== "body" || aa(u)) && (v = dn(n)), Xe(n))) {
    const d = wt(n);
    g = Dt(n), m.x = d.x + n.clientLeft, m.y = d.y + n.clientTop;
  }
  return {
    width: a.width * g.x,
    height: a.height * g.y,
    x: a.x * g.x - v.scrollLeft * g.x + m.x,
    y: a.y * g.y - v.scrollTop * g.y + m.y
  };
}
function Vs(e) {
  return Array.from(e.getClientRects());
}
function vr(e) {
  return wt(at(e)).left + dn(e).scrollLeft;
}
function Os(e) {
  const t = at(e), a = dn(e), n = e.ownerDocument.body, r = Ue(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), s = Ue(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
  let u = -a.scrollLeft + vr(e);
  const f = -a.scrollTop;
  return Fe(n).direction === "rtl" && (u += Ue(t.clientWidth, n.clientWidth) - r), {
    width: r,
    height: s,
    x: u,
    y: f
  };
}
function Hs(e, t) {
  const a = Pe(e), n = at(e), r = a.visualViewport;
  let s = n.clientWidth, u = n.clientHeight, f = 0, v = 0;
  if (r) {
    s = r.width, u = r.height;
    const g = Nn();
    (!g || g && t === "fixed") && (f = r.offsetLeft, v = r.offsetTop);
  }
  return {
    width: s,
    height: u,
    x: f,
    y: v
  };
}
function Ns(e, t) {
  const a = wt(e, !0, t === "fixed"), n = a.top + e.clientTop, r = a.left + e.clientLeft, s = Xe(e) ? Dt(e) : ct(1), u = e.clientWidth * s.x, f = e.clientHeight * s.y, v = r * s.x, g = n * s.y;
  return {
    width: u,
    height: f,
    x: v,
    y: g
  };
}
function Un(e, t, a) {
  let n;
  if (t === "viewport")
    n = Hs(e, a);
  else if (t === "document")
    n = Os(at(e));
  else if (Re(t))
    n = Ns(t, a);
  else {
    const r = gr(e);
    n = {
      ...t,
      x: t.x - r.x,
      y: t.y - r.y
    };
  }
  return Vt(n);
}
function br(e, t) {
  const a = dt(e);
  return a === t || !Re(a) || Ot(a) ? !1 : Fe(a).position === "fixed" || br(a, t);
}
function Es(e, t) {
  const a = t.get(e);
  if (a)
    return a;
  let n = ta(e, [], !1).filter((f) => Re(f) && Et(f) !== "body"), r = null;
  const s = Fe(e).position === "fixed";
  let u = s ? dt(e) : e;
  for (; Re(u) && !Ot(u); ) {
    const f = Fe(u), v = Hn(u);
    !v && f.position === "fixed" && (r = null), (s ? !v && !r : !v && f.position === "static" && !!r && ["absolute", "fixed"].includes(r.position) || aa(u) && !v && br(e, u)) ? n = n.filter((m) => m !== u) : r = f, u = dt(u);
  }
  return t.set(e, n), n;
}
function Is(e) {
  let {
    element: t,
    boundary: a,
    rootBoundary: n,
    strategy: r
  } = e;
  const u = [...a === "clippingAncestors" ? cn(t) ? [] : Es(t, this._c) : [].concat(a), n], f = u[0], v = u.reduce((g, m) => {
    const y = Un(t, m, r);
    return g.top = Ue(y.top, g.top), g.right = tt(y.right, g.right), g.bottom = tt(y.bottom, g.bottom), g.left = Ue(y.left, g.left), g;
  }, Un(t, f, r));
  return {
    width: v.right - v.left,
    height: v.bottom - v.top,
    x: v.left,
    y: v.top
  };
}
function Rs(e) {
  const {
    width: t,
    height: a
  } = mr(e);
  return {
    width: t,
    height: a
  };
}
function Fs(e, t, a) {
  const n = Xe(t), r = at(t), s = a === "fixed", u = wt(e, !0, s, t);
  let f = {
    scrollLeft: 0,
    scrollTop: 0
  };
  const v = ct(0);
  if (n || !n && !s)
    if ((Et(t) !== "body" || aa(r)) && (f = dn(t)), n) {
      const y = wt(t, !0, s, t);
      v.x = y.x + t.clientLeft, v.y = y.y + t.clientTop;
    } else r && (v.x = vr(r));
  const g = u.left + f.scrollLeft - v.x, m = u.top + f.scrollTop - v.y;
  return {
    x: g,
    y: m,
    width: u.width,
    height: u.height
  };
}
function gn(e) {
  return Fe(e).position === "static";
}
function Kn(e, t) {
  return !Xe(e) || Fe(e).position === "fixed" ? null : t ? t(e) : e.offsetParent;
}
function pr(e, t) {
  const a = Pe(e);
  if (cn(e))
    return a;
  if (!Xe(e)) {
    let r = dt(e);
    for (; r && !Ot(r); ) {
      if (Re(r) && !gn(r))
        return r;
      r = dt(r);
    }
    return a;
  }
  let n = Kn(e, t);
  for (; n && Ds(n) && gn(n); )
    n = Kn(n, t);
  return n && Ot(n) && gn(n) && !Hn(n) ? a : n || Ts(e) || a;
}
const Ws = async function(e) {
  const t = this.getOffsetParent || pr, a = this.getDimensions, n = await a(e.floating);
  return {
    reference: Fs(e.reference, await t(e.floating), e.strategy),
    floating: {
      x: 0,
      y: 0,
      width: n.width,
      height: n.height
    }
  };
};
function qs(e) {
  return Fe(e).direction === "rtl";
}
const Gs = {
  convertOffsetParentRelativeRectToViewportRelativeRect: As,
  getDocumentElement: at,
  getClippingRect: Is,
  getOffsetParent: pr,
  getElementRects: Ws,
  getClientRects: Vs,
  getDimensions: Rs,
  getScale: Dt,
  isElement: Re,
  isRTL: qs
};
function Ys(e, t) {
  let a = null, n;
  const r = at(e);
  function s() {
    var f;
    clearTimeout(n), (f = a) == null || f.disconnect(), a = null;
  }
  function u(f, v) {
    f === void 0 && (f = !1), v === void 0 && (v = 1), s();
    const {
      left: g,
      top: m,
      width: y,
      height: d
    } = e.getBoundingClientRect();
    if (f || t(), !y || !d)
      return;
    const h = ia(m), p = ia(r.clientWidth - (g + y)), w = ia(r.clientHeight - (m + d)), b = ia(g), D = {
      rootMargin: -h + "px " + -p + "px " + -w + "px " + -b + "px",
      threshold: Ue(0, tt(1, v)) || 1
    };
    let C = !0;
    function L(B) {
      const A = B[0].intersectionRatio;
      if (A !== v) {
        if (!C)
          return u();
        A ? u(!1, A) : n = setTimeout(() => {
          u(!1, 1e-7);
        }, 1e3);
      }
      C = !1;
    }
    try {
      a = new IntersectionObserver(L, {
        ...D,
        // Handle <iframe>s
        root: r.ownerDocument
      });
    } catch {
      a = new IntersectionObserver(L, D);
    }
    a.observe(e);
  }
  return u(!0), s;
}
function js(e, t, a, n) {
  n === void 0 && (n = {});
  const {
    ancestorScroll: r = !0,
    ancestorResize: s = !0,
    elementResize: u = typeof ResizeObserver == "function",
    layoutShift: f = typeof IntersectionObserver == "function",
    animationFrame: v = !1
  } = n, g = En(e), m = r || s ? [...g ? ta(g) : [], ...ta(t)] : [];
  m.forEach((k) => {
    r && k.addEventListener("scroll", a, {
      passive: !0
    }), s && k.addEventListener("resize", a);
  });
  const y = g && f ? Ys(g, a) : null;
  let d = -1, h = null;
  u && (h = new ResizeObserver((k) => {
    let [D] = k;
    D && D.target === g && h && (h.unobserve(t), cancelAnimationFrame(d), d = requestAnimationFrame(() => {
      var C;
      (C = h) == null || C.observe(t);
    })), a();
  }), g && !v && h.observe(g), h.observe(t));
  let p, w = v ? wt(e) : null;
  v && b();
  function b() {
    const k = wt(e);
    w && (k.x !== w.x || k.y !== w.y || k.width !== w.width || k.height !== w.height) && a(), w = k, p = requestAnimationFrame(b);
  }
  return a(), () => {
    var k;
    m.forEach((D) => {
      r && D.removeEventListener("scroll", a), s && D.removeEventListener("resize", a);
    }), y?.(), (k = h) == null || k.disconnect(), h = null, v && cancelAnimationFrame(p);
  };
}
const Us = Ls, Ks = ks, _s = zs, Xs = Ms, Qs = ws, Zs = Ss, Js = (e, t, a) => {
  const n = /* @__PURE__ */ new Map(), r = {
    platform: Gs,
    ...a
  }, s = {
    ...r.platform,
    _c: n
  };
  return ps(e, t, {
    ...r,
    platform: s
  });
}, it = (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  setup(e, { slots: t }) {
    const a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1);
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      a.value = !0;
    }), () => a.value && t.default ? t.default() : null;
  }
});
function el(e) {
  return { all: e = e || /* @__PURE__ */ new Map(), on: function(t, a) {
    var n = e.get(t);
    n ? n.push(a) : e.set(t, [a]);
  }, off: function(t, a) {
    var n = e.get(t);
    n && (a ? n.splice(n.indexOf(a) >>> 0, 1) : e.set(t, []));
  }, emit: function(t, a) {
    var n = e.get(t);
    n && n.slice().map(function(r) {
      r(a);
    }), (n = e.get("*")) && n.slice().map(function(r) {
      r(t, a);
    });
  } };
}
const tl = { class: "inline-block" }, _e = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsFloatingUi",
  __name: "FloatingUi",
  props: {
    disabled: { type: Boolean, default: !1 },
    placement: { type: String, default: "auto" },
    strategy: { type: String, default: "absolute" },
    overflowPadding: { type: Number, default: 5 },
    arrowPadding: { type: Number, default: 5 },
    offset: { type: Number, default: 10 },
    inline: { type: Boolean, default: !1 },
    shift: { type: Boolean, default: !1 },
    disableAnimation: { type: Boolean, default: !1 },
    animationEnterActiveClass: { type: String, default: "transition duration-75 ease-out" },
    animationEnterFromClass: { type: String, default: "transform scale-95 opacity-0" },
    animationEnterToClass: { type: String, default: "transform scale-100 opacity-100" },
    animationLeaveActiveClass: { type: String, default: "transition duration-50 ease-in" },
    animationLeaveFromClass: { type: String, default: "transform scale-100 opacity-100" },
    animationLeaveToClass: { type: String, default: "transform scale-95 opacity-0" },
    popperClass: { type: [String, Array, Object], default: void 0 },
    hideArrow: { type: Boolean, default: !1 },
    arrowClass: { type: String, default: void 0 },
    placementTopArrowClass: { type: String, default: void 0 },
    placementRightArrowClass: { type: String, default: void 0 },
    placementBottomArrowClass: { type: String, default: void 0 },
    placementLeftArrowClass: { type: String, default: void 0 },
    willOpen: { type: Function, default: null },
    willClose: { type: Function, default: null }
  },
  setup(e) {
    const t = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)({ left: "0px", top: "0px" }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)({ left: "0px", top: "0px" }), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(""), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), m = (L) => new Promise((B) => (v.value && clearTimeout(v.value), v.value = setTimeout(B, L), v.value)), y = (L) => new Promise(async (B, A) => L ? await L(B, A) : B()), d = async (L = 0) => {
      if (!b.disabled)
        try {
          if (g.value = !0, await m(L), g.value) {
            if (await y(b.willOpen), r.value || !g.value) return;
            g.value = !1, r.value = !0;
          }
        } catch {
          g.value = !1;
        }
    }, h = async (L = 0) => {
      try {
        if (g.value = !1, await m(L), await y(b.willClose), !r.value) return;
        r.value = !1;
      } catch {
        return;
      }
    }, p = async (L = 0, B = 0) => {
      r.value ? h(B) : d(L);
    }, w = el();
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.provide)("emitter", w), w.on("floating-ui-toggle", (L) => {
      L ? r.value || d() : r.value && h();
    }), on(a, (L) => {
      t.value && L.target && t.value?.contains(L.target) || r.value && h();
    }), ea("Escape", (L) => {
      r.value && (L.preventDefault(), h());
    });
    const b = e, k = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => f.value ? f.value.includes("top") ? b.placementTopArrowClass : f.value.includes("right") ? b.placementRightArrowClass : f.value.includes("bottom") ? b.placementBottomArrowClass : f.value.includes("left") ? b.placementLeftArrowClass : "" : ""), D = async () => {
      if (!t.value || !a.value) return;
      const L = {
        middleware: [],
        placement: b.placement,
        strategy: b.strategy
      }, B = b.placement.startsWith("auto");
      b.offset && L.middleware.push(Us(b.offset)), B ? L.middleware.push(Ks({
        alignment: b.placement.split("-")[1] ?? ""
      })) : L.placement = b.placement, b.inline && L.middleware.push(Zs()), B || L.middleware.push(Xs({
        padding: b.overflowPadding
      })), b.shift && L.middleware.push(_s({
        padding: b.overflowPadding
      })), !b.hideArrow && n.value && L.middleware.push(Qs({
        element: n.value,
        padding: b.arrowPadding
      }));
      const A = await Js(t.value, a.value, L), { x: E, y: M, placement: H, middlewareData: P } = A;
      if (s.value = {
        left: E ? `${E}px` : "",
        top: M ? `${M}px` : ""
      }, !b.hideArrow) {
        const { x: G, y: oe } = P.arrow;
        f.value = H, u.value = {
          left: G ? `${G}px` : "",
          top: oe ? `${oe}px` : ""
        };
      }
    };
    let C = null;
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(r, (L) => {
      L ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        D(), t.value && a.value && (C = js(t.value, a.value, D));
      }) : C && C();
    }), (L, B) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", tl, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
        ref_key: "triggerRef",
        ref: t,
        class: "inline-block w-full"
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(L.$slots, "trigger", {
          isOpen: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r),
          open: d,
          close: h,
          toggle: p
        })
      ], 512),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(it, null, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Teleport, { to: "body" }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
              css: !e.disableAnimation,
              "enter-active-class": e.animationEnterActiveClass,
              "enter-from-class": e.animationEnterFromClass,
              "enter-to-class": e.animationEnterToClass,
              "leave-active-class": e.animationLeaveActiveClass,
              "leave-from-class": e.animationLeaveFromClass,
              "leave-to-class": e.animationLeaveToClass
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                  key: 0,
                  ref_key: "popperRef",
                  ref: a,
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(e.popperClass),
                  style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s))
                }, [
                  e.hideArrow ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                    key: 0,
                    ref_key: "arrowRef",
                    ref: n,
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([e.arrowClass, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(k)]),
                    style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u))
                  }, null, 6)),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(L.$slots, "default", {
                    isOpen: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r),
                    open: d,
                    close: h,
                    toggle: p
                  })
                ], 6)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ]),
              _: 3
            }, 8, ["css", "enter-active-class", "enter-from-class", "enter-to-class", "leave-active-class", "leave-from-class", "leave-to-class"])
          ]))
        ]),
        _: 3
      })
    ]));
  }
}), _n = () => Date.now().toString(36) + Math.random().toString(36).substring(2), We = {
  created(e) {
    e.setAttribute("id", e.id || _n());
  },
  getSSRProps() {
    return {
      id: _n()
    };
  }
}, al = ["aria-expanded", "disabled", "onClick"], nl = {
  key: 0,
  class: "inline-block self-center w-5 h-5 -mr-1",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 20 20",
  fill: "currentColor"
}, rl = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  "fill-rule": "evenodd",
  d: "M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z",
  "clip-rule": "evenodd"
}, null, -1), sl = [
  rl
], ll = ["aria-labelledby"], da = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsActionButton",
  directives: {
    uid: We
  },
  __name: "ActionDropdown",
  props: {
    /**
     * The content of the dropdown trigger.
     */
    title: { type: String, default: "" },
    /**
     * Determines the purpose and particular function of the button trigger.
     */
    kind: { type: String, default: "ghost" },
    /**
     * Styling for the button trigger.
     */
    variant: { type: String, default: "gray" },
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" },
    /**
     * The distance between the popper and the trigger.
     */
    offset: { type: Number, default: 5 },
    /**
     * Delays opening the toggle in ms.
     */
    openDelay: { type: Number, default: 0 },
    /**
     * Delays closing the toggle in ms.
     */
    closeDelay: { type: Number, default: 0 },
    /**
     * Determines the size of the trigger button.
     */
    size: { type: String, default: "sm" },
    /**
     * Determines if the arrow should display or not.
     */
    hideArrow: { type: Boolean, default: !1 },
    /**
     * Determines whether the content of the popper will set the width of the popper.
     */
    auto: { type: Boolean, default: !1 },
    /**
     * The strategy of the popover on the screen.
     */
    strategy: { type: String, default: "absolute" },
    /**
     * The placement of the popover on the screen.
     */
    placement: { type: String, default: "bottom-start" },
    /**
     * Determines whether to use the block styling on the trigger button or not.
     */
    block: { type: Boolean, default: !1 },
    /**
     * Determines if the popover should display or not.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Allows for code execution prior to opening the popover.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the popover from opening
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willOpen(open, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the open process continue
     *    open()
     *  } catch (e) {
     *    // cancel the open process
     *    cancel()
     *  }
     * }
     * ```
     */
    willOpen: { type: Function, default: null },
    /**
     * Allows for code execution prior to closing the popover.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the popover from closing
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willClose(close, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the close process continue
     *    close()
     *  } catch (e) {
     *    // cancel the close process
     *    cancel()
     *  }
     * }
     * ```
     */
    willClose: { type: Function, default: null }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), n = (y, d, h) => {
      y ? h(t.closeDelay) : d(t.openDelay);
    }, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.size) {
        case "lg":
          return "action-btn-lg";
        case "md":
          return "action-btn-md";
        case "sm":
          return "action-btn-sm";
        case "xs":
          return "action-btn-xs";
        default:
          return "";
      }
    }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.kind ? "action-btn" : ""), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.kind) {
        case "primary":
          return "action-btn-primary";
        case "secondary":
          return "action-btn-secondary";
        case "ghost":
          return "action-btn-ghost";
        default:
          return "";
      }
    }), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.variant) {
        case "gray":
          return "action-btn-gray";
        case "red":
          return "action-btn-red";
        case "blue":
          return "action-btn-blue";
        default:
          return "";
      }
    }), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.disabled ? "disabled" : ""), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.block ? "action-btn-block" : "");
    return (y, d) => {
      const h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(_e, {
        "data-id": "sds-action-dropdown",
        offset: e.offset,
        strategy: e.strategy,
        placement: e.placement,
        disabled: e.disabled,
        "will-open": e.willOpen,
        "will-close": e.willClose,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([e.block ? "w-full" : ""]),
        "popper-class": {
          "bg-white absolute border shadow-lg rounded-md bg-white dark:border-gray-700 dark:bg-gray-850": !0,
          [e.auto ? "w-auto" : "w-56"]: !0,
          [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]: !0
        },
        "hide-arrow": "",
        shift: ""
      }, {
        trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: p, close: w, isOpen: b, toggle: k }) => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(y.$slots, "trigger", {
            open: p,
            close: w,
            isOpen: b,
            toggle: k
          }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
              ref_key: "button",
              ref: a,
              type: "button",
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["space-x", [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m),
                b && "active"
              ]]),
              "aria-haspopup": "true",
              "aria-expanded": b,
              disabled: e.disabled,
              onClick: (D) => n(b, p, w)
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(y.$slots, "title", {}, () => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.title), 1)
              ]),
              e.hideArrow ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", nl, sl))
            ], 10, al)), [
              [h]
            ])
          ])
        ]),
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: p, close: w, toggle: b, isOpen: k }) => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
            class: "py-2 rounded",
            "aria-orientation": "vertical",
            "aria-labelledby": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a).id || void 0
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(y.$slots, "default", {
              close: w,
              open: p,
              toggle: b,
              isOpen: k
            })
          ], 8, ll)
        ]),
        _: 3
      }, 8, ["offset", "strategy", "placement", "disabled", "will-open", "will-close", "class", "popper-class"]);
    };
  }
});
da.install = (e) => {
  e.component(da.name, da);
};
const ol = ["aria-label"], il = ["title"], cl = ["title"], ua = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsAvatar",
  __name: "Avatar",
  props: {
    /**
     * Determines the background color of the avatar when no image is present.
     */
    variant: {
      type: String,
      default: "gray"
    },
    /**
     * Determines the position of the image.
     */
    position: {
      type: String,
      default: "center"
    },
    /**
     * Determines the shape of the avatar.
     */
    shape: {
      type: String,
      default: "portrait"
    },
    /**
     * Determines the size of the avatar.
     */
    size: {
      type: String,
      default: "md"
    },
    /**
     * Determines the text name (ex. John Doe) will show "JD" initials as a placeholder when no image is present.
     * 
     * The full name, "John Doe" will display on hover with or without an image present.
     */
    name: {
      type: String,
      default: ""
    },
    /**
     * Set the image of the avatar.
     */
    src: {
      type: String,
      default: ""
    }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.position) {
        case "bottom":
          return "bg-bottom";
        case "left":
          return "bg-left";
        case "right":
          return "bg-right";
        case "top":
          return "bg-top";
        case "center":
        default:
          return "bg-center";
      }
    }), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      if (t.shape === "circle")
        switch (t.size) {
          case "lg":
            return "w-44";
          case "md":
            return "w-16";
          case "sm":
            return "w-12";
          case "xs":
            return "w-8";
        }
      else if (t.shape === "portrait")
        switch (t.size) {
          case "lg":
            return "w-44";
          case "md":
            return "w-16";
          case "sm":
            return "w-10";
          case "xs":
            return "w-6";
        }
      return "w-full";
    }), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.size === "lg" ? "text-6xl font-light" : t.size === "sm" ? "text-xl font-medium" : t.size === "xs" ? "text-sm font-semibold" : "text-2xl"), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.shape === "circle" ? "rounded-full aspect-square" : "aspect-[4/5]"), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      const v = [
        "bg-gray-100 dark:text-gray-400 dark:bg-gray-900",
        "bg-red-100 dark:text-red-500 dark:bg-red-900",
        "bg-yellow-25 dark:text-yellow-400 dark:bg-yellow-900",
        "bg-green-50 dark:text-green-400 dark:bg-green-900",
        "bg-blue-50 dark:text-blue-400 dark:bg-blue-900",
        "bg-purple-100 dark:text-purple-400 dark:bg-purple-900"
      ];
      if (t.variant && t.variant !== "random")
        return v.filter((g) => g.includes(t.variant))[0];
      {
        const g = Math.floor(Math.random() * v.length);
        return v[g];
      }
    }), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      if (!t.name)
        return;
      let v = t.name.trim().toUpperCase();
      return v.length > 2 && (v.includes(" ") && (v = v.split(" ").map((g) => g[0]).join("")), v.length > 2) ? v.charAt(0) + v.charAt(v.length - 1) : v.substring(0, 2);
    });
    return (v, g) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      "data-id": "sds-avatar",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-flex items-center justify-center", (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s)]),
      role: "img",
      "aria-label": e.name || "Avatar"
    }, [
      e.src ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        key: 0,
        title: e.name,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["bg-cover", (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s)]),
        style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)(`background-image: url(${e.src})`)
      }, null, 14, il)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
        key: 1,
        title: e.name,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["leading-none text-black cursor-default uppercase", (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u)])
      }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f)), 11, cl))
    ], 10, ol));
  }
});
ua.install = (e) => {
  e.component(ua.name, ua);
};
const fa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsBadge",
  __name: "Badge",
  props: {
    /**
     * Determines the overall look and feel of the component.
     */
    type: {
      type: String,
      default: "medium"
    },
    /**
     * Determines the color of the component.
     */
    variant: {
      type: String,
      default: "gray"
    }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      let n = "", r = "", s = "";
      switch (t.type === "light-border" && (s = "border border-current"), t.variant) {
        case "blue":
          t.type === "light-border" || t.type === "light" ? (r = "bg-blue-25 dark:bg-blue-900", n = "text-blue-700 dark:text-blue-300") : t.type === "medium" ? (r = "bg-blue-500", n = "text-white dark:text-black") : t.type === "dark" && (r = "bg-blue-700 dark:bg-blue-800", n = "text-white dark:text-blue-50");
          break;
        case "green":
          t.type === "light-border" || t.type === "light" ? (r = "bg-green-25 dark:bg-green-900", n = "text-green-700 dark:text-green-300") : t.type === "medium" ? (r = "bg-green-500", n = "text-white dark:text-black") : t.type === "dark" && (r = "bg-green-700 dark:bg-green-800", n = "text-white dark:text-green-50");
          break;
        case "teal":
          t.type === "light-border" || t.type === "light" ? (r = "bg-teal-25 dark:bg-teal-900", n = "text-teal-700 dark:text-teal-300") : t.type === "medium" ? (r = "bg-teal-500", n = "text-white dark:text-black") : t.type === "dark" && (r = "bg-teal-700 dark:bg-teal-800", n = "text-white dark:text-teal-50");
          break;
        case "orange":
          t.type === "light-border" || t.type === "light" ? (r = "bg-orange-25 dark:bg-orange-900", n = "text-orange-900 dark:text-orange-300") : t.type === "medium" ? (r = "bg-orange-200", n = "text-orange-800 dark:text-black") : t.type === "dark" && (r = "bg-orange-500 dark:bg-orange-600", n = "text-white dark:text-orange-50");
          break;
        case "red":
          t.type === "light-border" || t.type === "light" ? (r = "bg-red-25 dark:bg-red-900", n = "text-red-600 dark:text-red-300") : t.type === "medium" ? (r = "bg-red-500", n = "text-white dark:text-black") : t.type === "dark" && (r = "bg-red-700 dark:bg-red-800", n = "text-white dark:text-red-100");
          break;
        case "tan":
          t.type === "light-border" || t.type === "light" ? (r = "bg-tan-50 dark:bg-tan-900", n = "text-tan-900 dark:text-tan-300") : t.type === "medium" ? (r = "bg-tan-200", n = "text-tan-900 dark:text-black") : t.type === "dark" && (r = "bg-tan-600 dark:bg-tan-700", n = "text-white dark:text-tan-50");
          break;
        case "yellow":
          t.type === "light-border" || t.type === "light" ? (r = "bg-yellow-25 dark:bg-yellow-900", n = "text-yellow-900 dark:text-yellow-300") : t.type === "medium" ? (r = "bg-yellow-100 dark:bg-yellow-200", n = "text-yellow-800 dark:text-black") : t.type === "dark" && (r = "bg-yellow-500 dark:bg-yellow-600", n = "text-white dark:text-yellow-25");
          break;
        case "purple":
          t.type === "light-border" || t.type === "light" ? (r = "bg-purple-25 dark:bg-purple-900", n = "text-purple-600 dark:text-purple-300") : t.type === "medium" ? (r = "bg-purple-500", n = "text-white dark:text-black") : t.type === "dark" && (r = "bg-purple-700 dark:bg-purple-800", n = "text-white dark:text-purple-50");
          break;
        case "indigo":
          t.type === "light-border" || t.type === "light" ? (r = "bg-indigo-25 dark:bg-indigo-900", n = "text-indigo-600 dark:text-indigo-300") : t.type === "medium" ? (r = "bg-indigo-500", n = "text-white dark:text-black") : t.type === "dark" && (r = "bg-indigo-700 dark:bg-indigo-800", n = "text-white dark:text-indigo-50");
          break;
        case "gray":
        default:
          t.type === "light-border" || t.type === "light" ? (r = "bg-gray-100 dark:bg-gray-900", n = "text-gray-700 dark:text-gray-300") : t.type === "medium" ? (r = "bg-gray-500 dark:bg-gray-400", n = "text-white dark:text-black") : t.type === "dark" && (r = "bg-gray-700", n = "text-white dark:text-gray-50");
          break;
      }
      return [n, r, s];
    });
    return (n, r) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      "data-id": "sds-badge",
      role: "status",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-flex items-center justify-center gap-1 tracking-wide max-w-full uppercase px-2 py-1 text-xs font-bold text-center text-ellipsis whitespace-nowrap overflow-hidden align-baseline rounded", (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)])
    }, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(n.$slots, "default")
    ], 2));
  }
});
fa.install = (e) => {
  e.component(fa.name, fa);
};
const dl = ["type", "disabled", "aria-disabled", "aria-busy"], ul = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("title", null, "Pending", -1), fl = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("circle", {
  class: "opacity-25",
  cx: "12",
  cy: "12",
  r: "10",
  stroke: "currentColor",
  "stroke-width": "4"
}, null, -1), hl = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  class: "opacity-75",
  fill: "currentColor",
  d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
}, null, -1), yl = [
  ul,
  fl,
  hl
], Tt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsButton",
  __name: "Button",
  props: {
    /**
     * Determines the purpose and particular function of the component.
     */
    kind: { type: String, default: "" },
    /**
     * Determines the color of the component.
     */
    variant: { type: String, default: "" },
    /**
     * Determines the HTML type attribute for the button.
     */
    type: { type: String, default: "button" },
    /**
     * Determines the size.
     */
    size: { type: String, default: "" },
    /**
     * Sets the active state of a button.
     */
    active: { type: Boolean, default: !1 },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines whether to use the block styling or not.
     */
    block: { type: Boolean, default: !1 },
    /**
     * Determines whether to display a loading indicator and set the button to an active state.
     */
    pending: { type: Boolean, default: !1 }
  },
  emits: ["click"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.kind ? "btn" : ""), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.kind) {
        case "primary":
          return "btn-primary";
        case "secondary":
          return "btn-secondary";
        case "tertiary":
          return "btn-tertiary";
        case "ghost":
          return "btn-ghost";
        default:
          return "";
      }
    }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.variant) {
        case "blue":
          return "btn-blue";
        case "red":
          return "btn-red";
        case "white":
          return "btn-white";
        default:
          return "";
      }
    }), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.size) {
        case "lg":
          return "btn-lg";
        case "sm":
          return "btn-sm";
        case "xs":
          return "btn-xs";
        default:
          return "";
      }
    }), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.disabled ? "disabled" : ""), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.active || a.pending ? "active" : ""), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      if (!a.pending) return "";
      switch (a.size) {
        case "lg":
          return "active pointer-events-none px-[2.375rem]";
        case "sm":
          return "active pointer-events-none px-[0.5125rem]";
        case "xs":
          return "active pointer-events-none px-[0.085rem]";
        case "md":
        default:
          return "active pointer-events-none px-[1.4379rem]";
      }
    }), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.block ? "btn-block" : ""), d = () => {
      a.pending || n("click");
    };
    return (h, p) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
      "data-id": "sds-button",
      type: e.type,
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(y), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)]),
      disabled: e.disabled,
      "aria-disabled": e.disabled,
      "aria-busy": e.pending,
      onClick: d
    }, [
      e.pending ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
        key: 0,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex items-center", {
          "gap-0.5": e.size === "xs",
          "gap-1": e.size !== "xs"
        }])
      }, [
        ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["animate-spin text-current", {
            "h-2.5 w-2.5": e.size === "xs",
            "h-3 w-3": e.size === "sm",
            "h-3.5 w-3.5": e.size === "md" || e.size === "",
            "h-4 w-4": e.size === "lg"
          }]),
          xmlns: "http://www.w3.org/2000/svg",
          fill: "none",
          viewBox: "0 0 24 24",
          role: "graphics-symbol"
        }, yl, 2)),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(h.$slots, "default")
      ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(h.$slots, "default", { key: 1 })
    ], 10, dl));
  }
});
Tt.install = (e) => {
  e.component(Tt.name, Tt);
};
function fe(e, t) {
  return e instanceof Date ? new e.constructor(t) : new Date(t);
}
function ml(e) {
  return fe(e, Date.now());
}
function Z(e) {
  const t = Object.prototype.toString.call(e);
  return e instanceof Date || typeof e == "object" && t === "[object Date]" ? new e.constructor(+e) : typeof e == "number" || t === "[object Number]" || typeof e == "string" || t === "[object String]" ? new Date(e) : /* @__PURE__ */ new Date(NaN);
}
function tn(e) {
  const t = Z(e);
  return t.setHours(0, 0, 0, 0), t;
}
function lt(e, t) {
  const a = tn(e), n = tn(t);
  return +a == +n;
}
function vn(e) {
  return lt(e, ml(e));
}
function gl(e, t) {
  const a = +Z(e), [n, r] = [
    +Z(t.start),
    +Z(t.end)
  ].sort((s, u) => s - u);
  return a >= n && a <= r;
}
function Mn(e, t) {
  const a = Z(e), n = Z(t);
  return +a < +n;
}
function gt(e, t) {
  const a = Z(e), n = Z(t);
  return a.getTime() > n.getTime();
}
function Cn(e, t) {
  const a = Z(e), n = Z(t);
  return +a == +n;
}
function De(e) {
  return e instanceof Date || typeof e == "object" && Object.prototype.toString.call(e) === "[object Date]";
}
function Sn(e) {
  let t;
  return e.forEach((a) => {
    const n = Z(a);
    (!t || t > n || isNaN(+n)) && (t = n);
  }), t || /* @__PURE__ */ new Date(NaN);
}
function $n(e) {
  let t;
  return e.forEach(function(a) {
    const n = Z(a);
    (t === void 0 || t < n || isNaN(Number(n))) && (t = n);
  }), t || /* @__PURE__ */ new Date(NaN);
}
function Xn(e) {
  const t = Z(e), a = t.getFullYear(), n = t.getMonth(), r = fe(e, 0);
  return r.setFullYear(a, n + 1, 0), r.setHours(0, 0, 0, 0), r.getDate();
}
function St(e) {
  const t = Z(e);
  return t.setDate(1), t.setHours(0, 0, 0, 0), t;
}
function Qn(e) {
  return Z(e).getDay();
}
function Ze(e) {
  return Z(e).getHours();
}
function $e(e, t) {
  const a = Z(e);
  return a.setDate(t), a;
}
function Me(e, t) {
  const a = Z(e);
  return a.setHours(t), a;
}
function Te(e, t) {
  const a = Z(e);
  return a.setMinutes(t), a;
}
function He(e, t) {
  const a = Z(e);
  return a.setSeconds(t), a;
}
function Ne(e, t) {
  const a = Z(e);
  return a.setMilliseconds(t), a;
}
function ot(e, t) {
  const a = Z(e);
  if (isNaN(t)) return fe(e, NaN);
  if (!t)
    return a;
  const n = a.getDate(), r = fe(e, a.getTime());
  r.setMonth(a.getMonth() + t + 1, 0);
  const s = r.getDate();
  return n >= s ? r : (a.setFullYear(
    r.getFullYear(),
    r.getMonth(),
    n
  ), a);
}
function Zn(e, t) {
  return ot(e, -t);
}
const vl = {
  lessThanXSeconds: {
    one: "less than a second",
    other: "less than {{count}} seconds"
  },
  xSeconds: {
    one: "1 second",
    other: "{{count}} seconds"
  },
  halfAMinute: "half a minute",
  lessThanXMinutes: {
    one: "less than a minute",
    other: "less than {{count}} minutes"
  },
  xMinutes: {
    one: "1 minute",
    other: "{{count}} minutes"
  },
  aboutXHours: {
    one: "about 1 hour",
    other: "about {{count}} hours"
  },
  xHours: {
    one: "1 hour",
    other: "{{count}} hours"
  },
  xDays: {
    one: "1 day",
    other: "{{count}} days"
  },
  aboutXWeeks: {
    one: "about 1 week",
    other: "about {{count}} weeks"
  },
  xWeeks: {
    one: "1 week",
    other: "{{count}} weeks"
  },
  aboutXMonths: {
    one: "about 1 month",
    other: "about {{count}} months"
  },
  xMonths: {
    one: "1 month",
    other: "{{count}} months"
  },
  aboutXYears: {
    one: "about 1 year",
    other: "about {{count}} years"
  },
  xYears: {
    one: "1 year",
    other: "{{count}} years"
  },
  overXYears: {
    one: "over 1 year",
    other: "over {{count}} years"
  },
  almostXYears: {
    one: "almost 1 year",
    other: "almost {{count}} years"
  }
}, bl = (e, t, a) => {
  let n;
  const r = vl[e];
  return typeof r == "string" ? n = r : t === 1 ? n = r.one : n = r.other.replace("{{count}}", t.toString()), a?.addSuffix ? a.comparison && a.comparison > 0 ? "in " + n : n + " ago" : n;
};
function bn(e) {
  return (t = {}) => {
    const a = t.width ? String(t.width) : e.defaultWidth;
    return e.formats[a] || e.formats[e.defaultWidth];
  };
}
const pl = {
  full: "EEEE, MMMM do, y",
  long: "MMMM do, y",
  medium: "MMM d, y",
  short: "MM/dd/yyyy"
}, wl = {
  full: "h:mm:ss a zzzz",
  long: "h:mm:ss a z",
  medium: "h:mm:ss a",
  short: "h:mm a"
}, xl = {
  full: "{{date}} 'at' {{time}}",
  long: "{{date}} 'at' {{time}}",
  medium: "{{date}}, {{time}}",
  short: "{{date}}, {{time}}"
}, kl = {
  date: bn({
    formats: pl,
    defaultWidth: "full"
  }),
  time: bn({
    formats: wl,
    defaultWidth: "full"
  }),
  dateTime: bn({
    formats: xl,
    defaultWidth: "full"
  })
}, Ml = {
  lastWeek: "'last' eeee 'at' p",
  yesterday: "'yesterday at' p",
  today: "'today at' p",
  tomorrow: "'tomorrow at' p",
  nextWeek: "eeee 'at' p",
  other: "P"
}, Cl = (e, t, a, n) => Ml[e];
function Ft(e) {
  return (t, a) => {
    const n = a?.context ? String(a.context) : "standalone";
    let r;
    if (n === "formatting" && e.formattingValues) {
      const u = e.defaultFormattingWidth || e.defaultWidth, f = a?.width ? String(a.width) : u;
      r = e.formattingValues[f] || e.formattingValues[u];
    } else {
      const u = e.defaultWidth, f = a?.width ? String(a.width) : e.defaultWidth;
      r = e.values[f] || e.values[u];
    }
    const s = e.argumentCallback ? e.argumentCallback(t) : t;
    return r[s];
  };
}
const Sl = {
  narrow: ["B", "A"],
  abbreviated: ["BC", "AD"],
  wide: ["Before Christ", "Anno Domini"]
}, $l = {
  narrow: ["1", "2", "3", "4"],
  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
}, Ll = {
  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
  abbreviated: [
    "Jan",
    "Feb",
    "Mar",
    "Apr",
    "May",
    "Jun",
    "Jul",
    "Aug",
    "Sep",
    "Oct",
    "Nov",
    "Dec"
  ],
  wide: [
    "January",
    "February",
    "March",
    "April",
    "May",
    "June",
    "July",
    "August",
    "September",
    "October",
    "November",
    "December"
  ]
}, zl = {
  narrow: ["S", "M", "T", "W", "T", "F", "S"],
  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
  wide: [
    "Sunday",
    "Monday",
    "Tuesday",
    "Wednesday",
    "Thursday",
    "Friday",
    "Saturday"
  ]
}, Dl = {
  narrow: {
    am: "a",
    pm: "p",
    midnight: "mi",
    noon: "n",
    morning: "morning",
    afternoon: "afternoon",
    evening: "evening",
    night: "night"
  },
  abbreviated: {
    am: "AM",
    pm: "PM",
    midnight: "midnight",
    noon: "noon",
    morning: "morning",
    afternoon: "afternoon",
    evening: "evening",
    night: "night"
  },
  wide: {
    am: "a.m.",
    pm: "p.m.",
    midnight: "midnight",
    noon: "noon",
    morning: "morning",
    afternoon: "afternoon",
    evening: "evening",
    night: "night"
  }
}, Tl = {
  narrow: {
    am: "a",
    pm: "p",
    midnight: "mi",
    noon: "n",
    morning: "in the morning",
    afternoon: "in the afternoon",
    evening: "in the evening",
    night: "at night"
  },
  abbreviated: {
    am: "AM",
    pm: "PM",
    midnight: "midnight",
    noon: "noon",
    morning: "in the morning",
    afternoon: "in the afternoon",
    evening: "in the evening",
    night: "at night"
  },
  wide: {
    am: "a.m.",
    pm: "p.m.",
    midnight: "midnight",
    noon: "noon",
    morning: "in the morning",
    afternoon: "in the afternoon",
    evening: "in the evening",
    night: "at night"
  }
}, Bl = (e, t) => {
  const a = Number(e), n = a % 100;
  if (n > 20 || n < 10)
    switch (n % 10) {
      case 1:
        return a + "st";
      case 2:
        return a + "nd";
      case 3:
        return a + "rd";
    }
  return a + "th";
}, Pl = {
  ordinalNumber: Bl,
  era: Ft({
    values: Sl,
    defaultWidth: "wide"
  }),
  quarter: Ft({
    values: $l,
    defaultWidth: "wide",
    argumentCallback: (e) => e - 1
  }),
  month: Ft({
    values: Ll,
    defaultWidth: "wide"
  }),
  day: Ft({
    values: zl,
    defaultWidth: "wide"
  }),
  dayPeriod: Ft({
    values: Dl,
    defaultWidth: "wide",
    formattingValues: Tl,
    defaultFormattingWidth: "wide"
  })
};
function Wt(e) {
  return (t, a = {}) => {
    const n = a.width, r = n && e.matchPatterns[n] || e.matchPatterns[e.defaultMatchWidth], s = t.match(r);
    if (!s)
      return null;
    const u = s[0], f = n && e.parsePatterns[n] || e.parsePatterns[e.defaultParseWidth], v = Array.isArray(f) ? Vl(f, (y) => y.test(u)) : (
      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
      Al(f, (y) => y.test(u))
    );
    let g;
    g = e.valueCallback ? e.valueCallback(v) : v, g = a.valueCallback ? (
      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
      a.valueCallback(g)
    ) : g;
    const m = t.slice(u.length);
    return { value: g, rest: m };
  };
}
function Al(e, t) {
  for (const a in e)
    if (Object.prototype.hasOwnProperty.call(e, a) && t(e[a]))
      return a;
}
function Vl(e, t) {
  for (let a = 0; a < e.length; a++)
    if (t(e[a]))
      return a;
}
function Ol(e) {
  return (t, a = {}) => {
    const n = t.match(e.matchPattern);
    if (!n) return null;
    const r = n[0], s = t.match(e.parsePattern);
    if (!s) return null;
    let u = e.valueCallback ? e.valueCallback(s[0]) : s[0];
    u = a.valueCallback ? a.valueCallback(u) : u;
    const f = t.slice(r.length);
    return { value: u, rest: f };
  };
}
const Hl = /^(\d+)(th|st|nd|rd)?/i, Nl = /\d+/i, El = {
  narrow: /^(b|a)/i,
  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
  wide: /^(before christ|before common era|anno domini|common era)/i
}, Il = {
  any: [/^b/i, /^(a|c)/i]
}, Rl = {
  narrow: /^[1234]/i,
  abbreviated: /^q[1234]/i,
  wide: /^[1234](th|st|nd|rd)? quarter/i
}, Fl = {
  any: [/1/i, /2/i, /3/i, /4/i]
}, Wl = {
  narrow: /^[jfmasond]/i,
  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
}, ql = {
  narrow: [
    /^j/i,
    /^f/i,
    /^m/i,
    /^a/i,
    /^m/i,
    /^j/i,
    /^j/i,
    /^a/i,
    /^s/i,
    /^o/i,
    /^n/i,
    /^d/i
  ],
  any: [
    /^ja/i,
    /^f/i,
    /^mar/i,
    /^ap/i,
    /^may/i,
    /^jun/i,
    /^jul/i,
    /^au/i,
    /^s/i,
    /^o/i,
    /^n/i,
    /^d/i
  ]
}, Gl = {
  narrow: /^[smtwf]/i,
  short: /^(su|mo|tu|we|th|fr|sa)/i,
  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
}, Yl = {
  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
}, jl = {
  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
}, Ul = {
  any: {
    am: /^a/i,
    pm: /^p/i,
    midnight: /^mi/i,
    noon: /^no/i,
    morning: /morning/i,
    afternoon: /afternoon/i,
    evening: /evening/i,
    night: /night/i
  }
}, Kl = {
  ordinalNumber: Ol({
    matchPattern: Hl,
    parsePattern: Nl,
    valueCallback: (e) => parseInt(e, 10)
  }),
  era: Wt({
    matchPatterns: El,
    defaultMatchWidth: "wide",
    parsePatterns: Il,
    defaultParseWidth: "any"
  }),
  quarter: Wt({
    matchPatterns: Rl,
    defaultMatchWidth: "wide",
    parsePatterns: Fl,
    defaultParseWidth: "any",
    valueCallback: (e) => e + 1
  }),
  month: Wt({
    matchPatterns: Wl,
    defaultMatchWidth: "wide",
    parsePatterns: ql,
    defaultParseWidth: "any"
  }),
  day: Wt({
    matchPatterns: Gl,
    defaultMatchWidth: "wide",
    parsePatterns: Yl,
    defaultParseWidth: "any"
  }),
  dayPeriod: Wt({
    matchPatterns: jl,
    defaultMatchWidth: "any",
    parsePatterns: Ul,
    defaultParseWidth: "any"
  })
}, wr = {
  code: "en-US",
  formatDistance: bl,
  formatLong: kl,
  formatRelative: Cl,
  localize: Pl,
  match: Kl,
  options: {
    weekStartsOn: 0,
    firstWeekContainsDate: 1
  }
};
let _l = {};
function It() {
  return _l;
}
const xr = 6048e5, Xl = 864e5, Ql = 6e4, Zl = 36e5, Jl = 1e3;
function an(e) {
  const t = Z(e), a = new Date(
    Date.UTC(
      t.getFullYear(),
      t.getMonth(),
      t.getDate(),
      t.getHours(),
      t.getMinutes(),
      t.getSeconds(),
      t.getMilliseconds()
    )
  );
  return a.setUTCFullYear(t.getFullYear()), +e - +a;
}
function eo(e, t) {
  const a = tn(e), n = tn(t), r = +a - an(a), s = +n - an(n);
  return Math.round((r - s) / Xl);
}
function to(e) {
  const t = Z(e), a = fe(e, 0);
  return a.setFullYear(t.getFullYear(), 0, 1), a.setHours(0, 0, 0, 0), a;
}
function ao(e) {
  const t = Z(e);
  return eo(t, to(t)) + 1;
}
function ut(e, t) {
  const a = It(), n = t?.weekStartsOn ?? t?.locale?.options?.weekStartsOn ?? a.weekStartsOn ?? a.locale?.options?.weekStartsOn ?? 0, r = Z(e), s = r.getDay(), u = (s < n ? 7 : 0) + s - n;
  return r.setDate(r.getDate() - u), r.setHours(0, 0, 0, 0), r;
}
function Ht(e) {
  return ut(e, { weekStartsOn: 1 });
}
function kr(e) {
  const t = Z(e), a = t.getFullYear(), n = fe(e, 0);
  n.setFullYear(a + 1, 0, 4), n.setHours(0, 0, 0, 0);
  const r = Ht(n), s = fe(e, 0);
  s.setFullYear(a, 0, 4), s.setHours(0, 0, 0, 0);
  const u = Ht(s);
  return t.getTime() >= r.getTime() ? a + 1 : t.getTime() >= u.getTime() ? a : a - 1;
}
function no(e) {
  const t = kr(e), a = fe(e, 0);
  return a.setFullYear(t, 0, 4), a.setHours(0, 0, 0, 0), Ht(a);
}
function Mr(e) {
  const t = Z(e), a = +Ht(t) - +no(t);
  return Math.round(a / xr) + 1;
}
function In(e, t) {
  const a = Z(e), n = a.getFullYear(), r = It(), s = t?.firstWeekContainsDate ?? t?.locale?.options?.firstWeekContainsDate ?? r.firstWeekContainsDate ?? r.locale?.options?.firstWeekContainsDate ?? 1, u = fe(e, 0);
  u.setFullYear(n + 1, 0, s), u.setHours(0, 0, 0, 0);
  const f = ut(u, t), v = fe(e, 0);
  v.setFullYear(n, 0, s), v.setHours(0, 0, 0, 0);
  const g = ut(v, t);
  return a.getTime() >= f.getTime() ? n + 1 : a.getTime() >= g.getTime() ? n : n - 1;
}
function ro(e, t) {
  const a = It(), n = t?.firstWeekContainsDate ?? t?.locale?.options?.firstWeekContainsDate ?? a.firstWeekContainsDate ?? a.locale?.options?.firstWeekContainsDate ?? 1, r = In(e, t), s = fe(e, 0);
  return s.setFullYear(r, 0, n), s.setHours(0, 0, 0, 0), ut(s, t);
}
function Cr(e, t) {
  const a = Z(e), n = +ut(a, t) - +ro(a, t);
  return Math.round(n / xr) + 1;
}
function ce(e, t) {
  const a = e < 0 ? "-" : "", n = Math.abs(e).toString().padStart(t, "0");
  return a + n;
}
const st = {
  // Year
  y(e, t) {
    const a = e.getFullYear(), n = a > 0 ? a : 1 - a;
    return ce(t === "yy" ? n % 100 : n, t.length);
  },
  // Month
  M(e, t) {
    const a = e.getMonth();
    return t === "M" ? String(a + 1) : ce(a + 1, 2);
  },
  // Day of the month
  d(e, t) {
    return ce(e.getDate(), t.length);
  },
  // AM or PM
  a(e, t) {
    const a = e.getHours() / 12 >= 1 ? "pm" : "am";
    switch (t) {
      case "a":
      case "aa":
        return a.toUpperCase();
      case "aaa":
        return a;
      case "aaaaa":
        return a[0];
      case "aaaa":
      default:
        return a === "am" ? "a.m." : "p.m.";
    }
  },
  // Hour [1-12]
  h(e, t) {
    return ce(e.getHours() % 12 || 12, t.length);
  },
  // Hour [0-23]
  H(e, t) {
    return ce(e.getHours(), t.length);
  },
  // Minute
  m(e, t) {
    return ce(e.getMinutes(), t.length);
  },
  // Second
  s(e, t) {
    return ce(e.getSeconds(), t.length);
  },
  // Fraction of second
  S(e, t) {
    const a = t.length, n = e.getMilliseconds(), r = Math.trunc(
      n * Math.pow(10, a - 3)
    );
    return ce(r, t.length);
  }
}, $t = {
  am: "am",
  pm: "pm",
  midnight: "midnight",
  noon: "noon",
  morning: "morning",
  afternoon: "afternoon",
  evening: "evening",
  night: "night"
}, Jn = {
  // Era
  G: function(e, t, a) {
    const n = e.getFullYear() > 0 ? 1 : 0;
    switch (t) {
      case "G":
      case "GG":
      case "GGG":
        return a.era(n, { width: "abbreviated" });
      case "GGGGG":
        return a.era(n, { width: "narrow" });
      case "GGGG":
      default:
        return a.era(n, { width: "wide" });
    }
  },
  // Year
  y: function(e, t, a) {
    if (t === "yo") {
      const n = e.getFullYear(), r = n > 0 ? n : 1 - n;
      return a.ordinalNumber(r, { unit: "year" });
    }
    return st.y(e, t);
  },
  // Local week-numbering year
  Y: function(e, t, a, n) {
    const r = In(e, n), s = r > 0 ? r : 1 - r;
    if (t === "YY") {
      const u = s % 100;
      return ce(u, 2);
    }
    return t === "Yo" ? a.ordinalNumber(s, { unit: "year" }) : ce(s, t.length);
  },
  // ISO week-numbering year
  R: function(e, t) {
    const a = kr(e);
    return ce(a, t.length);
  },
  // Extended year. This is a single number designating the year of this calendar system.
  // The main difference between `y` and `u` localizers are B.C. years:
  // | Year | `y` | `u` |
  // |------|-----|-----|
  // | AC 1 |   1 |   1 |
  // | BC 1 |   1 |   0 |
  // | BC 2 |   2 |  -1 |
  // Also `yy` always returns the last two digits of a year,
  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
  u: function(e, t) {
    const a = e.getFullYear();
    return ce(a, t.length);
  },
  // Quarter
  Q: function(e, t, a) {
    const n = Math.ceil((e.getMonth() + 1) / 3);
    switch (t) {
      case "Q":
        return String(n);
      case "QQ":
        return ce(n, 2);
      case "Qo":
        return a.ordinalNumber(n, { unit: "quarter" });
      case "QQQ":
        return a.quarter(n, {
          width: "abbreviated",
          context: "formatting"
        });
      case "QQQQQ":
        return a.quarter(n, {
          width: "narrow",
          context: "formatting"
        });
      case "QQQQ":
      default:
        return a.quarter(n, {
          width: "wide",
          context: "formatting"
        });
    }
  },
  // Stand-alone quarter
  q: function(e, t, a) {
    const n = Math.ceil((e.getMonth() + 1) / 3);
    switch (t) {
      case "q":
        return String(n);
      case "qq":
        return ce(n, 2);
      case "qo":
        return a.ordinalNumber(n, { unit: "quarter" });
      case "qqq":
        return a.quarter(n, {
          width: "abbreviated",
          context: "standalone"
        });
      case "qqqqq":
        return a.quarter(n, {
          width: "narrow",
          context: "standalone"
        });
      case "qqqq":
      default:
        return a.quarter(n, {
          width: "wide",
          context: "standalone"
        });
    }
  },
  // Month
  M: function(e, t, a) {
    const n = e.getMonth();
    switch (t) {
      case "M":
      case "MM":
        return st.M(e, t);
      case "Mo":
        return a.ordinalNumber(n + 1, { unit: "month" });
      case "MMM":
        return a.month(n, {
          width: "abbreviated",
          context: "formatting"
        });
      case "MMMMM":
        return a.month(n, {
          width: "narrow",
          context: "formatting"
        });
      case "MMMM":
      default:
        return a.month(n, { width: "wide", context: "formatting" });
    }
  },
  // Stand-alone month
  L: function(e, t, a) {
    const n = e.getMonth();
    switch (t) {
      case "L":
        return String(n + 1);
      case "LL":
        return ce(n + 1, 2);
      case "Lo":
        return a.ordinalNumber(n + 1, { unit: "month" });
      case "LLL":
        return a.month(n, {
          width: "abbreviated",
          context: "standalone"
        });
      case "LLLLL":
        return a.month(n, {
          width: "narrow",
          context: "standalone"
        });
      case "LLLL":
      default:
        return a.month(n, { width: "wide", context: "standalone" });
    }
  },
  // Local week of year
  w: function(e, t, a, n) {
    const r = Cr(e, n);
    return t === "wo" ? a.ordinalNumber(r, { unit: "week" }) : ce(r, t.length);
  },
  // ISO week of year
  I: function(e, t, a) {
    const n = Mr(e);
    return t === "Io" ? a.ordinalNumber(n, { unit: "week" }) : ce(n, t.length);
  },
  // Day of the month
  d: function(e, t, a) {
    return t === "do" ? a.ordinalNumber(e.getDate(), { unit: "date" }) : st.d(e, t);
  },
  // Day of year
  D: function(e, t, a) {
    const n = ao(e);
    return t === "Do" ? a.ordinalNumber(n, { unit: "dayOfYear" }) : ce(n, t.length);
  },
  // Day of week
  E: function(e, t, a) {
    const n = e.getDay();
    switch (t) {
      case "E":
      case "EE":
      case "EEE":
        return a.day(n, {
          width: "abbreviated",
          context: "formatting"
        });
      case "EEEEE":
        return a.day(n, {
          width: "narrow",
          context: "formatting"
        });
      case "EEEEEE":
        return a.day(n, {
          width: "short",
          context: "formatting"
        });
      case "EEEE":
      default:
        return a.day(n, {
          width: "wide",
          context: "formatting"
        });
    }
  },
  // Local day of week
  e: function(e, t, a, n) {
    const r = e.getDay(), s = (r - n.weekStartsOn + 8) % 7 || 7;
    switch (t) {
      case "e":
        return String(s);
      case "ee":
        return ce(s, 2);
      case "eo":
        return a.ordinalNumber(s, { unit: "day" });
      case "eee":
        return a.day(r, {
          width: "abbreviated",
          context: "formatting"
        });
      case "eeeee":
        return a.day(r, {
          width: "narrow",
          context: "formatting"
        });
      case "eeeeee":
        return a.day(r, {
          width: "short",
          context: "formatting"
        });
      case "eeee":
      default:
        return a.day(r, {
          width: "wide",
          context: "formatting"
        });
    }
  },
  // Stand-alone local day of week
  c: function(e, t, a, n) {
    const r = e.getDay(), s = (r - n.weekStartsOn + 8) % 7 || 7;
    switch (t) {
      case "c":
        return String(s);
      case "cc":
        return ce(s, t.length);
      case "co":
        return a.ordinalNumber(s, { unit: "day" });
      case "ccc":
        return a.day(r, {
          width: "abbreviated",
          context: "standalone"
        });
      case "ccccc":
        return a.day(r, {
          width: "narrow",
          context: "standalone"
        });
      case "cccccc":
        return a.day(r, {
          width: "short",
          context: "standalone"
        });
      case "cccc":
      default:
        return a.day(r, {
          width: "wide",
          context: "standalone"
        });
    }
  },
  // ISO day of week
  i: function(e, t, a) {
    const n = e.getDay(), r = n === 0 ? 7 : n;
    switch (t) {
      case "i":
        return String(r);
      case "ii":
        return ce(r, t.length);
      case "io":
        return a.ordinalNumber(r, { unit: "day" });
      case "iii":
        return a.day(n, {
          width: "abbreviated",
          context: "formatting"
        });
      case "iiiii":
        return a.day(n, {
          width: "narrow",
          context: "formatting"
        });
      case "iiiiii":
        return a.day(n, {
          width: "short",
          context: "formatting"
        });
      case "iiii":
      default:
        return a.day(n, {
          width: "wide",
          context: "formatting"
        });
    }
  },
  // AM or PM
  a: function(e, t, a) {
    const r = e.getHours() / 12 >= 1 ? "pm" : "am";
    switch (t) {
      case "a":
      case "aa":
        return a.dayPeriod(r, {
          width: "abbreviated",
          context: "formatting"
        });
      case "aaa":
        return a.dayPeriod(r, {
          width: "abbreviated",
          context: "formatting"
        }).toLowerCase();
      case "aaaaa":
        return a.dayPeriod(r, {
          width: "narrow",
          context: "formatting"
        });
      case "aaaa":
      default:
        return a.dayPeriod(r, {
          width: "wide",
          context: "formatting"
        });
    }
  },
  // AM, PM, midnight, noon
  b: function(e, t, a) {
    const n = e.getHours();
    let r;
    switch (n === 12 ? r = $t.noon : n === 0 ? r = $t.midnight : r = n / 12 >= 1 ? "pm" : "am", t) {
      case "b":
      case "bb":
        return a.dayPeriod(r, {
          width: "abbreviated",
          context: "formatting"
        });
      case "bbb":
        return a.dayPeriod(r, {
          width: "abbreviated",
          context: "formatting"
        }).toLowerCase();
      case "bbbbb":
        return a.dayPeriod(r, {
          width: "narrow",
          context: "formatting"
        });
      case "bbbb":
      default:
        return a.dayPeriod(r, {
          width: "wide",
          context: "formatting"
        });
    }
  },
  // in the morning, in the afternoon, in the evening, at night
  B: function(e, t, a) {
    const n = e.getHours();
    let r;
    switch (n >= 17 ? r = $t.evening : n >= 12 ? r = $t.afternoon : n >= 4 ? r = $t.morning : r = $t.night, t) {
      case "B":
      case "BB":
      case "BBB":
        return a.dayPeriod(r, {
          width: "abbreviated",
          context: "formatting"
        });
      case "BBBBB":
        return a.dayPeriod(r, {
          width: "narrow",
          context: "formatting"
        });
      case "BBBB":
      default:
        return a.dayPeriod(r, {
          width: "wide",
          context: "formatting"
        });
    }
  },
  // Hour [1-12]
  h: function(e, t, a) {
    if (t === "ho") {
      let n = e.getHours() % 12;
      return n === 0 && (n = 12), a.ordinalNumber(n, { unit: "hour" });
    }
    return st.h(e, t);
  },
  // Hour [0-23]
  H: function(e, t, a) {
    return t === "Ho" ? a.ordinalNumber(e.getHours(), { unit: "hour" }) : st.H(e, t);
  },
  // Hour [0-11]
  K: function(e, t, a) {
    const n = e.getHours() % 12;
    return t === "Ko" ? a.ordinalNumber(n, { unit: "hour" }) : ce(n, t.length);
  },
  // Hour [1-24]
  k: function(e, t, a) {
    let n = e.getHours();
    return n === 0 && (n = 24), t === "ko" ? a.ordinalNumber(n, { unit: "hour" }) : ce(n, t.length);
  },
  // Minute
  m: function(e, t, a) {
    return t === "mo" ? a.ordinalNumber(e.getMinutes(), { unit: "minute" }) : st.m(e, t);
  },
  // Second
  s: function(e, t, a) {
    return t === "so" ? a.ordinalNumber(e.getSeconds(), { unit: "second" }) : st.s(e, t);
  },
  // Fraction of second
  S: function(e, t) {
    return st.S(e, t);
  },
  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
  X: function(e, t, a) {
    const n = e.getTimezoneOffset();
    if (n === 0)
      return "Z";
    switch (t) {
      case "X":
        return tr(n);
      case "XXXX":
      case "XX":
        return mt(n);
      case "XXXXX":
      case "XXX":
      default:
        return mt(n, ":");
    }
  },
  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
  x: function(e, t, a) {
    const n = e.getTimezoneOffset();
    switch (t) {
      case "x":
        return tr(n);
      case "xxxx":
      case "xx":
        return mt(n);
      case "xxxxx":
      case "xxx":
      default:
        return mt(n, ":");
    }
  },
  // Timezone (GMT)
  O: function(e, t, a) {
    const n = e.getTimezoneOffset();
    switch (t) {
      case "O":
      case "OO":
      case "OOO":
        return "GMT" + er(n, ":");
      case "OOOO":
      default:
        return "GMT" + mt(n, ":");
    }
  },
  // Timezone (specific non-location)
  z: function(e, t, a) {
    const n = e.getTimezoneOffset();
    switch (t) {
      case "z":
      case "zz":
      case "zzz":
        return "GMT" + er(n, ":");
      case "zzzz":
      default:
        return "GMT" + mt(n, ":");
    }
  },
  // Seconds timestamp
  t: function(e, t, a) {
    const n = Math.trunc(e.getTime() / 1e3);
    return ce(n, t.length);
  },
  // Milliseconds timestamp
  T: function(e, t, a) {
    const n = e.getTime();
    return ce(n, t.length);
  }
};
function er(e, t = "") {
  const a = e > 0 ? "-" : "+", n = Math.abs(e), r = Math.trunc(n / 60), s = n % 60;
  return s === 0 ? a + String(r) : a + String(r) + t + ce(s, 2);
}
function tr(e, t) {
  return e % 60 === 0 ? (e > 0 ? "-" : "+") + ce(Math.abs(e) / 60, 2) : mt(e, t);
}
function mt(e, t = "") {
  const a = e > 0 ? "-" : "+", n = Math.abs(e), r = ce(Math.trunc(n / 60), 2), s = ce(n % 60, 2);
  return a + r + t + s;
}
const ar = (e, t) => {
  switch (e) {
    case "P":
      return t.date({ width: "short" });
    case "PP":
      return t.date({ width: "medium" });
    case "PPP":
      return t.date({ width: "long" });
    case "PPPP":
    default:
      return t.date({ width: "full" });
  }
}, Sr = (e, t) => {
  switch (e) {
    case "p":
      return t.time({ width: "short" });
    case "pp":
      return t.time({ width: "medium" });
    case "ppp":
      return t.time({ width: "long" });
    case "pppp":
    default:
      return t.time({ width: "full" });
  }
}, so = (e, t) => {
  const a = e.match(/(P+)(p+)?/) || [], n = a[1], r = a[2];
  if (!r)
    return ar(e, t);
  let s;
  switch (n) {
    case "P":
      s = t.dateTime({ width: "short" });
      break;
    case "PP":
      s = t.dateTime({ width: "medium" });
      break;
    case "PPP":
      s = t.dateTime({ width: "long" });
      break;
    case "PPPP":
    default:
      s = t.dateTime({ width: "full" });
      break;
  }
  return s.replace("{{date}}", ar(n, t)).replace("{{time}}", Sr(r, t));
}, Ln = {
  p: Sr,
  P: so
}, lo = /^D+$/, oo = /^Y+$/, io = ["D", "DD", "YY", "YYYY"];
function $r(e) {
  return lo.test(e);
}
function Lr(e) {
  return oo.test(e);
}
function zn(e, t, a) {
  const n = co(e, t, a);
  if (console.warn(n), io.includes(e)) throw new RangeError(n);
}
function co(e, t, a) {
  const n = e[0] === "Y" ? "years" : "days of the month";
  return `Use \`${e.toLowerCase()}\` instead of \`${e}\` (in \`${t}\`) for formatting ${n} to the input \`${a}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
}
function zr(e) {
  if (!De(e) && typeof e != "number")
    return !1;
  const t = Z(e);
  return !isNaN(Number(t));
}
const uo = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, fo = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, ho = /^'([^]*?)'?$/, yo = /''/g, mo = /[a-zA-Z]/;
function Ce(e, t, a) {
  const n = It(), r = n.locale ?? wr, s = n.firstWeekContainsDate ?? n.locale?.options?.firstWeekContainsDate ?? 1, u = n.weekStartsOn ?? n.locale?.options?.weekStartsOn ?? 0, f = Z(e);
  if (!zr(f))
    throw new RangeError("Invalid time value");
  let v = t.match(fo).map((m) => {
    const y = m[0];
    if (y === "p" || y === "P") {
      const d = Ln[y];
      return d(m, r.formatLong);
    }
    return m;
  }).join("").match(uo).map((m) => {
    if (m === "''")
      return { isToken: !1, value: "'" };
    const y = m[0];
    if (y === "'")
      return { isToken: !1, value: go(m) };
    if (Jn[y])
      return { isToken: !0, value: m };
    if (y.match(mo))
      throw new RangeError(
        "Format string contains an unescaped latin alphabet character `" + y + "`"
      );
    return { isToken: !1, value: m };
  });
  r.localize.preprocessor && (v = r.localize.preprocessor(f, v));
  const g = {
    firstWeekContainsDate: s,
    weekStartsOn: u,
    locale: r
  };
  return v.map((m) => {
    if (!m.isToken) return m.value;
    const y = m.value;
    (Lr(y) || $r(y)) && zn(y, t, String(e));
    const d = Jn[y[0]];
    return d(f, y, r.localize, g);
  }).join("");
}
function go(e) {
  const t = e.match(ho);
  return t ? t[1].replace(yo, "'") : e;
}
function nr(e) {
  const t = Z(e);
  return t.setHours(23, 59, 59, 999), t;
}
const vo = {
  "data-id": "sds-calendar",
  class: "select-none"
}, bo = { key: 0 }, po = ["disabled"], wo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Go to previous month", -1), xo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "w-5 h-5",
  width: "32",
  height: "32",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "none",
    stroke: "currentColor",
    "stroke-linecap": "round",
    "stroke-linejoin": "round",
    "stroke-width": "48",
    d: "M328 112L184 256l144 144"
  })
], -1), ko = [
  wo,
  xo
], Mo = { class: "grow" }, Co = {
  key: 0,
  class: "hidden grow sm:block"
}, So = ["disabled"], $o = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Go to next month", -1), Lo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "w-5 h-5",
  width: "32",
  height: "32",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "none",
    stroke: "currentColor",
    "stroke-linecap": "round",
    "stroke-linejoin": "round",
    "stroke-width": "48",
    d: "M184 112l144 144l-144 144"
  })
], -1), zo = [
  $o,
  Lo
], Do = { class: "flex flex-col sm:flex-row sm:gap-8" }, To = { class: "grid grid-cols-7 w-56 h-60 place-content-start" }, Bo = ["disabled", "title", "onClick"], Po = {
  key: 0,
  class: "hidden sm:grid grid-cols-7 w- place-content-start"
}, Ao = ["disabled", "title", "onClick"], Vo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "mb-1 text-sm uppercase font-semibold text-gray-500" }, " Month ", -1), Oo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Month", -1), Ho = { class: "mt-1" }, No = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "mb-1 text-sm uppercase font-semibold text-gray-500" }, " Year ", -1), Eo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Year", -1), Io = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("hr", { class: "my-2" }, null, -1), Ro = { class: "text-sm text-gray-600 dark:text-gray-400 mb-2" }, Fo = { class: "flex gap-1" }, Wo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "my-auto flex-shrink-0 w-4 h-4 text-gray-700 dark:text-gray-300",
  width: "32",
  height: "32",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    d: "M256 8C119 8 8 119 8 256s111 248 248 248s248-111 248-248S393 8 256 8zm0 448c-110.5 0-200-89.5-200-200S145.5 56 256 56s200 89.5 200 200s-89.5 200-200 200zm61.8-104.4l-84.9-61.7c-3.1-2.3-4.9-5.9-4.9-9.7V116c0-6.6 5.4-12 12-12h32c6.6 0 12 5.4 12 12v141.7l66.8 48.6c5.4 3.9 6.5 11.4 2.6 16.8L334.6 349c-3.9 5.3-11.4 6.5-16.8 2.6z",
    fill: "currentColor"
  })
], -1), qo = { class: "w-full" }, Go = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Hour", -1), Yo = ["disabled"], jo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "my-auto" }, ":", -1), Uo = { class: "w-full" }, Ko = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Minutes", -1), _o = ["disabled"], Xo = { class: "w-full" }, Qo = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Meridian", -1), Zo = ["disabled"], Jo = {
  key: 0,
  class: "border-t my-2 pt-2 dark:border-gray-700 w-56"
}, ei = { class: "text-sm text-gray-600 dark:text-gray-400 mb-2" }, ti = { class: "flex gap-1" }, ai = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "my-auto flex-shrink-0 w-4 h-4 text-gray-700 dark:text-gray-300",
  width: "32",
  height: "32",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    d: "M256 8C119 8 8 119 8 256s111 248 248 248s248-111 248-248S393 8 256 8zm0 448c-110.5 0-200-89.5-200-200S145.5 56 256 56s200 89.5 200 200s-89.5 200-200 200zm61.8-104.4l-84.9-61.7c-3.1-2.3-4.9-5.9-4.9-9.7V116c0-6.6 5.4-12 12-12h32c6.6 0 12 5.4 12 12v141.7l66.8 48.6c5.4 3.9 6.5 11.4 2.6 16.8L334.6 349c-3.9 5.3-11.4 6.5-16.8 2.6z",
    fill: "currentColor"
  })
], -1), ni = { class: "w-full" }, ri = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Hour", -1), si = ["disabled"], li = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "my-auto" }, ":", -1), oi = { class: "w-full" }, ii = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Minute", -1), ci = ["disabled"], di = { class: "w-full" }, ui = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Meridian", -1), fi = ["disabled"], qt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsCalendar",
  __name: "Calendar",
  props: {
    /**
     * The v-model for the component.
     * 
     * For single selections, this value can be null or a date object.
     * 
     * For range selections, this is an object with start and end keys
     * that can either be null or a date object.
     * 
     * Range example:
     * 
     * **{ start: new Date(), end: null }**
     */
    modelValue: { type: [Object, Date], default: /* @__PURE__ */ new Date() },
    /**
     * Determines the mode in which the calendar will function.
     * 
     * Options include 'date', 'dateTime', and 'time'.
     */
    mode: { type: String, default: "date" },
    /**
     * Determines the minimum selectable date for this component.
     */
    min: { type: Date, default: null },
    /**
     * Determines the maximum selectable date for this component.
     */
    max: { type: Date, default: null },
    /**
     * Determines whether to use the current time when selecting a date that is equal to today.
     * 
     * If false, this sets the time to the start of the date.
     */
    useCurrentTimeForToday: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(_) {
        n("update:model-value", _);
      }
    }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(/* @__PURE__ */ new Date()), u = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], f = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], v = [...Array(200).keys()].map((_) => _ + 1900), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Ce(s.value, "MMMM")), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Ce(s.value, "yyyy")), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Qn(St(s.value)) + 1), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Xn(s.value)), h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(ot(s.value, 1)), p = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Ce(h.value, "MMMM")), w = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Ce(h.value, "yyyy")), b = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Qn(St(h.value)) + 1), k = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Xn(h.value)), D = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)("days"), C = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), L = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), B = () => {
      C.value = Ce(s.value, "MMMM"), L.value = Ce(s.value, "yyyy");
    };
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(() => D.value, () => {
      B();
    });
    const A = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.mode === "date" || a.mode === "dateTime"), E = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.mode === "dateTime" || a.mode === "time"), M = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), H = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), P = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), G = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), oe = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), U = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null);
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      K(), J(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        ie();
      });
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(() => a.modelValue, () => {
      ie();
    });
    const K = () => {
      if (a.mode === "time" && (!r.value || !(r.value instanceof Date) && (!r.value.start || !r.value.end))) {
        const _ = Me(Te(He(Ne(/* @__PURE__ */ new Date(), 0), 0), 0), 0);
        ge.value ? r.value = {
          start: _,
          end: _
        } : r.value = _;
      }
    }, J = () => {
      r.value && !(r.value instanceof Date) && r.value.start instanceof Date ? s.value = r.value.start : r.value && r.value instanceof Date ? s.value = r.value : a.min && a.min instanceof Date && gt(a.min, /* @__PURE__ */ new Date()) && (s.value = a.min), h.value = ot(s.value, 1);
    }, ie = () => {
      ge.value ? (r.value && !(r.value instanceof Date) && r.value.start instanceof Date ? (M.value = re(r.value.start, "hh"), H.value = re(r.value.start, "mm"), P.value = Ze(r.value.start) > 11 ? "pm" : "am") : (M.value = null, H.value = null, P.value = null), r.value && !(r.value instanceof Date) && r.value.end instanceof Date ? (G.value = re(r.value.end, "hh"), oe.value = re(r.value.end, "mm"), U.value = Ze(r.value.end) > 11 ? "pm" : "am") : (G.value = null, oe.value = null, U.value = null)) : r.value instanceof Date ? (M.value = re(r.value, "hh"), H.value = re(r.value, "mm"), P.value = Ze(r.value) > 11 ? "pm" : "am") : (M.value = null, H.value = null, P.value = null);
    }, de = (_, I, T = !1) => {
      switch (_) {
        case "hour":
          if (ge.value) {
            if (!T && r.value && !(r.value instanceof Date) && r.value.start instanceof Date) {
              const N = Ze(r.value.start) > 12 ? parseInt(I) + 12 : parseInt(I);
              r.value.start = Me(r.value.start, N);
            } else if (T && r.value && !(r.value instanceof Date) && r.value.end instanceof Date) {
              const N = Ze(r.value.end) > 12 ? parseInt(I) + 12 : parseInt(I);
              r.value.end = Me(r.value.end, N);
            }
          } else if (r.value instanceof Date) {
            const N = Ze(r.value) > 12 ? parseInt(I) + 12 : parseInt(I);
            r.value = Me(r.value, N);
          }
          break;
        case "minutes":
          ge.value ? !T && r.value && !(r.value instanceof Date) && r.value.start instanceof Date ? r.value.start = Te(r.value.start, parseInt(I)) : T && r.value && !(r.value instanceof Date) && r.value.end instanceof Date && (r.value.end = Te(r.value.end, parseInt(I))) : r.value instanceof Date && (r.value = Te(r.value, parseInt(I)));
          break;
        case "meridian":
          if (ge.value) {
            if (!T && r.value && !(r.value instanceof Date) && r.value.start instanceof Date) {
              const ae = Ze(r.value.start);
              let N = I === "am" && ae >= 12 ? ae - 12 : I === "pm" && ae < 12 ? ae + 12 : ae;
              r.value.start = Me(r.value.start, N);
            } else if (T && r.value && !(r.value instanceof Date) && r.value.end instanceof Date) {
              const ae = Ze(r.value.end);
              let N = I === "am" && ae >= 12 ? ae - 12 : I === "pm" && ae < 12 ? ae + 12 : ae;
              r.value.end = Me(r.value.end, N);
            }
          } else if (r.value instanceof Date) {
            const ae = Ze(r.value);
            let N = I === "am" && ae >= 12 ? ae - 12 : I === "pm" && ae < 12 ? ae + 12 : ae;
            r.value = Me(r.value, N);
          }
          break;
      }
      ge.value && r.value && !(r.value instanceof Date) && r.value.start instanceof Date && r.value.end instanceof Date && (r.value = {
        start: Sn([r.value.start, r.value.end]),
        end: $n([r.value.start, r.value.end])
      });
    }, ke = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => [...Array(12).keys()].map((I) => (I + 1).toLocaleString("en-US", {
      minimumIntegerDigits: 2,
      useGrouping: !1
    }))), me = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => [...Array(60).keys()].map((I) => I.toLocaleString("en-US", {
      minimumIntegerDigits: 2,
      useGrouping: !1
    }))), Ve = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => ["am", "pm"]), ht = () => {
      s.value = Zn(s.value, 1), h.value = Zn(h.value, 1);
    }, Mt = () => {
      s.value = ot(s.value, 1), h.value = ot(h.value, 1);
    }, R = () => {
      if (!C.value || !L.value) return;
      const _ = f.findIndex((I) => I === C.value) + 1;
      typeof _ == "number" && (s.value = new Date(parseInt(L.value), _, 0, 0, 0, 0, 0), h.value = ot(s.value, 1), D.value = "days");
    }, W = () => {
      s.value = /* @__PURE__ */ new Date(), h.value = ot(s.value, 1), D.value = "days";
    }, F = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.min instanceof Date ? Mn(St(a.min), St(s.value)) : !0), ue = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.max instanceof Date ? gt(St(a.max), St(s.value)) : !0), re = (_, I) => Ce(_, I), ge = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.modelValue && !De(a.modelValue)), nt = (_, I = !1) => {
      const T = I ? h.value : s.value;
      if (ge.value && r.value)
        if (r.value.end || !r.value.start)
          r.value = {
            start: a.useCurrentTimeForToday && vn($e(T, _)) ? /* @__PURE__ */ new Date() : Me(Te(He(Ne($e(T, _), 0), 0), 0), 0),
            end: null
          };
        else if (!(r.value instanceof Date) && De(r.value.start) && r.value.start instanceof Date) {
          const ae = r.value.start, N = nr($e(T, _));
          if (lt(ae, N) && gt(N, ae))
            r.value = { start: ae, end: N };
          else {
            const Q = Sn([ae, N]), ee = $n([ae, N]);
            r.value = {
              start: Cn(ae, Q) ? Q : a.useCurrentTimeForToday && vn(Q) ? /* @__PURE__ */ new Date() : Me(Te(He(Ne(Q, 0), 0), 0), 0),
              end: nr(ee)
            };
          }
        } else
          r.value.end = Me(Te(He(Ne($e(T, _), 0), 0), 0), 0);
      else
        r.value = a.useCurrentTimeForToday && vn($e(T, _)) ? /* @__PURE__ */ new Date() : Me(Te(He(Ne($e(T, _), 0), 0), 0), 0);
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        ie();
      });
    }, na = (_, I = !1) => {
      if (!(a.min instanceof Date)) return !1;
      const T = I ? h.value : s.value;
      return Mn($e(T, _), Me(Te(He(Ne(a.min, 0), 0), 0), 0));
    }, Ct = (_, I = !1) => {
      if (!(a.max instanceof Date)) return !1;
      const T = I ? h.value : s.value, ae = $e(T, _ - 1), N = Me(Te(He(Ne(a.max, 0), 0), 0), 0);
      return gt(ae, N) || Cn(ae, N);
    }, ra = (_, I = !1) => na(_, I) || Ct(_, I), rt = (_, I = !1) => {
      const T = I ? h.value : s.value;
      return r.value && !(r.value instanceof Date) && De(r.value.start) && r.value.start instanceof Date && De(r.value.end) && r.value.end instanceof Date ? gl(
        $e(T, _),
        { start: r.value.start, end: r.value.end }
      ) : !1;
    }, sa = (_, I = !1) => {
      const T = I ? h.value : s.value;
      return r.value && !(r.value instanceof Date) && De(r.value.start) && r.value.start instanceof Date && De(r.value.end) && r.value.end instanceof Date ? lt($e(T, _), r.value.start) : !1;
    }, la = (_, I = !1) => {
      const T = I ? h.value : s.value;
      return r.value && !(r.value instanceof Date) && De(r.value.start) && r.value.start instanceof Date && De(r.value.end) && r.value.end instanceof Date ? lt($e(T, _), r.value.end) : !1;
    }, Oe = (_, I = !1) => {
      if (r.value) {
        if (De(r.value) && r.value instanceof Date) {
          const T = I ? h.value : s.value;
          return lt($e(T, _), r.value);
        } else if (!(r.value instanceof Date) && (De(r.value.start) && r.value.start instanceof Date || De(r.value.end) && r.value.end instanceof Date)) {
          const T = I ? h.value : s.value;
          return De(r.value.start) && r.value.start instanceof Date && lt($e(T, _), r.value.start) || De(r.value.end) && r.value.end instanceof Date && lt($e(T, _), r.value.end);
        }
      } else return !1;
    }, yt = (_, I = !1) => {
      const T = I ? h.value : s.value;
      return lt($e(T, _), /* @__PURE__ */ new Date());
    };
    return (_, I) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", vo, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(A) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", bo, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(D) === "days" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex relative gap-1 mb-2 w-56", { "sm:w-120": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ge) }])
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
              class: "absolute left-0 top-0 text-gray-700 dark:text-gray-300 p-1 hover:bg-gray-100 dark:hover:bg-gray-750 rounded disabled:pointer-events-none disabled:opacity-50",
              type: "button",
              tabindex: "-1",
              disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(F),
              onClick: ht
            }, ko, 8, po),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Mo, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                class: "m-auto text-lg font-semibold flex gap-1 text-gray-900 hover:text-gray-500 dark:text-gray-100",
                type: "button",
                tabindex: "-1",
                onClick: I[0] || (I[0] = (T) => D.value = "years")
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)) + " " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)), 1)
              ])
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ge) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Co, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                class: "m-auto text-lg font-semibold flex gap-1 text-gray-900 hover:text-gray-500 dark:text-gray-100",
                type: "button",
                tabindex: "-1",
                onClick: I[1] || (I[1] = (T) => D.value = "years")
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(p)) + " " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(w)), 1)
              ])
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
              class: "absolute right-0 top-0 text-gray-700 dark:text-gray-300 p-1 hover:bg-gray-100 dark:hover:bg-gray-750 rounded disabled:pointer-events-none disabled:opacity-50",
              type: "button",
              tabindex: "-1",
              disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ue),
              onClick: Mt
            }, zo, 8, So)
          ], 2),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Do, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", To, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(u, (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                key: T,
                class: "text-sm font-bold text-gray-400 text-center uppercase mb-1"
              }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T.charAt(0)), 1)), 64)),
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                key: T,
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([
                  "w-8 h-8 mb-1",
                  T === 1 ? `col-start-${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(y)}` : "",
                  rt(T) ? "bg-blue-25 dark:bg-blue-900" : "",
                  sa(T) ? "bg-blue-25 dark:bg-blue-900 rounded-l-full" : "",
                  la(T) ? "bg-blue-25 dark:bg-blue-900 rounded-r-full" : ""
                ])
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["disabled:pointer-events-none disabled:opacity-25", {
                    "px-2 py-1 w-8 h-8 rounded-full text-sm": !0,
                    "hover:bg-gray-100 dark:hover:bg-gray-750": !Oe(T),
                    "font-bold bg-blue-500 dark:bg-blue-700 text-white": Oe(T),
                    "font-bold text-blue-500 bg-gray-100 dark:text-blue-100 dark:bg-gray-850": yt(T) && !Oe(T) && !rt(T),
                    "font-semibold text-blue-900 dark:text-blue-100": rt(T) && !Oe(T)
                  }]),
                  type: "button",
                  tabindex: "-1",
                  disabled: ra(T),
                  title: yt(T) ? "Today" : "",
                  onClick: (ae) => nt(T)
                }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 11, Bo)
              ], 2))), 128))
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ge) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Po, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(u, (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                key: T,
                class: "text-sm font-bold text-gray-400 text-center uppercase mb-1"
              }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T.charAt(0)), 1)), 64)),
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(k), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                key: T,
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([
                  "w-8 h-8 mb-1",
                  T === 1 ? `col-start-${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(b)}` : "",
                  rt(T, !0) ? "bg-blue-25 dark:bg-blue-900" : "",
                  sa(T, !0) ? "bg-blue-25 dark:bg-blue-900 rounded-l-full" : "",
                  la(T, !0) ? "bg-blue-25 dark:bg-blue-900 rounded-r-full" : ""
                ])
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["disabled:pointer-events-none disabled:opacity-25", {
                    "px-2 py-1 w-8 h-8 rounded-full text-sm": !0,
                    "hover:bg-gray-100 dark:hover:bg-gray-750": !Oe(T, !0),
                    "font-bold bg-blue-500 dark:bg-blue-700 text-white": Oe(T, !0),
                    "font-bold text-blue-500 bg-gray-100 dark:text-blue-400 dark:bg-gray-100": yt(T, !0) && !Oe(T, !0) && !rt(T, !0),
                    "font-semibold text-blue-900 dark:text-blue-100": rt(T, !0) && !Oe(T, !0)
                  }]),
                  type: "button",
                  tabindex: "-1",
                  disabled: ra(T, !0),
                  title: yt(T, !0) ? "Today" : "",
                  onClick: (ae) => nt(T, !0)
                }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 11, Ao)
              ], 2))), 128))
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ])
        ], 64)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
          key: 1,
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["grid gap-1 w-56", { "sm:w-120": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ge) }])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", null, [
            Vo,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", null, [
              Oo,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[2] || (I[2] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(C) ? C.value = T : null),
                class: "form-control form-control-sm"
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(f, (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1)), 64))
              ], 512), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(C)]
              ])
            ])
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Ho, [
            No,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", null, [
              Eo,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[3] || (I[3] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(L) ? L.value = T : null),
                class: "form-control form-control-sm"
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1))), 128))
              ], 512), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(L)]
              ])
            ])
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
            class: "mt-2 btn btn-primary btn-sm",
            type: "button",
            tabindex: "-1",
            onClick: I[4] || (I[4] = (T) => R())
          }, " Go to Date "),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
            class: "mt-2 btn btn-secondary btn-sm",
            type: "button",
            tabindex: "-1",
            onClick: I[5] || (I[5] = (T) => W())
          }, " Go to Today "),
          Io,
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
            class: "btn btn-secondary btn-sm",
            type: "button",
            tabindex: "-1",
            onClick: I[6] || (I[6] = (T) => D.value = "days")
          }, " Cancel ")
        ], 2))
      ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(E) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(D) === "days" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        key: 1,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({ "sm:flex sm:gap-8 sm:w-120": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(A) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ge) })
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["w-56", { "border-t my-2 pt-2 dark:border-gray-700": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(A) }])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Ro, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) instanceof Date ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(re((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), "eeee, MMM dd, yyyy")), 1)
            ], 64)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) && !((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) instanceof Date) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).start instanceof Date ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 1 }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(re((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).start, "eeee, MMM dd, yyyy")), 1)
            ], 64)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 2 }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" -- ")
            ], 64))
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Fo, [
            Wo,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", qo, [
              Go,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[7] || (I[7] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(M) ? M.value = T : null),
                disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(M),
                class: "form-control form-control-sm",
                onChange: I[8] || (I[8] = (T) => de("hour", T.target.value))
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ke), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1))), 128))
              ], 40, Yo), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(M)]
              ])
            ]),
            jo,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", Uo, [
              Ko,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[9] || (I[9] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(H) ? H.value = T : null),
                disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(H),
                class: "form-control form-control-sm",
                onChange: I[10] || (I[10] = (T) => de("minutes", T.target.value))
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(me), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1))), 128))
              ], 40, _o), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(H)]
              ])
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", Xo, [
              Qo,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[11] || (I[11] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(P) ? P.value = T : null),
                disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(P),
                class: "form-control form-control-sm",
                onChange: I[12] || (I[12] = (T) => de("meridian", T.target.value))
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(Ve), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1))), 128))
              ], 40, Zo), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(P)]
              ])
            ])
          ])
        ], 2),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ge) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Jo, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", ei, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) && !((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) instanceof Date) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).end instanceof Date ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(re((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).end, "eeee, MMM dd, yyyy")), 1)
            ], 64)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 1 }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" -- ")
            ], 64))
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", ti, [
            ai,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", ni, [
              ri,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[13] || (I[13] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(G) ? G.value = T : null),
                disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(G),
                class: "form-control form-control-sm",
                onChange: I[14] || (I[14] = (T) => de("hour", T.target.value, !0))
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(ke), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1))), 128))
              ], 40, si), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(G)]
              ])
            ]),
            li,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", oi, [
              ii,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[15] || (I[15] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(oe) ? oe.value = T : null),
                disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(oe),
                class: "form-control form-control-sm",
                onChange: I[16] || (I[16] = (T) => de("minutes", T.target.value, !0))
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(me), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1))), 128))
              ], 40, ci), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(oe)]
              ])
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", di, [
              ui,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("select", {
                "onUpdate:modelValue": I[17] || (I[17] = (T) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(U) ? U.value = T : null),
                disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(U),
                class: "form-control form-control-sm",
                onChange: I[18] || (I[18] = (T) => de("meridian", T.target.value, !0))
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(Ve), (T) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", { key: T }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(T), 1))), 128))
              ], 40, fi), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(U)]
              ])
            ])
          ])
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
      ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ]));
  }
});
qt.install = (e) => {
  e.component(qt.name, qt);
};
const hi = ["id", "value", "name", "required", "disabled", "onClick"], yi = ["for"], ha = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsCheckboxGroup",
  directives: {
    uid: We
  },
  __name: "CheckboxGroup",
  props: {
    /**
     * The v-model of the checkbox group.
     */
    modelValue: { type: Array, default: () => [] },
    /**
     * The name of the checkbox form field.
     */
    name: { type: String, default: null },
    /**
     * An array of options for the checkbox group.
     */
    options: { type: Array, default: () => [] },
    /**
     * Determines whether the checkbox group is disabled or not.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines whether the checkbox group is required or not.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Determines whether the options are stacked vertically or horizontally.
     */
    stacked: { type: Boolean, default: !1 },
    /**
     * Determines the label key used for options
     */
    labelKey: { type: String, default: "text" },
    /**
     * Determines the value key used for options
     */
    valueKey: { type: String, default: "value" },
    /**
     * Sets a valid styling if true.
     */
    valid: { type: Boolean, default: !1 },
    /**
     * Sets an invalid styling if true.
     */
    invalid: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value", "change"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(f) {
        n("update:model-value", f);
      }
    }), u = (f) => {
      n("change", f);
    };
    return (f, v) => {
      const g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        ref_key: "root",
        ref: r,
        "data-id": "sds-checkbox-group",
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex", {
          "flex-col gap-2": e.stacked,
          "gap-4": !e.stacked
        }])
      }, [
        ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.options, (m, y) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
          key: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}_${JSON.stringify(m)}`,
          class: "flex gap-2 items-center"
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
            id: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option_${y}`,
            "onUpdate:modelValue": v[0] || (v[0] = (d) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(s) ? s.value = d : null),
            type: "checkbox",
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({ valid: e.valid, invalid: e.invalid }),
            value: m[e.valueKey],
            name: e.name ? e.name : `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option`,
            required: e.required && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s).length < 1,
            disabled: e.disabled,
            onClick: (d) => u(m[e.valueKey])
          }, null, 10, hi), [
            [vue__WEBPACK_IMPORTED_MODULE_0__.vModelCheckbox, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s)]
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "label", {
            optionId: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option_${y}`,
            option: m
          }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", {
              for: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option_${y}`,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                "opacity-50 pointer-events-none select-none": e.disabled
              })
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(m[e.labelKey]), 1)
            ], 10, yi)
          ])
        ]))), 128))
      ], 2)), [
        [g]
      ]);
    };
  }
});
ha.install = (e) => {
  e.component(ha.name, ha);
};
it.install = (e) => {
  e.component(it.name, it);
};
const mi = ["onMouseover", "onMouseleave"], gi = ["onMouseover", "onMouseout"], vt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsPopover",
  __name: "Tooltip",
  props: {
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" },
    /**
     * Determines the purpose and particular function of the component.
     */
    type: { type: String, default: null },
    /**
     * Delays opening the toggle in ms.
     */
    openDelay: { type: Number, default: 0 },
    /**
     * Delays closing the toggle in ms.
     */
    closeDelay: { type: Number, default: 0 },
    /**
     * The width of the popover.
     */
    size: { type: String, default: "sm" },
    /**
     * The strategy of the popover on the screen.
     */
    strategy: { type: String, default: "absolute" },
    /**
     * The placement of the popover on the screen.
     */
    placement: { type: String, default: "top" },
    /**
     * Determines if the popover should display or not.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Allows for code execution prior to opening the tooltip.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the tooltip from opening
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willOpen(open, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the open process continue
     *    open()
     *  } catch (e) {
     *    // cancel the open process
     *    cancel()
     *  }
     * }
     * ```
     */
    willOpen: { type: Function, default: null },
    /**
     * Allows for code execution prior to closing the tooltip.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the tooltip from closing
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willClose(close, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the close process continue
     *    close()
     *  } catch (e) {
     *    // cancel the close process
     *    cancel()
     *  }
     * }
     * ```
     */
    willClose: { type: Function, default: null }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    }), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.type) {
        case "light":
          return "bg-gray-25 text-gray-900 border-gray-200";
        case "dark":
        default:
          return "bg-black text-gray-50 border-gray-800 dark:shadow-gray-900";
      }
    }), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.type) {
        case "light":
          return "bg-gray-25 border-gray-200";
        case "dark":
        default:
          return "bg-black border-gray-800";
      }
    }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.size) {
        case "sm":
          return "w-32";
        case "md":
          return "w-48";
        case "lg":
          return "w-56";
        case "xl":
          return "w-72";
        case "auto":
          return "w-auto";
        default:
          return "w-32";
      }
    });
    return (u, f) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(_e, {
      "data-id": "sds-tooltip",
      strategy: e.strategy,
      placement: e.placement,
      disabled: e.disabled,
      "will-open": e.willOpen,
      "will-close": e.willClose,
      "popper-class": `absolute text-xs shadow border rounded-md text-center ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n)} ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s)} ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)}`,
      "arrow-class": `absolute w-2 h-2 rotate-45 ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)}`,
      "placement-top-arrow-class": "-bottom-1 border-b border-r",
      "placement-right-arrow-class": "-left-1 border-b border-l",
      "placement-bottom-arrow-class": "-top-1 border-t border-l",
      "placement-left-arrow-class": "-right-1 border-t border-r",
      "disable-animation": "",
      shift: ""
    }, {
      trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: v, close: g }) => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          onMouseover: (m) => v(e.openDelay),
          onMouseleave: (m) => g(e.closeDelay)
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(u.$slots, "trigger")
        ], 40, mi)
      ]),
      default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: v, close: g, toggle: m, isOpen: y }) => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: "p-2",
          onMouseover: (d) => v(),
          onMouseout: (d) => g(e.closeDelay)
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(u.$slots, "default", {
            close: g,
            open: v,
            toggle: m,
            isOpen: y
          })
        ], 40, gi)
      ]),
      _: 3
    }, 8, ["strategy", "placement", "disabled", "will-open", "will-close", "popper-class", "arrow-class"]));
  }
}), vi = {
  "data-id": "sds-scroll-area",
  class: "scroll-area"
}, Gt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsScrollArea",
  __name: "ScrollArea",
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", vi, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(t.$slots, "default")
    ]));
  }
}), bi = ["disabled"], pi = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Combo box", -1), wi = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  fill: "currentColor",
  d: "M368 208A160 160 0 1 0 48 208a160 160 0 1 0 320 0zM337.1 371.1C301.7 399.2 256.8 416 208 416C93.1 416 0 322.9 0 208S93.1 0 208 0S416 93.1 416 208c0 48.8-16.8 93.7-44.9 129.1L505 471c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0L337.1 371.1z"
}, null, -1), xi = [
  wi
], ki = ["id", "placeholder", "disabled", "maxlength", "onKeyup"], Mi = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Clear query", -1), Ci = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M6 18L18 6M6 6l12 12" }, null, -1), Si = [
  Ci
], $i = {
  key: 1,
  class: "input-group-addon"
}, Li = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "border dark:border-gray-700 rounded shadow px-1.5 p-1 leading-3 cursor-default" }, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, "/")
], -1), zi = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", null, ' Press "/" to focus ', -1), Di = {
  key: 0,
  class: "absolute z-50 w-full p-0 mt-1 bg-white border rounded shadow-lg dark:border-gray-700 dark:bg-gray-850"
}, Ti = {
  key: 0,
  class: "overflow-x-auto flex gap-2 p-2 border-b border-gray-100 dark:border-gray-700"
}, Bi = ["disabled", "onClick"], Pi = {
  key: 0,
  class: "border-b border-gray-100 dark:border-gray-700"
}, Ai = {
  key: 0,
  class: "flex w-full px-4 py-2 text-sm text-left text-black list-none dark:text-white font-semibold"
}, Vi = ["data-active", "onClick"], Oi = ["data-active", "onClick"], Hi = { class: "border-t rounded-b border-gray-100 dark:border-gray-700 bg-gray-25 dark:bg-gray-800 px-4 py-2 flex gap-6 items-center text-sm text-gray-700 dark:text-gray-300" }, Ni = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "ml-auto flex items-center gap-1.5" }, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "flex gap-1 p-1 border border-gray-100 dark:border-gray-500 rounded shadow-inner" }, [
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
      class: "w-3 h-3",
      "aria-hidden": "true",
      focusable: "false",
      role: "img",
      xmlns: "http://www.w3.org/2000/svg",
      viewBox: "0 0 384 512"
    }, [
      /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
        fill: "currentColor",
        d: "M214.6 41.4c-12.5-12.5-32.8-12.5-45.3 0l-160 160c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L160 141.2V448c0 17.7 14.3 32 32 32s32-14.3 32-32V141.2L329.4 246.6c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3l-160-160z"
      })
    ]),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
      class: "w-3 h-3",
      "aria-hidden": "true",
      focusable: "false",
      role: "img",
      xmlns: "http://www.w3.org/2000/svg",
      viewBox: "0 0 384 512"
    }, [
      /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
        fill: "currentColor",
        d: "M169.4 470.6c12.5 12.5 32.8 12.5 45.3 0l160-160c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 370.8 224 64c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 306.7L54.6 265.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l160 160z"
      })
    ])
  ]),
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Up, down"),
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" to navigate ")
], -1), Ei = {
  key: 0,
  class: "flex items-center gap-1.5"
}, Ii = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "flex gap-1 p-1 border border-gray-100 dark:border-gray-500 rounded shadow-inner" }, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
    class: "w-3 h-3",
    "aria-hidden": "true",
    focusable: "false",
    role: "img",
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 448 512"
  }, [
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
      fill: "currentColor",
      d: "M9.4 233.4c-12.5 12.5-12.5 32.8 0 45.3l160 160c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L109.2 288 416 288c17.7 0 32-14.3 32-32s-14.3-32-32-32l-306.7 0L214.6 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0l-160 160z"
    })
  ]),
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
    class: "w-3 h-3",
    "aria-hidden": "true",
    focusable: "false",
    role: "img",
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 448 512"
  }, [
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
      fill: "currentColor",
      d: "M438.6 278.6c12.5-12.5 12.5-32.8 0-45.3l-160-160c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3L338.8 224 32 224c-17.7 0-32 14.3-32 32s14.3 32 32 32l306.7 0L233.4 393.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0l160-160z"
    })
  ])
], -1), Ri = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Left, right", -1), Fi = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "flex items-center gap-1.5" }, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "inline-block p-1 border border-gray-100 dark:border-gray-500 rounded shadow-inner" }, [
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
      class: "w-3 h-3",
      "aria-hidden": "true",
      focusable: "false",
      role: "img",
      xmlns: "http://www.w3.org/2000/svg",
      viewBox: "0 0 512 512"
    }, [
      /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
        fill: "currentColor",
        d: "M448 64c0-17.7 14.3-32 32-32s32 14.3 32 32V224c0 53-43 96-96 96H109.3l73.4 73.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0l-128-128c-12.5-12.5-12.5-32.8 0-45.3l128-128c12.5-12.5 32.8-12.5 45.3 0s12.5 32.8 0 45.3L109.3 256H416c17.7 0 32-14.3 32-32V64z"
      })
    ])
  ]),
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Enter"),
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" to select ")
], -1), ya = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsComboBox",
  __name: "ComboBox",
  props: {
    /**
     * Determines the id of the input.
     */
    id: { type: String, default: void 0 },
    /**
     * The value of the text input.
     */
    modelValue: { type: String, default: "" },
    /**
     * The placeholder for the input.
     */
    placeholder: { type: String, default: void 0 },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: void 0 },
    /**
     * The max amount of characters that can be entered into the input.
     */
    maxlength: { type: Number, default: void 0 },
    /**
     * Determines the size of the input field. Options are "sm" and "md".
     */
    size: { type: String, default: void 0 },
    /**
     * Determine whether to autofocus the input.
     */
    autofocus: { type: Boolean, default: void 0 },
    /**
     * Determines whether to focus the input on "/" key press.
     */
    focusOnKeyPress: { type: Boolean, default: !1 },
    /**
     * Determines whether to display the helper text for the "/" focus key press.
     */
    hideFocusHelperText: { type: Boolean, default: !1 },
    /**
     * The suggestions used for autosuggest.
     */
    suggestions: { type: Array, default: void 0 },
    /**
     * The label key used for each non-group suggestion.
     */
    optionLabel: { type: String, default: void 0 },
    /**
     * The label key used for each group suggestion.
     */
    optionGroupLabel: { type: String, default: void 0 },
    /**
     * The key used to determine the children array for each group suggestion.
     */
    optionGroupChildren: { type: String, default: void 0 },
    /**
     * Determine whether to use built-in suggestion filter based on modelValue.
     */
    filterSuggestions: { type: Boolean, default: void 0 },
    /**
     * The debounce period before complete event is emitted.
     */
    debounceComplete: { type: Number, default: 350 },
    /**
     * Determines whether to hide empty groups from the tabbed group suggestions.
     */
    hideEmptyGroups: { type: Boolean, default: !1 },
    /**
     * Determines whether to hide empty groups from the tabbed group suggestions.
     */
    disableGroupTabs: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value", "complete", "enter", "result"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (R) => {
      if (typeof document > "u") return R;
      let W = document.createElement("div");
      return W.innerHTML = R, W.textContent || W.innerText || "";
    }, s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(R) {
        n("update:model-value", R);
      }
    }), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(a.modelValue), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(-1), p = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)("label");
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(g, (R) => {
      L.value = -1, h.value = -1, m.value = r(R);
    }), ls(g, () => {
      ht();
    }, { debounce: a.debounceComplete }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(y, () => {
      h.value = -1, L.value = -1;
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(() => a.suggestions, (R) => {
      d.value || (y.value = typeof R < "u" && R.length > 0);
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(m, (R) => {
      d.value = R === r(g.value);
    });
    const w = (R) => {
      if (!Array.isArray(R)) return [];
      const W = R.reduce((F, ue) => {
        if (typeof ue != "string") {
          const re = ue;
          a.optionGroupChildren && ue[a.optionGroupChildren] ? (re[a.optionGroupChildren] = w(ue[a.optionGroupChildren]), re[a.optionGroupChildren].length > 0 && F.push(re)) : r(re[a.optionLabel ? a.optionLabel : p.value]).toLowerCase().includes(r(g.value).toLowerCase()) && F.push(re);
        }
        return F;
      }, []);
      return b(W);
    }, b = (R) => {
      if (!Array.isArray(R)) return [];
      let W = 0;
      return R.map((F) => (typeof F != "string" && (a.optionGroupChildren && F[a.optionGroupChildren] ? F[a.optionGroupChildren] = F[a.optionGroupChildren].map((ue) => (typeof ue != "string" && (ue.index = W, W++), ue)) : (F.index = W, W++)), F));
    }, k = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      let R = 0;
      return E.value?.forEach((W) => {
        typeof W != "string" && a.optionGroupChildren && W[a.optionGroupChildren] ? R = R + W[a.optionGroupChildren].length : R = R + 1;
      }), R;
    }), D = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.suggestions?.filter((R) => typeof R != "string" && a.optionGroupChildren && R[a.optionGroupChildren])), C = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      let R = -1;
      return D.value ? [
        { index: -1, key: R, label: "All", count: k.value },
        ...D.value.map((W, F) => {
          const ue = typeof W != "string" && a.optionGroupChildren && W[a.optionGroupChildren].length || 0;
          return ue > 0 && (R = R + 1), {
            index: F,
            key: R,
            label: typeof W != "string" && W[a.optionGroupLabel ? a.optionGroupLabel : p.value],
            count: ue
          };
        }).filter((W) => typeof W != "string" && W && a.hideEmptyGroups ? W.count > 0 : !0)
      ] : [];
    }), L = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(-1), B = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => C.value.find((R) => typeof R != "string" && R?.key === L.value)), A = (R) => {
      f.value.focus(), h.value = -1, L.value = R.key;
    }, E = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), M = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), H = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)();
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watchEffect)(() => {
      const R = a.suggestions?.map((F) => (typeof F != "object" && (F = {
        [a.optionLabel ? a.optionLabel : p.value]: F
      }), F));
      E.value = a.filterSuggestions && R ? w(R) : R && b(R);
      const W = a.suggestions?.filter((F) => typeof F != "string" && a.optionGroupChildren && F[a.optionGroupLabel ? a.optionGroupLabel : p.value] === B.value?.label);
      M.value = a.filterSuggestions && W ? w(W) : W && b(W), H.value = L.value === -1 ? E.value : M.value;
    });
    const P = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => y.value && H.value && H.value.length > 0);
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      a.autofocus && f.value.focus();
    }), ea("Escape", () => {
      m.value = r(g.value), d.value = !0, y.value = !1;
    }), on(s, () => {
      m.value = r(g.value), d.value = !0, y.value = !1;
    }), ea("/", (R) => {
      if (!a.focusOnKeyPress || !R.target) return;
      const W = R.target.tagName.toLowerCase();
      W !== "textarea" && W !== "input" && W !== "select" && (R.preventDefault(), f.value.focus());
    });
    const G = async () => {
      if (await (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(), !u.value) return;
      const R = u.value.$el;
      if (!R) return;
      const W = R.querySelector('[data-active="true"]');
      if (!W) return;
      const F = R.getBoundingClientRect(), ue = W.getBoundingClientRect();
      if (!(ue.top >= F.top && ue.bottom <= F.top + R.clientHeight)) {
        const ge = ue.top - F.top, nt = ue.bottom - F.bottom;
        Math.abs(ge) < Math.abs(nt) ? R.scrollTop += ge : R.scrollTop += nt;
      }
    }, oe = () => {
      y.value = !1, f.value.focus();
    }, U = () => {
      g.value = "", f.value.focus();
    }, K = (R) => {
      d.value = !0, typeof R == "string" ? g.value = R : g.value = a.optionLabel ? R[a.optionLabel] : R[p.value], Ve(R), Mt(), oe();
    }, J = () => {
      let R;
      return H.value.forEach((W) => {
        if (typeof W != "string")
          if (a.optionGroupChildren && W[a.optionGroupChildren]) {
            const F = W[a.optionGroupChildren].find((ue) => typeof ue != "string" && ue.index === h.value);
            F && (R = F);
          } else
            W.index === h.value && (R = W);
      }), R;
    }, ie = () => {
      const R = J();
      return R ? a.optionLabel ? R[a.optionLabel] : R[p.value] : "";
    }, de = async () => {
      await (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(), g.value = m.value;
    }, ke = () => {
      if (!a.disabled) {
        if (P.value) {
          const R = J();
          R && (g.value = ie(), Ve(R)), oe();
        }
        d.value = !0, Mt();
      }
    }, me = (R, W) => {
      if (!P.value && (R === "up" || R === "down"))
        y.value = !0;
      else {
        switch (R) {
          case "down":
            h.value < v.value.length - 1 ? h.value = h.value + 1 : h.value = -1;
            break;
          case "up":
            h.value > -1 ? h.value = h.value - 1 : h.value = v.value.length - 1;
            break;
          case "left":
            !a.disableGroupTabs && H.value.length > 0 && L.value > -1 && !W.metaKey && !W.ctrlKey && !W.shiftKey && (W.preventDefault(), h.value = -1, L.value = L.value - 1);
            break;
          case "right":
            !a.disableGroupTabs && H.value.length > 0 && L.value < C.value[C.value.length - 1].key && !W.metaKey && !W.ctrlKey && !W.shiftKey && (W.preventDefault(), h.value = -1, L.value = L.value + 1);
            break;
        }
        J() ? m.value = r(ie()) : m.value = r(g.value), G();
      }
    }, Ve = (R) => {
      n("result", R);
    }, ht = () => {
      n("complete", m.value);
    }, Mt = () => {
      n("enter", m.value);
    };
    return (R, W) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      ref_key: "root",
      ref: s,
      "data-id": "sds-combo-box",
      class: "relative"
    }, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["input-group", {
          disabled: e.disabled,
          "input-group-sm": e.size === "sm"
        }])
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
          class: "input-group-addon",
          disabled: e.disabled,
          tabindex: "-1",
          type: "button",
          onClick: W[0] || (W[0] = (F) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f)?.focus())
        }, [
          pi,
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
            "aria-hidden": "true",
            focusable: "false",
            role: "img",
            xmlns: "http://www.w3.org/2000/svg",
            viewBox: "0 0 512 512",
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
              "w-3.5 h-3.5": e.size === "sm",
              "w-4 h-4": e.size !== "sm"
            })
          }, xi, 2))
        ], 8, bi),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
          id: e.id,
          ref_key: "inputField",
          ref: f,
          "onUpdate:modelValue": W[1] || (W[1] = (F) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(m) ? m.value = F : null),
          type: "text",
          autocapitalize: "off",
          autocomplete: "off",
          spellcheck: "false",
          autocorrect: "off",
          class: "form-control",
          placeholder: e.placeholder,
          disabled: e.disabled,
          maxlength: e.maxlength,
          onInput: W[2] || (W[2] = (F) => de()),
          onKeydown: [
            W[3] || (W[3] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((F) => y.value = !1, ["tab"])),
            W[4] || (W[4] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((F) => me("down", F), ["prevent"]), ["down"])),
            W[5] || (W[5] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((F) => me("up", F), ["prevent"]), ["up"])),
            W[6] || (W[6] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((F) => me("left", F), ["left"])),
            W[7] || (W[7] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((F) => me("right", F), ["right"])),
            W[8] || (W[8] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(() => {
            }, ["prevent", "self"]), ["enter"]))
          ],
          onKeyup: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(ke, ["prevent", "self"]), ["enter"])
        }, null, 40, ki), [
          [
            vue__WEBPACK_IMPORTED_MODULE_0__.vModelText,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m),
            void 0,
            { trim: !0 }
          ]
        ]),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m).length > 0 && !e.disabled ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
          key: 0,
          tabindex: "-1",
          type: "button",
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["btn text-gray-500 hover:text-gray-900 dark:hover:text-gray-100", {
            "btn-sm py-1 px-2": e.size === "sm",
            "btn-sm py-2 px-3": e.size !== "sm"
          }]),
          onClick: U
        }, [
          Mi,
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
            fill: "none",
            "stroke-linecap": "round",
            "stroke-linejoin": "round",
            "stroke-width": "2",
            stroke: "currentColor",
            viewBox: "0 0 24 24",
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["mt-0.5", {
              "w-4 h-4": e.size === "sm",
              "w-5 h-5": e.size !== "sm"
            }]),
            "aria-hidden": "true"
          }, Si, 2))
        ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        e.focusOnKeyPress && !e.hideFocusHelperText ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", $i, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vt, null, {
            trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
              Li
            ]),
            default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
              zi
            ]),
            _: 1
          })
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(R.$slots, "default")
      ], 2),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
        "enter-active-class": "transition-opacity ease-linear duration-75",
        "enter-from-class": "opacity-0",
        "enter-to-class": "opacity-100",
        "leave-active-class": "transition-opacity ease-linear duration-75",
        "leave-from-class": "opacity-100",
        "leave-to-class": "opacity-0"
      }, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(P) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Di, [
            !e.disableGroupTabs && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(C).length > 1 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Ti, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(C), (F) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                key: F.index,
                type: "button",
                tabindex: "-1",
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["text-xs font-semibold p-2 rounded space-x-1.5", {
                  "text-gray-300 dark:text-gray-700": F.count < 1,
                  "bg-blue-25 text-blue-600 dark:bg-blue-900 dark:text-blue-50": F.count > 0 && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(L) === F.key,
                  "text-gray-600 dark:text-gray-300": F.count > 0 && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(L) !== F.key
                }]),
                disabled: F.count < 1,
                onClick: (ue) => A(F)
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(F.label), 1),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", {
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["text-white px-1 rounded-sm", {
                    "bg-gray-200 dark:bg-gray-800": F.count < 1,
                    "bg-blue-500 dark:bg-blue-700": F.count > 0 && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(L) === F.key,
                    "bg-gray-500 dark:bg-gray-700": F.count > 0 && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(L) !== F.key
                  }])
                }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(F.count), 3)
              ], 10, Bi))), 128))
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Gt, {
              ref_key: "scrollArea",
              ref: u,
              class: "max-h-72 [&>button+div]:border-t last:[&>div]:border-b-0 last:[&>button]:border-b-0"
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(H), (F, ue) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, {
                  key: `${F}_${ue}`
                }, [
                  e.optionGroupChildren && F[e.optionGroupChildren] ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Pi, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(L) === -1 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Ai, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(R.$slots, "optionGroup", {
                        option: F,
                        label: e.optionGroupLabel ? F[e.optionGroupLabel] : F
                      }, () => [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.optionGroupLabel ? F[e.optionGroupLabel] : F), 1)
                      ])
                    ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(F[e.optionGroupChildren], (re, ge) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                      key: `${F}_${re}_${ge}`,
                      ref_for: !0,
                      ref_key: "dropdownOption",
                      ref: v,
                      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex w-full px-4 py-2 text-sm text-left list-none cursor-pointer hover:text-black dark:hover:text-white hover:bg-gray-50 dark:hover:bg-gray-800", {
                        "text-gray-700 dark:text-gray-300": re.index !== (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h),
                        "text-black dark:text-white bg-gray-50 dark:bg-gray-800": re.index === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h)
                      }]),
                      "data-active": re.index === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h),
                      type: "button",
                      tabindex: "-1",
                      onClick: (nt) => K(re)
                    }, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(R.$slots, "option", {
                        option: re,
                        label: e.optionLabel ? re[e.optionLabel] : re[(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(p)]
                      }, () => [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.optionLabel ? re[e.optionLabel] : re[(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(p)]), 1)
                      ])
                    ], 10, Vi))), 128))
                  ])) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                    key: 1,
                    ref_for: !0,
                    ref_key: "dropdownOption",
                    ref: v,
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex w-full px-4 py-2 text-sm text-left list-none cursor-pointer hover:text-black dark:hover:text-white hover:bg-gray-50 dark:hover:bg-gray-800", {
                      "text-gray-700 dark:text-gray-300": F.index !== (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h),
                      "text-black dark:text-white bg-gray-50 dark:bg-gray-800": F.index === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h)
                    }]),
                    "data-active": F.index === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h),
                    type: "button",
                    tabindex: "-1",
                    onClick: (re) => K(F)
                  }, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(R.$slots, "option", {
                      option: F,
                      label: e.optionLabel ? F[e.optionLabel] : F[(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(p)]
                    }, () => [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.optionLabel ? F[e.optionLabel] : F[(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(p)]), 1)
                    ])
                  ], 10, Oi))
                ], 64))), 128))
              ]),
              _: 3
            }, 512),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Hi, [
              Ni,
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(C).length > 1 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Ei, [
                Ii,
                Ri,
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" to switch tabs ")
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
              Fi
            ])
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ]),
        _: 3
      })
    ], 512));
  }
});
ya.install = (e) => {
  e.component(ya.name, ya);
};
const Wi = {
  key: 0,
  class: "text-base"
}, qi = { class: "flex gap-2" }, Gi = {
  key: 0,
  class: "text-base mt-auto"
}, ma = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsDatapoint",
  __name: "Datapoint",
  props: {
    /**
     * Determines the content of the default slot.
     * 
     * This is overridden if the default slot is present.
     */
    modelValue: { type: [String, Number], default: null },
    /**
     * Determines the content of the label slot.
     * 
     * This is overridden if the label slot is present.
     */
    label: { type: String, default: null },
    /**
     * Determines the content of the context slot.
     * 
     * This is overridden if the context slot is present.
     */
    context: { type: String, default: null },
    /**
     * Determines the overall look and feel of the component.
     */
    size: {
      type: String,
      default: "md"
    },
    /**
     * Determines the color of the component.
     */
    variant: {
      type: String,
      default: null
    }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => typeof t.modelValue == "number" ? t.modelValue.toLocaleString() : t.modelValue), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      let s = "";
      switch (t.size) {
        case "sm":
          s = "text-lg";
          break;
        case "md":
          s = "text-3xl";
          break;
        default:
          s = "text-5xl";
      }
      return s;
    }), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      let s = "";
      switch (t.variant) {
        case "blue":
          s = "text-blue-600 dark:text-blue-400";
          break;
        case "green":
          s = "text-green-600 dark:text-green-400";
          break;
        case "teal":
          s = "text-teal-600 dark:text-teal-400";
          break;
        case "orange":
          t.size === "lg" ? s = "text-orange-400 dark:text-orange-300" : t.size === "md" ? s = "text-orange-500 dark:text-orange-300" : s = "text-orange-600 dark:text-orange-300";
          break;
        case "red":
          s = "text-red-600 dark:text-red-400";
          break;
        case "tan":
          s = "text-tan-600 dark:text-tan-400";
          break;
        case "yellow":
          t.size === "sm" ? s = "text-yellow-600 dark:text-yellow-300" : s = "text-yellow-500 dark:text-yellow-300";
          break;
        case "purple":
          s = "text-purple-600 dark:text-purple-400";
          break;
        case "indigo":
          s = "text-indigo-600 dark:text-indigo-400";
          break;
        case "gray":
          s = "text-gray-600 dark:text-gray-300";
          break;
        default:
          s = "text-black dark:text-white";
          break;
      }
      return s;
    });
    return (s, u) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", null, [
      s.$slots.label || e.label ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Wi, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(s.$slots, "label", {}, () => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.label), 1)
        ])
      ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", qi, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["font-bold", [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(s.$slots, "default", {}, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)), 1)
          ])
        ], 2),
        s.$slots.context || e.context ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Gi, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(s.$slots, "context", {}, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.context), 1)
          ])
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
      ])
    ]));
  }
});
ma.install = (e) => {
  e.component(ma.name, ma);
};
function Yi() {
  return Object.assign({}, It());
}
function ji(e, t) {
  const a = t instanceof Date ? fe(t, 0) : new t(0);
  return a.setFullYear(
    e.getFullYear(),
    e.getMonth(),
    e.getDate()
  ), a.setHours(
    e.getHours(),
    e.getMinutes(),
    e.getSeconds(),
    e.getMilliseconds()
  ), a;
}
const Ui = 10;
class Dr {
  subPriority = 0;
  validate(t, a) {
    return !0;
  }
}
class Ki extends Dr {
  constructor(t, a, n, r, s) {
    super(), this.value = t, this.validateValue = a, this.setValue = n, this.priority = r, s && (this.subPriority = s);
  }
  validate(t, a) {
    return this.validateValue(t, this.value, a);
  }
  set(t, a, n) {
    return this.setValue(t, a, this.value, n);
  }
}
class _i extends Dr {
  priority = Ui;
  subPriority = -1;
  set(t, a) {
    return a.timestampIsSet ? t : fe(t, ji(t, Date));
  }
}
class le {
  run(t, a, n, r) {
    const s = this.parse(t, a, n, r);
    return s ? {
      setter: new Ki(
        s.value,
        this.validate,
        this.set,
        this.priority,
        this.subPriority
      ),
      rest: s.rest
    } : null;
  }
  validate(t, a, n) {
    return !0;
  }
}
class Xi extends le {
  priority = 140;
  parse(t, a, n) {
    switch (a) {
      case "G":
      case "GG":
      case "GGG":
        return n.era(t, { width: "abbreviated" }) || n.era(t, { width: "narrow" });
      case "GGGGG":
        return n.era(t, { width: "narrow" });
      case "GGGG":
      default:
        return n.era(t, { width: "wide" }) || n.era(t, { width: "abbreviated" }) || n.era(t, { width: "narrow" });
    }
  }
  set(t, a, n) {
    return a.era = n, t.setFullYear(n, 0, 1), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = ["R", "u", "t", "T"];
}
const we = {
  month: /^(1[0-2]|0?\d)/,
  // 0 to 12
  date: /^(3[0-1]|[0-2]?\d)/,
  // 0 to 31
  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
  // 0 to 366
  week: /^(5[0-3]|[0-4]?\d)/,
  // 0 to 53
  hour23h: /^(2[0-3]|[0-1]?\d)/,
  // 0 to 23
  hour24h: /^(2[0-4]|[0-1]?\d)/,
  // 0 to 24
  hour11h: /^(1[0-1]|0?\d)/,
  // 0 to 11
  hour12h: /^(1[0-2]|0?\d)/,
  // 0 to 12
  minute: /^[0-5]?\d/,
  // 0 to 59
  second: /^[0-5]?\d/,
  // 0 to 59
  singleDigit: /^\d/,
  // 0 to 9
  twoDigits: /^\d{1,2}/,
  // 0 to 99
  threeDigits: /^\d{1,3}/,
  // 0 to 999
  fourDigits: /^\d{1,4}/,
  // 0 to 9999
  anyDigitsSigned: /^-?\d+/,
  singleDigitSigned: /^-?\d/,
  // 0 to 9, -0 to -9
  twoDigitsSigned: /^-?\d{1,2}/,
  // 0 to 99, -0 to -99
  threeDigitsSigned: /^-?\d{1,3}/,
  // 0 to 999, -0 to -999
  fourDigitsSigned: /^-?\d{1,4}/
  // 0 to 9999, -0 to -9999
}, Ge = {
  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
  basic: /^([+-])(\d{2})(\d{2})|Z/,
  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
  extended: /^([+-])(\d{2}):(\d{2})|Z/,
  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
};
function xe(e, t) {
  return e && {
    value: t(e.value),
    rest: e.rest
  };
}
function ve(e, t) {
  const a = t.match(e);
  return a ? {
    value: parseInt(a[0], 10),
    rest: t.slice(a[0].length)
  } : null;
}
function Ye(e, t) {
  const a = t.match(e);
  if (!a)
    return null;
  if (a[0] === "Z")
    return {
      value: 0,
      rest: t.slice(1)
    };
  const n = a[1] === "+" ? 1 : -1, r = a[2] ? parseInt(a[2], 10) : 0, s = a[3] ? parseInt(a[3], 10) : 0, u = a[5] ? parseInt(a[5], 10) : 0;
  return {
    value: n * (r * Zl + s * Ql + u * Jl),
    rest: t.slice(a[0].length)
  };
}
function Tr(e) {
  return ve(we.anyDigitsSigned, e);
}
function pe(e, t) {
  switch (e) {
    case 1:
      return ve(we.singleDigit, t);
    case 2:
      return ve(we.twoDigits, t);
    case 3:
      return ve(we.threeDigits, t);
    case 4:
      return ve(we.fourDigits, t);
    default:
      return ve(new RegExp("^\\d{1," + e + "}"), t);
  }
}
function nn(e, t) {
  switch (e) {
    case 1:
      return ve(we.singleDigitSigned, t);
    case 2:
      return ve(we.twoDigitsSigned, t);
    case 3:
      return ve(we.threeDigitsSigned, t);
    case 4:
      return ve(we.fourDigitsSigned, t);
    default:
      return ve(new RegExp("^-?\\d{1," + e + "}"), t);
  }
}
function Rn(e) {
  switch (e) {
    case "morning":
      return 4;
    case "evening":
      return 17;
    case "pm":
    case "noon":
    case "afternoon":
      return 12;
    case "am":
    case "midnight":
    case "night":
    default:
      return 0;
  }
}
function Br(e, t) {
  const a = t > 0, n = a ? t : 1 - t;
  let r;
  if (n <= 50)
    r = e || 100;
  else {
    const s = n + 50, u = Math.trunc(s / 100) * 100, f = e >= s % 100;
    r = e + u - (f ? 100 : 0);
  }
  return a ? r : 1 - r;
}
function Pr(e) {
  return e % 400 === 0 || e % 4 === 0 && e % 100 !== 0;
}
class Qi extends le {
  priority = 130;
  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
  parse(t, a, n) {
    const r = (s) => ({
      year: s,
      isTwoDigitYear: a === "yy"
    });
    switch (a) {
      case "y":
        return xe(pe(4, t), r);
      case "yo":
        return xe(
          n.ordinalNumber(t, {
            unit: "year"
          }),
          r
        );
      default:
        return xe(pe(a.length, t), r);
    }
  }
  validate(t, a) {
    return a.isTwoDigitYear || a.year > 0;
  }
  set(t, a, n) {
    const r = t.getFullYear();
    if (n.isTwoDigitYear) {
      const u = Br(
        n.year,
        r
      );
      return t.setFullYear(u, 0, 1), t.setHours(0, 0, 0, 0), t;
    }
    const s = !("era" in a) || a.era === 1 ? n.year : 1 - n.year;
    return t.setFullYear(s, 0, 1), t.setHours(0, 0, 0, 0), t;
  }
}
class Zi extends le {
  priority = 130;
  parse(t, a, n) {
    const r = (s) => ({
      year: s,
      isTwoDigitYear: a === "YY"
    });
    switch (a) {
      case "Y":
        return xe(pe(4, t), r);
      case "Yo":
        return xe(
          n.ordinalNumber(t, {
            unit: "year"
          }),
          r
        );
      default:
        return xe(pe(a.length, t), r);
    }
  }
  validate(t, a) {
    return a.isTwoDigitYear || a.year > 0;
  }
  set(t, a, n, r) {
    const s = In(t, r);
    if (n.isTwoDigitYear) {
      const f = Br(
        n.year,
        s
      );
      return t.setFullYear(
        f,
        0,
        r.firstWeekContainsDate
      ), t.setHours(0, 0, 0, 0), ut(t, r);
    }
    const u = !("era" in a) || a.era === 1 ? n.year : 1 - n.year;
    return t.setFullYear(u, 0, r.firstWeekContainsDate), t.setHours(0, 0, 0, 0), ut(t, r);
  }
  incompatibleTokens = [
    "y",
    "R",
    "u",
    "Q",
    "q",
    "M",
    "L",
    "I",
    "d",
    "D",
    "i",
    "t",
    "T"
  ];
}
class Ji extends le {
  priority = 130;
  parse(t, a) {
    return nn(a === "R" ? 4 : a.length, t);
  }
  set(t, a, n) {
    const r = fe(t, 0);
    return r.setFullYear(n, 0, 4), r.setHours(0, 0, 0, 0), Ht(r);
  }
  incompatibleTokens = [
    "G",
    "y",
    "Y",
    "u",
    "Q",
    "q",
    "M",
    "L",
    "w",
    "d",
    "D",
    "e",
    "c",
    "t",
    "T"
  ];
}
class ec extends le {
  priority = 130;
  parse(t, a) {
    return nn(a === "u" ? 4 : a.length, t);
  }
  set(t, a, n) {
    return t.setFullYear(n, 0, 1), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
}
class tc extends le {
  priority = 120;
  parse(t, a, n) {
    switch (a) {
      case "Q":
      case "QQ":
        return pe(a.length, t);
      case "Qo":
        return n.ordinalNumber(t, { unit: "quarter" });
      case "QQQ":
        return n.quarter(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.quarter(t, {
          width: "narrow",
          context: "formatting"
        });
      case "QQQQQ":
        return n.quarter(t, {
          width: "narrow",
          context: "formatting"
        });
      case "QQQQ":
      default:
        return n.quarter(t, {
          width: "wide",
          context: "formatting"
        }) || n.quarter(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.quarter(t, {
          width: "narrow",
          context: "formatting"
        });
    }
  }
  validate(t, a) {
    return a >= 1 && a <= 4;
  }
  set(t, a, n) {
    return t.setMonth((n - 1) * 3, 1), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "Y",
    "R",
    "q",
    "M",
    "L",
    "w",
    "I",
    "d",
    "D",
    "i",
    "e",
    "c",
    "t",
    "T"
  ];
}
class ac extends le {
  priority = 120;
  parse(t, a, n) {
    switch (a) {
      case "q":
      case "qq":
        return pe(a.length, t);
      case "qo":
        return n.ordinalNumber(t, { unit: "quarter" });
      case "qqq":
        return n.quarter(t, {
          width: "abbreviated",
          context: "standalone"
        }) || n.quarter(t, {
          width: "narrow",
          context: "standalone"
        });
      case "qqqqq":
        return n.quarter(t, {
          width: "narrow",
          context: "standalone"
        });
      case "qqqq":
      default:
        return n.quarter(t, {
          width: "wide",
          context: "standalone"
        }) || n.quarter(t, {
          width: "abbreviated",
          context: "standalone"
        }) || n.quarter(t, {
          width: "narrow",
          context: "standalone"
        });
    }
  }
  validate(t, a) {
    return a >= 1 && a <= 4;
  }
  set(t, a, n) {
    return t.setMonth((n - 1) * 3, 1), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "Y",
    "R",
    "Q",
    "M",
    "L",
    "w",
    "I",
    "d",
    "D",
    "i",
    "e",
    "c",
    "t",
    "T"
  ];
}
class nc extends le {
  incompatibleTokens = [
    "Y",
    "R",
    "q",
    "Q",
    "L",
    "w",
    "I",
    "D",
    "i",
    "e",
    "c",
    "t",
    "T"
  ];
  priority = 110;
  parse(t, a, n) {
    const r = (s) => s - 1;
    switch (a) {
      case "M":
        return xe(
          ve(we.month, t),
          r
        );
      case "MM":
        return xe(pe(2, t), r);
      case "Mo":
        return xe(
          n.ordinalNumber(t, {
            unit: "month"
          }),
          r
        );
      case "MMM":
        return n.month(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.month(t, { width: "narrow", context: "formatting" });
      case "MMMMM":
        return n.month(t, {
          width: "narrow",
          context: "formatting"
        });
      case "MMMM":
      default:
        return n.month(t, { width: "wide", context: "formatting" }) || n.month(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.month(t, { width: "narrow", context: "formatting" });
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 11;
  }
  set(t, a, n) {
    return t.setMonth(n, 1), t.setHours(0, 0, 0, 0), t;
  }
}
class rc extends le {
  priority = 110;
  parse(t, a, n) {
    const r = (s) => s - 1;
    switch (a) {
      case "L":
        return xe(
          ve(we.month, t),
          r
        );
      case "LL":
        return xe(pe(2, t), r);
      case "Lo":
        return xe(
          n.ordinalNumber(t, {
            unit: "month"
          }),
          r
        );
      case "LLL":
        return n.month(t, {
          width: "abbreviated",
          context: "standalone"
        }) || n.month(t, { width: "narrow", context: "standalone" });
      case "LLLLL":
        return n.month(t, {
          width: "narrow",
          context: "standalone"
        });
      case "LLLL":
      default:
        return n.month(t, { width: "wide", context: "standalone" }) || n.month(t, {
          width: "abbreviated",
          context: "standalone"
        }) || n.month(t, { width: "narrow", context: "standalone" });
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 11;
  }
  set(t, a, n) {
    return t.setMonth(n, 1), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "Y",
    "R",
    "q",
    "Q",
    "M",
    "w",
    "I",
    "D",
    "i",
    "e",
    "c",
    "t",
    "T"
  ];
}
function sc(e, t, a) {
  const n = Z(e), r = Cr(n, a) - t;
  return n.setDate(n.getDate() - r * 7), n;
}
class lc extends le {
  priority = 100;
  parse(t, a, n) {
    switch (a) {
      case "w":
        return ve(we.week, t);
      case "wo":
        return n.ordinalNumber(t, { unit: "week" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 1 && a <= 53;
  }
  set(t, a, n, r) {
    return ut(sc(t, n, r), r);
  }
  incompatibleTokens = [
    "y",
    "R",
    "u",
    "q",
    "Q",
    "M",
    "L",
    "I",
    "d",
    "D",
    "i",
    "t",
    "T"
  ];
}
function oc(e, t) {
  const a = Z(e), n = Mr(a) - t;
  return a.setDate(a.getDate() - n * 7), a;
}
class ic extends le {
  priority = 100;
  parse(t, a, n) {
    switch (a) {
      case "I":
        return ve(we.week, t);
      case "Io":
        return n.ordinalNumber(t, { unit: "week" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 1 && a <= 53;
  }
  set(t, a, n) {
    return Ht(oc(t, n));
  }
  incompatibleTokens = [
    "y",
    "Y",
    "u",
    "q",
    "Q",
    "M",
    "L",
    "w",
    "d",
    "D",
    "e",
    "c",
    "t",
    "T"
  ];
}
const cc = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], dc = [
  31,
  29,
  31,
  30,
  31,
  30,
  31,
  31,
  30,
  31,
  30,
  31
];
class uc extends le {
  priority = 90;
  subPriority = 1;
  parse(t, a, n) {
    switch (a) {
      case "d":
        return ve(we.date, t);
      case "do":
        return n.ordinalNumber(t, { unit: "date" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    const n = t.getFullYear(), r = Pr(n), s = t.getMonth();
    return r ? a >= 1 && a <= dc[s] : a >= 1 && a <= cc[s];
  }
  set(t, a, n) {
    return t.setDate(n), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "Y",
    "R",
    "q",
    "Q",
    "w",
    "I",
    "D",
    "i",
    "e",
    "c",
    "t",
    "T"
  ];
}
class fc extends le {
  priority = 90;
  subpriority = 1;
  parse(t, a, n) {
    switch (a) {
      case "D":
      case "DD":
        return ve(we.dayOfYear, t);
      case "Do":
        return n.ordinalNumber(t, { unit: "date" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    const n = t.getFullYear();
    return Pr(n) ? a >= 1 && a <= 366 : a >= 1 && a <= 365;
  }
  set(t, a, n) {
    return t.setMonth(0, n), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "Y",
    "R",
    "q",
    "Q",
    "M",
    "L",
    "w",
    "I",
    "d",
    "E",
    "i",
    "e",
    "c",
    "t",
    "T"
  ];
}
function un(e, t) {
  const a = Z(e);
  return isNaN(t) ? fe(e, NaN) : (t && a.setDate(a.getDate() + t), a);
}
function Fn(e, t, a) {
  const n = It(), r = a?.weekStartsOn ?? a?.locale?.options?.weekStartsOn ?? n.weekStartsOn ?? n.locale?.options?.weekStartsOn ?? 0, s = Z(e), u = s.getDay(), v = (t % 7 + 7) % 7, g = 7 - r, m = t < 0 || t > 6 ? t - (u + g) % 7 : (v + g) % 7 - (u + g) % 7;
  return un(s, m);
}
class hc extends le {
  priority = 90;
  parse(t, a, n) {
    switch (a) {
      case "E":
      case "EE":
      case "EEE":
        return n.day(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
      case "EEEEE":
        return n.day(t, {
          width: "narrow",
          context: "formatting"
        });
      case "EEEEEE":
        return n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
      case "EEEE":
      default:
        return n.day(t, { width: "wide", context: "formatting" }) || n.day(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 6;
  }
  set(t, a, n, r) {
    return t = Fn(t, n, r), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
}
class yc extends le {
  priority = 90;
  parse(t, a, n, r) {
    const s = (u) => {
      const f = Math.floor((u - 1) / 7) * 7;
      return (u + r.weekStartsOn + 6) % 7 + f;
    };
    switch (a) {
      case "e":
      case "ee":
        return xe(pe(a.length, t), s);
      case "eo":
        return xe(
          n.ordinalNumber(t, {
            unit: "day"
          }),
          s
        );
      case "eee":
        return n.day(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
      case "eeeee":
        return n.day(t, {
          width: "narrow",
          context: "formatting"
        });
      case "eeeeee":
        return n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
      case "eeee":
      default:
        return n.day(t, { width: "wide", context: "formatting" }) || n.day(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.day(t, { width: "short", context: "formatting" }) || n.day(t, { width: "narrow", context: "formatting" });
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 6;
  }
  set(t, a, n, r) {
    return t = Fn(t, n, r), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "y",
    "R",
    "u",
    "q",
    "Q",
    "M",
    "L",
    "I",
    "d",
    "D",
    "E",
    "i",
    "c",
    "t",
    "T"
  ];
}
class mc extends le {
  priority = 90;
  parse(t, a, n, r) {
    const s = (u) => {
      const f = Math.floor((u - 1) / 7) * 7;
      return (u + r.weekStartsOn + 6) % 7 + f;
    };
    switch (a) {
      case "c":
      case "cc":
        return xe(pe(a.length, t), s);
      case "co":
        return xe(
          n.ordinalNumber(t, {
            unit: "day"
          }),
          s
        );
      case "ccc":
        return n.day(t, {
          width: "abbreviated",
          context: "standalone"
        }) || n.day(t, { width: "short", context: "standalone" }) || n.day(t, { width: "narrow", context: "standalone" });
      case "ccccc":
        return n.day(t, {
          width: "narrow",
          context: "standalone"
        });
      case "cccccc":
        return n.day(t, { width: "short", context: "standalone" }) || n.day(t, { width: "narrow", context: "standalone" });
      case "cccc":
      default:
        return n.day(t, { width: "wide", context: "standalone" }) || n.day(t, {
          width: "abbreviated",
          context: "standalone"
        }) || n.day(t, { width: "short", context: "standalone" }) || n.day(t, { width: "narrow", context: "standalone" });
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 6;
  }
  set(t, a, n, r) {
    return t = Fn(t, n, r), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "y",
    "R",
    "u",
    "q",
    "Q",
    "M",
    "L",
    "I",
    "d",
    "D",
    "E",
    "i",
    "e",
    "t",
    "T"
  ];
}
function gc(e) {
  let a = Z(e).getDay();
  return a === 0 && (a = 7), a;
}
function vc(e, t) {
  const a = Z(e), n = gc(a), r = t - n;
  return un(a, r);
}
class bc extends le {
  priority = 90;
  parse(t, a, n) {
    const r = (s) => s === 0 ? 7 : s;
    switch (a) {
      case "i":
      case "ii":
        return pe(a.length, t);
      case "io":
        return n.ordinalNumber(t, { unit: "day" });
      case "iii":
        return xe(
          n.day(t, {
            width: "abbreviated",
            context: "formatting"
          }) || n.day(t, {
            width: "short",
            context: "formatting"
          }) || n.day(t, {
            width: "narrow",
            context: "formatting"
          }),
          r
        );
      case "iiiii":
        return xe(
          n.day(t, {
            width: "narrow",
            context: "formatting"
          }),
          r
        );
      case "iiiiii":
        return xe(
          n.day(t, {
            width: "short",
            context: "formatting"
          }) || n.day(t, {
            width: "narrow",
            context: "formatting"
          }),
          r
        );
      case "iiii":
      default:
        return xe(
          n.day(t, {
            width: "wide",
            context: "formatting"
          }) || n.day(t, {
            width: "abbreviated",
            context: "formatting"
          }) || n.day(t, {
            width: "short",
            context: "formatting"
          }) || n.day(t, {
            width: "narrow",
            context: "formatting"
          }),
          r
        );
    }
  }
  validate(t, a) {
    return a >= 1 && a <= 7;
  }
  set(t, a, n) {
    return t = vc(t, n), t.setHours(0, 0, 0, 0), t;
  }
  incompatibleTokens = [
    "y",
    "Y",
    "u",
    "q",
    "Q",
    "M",
    "L",
    "w",
    "d",
    "D",
    "E",
    "e",
    "c",
    "t",
    "T"
  ];
}
class pc extends le {
  priority = 80;
  parse(t, a, n) {
    switch (a) {
      case "a":
      case "aa":
      case "aaa":
        return n.dayPeriod(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
      case "aaaaa":
        return n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
      case "aaaa":
      default:
        return n.dayPeriod(t, {
          width: "wide",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
    }
  }
  set(t, a, n) {
    return t.setHours(Rn(n), 0, 0, 0), t;
  }
  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
}
class wc extends le {
  priority = 80;
  parse(t, a, n) {
    switch (a) {
      case "b":
      case "bb":
      case "bbb":
        return n.dayPeriod(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
      case "bbbbb":
        return n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
      case "bbbb":
      default:
        return n.dayPeriod(t, {
          width: "wide",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
    }
  }
  set(t, a, n) {
    return t.setHours(Rn(n), 0, 0, 0), t;
  }
  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
}
class xc extends le {
  priority = 80;
  parse(t, a, n) {
    switch (a) {
      case "B":
      case "BB":
      case "BBB":
        return n.dayPeriod(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
      case "BBBBB":
        return n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
      case "BBBB":
      default:
        return n.dayPeriod(t, {
          width: "wide",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "abbreviated",
          context: "formatting"
        }) || n.dayPeriod(t, {
          width: "narrow",
          context: "formatting"
        });
    }
  }
  set(t, a, n) {
    return t.setHours(Rn(n), 0, 0, 0), t;
  }
  incompatibleTokens = ["a", "b", "t", "T"];
}
class kc extends le {
  priority = 70;
  parse(t, a, n) {
    switch (a) {
      case "h":
        return ve(we.hour12h, t);
      case "ho":
        return n.ordinalNumber(t, { unit: "hour" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 1 && a <= 12;
  }
  set(t, a, n) {
    const r = t.getHours() >= 12;
    return r && n < 12 ? t.setHours(n + 12, 0, 0, 0) : !r && n === 12 ? t.setHours(0, 0, 0, 0) : t.setHours(n, 0, 0, 0), t;
  }
  incompatibleTokens = ["H", "K", "k", "t", "T"];
}
class Mc extends le {
  priority = 70;
  parse(t, a, n) {
    switch (a) {
      case "H":
        return ve(we.hour23h, t);
      case "Ho":
        return n.ordinalNumber(t, { unit: "hour" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 23;
  }
  set(t, a, n) {
    return t.setHours(n, 0, 0, 0), t;
  }
  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
}
class Cc extends le {
  priority = 70;
  parse(t, a, n) {
    switch (a) {
      case "K":
        return ve(we.hour11h, t);
      case "Ko":
        return n.ordinalNumber(t, { unit: "hour" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 11;
  }
  set(t, a, n) {
    return t.getHours() >= 12 && n < 12 ? t.setHours(n + 12, 0, 0, 0) : t.setHours(n, 0, 0, 0), t;
  }
  incompatibleTokens = ["h", "H", "k", "t", "T"];
}
class Sc extends le {
  priority = 70;
  parse(t, a, n) {
    switch (a) {
      case "k":
        return ve(we.hour24h, t);
      case "ko":
        return n.ordinalNumber(t, { unit: "hour" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 1 && a <= 24;
  }
  set(t, a, n) {
    const r = n <= 24 ? n % 24 : n;
    return t.setHours(r, 0, 0, 0), t;
  }
  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
}
class $c extends le {
  priority = 60;
  parse(t, a, n) {
    switch (a) {
      case "m":
        return ve(we.minute, t);
      case "mo":
        return n.ordinalNumber(t, { unit: "minute" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 59;
  }
  set(t, a, n) {
    return t.setMinutes(n, 0, 0), t;
  }
  incompatibleTokens = ["t", "T"];
}
class Lc extends le {
  priority = 50;
  parse(t, a, n) {
    switch (a) {
      case "s":
        return ve(we.second, t);
      case "so":
        return n.ordinalNumber(t, { unit: "second" });
      default:
        return pe(a.length, t);
    }
  }
  validate(t, a) {
    return a >= 0 && a <= 59;
  }
  set(t, a, n) {
    return t.setSeconds(n, 0), t;
  }
  incompatibleTokens = ["t", "T"];
}
class zc extends le {
  priority = 30;
  parse(t, a) {
    const n = (r) => Math.trunc(r * Math.pow(10, -a.length + 3));
    return xe(pe(a.length, t), n);
  }
  set(t, a, n) {
    return t.setMilliseconds(n), t;
  }
  incompatibleTokens = ["t", "T"];
}
class Dc extends le {
  priority = 10;
  parse(t, a) {
    switch (a) {
      case "X":
        return Ye(
          Ge.basicOptionalMinutes,
          t
        );
      case "XX":
        return Ye(Ge.basic, t);
      case "XXXX":
        return Ye(
          Ge.basicOptionalSeconds,
          t
        );
      case "XXXXX":
        return Ye(
          Ge.extendedOptionalSeconds,
          t
        );
      case "XXX":
      default:
        return Ye(Ge.extended, t);
    }
  }
  set(t, a, n) {
    return a.timestampIsSet ? t : fe(
      t,
      t.getTime() - an(t) - n
    );
  }
  incompatibleTokens = ["t", "T", "x"];
}
class Tc extends le {
  priority = 10;
  parse(t, a) {
    switch (a) {
      case "x":
        return Ye(
          Ge.basicOptionalMinutes,
          t
        );
      case "xx":
        return Ye(Ge.basic, t);
      case "xxxx":
        return Ye(
          Ge.basicOptionalSeconds,
          t
        );
      case "xxxxx":
        return Ye(
          Ge.extendedOptionalSeconds,
          t
        );
      case "xxx":
      default:
        return Ye(Ge.extended, t);
    }
  }
  set(t, a, n) {
    return a.timestampIsSet ? t : fe(
      t,
      t.getTime() - an(t) - n
    );
  }
  incompatibleTokens = ["t", "T", "X"];
}
class Bc extends le {
  priority = 40;
  parse(t) {
    return Tr(t);
  }
  set(t, a, n) {
    return [fe(t, n * 1e3), { timestampIsSet: !0 }];
  }
  incompatibleTokens = "*";
}
class Pc extends le {
  priority = 20;
  parse(t) {
    return Tr(t);
  }
  set(t, a, n) {
    return [fe(t, n), { timestampIsSet: !0 }];
  }
  incompatibleTokens = "*";
}
const Ac = {
  G: new Xi(),
  y: new Qi(),
  Y: new Zi(),
  R: new Ji(),
  u: new ec(),
  Q: new tc(),
  q: new ac(),
  M: new nc(),
  L: new rc(),
  w: new lc(),
  I: new ic(),
  d: new uc(),
  D: new fc(),
  E: new hc(),
  e: new yc(),
  c: new mc(),
  i: new bc(),
  a: new pc(),
  b: new wc(),
  B: new xc(),
  h: new kc(),
  H: new Mc(),
  K: new Cc(),
  k: new Sc(),
  m: new $c(),
  s: new Lc(),
  S: new zc(),
  X: new Dc(),
  x: new Tc(),
  t: new Bc(),
  T: new Pc()
}, Vc = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g, Oc = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g, Hc = /^'([^]*?)'?$/, Nc = /''/g, Ec = /\S/, Ic = /[a-zA-Z]/;
function pn(e, t, a, n) {
  const r = Yi(), s = r.locale ?? wr, u = r.firstWeekContainsDate ?? r.locale?.options?.firstWeekContainsDate ?? 1, f = r.weekStartsOn ?? r.locale?.options?.weekStartsOn ?? 0;
  if (t === "")
    return e === "" ? Z(a) : fe(a, NaN);
  const v = {
    firstWeekContainsDate: u,
    weekStartsOn: f,
    locale: s
  }, g = [new _i()], m = t.match(Oc).map((w) => {
    const b = w[0];
    if (b in Ln) {
      const k = Ln[b];
      return k(w, s.formatLong);
    }
    return w;
  }).join("").match(Vc), y = [];
  for (let w of m) {
    Lr(w) && zn(w, t, e), $r(w) && zn(w, t, e);
    const b = w[0], k = Ac[b];
    if (k) {
      const { incompatibleTokens: D } = k;
      if (Array.isArray(D)) {
        const L = y.find(
          (B) => D.includes(B.token) || B.token === b
        );
        if (L)
          throw new RangeError(
            `The format string mustn't contain \`${L.fullToken}\` and \`${w}\` at the same time`
          );
      } else if (k.incompatibleTokens === "*" && y.length > 0)
        throw new RangeError(
          `The format string mustn't contain \`${w}\` and any other token at the same time`
        );
      y.push({ token: b, fullToken: w });
      const C = k.run(
        e,
        w,
        s.match,
        v
      );
      if (!C)
        return fe(a, NaN);
      g.push(C.setter), e = C.rest;
    } else {
      if (b.match(Ic))
        throw new RangeError(
          "Format string contains an unescaped latin alphabet character `" + b + "`"
        );
      if (w === "''" ? w = "'" : b === "'" && (w = Rc(w)), e.indexOf(w) === 0)
        e = e.slice(w.length);
      else
        return fe(a, NaN);
    }
  }
  if (e.length > 0 && Ec.test(e))
    return fe(a, NaN);
  const d = g.map((w) => w.priority).sort((w, b) => b - w).filter((w, b, k) => k.indexOf(w) === b).map(
    (w) => g.filter((b) => b.priority === w).sort((b, k) => k.subPriority - b.subPriority)
  ).map((w) => w[0]);
  let h = Z(a);
  if (isNaN(h.getTime()))
    return fe(a, NaN);
  const p = {};
  for (const w of d) {
    if (!w.validate(h, v))
      return fe(a, NaN);
    const b = w.set(h, p, v);
    Array.isArray(b) ? (h = b[0], Object.assign(p, b[1])) : h = b;
  }
  return fe(a, h);
}
function Rc(e) {
  return e.match(Hc)[1].replace(Nc, "'");
}
function wn(e, t) {
  return un(e, -t);
}
function rr(e, t) {
  return ot(e, t * 12);
}
const Fc = ["disabled", "onClick"], Wc = {
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512",
  "aria-hidden": "true",
  role: "img",
  class: "fill-current w-4 h-4"
}, qc = {
  key: 0,
  d: "M256 8C119 8 8 119 8 256s111 248 248 248s248-111 248-248S393 8 256 8zm0 448c-110.5 0-200-89.5-200-200S145.5 56 256 56s200 89.5 200 200s-89.5 200-200 200zm61.8-104.4l-84.9-61.7c-3.1-2.3-4.9-5.9-4.9-9.7V116c0-6.6 5.4-12 12-12h32c6.6 0 12 5.4 12 12v141.7l66.8 48.6c5.4 3.9 6.5 11.4 2.6 16.8L334.6 349c-3.9 5.3-11.4 6.5-16.8 2.6z",
  fill: "currentColor"
}, Gc = {
  key: 1,
  d: "M148 288h-40c-6.6 0-12-5.4-12-12v-40c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12zm108-12v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm96 0v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm-96 96v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm-96 0v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm192 0v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm96-260v352c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V112c0-26.5 21.5-48 48-48h48V12c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v52h128V12c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v52h48c26.5 0 48 21.5 48 48zm-48 346V160H48v298c0 3.3 2.7 6 6 6h340c3.3 0 6-2.7 6-6z"
}, Yc = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Select a date", -1), jc = ["title", "placeholder", "readonly", "disabled", "required", "pattern", "onFocusin", "onKeydown", "onMousedown", "onKeyup"], Uc = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  d: "M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z",
  fill: "currentColor"
}, null, -1), Kc = [
  Uc
], _c = ["disabled", "onClick"], Xc = {
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512",
  "aria-hidden": "true",
  role: "img",
  class: "fill-current w-4 h-4"
}, Qc = {
  key: 0,
  d: "M256 8C119 8 8 119 8 256s111 248 248 248s248-111 248-248S393 8 256 8zm0 448c-110.5 0-200-89.5-200-200S145.5 56 256 56s200 89.5 200 200s-89.5 200-200 200zm61.8-104.4l-84.9-61.7c-3.1-2.3-4.9-5.9-4.9-9.7V116c0-6.6 5.4-12 12-12h32c6.6 0 12 5.4 12 12v141.7l66.8 48.6c5.4 3.9 6.5 11.4 2.6 16.8L334.6 349c-3.9 5.3-11.4 6.5-16.8 2.6z",
  fill: "currentColor"
}, Zc = {
  key: 1,
  d: "M148 288h-40c-6.6 0-12-5.4-12-12v-40c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12zm108-12v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm96 0v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm-96 96v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm-96 0v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm192 0v-40c0-6.6-5.4-12-12-12h-40c-6.6 0-12 5.4-12 12v40c0 6.6 5.4 12 12 12h40c6.6 0 12-5.4 12-12zm96-260v352c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V112c0-26.5 21.5-48 48-48h48V12c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v52h128V12c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v52h48c26.5 0 48 21.5 48 48zm-48 346V160H48v298c0 3.3 2.7 6 6 6h340c3.3 0 6-2.7 6-6z"
}, Jc = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Select a date", -1), ed = ["title", "placeholder", "readonly", "disabled", "required", "pattern", "onFocusin", "onKeydown", "onMousedown", "onKeyup"], td = { class: "p-4" }, ga = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsDatepicker",
  __name: "Datepicker",
  props: {
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" },
    /**
     * Determines whether to display or hide the arrow for range selection.
     */
    hideArrow: { type: Boolean, default: !1 },
    /**
     * Determines the sizing of the component.
     */
    size: { type: String, default: "md" },
    /**
     * Determines the mode of the component.
     */
    mode: { type: String, default: "date" },
    /**
     * The placement of the popover on the screen.
     */
    placement: { type: String, default: "bottom" },
    /**
     * The v-model for the component.
     *
     * For single selections, this value can be null or a date object.
     *
     * For range selections, this is an object with start and end keys
     * that can either be null or a date object.
     *
     * Range example:
     *
     * **{ start: new Date(), end: null }**
     */
    modelValue: { type: [Object, Date], default: null },
    /**
     * The max date allowed for the datepicker.
     */
    max: { type: Date, default: null },
    /**
     * The min date allowed for the datepicker.
     */
    min: { type: Date, default: null },
    /**
     * Determines if the component is required.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Sets a valid styling if true.
     */
    valid: { type: Boolean, default: !1 },
    /**
     * Sets an invalid styling if true.
     */
    invalid: { type: Boolean, default: !1 },
    /**
     * Determines if the component is readonly.
     */
    readonly: { type: Boolean, default: !1 },
    /**
     * Determines if the component is disabled.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines whether to use the current time when selecting a date that is equal to today.
     *
     * If false, this sets the time to the start of the date.
     */
    useCurrentTimeForToday: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)({ start: "", end: "" }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    }), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.modelValue && !(a.modelValue instanceof Date)), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.mode) {
        case "date":
          return "mm/dd/yyyy";
        case "time":
          return "hh:mm am/pm";
        case "dateTime":
          return "mm/dd/yyyy hh:mm am/pm";
        default:
          return "mm/dd/yyyy";
      }
    }), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.mode) {
        case "date":
          return "MM/dd/yyyy";
        case "time":
          return "hh:mm aaa";
        case "dateTime":
          return "MM/dd/yyyy hh:mm aaa";
        default:
          return "MM/dd/yyyy";
      }
    }), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.mode) {
        case "date":
          return "[0-9]{2}/[0-9]{2}/[0-9]{4}";
        case "time":
          return "[0-9]{2}:[0-9]{2} [a|p]m";
        case "dateTime":
          return "[0-9]{2}/[0-9]{2}/[0-9]{4} [0-9]{2}:[0-9]{2} [a|p]m";
        default:
          return "[0-9]{2}/[0-9]{2}/[0-9]{4}";
      }
    }), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(b) {
        n("update:model-value", b);
      }
    }), h = (b) => {
      if (b === "now") {
        const C = /* @__PURE__ */ new Date();
        return { date: C, text: Ce(C, m.value) };
      } else if (b === "today") {
        const C = Me(Te(He(Ne(/* @__PURE__ */ new Date(), 0), 0), 0), 0);
        return { date: C, text: Ce(C, m.value) };
      } else if (b === "tomorrow") {
        const C = un(Me(Te(He(Ne(/* @__PURE__ */ new Date(), 0), 0), 0), 0), 1);
        return { date: C, text: Ce(C, m.value) };
      } else if (b === "yesterday") {
        const C = wn(Me(Te(He(Ne(/* @__PURE__ */ new Date(), 0), 0), 0), 0), 1);
        return { date: C, text: Ce(C, m.value) };
      }
      const D = [
        "MM/dd/yyyy hh:mm aaa",
        "MM/dd/yyyy hh:mm a",
        "MM/dd/yyyy h:mm aaa",
        "MM/dd/yyyy h:mm a",
        "MM/dd/yyyy hh:mmaaa",
        "MM/dd/yyyy hh:mma",
        "MM/dd/yyyy h:mmaaa",
        "MM/dd/yyyy h:mma",
        "MM/dd/yyyy H:mm",
        "MM/dd/yyyy HH:mm",
        "MM/dd/yyyy HH:mm:ss",
        "MM-dd-yyyy hh:mm aaa",
        "MM-dd-yyyy hh:mm a",
        "MM-dd-yyyy h:mm aaa",
        "MM-dd-yyyy h:mm a",
        "MM-dd-yyyy ha",
        "MM-dd-yyyy haaa",
        "MM-dd-yyyy hh:mmaaa",
        "MM-dd-yyyy hh:mma",
        "MM-dd-yyyy h:mmaaa",
        "MM-dd-yyyy h:mma",
        "MM-dd-yyyy H:mm",
        "MM-dd-yyyy HH:mm",
        "MM-dd-yyyy HH:mm:ss",
        "yyyy-MM-dd hh:mm aaa",
        "yyyy-MM-dd hh:mm a",
        "yyyy-MM-dd h:mm aaa",
        "yyyy-MM-dd h:mm a",
        "yyyy-MM-dd hh:mma",
        "yyyy-MM-dd h:mmaaa",
        "yyyy-MM-dd h:mma",
        "yyyy-MM-dd H:mm",
        "yyyy-MM-dd HH:mm",
        "yyyy-MM-dd HH:mm:ss",
        "MM/dd/yyyy",
        "MM-dd-yyyy",
        "yyyy-MM-dd",
        "M/d",
        "MM/dd",
        "MM/yyyy",
        "M-d",
        "MM-dd",
        "MM-yyyy",
        "yyyy/MM",
        "yyyy-MM",
        "M/dd/yyyy hh:mm aaa",
        "M/dd/yyyy hh:mm a",
        "M/dd/yyyy h:mm aaa",
        "M/dd/yyyy h:mm a",
        "M/dd/yyyy ha",
        "M/dd/yyyy haaa",
        "M/dd/yyyy hh:mmaaa",
        "M/dd/yyyy hh:mma",
        "M/dd/yyyy h:mmaaa",
        "M/dd/yyyy h:mma",
        "M/dd/yyyy H:mm",
        "M/dd/yyyy HH:mm",
        "M/dd/yyyy HH:mm:ss",
        "M-dd-yyyy hh:mm aaa",
        "M-dd-yyyy hh:mm a",
        "M-dd-yyyy h:mm aaa",
        "M-dd-yyyy h:mm a",
        "M-dd-yyyy hh:mmaaa",
        "M-dd-yyyy hh:mma",
        "M-dd-yyyy h:mmaaa",
        "M-dd-yyyy h:mma",
        "M-dd-yyyy H:mm",
        "M-dd-yyyy HH:mm",
        "M-dd-yyyy HH:mm:ss",
        "yyyy-M-dd hh:mm aaa",
        "yyyy-M-dd hh:mm a",
        "yyyy-M-dd h:mm aaa",
        "yyyy-M-dd h:mm a",
        "yyyy-M-dd hh:mma",
        "yyyy-M-dd h:mmaaa",
        "yyyy-M-dd h:mma",
        "yyyy-M-dd H:mm",
        "yyyy-M-dd HH:mm",
        "yyyy-M-dd HH:mm:ss",
        "yyyy-M-dd",
        "M/yyyy",
        "M-yyyy",
        "M/yyyy haaa",
        "M-yyyy haaa",
        "M/yyyy ha",
        "M/yyyy HH:mm:ss",
        "M-yyyy HH:mm:ss",
        "M.yyyy HH:mm:ss",
        "M-yyyy ha",
        "M/yyyy h:mmaaa",
        "M-yyyy h:mmaaa",
        "M/yyyy h:mma",
        "M-yyyy h:mma",
        "M/yyyy h:mm aaa",
        "M-yyyy h:mm aaa",
        "M/yyyy h:mm a",
        "M-yyyy h:mm a",
        "yyyy/M",
        "yyyy-M",
        "yyyy",
        "EEE",
        "EEEE",
        "LLL",
        "LLLL",
        "LLL yyyy",
        "LLLL yyyy",
        "LLL dd yyyy",
        "LLLL dd yyyy",
        "hh:mm aaa",
        "hh:mm a",
        "h:mm aaa",
        "h:mm a",
        "hh:mmaaa",
        "hh:mma",
        "h:mmaaa",
        "h:mma",
        "HH:mm:ss",
        "H:mm",
        "HH:mm",
        "QQQ",
        "QQQQ",
        "QQQ yyyy",
        "QQQQ yyyy",
        "PP",
        "PPP",
        "PPPP",
        "bbb",
        "h BBB",
        "h:mm BBB",
        "hh BBB",
        "hh:mm BBB",
        "hBBB",
        "h:mmBBB",
        "hhBBB",
        "hh:mmBBB"
      ].filter((C) => zr(pn(b, C, /* @__PURE__ */ new Date())));
      if (D.length > 0) {
        let C = pn(b, D[0], /* @__PURE__ */ new Date());
        if (a.mode === "date")
          C = Me(Te(He(Ne(C, 0), 0), 0), 0);
        else if (a.mode === "time") {
          const M = Ce(C, "HH:mm:ss"), H = Ce(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
          C = pn(`${H} ${M}`, "yyyy-MM-dd HH:mm:ss", /* @__PURE__ */ new Date());
        }
        const L = C.getFullYear();
        L < 41 ? C = rr(C, 2e3) : L >= 41 && L < 99 && (C = rr(C, 1900));
        const B = Mn(C, a.min), A = gt(wn(C, 1), a.max), E = Cn(wn(C, 1), a.max);
        if (!B && !A && !E)
          return { date: C, text: Ce(C, m.value) };
      }
      return { date: null, text: "" };
    };
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(d, (b) => {
      if (v.value) {
        const k = b && b.start && h(Ce(b.start, "yyyy-MM-dd HH:mm:ss")) || { date: null, text: "" }, D = b.end && h(Ce(b.end, "yyyy-MM-dd HH:mm:ss")) || { date: null, text: "" };
        k.date && D.date && gt(k.date, D.date) ? r.value = {
          start: D.text,
          end: k.text
        } : r.value = {
          start: k.text,
          end: D.text
        };
      } else {
        const k = b && h(Ce(b, "yyyy-MM-dd HH:mm:ss")) || { date: null, text: "" };
        r.value = {
          start: k.text,
          end: ""
        };
      }
    }, { deep: !0, immediate: !0 });
    const p = (b, k) => {
      b && b instanceof Date || b && !(b instanceof Date) && !b.start ? s.value.focus() : b && !(b instanceof Date) && !b.end || b && !(b instanceof Date) && b.end ? u.value.focus() : s.value.focus(), a.mode === "date" && (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        (v.value && r.value.start && r.value.end || !v.value && r.value.start) && k();
      });
    }, w = () => {
      if (v.value) {
        const b = h(r.value.start), k = h(r.value.end);
        d.value = {
          start: b.date && k.date && Sn([b.date, k.date]) || b.date,
          end: b.date && k.date && $n([b.date, k.date]) || k.date
        }, b.date && k.date && gt(b.date, k.date) ? r.value = {
          start: k.text,
          end: b.text
        } : r.value = {
          start: b.text,
          end: k.text
        };
      } else {
        const b = h(r.value.start);
        d.value = b.date, r.value = {
          start: b.text,
          end: ""
        };
      }
    };
    return (b, k) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(_e, {
      "data-id": "sds-datepicker",
      class: "w-full",
      placement: e.placement,
      disabled: e.disabled,
      "popper-class": `absolute bg-white border dark:text-gray-50 dark:bg-gray-850 dark:border-gray-700 shadow-lg rounded-md w-auto ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f)}`,
      "arrow-class": "absolute bg-white border dark:bg-gray-850 dark:border-gray-700 w-3 h-3 rotate-45",
      "placement-top-arrow-class": "-bottom-1.5 border-t-0 border-l-0",
      "placement-right-arrow-class": "-left-1.5 border-t-0 border-r-0",
      "placement-bottom-arrow-class": "-top-1.5 border-b-0 border-r-0",
      "placement-left-arrow-class": "-right-1.5 border-b-0 border-l-0"
    }, {
      trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: D, close: C, toggle: L }) => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex w-full", { "gap-1": e.size === "sm", "gap-2": e.size !== "sm" }])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["w-full input-group", {
              "input-group-sm": e.size === "sm",
              disabled: e.disabled,
              valid: e.valid,
              invalid: e.invalid
            }])
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
              type: "button",
              tabindex: "-1",
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["input-group-addon fill-current", {
                "pointer-events-none text-gray-300 border-gray-200": e.disabled || e.readonly,
                "border-none": e.disabled
              }]),
              disabled: e.disabled || e.readonly,
              onClick: (B) => {
                L(), b.$refs.startDateInput.focus();
              }
            }, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", Wc, [
                e.mode === "time" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", qc)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Gc))
              ])),
              Yc
            ], 10, Fc),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
              ref_key: "startDateInput",
              ref: s,
              "onUpdate:modelValue": k[0] || (k[0] = (B) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).start = B),
              "aria-label": "Start date",
              type: "text",
              class: "form-control",
              title: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)}`,
              placeholder: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g),
              readonly: e.readonly,
              disabled: e.disabled,
              required: e.required,
              pattern: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(y),
              onFocusin: (B) => e.readonly ? void 0 : D(),
              onKeydown: [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((B) => {
                  w(), C();
                }, ["tab"]),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((B) => {
                  w(), e.readonly || L();
                }, ["prevent"]), ["enter"])
              ],
              onMousedown: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((B) => e.readonly ? void 0 : L(), ["stop"]),
              onKeyup: [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((B) => C(), ["up"]),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((B) => e.readonly ? void 0 : D(), ["down"])
              ],
              onChange: w
            }, null, 40, jc), [
              [vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).start]
            ])
          ], 2),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
            e.hideArrow ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
              key: 0,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex my-auto flex-shrink-0", {
                "opacity-50": e.disabled || e.readonly
              }])
            }, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
                xmlns: "http://www.w3.org/2000/svg",
                "xmlns:xlink": "http://www.w3.org/1999/xlink",
                "aria-hidden": "true",
                role: "img",
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["text-gray-700", { "w-5 h-5": e.size !== "sm", "w-4 h-4": e.size === "sm" }]),
                width: "32",
                height: "32",
                preserveAspectRatio: "xMidYMid meet",
                viewBox: "0 0 24 24"
              }, Kc, 2))
            ], 2)),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["w-full input-group", {
                "input-group-sm": e.size === "sm",
                disabled: e.disabled,
                valid: e.valid,
                invalid: e.invalid
              }])
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                type: "button",
                tabindex: "-1",
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["input-group-addon fill-current", {
                  "pointer-events-none opacity-50": e.disabled || e.readonly
                }]),
                disabled: e.disabled || e.readonly,
                onClick: (B) => {
                  L(), b.$refs.endDateInput.focus();
                }
              }, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", Xc, [
                  e.mode === "time" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Qc)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Zc))
                ])),
                Jc
              ], 10, _c),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
                ref_key: "endDateInput",
                ref: u,
                "onUpdate:modelValue": k[1] || (k[1] = (B) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).end = B),
                "aria-label": "End date",
                type: "text",
                class: "form-control",
                title: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)}`,
                placeholder: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g),
                readonly: e.readonly,
                disabled: e.disabled,
                required: e.required,
                pattern: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(y),
                onFocusin: (B) => e.readonly ? void 0 : D(),
                onKeydown: [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((B) => {
                    w(), C();
                  }, ["tab"]),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((B) => {
                    w(), e.readonly || L();
                  }, ["prevent"]), ["enter"])
                ],
                onMousedown: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((B) => e.readonly ? void 0 : L(), ["stop"]),
                onKeyup: [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((B) => C(), ["up"]),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.withKeys)((B) => e.readonly ? void 0 : D(), ["down"])
                ],
                onChange: w
              }, null, 40, ed), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).end]
              ])
            ], 2)
          ], 64)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ], 2)
      ]),
      default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ close: D }) => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", td, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(qt, {
            modelValue: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d),
            "onUpdate:modelValue": [
              k[2] || (k[2] = (C) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(d) ? d.value = C : null),
              (C) => p(C, D)
            ],
            min: e.min,
            max: e.max,
            mode: e.mode,
            "use-current-time-for-today": e.useCurrentTimeForToday
          }, null, 8, ["modelValue", "min", "max", "mode", "use-current-time-for-today", "onUpdate:modelValue"])
        ])
      ]),
      _: 1
    }, 8, ["placement", "disabled", "popper-class"]));
  }
});
ga.install = (e) => {
  e.component(ga.name, ga);
};
const ad = ["aria-expanded", "disabled", "onClick"], nd = {
  key: 0,
  class: "inline-block self-center w-5 h-5 -mr-1",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 20 20",
  fill: "currentColor"
}, rd = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  "fill-rule": "evenodd",
  d: "M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z",
  "clip-rule": "evenodd"
}, null, -1), sd = [
  rd
], ld = ["aria-labelledby"], va = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsDropdown",
  directives: {
    uid: We
  },
  __name: "Dropdown",
  props: {
    /**
     * The content of the dropdown trigger.
     */
    title: { type: String, default: "" },
    /**
     * Determines the purpose and particular function of the button trigger.
     */
    kind: { type: String, default: "secondary" },
    /**
     * Styling for the button trigger.
     */
    variant: { type: String, default: "" },
    /**
     * Allows you to force dark mode on all child components
     */
    type: { type: String, default: void 0 },
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" },
    /**
     * The distance between the popper and the trigger.
     */
    offset: { type: Number, default: 5 },
    /**
     * Delays opening the toggle in ms.
     */
    openDelay: { type: Number, default: 0 },
    /**
     * Delays closing the toggle in ms.
     */
    closeDelay: { type: Number, default: 0 },
    /**
     * Determines the size of the trigger button.
     */
    size: { type: String, default: "md" },
    /**
     * Determines if the arrow should display or not.
     */
    hideArrow: { type: Boolean, default: !1 },
    /**
     * Determines whether the content of the popper will set the width of the popper.
     */
    auto: { type: Boolean, default: !1 },
    /**
     * The strategy of the popover on the screen.
     */
    strategy: { type: String, default: "absolute" },
    /**
     * The placement of the popover on the screen.
     */
    placement: { type: String, default: "bottom-start" },
    /**
     * Determines whether to use the block styling on the trigger button or not.
     */
    block: { type: Boolean, default: !1 },
    /**
     * Determines if the popover should display or not.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Allows for code execution prior to opening the popover.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the popover from opening
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willOpen(open, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the open process continue
     *    open()
     *  } catch (e) {
     *    // cancel the open process
     *    cancel()
     *  }
     * }
     * ```
     */
    willOpen: { type: Function, default: null },
    /**
     * Allows for code execution prior to closing the popover.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the popover from closing
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willClose(close, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the close process continue
     *    close()
     *  } catch (e) {
     *    // cancel the close process
     *    cancel()
     *  }
     * }
     * ```
     */
    willClose: { type: Function, default: null }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), n = (y, d, h) => {
      y ? h(t.closeDelay) : d(t.openDelay);
    }, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.size) {
        case "md":
          return "";
        case "sm":
          return "btn-sm";
        default:
          return "";
      }
    }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.kind ? "btn" : ""), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.kind) {
        case "primary":
          return "btn-primary";
        case "secondary":
          return "btn-secondary";
        case "tertiary":
          return "btn-tertiary";
        case "ghost":
          return "btn-ghost";
        default:
          return "";
      }
    }), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.variant) {
        case "blue":
          return "btn-blue";
        case "red":
          return "btn-red";
        case "white":
          return "btn-white";
        default:
          return "";
      }
    }), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.disabled ? "disabled" : ""), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.block ? "btn-block" : "");
    return (y, d) => {
      const h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(_e, {
        "data-id": "sds-dropdown",
        offset: e.offset,
        strategy: e.strategy,
        placement: e.placement,
        disabled: e.disabled,
        "will-open": e.willOpen,
        "will-close": e.willClose,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([e.block ? "w-full" : ""]),
        "popper-class": {
          "bg-gray-850 border-gray-700": e.type === "dark",
          "bg-white absolute border shadow-lg rounded-md bg-white dark:border-gray-700 dark:bg-gray-850": !0,
          [e.auto ? "w-auto" : "w-56"]: !0,
          [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]: !0
        },
        "hide-arrow": "",
        shift: ""
      }, {
        trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: p, close: w, isOpen: b, toggle: k }) => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(y.$slots, "trigger", {
            open: p,
            close: w,
            isOpen: b,
            toggle: k
          }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
              ref_key: "button",
              ref: a,
              type: "button",
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["space-x", [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m),
                e.type && "hover:bg-gray-800 text-white border-0",
                !b && e.type && "bg-gray-900",
                b && e.type && "active bg-gray-800",
                b && "active"
              ]]),
              "aria-haspopup": "true",
              "aria-expanded": b,
              disabled: e.disabled,
              onClick: (D) => n(b, p, w)
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(y.$slots, "title", {}, () => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.title), 1)
              ]),
              e.hideArrow ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", nd, sd))
            ], 10, ad)), [
              [h]
            ])
          ])
        ]),
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: p, close: w, toggle: b, isOpen: k }) => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([
              "py-2 rounded",
              e.type === "dark" ? "dropdown-dark bg-gray-850" : ""
            ]),
            "aria-orientation": "vertical",
            "aria-labelledby": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a).id || void 0
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(y.$slots, "default", {
              close: w,
              open: p,
              toggle: b,
              isOpen: k
            })
          ], 10, ld)
        ]),
        _: 3
      }, 8, ["offset", "strategy", "placement", "disabled", "will-open", "will-close", "class", "popper-class"]);
    };
  }
});
va.install = (e) => {
  e.component(va.name, va);
};
const od = {
  "data-id": "sds-dropdown-divider",
  class: "[.dropdown-dark_&]:bg-gray-850 [.dropdown-dark_&]:border-gray-700 my-2 border-t border-gray-100 dark:border-gray-700"
}, ba = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsDropdownDivider",
  __name: "DropdownDivider",
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", od));
  }
});
ba.install = (e) => {
  e.component(ba.name, ba);
};
const id = {
  "data-id": "sds-dropdown-header",
  class: "[.dropdown-dark_&]:bg-gray-850 [.dropdown-dark_&]:text-gray-300 px-4 py-1 text-sm font-semibold leading-5 text-gray-500 dark:text-gray-300"
}, pa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsDropdownHeader",
  __name: "DropdownHeader",
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", id, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(t.$slots, "default")
    ]));
  }
});
pa.install = (e) => {
  e.component(pa.name, pa);
};
const wa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsDropdownItem",
  __name: "DropdownItem",
  props: {
    /**
     * Styling for the item.
     */
    variant: { type: String, default: "gray" },
    /**
     * Determines the tag use for the component.
     */
    tag: {
      type: String,
      default: "a"
    },
    //  type prop
    /**
     * Determines whether to close the parent dropdown when this component is clicked.
     */
    closeOnClick: {
      type: Boolean,
      default: !0
    },
    /**
     * Determines if this component is currently active.
     */
    active: {
      type: Boolean,
      default: !1
    },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: {
      type: Boolean,
      default: !1
    }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.inject)("emitter"), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.variant) {
        case "gray":
          return "[.dropdown-dark_&]:hover:bg-gray-800 [.dropdown-dark_&]:bg-gray-850 [.dropdown-dark_&]:text-white hover:bg-gray-50 dark:text-white dark:hover:bg-gray-800 hover:text-black dark:hover:text-white";
        case "red":
        default:
          return "[.dropdown-dark_&]:hover:bg-gray-800 [.dropdown-dark_&]:bg-gray-850 [.dropdown-dark_&]:text-red-300 text-red-600 hover:bg-red-50 dark:text-red-300 dark:hover:bg-gray-800 hover:text-red-600 dark:hover:text-red-600";
      }
    });
    return (r, s) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(e.tag), {
      "data-id": "sds-dropdown-item",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([
        "block w-full select-none px-4 text-sm leading-5 text-left hover:no-underline",
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n),
        {
          "border-l-8 border-solid border-red-700 dark:border-red-400": e.active,
          "pointer-events-none opacity-50": e.disabled
        }
      ]),
      disabled: e.disabled,
      role: "menuitem",
      onClick: s[0] || (s[0] = (u) => e.closeOnClick ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)?.emit("floating-ui-toggle", !1) : null)
    }, {
      default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex py-2", e.active && "-ml-2"])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "default")
        ], 2)
      ]),
      _: 3
    }, 8, ["class", "disabled"]));
  }
});
wa.install = (e) => {
  e.component(wa.name, wa);
};
const cd = ["disabled", "aria-disabled"], xa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsExpandCollapse",
  __name: "ExpandCollapse",
  props: {
    /**
     * Determines the expanded state of the component.
     */
    modelValue: { type: Boolean, default: !1 },
    /**
     * Determines the purpose and particular function of the component.
     */
    kind: { type: String, default: "primary" },
    /**
     * Determines the color variant of the component.
     */
    variant: { type: String, default: "blue" },
    /**
     * Determines the label for the expanded state.
     */
    expandLabel: { type: String, default: "Show more" },
    /**
     * Determines the label for the collapse state.
     */
    collapseLabel: { type: String, default: "Show less" },
    /**
     * Determines the disabled state of the component.
     */
    disabled: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value"],
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
      "data-id": "sds-expand-collapse",
      type: "button",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["link link-cta", {
        disabled: e.disabled,
        "link-cta-up": e.modelValue,
        "link-cta-down": !e.modelValue,
        "link-primary": e.kind === "primary",
        "link-secondary": e.kind === "secondary",
        "link-tertiary": e.kind === "tertiary",
        "link-blue": e.variant === "blue",
        "link-red": e.variant === "red"
      }]),
      disabled: e.disabled,
      "aria-disabled": e.disabled,
      onClick: a[0] || (a[0] = (n) => t.$emit("update:model-value", !e.modelValue))
    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.modelValue ? e.collapseLabel : e.expandLabel), 11, cd));
  }
});
xa.install = (e) => {
  e.component(xa.name, xa);
};
const dd = {
  "data-id": "sds-file-uploader",
  class: "border-2 border-dashed dark:border-gray-700 rounded p-4 relative"
}, ud = ["accept", "multiple", "required", "name"], fd = { class: "space-y-2" }, hd = { class: "flex gap-2" }, yd = ["for"], md = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "my-auto h-4 w-4 text-gray-700",
  width: "32",
  height: "32",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "currentColor",
    d: "M105.4 182.6c12.5 12.49 32.76 12.5 45.25.001L224 109.3V352c0 17.67 14.33 32 32 32s32-14.33 32-32V109.3l73.38 73.38c12.49 12.49 32.75 12.49 45.25-.001c12.49-12.49 12.49-32.75 0-45.25l-128-128C272.4 3.125 264.2 0 256 0s-16.4 3.125-22.6 9.375L105.4 137.4c-12.52 12.5-12.52 32.7 0 45.2zM480 352H320c0 35.35-28.65 64-64 64s-64-28.65-64-64H32c-17.67 0-32 14.33-32 32v96c0 17.67 14.33 32 32 32h448c17.67 0 32-14.33 32-32v-96c0-17.7-14.3-32-32-32zm-48 104c-13.2 0-24-10.8-24-24s10.8-24 24-24s24 10.8 24 24s-10.8 24-24 24z"
  })
], -1), gd = { class: "my-auto" }, vd = { class: "text-gray-600 dark:text-gray-400 text-sm" }, bd = { key: 0 }, pd = { class: "flex" }, wd = { class: "my-auto flex gap-1 grow" }, xd = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "w-4 h-4 my-auto text-green-700",
  width: "32",
  height: "32",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "currentColor",
    d: "M243.8 339.8c-10.9 10.9-28.7 10.9-39.6 0l-64-64c-10.9-10.9-10.9-28.7 0-39.6c10.9-10.9 28.7-10.9 39.6 0l44.2 44.2l108.2-108.2c10.9-10.9 28.7-10.9 39.6 0c10.9 10.9 10.9 28.7 0 39.6l-128 128zM512 256c0 141.4-114.6 256-256 256S0 397.4 0 256S114.6 0 256 0s256 114.6 256 256zM256 48C141.1 48 48 141.1 48 256s93.1 208 208 208s208-93.1 208-208S370.9 48 256 48z"
  })
], -1), kd = { class: "my-auto" }, Md = { class: "my-auto text-gray-700 text-sm uppercase" }, Cd = ["onClick"], Sd = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  fill: "none",
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  class: "h-5 w-5",
  "aria-hidden": "true"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M6 18L18 6M6 6l12 12" })
], -1), $d = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Remove file", -1), Ld = [
  Sd,
  $d
], zd = { class: "flex" }, Dd = { class: "my-auto flex gap-1 grow" }, Td = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "w-4 h-4 my-auto text-red-700",
  width: "32",
  height: "32",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "currentColor",
    d: "M175 175c9.4-9.3 24.6-9.3 33.1 0l47 47.1L303 175c9.4-9.3 24.6-9.3 33.1 0c10.2 9.4 10.2 24.6 0 33.1l-46.2 47l46.2 47.9c10.2 9.4 10.2 24.6 0 33.1c-8.5 10.2-23.7 10.2-33.1 0l-47.9-46.2l-47 46.2c-8.5 10.2-23.7 10.2-33.1 0c-9.3-8.5-9.3-23.7 0-33.1l47.1-47.9l-47.1-47c-9.3-8.5-9.3-23.7 0-33.1zm337 81c0 141.4-114.6 256-256 256S0 397.4 0 256S114.6 0 256 0s256 114.6 256 256zM256 48C141.1 48 48 141.1 48 256s93.1 208 208 208s208-93.1 208-208S370.9 48 256 48z"
  })
], -1), Bd = { class: "my-auto" }, Pd = { class: "my-auto text-gray-700 text-sm uppercase" }, Ad = ["onClick"], Vd = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  fill: "none",
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  class: "h-5 w-5",
  "aria-hidden": "true"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M6 18L18 6M6 6l12 12" })
], -1), Od = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Remove file", -1), Hd = [
  Vd,
  Od
], Nd = {
  key: 0,
  class: "text-red-700 text-xs ml-5 mt-1"
}, Ed = {
  key: 1,
  class: "text-red-700 text-xs ml-5 mt-1"
}, ka = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsFileUploader",
  directives: {
    uid: We
  },
  __name: "FileUploader",
  props: {
    /**
     * An array of files. This prop is optional.
     * 
     * This syncs with the internal fileList and invalidFileList
     * to give developers more control over files.
     * 
     * Each file has `name`, `type`, `size`, `lastModified` properties.
     * 
     * You can check a file's validity using its `invalidType`
     * and `invalidSize` boolean properties. They are only
     * present if the file is invalid
     */
    modelValue: { type: Array, default: () => [] },
    /**
     * Determines the form name to use for the upload input field.
     */
    name: { type: String, default: "sdsFileUploader" },
    /**
     * Determines whether the user can upload more than one file.
     */
    multiple: { type: Boolean, default: !1 },
    /**
     * Determines if the file upload field is required.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Determines the accepted file formats used on the upload input field.
     */
    accept: { type: String, default: void 0 },
    /**
     * Determines the file types used for validation.
     */
    allowedFiletypes: { type: Array, default: () => [] },
    /**
     * Determines the maximum allowed filesize in megabytes for each uploaded file.
     */
    filesize: { type: Number, default: 10 },
    /**
     * Determines the helper text used to describe the upload field.
     */
    helperText: { type: String, default: void 0 }
  },
  emits: ["add", "remove", "remove-invalid", "update:model-value"],
  setup(e, { emit: t }) {
    const a = t, n = e, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)([]), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)([]), f = (h) => {
      if (!r.value) return;
      const p = new DataTransfer();
      s.value = s.value.filter((w) => !(w.name === h.name && w.lastModified === h.lastModified && w.size === h.size && w.type === h.type)), s.value.forEach((w) => {
        p.items.add(w);
      }), r.value.files = p.files, a("remove", { files: s.value, invalidFiles: u.value }), a("update:model-value", [...s.value, ...u.value]);
    }, v = (h) => {
      u.value = u.value.filter((p) => !(p.name === h.name && p.lastModified === h.lastModified && p.size === h.size && p.type === h.type)), a("remove-invalid", { files: s.value, invalidFiles: u.value }), a("update:model-value", [...s.value, ...u.value]);
    }, g = (h) => s.value.find((p) => p.name === h.name && p.lastModified === h.lastModified && p.size === h.size && p.type === h.type), m = (h) => {
      if (!h.target) return;
      const p = h.target.files;
      Array.from(p).forEach((w) => {
        g(w) || y(w);
      }), a("add", { files: s.value, invalidFiles: u.value }), a("update:model-value", [...s.value, ...u.value]);
    }, y = (h) => {
      if (!r.value) return;
      const p = new DataTransfer(), w = parseFloat((h.size / 1024 / 1024).toFixed(4)), b = h.type, k = n.allowedFiletypes.length > 0 && n.allowedFiletypes.includes(b) || n.allowedFiletypes.length < 1;
      n.multiple && s.value.forEach((D) => {
        p.items.add(D);
      }), w <= n.filesize && k ? (p.items.add(h), r.value.files = p.files, s.value = Array.from(r.value.files) || [], n.multiple || (u.value = [])) : w > n.filesize ? n.multiple ? (h.invalidSize = !0, u.value.push(h), u.value = u.value.filter(
        (D, C, L) => C === L.findIndex((B) => B.name === D.name && B.lastModified === D.lastModified && B.size === D.size && B.type === D.type)
      )) : (s.value = [], r.value.files = p.files, h.invalidSize = !0, u.value = [h]) : k || (n.multiple ? (h.invalidType = !0, u.value.push(h), u.value = u.value.filter(
        (D, C, L) => C === L.findIndex((B) => B.name === D.name && B.lastModified === D.lastModified && B.size === D.size && B.type === D.type)
      )) : (s.value = [], r.value.files = p.files, h.invalidType = !0, u.value = [h]));
    }, d = (h) => {
      const p = ["b", "kb", "mb", "gb", "tb"];
      if (h <= 0 || h > 999999999999999)
        return "n/a";
      const w = parseInt(`${Math.floor(Math.log(h) / Math.log(1024))}`, 10);
      return w === 0 ? `${h}${p[w]}` : `${Math.ceil(h / 1024 ** w)} ${p[w]}`;
    };
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(() => n.modelValue, (h) => {
      if (!r.value) return;
      const p = new DataTransfer();
      h.forEach((w) => p.items.add(w)), r.value.files = p.files, s.value = [], u.value = [], Array.from(p.files).forEach((w) => {
        y(w);
      });
    }, { immediate: !0, deep: !0 }), (h, p) => {
      const w = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", dd, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
          ref_key: "fileInput",
          ref: r,
          type: "file",
          accept: e.accept,
          multiple: e.multiple,
          required: e.required,
          class: "absolute inset-0 opacity-0 cursor-pointer",
          name: e.name,
          onChange: m
        }, null, 40, ud), [
          [w]
        ]),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", fd, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", hd, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", {
              for: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id,
              class: "btn btn-secondary cursor-pointer z-10"
            }, "Browse", 8, yd),
            md,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", gd, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.multiple ? "Drag and drop your files here" : "Drag and drop a file here"), 1)
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", vd, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.helperText ? e.helperText : e.multiple ? `Use files under ${e.filesize} MB.` : `Use a file under ${e.filesize} MB.`), 1),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(h.$slots, "default", {
            files: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s),
            invalidFiles: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u),
            removeFile: f,
            removeInvalidFile: v,
            byteToSize: d
          }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s).length > 0 || (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u).length > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("ul", bd, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s), (b) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
                key: b.name + b.size + b.type + b.lastModified,
                class: "py-2 border-b only:border-0 last:pb-0 last:border-0"
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", pd, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", wd, [
                    xd,
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", kd, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(b.name), 1),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Md, "(" + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(d(b.size)) + ")", 1)
                  ]),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                    class: "my-auto z-10 link hover:text-red-700 dark:hover:text-red-400",
                    onClick: (k) => f(b)
                  }, Ld, 8, Cd)
                ])
              ]))), 128)),
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u), (b) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
                key: b.name + b.size + b.type + b.lastModified,
                class: "py-2 border-b only:border-0 last:pb-0 last:border-0"
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", zd, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Dd, [
                    Td,
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Bd, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(b.name), 1),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Pd, "(" + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(d(b.size)) + ")", 1)
                  ]),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                    class: "my-auto z-10 link hover:text-red-700 dark:hover:text-red-400",
                    onClick: (k) => v(b)
                  }, Hd, 8, Ad)
                ]),
                b.invalidType ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", Nd, " Invalid file type ")) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                b.invalidSize ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", Ed, " File size is over " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.filesize) + " MB. ", 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ]))), 128))
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ])
        ])
      ]);
    };
  }
});
ka.install = (e) => {
  e.component(ka.name, ka);
};
const Id = ["aria-expanded", "disabled", "onClick"], Rd = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "inline-block self-center w-5 h-5 -mr-1",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 20 20",
  fill: "currentColor"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    "fill-rule": "evenodd",
    d: "M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z",
    "clip-rule": "evenodd"
  })
], -1), Fd = ["aria-labelledby"], Wd = {
  key: 0,
  class: "input-group input-group-sm mb-2 border-b"
}, qd = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  "aria-hidden": "true",
  focusable: "false",
  role: "img",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512",
  class: "w-3.5 h-3.5"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "currentColor",
    d: "M368 208A160 160 0 1 0 48 208a160 160 0 1 0 320 0zM337.1 371.1C301.7 399.2 256.8 416 208 416C93.1 416 0 322.9 0 208S93.1 0 208 0S416 93.1 416 208c0 48.8-16.8 93.7-44.9 129.1L505 471c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0L337.1 371.1z"
  })
], -1), Gd = [
  qd
], Yd = {
  key: 1,
  class: "pb-2 mb-2 space-x-2 space-y-2 border-b dark:border-gray-700"
}, jd = { class: "text-gray-900 dark:text-gray-50 flex gap-2 items-center w-max" }, Ud = ["checked", ".indeterminate"], Kd = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "my-auto" }, "Select all", -1), _d = { class: "scroll-area max-h-48" }, Xd = { class: "space-x-2 flex items-center" }, Qd = ["id", "onUpdate:modelValue", "value"], Zd = ["for"], Jd = { class: "pt-4 space-y-2" }, Ma = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsFilterByDropdown",
  directives: {
    uid: We
  },
  __name: "FilterByDropdown",
  props: {
    /**
     * The v-model for this component. Determines opened/closed state.
     */
    modelValue: { type: Array, default: () => [] },
    /**
     * Determines the purpose and particular function of the component.
     */
    kind: { type: String, default: "secondary" },
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" },
    /**
     * The title for the toggle button.
     */
    title: { type: String, default: "Filter" },
    /**
     * Determine whether to enable option filtering on the dropdown.
     */
    enableFilter: { type: Boolean, default: !1 },
    /**
     * Determines whether to alphabetically sort the options.
     */
    enableSortOptions: { type: Boolean, default: !1 },
    /**
     * Determines the placement of the dropdown on the screen.
     */
    placement: { type: String, default: "bottom-start" },
    /**
     * Determines if the dropdown is disabled
     */
    disabled: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(""), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)([]), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    }), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(B) {
        n("update:model-value", B);
      }
    }), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => f.value.every((B) => B.selected)), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => f.value.some((B) => B.selected)), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => y.value && !m.value), h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => f.value.filter(
      (B) => B.text && B.text.toLowerCase().includes(u.value.toLowerCase())
    )), p = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.kind) {
        case "primary":
          return "link link-primary link-blue";
        case "secondary":
          return "link link-secondary link-blue";
        default:
          return "";
      }
    }), w = () => {
      m.value ? C() : L();
    }, b = () => {
      n("update:model-value", f.value);
    }, k = () => {
      D();
    }, D = () => {
      const B = JSON.parse(JSON.stringify(g.value));
      a.enableSortOptions ? f.value = B.sort((A, E) => A.text.toLowerCase() < E.text.toLowerCase() ? -1 : A.text.toLowerCase() > E.text.toLowerCase() ? 1 : 0).sort((A, E) => A.selected > E.selected ? -1 : A.selected < E.selected ? 1 : 0) : f.value = B, u.value = "";
    }, C = () => {
      f.value.forEach((B) => {
        B.selected = !1;
      });
    }, L = () => {
      f.value.forEach((B) => {
        B.selected = !0;
      });
    };
    return (B, A) => {
      const E = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(_e, {
        "data-id": "sds-filter-by-dropdown",
        placement: e.placement,
        "popper-class": `absolute border shadow-lg rounded-md bg-white dark:border-gray-700 dark:bg-gray-850 w-72 ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v)}`,
        "arrow-class": "absolute bg-white border dark:border-gray-700 dark:bg-gray-850 w-3 h-3 rotate-45",
        "placement-top-arrow-class": "-bottom-1.5 border-t-0 border-l-0",
        "placement-right-arrow-class": "-left-1.5 border-t-0 border-r-0",
        "placement-bottom-arrow-class": "-top-1.5 border-b-0 border-r-0",
        "placement-left-arrow-class": "-right-1.5 border-b-0 border-l-0",
        shift: ""
      }, {
        trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ isOpen: M, toggle: H }) => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
            ref_key: "button",
            ref: r,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(p)),
            type: "button",
            "aria-haspopup": "true",
            "aria-expanded": M,
            disabled: e.disabled,
            onClick: (P) => {
              H(), D();
            }
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(B.$slots, "title", {}, () => [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.title), 1)
            ]),
            Rd
          ], 10, Id)), [
            [E]
          ])
        ]),
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ close: M }) => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
            class: "p-4",
            "aria-orientation": "vertical",
            "aria-labelledby": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).id || void 0
          }, [
            e.enableFilter ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Wd, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                class: "input-group-addon mt-0.5",
                onClick: A[0] || (A[0] = (H) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s)?.focus())
              }, Gd),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
                ref_key: "filterTextInput",
                ref: s,
                "onUpdate:modelValue": A[1] || (A[1] = (H) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(u) ? u.value = H : null),
                type: "text",
                class: "form-control",
                placeholder: "Type to filter"
              }, null, 512), [
                [vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u)]
              ])
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            e.enableFilter ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Yd, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", jd, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
                  type: "checkbox",
                  class: "my-auto",
                  checked: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m),
                  ".indeterminate": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d),
                  onClick: A[2] || (A[2] = (H) => w())
                }, null, 40, Ud),
                Kd
              ])
            ])),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _d, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("ul", null, [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h), (H) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
                  key: H.id,
                  class: "space-y-2"
                }, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Xd, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
                      id: `filter_by_dropdown_selection_list_${H.id}`,
                      "onUpdate:modelValue": (P) => H.selected = P,
                      type: "checkbox",
                      class: "focus:ring-0",
                      value: H.id
                    }, null, 8, Qd), [
                      [vue__WEBPACK_IMPORTED_MODULE_0__.vModelCheckbox, H.selected]
                    ]),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", {
                      for: `filter_by_dropdown_selection_list_${H.id}`,
                      class: "text-gray-900 dark:text-gray-50 ml-1 block"
                    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(H.text), 9, Zd)
                  ])
                ]))), 128))
              ])
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Jd, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Tt, {
                kind: "primary",
                size: "sm",
                block: "",
                onClick: (H) => {
                  b(), M();
                }
              }, {
                default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" Apply filter ")
                ]),
                _: 2
              }, 1032, ["onClick"]),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Tt, {
                kind: "ghost",
                size: "sm",
                block: "",
                onClick: (H) => {
                  k(), M();
                }
              }, {
                default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" Cancel ")
                ]),
                _: 2
              }, 1032, ["onClick"])
            ])
          ], 8, Fd)
        ]),
        _: 3
      }, 8, ["placement", "popper-class"]);
    };
  }
});
Ma.install = (e) => {
  e.component(Ma.name, Ma);
};
const eu = {
  "data-id": "sds-indicator",
  class: "inline-block"
}, tu = { class: "flex items-start relative" }, au = {
  key: 0,
  class: "sr-only"
}, nu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsIndicator",
  __name: "Indicator",
  props: {
    /**
     * Determines whether to display the indicator or not.
     */
    hideIndicator: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the placement of the indicator.
     */
    placement: {
      type: String,
      default: "top-right"
    },
    /**
     * Determines whether the indicator is placed over a portrait (rectangle) or a circle.
     */
    placementOver: {
      type: String,
      default: "portrait"
    },
    /**
     * Determines the size of the component.
     */
    size: {
      type: String,
      default: "md"
    },
    /**
     * Determines the status of the indicator (used for accessibility).
     */
    status: {
      type: String,
      default: null
    },
    /**
     * Determines the color of the component.
     */
    variant: {
      type: String,
      default: "primary"
    }
  },
  setup(e) {
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.useCssVars)((f) => ({
      "58b65808": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s),
      c0137a38: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u)
    }));
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.size) {
        case "sm":
          switch (t.placement) {
            case "top-right":
              return t.placementOver === "circle" ? "top-0.5 right-0.5" : "-top-1 -right-1";
            case "top-left":
              return t.placementOver === "circle" ? "top-0.5 left-0.5" : "-top-1 -left-1";
            case "bottom-right":
              return t.placementOver === "circle" ? "bottom-0.5 right-0.5" : "-bottom-1 -right-1";
            case "bottom-left":
              return t.placementOver === "circle" ? "bottom-0.5 left-0.5" : "-bottom-1 -left-1";
            default:
              return null;
          }
        case "lg":
          switch (t.placement) {
            case "top-right":
              return t.placementOver === "circle" ? "top-1.5 right-1.5" : "-top-2.5 -right-2.5";
            case "top-left":
              return t.placementOver === "circle" ? "top-1.5 left-1.5" : "-top-2.5 -left-2.5";
            case "bottom-right":
              return t.placementOver === "circle" ? "bottom-1.5 right-1.5" : "-bottom-2.5 -right-2.5";
            case "bottom-left":
              return t.placementOver === "circle" ? "bottom-1.5 left-1.5" : "-bottom-2.5 -left-2.5";
            default:
              return null;
          }
        case "md":
        default:
          switch (t.placement) {
            case "top-right":
              return t.placementOver === "circle" ? "top-0.5 right-0.5" : "-top-1.5 -right-1.5";
            case "top-left":
              return t.placementOver === "circle" ? "top-0.5 left-0.5" : "-top-1.5 -left-1.5";
            case "bottom-right":
              return t.placementOver === "circle" ? "bottom-0.5 right-0.5" : "-bottom-1.5 -right-1.5";
            case "bottom-left":
              return t.placementOver === "circle" ? "bottom-0.5 left-0.5" : "-bottom-1.5 -left-1.5";
            default:
              return null;
          }
      }
    }), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.size) {
        case "sm":
          return "h-3 w-3";
        case "lg":
          return "h-10 w-10";
        case "md":
        default:
          return "h-4 w-4";
      }
    }), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.variant) {
        case "gray":
          return "bg-gray-300";
        case "green":
          return "bg-green-500 dark:bg-green-300";
        case "orange":
          return "bg-orange-500 dark:bg-orange-300";
        case "red":
          return "bg-red-500 dark:bg-red-300";
        case "blue":
        default:
          return "bg-blue-500 dark:bg-blue-300";
      }
    }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      let f = 1e3, v = 1e3, g = 0, m = 0, y = 0, d = 0;
      switch (t.size) {
        case "sm":
          d = t.placementOver === "circle" ? 0 : -2, y = 8;
          break;
        case "md":
          d = t.placementOver === "circle" ? -1 : -4, y = 11;
          break;
        case "lg":
          d = t.placementOver === "circle" ? 1 : -2, y = 25;
          break;
      }
      if (t.placementOver === "circle")
        switch (t.placement) {
          case "top-left":
            g = y + d, m = y + d;
            break;
          case "top-right":
            g = f - y - d, m = y + d;
            break;
          case "bottom-right":
            g = f - y - d, m = v - y - d;
            break;
          case "bottom-left":
            g = y + d, m = v - y - d;
        }
      else
        switch (t.placement) {
          case "top-left":
            g = y / 2 + d, m = y / 2 + d;
            break;
          case "top-right":
            g = f - y / 2 - d, m = y / 2 + d;
            break;
          case "bottom-right":
            g = f - y / 2 - d, m = v - y / 2 - d;
            break;
          case "bottom-left":
            g = y / 2 + d, m = v - y / 2 - d;
        }
      return t.hideIndicator ? "none" : `url('data:image/svg+xml,<svg viewBox="0 0 ${f} ${v}" xmlns="http://www.w3.org/2000/svg"><circle cx="${g}" cy="${m}" r="${y}" /></svg>'), linear-gradient(#fff, #fff)`;
    }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.placement) {
        case "top-left":
          return "0 0";
        case "top-right":
          return "100% 0";
        case "bottom-right":
          return "100% 100%";
        case "bottom-left":
          return "0 100%";
        default:
          return null;
      }
    });
    return (f, v) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", eu, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", tu, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "default"),
        e.hideIndicator ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
          key: 0,
          role: "status",
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["absolute rounded-full", [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]])
        }, [
          e.status ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", au, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.status), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ], 2))
      ])
    ]));
  }
}), Ar = (e, t) => {
  const a = e.__vccOpts || e;
  for (const [n, r] of t)
    a[n] = r;
  return a;
}, Yt = /* @__PURE__ */ Ar(nu, [["__scopeId", "data-v-439548cc"]]), ru = { class: "p-4 flex h-screen w-screen" }, su = { class: "ml-auto mt-auto relative" }, lu = ["aria-expanded"], ou = { class: "w-6 h-6" }, iu = {
  key: 0,
  class: "inline-block h-6 w-6",
  "aria-hidden": "true",
  role: "img",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512"
}, cu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  fill: "currentColor",
  d: "M233.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L256 338.7 86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z"
}, null, -1), du = [
  cu
], uu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "inline-block h-6 w-6",
  "aria-hidden": "true",
  role: "img",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 576 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "currentColor",
    d: "M544 32c17.7 0 32 14.3 32 32V448c0 17.7-14.3 32-32 32s-32-14.3-32-32V64c0-17.7 14.3-32 32-32zM64 190.3L480 64V448L348.9 408.2C338.2 449.5 300.7 480 256 480c-53 0-96-43-96-96c0-11 1.9-21.7 5.3-31.5L64 321.7C63.1 338.6 49.1 352 32 352c-17.7 0-32-14.3-32-32V192c0-17.7 14.3-32 32-32c17.1 0 31.1 13.4 32 30.3zm239 203.9l-91.6-27.8c-2.1 5.4-3.3 11.4-3.3 17.6c0 26.5 21.5 48 48 48c23 0 42.2-16.2 46.9-37.8z"
  })
], -1), fu = { class: "sr-only" }, hu = ["aria-labelledby"], yu = { class: "grow uppercase font-bold text-lg" }, mu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "inline-block h-6 w-6",
  "aria-hidden": "true",
  role: "img",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "currentColor",
    d: "M233.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L256 338.7 86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z"
  })
], -1), gu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Close", -1), vu = [
  mu,
  gu
], bu = { class: "grow mx-6 mt-4 mb-2 overflow-auto" }, pu = {
  key: 0,
  class: "border-t border-gray-100 dark:border-gray-700"
}, wu = { class: "grid grid-flow-col auto-cols-fr" }, xu = ["onClick"], ku = {
  key: 0,
  class: "h-4 w-4 mx-auto"
}, Mu = ["src", "alt"], Cu = { class: "mx-auto" }, Ca = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsFloatingActionButton",
  directives: {
    uid: We
  },
  __name: "FloatingActionButton",
  props: {
    /**
     * An array of tab objects. Each object must have a unique "key".
     *
     * Example object:
     *
     * ```
     * {
     *    key: 'tab1',
     *    tabName: 'Tab 1',
     *    title: 'Active Tab 1',
     *    active: true,
     *    iconSrc: '/file.png'
     * }
     * ```
     */
    modelValue: {
      type: Array,
      required: !0
    },
    /**
     * Determines the color of the component.
     */
    variant: {
      type: String,
      default: "blue"
    },
    /**
     * Determines whether to display the indicator or not.
     */
    showIndicator: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the color of the trigger button's indictor.
     */
    indicatorVariant: {
      type: String,
      default: "blue"
    }
  },
  emits: ["update:model-value", "open", "close"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.variant), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(h) {
        n("update:model-value", h);
      }
    }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => s.value.find((h) => h.active) || { key: 0, title: "", tabName: "" }), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1);
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(m, (h) => {
      n(h ? "open" : "close");
    }), on(v, () => {
      m.value && (m.value = !1);
    }, { ignore: [g] }), ea("Escape", (h) => {
      m.value && (h.preventDefault(), m.value = !1);
    });
    const y = (h) => {
      if (f.value === null) return;
      const p = f.value.querySelectorAll(
        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
      );
      if (p.length < 2 && h.key === "Tab") {
        h.preventDefault();
        return;
      }
      const w = p.length - 1;
      h.key === "Tab" && h.shiftKey === !1 && h.target === p[w] ? (h.preventDefault(), p[0].focus()) : h.key === "Tab" && h.shiftKey === !0 && h.target === p[0] && (h.preventDefault(), p[w].focus());
    }, d = (h) => {
      s.value.map((p) => p.active = h.key === p.key);
    };
    return (h, p) => {
      const w = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(it, null, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Teleport, { to: "body" }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
              ref_key: "container",
              ref: f,
              "data-id": "sds-floating-action-button",
              class: "hidden sm:block fixed inset-0 h-screen w-screen pointer-events-none z-50",
              onKeydown: y
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", ru, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", su, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Yt, {
                    "hide-indicator": !e.showIndicator,
                    variant: e.indicatorVariant
                  }, {
                    default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                        ref_key: "button",
                        ref: g,
                        type: "button",
                        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["ml-auto mt-auto btn btn-primary rounded-lg p-4 pointer-events-auto", {
                          "btn-blue": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === "blue",
                          "btn-red": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === "red"
                        }]),
                        "aria-haspopup": "true",
                        "aria-expanded": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m),
                        onClick: p[0] || (p[0] = (b) => m.value = !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m))
                      }, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", ou, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", iu, du)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m) ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(h.$slots, "trigger-icon", { key: 1 }, () => [
                            uu
                          ])
                        ]),
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", fu, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m) ? "close" : "open"), 1)
                      ], 10, lu)), [
                        [w]
                      ])
                    ]),
                    _: 3
                  }, 8, ["hide-indicator", "variant"]),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
                    "enter-active-class": "transition duration-75 ease-out",
                    "enter-from-class": "transform scale-95 opacity-0",
                    "enter-to-class": "transform scale-100 opacity-100",
                    "leave-active-class": "transition duration-50 ease-in",
                    "leave-from-class": "transform scale-100 opacity-100",
                    "leave-to-class": "transform scale-95 opacity-0"
                  }, {
                    default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                        key: 0,
                        ref_key: "modal",
                        ref: v,
                        class: "absolute flex flex-col bottom-20 right-0 pointer-events-auto border border-gray-100 dark:border-gray-700 rounded-lg h-144 max-w-[32rem] w-[calc(100vw-2rem)] sm:w-[32rem] bg-white dark:bg-gray-900 shadow-lg",
                        "aria-orientation": "vertical",
                        "aria-labelledby": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g).id || void 0
                      }, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["p-6 rounded-t-lg flex gap-4", {
                            "text-white bg-blue-500": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === "blue",
                            "text-white bg-red-500": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === "red"
                          }])
                        }, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("h2", yu, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u).title), 1),
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                            class: "hover:text-blue-200",
                            onClick: p[1] || (p[1] = (b) => m.value = !1)
                          }, vu)
                        ], 2),
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", bu, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u) ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(h.$slots, `tab(${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u).key})`, {
                            key: 0,
                            tab: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u)
                          }) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                        ]),
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s).length > 1 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", pu, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("nav", wu, [
                            ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s), (b) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                              key: b.key,
                              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                                "border-t-gray-900 hover:border-t-900 dark:hover:border-t-200 dark:border-t-gray-200": b.active,
                                "border-t-transparent hover:border-t-gray-100 dark:hover:border-t-gray-500": !b.active
                              }, "flex flex-col gap-2 p-6 pt-4 text-sm font-bold border-t-4 transition-colors duration-200"]),
                              onClick: (k) => d(b)
                            }, [
                              h.$slots[`tab-icon(${b.key})`] || b.iconSrc ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", ku, [
                                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(h.$slots, `tab-icon(${b.key})`, {}, () => [
                                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("img", {
                                    src: b.iconSrc,
                                    alt: b.tabName,
                                    class: "h-4 w-4",
                                    width: "16",
                                    height: "16"
                                  }, null, 8, Mu)
                                ])
                              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Cu, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(b.tabName), 1)
                            ], 10, xu))), 128))
                          ])
                        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                      ], 8, hu)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                    ]),
                    _: 3
                  })
                ])
              ])
            ], 544)
          ]))
        ]),
        _: 3
      });
    };
  }
});
Ca.install = (e) => {
  e.component(Ca.name, Ca);
};
_e.install = (e) => {
  e.component(_e.name, _e);
};
const Su = {
  key: 0,
  class: "sr-only"
}, $u = { class: "grow" }, Lu = ["aria-hidden"], zu = { "aria-label": "test" }, Du = {
  key: 1,
  class: "block text-xs italic text-green-700 dark:text-green-300 pt-1"
}, Tu = {
  key: 2,
  class: "block text-xs italic text-red-500 dark:text-red-300 pt-1"
}, Sa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsFormGroup",
  directives: {
    uid: We
  },
  __name: "FormGroup",
  props: {
    /**
     * Determines whether to render the component as a fieldset with a legend or
     * a div with a label.
     */
    el: { type: String, default: "div" },
    /**
     * Determines whether to display the required/optional labeling.
     */
    showMarker: { type: Boolean, default: !1 },
    /**
     * Determines the text of the label.
     */
    label: { type: String, default: null },
    /**
     * Optionally determine the value of the label's for attribute. Only
     * necessary if you aren't using the automatically generated
     * id and `el` equals `div`.
     */
    labelFor: { type: String, default: null },
    /**
     * Determines the alignment of the label.
     */
    labelAlignment: { type: String, default: "left" },
    /**
     * Determines the width of the label.
     */
    labelWidth: { type: [Number, String], default: "auto" },
    /**
     * Determines the top margin of the label.
     */
    labelMargin: { type: [Number, String], default: null },
    /**
     * Determines the display style of the form group.
     */
    labelPosition: { type: String, default: "top" },
    /**
     * Determines the helper text of the form field.
     */
    helperText: { type: String, default: null },
    /**
     * Determines the success message displayed when `state`
     * is `true`
     */
    validFeedback: { type: String, default: null },
    /**
     * Determines the failure message displayed when `state`
     * is `false`
     */
    invalidFeedback: { type: String, default: null },
    /**
     * Determines the valid/invalid state of the form group.
     * 
     * If `true`, the field is valid. If `false`, the field is invalid.
     * If `null`, there is no valid or invalid state associated with
     * the field.
     */
    state: { type: Boolean, default: null },
    /**
     * Determines if the form group is required.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Determines if the form group is readonly.
     */
    readonly: { type: Boolean, default: !1 },
    /**
     * Determines whether the form group is disabled or not.
     */
    disabled: { type: Boolean, default: !1 }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.labelFor || `${a.value?.id}_form-control`);
    return (r, s) => {
      const u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(e.el), {
        ref_key: "root",
        ref: a,
        disabled: e.el === "fieldset" ? e.disabled : void 0,
        "data-id": "sds-form-group",
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex", {
          "flex-col gap-2": e.labelPosition === "top",
          "gap-4": e.labelPosition === "left"
        }])
      }, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          e.el === "fieldset" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("legend", Su, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.label), 1),
            e.required ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
              key: 0,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                "sr-only": !e.showMarker
              })
            }, "* required", 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            e.required ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
              key: 1,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                "sr-only": !e.showMarker
              })
            }, "(optional)", 2))
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(e.el === "div" ? "label" : "span"), {
            for: e.el === "div" ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n) : void 0,
            "aria-hidden": e.el === "fieldset" ? !0 : void 0,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex font-semibold text-gray-900 dark:text-gray-50", {
              "opacity-50 pointer-events-none select-none": e.disabled,
              "gap-1 items-center": e.labelPosition === "top",
              "place-content-start": e.labelAlignment === "left" && e.labelPosition === "top",
              "place-content-center": e.labelAlignment === "center" && e.labelPosition === "top",
              "place-content-end": e.labelAlignment === "right" && e.labelPosition === "top",
              "flex-col place-content-start": e.labelPosition === "left",
              "text-left": e.labelAlignment === "left" && e.labelPosition === "left",
              "text-center": e.labelAlignment === "center" && e.labelPosition === "left",
              "text-right": e.labelAlignment === "right" && e.labelPosition === "left",
              "mt-0": e.labelMargin === 0,
              "mt-0.5": e.labelMargin === 0.5,
              "mt-1": e.labelMargin === 1,
              "mt-1.5": e.labelMargin === 1.5,
              "mt-2": e.labelMargin === 2,
              "mt-2.5": e.labelMargin === 2.5,
              "mt-3": e.labelMargin === 3,
              "mt-3.5": e.labelMargin === 3.5,
              "mt-4": e.labelMargin === 4,
              "my-4": e.labelMargin === "auto",
              "w-1/12": e.labelWidth === 1,
              "w-2/12": e.labelWidth === 2,
              "w-3/12": e.labelWidth === 3,
              "w-4/12": e.labelWidth === 4,
              "w-5/12": e.labelWidth === 5,
              "w-6/12": e.labelWidth === 6,
              "w-7/12": e.labelWidth === 7,
              "w-8/12": e.labelWidth === 8,
              "w-9/12": e.labelWidth === 9,
              "w-10/12": e.labelWidth === 10,
              "w-11/12": e.labelWidth === 11,
              "w-auto": e.labelWidth === "auto"
            }])
          }, {
            default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "label", { label: e.label }, () => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.label), 1)
              ]),
              e.required ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                key: 0,
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                  "sr-only": !e.showMarker
                }, "font-normal text-red-500 dark:text-red-300 text-xs"])
              }, "* required", 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
              e.required ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                key: 1,
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                  "sr-only": !e.showMarker
                }, "font-normal italic text-gray-600 dark:text-gray-400 text-xs"])
              }, "(optional)", 2))
            ]),
            _: 3
          }, 8, ["for", "aria-hidden", "class"])),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", $u, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", null, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "default", {
                id: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n),
                valid: e.state === !0,
                invalid: e.state === !1,
                disabled: e.disabled,
                required: e.required,
                readonly: e.readonly
              })
            ]),
            (e.helperText || r.$slots.helperText) && !e.disabled ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", {
              key: 0,
              "aria-hidden": e.disabled ? !0 : void 0,
              class: "block text-xs italic text-gray-600 dark:text-gray-400 pt-1"
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "helperText", { helperText: e.helperText }, () => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", zu, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.helperText), 1)
              ])
            ], 8, Lu)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            e.state && (e.validFeedback || r.$slots.validFeedback) && !e.disabled ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", Du, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "validFeedback", { validFeedback: e.validFeedback }, () => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.validFeedback), 1)
              ])
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            e.state === !1 && (e.invalidFeedback || r.$slots.invalidFeedback) && !e.disabled ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", Tu, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "invalidFeedback", { invalidFeedback: e.invalidFeedback }, () => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.invalidFeedback), 1)
              ])
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ])
        ]),
        _: 3
      }, 8, ["disabled", "class"])), [
        [u]
      ]);
    };
  }
});
Sa.install = (e) => {
  e.component(Sa.name, Sa);
};
Yt.install = (e) => {
  e.component(Yt.name, Yt);
};
const Vr = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsCharacterCounter",
  __name: "CharacterCounter",
  props: {
    /**
     * The current count value.
     */
    currentValue: { type: Number, default: 0 },
    /**
     * The minimum value allowed.
     */
    minValue: { type: Number, default: 0 },
    /**
     * The maximum value allowed.
     */
    maxValue: { type: Number, default: 0 }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.maxValue - t.currentValue);
    return (n, r) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      "data-id": "sds-character-counter",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({ "text-red-700 dark:text-red-300": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a) < 0 || e.currentValue < e.minValue && e.currentValue > 0 })
    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a).toLocaleString()), 3));
  }
}), Bu = {
  "data-id": "sds-input",
  class: "w-full relative"
}, Pu = ["id", "type", "maxlength", "placeholder", "autofocus", "disabled", "readonly", "required", "pattern"], $a = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsInput",
  __name: "Input",
  props: {
    /**
     * The v-model of the component (the text input).
     */
    modelValue: { type: String, default: "" },
    /**
     * Determines whether to display the character counter or not.
     */
    countCharacters: { type: Boolean, default: !1 },
    /**
     * Determines the maxlength of the component.
     */
    maxlength: { type: Number, default: 524288 },
    /**
     * Determines the id of the input.
     */
    id: { type: String, default: void 0 },
    /**
     * Determines the placeholder of the component.
     */
    placeholder: { type: String, default: "" },
    /**
     * Determines the type of the input field.
     */
    type: { type: String, default: "text" },
    /**
     * Determines the size of the input field. Options are "sm" and "md".
     */
    size: { type: String, default: "" },
    /**
     * Determines whether to autofocus the input or not.
     */
    autofocus: { type: Boolean, default: !1 },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines whether the input is required or not.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Determines the regex pattern used for validation.
     */
    pattern: { type: String, default: void 0 },
    /**
     * Determines whether the input is read-only or not.
     */
    readonly: { type: Boolean, default: !1 },
    /**
     * Sets a valid styling if true.
     */
    valid: { type: Boolean, default: !1 },
    /**
     * Sets an invalid styling if true.
     */
    invalid: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(s) {
        n("update:model-value", s);
      }
    });
    return (s, u) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Bu, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
        id: e.id,
        "onUpdate:modelValue": u[0] || (u[0] = (f) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(r) ? r.value = f : null),
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["form-control", {
          valid: e.valid,
          invalid: e.invalid,
          "form-control-sm": e.size === "sm"
        }]),
        type: e.type,
        maxlength: e.maxlength,
        placeholder: e.placeholder,
        autofocus: e.autofocus,
        disabled: e.disabled,
        readonly: e.readonly,
        required: e.required,
        pattern: e.pattern
      }, null, 10, Pu), [
        [vue__WEBPACK_IMPORTED_MODULE_0__.vModelDynamic, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]
      ]),
      e.countCharacters ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(Vr, {
        key: 0,
        class: "absolute right-0 text-gray-600 dark:text-gray-400",
        "current-value": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).length,
        "max-value": e.maxlength
      }, null, 8, ["current-value", "max-value"])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ]));
  }
});
$a.install = (e) => {
  e.component($a.name, $a);
};
const Au = ["target", "rel", "tabindex"], Bt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLink",
  __name: "Link",
  props: {
    /**
     * Determines the purpose and particular function of the component.
     */
    kind: { type: String, default: "primary" },
    /**
     * Determines the type of the component.
     */
    type: { type: String, default: "standalone" },
    /**
     * Determines the color variant of the component.
     */
    variant: { type: String, default: "blue" },
    /**
     * Determines whether to display a decorated underline.
     */
    decoration: { type: String, default: void 0 },
    /**
     * Determines the size of the component.
     */
    size: { type: String, default: void 0 },
    /**
     * Applies the appropriate attributes for external links and opens them in a new tab. It also creates a REL attribute that prevents browser sniffing.
     */
    external: { type: Boolean, default: !1 },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: !1 }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.kind) {
        case "primary":
          return "link-primary";
        case "secondary":
          return "link-secondary";
        case "tertiary":
          return "link-tertiary";
        default:
          return "";
      }
    }), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.type) {
        case "inline":
          return "link-inline";
        case "cta":
          return "link-cta";
        case "standalone":
        default:
          return "";
      }
    }), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.variant) {
        case "red":
          return "link-red";
        case "white":
          return "link-white";
        case "blue":
        default:
          return "link-blue";
      }
    }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      const v = t.decoration, g = t.variant;
      if (v)
        switch (g) {
          case "red":
            return "underline underline-offset-2 decoration-red-500";
          case "white":
            return "underline underline-offset-2 decoration-white";
          case "blue":
          default:
            return "underline underline-offset-2 decoration-blue-500";
        }
      return "";
    }), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      const v = t.size;
      if (v)
        switch (v) {
          case "xs":
            return "text-xs";
          case "sm":
            return "text-sm";
          case "lg":
            return "text-lg";
          case "xl":
            return "text-xl";
          case "md":
          default:
            return "text-base";
        }
      return "";
    }), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.disabled ? "disabled" : "");
    return (v, g) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
      "data-id": "sds-link",
      target: e.external ? "_blank" : void 0,
      rel: e.external ? "noopener noreferrer" : void 0,
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["link", (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f)]),
      tabindex: e.disabled ? -1 : void 0
    }, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(v.$slots, "default")
    ], 10, Au));
  }
}), Vu = {
  id: "Layer_1",
  "data-id": "sds-sei-wordmark",
  version: "1.1",
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  x: "0px",
  y: "0px",
  viewBox: "0 0 851.9 144.2",
  style: { "enable-background": "new 0 0 851.9 144.2" },
  "xml:space": "preserve"
}, Ou = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode)(`<g><polygon class="fill-current" points="213.5,18.7 213.5,45.5 218,45.5 218,47.3 200.1,47.3 200.1,45.5 204.6,45.5 204.6,20.6 201.1,20.6 
		201.1,18.7 	"></polygon><path class="fill-current" d="M36.9,1.4h-1.6c-0.1,1.4-0.8,2-2.2,2C30.4,3.4,26.3,0,21.6,0C8.1,0,0,13.3,0,25c0,11.8,7.8,23.4,20.8,23.4
		c7.9,0,10.8-3.7,12.9-3.7c1.4,0,1.6,1.2,1.6,2.7h1.8V31.2h-1.8l-0.4,2.2c-0.9,5.3-5.1,13.2-13.5,13.2c-7.5,0-10.4-6.5-10.4-22.4
		C11,7.4,15,1.8,21.6,1.8c7.5,0,12.6,8.4,13.7,15.1h1.6V1.4z"></path><path class="fill-current" d="M60,39.6c-0.1,3.4-2.1,6.3-5.1,6.3c-4.4,0-4.6-3.7-4.6-6.6c0-3.4,0.4-5.7,4.6-6.2l5.1-0.5V39.6z M71.8,41.7
		c0,1.7-1.1,3.6-1.8,3.6c-1.2,0-1.4-1.2-1.4-3.2V27.2c0-7.4-6.9-9.2-13.6-9.2c-6.5,0-11.2,3.2-11.2,6.8c0,2.3,1.3,4.2,4.2,4.2
		c2.5,0,4-1.6,4-3.9c0-3.3-3.4-3.3-3.4-3.4c0-1.5,3.8-1.9,6-1.9c4.9,0,5.5,1.8,5.5,5.7v5.4l-6.4,0.5c-5.9,0.5-12.3,2-12.3,8.8
		c0,5.6,5.1,7.9,10,7.9c2.5,0,7-1,8.7-4.1c1.2,2.7,3.6,4.1,6.5,4.1c4.2,0,6.9-2.5,6.9-6.3H71.8z"></path><polygon class="fill-current" points="674.5,18.6 674.5,45.4 679,45.4 679,47.2 661.1,47.2 661.1,45.4 665.6,45.4 665.6,20.5 661.1,20.5 
		661.1,18.6 	"></polygon><path class="fill-current" d="M286,32.5l10.7-30.7h14.8l0,1.8h-4.2v42h4.2v1.8h-17.8v-1.8h4.3V4h-0.1l-15.1,43.3H281L265.5,3.2h-0.1V40
		c0,5.2,1.4,5.5,4.9,5.5h0.2v1.8h-11.2v-1.8l0,0c3.7,0,4.4-2.2,4.4-4.9v-37h-4.4V1.7h16.3L286,32.5z"></path><path class="fill-current" d="M321.8,29.9v-4.4c0-4.3,1.9-5.7,4.1-5.7c3.1,0,4.1,2.1,4.1,5.7v4.4H321.8z M321.8,31.6h17.9
		c-0.1-7-6.5-13.7-13.4-13.6c-7.6,0-14.3,6.6-14.3,15.4c0,8.4,6.2,14.7,14.5,14.7c8,0,11.9-4.9,13.4-11.3h-1.8
		c-1.4,6-4.6,9.5-9.6,9.5c-6,0-6.7-4.7-6.7-9.1V31.6z"></path><path class="fill-current" d="M591.1,29.8v-4.4c0-4.3,1.9-5.7,4.1-5.7c3.1,0,4.1,2.1,4.1,5.7v4.4H591.1z M591.1,31.5H609
		c-0.1-7-6.5-13.7-13.4-13.6c-7.6,0-14.3,6.6-14.3,15.4c0,8.4,6.2,14.7,14.5,14.7c8,0,11.9-4.9,13.4-11.3h-1.8
		c-1.4,6-4.6,9.5-9.6,9.5c-6,0-6.7-4.7-6.7-9.1V31.5z"></path><polygon class="fill-current" points="339.8,1.8 339.8,3.4 344.3,3.4 344.3,45.5 339.8,45.5 339.8,47.3 357.7,47.3 357.7,45.5 353.3,45.5 
		353.3,1.8 	"></polygon><polygon class="fill-current" points="359,1.8 359,3.4 363.4,3.4 363.4,45.5 359,45.5 359,47.3 376.9,47.3 376.9,45.5 372.4,45.5 372.4,1.8 
			"></polygon><path class="fill-current" d="M397.4,39.5c0,4.9-2,6.9-5.3,6.9c-3.3,0-5.3-2-5.3-6.9V26.7c0-4.9,2-6.9,5.3-6.9c3.3,0,5.3,2,5.3,6.9V39.5z
		 M407.5,33.1c0-8.9-6.9-15-15.4-15c-8.6,0-15.4,6.2-15.4,15c0,8.9,6.9,15,15.4,15C400.7,48.1,407.5,41.9,407.5,33.1"></path><path class="fill-current" d="M454.1,3.3h4.5v28.8c0,10,6.9,16.1,17.5,16.1c11.9,0,17.1-6.3,17.1-15.8V7.8c0-3.8,1-4.5,3.4-4.5h1.3V1.5
		h-11.4v1.7h0.8c3.3,0,3.8,1,3.8,4.8v25c0,8.8-5.5,12.8-11,12.8c-9.5,0-11.3-6.4-11.9-14.6V3.3h4.2V1.5h-18.3V3.3z"></path><path class="fill-current" d="M566.3,47.9h1.7l9.6-22.7c1.9-4.2,3-4.8,4.5-4.8h0.6v-1.8h-10.1v1.8h1.2c1.9,0,2.7-0.1,2.7,1.6
		c0,1-0.3,2.1-1.1,3.9l-4.4,10.4L564,20.4h3.6v-1.8h-16.3v1.8h3L566.3,47.9z"></path><path class="fill-current" d="M638.6,47.9h1.5c0.3-1,1-1.6,2.3-1.6c1.7,0,3.7,1.6,7.3,1.6c6.2,0,10.4-5.3,10.4-10.6c0-7.9-5.4-8.5-12.4-9.5
		c-3.6-0.5-5.7-1-5.7-3.9c0-3,2.7-4.3,6.2-4.3c4.9,0,6.7,3.2,8.4,7.4h1.5l0-9.2h-1.5c0,0.8-0.7,1.4-1.9,1.4c-2.1,0-3.8-1.4-6.7-1.4
		c-6.5,0-9.7,5.5-9.7,9.7c0,8.4,6.4,9.1,11.3,9.7c4.7,0.6,6.4,0.9,6.4,3.9c0,3.4-2.9,5-6.4,5c-4.9,0-8.3-4.3-9.5-9h-1.5V47.9z"></path><polygon class="fill-current" points="549,18.6 549,45.4 553.5,45.4 553.5,47.2 535.6,47.2 535.6,45.4 540.1,45.4 540.1,20.5 535.6,20.5 
		535.6,18.6 	"></polygon><path class="fill-current" d="M540.1,9.7c0,2.5,2,4.5,4.5,4.5c2.5,0,4.5-2,4.5-4.5c0-2.5-2-4.5-4.5-4.5C542,5.2,540.1,7.2,540.1,9.7"></path><path class="fill-current" d="M665.6,9.7c0,2.5,2,4.5,4.5,4.5c2.5,0,4.5-2,4.5-4.5c0-2.5-2-4.5-4.5-4.5C667.6,5.2,665.6,7.2,665.6,9.7"></path><path class="fill-current" d="M149.8,29.9v-4.4c0-4.3,1.9-5.7,4.1-5.7c3.1,0,4.1,2.1,4.1,5.7v4.4H149.8z M149.8,31.6h17.9
		c-0.1-7-6.5-13.7-13.4-13.6c-7.6,0-14.3,6.6-14.3,15.4c0,8.4,6.2,14.7,14.5,14.7c8,0,11.9-4.9,13.4-11.3h-1.8
		c-1.4,6-4.6,9.5-9.6,9.5c-6,0-6.7-4.7-6.7-9.1V31.6z"></path><path class="fill-current" d="M228,29.9v-4.4c0-4.3,1.9-5.7,4.1-5.7c2.3,0,4.1,1.3,4.1,5.7v4.4H228z M228,31.6h17.9
		c-0.1-7-6.5-13.7-13.4-13.6c-7.6,0-14.3,6.6-14.3,15.4c0,8.4,6.2,14.7,14.5,14.7c8,0,11.9-4.9,13.4-11.3h-1.8
		c-1.4,6-4.6,9.5-9.6,9.5c-6,0-6.7-4.7-6.7-9.1V31.6z"></path><path class="fill-current" d="M529.8,45.5V28c0-7-3-10.3-9.1-10.3c-4.3,0-8.7,2.5-10.5,6.3h0v-5.2h-13.4v1.7h4.5v25h-4.5v1.8H514v-1.8h-3.8
		V28.4c0.6-2.4,3.6-8,7.1-8c2.4,0,3.5,0.8,3.5,5.2v19.9h-3.7v1.8h17.1v-1.8H529.8z"></path><path class="fill-current" d="M420.9,18.8v5.2h0c1.8-3.8,6.2-6.3,10.5-6.3c6.2,0,9.1,3.3,9.1,10.3v17.5h4.5v1.8h-17.1v-1.8h3.7V25.7
		c0-4.3-1.2-5.2-3.5-5.2c-3.5,0-6.6,5.6-7.1,8v17.1h3.8v1.8h-17.2v-1.8h4.5v-25h-4.5v-1.7H420.9z"></path><path class="fill-current" d="M135.5,45.6V28.1c0-7-3-10.3-9.1-10.3c-4.3,0-8.7,2.5-10.5,6.3h0v-5.2h-13.4v1.7h4.5v25h-4.5v1.8h17.2v-1.8
		h-3.8V28.5c0.6-2.4,3.6-8,7.1-8c2.4,0,3.5,0.8,3.5,5.2v19.9h-3.7v1.8H140v-1.8H135.5z"></path><path class="fill-current" d="M204.6,9.8c0,2.5,2,4.5,4.5,4.5c2.5,0,4.5-2,4.5-4.5c0-2.5-2-4.5-4.5-4.5C206.6,5.4,204.6,7.4,204.6,9.8"></path><path class="fill-current" d="M718,18.6v1.9c2.8,0,4,0.3,4,1.5c0,1-0.3,2.1-1.1,3.9l-4.4,10.4l-7-15.8h3.7v-1.9h-22.3V4.7h-1.2
		c0,6.9-4.7,13.9-11.2,13.9v1.9h3.4v20.1c0,6.2,5.3,7.4,7.1,7.4c4,0,6.6-1.6,8.6-5l-1.4-0.8c-0.8,1.2-1.8,2.7-3.4,2.7
		c-1.3,0-2-0.9-2-3.1V20.5h9l11.8,27.3l-4.1,9.7l0,0c0,0,0,0,0,0l0,0c-0.1,0.2-0.3,0.3-0.5,0.3c-0.2,0-0.4-0.2-0.5-0.4c0,0,0,0,0,0
		c-0.5-1.9-2.2-3.2-4.3-3.2c-2.5,0-4.5,2-4.5,4.5c0,1.7,1,3.2,2.4,4c0,0,0,0,0,0c0,0,0.1,0,0.1,0.1c0.1,0,0.2,0.1,0.3,0.1
		c0.5,0.2,1,0.3,1.6,0.3c3.8,0.3,5.7-2.5,7-5.3c0.3-0.6,0.6-1.3,0.8-1.9c0.6-1.4,1.6-3.7,2.7-6.5l0,0l1.1-2.6l0,0l9.1-21.6
		c1.9-4.2,2.7-4.8,5-4.8h0v-1.9H718z"></path><path class="fill-current" d="M95.9,17.7c-4.1,0-7.3,2.9-8.6,6.1h-0.1v-4.9H74v1.8h4.5v24.9H74v1.8h19.4v-1.8h-6v-14c0-4.2,1.1-8.4,3.8-10.8
		c0.2-0.1,0.4-0.1,0.6-0.1c0.2,0.1,0.3,0.3,0.3,0.6l0,0c-0.2,0.5-0.3,1.1-0.3,1.8c-0.1,2.4,1.9,4.2,4.4,4.2c3.1,0,4.9-2.3,4.9-4.7
		C101.1,19.6,99,17.7,95.9,17.7z"></path><path class="fill-current" d="M193.5,19.8c0.1,0,0.3-0.1,0.4,0c0.1,0.1,0.1,0.2,0,0.4l0,0c-0.4,0.7-0.5,1.5-0.2,2.4c0.3,0.9,1.1,1.6,2,1.8
		c1.9,0.4,3.5-0.9,3.5-2.7c0-1.1-0.7-2-1.5-2.5c-0.8-0.5-1.8-0.8-2.9-0.8c-1.7,0-3.5,0.9-4.8,2c0,0,0,0,0,0
		c-0.3-0.2-0.6-0.4-0.9-0.6c-1.8-1-4.1-1.7-7.2-1.7c-5.4,0-11.3,3.6-11.3,9.5c0,3.6,1.9,6.4,5.4,7.9v0.1c-2.5,0.3-6.5,2.1-6.5,7.5
		c0,3.2,1.5,5.7,4.2,6.5v0.1c-2.6,0.7-5.6,3.3-5.6,6.4c0,4.8,5.6,8.5,12.8,8.5c9,0,14.9-6.1,14.9-14c0-6.3-3.1-9.1-9.5-9h-10.8
		c-1.6,0-2.7-0.1-2.7-1.8c0-1.6,2.5-3.4,4.9-3.4c0.4,0,1.1,0.3,1.3,0.4c0.8,0.3,1.6,0.4,2.7,0.4c5.6,0,11.5-3.2,11.5-9.3
		c0-1.9-0.8-4.5-2.4-6.1c-0.1-0.1-0.1-0.2,0-0.3c0.6-0.5,1.3-0.9,1.7-1.1C193,20,193.2,19.9,193.5,19.8L193.5,19.8z M184.9,49.6
		c6.5,0,8.2,0.3,8.2,4.2c0,4.7-5.8,9.1-12.3,9.1c-5.8,0-8.6-3.6-8.8-6.7c0-2.9,1.4-4.7,3.2-6.6H184.9z M186,27.5
		c0,7.5-1.7,7.8-4.1,7.8c-2.6,0-4-0.5-4-8c0-5.3,0.6-7.5,4-7.5C184.9,19.8,185.9,20,186,27.5L186,27.5z"></path><path class="fill-current" d="M631.7,17.5c-4.1,0-7.3,2.9-8.6,6.1H623v-4.9h-13.3v1.8h4.5v24.9h-4.5v1.8h19.4v-1.8h-6v-14
		c0-4.2,1.1-8.4,3.8-10.8c0.2-0.1,0.4-0.1,0.6-0.1c0.2,0.1,0.3,0.3,0.3,0.6l0,0c-0.2,0.5-0.3,1.1-0.3,1.8c-0.1,2.4,1.9,4.2,4.4,4.2
		c3.1,0,4.9-2.3,4.9-4.7C636.8,19.3,634.7,17.5,631.7,17.5z"></path></g><g><path class="fill-current" d="M30.2,116.6c0,3.9-1.4,6.9-4.3,9.2c-2.8,2.3-6.6,3.4-11.3,3.4c-5.7,0-10-0.6-13-1.9v-3.2
		c3.3,1.4,7.6,2.1,12.8,2.1c3.8,0,6.8-0.9,9.1-2.6c2.2-1.7,3.3-4,3.3-6.9c0-1.8-0.4-3.2-1.1-4.4c-0.7-1.2-1.9-2.2-3.6-3.2
		c-1.7-1-4.1-2-7.4-3.1c-4.7-1.6-8-3.4-9.8-5.3c-1.8-1.9-2.7-4.4-2.7-7.6c0-3.5,1.4-6.3,4.1-8.5c2.7-2.2,6.2-3.3,10.5-3.3
		c4.4,0,8.5,0.8,12.3,2.5l-1.2,2.8c-3.9-1.6-7.5-2.4-11-2.4c-3.4,0-6.2,0.8-8.2,2.4s-3,3.7-3,6.5c0,1.7,0.3,3.1,0.9,4.2
		c0.6,1.1,1.6,2.1,3.1,3c1.4,0.9,3.9,1.9,7.3,3.2c3.6,1.2,6.3,2.5,8.2,3.6c1.8,1.2,3.1,2.5,4,4C29.8,112.7,30.2,114.5,30.2,116.6z"></path><path class="fill-current" d="M66.8,111.2c0,5.6-1.4,10-4.1,13.2c-2.7,3.2-6.5,4.7-11.3,4.7c-3,0-5.7-0.7-8-2.2c-2.3-1.5-4.1-3.6-5.3-6.3
		c-1.2-2.7-1.8-5.9-1.8-9.5c0-5.6,1.4-10,4.1-13.2c2.7-3.1,6.5-4.7,11.2-4.7c4.7,0,8.5,1.6,11.2,4.8
		C65.5,101.3,66.8,105.7,66.8,111.2z M39.6,111.2c0,4.7,1,8.4,3.1,11.1c2.1,2.7,5,4,8.8,4s6.8-1.3,8.8-4c2.1-2.7,3.1-6.4,3.1-11.1
		c0-4.8-1.1-8.5-3.2-11.1c-2.1-2.6-5.1-3.9-8.9-3.9s-6.7,1.3-8.8,3.9C40.6,102.8,39.6,106.5,39.6,111.2z"></path><path class="fill-current" d="M88.5,96.8h-8.1v31.8h-3.1V96.8h-6.4v-1.8l6.4-1.2v-2.7c0-4.2,0.8-7.3,2.3-9.3c1.6-2,4.1-3,7.6-3
		c1.9,0,3.8,0.3,5.7,0.9l-0.7,2.7c-1.7-0.5-3.4-0.8-5-0.8c-2.5,0-4.2,0.7-5.2,2.2s-1.5,3.8-1.5,7.1V94h8.1V96.8z"></path><path class="fill-current" d="M106.3,126.4c2,0,3.7-0.2,5.2-0.5v2.5c-1.5,0.5-3.3,0.8-5.3,0.8c-3,0-5.3-0.8-6.7-2.4
		c-1.4-1.6-2.2-4.2-2.2-7.7V96.8h-5.1v-1.8l5.1-1.4l1.6-7.8h1.6V94h10.1v2.7h-10.1v21.8c0,2.6,0.5,4.6,1.4,5.9
		C102.8,125.8,104.3,126.4,106.3,126.4z"></path><path class="fill-current" d="M147.5,128.5l-7.6-23.1c-0.5-1.6-1.1-3.9-1.9-6.9h-0.2l-0.7,2.3l-1.4,4.6l-7.7,23H125L115.1,94h3.4l5.5,20
		c1.3,5,2.1,8.6,2.5,10.9h0.2c1.2-5,2.2-8.2,2.7-9.9l7.1-21h2.9l6.8,21c1.5,5,2.5,8.3,2.8,9.9h0.2c0.2-1.4,1-5.1,2.5-11L157,94h3.2
		l-9.4,34.5H147.5z"></path><path class="fill-current" d="M187,128.5l-0.8-5.5H186c-1.7,2.2-3.5,3.8-5.3,4.7c-1.8,0.9-4,1.4-6.5,1.4c-3.4,0-6-0.9-7.9-2.6
		c-1.9-1.7-2.8-4.1-2.8-7.2c0-3.4,1.4-6,4.2-7.8c2.8-1.9,6.9-2.8,12.2-3l6.6-0.2v-2.3c0-3.3-0.7-5.8-2-7.4c-1.3-1.7-3.5-2.5-6.4-2.5
		c-3.2,0-6.5,0.9-9.9,2.7l-1.2-2.7c3.8-1.8,7.5-2.7,11.2-2.7c3.8,0,6.6,1,8.5,3c1.9,2,2.8,5,2.8,9.2v22.9H187z M174.3,126.3
		c3.7,0,6.6-1.1,8.7-3.2c2.1-2.1,3.2-5,3.2-8.8V111l-6,0.3c-4.8,0.2-8.3,1-10.4,2.3c-2.1,1.3-3.1,3.3-3.1,6c0,2.2,0.7,3.8,2,5
		C170,125.7,171.9,126.3,174.3,126.3z"></path><path class="fill-current" d="M215.1,93.4c1.5,0,3,0.1,4.7,0.4l-0.6,3c-1.4-0.4-2.9-0.5-4.5-0.5c-2.9,0-5.4,1.2-7.2,3.7
		c-1.9,2.5-2.8,5.6-2.8,9.5v19h-3.1V94h2.7l0.3,6.2h0.2c1.4-2.5,2.9-4.3,4.5-5.3C210.8,93.9,212.8,93.4,215.1,93.4z"></path><path class="fill-current" d="M236.6,129.2c-5,0-8.9-1.5-11.7-4.6c-2.8-3.1-4.2-7.4-4.2-13c0-5.5,1.4-9.9,4.1-13.2c2.7-3.3,6.4-5,10.9-5
		c4.1,0,7.3,1.4,9.6,4.3c2.3,2.8,3.5,6.7,3.5,11.6v2.5H224c0,4.7,1.1,8.4,3.3,10.9c2.2,2.5,5.3,3.7,9.3,3.7c2,0,3.7-0.1,5.2-0.4
		c1.5-0.3,3.4-0.9,5.7-1.8v2.9c-1.9,0.8-3.7,1.4-5.4,1.7S238.6,129.2,236.6,129.2z M235.7,96.2c-3.3,0-6,1.1-8,3.3
		c-2,2.2-3.2,5.3-3.5,9.5h21.3c0-4-0.9-7.1-2.6-9.4C241.2,97.3,238.8,96.2,235.7,96.2z"></path><path class="fill-current" d="M300.1,128.5h-25.4V82.1h25.4v3H278v17.6h20.9v3H278v19.9h22.1V128.5z"></path><path class="fill-current" d="M331.6,128.5v-22.4c0-3.5-0.7-6-2.2-7.6c-1.5-1.6-3.7-2.4-6.8-2.4c-4.1,0-7.1,1-9.1,3.1
		c-1.9,2.1-2.9,5.5-2.9,10.1v19h-3.1V94h2.7l0.6,4.7h0.2c2.2-3.6,6.2-5.4,12-5.4c7.8,0,11.7,4.2,11.7,12.6v22.6H331.6z"></path><path class="fill-current" d="M372.3,94v2.2l-7.1,0.4c1.9,2.4,2.9,5,2.9,7.8c0,3.3-1.1,6-3.3,8.1c-2.2,2.1-5.2,3.1-8.9,3.1
		c-1.6,0-2.7-0.1-3.3-0.2c-1.2,0.7-2.2,1.4-2.9,2.3c-0.7,0.9-1,1.8-1,2.8c0,1.1,0.4,1.9,1.3,2.4s2.2,0.8,4.2,0.8h6
		c3.7,0,6.6,0.8,8.6,2.3c2,1.5,3,3.7,3,6.7c0,3.6-1.5,6.4-4.4,8.4c-3,2-7.2,3-12.6,3c-4.3,0-7.7-0.8-10.1-2.5c-2.4-1.7-3.6-4-3.6-7
		c0-2.4,0.7-4.3,2.2-5.9c1.5-1.6,3.5-2.6,6-3.2c-1-0.4-1.9-1.1-2.5-1.9c-0.6-0.8-0.9-1.8-0.9-2.8c0-2.3,1.5-4.3,4.4-6.1
		c-2-0.8-3.6-2.1-4.7-3.9c-1.1-1.8-1.7-3.8-1.7-6.1c0-3.4,1.1-6.2,3.3-8.3c2.2-2.1,5.1-3.1,8.9-3.1c2.3,0,4,0.2,5.3,0.7H372.3z
		 M344.4,134.4c0,4.7,3.5,7.1,10.6,7.1c9.1,0,13.6-2.9,13.6-8.7c0-2.1-0.7-3.6-2.1-4.5c-1.4-0.9-3.7-1.4-6.9-1.4h-5.6
		C347.5,126.9,344.4,129.4,344.4,134.4z M347,104.8c0,2.7,0.8,4.7,2.4,6.2c1.6,1.5,3.8,2.2,6.5,2.2c2.9,0,5.1-0.7,6.6-2.2
		s2.3-3.6,2.3-6.3c0-2.9-0.8-5.1-2.4-6.6s-3.8-2.2-6.6-2.2c-2.8,0-4.9,0.8-6.5,2.4C347.8,99.8,347,102,347,104.8z"></path><path class="fill-current" d="M380.2,84.5c0-2,0.7-3,2-3c0.7,0,1.2,0.3,1.5,0.8c0.4,0.5,0.6,1.3,0.6,2.3c0,1-0.2,1.7-0.6,2.3
		c-0.4,0.6-0.9,0.8-1.5,0.8C380.9,87.5,380.2,86.5,380.2,84.5z M383.8,128.5h-3.1V94h3.1V128.5z"></path><path class="fill-current" d="M420.2,128.5v-22.4c0-3.5-0.7-6-2.2-7.6c-1.5-1.6-3.7-2.4-6.8-2.4c-4.1,0-7.1,1-9.1,3.1
		c-1.9,2.1-2.9,5.5-2.9,10.1v19h-3.1V94h2.7l0.6,4.7h0.2c2.2-3.6,6.2-5.4,12-5.4c7.8,0,11.7,4.2,11.7,12.6v22.6H420.2z"></path><path class="fill-current" d="M446.9,129.2c-5,0-8.9-1.5-11.7-4.6c-2.8-3.1-4.2-7.4-4.2-13c0-5.5,1.4-9.9,4.1-13.2c2.7-3.3,6.4-5,10.9-5
		c4.1,0,7.3,1.4,9.6,4.3c2.3,2.8,3.5,6.7,3.5,11.6v2.5h-24.9c0,4.7,1.1,8.4,3.3,10.9c2.2,2.5,5.3,3.7,9.3,3.7c2,0,3.7-0.1,5.2-0.4
		c1.5-0.3,3.4-0.9,5.7-1.8v2.9c-1.9,0.8-3.7,1.4-5.4,1.7S448.9,129.2,446.9,129.2z M446,96.2c-3.3,0-6,1.1-8,3.3
		c-2,2.2-3.2,5.3-3.5,9.5h21.3c0-4-0.9-7.1-2.6-9.4C451.5,97.3,449.1,96.2,446,96.2z"></path><path class="fill-current" d="M481.4,129.2c-5,0-8.9-1.5-11.7-4.6c-2.8-3.1-4.2-7.4-4.2-13c0-5.5,1.4-9.9,4.1-13.2c2.7-3.3,6.4-5,10.9-5
		c4.1,0,7.3,1.4,9.6,4.3c2.3,2.8,3.5,6.7,3.5,11.6v2.5h-24.9c0,4.7,1.1,8.4,3.3,10.9c2.2,2.5,5.3,3.7,9.3,3.7c2,0,3.7-0.1,5.2-0.4
		c1.5-0.3,3.4-0.9,5.7-1.8v2.9c-1.9,0.8-3.7,1.4-5.4,1.7S483.4,129.2,481.4,129.2z M480.5,96.2c-3.3,0-6,1.1-8,3.3
		c-2,2.2-3.2,5.3-3.5,9.5h21.3c0-4-0.9-7.1-2.6-9.4C486,97.3,483.6,96.2,480.5,96.2z"></path><path class="fill-current" d="M515,93.4c1.5,0,3,0.1,4.7,0.4l-0.6,3c-1.4-0.4-2.9-0.5-4.5-0.5c-2.9,0-5.4,1.2-7.2,3.7
		c-1.9,2.5-2.8,5.6-2.8,9.5v19h-3.1V94h2.7l0.3,6.2h0.2c1.4-2.5,2.9-4.3,4.5-5.3C510.8,93.9,512.7,93.4,515,93.4z"></path><path class="fill-current" d="M524.1,84.5c0-2,0.7-3,2-3c0.7,0,1.2,0.3,1.5,0.8c0.4,0.5,0.6,1.3,0.6,2.3c0,1-0.2,1.7-0.6,2.3
		c-0.4,0.6-0.9,0.8-1.5,0.8C524.7,87.5,524.1,86.5,524.1,84.5z M527.7,128.5h-3.1V94h3.1V128.5z"></path><path class="fill-current" d="M564,128.5v-22.4c0-3.5-0.7-6-2.2-7.6c-1.5-1.6-3.7-2.4-6.8-2.4c-4.1,0-7.1,1-9.1,3.1
		c-1.9,2.1-2.9,5.5-2.9,10.1v19H540V94h2.7l0.6,4.7h0.2c2.2-3.6,6.2-5.4,12-5.4c7.8,0,11.7,4.2,11.7,12.6v22.6H564z"></path><path class="fill-current" d="M605.6,94v2.2l-7.1,0.4c1.9,2.4,2.9,5,2.9,7.8c0,3.3-1.1,6-3.3,8.1c-2.2,2.1-5.2,3.1-8.9,3.1
		c-1.6,0-2.7-0.1-3.3-0.2c-1.2,0.7-2.2,1.4-2.9,2.3c-0.7,0.9-1,1.8-1,2.8c0,1.1,0.4,1.9,1.3,2.4s2.2,0.8,4.2,0.8h6
		c3.7,0,6.6,0.8,8.6,2.3c2,1.5,3,3.7,3,6.7c0,3.6-1.5,6.4-4.4,8.4c-3,2-7.2,3-12.6,3c-4.3,0-7.7-0.8-10.1-2.5c-2.4-1.7-3.6-4-3.6-7
		c0-2.4,0.7-4.3,2.2-5.9c1.5-1.6,3.5-2.6,6-3.2c-1-0.4-1.9-1.1-2.5-1.9c-0.6-0.8-0.9-1.8-0.9-2.8c0-2.3,1.5-4.3,4.4-6.1
		c-2-0.8-3.6-2.1-4.7-3.9c-1.1-1.8-1.7-3.8-1.7-6.1c0-3.4,1.1-6.2,3.3-8.3c2.2-2.1,5.1-3.1,8.9-3.1c2.3,0,4,0.2,5.3,0.7H605.6z
		 M577.7,134.4c0,4.7,3.5,7.1,10.6,7.1c9.1,0,13.6-2.9,13.6-8.7c0-2.1-0.7-3.6-2.1-4.5c-1.4-0.9-3.7-1.4-6.9-1.4h-5.7
		C580.9,126.9,577.7,129.4,577.7,134.4z M580.3,104.8c0,2.7,0.8,4.7,2.4,6.2c1.6,1.5,3.8,2.2,6.5,2.2c2.9,0,5.1-0.7,6.6-2.2
		s2.3-3.6,2.3-6.3c0-2.9-0.8-5.1-2.4-6.6s-3.8-2.2-6.6-2.2c-2.8,0-4.9,0.8-6.5,2.4C581.1,99.8,580.3,102,580.3,104.8z"></path><path class="fill-current" d="M626.5,128.5V82.1h3.2v46.4H626.5z"></path><path class="fill-current" d="M665.9,128.5v-22.4c0-3.5-0.7-6-2.2-7.6c-1.5-1.6-3.7-2.4-6.8-2.4c-4.1,0-7.1,1-9.1,3.1
		c-1.9,2.1-2.9,5.5-2.9,10.1v19h-3.1V94h2.7l0.6,4.7h0.2c2.2-3.6,6.2-5.4,12-5.4c7.8,0,11.7,4.2,11.7,12.6v22.6H665.9z"></path><path class="fill-current" d="M700.9,119.6c0,3.1-1.2,5.5-3.5,7.1c-2.3,1.7-5.7,2.5-10,2.5c-4.6,0-8.3-0.7-11-2.1v-3.4
		c3.5,1.7,7.1,2.6,11,2.6c3.4,0,6-0.6,7.8-1.7c1.8-1.1,2.7-2.6,2.7-4.5c0-1.7-0.7-3.2-2.1-4.4c-1.4-1.2-3.7-2.3-6.9-3.5
		c-3.4-1.2-5.9-2.3-7.3-3.2c-1.4-0.9-2.4-1.9-3.2-3c-0.7-1.1-1.1-2.5-1.1-4.1c0-2.6,1.1-4.6,3.3-6.1c2.2-1.5,5.2-2.3,9.1-2.3
		c3.7,0,7.3,0.7,10.6,2.1l-1.2,2.9c-3.4-1.4-6.5-2.1-9.4-2.1c-2.8,0-5,0.5-6.7,1.4c-1.7,0.9-2.5,2.2-2.5,3.9c0,1.8,0.6,3.2,1.9,4.3
		c1.3,1.1,3.8,2.3,7.5,3.6c3.1,1.1,5.4,2.1,6.8,3c1.4,0.9,2.5,1.9,3.2,3.1S700.9,118,700.9,119.6z"></path><path class="fill-current" d="M719.3,126.4c2,0,3.7-0.2,5.2-0.5v2.5c-1.5,0.5-3.3,0.8-5.3,0.8c-3,0-5.3-0.8-6.7-2.4
		c-1.4-1.6-2.2-4.2-2.2-7.7V96.8h-5.1v-1.8l5.1-1.4l1.6-7.8h1.6V94h10.1v2.7h-10.1v21.8c0,2.6,0.5,4.6,1.4,5.9
		C715.8,125.8,717.3,126.4,719.3,126.4z"></path><path class="fill-current" d="M730.4,84.5c0-2,0.7-3,2-3c0.7,0,1.2,0.3,1.5,0.8c0.4,0.5,0.6,1.3,0.6,2.3c0,1-0.2,1.7-0.6,2.3
		c-0.4,0.6-0.9,0.8-1.5,0.8C731,87.5,730.4,86.5,730.4,84.5z M733.9,128.5h-3.1V94h3.1V128.5z"></path><path class="fill-current" d="M756.2,126.4c2,0,3.7-0.2,5.2-0.5v2.5c-1.5,0.5-3.3,0.8-5.3,0.8c-3,0-5.3-0.8-6.7-2.4
		c-1.4-1.6-2.2-4.2-2.2-7.7V96.8h-5.1v-1.8l5.1-1.4l1.6-7.8h1.6V94h10.1v2.7h-10.1v21.8c0,2.6,0.5,4.6,1.4,5.9
		C752.8,125.8,754.2,126.4,756.2,126.4z"></path><path class="fill-current" d="M769.5,94v22.3c0,3.5,0.7,6,2.2,7.6c1.5,1.6,3.7,2.4,6.8,2.4c4.1,0,7.1-1,9.1-3.1c1.9-2.1,2.9-5.4,2.9-10.1V94
		h3.1v34.5h-2.7l-0.6-4.8h-0.2c-2.2,3.6-6.2,5.4-12,5.4c-7.8,0-11.8-4.2-11.8-12.6V94H769.5z"></path><path class="fill-current" d="M814.8,126.4c2,0,3.7-0.2,5.2-0.5v2.5c-1.5,0.5-3.3,0.8-5.3,0.8c-3,0-5.3-0.8-6.7-2.4
		c-1.4-1.6-2.2-4.2-2.2-7.7V96.8h-5.1v-1.8l5.1-1.4l1.6-7.8h1.6V94h10.1v2.7H809v21.8c0,2.6,0.5,4.6,1.4,5.9
		C811.3,125.8,812.8,126.4,814.8,126.4z"></path><path class="fill-current" d="M839.7,129.2c-5,0-8.9-1.5-11.7-4.6c-2.8-3.1-4.2-7.4-4.2-13c0-5.5,1.4-9.9,4.1-13.2c2.7-3.3,6.4-5,10.9-5
		c4.1,0,7.3,1.4,9.6,4.3c2.3,2.8,3.5,6.7,3.5,11.6v2.5h-24.9c0,4.7,1.1,8.4,3.3,10.9c2.2,2.5,5.3,3.7,9.3,3.7c2,0,3.7-0.1,5.2-0.4
		c1.5-0.3,3.4-0.9,5.7-1.8v2.9c-1.9,0.8-3.7,1.4-5.4,1.7S841.7,129.2,839.7,129.2z M838.8,96.2c-3.3,0-6,1.1-8,3.3
		c-2,2.2-3.2,5.3-3.5,9.5h21.3c0-4-0.9-7.1-2.6-9.4C844.2,97.3,841.8,96.2,838.8,96.2z"></path></g>`, 2), Hu = [
  Ou
], Pt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsSeiWordmark",
  __name: "SeiWordmark",
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", Vu, Hu));
  }
}), Nu = {
  "data-id": "sds-layout-app",
  class: "flex flex-col h-screen dark:text-gray-50"
}, Eu = { class: "md:hidden my-auto p-3 bg-white dark:bg-gray-950 border-b border-gray-100 dark:border-gray-800" }, Iu = { class: "flex items-center gap-2" }, Ru = {
  key: 0,
  class: "hidden md:block grow"
}, Fu = ["href"], Wu = { class: "text-red-600 dark:text-red-400 font-bold" }, qu = {
  key: 1,
  class: "flex"
}, Gu = { class: "text-red-600 dark:text-red-400 font-bold" }, Yu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "text-black dark:text-white h-6 w-6 inline-block",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 48 48"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("g", {
    fill: "none",
    stroke: "currentColor",
    "stroke-width": "4",
    "stroke-linecap": "round",
    "stroke-linejoin": "round"
  }, [
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M7.95 11.95h32" }),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M7.95 23.95h32" }),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M7.95 35.95h32" })
  ])
], -1), ju = { class: "flex items-center" }, Uu = {
  key: 0,
  class: "text-red-600 dark:text-red-400 font-bold"
}, Ku = { key: 1 }, _u = { class: "flex grow flex-shrink-0" }, Xu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Toggle mobile menu", -1), Qu = [
  Xu
], Zu = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Toggle mobile menu", -1), Ju = [
  Zu
], e0 = { class: "h-screen flex flex-col sticky top-0" }, t0 = { class: "overflow-y-auto grow overscroll-contain" }, a0 = {
  key: 0,
  class: "px-3"
}, n0 = { class: "border-b border-gray-100 dark:border-gray-800 mb-3" }, r0 = { class: "flex gap-2 py-3" }, s0 = {
  key: 0,
  class: "block w-4 h-4 my-auto flex-shrink-0"
}, l0 = ["href"], o0 = ["src", "alt"], i0 = {
  key: 1,
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 576 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current text-blue-400"
}, c0 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M172.1 40.16L268.1 3.76C280.9-1.089 295.1-1.089 307.9 3.76L403.9 40.16C425.6 48.41 440 69.25 440 92.52V204.7C441.3 205.1 442.6 205.5 443.9 205.1L539.9 242.4C561.6 250.6 576 271.5 576 294.7V413.9C576 436.1 562.9 456.2 542.5 465.1L446.5 507.3C432.2 513.7 415.8 513.7 401.5 507.3L288 457.5L174.5 507.3C160.2 513.7 143.8 513.7 129.5 507.3L33.46 465.1C13.13 456.2 0 436.1 0 413.9V294.7C0 271.5 14.39 250.6 36.15 242.4L132.1 205.1C133.4 205.5 134.7 205.1 136 204.7V92.52C136 69.25 150.4 48.41 172.1 40.16V40.16zM290.8 48.64C289 47.95 286.1 47.95 285.2 48.64L206.8 78.35L287.1 109.5L369.2 78.35L290.8 48.64zM392 210.6V121L309.6 152.6V241.8L392 210.6zM154.8 250.9C153 250.2 150.1 250.2 149.2 250.9L70.81 280.6L152 311.7L233.2 280.6L154.8 250.9zM173.6 455.3L256 419.1V323.2L173.6 354.8V455.3zM342.8 280.6L424 311.7L505.2 280.6L426.8 250.9C425 250.2 422.1 250.2 421.2 250.9L342.8 280.6zM528 413.9V323.2L445.6 354.8V455.3L523.2 421.2C526.1 419.9 528 417.1 528 413.9V413.9z" }, null, -1), d0 = [
  c0
], u0 = { class: "sr-only" }, f0 = ["src", "alt"], h0 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 576 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current text-blue-400"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M172.1 40.16L268.1 3.76C280.9-1.089 295.1-1.089 307.9 3.76L403.9 40.16C425.6 48.41 440 69.25 440 92.52V204.7C441.3 205.1 442.6 205.5 443.9 205.1L539.9 242.4C561.6 250.6 576 271.5 576 294.7V413.9C576 436.1 562.9 456.2 542.5 465.1L446.5 507.3C432.2 513.7 415.8 513.7 401.5 507.3L288 457.5L174.5 507.3C160.2 513.7 143.8 513.7 129.5 507.3L33.46 465.1C13.13 456.2 0 436.1 0 413.9V294.7C0 271.5 14.39 250.6 36.15 242.4L132.1 205.1C133.4 205.5 134.7 205.1 136 204.7V92.52C136 69.25 150.4 48.41 172.1 40.16V40.16zM290.8 48.64C289 47.95 286.1 47.95 285.2 48.64L206.8 78.35L287.1 109.5L369.2 78.35L290.8 48.64zM392 210.6V121L309.6 152.6V241.8L392 210.6zM154.8 250.9C153 250.2 150.1 250.2 149.2 250.9L70.81 280.6L152 311.7L233.2 280.6L154.8 250.9zM173.6 455.3L256 419.1V323.2L173.6 354.8V455.3zM342.8 280.6L424 311.7L505.2 280.6L426.8 250.9C425 250.2 422.1 250.2 421.2 250.9L342.8 280.6zM528 413.9V323.2L445.6 354.8V455.3L523.2 421.2C526.1 419.9 528 417.1 528 413.9V413.9z" })
], -1), y0 = { class: "sr-only" }, m0 = ["href"], g0 = {
  key: 1,
  class: "my-auto"
}, v0 = {
  key: 1,
  class: "grid grid-cols-1 pb-24"
}, b0 = ["href", "onClick"], p0 = {
  key: 0,
  class: "inline-block w-4 h-4 my-auto flex-shrink-0"
}, w0 = ["src", "alt"], x0 = {
  key: 1,
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current"
}, k0 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M384 215.1V102.5c0-15-9.3-28.4-23.4-33.7l-92-34.5c-8.1-3.1-17.1-3.1-25.3 0l-92 34.5c-14.1 5.3-23.4 18.7-23.4 33.7v112.6L23.4 254.4C9.3 259.6 0 273.1 0 288.1v106.6c0 13.6 7.7 26.1 19.9 32.2l98.6 49.3c10.1 5.1 22.1 5.1 32.2 0L256 423.6l105.3 52.6c10.1 5.1 22.1 5.1 32.2 0l98.6-49.3c12.2-6.1 19.9-18.6 19.9-32.2V288.1c0-15-9.3-28.4-23.4-33.7L384 215.1zm-116 34.8V152l92-31.7v97.6l-92 32zM152 94.2l104-39 104 39v.2L256 131 152 94.3v-.1zm0 26.1l92 31.7v97.9l-92-32v-97.6zm-30 329.4l-96.8-48.4V308l96.8 39.3v102.4zM25.2 280.8v-.2l109.4-41 108.1 40.5v1.2l-108.1 43.9-109.4-44.4zm122 66.5l95.5-38.8V402l-95.5 47.8V347.3zm217.6 102.4L269.3 402v-93.4l95.5 38.8v102.3zm122-48.4L390 449.7V347.3l96.8-39.3v93.3zm0-120.5l-109.4 44.4-108.1-43.9v-1.2l108.1-40.5 109.4 41v.2z" }, null, -1), M0 = [
  k0
], C0 = { class: "sr-only" }, S0 = { class: "inline-block my-auto text-left" }, $0 = {
  key: 0,
  class: "inline-block my-auto"
}, L0 = { class: "flex items-center justify-center px-2 py-1 text-xs font-bold rounded-full text-white bg-red-600 dark:bg-red-700" }, z0 = {
  class: "shrink-0 w-4 h-4 ml-auto my-auto",
  fill: "none",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  "aria-hidden": "true",
  xmlns: "http://www.w3.org/2000/svg"
}, D0 = {
  key: 0,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "3",
  d: "M19 9l-7 7-7-7"
}, T0 = {
  key: 1,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "3",
  d: "M9 5l7 7-7 7"
}, B0 = ["href", "onClick"], P0 = { class: "inline-block my-auto text-left" }, A0 = {
  key: 0,
  class: "inline-block my-auto"
}, V0 = { class: "flex items-center justify-center px-2 py-1 text-xs font-bold rounded-full text-white bg-red-600 dark:bg-red-700" }, O0 = ["href", "onClick"], H0 = {
  key: 0,
  class: "inline-block w-4 h-4 my-auto flex-shrink-0"
}, N0 = ["src", "alt"], E0 = {
  key: 1,
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current"
}, I0 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M384 215.1V102.5c0-15-9.3-28.4-23.4-33.7l-92-34.5c-8.1-3.1-17.1-3.1-25.3 0l-92 34.5c-14.1 5.3-23.4 18.7-23.4 33.7v112.6L23.4 254.4C9.3 259.6 0 273.1 0 288.1v106.6c0 13.6 7.7 26.1 19.9 32.2l98.6 49.3c10.1 5.1 22.1 5.1 32.2 0L256 423.6l105.3 52.6c10.1 5.1 22.1 5.1 32.2 0l98.6-49.3c12.2-6.1 19.9-18.6 19.9-32.2V288.1c0-15-9.3-28.4-23.4-33.7L384 215.1zm-116 34.8V152l92-31.7v97.6l-92 32zM152 94.2l104-39 104 39v.2L256 131 152 94.3v-.1zm0 26.1l92 31.7v97.9l-92-32v-97.6zm-30 329.4l-96.8-48.4V308l96.8 39.3v102.4zM25.2 280.8v-.2l109.4-41 108.1 40.5v1.2l-108.1 43.9-109.4-44.4zm122 66.5l95.5-38.8V402l-95.5 47.8V347.3zm217.6 102.4L269.3 402v-93.4l95.5 38.8v102.3zm122-48.4L390 449.7V347.3l96.8-39.3v93.3zm0-120.5l-109.4 44.4-108.1-43.9v-1.2l108.1-40.5 109.4 41v.2z" }, null, -1), R0 = [
  I0
], F0 = { class: "sr-only" }, W0 = { class: "inline-block my-auto text-left" }, q0 = {
  key: 0,
  class: "inline-block my-auto"
}, G0 = { class: "flex items-center justify-center px-2 py-1 text-xs font-bold rounded-full text-white bg-red-600 dark:bg-red-700" }, Y0 = {
  key: 0,
  class: "p-3"
}, j0 = { class: "pt-3 border-t border-gray-100 dark:border-gray-800 items-center flex gap-2 flex-shrink-0" }, U0 = { class: "h-screen flex flex-col sticky top-0" }, K0 = { class: "my-auto px-3" }, _0 = { class: "border-b border-gray-100 dark:border-gray-800" }, X0 = { class: "flex items-center gap-2 pt-3" }, Q0 = {
  key: 0,
  class: "hidden md:block grow"
}, Z0 = ["href"], J0 = { class: "text-red-600 dark:text-red-400 font-bold" }, e1 = {
  key: 1,
  class: "flex"
}, t1 = { class: "text-red-600 dark:text-red-400 font-bold" }, a1 = {
  key: 1,
  class: "mx-auto"
}, n1 = ["title"], r1 = {
  "aria-hidden": "true",
  class: "w-4 h-4 mx-auto",
  fill: "none",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  xmlns: "http://www.w3.org/2000/svg"
}, s1 = {
  key: 0,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  d: "M13 5l7 7-7 7M5 5l7 7-7 7"
}, l1 = {
  key: 1,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  d: "M11 19l-7-7 7-7m8 14l-7-7 7-7"
}, o1 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  "xmlns:xlink": "http://www.w3.org/1999/xlink",
  "aria-hidden": "true",
  role: "img",
  class: "text-white h-6 w-6 inline-block",
  preserveAspectRatio: "xMidYMid meet",
  viewBox: "0 0 48 48"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("g", {
    fill: "none",
    stroke: "currentColor",
    "stroke-width": "4",
    "stroke-linecap": "round",
    "stroke-linejoin": "round"
  }, [
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M7.95 11.95h32" }),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M7.95 23.95h32" }),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M7.95 35.95h32" })
  ])
], -1), i1 = { class: "text-xl leading-6 flex" }, c1 = {
  key: 0,
  class: "text-red-600 dark:text-red-400 font-bold"
}, d1 = { key: 1 }, u1 = {
  key: 1,
  class: "sticky top-0 z-10"
}, f1 = {
  key: 0,
  class: "flex gap-2 py-3"
}, h1 = ["href"], y1 = ["src", "alt"], m1 = {
  key: 1,
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 576 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current text-blue-400"
}, g1 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M172.1 40.16L268.1 3.76C280.9-1.089 295.1-1.089 307.9 3.76L403.9 40.16C425.6 48.41 440 69.25 440 92.52V204.7C441.3 205.1 442.6 205.5 443.9 205.1L539.9 242.4C561.6 250.6 576 271.5 576 294.7V413.9C576 436.1 562.9 456.2 542.5 465.1L446.5 507.3C432.2 513.7 415.8 513.7 401.5 507.3L288 457.5L174.5 507.3C160.2 513.7 143.8 513.7 129.5 507.3L33.46 465.1C13.13 456.2 0 436.1 0 413.9V294.7C0 271.5 14.39 250.6 36.15 242.4L132.1 205.1C133.4 205.5 134.7 205.1 136 204.7V92.52C136 69.25 150.4 48.41 172.1 40.16V40.16zM290.8 48.64C289 47.95 286.1 47.95 285.2 48.64L206.8 78.35L287.1 109.5L369.2 78.35L290.8 48.64zM392 210.6V121L309.6 152.6V241.8L392 210.6zM154.8 250.9C153 250.2 150.1 250.2 149.2 250.9L70.81 280.6L152 311.7L233.2 280.6L154.8 250.9zM173.6 455.3L256 419.1V323.2L173.6 354.8V455.3zM342.8 280.6L424 311.7L505.2 280.6L426.8 250.9C425 250.2 422.1 250.2 421.2 250.9L342.8 280.6zM528 413.9V323.2L445.6 354.8V455.3L523.2 421.2C526.1 419.9 528 417.1 528 413.9V413.9z" }, null, -1), v1 = [
  g1
], b1 = { class: "sr-only" }, p1 = ["src", "alt"], w1 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 576 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current text-blue-400"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M172.1 40.16L268.1 3.76C280.9-1.089 295.1-1.089 307.9 3.76L403.9 40.16C425.6 48.41 440 69.25 440 92.52V204.7C441.3 205.1 442.6 205.5 443.9 205.1L539.9 242.4C561.6 250.6 576 271.5 576 294.7V413.9C576 436.1 562.9 456.2 542.5 465.1L446.5 507.3C432.2 513.7 415.8 513.7 401.5 507.3L288 457.5L174.5 507.3C160.2 513.7 143.8 513.7 129.5 507.3L33.46 465.1C13.13 456.2 0 436.1 0 413.9V294.7C0 271.5 14.39 250.6 36.15 242.4L132.1 205.1C133.4 205.5 134.7 205.1 136 204.7V92.52C136 69.25 150.4 48.41 172.1 40.16V40.16zM290.8 48.64C289 47.95 286.1 47.95 285.2 48.64L206.8 78.35L287.1 109.5L369.2 78.35L290.8 48.64zM392 210.6V121L309.6 152.6V241.8L392 210.6zM154.8 250.9C153 250.2 150.1 250.2 149.2 250.9L70.81 280.6L152 311.7L233.2 280.6L154.8 250.9zM173.6 455.3L256 419.1V323.2L173.6 354.8V455.3zM342.8 280.6L424 311.7L505.2 280.6L426.8 250.9C425 250.2 422.1 250.2 421.2 250.9L342.8 280.6zM528 413.9V323.2L445.6 354.8V455.3L523.2 421.2C526.1 419.9 528 417.1 528 413.9V413.9z" })
], -1), x1 = { class: "sr-only" }, k1 = ["href"], M1 = { class: "overflow-y-auto grow overscroll-contain pt-3" }, C1 = {
  key: 0,
  class: "grid grid-cols-1 pb-24"
}, S1 = ["href", "onClick"], $1 = ["src", "alt"], L1 = {
  key: 1,
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current"
}, z1 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M384 215.1V102.5c0-15-9.3-28.4-23.4-33.7l-92-34.5c-8.1-3.1-17.1-3.1-25.3 0l-92 34.5c-14.1 5.3-23.4 18.7-23.4 33.7v112.6L23.4 254.4C9.3 259.6 0 273.1 0 288.1v106.6c0 13.6 7.7 26.1 19.9 32.2l98.6 49.3c10.1 5.1 22.1 5.1 32.2 0L256 423.6l105.3 52.6c10.1 5.1 22.1 5.1 32.2 0l98.6-49.3c12.2-6.1 19.9-18.6 19.9-32.2V288.1c0-15-9.3-28.4-23.4-33.7L384 215.1zm-116 34.8V152l92-31.7v97.6l-92 32zM152 94.2l104-39 104 39v.2L256 131 152 94.3v-.1zm0 26.1l92 31.7v97.9l-92-32v-97.6zm-30 329.4l-96.8-48.4V308l96.8 39.3v102.4zM25.2 280.8v-.2l109.4-41 108.1 40.5v1.2l-108.1 43.9-109.4-44.4zm122 66.5l95.5-38.8V402l-95.5 47.8V347.3zm217.6 102.4L269.3 402v-93.4l95.5 38.8v102.3zm122-48.4L390 449.7V347.3l96.8-39.3v93.3zm0-120.5l-109.4 44.4-108.1-43.9v-1.2l108.1-40.5 109.4 41v.2z" }, null, -1), D1 = [
  z1
], T1 = { class: "sr-only" }, B1 = {
  key: 0,
  class: "inline-block my-auto text-left"
}, P1 = {
  key: 0,
  class: "flex items-center justify-center px-2 py-1 text-xs font-bold rounded-full text-white bg-red-600 dark:bg-red-700"
}, A1 = {
  key: 1,
  class: "flex justify-center p-1 rounded-full bg-red-600"
}, V1 = { class: "sr-only" }, O1 = {
  key: 2,
  class: "shrink-0 w-4 h-4 ml-auto my-auto",
  fill: "none",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  "aria-hidden": "true",
  xmlns: "http://www.w3.org/2000/svg"
}, H1 = {
  key: 0,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "3",
  d: "M19 9l-7 7-7-7"
}, N1 = {
  key: 1,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "3",
  d: "M9 5l7 7-7 7"
}, E1 = ["href", "onClick"], I1 = { class: "inline-block my-auto text-left" }, R1 = {
  key: 0,
  class: "inline-block my-auto"
}, F1 = { class: "flex items-center justify-center px-2 py-1 text-xs font-bold rounded-full text-white bg-red-600 dark:bg-red-700" }, W1 = ["href", "onClick"], q1 = ["src", "alt"], G1 = {
  key: 1,
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 512 512",
  "aria-hidden": "true",
  class: "w-4 h-4 fill-current"
}, Y1 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M384 215.1V102.5c0-15-9.3-28.4-23.4-33.7l-92-34.5c-8.1-3.1-17.1-3.1-25.3 0l-92 34.5c-14.1 5.3-23.4 18.7-23.4 33.7v112.6L23.4 254.4C9.3 259.6 0 273.1 0 288.1v106.6c0 13.6 7.7 26.1 19.9 32.2l98.6 49.3c10.1 5.1 22.1 5.1 32.2 0L256 423.6l105.3 52.6c10.1 5.1 22.1 5.1 32.2 0l98.6-49.3c12.2-6.1 19.9-18.6 19.9-32.2V288.1c0-15-9.3-28.4-23.4-33.7L384 215.1zm-116 34.8V152l92-31.7v97.6l-92 32zM152 94.2l104-39 104 39v.2L256 131 152 94.3v-.1zm0 26.1l92 31.7v97.9l-92-32v-97.6zm-30 329.4l-96.8-48.4V308l96.8 39.3v102.4zM25.2 280.8v-.2l109.4-41 108.1 40.5v1.2l-108.1 43.9-109.4-44.4zm122 66.5l95.5-38.8V402l-95.5 47.8V347.3zm217.6 102.4L269.3 402v-93.4l95.5 38.8v102.3zm122-48.4L390 449.7V347.3l96.8-39.3v93.3zm0-120.5l-109.4 44.4-108.1-43.9v-1.2l108.1-40.5 109.4 41v.2z" }, null, -1), j1 = [
  Y1
], U1 = { class: "sr-only" }, K1 = {
  key: 0,
  class: "inline-block my-auto text-left"
}, _1 = {
  key: 0,
  class: "flex items-center justify-center px-2 py-1 text-xs font-bold rounded-full text-white bg-red-600 dark:bg-red-700"
}, X1 = {
  key: 1,
  class: "flex justify-center p-1 rounded-full bg-red-600 dark:bg-red-700"
}, Q1 = { class: "sr-only" }, Z1 = {
  key: 0,
  class: "items-center flex gap-2 flex-shrink-0 p-3"
}, J1 = { class: "bg-gray-50 dark:bg-black flex flex-col items-stretch grow min-w-0" }, e2 = { class: "grow pb-4" }, t2 = {
  key: 0,
  class: "bg-gray-25 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-800 px-3 py-3 sticky top-0 z-40 flex flex-col gap-4 md:flex-row"
}, a2 = { class: "grow my-auto flex flex-row gap-2" }, n2 = { class: "text-xl font-light text-gray-900 dark:text-gray-100" }, r2 = {
  key: 0,
  class: "flex-shrink-0 my-auto flex flex-col md:flex-row gap-2"
}, s2 = { class: "p-4" }, l2 = {
  key: 0,
  class: "px-4"
}, o2 = { class: "text-xs p-4" }, i2 = { class: "border-t border-gray-200 dark:border-gray-800 flex flex-col lg:flex-row gap-4 pt-4" }, c2 = { class: "flex-shrink-0 flex order-2 lg:order-1" }, d2 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Software Engineering Institute", -1), u2 = {
  key: 0,
  class: "flex-shrink flex lg:mx-auto order-1 lg:order-2"
}, f2 = { class: "my-auto" }, h2 = { class: "flex-shrink-0 flex lg:ml-auto order-3" }, y2 = { class: "my-auto" }, m2 = { class: "flex flex-col" }, g2 = { class: "ml-auto" }, v2 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", { class: "ml-auto" }, " Proprietary. SEI Internal Use Only ", -1), b2 = {
  key: 1,
  class: "bg-blue-500 text-white dark:bg-blue-700 p-4 sticky bottom-0 z-40"
}, La = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutApp",
  __name: "LayoutApp",
  props: {
    /**
     * The v-model that determines collapsed state.
     */
    modelValue: { type: Boolean, default: !1 },
    /**
     * The width class of the non-collapsed sidebar when not in a mobile responsive view.
     */
    sidebarWidth: { type: String, default: "w-72" },
    /**
     * Determines whether to enable collapsing functionality.
     *
     * Ensure to have an icon for every item in the **sidebarNavigationItems** array for this to look nice.
     *
     * Including an **appIconUrl** will also improve the user experience.
     */
    enableCollapsibleSidebar: { type: Boolean, default: !1 },
    /**
     * The app suite name's prefix (styled in red) for the layout.
     */
    appSuitePrefix: { type: String, default: "SEI" },
    /**
     * The app suite name for the layout.
     */
    appSuite: { type: String, default: null },
    /**
     * The app suite url for the layout.
     */
    appSuiteUrl: { type: String, default: null },
    /**
     * The app name for the layout.
     */
    appName: { type: String, default: null },
    /**
     * The app url for the layout.
     */
    appUrl: { type: String, default: null },
    /**
     * Determines whether to hide the **appName** in the mobile header.
     *
     * This is useful when an application's name is very long.
     */
    hideAppNameInMobileHeader: { type: Boolean, default: !1 },
    /**
     * The app icon url for the layout.
     */
    appIconUrl: { type: String, default: null },
    /**
     * The page title for the layout.
     */
    pageTitle: { type: String, default: null },
    /**
     * Determines whether to hide the page header.
     */
    hidePageHeader: { type: Boolean, default: !1 },
    /**
     * The sidebar navigation array for the layout.
     *
     * Each item should have a unique **id**, **title**, **active**, and **href** key value pair. **badgeCount** and **iconUrl** are optional.
     *
     * Item object:
     *
     * { id: Number, title: String, active: Boolean, href: String, badgeCount: Number, iconUrl: String }
     */
    sidebarNavigationItems: { type: Array, default: () => [] },
    /**
     * Determines whether to hide the app icon.
     */
    hideAppIcon: { type: Boolean, default: !1 },
    /**
     * Determines whether to hide the icons in the sidebar.
     */
    hideSidebarIcons: { type: Boolean, default: !1 },
    /**
     * Determines whether to hide the action bar slot.
     */
    hideActionBar: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value", "navigate"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.useSlots)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)([]), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (/* @__PURE__ */ new Date()).getFullYear()), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.enableCollapsibleSidebar && d.value ? "w-auto" : a.sidebarWidth), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(A) {
        n("update:model-value", A);
      }
    });
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(s, (A) => {
      A ? (document.documentElement.classList.add("layout-app-internal-prevent-scroll"), (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        u.value.focus();
      })) : (document.documentElement.classList.remove("layout-app-internal-prevent-scroll"), f.value.focus());
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(d, (A) => {
      A && (g.value = []);
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      document.addEventListener("keyup", L);
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      document.documentElement.classList.remove("layout-app-internal-prevent-scroll"), document.removeEventListener("keyup", L);
    });
    const h = (A) => {
      if (!A.items)
        return null;
      let E = 0;
      return A.items.forEach((M) => {
        M.badgeCount && (E = E + M.badgeCount);
      }), E;
    }, p = (A) => A.items && A.items.filter((E) => E.active).length, w = (A) => g.value.filter((E) => E.id === A.id).length, b = (A) => {
      d.value = !1, w(A) ? g.value = g.value.filter(
        (E) => E.id !== A.id
      ) : g.value.push(A);
    }, k = (A) => !!r[A], D = (A, E, M) => {
      s.value = !1, n("navigate", { group: A, item: E, event: M });
    }, C = () => {
      a.enableCollapsibleSidebar ? d.value = !d.value : d.value = !1;
    }, L = (A) => {
      if (!A.target) return;
      const E = A.target.tagName.toLowerCase();
      E !== "textarea" && E !== "input" && A.key === "[" && C();
    }, B = (A) => {
      if (A.key === "Escape") {
        s.value = !1;
        return;
      }
      const E = v.value.querySelectorAll(
        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
      );
      if (E.length < 2 && A.key === "Tab") {
        A.preventDefault();
        return;
      }
      const M = E.length - 1;
      A.key === "Tab" && A.shiftKey === !1 && A.target === E[M] ? (A.preventDefault(), E[0].focus()) : A.key === "Tab" && A.shiftKey === !0 && A.target === E[0] && (A.preventDefault(), E[M].focus());
    };
    return (A, E) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Nu, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("header", Eu, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Iu, [
          e.appSuite && !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("h1", Ru, [
            e.appSuiteUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
              key: 0,
              href: e.appSuiteUrl,
              class: "flex hover:underline",
              onClick: E[0] || (E[0] = (M) => D(null, { title: e.appSuite, href: e.appSuiteUrl }, M))
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Wu, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)
            ], 8, Fu)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", qu, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Gu, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)
            ]))
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ]),
        e.appSuite || e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
          key: 0,
          ref_key: "mobileMenuOpenBtn",
          ref: f,
          class: "flex items-center md:hidden gap-1 focus:outline-none",
          onClick: E[1] || (E[1] = (M) => s.value = !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s))
        }, [
          Yu,
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", ju, [
            e.appSuitePrefix ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", Uu, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            e.appSuite ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", Ku, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ])
        ], 512)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
      ]),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _u, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
          "enter-active-class": "transition-opacity ease-linear duration-150",
          "enter-from-class": "opacity-0",
          "enter-to-class": "opacity-100",
          "leave-active-class": "transition-opacity ease-linear duration-150",
          "leave-from-class": "opacity-100",
          "leave-to-class": "opacity-0"
        }, {
          default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
              key: 0,
              class: "bg-black bg-opacity-40 fixed inset h-screen w-screen z-50 md:hidden",
              onClick: E[2] || (E[2] = (M) => s.value = !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s))
            }, Qu)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ]),
          _: 1
        }),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
          "enter-active-class": "transition-transform ease-linear duration-150",
          "enter-from-class": "-translate-x-full",
          "enter-to-class": "translate-x-0",
          "leave-active-class": "transition-transform ease-linear duration-150",
          "leave-from-class": "translate-x-0",
          "leave-to-class": "-translate-x-full"
        }, {
          default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("aside", {
              key: 0,
              ref_key: "mobileSidebarContainer",
              ref: v,
              "aria-label": "mobile sidebar",
              class: "md:hidden fixed w-2/3 z-50 bg-white dark:bg-gray-950 flex-shrink-0 border-r border-gray-200 dark:border-gray-800",
              onKeydown: B
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                ref_key: "mobileMenuCloseBtn",
                ref: u,
                class: "sr-only",
                onClick: E[3] || (E[3] = (M) => s.value = !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s))
              }, Ju, 512),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", e0, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", t0, [
                  e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", a0, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", n0, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", r0, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "app-icon", { classList: "block w-4 h-4 my-auto flex-shrink-0" }, () => [
                          e.hideAppIcon ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", s0, [
                            e.appUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                              key: 0,
                              href: e.appUrl,
                              onClick: E[4] || (E[4] = (M) => D(null, { title: e.appName, href: e.appUrl }, M))
                            }, [
                              e.appIconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                                key: 0,
                                src: e.appIconUrl,
                                alt: e.appName,
                                class: "w-4 h-4"
                              }, null, 8, o0)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", i0, d0)),
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", u0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 1)
                            ], 8, l0)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 1 }, [
                              e.appIconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                                key: 0,
                                src: e.appIconUrl,
                                alt: e.appName,
                                class: "w-4 h-4"
                              }, null, 8, f0)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                              h0,
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", y0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 1)
                            ], 64))
                          ]))
                        ]),
                        e.appUrl && e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                          key: 0,
                          href: e.appUrl,
                          class: "my-auto hover:underline",
                          onClick: E[5] || (E[5] = (M) => D(null, { title: e.appName, href: e.appUrl }, M))
                        }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 9, m0)) : e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", g0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                      ])
                    ])
                  ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                  e.sidebarNavigationItems.length > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("nav", v0, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "mobile-sidebar-navigation", {
                      items: e.sidebarNavigationItems,
                      collapsed: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d)
                    }, () => [
                      ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.sidebarNavigationItems, (M) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, {
                        key: M.id
                      }, [
                        M.items ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                            href: M.href,
                            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex items-center relative w-full gap-2 pl-2 px-3 py-2 border-l-4", {
                              "border-transparent text-gray-700 hover:text-gray-900 dark:text-gray-300 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-800": !p(M) || w(M),
                              "border-red-600 bg-gray-25 dark:bg-gray-900 hover:bg-gray-50 dark:hover:bg-gray-800": p(M) && !w(M)
                            }]),
                            onClick: (H) => b(M)
                          }, [
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "mobile-sidebar-navigation-item-icon", {
                              item: M,
                              classList: "inline-block w-4 h-4 my-auto flex-shrink-0"
                            }, () => [
                              e.hideSidebarIcons ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", p0, [
                                M.iconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                                  key: 0,
                                  src: M.iconUrl,
                                  alt: M.title,
                                  class: "w-4 h-4"
                                }, null, 8, w0)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", x0, M0)),
                                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", C0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)
                              ]))
                            ]),
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", S0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1),
                            h(M) && !w(M) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", $0, [
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", L0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(h(M)), 1)
                            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                            ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", z0, [
                              w(M) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", D0)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", T0))
                            ]))
                          ], 10, b0),
                          w(M) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(M.items, (H) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                            key: H.id,
                            href: H.href,
                            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex relative gap-2 px-3 py-2 border-l-4", {
                              "border-transparent text-gray-700 hover:text-gray-900 dark:text-gray-300 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-800": !H.active,
                              "border-red-600 bg-gray-25 dark:bg-gray-900 hover:bg-gray-50 dark:hover:bg-gray-800": H.active,
                              "pl-8": !e.hideSidebarIcons,
                              "pl-4": e.hideSidebarIcons
                            }]),
                            onClick: (P) => D(M, H, P)
                          }, [
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", P0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(H.title), 1),
                            H.badgeCount ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", A0, [
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", V0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(H.badgeCount), 1)
                            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                          ], 10, B0))), 128)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                        ], 64)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                          key: 1,
                          href: M.href,
                          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex relative gap-2 pl-2 px-3 py-2 border-l-4", {
                            "border-transparent hover:bg-gray-50 dark:hover:bg-gray-800": !M.active,
                            "border-red-600 bg-gray-25 dark:bg-gray-900 hover:bg-gray-50 dark:hover:bg-gray-800": M.active
                          }]),
                          onClick: (H) => D(null, M, H)
                        }, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "mobile-sidebar-navigation-item-icon", {
                            item: M,
                            classList: "inline-block w-4 h-4 my-auto flex-shrink-0"
                          }, () => [
                            e.hideSidebarIcons ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", H0, [
                              M.iconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                                key: 0,
                                src: M.iconUrl,
                                alt: M.title,
                                class: "w-4 h-4"
                              }, null, 8, N0)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", E0, R0)),
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", F0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)
                            ]))
                          ]),
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", W0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1),
                          M.badgeCount ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", q0, [
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", G0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.badgeCount), 1)
                          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                        ], 10, O0))
                      ], 64))), 128))
                    ]),
                    k("user-section") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Y0, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", j0, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "user-section", { collapsed: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) })
                      ])
                    ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                  ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ])
              ])
            ], 544)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ]),
          _: 3
        }),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("aside", {
          "aria-label": "desktop sidebar",
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["hidden md:block bg-white dark:bg-gray-950 border-r border-gray-200 dark:border-gray-800 flex-shrink-0 z-50", [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(y)]])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", U0, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("header", K0, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _0, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", X0, [
                  e.appSuite && !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("h1", Q0, [
                    e.appSuiteUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                      key: 0,
                      href: e.appSuiteUrl,
                      class: "flex hover:underline",
                      onClick: E[6] || (E[6] = (M) => D(null, { title: e.appSuite, href: e.appSuiteUrl }, M))
                    }, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", J0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1),
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)
                    ], 8, Z0)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", e1, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", t1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1),
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)
                    ]))
                  ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                  e.enableCollapsibleSidebar ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", a1, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                      id: "btn-collapse-toggle",
                      title: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? "Expand sidebar ( [ )" : "Collapse sidebar ( [ )",
                      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["btn btn-ghost btn-sm px-1 py-1 text-gray-700 dark:text-gray-300", { "w-full": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d), "w-auto": !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) }]),
                      onClick: C
                    }, [
                      ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", r1, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", s1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", l1))
                      ]))
                    ], 10, n1)
                  ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ]),
                e.appSuite || e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                  key: 0,
                  ref_key: "mobileMenuOpenBtn",
                  ref: f,
                  class: "flex md:hidden gap-1 focus:outline-none",
                  onClick: E[7] || (E[7] = (M) => s.value = !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s))
                }, [
                  o1,
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", i1, [
                    e.appSuitePrefix ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", c1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    e.appSuite ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", d1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    e.appName && !e.hideAppNameInMobileHeader ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                      key: 2,
                      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["text-sm text-left font-bold text-gray-200 text-ellipsis overflow-hidden whitespace-nowrap w-40 mt-auto mr-auto", [e.appSuite ? "ml-1" : ""]])
                    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 3)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                  ])
                ], 512)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", u1, [
                  e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", f1, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "app-icon", { classList: "block w-4 h-4 my-auto flex-shrink-0" }, () => [
                      e.hideAppIcon ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                        key: 0,
                        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["block w-4 h-4 my-auto flex-shrink-0", { "mx-auto": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) }])
                      }, [
                        e.appUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                          key: 0,
                          href: e.appUrl,
                          onClick: E[8] || (E[8] = (M) => D(null, { title: e.appName, href: e.appUrl }, M))
                        }, [
                          e.appIconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                            key: 0,
                            src: e.appIconUrl,
                            alt: e.appName,
                            class: "w-4 h-4"
                          }, null, 8, y1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", m1, v1)),
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", b1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 1)
                        ], 8, h1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 1 }, [
                          e.appIconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                            key: 0,
                            src: e.appIconUrl,
                            alt: e.appName,
                            class: "w-4 h-4"
                          }, null, 8, p1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                          w1,
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", x1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 1)
                        ], 64))
                      ], 2))
                    ]),
                    e.appUrl && e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                      key: 0,
                      href: e.appUrl,
                      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["my-auto hover:underline", { "sr-only": e.enableCollapsibleSidebar && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) }]),
                      onClick: E[9] || (E[9] = (M) => D(null, { title: e.appName, href: e.appUrl }, M))
                    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 11, k1)) : e.appName ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                      key: 1,
                      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["my-auto", { "sr-only": e.enableCollapsibleSidebar && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) }])
                    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appName), 3)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                  ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ])
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", M1, [
              e.sidebarNavigationItems.length > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("nav", C1, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "sidebar-navigation", {
                  items: e.sidebarNavigationItems,
                  collapsed: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d)
                }, () => [
                  ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.sidebarNavigationItems, (M) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, {
                    key: M.id
                  }, [
                    M.items ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vt, {
                        placement: "right",
                        disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d)
                      }, {
                        trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                            href: M.href,
                            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex item-center relative w-full gap-2 pl-2 px-3 py-2 border-l-4", {
                              "border-transparent text-gray-700 hover:text-gray-900 dark:text-gray-300 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-800": !p(M) || w(M),
                              "border-red-600 bg-gray-25 dark:bg-gray-900 hover:bg-gray-50 dark:hover:bg-gray-800": p(M) && (!w(M) || (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d))
                            }]),
                            onClick: (H) => b(M)
                          }, [
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "sidebar-navigation-item-icon", {
                              item: M,
                              classList: "inline-block w-4 h-4 my-auto flex-shrink-0"
                            }, () => [
                              e.hideSidebarIcons ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                                key: 0,
                                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-block w-4 h-4 my-auto flex-shrink-0", { "mx-auto": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) }])
                              }, [
                                M.iconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                                  key: 0,
                                  src: M.iconUrl,
                                  alt: M.title,
                                  class: "w-4 h-4"
                                }, null, 8, $1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", L1, D1)),
                                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", T1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)
                              ], 2))
                            ]),
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", B1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)),
                            h(M) && !w(M) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                              key: 1,
                              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-block my-auto", {
                                "absolute bottom-1 right-3": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d)
                              }])
                            }, [
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", A1, [
                                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", V1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(h(M)), 1)
                              ])) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", P1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(h(M)), 1))
                            ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", O1, [
                              w(M) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", H1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", N1))
                            ]))
                          ], 10, S1)
                        ]),
                        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)
                        ]),
                        _: 2
                      }, 1032, ["disabled"]),
                      !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) && w(M) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(M.items, (H) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                        key: H.id,
                        href: H.href,
                        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex relative gap-2 px-3 py-2 border-l-4", {
                          "border-transparent text-gray-700 hover:text-gray-900 dark:text-gray-300 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-800": !H.active,
                          "border-red-600 bg-gray-25 dark:bg-gray-900 hover:bg-gray-50 dark:hover:bg-gray-800": H.active,
                          "pl-8": !e.hideSidebarIcons,
                          "pl-4": e.hideSidebarIcons
                        }]),
                        onClick: (P) => D(M, H, P)
                      }, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", I1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(H.title), 1),
                        H.badgeCount ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", R1, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", F1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(H.badgeCount), 1)
                        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                      ], 10, E1))), 128)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                    ], 64)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(vt, {
                      key: 1,
                      placement: "right",
                      disabled: !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d)
                    }, {
                      trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
                          href: M.href,
                          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex relative gap-2 pl-2 px-3 py-2 border-l-4", {
                            "border-transparent text-gray-700 hover:text-gray-900 dark:text-gray-300 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-800": !M.active,
                            "border-red-600 bg-gray-25 dark:bg-gray-900 hover:bg-gray-50 dark:hover:bg-gray-800": M.active
                          }]),
                          onClick: (H) => D(null, M, H)
                        }, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "sidebar-navigation-item-icon", {
                            item: M,
                            classList: "inline-block w-4 h-4 my-auto flex-shrink-0"
                          }, () => [
                            e.hideSidebarIcons ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                              key: 0,
                              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-block w-4 h-4 my-auto flex-shrink-0", { "mx-auto": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) }])
                            }, [
                              M.iconUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("img", {
                                key: 0,
                                src: M.iconUrl,
                                alt: M.title,
                                class: "w-4 h-4"
                              }, null, 8, q1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", G1, j1)),
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", U1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)
                            ], 2))
                          ]),
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", K1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)),
                          M.badgeCount ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
                            key: 1,
                            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-block my-auto", {
                              "absolute bottom-1 right-3": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d)
                            }])
                          }, [
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", X1, [
                              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Q1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.badgeCount), 1)
                            ])) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", _1, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.badgeCount), 1))
                          ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                        ], 10, W1)
                      ]),
                      default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(M.title), 1)
                      ]),
                      _: 2
                    }, 1032, ["disabled"]))
                  ], 64))), 128))
                ])
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ]),
            k("user-section") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Z1, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "user-section", { collapsed: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) })
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ])
        ], 2),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", J1, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("main", e2, [
            e.hidePageHeader ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", t2, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", a2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "page-title", { classList: "text-xl font-light text-gray-900 dark:text-gray-100" }, () => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", n2, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.pageTitle), 1)
                ])
              ]),
              k("page-header") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", r2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "page-header")
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ])),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", s2, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "default")
            ])
          ]),
          k("footer-top") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", l2, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "footer-top")
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("footer", o2, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", i2, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", c2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Bt, {
                  href: "https://sei.cmu.edu",
                  title: "Software Engineering Institute",
                  class: "my-auto text-black dark:text-white",
                  external: ""
                }, {
                  default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Pt, { class: "h-10" }),
                    d2
                  ]),
                  _: 1
                })
              ]),
              k("footer-middle") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", u2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", f2, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "footer-middle")
                ])
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", h2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", y2, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "footer-right", { year: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m) }, () => [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", m2, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", g2, " © " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)) + " Carnegie Mellon University ", 1),
                      v2
                    ])
                  ])
                ])
              ])
            ])
          ]),
          !e.hideActionBar && k("action-bar") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("aside", b2, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(A.$slots, "action-bar")
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ])
      ])
    ]));
  }
});
La.install = (e) => {
  e.component(La.name, La);
};
const p2 = {
  "data-id": "sds-layout-app-simple",
  class: "flex flex-col h-screen dark:text-gray-50"
}, w2 = { class: "bg-white dark:bg-gray-950 border-b border-gray-100 dark:border-gray-800 px-4 py-2 flex flex-shrink-0" }, x2 = { class: "my-auto" }, k2 = {
  key: 0,
  class: "block"
}, M2 = ["href"], C2 = { class: "text-red-600 dark:text-red-400 font-bold" }, S2 = {
  key: 1,
  class: "flex"
}, $2 = { class: "text-red-600 dark:text-red-400 font-bold" }, L2 = { class: "ml-auto my-auto items-center flex gap-2 flex-shrink-0" }, z2 = { class: "flex grow flex-shrink-0" }, D2 = { class: "bg-gray-50 dark:bg-black flex flex-col items-stretch grow min-w-0" }, T2 = { class: "grow pb-4" }, B2 = {
  key: 0,
  class: "bg-gray-25 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-800 px-4 py-3 sticky top-0 z-40 flex flex-col gap-4 md:flex-row"
}, P2 = { class: "grow my-auto flex flex-row gap-2" }, A2 = { class: "text-xl font-light text-gray-900 dark:text-gray-100" }, V2 = {
  key: 0,
  class: "flex-shrink-0 my-auto flex flex-col md:flex-row gap-2"
}, O2 = { class: "p-4" }, H2 = {
  key: 0,
  class: "px-4"
}, N2 = { class: "text-xs p-4" }, E2 = { class: "border-t border-gray-200 dark:border-gray-800 flex flex-col lg:flex-row gap-4 pt-4" }, I2 = { class: "flex-shrink-0 flex order-2 lg:order-1" }, R2 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Software Engineering Institute", -1), F2 = {
  key: 0,
  class: "flex-shrink flex lg:mx-auto order-1 lg:order-2"
}, W2 = { class: "my-auto" }, q2 = { class: "flex-shrink-0 flex lg:ml-auto order-3" }, G2 = { class: "my-auto" }, Y2 = { class: "flex flex-col" }, j2 = { class: "ml-auto" }, U2 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", { class: "ml-auto" }, " Proprietary. SEI Internal Use Only ", -1), K2 = {
  key: 1,
  class: "bg-blue-500 text-white dark:bg-blue-700 p-4 sticky bottom-0 z-40"
}, za = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutAppSimple",
  __name: "LayoutAppSimple",
  props: {
    /**
     * The app suite name's prefix (styled in red) for the layout.
     */
    appSuitePrefix: { type: String, default: "SEI" },
    /**
     * The app suite name for the layout.
     */
    appSuite: { type: String, default: null },
    /**
     * The app suite url for the layout.
     */
    appSuiteUrl: { type: String, default: null },
    /**
     * The app name for the layout.
     */
    appName: { type: String, default: null },
    /**
     * The page title for the layout.
     */
    pageTitle: { type: String, default: null },
    /**
     * Determines whether to hide the page header.
     */
    hidePageHeader: { type: Boolean, default: !1 },
    /**
     * Determines whether to hide the action bar slot.
     */
    hideActionBar: { type: Boolean, default: !1 }
  },
  emits: ["navigate"],
  setup(e, { emit: t }) {
    const a = t, n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.useSlots)(), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (/* @__PURE__ */ new Date()).getFullYear()), s = (f) => !!n[f], u = (f, v, g) => {
      a("navigate", { group: f, item: v, event: g });
    };
    return (f, v) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", p2, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", w2, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("header", x2, [
          e.appSuite ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("h1", k2, [
            e.appSuiteUrl ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
              key: 0,
              href: e.appSuiteUrl,
              class: "flex hover:underline",
              onClick: v[0] || (v[0] = (g) => u(null, { title: e.appSuite, href: e.appSuiteUrl }, g))
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", C2, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)
            ], 8, M2)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", S2, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", $2, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuitePrefix), 1),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.appSuite), 1)
            ]))
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ]),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", L2, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "user-section")
        ])
      ]),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", z2, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", D2, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("main", T2, [
            e.hidePageHeader ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", B2, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", P2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "page-title", { classList: "text-xl font-light text-gray-900 dark:text-gray-100" }, () => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", A2, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.pageTitle), 1)
                ])
              ]),
              s("page-header") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", V2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "page-header")
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ])),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", O2, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "default")
            ])
          ]),
          s("footer-top") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", H2, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "footer-top")
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("footer", N2, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", E2, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", I2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Bt, {
                  href: "https://sei.cmu.edu",
                  title: "Software Engineering Institute",
                  class: "my-auto text-black dark:text-white",
                  external: ""
                }, {
                  default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Pt, { class: "h-10" }),
                    R2
                  ]),
                  _: 1
                })
              ]),
              s("footer-middle") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", F2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", W2, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "footer-middle")
                ])
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", q2, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", G2, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "footer-right", { year: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) }, () => [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Y2, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", j2, " © " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)) + " Carnegie Mellon University ", 1),
                      U2
                    ])
                  ])
                ])
              ])
            ])
          ]),
          !e.hideActionBar && s("action-bar") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("aside", K2, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "action-bar")
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ])
      ])
    ]));
  }
});
za.install = (e) => {
  e.component(za.name, za);
};
const _2 = {
  "data-id": "sds-layout-sei-external-wordmark",
  viewBox: "0 0 728.14 64.49"
}, X2 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode)('<polygon class="cls-1" points="213.53 18.71 213.53 45.54 218 45.54 218 47.31 200.12 47.31 200.12 45.54 204.59 45.54 204.59 20.6 201.12 20.6 201.12 18.71 213.53 18.71"></polygon><path class="cls-1" d="M36.93,1.38H35.31c-.07,1.38-.79,2-2.17,2C30.38,3.35,26.35,0,21.62,0,8.15,0,0,13.27,0,25S7.75,48.37,20.76,48.37c7.88,0,10.84-3.75,12.94-3.75,1.38,0,1.63,1.22,1.63,2.69h1.78V31.21H35.34l-.39,2.23C34,38.77,29.9,46.63,21.42,46.63,13.93,46.63,11,40.15,11,24.18,11,7.43,15,1.79,21.62,1.79c7.49,0,12.64,8.4,13.69,15.1h1.62Z"></path><path class="cls-1" d="M60,39.6c-.13,3.44-2.07,6.25-5.12,6.25-4.41,0-4.6-3.72-4.6-6.56,0-3.44.39-5.7,4.6-6.16L60,32.61ZM71.8,41.74c0,1.68-1.11,3.63-1.84,3.63-1.17,0-1.43-1.23-1.43-3.24V27.22c0-7.39-6.94-9.2-13.61-9.2-6.48,0-11.21,3.17-11.21,6.8A3.91,3.91,0,0,0,47.92,29a3.69,3.69,0,0,0,4-3.89c0-3.3-3.42-3.34-3.42-3.42,0-1.47,3.81-1.94,6-1.94,4.86,0,5.51,1.79,5.51,5.68v5.44l-6.35.52c-5.9.45-12.32,2-12.32,8.75,0,5.64,5.06,7.91,10,7.91,2.53,0,7-1,8.69-4.08a6.65,6.65,0,0,0,6.48,4.08c4.21,0,6.93-2.53,6.93-6.35Z"></path><polygon class="cls-1" points="674.53 18.61 674.53 45.45 679 45.45 679 47.22 661.11 47.22 661.11 45.45 665.58 45.45 665.58 20.5 661.11 20.5 661.11 18.61 674.53 18.61"></polygon><path class="cls-1" d="M286,32.45,296.7,1.73h14.81l0,1.83h-4.24v42h4.24v1.79H293.68V45.53H298V4h-.13l-15.1,43.29H281L265.53,3.25h-.13V40c0,5.25,1.36,5.53,4.86,5.53h.2v1.79H259.25V45.53h0c3.7,0,4.39-2.16,4.39-4.95v-37h-4.39V1.69h16.26Z"></path><path class="cls-1" d="M321.83,29.87V25.52c0-4.34,1.88-5.7,4.08-5.7,3.11,0,4.08,2.14,4.08,5.7v4.36Zm0,1.76h17.89c-.07-7-6.55-13.74-13.35-13.61-7.65,0-14.26,6.61-14.26,15.36,0,8.43,6.16,14.71,14.45,14.71,8,0,11.93-4.93,13.35-11.34h-1.77c-1.42,6-4.59,9.45-9.64,9.45-6,0-6.68-4.72-6.68-9.13Z"></path><path class="cls-1" d="M591.08,29.77V25.41c0-4.34,1.88-5.7,4.08-5.7,3.11,0,4.08,2.14,4.08,5.7v4.36Zm0,1.76H609c-.07-7-6.55-13.74-13.35-13.61-7.65,0-14.26,6.61-14.26,15.36,0,8.43,6.16,14.71,14.45,14.71,8,0,11.93-4.93,13.35-11.34H607.4c-1.42,6-4.59,9.45-9.64,9.45-6,0-6.68-4.72-6.68-9.13Z"></path><polygon class="cls-1" points="339.83 1.79 339.83 3.44 344.31 3.44 344.31 45.48 339.83 45.48 339.83 47.32 357.72 47.32 357.72 45.48 353.25 45.48 353.25 1.79 339.83 1.79"></polygon><polygon class="cls-1" points="358.97 1.79 358.97 3.44 363.44 3.44 363.44 45.48 358.97 45.48 358.97 47.32 376.86 47.32 376.86 45.48 372.39 45.48 372.39 1.79 358.97 1.79"></polygon><path class="cls-1" d="M397.43,39.47c0,4.86-2,6.87-5.31,6.87s-5.31-2-5.31-6.87V26.71c0-4.86,2-6.87,5.31-6.87s5.31,2,5.31,6.87Zm10.11-6.41c0-8.88-6.87-15-15.42-15s-15.42,6.16-15.42,15,6.87,15,15.42,15,15.42-6.16,15.42-15"></path><path class="cls-1" d="M454.05,3.28h4.53V32.07c0,10,6.93,16.14,17.5,16.14,11.93,0,17.11-6.29,17.11-15.81V7.78c0-3.76,1-4.5,3.37-4.5h1.31V1.54h-11.4V3.28h.82c3.3,0,3.76,1,3.76,4.76V33c0,8.82-5.47,12.83-11,12.83-9.46,0-11.34-6.35-11.9-14.65V3.28h4.25V1.54H454.05Z"></path><path class="cls-1" d="M566.34,47.95h1.75l9.59-22.68c1.94-4.24,3-4.77,4.47-4.84h.58V18.65H572.62v1.79h1.23c1.88,0,2.74-.12,2.74,1.56a10.5,10.5,0,0,1-1.1,3.94l-4.4,10.37L564,20.45h3.6V18.65H551.37v1.79h3Z"></path><path class="cls-1" d="M638.55,47.95h1.54a2.07,2.07,0,0,1,2.29-1.55c1.69,0,3.7,1.55,7.32,1.55a10.57,10.57,0,0,0,10.37-10.63c0-7.91-5.44-8.49-12.38-9.46-3.63-.52-5.68-1-5.68-3.89,0-3,2.66-4.32,6.16-4.32,4.86,0,6.75,3.22,8.36,7.44h1.53v-9.2h-1.47c0,.78-.67,1.43-1.9,1.43-2.08,0-3.76-1.43-6.74-1.43a9.63,9.63,0,0,0-9.66,9.66c0,8.36,6.35,9.08,11.28,9.66,4.67.58,6.35.88,6.35,3.86,0,3.43-2.85,5-6.35,5-4.92,0-8.31-4.26-9.48-9h-1.54Z"></path><polygon class="cls-1" points="549 18.61 549 45.45 553.47 45.45 553.47 47.22 535.58 47.22 535.58 45.45 540.05 45.45 540.05 20.5 535.58 20.5 535.58 18.61 549 18.61"></polygon><path class="cls-1" d="M540.06,9.67a4.46,4.46,0,1,0,4.46-4.47,4.45,4.45,0,0,0-4.46,4.47"></path><path class="cls-1" d="M665.57,9.67A4.46,4.46,0,1,0,670,5.2a4.45,4.45,0,0,0-4.46,4.47"></path><path class="cls-1" d="M149.79,29.86V25.51c0-4.34,1.88-5.7,4.08-5.7,3.11,0,4.08,2.14,4.08,5.7v4.35Zm0,1.76h17.89c-.07-7-6.55-13.74-13.35-13.61-7.65,0-14.26,6.61-14.26,15.36,0,8.43,6.16,14.71,14.45,14.71,8,0,11.93-4.93,13.35-11.34H166.1c-1.42,6-4.59,9.45-9.64,9.45-6,0-6.68-4.72-6.68-9.13Z"></path><path class="cls-1" d="M228,29.86V25.51c0-4.34,1.88-5.7,4.08-5.7s4.08,1.34,4.08,5.7v4.35Zm0,1.76h17.89c-.07-7-6.55-13.74-13.35-13.61-7.65,0-14.26,6.61-14.26,15.36,0,8.43,6.16,14.71,14.45,14.71,8,0,11.93-4.93,13.35-11.34h-1.77c-1.42,6-4.59,9.45-9.64,9.45-6,0-6.68-4.72-6.68-9.13Z"></path><path class="cls-1" d="M529.84,45.46V28c0-7-3-10.27-9.14-10.27-4.35,0-8.75,2.49-10.5,6.25h0V18.7H496.79v1.75h4.47v25h-4.47v1.75H514V45.46H510.2V28.36c.56-2.41,3.61-8,7.15-8,2.35,0,3.55.81,3.55,5.16v19.9h-3.7v1.75h17.11V45.46Z"></path><path class="cls-1" d="M420.93,18.8v5.25h0c1.75-3.76,6.15-6.25,10.5-6.25,6.16,0,9.14,3.27,9.14,10.27v17.5H445v1.75H427.93V45.57h3.7V25.67c0-4.35-1.19-5.16-3.55-5.16-3.54,0-6.59,5.55-7.15,8v17.1h3.83v1.75H407.52V45.57H412v-25h-4.47V18.8Z"></path><path class="cls-1" d="M135.52,45.56V28.06c0-7-3-10.27-9.14-10.27-4.35,0-8.75,2.49-10.5,6.25h0V18.79H102.47v1.75h4.47v25h-4.47v1.75h17.24V45.56h-3.83V28.46c.56-2.41,3.61-8,7.15-8,2.35,0,3.55.81,3.55,5.16v19.9h-3.7v1.75H140V45.56Z"></path><path class="cls-1" d="M204.62,9.84a4.46,4.46,0,1,0,4.46-4.47,4.45,4.45,0,0,0-4.46,4.47"></path><path class="cls-1" d="M718,18.62V20.5c2.76,0,4,.25,4,1.5a10.5,10.5,0,0,1-1.1,3.94l-4.4,10.37-7-15.81h3.68V18.62H690.81V4.72h-1.17c0,6.87-4.67,13.93-11.21,13.93v1.85h3.44V40.56A7.1,7.1,0,0,0,689,47.95a9.22,9.22,0,0,0,8.62-5l-1.39-.76c-.78,1.17-1.81,2.72-3.43,2.72-1.3,0-2-.92-2-3.06V20.51h9l11.84,27.31-4.1,9.65v0h0a.55.55,0,0,1-.49.32.54.54,0,0,1-.51-.37v0a4.46,4.46,0,1,0-6.3,5.18h0l.14.06.26.12a4.51,4.51,0,0,0,1.63.34c3.76.32,5.69-2.46,7-5.29.3-.64.57-1.29.83-1.9.57-1.37,1.56-3.73,2.73-6.48h0L714,46.82h0l9.12-21.55c1.94-4.24,2.69-4.78,5-4.78h0V18.62Z"></path><path class="cls-1" d="M95.94,17.71a9.29,9.29,0,0,0-8.56,6.09h-.13V18.87H74v1.81h4.47V45.62H74V47.4H93.34V45.62h-6v-14c0-4.17,1.09-8.44,3.83-10.79a.53.53,0,0,1,.85.5h0a6.22,6.22,0,0,0-.35,1.85,4.19,4.19,0,0,0,4.41,4.21,4.68,4.68,0,0,0,4.93-4.73C101.06,19.59,99,17.71,95.94,17.71Z"></path><path class="cls-1" d="M193.49,19.82c.13,0,.29-.11.39,0a.27.27,0,0,1,0,.35h0a2.78,2.78,0,0,0-.24,2.38,2.74,2.74,0,0,0,2,1.77,2.79,2.79,0,0,0,3.47-2.72,3,3,0,0,0-1.53-2.53,5.29,5.29,0,0,0-2.85-.75,7.68,7.68,0,0,0-4.76,2h0q-.44-.32-.92-.6A14,14,0,0,0,181.83,18c-5.44,0-11.28,3.56-11.28,9.46a8.42,8.42,0,0,0,5.38,7.91v.13A7.08,7.08,0,0,0,169.45,43c0,3.24,1.49,5.7,4.22,6.48v.13c-2.59.71-5.58,3.31-5.58,6.42,0,4.8,5.64,8.49,12.83,8.49,9,0,14.91-6.09,14.91-14,0-6.29-3.11-9.14-9.46-9H175.61c-1.62,0-2.7-.07-2.7-1.82s2.49-3.37,4.95-3.37a4.87,4.87,0,0,1,1.32.39,8.35,8.35,0,0,0,2.66.39c5.57,0,11.54-3.18,11.54-9.33A9.62,9.62,0,0,0,191,21.61a.22.22,0,0,1,0-.33,13.23,13.23,0,0,1,1.69-1.1,3.64,3.64,0,0,1,.76-.35Zm-8.61,29.82c6.48,0,8.2.27,8.2,4.23,0,4.73-5.8,9.07-12.34,9.07-5.83,0-8.63-3.58-8.76-6.69,0-2.85,1.42-4.73,3.17-6.61ZM186,27.51c0,7.53-1.75,7.78-4.08,7.78-2.59,0-4-.5-4-8,0-5.25.58-7.48,4-7.48,3,0,4,.2,4.08,7.66Z"></path><path class="cls-1" d="M631.67,17.45a9.29,9.29,0,0,0-8.56,6.09H623V18.61H609.7v1.81h4.47V45.36H609.7v1.77h19.38V45.36h-6v-14c0-4.17,1.09-8.43,3.82-10.78a.53.53,0,0,1,.85.5v0a6.23,6.23,0,0,0-.34,1.83,4.19,4.19,0,0,0,4.41,4.21,4.68,4.68,0,0,0,4.93-4.73C636.79,19.33,634.72,17.45,631.67,17.45Z"></path>', 26), Q2 = [
  X2
], jt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutSeiExternalWordmark",
  __name: "LayoutSeiExternalWordmark",
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", _2, Q2));
  }
}), Z2 = { "data-id": "sds-layout-sei-external-header" }, J2 = { class: "bg-red-500" }, ef = { class: "container px-4 py-2 mx-auto md:px-8" }, tf = {
  href: "https://www.cmu.edu/",
  target: "_self",
  class: "block w-80"
}, af = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Carnegie Mellon University", -1), nf = { class: "text-gray-700 bg-white" }, rf = { class: "container px-4 pt-8 mx-auto space-y-8 md:px-8" }, sf = { class: "pb-6 space-y-4 border-b" }, lf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("h1", { class: "text-5xl font-extralight" }, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
    href: "https://sei.cmu.edu",
    class: "break-words hover:text-red-500"
  }, "Software Engineering Institute")
], -1), of = {
  key: 0,
  class: "text-2xl text-gray-500 break-words"
}, Ut = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutSeiExternalHeader",
  __name: "LayoutSeiExternalHeader",
  props: {
    /**
     * An object containing various properties that display in the header.
     */
    page: {
      type: Object,
      default: () => ({})
    }
  },
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("header", Z2, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", J2, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", ef, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", tf, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(jt, { class: "text-white fill-current h-7" }),
            af
          ])
        ])
      ]),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", nf, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", rf, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", sf, [
            lf,
            e.page.organization ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("h2", of, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.page.organization), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ])
        ])
      ])
    ]));
  }
}), cf = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABN8AAABQCAMAAAAeGCORAAACu1BMVEVMaXHZ2dnZ2dnZ2dmXl5fZ2dlVVVXV1NaamppVVVVVVVVVVVX///9VVVW/KR7VRDcAYeT/CYdMkqXRQzjNRDjx8fHv7+8p1dnHRTrw+PrARTr+/v88OvHbRTi9HxOhoaEuzdUdqec5RvAbtub3+vvhREvGPDE0X+rC3/Dx9PUez98kwd05Ue7ZR1g3Wey+JBfCWXn/+fU1wc+yYohtg7MWw+f/8u45mcvPUWj+/fxQNOsua+smnOBzLePX3OQoeuqjbZWzKbaoKsFhL+kdmeq4PDKQK9R8OsuTdqD+5No+ssiDK90jiupeX1+dKcxkPdf+0Lsvksjiw8T/7ONCQUGUOLxfd6uEfqmpNqn+2cxBPujPamLUjIbfubiSQp3ZrKksi916jKv/qnefTZBomLbOe3UvsdRhXr3nWVK7NpZVpb7/xaMzfNn/to1PS9rYn5o9bc/KWlFNY8WDRqtxT7WludK6xM/0sa+gzOqGV6Hnz85yYa52tuL/jUQXFxdGn8XBMSa/yd3/gTPldnD/nV/qioXQOHNUl6m8Ukmxs7Vort5YkbzlmsD/bBH/dx9XbrkZbeP8IJCNOWEqZdP/XApcc9UwPtq4t9+PpbjvnJs2XredPHr3NplOZIF3OHegsuRJQr9pNKlgmd7b4fFVRYVIX6DLtsiHq968a2TuaK2HkeinM1IAerwAe7zrPjvuPjfnNUngy6fhNlbSixMAdbkAervyOzMSg8Dn3NrZ2dnmQUAAd7rdT0PbNGPasWsEAQHFKp69Kari7/heqd3cvIXcRzrdSz/i2MeLi4vOL4TdTUHKLJHcSDsiIiLcSj2LwuXdUETQgwHyNzbsNT0AAADWLXTlLScxMTHl5eX/VQA6WJmz1+3/ZgAiisTIycnVlzDXo0vQ5vUNDQ0pRGeqqap7e3u9vb0rKytra2sUUHcwAAAADHRSTlMA2nhQLqnj/RaJVL7yjhkNAAApd0lEQVR4XuzZ11LrMBCA4bz/s6zknl7ondN7r8BjoNVaYuNgMhNERiH723E8dqILLr5Zh86XwHVs+4GjVcevWhubzlhHdS98F4vRqhUFFaXsCw+qcQcAD+7U31T2ACa6Sqt+CBytuoOdY6em96bJZJLnaZq+pd64ugsl3aSR1rqDfQtcx/Y3cLTqO9dsNvuzaua7bhladRA4WvVT4GjVz4F7or9AHG2Ub0SZ+LbDgat9S4k3B1wXN15CG08nm+hboOLzTXwT38Q37NzG5reczW+uedvcvpHzm/gmvolvZw/6drHcN6hhA+VdA+IOr4D9gAdO0acBdwB3eT2+kXCNB9TU8oYb1rWvu8kNWxjfIp7fxDfxTXxrH9+eqW+77AG19Qc4Lxzi1ija+U18E9/EN/Ft9x7gcjbA4cuU4LZYrL+/iW/im/i28uPpct8ossqfz58Bwgd4BLrGKQQF2JP7VgPHfJs0BzjcUbiECac1HuZow7f4fRPfxDfxbbw1vnHgTh1wfoCjEtzMrk2J5pFrWGS+iW/im/gW4PF0433zwLX8h0GbzR50a0QbFp1v4lv/ODuYTg+y4774Jr4x3h7tm1IVWLFGIzyC8jdIM4BKAeDnlL1Iqfqraj2/v1H8CZUPcDTBacKNhBuytGsLfbv8/8938tFfnkXmW1a8poqf00x8E99WfTw9bPjmPCvLqtcryxFUProBcDfdWeX8G/G3Vt/4AMeBG6aGtRo4KxruNm3PGXHb5dvl1YD14zpS3/rIG1UUxa9MfBPfWnhb5tuh941Xfn/5e2/v636vZBfBI6dwB6KuotyZwtbkGwnXGODy1DY0O224+46GzjvXVvl2M5jrJFLfbtm3w9ckwjiA41VbbfVMgAiQ0AA8KeAYgzADEBQCBIg1YSTbGA4CR0QELMdY1BIFBvQ6gV7F3nmQaGTuZmSmtSIbEAQSm/0l/e7uued57rgjkbtzpt/nNucdDBjw4Xfes8IBrQgdNZ33beTbzrW1rVCtVnv1KhTaWlu71l/fxJ5uT6lvLGOlbTeS69wukXvOvOqb9EpfBOa9U/NbOBymwH01Aw6WfHAVDoLv+1ylsl9pwBp439735tvnd5ouq+f/HC/fmgc64A7rDvs28m1+y4c0rTnlm5XjG6T3TeINqbl/l+iDBfjCvgkKbDCpkQS8SU7KAd8gZoL7AuE9InLca7I0/YADiFM6Pr4lXsglRr7h6tg1ClzVSd9Gvu1sXUKo777peevBN+iEnIAD3m4zcl+R6cL/WkolIz+zd6gCmeWc8O0DAU4Z4LIUOA4OdnE8LCIcJ+qAq/TbN/z3DnXv25//2TeoWSg0y9JD1EMMXLHqnG8j3+YvInSsfBOt8g2GsFILMT0hH8GBaTRlWlOhE3TbRCB7fcNpgctm98gIpzDHSwu3kEnFY+BcUkKOneHgpb++vUQj30wrHGHh6oPr2/iYHWadH7PLt3kf6qtvomgNb6xvlC6hhphaJSIaAxskENnoJSXBbt8ixLewDNwq9u2nDBy/B6jRBQXTubnoDIIuwDvgDVJ4k4kz9A2hmVh09t7K4+e2+5YYat/Kc8vLS+V/bBYpQoVB9Q1+6/iE9b5NTU1O2OLbzlVkh2+b7Rq46e6sb9Nz2wa+iSa89TK+Ud+IYru/3YipjX1jbkjhwD8KinJ5GT3nnp9GIpFwBAtHgIOy6gjHwyEtKJ1LbQSQmp9P8nBwnMhxZL+IsW+kwOzKM1t9ezS8vm08eOh3TXtd/sVf5jUV4A7Lg+vbu7OnbPBt6sykHb6FkA2+bXaQmq9NzrUMfNvfF3vgrTvfoN23Gt/WS/TWFBSjYdcE+vRBIJft9k2JALdKJjhoLysDBwUzqY3YDGLzwzCX5CEywkGmvtFi9x/b59vVYfVtaeGp1zvtgqa9C7pr9SOo3mSBqw6ub9DJ09b7BsKds9y3BOrRtxZoZdb6JcRU24TRrdVBtY+GvnXPm358M/ctLycz1TG4P6UJ9CZUINBp6MtL2ewbFe4Oe4uqBLbdzW1EAzeQPj8fDPJBPqkIB3XpGxRbeW6Pbwk0nL7NLbgANzXvsuZiFW8OqZbJhrhisTnAvkHjY5b7Bp0fs9i3UK++1XzAlnFtpM3d7vgkXIx8a2h8E1neGt+/eTyeT98a3Y9v+ucLb3TPF66X8F6QvIKabrcvtk766s63SjqTyaVSqdl4PBqNBiA8Yc0EIDgVj8/C5Vwmk66Y+XZL5S0SVoRbhQhwwcWlMtBm2M0gBMDxFDhYnLlvbDfuPbPDt19D6Vt58anXxaQb4IoHuMOmyl3xoD7Yvln8MdyU2uSElb7Nox592wS2TIBbR4a1Pxr6ZsJbw+P5kUxLJUWP53u345t+ftN+ANfexcNZ3mgvb165KJCTNGPf0n/Ju/+XNs44gOMAZa30uU4HhpzhIkAQA5REFKcAbReYIJLiYiIRDbKMQVorMiBNELtNVVRRiSKgRAEKbSn1gK0ZJqQMmq21E1cdDBomq03YbP+MPfdc7vLc9TnPXB7rSt8WzLf++uLzPM9dbAcl1D6u4RvMdVUe4R77HyPhCntwcwCl7ZuaOLJvxDrHqPv2JfgQfQuY4eyG5zBn8Q7+kDpIohUqevh++0Z5G46R+6iCom9ho75FgRZwszZAKicsUgnrU1w3mbcdbm8ykMxW21l7dTYZmNzjOML4pju/CUglfpEXy5nNhHwVL/ytDt2Jjy9adXyLgBKLkH1DFYETfEPAXRN88+j61isIJ4Sui/tR1ze8gQW6vq3b3qFv7pSif0/Nt74LaHjT9m3rQLi8F/VKXq8+3HqvfaO8DcfI6W/DGV6e2kZXVppQ3Xq+1aPPY2Bh75DaH4nmbATfHhF4e8qFIlkW0mYSgsix2f4Q91xnfCOeL2zwELgMQNX/neA31N+ZJDzgkXYbuGniu7wUybcIKLkI0Te5gnB+vwjcb/DfgwDQ7kGL0+lsKXRRMu5iCb6BhiBN39az4B36lq9NYc38fkq+JXvh8KbKMa0+NU0m4bVvQj/It6T+etK+TZG6zuRhbyj4RnUbjlF0/gwl32wAa/TO8e+vzwEhy/4xxzebTTBO+/reR9jw9mRv1cTaTXh21rT6nDuGb5zSNwRWYnN2P5eLfpdO8yJtsmBoXsO/MwQ9x96GafkWAgYKEXxra5N4Q8D5P/PDrok5j/bNiVICR/ZNu54FSr7hvNH3Lf/CyzDeF3nFa+5ncm++/fN0fPOY5eGNvP+WTEqPEHCv5K8U+fmkffuE0NQKmnPdFHyjug3HqKo4R8O3OwDLhPOmP7+J5dRr1F2gVT1p/03EDeeNGx9mq03qqtnhEKfiTd83kat0Ag5uiQQ2lgkP8Jux0LMiapJ1R32/ZQQYKELyDYWNcBA4Wbi4rm84cUZ8Aw0TlHzrtoMT8i3P1B6eRTs+h88YrU+fjm+BOsSbKmsfki3Q1/uNua7O3DskXxkibrsdIOkM+DbRKRw2tTa0D84b8+26uI6nML/R3YZj5PS34QweL4T/MuAbsEWJh6dk3gjrUww3FDdpYk2kWFMvpzu+Sb7hwPEyZMq76xWv8sg9OK2hp3gavjUDAzWTfUPACcT5rvpcPr+rCFz8LiBnQb7JtcjEtZB8CwYHBzp7GgC5gXkKvq2PAkW2S1I3y/Qt7z5MYR2680Z9C9++EausjN24HU4Rm7u/tlhVtbh2f+64vgXguSkpTzbb/3Wdw2q1OmBW67RHGuAebkmT3IEB30Cx9jEjvu2m3HR8o7wNx0jh23B0fWsqxbcokMvsKheuesenZN+2Jd7sdhMx1jP98VMFb/q+qa1CQ1phXIPACa4V/1BWWvV/jry/PgQMFSL41tHRJhkH87lcEDgxsm8WS6st228SfGuEP7hwKNE3UgsTgz2AUPtC2b7NAM0ulefb639SqmpfG/LtXqxSLnaPoBu0TWpx7li+9X/vuECsr8/swLflrOakdK5g3Ldl6BveQOm+TaVo+UZ5G44hdf5Mmb41AazuUnwbAViZqK5v6BPavm0X4sYx3uysUOG5LfB5jXlHc3zT9i2NxaMzA/yln3jxECKR4PlNPg1/Fy6B24Adcb4wCQw1+bZvHW3Cj5g4wbl8Bd78X6l8s7S22pJ3rzTGl5aGoW+NKGQcEk7HN9T8RGcrUNc1Vq5vN0/KN+/L1Fu99Jbu2+jlSkWXR1OKPGtVitY8+r4FIG/k4NymemGo7PntFhhT+ga6lkv1LUzNN8rbcAy5inOn4BsqA/DY+t2jfdvV9m272E4oK/PG2pOB/qGhQNLOCs8CNTVmMwIOY42DPcHGN5VvPJSL38QqTGXKl6Bu/Kcj+7lMJlcfnf2CR8LxOvdnrQJDrRJ8E5KGOLRI9QmLVDHkm0RbdWrmSnwJFo/HoW+WpUY5p5yeb7CFYBdQ1XDrf+qb92yK0Flvqb6FY5WqYmHS8IaPcHq+eTR50zhxKG//LQiCKt9A83Jpvk2lqPlGeRvuP3bu/rWpK4wDOAygCCe00hcSw1KAEJafSunIyMCtIDUWKcbEzoW2KZuGCbWUUKttakvtIqhYURE2QXzDzQoNIMtYMkWhnV0YdhWQtVKWrSVt/DN2zj333ue+nXvubUMtw+/N1aQ3Ag320+c5L9fByq7t8o03j+BdHV68BANzFn3T7MSKuKTazd8z3SZkz3TE73dFcPVG8lLJ26sTOE9fSLyBbzM0uAjLHnZBVp7Qim4FvoR3bGWfKFF2r879nIWblbN8O4M2lTMM3w5KNVzn/s5OItyXgnDx+I8Cbf7lqlLrdYE2nGM41/Pgm0Y48I2ddLsOuB3pW7mYN0xxwZ5vd2oMckfB226DXDb3LQUzp/x4kmLZ9mzT86d9uCHVFd72fDut8a2KZZUt32AYrpK+wTDcdvrGaUS9s64t+PbheYk3V24ay0bT1pZYJrzRKKu383ietT5RDeUb+EZD7m+JIB/RIbaswuDhbPZveAkL5egEKtu3MDJKEJnHHTbwDUKJI7xR4ahvVY2tt0mIbGJaqG/HWlpa8SEJ18L3DZIOaIHbgb6tlfKMNK7Z8e1cjWHkFjWy2zARU9+SwJvF+u33f/95lpPXvz224NskuoJPOpMQRmGdb6jPjm/H85JvHdiwgmNhbeHIekn7yb49srA2vtRRKFr3DYbhKusbDMNtv2+XGJJt3rf5Vzm/yFvqgqSbE8PWlrxAeVNXcAKHroTvBcs3Ytlht9q3DK7fVL59ov8+Zg9nefOnMePpg5sc4WJ63/YehIT24wOXcJJwgm+YtjjNsfgxKderiG+tNC1AnLFv6bGxSe0k6VSfBrjJneUbZ5lWhx3fPjf27XPp+i1j326Z+ZYw5K1JCGPFCNyxnMTK/oU0Sgt96Vhw8k0Mtet9C07Z8K2Yh/qtMG44gbMOhfFzR9G6bzAMV0nfYBhuu31bWZw7awe4s3zfoHzz50TeZONk3uqcdVC/kff7E75q4I3hG7t+W1TdIA52cj3h7M9qZ0yP/nrGTDh3u4FvNAepcxg4/OiUcg/7NhKXA8Ldxr7dpr6BcTSM9W/BqPbWb2NRda9zZSvzp5/h+Le4PmRhqVwuL5Xl12sbeWY24F1l4Z+Z7F94WMPIQ+hODXOZ7duAbk8WmVOY8DmdTt/EhPBClZ5lyGNL+09vhG8ItvWjfnym37SjqN43FLbu2/fwi6FQeK3Iel6K47Uy4xfZvlV4GM7Bya5t9m0VuVZX3Mhq3HNW6rcULd/qG6Zl3pz0AN5wpAJO8q22munbjNa3jLY/hefaG8XNmK3vDTCXf5wwG5oLGPkGwIXIQUq4kKDb4KDg22BcKxz4BuH4RhPoU7ahU+ouu31qi/uzTm9xfS8tJIpyZeHIswM/iuNF3v76qyzfrtLr11i+XWP6lppoUuPW5Et296Ry5H9vQy7VM9DlhBsm6TZs/fYTuZUI+Mas3YhtZNytD/8dRQED34LWfasC3xaMb1WgnbZ5vmHDNxiGq6RvMAy3vfUbspVZC769PNFQT7vTAWX1pgGOHC809RsGjvKmX9+rq99mMqr+1IuMgzvUTGYzvhHhwjZ9g9AeFYS79x327d4gSVxibiQ+MkJ9GzlAIxPXauIb3PpNwVg/UqZvR/hWei69bsyzA549L3F8G6phZoiWb8xcZvnWpSzfPE3ORKQ+GAy6aYI43vpIt9PTBNMLquSwbjzfSO1GbAujsHAGDH1DY1Z9G1I39uPrpY2LhTJ9QX9FvFVcWKK9qy3fQLhK+gbDcNvo2yKylY+4vkF7Wr+s6k59mjjr6uqqBcv+or5N1NbWki/ofWP3p9wMY99mTHxrZvlGhYsh4zQb+bYPfAvtDYnpxI/BQeLbKPaNZkRInPxBfHtAfKNpBeNYvkECCuHSqnY6vRN8W1e3p/wGtcDx7T7bt/vk+iO2b48YvvV6lLolexuCbiQHFvT0gnDJ7pRKOK5vpHaTbYuhGMu3Pp5vsDYEfIOFNx1QKRflC4Bdoz3fYBiuwr7BMBzft3OImx94vl3yIjsZtuLbGeqbqxd4605F1En1Et+S3wrp9WPfBrqE508NfJsx8i1jyTcXHoEz8w0xfOPdG07v2759e8kDlAsdlIULgW9gnJAHom8AnCwc0zdIFLrUsaCS3ys7wLe30sulKtOBniUYPjL37STbt5N0doGZWwzfnB7oTJM9XtBNQ1y9fO8kj2ciEbHk22T7FNmrQGo34ppwtuO5hWbUbORbMIhQc3iS69uQyreyps8vSs8W5AtLgnYs3yo8DOewll2V8c3Pqd9sN6hn+b7N/ykOv7m6Zd/aBrwuiB/HldtTV+frEr+g2OXQVf1CX79ljOo30p/y84l0MyWbvoFwUYu+0RDgDpEDSrjQoOjbqUF8ENsE3cC30aNCDhyVkOP7BntODSu42Lv3DWZGj+TNAoNFbzm+XWX7dpUOvzFzzdg3mFzwTAz4QTdd3N6IU/Hebiu+9eO+NI3GSN1GXBPPKPWNmdgNc9+OqyeeSyCR8PGvS0+gYCsIzb9t36BJraRvMAxXCd8+4/hmt4BzzVnw7Q9pemFa4ZurASI2r07sm36ParLWYn+a0fs2O7y4ODyrERkv8s2Q2PUNctOibxBCHDFOIk7yDTJ6amSUHKJvRDgROTkM35glXBop8vW7983Bn15Qv6+D41uNScj13SYx9k02y+NMKXRb3ig1looNauByylqvi++bOObWL9RtURQVzwDHNxS4YerbaZVvZe3nuCR+gGuKEqxAYts3yAcV9A2yqwK+neP4ZncEboXr2/w8Wf0mCqb3DbKc9DF8q96kb7OXfsniZM6qxF7Bvm2mP4WcD9j27RB+kITIgXPqrsq3UXLQSPXbx0fl2PMNBdNGkwzNV7i+vfetRzFtIFe/DYUj9BsZd2yoetScD+ZRPQlz36aiU3S8jdZuxDXhDPB9QzGWb7A2BNb3aidqxum4p/4z/z/Wb+4htm+QYWQ5i2a+zYsB3/bofYMIvnn1/WltdbXWt4yRbzMa31yHs08yRL3sHFJkFb91877BABzft0/30QcFDh97qXHkIfh2V8DtGwqc0rcvPqb5Cozj+wbply6HEaSP69v7/jThkXn7j7xzfWkrzeM4CwsC6AhkEprGGpBD6KGAKMViKX0nYEHG1lDIRVLF2FLtxbIdxTXq2JZWS+0uVrctM3RpGXZmSN51WbM7EKgUAjQtQBhDS4UJGvtn7HPN85zzOzePUyP1e45JPFHQg3z83S4cb4F8AXtzWIQS8j8SikPRZw/5JudMabyN2W4dlG2Cb1ZKWfCtTvCNuaNaB7VcB96g+iLjb4+t+AbXADqvDoH7ZYR+nVRZ9Zud/fb1WILoHO7POkdfjyG+NUK+2cff1l5meC7ig7bEN+OabyKBas+3k0IIcphvSBRwf2F8u1jVX/GBdP5HxLf3Vb4dHxgQjLPjGwTcAzlUOGfDt4OfX+AGWWtoleOt1MDgxghXqJMBF2vWDUqCfBO+KbPbujnTqnzrrO+05lsE8g2ab9kesJtnGpN5I9sA3sD6IvOnx835Btc422vCCd9EfiEp5xe8RD6vHH9DGQas2Tjpz5oln3gasWz7FzIZXX3Iq8z/+AZ7jQGnfGTz4FzUh5gXwLWZ8U0gDhOOi/DtIuIbOoUeIv14mvBNAI7IjG+Lc3O3B0e6TQGXkgviLfl28OtDhHvamlACDG/rxZxGxUJJcofOSQZca78V33qJ7dansdna6LM939pM+XY3a8e3YiUb/sP49qc/17T+zZ5v5x3xbQER7qgDG86/4IhvR/pBfUjomq/ExfiG8qdMnlCc1fdK0taHpKH9ltbx7d1LtocBfe1HRVwP8B7Undb3WrZoddjx7erJb/BBdPGbfzK+Id2gaCNw43x7eB9raGjo+BACHJfFfMtBalbCgrcRYMDVjm9BZ/W9+drU94rsaXNMZX9bSriY06nYIP0peQ9JEbi4Bd+o7cb41kZtNsY4yDcoU77Jo6CgG1oW9hvwT/dz/4L7+Nt7R3z7oCgB1+Yb5Buv71VXD1d1r6qkl745ac03O/80o/dPZ8i4NzakXM6hMr5lsHbCtyfAtLPjWxM7BOKu4gOL8u0G18MbD5neU74xDRHGQb5BzY1okwwp5qFKv89Irfuzyvu8PyvZzCwx/n8sL/BWRCLPOclDVWQHNWbJN8E2zjT3fAO1Icb5hXmWX/ikHwxXwdq//afu+eZzxrcpQDcr882ebzGvT1cAd+hw6DA6sS96jRt3IY43iW8eHd/SVFZ8E2Zamu9j0ILvxMu0i/76O33WS54h35oQ2poI4KLR6MkoBhw+kADfHuKHp0Tvv9PwDRGOCPANKqX50ftYHdygxLzF2vItG3bcXy+nIYJ71l8/1kxbSn3cOy0XGdpyxfX5PPtsS+Jb0jHfSNytD/DNtX8qakNM6kMY1wrMIJ7W5VUL+3d+iHu+nTbkG9QHF9E3i/jbr6sqGB9yiGvVy4JzgG9W9lvaNL8gwmx8q1YaJRgg39JYTucj3em2MYwjRnwjhCNP0ShhHKUb5Nt1BLfj/zj94pWq+gOIb2dnTswg3b9MGMdlO//tilHPqfSTD9aYb1tO5iM16KdfBPdkPpLgW3NSkc03hIYC+kVQacg25VvYhG9Ju/ibnDftxGyjH+7zC0NwsJTs+hfYna6QN+a1dzi8f+e/uefbtw75tvCq3l6/rznj29u3R3i21N/fpWutD/G3cHoBy0P4pvj9ShzYb1b+aZrVh8h9WJk0XbGl59u/LedbulKvMd+aGOSiRFfxQXRjBfFt+el1Koy3FxIsn549gfiGdRnpviO+wZaFFKjy7asx3+bL9vMtRZCuPM+u7Nl8yxjlW5zfRRx9KxaCPgWZQlulfE7mG/RPrxnyTfScYhsO5Bd2VR+yYcC3gm7v/zxvyNrW9jXkD878XignI+CUKQd8e0v0+lKJe6iJri7ZfAvF1Sr5quE3jycWRxrz7CS/gAT4RuEG+Zbek/nkTUJRTrgq4Ajflq5zPVXrtXybEYTDGrpszTfRdAo91A6AvFrxLRveyXzyMCfens0nTzK+8exCAfml2zRf2lPE3qmObwGfVOE7O2ld3/tI7ltgnOvjNb6u6nsfg8Gg8LYVxMseuf20XHeA9i+4suDerVny7a2QZMD5lH7iolLzLYTwxsCn/hTi5hs+WWGIRDjb/oU0tN+YIN/2ZL9MkwZwUQ64FaSlFS3fnp6u1/EN440DjsvR/gXYkjUIykZ2xTd1F3wLgv0yFgu0gmZ8A4CDeLMEnOl+mYTWfvNOI76x/Yjz1TK44idQ4CsPSoJ8AzVwEVorgl/zvKqb/qy7JoOPC1vzGxvBBvnO07sazlc2KmxwUv6A7c+CmvDbdWY559sb3MJA5S/F73WxgUgxvHVGmG8ccEiNQIBv9vZbOkNMPcg3lqNA+pz7AZuMALeysvwL0vLKM863UXTc6NTz7Qw+iGYuz1jz7cHtK1cGUwYxuA5qwC1KJp0LvoElqD+451td2HY/IARgcE/2A4rZls0xZkwrCAXTPs63HBUmHlNAdk9bE/b99aT3tFeajcSfI276628a8K08Te9UTpuorpvmt5BfP3D7T6EWJo6+UhwH3yDfZB1Jqt7q8tNSfzwZi8UTeEEg1z2RXaCE8zTiQ8hufi9qmjfiWzqTSUO+ZbA+935nDd7wien2zI/btgMBpZPybXQUn8vaZMV/kPk2fGYYE24GI+7yGQu+XWmjCdyUQT4BdGnNuePbgKaH2RXfRHSNqxAEsbeCeDcnvmfv9jsTXrXO8u4FRIwy49unqvm2rZqYb7Z8W+xexDYc5hz5GKHPjHsGspyPdNdocUVuM1wUEkmEje0iuF7T/fW14BvUwu9meFvYGd/eNEoNWV4yEYl1mfLCEUY3dBC2eaztt4wT+43vAkw7yi+IAjgX6vjNxn5raYq2RFuwVyq0vDRKtQT4NoyECSfLkG8PIvq2+hQw125LxHPHtx+0WSpiwZ0f2Bnf4PaYXI+mTKTSkwMbaAz5BnXz+Shi3N9Gn1ObBhLu5+8R4/7+/c+Cbhb99c3X2L/1Tewlk1eVMucbusAUKInq3tbZSWfzLR8NPjL8sBPk27eGied5HuPU17xJN7dMr0O+wcDb7gXpxgNvtefbhN8F3gDfGOASHHBQSqLrkJRdEOYb4FuGKm2QP01DvlH3FNpvYD/grhMM49Z8a8FnSzT6Sz3gG9FyQL6ufCR0w4dGRnzrlUt6waWU3kHtdcQ3qJKujvI0MmuUnfINGhLlhnyFuKF1lXxDGexHteebe0G+cQNOtJ8qKBRfzpe8dVsCbz1VvKljUvI0YTcfyb0g324iAbxlN7eQKuh+9awXptEiwE/aJTKVrTC+XAhv2e4HhIE39zILvNWeb+9eWQ0lt+cbtOC8Jnjr7wpJ0bevmf2GTtP8aQbsXyBhNi3fKNvSGcf1Ie4d1EumfGup0q2lZeWFId8ujC6pmtDm2WGm9uH2M+1WfEtpaoxZJwOogRMua4dLvj2uN9CAC75lN8lFofJ6uKEhvM6vigVPNeHbZIhG4LwUcBtlEtPKieRCWOV488q1IfHS3vDtc94Bq8Cbe8HA277g29SEKd0CE2tu+Pa6Me4zMuG8agLhjasafQP2m91+QMg3bqZB/xTU98oad2W+Qb4RqkmAQ3zrhHy7gDS69Ewz1+kUhVs7wRs+yQPgG2svBdG1iMAZyDksOuIblM+omtIN37L5XNFW5WC2Nnwr9X9FAJdkgNvMoRSqoFuxwVsd/jYGSnu/GL7BwJt7gcBbTfk2hfUOJRYsZiJNre2Ub2+oGlG+VNXTzb+a5M6pyJ7i0yT+xtm0g/q3DOBbGgn2n3KNu8Ib5FsLt9/wgbUS0PPtAtOSsOz8MwRvx4j1xnSGPAK+kdo2y4KQOX0ALuWSbwP1UIorvmXzZVu85bO14lspQQEX89EW7Mo6xxvJiFQzp4mQGN7bGi99WXyDgTf3AoG3WvLNfjBSJ6gLsePbG6Ejh5OTqow4v7907R7GG5dHa795TOJvhvvrDfiGA3UG9SFgvqVOt3o7650rcus3Q75hqDXRByJovyG8cS3964WqKIr6YuIEwtsxdLQfaxcy45vhVKRFiXjgglO+wRIRqAFXfMMb1i01HczWjm+lxCwmV/Phc3T9ghpk03vL4aCvarzFWlulRQ2lL4RvMPC2e4HAW634BqNuUIGjU2tO+fbGQK9DXT8lVtlkXr9vtT+JauEkvInsKUeb4/56zKuXgG+YhA74BnXp1p0n4+Pjvb2RSHd3d19HR0cb9fiQ+rq7I5FI7/j4kyd37tz6L/sOyDdGNkG4Jk2YTbnO+Xbq1CnkpD5/vrD2HL0cJnw7dqwdHXZ8awN808bbevVfNuKYb7DGF+g7d3zLbm4XLbS9ma0l30p0cUzzV7FJL92fVaoEg8EKTbEEAp3KZHJW3rJ17v/s3b9LG2Ecx/HRRbJ4bc8I0eTkqs2Row6F0tAsZhAilJilJCGtkCylhNuKQwmhgw4tgkhdQoYuReJYSCfByaF/wIFFSGnAP6PPD80nuefBhOvpA0feSW+wSwvy4nvP81zihsM3LLwFmbDwpso3CNdjcojNX0C3sb79kqdls9Hdaqler5eq36NZoptOfNM9m6cUNxg30fx2IjsfcsJ+3JH5xoNvgQXfPFmJRHt2qK8HHLeR4nHDSNK4bkvkxS9y316P+dC3LQE8P77xjoRfC9eHb6xLnFbwdrp5+VOtb263GmHCNYpld5UQt8D/4+z7nZe7dYf8rfDNWSHwDQtvQYaFN/W+4WRvb1nAbYU+kOXXN6RFo2aWZ5o6bWR6Y8Qx2+ZufX6hM9H+AhWu05Hvn96/bwS4oX/gt4MM5+3NEG7xmlFLGknW2lKSyrbELjSJb9sjh0E/Cz997j0ysuHLN15rxrO/0PLjG2+xIOetQO5NVfmGyo7NhLPNYj3vPlhdXaY93CmXnEZsaHaLFPNuaHzDwluQQTeVvomRTYbePFVuYf6sd/EBk5tv3wBcVB+kYXojYXxjf27x7WSS+W2Q8vnNSli0ROL47BqelYNMLgfa0vF0vEZ0IyV5RDfeGr+seXwTv2BhW/IQatM70PnwDbX2bvZRF14etXycf0MzdF3L0x/opsY3VHGIbpSwWMTUHadYdBzdJLbFItCtAd3C4BsW3oIMC2/KfAs4+CZPG/FNk45v9IomuD/lt6HC8wvy8yH4/tO79c2y6HvwsqwUuR4et9vt48N9wlsunRvWjWTUjKQx4I0Jh+Abaj6V3Ho2vful7zHj+fMNtVpvScw2f76hvX6BHi3jnX4s9HHoTZlvqFw1Y5S4iG3bMRq2FCh7tl7acd0w+YaFtyDDwlvofQNwus6I065fA+AQxrdx8xt8E9ffOnLfOqy79s26sY1daKlU6jFrfz/DeEun1ylu9EXi05vhGd+kvqHmFnYOZL55b2P9+ibm3zd0uXjev9rcvOqf/8Wym1rfULdS1RscNkSxsxtOqeyiEPimoDD6BuB0kwvn2Ttl4xvr/z8/5AcDjrxV+YbA2wtShumWWydx3uI1+jYwvWF8E3wT+vRq69nGu+Zv9MW75aDeNx8p9A3l61VHb5CBjWdHzN1iqYLJberb1DcxTaeZGN8k89vcON9mx/pGcaPneOXPZynwzcMbnd7iLMbb6OLbkyXWI/ISfAss0bepb2I7+XKlTquU810XTX2b+iZPo+ObJsxvaMznv3Um9I3wJrs/HXSfvv1r5+5VI4ehKAA/QgoXrsLaBNaggelEii22yQvkPaVyCKmmMswDLGy3xTb7Gnt9r+RjRTYmExCj5B55gn+Y9uPIUibWt5+U0N76p74X4R64vYX6Zg6mm0bb8iGjjG/q2/VR39Q3ABc2vu3Ut83/Pz29PCLPE2KU50eE975xfPrg5VRofnqkAdzy2Smlj7j1ePcmwAXZwFvNvl1eP5BLVb6pb+rbSGmowaG/7dY39Dc0uEX4xsknt7yY5/IHheanRwJORuAtrW+UPgLHOcT6Zkwno5V0/KnPt3lx9Pef16uDX1Q6375v6pv6Nkoa9Lf9+pb7xko5NszRkHO5OR3ehQccL3/jZRnfjhLCTTJk9S2WN4ngZg9GgGuX6ar1TfLv8u3KXIi3WnxT39S3cU6T7g2Bb/v9zdMAWWwbieZZNAfEuNPxLXyH46c4SgnfJEPq26K9PcRYy7oxbsTbW+HaKn37eCrxTX1T30YJgJvTJMLd7fQ3ISwhzktxczN8MM57ApAGX5TubyhvG/UNuE0H8cbJdbtd39Q39U19GzkZcN9Zt3f3txM277qleLhAXFhF9XTQxxX3bRjA26pvdhrMmxXdZCSp0LdfX8E39U19G9dyfz+Sa9kv9+L1235/8+FDbqVPRD+H0/AwOMcp4dvAuEXe0tUFtDfRzQbdUN/UtzQ36Jv6pr6t4sYBcHSStbfafRvINuTH9vTUxhgL3kwNvqlv6pv2t3XdBLjt+lZ/f1vqxrxl9S3XDfPTOnxT39Q3ff+W6RYz3gXf3tnfXIDN+XBH9IrLqMlbOefdvP7A2rky798WutHBgW/9U9gaYulYBa4S39Q39U3XF1LccuCabPW0et/SqenAulE2Z6fGWOiWp7tV39Q39U3XTyNueZoA3Gfrb8CNgVtbPcXSAscgbb5DpKvXt/P5/Pfa0He/hG/q239BOcy5ZnLYXQAAAABJRU5ErkJggg==", df = { "data-id": "sds-layout-sei-external-footer" }, uf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode)('<div class="py-8 text-white bg-gray-250"><div class="container px-4 mx-auto space-y-6 md:px-8"><ul class="grid grid-cols-1 gap-6 md:grid-cols-3"><li><a href="https://vulcoord.cert.org/VulReport/" class="hover:underline focus:underline focus:outline-none">Report a Vulnerability to CERT/CC</a></li><li><a href="https://sei.cmu.edu/subscribe-to-sei-bulletin/" class="hover:underline focus:underline focus:outline-none">Subscribe to SEI Bulletin</a></li><li><a href="https://sei.cmu.edu/legal/request-permission-to-use-sei-material" class="hover:underline focus:underline focus:outline-none">Request Permission to Use SEI Materials</a></li></ul></div></div>', 1), ff = { class: "py-8 text-gray-100 bg-gray-900" }, hf = { class: "container px-4 mx-auto space-y-6 md:px-8" }, yf = { class: "grid grid-cols-1 gap-8 md:grid-cols-3" }, mf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", null, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("address", { class: "not-italic" }, [
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" Carnegie Mellon University"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("br"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" Software Engineering Institute"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("br"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" 4500 Fifth Avenue"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("br"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" Pittsburgh, PA 15213-2612"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("br"),
    /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
      href: "tel:412-268-5800",
      target: "_self",
      class: "hover:underline"
    }, "412-268-5800")
  ])
], -1), gf = { class: "space-x-2" }, vf = { class: "inline-block" }, bf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Facebook", -1), pf = [
  bf
], wf = { class: "inline-block" }, xf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Twitter", -1), kf = [
  xf
], Mf = { class: "inline-block" }, Cf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "LinkedIn", -1), Sf = [
  Cf
], $f = { class: "inline-block" }, Lf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "YouTube", -1), zf = [
  Lf
], Df = { class: "inline-block" }, Tf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "iTunes", -1), Bf = [
  Tf
], Pf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", null, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
    href: "https://sei.cmu.edu/contact-us/",
    target: "_self",
    class: "py-8 text-xl text-center transition-colors duration-100 rounded-none btn btn-tertiary btn-red btn-lg btn-block"
  }, " Contact Us ")
], -1), Af = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createStaticVNode)('<ul class="space-x-1 text-sm"><li class="inline-block"><a href="https://www.sei.cmu.edu/locations/index.cfm" target="_self" class="hover:underline">Office Locations</a></li><li class="inline-block"> | </li><li class="inline-block"><a href="https://www.sei.cmu.edu/additional-sites-directory/index.cfm" target="_self" class="hover:underline">Additional Sites Directory</a></li><li class="inline-block"> | </li><li class="inline-block"><a href="https://www.sei.cmu.edu/legal/index.cfm" target="_self" class="hover:underline">Legal</a></li><li class="inline-block"> | </li><li class="inline-block"><a href="https://www.sei.cmu.edu/legal/privacy-notice/index.cfm" target="_self" class="hover:underline">Privacy Notice</a></li><li class="inline-block"> | </li><li class="inline-block"><a href="https://www.cmu.edu/hr/ethics-hotline/" target="_self" class="hover:underline">CMU Ethics Hotline</a></li><li class="inline-block"> | </li><li class="inline-block"><a href="https://www.sei.cmu.edu/index.cfm" target="_self" class="hover:underline">www.sei.cmu.edu</a></li></ul>', 1), Vf = { class: "text-sm" }, Kt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutSeiExternalFooter",
  __name: "LayoutSeiExternalFooter",
  setup(e) {
    const t = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => (/* @__PURE__ */ new Date()).getFullYear()), a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => cf);
    return (n, r) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("footer", df, [
      uf,
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", ff, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", hf, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", yf, [
            mf,
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("ul", gf, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("li", vf, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
                  href: "https://www.facebook.com/SEICMU/",
                  rel: "noopener",
                  target: "_blank",
                  class: "inline-block hover:border-b-0 hover:opacity-50 focus:border-b-0 focus:opacity-50 facebook",
                  style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
                    height: "30px",
                    width: "30px",
                    backgroundRepeat: "no-repeat",
                    backgroundImage: `url(${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)})`,
                    backgroundPosition: "0 0",
                    backgroundSize: "auto 100%"
                  })
                }, pf, 4)
              ]),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("li", wf, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
                  href: "https://twitter.com/sei_cmu",
                  rel: "noopener",
                  target: "_blank",
                  class: "inline-block hover:border-b-0 hover:opacity-50 focus:border-b-0 focus:opacity-50 twitter",
                  style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
                    height: "30px",
                    width: "30px",
                    backgroundRepeat: "no-repeat",
                    backgroundImage: `url(${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)})`,
                    backgroundPosition: "-32px 0",
                    backgroundSize: "auto 100%",
                    content: ""
                  })
                }, kf, 4)
              ]),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("li", Mf, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
                  href: "https://www.linkedin.com/company/software-engineering-institute",
                  rel: "noopener",
                  target: "_blank",
                  class: "inline-block hover:border-b-0 hover:opacity-50 focus:border-b-0 focus:opacity-50 linkedin",
                  style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
                    height: "30px",
                    width: "30px",
                    backgroundRepeat: "no-repeat",
                    backgroundImage: `url(${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)})`,
                    backgroundPosition: "-96px 0",
                    backgroundSize: "auto 100%"
                  })
                }, Sf, 4)
              ]),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("li", $f, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
                  href: "https://www.youtube.com/user/TheSEICMU",
                  rel: "noopener",
                  target: "_blank",
                  class: "inline-block hover:border-b-0 hover:opacity-50 focus:border-b-0 focus:opacity-50 youtube",
                  style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
                    height: "30px",
                    width: "30px",
                    backgroundRepeat: "no-repeat",
                    backgroundImage: `url(${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)})`,
                    backgroundPosition: "-129px 0",
                    backgroundSize: "auto 100%"
                  })
                }, zf, 4)
              ]),
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("li", Df, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
                  href: "https://podcasts.apple.com/us/podcast/software-engineering-institute-sei-podcast-series/id566573552?mt=2",
                  rel: "noopener",
                  target: "_blank",
                  class: "inline-block hover:border-b-0 hover:opacity-50 focus:border-b-0 focus:opacity-50 itunes",
                  style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
                    height: "30px",
                    width: "30px",
                    backgroundRepeat: "no-repeat",
                    backgroundImage: `url(${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)})`,
                    backgroundPosition: "-161px 0",
                    backgroundSize: "auto 100%",
                    borderRadius: "50%"
                  })
                }, Bf, 4)
              ])
            ]),
            Pf
          ]),
          Af,
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Vf, " © " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(t)) + " Carnegie Mellon University ", 1)
        ])
      ])
    ]));
  }
}), Of = {
  "data-id": "sds-layout-sei-external-nav",
  class: "space-y-4"
}, Hf = { class: "text-xl text-gray-600 break-words" }, Nf = { class: "pb-2 space-y-2" }, Ef = ["href"], If = {
  key: 0,
  class: "pt-2 border-t"
}, Rf = ["href"], Ff = { class: "group-hover:underline" }, Wf = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  viewBox: "0 0 32 32",
  class: "block w-5 h-5 my-auto fill-current",
  "aria-hidden": "true"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M11.303 8l11.394 7.997L11.303 24z" })
], -1), _t = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutSeiExternalNav",
  __name: "LayoutSeiExternalNav",
  props: {
    /**
     * An object containing various properties that determine the navigation.
     */
    page: {
      type: Object,
      default: () => ({})
    }
  },
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Of, [
      ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.page.nav, (n) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        key: n.title,
        class: "p-4 space-y-2 bg-gray-100"
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("h3", Hf, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(n.title), 1),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("ul", Nf, [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(n.items, (r) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
            key: r.title
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
              href: r.url,
              class: "text-red-500 break-words hover:text-red-700 hover:underline"
            }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(r.title), 9, Ef)
          ]))), 128))
        ]),
        n.seeAll ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", If, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
            href: n.seeAll.url,
            class: "inline-flex font-bold uppercase group text-gray-900"
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", Ff, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(n.seeAll.title), 1),
            Wf
          ], 8, Rf)
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
      ]))), 128))
    ]));
  }
}), qf = {
  "data-id": "sds-layout-sei-external-header-content",
  class: "space-y-4"
}, Gf = {
  key: 0,
  class: "text-3xl text-gray-500 break-words font-extralight"
}, Yf = {
  key: 1,
  class: "text-xl text-gray-500 break-words"
}, jf = ["innerHTML"], At = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutSeiExternalHeaderContent",
  __name: "LayoutSeiExternalHeaderContent",
  props: {
    /**
     * An object containing various properties that display in the content.
     */
    page: {
      type: Object,
      default: () => ({})
    }
  },
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", qf, [
      e.page.title ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("h3", Gf, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.page.title), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      e.page.subtitle ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("h4", Yf, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.page.subtitle), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      e.page.description ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        key: 2,
        class: "max-w-screen-md prose break-words prose-red",
        innerHTML: e.page.description
      }, null, 8, jf)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ]));
  }
}), Uf = {
  "data-id": "sds-layout-sei-external-masthead",
  class: "py-8 bg-white"
}, Kf = { class: "container px-4 mx-auto md:px-8" }, _f = {
  key: 0,
  class: "grid grid-cols-1 gap-8 lg:grid-cols-12"
}, Xf = { class: "order-2 lg:col-span-3 lg:order-1" }, Qf = {
  key: 0,
  class: "order-1 lg:col-span-9 lg:order-2"
}, Xt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutSeiExternalMasthead",
  __name: "LayoutSeiExternalMasthead",
  props: {
    /**
     * An object containing various properties that display in the masthead.
     */
    page: {
      type: Object,
      default: () => ({})
    }
  },
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Uf, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Kf, [
        e.page.nav ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", _f, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Xf, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(_t, { page: e.page }, null, 8, ["page"])
          ]),
          e.page.title || e.page.subtitle || e.page.description ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Qf, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(At, { page: e.page }, null, 8, ["page"])
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ])) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 1 }, [
          e.page.title || e.page.subtitle || e.page.description ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(At, {
            key: 0,
            page: e.page
          }, null, 8, ["page"])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ], 64))
      ])
    ]));
  }
}), Zf = {
  "data-id": "sds-layout-sei-external",
  class: "flex flex-col w-full min-h-screen text-gray-900 bg-white"
}, Jf = { class: "grow" }, eh = {
  key: 1,
  class: "container p-4 mx-auto md:p-8"
}, Da = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutSeiExternal",
  __name: "LayoutSeiExternal",
  props: {
    /**
     * An object containing various properties that display in the header and masthead.
     */
    page: {
      type: Object,
      default: () => ({})
    },
    /**
     * Removes the content padding from the default slot section.
     * Useful when you want to custom style the main content section.
     */
    removeContentPadding: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines whether to show the masthead section or not.
     */
    showMasthead: {
      type: Boolean,
      default: !1
    }
  },
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Zf, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(t.$slots, "header", {}, () => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Ut, { page: e.page }, null, 8, ["page"])
      ]),
      e.showMasthead ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(t.$slots, "masthead", { key: 0 }, () => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Xt, { page: e.page }, null, 8, ["page"])
      ]) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("main", Jf, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
            "bg-gray-25": e.showMasthead
          })
        }, [
          e.removeContentPadding ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(t.$slots, "default", { key: 0 }) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", eh, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(t.$slots, "default")
          ]))
        ], 2)
      ]),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Kt)
    ]));
  }
});
Da.install = (e) => {
  e.component(Da.name, Da);
};
Kt.install = (e) => {
  e.component(Kt.name, Kt);
};
Ut.install = (e) => {
  e.component(Ut.name, Ut);
};
At.install = (e) => {
  e.component(At.name, At);
};
Xt.install = (e) => {
  e.component(Xt.name, Xt);
};
_t.install = (e) => {
  e.component(_t.name, _t);
};
jt.install = (e) => {
  e.component(jt.name, jt);
};
const th = {
  "data-id": "sds-layout-stacked",
  class: "flex flex-col w-full min-h-screen"
}, ah = { class: "grow" }, Ta = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLayoutStacked",
  __name: "LayoutStacked",
  props: {
    /**
     * Determines whether to make the header sticky or not.
     */
    stickyHeader: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines whether to make the footer sticky or not.
     */
    stickyFooter: {
      type: Boolean,
      default: !1
    }
  },
  setup(e) {
    const t = (0,vue__WEBPACK_IMPORTED_MODULE_0__.useSlots)(), a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!t.header), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!t.footer);
    return (r, s) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", th, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("header", {
        key: 0,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["z-30 flex-shrink", { "sticky top-0 shadow": e.stickyHeader }])
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "header")
      ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("main", ah, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "default")
      ]),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("footer", {
        key: 1,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["z-20 flex-shrink", { "sticky bottom-0 shadow": e.stickyFooter }])
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "footer")
      ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ]));
  }
});
Ta.install = (e) => {
  e.component(Ta.name, Ta);
};
Bt.install = (e) => {
  e.component(Bt.name, Bt);
};
const Ba = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLoadingSkeleton",
  __name: "LoadingSkeleton",
  props: {
    /**
     * Sets the height of the skeleton. Accepts tailwind height classes.
     */
    height: {
      default: "h-full",
      type: String
    },
    /**
     * Sets the width of the skeleton. Accepts tailwind width classes.
     */
    width: {
      default: "w-full",
      type: String
    }
  },
  setup(e) {
    return (t, a) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", {
      "data-id": "sds-loading-skeleton",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["rounded flex flex-row relative overflow-hidden bg-gray-100 dark:bg-gray-800 animate-pulse", e.width, e.height])
    }, null, 2));
  }
});
Ba.install = (e) => {
  e.component(Ba.name, Ba);
};
const nh = {
  "data-id": "sds-loading-spinner",
  role: "status"
}, rh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("circle", {
  class: "opacity-25",
  cx: "12",
  cy: "12",
  r: "10",
  stroke: "currentColor",
  "stroke-width": "4"
}, null, -1), sh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  class: "opacity-75",
  fill: "currentColor",
  d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
}, null, -1), lh = [
  rh,
  sh
], oh = {
  key: 0,
  class: "sr-only"
}, Pa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsLoadingSpinner",
  __name: "LoadingSpinner",
  props: {
    /**
     * Sets the size of the spinner.
     */
    size: { type: String, default: "md" },
    /**
     * Sets the accessiblity label for the spinner.
     */
    label: { type: String, default: null }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.size) {
        case "lg":
          return "h-20 w-20";
        case "sm":
          return "h-4 w-4";
        case "auto":
          return "";
        default:
          return "h-12 w-12";
      }
    });
    return (n, r) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", nh, [
      ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["animate-spin", (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)]),
        xmlns: "http://www.w3.org/2000/svg",
        fill: "none",
        viewBox: "0 0 24 24"
      }, lh, 2)),
      e.label ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", oh, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.label), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ]));
  }
});
Pa.install = (e) => {
  e.component(Pa.name, Pa);
};
const ih = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M256 217.9L383 345c9.4 9.4 24.6 9.4 33.9 0 9.4-9.4 9.3-24.6 0-34L273 167c-9.1-9.1-23.7-9.3-33.1-.7L95 310.9c-4.7 4.7-7 10.9-7 17s2.3 12.3 7 17c9.4 9.4 24.6 9.4 33.9 0l127.1-127z" }, null, -1), ch = [
  ih
], dh = {
  key: 1,
  class: "ml-0 relative inline-block w-4 h-4",
  xmlns: "http://www.w3.org/2000/svg",
  viewBox: "0 0 24 24",
  fill: "currentColor"
}, uh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  fill: "currentColor",
  d: "M14 5a1 1 0 1 1 0-2h6a1 1 0 0 1 1 1v6a1 1 0 1 1-2 0V6.414l-9.293 9.293a1 1 0 0 1-1.414-1.414L17.586 5zM3 7a2 2 0 0 1 2-2h5a1 1 0 1 1 0 2H5v12h12v-5a1 1 0 1 1 2 0v5a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"
}, null, -1), fh = [
  uh
], Aa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsMegaMenu",
  __name: "MegaMenu",
  props: {
    /**
     * An array of top-level navigation items ("top links").
     * Each navigation item is defined by a "topLink" object.
     * A navigation label is applied with the "title" key.
     * It also supplies the "content" object to retrieve data
     * from within a Mega Menu panel. I.e.:
     * `<template #panel(key)={ content }>{{ content.item }}</template>`
     *
     * Instead of an accordion-like function, the top link can
     * also be setup as an anchor tag with the "tag" setting.
     *
     * ```
     * {
     *   key: string
     *   tag?: 'button' | 'a'
     *   title?: string
     *   href?: string
     *   alignment?: 'left' | 'right' | 'center'
     *   content?: Object
     *   external?: boolean
     *   active?: boolean
     *   selected?: boolean
     *   disabled?: boolean
     *   onClick?: Function
     * }
     *
     * ```
     */
    modelValue: { type: Array, default: () => [] },
    /**
     * Overall look and feel of the component (two options)
     */
    type: { type: String, default: "underline" },
    /**
     * Sets the panel width. Full width stretches to fill the width of the screen.
     * Auto width will fit the width of the content inside the panel.
     */
    width: { type: String, default: "full" }
  },
  emits: [
    /**
     * When data supplied to the Mega Menu component
     * changes, emit an event. This lets developers
     * trigger other actions off the Mega Menu's modelValue
     * when it changes.
     */
    "update:model-value"
  ],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      /* Get SdsMegaMenu modelValue property */
      get() {
        return a.modelValue;
      },
      /* Set SdsMegaMenu modelValue property */
      set(M) {
        n("update:model-value", M);
      }
    }), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.modelValue.find((H) => H.selected) || null), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)([]), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => typeof document > "u" ? null : g.value ? document.querySelector(`#sds-megamenu__top-link_${g.value.key}`) : null), { bottom: d } = mn(u), { right: h } = mn(f), { right: p } = mn(v), w = (M = !0) => {
      M && y.value?.focus(), r.value = r.value.map((H) => (H.selected = !1, H)), D("close");
    };
    on(u, () => {
      w(!1);
    }), cr(u, () => {
      w(!1);
    }), ea("Escape", (M) => {
      s.value && (M.preventDefault(), w());
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watchEffect)(() => {
      if (m.value = [], v.value) {
        const M = Array.prototype.slice.call(v.value.querySelectorAll(
          'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
        ));
        m.value = M;
      }
    });
    const b = (M) => {
      if (!v.value) return;
      if (m.value.length < 2 && M.key === "Tab") {
        M.preventDefault();
        return;
      }
      const H = m.value.length - 1;
      M.key === "Tab" && M.shiftKey === !1 && M.target === m.value[H] || M.key === "Tab" && M.shiftKey === !0 && M.target === m.value[0] ? (M.preventDefault(), y.value?.focus()) : M.key === "Tab" && M.shiftKey === !1 && M.target === y.value ? (M.preventDefault(), m.value[0].focus()) : M.key === "Tab" && M.shiftKey === !0 && M.target === y.value && (M.preventDefault(), m.value[H].focus());
    }, k = async (M, H) => {
      if (M.tag === "a" && M.href)
        return !0;
      H.preventDefault(), r.value = r.value.map((P) => (P.selected = P.selected ? !1 : M.key === P.key, P)), D();
    }, D = (M = null) => {
      if (M === "close")
        s.value = !1;
      else {
        let H = 0;
        r.value.forEach((P) => {
          P.selected && H++;
        }), H ? s.value = !0 : s.value = !1;
      }
    }, C = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => v.value && f.value ? p.value >= h.value : !1), L = us(ds), B = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), A = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), E = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => L.smaller("xl").value ? 16 : 32);
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(y, (M) => {
      if (a.width === "full")
        B.value = void 0, A.value = void 0;
      else if (a.width === "auto") {
        const H = M?.offsetLeft || 0, P = (M?.offsetLeft || 0) - f.value?.offsetLeft - E.value > 0;
        B.value = `${P ? H - E.value : H}px`, A.value = void 0;
      }
    }, { deep: !0 }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(C, (M) => {
      a.width !== "full" && M && (B.value = void 0, A.value = `${f.value?.offsetLeft || 0}px`);
    }), (M, H) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("nav", {
        ref_key: "root",
        ref: u,
        "data-id": "sds-megamenu",
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["relative w-full flex flex-col bg-white dark:bg-gray-900 border-b-2 border-gray-100 dark:border-gray-800", {
          "z-20": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s)
        }]),
        onKeydown: b,
        onClick: H[3] || (H[3] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((P) => w(!1), ["self"]))
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: "w-full text-gray-900 dark:text-gray-100 container mx-auto px-4 max-w-full lg:px-8 lg:max-w-screen-lg xl:max-w-screen-xl 2xl:px-12 2xl:max-w-screen-2xl",
          onClick: H[1] || (H[1] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((P) => w(!1), ["self"]))
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
            ref_key: "menu",
            ref: f,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex flex-row", {
              "gap-4 xl:gap-8": e.type === "underline"
            }]),
            role: "menu",
            onClick: H[0] || (H[0] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((P) => w(!1), ["self"]))
          }, [
            ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), (P) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(P.tag ? P.tag : "button"), {
              id: `sds-megamenu__top-link_${P.key}`,
              key: P.key,
              type: !P.tag || P.tag === "button" ? "button" : void 0,
              href: P.href ? P.href : void 0,
              "aria-haspopup": P.tag === "button" ? !0 : void 0,
              "aria-expanded": P.tag === "button" ? P.selected : void 0,
              "data-id": `sds-megamenu_${P.key}`,
              "data-selected": P.selected,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                "z-30": P.selected,
                "hover:z-30": !P.selected,
                "ml-auto": P.alignment === "right",
                "mr-auto": P.alignment === "left",
                "mx-auto": P.alignment === "center",
                "px-2 xl:px-3 2xl:px-4 border-gray-100 dark:border-gray-800 font-semibold": e.type === "block",
                "text-gray-700 dark:text-gray-100 hover:text-gray-900 hover:bg-gray-50 dark:hover:text-gray-100 dark:hover:bg-gray-850": e.type === "block" && !(P.selected || P.active && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).filter((G) => G.key !== P.key && G.selected).length < 1),
                "text-white bg-red-600 dark:text-gray-900 dark:bg-red-300": e.type === "block" && (P.selected || P.active && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).filter((G) => G.key !== P.key && G.selected).length < 1),
                "hover:text-red-600 hover:border-red-600 dark:hover:text-red-300 dark:hover:border-red-300": e.type === "underline",
                "text-red-600 dark:text-red-300 border-red-600 dark:border-red-300": e.type === "underline" && P.selected,
                "border-red-600 dark:border-red-300": e.type === "underline" && P.active,
                "border-transparent dark:border-transparent": e.type === "underline" && (!P.selected && !P.active || P.active && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).filter((G) => G.key !== P.key && G.selected).length > 0)
              }, "flex items-center gap-0.5 xl:gap-1 my-auto py-2 space-x border-b-2 group -mb-0.5 overflow-y-visible select-none shrink-0 text-sm xl:text-base focus-visible:outline focus-visible:outline-2 cursor-pointer"]),
              role: "menuitem",
              onClick: (G) => {
                k(P, G), P.onClick && P?.onClick(P, G);
              }
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(M.$slots, `link(${P.key})`, { item: P }, () => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(P.title), 1),
                  P.tag !== "a" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
                    key: 0,
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                      "rotate-0": P.selected,
                      "rotate-180": !P.selected
                    }, "mt-0.5 relative inline-block w-4 h-4 transition-transform ease-in-out duration-300"]),
                    xmlns: "http://www.w3.org/2000/svg",
                    viewBox: "0 0 550 500",
                    fill: "currentColor"
                  }, ch, 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                  P.tag === "a" && P.external ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", dh, fh)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ])
              ]),
              _: 2
            }, 1032, ["id", "type", "href", "aria-haspopup", "aria-expanded", "data-id", "data-selected", "class", "onClick"]))), 128))
          ], 2)
        ]),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
          "enter-active-class": "transition-transform ease-in-out origin-top duration-150",
          "enter-from-class": "scale-y-0",
          "enter-to-class": "scale-y-100",
          "leave-active-class": "transition-transform ease-in-out origin-top duration-200",
          "leave-from-class": "scale-y-100",
          "leave-to-class": "scale-y-0"
        }, {
          default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
              key: 0,
              role: "menu",
              class: "z-20",
              onClick: H[2] || (H[2] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((P) => w(!1), ["self"]))
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)?.tag !== "a" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                ref_key: "panel",
                ref: v,
                key: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)?.key,
                style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
                  left: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(B),
                  right: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(A)
                }),
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                  "shadow-lg border-t-2 border-b border-gray-100 dark:border-gray-800 rounded-b-lg": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)?.selected,
                  "border-x": e.width === "auto",
                  "w-full": e.width === "full"
                }, "absolute text-gray-900 dark:text-gray-100 bg-white dark:bg-gray-900"])
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                    "container mx-auto max-w-full lg:max-w-screen-lg xl:max-w-screen-xl 2xl:max-w-screen-2xl py-4 px-8 2xl:px-12": e.width === "full",
                    "p-4 xl:px-8": e.width === "auto"
                  })
                }, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)?.selected ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(M.$slots, `panel(${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g).key})`, {
                    key: 0,
                    close: w,
                    item: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g),
                    content: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g).content
                  }, () => [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g)?.selected ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(M.$slots, "default", {
                      key: 0,
                      close: w,
                      item: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g),
                      content: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g).content
                    }) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                  ]) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ], 2)
              ], 6)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ]),
          _: 3
        })
      ], 34),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
        "enter-active-class": "transition-opacity ease-in-out duration-150",
        "enter-from-class": "opacity-0",
        "enter-to-class": "opacity-100",
        "leave-active-class": "transition-opacity ease-in-out duration-150",
        "leave-from-class": "opacity-100",
        "leave-to-class": "opacity-0"
      }, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          e.width === "full" && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
            key: 0,
            class: "z-10 mt-auto fixed inset-x-0 bottom-0 bg-black/50",
            style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
              top: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d)}px`
            })
          }, null, 4)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ]),
        _: 1
      })
    ], 64));
  }
});
Aa.install = (e) => {
  e.component(Aa.name, Aa);
};
const hh = ["target", "rel", "tabindex"], yh = { key: 0 }, mh = { class: "flex flex-row gap-4" }, gh = { key: 0 }, vh = { class: "flex flex-row justify-start w-full group" }, bh = { class: "group-hover:text-red-600 dark:group-hover:text-red-300 w-fit inline-block my-auto" }, ph = {
  key: 0,
  class: "w-fit my-auto h-full whitespace-nowrap"
}, wh = {
  key: 0,
  class: "-ml-1 relative inline-block mb-0.5 w-6 h-6 group-hover:ml-1 text-red-600 dark:text-red-300 transition-all",
  xmlns: "http://www.w3.org/2000/svg",
  width: "24",
  height: "24",
  viewBox: "0 0 24 24",
  fill: "none"
}, xh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  class: "transition-transform group-hover:-rotate-45 group-hover:translate-y-[7px] group-hover:-translate-x-[0.5px] group-hover:scale-y-90 group-hover:scale-x-95",
  "stroke-width": "0.5",
  d: "M18.7063 12.7086C19.0969 12.318 19.0969 11.6836 18.7063 11.293L13.7063 6.29297C13.3156 5.90234 12.6813 5.90234 12.2906 6.29297C11.9 6.68359 11.9 7.31797 12.2906 7.70859L15.5875 11.0023H6C5.44687 11.0023 5 11.4492 5 12.0023C5 12.5555 5.44687 13.0023 6 13.0023H15.5844L12.2937 16.2961C11.9031 16.6867 11.9031 17.3211 12.2937 17.7117C12.6844 18.1023 13.3188 18.1023 13.7094 17.7117L18.7094 12.7117L18.7063 12.7086Z",
  fill: "currentColor"
}, null, -1), kh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  d: "M11 5H7C5.89543 5 5 5.89543 5 7V17C5 18.1046 5.89543 19 7 19H17C18.1046 19 19 18.1046 19 17V13",
  class: "opacity-0 group-hover:opacity-100 transition-opacity scale-90",
  stroke: "currentColor",
  "stroke-width": "2",
  "stroke-linecap": "round"
}, null, -1), Mh = [
  xh,
  kh
], Ch = {
  key: 1,
  class: "inline-block w-4 mb-1 h-4 transition-all text-red-600 dark:text-red-300 group-hover:ml-2",
  xmlns: "http://www.w3.org/2000/svg",
  width: "16",
  height: "16",
  viewBox: "0 0 448 512"
}, Sh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  fill: "currentColor",
  d: "M438.6 278.6c12.5-12.5 12.5-32.8 0-45.3l-160-160c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3L338.8 224H32c-17.7 0-32 14.3-32 32s14.3 32 32 32h306.7L233.4 393.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0l160-160z"
}, null, -1), $h = [
  Sh
], Lh = {
  key: 2,
  class: "w-4 h-4 mb-[1px] -ml-0.5 opacity-0 group-hover:opacity-100 relative inline-block transition-all",
  xmlns: "http://www.w3.org/2000/svg",
  width: "24",
  height: "24",
  viewBox: "0 0 24 24",
  fill: "none"
}, zh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  class: "transition-transform -rotate-45 translate-y-[7px] -translate-x-[0.5px] scale-y-90 scale-x-95",
  "stroke-width": "0.5",
  d: "M18.7063 12.7086C19.0969 12.318 19.0969 11.6836 18.7063 11.293L13.7063 6.29297C13.3156 5.90234 12.6813 5.90234 12.2906 6.29297C11.9 6.68359 11.9 7.31797 12.2906 7.70859L15.5875 11.0023H6C5.44687 11.0023 5 11.4492 5 12.0023C5 12.5555 5.44687 13.0023 6 13.0023H15.5844L12.2937 16.2961C11.9031 16.6867 11.9031 17.3211 12.2937 17.7117C12.6844 18.1023 13.3188 18.1023 13.7094 17.7117L18.7094 12.7117L18.7063 12.7086Z",
  fill: "currentColor"
}, null, -1), Dh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  d: "M11 5H7C5.89543 5 5 5.89543 5 7V17C5 18.1046 5.89543 19 7 19H17C18.1046 19 19 18.1046 19 17V13",
  class: "opacity-100 scale-90",
  stroke: "currentColor",
  "stroke-width": "2",
  "stroke-linecap": "round"
}, null, -1), Th = [
  zh,
  Dh
], Bh = { class: "text-gray-600 dark:text-gray-400" }, Va = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsMegaMenuItem",
  __name: "MegaMenuItem",
  props: {
    /**
     * Main MegaMenuItem text content
     */
    label: { type: String, default: "" },
    /**
     * Determines the MegaMenuItem component type to use.
     */
    type: {
      type: String,
      default: "simple"
    },
    /**
     * Applies the appropriate attributes for external links and opens them in a new tab. It also creates a REL attribute that prevents browser sniffing.
     */
    external: { type: Boolean, default: !1 },
    /**
     * Gives the link a "Call to Action" styling.
     */
    cta: { type: Boolean, default: !1 },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: !1 }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.type || t.cta ? "link group w-full no-underline" : ""), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.type) {
        case "landing-page":
          return "p-4 text-lg hover:no-underline hover:text-red-600 dark:hover:text-red-300";
        case "descriptive":
          return "p-4 transition-all rounded-lg hover:no-underline hover:bg-gray-25 hover:dark:bg-gray-850";
        case "simple":
          return "p-4 text-sm transition-all rounded-lg hover:bg-gray-25 hover:dark:bg-gray-850 hover:text-red-600 dark:hover:text-red-300";
        default:
          return "";
      }
    }), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => t.disabled ? "disabled" : "");
    return (s, u) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
      "data-id": "sds-megamenuitem",
      target: e.external ? "_blank" : void 0,
      rel: e.external ? "noopener noreferrer" : void 0,
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n), (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]),
      tabindex: e.disabled ? -1 : void 0,
      role: "menuitem"
    }, [
      s.$slots.top ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", yh, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(s.$slots, "top")
      ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", mh, [
        s.$slots.left ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", gh, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(s.$slots, "left")
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([
            e.type === "descriptive" ? "gap-1" : "",
            "flex flex-col"
          ])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", vh, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", bh, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.label), 1),
              e.cta || e.type === "landing-page" || e.external ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", ph, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(
                  " "
                  /* This is a whitespace character, it will prevent the trailing icon from wrapping */
                ) + " "),
                e.external && e.type === "landing-page" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", wh, Mh)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                (e.cta || e.type === "landing-page") && !e.external ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", Ch, $h)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                e.external && (e.type === "simple" || e.type === "descriptive") ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", Lh, Th)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ])
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("p", Bh, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(s.$slots, "default")
          ])
        ], 2)
      ])
    ], 10, hh));
  }
});
Va.install = (e) => {
  e.component(Va.name, Va);
};
function sr(e, t = {}) {
  return e ? e(t).some((a) => a.type === vue__WEBPACK_IMPORTED_MODULE_0__.Comment || Array.isArray(a.children) && !a.children.length ? !1 : a.type !== vue__WEBPACK_IMPORTED_MODULE_0__.Text || typeof a.children == "string" && a.children.trim() !== "") : !1;
}
const Ph = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Close panel", -1), Ah = [
  Ph
], Vh = ["aria-labelledby"], Oh = { class: "flex items-center p-6 pb-0" }, Hh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "w-6 h-6",
  fill: "none",
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  stroke: "currentColor",
  viewBox: "0 0 24 24"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M6 18L18 6M6 6l12 12" })
], -1), Nh = [
  Hh
], Eh = { class: "p-6 flex grow flex-col" }, Ih = {
  key: 0,
  class: "flex flex-shrink-0 sticky w-full bottom-0 p-6 bg-white/50 dark:bg-gray-900/50 backdrop-blur"
}, Qt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsPanel",
  directives: {
    uid: We,
    focus: {
      mounted(e) {
        e.focus();
      }
    }
  },
  __name: "Panel",
  props: {
    /**
     * The v-model that determines the show/hide state of the panel.
     */
    modelValue: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the size of the panel.
     */
    size: {
      type: String,
      default: "md"
    },
    /**
     * Determines the location of the panel.
     */
    side: {
      type: String,
      default: "right"
    },
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.useSlots)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => sr(r.title)), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => sr(r.footer)), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(b) {
        n("update:model-value", b);
      }
    }), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    });
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      d();
    });
    const y = () => {
      typeof document > "u" || (document.documentElement.classList.add("panel-prevent-scroll"), setTimeout(() => {
        document.addEventListener("keyup", p);
      }, 0));
    }, d = () => {
      typeof document > "u" || (document.documentElement.classList.remove("panel-prevent-scroll"), document.removeEventListener("keyup", p));
    }, h = () => {
      g.value = !1;
    }, p = (b) => {
      b.key === "Escape" && h();
    }, w = (b) => {
      if (u.value === null) return;
      if (b.key === "Escape") {
        h();
        return;
      }
      const k = u.value.querySelectorAll(
        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
      );
      if (k.length < 2 && b.key === "Tab") {
        b.preventDefault();
        return;
      }
      const D = k.length - 1;
      b.key === "Tab" && b.shiftKey === !1 && b.target === k[D] ? (b.preventDefault(), k[0].focus()) : b.key === "Tab" && b.shiftKey === !0 && b.target === k[0] && (b.preventDefault(), k[D].focus());
    };
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(g, (b) => {
      g.value = b, !(typeof document > "u") && (b ? y() : d());
    }, { immediate: !0 }), (b, k) => {
      const D = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid"), C = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("focus");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(it, null, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Teleport, { to: "body" }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
              "enter-active-class": "transition-opacity duration-75",
              "enter-from-class": "opacity-0",
              "leave-active-class": "transition-opacity duration-75 delay-150",
              "leave-to-class": "opacity-0"
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                  key: 0,
                  "data-id": "sds-panel-backdrop",
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["fixed inset-0 block h-full px-2 py-0 overflow-auto bg-black bg-opacity-50", [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)]])
                }, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                    class: "absolute inset-0",
                    onClick: h
                  }, Ah)
                ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ]),
              _: 1
            }),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
              "enter-from-class": `${e.side === "left" ? "-translate-x-full" : "translate-x-full"}`,
              "enter-to-class": `${e.side === "left" ? "-translate-x-0" : "translate-x-0"}`,
              "leave-from-class": `${e.side === "left" ? "-translate-x-0" : "translate-x-0"}`,
              "leave-to-class": `${e.side === "left" ? "-translate-x-full" : "translate-x-full"}`,
              "leave-active-class": "transform transition ease-in-out duration-150",
              "enter-active-class": "transform transition ease-in-out duration-150 delay-75"
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                  key: 0,
                  ref_key: "panelContainer",
                  ref: u,
                  role: "dialog",
                  "data-id": "sds-panel",
                  "aria-labelledby": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s).id || void 0,
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                    [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)]: !0,
                    "max-w-sm": e.size === "sm",
                    "max-w-md": e.size === "md",
                    "max-w-lg": e.size === "lg",
                    "max-w-xl": e.size === "xl",
                    "right-0 rounded-r-none": e.side === "right",
                    "left-0 rounded-l-none": e.side === "left"
                  }, "fixed flex flex-col inset-y-0 w-11/12 bg-white overflow-y-scroll border rounded-lg shadow-xl dark:text-gray-25 dark:bg-gray-900 dark:border-gray-800"]),
                  onKeydown: w
                }, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("header", Oh, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f) ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                      key: 0,
                      ref_key: "titleWrapper",
                      ref: s,
                      class: "flex items-center gap-2 text-2xl leading-7 font-light"
                    }, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(b.$slots, "title")
                    ])), [
                      [D]
                    ]) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                      "aria-label": "close",
                      class: "inline-block p-0 ml-auto text-3xl text-gray-500 bg-transparent border-0 cursor-pointer hover:text-gray-700 hover:outline-none focus:text-gray-700 focus:outline-none dark:hover:text-gray-300 dark:focus:text-gray-300 active:text-gray-500 dark:active:text-gray-600",
                      onClick: h
                    }, Nh)), [
                      [C]
                    ])
                  ]),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("main", Eh, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(b.$slots, "default")
                  ]),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("footer", Ih, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(b.$slots, "footer")
                  ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ], 42, Vh)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ]),
              _: 3
            }, 8, ["enter-from-class", "enter-to-class", "leave-from-class", "leave-to-class"])
          ]))
        ]),
        _: 3
      });
    };
  }
}), Rh = {
  "data-id": "sds-mobilemenu",
  role: "menu"
}, Fh = { key: 0 }, Wh = { key: 0 }, qh = {
  name: "SdsMobileMenu"
}, Oa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  ...qh,
  props: {
    /**
     * Provides the navigation item values used to populate the mobile menu.
     */
    mobileMenus: {
      type: Array,
      default: () => []
    },
    /**
     * The v-model that determines the show/hide state of the panel.
     */
    modelValue: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the size of the panel.
     */
    size: {
      type: String,
      default: "md"
    },
    /**
     * Determines the location of the panel.
     */
    side: {
      type: String,
      default: "right"
    },
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" }
  },
  emits: [
    /**
     * When data supplied to the Mobile Menu component
     * changes, emit an event. This lets developers
     * trigger other actions off the Mobile Menu's modelValue
     * when it changes.
     */
    "update:model-value"
  ],
  setup(e, { emit: t }) {
    const a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)("transition-all duration-200 ease-in-out relative overflow-visible top-0 h-0"), n = e, r = t, s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)("root"), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(n.mobileMenus), f = (p = null) => {
      if (typeof document > "u") return null;
      u.value.map((w) => {
        w.selected = w.selected ? !1 : p === w.key, w.selected && p && (s.value = p);
      });
    }, v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => u.value.find((p) => p.selected && p.type !== "expand")), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return n.modelValue;
      },
      set(p) {
        r("update:model-value", p);
      }
    });
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      y();
    });
    const m = () => {
      typeof document > "u" || (document.documentElement.classList.add("panel-prevent-scroll"), setTimeout(() => {
        document.addEventListener("keyup", h);
      }, 0));
    }, y = () => {
      typeof document > "u" || (document.documentElement.classList.remove("panel-prevent-scroll"), document.removeEventListener("keyup", h));
    }, d = () => {
      g.value = !1;
    }, h = (p) => {
      p.key === "Escape" && d();
    };
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(g, (p) => {
      g.value = p, !(typeof document > "u") && (p ? m() : y());
    }, { immediate: !0 }), (p, w) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("nav", Rh, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(Qt, {
        modelValue: g.value,
        "onUpdate:modelValue": w[0] || (w[0] = (b) => g.value = b),
        side: e.side,
        size: e.size,
        "z-index": e.zIndex
      }, {
        title: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(p.$slots, "title", {
            navigate: f,
            activePanel: s.value
          })
        ]),
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
            "enter-active-class": a.value,
            "enter-from-class": "opacity-0 -right-full ml-40",
            "enter-to-class": "opacity-1 right-0 ml-0",
            "leave-active-class": a.value,
            "leave-from-class": "opacity-1 right-0 ml-0",
            "leave-to-class": "opacity-0 -right-full ml-40"
          }, {
            default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
              typeof v.value < "u" && s.value === v.value.key ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Fh, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(p.$slots, `panel(${s.value})`, {
                  navigate: f,
                  activePanel: s.value
                })
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ]),
            _: 3
          }, 8, ["enter-active-class", "leave-active-class"]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
            "enter-active-class": a.value,
            "enter-from-class": "opacity-0 -left-full mr-40",
            "enter-to-class": "opacity-1 left-0 mr-0",
            "leave-active-class": a.value,
            "leave-from-class": "opacity-1 left-0 mr-0",
            "leave-to-class": "opacity-0 -left-full mr-40"
          }, {
            default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
              typeof v.value > "u" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Wh, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(p.$slots, "default", {
                  navigate: f,
                  activePanel: s.value
                })
              ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ]),
            _: 3
          }, 8, ["enter-active-class", "leave-active-class"])
        ]),
        footer: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(p.$slots, "footer", {
            navigate: f,
            activePanel: s.value
          })
        ]),
        _: 3
      }, 8, ["modelValue", "side", "size", "z-index"])
    ]));
  }
});
Oa.install = (e) => {
  e.component(Oa.name, Oa);
};
const Gh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Close modal", -1), Yh = [
  Gh
], jh = ["aria-labelledby"], Uh = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "w-6 h-6",
  fill: "none",
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  stroke: "currentColor",
  viewBox: "0 0 24 24"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M6 18L18 6M6 6l12 12" })
], -1), Kh = [
  Uh
], _h = { class: "p-6" }, Xh = {
  key: 0,
  class: "p-6 pt-0"
}, Ha = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsModal",
  directives: {
    uid: We,
    focus: {
      mounted(e) {
        e.focus();
      }
    }
  },
  __name: "Modal",
  props: {
    /**
     * The v-model that determines the show/hide state of the modal.
     */
    modelValue: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the size of the modal.
     */
    size: {
      type: String,
      default: "md"
    },
    /**
     * Determines the title of the modal.
     */
    title: { type: String, default: null },
    /**
     * Determines if the modal header should be hidden.
     */
    hideHeader: { type: Boolean, default: !1 },
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, required: !1, default: "50" }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.useSlots)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!r.title), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!r.footer), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(b) {
        n("update:model-value", b);
      }
    }), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (a.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    });
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      d();
    });
    const y = () => {
      typeof document > "u" || (document.documentElement.classList.add("modal-prevent-scroll"), setTimeout(() => {
        document.addEventListener("keyup", p);
      }, 0));
    }, d = () => {
      typeof document > "u" || (document.documentElement.classList.remove("modal-prevent-scroll"), document.removeEventListener("keyup", p));
    }, h = () => {
      g.value = !1;
    }, p = (b) => {
      b.key === "Escape" && h();
    }, w = (b) => {
      if (u.value === null) return;
      if (b.key === "Escape") {
        h();
        return;
      }
      const k = u.value.querySelectorAll(
        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
      );
      if (k.length < 2 && b.key === "Tab") {
        b.preventDefault();
        return;
      }
      const D = k.length - 1;
      b.key === "Tab" && b.shiftKey === !1 && b.target === k[D] ? (b.preventDefault(), k[0].focus()) : b.key === "Tab" && b.shiftKey === !0 && b.target === k[0] && (b.preventDefault(), k[D].focus());
    };
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(g, (b) => {
      g.value = b, !(typeof document > "u") && (b ? y() : d());
    }, { immediate: !0 }), (b, k) => {
      const D = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid"), C = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("focus");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(it, null, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Teleport, { to: "body" }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
              "enter-active-class": "transition-opacity duration-75",
              "enter-from-class": "opacity-0",
              "leave-active-class": "transition-opacity duration-75 delay-75",
              "leave-to-class": "opacity-0"
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                  key: 0,
                  "data-id": "sds-modal-backdrop",
                  class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["fixed inset-0 block h-full bg-black bg-opacity-50", [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)]])
                }, null, 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ]),
              _: 1
            }),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
              "enter-active-class": "transition-all duration-75 delay-75",
              "enter-from-class": "transform scale-90 opacity-0",
              "leave-active-class": "transition-all duration-75",
              "leave-to-class": "transform scale-90 opacity-0"
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                  key: 0,
                  class: "fixed inset-0 block h-full w-full overflow-auto z-50",
                  onClick: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(h, ["self"])
                }, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["fixed inset-0 h-full w-full cursor-auto", {
                      "sr-only": e.hideHeader
                    }]),
                    onClick: h
                  }, Yh, 2),
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                    ref_key: "modalContainer",
                    ref: u,
                    role: "dialog",
                    "data-id": "sds-modal",
                    "aria-labelledby": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s).id || void 0,
                    class: "z-50 p-2",
                    onKeydown: w,
                    onClick: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(h, ["self"])
                  }, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["relative block w-full mx-auto bg-white border rounded-lg shadow-xl dark:text-gray-25 dark:bg-gray-900 dark:border-gray-800 md:my-16", {
                        [(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m)]: !0,
                        "md:max-w-sm": e.size === "sm",
                        "md:max-w-xl": e.size === "md",
                        "md:max-w-xl lg:max-w-2xl": e.size === "lg",
                        "md:max-w-xl lg:max-w-2xl xl:max-w-4xl": e.size === "xl",
                        "md:max-w-xl lg:max-w-2xl xl:max-w-4xl 2xl:max-w-6xl": e.size === "2xl"
                      }])
                    }, [
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex items-center p-6 pb-0", {
                          "sr-only": e.hideHeader
                        }])
                      }, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(f) || e.title ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
                          key: 0,
                          ref_key: "titleWrapper",
                          ref: s,
                          class: "flex items-center gap-2 text-2xl leading-7 font-light"
                        }, [
                          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(b.$slots, "title", {}, () => [
                            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.title), 1)
                          ])
                        ])), [
                          [D]
                        ]) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                          "aria-label": "close",
                          class: "inline-block p-0 ml-auto text-3xl text-gray-500 bg-transparent border-0 cursor-pointer hover:text-gray-700 hover:outline-none focus:text-gray-700 focus:outline-none dark:hover:text-gray-300 dark:focus:text-gray-300 active:text-gray-500 dark:active:text-gray-600",
                          onClick: h
                        }, Kh)), [
                          [C]
                        ])
                      ], 2),
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _h, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(b.$slots, "default")
                      ]),
                      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Xh, [
                        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(b.$slots, "footer")
                      ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                    ], 2)
                  ], 40, jh)
                ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ]),
              _: 3
            })
          ]))
        ]),
        _: 3
      });
    };
  }
});
Ha.install = (e) => {
  e.component(Ha.name, Ha);
};
function Qh(e, t) {
  let a;
  return function(...n) {
    const r = this;
    clearTimeout(a), a = setTimeout(() => {
      e.apply(r, n);
    }, t);
  };
}
const fn = (e) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.pushScopeId)("data-v-2541a05b"), e = e(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.popScopeId)(), e), Zh = ["title", "aria-label", "disabled", "onClick"], Jh = /* @__PURE__ */ fn(() => /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { "aria-hidden": "true" }, "×", -1)), e4 = [
  Jh
], t4 = /* @__PURE__ */ fn(() => /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("option", null, null, -1)), a4 = [
  t4
], n4 = ["value", "placeholder", "readonly", "disabled", "maxlength"], r4 = /* @__PURE__ */ fn(() => /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Enter text", -1)), s4 = /* @__PURE__ */ fn(() => /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  fill: "none",
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  class: "h-5 w-5",
  "aria-hidden": "true"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M6 18L18 6M6 6l12 12" })
], -1)), l4 = [
  s4
], o4 = {
  key: 1,
  "aria-hidden": "true",
  class: "multiselect-caret"
}, i4 = ["id", "required", "multiple"], c4 = ["value"], d4 = {
  key: 0,
  class: "dropdown-list-item loading"
}, u4 = ["disabled", "onClick", "onMouseover"], f4 = {
  key: 2,
  class: "dropdown-list-item default"
}, h4 = {
  key: 3,
  class: "dropdown-list-item no-result"
}, y4 = {
  key: 4,
  class: "dropdown-list-item cannot-add-result"
}, m4 = {
  key: 5,
  class: "dropdown-list-item invalid-input"
}, g4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsMultiselect",
  __name: "Multiselect",
  props: {
    /**
     * Determines the id of the component.
     */
    id: { type: String, default: void 0 },
    /**
     * An array of the selected options.
     */
    selected: {
      type: Array,
      default: () => []
    },
    /**
     * An array of options that can be selected.
     */
    options: {
      type: Array,
      default: () => []
    },
    /**
     * The key used for an option's value.
     *
     * Be careful when setting this as it can trigger `undefined`
     * errors if it doesn't exist in the options object.
     */
    valueKey: {
      type: String,
      default: "key"
    },
    /**
     * The key used for an option's label.
     *
     * Be careful when setting this as it can trigger `undefined`
     * and `trim()` errors if it doesn't exist in the options object.
     */
    labelKey: {
      type: String,
      default: "value"
    },
    /**
     * The v-model that determines the text value of the input field.
     */
    modelValue: {
      type: String,
      default: ""
    },
    /**
     * Determines whether to enable autofocus or not.
     */
    autofocus: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines whether more than one option can be selected.
     */
    multiple: {
      type: Boolean,
      default: !1
    },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the required state of the component.
     */
    required: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the loading state of the component.
     */
    loading: {
      type: Boolean,
      default: !1
    },
    /**
     * The message displayed while loading is true.
     */
    loadingMsg: {
      type: String,
      default: "Loading..."
    },
    /**
     * The message that displays when the menu is initially opened.
     */
    defaultMsg: {
      type: String,
      default: ""
    },
    /**
     * The message that displays when there are no results returned from a lookup.
     */
    noResultsMsg: {
      type: String,
      default: ""
    },
    /**
     * The message that displays when you cannot select more items.
     */
    cannotAddResultsMsg: {
      type: String,
      default: "You have added the maximum amount of items allowed."
    },
    /**
     * The message that displays when the user enters invalid text.
     */
    invalidInputMsg: {
      type: String,
      default: "HTML input is not allowed."
    },
    /**
     * Determines whether to show or hide your selections as tags inside the input field.
     */
    hideTags: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines whether you can loop through the menu's options with the arrow keys
     * (e.g., pressing down on that last result sends you to the first result).
     */
    canLoopOptions: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines if options can be toggled when selected from the options list.
     */
    toggleSelectedOptions: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines if selected options should appear in the options list.
     */
    hideSelectedOptions: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines whether to close the menu on selection.
     */
    closeOnSelection: {
      type: Boolean,
      default: !0
    },
    /**
     * Determines whether the component allows for searching.
     */
    canSearch: {
      type: Boolean,
      default: !0
    },
    /**
     * Determines whether to remove the last selection.
     */
    disableRemoveLastSelection: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines if the input should be cleared after making a selection.
     */
    clearInputOnSelection: {
      type: Boolean,
      default: !0
    },
    /**
     * Determines if the options list should be purged on selection.
     */
    clearOptionsOnSelection: {
      type: Boolean,
      default: !0
    },
    /**
     * Determines the placeholder of the input.
     */
    placeholder: {
      type: String,
      default: ""
    },
    /**
     * Determines the position of the menu.
     */
    openDirection: {
      type: String,
      default: "auto"
    },
    /**
     * Determines the max height of the open menu.
     */
    maxHeight: {
      type: Number,
      default: 200
    },
    /**
     * Determines whether to hide the caret or not.
     */
    hideCaret: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines whether to show the clear field button or not.
     */
    showClear: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines whether the multiselect will accept new values from the input.
     */
    taggable: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the maxlength of the input field.
     */
    maxlength: {
      type: Number,
      default: void 0
    },
    /**
     * Determines the max number of items that can be selected.
     */
    maxItems: {
      type: Number,
      default: -1
    },
    /**
     * Determines if new tags are forced to be lowercase.
     */
    enforceLowercaseNewTag: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines if the multiselect shows a valid state
     */
    valid: {
      type: Boolean,
      default: !1
    },
    /**
    * Determines if the multiselect shows an invalid state
    */
    invalid: {
      type: Boolean,
      default: !1
    }
  },
  emits: ["update:model-value", "update-selected", "update-options", "open", "close", "focus"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), y = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(0), h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)("auto"), p = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), w = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => b.value || D.value || C.value || k.value || B.value || A.value), b = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.loading && g.value && E.value), k = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => G.value.length > 0 && g.value && !a.loading && E.value), D = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.defaultMsg !== "" && P.value === "" && G.value.length < 1 && !a.loading && g.value && E.value), C = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.noResultsMsg !== "" && P.value !== "" && G.value.length < 1 && !a.loading && g.value && E.value), L = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.placeholder !== "" && a.selected.length < 1 && P.value === ""), B = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => g.value && !E.value && H.value), A = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !H.value), E = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => H.value && (a.maxItems < 0 || a.selected.length < a.maxItems)), M = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !a.canSearch), H = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !P.value.match(/<[^\s]|&[^\s;]*;/gi) !== null), P = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.modelValue.trim() || ""), G = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      const N = a.options;
      return a.taggable && P.value !== "" && (N.some((Q) => a.enforceLowercaseNewTag ? Q[a.labelKey].trim().toLowerCase() === P.value.toLowerCase() : Q[a.labelKey].trim() === P.value) || N.push(oe.value)), a.hideSelectedOptions ? N.filter((Q) => a.selected.filter((ee) => Q[a.valueKey] === ee[a.valueKey]).length === 0) : N;
    }), oe = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      const N = {}, Q = Math.floor(Math.random() * 9e5 + 1e5);
      return N[a.valueKey] = Q, N[a.labelKey] = a.enforceLowercaseNewTag ? P.value.toLowerCase() : P.value, N.isNewTag = !0, N;
    });
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(w, (N) => {
      N && I();
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(G, () => {
      d.value = 0;
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      J(), setTimeout(() => {
        a.autofocus && (u.value.focus(), m.value = !0);
      }, 0), document.addEventListener("click", yt), document.addEventListener("keyup", _), r.value = Qh(I, 150), document.addEventListener("scroll", r.value), window.addEventListener("resize", r.value);
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      document.removeEventListener("click", yt), document.removeEventListener("keyup", _), document.removeEventListener("scroll", r.value), window.removeEventListener("resize", r.value);
    });
    const U = () => {
      u.value.setSelectionRange(0, a.modelValue.length);
    }, K = (N) => {
      !a.canSearch || !N.target || W(N.target.value);
    }, J = () => {
      requestAnimationFrame(() => {
        if (L.value)
          y.value = "100%";
        else {
          const Q = f.value && typeof f.value < "u" ? f.value.clientWidth + 20 : 0;
          let ee = (s.value?.clientWidth || 0) - 20;
          (!a.hideCaret || a.showClear && a.selected.length > 0) && (ee = ee - 10);
          const qe = Math.min(Math.max(Q, 20), ee);
          y.value = qe + "px";
        }
      });
    }, ie = () => {
      if (a.modelValue !== "" || !a.canSearch || a.hideTags || a.disableRemoveLastSelection)
        return;
      const N = a.selected;
      N.splice(-1, 1), F(N), I();
    }, de = (N) => {
      if (!E.value) return;
      if (me(N)) {
        a.toggleSelectedOptions && ke(N);
        return;
      }
      let Q = [];
      a.multiple && (Q = a.selected), Q.push(N), F(Q), a.clearInputOnSelection && ht(), a.clearOptionsOnSelection && R(), Oe(), I();
    }, ke = (N) => {
      F(
        a.selected.filter(
          (Q) => Q[a.valueKey] !== N[a.valueKey]
        )
      ), Oe(), I();
    }, me = (N) => a.selected.some(
      (Q) => Q[a.labelKey] === N[a.labelKey]
    ), Ve = () => {
      n("focus"), u.value.focus();
    }, ht = () => {
      W("");
    }, Mt = () => {
      F([]);
    }, R = () => {
      ue([]);
    }, W = (N) => {
      n("update:model-value", N), J(), I();
    }, F = (N) => {
      n("update-selected", N), J(), d.value > G.value.length - 1 && (d.value = G.value.length - 1);
    }, ue = (N) => {
      n("update-options", N);
    }, re = () => {
      a.disabled || w.value || (n("open"), Ve(), g.value = !0, (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        d.value = 0;
      }));
    }, ge = () => {
      w.value && (n("close"), a.multiple || ht(), g.value = !1, d.value = 0);
    }, nt = () => {
      Mt(), ht(), Ve(), I();
    }, na = (N) => {
      if (!w.value) return;
      const Q = 0;
      switch (N) {
        case "down":
          d.value < G.value.length - 1 ? (d.value = d.value + 1, Ct()) : (a.canLoopOptions && (d.value = Q), a.canLoopOptions && Ct());
          break;
        case "up":
          d.value > Q ? (d.value = d.value - 1, Ct()) : (a.canLoopOptions && (d.value = G.value.length - 1), a.canLoopOptions && Ct(!0));
          break;
      }
    }, Ct = (N = !1) => {
      if (!w.value || typeof v.value > "u")
        return;
      const Q = v.value.children[d.value] || !1, ee = Q ? Q.offsetHeight : 0;
      let qe = 0;
      for (let yn = 0; yn < d.value; yn++)
        qe += v.value.children[yn].offsetHeight;
      const oa = qe + ee, hn = {
        top: v.value.scrollTop || 0,
        bottom: v.value.offsetHeight + v.value.scrollTop || 0
      };
      N ? v.value.scrollTop = oa : qe <= hn.top ? v.value.scrollTop = qe : oa >= hn.bottom && (v.value.scrollTop = hn.top + ee);
    }, ra = async (N) => {
      w.value && d.value <= G.value.length - 1 && d.value > -1 && E.value && a.modelValue && a.modelValue.trim() !== "" && !me(G.value[d.value]) && (de(G.value[d.value]), N.preventDefault()), W(""), await (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(), ge();
    }, rt = (N) => {
      if (a.disabled) return;
      const Q = [
        "Enter",
        "Backspace",
        "Delete",
        "Tab",
        "Alt",
        "Shift",
        "Control",
        "Meta",
        "CapsLock",
        "Fn",
        "FnLock",
        "Hyper",
        "NumLock",
        "ScrollLock",
        "Super",
        "Symbol",
        "SymbolLock",
        "ArrowLeft",
        "ArrowRight",
        "Left",
        "Right"
      ];
      N.key === "Enter" && w.value ? d.value <= G.value.length - 1 && d.value > -1 && de(G.value[d.value]) : N.key === "Escape" ? (N.preventDefault(), N.stopPropagation(), T()) : N.key === "Tab" ? m.value || (m.value = !0) : !w.value && !Q.includes(N.key) && re();
    }, sa = (N) => {
      a.disabled || (!a.canSearch && N.key === "Space" && N.preventDefault(), N.key === "Enter" && w.value && N.preventDefault(), N.key === "Delete" || N.key === "Backspace" ? ie() : N.key === "Tab" ? w.value && (N.preventDefault(), d.value <= G.value.length - 1 && d.value > -1 && E.value && a.modelValue && a.modelValue.trim() !== "" && !me(G.value[d.value]) && de(G.value[d.value])) : N.key === "ArrowUp" || N.key === "Up" ? (N.preventDefault(), N.stopPropagation(), na("up")) : (N.key === "ArrowDown" || N.key === "Down") && (N.preventDefault(), N.stopPropagation(), na("down")));
    }, la = () => {
      a.disabled || (re(), m.value = !0);
    }, Oe = () => {
      a.closeOnSelection ? ge() : Ve();
    }, yt = (N) => {
      s.value?.contains(N.target) || (w.value && d.value <= G.value.length - 1 && d.value > -1 && E.value && a.modelValue && a.modelValue.trim() !== "" && (de(G.value[d.value]), N.preventDefault()), m.value && (m.value = !1), ge());
    }, _ = (N) => {
      s.value?.contains(N.target) || m.value && (m.value = !1);
    }, I = () => {
      w.value && (0,vue__WEBPACK_IMPORTED_MODULE_0__.nextTick)(() => {
        if (a.openDirection === "down" && (p.value = !1), a.openDirection === "up" && (p.value = !0, h.value = s.value.clientHeight + "px"), a.openDirection === "auto") {
          const Q = window.innerHeight - s.value.getBoundingClientRect().bottom < a.maxHeight;
          p.value = Q, h.value = p.value ? s.value.clientHeight + "px" : "auto";
        }
      });
    }, T = () => {
      ge();
    }, ae = () => {
      u.value.focus(), m.value || (m.value = !0);
    };
    return (N, Q) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      ref_key: "root",
      ref: s,
      "data-id": "sds-multiselect",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["sds-multiselect", {
        valid: e.valid,
        invalid: e.invalid,
        open: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(w),
        active: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m),
        disabled: e.disabled,
        up: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(p),
        canSearch: e.canSearch,
        hideCaret: e.hideCaret,
        showClear: e.showClear,
        hasTags: !e.hideTags && e.selected.length > 0,
        showResults: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(k)
      }]),
      onMouseup: la,
      onMousedown: Q[2] || (Q[2] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(() => {
      }, ["prevent", "stop", "self"])),
      onDblclick: U,
      onKeydown: Q[3] || (Q[3] = (ee) => sa(ee)),
      onKeyup: Q[4] || (Q[4] = (ee) => rt(ee))
    }, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("ul", {
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["tag-list", { single: !e.multiple }])
      }, [
        !e.hideTags || !e.multiple ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.selected, (ee) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
          key: ee[e.valueKey],
          class: "tag-list-item"
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(N.$slots, "tagTemplate", {
            tag: ee,
            remove: ke,
            disabled: e.disabled
          }, () => [
            e.multiple ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
              key: 0,
              type: "button",
              class: "remove",
              tabindex: "-1",
              title: `Clear ${ee[e.labelKey]}`,
              "aria-label": `Clear ${ee[e.labelKey]}`,
              disabled: e.disabled,
              onClick: (qe) => ke(ee)
            }, e4, 8, Zh)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(ee[e.labelKey]), 1)
          ], !0)
        ]))), 128)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("li", {
          style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
            width: !e.multiple && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(w) && e.canSearch ? "100%" : (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(y)
          }),
          class: "tag-list-item input"
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", {
            ref_key: "fauxInput",
            ref: f,
            class: "faux-input",
            "aria-hidden": "true"
          }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.modelValue), 513),
          e.required && e.selected.length < 1 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("select", {
            key: 0,
            class: "faux-input",
            "aria-hidden": "true",
            tabindex: "-1",
            required: "",
            onFocus: ae
          }, a4, 32)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", null, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
              ref_key: "input",
              ref: u,
              value: e.modelValue,
              placeholder: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(L) ? e.placeholder : "",
              readonly: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(M),
              disabled: e.disabled,
              style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({
                width: !e.multiple && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(w) && e.canSearch ? "100%" : (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(y)
              }),
              maxlength: e.maxlength,
              autocomplete: "off",
              spellcheck: "false",
              autocorrect: "off",
              type: "text",
              class: "p-0 m-0 border-0 focus:shadow-none focus:ring-0",
              onBlur: Q[0] || (Q[0] = (ee) => ra(ee)),
              onInput: Q[1] || (Q[1] = (ee) => K(ee))
            }, null, 44, n4),
            r4
          ])
        ], 4)
      ], 2),
      e.selected.length > 0 && e.showClear ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
        key: 0,
        type: "button",
        tabindex: "-1",
        title: "Clear all",
        "aria-label": "Clear all",
        class: "multiselect-clear",
        onClick: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)(nt, ["prevent", "stop"])
      }, l4)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      !e.hideCaret && !(e.showClear && e.selected.length > 0) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", o4)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      e.id ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("select", {
        key: 2,
        id: e.id,
        required: e.required,
        multiple: e.multiple,
        class: "sr-only",
        "aria-hidden": "true",
        tabindex: "-1"
      }, [
        ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.selected, (ee) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", {
          key: ee.id,
          value: ee.id,
          selected: ""
        }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(ee[e.labelKey]), 9, c4))), 128))
      ], 8, i4)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(w) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("ul", {
        key: 3,
        ref_key: "dropdownMenu",
        ref: v,
        style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({ bottom: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(h), maxHeight: e.maxHeight + "px" }),
        class: "dropdown-list"
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(b) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", d4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(N.$slots, "loadingTemplate", { loadingMsg: e.loadingMsg }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.loadingMsg), 1)
          ], !0)
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(k) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 1 }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(G), (ee, qe) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
          key: ee[e.valueKey],
          disabled: e.disabled,
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["dropdown-list-item", { selected: me(ee), active: qe === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(d) }]),
          onClick: (oa) => de(ee),
          onMouseover: (oa) => d.value = qe
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(N.$slots, "optionTemplate", {
            option: ee,
            add: de,
            disabled: e.disabled,
            isSelectedOption: me(ee)
          }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(ee[e.labelKey]) + " ", 1),
            ee.isNewTag && !me(ee) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)(" (new) ")
            ], 64)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ], !0)
        ], 42, u4))), 128)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(D) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", f4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(N.$slots, "defaultTemplate", { defaultMsg: e.defaultMsg }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.defaultMsg), 1)
          ], !0)
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(C) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", h4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(N.$slots, "noResultsTemplate", { noResultsMsg: e.noResultsMsg }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.noResultsMsg), 1)
          ], !0)
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(B) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", y4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(N.$slots, "cannotAddResultsTemplate", { cannotAddResultsMsg: e.cannotAddResultsMsg }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.cannotAddResultsMsg), 1)
          ], !0)
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(A) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", m4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(N.$slots, "invalidInputTemplate", { invalidInputMsg: e.invalidInputMsg }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.invalidInputMsg), 1)
          ], !0)
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
      ], 4)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ], 34));
  }
}), Na = /* @__PURE__ */ Ar(g4, [["__scopeId", "data-v-2541a05b"]]);
Na.install = (e) => {
  e.component(Na.name, Na);
};
const v4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  xmlns: "http://www.w3.org/2000/svg",
  class: "mr-2 my-auto pt-0.5 relative w-6 h-6 self-center flex flex-col",
  viewBox: "0 0 256 256"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    fill: "currentColor",
    d: "M222 128a6 6 0 0 1-6 6H54.49l61.75 61.76a6 6 0 1 1-8.48 8.48l-72-72a6 6 0 0 1 0-8.48l72-72a6 6 0 0 1 8.48 8.48L54.49 122H216a6 6 0 0 1 6 6"
  })
], -1), b4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("h3", { class: "text-2xl font-thin" }, " Go Back ", -1), p4 = [
  v4,
  b4
], w4 = {
  key: 0,
  class: "my-auto"
}, x4 = {
  key: 0,
  class: "select-none text-lg"
}, k4 = {
  key: 1,
  class: "my-auto ml-auto text-gray-500 dark:text-gray-400 group-hover:text-red-700 group-hover:dark:text-gray-100"
}, M4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  fill: "none",
  stroke: "currentColor",
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "48",
  d: "m184 112l144 144l-144 144"
}, null, -1), C4 = [
  M4
], S4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("hr", { class: "border-gray-200 dark:border-gray-700" }, null, -1), $4 = {
  key: 3,
  class: "mt-4 mb-2 border-gray-200 dark:border-gray-700"
}, L4 = {
  name: "SdsNavigationItem"
}, Ea = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  ...L4,
  props: {
    /**
     * Determines show/hide state of the panel or the open/closed state of the 'expand'-able navigation item.
     */
    selected: {
      type: Boolean,
      default: !1
    },
    /**
     * This is the main navigation item text.
     */
    label: {
      type: String,
      default: ""
    },
    /**
     * Provides the "href" link to the Navigation Item
     */
    href: {
      type: String,
      default: null
    },
    /**
     * Applies the appropriate attributes for external links and opens them in a new tab. It also creates a REL attribute that prevents browser sniffing.
     */
    external: {
      type: Boolean,
      default: !1
    },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: {
      type: Boolean,
      default: !1
    },
    /**
     * The "type" prop determines the interaction for navigating to menu item's children.
     */
    type: {
      type: String,
      default: "simple"
    },
    /**
     * Override the default event handler.
     */
    onClick: {
      type: Function,
      default: null
    }
  },
  setup(e) {
    const t = (0,vue__WEBPACK_IMPORTED_MODULE_0__.getCurrentInstance)()?.vnode.key ?? null;
    return (a, n) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, [
      e.type === "back" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
        key: 0,
        class: "flex flex-row text-gray-700 dark:text-gray-300 text-xl cursor-pointer mb-4 w-full",
        onClick: n[0] || (n[0] = (r) => {
          e.onClick(r);
        })
      }, p4)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      e.type !== "back" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(e.href ? "a" : "button"), {
        key: 1,
        id: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(t) ? `sds-navigationitem__${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(t).toString()}` : "sds-navigationitem",
        "data-id": "sds-navigationitem",
        "data-type": e.type,
        target: e.external ? "_blank" : void 0,
        rel: e.external ? "noopener noreferrer" : void 0,
        href: e.href ? e.href : void 0,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["group flex flex-row gap-4 text-sm transition-all border-l-8 w-[calc(100%+3rem)] -mx-6 py-3 pl-4 pr-6", {
          "cursor-pointer": e.type !== "title" && !e.disabled,
          "text-gray-400 bg-white dark:text-gray-700 dark:bg-gray-900 hover:text-gray-400 hover:bg-white hover:dark:text-gray-600 hover:dark:bg-gray-900 select-none pointer-events-none cursor-default border-l-transparent": e.disabled,
          "text-gray-700 bg-white dark:text-gray-400 dark:bg-gray-900 hover:text-red-700 hover:bg-gray-50 hover:dark:text-red-100 hover:dark:bg-gray-850 border-l-transparent": !e.disabled && !e.selected && e.type !== "title",
          "border-l-red-700 dark:border-l-red-400 text-gray-900 dark:text-gray-100 hover:text-red-700 hover:dark:text-red-100 hover:bg-gray-50 hover:dark:bg-gray-850": e.selected,
          "border-l-red-700 dark:border-l-red-400 text-gray-900 dark:text-gray-100 cursor-default": e.type === "title"
        }]),
        tabindex: e.disabled || e.type === "title" ? -1 : e.href ? void 0 : 0,
        role: "menuitem",
        onClick: e.onClick
      }, {
        default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
          a.$slots.left ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", w4, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(a.$slots, "left")
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(a.$slots, "default", {}, () => [
            e.label ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", x4, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.label), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ]),
          e.type === "expand" && a.$slots.children || e.type === "slide" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", k4, [
            ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
              xmlns: "http://www.w3.org/2000/svg",
              width: "22",
              height: "22",
              viewBox: "0 0 512 512",
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["ml-auto -mr-1 shrink-0", {
                "transition-transform mr-0": e.type === "expand",
                "rotate-90": !e.selected && e.type === "expand",
                "-rotate-90": e.selected && e.type === "expand"
              }])
            }, C4, 2))
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ]),
        _: 3
      }, 8, ["id", "data-type", "target", "rel", "href", "class", "tabindex", "onClick"])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      a.$slots.children && e.type === "expand" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        key: 2,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["-mx-6 px-6 bg-white dark:bg-gray-900 relative top-0 transition-all ease-in-out duration-200 origin-top", {
          "z-10 opacity-1 max-h-screen": e.selected,
          "-z-10 opacity-0 max-h-0 select-none": !e.selected
        }])
      }, [
        S4,
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(a.$slots, "children")
      ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      e.type === "title" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("hr", $4)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ], 64));
  }
});
Ea.install = (e) => {
  e.component(Ea.name, Ea);
};
const z4 = {
  key: 0,
  "data-id": "sds-paginator",
  class: "paginator",
  "aria-label": "Page navigation"
}, D4 = {
  class: "btn-toolbar",
  role: "toolbar"
}, T4 = { class: "mr-2 btn-group" }, B4 = ["disabled"], P4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "w-3 h-3 my-auto",
  fill: "none",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  xmlns: "http://www.w3.org/2000/svg"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    "stroke-linecap": "round",
    "stroke-linejoin": "round",
    "stroke-width": "3",
    d: "M11 19l-7-7 7-7m8 14l-7-7 7-7"
  })
], -1), A4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, "First", -1), V4 = [
  P4,
  A4
], O4 = { class: "mr-2 btn-group" }, H4 = ["disabled"], N4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "w-3 h-3 my-auto",
  fill: "none",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  xmlns: "http://www.w3.org/2000/svg"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    "stroke-linecap": "round",
    "stroke-linejoin": "round",
    "stroke-width": "3",
    d: "M15 19l-7-7 7-7"
  })
], -1), E4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, "Prev", -1), I4 = [
  N4,
  E4
], R4 = {
  key: 0,
  class: "hidden btn-group md:block"
}, F4 = ["disabled", "onClick"], W4 = { class: "flex md:hidden mx-3" }, q4 = { class: "m-auto text-sm font-semibold" }, G4 = { class: "ml-2 btn-group" }, Y4 = ["disabled"], j4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, "Next", -1), U4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "w-3 h-3 my-auto",
  fill: "none",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  xmlns: "http://www.w3.org/2000/svg"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    "stroke-linecap": "round",
    "stroke-linejoin": "round",
    "stroke-width": "3",
    d: "M9 5l7 7-7 7"
  })
], -1), K4 = [
  j4,
  U4
], _4 = { class: "ml-2 btn-group" }, X4 = ["disabled"], Q4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, "Last", -1), Z4 = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  class: "w-3 h-3 my-auto",
  fill: "none",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  xmlns: "http://www.w3.org/2000/svg"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
    "stroke-linecap": "round",
    "stroke-linejoin": "round",
    "stroke-width": "3",
    d: "M13 5l7 7-7 7M5 5l7 7-7 7"
  })
], -1), J4 = [
  Q4,
  Z4
], Ia = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsPaginator",
  __name: "Paginator",
  props: {
    /**
     * The active page number.
     */
    currentPage: {
      type: Number,
      default: 1
    },
    /**
     * The total number of pages.
     */
    totalPages: {
      type: Number,
      default: 0
    },
    /**
     * Determines whether to show the loading state or not.
     */
    loading: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines the page threshold before the ellipsis truncation begins.
     */
    threshold: {
      type: Number,
      default: 5
    }
  },
  emits: ["go-to-page"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.currentPage <= 1 || a.loading), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.currentPage >= a.totalPages || a.loading), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      if (a.totalPages <= a.threshold)
        return Array.apply(null, Array(a.totalPages)).map((v, g) => g + 1);
      if (a.currentPage < a.threshold)
        return Array.apply(null, Array(a.threshold)).map((g, m) => m + 1).concat(["...", a.totalPages]);
      if (a.currentPage > a.totalPages - a.threshold + 1)
        return [1, "..."].concat(
          Array.apply(null, Array(a.threshold)).map((g, m) => a.totalPages - a.threshold + m + 1)
        );
      {
        let v = [1, "..."];
        return v = v.concat(
          Array.apply(null, Array(a.threshold - 3)).map((g, m) => a.currentPage + m - a.threshold + 3)
        ), v.push(a.currentPage), v = v.concat(
          Array.apply(null, Array(a.threshold - 3)).map((g, m) => a.currentPage + m + 1)
        ), v.concat(["...", a.totalPages]);
      }
    }), f = (v, g) => {
      n("go-to-page", { page: v, event: g });
    };
    return (v, g) => e.totalPages > 1 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("nav", z4, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", D4, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", T4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
            disabled: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r),
            class: "flex space-x-1 btn btn-ghost btn-sm py-2",
            title: "First",
            onClick: g[0] || (g[0] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((m) => f(1, m), ["prevent"]))
          }, V4, 8, B4)
        ]),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", O4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
            disabled: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r),
            class: "flex space-x-1 btn btn-ghost btn-sm py-2",
            title: "Prev",
            onClick: g[1] || (g[1] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((m) => f(e.currentPage - 1, m), ["prevent"]))
          }, I4, 8, H4)
        ]),
        e.totalPages > 1 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", R4, [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u), (m, y) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
            key: y,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
              "shadow-none border-transparent": m === "..."
            }, "btn btn-ghost btn-sm py-2"]),
            disabled: m === "..." || e.loading || e.currentPage === m,
            onClick: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((d) => f(m, d), ["prevent"])
          }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(m.toLocaleString()), 11, F4))), 128))
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", W4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", q4, "Page " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.currentPage.toLocaleString()), 1)
        ]),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", G4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
            disabled: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s),
            class: "flex space-x-1 btn btn-ghost btn-sm py-2",
            title: "Next",
            onClick: g[2] || (g[2] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((m) => f(e.currentPage + 1, m), ["prevent"]))
          }, K4, 8, Y4)
        ]),
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", _4, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
            disabled: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s),
            class: "flex space-x-1 btn btn-ghost btn-sm py-2",
            title: "Last",
            onClick: g[3] || (g[3] = (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((m) => f(e.totalPages, m), ["prevent"]))
          }, J4, 8, X4)
        ])
      ])
    ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0);
  }
});
Ia.install = (e) => {
  e.component(Ia.name, Ia);
};
Qt.install = (e) => {
  e.component(Qt.name, Qt);
};
const ey = ["onMouseover", "onMouseleave"], ty = ["onMouseover", "onMouseout"], Ra = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsPopover",
  __name: "Popover",
  props: {
    /**
     * The z-index for the popover.
     */
    zIndex: { type: String, default: "50" },
    /**
     * Delays opening the toggle in ms.
     */
    openDelay: { type: Number, default: 500 },
    /**
     * Delays closing the toggle in ms.
     */
    closeDelay: { type: Number, default: 250 },
    /**
     * The width of the popover.
     */
    size: { type: String, default: "lg" },
    /**
     * The strategy of the popover on the screen.
     */
    strategy: { type: String, default: "absolute" },
    /**
     * The placement of the popover on the screen.
     */
    placement: { type: String, default: "auto" },
    /**
     * Determines if the popover should display or not.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Allows for code execution prior to opening the popover.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the popover from opening
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willOpen(open, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the open process continue
     *    open()
     *  } catch (e) {
     *    // cancel the open process
     *    cancel()
     *  }
     * }
     * ```
     */
    willOpen: { type: Function, default: null },
    /**
     * Allows for code execution prior to closing the popover.
     * 
     * A `cancel()` callback can be called as well to cancel
     * the opening process.
     * 
     * For example, this can prevent the popover from closing
     * until a call to a backend API completes.
     * 
     * Example definition in parent component:
     * 
     * ```
     * async willClose(close, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    // let the close process continue
     *    close()
     *  } catch (e) {
     *    // cancel the close process
     *    cancel()
     *  }
     * }
     * ```
     */
    willClose: { type: Function, default: null }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.zIndex) {
        case "0":
          return "z-0";
        case "10":
          return "z-10";
        case "20":
          return "z-20";
        case "30":
          return "z-30";
        case "40":
          return "z-40";
        case "50":
          return "z-50";
        case "auto":
          return "z-auto";
        default:
          return "";
      }
    }), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => {
      switch (t.size) {
        case "sm":
          return "w-80";
        case "lg":
          return "w-96";
        case "auto":
          return "w-auto";
        default:
          return "w-80";
      }
    });
    return (r, s) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(_e, {
      "data-id": "sds-popover",
      strategy: e.strategy,
      placement: e.placement,
      disabled: e.disabled,
      "will-open": e.willOpen,
      "will-close": e.willClose,
      "popper-class": `absolute bg-white dark:text-gray-50 dark:bg-gray-850 dark:border-gray-700 border shadow-lg rounded-md ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n)} ${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a)}`,
      "arrow-class": "absolute bg-white dark:bg-gray-850 dark:border-gray-700 border w-3 h-3 rotate-45",
      "placement-top-arrow-class": "-bottom-1.5 border-t-0 border-l-0",
      "placement-right-arrow-class": "-left-1.5 border-t-0 border-r-0",
      "placement-bottom-arrow-class": "-top-1.5 border-b-0 border-r-0",
      "placement-left-arrow-class": "-right-1.5 border-b-0 border-l-0",
      shift: ""
    }, {
      trigger: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: u, close: f }) => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          onMouseover: (v) => u(e.openDelay),
          onMouseleave: (v) => f(e.closeDelay)
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "trigger")
        ], 40, ey)
      ]),
      default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(({ open: u, close: f, toggle: v, isOpen: g }) => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: "p-4",
          onMouseover: (m) => u(),
          onMouseout: (m) => f(e.closeDelay)
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(r.$slots, "default", {
            close: f,
            open: u,
            toggle: v,
            isOpen: g
          })
        ], 40, ty)
      ]),
      _: 3
    }, 8, ["strategy", "placement", "disabled", "will-open", "will-close", "popper-class"]));
  }
});
Ra.install = (e) => {
  e.component(Ra.name, Ra);
};
const ay = ["id", "value", "name", "required", "disabled", "onClick"], ny = ["for"], Fa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsRadioGroup",
  directives: {
    uid: We
  },
  __name: "RadioGroup",
  props: {
    /**
     * The v-model of the radio group.
     */
    modelValue: { type: [Boolean, String, Number], default: null },
    /**
     * The name of the radio form field.
     */
    name: { type: String, default: null },
    /**
     * An array of options for the radio group.
     */
    options: { type: Array, default: () => [] },
    /**
     * Determines whether the radio group is disabled or not.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines whether the radio group is required or not.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Determines whether the options are stacked vertically or horizontally.
     */
    stacked: { type: Boolean, default: !1 },
    /**
     * Determines the label key used for options
     */
    labelKey: { type: String, default: "text" },
    /**
     * Determines the value key used for options
     */
    valueKey: { type: String, default: "value" },
    /**
     * Sets a valid styling if true.
     */
    valid: { type: Boolean, default: !1 },
    /**
     * Sets an invalid styling if true.
     */
    invalid: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value", "change"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(f) {
        n("update:model-value", f);
      }
    }), u = (f) => {
      n("change", f);
    };
    return (f, v) => {
      const g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        ref_key: "root",
        ref: r,
        "data-id": "sds-radio-group",
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex", {
          "flex-col gap-2": e.stacked,
          "gap-4": !e.stacked
        }])
      }, [
        ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.options, (m, y) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
          key: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}_${JSON.stringify(m)}`,
          class: "flex gap-2 items-center"
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("input", {
            id: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option_${y}`,
            "onUpdate:modelValue": v[0] || (v[0] = (d) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(s) ? s.value = d : null),
            type: "radio",
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({ valid: e.valid, invalid: e.invalid }),
            value: m[e.valueKey],
            name: e.name ? e.name : `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option`,
            required: e.required && !(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s),
            disabled: e.disabled,
            onClick: (d) => u(m[e.valueKey])
          }, null, 10, ay), [
            [vue__WEBPACK_IMPORTED_MODULE_0__.vModelRadio, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s)]
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(f.$slots, "label", {
            optionId: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option_${y}`,
            option: m
          }, () => [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("label", {
              for: `${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__option_${y}`,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                "opacity-50 pointer-events-none select-none": e.disabled
              })
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(m[e.labelKey]), 1)
            ], 10, ny)
          ])
        ]))), 128))
      ], 2)), [
        [g]
      ]);
    };
  }
});
Fa.install = (e) => {
  e.component(Fa.name, Fa);
};
const ry = ["width", "height"], sy = ["width", "height", "x", "y"], Wa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsResizer",
  __name: "Resizer",
  props: {
    /**
     * If the "clamp" property is set,
     * the slot content can not be
     * resized beyond its original size.
     */
    clamp: { type: Boolean, default: !0 },
    /**
     * Set the direction you'd like the
     * resizer to grow/shrink. This is
     * the side of the slot content that
     * can be clicked and dragged.
     */
    direction: { type: String, default: "bottom" },
    /**
     * Set the initial height (if direction == 'bottom') or
     * width (if direction == 'right').
     */
    initial: { type: Number, default: null },
    /**
     * Set the max width (if direction right)
     * or max height (if direction bottom) of
     * the resizer. If no max is set, the original
     * width or height will be used (if clamp is true).
     */
    max: { type: Number, default: null },
    /**
     * Set the min width (if direction right)
     * or min height (if direction bottom) of
     * the resizer. If no min is set, resizer
     * will be able to shrink to 0.
     */
    min: { type: Number, default: null }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null);
    let r = !1, s = !1, u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(!1), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)({
      clicks: 0,
      timer: void 0,
      delay: 300
    }), v = 0, g = 0;
    const m = t.max ? t.direction === "right" ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(t.max) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)() : (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), y = t.max ? t.direction === "bottom" ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(t.max) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)() : (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), d = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), h = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(null), p = [
      "flex-col",
      "overflow-y-auto",
      "after:mx-auto",
      "after:border-solid",
      "after:border-transparent",
      "after:border-b",
      "group-[.relative]:dark:after:border-white",
      "group-[.relative]:after:border-black",
      'after:content-[""]',
      "after:to-transparent",
      "group-[.relative]:after:bg-gradient-to-t",
      "after:from-black/5",
      "dark:after:from-black/40",
      "dark:after:via-black/5",
      "after:w-full",
      "after:h-12",
      "after:block",
      "after:absolute",
      "after:bottom-0",
      "after:w-fit"
    ], w = [
      "flex-row",
      "overflow-x-auto",
      "after:border-solid",
      "after:border-transparent",
      "after:border-r",
      "group-[.relative]:dark:after:border-white",
      "group-[.relative]:after:border-black",
      'after:content-[""]',
      "after:to-transparent",
      "group-[.relative]:after:bg-gradient-to-l",
      "after:from-black/5",
      "dark:after:from-black/40",
      "dark:after:via-black/5",
      "after:w-12",
      "after:h-full",
      "after:block",
      "after:absolute",
      "after:right-0",
      "after:top-0",
      "after:h-[calc(100%+8em)]"
    ], b = (U, K) => {
      K === "bottom" ? U.scrollTop = 0 : U.scrollLeft = 0;
    }, k = (U) => {
      U.preventDefault(), f.value.clicks++, f.value.clicks === 1 ? f.value.timer = setTimeout(() => {
        f.value.clicks = 0;
      }, f.value.delay) : (f.value.timer && clearTimeout(f.value.timer), d.value = t.initial ? `${t.initial}px` : m.value ? `${m.value}px` : null, h.value = t.initial ? `${t.initial}px` : y.value ? `${y.value}px` : null, n.value && b(n.value, t.direction), f.value.clicks = 0);
    }, D = (U) => {
      U.preventDefault(), r = !0;
    }, C = (U) => {
      U.preventDefault(), s = !0;
    }, L = (U, K) => {
      switch (K) {
        case "bottom":
          C(U);
          break;
        case "right":
          D(U);
          break;
        default:
          C(U);
          break;
      }
    }, B = (U) => {
      U.preventDefault(), !(r || s) && (u.value = !0);
    }, A = (U) => {
      U.preventDefault(), !(r || s) && (u.value = !1);
    }, E = (U) => {
      if (!(!r && !s)) {
        if (r && a.value !== null) {
          const K = a.value.getBoundingClientRect();
          U instanceof MouseEvent ? v = U.clientX - K.right : window?.TouchEvent && U instanceof TouchEvent && (v = U.touches[0].clientX - K.right);
          const J = v + a.value.offsetWidth < 1 ? "0px !important" : `${a.value.offsetWidth + v}px !important`;
          if (t.clamp) {
            const ie = m.value && a.value.offsetWidth + v > (t.direction === "right", m.value) ? d.value : J;
            ie && parseInt(ie) > t.min && (d.value = ie);
          } else
            d.value = J;
        }
        if (s && a.value !== null) {
          const K = a.value.getBoundingClientRect();
          U instanceof MouseEvent ? g = U.clientY - K.bottom : window?.TouchEvent && U instanceof TouchEvent && (g = U.touches[0].clientY - K.bottom);
          const J = g + a.value.offsetHeight < 1 ? "0px !important" : `${a.value.offsetHeight + g}px !important`;
          if (t.clamp) {
            const ie = y.value && a.value.offsetHeight + g > y.value ? h.value : J;
            ie && parseInt(ie) > t.min && (h.value = ie);
          } else
            h.value = J;
        }
      }
    }, M = (U) => {
      r = !1, s = !1;
    }, H = () => {
      if (t.direction === "bottom") {
        if (h.value)
          return h.value > y.value ? "fit-content" : h.value;
      } else if (t.direction === "right")
        return "";
    }, P = () => {
      if (t.direction === "right")
        return d.value;
      if (t.direction === "bottom")
        return "";
    }, G = () => t.direction === "right" ? {
      width: P()
    } : {
      height: H()
    }, oe = () => {
      y.value = y.value ? y.value : a.value?.scrollHeight, m.value = m.value ? m.value : a.value?.scrollWidth, t.initial && d.value == null && h.value == null && (t.direction === "bottom" ? h.value = `${t.initial}px` : d.value = `${t.initial}px`);
    };
    return (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      oe(), document?.addEventListener("mousemove", E), document?.addEventListener("touchmove", E), document?.addEventListener("mouseup", M), document?.addEventListener("touchend", M);
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      document?.removeEventListener("mousemove", E), document?.removeEventListener("touchmove", E), document?.removeEventListener("mouseup", M), document?.removeEventListener("touchend", M);
    }), (U, K) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      "data-id": "sds-resizer",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex justify-end", {
        "flex-col max-w-full": e.direction === "bottom",
        "flex-row max-w-full": e.direction === "right"
      }])
    }, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
        ref_key: "scrollAreaOuter",
        ref: a,
        style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)(G()),
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["relative flex", [
          e.direction === "right" ? "overflow-y-auto overflow-x-hidden flex-row" : "overflow-x-auto overflow-y-hidden flex-col",
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u) ? "group" : null
        ]])
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          ref_key: "scrollAreaInner",
          ref: n,
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(e.direction === "right" ? w : p)
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(U.$slots, "default")
        ], 2)
      ], 6),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["opacity-30 hover:opacity-90 relative z-0 bg-transparent", {
          "w-full h-0 flex-row hover:cursor-row-resize active:cursor-row-resize": e.direction === "bottom",
          "h-full w-0 flex-col hover:cursor-col-resize active:cursor-col-resize": e.direction === "right"
        }]),
        onClick: K[0] || (K[0] = (J) => k(J)),
        onTouch: K[1] || (K[1] = (J) => k(J)),
        onMouseout: K[2] || (K[2] = (J) => A(J)),
        onMouseover: K[3] || (K[3] = (J) => B(J)),
        onMousedown: K[4] || (K[4] = (J) => L(J, e.direction)),
        onTouchstart: K[5] || (K[5] = (J) => L(J, e.direction))
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["absolute", {
            "w-full h-4": e.direction === "bottom",
            "h-full w-4": e.direction === "right"
          }])
        }, [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
            xmlns: "http://www.w3.org/2000/svg",
            width: e.direction === "bottom" ? 64 : 16,
            height: e.direction === "bottom" ? 16 : 64,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
              "mx-auto": e.direction === "bottom",
              "my-auto h-full": e.direction === "right"
            }),
            viewBox: "0 0 10 10"
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("rect", {
              width: e.direction === "bottom" ? 32 : 4,
              height: e.direction === "bottom" ? 4 : 32,
              x: e.direction === "bottom" ? -11.5 : 3,
              y: e.direction === "bottom" ? 3 : -11.5,
              fill: "currentColor",
              stroke: "currentColor",
              "stroke-linecap": "round",
              "stroke-linejoin": "round",
              "stroke-width": "0",
              rx: "2"
            }, null, 8, sy)
          ], 10, ry))
        ], 2)
      ], 34)
    ], 2));
  }
});
Wa.install = (e) => {
  e.component(Wa.name, Wa);
};
Gt.install = (e) => {
  e.component(Gt.name, Gt);
};
function ly(e, t) {
  let a, n = !1;
  return () => {
    a && clearTimeout(a), n ? a = setTimeout(e, t) : (e(), n = !0, setTimeout(() => {
      n = !1;
    }, t));
  };
}
const oy = ["href", "onClick"], iy = 56, qa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsScrollspy",
  __name: "Scrollspy",
  props: {
    /**
     * Determines the items list that is observed when the page scrolls.
     * 
     * This accepts an array of objects.
     * 
     * Example object:
     * 
     * `{ id: string, text: string }`
     * 
     * The object's `id` property should be a unique id for an HTML element. For example,
     * if you want the item to observe `<div id="test">`, the `id` would
     * be `test`.
     * 
     * The object's `text` property should be the content of the link that is observing
     * the page.
     */
    items: {
      type: Array,
      default: () => []
    },
    /**
     * The HTML selector of the container for the element being spied upon.
     */
    parent: { type: String, default: void 0 },
    /**
     * Determines the CSS class list for each item.
     */
    itemClass: { type: String, default: "" },
    /**
     * Determines the CSS class list for the active item.
     */
    activeClass: { type: String, default: "" },
    /**
     * Determines the CSS class list for the inactive items.
     */
    inactiveClass: { type: String, default: "" }
  },
  setup(e) {
    const t = e, a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => typeof document > "u" ? null : t.parent ? document.querySelector(t.parent) : null), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), s = (y) => {
      const d = document.getElementById(y.id);
      return d ? d.getBoundingClientRect().top - iy - 15 : 0;
    }, u = (y, d, h) => {
      const p = a.value && a.value.getBoundingClientRect().top || window.scrollY;
      return y === 0 && p === 0 ? [!0, null] : p < s(d) ? [!1, null] : !h || p < s(h) ? [!0, d.id] : [!1, null];
    }, f = (y) => {
      const h = document.getElementById(y.id).getBoundingClientRect();
      if (a.value) {
        const p = a.value.getBoundingClientRect();
        return h.top >= p.top && h.bottom <= p.bottom;
      } else
        return h.top >= 0 && h.bottom <= (window.innerHeight || document.documentElement.clientHeight);
    }, v = () => {
      const y = [];
      if (r.value = n.value, t.items.forEach((d) => {
        f(d) && y.push(d);
      }), y.length) {
        n.value = y[0].id;
        return;
      }
      if (r.value) {
        n.value = r.value;
        return;
      }
      if (t.items.length && !n.value) {
        for (let d = 0; d < t.items.length; d++) {
          const h = t.items[d], p = t.items[d + 1], [w, b] = u(d, h, p);
          w && (n.value = b);
        }
        return;
      }
    }, g = ly(v, 100);
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      requestAnimationFrame(v), a.value ? a.value.addEventListener("scroll", g) : window.addEventListener("scroll", g);
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      a.value ? a.value.removeEventListener("scroll", g) : window.removeEventListener("scroll", g);
    });
    const m = (y, d) => {
      if (!a.value) return;
      const h = document.getElementById(y);
      h && (d.preventDefault(), a.value.scrollTop = h.offsetTop - a.value.offsetTop);
    };
    return (y, d) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("nav", null, [
      ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.items, (h) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
        key: h.id,
        href: `#${h.id}`,
        "data-id": "sds-scrollspy",
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
          [e.itemClass]: !0,
          [e.activeClass]: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n) === h.id,
          [e.inactiveClass]: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n) !== h.id
        }),
        onClick: (p) => e.parent ? m(h.id, p) : void 0
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(y.$slots, "default", { item: h }, () => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(h.text), 1)
        ])
      ], 10, oy))), 128))
    ]));
  }
});
qa.install = (e) => {
  e.component(qa.name, qa);
};
const cy = { class: "self-center grow" }, dy = {
  key: 0,
  class: "slot-title"
}, uy = {
  key: 1,
  class: "text-sm text-gray-500 dark:text-gray-400"
}, Ga = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsSection",
  __name: "Section",
  props: {
    /**
     * Determines the overall look and feel of the section.
     */
    type: {
      type: String,
      default: ""
    },
    /**
     * Determines if the header is hidden or shown.
     */
    hideHeader: {
      type: Boolean,
      default: !1
    },
    /**
     * Determines if the content is hidden or shown.
     */
    hideContent: {
      type: Boolean,
      default: !1
    },
    /**
     * The class list for the nav slot.
     */
    navClass: {
      type: String,
      default: ""
    },
    /**
     * The class list of the default slot.
     */
    contentClass: {
      type: String,
      default: "p-4"
    }
  },
  setup(e) {
    const t = (0,vue__WEBPACK_IMPORTED_MODULE_0__.useSlots)(), a = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!t.title), n = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!t.subtitle), r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!t.nav), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => !!t.default);
    return (u, f) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      "data-id": "sds-section",
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["block bg-white dark:bg-gray-950", {
        "border border-gray-200 dark:border-gray-800": e.type === "simple" || e.type === "raised",
        "shadow border rounded-lg": e.type === "raised"
      }])
    }, [
      e.hideHeader ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("header", {
        key: 0,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
          "border-b dark:border-gray-800": e.type === "simple" || e.type === "raised",
          "border-0 border-t-2 border-gray-900 dark:border-gray-600": e.type === "accented"
        })
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex px-4 py-3", { "border-b border-gray-300 dark:border-gray-800": e.type === "accented" }])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", cy, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(a) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", dy, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(u.$slots, "title")
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(n) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", uy, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(u.$slots, "subtitle")
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ]),
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
            key: 0,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["flex items-stretch self-start justify-center ml-auto", [e.navClass]])
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(u.$slots, "nav")
          ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ], 2)
      ], 2)),
      !e.hideContent && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        key: 1,
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([e.contentClass])
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(u.$slots, "default")
      ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ], 2));
  }
});
Ga.install = (e) => {
  e.component(Ga.name, Ga);
};
Pt.install = (e) => {
  e.component(Pt.name, Pt);
};
const fy = ["id", "disabled", "required", "name"], hy = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("option", {
  disabled: "",
  value: ""
}, null, -1), yy = ["value"], Ya = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsSelect",
  __name: "Select",
  props: {
    /**
     * Determines the id of the select.
     */
    id: { type: String, default: void 0 },
    /**
     * The name of the select form field.
     */
    name: { type: String, default: null },
    /**
     * The v-model of the component.
     */
    modelValue: { type: [Boolean, String, Number, Array, Object], default: null },
    /**
     * The options for the component.
     * 
     * Expects: `{ id, value, text }`
     */
    options: { type: Array, default: () => [] },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines whether the select is required or not.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Determines the size of the component.
     */
    size: { type: String, default: "md" },
    /**
     * Determines the label key used for options
     */
    labelKey: { type: String, default: "text" },
    /**
     * Determines the value key used for options
     */
    valueKey: { type: String, default: "value" },
    /**
     * Sets a valid styling if true.
     */
    valid: { type: Boolean, default: !1 },
    /**
     * Sets an invalid styling if true.
     */
    invalid: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(s) {
        n("update:model-value", s);
      }
    });
    return (s, u) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("select", {
      id: e.id,
      "onUpdate:modelValue": u[0] || (u[0] = (f) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(r) ? r.value = f : null),
      "data-id": "sds-select",
      disabled: e.disabled,
      required: e.required,
      name: e.name ? e.name : void 0,
      class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["form-control", { "form-control-sm": e.size === "sm", valid: e.valid, invalid: e.invalid }])
    }, [
      hy,
      ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(e.options, (f) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("option", {
        key: `${e.id}_${JSON.stringify(f)}`,
        value: f[e.valueKey]
      }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(f[e.labelKey]), 9, yy))), 128))
    ], 10, fy)), [
      [vue__WEBPACK_IMPORTED_MODULE_0__.vModelSelect, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]
    ]);
  }
});
Ya.install = (e) => {
  e.component(Ya.name, Ya);
};
const my = {
  role: "tablist",
  class: "flex whitespace-nowrap z-10"
}, gy = ["id", "aria-labelledby"], ja = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsTabs",
  directives: {
    uid: We
  },
  __name: "Tabs",
  props: {
    /**
     * Determines the array of tab objects.
     *
     * Format of tab object:
     *
     * ```
     * {
     *   key: string
     *   tag?: 'button' | 'a'
     *   title?: string
     *   href?: string
     *   align?: 'left' | 'right' | 'center'
     *   external?: boolean
     *   active?: boolean
     *   disabled?: boolean
     * }
     * ```
     */
    modelValue: { type: Array, default: () => [] },
    /**
     * The overall look and feel of the component.
     */
    type: { type: String, default: "folder" },
    /**
     * Allows for code execution prior to changing tabs.
     *
     * Provides the selected `tab` for general use.
     *
     * Must call an `open()` callback to complete the process.
     *
     * A `cancel()` callback can be called to cancel
     * the process.
     *
     * Example definition in parent component:
     *
     * ```
     * async willChangeTab(tab, open, cancel) {
     *  try {
     *    await SOME_API_CALL_RESPONSE()
     *    console.log(tab)
     *    // let the open process continue
     *    open()
     *  } catch (e) {
     *    // cancel the open process
     *    cancel()
     *  }
     * }
     * ```
     */
    willChangeTab: { type: Function, default: null }
  },
  emits: ["update:model-value", "change"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(v) {
        n("update:model-value", v);
      }
    }), u = (v, g) => new Promise(async (m, y) => g ? await g(v, m, y) : m()), f = async (v) => {
      if (v.tag === "a" && v.href)
        return !0;
      await u(v, a.willChangeTab), s.value = s.value.map((g) => (g.active = v.key === g.key, g)), n("change", v);
    };
    return (v, g) => {
      const m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDirective)("uid");
      return (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)(((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
        ref_key: "root",
        ref: r,
        "data-id": "sds-tabs"
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["overflow-x-auto", {
            "bg-gray-50 dark:bg-gray-850 rounded-t": e.type === "folder"
          }])
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("ul", my, [
            ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s), (y) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
              key: y.key,
              role: "presentation",
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                "mr-auto": y.align === "left",
                "ml-auto": y.align === "right",
                "mx-auto": y.align === "center"
              })
            }, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(y.tag || "button"), {
                id: `sds-tabs-${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__${y.key}__tab`,
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                  "tab text-sm inline-block rounded-t py-2 px-4 font-semibold": e.type === "folder",
                  "bg-white dark:bg-gray-900 border-l border-t border-r text-blue-600 border-gray-200 dark:border-gray-800 dark:text-blue-300": e.type === "folder" && y.active,
                  "text-gray-600 dark:text-gray-300 hover:text-black dark:hover:text-white": e.type === "folder" && !y.active,
                  "tab tab-underline tab-red": e.type === "underline",
                  "tab tab-block tab-red": e.type === "block",
                  active: (e.type === "underline" || e.type === "block") && y.active,
                  disabled: (e.type === "underline" || e.type === "block") && y.disabled
                }),
                href: y.tag === "a" && y.href || void 0,
                target: y.tag === "a" && y.href && y.external ? "_blank" : void 0,
                rel: y.tag === "a" && y.href && y.external ? "noopener noreferrer" : void 0,
                type: y.tag === "button" ? "button" : void 0,
                disabled: y.disabled,
                "aria-disabled": y.disabled,
                tabindex: y.disabled ? -1 : void 0,
                "aria-selected": y.active ? "true" : "false",
                "aria-controls": `sds-tabs-${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__${y.key}__tab-content`,
                "data-active": y.active ? !0 : void 0,
                role: "tab",
                onClick: (d) => f(y)
              }, {
                default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(v.$slots, `tab(${y.key})`, {}, () => [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(y.title), 1)
                  ])
                ]),
                _: 2
              }, 1032, ["id", "class", "href", "target", "rel", "type", "disabled", "aria-disabled", "tabindex", "aria-selected", "aria-controls", "data-active", "onClick"]))
            ], 2))), 128))
          ])
        ], 2),
        ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s), (y) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, [
          y.active ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
            id: `sds-tabs-${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__${y.key}__tab-content`,
            key: y.key,
            "aria-labelledby": `sds-tabs-${(0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)?.id}__${y.key}__tab`,
            role: "tabpanel",
            tabindex: "0"
          }, [
            y.active ? (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(v.$slots, `panel(${y.key})`, { key: 0 }, () => [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(v.$slots, "panel", { item: y })
            ]) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
          ], 8, gy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ], 64))), 256))
      ])), [
        [m]
      ]);
    };
  }
});
ja.install = (e) => {
  e.component(ja.name, ja);
};
const vy = ["id"], by = { key: 0 }, py = { class: "border-t dark:border-gray-700" }, wy = { key: 0 }, xy = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Drawers", -1), ky = [
  xy
], My = ["onClick"], Cy = {
  key: 0,
  d: "M41 288h238c21.4 0 32.1 25.9 17 41L177 448c-9.4 9.4-24.6 9.4-33.9 0L24 329c-15.1-15.1-4.4-41 17-41zm255-105L177 64c-9.4-9.4-24.6-9.4-33.9 0L24 183c-15.1 15.1-4.4 41 17 41h238c21.4 0 32.1-25.9 17-41z",
  fill: "currentColor"
}, Sy = {
  key: 1,
  d: "M279 224H41c-21.4 0-32.1-25.9-17-41L143 64c9.4-9.4 24.6-9.4 33.9 0l119 119c15.2 15.1 4.5 41-16.9 41z",
  fill: "currentColor"
}, $y = {
  key: 2,
  d: "M41 288h238c21.4 0 32.1 25.9 17 41L177 448c-9.4 9.4-24.6 9.4-33.9 0L24 329c-15.1-15.1-4.4-41 17-41z",
  fill: "currentColor"
}, Ly = ["onClick"], zy = {
  key: 0,
  d: "M41 288h238c21.4 0 32.1 25.9 17 41L177 448c-9.4 9.4-24.6 9.4-33.9 0L24 329c-15.1-15.1-4.4-41 17-41zm255-105L177 64c-9.4-9.4-24.6-9.4-33.9 0L24 183c-15.1 15.1-4.4 41 17 41h238c21.4 0 32.1-25.9 17-41z",
  fill: "currentColor"
}, Dy = {
  key: 1,
  d: "M279 224H41c-21.4 0-32.1-25.9-17-41L143 64c9.4-9.4 24.6-9.4 33.9 0l119 119c15.2 15.1 4.5 41-16.9 41z",
  fill: "currentColor"
}, Ty = {
  key: 2,
  d: "M41 288h238c21.4 0 32.1 25.9 17 41L177 448c-9.4 9.4-24.6 9.4-33.9 0L24 329c-15.1-15.1-4.4-41 17-41z",
  fill: "currentColor"
}, By = ["id"], Py = {
  key: 0,
  class: "cursor-pointer w-4"
}, Ay = ["onClick"], Vy = {
  key: 0,
  height: "16",
  class: "mt-1 text-gray-600 dark:text-gray-400 hover:text-blue-500 dark:hover:text-blue-400",
  viewBox: "0 0 512 512",
  width: "16",
  xmlns: "http://www.w3.org/2000/svg"
}, Oy = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  d: "M233.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L256 338.7L86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z",
  fill: "currentColor"
}, null, -1), Hy = [
  Oy
], Ny = {
  key: 1,
  height: "16",
  class: "mt-1 text-gray-600 dark:text-gray-400 hover:text-blue-500 dark:hover:text-blue-400",
  viewBox: "0 0 384 512",
  width: "16",
  xmlns: "http://www.w3.org/2000/svg"
}, Ey = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", {
  d: "M342.6 233.4c12.5 12.5 12.5 32.8 0 45.3l-192 192c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3L274.7 256L105.4 86.6c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l192 192z",
  fill: "currentColor"
}, null, -1), Iy = [
  Ey
], Ry = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Toggle drawer", -1), Fy = ["id"], Wy = ["colspan"], Ua = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsTable",
  __name: "Table",
  props: {
    /**
     * A unique id used as a prefix for unique table row ids.
     */
    id: {
      type: String,
      default: null
    },
    /**
     * An array of objects. Each object must have a unique "id" but everything else is optional.
     *
     * Please note that the **items** keys map 1:1 to the **fields** keys, meaning that, any key found in the items
     * array that is not in the fields array will be ignored and not displayed.
     *
     * Example object:
     *
     * **{ id: 1, title: "Title", lastModified: "01/01/2019" }**
     */
    items: {
      type: Array,
      default: () => []
    },
    /**
     * An array of objects. These objects determine the column headers.
     *
     * Each object must contain a unique "key" and a "label" for use in the table column header.
     *
     * Optional object properties include a "sortable" boolean, a "format" function, and an "align"
     * string. The "sortable" key indicates whether a table column is sortable. The "format" key allows for
     * customization of the item's data. The "align" key enables you to align the content of that field's
     * header and content to the "left", "center", or "right".
     *
     * Basic example object (not sortable):
     *
     * **{ key: "id", label: "ID" }**
     *
     * Advanced example object (sortable, custom formatter, and alignment):
     *
     * **{
     *   key: "lastModifiedDate",
     *   label: "Last Modified",
     *   align: "right"
     *   sortable: true,
     *   format: (date) => date.toLocaleDateString()
     * }**
     */
    fields: {
      type: Array,
      default: () => []
    },
    /**
     * Determines the field key to sort by.
     */
    sortBy: { type: String, default: "" },
    /**
     * Determines if sorting should be descending or ascending.
     */
    sortDesc: { type: Boolean, default: !1 },
    /**
     * Determines the caption for the table if desired.
     */
    caption: { type: String, default: null },
    /**
     * Determines the CSS classes used on the sorted column.
     */
    sortedColumnClass: { type: String, default: null },
    /**
     * Toggles on/off a drawer below each table row
     */
    enableDrawer: { type: Boolean, default: !1 },
    /**
     * Overrides the built-in sorting behavior of the table.
     * 
     * This is useful when an external source should control
     * the table's sorting.
     *
     * If the `onSort` prop is set, the table will not sort unless
     * you provide the logic to update the table's `items` prop.
     * 
     * Furthermore, your logic must also set the `sortBy` and 
     * `sortDesc` props on the table in order for the table's
     * header to reflect your changes.
     * 
     * Method's definition:
     * 
     * `onSort({ field, sortBy, sortDesc })`
     * 
     * This method provides the following parameters for use:
     * 
     * * `field`: The field you are sorting on.
     * * `sortBy`: The field key. Provided as a helper that can be used to update the `sortBy` prop of this component.
     * * `sortDesc`: The component's internal value for what it expects the `sortDesc` prop to equal. Provided as a helper that can be used to update the `sortDesc` prop of the component.
     */
    onSort: { type: Function, default: void 0 }
  },
  emits: ["open-drawer"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(a.sortBy), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(a.sortDesc ? -1 : 1), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(-1), f = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.fields.flatMap((k) => k.fields ? k.fields : k)), v = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.onSort ? a.items : a.items.sort((D, C) => w(D, C, r.value))), g = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.fields.filter((k) => !k.hidden)), m = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Object.entries(g.value).map(([k, D]) => D.key));
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(() => a.sortBy, (k) => {
      r.value = k;
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.watch)(() => a.sortDesc, (k) => {
      s.value = k ? -1 : 1;
    });
    const y = (k) => {
      u.value === k.id ? u.value = -1 : (u.value = k.id, n("open-drawer", k));
    }, d = (k) => {
      const D = a.fields.find((C) => C.key === k);
      return D && D.header ? "th" : "td";
    }, h = (k, D = "") => {
      const C = f.value.find((L) => L.key === D);
      return C && C.format ? C.format(k[D]) : k[D];
    }, p = (k) => {
      a.onSort ? a.onSort({
        field: k,
        sortBy: k.key,
        sortDesc: s.value === 0 ? !1 : s.value === 1
      }) : (r.value = k.key, s.value = s.value === 0 ? 1 : s.value === 1 ? -1 : 1);
    }, w = (k, D, C) => {
      const L = k[C], B = D[C];
      return typeof L == "number" && typeof B == "number" || L instanceof Date && B instanceof Date ? (L < B ? -1 : L > B ? 1 : 0) * s.value : b(L).localeCompare(b(B)) * s.value;
    }, b = (k) => k === null || typeof k > "u" ? "" : k instanceof Object ? Object.keys(k).sort().map((D) => b(k[D])).join(" ") : String(k);
    return (k, D) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("table", {
      id: e.id || "sds-table",
      "data-id": "sds-table",
      class: "table-prose dark:table-prose-invert"
    }, [
      k.$slots.caption || e.caption ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("caption", by, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(k.$slots, "caption", {}, () => [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.caption), 1)
        ])
      ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("colgroup", null, [
        ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g), (C) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(k.$slots, `col(${C.key})`, {
          active: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key,
          activeClass: e.sortedColumnClass
        }, () => [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("col", {
            key: C.key,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
              [e.sortedColumnClass]: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key
            })
          }, null, 2))
        ])), 256))
      ]),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("thead", py, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("tr", null, [
          e.enableDrawer ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("th", wy, ky)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g), (C) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, [
            C.fields ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("th", {
              key: C.key,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                [e.sortedColumnClass || ""]: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key,
                "text-left": !C.align || C.align === "left",
                "text-center": C.align === "center",
                "text-right": C.align === "right"
              }, "whitespace-nowrap select-none group"])
            }, [
              ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)(C.fields, (L, B) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("button", {
                key: L.key,
                type: "button",
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["after:content-['/'] after:font-normal after:inline-block after:ml-0.5 last:after:hidden", {
                  "cursor-default after:mr-0.5": !L.sortable,
                  "after:mr-4": L.sortable
                }]),
                onClick: (A) => L.sortable ? p(L) : void 0
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(k.$slots, `head(${L.key})`, {
                  field: L,
                  active: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === L.key
                }, () => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", {
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                      "text-gray-900 dark:text-gray-100": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === L.key,
                      "font-normal": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) !== L.key && B !== 0
                    })
                  }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(L.label), 3),
                  L.sortable ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
                    key: 0,
                    xmlns: "http://www.w3.org/2000/svg",
                    "xmlns:xlink": "http://www.w3.org/1999/xlink",
                    "aria-hidden": "true",
                    role: "img",
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-block w-4 h-4 text-gray-900 dark:text-gray-100 -mt-2", {
                      "opacity-100": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === L.key,
                      "opacity-0 -mb-1 group-hover:opacity-50": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) !== L.key,
                      "-mb-3": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === L.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) > 0,
                      "-mt-2": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === L.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) < 0
                    }]),
                    preserveAspectRatio: "xMidYMid meet",
                    viewBox: "0 0 320 512"
                  }, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) !== L.key ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Cy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === L.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Sy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === L.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) < 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", $y)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                  ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ])
              ], 10, My))), 128))
            ], 2)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("th", {
              key: C.key,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                [e.sortedColumnClass || ""]: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key,
                "text-left": !C.align || C.align === "left",
                "text-center": C.align === "center",
                "text-right": C.align === "right"
              }, "whitespace-nowrap space-x-1 select-none group"])
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                  "cursor-default": !C.sortable
                }),
                onClick: (L) => C.sortable ? p(C) : void 0
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(k.$slots, `head(${C.key})`, {
                  field: C,
                  active: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key
                }, () => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", {
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                      "text-gray-900 dark:text-gray-100": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key
                    })
                  }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(C.label), 3),
                  C.sortable ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
                    key: 0,
                    xmlns: "http://www.w3.org/2000/svg",
                    "xmlns:xlink": "http://www.w3.org/1999/xlink",
                    "aria-hidden": "true",
                    role: "img",
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["inline-block w-4 h-4 text-gray-900 dark:text-gray-100 -mt-2", {
                      "opacity-100": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key,
                      "opacity-0 -mb-1 group-hover:opacity-50": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) !== C.key,
                      "-mb-3": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) > 0,
                      "-mt-2": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) < 0
                    }]),
                    preserveAspectRatio: "xMidYMid meet",
                    viewBox: "0 0 320 512"
                  }, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) !== C.key ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", zy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Dy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) === C.key && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) < 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Ty)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                  ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
                ])
              ], 10, Ly)
            ], 2))
          ], 64))), 256))
        ])
      ]),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("tbody", null, [
        ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(v), (C, L) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, {
          key: C.id
        }, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("tr", {
            id: `${e.id || "sds-table"}_tr_${C.id || L}`,
            class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
              "dark:[.table-prose_tbody_&]:border-b-0 [.table-prose_tbody_&]:border-b-0 border-b-0 dark:[.table-prose_tbody_&]:bg-gray-850 [.table-prose_tbody_&]:bg-gray-25 bg-gray-25 dark:bg-gray-850": C.id === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u)
            })
          }, [
            e.enableDrawer ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("td", Py, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                onClick: (B) => y(C)
              }, [
                C.id === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", Vy, Hy)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", Ny, Iy)),
                Ry
              ], 8, Ay)
            ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
            ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m), (B) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)((0,vue__WEBPACK_IMPORTED_MODULE_0__.resolveDynamicComponent)(d(B)), {
              key: B,
              class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
                "text-left": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g).find((A) => A.key === B)?.align === "left",
                "text-center": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g).find((A) => A.key === B)?.align === "center",
                "text-right": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(g).find((A) => A.key === B)?.align === "right"
              })
            }, {
              default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(k.$slots, `cell(${B})`, {
                  value: h(C, B),
                  item: C,
                  format: (A) => h(C, A)
                }, () => [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(h(C, B)), 1)
                ])
              ]),
              _: 2
            }, 1032, ["class"]))), 128))
          ], 10, By),
          C.id === (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("tr", {
            key: 0,
            id: `${e.id || "sds-table"}_tr_${C.id || L}_drawer`,
            class: "dark:[.table-prose_tbody_&]:bg-gray-850 [.table-prose_tbody_&]:bg-gray-25 bg-gray-25 dark:bg-gray-850"
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("td", {
              colspan: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(m).length + 1
            }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(k.$slots, "drawer", { item: C })
            ], 8, Wy)
          ], 8, Fy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ], 64))), 128))
      ])
    ], 8, vy));
  }
});
Ua.install = (e) => {
  e.component(Ua.name, Ua);
};
const qy = {
  "data-id": "sds-textarea",
  class: "w-full relative"
}, Gy = ["id", "rows", "maxlength", "minlength", "placeholder", "autofocus", "disabled", "readonly", "required"], Ka = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsTextarea",
  __name: "Textarea",
  props: {
    /**
     * The v-model for this component's text input.
     */
    modelValue: { type: String, default: "" },
    /**
     * Determine whether to display the character counter or not.
     */
    countCharacters: { type: Boolean, default: !1 },
    /**
     * Determines the minlength of the component.
     */
    minlength: { type: Number, default: 0 },
    /**
     * Determines the maxlength of the component.
     */
    maxlength: { type: Number, default: 524288 },
    /**
     * Determines the id of the textarea.
     */
    id: { type: String, default: void 0 },
    /**
     * Determines the placeholder text of the component.
     */
    placeholder: { type: String, default: "" },
    /**
     * Determines the row (height) of the component.
     */
    rows: { type: Number, default: 5 },
    /**
     * Determines whether to autofocus the component or not.
     */
    autofocus: { type: Boolean, default: !1 },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: { type: Boolean, default: !1 },
    /**
     * Determines the required state of the component.
     */
    required: { type: Boolean, default: !1 },
    /**
     * Determines the read-only state of the component.
     */
    readonly: { type: Boolean, default: !1 },
    /**
     * Gives the component a valid/success styling.
     */
    valid: { type: Boolean, default: !1 },
    /**
     * Gives the component an invalid/danger styling.
     */
    invalid: { type: Boolean, default: !1 },
    /**
      * Determines whether or not the component can be resized
      */
    resize: { type: Boolean, default: !1 }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(s) {
        n("update:model-value", s);
      }
    });
    return (s, u) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", qy, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.withDirectives)((0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("textarea", {
        id: e.id,
        "onUpdate:modelValue": u[0] || (u[0] = (f) => (0,vue__WEBPACK_IMPORTED_MODULE_0__.isRef)(r) ? r.value = f : null),
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["form-control", { valid: e.valid, invalid: e.invalid, "resize-none": !e.resize }]),
        rows: e.rows,
        maxlength: e.maxlength,
        minlength: e.minlength,
        placeholder: e.placeholder,
        autofocus: e.autofocus,
        disabled: e.disabled,
        readonly: e.readonly,
        required: e.required
      }, null, 10, Gy), [
        [vue__WEBPACK_IMPORTED_MODULE_0__.vModelText, (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r)]
      ]),
      e.countCharacters ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(Vr, {
        key: 0,
        class: "absolute right-0 text-gray-600 dark:text-gray-400",
        "current-value": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).length,
        "min-value": e.minlength,
        "max-value": e.maxlength
      }, null, 8, ["current-value", "min-value", "max-value"])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
    ]));
  }
});
Ka.install = (e) => {
  e.component(Ka.name, Ka);
};
const Yy = { class: "overflow-hidden rounded ring-1 ring-black dark:ring-gray-700 ring-opacity-5" }, jy = { class: "p-4" }, Uy = { class: "flex toasts-start" }, Ky = { class: "flex-shrink-0" }, _y = {
  key: 0,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  d: "M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"
}, Xy = {
  key: 1,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  d: "M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
}, Qy = {
  key: 2,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  d: "M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"
}, Zy = {
  key: 3,
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  d: "M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
}, Jy = { class: "ml-3 w-0 flex-1 pt-0.5" }, em = {
  key: 0,
  class: "text-sm font-medium leading-5 text-gray-900 dark:text-gray-100"
}, tm = {
  key: 1,
  class: "mt-1 text-sm leading-5 text-gray-600 dark:text-gray-400"
}, am = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("svg", {
  fill: "none",
  "stroke-linecap": "round",
  "stroke-linejoin": "round",
  "stroke-width": "2",
  stroke: "currentColor",
  viewBox: "0 0 24 24",
  class: "h-5 w-5",
  "aria-hidden": "true"
}, [
  /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("path", { d: "M6 18L18 6M6 6l12 12" })
], -1), nm = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Close toast", -1), rm = [
  am,
  nm
], Zt = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsToast",
  __name: "Toast",
  props: {
    /**
     * Determines the id of the component.
     */
    id: { type: Number, required: !0 },
    /**
     * Determines the purpose and particular function of the component.
     */
    type: { type: String, default: null },
    /**
     * Determines the title content of the component.
     */
    title: { type: String, required: !0 },
    /**
     * Determines the text content of the component.
     */
    text: { type: String, required: !0 },
    /**
     * Determines the wait time in milliseconds before automatically emitting the "remove" event for this component.
     */
    autoHideDelay: { type: Number, default: 5e3 },
    /**
     * Determines whether to ignore the autoHideDelay property.
     */
    noAutoHide: { type: Boolean, default: !1 }
  },
  emits: ["remove"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.ref)(), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.type);
    (0,vue__WEBPACK_IMPORTED_MODULE_0__.onMounted)(() => {
      v();
    }), (0,vue__WEBPACK_IMPORTED_MODULE_0__.onUnmounted)(() => {
      f();
    });
    const u = () => {
      n("remove", a.id);
    }, f = () => {
      r.value && clearTimeout(r.value);
    }, v = () => {
      f(), !a.noAutoHide && (r.value = setTimeout(() => {
        u();
      }, a.autoHideDelay));
    };
    return (g, m) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", {
      "data-id": "sds-toast",
      role: "alert",
      "aria-live": "polite",
      class: "w-full max-w-sm bg-white rounded shadow-lg pointer-events-auto dark:bg-gray-850 dark:border dark:border-gray-700",
      onMouseenter: f,
      onMouseleave: v
    }, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Yy, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", jy, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Uy, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Ky, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("svg", {
                key: 0,
                class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)([{
                  " text-green-400 dark:text-green-300": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "success",
                  " text-blue-400 dark:text-blue-300": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "info",
                  " text-orange-300 dark:text-orange-300": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "warning",
                  " text-red-600 dark:text-red-300": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) && (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "danger"
                }, "w-6 h-6"]),
                xmlns: "http://www.w3.org/2000/svg",
                fill: "none",
                viewBox: "0 0 24 24",
                stroke: "currentColor"
              }, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "success" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", _y)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "info" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Xy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "warning" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Qy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) === "danger" ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("path", Zy)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
              ], 2)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", Jy, [
              e.title ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", em, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.title), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0),
              e.text ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", tm, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.text), 1)) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
            ]),
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", { class: "flex flex-shrink-0 ml-4" }, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
                class: "inline-flex text-gray-600 dark:text-gray-400 transition duration-150 ease-in-out focus:outline-none hover:text-gray-900 dark:hover:text-gray-100",
                onClick: u
              }, rm)
            ])
          ])
        ])
      ])
    ], 32));
  }
});
Zt.install = (e) => {
  e.component(Zt.name, Zt);
};
const sm = {
  key: 0,
  "data-id": "sds-toaster",
  class: "fixed inset-0 z-50 p-4 pointer-events-none sm:p-6"
}, _a = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsToaster",
  __name: "Toaster",
  props: {
    /**
     * The v-model for this component. It accepts an array of toasts. See the Toast component for guidance.
     */
    modelValue: {
      type: Array,
      default: () => []
    }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(u) {
        n("update:model-value", u);
      }
    }), s = (u) => {
      r.value = r.value.filter((f) => u !== f.id);
    };
    return (u, f) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Transition, {
      "enter-active-class": "transition duration-150 ease-out transform",
      "enter-from-class": "translate-y-2 opacity-0 sm:translate-y-0 sm:translate-x-12",
      "enter-to-class": "translate-y-0 opacity-100 sm:translate-x-0",
      "leave-active-class": "transition duration-200 ease-in",
      "leave-from-class": "opacity-100",
      "leave-to-class": "opacity-0"
    }, {
      default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).length > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", sm, [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.createVNode)(vue__WEBPACK_IMPORTED_MODULE_0__.TransitionGroup, {
            tag: "div",
            "enter-active-class": "transition duration-150 ease-out transform",
            "enter-from-class": "translate-y-2 opacity-0 sm:translate-y-0 sm:translate-x-2",
            "enter-to-class": "translate-y-0 opacity-100 sm:translate-x-0",
            "leave-active-class": "transition duration-200 ease-in",
            "leave-from-class": "opacity-100",
            "leave-to-class": "opacity-0",
            class: "space-y-4"
          }, {
            default: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withCtx)(() => [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderSlot)(u.$slots, "default", {
                toasts: (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r),
                removeToast: s
              }, () => [
                ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), (v) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createBlock)(Zt, {
                  id: v.id,
                  key: v.id,
                  type: v.type,
                  title: v.title,
                  text: v.text,
                  "auto-hide-delay": v.autoHideDelay || 5e3,
                  "no-auto-hide": v.noAutoHide || !1,
                  class: "ml-auto",
                  onRemove: s
                }, null, 8, ["id", "type", "title", "text", "auto-hide-delay", "no-auto-hide"]))), 128))
              ])
            ]),
            _: 3
          })
        ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
      ]),
      _: 3
    }));
  }
});
_a.install = (e) => {
  e.component(_a.name, _a);
};
const lm = {
  "data-id": "sds-toggle-switch",
  class: "flex items-center"
}, om = ["disabled", "aria-checked"], im = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", { class: "sr-only" }, "Toggle switch", -1), Xa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsToggleSwitch",
  __name: "ToggleSwitch",
  props: {
    /**
     * The v-model state of this component. Determines true or false value.
     */
    modelValue: {
      type: Boolean,
      default: !1
    },
    /**
     * Disables the component to prevent user interaction.
     */
    disabled: {
      type: Boolean,
      default: !1
    }
  },
  emits: ["update:model-value"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)({
      get() {
        return a.modelValue;
      },
      set(u) {
        n("update:model-value", u);
      }
    }), s = () => {
      r.value = !r.value;
    };
    return (u, f) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", lm, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("button", {
        type: "button",
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["disabled:opacity-50 dark:disabled:opacity-100 hover:shadow-md relative inline-flex flex-shrink-0 h-6 w-11 border-2 border-transparent rounded-full cursor-pointer transition-colors ease-in-out duration-200 focus:outline-none disabled:cursor-default disabled:shadow-none", [
          (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) ? "bg-green-500 disabled:bg-green-200 dark:disabled:bg-green-800" : "bg-gray-700 disabled:bg-gray-200 dark:disabled:bg-gray-800"
        ]]),
        disabled: e.disabled,
        role: "switch",
        "aria-checked": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r),
        onClick: s
      }, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", {
          "aria-hidden": "true",
          class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["pointer-events-none inline-block h-4 w-4 my-0.5 rounded-full transform transition ease-in-out duration-200", [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r) ? "translate-x-[1.375rem]" : "translate-x-[0.125rem]",
            e.disabled ? "bg-gray-50 dark:bg-gray-500" : "bg-white drop-shadow shadow-lg"
          ]])
        }, null, 2),
        im
      ], 10, om)
    ]));
  }
});
Xa.install = (e) => {
  e.component(Xa.name, Xa);
};
vt.install = (e) => {
  e.component(vt.name, vt);
};
const cm = {
  "data-id": "sds-top-five-chart",
  class: "space-y-4 chart"
}, dm = { key: 0 }, um = { class: "space-y-6" }, fm = { class: "flex" }, hm = { class: "grow" }, ym = { class: "mb-2" }, mm = ["title", "aria-valuenow", "aria-valuemax"], gm = { class: "sr-only" }, vm = { class: "text-sm font-semibold chart-label-section" }, bm = ["href"], pm = ["onClick"], wm = { key: 1 }, xm = {
  key: 0,
  class: "mt-4"
}, km = ["href"], Mm = { key: 1 }, Cm = { key: 0 }, Sm = { key: 1 }, Qa = /* @__PURE__ */ (0,vue__WEBPACK_IMPORTED_MODULE_0__.defineComponent)({
  name: "SdsTopFiveChart",
  __name: "TopFiveChart",
  props: {
    /**
     * The title of the chart.
     */
    title: {
      type: String,
      default: null
    },
    /**
     * An array of objects. Each object must contain a unique "id" param and a "title" and "count" param. The "url" param is optional.
     *
     * If the "url" param is present, the entries display a regular clickable link. If the "url" param is not present,
     * and doNotLinkEntries is false, then the resultClick event is fired when an entry's clickable link is triggered.
     *
     * Example object: { id: 1, title: "Entry title", url: "https://seinet.sei.cmu.edu", count: 20 }
     */
    entries: {
      type: Array,
      default: () => []
    },
    /**
     * This prevents all entries from having a clickable link if set to true.
     */
    doNotLinkEntries: {
      type: Boolean,
      default: !1
    },
    /**
     * The url for the "View All" link. Hides the link if null or omitted.
     */
    viewAllUrl: {
      type: String,
      default: null
    },
    /**
     * Determines the color of the progress bars.
     */
    variant: {
      type: String,
      default: null
    },
    /**
     * Displays a "%" character if true.
     */
    showPercent: {
      type: Boolean,
      default: !1
    },
    /**
     * Decreases the size of the chart title and makes it bold if true.
     */
    smallHeading: {
      type: Boolean,
      default: !1
    },
    /**
     * The message displayed when no entries data is available.
     */
    noDataMsg: {
      type: String,
      default: "There is no chart data to display at this time."
    },
    /**
     * The message displayed when the entries data is missing the required "id", "title", or "count" params.
     */
    missingPropsMsg: {
      type: String,
      default: "The chart data is malformed and cannot be displayed at this time."
    }
  },
  emits: ["result-click"],
  setup(e, { emit: t }) {
    const a = e, n = t, r = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => s.value ? a.entries.slice(0, 5) : []), s = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => a.entries.length < 1 ? !0 : a.entries.every((d) => Object.prototype.hasOwnProperty.call(d, "id") && Object.prototype.hasOwnProperty.call(d, "title") && Object.prototype.hasOwnProperty.call(d, "count"))), u = (0,vue__WEBPACK_IMPORTED_MODULE_0__.computed)(() => Math.max.apply(
      Math,
      r.value.map((d) => d.count)
    )), f = (d) => d * 100 / u.value, v = (d) => a.showPercent ? `${d}%` : d, g = (d) => typeof d.url < "u", m = (d) => {
      n("result-click", d);
    }, y = (d) => {
      switch (a.variant) {
        case "teal":
          if (d === 0)
            return "bg-teal-800 dark:bg-teal-600";
          if (d === 1)
            return "bg-teal-700 dark:bg-teal-500";
          if (d === 2)
            return "bg-teal-600 dark:bg-teal-400";
          if (d === 3)
            return "bg-teal-500 dark:bg-teal-300";
          if (d === 4)
            return "bg-teal-400 dark:bg-teal-200";
          break;
        case "red":
          if (d === 0)
            return "bg-red-800 dark:bg-red-600";
          if (d === 1)
            return "bg-red-700 dark:bg-red-500";
          if (d === 2)
            return "bg-red-600 dark:bg-red-400";
          if (d === 3)
            return "bg-red-500 dark:bg-red-300";
          if (d === 4)
            return "bg-red-400 dark:bg-red-200";
          break;
        case "gray":
          if (d === 0)
            return "bg-gray-800 dark:bg-gray-600";
          if (d === 1)
            return "bg-gray-700 dark:bg-gray-500";
          if (d === 2)
            return "bg-gray-600 dark:bg-gray-400";
          if (d === 3)
            return "bg-gray-500 dark:bg-gray-300";
          if (d === 4)
            return "bg-gray-400 dark:bg-gray-200";
          break;
        case "tan":
          if (d === 0)
            return "bg-tan-800 dark:bg-tan-600";
          if (d === 1)
            return "bg-tan-700 dark:bg-tan-500";
          if (d === 2)
            return "bg-tan-600 dark:bg-tan-400";
          if (d === 3)
            return "bg-tan-500 dark:bg-tan-300";
          if (d === 4)
            return "bg-tan-400 dark:bg-tan-200";
          break;
        case "green":
          if (d === 0)
            return "bg-green-800 dark:bg-green-600";
          if (d === 1)
            return "bg-green-700 dark:bg-green-500";
          if (d === 2)
            return "bg-green-600 dark:bg-green-400";
          if (d === 3)
            return "bg-green-500 dark:bg-green-300";
          if (d === 4)
            return "bg-green-400 dark:bg-green-200";
          break;
        case "yellow":
          if (d === 0)
            return "bg-yellow-800 dark:bg-yellow-600";
          if (d === 1)
            return "bg-yellow-700 dark:bg-yellow-500";
          if (d === 2)
            return "bg-yellow-600 dark:bg-yellow-400";
          if (d === 3)
            return "bg-yellow-500 dark:bg-yellow-300";
          if (d === 4)
            return "bg-yellow-400 dark:bg-yellow-200";
          break;
        case "orange":
          if (d === 0)
            return "bg-orange-800 dark:bg-orange-600";
          if (d === 1)
            return "bg-orange-700 dark:bg-orange-500";
          if (d === 2)
            return "bg-orange-600 dark:bg-orange-400";
          if (d === 3)
            return "bg-orange-500 dark:bg-orange-300";
          if (d === 4)
            return "bg-orange-400 dark:bg-orange-200";
          break;
        case "indigo":
          if (d === 0)
            return "bg-indigo-800 dark:bg-indigo-600";
          if (d === 1)
            return "bg-indigo-700 dark:bg-indigo-500";
          if (d === 2)
            return "bg-indigo-600 dark:bg-indigo-400";
          if (d === 3)
            return "bg-indigo-500 dark:bg-indigo-300";
          if (d === 4)
            return "bg-indigo-400 dark:bg-indigo-200";
          break;
        case "purple":
          if (d === 0)
            return "bg-purple-800 dark:bg-purple-600";
          if (d === 1)
            return "bg-purple-700 dark:bg-purple-500";
          if (d === 2)
            return "bg-purple-600 dark:bg-purple-400";
          if (d === 3)
            return "bg-purple-500 dark:bg-purple-300";
          if (d === 4)
            return "bg-purple-400 dark:bg-purple-200";
          break;
        case "blue":
        default:
          if (d === 0)
            return "bg-blue-800 dark:bg-blue-600";
          if (d === 1)
            return "bg-blue-700 dark:bg-blue-500";
          if (d === 2)
            return "bg-blue-600 dark:bg-blue-400";
          if (d === 3)
            return "bg-blue-500 dark:bg-blue-300";
          if (d === 4)
            return "bg-blue-400 dark:bg-blue-200";
          break;
      }
    };
    return (d, h) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", cm, [
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("h3", {
        class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)({
          "text-lg font-light": e.smallHeading,
          "text-2xl font-light": !e.smallHeading
        })
      }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.title), 3),
      (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r).length > 0 ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", dm, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("ul", um, [
          ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(!0), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, (0,vue__WEBPACK_IMPORTED_MODULE_0__.renderList)((0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(r), (p, w) => ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", {
            key: p.id
          }, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", fm, [
              (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", hm, [
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", ym, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", {
                    class: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeClass)(["h-6 mr-2 rounded", [y(w)]]),
                    role: "progressbar",
                    title: `${p.count}`,
                    "aria-valuenow": p.count,
                    "aria-valuemin": "0",
                    "aria-valuemax": (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(u),
                    style: (0,vue__WEBPACK_IMPORTED_MODULE_0__.normalizeStyle)({ width: `${f(p.count)}%` })
                  }, [
                    (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("span", gm, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(v(p.count)) + " " + (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(p.title), 1)
                  ], 14, mm)
                ]),
                (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("div", vm, [
                  (0,vue__WEBPACK_IMPORTED_MODULE_0__.createTextVNode)((0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(v(p.count)) + " · ", 1),
                  e.doNotLinkEntries ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("span", wm, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(p.title), 1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)(vue__WEBPACK_IMPORTED_MODULE_0__.Fragment, { key: 0 }, [
                    g(p) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                      key: 0,
                      href: p.url,
                      class: "hover:underline focus:underline focus:outline-none"
                    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(p.title), 9, bm)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("a", {
                      key: 1,
                      href: "#",
                      class: "hover:underline focus:underline focus:outline-none",
                      onClick: (0,vue__WEBPACK_IMPORTED_MODULE_0__.withModifiers)((b) => m(p), ["prevent"])
                    }, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(p.title), 9, pm))
                  ], 64))
                ])
              ])
            ])
          ]))), 128)),
          e.viewAllUrl !== null ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("li", xm, [
            (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementVNode)("a", {
              href: e.viewAllUrl,
              class: "link link-primary link-blue link-cta"
            }, " View All ", 8, km)
          ])) : (0,vue__WEBPACK_IMPORTED_MODULE_0__.createCommentVNode)("", !0)
        ])
      ])) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("div", Mm, [
        (0,vue__WEBPACK_IMPORTED_MODULE_0__.unref)(s) ? ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", Cm, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.noDataMsg), 1)) : ((0,vue__WEBPACK_IMPORTED_MODULE_0__.openBlock)(), (0,vue__WEBPACK_IMPORTED_MODULE_0__.createElementBlock)("p", Sm, (0,vue__WEBPACK_IMPORTED_MODULE_0__.toDisplayString)(e.missingPropsMsg), 1))
      ]))
    ]));
  }
});
Qa.install = (e) => {
  e.component(Qa.name, Qa);
};
const lr = {
  SdsActionButton: ca,
  SdsActionDropdown: da,
  SdsAvatar: ua,
  SdsBadge: fa,
  SdsButton: Tt,
  SdsCalendar: qt,
  SdsCheckboxGroup: ha,
  SdsClientOnly: it,
  SdsComboBox: ya,
  SdsDatapoint: ma,
  SdsDatepicker: ga,
  SdsDropdown: va,
  SdsDropdownDivider: ba,
  SdsDropdownHeader: pa,
  SdsDropdownItem: wa,
  SdsExpandCollapse: xa,
  SdsFileUploader: ka,
  SdsFilterByDropdown: Ma,
  SdsFloatingActionButton: Ca,
  SdsFloatingUi: _e,
  SdsFormGroup: Sa,
  SdsIndicator: Yt,
  SdsInput: $a,
  SdsLayoutApp: La,
  SdsLayoutAppSimple: za,
  SdsLayoutSeiExternal: Da,
  SdsLayoutSeiExternalFooter: Kt,
  SdsLayoutSeiExternalHeader: Ut,
  SdsLayoutSeiExternalHeaderContent: At,
  SdsLayoutSeiExternalMasthead: Xt,
  SdsLayoutSeiExternalNav: _t,
  SdsLayoutSeiExternalWordmark: jt,
  SdsLayoutStacked: Ta,
  SdsLink: Bt,
  SdsLoadingSkeleton: Ba,
  SdsLoadingSpinner: Pa,
  SdsMegaMenu: Aa,
  SdsMegaMenuItem: Va,
  SdsMobileMenu: Oa,
  SdsModal: Ha,
  SdsMultiselect: Na,
  SdsNavigationItem: Ea,
  SdsPaginator: Ia,
  SdsPanel: Qt,
  SdsPopover: Ra,
  SdsRadioGroup: Fa,
  SdsResizer: Wa,
  SdsScrollArea: Gt,
  SdsScrollspy: qa,
  SdsSection: Ga,
  SdsSeiWordmark: Pt,
  SdsSelect: Ya,
  SdsTabs: ja,
  SdsTable: Ua,
  SdsTextarea: Ka,
  SdsToast: Zt,
  SdsToaster: _a,
  SdsToggleSwitch: Xa,
  SdsTooltip: vt,
  SdsTopFiveChart: Qa
}, Lm = {
  install(e) {
    Object.keys(lr).forEach((t) => {
      e.component(t, lr[t]);
    });
  }
};



/***/ }),

/***/ "./src/js/global/wait_for_elem.js":
/*!****************************************!*\
  !*** ./src/js/global/wait_for_elem.js ***!
  \****************************************/
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   waitForElem: () => (/* binding */ waitForElem)
/* harmony export */ });
function waitForElem(selector) {
  /* Promise-based way to wait for DOM-element
   * to exist. When it does, run a callback. */
  return new Promise(res => {
    if (document.querySelector(selector)) {
      return res(document.querySelectorAll(selector));
    }

    const observer = new MutationObserver(() => {
      if (document.querySelector(selector)) {
        res(document.querySelectorAll(selector));
        observer.disconnect();
      }
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
}


/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	(() => {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = (module) => {
/******/ 			var getter = module && module.__esModule ?
/******/ 				() => (module['default']) :
/******/ 				() => (module);
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) => {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/global */
/******/ 	(() => {
/******/ 		__webpack_require__.g = (function() {
/******/ 			if (typeof globalThis === 'object') return globalThis;
/******/ 			try {
/******/ 				return this || new Function('return this')();
/******/ 			} catch (e) {
/******/ 				if (typeof window === 'object') return window;
/******/ 			}
/******/ 		})();
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) => {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
(() => {
var exports = __webpack_exports__;
/*!*************************!*\
  !*** ./src/vue/main.ts ***!
  \*************************/

Object.defineProperty(exports, "__esModule", ({ value: true }));
var vue_1 = __webpack_require__(/*! vue */ "./node_modules/vue/index.js");
/* Import the SDS components library */
var index_mjs_1 = __webpack_require__(/*! @sds/components-vue3/dist/index.mjs */ "./node_modules/@sds/components-vue3/dist/index.mjs");
/* Setup Vue application */
var GenericButton_vue_1 = __webpack_require__(/*! ./GenericButton.vue */ "./src/vue/GenericButton.vue");
/* Local import, wait for mount element(s) to exist in the DOM. */
var wait_for_elem_js_1 = __webpack_require__(/*! ../js/global/wait_for_elem.js */ "./src/js/global/wait_for_elem.js");
(0, wait_for_elem_js_1.waitForElem)('[name="sds-button"]').then(function (matchedElems) {
    matchedElems.forEach(function (matchedElem) {
        var children = matchedElem.childNodes;
        if (children) {
            /* Nodes will be in the order: [ text, input, text ], the 'text' is whitespace.
             * Select the input element (children[1]) to get the <input /> tag with button data. */
            var dataInput = children[1];
            if (dataInput) {
                var dataset = dataInput.dataset;
                if (dataset) {
                    (0, vue_1.createApp)(GenericButton_vue_1.default)
                        .use(index_mjs_1.default)
                        /**
                         * The button data is preconfigured in the Django template.
                         * Pass it on to the mounted component:
                         */
                        .provide('dataset', dataset)
                        .mount(matchedElem);
                }
            }
        }
    });
});

})();

/******/ })()
;
//# sourceMappingURL=vue-410b671986439df0ee41.js.map